@unifiedcommerce/plugin-pos 0.0.1

package/src/routes/shifts.ts

@@ -0,0 +1,100 @@
+import { router } from "@unifiedcommerce/core";
+import { z } from "@hono/zod-openapi";
+import type { ShiftService } from "../services/shift-service";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+
+export function buildShiftRoutes(
+  service: ShiftService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("POS Shifts", "/pos/shifts", ctx);
+
+  r.post("/open")
+    .summary("Open shift")
+    .permission("pos:operate")
+    .input(z.object({
+      terminalId: z.string().uuid(),
+      openingFloat: z.number().int().min(0),
+    }))
+    .handler(async ({ input, actor, orgId }) => {
+      const body = input as { terminalId: string; openingFloat: number };
+      const result = await service.open(orgId, {
+        ...body,
+        operatorId: actor!.userId,
+      });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/{id}/close")
+    .summary("Close shift")
+    .permission("pos:operate")
+    .input(z.object({
+      closingCount: z.number().int().min(0),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { closingCount: number };
+      const result = await service.close(orgId, params.id!, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/current")
+    .summary("Get current open shift")
+    .permission("pos:operate")
+    .handler(async ({ actor, orgId }) => {
+      const result = await service.getCurrent(orgId, actor!.userId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/{id}")
+    .summary("Get shift details")
+    .permission("pos:operate")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/{id}/report")
+    .summary("Z-report")
+    .permission("pos:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.getReport(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  // ─── Cash Events ───────────────────────────────────────────────────
+
+  r.post("/{id}/cash-events")
+    .summary("Record cash event")
+    .permission("pos:operate")
+    .input(z.object({
+      type: z.enum(["drop", "pickup", "paid_in", "paid_out"]),
+      amount: z.number().int().positive(),
+      reason: z.string().max(500).optional(),
+    }))
+    .handler(async ({ params, input, actor }) => {
+      const body = input as { type: "drop" | "pickup" | "paid_in" | "paid_out"; amount: number; reason?: string };
+      const result = await service.addCashEvent(params.id!, {
+        ...body,
+        performedBy: actor!.userId,
+      });
+
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/{id}/cash-events")
+    .summary("List cash events")
+    .permission("pos:operate")
+    .handler(async ({ params }) => {
+      const result = await service.listCashEvents(params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/routes/terminals.ts

@@ -0,0 +1,62 @@
+import { router } from "@unifiedcommerce/core";
+import { z } from "@hono/zod-openapi";
+import type { TerminalService } from "../services/terminal-service";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+
+export function buildTerminalRoutes(
+  service: TerminalService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("POS Terminals", "/pos/terminals", ctx);
+
+  r.post("/")
+    .summary("Register terminal")
+    .permission("pos:admin")
+    .input(z.object({
+      name: z.string().min(1).max(100),
+      code: z.string().min(1).max(20),
+      type: z.enum(["register", "tablet", "mobile", "kiosk"]).optional(),
+      metadata: z.record(z.string(), z.unknown()).optional(),
+    }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as { name: string; code: string; type?: "register" | "tablet" | "mobile" | "kiosk"; metadata?: Record<string, unknown> };
+      const result = await service.create(orgId, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/")
+    .summary("List terminals")
+    .permission("pos:admin")
+    .handler(async ({ orgId }) => {
+      const result = await service.list(orgId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.patch("/{id}")
+    .summary("Update terminal")
+    .permission("pos:admin")
+    .input(z.object({
+      name: z.string().min(1).max(100).optional(),
+      isActive: z.boolean().optional(),
+      metadata: z.record(z.string(), z.unknown()).optional(),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { name?: string; isActive?: boolean; metadata?: Record<string, unknown> };
+      const result = await service.update(orgId, params.id!, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.delete("/{id}")
+    .summary("Deactivate terminal")
+    .permission("pos:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.deactivate(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/routes/transactions.ts

@@ -0,0 +1,192 @@
+import { router } from "@unifiedcommerce/core";
+import { z } from "@hono/zod-openapi";
+import type { TransactionService } from "../services/transaction-service";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+
+export function buildTransactionRoutes(
+  service: TransactionService,
+  cartService: { create: (input: { currency?: string; metadata?: Record<string, unknown> }, actor: unknown) => Promise<{ ok: boolean; value?: { id: string } }> },
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("POS Transactions", "/pos/transactions", ctx);
+
+  r.post("/")
+    .summary("Start transaction")
+    .permission("pos:operate")
+    .input(z.object({
+      shiftId: z.string().uuid(),
+      terminalId: z.string().uuid(),
+      type: z.enum(["sale", "return", "exchange"]).optional(),
+      customerId: z.string().uuid().optional(),
+      currency: z.string().min(3).max(3).optional(),
+    }))
+    .handler(async ({ input, actor, orgId }) => {
+      const body = input as { shiftId: string; terminalId: string; type?: "sale" | "return" | "exchange"; customerId?: string; currency?: string };
+
+      // Create a cart for this transaction
+      const cartResult = await cartService.create(
+        { currency: body.currency ?? "USD", metadata: { posTransaction: true } },
+        actor,
+      );
+      if (!cartResult.ok || !cartResult.value) {
+        throw new Error("Failed to create cart for POS transaction");
+      }
+
+      const result = await service.create(orgId, {
+        shiftId: body.shiftId,
+        terminalId: body.terminalId,
+        operatorId: actor!.userId,
+        cartId: cartResult.value.id,
+        ...(body.type != null ? { type: body.type } : {}),
+        ...(body.customerId != null ? { customerId: body.customerId } : {}),
+      });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  // NOTE: /held must be registered BEFORE /{id} to avoid UUID validation catching "held"
+  r.get("/held")
+    .summary("List held transactions")
+    .permission("pos:operate")
+    .query(z.object({
+      terminalId: z.string().uuid(),
+    }))
+    .handler(async ({ query, orgId }) => {
+      const q = query as { terminalId: string };
+      const result = await service.listHeld(orgId, q.terminalId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/{id}")
+    .summary("Get transaction")
+    .permission("pos:operate")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/{id}/items")
+    .summary("Add item to transaction")
+    .permission("pos:operate")
+    .input(z.object({
+      entityId: z.string().uuid(),
+      variantId: z.string().uuid().optional(),
+      quantity: z.number().int().min(1).max(9999).optional(),
+      notes: z.string().max(500).optional(),
+    }))
+    .handler(async ({ params, input, actor, services, orgId }) => {
+      const body = input as { entityId: string; variantId?: string; quantity?: number; notes?: string };
+      const txnResult = await service.getById(orgId, params.id!);
+      if (!txnResult.ok) throw new Error(txnResult.error);
+      if (txnResult.value.status !== "open") throw new Error("Transaction is not open");
+
+      // Delegate to cart service
+      const cart = services.cart as { addItem: (input: unknown, actor: unknown) => Promise<{ ok: boolean; value?: unknown }> };
+      const addResult = await cart.addItem({
+        cartId: txnResult.value.cartId,
+        entityId: body.entityId,
+        variantId: body.variantId,
+        quantity: body.quantity ?? 1,
+        notes: body.notes,
+      }, actor);
+
+      if (!addResult.ok) throw new Error("Failed to add item");
+      return addResult.value;
+    });
+
+  r.patch("/{id}/items/{itemId}")
+    .summary("Update line item")
+    .permission("pos:operate")
+    .input(z.object({
+      quantity: z.number().int().min(1).max(9999).optional(),
+      notes: z.string().max(500).optional(),
+    }))
+    .handler(async ({ params, input, actor, services, orgId }) => {
+      const body = input as { quantity?: number; notes?: string };
+      const txnResult = await service.getById(orgId, params.id!);
+      if (!txnResult.ok) throw new Error(txnResult.error);
+      if (txnResult.value.status !== "open") throw new Error("Transaction is not open");
+
+      const cart = services.cart as {
+        updateQuantity: (input: { cartId: string; itemId: string; quantity: number }, actor: unknown) => Promise<{ ok: boolean; value?: unknown }>;
+      };
+
+      if (body.quantity != null) {
+        const updateResult = await cart.updateQuantity({
+          cartId: txnResult.value.cartId,
+          itemId: params.itemId!,
+          quantity: body.quantity,
+        }, actor);
+        if (!updateResult.ok) throw new Error("Failed to update item");
+        return updateResult.value;
+      }
+      return { updated: true };
+    });
+
+  r.delete("/{id}/items/{itemId}")
+    .summary("Remove line item")
+    .permission("pos:operate")
+    .handler(async ({ params, actor, services, orgId }) => {
+      const txnResult = await service.getById(orgId, params.id!);
+      if (!txnResult.ok) throw new Error(txnResult.error);
+      if (txnResult.value.status !== "open") throw new Error("Transaction is not open");
+
+      const cart = services.cart as {
+        removeItem: (cartId: string, itemId: string, actor: unknown) => Promise<{ ok: boolean }>;
+      };
+      await cart.removeItem(txnResult.value.cartId, params.itemId!, actor);
+      return { removed: true };
+    });
+
+  r.post("/{id}/customer")
+    .summary("Associate customer")
+    .permission("pos:operate")
+    .input(z.object({
+      customerId: z.string().uuid(),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { customerId: string };
+      const result = await service.setCustomer(orgId, params.id!, body.customerId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/{id}/hold")
+    .summary("Hold transaction")
+    .permission("pos:operate")
+    .input(z.object({
+      label: z.string().min(1).max(200),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { label: string };
+      const result = await service.hold(orgId, params.id!, body.label);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/{id}/recall")
+    .summary("Recall held transaction")
+    .permission("pos:operate")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.recall(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/{id}/void")
+    .summary("Void transaction")
+    .permission("pos:manage")
+    .input(z.object({
+      reason: z.string().min(1).max(500),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { reason: string };
+      const result = await service.void(orgId, params.id!, body.reason);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/schema.ts

@@ -0,0 +1,136 @@
+/**
+ * POS Plugin Schema — RFC-023 Tier 0 Core Primitives
+ *
+ * 6 tables replacing the old single pos_sessions table:
+ * - pos_terminals: physical register/device registry
+ * - pos_shifts: operator working periods with cash tracking
+ * - pos_cash_events: cash drawer operations within a shift
+ * - pos_transactions: individual sales, returns, exchanges
+ * - pos_payments: payment records (supports split tender)
+ * - pos_return_items: links return transactions to original order line items
+ */
+
+import { pgTable, uuid, text, integer, boolean, timestamp, jsonb, index, uniqueIndex } from "drizzle-orm/pg-core";
+
+// ─── Terminals ──────────────────────────────────────────────────────────
+
+export const posTerminals = pgTable("pos_terminals", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  name: text("name").notNull(),
+  code: text("code").notNull(),
+  type: text("type", { enum: ["register", "tablet", "mobile", "kiosk"] }).notNull().default("register"),
+  isActive: boolean("is_active").notNull().default(true),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_pos_terminals_org").on(table.organizationId),
+  codeUnique: uniqueIndex("pos_terminals_org_code_unique").on(table.organizationId, table.code),
+}));
+
+// ─── Shifts ─────────────────────────────────────────────────────────────
+
+export const posShifts = pgTable("pos_shifts", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  terminalId: uuid("terminal_id").references(() => posTerminals.id, { onDelete: "cascade" }).notNull(),
+  operatorId: text("operator_id").notNull(),
+  status: text("status", { enum: ["open", "closed"] }).notNull().default("open"),
+  openingFloat: integer("opening_float").notNull().default(0),
+  closingCount: integer("closing_count"),
+  expectedCash: integer("expected_cash"),
+  cashVariance: integer("cash_variance"),
+  salesCount: integer("sales_count").notNull().default(0),
+  salesTotal: integer("sales_total").notNull().default(0),
+  refundsCount: integer("refunds_count").notNull().default(0),
+  refundsTotal: integer("refunds_total").notNull().default(0),
+  voidsCount: integer("voids_count").notNull().default(0),
+  closedAt: timestamp("closed_at", { withTimezone: true }),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_pos_shifts_org").on(table.organizationId),
+  terminalIdx: index("idx_pos_shifts_terminal").on(table.terminalId),
+}));
+
+// ─── Cash Events ────────────────────────────────────────────────────────
+
+export const posCashEvents = pgTable("pos_cash_events", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  shiftId: uuid("shift_id").references(() => posShifts.id, { onDelete: "cascade" }).notNull(),
+  type: text("type", { enum: ["float", "drop", "pickup", "paid_in", "paid_out"] }).notNull(),
+  amount: integer("amount").notNull(),
+  reason: text("reason"),
+  performedBy: text("performed_by").notNull(),
+  performedAt: timestamp("performed_at", { withTimezone: true }).defaultNow().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  shiftIdx: index("idx_pos_cash_events_shift").on(table.shiftId),
+}));
+
+// ─── Transactions ───────────────────────────────────────────────────────
+
+export const posTransactions = pgTable("pos_transactions", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  shiftId: uuid("shift_id").references(() => posShifts.id, { onDelete: "cascade" }).notNull(),
+  terminalId: uuid("terminal_id").references(() => posTerminals.id).notNull(),
+  operatorId: text("operator_id").notNull(),
+  cartId: uuid("cart_id").notNull(),
+  orderId: uuid("order_id"),
+  type: text("type", { enum: ["sale", "return", "exchange"] }).notNull().default("sale"),
+  status: text("status", { enum: ["open", "held", "completed", "voided"] }).notNull().default("open"),
+  customerId: uuid("customer_id"),
+  receiptNumber: text("receipt_number").notNull(),
+  subtotal: integer("subtotal").notNull().default(0),
+  taxTotal: integer("tax_total").notNull().default(0),
+  total: integer("total").notNull().default(0),
+  discountTotal: integer("discount_total").notNull().default(0),
+  holdLabel: text("hold_label"),
+  voidReason: text("void_reason"),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  completedAt: timestamp("completed_at", { withTimezone: true }),
+}, (table) => ({
+  orgIdx: index("idx_pos_transactions_org").on(table.organizationId),
+  shiftIdx: index("idx_pos_transactions_shift").on(table.shiftId),
+  statusIdx: index("idx_pos_transactions_status").on(table.status),
+  receiptIdx: index("idx_pos_transactions_receipt").on(table.receiptNumber),
+}));
+
+// ─── Payments (Tenders) ─────────────────────────────────────────────────
+
+export const posPayments = pgTable("pos_payments", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  transactionId: uuid("transaction_id").references(() => posTransactions.id, { onDelete: "cascade" }).notNull(),
+  method: text("method", { enum: ["cash", "card", "gift_card", "store_credit", "other"] }).notNull(),
+  amount: integer("amount").notNull(),
+  changeGiven: integer("change_given").notNull().default(0),
+  reference: text("reference"),
+  status: text("status", { enum: ["collected", "refunded"] }).notNull().default("collected"),
+  processedAt: timestamp("processed_at", { withTimezone: true }).defaultNow().notNull(),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  transactionIdx: index("idx_pos_payments_transaction").on(table.transactionId),
+}));
+
+// ─── Return Items ───────────────────────────────────────────────────────
+
+export const posReturnItems = pgTable("pos_return_items", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  transactionId: uuid("transaction_id").references(() => posTransactions.id, { onDelete: "cascade" }).notNull(),
+  originalOrderId: uuid("original_order_id").notNull(),
+  originalLineItemId: uuid("original_line_item_id").notNull(),
+  quantity: integer("quantity").notNull(),
+  reason: text("reason", { enum: ["defective", "wrong_item", "changed_mind", "other"] }).notNull(),
+  restockingFee: integer("restocking_fee").notNull().default(0),
+  refundAmount: integer("refund_amount").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  transactionIdx: index("idx_pos_return_items_transaction").on(table.transactionId),
+  originalOrderIdx: index("idx_pos_return_items_order").on(table.originalOrderId),
+}));

package/src/services/lookup-service.ts

@@ -0,0 +1,136 @@
+import { eq, and } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import type { PluginResult } from "@unifiedcommerce/core";
+import { variants, sellableEntities } from "@unifiedcommerce/core/schema";
+import type { Db } from "../types";
+
+export interface LookupResult {
+  entityId: string;
+  variantId: string;
+  entityType: string;
+  slug: string;
+  barcode: string | null;
+  sku: string | null;
+  title?: string | undefined;
+  price?: number | undefined;
+}
+
+/**
+ * Item lookup service for POS.
+ * Uses indexed queries on variants.barcode and variants.sku.
+ *
+ * Depends on core schema tables (variants, sellable_entities, entity_attributes)
+ * accessed via the scoped DB proxy.
+ */
+export class LookupService {
+  constructor(
+    private db: Db,
+    private services: Record<string, unknown>,
+  ) {}
+
+  /**
+   * Find entity + variant by barcode. Single indexed query.
+   */
+  async byBarcode(orgId: string, barcode: string): Promise<PluginResult<LookupResult>> {
+
+    const rows = await this.db
+      .select({
+        variantId: variants.id,
+        entityId: variants.entityId,
+        barcode: variants.barcode,
+        sku: variants.sku,
+        entityType: sellableEntities.type,
+        slug: sellableEntities.slug,
+        orgId: sellableEntities.organizationId,
+      })
+      .from(variants)
+      .innerJoin(sellableEntities, eq(variants.entityId, sellableEntities.id))
+      .where(and(
+        eq(variants.barcode, barcode),
+        eq(sellableEntities.organizationId, orgId),
+      ))
+      .limit(1);
+
+    if (rows.length === 0) return Err("No item found for barcode");
+
+    const row = rows[0]!;
+    return Ok({
+      entityId: row.entityId,
+      variantId: row.variantId,
+      entityType: row.entityType,
+      slug: row.slug,
+      barcode: row.barcode,
+      sku: row.sku,
+    });
+  }
+
+  /**
+   * Find entity + variant by SKU. Single indexed query.
+   */
+  async bySku(orgId: string, sku: string): Promise<PluginResult<LookupResult>> {
+    const rows = await this.db
+      .select({
+        variantId: variants.id,
+        entityId: variants.entityId,
+        barcode: variants.barcode,
+        sku: variants.sku,
+        entityType: sellableEntities.type,
+        slug: sellableEntities.slug,
+        orgId: sellableEntities.organizationId,
+      })
+      .from(variants)
+      .innerJoin(sellableEntities, eq(variants.entityId, sellableEntities.id))
+      .where(and(
+        eq(variants.sku, sku),
+        eq(sellableEntities.organizationId, orgId),
+      ))
+      .limit(1);
+
+    if (rows.length === 0) return Err("No item found for SKU");
+
+    const row = rows[0]!;
+    return Ok({
+      entityId: row.entityId,
+      variantId: row.variantId,
+      entityType: row.entityType,
+      slug: row.slug,
+      barcode: row.barcode,
+      sku: row.sku,
+    });
+  }
+
+  /**
+   * Quick text search across entity attributes (name, title).
+   * Delegates to the core search service.
+   */
+  async search(orgId: string, query: string): Promise<PluginResult<LookupResult[]>> {
+    const searchService = this.services.search as {
+      search: (params: { query: string; organizationId?: string; limit?: number }) => Promise<{
+        ok: boolean;
+        value?: { results: Array<{ entityId: string; type: string; slug: string; title?: string }> };
+      }>;
+    } | undefined;
+
+    if (!searchService) {
+      return Ok([]);
+    }
+
+    const result = await searchService.search({
+      query,
+      organizationId: orgId,
+      limit: 20,
+    });
+
+    if (!result.ok || !result.value) return Ok([]);
+
+    return Ok(result.value.results.map((r): LookupResult => ({
+      entityId: r.entityId,
+      variantId: "",
+      entityType: r.type,
+      slug: r.slug,
+      barcode: null,
+      sku: null,
+      title: r.title ?? undefined,
+    })));
+  }
+}