@pylonsync/create-pylon 0.3.344 → 0.3.346

package/templates/inventory/app/workspace.tsx

@@ -0,0 +1,172 @@
+"use client";
+
+import React, { useEffect, useMemo, useRef, useState } from "react";
+import { callFn, db, useRouter } from "@pylonsync/react";
+import { useAuth } from "@pylonsync/client";
+import { Sidebar } from "@/components/sidebar";
+import { CommandPalette } from "@/components/command-palette";
+import type { SearchItem } from "@/lib/search";
+import { onHandByProduct, summarize, type Movement, type Product } from "@/lib/stock";
+
+export type ProductRow = Product;
+export type MovementRow = Movement;
+export interface UserRow {
+  id: string;
+  email: string;
+  displayName?: string | null;
+}
+
+export interface WorkspaceData {
+  products: ProductRow[];
+  movements: MovementRow[];
+  /** On-hand for every product, computed once per render rather than per row. */
+  levels: Map<string, number>;
+  productName: (id: string | null | undefined) => string | null;
+  actorName: (id: string | null | undefined) => string | null;
+  loading: boolean;
+}
+
+/**
+ * The app shell, and the ONLY place that touches `db`.
+ *
+ * Every view below receives plain data through the render prop and reports
+ * changes through callbacks, which is what lets the components in `components/`
+ * render from fixtures in a test with nothing mocked.
+ *
+ * The queries are live: a movement recorded at the back door updates the level
+ * on the shop floor\'s screen immediately, so nobody sells what was just
+ * damaged.
+ */
+export function Workspace({
+  email,
+  pathname,
+  children,
+}: {
+  email: string;
+  pathname: string;
+  children: (data: WorkspaceData) => React.ReactNode;
+}) {
+  const router = useRouter();
+  const { signOut } = useAuth();
+  const { data: products, loading } = db.useQuery<ProductRow>("Product");
+  const { data: movements } = db.useQuery<MovementRow>("Movement");
+  const { data: users } = db.useQuery<UserRow>("User");
+
+  const [paletteOpen, setPaletteOpen] = useState(false);
+  const seeded = useRef(false);
+
+  const productList = products ?? [];
+  const movementList = movements ?? [];
+
+  useEffect(() => {
+    if (loading || seeded.current) return;
+    if (productList.length > 0) {
+      seeded.current = true;
+      return;
+    }
+    seeded.current = true;
+    callFn("seedWorkspace", {}).catch(() => {
+      seeded.current = false;
+    });
+  }, [loading, productList.length]);
+
+  useEffect(() => {
+    function onKey(event: KeyboardEvent) {
+      const target = event.target as HTMLElement | null;
+      const typing =
+        !!target &&
+        (target.tagName === "INPUT" ||
+          target.tagName === "TEXTAREA" ||
+          target.isContentEditable);
+      if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === "k") {
+        event.preventDefault();
+        setPaletteOpen((open) => !open);
+      } else if (event.key === "/" && !typing) {
+        event.preventDefault();
+        setPaletteOpen(true);
+      }
+    }
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+
+  // One pass over the ledger for the whole render — calling onHand() per row
+  // would be O(products x movements).
+  const levels = useMemo(() => onHandByProduct(movementList), [movementList]);
+  const productById = useMemo(
+    () => new Map(productList.map((p) => [p.id, p] as const)),
+    [productList],
+  );
+  const userById = useMemo(
+    () => new Map((users ?? []).map((u) => [u.id, u] as const)),
+    [users],
+  );
+
+  const searchIndex = useMemo<SearchItem[]>(
+    () =>
+      productList.map((product) => ({
+        id: `product:${product.id}`,
+        type: "company" as const,
+        title: product.name,
+        subtitle: product.sku,
+        href: `/products/${product.id}`,
+        keywords: product.category ?? undefined,
+      })),
+    [productList],
+  );
+
+  const summary = summarize(productList, movementList);
+
+  const data: WorkspaceData = {
+    products: productList,
+    movements: movementList,
+    levels,
+    productName: (id) => productById.get(id ?? "")?.name ?? null,
+    actorName: (id) => {
+      const user = userById.get(id ?? "");
+      return user?.displayName || user?.email || null;
+    },
+    loading,
+  };
+
+  return (
+    <div className="flex h-screen overflow-hidden">
+      <Sidebar
+        workspace="Inventory"
+        email={email}
+        pathname={pathname}
+        counts={{ "/": summary.skuCount }}
+        onOpenCommand={() => setPaletteOpen(true)}
+        onSignOut={async () => {
+          await signOut();
+          window.location.assign("/login");
+        }}
+      />
+      <main className="flex min-w-0 flex-1 flex-col">{children(data)}</main>
+
+      <CommandPalette
+        open={paletteOpen}
+        items={searchIndex}
+        actions={[
+          {
+            id: "new-product",
+            label: "New product",
+            run: () => router.push("/?new=product"),
+          },
+          {
+            id: "reorder",
+            label: `Needs reorder (${summary.lowCount + summary.outCount})`,
+            run: () => router.push("/?filter=reorder"),
+          },
+          {
+            id: "go-movements",
+            label: "Go to Movements",
+            run: () => router.push("/movements"),
+          },
+        ]}
+        onClose={() => setPaletteOpen(false)}
+        onSelect={(item) => router.push(item.href)}
+      />
+    </div>
+  );
+}

package/templates/inventory/app.ts

@@ -0,0 +1,154 @@
+import {
+  entity,
+  field,
+  policy,
+  auth,
+  buildManifest,
+  discoverAppRoutes,
+  font,
+} from "@pylonsync/sdk";
+
+// ---------------------------------------------------------------------------
+// inventory — stock control for a small business: products, an append-only
+// ledger of movements, and the levels derived from it.
+//
+// THE CENTRAL DECISION: there is no `quantity` column. On-hand is the SUM of a
+// product's movements. A mutable counter is the classic inventory bug — two
+// people receive the same delivery, both read 10, both write 15, and five units
+// vanish with nothing to audit. Appending "+5" twice gives 20 and shows exactly
+// who did it. It also makes every count explainable from the same rows that
+// produced it.
+//
+//   • Product  — sku, name, cost, price, reorder point.
+//   • Movement — a signed delta with a reason. Append-only; never edited.
+//   • User     — a team member (email/password).
+//
+// Money is INTEGER CENTS; quantities are whole units. You cannot hold half a
+// physical thing, and allowing it hides unit-of-measure mistakes.
+//
+// The realtime hook: a movement recorded at the back door updates the level on
+// the shop floor's screen immediately — nobody sells what was just damaged.
+//
+// TRUST MODEL: an internal tool for ONE business. Every entity is readable and
+// writable by any SIGNED-IN user and by nobody else.
+// ---------------------------------------------------------------------------
+
+const TEAM = "auth.userId != null";
+
+const Product = entity(
+  "Product",
+  {
+    // Unique: two rows sharing a SKU means two different answers to "how many
+    // do we have", which is the question this app exists to answer.
+    sku: field.string().unique(),
+    name: field.string(),
+    category: field.string().optional(),
+    // What it costs YOU — valuation is at cost, not at retail.
+    unitCostCents: field.number().default(0),
+    unitPriceCents: field.number().default(0),
+    // Order more at or below this. 0 / unset means never flag it.
+    reorderPoint: field.number().default(0),
+    // Discontinued lines stay for their movement history rather than being
+    // deleted — removing the product would orphan the ledger that explains
+    // last quarter's numbers.
+    archived: field.boolean().default(false),
+    createdAt: field.datetime().defaultNow(),
+  },
+  {
+    indexes: [
+      { name: "by_sku", fields: ["sku"], unique: true },
+      { name: "by_category", fields: ["category"], unique: false },
+    ],
+  },
+);
+
+// APPEND-ONLY. Nothing in the app updates or deletes a movement: a correction
+// is another movement in the opposite direction, which is what makes the
+// history trustworthy. The policy enforces that, not just convention.
+const Movement = entity(
+  "Movement",
+  {
+    productId: field.id("Product"),
+    // Signed whole units: positive receives, negative issues. Never zero.
+    delta: field.number(),
+    // "received" | "sold" | "returned" | "damaged" | "count" — see REASONS.
+    reason: field.string(),
+    note: field.string().optional(),
+    actorId: field.id("User").readonly().optional(),
+    createdAt: field.datetime().defaultNow(),
+  },
+  {
+    indexes: [
+      { name: "by_product", fields: ["productId"], unique: false },
+      { name: "by_created", fields: ["createdAt"], unique: false },
+    ],
+  },
+);
+
+const User = entity(
+  "User",
+  {
+    email: field.string(),
+    displayName: field.string().optional(),
+    passwordHash: field.string().serverOnly().optional(),
+    avatarColor: field.string().optional(),
+    emailVerified: field.datetime().optional(),
+    createdAt: field.datetime().defaultNow(),
+  },
+  { indexes: [{ name: "by_email", fields: ["email"], unique: true }] },
+);
+
+const productPolicy = policy({
+  name: "product_team",
+  entity: "Product",
+  allowRead: TEAM,
+  allowInsert: TEAM,
+  allowUpdate: TEAM,
+  allowDelete: TEAM,
+});
+
+// The ledger is INSERT-ONLY at the policy level. Editing a movement would
+// silently rewrite history and change a past valuation; deleting one would make
+// the current level unexplainable. Corrections are new rows.
+const movementPolicy = policy({
+  name: "movement_append_only",
+  entity: "Movement",
+  allowRead: TEAM,
+  allowInsert: TEAM,
+  allowUpdate: "false",
+  allowDelete: "false",
+});
+
+const userPolicy = policy({
+  name: "user_team_read",
+  entity: "User",
+  allowRead: TEAM,
+  allowInsert: "false",
+  allowUpdate: "false",
+  allowDelete: "false",
+});
+
+const manifest = buildManifest({
+  name: "__APP_NAME__",
+  version: "0.1.0",
+  entities: [Product, Movement, User],
+  queries: [],
+  actions: [],
+  policies: [productPolicy, movementPolicy, userPolicy],
+  auth: auth(),
+  fonts: [
+    font({
+      family: "Inter",
+      variable: "--font-sans",
+      weights: ["400", "500", "600", "700"],
+      subsets: ["latin"],
+      display: "swap",
+      preload: true,
+    }),
+  ],
+  routes: await discoverAppRoutes(),
+});
+
+console.log(JSON.stringify(manifest, null, 2));
+
+export default manifest;

package/templates/inventory/bunfig

@@ -0,0 +1,4 @@
+[test]
+# Register a DOM (happy-dom) before any test runs so React component tests can
+# render under `pylon test` / `bun test`. Harmless for pure-logic tests.
+preload = ["./tests/setup.ts"]

package/templates/inventory/components/avatar.tsx

@@ -0,0 +1,40 @@
+import React from "react";
+import { cn } from "@/lib/utils";
+import { accentIndex, initials } from "@/lib/format";
+
+// Deterministic accent per record — the same company keeps its colour across
+// sessions and machines without storing one. Hues are muted so a dense list
+// doesn't turn into confetti.
+const ACCENTS = [
+  "bg-indigo-500/15 text-indigo-500 dark:text-indigo-300",
+  "bg-emerald-500/15 text-emerald-600 dark:text-emerald-300",
+  "bg-amber-500/15 text-amber-600 dark:text-amber-300",
+  "bg-rose-500/15 text-rose-500 dark:text-rose-300",
+  "bg-sky-500/15 text-sky-600 dark:text-sky-300",
+  "bg-violet-500/15 text-violet-500 dark:text-violet-300",
+];
+
+export function Avatar({
+  name,
+  size = "md",
+  className,
+}: {
+  name: string | null | undefined;
+  size?: "sm" | "md";
+  className?: string;
+}) {
+  const label = initials(name);
+  return (
+    <span
+      aria-hidden="true"
+      className={cn(
+        "inline-flex shrink-0 select-none items-center justify-center rounded-full font-medium",
+        size === "sm" ? "size-5 text-[9px]" : "size-6 text-[10px]",
+        ACCENTS[accentIndex(name ?? "?", ACCENTS.length)],
+        className,
+      )}
+    >
+      {label}
+    </span>
+  );
+}

package/templates/inventory/components/command-palette.tsx

@@ -0,0 +1,162 @@
+import React, { useEffect, useMemo, useRef, useState } from "react";
+import { Building2, Plus, Search, User } from "lucide-react";
+import { cn } from "@/lib/utils";
+import { Kbd } from "@/components/kbd";
+import { moveSelection, searchItems, type SearchItem } from "@/lib/search";
+
+const TYPE_ICON: Record<SearchItem["type"], React.ReactNode> = {
+  deal: <Search />,
+  company: <Building2 />,
+  contact: <User />,
+};
+
+export interface CommandAction {
+  id: string;
+  label: string;
+  run: () => void;
+}
+
+/**
+ * ⌘K. Searches the synced replica in memory, so results land as you type with
+ * no request per keystroke — see lib/search.ts for the ranking.
+ *
+ * Presentational: items and actions come in as props, selection is delegated
+ * through onSelect. Keyboard handling lives here because it belongs to the
+ * widget, not to the page that opened it.
+ */
+export function CommandPalette({
+  open,
+  items,
+  actions = [],
+  onClose,
+  onSelect,
+}: {
+  open: boolean;
+  items: SearchItem[];
+  actions?: CommandAction[];
+  onClose: () => void;
+  onSelect: (item: SearchItem) => void;
+}) {
+  const [query, setQuery] = useState("");
+  const [index, setIndex] = useState(0);
+  const inputRef = useRef<HTMLInputElement | null>(null);
+
+  const results = useMemo(() => searchItems(items, query), [items, query]);
+  const shownActions = query.trim() ? [] : actions;
+  const rows = useMemo(
+    () => [
+      ...shownActions.map((a) => ({ kind: "action" as const, action: a })),
+      ...results.map((item) => ({ kind: "item" as const, item })),
+    ],
+    [shownActions, results],
+  );
+
+  useEffect(() => {
+    if (!open) return;
+    setQuery("");
+    setIndex(0);
+    // Focus after paint so the dialog is mounted and the caret lands.
+    const id = requestAnimationFrame(() => inputRef.current?.focus());
+    return () => cancelAnimationFrame(id);
+  }, [open]);
+
+  useEffect(() => {
+    setIndex(0);
+  }, [query]);
+
+  if (!open) return null;
+
+  function commit(at: number) {
+    const row = rows[at];
+    if (!row) return;
+    if (row.kind === "action") row.action.run();
+    else onSelect(row.item);
+    onClose();
+  }
+
+  return (
+    <div
+      className="fixed inset-0 z-50 flex items-start justify-center bg-black/50 pt-[12vh]"
+      // Clicking the backdrop dismisses; clicks inside the panel must not.
+      onMouseDown={(event) => {
+        if (event.target === event.currentTarget) onClose();
+      }}
+    >
+      <div
+        role="dialog"
+        aria-modal="true"
+        aria-label="Search"
+        className="w-full max-w-lg overflow-hidden rounded-xl border border-border bg-popover shadow-2xl"
+        onKeyDown={(event) => {
+          if (event.key === "Escape") {
+            event.preventDefault();
+            onClose();
+          } else if (event.key === "ArrowDown") {
+            event.preventDefault();
+            setIndex((i) => moveSelection(i, 1, rows.length));
+          } else if (event.key === "ArrowUp") {
+            event.preventDefault();
+            setIndex((i) => moveSelection(i, -1, rows.length));
+          } else if (event.key === "Enter") {
+            event.preventDefault();
+            commit(index);
+          }
+        }}
+      >
+        <div className="flex items-center gap-2 border-b border-border px-3">
+          <Search className="size-4 shrink-0 text-muted-foreground" />
+          <input
+            ref={inputRef}
+            value={query}
+            onChange={(event) => setQuery(event.target.value)}
+            placeholder="Search deals, companies, contacts…"
+            aria-label="Search deals, companies and contacts"
+            className="h-11 flex-1 bg-transparent text-[13px] outline-none placeholder:text-muted-foreground"
+          />
+          <Kbd>esc</Kbd>
+        </div>
+
+        <div className="max-h-80 overflow-y-auto p-1.5">
+          {rows.length === 0 ? (
+            <p className="px-3 py-6 text-center text-[12px] text-muted-foreground">
+              No matches for “{query}”
+            </p>
+          ) : (
+            rows.map((row, at) => (
+              <button
+                key={row.kind === "action" ? row.action.id : row.item.id}
+                type="button"
+                // Pointer hover moves selection so mouse and keyboard agree.
+                onMouseMove={() => setIndex(at)}
+                onClick={() => commit(at)}
+                aria-selected={at === index}
+                className={cn(
+                  "flex w-full items-center gap-2.5 rounded-md px-2.5 py-2 text-left text-[13px] transition-colors",
+                  "[&_svg]:size-3.5 [&_svg]:shrink-0 [&_svg]:text-muted-foreground",
+                  at === index ? "bg-surface-2" : "hover:bg-surface-2/60",
+                )}
+              >
+                {row.kind === "action" ? (
+                  <>
+                    <Plus />
+                    <span className="flex-1 truncate">{row.action.label}</span>
+                  </>
+                ) : (
+                  <>
+                    {TYPE_ICON[row.item.type]}
+                    <span className="flex-1 truncate">{row.item.title}</span>
+                    {row.item.subtitle ? (
+                      <span className="truncate text-[12px] text-muted-foreground">
+                        {row.item.subtitle}
+                      </span>
+                    ) : null}
+                  </>
+                )}
+              </button>
+            ))
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

package/templates/inventory/components/data-table.tsx

@@ -0,0 +1,90 @@
+import React from "react";
+import { cn } from "@/lib/utils";
+
+export interface ColumnDef<Row> {
+  key: string;
+  header: string;
+  /** Cell content. Return a string and it's rendered as-is. */
+  cell: (row: Row) => React.ReactNode;
+  /** Right-align and tabular-figure a numeric column. */
+  numeric?: boolean;
+  className?: string;
+}
+
+/**
+ * A dense list view. Rows are 36px so a screenful is a screenful of data, and
+ * the header sticks while the body scrolls.
+ *
+ * Generic and presentational — every view here uses the same one, which is why
+ * companies and contacts look like the same product.
+ */
+export function DataTable<Row extends { id: string }>({
+  rows,
+  columns,
+  onRowClick,
+  empty,
+}: {
+  rows: Row[];
+  columns: ColumnDef<Row>[];
+  onRowClick?: (row: Row) => void;
+  empty?: React.ReactNode;
+}) {
+  if (rows.length === 0 && empty) return <>{empty}</>;
+
+  return (
+    <div className="min-h-0 flex-1 overflow-auto">
+      <table className="w-full border-collapse text-[13px]">
+        <thead className="sticky top-0 z-10 bg-background">
+          <tr className="hairline">
+            {columns.map((column) => (
+              <th
+                key={column.key}
+                scope="col"
+                className={cn(
+                  "h-8 px-4 text-left text-[11px] font-medium text-muted-foreground",
+                  column.numeric && "text-right",
+                  column.className,
+                )}
+              >
+                {column.header}
+              </th>
+            ))}
+          </tr>
+        </thead>
+        <tbody>
+          {rows.map((row) => (
+            <tr
+              key={row.id}
+              onClick={onRowClick ? () => onRowClick(row) : undefined}
+              tabIndex={onRowClick ? 0 : undefined}
+              onKeyDown={
+                onRowClick
+                  ? (event) => {
+                      if (event.key === "Enter") onRowClick(row);
+                    }
+                  : undefined
+              }
+              className={cn(
+                "border-b border-border/60 transition-colors",
+                onRowClick && "cursor-pointer hover:bg-surface-1",
+              )}
+            >
+              {columns.map((column) => (
+                <td
+                  key={column.key}
+                  className={cn(
+                    "h-9 max-w-0 truncate px-4",
+                    column.numeric && "tabular text-right",
+                    column.className,
+                  )}
+                >
+                  {column.cell(row)}
+                </td>
+              ))}
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}

package/templates/inventory/components/empty-state.tsx

@@ -0,0 +1,43 @@
+import React from "react";
+import { cn } from "@/lib/utils";
+
+/**
+ * An empty state that says what this screen is for and offers the one action
+ * that fills it. "No records found" tells a new user nothing and gives them
+ * nowhere to go.
+ */
+export function EmptyState({
+  icon,
+  title,
+  description,
+  action,
+  className,
+}: {
+  icon?: React.ReactNode;
+  title: string;
+  description?: string;
+  action?: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <div
+      className={cn(
+        "flex flex-col items-center justify-center px-6 py-16 text-center",
+        className,
+      )}
+    >
+      {icon ? (
+        <div className="mb-3 flex size-9 items-center justify-center rounded-lg bg-surface-2 text-muted-foreground [&_svg]:size-4">
+          {icon}
+        </div>
+      ) : null}
+      <p className="text-[13px] font-medium">{title}</p>
+      {description ? (
+        <p className="mt-1 max-w-sm text-[12px] leading-5 text-muted-foreground">
+          {description}
+        </p>
+      ) : null}
+      {action ? <div className="mt-4">{action}</div> : null}
+    </div>
+  );
+}

package/templates/inventory/components/kbd.tsx

@@ -0,0 +1,23 @@
+import React from "react";
+import { cn } from "@/lib/utils";
+
+/** A keyboard hint. Present in the UI because the shortcuts are real. */
+export function Kbd({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <kbd
+      className={cn(
+        "inline-flex h-5 min-w-5 items-center justify-center rounded border border-border bg-surface-2 px-1.5",
+        "font-sans text-[10px] font-medium text-muted-foreground",
+        className,
+      )}
+    >
+      {children}
+    </kbd>
+  );
+}