@tokenoftrust/storefront-runner 0.1.0

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

@@ -0,0 +1,289 @@
+/**
+ * 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 FacetValue,
+  type ListProductsQuery,
+  type ListProductsResponse,
+} from "@tot/public-runtime";
+
+/** 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`;
+  }
+}
+
+/** Facet counts over the collection-scoped pool (BEFORE option/tag/price filters). */
+async function buildFacetsSql(
+  db: Queryable,
+  poolSql: string,
+  poolParams: unknown[],
+): Promise<Facet[]> {
+  const rows = await db.all<{ name: string; value: string; n: number }>(
+    `SELECT pf.name AS name, pf.value AS value, COUNT(DISTINCT pf.handle) AS n
+       FROM product_facets pf
+      WHERE pf.handle IN (SELECT p.handle ${poolSql})
+      GROUP BY pf.name, pf.value
+      ORDER BY pf.name ASC, n DESC, pf.value ASC`,
+    ...poolParams,
+  );
+  const byName = new Map<string, FacetValue[]>();
+  for (const r of rows) {
+    const values = byName.get(r.name) ?? [];
+    values.push({ value: r.value, count: r.n });
+    byName.set(r.name, values);
+  }
+  const facets: Facet[] = [...byName.entries()].map(([name, values]) => ({ name, values }));
+
+  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}`,
+    ...poolParams,
+  );
+  facets.push({
+    name: "availability",
+    values: [
+      { value: "in-stock", count: avail?.instock ?? 0 },
+      { value: "all", count: avail?.total ?? 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). Facets are computed over the collection-scoped pool,
+ * BEFORE the option/tag/price filters, to match the storefront's facet UI.
+ */
+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 filterSql: string[] = [];
+  const filterParams: unknown[] = [];
+
+  for (const [name, values] of Object.entries(query.filters ?? {})) {
+    if (name === "availability" || name === "price" || !values.length) continue;
+    const placeholders = values.map(() => "?").join(",");
+    filterSql.push(
+      `p.handle IN (SELECT handle FROM product_facets WHERE name = ? AND value IN (${placeholders}))`,
+    );
+    filterParams.push(name, ...values);
+  }
+  if (query.tags?.length) {
+    const placeholders = query.tags.map(() => "?").join(",");
+    filterSql.push(
+      `p.handle IN (SELECT handle FROM product_facets WHERE name = 'tags' AND value IN (${placeholders}))`,
+    );
+    filterParams.push(...query.tags);
+  }
+  if (query.availability === "in-stock") filterSql.push("p.available = 1");
+  if (query.priceMin != null) {
+    filterSql.push("p.price_max >= ?");
+    filterParams.push(query.priceMin);
+  }
+  if (query.priceMax != null) {
+    filterSql.push("p.price_min <= ?");
+    filterParams.push(query.priceMax);
+  }
+  if (query.q?.trim()) {
+    const like = `%${query.q.trim().toLowerCase()}%`;
+    filterSql.push(
+      "(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 ?)",
+    );
+    filterParams.push(like, like, like, like, like);
+  }
+
+  const filterClause = filterSql.length ? ` AND ${filterSql.join(" AND ")}` : "";
+  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);
+  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,
+  };
+}