Build a CRM

Create a workspace called "CRM", then build a sales-pipeline app.
Contacts have a name, email, company, and phone. Deals have a title, a
value, a stage (Lead / Qualified / Proposal / Won / Lost), a linked contact,
a close date, and an owner. I want a pipeline board I can drag deals across,
a KPI row showing open and won value, and reps should only see their own deals.

// apps/crm/src/api/listDeals.ts
import { z } from 'zod';
import { createEndpoint } from 'zitejs/backend';
import { zite } from 'zitejs/db';

export default createEndpoint({
  description: 'List deals, optionally filtered by stage',
  authenticated: true,
  inputSchema: z.object({ stage: z.string().optional() }),
  outputSchema: z.object({
    deals: z.array(z.object({
      id: z.string(),
      title: z.string(),
      value: z.number().nullable(),
      stage: z.string(),
    })),
  }),
  execute: async ({ input }) => {
    const { records } = await zite.deals.findAll({
      filters: input.stage ? { stage: input.stage } : undefined,
      sort: [{ field: 'closeDate', direction: 'asc' }],
      limit: 500,
    });
    return {
      deals: records.map(d => ({ id: d.id, title: d.title, value: d.value, stage: d.stage })),
    };
  },
});

// apps/crm/src/api/moveDeal.ts
import { z } from 'zod';
import { createEndpoint, ZiteError } from 'zitejs/backend';
import { zite } from 'zitejs/db';

export default createEndpoint({
  description: 'Move a deal to a different pipeline stage',
  authenticated: true,
  inputSchema: z.object({
    dealId: z.string(),
    stage: z.enum(['Lead', 'Qualified', 'Proposal', 'Won', 'Lost']),
  }),
  outputSchema: z.object({ ok: z.boolean() }),
  execute: async ({ input }) => {
    const deal = await zite.deals.findOne({ id: input.dealId });
    if (!deal) throw new ZiteError({ code: 'NOT_FOUND', message: 'Deal not found' });
    await zite.deals.update({ id: input.dealId, record: { stage: input.stage } });
    return { ok: true };
  },
});

// apps/crm/src/api/pipelineSummary.ts
import { z } from 'zod';
import { createEndpoint } from 'zitejs/backend';
import { zite } from 'zitejs/db';

export default createEndpoint({
  description: 'Total deal value and count grouped by pipeline stage',
  authenticated: true,
  inputSchema: z.object({}),
  outputSchema: z.object({
    byStage: z.array(z.object({ stage: z.string(), total: z.number(), count: z.number() })),
    openValue: z.number(),
    wonValue: z.number(),
  }),
  execute: async () => {
    const { rows } = await zite.sql({
      query: `
        SELECT "stage", COALESCE(SUM("value"), 0) AS "total", COUNT(*) AS "count"
        FROM "Deals"
        GROUP BY "stage"
      `,
    });
    const byStage = rows.map(r => ({
      stage: String(r.stage), total: Number(r.total), count: Number(r.count),
    }));
    const sumOf = (stages: string[]) =>
      byStage.filter(s => stages.includes(s.stage)).reduce((n, s) => n + s.total, 0);
    return {
      byStage,
      openValue: sumOf(['Lead', 'Qualified', 'Proposal']),
      wonValue: sumOf(['Won']),
    };
  },
});

// apps/crm/src/App.tsx
import { useEffect, useState } from 'react';
import { pipelineSummary, PipelineSummaryOutputType } from 'zitejs/api';
import { Card, CardContent } from '@project/components/ui/card';
import { PipelineBoard } from './components/PipelineBoard';

const money = (n: number) => n.toLocaleString('en-US', { style: 'currency', currency: 'USD' });

export default function App() {
  const [summary, setSummary] = useState<PipelineSummaryOutputType>();
  useEffect(() => { pipelineSummary({}).then(setSummary); }, []);

  return (
    <div className="p-6 space-y-6">
      <div className="grid grid-cols-2 gap-4 md:grid-cols-4">
        <Kpi label="Open pipeline" value={summary ? money(summary.openValue) : '—'} />
        <Kpi label="Won" value={summary ? money(summary.wonValue) : '—'} />
        {summary?.byStage.map(s => (
          <Kpi key={s.stage} label={s.stage} value={`${s.count} · ${money(s.total)}`} />
        ))}
      </div>
      <PipelineBoard />
    </div>
  );
}

function Kpi({ label, value }: { label: string; value: string }) {
  return (
    <Card>
      <CardContent className="p-4">
        <div className="text-sm text-muted-foreground">{label}</div>
        <div className="text-2xl font-semibold">{value}</div>
      </CardContent>
    </Card>
  );
}

{
  "version": "1.0",
  "defaultPolicy": "deny",
  "roles": [
    { "id": "role_manager", "name": "Sales manager" }
  ],
  "tables": {
    "Deals": {
      "rules": [
        {
          "roleId": "builtin:all-team-members",
          "operation": "read",
          "rowFilter": { "type": "comparison", "field": "ownerEmail", "operator": "eq", "userField": "email" }
        },
        {
          "roleId": "builtin:all-team-members",
          "operation": "update",
          "rowFilter": { "type": "comparison", "field": "ownerEmail", "operator": "eq", "userField": "email" }
        },
        { "roleId": "builtin:all-team-members", "operation": "create" },
        { "roleId": "role_manager", "operation": "read" },
        { "roleId": "role_manager", "operation": "create" },
        { "roleId": "role_manager", "operation": "update" },
        { "roleId": "role_manager", "operation": "delete" }
      ]
    },
    "Contacts": {
      "rules": [
        { "roleId": "builtin:all-team-members", "operation": "read" },
        { "roleId": "builtin:all-team-members", "operation": "create" },
        { "roleId": "builtin:all-team-members", "operation": "update" }
      ]
    }
  }
}