@tokenoftrust/storefront-runner 1.3.2

package/apps/storefront/src/lib/d1/catalog.ts

@@ -0,0 +1,366 @@
+/**
+ * D1 catalog read-model queries (the one-store target — epics/edge-read-replica.md).
+ *
+ * Queries run against a small `Queryable` seam so the SAME code serves D1 in the
+ * Worker (via `fromD1`) and an in-memory `node:sqlite` in tests. Covers FTS5
+ * (trigram) search, getProductByHandle, collections, and faceted `listProducts`
+ * (filter + sort + paginate + facet counts in SQL GROUP BY) — the full read path,
+ * verified end-to-end against the real D1 engine (workerd).
+ */
+import {
+  CATALOG_D1_SCHEMA,
+  toProductRow,
+  toCollectionRow,
+  facetRows,
+  collectionRows,
+  type CatalogCollection,
+  type CatalogProduct,
+  type Facet,
+  type ListProductsQuery,
+  type ListProductsResponse,
+} from "@tot/public-runtime";
+import { PRICE_BUCKETS } from "../priceBuckets.js";
+
+/** Minimal async query seam — implemented by D1 and by the node:sqlite test shim. */
+export interface Queryable {
+  all<T = Record<string, unknown>>(sql: string, ...params: unknown[]): Promise<T[]>;
+  first<T = Record<string, unknown>>(sql: string, ...params: unknown[]): Promise<T | null>;
+  run(sql: string, ...params: unknown[]): Promise<void>;
+  exec(sql: string): Promise<void>;
+}
+
+/** The slice of the Cloudflare D1Database we use (kept local to avoid a types dep). */
+export interface D1Like {
+  prepare(sql: string): {
+    bind(...vals: unknown[]): {
+      all(): Promise<{ results: unknown[] }>;
+      first(): Promise<unknown>;
+      run(): Promise<unknown>;
+    };
+  };
+  exec(sql: string): Promise<unknown>;
+}
+
+/** Adapt a Cloudflare D1Database to the Queryable seam. */
+export function fromD1(db: D1Like): Queryable {
+  return {
+    all: async <T>(sql: string, ...params: unknown[]) =>
+      (await db.prepare(sql).bind(...params).all()).results as T[],
+    first: async <T>(sql: string, ...params: unknown[]) =>
+      ((await db.prepare(sql).bind(...params).first()) ?? null) as T | null,
+    run: async (sql: string, ...params: unknown[]) => {
+      await db.prepare(sql).bind(...params).run();
+    },
+    exec: async (sql: string) => {
+      await db.exec(sql);
+    },
+  };
+}
+
+/** Create the catalog schema (idempotent). Used for local/test seeding. */
+export async function initSchema(db: Queryable): Promise<void> {
+  await db.exec(CATALOG_D1_SCHEMA);
+}
+
+/** Insert one product into all read-model tables (products, fts, facets, collections). */
+export async function insertProduct(db: Queryable, p: CatalogProduct, position = 0): Promise<void> {
+  const r = toProductRow(p, position);
+  await db.run(
+    `INSERT OR REPLACE INTO products
+       (handle,title,vendor,product_type,tags,description_text,price_min,price_max,currency,image,available,status,position,created_at,data)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+    r.handle, r.title, r.vendor, r.product_type, r.tags, r.description_text,
+    r.price_min, r.price_max, r.currency, r.image, r.available, r.status,
+    r.position, r.created_at, r.data,
+  );
+  await db.run(
+    `INSERT INTO products_fts (handle,title,vendor,product_type,tags,description_text)
+     VALUES (?,?,?,?,?,?)`,
+    p.handle, p.title, p.vendor ?? "", p.product_type ?? "", p.tags.join(" "), p.description_text,
+  );
+  for (const f of facetRows(p)) {
+    await db.run(`INSERT INTO product_facets (handle,name,value) VALUES (?,?,?)`, p.handle, f.name, f.value);
+  }
+  for (const c of collectionRows(p)) {
+    await db.run(`INSERT INTO product_collections (handle,collection) VALUES (?,?)`, p.handle, c.collection);
+  }
+}
+
+/** Insert one collection row. */
+export async function insertCollection(db: Queryable, c: CatalogCollection): Promise<void> {
+  const r = toCollectionRow(c);
+  await db.run(
+    `INSERT OR REPLACE INTO collections (handle,title,position,data) VALUES (?,?,?,?)`,
+    r.handle, r.title, r.position, r.data,
+  );
+}
+
+export async function listCollections(db: Queryable): Promise<CatalogCollection[]> {
+  const rows = await db.all<{ data: string }>(`SELECT data FROM collections ORDER BY position ASC`);
+  return rows.map((r) => JSON.parse(r.data) as CatalogCollection);
+}
+
+export async function getCollectionByHandle(
+  db: Queryable,
+  handle: string,
+): Promise<CatalogCollection | null> {
+  const row = await db.first<{ data: string }>(
+    `SELECT data FROM collections WHERE handle = ?`,
+    handle,
+  );
+  return row ? (JSON.parse(row.data) as CatalogCollection) : null;
+}
+
+/** Build an FTS5 query expression: implicit-AND of quoted terms (trigram substring). */
+function ftsExpr(q: string): string | null {
+  const terms = q
+    .trim()
+    .split(/\s+/)
+    .filter((t) => t.length >= 3) // FTS5 trigram tokens are 3 chars; shorter can't match
+    .map((t) => `"${t.replace(/"/g, '""')}"`);
+  return terms.length ? terms.join(" ") : null;
+}
+
+/** Typo-tolerant search over the active catalog, ranked by FTS5 relevance. */
+export async function searchProducts(
+  db: Queryable,
+  q: string,
+  limit = 24,
+): Promise<CatalogProduct[]> {
+  const expr = ftsExpr(q);
+  if (!expr) return [];
+  const rows = await db.all<{ data: string }>(
+    `SELECT p.data AS data
+       FROM products_fts f
+       JOIN products p ON p.handle = f.handle
+      WHERE products_fts MATCH ? AND p.status = 'active'
+      ORDER BY rank
+      LIMIT ?`,
+    expr, limit,
+  );
+  return rows.map((r) => JSON.parse(r.data) as CatalogProduct);
+}
+
+/** Full product by handle (resolves drafts too — callers gate visibility). */
+export async function getProductByHandle(
+  db: Queryable,
+  handle: string,
+): Promise<CatalogProduct | null> {
+  const row = await db.first<{ data: string }>(
+    `SELECT data FROM products WHERE handle = ?`,
+    handle,
+  );
+  return row ? (JSON.parse(row.data) as CatalogProduct) : null;
+}
+
+function sortClause(sort?: ListProductsQuery["sort"]): string {
+  switch (sort) {
+    case "price-asc":
+      return "ORDER BY p.price_min ASC, p.title COLLATE NOCASE ASC";
+    case "price-desc":
+      return "ORDER BY p.price_min DESC, p.title COLLATE NOCASE ASC";
+    case "newest":
+      return "ORDER BY p.created_at DESC";
+    case "title-asc":
+      return "ORDER BY p.title COLLATE NOCASE ASC";
+    case "featured":
+    default:
+      // Bestsellers float up, then the load order (position) — mirrors the
+      // in-Worker featured sort.
+      return `ORDER BY (CASE WHEN EXISTS (
+                SELECT 1 FROM product_facets f
+                 WHERE f.handle = p.handle AND f.name = 'tags' AND f.value = 'bestseller'
+              ) THEN 0 ELSE 1 END), p.position ASC`;
+  }
+}
+
+/** One filter clause, tagged with the facet group it belongs to (so a
+ * per-group facet-count query can exclude just its own clause). "__q__" is
+ * the free-text search — never excluded, since it narrows every facet. */
+interface FilterClause {
+  name: string;
+  sql: string;
+  params: unknown[];
+}
+
+function buildFilterClauses(query: ListProductsQuery): FilterClause[] {
+  const clauses: FilterClause[] = [];
+  for (const [name, values] of Object.entries(query.filters ?? {})) {
+    if (name === "availability" || name === "price" || !values.length) continue;
+    const placeholders = values.map(() => "?").join(",");
+    clauses.push({
+      name,
+      sql: `p.handle IN (SELECT handle FROM product_facets WHERE name = ? AND value IN (${placeholders}))`,
+      params: [name, ...values],
+    });
+  }
+  if (query.tags?.length) {
+    const placeholders = query.tags.map(() => "?").join(",");
+    clauses.push({
+      name: "tags",
+      sql: `p.handle IN (SELECT handle FROM product_facets WHERE name = 'tags' AND value IN (${placeholders}))`,
+      params: [...query.tags],
+    });
+  }
+  if (query.availability === "in-stock") {
+    clauses.push({ name: "availability", sql: "p.available = 1", params: [] });
+  }
+  if (query.priceMin != null) {
+    clauses.push({ name: "price", sql: "p.price_max >= ?", params: [query.priceMin] });
+  }
+  if (query.priceMax != null) {
+    clauses.push({ name: "price", sql: "p.price_min <= ?", params: [query.priceMax] });
+  }
+  if (query.q?.trim()) {
+    const like = `%${query.q.trim().toLowerCase()}%`;
+    clauses.push({
+      name: "__q__",
+      sql: "(lower(p.title) LIKE ? OR lower(p.vendor) LIKE ? OR lower(p.product_type) LIKE ? OR lower(p.description_text) LIKE ? OR lower(p.tags) LIKE ?)",
+      params: [like, like, like, like, like],
+    });
+  }
+  return clauses;
+}
+
+/** Render clauses (minus one excluded group, if given) as an " AND ..." suffix. */
+function clauseSqlExcept(
+  clauses: FilterClause[],
+  except?: string,
+): { sql: string; params: unknown[] } {
+  const kept = clauses.filter((c) => c.name !== except);
+  return {
+    sql: kept.length ? ` AND ${kept.map((c) => c.sql).join(" AND ")}` : "",
+    params: kept.flatMap((c) => c.params),
+  };
+}
+
+/**
+ * Facet counts with LIVE narrowing: each group's value counts apply every
+ * OTHER active filter (all groups but its own, plus q/availability/price),
+ * matching the storefront's multi-select facet UI. A value known to the pool
+ * but narrowed to zero by other filters still appears (count: 0) instead of
+ * vanishing, so the facet list stays stable while filtering.
+ */
+async function buildFacetsSql(
+  db: Queryable,
+  poolSql: string,
+  poolParams: unknown[],
+  clauses: FilterClause[],
+): Promise<Facet[]> {
+  // Discover every (name, value) pair present anywhere in the pool
+  // (unfiltered), so facet groups/values don't disappear when narrowed to 0.
+  const allRows = await db.all<{ name: string; value: string }>(
+    `SELECT DISTINCT pf.name AS name, pf.value AS value
+       FROM product_facets pf
+      WHERE pf.handle IN (SELECT p.handle ${poolSql})`,
+    ...poolParams,
+  );
+  const namesInOrder: string[] = [];
+  const valuesByName = new Map<string, string[]>();
+  for (const r of allRows) {
+    if (!valuesByName.has(r.name)) {
+      namesInOrder.push(r.name);
+      valuesByName.set(r.name, []);
+    }
+    valuesByName.get(r.name)!.push(r.value);
+  }
+
+  const facets: Facet[] = [];
+  for (const name of namesInOrder) {
+    const { sql: exceptSql, params: exceptParams } = clauseSqlExcept(clauses, name);
+    const rows = await db.all<{ value: string; n: number }>(
+      `SELECT pf.value AS value, COUNT(DISTINCT pf.handle) AS n
+         FROM product_facets pf
+        WHERE pf.name = ?
+          AND pf.handle IN (SELECT p.handle ${poolSql}${exceptSql})
+        GROUP BY pf.value`,
+      name, ...poolParams, ...exceptParams,
+    );
+    const counts = new Map<string, number>(valuesByName.get(name)!.map((v) => [v, 0]));
+    for (const r of rows) counts.set(r.value, r.n);
+    facets.push({
+      name,
+      values: [...counts.entries()]
+        .map(([value, count]) => ({ value, count }))
+        .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value)),
+    });
+  }
+
+  const { sql: availExceptSql, params: availExceptParams } = clauseSqlExcept(
+    clauses,
+    "availability",
+  );
+  const avail = await db.first<{ instock: number | null; total: number }>(
+    `SELECT SUM(CASE WHEN p.available = 1 THEN 1 ELSE 0 END) AS instock, COUNT(*) AS total ${poolSql}${availExceptSql}`,
+    ...poolParams, ...availExceptParams,
+  );
+  facets.push({
+    name: "availability",
+    values: [
+      { value: "in-stock", count: avail?.instock ?? 0 },
+      { value: "all", count: avail?.total ?? 0 },
+    ],
+  });
+
+  const { sql: priceExceptSql, params: priceExceptParams } = clauseSqlExcept(clauses, "price");
+  // Bucket boundaries are fixed numeric constants (PRICE_BUCKETS), not user
+  // input, so inlining them into the CASE expression is safe.
+  const bucketCase = PRICE_BUCKETS.map(
+    (b) =>
+      `SUM(CASE WHEN p.price_min >= ${b.min}${b.max != null ? ` AND p.price_min < ${b.max}` : ""} THEN 1 ELSE 0 END) AS "${b.key}"`,
+  ).join(", ");
+  const priceRow = await db.first<Record<string, number>>(
+    `SELECT ${bucketCase} ${poolSql}${priceExceptSql}`,
+    ...poolParams, ...priceExceptParams,
+  );
+  facets.push({
+    name: "price",
+    values: PRICE_BUCKETS.map((b) => ({ value: b.key, count: priceRow?.[b.key] ?? 0 })),
+  });
+
+  return facets;
+}
+
+/**
+ * Faceted listing — filter, sort, paginate, and count facets in SQL, replacing
+ * the in-Worker O(products×options×variants) scan. Option/tag filters are
+ * intra-group OR, inter-group AND (a product matches a group if it has any
+ * variant value in it). Facet counts are LIVE: each group's counts reflect
+ * every OTHER active filter (see buildFacetsSql), not just the collection pool.
+ */
+export async function listProducts(
+  db: Queryable,
+  query: ListProductsQuery = {},
+): Promise<ListProductsResponse> {
+  const pageSize = Math.max(1, query.pageSize ?? 12);
+
+  // Pool: active products, optionally scoped to a collection.
+  const poolJoin = query.collection
+    ? "JOIN product_collections pc ON pc.handle = p.handle AND pc.collection = ?"
+    : "";
+  const poolParams: unknown[] = query.collection ? [query.collection] : [];
+  const poolSql = `FROM products p ${poolJoin} WHERE p.status = 'active'`;
+
+  // Result filters layered on the pool.
+  const clauses = buildFilterClauses(query);
+  const { sql: filterClause, params: filterParams } = clauseSqlExcept(clauses);
+  const resultParams = [...poolParams, ...filterParams];
+
+  const totalRow = await db.first<{ n: number }>(
+    `SELECT COUNT(*) AS n ${poolSql}${filterClause}`,
+    ...resultParams,
+  );
+  const total = totalRow?.n ?? 0;
+  const pageCount = Math.max(1, Math.ceil(total / pageSize));
+  const page = Math.min(Math.max(1, query.page ?? 1), pageCount);
+  const offset = (page - 1) * pageSize;
+
+  const rows = await db.all<{ data: string }>(
+    `SELECT p.data AS data ${poolSql}${filterClause} ${sortClause(query.sort)} LIMIT ? OFFSET ?`,
+    ...resultParams, pageSize, offset,
+  );
+  const products = rows.map((r) => JSON.parse(r.data) as CatalogProduct);
+
+  const facets = await buildFacetsSql(db, poolSql, poolParams, clauses);
+  return { products, page, pageSize, total, facets };
+}

package/apps/storefront/src/lib/dashboard/staffAdmission.ts

@@ -0,0 +1,43 @@
+/**
+ * Pure helpers for the ToT-staff two-phase admission (#8425 staff access), kept
+ * out of the Astro route files so the gate + selection-builder are unit-testable.
+ *
+ * PHASE 1 (admission gate): only a session that actually carries ToT-staff scope
+ * (`staff[]` non-empty) may search vendors or enter one. This is the near-side
+ * gate on the storefront's staff endpoints; tot20 re-checks staff scope + writes
+ * the audit row on the far side (`staffVendorAccess`), so this is defence-in-depth,
+ * not the authority.
+ *
+ * PHASE 2 (scope): after tot20 admits, we build a short-lived {@link StaffSelection}
+ * scoped to the returned staffRoles capability. It is stamped on the session as a
+ * DISTINCT marker from `tenants[]` — never a synthesized membership.
+ */
+import type { SessionRecord, StaffSelection } from "@/lib/auth/session";
+
+/**
+ * Staff selection lifetime. Deliberately short: staff cross-vendor access is a
+ * deliberate, audited act, not a standing grant — re-entering re-audits.
+ */
+export const STAFF_SELECTION_TTL_SECONDS = 30 * 60;
+
+/** True when the session carries ToT-staff scope (the admission-gate predicate). */
+export function isStaffSession(
+  session: Pick<SessionRecord, "staff"> | null | undefined,
+): boolean {
+  return !!session && Array.isArray(session.staff) && session.staff.length > 0;
+}
+
+/** Build the short-lived staff selection marker to stamp on the session. */
+export function buildStaffSelection(input: {
+  resource: string;
+  capability: string;
+  nowSeconds: number;
+  ttlSeconds?: number;
+}): StaffSelection {
+  const ttl = input.ttlSeconds && input.ttlSeconds > 0 ? input.ttlSeconds : STAFF_SELECTION_TTL_SECONDS;
+  return {
+    resource: input.resource.trim(),
+    capability: input.capability,
+    exp: input.nowSeconds + ttl,
+  };
+}