@tokenoftrust/storefront-runner 1.3.2

package/apps/storefront/src/lib/admin/services/mock/orders.ts

@@ -0,0 +1,184 @@
+import type { AdminTenantEnvelope } from "../../envelope";
+import { MOCK_ANCHOR_ISO, offsetIso, pick, randomBool, randomInt, seededRandom } from "../../seed";
+import type {
+  OrderDetail,
+  OrderEvidenceEvent,
+  OrderLineItem,
+  OrderQueueSummary,
+  OrderRow,
+  OrdersViewModel,
+} from "../../viewmodels/orders";
+import { tenantProfile } from "./tenants";
+import { memoizeByEnvelope } from "../../memoizeByEnvelope";
+
+// Must stay index-aligned with customers.ts's NAMES: an order's customerId is
+// derived from the picked name's position here, and customers.ts assigns each
+// customer the id `cust-<tenant>-<position>`. The evidence graph joins order→
+// customer by that shared id, so these two arrays must remain identical.
+const CUSTOMER_NAMES = [
+  "Riley Harper",
+  "Jordan Lee",
+  "Casey Nguyen",
+  "Morgan Blake",
+  "Sam Ortiz",
+  "Avery Chen",
+  "Quinn Sullivan",
+  "Reese Patel",
+];
+
+// Must stay index-aligned with products.ts's PRODUCT_NAMES: an order's productId
+// is derived from the picked item's position here, and products.ts assigns each
+// product the id `prod-<tenant>-<position>`. The evidence graph joins order→
+// product by that shared id, so these pools must remain identical per vertical.
+const ITEM_POOLS: Record<string, string[]> = {
+  vape: ["Vape Pen Starter Kit", "Disposable Vape 5000", "Nicotine Pouches 6mg", "Replacement Coil 3-Pack"],
+  tobacco: ["Pipe Tobacco 1oz", "Cigar Sampler Pack", "Rolling Papers 32ct", "Loose Leaf Blend"],
+};
+
+function buildRow(rng: () => number, index: number, targetTenant: string, vertical: string): OrderRow {
+  const items = ITEM_POOLS[vertical] ?? ITEM_POOLS.vape!;
+  const total = randomInt(rng, 45, 420);
+  const isHold = randomBool(rng, index === 0 ? 1 : 0.28);
+  const isCompleted = !isHold && randomBool(rng, 0.35);
+  const payment = isHold ? "authorized" : "captured";
+  const shipState = isHold ? "hold_review_required" : isCompleted ? "completed" : "ready_to_ship";
+  const blocker = isHold ? pick(rng, ["Payment capture", "Manual review", "Age verification hold"]) : null;
+
+  const customerIndex = randomInt(rng, 0, CUSTOMER_NAMES.length - 1);
+  const itemIndex = randomInt(rng, 0, items.length - 1);
+
+  return {
+    id: `#${2_200_000_000 + Math.floor(rng() * 90_000_000)}`,
+    placedAt: offsetIso(MOCK_ANCHOR_ISO, -randomInt(rng, 5, 600)),
+    customerId: `cust-${targetTenant}-${customerIndex}`,
+    customerName: CUSTOMER_NAMES[customerIndex]!,
+    customerNote: index === 0 ? "First-time customer" : `Returning customer, ${randomInt(rng, 2, 6)} orders`,
+    itemsSummary: items[itemIndex]!,
+    productId: `prod-${targetTenant}-${itemIndex}`,
+    total,
+    payment,
+    shipState,
+    blocker,
+    nextStep: isHold ? (blocker === "Payment capture" ? "Capture payment" : "Review risk") : isCompleted ? "View record" : "Create label",
+    riskLevel: isHold ? "high" : randomBool(rng, 0.15) ? "medium" : "low",
+  };
+}
+
+function buildDetail(row: OrderRow, rng: () => number): OrderDetail {
+  const lineItems: OrderLineItem[] = [
+    { sku: `sku-${row.id.slice(1, 6)}`, name: row.itemsSummary, quantity: 1, unitPrice: Math.round(row.total * 0.82) },
+  ];
+  const shipping = 5;
+  const estimatedTax = 0;
+  const taxesAndFees = row.total - lineItems[0]!.unitPrice - shipping;
+
+  const evidenceTimeline: OrderEvidenceEvent[] = [
+    { title: "Order imported", detail: "Storefront order became available in the admin queue.", at: row.placedAt },
+    { title: "Payment authorized", detail: "The customer completed checkout and payment was authorized.", at: offsetIso(row.placedAt, 0) },
+  ];
+  if (row.blocker) {
+    evidenceTimeline.push({ title: "Hold added", detail: `${row.blocker} must be resolved before shipment.`, at: offsetIso(row.placedAt, 1) });
+  }
+
+  return {
+    ...row,
+    lineItems,
+    shipping,
+    estimatedTax,
+    taxesAndFees,
+    readinessChecks: [
+      {
+        key: "payment_capture",
+        label: "Payment capture",
+        value: row.payment === "captured" ? "Captured" : "Authorized",
+        detail: "Capture the authorization before creating the shipping label.",
+        tone: row.payment === "captured" ? "green" : "amber",
+        action: "Capture payment",
+        blocking: row.payment !== "captured",
+      },
+      {
+        key: "tax_and_fees",
+        label: "Tax and fees",
+        value: "Collected",
+        detail: "Required amounts are included in the order total.",
+        tone: "blue",
+        action: "View total",
+        blocking: false,
+      },
+      {
+        key: "identity_and_age",
+        label: "Identity and age",
+        value: row.blocker === "Age verification hold" ? "Needs review" : "Passed",
+        detail: "Checkout assurance completed before order placement.",
+        tone: row.blocker === "Age verification hold" ? "amber" : "green",
+        action: "View evidence",
+        blocking: row.blocker === "Age verification hold",
+      },
+      {
+        key: "address",
+        label: "Address",
+        value: "Serviceable",
+        detail: "Destination is deliverable after any hold is resolved.",
+        tone: "green",
+        action: "View address",
+        blocking: false,
+      },
+    ],
+    evidenceTimeline,
+  };
+}
+
+function computeOrdersViewModel(envelope: AdminTenantEnvelope): OrdersViewModel {
+  const { targetTenant } = envelope;
+  const profile = tenantProfile(targetTenant);
+  const rng = seededRandom(`orders:${targetTenant}`);
+
+  const rowCount = randomInt(rng, 5, 8);
+  const rows = Array.from({ length: rowCount }, (_, index) => buildRow(rng, index, targetTenant, profile.vertical));
+
+  // Newest-first, so the "All orders — Newest first" queue copy and the
+  // "Oldest open order first" unfulfilled copy actually hold, and so
+  // today.oldestOpenAt below can be read off the chronological tail.
+  rows.sort((a, b) => new Date(b.placedAt).getTime() - new Date(a.placedAt).getTime());
+
+  const detailsById: Record<string, OrderDetail> = {};
+  for (const row of rows) {
+    detailsById[row.id] = buildDetail(row, rng);
+  }
+
+  const needsAttention = rows.filter((r) => r.shipState === "hold_review_required").length;
+  const readyToShip = rows.filter((r) => r.shipState === "ready_to_ship").length;
+  const completed = rows.filter((r) => r.shipState === "completed").length;
+
+  const queues: OrderQueueSummary[] = [
+    { key: "needs_attention", label: "Needs attention", count: needsAttention, detail: "Hold before shipment" },
+    { key: "ready_to_ship", label: "Ready to ship", count: readyToShip, detail: "Labels available" },
+    { key: "unfulfilled", label: "Unfulfilled", count: readyToShip + needsAttention, detail: "Oldest open order first" },
+    { key: "all", label: "All orders", count: rows.length, detail: "Newest first" },
+    { key: "completed", label: "Completed", count: completed, detail: "Delivered" },
+  ];
+
+  const paidOrders = rows.filter((r) => r.payment === "captured");
+  const grossSales = paidOrders.reduce((sum, r) => sum + r.total, 0);
+
+  const openPlacedAt = rows.filter((r) => r.shipState !== "completed").map((r) => r.placedAt);
+  const oldestOpenAt = openPlacedAt.length
+    ? openPlacedAt.reduce((oldest, at) => (at < oldest ? at : oldest))
+    : null;
+
+  return {
+    targetTenant,
+    queues,
+    rows,
+    detailsById,
+    today: {
+      grossSales,
+      paidOrders: paidOrders.length,
+      averageOrder: paidOrders.length ? Math.round((grossSales / paidOrders.length) * 100) / 100 : 0,
+      refunds: 0,
+      oldestOpenAt,
+    },
+  };
+}
+
+export const getOrdersViewModel = memoizeByEnvelope(computeOrdersViewModel);

package/apps/storefront/src/lib/admin/services/mock/products.ts

@@ -0,0 +1,105 @@
+import type { AdminTenantEnvelope } from "../../envelope";
+import { MOCK_ANCHOR_ISO, offsetIso, pick, randomBool, randomInt, seededRandom } from "../../seed";
+import type {
+  ExciseCheckKey,
+  ExciseReadinessCheck,
+  ProductDetail,
+  ProductRow,
+  ProductsViewModel,
+  ProductVariant,
+} from "../../viewmodels/products";
+import { tenantProfile } from "./tenants";
+import { memoizeByEnvelope } from "../../memoizeByEnvelope";
+
+// Must stay index-aligned with orders.ts's ITEM_POOLS: a product's id is
+// `prod-<tenant>-<position here>`, and orders.ts derives each order's productId
+// from the same position, so the evidence graph can join order→product by id.
+const PRODUCT_NAMES: Record<string, string[]> = {
+  vape: ["Vape Pen Starter Kit", "Disposable Vape 5000", "Nicotine Pouches 6mg", "Replacement Coil 3-Pack"],
+  tobacco: ["Pipe Tobacco 1oz", "Cigar Sampler Pack", "Rolling Papers 32ct", "Loose Leaf Blend"],
+};
+
+const EXCISE_CHECK_DEFS: { key: ExciseCheckKey; label: string }[] = [
+  { key: "tax_class", label: "Tax class" },
+  { key: "exempt_flag", label: "Exempt flag" },
+  { key: "nicotine_flag", label: "Nicotine flag" },
+  { key: "wholesale_basis", label: "Wholesale basis" },
+  { key: "retail_price", label: "Retail price" },
+  { key: "pack_quantity", label: "Pack quantity" },
+  { key: "volume_or_weight", label: "Volume or weight" },
+  { key: "category", label: "Product category" },
+];
+
+function buildExciseChecks(rng: () => number): ExciseReadinessCheck[] {
+  return EXCISE_CHECK_DEFS.map((def) => {
+    const present = randomBool(rng, 0.82);
+    return {
+      key: def.key,
+      label: def.label,
+      present,
+      value: present ? pick(rng, ["Set", "Confirmed", "20mg", "Case of 12", "Vape"]) : null,
+    };
+  });
+}
+
+function computeProductsViewModel(envelope: AdminTenantEnvelope): ProductsViewModel {
+  const { targetTenant } = envelope;
+  const profile = tenantProfile(targetTenant);
+  const rng = seededRandom(`products:${targetTenant}`);
+  const names = PRODUCT_NAMES[profile.vertical] ?? PRODUCT_NAMES.vape!;
+
+  const rows: ProductRow[] = [];
+  const detailsById: Record<string, ProductDetail> = {};
+
+  names.forEach((name, index) => {
+    const id = `prod-${targetTenant}-${index}`;
+    const exciseChecks = buildExciseChecks(rng);
+    const missingExciseCount = exciseChecks.filter((c) => !c.present).length;
+    const readinessScore = Math.max(0, 100 - missingExciseCount * 15);
+    const sellable = missingExciseCount === 0;
+
+    const row: ProductRow = {
+      id,
+      name,
+      productType: profile.vertical === "vape" ? "Vaping device" : "Tobacco product",
+      category: profile.vertical === "vape" ? "Vape" : "Tobacco",
+      status: "active",
+      readinessScore,
+      sellable,
+      aiChannelReady: sellable && randomBool(rng, 0.6),
+      missingExciseCount,
+    };
+    rows.push(row);
+
+    const variants: ProductVariant[] = Array.from({ length: randomInt(rng, 1, 3) }, (_, vIndex) => ({
+      sku: `${id}-v${vIndex}`,
+      name: vIndex === 0 ? "Default" : `Variant ${vIndex}`,
+      inventory: randomInt(rng, 0, 250),
+      price: randomInt(rng, 15, 65),
+    }));
+
+    detailsById[id] = {
+      ...row,
+      variants,
+      media: [{ url: `/mock/admin/products/${id}.png`, alt: name, kind: "image" }],
+      exciseChecks,
+      activity: [
+        { title: "Listed", detail: `${name} added to catalog.`, at: offsetIso(MOCK_ANCHOR_ISO, -randomInt(rng, 1000, 20000)) },
+      ],
+      complianceNotes: missingExciseCount > 0 ? [`${missingExciseCount} excise metadata field(s) missing before this can sell.`] : [],
+    };
+  });
+
+  return {
+    targetTenant,
+    savedViews: [
+      { key: "all", label: "All products" },
+      { key: "not_sellable", label: "Not sellable" },
+      { key: "ai_channel_ready", label: "AI channel ready" },
+    ],
+    rows,
+    detailsById,
+  };
+}
+
+export const getProductsViewModel = memoizeByEnvelope(computeProductsViewModel);

package/apps/storefront/src/lib/admin/services/mock/reporting.ts

@@ -0,0 +1,51 @@
+import type { AdminTenantEnvelope } from "../../envelope";
+import { memoizeByEnvelope } from "../../memoizeByEnvelope";
+import { pick, randomInt, seededRandom } from "../../seed";
+import type { AnalysisBriefItem, ReportingCategory, ReportingSummary, ReportingViewModel } from "../../viewmodels/reporting";
+
+const CATEGORY_DEFS: { category: ReportingCategory; label: string; drilldownHref: string }[] = [
+  { category: "sales", label: "Sales", drilldownHref: "#orders" },
+  { category: "products", label: "Products", drilldownHref: "#products" },
+  { category: "customers", label: "Customers", drilldownHref: "#customers" },
+  { category: "fulfillment", label: "Fulfillment", drilldownHref: "#fulfillment" },
+  { category: "compliance", label: "Compliance", drilldownHref: "#products" },
+  { category: "tax", label: "Tax", drilldownHref: "#settings" },
+  { category: "risk", label: "Risk", drilldownHref: "#orders" },
+];
+
+const TRENDS = ["up", "down", "flat"] as const;
+
+function computeReportingViewModel(envelope: AdminTenantEnvelope): ReportingViewModel {
+  const { targetTenant } = envelope;
+  const rng = seededRandom(`reporting:${targetTenant}`);
+
+  const summaries: ReportingSummary[] = CATEGORY_DEFS.map((def) => ({
+    category: def.category,
+    label: def.label,
+    headline: `${def.label} this week`,
+    value: def.category === "sales" ? `$${randomInt(rng, 4000, 18000).toLocaleString()}` : `${randomInt(rng, 2, 40)}`,
+    trend: pick(rng, TRENDS),
+    drilldownHref: def.drilldownHref,
+  }));
+
+  const drivers: AnalysisBriefItem[] = [
+    {
+      title: "Hold volume rose on weekend orders",
+      detail: "Manual review holds increased; capacity to clear them stayed flat.",
+      drilldownHref: "#orders",
+      evidenceRef: "evidence:orders-hold-trend",
+    },
+  ];
+  const watchItems: AnalysisBriefItem[] = [
+    {
+      title: "Excise metadata gaps in new listings",
+      detail: "Recently added products are missing pack quantity or tax class.",
+      drilldownHref: "#products",
+      evidenceRef: "evidence:products-excise-gaps",
+    },
+  ];
+
+  return { targetTenant, summaries, analysisBrief: { drivers, watchItems } };
+}
+
+export const getReportingViewModel = memoizeByEnvelope(computeReportingViewModel);

package/apps/storefront/src/lib/admin/services/mock/settings.ts

@@ -0,0 +1,70 @@
+import { DEFAULT_CHECKOUT_STYLE } from "@tot/public-runtime";
+import type { AdminTenantEnvelope } from "../../envelope";
+import { memoizeByEnvelope } from "../../memoizeByEnvelope";
+import { MOCK_ANCHOR_ISO, offsetIso, randomInt, seededRandom } from "../../seed";
+import type { SettingsAuditEvent, SettingsSection, SettingsViewModel } from "../../viewmodels/settings";
+
+const SECTION_DEFS: Omit<SettingsSection, "riskyChangeReview">[] = [
+  { key: "store", label: "Store", summary: "Store profile, branding, and white-label copy." },
+  { key: "checkout", label: "Checkout", summary: "Checkout assurance and identity/age verification flow." },
+  { key: "cart_appearance", label: "Cart & checkout appearance", summary: "FoxyCart brand colors and templates, prepopulated from the theme." },
+  { key: "payments", label: "Payments", summary: "Payment capture timing and gateway configuration." },
+  { key: "shipping", label: "Shipping", summary: "Carriers, rates, and shipping restrictions by region." },
+  { key: "taxes", label: "Taxes", summary: "Excise and sales tax configuration by jurisdiction." },
+  { key: "products", label: "Products", summary: "Catalog and category-to-tax-class mappings." },
+  { key: "customers", label: "Customers", summary: "Segmentation and support-flag rules." },
+  { key: "notifications", label: "Notifications", summary: "Merchant and customer notification templates." },
+  { key: "users_access", label: "Users & access", summary: "Staff roles, permissions, and internal tenant picker access." },
+  { key: "integrations", label: "Integrations", summary: "Connected services and API credentials." },
+  { key: "compliance", label: "Compliance", summary: "Evidence retention and reporting cadence." },
+  { key: "ai_admin_policy", label: "AI / admin policy", summary: "AI guardrails and approval mode for assist surfaces." },
+];
+
+const RISKY_SECTIONS = new Set(["payments", "shipping", "taxes", "users_access", "ai_admin_policy"]);
+
+function computeSettingsViewModel(envelope: AdminTenantEnvelope): SettingsViewModel {
+  const { targetTenant } = envelope;
+  const rng = seededRandom(`settings:${targetTenant}`);
+
+  const sections: SettingsSection[] = SECTION_DEFS.map((def) => ({
+    ...def,
+    riskyChangeReview: RISKY_SECTIONS.has(def.key),
+  }));
+
+  const auditTrail: SettingsAuditEvent[] = [
+    {
+      operator: "internal-staff@tokenoftrust.com",
+      targetTenant,
+      action: "settings.shipping_restrictions.updated",
+      change: "Updated shipping restriction list",
+      at: offsetIso(MOCK_ANCHOR_ISO, -randomInt(rng, 60, 5000)),
+    },
+  ];
+
+  return {
+    targetTenant,
+    sections,
+    shippingRestrictions: [
+      { region: "Utah", reason: "Vapor product shipping restriction" },
+      { region: "Massachusetts", reason: "Flavored tobacco restriction" },
+    ],
+    aiPolicyMode: "approval_required",
+    internalTenantPickerEnabled: true,
+    auditTrail,
+    // The admin console renders from mock data; the checkout-styling editor
+    // starts from the neutral baseline (an un-styled tenant). A real published
+    // override is resolved server-side via resolveCheckoutStyle at render time
+    // once the read path is wired in — until then the editor shows the default,
+    // and SAVE is already live (POST /api/admin/checkout-style publishes to the
+    // versioned spine). Cloning keeps the shared DEFAULT_CHECKOUT_STYLE constant
+    // immutable if a caller mutates the view model.
+    checkoutStyle: {
+      ...DEFAULT_CHECKOUT_STYLE,
+      colors: { ...DEFAULT_CHECKOUT_STYLE.colors },
+      typography: { ...DEFAULT_CHECKOUT_STYLE.typography },
+      button: { ...DEFAULT_CHECKOUT_STYLE.button },
+    },
+  };
+}
+
+export const getSettingsViewModel = memoizeByEnvelope(computeSettingsViewModel);

package/apps/storefront/src/lib/admin/services/mock/tenants.ts

@@ -0,0 +1,29 @@
+/**
+ * Seeded tenant registry for admin mock data. Two curated tenants give the
+ * console realistic, vertical-flavored demo data; any other `targetTenant`
+ * still gets a stable (if generic) profile via deterministic fallback, so no
+ * caller has to special-case "unknown" tenants.
+ */
+
+export type MockVertical = "vape" | "tobacco";
+
+export interface SeededTenantProfile {
+  targetTenant: string;
+  displayName: string;
+  vertical: MockVertical;
+}
+
+export const SEEDED_TENANTS: readonly SeededTenantProfile[] = [
+  { targetTenant: "northridge-vapor.com", displayName: "Northridge Vapor Co.", vertical: "vape" },
+  { targetTenant: "cascade-tobacco.com", displayName: "Cascade Tobacco Exchange", vertical: "tobacco" },
+];
+
+/** Deterministic fallback profile for any tenant not in `SEEDED_TENANTS`. */
+function fallbackProfile(targetTenant: string): SeededTenantProfile {
+  const vertical: MockVertical = targetTenant.length % 2 === 0 ? "vape" : "tobacco";
+  return { targetTenant, displayName: targetTenant, vertical };
+}
+
+export function tenantProfile(targetTenant: string): SeededTenantProfile {
+  return SEEDED_TENANTS.find((t) => t.targetTenant === targetTenant) ?? fallbackProfile(targetTenant);
+}