omni-sync-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,816 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OmniSyncClient: () => OmniSyncClient,
+  OmniSyncError: () => OmniSyncError,
+  createWebhookHandler: () => createWebhookHandler,
+  isCouponApplicableToProduct: () => isCouponApplicableToProduct,
+  isWebhookEventType: () => isWebhookEventType,
+  parseWebhookEvent: () => parseWebhookEvent,
+  verifyWebhook: () => verifyWebhook
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.omni-sync.com";
+var DEFAULT_TIMEOUT = 3e4;
+var OmniSyncClient = class {
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("OmniSyncClient: apiKey is required");
+    }
+    if (!options.apiKey.startsWith("omni_")) {
+      console.warn('OmniSyncClient: apiKey should start with "omni_"');
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+  }
+  // -------------------- Private Methods --------------------
+  async request(method, path, body, queryParams) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "X-SDK-Version": "0.1.0"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new OmniSyncError(
+          errorData.message || `Request failed with status ${response.status}`,
+          response.status,
+          errorData
+        );
+      }
+      const text = await response.text();
+      if (!text) return {};
+      return JSON.parse(text);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof OmniSyncError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new OmniSyncError("Request timeout", 408);
+        }
+        throw new OmniSyncError(error.message, 0);
+      }
+      throw new OmniSyncError("Unknown error occurred", 0);
+    }
+  }
+  // -------------------- Products --------------------
+  /**
+   * Get a list of products with pagination
+   */
+  async getProducts(params) {
+    return this.request("GET", "/api/v1/products", void 0, {
+      page: params?.page,
+      limit: params?.limit,
+      search: params?.search,
+      status: params?.status,
+      type: params?.type,
+      sortBy: params?.sortBy,
+      sortOrder: params?.sortOrder
+    });
+  }
+  /**
+   * Get a single product by ID
+   */
+  async getProduct(productId) {
+    return this.request("GET", `/api/v1/products/${productId}`);
+  }
+  /**
+   * Create a new product
+   */
+  async createProduct(data) {
+    return this.request("POST", "/api/v1/products", data);
+  }
+  /**
+   * Update an existing product
+   */
+  async updateProduct(productId, data) {
+    return this.request("PATCH", `/api/v1/products/${productId}`, data);
+  }
+  /**
+   * Delete a product
+   */
+  async deleteProduct(productId) {
+    await this.request("DELETE", `/api/v1/products/${productId}`);
+  }
+  // -------------------- Orders --------------------
+  /**
+   * Get a list of orders with pagination
+   */
+  async getOrders(params) {
+    return this.request("GET", "/api/v1/orders", void 0, {
+      page: params?.page,
+      limit: params?.limit,
+      status: params?.status,
+      sortBy: params?.sortBy,
+      sortOrder: params?.sortOrder
+    });
+  }
+  /**
+   * Get a single order by ID
+   */
+  async getOrder(orderId) {
+    return this.request("GET", `/api/v1/orders/${orderId}`);
+  }
+  /**
+   * Create a new order
+   * This will automatically deduct inventory and sync to connected platforms
+   */
+  async createOrder(data) {
+    return this.request("POST", "/api/v1/orders", data);
+  }
+  /**
+   * Update an order (e.g., change status)
+   */
+  async updateOrder(orderId, data) {
+    return this.request("PATCH", `/api/v1/orders/${orderId}`, data);
+  }
+  // -------------------- Inventory --------------------
+  /**
+   * Update inventory for a product
+   * This will sync inventory to all connected platforms
+   */
+  async updateInventory(productId, data) {
+    await this.request("PUT", `/api/v1/products/${productId}/inventory`, data);
+  }
+  /**
+   * Get current inventory for a product
+   */
+  async getInventory(productId) {
+    return this.request("GET", `/api/v1/products/${productId}/inventory`);
+  }
+  // -------------------- Sync --------------------
+  /**
+   * Trigger a sync to a specific platform or all platforms
+   */
+  async triggerSync(platform) {
+    return this.request("POST", "/api/v1/sync", { platform });
+  }
+  /**
+   * Get the status of a sync job
+   */
+  async getSyncStatus(jobId) {
+    return this.request("GET", `/api/v1/sync/${jobId}`);
+  }
+  // -------------------- Store Info --------------------
+  /**
+   * Get information about the connected store
+   */
+  async getStoreInfo() {
+    return this.request("GET", "/api/v1/store");
+  }
+  // -------------------- Coupons --------------------
+  /**
+   * Get a list of coupons with pagination
+   */
+  async getCoupons(params) {
+    return this.request("GET", "/api/v1/coupons", void 0, {
+      page: params?.page,
+      limit: params?.limit,
+      search: params?.search,
+      status: params?.status,
+      type: params?.type,
+      platform: params?.platform,
+      sortBy: params?.sortBy,
+      sortOrder: params?.sortOrder
+    });
+  }
+  /**
+   * Get a single coupon by ID
+   */
+  async getCoupon(couponId) {
+    return this.request("GET", `/api/v1/coupons/${couponId}`);
+  }
+  /**
+   * Create a new coupon.
+   * Returns validation warnings if syncing to platforms that don't support certain features.
+   *
+   * @example
+   * ```typescript
+   * const coupon = await omni.createCoupon({
+   *   code: 'SUMMER20',
+   *   type: 'PERCENTAGE',
+   *   value: 20,
+   *   applicableCategories: ['cat_electronics'],
+   *   excludedProducts: ['prod_clearance_item'],
+   *   platforms: ['WOOCOMMERCE', 'SHOPIFY'],
+   * });
+   *
+   * // Check for platform limitations
+   * if (coupon.validationWarnings?.length) {
+   *   console.warn('Some features not supported:', coupon.validationWarnings);
+   * }
+   * ```
+   */
+  async createCoupon(data) {
+    return this.request("POST", "/api/v1/coupons", data);
+  }
+  /**
+   * Update an existing coupon
+   */
+  async updateCoupon(couponId, data) {
+    return this.request("PATCH", `/api/v1/coupons/${couponId}`, data);
+  }
+  /**
+   * Delete a coupon
+   */
+  async deleteCoupon(couponId) {
+    await this.request("DELETE", `/api/v1/coupons/${couponId}`);
+  }
+  /**
+   * Sync a coupon to all connected platforms.
+   * Returns a sync job that can be tracked with getSyncStatus().
+   */
+  async syncCoupon(couponId) {
+    return this.request("POST", `/api/v1/coupons/${couponId}/sync`);
+  }
+  /**
+   * Publish a coupon to specific platforms.
+   * Use this for selective syncing instead of syncing to all platforms.
+   *
+   * @example
+   * ```typescript
+   * // Only sync to WooCommerce and Shopify
+   * await omni.publishCoupon('coupon_123', ['WOOCOMMERCE', 'SHOPIFY']);
+   * ```
+   */
+  async publishCoupon(couponId, platforms) {
+    return this.request("POST", `/api/v1/coupons/${couponId}/publish`, { platforms });
+  }
+  /**
+   * Get platform capabilities for coupon features.
+   * Use this to understand what features each platform supports.
+   *
+   * @example
+   * ```typescript
+   * const capabilities = await omni.getCouponPlatformCapabilities();
+   * if (!capabilities.SHOPIFY.supportsProductExclusions) {
+   *   console.log('Shopify does not support product exclusions');
+   * }
+   * ```
+   */
+  async getCouponPlatformCapabilities() {
+    return this.request(
+      "GET",
+      "/api/v1/coupons/platform-capabilities"
+    );
+  }
+  // -------------------- Customers --------------------
+  /**
+   * Create a new customer
+   *
+   * @example
+   * ```typescript
+   * const customer = await omni.createCustomer({
+   *   email: 'customer@example.com',
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   *   acceptsMarketing: true,
+   * });
+   * ```
+   */
+  async createCustomer(data) {
+    return this.request("POST", "/api/v1/customers", data);
+  }
+  /**
+   * Get a customer by ID
+   */
+  async getCustomer(customerId) {
+    return this.request("GET", `/api/v1/customers/${customerId}`);
+  }
+  /**
+   * Update a customer
+   */
+  async updateCustomer(customerId, data) {
+    return this.request("PATCH", `/api/v1/customers/${customerId}`, data);
+  }
+  /**
+   * Get a customer by email
+   */
+  async getCustomerByEmail(email) {
+    return this.request("GET", "/api/v1/customers/by-email", void 0, { email });
+  }
+  /**
+   * Login an existing customer (returns JWT token)
+   *
+   * @example
+   * ```typescript
+   * const auth = await omni.loginCustomer('customer@example.com', 'password123');
+   * console.log('Customer logged in:', auth.customer.email);
+   * // Store auth.token for subsequent authenticated requests
+   * ```
+   */
+  async loginCustomer(email, password) {
+    return this.request("POST", "/api/v1/customers/login", {
+      email,
+      password
+    });
+  }
+  /**
+   * Register a new customer with password (creates account)
+   *
+   * @example
+   * ```typescript
+   * const auth = await omni.registerCustomer({
+   *   email: 'newcustomer@example.com',
+   *   password: 'securepassword123',
+   *   firstName: 'Jane',
+   *   lastName: 'Doe',
+   * });
+   * ```
+   */
+  async registerCustomer(data) {
+    return this.request("POST", "/api/v1/customers/register", data);
+  }
+  /**
+   * Request a password reset email for a customer
+   */
+  async forgotPassword(email) {
+    return this.request("POST", "/api/v1/customers/forgot-password", {
+      email
+    });
+  }
+  /**
+   * Get all addresses for a customer
+   */
+  async getCustomerAddresses(customerId) {
+    return this.request("GET", `/api/v1/customers/${customerId}/addresses`);
+  }
+  /**
+   * Add an address to a customer
+   *
+   * @example
+   * ```typescript
+   * const address = await omni.addCustomerAddress('cust_123', {
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   *   line1: '123 Main St',
+   *   city: 'New York',
+   *   region: 'NY',
+   *   postalCode: '10001',
+   *   country: 'US',
+   *   isDefault: true,
+   * });
+   * ```
+   */
+  async addCustomerAddress(customerId, address) {
+    return this.request(
+      "POST",
+      `/api/v1/customers/${customerId}/addresses`,
+      address
+    );
+  }
+  /**
+   * Update a customer address
+   */
+  async updateCustomerAddress(customerId, addressId, address) {
+    return this.request(
+      "PATCH",
+      `/api/v1/customers/${customerId}/addresses/${addressId}`,
+      address
+    );
+  }
+  /**
+   * Delete a customer address
+   */
+  async deleteCustomerAddress(customerId, addressId) {
+    await this.request("DELETE", `/api/v1/customers/${customerId}/addresses/${addressId}`);
+  }
+  /**
+   * Get orders for a customer
+   *
+   * @example
+   * ```typescript
+   * const orders = await omni.getCustomerOrders('cust_123', { page: 1, limit: 10 });
+   * console.log(`Customer has ${orders.meta.total} total orders`);
+   * ```
+   */
+  async getCustomerOrders(customerId, params) {
+    return this.request(
+      "GET",
+      `/api/v1/customers/${customerId}/orders`,
+      void 0,
+      { page: params?.page, limit: params?.limit }
+    );
+  }
+  // -------------------- Cart --------------------
+  /**
+   * Create a new cart for a guest user
+   * Returns a cart with a sessionToken that identifies this cart
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.createCart();
+   * console.log('Cart session:', cart.sessionToken);
+   * // Store sessionToken in localStorage or cookie
+   * ```
+   */
+  async createCart() {
+    return this.request("POST", "/api/v1/cart");
+  }
+  /**
+   * Get a cart by session token (for guest users)
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.getCartBySession('sess_abc123');
+   * console.log('Items in cart:', cart.itemCount);
+   * ```
+   */
+  async getCartBySession(sessionToken) {
+    return this.request("GET", `/api/v1/cart/session/${sessionToken}`);
+  }
+  /**
+   * Get a cart by customer ID (for authenticated users)
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.getCartByCustomer('cust_123');
+   * console.log('Customer cart total:', cart.subtotal);
+   * ```
+   */
+  async getCartByCustomer(customerId) {
+    return this.request("GET", `/api/v1/cart/customer/${customerId}`);
+  }
+  /**
+   * Get a cart by ID
+   */
+  async getCart(cartId) {
+    return this.request("GET", `/api/v1/cart/${cartId}`);
+  }
+  /**
+   * Add an item to the cart
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.addToCart('cart_123', {
+   *   productId: 'prod_abc',
+   *   quantity: 2,
+   *   notes: 'Gift wrap please',
+   * });
+   * ```
+   */
+  async addToCart(cartId, item) {
+    return this.request("POST", `/api/v1/cart/${cartId}/items`, item);
+  }
+  /**
+   * Update an item quantity in the cart
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.updateCartItem('cart_123', 'item_456', { quantity: 3 });
+   * ```
+   */
+  async updateCartItem(cartId, itemId, data) {
+    return this.request("PATCH", `/api/v1/cart/${cartId}/items/${itemId}`, data);
+  }
+  /**
+   * Remove an item from the cart
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.removeCartItem('cart_123', 'item_456');
+   * ```
+   */
+  async removeCartItem(cartId, itemId) {
+    return this.request("DELETE", `/api/v1/cart/${cartId}/items/${itemId}`);
+  }
+  /**
+   * Clear all items from the cart
+   *
+   * @example
+   * ```typescript
+   * await omni.clearCart('cart_123');
+   * ```
+   */
+  async clearCart(cartId) {
+    await this.request("DELETE", `/api/v1/cart/${cartId}/items`);
+  }
+  /**
+   * Apply a coupon to the cart
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.applyCoupon('cart_123', 'SAVE20');
+   * console.log('Discount:', cart.discountAmount);
+   * ```
+   */
+  async applyCoupon(cartId, code) {
+    return this.request("POST", `/api/v1/cart/${cartId}/coupon`, { code });
+  }
+  /**
+   * Remove a coupon from the cart
+   *
+   * @example
+   * ```typescript
+   * const cart = await omni.removeCoupon('cart_123');
+   * ```
+   */
+  async removeCoupon(cartId) {
+    return this.request("DELETE", `/api/v1/cart/${cartId}/coupon`);
+  }
+  /**
+   * Merge a guest cart into a customer's cart (after login)
+   * The guest cart items are moved to the customer's cart
+   *
+   * @example
+   * ```typescript
+   * // After customer logs in, merge their guest cart
+   * const mergedCart = await omni.mergeCarts({
+   *   sourceSessionToken: 'sess_guest_abc',
+   *   targetCustomerId: 'cust_123',
+   * });
+   * ```
+   */
+  async mergeCarts(data) {
+    return this.request("POST", "/api/v1/cart/merge", data);
+  }
+  // -------------------- Checkout --------------------
+  /**
+   * Create a checkout from a cart
+   * Starts the checkout process and returns checkout with available options
+   *
+   * @example
+   * ```typescript
+   * const checkout = await omni.createCheckout({ cartId: 'cart_123' });
+   * console.log('Checkout created:', checkout.id);
+   * ```
+   */
+  async createCheckout(data) {
+    return this.request("POST", "/api/v1/checkout", data);
+  }
+  /**
+   * Get a checkout by ID
+   *
+   * @example
+   * ```typescript
+   * const checkout = await omni.getCheckout('checkout_123');
+   * console.log('Status:', checkout.status);
+   * ```
+   */
+  async getCheckout(checkoutId) {
+    return this.request("GET", `/api/v1/checkout/${checkoutId}`);
+  }
+  /**
+   * Set customer information on checkout
+   *
+   * @example
+   * ```typescript
+   * const checkout = await omni.setCheckoutCustomer('checkout_123', {
+   *   email: 'customer@example.com',
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   * });
+   * ```
+   */
+  async setCheckoutCustomer(checkoutId, data) {
+    return this.request("PATCH", `/api/v1/checkout/${checkoutId}/customer`, data);
+  }
+  /**
+   * Set shipping address on checkout
+   * Returns the checkout and available shipping rates for the address
+   *
+   * @example
+   * ```typescript
+   * const { checkout, rates } = await omni.setShippingAddress('checkout_123', {
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   *   line1: '123 Main St',
+   *   city: 'New York',
+   *   region: 'NY',
+   *   postalCode: '10001',
+   *   country: 'US',
+   * });
+   * console.log('Available rates:', rates);
+   * ```
+   */
+  async setShippingAddress(checkoutId, address) {
+    return this.request(
+      "PATCH",
+      `/api/v1/checkout/${checkoutId}/shipping-address`,
+      address
+    );
+  }
+  /**
+   * Get available shipping rates for a checkout
+   * Requires shipping address to be set first
+   *
+   * @example
+   * ```typescript
+   * const rates = await omni.getShippingRates('checkout_123');
+   * console.log('Shipping options:', rates);
+   * ```
+   */
+  async getShippingRates(checkoutId) {
+    return this.request("GET", `/api/v1/checkout/${checkoutId}/shipping-rates`);
+  }
+  /**
+   * Select a shipping method for checkout
+   *
+   * @example
+   * ```typescript
+   * const checkout = await omni.selectShippingMethod('checkout_123', 'rate_express');
+   * console.log('Shipping cost:', checkout.shippingAmount);
+   * ```
+   */
+  async selectShippingMethod(checkoutId, shippingRateId) {
+    return this.request("PATCH", `/api/v1/checkout/${checkoutId}/shipping-method`, {
+      shippingRateId
+    });
+  }
+  /**
+   * Set billing address on checkout
+   * Can optionally use shipping address as billing address
+   *
+   * @example
+   * ```typescript
+   * // Use same as shipping
+   * const checkout = await omni.setBillingAddress('checkout_123', {
+   *   ...shippingAddress,
+   *   sameAsShipping: true,
+   * });
+   *
+   * // Or set different billing address
+   * const checkout = await omni.setBillingAddress('checkout_123', {
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   *   line1: '456 Business Ave',
+   *   city: 'New York',
+   *   region: 'NY',
+   *   postalCode: '10002',
+   *   country: 'US',
+   * });
+   * ```
+   */
+  async setBillingAddress(checkoutId, address) {
+    return this.request(
+      "PATCH",
+      `/api/v1/checkout/${checkoutId}/billing-address`,
+      address
+    );
+  }
+  /**
+   * Complete the checkout and create an order
+   * Requires customer email, shipping address, and shipping method to be set
+   *
+   * @example
+   * ```typescript
+   * const { orderId } = await omni.completeCheckout('checkout_123');
+   * console.log('Order created:', orderId);
+   * ```
+   */
+  async completeCheckout(checkoutId) {
+    return this.request(
+      "POST",
+      `/api/v1/checkout/${checkoutId}/complete`
+    );
+  }
+};
+var OmniSyncError = class extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.name = "OmniSyncError";
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+
+// src/webhooks.ts
+function verifyWebhook(payload, signature, secret) {
+  if (!signature || !secret) {
+    return false;
+  }
+  const payloadString = typeof payload === "string" ? payload : JSON.stringify(payload);
+  return verifyHmacSignature(payloadString, signature, secret);
+}
+function verifyHmacSignature(payload, signature, secret) {
+  try {
+    if (typeof globalThis.crypto === "undefined") {
+      const crypto2 = require("crypto");
+      const expectedSignature2 = crypto2.createHmac("sha256", secret).update(payload).digest("hex");
+      return timingSafeEqual(signature, expectedSignature2);
+    }
+    const crypto = require("crypto");
+    const expectedSignature = crypto.createHmac("sha256", secret).update(payload).digest("hex");
+    return timingSafeEqual(signature, expectedSignature);
+  } catch (error) {
+    console.error("Webhook signature verification failed:", error);
+    return false;
+  }
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+function parseWebhookEvent(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    throw new Error("Invalid webhook payload: expected object");
+  }
+  const event = payload;
+  if (typeof event.event !== "string") {
+    throw new Error("Invalid webhook payload: missing or invalid event type");
+  }
+  if (typeof event.storeId !== "string") {
+    throw new Error("Invalid webhook payload: missing storeId");
+  }
+  if (typeof event.entityId !== "string") {
+    throw new Error("Invalid webhook payload: missing entityId");
+  }
+  return {
+    event: event.event,
+    storeId: event.storeId,
+    entityId: event.entityId,
+    platform: event.platform || "CUSTOM",
+    data: event.data,
+    timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function isWebhookEventType(event, type) {
+  return event.event === type;
+}
+function createWebhookHandler(handlers) {
+  return async (payload) => {
+    const event = parseWebhookEvent(payload);
+    const handler = handlers[event.event];
+    if (handler) {
+      await handler(event);
+    }
+  };
+}
+
+// src/types.ts
+function isCouponApplicableToProduct(coupon, productId, productCategoryIds) {
+  if (coupon.excludedProducts?.includes(productId)) {
+    return false;
+  }
+  if (coupon.excludedCategories?.some((cat) => productCategoryIds.includes(cat))) {
+    return false;
+  }
+  if (coupon.applicableProducts && coupon.applicableProducts.length > 0) {
+    if (!coupon.applicableProducts.includes(productId)) {
+      return false;
+    }
+  }
+  if (coupon.applicableCategories && coupon.applicableCategories.length > 0) {
+    if (!coupon.applicableCategories.some((cat) => productCategoryIds.includes(cat))) {
+      return false;
+    }
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OmniSyncClient,
+  OmniSyncError,
+  createWebhookHandler,
+  isCouponApplicableToProduct,
+  isWebhookEventType,
+  parseWebhookEvent,
+  verifyWebhook
+});