@openlup/platform 0.26.0 → 0.28.0

package/src/commerce/server/offerAvailability.ts

@@ -0,0 +1,275 @@
+import {
+  DEFAULT_LOW_STOCK_THRESHOLD,
+  deriveOfferAvailability,
+} from "../offerAvailability.js";
+import type {
+  CommerceOfferAvailability,
+  CommerceOfferAvailabilityRequestItem,
+} from "../contracts/availability.js";
+import type {
+  CommerceOfferAvailabilityPort,
+} from "../contracts/availability.js";
+
+export interface OfferAvailabilityQueryClient {
+  from(table: string): OfferAvailabilityQueryBuilder;
+}
+
+interface OfferAvailabilityQueryBuilder extends PromiseLike<OfferAvailabilityQueryResult> {
+  select(columns: string, options?: Record<string, unknown>): OfferAvailabilityQueryBuilder;
+  in(column: string, values: unknown[]): PromiseLike<OfferAvailabilityQueryResult>;
+}
+
+interface OfferAvailabilityQueryResult {
+  data: unknown;
+  error: { code?: string; message?: string } | null;
+}
+
+interface InventoryBalanceRow {
+  on_hand: number;
+  unavailable: number;
+  safety_stock: number;
+  catalog_skus?: { sku?: string } | null;
+  inventory_locations?: {
+    status?: string;
+    fulfillable?: boolean;
+  } | null;
+  inventory_lots?: {
+    status?: string | null;
+    expires_at?: string | null;
+  } | null;
+}
+
+interface ProviderStockCurrentRow {
+  sku: string;
+  provider_kind: string;
+  provider_for_sale_quantity: number;
+  last_synced_at: string;
+  stale_after: string;
+}
+
+interface InventoryReservationRow {
+  quantity: number;
+  status: string;
+  expires_at: string | null;
+  catalog_skus?: { sku?: string } | null;
+  commerce_orders?: { status?: string } | null;
+}
+
+// Orders in a terminal, non-committed state must NOT hold stock. A cancelled
+// order historically stranded its `reserved` rows (no release path fired), so
+// even with the release-on-cancel trigger in place we defensively exclude these
+// here — legacy stranded rows can never depress sellableNow. Paid /
+// fulfillment_pending / pending_payment reservations stay counted: that stock is
+// legitimately committed.
+const TERMINAL_ORDER_STATUSES: ReadonlySet<string> = new Set([
+  "cancelled",
+  "failed",
+  "expired",
+]);
+
+export function createOfferAvailabilityPort(
+  client: OfferAvailabilityQueryClient,
+  options: { isStockProvider: (providerKind: string) => boolean; lowStockThreshold?: number; now?: () => Date },
+): CommerceOfferAvailabilityPort {
+  const lowStockThreshold = options.lowStockThreshold ?? DEFAULT_LOW_STOCK_THRESHOLD;
+  const now = options.now ?? (() => new Date());
+
+  return {
+    async getAvailability({ items }) {
+      if (items.length === 0) return [];
+
+      const skus = [...new Set(items.map((item) => item.sku))];
+      const [providerResult, balanceResult, reservationResult] = await Promise.all([
+        client
+          .from("fulfillment_provider_stock_current")
+          .select("sku, provider_kind, provider_for_sale_quantity, last_synced_at, stale_after")
+          .in("sku", skus),
+        client
+          .from("inventory_balances")
+          .select(
+            "on_hand, unavailable, safety_stock, catalog_skus!inventory_balances_sku_id_fkey!inner(sku), inventory_locations!inventory_balances_location_id_fkey!inner(status, fulfillable), inventory_lots!inventory_balances_lot_id_fkey(status, expires_at)",
+          )
+          .in("catalog_skus.sku", skus),
+        client
+          .from("inventory_reservations")
+          .select(
+            "quantity, status, expires_at, catalog_skus!inventory_reservations_sku_id_fkey!inner(sku), commerce_orders!inventory_reservations_order_id_fkey!inner(status)",
+          )
+          .in("catalog_skus.sku", skus),
+      ]);
+
+      if (providerResult.error || balanceResult.error || reservationResult.error) {
+        return items.map((item) => unknownAvailability(item, "inventory_read_failed"));
+      }
+
+      const requestedAt = now();
+      const activeReservedBySku = sumActiveReservedBySku(
+        (reservationResult.data ?? []) as InventoryReservationRow[],
+        requestedAt,
+      );
+      const safetyStockBySku = sumSafetyStockBySku(
+        (balanceResult.data ?? []) as InventoryBalanceRow[],
+        requestedAt,
+      );
+      const providerBySku = providerStockBySku(
+        (providerResult.data ?? []) as ProviderStockCurrentRow[],
+        options.isStockProvider,
+      );
+      if (providerBySku.size > 0) {
+        return items.map((item) =>
+          providerAvailability({
+            item,
+            provider: providerBySku.get(item.sku) ?? null,
+            activeReserved: activeReservedBySku.get(item.sku) ?? 0,
+            safetyStock: safetyStockBySku.get(item.sku) ?? 0,
+            requestedAt,
+            lowStockThreshold,
+          }),
+        );
+      }
+
+      const localBaseBySku = sumLocalAvailableBaseBySku(
+        (balanceResult.data ?? []) as InventoryBalanceRow[],
+        requestedAt,
+      );
+      return items.map((item) => {
+        const sellableNow = localBaseBySku.has(item.sku)
+          ? Math.max(0, (localBaseBySku.get(item.sku) ?? 0) - (activeReservedBySku.get(item.sku) ?? 0))
+          : null;
+        return deriveOfferAvailability({
+          ...item,
+          sellableNow,
+          lowStockThreshold,
+          source: "inventory",
+        });
+      });
+    },
+  };
+}
+
+function providerStockBySku(rows: readonly ProviderStockCurrentRow[], isStockProvider: (providerKind: string) => boolean): Map<string, ProviderStockCurrentRow> {
+  return new Map(
+    rows
+      .filter((row) => isStockProvider(row.provider_kind) && row.sku)
+      .map((row) => [row.sku, row]),
+  );
+}
+
+function providerAvailability(input: {
+  item: CommerceOfferAvailabilityRequestItem;
+  provider: ProviderStockCurrentRow | null;
+  activeReserved: number;
+  safetyStock: number;
+  requestedAt: Date;
+  lowStockThreshold: number;
+}): CommerceOfferAvailability {
+  if (!input.provider) {
+    return unavailable(input.item, "provider_stock_missing");
+  }
+  if (Date.parse(input.provider.stale_after) <= input.requestedAt.getTime()) {
+    return unavailable(input.item, "provider_stock_stale");
+  }
+  return deriveOfferAvailability({
+    ...input.item,
+    sellableNow: Math.max(
+      0,
+      input.provider.provider_for_sale_quantity - input.activeReserved - input.safetyStock,
+    ),
+    lowStockThreshold: input.lowStockThreshold,
+    source: "inventory_provider",
+  });
+}
+
+function sumActiveReservedBySku(
+  rows: readonly InventoryReservationRow[],
+  requestedAt: Date,
+): Map<string, number> {
+  const result = new Map<string, number>();
+  for (const row of rows) {
+    const sku = row.catalog_skus?.sku;
+    if (!sku || !reservationBlocksStock(row, requestedAt)) continue;
+    result.set(sku, (result.get(sku) ?? 0) + row.quantity);
+  }
+  return result;
+}
+
+function sumSafetyStockBySku(
+  rows: readonly InventoryBalanceRow[],
+  requestedAt: Date,
+): Map<string, number> {
+  const result = new Map<string, number>();
+  for (const row of rows) {
+    const sku = row.catalog_skus?.sku;
+    if (!sku || !balanceUsable(row, requestedAt)) continue;
+    result.set(sku, (result.get(sku) ?? 0) + row.safety_stock);
+  }
+  return result;
+}
+
+function sumLocalAvailableBaseBySku(
+  rows: readonly InventoryBalanceRow[],
+  requestedAt: Date,
+): Map<string, number> {
+  const result = new Map<string, number>();
+  for (const row of rows) {
+    const sku = row.catalog_skus?.sku;
+    if (!sku || !balanceUsable(row, requestedAt)) continue;
+    result.set(
+      sku,
+      (result.get(sku) ?? 0) + Math.max(0, row.on_hand - row.unavailable - row.safety_stock),
+    );
+  }
+  return result;
+}
+
+function balanceUsable(row: InventoryBalanceRow, requestedAt: Date): boolean {
+  const location = row.inventory_locations;
+  if (location?.status !== "active" || location.fulfillable !== true) return false;
+  const lotStatus = row.inventory_lots?.status;
+  if (lotStatus && lotStatus !== "available") return false;
+  const expiresAt = row.inventory_lots?.expires_at;
+  if (expiresAt && Date.parse(expiresAt) <= requestedAt.getTime()) return false;
+  return true;
+}
+
+function reservationBlocksStock(row: InventoryReservationRow, requestedAt: Date): boolean {
+  if (row.status !== "reserved") return false;
+  // A reserved row tied to a terminal (cancelled/failed/expired) order is a
+  // stranded hold — do not let it depress sellableNow.
+  const orderStatus = row.commerce_orders?.status;
+  if (orderStatus && TERMINAL_ORDER_STATUSES.has(orderStatus)) return false;
+  if (!row.expires_at) return true;
+  return Date.parse(row.expires_at) > requestedAt.getTime();
+}
+
+function unavailable(
+  item: CommerceOfferAvailabilityRequestItem,
+  reasonCode: string,
+): CommerceOfferAvailability {
+  return {
+    sku: item.sku,
+    productSlug: item.productSlug,
+    variantId: item.variantId,
+    status: "out_of_stock",
+    visibleInConfigurator: false,
+    sellableNow: 0,
+    reasonCode,
+    source: "inventory_provider",
+  };
+}
+
+function unknownAvailability(
+  item: CommerceOfferAvailabilityRequestItem,
+  reasonCode: string,
+): CommerceOfferAvailability {
+  return {
+    sku: item.sku,
+    productSlug: item.productSlug,
+    variantId: item.variantId,
+    status: "unknown",
+    visibleInConfigurator: true,
+    sellableNow: null,
+    reasonCode,
+    source: "inventory",
+  };
+}

package/src/commerce/server/orderDraftRpcPayload.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { commerceIdempotencyKeySchema } from "../contractPrimitives.js";
+
+export const ORDER_DRAFT_RPC_NAME = "commerce_create_order_draft_with_outbox";
+
+// Keep the emitted declaration in Zod's public types rather than expanding its
+// internal mapped output, which cannot be checked by a strict installed consumer.
+type OrderDraftRpcSchema<Quote extends z.ZodType, Draft extends z.ZodType> = z.ZodObject<{
+  p_idempotency_key: z.ZodString;
+  p_quote_snapshot: Quote;
+  p_order_draft_snapshot: Draft;
+  p_client_id: z.ZodOptional<z.ZodGUID>;
+}, z.core.$strict>;
+
+export function createOrderDraftRpcPayload<Quote extends z.ZodType, Draft extends z.ZodType>(input: {
+  quoteSchema: Quote;
+  draftSchema: Draft;
+  createSnapshot(quote: z.output<Quote>): z.input<Draft>;
+}) {
+  const orderDraftRpcArgsSchema: OrderDraftRpcSchema<Quote, Draft> = z.object({
+    p_idempotency_key: commerceIdempotencyKeySchema,
+    p_quote_snapshot: input.quoteSchema,
+    p_order_draft_snapshot: input.draftSchema,
+    // Omit the optional client for anonymous calls, preserving the three-argument RPC.
+    p_client_id: z.guid().optional(),
+  }).strict();
+  function createOrderDraftRpcArgs(
+    request: { idempotencyKey: string; quoteSnapshot: z.output<Quote> },
+    clientId: string | null = null,
+  ): z.output<OrderDraftRpcSchema<Quote, Draft>> {
+    const base = {
+      p_idempotency_key: request.idempotencyKey,
+      p_quote_snapshot: request.quoteSnapshot,
+      p_order_draft_snapshot: input.createSnapshot(request.quoteSnapshot),
+    };
+    return orderDraftRpcArgsSchema.parse(clientId ? { ...base, p_client_id: clientId } : base);
+  }
+  return { orderDraftRpcArgsSchema, createOrderDraftRpcArgs };
+}

package/src/commerce/server/orderFeedbackSubmit.ts

@@ -0,0 +1,40 @@
+import {
+  ORDER_FEEDBACK_SUBMIT_RPC_NAME,
+  type OrderFeedbackSubmitRequest,
+} from "../orderFeedbackContracts.js";
+
+interface RpcError {
+  message?: string;
+}
+
+export interface OrderFeedbackSubmitRpcClient {
+  rpc(
+    functionName: typeof ORDER_FEEDBACK_SUBMIT_RPC_NAME,
+    args: {
+      p_token: string;
+      p_rating: number;
+      p_comment: string | null;
+    },
+  ): PromiseLike<{ data: unknown; error: RpcError | null }>;
+}
+
+export interface OrderFeedbackSubmitPort {
+  submit(request: OrderFeedbackSubmitRequest): Promise<unknown>;
+}
+
+/** Hosted token feedback only; the adopter must provide this RPC. Native db/platform has no binding. */
+export function createSupabaseOrderFeedbackSubmitPort(
+  client: OrderFeedbackSubmitRpcClient,
+): OrderFeedbackSubmitPort {
+  return {
+    async submit(request) {
+      const { data, error } = await client.rpc(ORDER_FEEDBACK_SUBMIT_RPC_NAME, {
+        p_token: request.token,
+        p_rating: request.rating,
+        p_comment: request.comment ?? null,
+      });
+      if (error) throw new Error(error.message ?? "order_feedback_submit_failed");
+      return data;
+    },
+  };
+}

package/src/commerce/server/orderFeedbackTokenCheck.ts

@@ -0,0 +1,28 @@
+import {
+  ORDER_FEEDBACK_CHECK_RPC_NAME,
+  type OrderFeedbackTokenCheckRequest,
+} from "../orderFeedbackContracts.js";
+
+interface RpcError {
+  message?: string;
+}
+
+export interface OrderFeedbackTokenCheckRpcClient {
+  rpc(
+    functionName: typeof ORDER_FEEDBACK_CHECK_RPC_NAME,
+    args: { p_token: string },
+  ): PromiseLike<{ data: unknown; error: RpcError | null }>;
+}
+
+/** Hosted token feedback only; the adopter must provide this RPC. Native db/platform has no binding. */
+export function createSupabaseOrderFeedbackTokenCheckPort(client: OrderFeedbackTokenCheckRpcClient) {
+  return {
+    async check(request: OrderFeedbackTokenCheckRequest): Promise<unknown> {
+      const { data, error } = await client.rpc(ORDER_FEEDBACK_CHECK_RPC_NAME, {
+        p_token: request.token,
+      });
+      if (error) throw new Error(error.message ?? "order_feedback_token_check_failed");
+      return data;
+    },
+  };
+}

package/src/commerce/server/orderReviewAdminHandlers.ts

@@ -0,0 +1,43 @@
+import {
+  orderReviewAdminRevokeSchema,
+  orderReviewReferenceSchema,
+  orderReviewModerationSchema,
+  type OrderReviewFailure,
+} from "../orderReviewContracts.js";
+import { runOrderReviewCommand } from "./orderReviewHandlers.js";
+import type { OrderReviewAdminReadPort, OrderReviewLifecyclePort } from "../orderReviewPorts.js";
+
+type Result<T> = { ok: true; value: T; replayed?: boolean } | { ok: false; error: OrderReviewFailure };
+
+/** Actor identity is supplied only by the already-authorized route composition. */
+export function createOrderReviewAdminHandlers(
+  lifecycle: OrderReviewLifecyclePort,
+  readPort: OrderReviewAdminReadPort,
+) {
+  return {
+    async list(actorRef: string, input: { cursor?: string; limit?: number }): Promise<Result<Awaited<ReturnType<OrderReviewAdminReadPort["list"]>>>> {
+      if (!validActor(actorRef)) return unavailable();
+      const limit = Math.min(Math.max(input.limit ?? 25, 1), 100);
+      try { return { ok: true, value: await readPort.list({ actorRef, cursor: input.cursor, limit }) }; }
+      catch { return unavailable(); }
+    },
+    async read(actorRef: string, reviewRef: string): Promise<Result<Awaited<ReturnType<OrderReviewAdminReadPort["read"]>>>> {
+      if (!validActor(actorRef) || !orderReviewReferenceSchema.safeParse(reviewRef).success) return unavailable();
+      try {
+        const review = await readPort.read({ actorRef, reviewRef });
+        return review ? { ok: true, value: review } : unavailable();
+      } catch { return unavailable(); }
+    },
+    async moderate(actorRef: string, input: unknown) {
+      if (!validActor(actorRef)) return unavailable();
+      return runOrderReviewCommand(orderReviewModerationSchema.safeParse(input), (data) => lifecycle.moderate({ ...data, actorRef }), (result) => result.value);
+    },
+    async revoke(actorRef: string, input: { reviewRef?: string; idempotencyKey?: string }) {
+      if (!validActor(actorRef)) return unavailable();
+      return runOrderReviewCommand(orderReviewAdminRevokeSchema.safeParse(input), (data) => lifecycle.revoke({ ...data, actorRef }), (result) => result);
+    },
+  };
+}
+
+function validActor(value: string): boolean { return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(value); }
+function unavailable() { return { ok: false as const, error: { kind: "unavailable" as const } }; }

package/src/commerce/server/orderReviewHandlers.ts

@@ -0,0 +1,57 @@
+import {
+  orderReviewFailure,
+  orderReviewMediaConfirmSchema,
+  orderReviewMediaIntentSchema,
+  orderReviewSubmitSchema,
+  type OrderReview,
+  type OrderReviewFailure,
+  type OrderReviewReadResult,
+} from "../orderReviewContracts.js";
+import type { OrderReviewLifecyclePort } from "../orderReviewPorts.js";
+
+type Result<T> = { ok: true; value: T; replayed?: boolean } | { ok: false; error: OrderReviewFailure };
+
+/** HTTP-neutral customer orchestration; route composition owns bearer extraction. */
+export function createOrderReviewHandlers(port: OrderReviewLifecyclePort) {
+  return {
+    async read(grant: string): Promise<Result<OrderReviewReadResult>> {
+      try {
+        const result = await port.read(grant);
+        return result ? { ok: true, value: result } : { ok: false, error: { kind: "unavailable" } };
+      } catch (error) {
+        return { ok: false, error: orderReviewFailure(errorCode(error)) };
+      }
+    },
+    async submit(input: unknown) {
+      return runOrderReviewCommand(orderReviewSubmitSchema.safeParse(input), (data) => port.submit(data), (result) => result.value);
+    },
+    async createMediaIntent(input: unknown) {
+      return runOrderReviewCommand(orderReviewMediaIntentSchema.safeParse(input), (data) => port.createMediaIntent(data), (result) => result);
+    },
+    async confirmMedia(input: unknown) {
+      return runOrderReviewCommand(orderReviewMediaConfirmSchema.safeParse(input), (data) => port.confirmMedia(data), (result) => result.value);
+    },
+  };
+}
+
+/** Shared command scaffold: parse result, one port call, the value mapper, failure mapping. */
+export async function runOrderReviewCommand<D, R extends { replayed?: boolean }, V>(
+  parsed: { success: true; data: D } | { success: false },
+  call: (data: D) => Promise<R>,
+  map: (result: R) => V,
+) {
+  if (parsed.success === false) return invalid();
+  try {
+    const result = await call(parsed.data);
+    return { ok: true as const, value: map(result), replayed: result.replayed };
+  } catch (error) {
+    return failure(error);
+  }
+}
+
+function invalid() { return { ok: false as const, error: { kind: "invalid" as const } }; }
+function failure(error: unknown) { return { ok: false as const, error: orderReviewFailure(errorCode(error)) }; }
+function errorCode(error: unknown): string | undefined {
+  return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+    ? error.code : undefined;
+}

package/src/commerce/server/orderReviewLifecycle.ts

@@ -0,0 +1,129 @@
+import {
+  ORDER_REVIEW_CONTRACT_VERSION,
+  orderReviewAdminDetailSchema,
+  orderReviewMediaSchema,
+  orderReviewMediaIntentResultSchema,
+  orderReviewReadResultSchema,
+  orderReviewSchema,
+  type OrderReview,
+  type OrderReviewAdminDetail,
+  type OrderReviewMedia,
+} from "../orderReviewContracts.js";
+import type { OrderReviewAdminReadPort, OrderReviewLifecyclePort, Replay } from "../orderReviewPorts.js";
+// Structural equivalent of the host query executor; declarations need no optional pg peer.
+type PgQueryExecutor = { query(text: string, values?: unknown[]): Promise<{ rows: Record<string, unknown>[] }> };
+
+const READ = "SELECT public.order_review_read($1::text, now()) AS response";
+const SUBMIT = "SELECT public.order_review_submit($1::text,$2::integer,$3::text,$4::text,now()) AS response";
+const INTENT = "SELECT public.order_review_create_media_intent($1::text,$2::text,$3::integer,$4::text,$5::text,now()) AS response";
+const CONFIRM = "SELECT public.order_review_confirm_media($1::text,$2::text,$3::text,$4::text,now()) AS response";
+const MODERATE = "SELECT public.order_review_moderate($1::text,$2::text,$3::text,$4::text,now()) AS response";
+const REVOKE = "SELECT public.order_review_revoke_access($1::text,$2::text,$3::text,now()) AS response";
+const ADMIN_LIST = "SELECT public.order_review_admin_list($1::text,$2::text,$3::integer,now()) AS response";
+const ADMIN_READ = "SELECT public.order_review_admin_read($1::text,$2::text,now()) AS response";
+
+export function createPostgresOrderReviewLifecyclePort(executor: PgQueryExecutor): OrderReviewLifecyclePort {
+  return {
+    async read(grant) {
+      const response = await call(executor, READ, [grant]);
+      if (response === null) return null;
+      return readResult(response);
+    },
+    async submit(input) {
+      return replay(review(required(await call(executor, SUBMIT, [input.grant, input.rating, input.comment ?? null, input.fingerprint]))));
+    },
+    async createMediaIntent(input) {
+      return mediaIntent(required(await call(executor, INTENT, [
+        input.grant, input.contentType, input.byteLength, input.capabilityDigest, input.commandKey,
+      ])));
+    },
+    async confirmMedia(input) {
+      return replay(media(required(await call(executor, CONFIRM, [input.grant, input.mediaRef, input.digest, input.commandKey]))));
+    },
+    async moderate(input) {
+      return replay(review(await call(executor, MODERATE, [
+        input.reviewRef, input.action, input.actorRef, input.idempotencyKey,
+      ])));
+    },
+    async revoke(input) {
+      const response = object(await call(executor, REVOKE, [input.reviewRef, input.actorRef, input.idempotencyKey]));
+      if (!response) throw invalid();
+      return { replayed: response.replayed === true };
+    },
+  };
+}
+
+/** Admin route composition authenticates the actor before invoking this adapter. */
+export function createPostgresOrderReviewAdminReadPort(executor: PgQueryExecutor): OrderReviewAdminReadPort {
+  return {
+    async list(input) {
+      const row = object(await call(executor, ADMIN_LIST, [input.actorRef, input.cursor ?? null, input.limit]));
+      if (!row || !Array.isArray(row.items)) throw invalid();
+      const items = row.items.map((item) => review(item));
+      const nextCursor = row.nextCursor;
+      if (nextCursor !== undefined && typeof nextCursor !== "string") throw invalid();
+      return nextCursor === undefined ? { items } : { items, nextCursor: nextCursor as string };
+    },
+    async read(input) {
+      const response = await call(executor, ADMIN_READ, [input.actorRef, input.reviewRef]);
+      return response === null ? null : adminDetail(response);
+    },
+  };
+}
+
+async function call(executor: PgQueryExecutor, sql: string, values: unknown[]): Promise<unknown> {
+  const result = await executor.query(sql, values);
+  return object(result.rows[0])?.response ?? null;
+}
+
+function replay<T>(value: T & { replayed?: unknown }): Replay<T> {
+  const { replayed, ...result } = value;
+  return { value: result as T, replayed: replayed === true };
+}
+function review(value: unknown): OrderReview & { replayed?: unknown } {
+  const row = object(value);
+  if (!row) throw invalid();
+  const { replayed, ...payload } = row;
+  const parsed = orderReviewSchema.parse({
+    contractVersion: payload.contractVersion ?? ORDER_REVIEW_CONTRACT_VERSION,
+    ...payload,
+    comment: payload.comment ?? null,
+  });
+  return { ...parsed, ...(typeof replayed === "boolean" ? { replayed } : {}) };
+}
+function media(value: unknown): OrderReviewMedia & { replayed?: unknown } {
+  const row = object(value);
+  if (!row) throw invalid();
+  const { replayed, ...payload } = row;
+  const parsed = orderReviewMediaSchema.parse(payload);
+  return { ...parsed, ...(typeof replayed === "boolean" ? { replayed } : {}) };
+}
+function mediaIntent(value: unknown) {
+  const row = object(value);
+  if (!row) throw invalid();
+  return orderReviewMediaIntentResultSchema.parse(row);
+}
+function readResult(value: unknown) {
+  const row = object(value);
+  if (!row || !Array.isArray(row.media)) throw invalid();
+  return orderReviewReadResultSchema.parse({
+    review: row.review === null ? null : review(row.review),
+    media: row.media.map((item) => media(item)),
+  });
+}
+function adminDetail(value: unknown): OrderReviewAdminDetail {
+  const row = object(value);
+  if (!row || !Array.isArray(row.media)) throw invalid();
+  return orderReviewAdminDetailSchema.parse({
+    review: review(row.review),
+    media: row.media.map((item) => media(item)),
+  });
+}
+function object(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+function invalid() { return Object.assign(new Error("order_review_response_invalid"), { code: "order_review_invalid" }); }
+function required(value: unknown): unknown {
+  if (value === null) throw Object.assign(new Error("order_review_unavailable"), { code: "order_review_unavailable" });
+  return value;
+}