@thorprovider/adapters 4.1.0 → 4.2.0

package/src/providers/mock/mock.ts

@@ -0,0 +1,917 @@
+import type {
+  Cart,
+  CartItem,
+  Collection,
+  Country,
+  FulfillmentOption,
+  Image,
+  InventoryLevel,
+  Money,
+  Order,
+  PaymentMethod,
+  Product,
+  ProductCategory,
+  Region,
+  SelectedOption,
+  ShippingMethod,
+  StockLocation,
+  StockStatus,
+  StockValidation,
+} from '@thorprovider/types';
+
+const FIXTURE_TIMESTAMP = '2026-01-01T00:00:00.000Z';
+const DEFAULT_SITE_URL = 'https://mock.thorcommerce.local';
+
+interface MockRegionFixture {
+  id: string;
+  name: string;
+  currencyCode: string;
+  locale?: string;
+  taxRate?: number;
+  countries: Country[];
+}
+
+interface MockCollectionFixture {
+  id: string;
+  handle: string;
+  title: string;
+  description: string;
+}
+
+interface MockCategoryFixture {
+  id: string;
+  handle: string;
+  name: string;
+  description: string;
+  parentCategoryId?: string;
+}
+
+interface MockVariantFixture {
+  id: string;
+  title: string;
+  price: number;
+  compareAtPrice?: number;
+  quantityAvailable: number;
+  selectedOptions: SelectedOption[];
+}
+
+interface MockProductFixture {
+  id: string;
+  handle: string;
+  title: string;
+  description: string;
+  imageLabel: string;
+  imageHue: number;
+  collectionHandles: string[];
+  categoryHandle: string;
+  productType: string;
+  vendor: string;
+  tags: string[];
+  options: Array<{ id: string; name: string; values: string[] }>;
+  variants: MockVariantFixture[];
+}
+
+export interface MockCartState {
+  id: string;
+  regionId?: string;
+  lines: Array<{
+    id: string;
+    merchandiseId: string;
+    quantity: number;
+  }>;
+  shippingMethodId?: string;
+  paymentProviderId?: string;
+  discountCode?: string;
+  completedAt?: string;
+}
+
+const regionFixtures: MockRegionFixture[] = [
+  {
+    id: 'mock-region-us',
+    name: 'United States',
+    currencyCode: 'USD',
+    locale: 'en-US',
+    taxRate: 0.08,
+    countries: [{ code: 'US', name: 'United States' }],
+  },
+  {
+    id: 'mock-region-eu',
+    name: 'Europe',
+    currencyCode: 'EUR',
+    locale: 'en-ES',
+    taxRate: 0.21,
+    countries: [
+      { code: 'ES', name: 'Spain' },
+      { code: 'FR', name: 'France' },
+      { code: 'DE', name: 'Germany' },
+    ],
+  },
+];
+
+const collectionFixtures: MockCollectionFixture[] = [
+  {
+    id: 'mock-collection-new-arrivals',
+    handle: 'new-arrivals',
+    title: 'New Arrivals',
+    description: 'Fresh mock catalog items for layout and merchandising flows.',
+  },
+  {
+    id: 'mock-collection-best-sellers',
+    handle: 'best-sellers',
+    title: 'Best Sellers',
+    description: 'High-performing mock products used to design hero grids and featured sections.',
+  },
+  {
+    id: 'mock-collection-studio-essentials',
+    handle: 'studio-essentials',
+    title: 'Studio Essentials',
+    description: 'A balanced fixture set for mock storefront navigation and detail pages.',
+  },
+];
+
+const categoryFixtures: MockCategoryFixture[] = [
+  {
+    id: 'mock-category-jackets',
+    handle: 'jackets',
+    name: 'Jackets',
+    description: 'Outerwear and layering pieces.',
+  },
+  {
+    id: 'mock-category-dresses',
+    handle: 'dresses',
+    name: 'Dresses',
+    description: 'Editorial silhouettes for seasonal collections.',
+  },
+  {
+    id: 'mock-category-home',
+    handle: 'home',
+    name: 'Home',
+    description: 'Decor and living objects for lifestyle layouts.',
+  },
+  {
+    id: 'mock-category-accessories',
+    handle: 'accessories',
+    name: 'Accessories',
+    description: 'Complementary products for cart and bundle flows.',
+  },
+];
+
+const productFixtures: MockProductFixture[] = [
+  {
+    id: 'mock-product-aurora-jacket',
+    handle: 'aurora-jacket',
+    title: 'Aurora Quilted Jacket',
+    description: 'Lightweight quilted outerwear with tonal hardware and a soft structured collar.',
+    imageLabel: 'Aurora Jacket',
+    imageHue: 222,
+    collectionHandles: ['new-arrivals', 'best-sellers'],
+    categoryHandle: 'jackets',
+    productType: 'outerwear',
+    vendor: 'Thor Atelier',
+    tags: ['outerwear', 'quilted', 'winter'],
+    options: [
+      { id: 'aurora-size', name: 'Size', values: ['S', 'M', 'L'] },
+      { id: 'aurora-color', name: 'Color', values: ['Midnight'] },
+    ],
+    variants: [
+      {
+        id: 'mock-variant-aurora-s',
+        title: 'S / Midnight',
+        price: 129,
+        compareAtPrice: 159,
+        quantityAvailable: 8,
+        selectedOptions: [
+          { name: 'Size', value: 'S' },
+          { name: 'Color', value: 'Midnight' },
+        ],
+      },
+      {
+        id: 'mock-variant-aurora-m',
+        title: 'M / Midnight',
+        price: 129,
+        compareAtPrice: 159,
+        quantityAvailable: 12,
+        selectedOptions: [
+          { name: 'Size', value: 'M' },
+          { name: 'Color', value: 'Midnight' },
+        ],
+      },
+    ],
+  },
+  {
+    id: 'mock-product-solis-dress',
+    handle: 'solis-dress',
+    title: 'Solis Pleated Dress',
+    description: 'A fluid pleated dress with a clean neckline designed for hero storytelling.',
+    imageLabel: 'Solis Dress',
+    imageHue: 18,
+    collectionHandles: ['new-arrivals', 'studio-essentials'],
+    categoryHandle: 'dresses',
+    productType: 'dress',
+    vendor: 'Thor Atelier',
+    tags: ['dress', 'occasion', 'pleated'],
+    options: [
+      { id: 'solis-size', name: 'Size', values: ['XS', 'S', 'M'] },
+      { id: 'solis-color', name: 'Color', values: ['Clay'] },
+    ],
+    variants: [
+      {
+        id: 'mock-variant-solis-xs',
+        title: 'XS / Clay',
+        price: 164,
+        quantityAvailable: 4,
+        selectedOptions: [
+          { name: 'Size', value: 'XS' },
+          { name: 'Color', value: 'Clay' },
+        ],
+      },
+      {
+        id: 'mock-variant-solis-s',
+        title: 'S / Clay',
+        price: 164,
+        quantityAvailable: 9,
+        selectedOptions: [
+          { name: 'Size', value: 'S' },
+          { name: 'Color', value: 'Clay' },
+        ],
+      },
+    ],
+  },
+  {
+    id: 'mock-product-helios-lamp',
+    handle: 'helios-lamp',
+    title: 'Helios Table Lamp',
+    description: 'Warm ambient lamp with sculptural proportions for lifestyle and home grids.',
+    imageLabel: 'Helios Lamp',
+    imageHue: 45,
+    collectionHandles: ['best-sellers', 'studio-essentials'],
+    categoryHandle: 'home',
+    productType: 'lighting',
+    vendor: 'Thor Home',
+    tags: ['home', 'lighting', 'decor'],
+    options: [{ id: 'helios-finish', name: 'Finish', values: ['Brass'] }],
+    variants: [
+      {
+        id: 'mock-variant-helios-brass',
+        title: 'Brass',
+        price: 96,
+        quantityAvailable: 15,
+        selectedOptions: [{ name: 'Finish', value: 'Brass' }],
+      },
+    ],
+  },
+  {
+    id: 'mock-product-luna-bag',
+    handle: 'luna-bag',
+    title: 'Luna Crossbody Bag',
+    description: 'Compact everyday bag for accessory rails, checkout add-ons, and bundle modules.',
+    imageLabel: 'Luna Bag',
+    imageHue: 306,
+    collectionHandles: ['studio-essentials'],
+    categoryHandle: 'accessories',
+    productType: 'bag',
+    vendor: 'Thor Atelier',
+    tags: ['bag', 'accessory', 'everyday'],
+    options: [{ id: 'luna-color', name: 'Color', values: ['Berry'] }],
+    variants: [
+      {
+        id: 'mock-variant-luna-berry',
+        title: 'Berry',
+        price: 82,
+        quantityAvailable: 18,
+        selectedOptions: [{ name: 'Color', value: 'Berry' }],
+      },
+    ],
+  },
+];
+
+const stockLocationFixture: StockLocation = {
+  id: 'mock-stock-primary',
+  name: 'Mock Main Warehouse',
+  address: {
+    address1: '100 Mock Avenue',
+    city: 'Design City',
+    countryCode: 'US',
+    postalCode: '10001',
+    province: 'NY',
+  },
+  metadata: {
+    timezone: 'America/New_York',
+  },
+};
+
+const cartStore = new Map<string, MockCartState>();
+const orderStore = new Map<string, Order>();
+
+let sequence = 0;
+
+function nextId(prefix: string): string {
+  sequence += 1;
+  return `${prefix}-${sequence}`;
+}
+
+function createMoney(amount: number, currencyCode: string): Money {
+  return {
+    amount: amount.toFixed(2),
+    currencyCode,
+  };
+}
+
+function createImage(label: string, hue: number): Image {
+  const svg = `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 1200" role="img" aria-label="${label}">
+      <defs>
+        <linearGradient id="g" x1="0" x2="1" y1="0" y2="1">
+          <stop offset="0%" stop-color="hsl(${hue}, 72%, 72%)" />
+          <stop offset="100%" stop-color="hsl(${(hue + 48) % 360}, 62%, 42%)" />
+        </linearGradient>
+      </defs>
+      <rect width="1200" height="1200" fill="url(#g)" rx="48" />
+      <circle cx="910" cy="280" r="180" fill="rgba(255,255,255,0.22)" />
+      <text x="90" y="990" fill="white" font-family="Arial, sans-serif" font-size="96" font-weight="700">${label}</text>
+    </svg>
+  `.trim();
+
+  return {
+    url: `data:image/svg+xml;charset=UTF-8,${encodeURIComponent(svg)}`,
+    altText: label,
+    width: 1200,
+    height: 1200,
+  };
+}
+
+function getRegionFixture(regionId?: string): MockRegionFixture {
+  if (!regionId) {
+    return regionFixtures[0];
+  }
+
+  return regionFixtures.find((region) => region.id === regionId) ?? regionFixtures[0];
+}
+
+function createProductImageSet(label: string, hue: number): { featuredImage: Image; images: Image[] } {
+  const featuredImage = createImage(label, hue);
+
+  return {
+    featuredImage,
+    images: [featuredImage, createImage(`${label} Detail`, (hue + 18) % 360)],
+  };
+}
+
+function buildCollections(): Collection[] {
+  return collectionFixtures.map((collection) => ({
+    id: collection.id,
+    handle: collection.handle,
+    title: collection.title,
+    description: collection.description,
+    path: `/collections/${collection.handle}`,
+    updatedAt: FIXTURE_TIMESTAMP,
+  }));
+}
+
+function buildCategories(): ProductCategory[] {
+  return categoryFixtures.map((category) => ({
+    id: category.id,
+    handle: category.handle,
+    name: category.name,
+    description: category.description,
+    parentCategoryId: category.parentCategoryId,
+    productCount: productFixtures.filter((product) => product.categoryHandle === category.handle).length,
+    image: createImage(category.name, 180).url,
+  }));
+}
+
+function buildProducts(currencyCode: string): Product[] {
+  const collections = buildCollections();
+
+  return productFixtures.map((product) => {
+    const { featuredImage, images } = createProductImageSet(product.imageLabel, product.imageHue);
+    const variants = product.variants.map((variant) => ({
+      id: variant.id,
+      title: variant.title,
+      availableForSale: variant.quantityAvailable > 0,
+      selectedOptions: variant.selectedOptions,
+      price: createMoney(variant.price, currencyCode),
+      compareAtPrice: variant.compareAtPrice
+        ? createMoney(variant.compareAtPrice, currencyCode)
+        : undefined,
+      quantityAvailable: variant.quantityAvailable,
+      image: featuredImage,
+    }));
+
+    const prices = product.variants.map((variant) => variant.price);
+
+    return {
+      id: product.id,
+      handle: product.handle,
+      title: product.title,
+      description: product.description,
+      availableForSale: variants.some((variant) => variant.availableForSale),
+      options: product.options,
+      variants,
+      featuredImage,
+      images,
+      priceRange: {
+        minVariantPrice: createMoney(Math.min(...prices), currencyCode),
+        maxVariantPrice: createMoney(Math.max(...prices), currencyCode),
+      },
+      collections: product.collectionHandles
+        .map((handle) => collections.find((collection) => collection.handle === handle))
+        .filter((collection): collection is Collection => Boolean(collection))
+        .map((collection) => ({
+          id: collection.id,
+          title: collection.title,
+          handle: collection.handle,
+        })),
+      productType: product.productType,
+      vendor: product.vendor,
+      tags: product.tags,
+      createdAt: FIXTURE_TIMESTAMP,
+      updatedAt: FIXTURE_TIMESTAMP,
+      metadata: {
+        categoryHandle: product.categoryHandle,
+        collectionHandles: product.collectionHandles,
+      },
+    };
+  });
+}
+
+function filterProducts(products: Product[], options: {
+  query?: string;
+  categoryIds?: string[];
+  collectionIds?: string[];
+}): Product[] {
+  const query = options.query?.trim().toLowerCase();
+  const categoryIds = new Set(options.categoryIds ?? []);
+  const collectionIds = new Set(options.collectionIds ?? []);
+
+  return products.filter((product) => {
+    if (query) {
+      const matchesQuery = [product.title, product.description, ...(product.tags ?? [])]
+        .join(' ')
+        .toLowerCase()
+        .includes(query);
+
+      if (!matchesQuery) {
+        return false;
+      }
+    }
+
+    if (categoryIds.size > 0) {
+      const categoryHandle = String(product.metadata?.categoryHandle ?? '');
+      const category = categoryFixtures.find((item) => item.handle === categoryHandle);
+      const matchesCategory = category
+        ? categoryIds.has(category.id) || categoryIds.has(category.handle)
+        : false;
+
+      if (!matchesCategory) {
+        return false;
+      }
+    }
+
+    if (collectionIds.size > 0) {
+      const productCollections = (product.collections ?? []).map((collection) => collection.handle);
+      const matchesCollection = (product.collections ?? []).some(
+        (collection) => collectionIds.has(collection.id) || collectionIds.has(collection.handle)
+      ) || productCollections.some((handle) => collectionIds.has(handle));
+
+      if (!matchesCollection) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+}
+
+function sortProducts(products: Product[], sortKey?: string, reverse?: boolean): Product[] {
+  const sorted = [...products];
+
+  switch (sortKey) {
+    case 'price':
+    case 'price-asc':
+    case 'price-desc':
+      sorted.sort(
+        (left, right) =>
+          Number(left.priceRange.minVariantPrice.amount) - Number(right.priceRange.minVariantPrice.amount)
+      );
+      break;
+    case 'created_at':
+    case 'createdAt':
+    case 'newest':
+      sorted.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+      break;
+    case 'title':
+    case 'name':
+    default:
+      sorted.sort((left, right) => left.title.localeCompare(right.title));
+      break;
+  }
+
+  const shouldReverse = reverse || sortKey === 'price-desc' || sortKey === 'newest';
+  return shouldReverse ? sorted.reverse() : sorted;
+}
+
+function paginateProducts(products: Product[], skip?: number, first?: number): Product[] {
+  const start = Math.max(0, skip ?? 0);
+  const end = first ? start + first : undefined;
+  return products.slice(start, end);
+}
+
+function resolveVariant(currencyCode: string, merchandiseId: string): {
+  product: Product;
+  variant: Product['variants'][number];
+} | undefined {
+  const products = buildProducts(currencyCode);
+
+  for (const product of products) {
+    const variant = product.variants.find((item) => item.id === merchandiseId);
+    if (variant) {
+      return { product, variant };
+    }
+  }
+
+  return undefined;
+}
+
+function getShippingPrice(methodId: string | undefined): number {
+  switch (methodId) {
+    case 'mock-shipping-express':
+      return 18;
+    case 'mock-shipping-standard':
+      return 8;
+    default:
+      return 0;
+  }
+}
+
+function buildExternalCart(state: MockCartState, currencyCode: string, siteUrl: string): Cart {
+  const region = getRegionFixture(state.regionId);
+  const regionCurrency = region.currencyCode || currencyCode;
+
+  const lines: CartItem[] = state.lines.flatMap((line) => {
+    const resolved = resolveVariant(regionCurrency, line.merchandiseId);
+    if (!resolved || !resolved.product.featuredImage) {
+      return [];
+    }
+
+    const lineTotal = Number(resolved.variant.price.amount) * line.quantity;
+    const stockStatus: StockStatus = resolved.variant.quantityAvailable && resolved.variant.quantityAvailable > 0
+      ? 'in_stock'
+      : 'out_of_stock';
+
+    return [{
+      id: line.id,
+      quantity: line.quantity,
+      stockStatus,
+      cost: {
+        totalAmount: createMoney(lineTotal, regionCurrency),
+      },
+      merchandise: {
+        id: resolved.variant.id,
+        title: resolved.variant.title,
+        selectedOptions: resolved.variant.selectedOptions,
+        product: {
+          id: resolved.product.id,
+          handle: resolved.product.handle,
+          title: resolved.product.title,
+          featuredImage: resolved.product.featuredImage,
+        },
+      },
+    }];
+  });
+
+  const subtotal = lines.reduce(
+    (sum, line) => sum + Number(line.cost.totalAmount.amount),
+    0
+  );
+  const shipping = getShippingPrice(state.shippingMethodId);
+  const discount = state.discountCode ? subtotal * 0.1 : 0;
+  const taxableBase = Math.max(subtotal + shipping - discount, 0);
+  const totalTax = region.taxRate ? taxableBase * region.taxRate : 0;
+  const total = taxableBase + totalTax;
+
+  return {
+    id: state.id,
+    checkoutUrl: `${siteUrl}/checkout?cart=${state.id}`,
+    cost: {
+      subtotalAmount: createMoney(subtotal, regionCurrency),
+      totalAmount: createMoney(total, regionCurrency),
+      totalTaxAmount: createMoney(totalTax, regionCurrency),
+    },
+    lines,
+    totalQuantity: lines.reduce((sum, line) => sum + line.quantity, 0),
+    completedAt: state.completedAt,
+  };
+}
+
+function buildOrderFromCart(state: MockCartState, currencyCode: string, siteUrl: string): Order {
+  const cart = buildExternalCart(state, currencyCode, siteUrl);
+
+  return {
+    id: `mock-order-${state.id}`,
+    orderNumber: `${1000 + sequence}`,
+    email: 'mock-customer@thorprovider.dev',
+    status: 'completed',
+    paymentStatus: state.paymentProviderId ? 'paid' : 'pending',
+    fulfillmentStatus: state.shippingMethodId ? 'fulfilled' : 'unfulfilled',
+    items: cart.lines.map((line) => ({
+      id: line.id ?? nextId('mock-order-line'),
+      title: line.merchandise.product.title,
+      variantTitle: line.merchandise.title,
+      quantity: line.quantity,
+      price: line.merchandise.product.featuredImage
+        ? createMoney(Number(line.cost.totalAmount.amount) / Math.max(line.quantity, 1), cart.cost.totalAmount.currencyCode)
+        : createMoney(0, cart.cost.totalAmount.currencyCode),
+      total: line.cost.totalAmount,
+      productId: line.merchandise.product.id,
+      variantId: line.merchandise.id,
+      image: line.merchandise.product.featuredImage,
+    })),
+    subtotal: cart.cost.subtotalAmount,
+    total: cart.cost.totalAmount,
+    tax: cart.cost.totalTaxAmount,
+    shipping: createMoney(getShippingPrice(state.shippingMethodId), cart.cost.totalAmount.currencyCode),
+    discount: createMoney(state.discountCode ? Number(cart.cost.subtotalAmount.amount) * 0.1 : 0, cart.cost.totalAmount.currencyCode),
+    createdAt: FIXTURE_TIMESTAMP,
+    updatedAt: FIXTURE_TIMESTAMP,
+    completedAt: state.completedAt,
+    metadata: {
+      provider: 'mock',
+      checkoutUrl: cart.checkoutUrl,
+    },
+  };
+}
+
+export function getMockCollections(): Collection[] {
+  return buildCollections();
+}
+
+export function getMockCategories(): ProductCategory[] {
+  return buildCategories();
+}
+
+export function getMockProducts(options?: {
+  currencyCode?: string;
+  query?: string;
+  sortKey?: string;
+  reverse?: boolean;
+  first?: number;
+  skip?: number;
+  categoryIds?: string[];
+  collectionIds?: string[];
+  regionId?: string;
+}): Product[] {
+  const region = getRegionFixture(options?.regionId);
+  const currencyCode = options?.currencyCode ?? region.currencyCode;
+  const products = buildProducts(currencyCode);
+  const filtered = filterProducts(products, {
+    query: options?.query,
+    categoryIds: options?.categoryIds,
+    collectionIds: options?.collectionIds,
+  });
+  const sorted = sortProducts(filtered, options?.sortKey, options?.reverse);
+
+  return paginateProducts(sorted, options?.skip, options?.first);
+}
+
+export function getMockProduct(handle: string, regionId?: string): Product | undefined {
+  const region = getRegionFixture(regionId);
+  return buildProducts(region.currencyCode).find(
+    (product) => product.handle === handle || product.id === handle
+  );
+}
+
+export function getMockProductRecommendations(productId: string, regionId?: string): Product[] {
+  const product = getMockProduct(productId, regionId)
+    ?? buildProducts(getRegionFixture(regionId).currencyCode).find((item) => item.id === productId);
+
+  if (!product) {
+    return [];
+  }
+
+  const collectionHandles = new Set((product.collections ?? []).map((collection) => collection.handle));
+
+  return buildProducts(getRegionFixture(regionId).currencyCode)
+    .filter((candidate) => candidate.id !== product.id)
+    .filter((candidate) =>
+      (candidate.collections ?? []).some((collection) => collectionHandles.has(collection.handle))
+    )
+    .slice(0, 4);
+}
+
+export function getMockCollection(handle: string): Collection | undefined {
+  return buildCollections().find(
+    (collection) => collection.handle === handle || collection.id === handle
+  );
+}
+
+export function getMockCategory(idOrHandle: string): ProductCategory | undefined {
+  return buildCategories().find(
+    (category) => category.handle === idOrHandle || category.id === idOrHandle
+  );
+}
+
+export function getMockRegions(): Array<{
+  id: string;
+  name: string;
+  currency_code: string;
+  countries: Array<{ id: string; iso_2: string; name: string; display_name?: string }>;
+}> {
+  return regionFixtures.map((region) => ({
+    id: region.id,
+    name: region.name,
+    currency_code: region.currencyCode,
+    countries: region.countries.map((country) => ({
+      id: `country-${country.code.toLowerCase()}`,
+      iso_2: country.code.toLowerCase(),
+      name: country.name,
+      display_name: country.name,
+    })),
+  }));
+}
+
+export function getMockAdminRegions(): Region[] {
+  return regionFixtures.map((region) => ({
+    id: region.id,
+    name: region.name,
+    countryCodes: region.countries.map((country) => country.code),
+    currency: region.currencyCode,
+    taxRate: region.taxRate,
+    isEnabled: true,
+  }));
+}
+
+export function getMockRegionCountries(regionId: string): Country[] {
+  const region = regionFixtures.find((item) => item.id === regionId);
+  return region?.countries ?? [];
+}
+
+export function createMockCart(regionId?: string): MockCartState {
+  const cart: MockCartState = {
+    id: nextId('mock-cart'),
+    regionId: regionId ?? regionFixtures[0].id,
+    lines: [],
+  };
+
+  cartStore.set(cart.id, cart);
+  return cart;
+}
+
+export function getMockCartState(cartId: string): MockCartState | undefined {
+  return cartStore.get(cartId);
+}
+
+export function saveMockCartState(cart: MockCartState): MockCartState {
+  cartStore.set(cart.id, cart);
+  return cart;
+}
+
+export function buildMockCart(cart: MockCartState, currencyCode?: string, siteUrl?: string): Cart {
+  return buildExternalCart(
+    cart,
+    currencyCode ?? getRegionFixture(cart.regionId).currencyCode,
+    siteUrl ?? DEFAULT_SITE_URL
+  );
+}
+
+export function getMockShippingMethods(regionId?: string): ShippingMethod[] {
+  const currencyCode = getRegionFixture(regionId).currencyCode;
+
+  return [
+    {
+      id: 'mock-shipping-standard',
+      name: 'Standard Shipping',
+      description: 'Fixture shipping option for checkout and cart layouts.',
+      price: createMoney(8, currencyCode),
+      estimatedDays: '3-5 business days',
+    },
+    {
+      id: 'mock-shipping-express',
+      name: 'Express Shipping',
+      description: 'Faster fixture shipping option for premium checkout flows.',
+      price: createMoney(18, currencyCode),
+      estimatedDays: '1-2 business days',
+    },
+  ];
+}
+
+export function getMockPaymentMethods(currencyCode: string): PaymentMethod[] {
+  return [
+    {
+      id: 'mock-card',
+      name: 'Mock Card',
+      type: 'card',
+      isEnabled: true,
+      requiresSetup: true,
+      description: `Fixture card checkout for ${currencyCode}.`,
+    },
+    {
+      id: 'mock-cash',
+      name: 'Cash on Delivery',
+      type: 'cash_on_delivery',
+      isEnabled: true,
+      requiresSetup: false,
+      description: 'Mock cash payment option for checkout prototypes.',
+    },
+  ];
+}
+
+export function getMockStockLocations(): StockLocation[] {
+  return [stockLocationFixture];
+}
+
+export function getMockInventoryLevels(variantId: string): InventoryLevel[] {
+  for (const region of regionFixtures) {
+    const resolved = resolveVariant(region.currencyCode, variantId);
+    if (resolved) {
+      return [{
+        locationId: stockLocationFixture.id,
+        locationName: stockLocationFixture.name,
+        availableQuantity: resolved.variant.quantityAvailable ?? 0,
+        reservedQuantity: 0,
+        stockedQuantity: resolved.variant.quantityAvailable ?? 0,
+      }];
+    }
+  }
+
+  return [];
+}
+
+export function validateMockCartStock(cart: MockCartState): StockValidation {
+  const currencyCode = getRegionFixture(cart.regionId).currencyCode;
+  const unavailableItems = cart.lines.flatMap((line) => {
+    const resolved = resolveVariant(currencyCode, line.merchandiseId);
+    if (!resolved) {
+      return [];
+    }
+
+    const availableQuantity = resolved.variant.quantityAvailable ?? 0;
+
+    if (line.quantity <= availableQuantity) {
+      return [];
+    }
+
+    return [{
+      variantId: resolved.variant.id,
+      productName: resolved.product.title,
+      requestedQuantity: line.quantity,
+      availableQuantity,
+    }];
+  });
+
+  return {
+    allAvailable: unavailableItems.length === 0,
+    unavailableItems,
+  };
+}
+
+export function getMockFulfillmentOptions(regionId?: string): FulfillmentOption[] {
+  return getMockShippingMethods(regionId).map((method) => ({
+    id: method.id,
+    providerId: 'mock-fulfillment',
+    name: method.name,
+    description: method.description,
+    price: method.price,
+    estimatedDays: method.estimatedDays,
+    stockLocation: stockLocationFixture,
+  }));
+}
+
+export function completeMockCheckout(cart: MockCartState, currencyCode?: string, siteUrl?: string): Order {
+  const completedAt = new Date().toISOString();
+  const nextCart = {
+    ...cart,
+    completedAt,
+  };
+
+  cartStore.set(nextCart.id, nextCart);
+
+  const order = buildOrderFromCart(
+    nextCart,
+    currencyCode ?? getRegionFixture(nextCart.regionId).currencyCode,
+    siteUrl ?? DEFAULT_SITE_URL
+  );
+
+  orderStore.set(order.id, order);
+  return order;
+}
+
+export function getMockAdminOrders(): { orders: Order[]; count: number } {
+  const orders = Array.from(orderStore.values()).sort((left, right) =>
+    right.createdAt.localeCompare(left.createdAt)
+  );
+
+  return {
+    orders,
+    count: orders.length,
+  };
+}
+
+export function getMockOrder(orderId: string): Order | undefined {
+  return orderStore.get(orderId);
+}
+
+export function saveMockOrder(order: Order): Order {
+  orderStore.set(order.id, order);
+  return order;
+}