@thorprovider/adapters 4.1.0 → 4.2.1

package/src/providers/mock/index.ts

@@ -0,0 +1,427 @@
+import type {
+  Cart,
+  CartLineInput,
+  CartLineUpdate,
+  Collection,
+  CollectionProductsOptions,
+  GetCategoriesOptions,
+  GetCollectionsOptions,
+  GetOrdersOptions,
+  GetProductsOptions,
+  InventoryLevel,
+  Order,
+  PaymentMethodsOptions,
+  Product,
+  ProductCategory,
+  Region,
+  ShippingMethod,
+  StockLocation,
+  StockValidation,
+  StorefrontContext,
+  FulfillmentOption,
+  PaymentMethod,
+} from '@thorprovider/types';
+import type { CommerceProvider, ProviderConfig } from '../../types/provider';
+import { ProviderAPIError, ResourceNotFoundError } from '../../core/errors';
+import { MOCK_CAPABILITIES } from '../../types/capabilities.types';
+import {
+  buildMockCart,
+  completeMockCheckout,
+  createMockCart,
+  getMockAdminOrders,
+  getMockAdminRegions,
+  getMockCategories,
+  getMockCategory,
+  getMockCollection,
+  getMockCollections,
+  getMockCartState,
+  getMockFulfillmentOptions,
+  getMockInventoryLevels,
+  getMockOrder,
+  getMockPaymentMethods,
+  getMockProduct,
+  getMockProductRecommendations,
+  getMockProducts,
+  getMockRegionCountries,
+  getMockRegions,
+  getMockShippingMethods,
+  getMockStockLocations,
+  saveMockCartState,
+  saveMockOrder,
+  validateMockCartStock,
+} from './mock';
+
+export interface MockProviderConfig extends ProviderConfig {
+  currencyCode?: string;
+  siteUrl?: string;
+}
+
+export class MockProvider implements CommerceProvider {
+  readonly name = 'mock';
+  readonly version = '1.0.0';
+  readonly capabilities = MOCK_CAPABILITIES;
+  readonly isMock = true;
+
+  private readonly currencyCode: string;
+  private readonly siteUrl: string;
+
+  constructor(config: MockProviderConfig = {}) {
+    this.currencyCode = config.currencyCode ?? 'USD';
+    this.siteUrl = config.siteUrl ?? 'https://mock.thorcommerce.local';
+  }
+
+  private hasVariant(merchandiseId: string, regionId?: string): boolean {
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      regionId,
+    }).some((product) =>
+      product.variants.some((variant) => variant.id === merchandiseId)
+    );
+  }
+
+  async getProduct(handle: string, options?: { regionId?: string }): Promise<Product | undefined> {
+    return getMockProduct(handle, options?.regionId);
+  }
+
+  async getProducts(options?: GetProductsOptions): Promise<Product[]> {
+    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: string): Promise<Product[]> {
+    return getMockProductRecommendations(productId);
+  }
+
+  async getCollection(handle: string): Promise<Collection | undefined> {
+    return getMockCollection(handle);
+  }
+
+  async getCollections(options?: GetCollectionsOptions): Promise<Collection[]> {
+    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: string, options?: CollectionProductsOptions): Promise<Product[]> {
+    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: string): Promise<ProductCategory | undefined> {
+    return getMockCategory(idOrHandle);
+  }
+
+  async getCategories(options?: GetCategoriesOptions): Promise<ProductCategory[]> {
+    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: string, options?: CollectionProductsOptions): Promise<Product[]> {
+    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?: { regionId?: string }): Promise<Cart> {
+    const cart = createMockCart(options?.regionId);
+    return buildMockCart(cart, this.currencyCode, this.siteUrl);
+  }
+
+  async getCart(cartId: string): Promise<Cart | undefined> {
+    const cart = getMockCartState(cartId);
+    return cart ? buildMockCart(cart, this.currencyCode, this.siteUrl) : undefined;
+  }
+
+  async addToCart(cartId: string, lines: CartLineInput[]): Promise<Cart> {
+    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: string, lineIds: string[]): Promise<Cart> {
+    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: string, lines: CartLineUpdate[]): Promise<Cart> {
+    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(): Promise<Array<{ id: string; name: string; currency_code: string; countries?: Array<{ id: string; iso_2: string; name: string; display_name?: string }> }>> {
+    return getMockRegions();
+  }
+
+  async completeCheckout(cartId: string): Promise<Order> {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError('cart', cartId);
+    }
+
+    const order = completeMockCheckout(cart, this.currencyCode, this.siteUrl);
+    return order;
+  }
+
+  async getShippingMethods(cartId: string): Promise<ShippingMethod[]> {
+    const cart = getMockCartState(cartId);
+    return getMockShippingMethods(cart?.regionId);
+  }
+
+  async getRegionCountries(regionId: string) {
+    return getMockRegionCountries(regionId);
+  }
+
+  async addShippingMethod(cartId: string, methodId: string): Promise<Cart> {
+    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: string, providerId: string): Promise<void> {
+    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: string, code: string): Promise<Cart> {
+    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: string, _code: string): Promise<Cart> {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError('cart', cartId);
+    }
+
+    const saved = saveMockCartState({ ...cart, discountCode: undefined });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+
+  async getOrders(_options: GetOrdersOptions): Promise<Order[]> {
+    return getMockAdminOrders().orders;
+  }
+
+  async getPaymentMethods(options: PaymentMethodsOptions): Promise<PaymentMethod[]> {
+    return getMockPaymentMethods(options.currencyCode ?? this.currencyCode);
+  }
+
+  async getStockLocations(): Promise<StockLocation[]> {
+    return getMockStockLocations();
+  }
+
+  async checkInventoryLevels(variantId: string): Promise<InventoryLevel[]> {
+    return getMockInventoryLevels(variantId);
+  }
+
+  async validateCartStock(cartId: string): Promise<StockValidation> {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError('cart', cartId);
+    }
+
+    return validateMockCartStock(cart);
+  }
+
+  async getFulfillmentOptions(cartId: string, _salesChannelId: string): Promise<FulfillmentOption[]> {
+    const cart = getMockCartState(cartId);
+    return getMockFulfillmentOptions(cart?.regionId);
+  }
+
+  async cancelOrder(orderId: string): Promise<Order> {
+    const order = getMockOrder(orderId);
+    if (!order) {
+      throw new ResourceNotFoundError('order', orderId);
+    }
+
+    return saveMockOrder({
+      ...order,
+      status: 'cancelled',
+      updatedAt: new Date().toISOString(),
+      cancelledAt: new Date().toISOString(),
+    });
+  }
+
+  async createFulfillment(_orderId: string, _items?: Array<{ id: string; quantity: number }>): Promise<void> {
+    return;
+  }
+
+  async createRefund(orderId: string, _amount?: number, _reason?: string): Promise<void> {
+    const order = getMockOrder(orderId);
+    if (!order) {
+      throw new ResourceNotFoundError('order', orderId);
+    }
+
+    saveMockOrder({
+      ...order,
+      status: 'refunded',
+      paymentStatus: 'refunded',
+      updatedAt: new Date().toISOString(),
+    });
+  }
+
+  async getAdminOrders(): Promise<{ orders: Order[]; count: number }> {
+    return getMockAdminOrders();
+  }
+
+  async getAdminRegions(): Promise<Region[]> {
+    return getMockAdminRegions();
+  }
+
+  async getStorefrontContext(): Promise<StorefrontContext> {
+    return {
+      id: 'mock-storefront',
+      name: 'Mock Storefront',
+      platformType: 'mock',
+      requiresProductScoping: false,
+      currencyCode: this.currencyCode,
+      locale: 'en-US',
+      metadata: {
+        mode: 'design',
+      },
+    };
+  }
+
+  isStorefrontRequired(): boolean {
+    return false;
+  }
+}