Build an inventory tracker

Create a workspace called "Inventory", then build a stock-management app.
Products have a name, SKU, price, quantity on hand, and a category. Every
stock change is logged as a movement (which product, a +/- delta, a reason).
I want a searchable product list, a dialog to adjust stock, the ability to
scan a barcode to find a product, and a daily alert when items run low.

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

export default createEndpoint({
  description: 'List products, optionally filtered by category, name search, or exact SKU',
  authenticated: true,
  inputSchema: z.object({
    category: z.string().optional(),
    search: z.string().optional(),
    sku: z.string().optional(),
  }),
  outputSchema: z.object({
    products: z.array(z.object({
      id: z.string(),
      name: z.string(),
      sku: z.string(),
      price: z.number().nullable(),
      quantity: z.number().nullable(),
      category: z.string().nullable(),
    })),
  }),
  execute: async ({ input }) => {
    const filter: Record<string, unknown> = {};
    if (input.category) filter.category = input.category;
    if (input.sku) filter.sku = input.sku;
    if (input.search) filter.name = { contains: input.search };

    const { records } = await zite.Products.findAll({
      filter: Object.keys(filter).length ? filter : undefined,
      sort: [{ field: 'name', direction: 'asc' }],
      limit: 500,
    });
    return {
      products: records.map(p => ({
        id: p.id, name: p.name, sku: p.sku,
        price: p.price, quantity: p.quantity, category: p.category,
      })),
    };
  },
});

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

export default createEndpoint({
  description: 'Record a stock movement and update the product quantity',
  authenticated: true,
  inputSchema: z.object({
    productId: z.string(),
    delta: z.number().int(),
    reason: z.string().min(1),
  }),
  outputSchema: z.object({ quantity: z.number() }),
  execute: async ({ input }) => {
    const product = await zite.Products.findOne({ id: input.productId });
    if (!product) throw new ZiteError('Product not found', { statusCode: 404 });

    const quantity = (product.quantity ?? 0) + input.delta;
    if (quantity < 0) throw new ZiteError('Not enough stock on hand', { statusCode: 400 });

    await zite.StockMovements.create({
      record: { product: [input.productId], delta: input.delta, reason: input.reason },
    });
    await zite.Products.update({ id: input.productId, record: { quantity } });
    return { quantity };
  },
});

// apps/inventory/src/App.tsx
import { useEffect, useState } from 'react';
import { listProducts, ListProductsOutputType } from 'zitejs/api';
import { Input } from '@project/components/ui/input';
import { Button } from '@project/components/ui/button';
import { Badge } from '@project/components/ui/badge';
import { AdjustStockDialog } from './components/AdjustStockDialog';

type Product = ListProductsOutputType['products'][number];

export default function App() {
  const [search, setSearch] = useState('');
  const [products, setProducts] = useState<Product[]>([]);
  const [adjusting, setAdjusting] = useState<Product>();

  const load = () => listProducts({ search: search || undefined }).then(d => setProducts(d.products));
  useEffect(() => { load(); }, [search]);

  return (
    <div className="p-6 space-y-4">
      <Input placeholder="Search products…" value={search} onChange={e => setSearch(e.target.value)} />
      {products.map(p => (
        <div key={p.id} className="flex items-center justify-between border rounded-lg p-4">
          <div>
            <div className="font-medium">{p.name}</div>
            <div className="text-sm text-muted-foreground">{p.sku}</div>
          </div>
          <div className="flex items-center gap-3">
            <Badge variant={(p.quantity ?? 0) <= 10 ? 'destructive' : 'secondary'}>
              {p.quantity ?? 0} in stock
            </Badge>
            <Button variant="outline" onClick={() => setAdjusting(p)}>Adjust</Button>
          </div>
        </div>
      ))}
      {adjusting && (
        <AdjustStockDialog
          product={adjusting}
          onClose={() => setAdjusting(undefined)}
          onDone={() => { setAdjusting(undefined); load(); }}
        />
      )}
    </div>
  );
}

{
  "version": "1.0",
  "defaultPolicy": "deny",
  "roles": [
    { "id": "builtin:all-team-members", "name": "All team members" }
  ],
  "tables": {
    "Products": {
      "rules": [
        { "roles": ["All team members"], "operations": ["read", "create", "update", "delete"] }
      ]
    },
    "StockMovements": {
      "rules": [
        { "roles": ["All team members"], "operations": ["read", "create", "update", "delete"] }
      ]
    }
  }
}