@01.software/init 0.9.2 → 0.10.1

package/dist/create-app-templates/ecommerce/lib/commerce/adapters/mock.ts

@@ -0,0 +1,346 @@
+import seed from '../../../data/mock-catalog.json' with { type: 'json' }
+import { normalizeCartLines } from '../../cart/normalize.ts'
+import type { CommerceProvider } from '../provider.ts'
+import { checkVariantStock } from '../stock.ts'
+import type {
+  CartItemView,
+  CartView,
+  CheckoutCartInput,
+  CreatePendingOrderResult,
+  Order,
+  ProductDetail,
+  ProductVariant,
+  ShippingPolicy,
+} from '../types.ts'
+
+/**
+ * In-memory server-cart emulation for the zero-backend demo. The mock stands in
+ * for the Console `commerce.cart.*` + `orders.checkout` surface so the template
+ * runs without credentials. Carts and orders live in module-level maps for the
+ * lifetime of the dev server process — there is no file-based index.
+ */
+type MockCartItem = {
+  cartItemId: string
+  productId: string
+  variantId: string
+  optionId?: string
+  quantity: number
+  unitPrice: number
+  requiresShipping?: boolean | null
+}
+
+type MockCart = {
+  id: string
+  cartToken: string
+  currency: string
+  items: MockCartItem[]
+}
+
+const carts = new Map<string, MockCart>()
+const orders = new Map<string, Order>()
+
+export function createMockCommerceProvider(): CommerceProvider {
+  const products = seed.products as ProductDetail[]
+  const shippingPolicy = seed.shippingPolicy as ShippingPolicy
+  const variants = allVariants(products)
+  const variantById = new Map(variants.map((variant) => [variant.id, variant]))
+
+  function viewCart(cart: MockCart): CartView {
+    const items: CartItemView[] = cart.items.map((item) => {
+      const variant = variantById.get(item.variantId)
+      const detail = products.find(
+        (entry) => entry.product.id === item.productId,
+      )
+      const image =
+        variant?.images[0] ??
+        detail?.product.thumbnail ??
+        detail?.product.images[0] ??
+        null
+      return {
+        cartItemId: item.cartItemId,
+        productId: item.productId,
+        variantId: item.variantId,
+        quantity: item.quantity,
+        unitAmount: item.unitPrice,
+        lineAmount: item.unitPrice * item.quantity,
+        requiresShipping: item.requiresShipping,
+        productTitle: detail?.product.title ?? 'Unknown product',
+        variantTitle: variant?.title,
+        image,
+      }
+    })
+
+    const subtotalAmount = items.reduce((sum, item) => sum + item.lineAmount, 0)
+    const hasShippableItems = items.some(
+      (item) => item.requiresShipping !== false,
+    )
+    const shippingAmount =
+      !hasShippableItems || subtotalAmount === 0
+        ? 0
+        : shippingPolicy.freeAboveAmount !== undefined &&
+            subtotalAmount >= shippingPolicy.freeAboveAmount
+          ? 0
+          : shippingPolicy.baseAmount
+
+    return {
+      id: cart.id,
+      currency: shippingPolicy.currency,
+      subtotalAmount,
+      shippingAmount,
+      discountAmount: 0,
+      totalAmount: subtotalAmount + shippingAmount,
+      items,
+    }
+  }
+
+  function requireCart(cartToken: string): MockCart {
+    const cart = carts.get(cartToken)
+    if (!cart) throw new Error('Cart not found')
+    return cart
+  }
+
+  return {
+    async listProducts(input) {
+      const limit = input?.limit ?? 24
+      const publishedProducts = products.filter(
+        (entry) => entry.product.status === 'published',
+      )
+      return {
+        products: publishedProducts.slice(0, limit),
+        total: publishedProducts.length,
+      }
+    },
+
+    async getProductBySlug(slug) {
+      return (
+        products.find(
+          (entry) =>
+            entry.product.slug === slug && entry.product.status === 'published',
+        ) ?? null
+      )
+    },
+
+    async getVariantsByIds(ids) {
+      const idSet = new Set(ids)
+      return variants.filter((variant) => idSet.has(variant.id))
+    },
+
+    async getShippingPolicy() {
+      return shippingPolicy
+    },
+
+    async checkStock(items) {
+      return checkVariantStock({
+        lines: normalizeCartLines(items),
+        variants,
+      })
+    },
+
+    async createCart() {
+      const cartToken = `mock_cart_${crypto.randomUUID()}`
+      carts.set(cartToken, {
+        id: `cart_${crypto.randomUUID()}`,
+        cartToken,
+        currency: shippingPolicy.currency,
+        items: [],
+      })
+      return { cartToken }
+    },
+
+    async getCart(cartToken) {
+      const cart = carts.get(cartToken)
+      return cart ? viewCart(cart) : null
+    },
+
+    async addCartItem({ cartToken, item }) {
+      const cart = requireCart(cartToken)
+      const variant = variantById.get(item.variantId)
+      if (!variant) throw new Error('Variant not found')
+
+      const existing = cart.items.find(
+        (line) => line.variantId === item.variantId,
+      )
+      const nextQuantity = (existing?.quantity ?? 0) + item.quantity
+      const stock = checkVariantStock({
+        lines: [{ variantId: item.variantId, quantity: nextQuantity }],
+        variants,
+      })
+      if (!stock.ok) throw new Error('Insufficient stock')
+
+      if (existing) {
+        existing.quantity = Math.min(99, nextQuantity)
+        existing.requiresShipping =
+          existing.requiresShipping !== false ||
+          variant.requiresShipping !== false
+      } else {
+        cart.items.push({
+          cartItemId: `item_${crypto.randomUUID()}`,
+          productId: item.productId || variant.productId,
+          variantId: item.variantId,
+          optionId: item.optionId,
+          quantity: Math.min(99, item.quantity),
+          unitPrice: variant.price,
+          requiresShipping: variant.requiresShipping !== false,
+        })
+      }
+      return viewCart(cart)
+    },
+
+    async updateCartItem({ cartToken, cartItemId, quantity }) {
+      const cart = requireCart(cartToken)
+      const line = cart.items.find((entry) => entry.cartItemId === cartItemId)
+      if (!line) throw new Error('Cart item not found')
+      if (quantity <= 0) {
+        cart.items = cart.items.filter(
+          (entry) => entry.cartItemId !== cartItemId,
+        )
+      } else {
+        line.quantity = Math.min(99, Math.floor(quantity))
+      }
+      return viewCart(cart)
+    },
+
+    async removeCartItem({ cartToken, cartItemId }) {
+      const cart = requireCart(cartToken)
+      cart.items = cart.items.filter((entry) => entry.cartItemId !== cartItemId)
+      return viewCart(cart)
+    },
+
+    async clearCart({ cartToken }) {
+      const cart = requireCart(cartToken)
+      cart.items = []
+      return viewCart(cart)
+    },
+
+    async checkoutCart(input) {
+      return checkoutMockCart({ input, products, viewCart, requireCart })
+    },
+
+    async getOrderByPaymentId({ paymentId }) {
+      return orders.get(paymentId) ?? null
+    },
+
+    async confirmOrderPayment(input) {
+      const order = orders.get(input.paymentId)
+      if (!order) throw new Error('Order not found')
+      const paidOrder: Order = {
+        ...order,
+        displayStatus: 'paid',
+        transactions: order.transactions.map((transaction) =>
+          transaction.paymentId === input.paymentId
+            ? { ...transaction, provider: input.provider, status: 'paid' }
+            : transaction,
+        ),
+      }
+      orders.set(input.paymentId, paidOrder)
+      return paidOrder
+    },
+
+    async markPaymentFailed(input) {
+      const order = orders.get(input.paymentId)
+      if (!order) return null
+      const failedOrder: Order = {
+        ...order,
+        transactions: order.transactions.map((transaction) =>
+          transaction.paymentId === input.paymentId
+            ? { ...transaction, provider: input.provider, status: 'failed' }
+            : transaction,
+        ),
+      }
+      orders.set(input.paymentId, failedOrder)
+      return failedOrder
+    },
+
+    async cancelPendingOrder(input) {
+      const order = orders.get(input.paymentId)
+      if (!order) return null
+      const canceledOrder: Order = {
+        ...order,
+        displayStatus: 'canceled',
+        transactions: order.transactions.map((transaction) =>
+          transaction.paymentId === input.paymentId
+            ? { ...transaction, provider: input.provider, status: 'canceled' }
+            : transaction,
+        ),
+      }
+      orders.set(input.paymentId, canceledOrder)
+      return canceledOrder
+    },
+  }
+}
+
+function checkoutMockCart(args: {
+  input: CheckoutCartInput
+  products: ProductDetail[]
+  viewCart: (cart: MockCart) => CartView
+  requireCart: (cartToken: string) => MockCart
+}): CreatePendingOrderResult {
+  const cart = args.requireCart(args.input.cartToken)
+  const view = args.viewCart(cart)
+  if (view.items.length === 0) throw new Error('Cart is empty')
+
+  const paymentId = `mock_${Date.now()}_${Math.random().toString(16).slice(2)}`
+  const orderNumber = `ORD-${Date.now().toString().slice(-8)}`
+  const order: Order = {
+    id: `order_${paymentId}`,
+    orderNumber,
+    displayStatus: 'pending',
+    items: view.items.map((item) => ({
+      variantId: item.variantId,
+      productTitle: item.productTitle,
+      variantTitle: item.variantTitle,
+      quantity: item.quantity,
+      unitAmount: item.unitAmount,
+      lineAmount: item.lineAmount,
+    })),
+    customerSnapshot: args.input.customerSnapshot,
+    ...(args.input.shippingAddress
+      ? { shippingAddress: args.input.shippingAddress }
+      : {}),
+    subtotalAmount: view.subtotalAmount,
+    shippingAmount: view.shippingAmount,
+    totalAmount: view.totalAmount,
+    transactions: [
+      {
+        paymentId,
+        provider: 'mock',
+        status: 'pending',
+        amount: view.totalAmount,
+      },
+    ],
+  }
+
+  orders.set(paymentId, order)
+  // The cart is consumed by checkout (Shopify cart→checkout boundary); the
+  // browser cookie will resolve to no active cart and mint a fresh one.
+  carts.delete(args.input.cartToken)
+
+  return {
+    order,
+    paymentId,
+    paymentName: buildPaymentName(order.items.map((item) => item.productTitle)),
+    amount: view.totalAmount,
+    currency: view.currency,
+  }
+}
+
+function allVariants(products: ProductDetail[]): ProductVariant[] {
+  return products.flatMap((entry) => entry.variants)
+}
+
+function buildPaymentName(productTitles: string[]): string {
+  const [first, ...rest] = productTitles
+  if (!first) return 'Order'
+  return rest.length === 0 ? first : `${first} and ${rest.length} more`
+}
+
+/** Test helper: reset the in-memory stores between cases. */
+export function resetMockCommerceState(): void {
+  carts.clear()
+  orders.clear()
+}
+
+/** Test helper: read a stored mock order by its mock payment id. */
+export function getMockOrder(paymentId: string): Order | null {
+  return orders.get(paymentId) ?? null
+}

package/dist/create-app-templates/ecommerce/lib/commerce/adapters/software-mappers.ts

@@ -0,0 +1,312 @@
+import type {
+  CommerceImage,
+  Order,
+  PaymentTransaction,
+  Product,
+  ProductDetail,
+  ProductOption,
+  ProductVariant,
+  ProductVariantOptionValue,
+} from "../types.ts";
+
+type SoftwareMedia =
+  | string
+  | number
+  | {
+      url?: string | null;
+      alt?: string | null;
+      width?: number | null;
+      height?: number | null;
+    }
+  | null
+  | undefined;
+
+type SoftwareProduct = {
+  id: string | number;
+  slug?: string | null;
+  title?: string | null;
+  description?: string | null;
+  status?: string | null;
+};
+
+type SoftwareOptionValue = {
+  id: string | number;
+  slug?: string | null;
+  value?: string | null;
+  label?: string | null;
+};
+
+type SoftwareOption = {
+  id: string | number;
+  slug?: string | null;
+  name?: string | null;
+  title?: string | null;
+  values?: SoftwareOptionValue[] | null;
+};
+
+type SoftwareVariantOptionValue = {
+  optionId?: string | number | null;
+  option?: string | number | { id?: string | number | null } | null;
+  valueId?: string | number | null;
+  value?: string | number | SoftwareOptionValue | null;
+  slug?: string | null;
+  valueSlug?: string | null;
+  label?: string | null;
+};
+
+type SoftwareVariant = {
+  id: string | number;
+  product?: string | number | SoftwareProduct | null;
+  title?: string | null;
+  displayName?: string | null;
+  sku?: string | null;
+  price?: number | null;
+  stock?: number | null;
+  reservedStock?: number | null;
+  isUnlimited?: boolean | null;
+  optionValues?: SoftwareVariantOptionValue[] | null;
+  images?: SoftwareMedia[] | null;
+  media?: SoftwareMedia[] | null;
+};
+
+export type SoftwareProductDetailLike = {
+  product: SoftwareProduct;
+  variants?: SoftwareVariant[] | null;
+  options?: SoftwareOption[] | null;
+  images?: SoftwareMedia[] | null;
+};
+
+export type SoftwareProductDetailResultLike =
+  | { found: true; product: SoftwareProductDetailLike }
+  | { found: false; reason?: string };
+
+type SoftwareOrderItemLike = {
+  variant?: string | number | SoftwareVariant | null;
+  product?: string | number | SoftwareProduct | null;
+  quantity?: number | null;
+  unitPrice?: number | null;
+  totalPrice?: number | null;
+  unitAmount?: number | null;
+  lineAmount?: number | null;
+};
+
+type SoftwareTransactionLike = {
+  pgPaymentId?: string | null;
+  pgProvider?: string | null;
+  status?: PaymentTransaction["status"] | null;
+  amount?: number | null;
+};
+
+export type SoftwareOrderLike = {
+  id: string | number;
+  orderNumber?: string | null;
+  displayStatus?: Order["displayStatus"] | null;
+  status?: Order["displayStatus"] | null;
+  customerSnapshot?: {
+    name?: string | null;
+    email?: string | null;
+    phone?: string | null;
+  } | null;
+  shippingAddress?: {
+    recipientName?: string | null;
+    phone?: string | null;
+    postalCode?: string | null;
+    address?: string | null;
+    detailAddress?: string | null;
+    deliveryMessage?: string | null;
+  } | null;
+  subtotalAmount?: number | null;
+  shippingAmount?: number | null;
+  totalAmount?: number | null;
+  items?: { docs?: (string | SoftwareOrderItemLike)[] | null } | null;
+  transactions?: { docs?: (string | SoftwareTransactionLike)[] | null } | null;
+};
+
+export function mapSoftwareProductDetail(
+  detail: SoftwareProductDetailLike,
+): ProductDetail {
+  const images = (detail.images ?? []).flatMap(mapSoftwareImage);
+  const product = mapSoftwareProduct(detail.product, images);
+
+  return {
+    product,
+    variants: (detail.variants ?? []).map((variant) =>
+      mapSoftwareVariant(variant, product.id),
+    ),
+    options: (detail.options ?? []).map(mapSoftwareOption),
+  };
+}
+
+export function mapSoftwareProductDetailResult(
+  result: SoftwareProductDetailResultLike,
+): ProductDetail | null {
+  if (!result.found) return null;
+  return mapSoftwareProductDetail(result.product);
+}
+
+export function mapSoftwareProduct(
+  product: SoftwareProduct,
+  images: CommerceImage[] = [],
+): Product {
+  const status =
+    product.status === "draft" || product.status === "archived"
+      ? product.status
+      : "published";
+
+  return {
+    id: String(product.id),
+    slug: product.slug ?? String(product.id),
+    title: product.title ?? "Untitled product",
+    description: product.description ?? undefined,
+    thumbnail: images[0] ?? null,
+    images,
+    status,
+  };
+}
+
+export function mapSoftwareVariant(
+  variant: SoftwareVariant,
+  fallbackProductId: string,
+): ProductVariant {
+  const productId =
+    typeof variant.product === "object" && variant.product
+      ? String(variant.product.id)
+      : variant.product != null
+        ? String(variant.product)
+        : fallbackProductId;
+
+  return {
+    id: String(variant.id),
+    productId,
+    title: variant.displayName ?? variant.title ?? undefined,
+    sku: variant.sku ?? undefined,
+    price: variant.price ?? 0,
+    stock: variant.stock ?? 0,
+    reservedStock: variant.reservedStock ?? 0,
+    isUnlimited: Boolean(variant.isUnlimited),
+    optionValues: (variant.optionValues ?? []).map(mapSoftwareVariantOptionValue),
+    images: [...(variant.images ?? []), ...(variant.media ?? [])].flatMap(
+      mapSoftwareImage,
+    ),
+  };
+}
+
+export function mapSoftwareOrder(order: SoftwareOrderLike): Order {
+  const transactions = (order.transactions?.docs ?? []).flatMap((transaction) =>
+    typeof transaction === "string" ? [] : [mapSoftwareTransaction(transaction)],
+  );
+
+  return {
+    id: String(order.id),
+    orderNumber: order.orderNumber ?? String(order.id),
+    displayStatus: order.displayStatus ?? order.status ?? "pending",
+    items: (order.items?.docs ?? []).flatMap((item) =>
+      typeof item === "string" ? [] : [mapSoftwareOrderItem(item)],
+    ),
+    customerSnapshot: {
+      name: order.customerSnapshot?.name ?? "",
+      email: order.customerSnapshot?.email ?? "",
+      phone: order.customerSnapshot?.phone ?? "",
+    },
+    shippingAddress: {
+      recipientName: order.shippingAddress?.recipientName ?? "",
+      phone: order.shippingAddress?.phone ?? "",
+      postalCode: order.shippingAddress?.postalCode ?? "",
+      address: order.shippingAddress?.address ?? "",
+      detailAddress: order.shippingAddress?.detailAddress ?? "",
+      deliveryMessage: order.shippingAddress?.deliveryMessage ?? "",
+    },
+    subtotalAmount: order.subtotalAmount ?? 0,
+    shippingAmount: order.shippingAmount ?? 0,
+    totalAmount: order.totalAmount ?? 0,
+    transactions,
+  };
+}
+
+function mapSoftwareOption(option: SoftwareOption): ProductOption {
+  return {
+    id: String(option.id),
+    slug: option.slug ?? String(option.id),
+    title: option.title ?? option.name ?? "Option",
+    values: (option.values ?? []).map((value) => ({
+      id: String(value.id),
+      slug: value.slug ?? String(value.id),
+      value: value.value ?? value.label ?? String(value.id),
+    })),
+  };
+}
+
+function mapSoftwareVariantOptionValue(
+  value: SoftwareVariantOptionValue,
+): ProductVariantOptionValue {
+  const rawValue = value.value;
+  const valueObject =
+    typeof rawValue === "object" && rawValue !== null ? rawValue : null;
+  const option = value.option;
+  const optionId =
+    value.optionId ??
+    (typeof option === "object" && option !== null ? option.id : option);
+
+  return {
+    optionId: optionId != null ? String(optionId) : "",
+    valueId:
+      value.valueId != null
+        ? String(value.valueId)
+        : valueObject?.id != null
+          ? String(valueObject.id)
+          : rawValue != null
+            ? String(rawValue)
+            : "",
+    valueSlug: value.valueSlug ?? value.slug ?? valueObject?.slug ?? "",
+    value:
+      value.label ??
+      valueObject?.value ??
+      valueObject?.label ??
+      (rawValue != null ? String(rawValue) : ""),
+  };
+}
+
+function mapSoftwareOrderItem(item: SoftwareOrderItemLike): Order["items"][number] {
+  const product =
+    typeof item.product === "object" && item.product !== null ? item.product : null;
+  const variant =
+    typeof item.variant === "object" && item.variant !== null ? item.variant : null;
+
+  return {
+    variantId:
+      typeof item.variant === "object" && item.variant !== null
+        ? String(item.variant.id)
+        : item.variant != null
+          ? String(item.variant)
+          : "",
+    productTitle: product?.title ?? "Product",
+    variantTitle: variant?.displayName ?? variant?.title ?? undefined,
+    quantity: item.quantity ?? 0,
+    unitAmount: item.unitAmount ?? item.unitPrice ?? 0,
+    lineAmount: item.lineAmount ?? item.totalPrice ?? 0,
+  };
+}
+
+function mapSoftwareTransaction(
+  transaction: SoftwareTransactionLike,
+): PaymentTransaction {
+  return {
+    paymentId: transaction.pgPaymentId ?? "",
+    provider: transaction.pgProvider ?? "unknown",
+    status: transaction.status ?? "pending",
+    amount: transaction.amount ?? 0,
+  };
+}
+
+function mapSoftwareImage(media: SoftwareMedia): CommerceImage[] {
+  if (!media || typeof media !== "object" || !media.url) return [];
+
+  return [
+    {
+      url: media.url,
+      alt: media.alt ?? undefined,
+      width: media.width ?? undefined,
+      height: media.height ?? undefined,
+    },
+  ];
+}