@thorprovider/adapters 4.0.1 → 4.2.0

package/dist/index.mjs

@@ -4,6 +4,31 @@ import {
 } from "@thorprovider/types";
 
 // src/types/capabilities.types.ts
+var MOCK_CAPABILITIES = {
+  updateProfile: false,
+  updateEmail: false,
+  changePasswordDirect: false,
+  changePasswordViaEmail: false,
+  deleteAccount: false,
+  uploadAvatar: false,
+  avatarViaMetadata: false,
+  customAttributes: false,
+  fetchOrders: true,
+  cancelOrder: true,
+  manageAddresses: false,
+  defaultAddress: false,
+  applyDiscounts: true,
+  shippingCalculation: true,
+  guestCheckout: true,
+  savedPaymentMethods: false,
+  listPaymentProviders: true,
+  regionSpecificPayments: true,
+  wishlist: false,
+  advancedSearch: false,
+  facetedFilters: false,
+  productReviews: false,
+  loyaltyProgram: false
+};
 var MEDUSA_CAPABILITIES = {
   // Profile Management
   updateProfile: true,
@@ -7952,6 +7977,1011 @@ var MagentoProvider = class {
   }
 };
 
+// src/providers/mock/mock.ts
+var FIXTURE_TIMESTAMP = "2026-01-01T00:00:00.000Z";
+var DEFAULT_SITE_URL = "https://mock.thorcommerce.local";
+var regionFixtures = [
+  {
+    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" }
+    ]
+  }
+];
+var collectionFixtures = [
+  {
+    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."
+  }
+];
+var categoryFixtures = [
+  {
+    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."
+  }
+];
+var productFixtures = [
+  {
+    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" }]
+      }
+    ]
+  }
+];
+var stockLocationFixture = {
+  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"
+  }
+};
+var cartStore = /* @__PURE__ */ new Map();
+var orderStore = /* @__PURE__ */ new Map();
+var sequence = 0;
+function nextId(prefix) {
+  sequence += 1;
+  return `${prefix}-${sequence}`;
+}
+function createMoney(amount, currencyCode) {
+  return {
+    amount: amount.toFixed(2),
+    currencyCode
+  };
+}
+function createImage(label, hue) {
+  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) {
+  if (!regionId) {
+    return regionFixtures[0];
+  }
+  return regionFixtures.find((region) => region.id === regionId) ?? regionFixtures[0];
+}
+function createProductImageSet(label, hue) {
+  const featuredImage = createImage(label, hue);
+  return {
+    featuredImage,
+    images: [featuredImage, createImage(`${label} Detail`, (hue + 18) % 360)]
+  };
+}
+function buildCollections() {
+  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() {
+  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) {
+  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) : void 0,
+      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) => 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, options) {
+  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, sortKey, reverse) {
+  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, skip, first) {
+  const start = Math.max(0, skip ?? 0);
+  const end = first ? start + first : void 0;
+  return products.slice(start, end);
+}
+function resolveVariant(currencyCode, merchandiseId) {
+  const products = buildProducts(currencyCode);
+  for (const product of products) {
+    const variant = product.variants.find((item) => item.id === merchandiseId);
+    if (variant) {
+      return { product, variant };
+    }
+  }
+  return void 0;
+}
+function getShippingPrice(methodId) {
+  switch (methodId) {
+    case "mock-shipping-express":
+      return 18;
+    case "mock-shipping-standard":
+      return 8;
+    default:
+      return 0;
+  }
+}
+function buildExternalCart(state, currencyCode, siteUrl) {
+  const region = getRegionFixture(state.regionId);
+  const regionCurrency = region.currencyCode || currencyCode;
+  const lines = 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 = 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, currencyCode, siteUrl) {
+  const cart = buildExternalCart(state, currencyCode, siteUrl);
+  return {
+    id: `mock-order-${state.id}`,
+    orderNumber: `${1e3 + 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
+    }
+  };
+}
+function getMockCollections() {
+  return buildCollections();
+}
+function getMockCategories() {
+  return buildCategories();
+}
+function getMockProducts(options) {
+  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);
+}
+function getMockProduct(handle, regionId) {
+  const region = getRegionFixture(regionId);
+  return buildProducts(region.currencyCode).find(
+    (product) => product.handle === handle || product.id === handle
+  );
+}
+function getMockProductRecommendations(productId, regionId) {
+  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);
+}
+function getMockCollection(handle) {
+  return buildCollections().find(
+    (collection) => collection.handle === handle || collection.id === handle
+  );
+}
+function getMockCategory(idOrHandle) {
+  return buildCategories().find(
+    (category) => category.handle === idOrHandle || category.id === idOrHandle
+  );
+}
+function getMockRegions() {
+  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
+    }))
+  }));
+}
+function getMockAdminRegions() {
+  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
+  }));
+}
+function getMockRegionCountries(regionId) {
+  const region = regionFixtures.find((item) => item.id === regionId);
+  return region?.countries ?? [];
+}
+function createMockCart(regionId) {
+  const cart = {
+    id: nextId("mock-cart"),
+    regionId: regionId ?? regionFixtures[0].id,
+    lines: []
+  };
+  cartStore.set(cart.id, cart);
+  return cart;
+}
+function getMockCartState(cartId) {
+  return cartStore.get(cartId);
+}
+function saveMockCartState(cart) {
+  cartStore.set(cart.id, cart);
+  return cart;
+}
+function buildMockCart(cart, currencyCode, siteUrl) {
+  return buildExternalCart(
+    cart,
+    currencyCode ?? getRegionFixture(cart.regionId).currencyCode,
+    siteUrl ?? DEFAULT_SITE_URL
+  );
+}
+function getMockShippingMethods(regionId) {
+  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"
+    }
+  ];
+}
+function getMockPaymentMethods(currencyCode) {
+  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."
+    }
+  ];
+}
+function getMockStockLocations() {
+  return [stockLocationFixture];
+}
+function getMockInventoryLevels(variantId) {
+  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 [];
+}
+function validateMockCartStock(cart) {
+  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
+  };
+}
+function getMockFulfillmentOptions(regionId) {
+  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
+  }));
+}
+function completeMockCheckout(cart, currencyCode, siteUrl) {
+  const completedAt = (/* @__PURE__ */ 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;
+}
+function getMockAdminOrders() {
+  const orders = Array.from(orderStore.values()).sort(
+    (left, right) => right.createdAt.localeCompare(left.createdAt)
+  );
+  return {
+    orders,
+    count: orders.length
+  };
+}
+function getMockOrder(orderId) {
+  return orderStore.get(orderId);
+}
+function saveMockOrder(order) {
+  orderStore.set(order.id, order);
+  return order;
+}
+
+// src/providers/mock/index.ts
+var MockProvider = class {
+  name = "mock";
+  version = "1.0.0";
+  capabilities = MOCK_CAPABILITIES;
+  isMock = true;
+  currencyCode;
+  siteUrl;
+  constructor(config = {}) {
+    this.currencyCode = config.currencyCode ?? "USD";
+    this.siteUrl = config.siteUrl ?? "https://mock.thorcommerce.local";
+  }
+  hasVariant(merchandiseId, regionId) {
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      regionId
+    }).some(
+      (product) => product.variants.some((variant) => variant.id === merchandiseId)
+    );
+  }
+  async getProduct(handle, options) {
+    return getMockProduct(handle, options?.regionId);
+  }
+  async getProducts(options) {
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      query: options?.query,
+      sortKey: options?.sortKey,
+      reverse: options?.reverse,
+      first: options?.first,
+      skip: options?.skip,
+      categoryIds: options?.categoryIds,
+      collectionIds: options?.collectionIds,
+      regionId: options?.regionId
+    });
+  }
+  async getProductRecommendations(productId) {
+    return getMockProductRecommendations(productId);
+  }
+  async getCollection(handle) {
+    return getMockCollection(handle);
+  }
+  async getCollections(options) {
+    const collections = getMockCollections();
+    const query = options?.query?.trim().toLowerCase();
+    const filtered = query ? collections.filter(
+      (collection) => [collection.title, collection.description, collection.handle].join(" ").toLowerCase().includes(query)
+    ) : collections;
+    return filtered.slice(0, options?.limit ?? filtered.length);
+  }
+  async getCollectionProducts(handle, options) {
+    const collection = getMockCollection(handle);
+    if (!collection) {
+      return [];
+    }
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      collectionIds: [collection.id],
+      sortKey: options?.sortKey,
+      reverse: options?.reverse,
+      first: options?.first
+    });
+  }
+  async getCategory(idOrHandle) {
+    return getMockCategory(idOrHandle);
+  }
+  async getCategories(options) {
+    const categories = getMockCategories();
+    const query = options?.query?.trim().toLowerCase();
+    let filtered = query ? categories.filter(
+      (category) => [category.name, category.description ?? "", category.handle].join(" ").toLowerCase().includes(query)
+    ) : categories;
+    if (options?.parentCategoryId) {
+      filtered = filtered.filter((category) => category.parentCategoryId === options.parentCategoryId);
+    }
+    return filtered.slice(0, options?.limit ?? filtered.length);
+  }
+  async getCategoryProducts(handle, options) {
+    const category = getMockCategory(handle);
+    if (!category) {
+      return [];
+    }
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      categoryIds: [category.id],
+      sortKey: options?.sortKey,
+      reverse: options?.reverse,
+      first: options?.first
+    });
+  }
+  async createCart(options) {
+    const cart = createMockCart(options?.regionId);
+    return buildMockCart(cart, this.currencyCode, this.siteUrl);
+  }
+  async getCart(cartId) {
+    const cart = getMockCartState(cartId);
+    return cart ? buildMockCart(cart, this.currencyCode, this.siteUrl) : void 0;
+  }
+  async addToCart(cartId, lines) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    for (const line of lines) {
+      if (!this.hasVariant(line.merchandiseId, cart.regionId)) {
+        throw new ResourceNotFoundError("variant", line.merchandiseId);
+      }
+    }
+    const nextLines = [...cart.lines];
+    for (const line of lines) {
+      const existing = nextLines.find((item) => item.merchandiseId === line.merchandiseId);
+      if (existing) {
+        existing.quantity += line.quantity;
+      } else {
+        nextLines.push({
+          id: `mock-line-${line.merchandiseId}`,
+          merchandiseId: line.merchandiseId,
+          quantity: line.quantity
+        });
+      }
+    }
+    const saved = saveMockCartState({ ...cart, lines: nextLines });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async removeFromCart(cartId, lineIds) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const saved = saveMockCartState({
+      ...cart,
+      lines: cart.lines.filter((line) => !lineIds.includes(line.id))
+    });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async updateCart(cartId, lines) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    for (const line of lines) {
+      if (!this.hasVariant(line.merchandiseId, cart.regionId)) {
+        throw new ResourceNotFoundError("variant", line.merchandiseId);
+      }
+    }
+    const updates = new Map(lines.map((line) => [line.id, line]));
+    const nextLines = cart.lines.map((line) => {
+      const update = updates.get(line.id);
+      if (!update) {
+        return line;
+      }
+      return {
+        ...line,
+        merchandiseId: update.merchandiseId,
+        quantity: update.quantity
+      };
+    }).filter((line) => line.quantity > 0);
+    const saved = saveMockCartState({ ...cart, lines: nextLines });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async getRegions() {
+    return getMockRegions();
+  }
+  async completeCheckout(cartId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const order = completeMockCheckout(cart, this.currencyCode, this.siteUrl);
+    return order;
+  }
+  async getShippingMethods(cartId) {
+    const cart = getMockCartState(cartId);
+    return getMockShippingMethods(cart?.regionId);
+  }
+  async getRegionCountries(regionId) {
+    return getMockRegionCountries(regionId);
+  }
+  async addShippingMethod(cartId, methodId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const allowed = getMockShippingMethods(cart.regionId).some((method) => method.id === methodId);
+    if (!allowed) {
+      throw new ProviderAPIError(`Unknown mock shipping method: ${methodId}`, "mock", 400);
+    }
+    const saved = saveMockCartState({ ...cart, shippingMethodId: methodId });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async initiatePaymentSession(cartId, providerId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const allowed = getMockPaymentMethods(this.currencyCode).some((method) => method.id === providerId);
+    if (!allowed) {
+      throw new ProviderAPIError(`Unknown mock payment method: ${providerId}`, "mock", 400);
+    }
+    saveMockCartState({ ...cart, paymentProviderId: providerId });
+  }
+  async applyDiscountCode(cartId, code) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const normalized = code.trim();
+    if (!normalized) {
+      throw new ProviderAPIError("Discount code is required.", "mock", 400);
+    }
+    const saved = saveMockCartState({ ...cart, discountCode: normalized });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async removeDiscountCode(cartId, _code) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const saved = saveMockCartState({ ...cart, discountCode: void 0 });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async getOrders(_options) {
+    return getMockAdminOrders().orders;
+  }
+  async getPaymentMethods(options) {
+    return getMockPaymentMethods(options.currencyCode ?? this.currencyCode);
+  }
+  async getStockLocations() {
+    return getMockStockLocations();
+  }
+  async checkInventoryLevels(variantId) {
+    return getMockInventoryLevels(variantId);
+  }
+  async validateCartStock(cartId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    return validateMockCartStock(cart);
+  }
+  async getFulfillmentOptions(cartId, _salesChannelId) {
+    const cart = getMockCartState(cartId);
+    return getMockFulfillmentOptions(cart?.regionId);
+  }
+  async cancelOrder(orderId) {
+    const order = getMockOrder(orderId);
+    if (!order) {
+      throw new ResourceNotFoundError("order", orderId);
+    }
+    return saveMockOrder({
+      ...order,
+      status: "cancelled",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async createFulfillment(_orderId, _items) {
+    return;
+  }
+  async createRefund(orderId, _amount, _reason) {
+    const order = getMockOrder(orderId);
+    if (!order) {
+      throw new ResourceNotFoundError("order", orderId);
+    }
+    saveMockOrder({
+      ...order,
+      status: "refunded",
+      paymentStatus: "refunded",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async getAdminOrders() {
+    return getMockAdminOrders();
+  }
+  async getAdminRegions() {
+    return getMockAdminRegions();
+  }
+  async getStorefrontContext() {
+    return {
+      id: "mock-storefront",
+      name: "Mock Storefront",
+      platformType: "mock",
+      requiresProductScoping: false,
+      currencyCode: this.currencyCode,
+      locale: "en-US",
+      metadata: {
+        mode: "design"
+      }
+    };
+  }
+  isStorefrontRequired() {
+    return false;
+  }
+};
+
 // src/factory/index.ts
 function createProvider(options) {
   if (!options || !options.provider) {
@@ -7962,6 +8992,8 @@ function createProvider(options) {
   }
   const config = options.config;
   switch (options.provider) {
+    case "mock":
+      return new MockProvider(config);
     case "medusa":
       return new MedusaProvider(config);
     case "shopify":
@@ -7996,10 +9028,12 @@ export {
   ConfigurationError,
   MAGENTO_CAPABILITIES,
   MEDUSA_CAPABILITIES,
+  MOCK_CAPABILITIES,
   MagentoProvider,
   MedusaMetadataAdapter,
   MedusaProvider,
   MetricsService,
+  MockProvider,
   ProviderAPIError,
   ProviderNotFoundError,
   ResourceNotFoundError,