@thorprovider/adapters 4.2.0 → 4.2.2

package/dist/index.mjs

@@ -71,6 +71,41 @@ var MEDUSA_CAPABILITIES = {
   loyaltyProgram: false
   // Requires custom implementation
 };
+var STELORDER_CAPABILITIES = {
+  // Profile Management
+  updateProfile: false,
+  updateEmail: false,
+  changePasswordDirect: false,
+  changePasswordViaEmail: false,
+  deleteAccount: false,
+  // Avatar
+  uploadAvatar: false,
+  avatarViaMetadata: false,
+  // Custom Attributes
+  customAttributes: false,
+  // Orders
+  fetchOrders: true,
+  cancelOrder: false,
+  // Addresses
+  manageAddresses: true,
+  defaultAddress: false,
+  // Cart/Checkout
+  applyDiscounts: false,
+  shippingCalculation: false,
+  guestCheckout: false,
+  savedPaymentMethods: false,
+  listPaymentProviders: true,
+  regionSpecificPayments: false,
+  // Wishlist
+  wishlist: false,
+  // Search
+  advancedSearch: false,
+  facetedFilters: false,
+  // Reviews
+  productReviews: false,
+  // Loyalty
+  loyaltyProgram: false
+};
 var SHOPIFY_CAPABILITIES = {
   // Profile Management
   updateProfile: true,
@@ -488,6 +523,9 @@ async function fetchWithRetry(url, init, retryConfig) {
   }
   throw lastError;
 }
+function createFetchWithRetry(retryConfig) {
+  return (url, init) => fetchWithRetry(url, init, retryConfig);
+}
 
 // src/resilience/circuit-breaker.ts
 var CircuitBreaker = class {
@@ -7977,6 +8015,1031 @@ var MagentoProvider = class {
   }
 };
 
+// src/providers/stelorder/transforms.ts
+function normalizeStelCollection(payload) {
+  if (!payload) {
+    return [];
+  }
+  return Array.isArray(payload) ? payload : [payload];
+}
+function normalizeStelEntity(payload) {
+  if (!payload) {
+    return void 0;
+  }
+  return Array.isArray(payload) ? payload[0] : payload;
+}
+function transformStelMoney(amount, currencyCode = "USD") {
+  const normalizedAmount = typeof amount === "string" ? Number.parseFloat(amount) : amount ?? 0;
+  return {
+    amount: Number.isFinite(normalizedAmount) ? normalizedAmount.toFixed(2) : "0.00",
+    currencyCode: currencyCode.toUpperCase()
+  };
+}
+function transformStelImage(url, altText = "") {
+  const normalizedUrl = url?.trim();
+  if (!normalizedUrl) {
+    return void 0;
+  }
+  return {
+    url: normalizedUrl,
+    altText,
+    width: 800,
+    height: 800
+  };
+}
+function normalizeStelDate(value) {
+  if (!value) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : parsed.toISOString();
+}
+function toStelStringId(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return String(value);
+}
+function slugify(value) {
+  return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildStelHandle(...candidates) {
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === void 0) {
+      continue;
+    }
+    const normalized = slugify(String(candidate).trim());
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "stel-item";
+}
+function transformStelProductImages(product) {
+  const images = [];
+  if (!product["item-images"]) {
+    return images;
+  }
+  const sorted = [...product["item-images"]].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  for (const img of sorted) {
+    const transformed = transformStelImage(img["item-image-path"], product.name ?? "");
+    if (transformed) {
+      images.push(transformed);
+    }
+  }
+  return images;
+}
+function deriveStelStockStatus(product) {
+  if (!product["stock-enabled"]) {
+    return "in_stock";
+  }
+  const realStock = product["real-stock"] ?? 0;
+  const minimumStock = product["minimum-stock"] ?? 0;
+  if (realStock <= 0) {
+    return "out_of_stock";
+  }
+  if (realStock <= minimumStock) {
+    return "low_stock";
+  }
+  return "in_stock";
+}
+function buildSyntheticVariant(product, currencyCode) {
+  const price = transformStelMoney(product["sales-price"], currencyCode);
+  const stockStatus = deriveStelStockStatus(product);
+  const quantityAvailable = product["stock-enabled"] ? product["real-stock"] ?? 0 : void 0;
+  const image = product["item-images"]?.[0] ? transformStelImage(product["item-images"][0]["item-image-path"], product.name ?? "") : void 0;
+  return {
+    id: toStelStringId(product.id),
+    title: "Default",
+    sku: product.barcode ?? product["full-reference"] ?? void 0,
+    availableForSale: stockStatus !== "out_of_stock",
+    selectedOptions: [],
+    price,
+    compareAtPrice: void 0,
+    quantityAvailable,
+    stockStatus,
+    image
+  };
+}
+function transformStelProduct(raw, currencyCode) {
+  const id = toStelStringId(raw.id);
+  const handle = buildStelHandle(raw["full-reference"], raw.reference, raw.name, raw.id);
+  const price = transformStelMoney(raw["sales-price"], currencyCode);
+  const images = transformStelProductImages(raw);
+  const variant = buildSyntheticVariant(raw, currencyCode);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id,
+    handle,
+    title: raw.name ?? "",
+    description: raw.description ?? "",
+    availableForSale: variant.availableForSale,
+    options: [],
+    variants: [variant],
+    featuredImage: images[0],
+    images,
+    priceRange: {
+      minVariantPrice: price,
+      maxVariantPrice: price
+    },
+    productType: void 0,
+    vendor: void 0,
+    tags: raw.promotional ? ["promotional"] : [],
+    createdAt: normalizeStelDate(raw["creation-date"]),
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"]) || now,
+    metadata: {
+      stelFullReference: raw["full-reference"],
+      stelReference: raw.reference,
+      stelBarcode: raw.barcode,
+      stelCategoryId: raw["product-category-id"],
+      stelInactive: raw.inactive,
+      stelPromotional: raw.promotional,
+      stelPurchasePrice: raw["purchase-price"]
+    }
+  };
+}
+function transformStelCategory(raw) {
+  const id = toStelStringId(raw.id);
+  const handle = buildStelHandle(raw.slug, raw.name, raw.id);
+  return {
+    id,
+    name: raw.name ?? "",
+    handle,
+    description: raw.description ?? void 0,
+    parentCategoryId: raw["parent-category-id"] ? toStelStringId(raw["parent-category-id"]) : void 0,
+    metadata: {
+      stelSlug: raw.slug
+    }
+  };
+}
+function transformStelCategoryToCollection(raw) {
+  const id = toStelStringId(raw.id);
+  const handle = buildStelHandle(raw.slug, raw.name, raw.id);
+  return {
+    id,
+    handle,
+    title: raw.name ?? "",
+    description: raw.description ?? "",
+    path: `/collections/${handle}`,
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"])
+  };
+}
+function transformStelWarehouseToStockLocation(raw) {
+  return {
+    id: toStelStringId(raw.id),
+    name: raw.name ?? "Warehouse"
+  };
+}
+function transformStelProductWarehouseToInventoryLevel(pw) {
+  return {
+    locationId: toStelStringId(pw["warehouse-id"]),
+    locationName: pw["warehouse-path"] ?? `Warehouse ${pw["warehouse-id"] ?? "unknown"}`,
+    availableQuantity: pw["real-stock"] ?? 0,
+    reservedQuantity: Math.max(0, (pw["virtual-stock"] ?? 0) - (pw["real-stock"] ?? 0)),
+    stockedQuantity: pw["virtual-stock"] ?? pw["real-stock"] ?? 0
+  };
+}
+function splitStelName(fullName) {
+  if (!fullName?.trim()) {
+    return { firstName: "", lastName: "" };
+  }
+  const parts = fullName.trim().split(/\s+/);
+  const firstName = parts[0] ?? "";
+  const lastName = parts.length > 1 ? parts.slice(1).join(" ") : "";
+  return { firstName, lastName };
+}
+function transformStelClient(raw) {
+  const { firstName, lastName } = splitStelName(raw.name ?? raw["business-name"]);
+  return {
+    id: toStelStringId(raw.id),
+    email: raw.email ?? "",
+    firstName: firstName || null,
+    lastName: lastName || null,
+    phone: raw.phone ?? raw.mobile ?? null,
+    hasAccount: true,
+    createdAt: normalizeStelDate(raw["utc-last-modification-date"]),
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"]),
+    metadata: {
+      stelBusinessName: raw["business-name"],
+      stelRateId: raw["rate-id"],
+      stelPaymentOptionId: raw["payment-option-id"],
+      stelPaymentTermId: raw["payment-term-id"],
+      stelDeliveryOptionId: raw["delivery-option-id"]
+    }
+  };
+}
+function deriveStelOrderStatus(raw) {
+  if (raw.deleted) {
+    return "cancelled";
+  }
+  const status = (raw.status ?? "").toLowerCase();
+  if (status.includes("cancel") || status.includes("anulad")) {
+    return "cancelled";
+  }
+  if (status.includes("complet") || status.includes("cerrad") || status.includes("settled")) {
+    return "completed";
+  }
+  if (status.includes("process") || status.includes("confirm")) {
+    return "processing";
+  }
+  return "pending";
+}
+function deriveStelPaymentStatus(raw) {
+  const orderStatus = deriveStelOrderStatus(raw);
+  if (orderStatus === "completed") {
+    return "paid";
+  }
+  if (orderStatus === "cancelled") {
+    return "pending";
+  }
+  return "pending";
+}
+function deriveStelFulfillmentStatus(raw) {
+  const orderStatus = deriveStelOrderStatus(raw);
+  if (orderStatus === "completed") {
+    return "fulfilled";
+  }
+  return "unfulfilled";
+}
+function transformStelDocumentLine(line, index, currencyCode) {
+  const unitPrice = line["item-base-price"] ?? 0;
+  const quantity = line.units ?? 1;
+  const lineTotal = unitPrice * quantity;
+  return {
+    id: toStelStringId(line["item-id"] ?? index),
+    title: line["item-name"] ?? "",
+    variantTitle: void 0,
+    quantity,
+    price: transformStelMoney(unitPrice, currencyCode),
+    total: transformStelMoney(lineTotal, currencyCode),
+    sku: void 0,
+    productId: line["item-id"] ? toStelStringId(line["item-id"]) : void 0
+  };
+}
+function transformStelSalesOrder(raw, currencyCode) {
+  const id = toStelStringId(raw.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const items = (raw["document-lines"] ?? []).filter((line) => line["line-type"] === "ITEM" || !line["line-type"]).map((line, i) => transformStelDocumentLine(line, i, currencyCode));
+  const status = deriveStelOrderStatus(raw);
+  return {
+    id,
+    orderNumber: raw.reference ?? id,
+    email: raw.email ?? "",
+    status,
+    paymentStatus: deriveStelPaymentStatus(raw),
+    fulfillmentStatus: deriveStelFulfillmentStatus(raw),
+    customerId: raw["client-id"] ? toStelStringId(raw["client-id"]) : void 0,
+    items,
+    subtotal: transformStelMoney(raw["total-base"], currencyCode),
+    total: transformStelMoney(raw.total, currencyCode),
+    tax: raw["total-tax"] != null ? transformStelMoney(raw["total-tax"], currencyCode) : void 0,
+    createdAt: normalizeStelDate(raw["creation-date"]),
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"]) || now,
+    cancelledAt: status === "cancelled" ? normalizeStelDate(raw["utc-last-modification-date"]) : void 0,
+    completedAt: status === "completed" ? normalizeStelDate(raw["utc-last-modification-date"]) : void 0,
+    metadata: {
+      stelReference: raw.reference,
+      stelStatus: raw.status,
+      stelPaymentOptionId: raw["payment-option-id"],
+      stelPaymentTermId: raw["payment-term-id"],
+      stelDeliveryOptionId: raw["delivery-option-id"]
+    }
+  };
+}
+function inferPaymentMethodType(name) {
+  if (!name) {
+    return "other";
+  }
+  const lower = name.toLowerCase();
+  if (lower.includes("transfer") || lower.includes("bank") || lower.includes("sepa") || lower.includes("iban")) {
+    return "bank_transfer";
+  }
+  if (lower.includes("card") || lower.includes("tarjeta") || lower.includes("visa") || lower.includes("master")) {
+    return "card";
+  }
+  if (lower.includes("paypal") || lower.includes("wallet") || lower.includes("apple") || lower.includes("google")) {
+    return "wallet";
+  }
+  if (lower.includes("cash") || lower.includes("contrar") || lower.includes("efectivo") || lower.includes("cod")) {
+    return "cash_on_delivery";
+  }
+  if (lower.includes("crypto") || lower.includes("bitcoin")) {
+    return "crypto";
+  }
+  return "other";
+}
+function transformStelPaymentOption(raw) {
+  return {
+    id: toStelStringId(raw.id),
+    name: raw.name ?? "Payment Option",
+    type: inferPaymentMethodType(raw.name),
+    isEnabled: !raw.deleted,
+    requiresSetup: false,
+    description: raw.description ?? void 0,
+    metadata: {
+      stelPath: raw.path,
+      source: "paymentOption"
+    }
+  };
+}
+function transformStelDeliveryOption(raw, currencyCode) {
+  return {
+    id: toStelStringId(raw.id),
+    name: raw.name ?? "Delivery Option",
+    price: transformStelMoney(0, currencyCode),
+    description: raw.description ?? void 0
+  };
+}
+
+// src/providers/stelorder/client.ts
+var DEFAULT_RETRY_CONFIG2 = {
+  maxRetries: 2,
+  initialDelayMs: 300,
+  backoffMultiplier: 2,
+  maxDelayMs: 5e3,
+  timeoutMs: 1e4,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateDelay2(attempt, retryConfig) {
+  const delay = retryConfig.initialDelayMs * Math.pow(retryConfig.backoffMultiplier, attempt);
+  return Math.min(delay, retryConfig.maxDelayMs);
+}
+function isRetryableError2(error, retryConfig) {
+  if (error instanceof ProviderAPIError) {
+    return typeof error.status === "number" && retryConfig.retryableStatusCodes.includes(error.status);
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return error.name === "AbortError" || error.name === "TimeoutError" || message.includes("fetch failed") || message.includes("timeout") || message.includes("econnrefused") || message.includes("etimedout");
+}
+function createRetryingFetch(fetchImplementation, retryConfig, logger2) {
+  return async (url, init) => {
+    let lastError = new Error("Unknown STEL Order request error");
+    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt += 1) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), retryConfig.timeoutMs);
+      try {
+        const response = await fetchImplementation(url, {
+          ...init,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok && retryConfig.retryableStatusCodes.includes(response.status)) {
+          throw new ProviderAPIError(
+            `STEL Order API error: ${response.status} ${response.statusText}`,
+            "stelorder",
+            response.status
+          );
+        }
+        return response;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        lastError = error;
+        if (attempt >= retryConfig.maxRetries || !isRetryableError2(error, retryConfig)) {
+          throw error;
+        }
+        const delay = calculateDelay2(attempt, retryConfig);
+        logger2.warn("STEL request failed, retrying.", {
+          url,
+          attempt: attempt + 1,
+          maxAttempts: retryConfig.maxRetries + 1,
+          nextRetryIn: delay,
+          error: extractErrorMessage(error)
+        });
+        await sleep2(delay);
+      }
+    }
+    throw lastError;
+  };
+}
+async function parseErrorResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  try {
+    if (contentType.includes("application/json")) {
+      const body = await response.json();
+      const message = extractErrorMessage(body);
+      if (message && message !== "An unknown error occurred") {
+        return message;
+      }
+    }
+  } catch {
+  }
+  try {
+    const text = await response.text();
+    if (text.trim()) {
+      return text.trim();
+    }
+  } catch {
+  }
+  return `STEL Order API error: ${response.status} ${response.statusText}`;
+}
+function normalizeStelApiBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim();
+  if (!trimmed) {
+    throw new ConfigurationError("Stel Order baseUrl is required.");
+  }
+  const normalized = trimmed.replace(/\/api\/openapi\.json$/i, "").replace(/\/+$/, "");
+  return normalized.endsWith("/app") ? normalized : `${normalized}/app`;
+}
+var StelOrderClient = class {
+  apiBaseUrl;
+  apiKey;
+  logger;
+  retryConfig;
+  fetchImplementation;
+  constructor(config) {
+    const apiKey = config.apiKey ?? config.publishableKey;
+    if (!apiKey) {
+      throw new ConfigurationError(
+        "Stel Order API key is required. Pass `apiKey` or `publishableKey` to createProvider()."
+      );
+    }
+    this.apiBaseUrl = normalizeStelApiBaseUrl(config.baseUrl);
+    this.apiKey = apiKey;
+    this.logger = createLogger("StelOrderClient", config.debug);
+    this.retryConfig = {
+      ...DEFAULT_RETRY_CONFIG2,
+      ...config.retry
+    };
+    this.fetchImplementation = config.customFetch ? createRetryingFetch(config.customFetch, this.retryConfig, this.logger) : void 0;
+    this.logger.info("Initializing Stel Order client", {
+      apiBaseUrl: this.apiBaseUrl,
+      retryConfig: this.retryConfig
+    });
+  }
+  async list(resource, query) {
+    const payload = await this.request({
+      method: "GET",
+      path: resource,
+      query
+    });
+    return normalizeStelCollection(payload);
+  }
+  async getOne(resource, id, query) {
+    const payload = await this.request({
+      method: "GET",
+      path: `${resource}/${id}`,
+      query
+    });
+    return normalizeStelEntity(payload);
+  }
+  async create(resource, body) {
+    return this.request({
+      method: "POST",
+      path: resource,
+      body
+    });
+  }
+  async update(resource, id, body) {
+    return this.request({
+      method: "PUT",
+      path: `${resource}/${id}`,
+      body
+    });
+  }
+  async remove(resource, id) {
+    await this.request({
+      method: "DELETE",
+      path: `${resource}/${id}`
+    });
+  }
+  buildUrl(path, query) {
+    const normalizedPath = path.replace(/^\/+/, "");
+    const url = new URL(`${this.apiBaseUrl}/${normalizedPath}`);
+    if (!query) {
+      return url.toString();
+    }
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0 || value === null || value === "") {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url.searchParams.set(key, value.map(String).join(","));
+        continue;
+      }
+      url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  buildHeaders(headers, hasBody = false) {
+    const normalizedHeaders = new Headers(headers);
+    normalizedHeaders.set("Accept", "application/json");
+    normalizedHeaders.set("APIKEY", this.apiKey);
+    if (hasBody && !normalizedHeaders.has("Content-Type")) {
+      normalizedHeaders.set("Content-Type", "application/json");
+    }
+    return normalizedHeaders;
+  }
+  async executeFetch(url, init) {
+    if (this.fetchImplementation) {
+      return this.fetchImplementation(url, init);
+    }
+    return fetchWithRetry(url, init, this.retryConfig);
+  }
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const hasBody = options.body !== void 0;
+    this.logger.debug("STEL request", {
+      method: options.method,
+      url
+    });
+    const response = await this.executeFetch(url, {
+      method: options.method,
+      headers: this.buildHeaders(options.headers, hasBody),
+      body: hasBody ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      const message = await parseErrorResponse(response);
+      throw new ProviderAPIError(message, "stelorder", response.status);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    }
+    return await response.text();
+  }
+};
+
+// src/providers/stelorder/index.ts
+var StelOrderProvider = class {
+  name = "stelorder";
+  version = "1.0.0";
+  capabilities = STELORDER_CAPABILITIES;
+  client;
+  logger;
+  currencyCode;
+  storefrontId;
+  companyName;
+  constructor(config) {
+    this.client = new StelOrderClient(config);
+    this.logger = createLogger("StelOrderProvider", config.debug);
+    this.currencyCode = config.currencyCode ?? "USD";
+    this.storefrontId = config.storefrontId ?? "stelorder-primary";
+    this.companyName = config.companyName ?? "Stel Order";
+    this.logger.info("Initializing Stel Order provider", {
+      storefrontId: this.storefrontId,
+      companyName: this.companyName,
+      currencyCode: this.currencyCode
+    });
+  }
+  // ============================================
+  // Product Operations
+  // ============================================
+  async getProduct(handle, _options) {
+    this.logger.debug("getProduct", { handle });
+    try {
+      if (/^\d+$/.test(handle)) {
+        const raw = await this.client.getOne("products", handle);
+        return raw ? transformStelProduct(raw, this.currencyCode) : void 0;
+      }
+      const rawProducts = await this.client.list("products", { limit: 100 });
+      for (const raw of rawProducts) {
+        const productHandle = buildStelHandle(raw["full-reference"], raw.reference, raw.name, raw.id);
+        if (productHandle === handle) {
+          return transformStelProduct(raw, this.currencyCode);
+        }
+      }
+      return void 0;
+    } catch (error) {
+      this.logger.error("getProduct failed", { handle, error });
+      throw this.wrapError("getProduct", error);
+    }
+  }
+  async getProducts(options) {
+    this.logger.debug("getProducts", { options });
+    try {
+      const query = {};
+      if (options?.first) {
+        query.limit = options.first;
+      }
+      if (options?.skip) {
+        query.start = options.skip;
+      }
+      if (typeof options?.after === "number") {
+        query.start = options.after;
+      }
+      if (options?.sortKey) {
+        query.sort = options.reverse ? `-${options.sortKey}` : options.sortKey;
+      }
+      if (options?.categoryIds?.length) {
+        query["product-category-id"] = `in:${options.categoryIds.join(",")}`;
+      }
+      const rawProducts = await this.client.list("products", query);
+      let products = rawProducts.filter((p) => !p.deleted && !p.inactive).map((p) => transformStelProduct(p, this.currencyCode));
+      if (options?.query) {
+        const needle = options.query.toLowerCase();
+        products = products.filter(
+          (p) => p.title.toLowerCase().includes(needle) || p.description.toLowerCase().includes(needle) || p.handle.includes(needle)
+        );
+      }
+      return products;
+    } catch (error) {
+      this.logger.error("getProducts failed", { options, error });
+      throw this.wrapError("getProducts", error);
+    }
+  }
+  async getProductRecommendations(_productId) {
+    return [];
+  }
+  // ============================================
+  // Category Operations
+  // ============================================
+  async getCategory(idOrHandle) {
+    this.logger.debug("getCategory", { idOrHandle });
+    try {
+      if (/^\d+$/.test(idOrHandle)) {
+        const raw = await this.client.getOne("productCategories", idOrHandle);
+        return raw ? transformStelCategory(raw) : void 0;
+      }
+      const rawCategories = await this.client.list("productCategories");
+      for (const raw of rawCategories) {
+        const catHandle = buildStelHandle(raw.slug, raw.name, raw.id);
+        if (catHandle === idOrHandle) {
+          return transformStelCategory(raw);
+        }
+      }
+      return void 0;
+    } catch (error) {
+      this.logger.error("getCategory failed", { idOrHandle, error });
+      throw this.wrapError("getCategory", error);
+    }
+  }
+  async getCategories(options) {
+    this.logger.debug("getCategories", { options });
+    try {
+      if (options?.customFetcher) {
+        return options.customFetcher(options);
+      }
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.parentCategoryId) {
+        query["parent-category-id"] = options.parentCategoryId;
+      }
+      const rawCategories = await this.client.list("productCategories", query);
+      let categories = rawCategories.filter((c) => !c.deleted).map(transformStelCategory);
+      if (options?.query) {
+        const needle = options.query.toLowerCase();
+        categories = categories.filter(
+          (c) => c.name.toLowerCase().includes(needle) || c.handle.includes(needle)
+        );
+      }
+      return categories;
+    } catch (error) {
+      this.logger.error("getCategories failed", { options, error });
+      throw this.wrapError("getCategories", error);
+    }
+  }
+  async getCategoryProducts(handle, options) {
+    this.logger.debug("getCategoryProducts", { handle, options });
+    try {
+      const category = await this.getCategory(handle);
+      if (!category) {
+        return [];
+      }
+      return this.getProducts({
+        categoryIds: [category.id],
+        first: options?.first,
+        sortKey: options?.sortKey,
+        reverse: options?.reverse,
+        after: options?.after
+      });
+    } catch (error) {
+      this.logger.error("getCategoryProducts failed", { handle, error });
+      throw this.wrapError("getCategoryProducts", error);
+    }
+  }
+  // ============================================
+  // Collection Operations (alias categories)
+  // ============================================
+  async getCollection(handle) {
+    this.logger.debug("getCollection", { handle });
+    try {
+      if (/^\d+$/.test(handle)) {
+        const raw = await this.client.getOne("productCategories", handle);
+        return raw ? transformStelCategoryToCollection(raw) : void 0;
+      }
+      const rawCategories = await this.client.list("productCategories");
+      for (const raw of rawCategories) {
+        const catHandle = buildStelHandle(raw.slug, raw.name, raw.id);
+        if (catHandle === handle) {
+          return transformStelCategoryToCollection(raw);
+        }
+      }
+      return void 0;
+    } catch (error) {
+      this.logger.error("getCollection failed", { handle, error });
+      throw this.wrapError("getCollection", error);
+    }
+  }
+  async getCollections(options) {
+    this.logger.debug("getCollections", { options });
+    try {
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      const rawCategories = await this.client.list("productCategories", query);
+      let collections = rawCategories.filter((c) => !c.deleted).map(transformStelCategoryToCollection);
+      if (options?.query) {
+        const needle = options.query.toLowerCase();
+        collections = collections.filter(
+          (c) => c.title.toLowerCase().includes(needle) || c.handle.includes(needle)
+        );
+      }
+      return collections;
+    } catch (error) {
+      this.logger.error("getCollections failed", { options, error });
+      throw this.wrapError("getCollections", error);
+    }
+  }
+  async getCollectionProducts(handle, options) {
+    return this.getCategoryProducts(handle, options);
+  }
+  // ============================================
+  // Inventory Operations
+  // ============================================
+  async getStockLocations(_params) {
+    this.logger.debug("getStockLocations");
+    try {
+      const rawWarehouses = await this.client.list("warehouses");
+      return rawWarehouses.filter((w) => !w.deleted).map(transformStelWarehouseToStockLocation);
+    } catch (error) {
+      this.logger.error("getStockLocations failed", { error });
+      throw this.wrapError("getStockLocations", error);
+    }
+  }
+  async checkInventoryLevels(variantId, _salesChannelId) {
+    this.logger.debug("checkInventoryLevels", { variantId });
+    try {
+      const raw = await this.client.getOne("products", variantId);
+      if (!raw?.["product-warehouses"]?.length) {
+        return [];
+      }
+      return raw["product-warehouses"].map(transformStelProductWarehouseToInventoryLevel);
+    } catch (error) {
+      this.logger.error("checkInventoryLevels failed", { variantId, error });
+      throw this.wrapError("checkInventoryLevels", error);
+    }
+  }
+  validateCartStock(_cartId) {
+    return this.notSupported("validateCartStock");
+  }
+  getFulfillmentOptions(_cartId, _salesChannelId) {
+    return this.notSupported("getFulfillmentOptions");
+  }
+  // ============================================
+  // Cart Operations (unsupported — STEL is ERP, not storefront)
+  // ============================================
+  createCart(_options) {
+    return this.notSupported("createCart");
+  }
+  getCart(_cartId) {
+    return this.notSupported("getCart");
+  }
+  addToCart(_cartId, _lines) {
+    return this.notSupported("addToCart");
+  }
+  removeFromCart(_cartId, _lineIds) {
+    return this.notSupported("removeFromCart");
+  }
+  updateCart(_cartId, _lines) {
+    return this.notSupported("updateCart");
+  }
+  // ============================================
+  // Checkout Operations (unsupported)
+  // ============================================
+  completeCheckout(_cartId) {
+    return this.notSupported("completeCheckout");
+  }
+  getRegionCountries(_regionId) {
+    return this.notSupported("getRegionCountries");
+  }
+  addShippingMethod(_cartId, _methodId) {
+    return this.notSupported("addShippingMethod");
+  }
+  initiatePaymentSession(_cartId, _providerId) {
+    return this.notSupported("initiatePaymentSession");
+  }
+  applyDiscountCode(_cartId, _code) {
+    return this.notSupported("applyDiscountCode");
+  }
+  removeDiscountCode(_cartId, _code) {
+    return this.notSupported("removeDiscountCode");
+  }
+  // ============================================
+  // Payment Methods
+  // ============================================
+  async getPaymentMethods(_options) {
+    this.logger.debug("getPaymentMethods");
+    try {
+      const rawOptions = await this.client.list("paymentOptions");
+      return rawOptions.filter((o) => !o.deleted).map(transformStelPaymentOption);
+    } catch (error) {
+      this.logger.error("getPaymentMethods failed", { error });
+      throw this.wrapError("getPaymentMethods", error);
+    }
+  }
+  // ============================================
+  // Shipping / Delivery Methods
+  // ============================================
+  async getShippingMethods(_cartId) {
+    this.logger.debug("getShippingMethods (delivery options listing)");
+    try {
+      const rawOptions = await this.client.list("deliveryOptions");
+      return rawOptions.filter((o) => !o.deleted).map((o) => transformStelDeliveryOption(o, this.currencyCode));
+    } catch (error) {
+      this.logger.error("getShippingMethods failed", { error });
+      throw this.wrapError("getShippingMethods", error);
+    }
+  }
+  // ============================================
+  // Customer Operations (optional)
+  // ============================================
+  async getCustomer(customerId) {
+    this.logger.debug("getCustomer", { customerId });
+    try {
+      const raw = await this.client.getOne("clients", customerId);
+      return raw ? transformStelClient(raw) : void 0;
+    } catch (error) {
+      this.logger.error("getCustomer failed", { customerId, error });
+      throw this.wrapError("getCustomer", error);
+    }
+  }
+  async getCustomers(options) {
+    this.logger.debug("getCustomers", { options });
+    try {
+      if (options?.customFetcher) {
+        return options.customFetcher(options);
+      }
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.offset) {
+        query.start = options.offset;
+      }
+      const rawClients = await this.client.list("clients", query);
+      let customers = rawClients.filter((c) => !c.deleted).map(transformStelClient);
+      if (options?.search) {
+        const needle = options.search.toLowerCase();
+        customers = customers.filter(
+          (c) => c.email.toLowerCase().includes(needle) || (c.firstName ?? "").toLowerCase().includes(needle) || (c.lastName ?? "").toLowerCase().includes(needle)
+        );
+      }
+      return customers;
+    } catch (error) {
+      this.logger.error("getCustomers failed", { options, error });
+      throw this.wrapError("getCustomers", error);
+    }
+  }
+  async updateCustomer(customerId, data) {
+    this.logger.debug("updateCustomer", { customerId, data });
+    try {
+      const stelPayload = {};
+      if (data.firstName || data.lastName) {
+        stelPayload.name = [data.firstName, data.lastName].filter(Boolean).join(" ");
+      }
+      if (data.email) {
+        stelPayload.email = data.email;
+      }
+      if (data.phone) {
+        stelPayload.phone = data.phone;
+      }
+      const raw = await this.client.update("clients", customerId, stelPayload);
+      return transformStelClient(raw);
+    } catch (error) {
+      this.logger.error("updateCustomer failed", { customerId, error });
+      throw this.wrapError("updateCustomer", error);
+    }
+  }
+  // ============================================
+  // Order Operations (optional)
+  // ============================================
+  async getOrder(orderId) {
+    this.logger.debug("getOrder", { orderId });
+    try {
+      const raw = await this.client.getOne("salesOrders", orderId);
+      return raw ? transformStelSalesOrder(raw, this.currencyCode) : void 0;
+    } catch (error) {
+      this.logger.error("getOrder failed", { orderId, error });
+      throw this.wrapError("getOrder", error);
+    }
+  }
+  async getOrders(options) {
+    this.logger.debug("getOrders", { options });
+    try {
+      if (options?.customFetcher) {
+        return options.customFetcher(options);
+      }
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.offset) {
+        query.start = options.offset;
+      }
+      if (options?.customerId) {
+        query["client-id"] = options.customerId;
+      }
+      const rawOrders = await this.client.list("salesOrders", query);
+      return rawOrders.filter((o) => !o.deleted).map((o) => transformStelSalesOrder(o, this.currencyCode));
+    } catch (error) {
+      this.logger.error("getOrders failed", { options, error });
+      throw this.wrapError("getOrders", error);
+    }
+  }
+  async getAdminOrders(options) {
+    this.logger.debug("getAdminOrders", { options });
+    try {
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.offset) {
+        query.start = options.offset;
+      }
+      const rawOrders = await this.client.list("salesOrders", query);
+      let orders = rawOrders.filter((o) => !o.deleted).map((o) => transformStelSalesOrder(o, this.currencyCode));
+      if (options?.search) {
+        const needle = options.search.toLowerCase();
+        orders = orders.filter(
+          (o) => o.orderNumber.toLowerCase().includes(needle) || o.email.toLowerCase().includes(needle)
+        );
+      }
+      if (options?.status) {
+        const statuses = Array.isArray(options.status) ? options.status : [options.status];
+        orders = orders.filter((o) => statuses.includes(o.status));
+      }
+      return { orders, count: orders.length };
+    } catch (error) {
+      this.logger.error("getAdminOrders failed", { options, error });
+      throw this.wrapError("getAdminOrders", error);
+    }
+  }
+  cancelOrder(_orderId) {
+    return this.notSupported("cancelOrder");
+  }
+  createFulfillment(_orderId, _items) {
+    return this.notSupported("createFulfillment");
+  }
+  createRefund(_orderId, _amount, _reason) {
+    return this.notSupported("createRefund");
+  }
+  // ============================================
+  // Storefront Context
+  // ============================================
+  async getStorefrontContext() {
+    return {
+      id: this.storefrontId,
+      name: this.companyName,
+      platformType: "stelorder",
+      requiresProductScoping: false,
+      currencyCode: this.currencyCode,
+      metadata: {
+        apiBaseUrl: this.client.apiBaseUrl,
+        singleCompany: true,
+        providerVersion: this.version
+      }
+    };
+  }
+  isStorefrontRequired() {
+    return false;
+  }
+  // ============================================
+  // Internal helpers
+  // ============================================
+  notSupported(operation) {
+    return Promise.reject(
+      new ProviderAPIError(
+        `Stel Order does not support \`${operation}\`. STEL is an ERP adapter without cart/checkout/auth capabilities.`,
+        "stelorder",
+        501
+      )
+    );
+  }
+  wrapError(operation, error) {
+    if (error instanceof ProviderAPIError) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new ProviderAPIError(
+      `Stel Order \`${operation}\` failed: ${message}`,
+      "stelorder",
+      500
+    );
+  }
+};
+
 // src/providers/mock/mock.ts
 var FIXTURE_TIMESTAMP = "2026-01-01T00:00:00.000Z";
 var DEFAULT_SITE_URL = "https://mock.thorcommerce.local";
@@ -8996,6 +10059,8 @@ function createProvider(options) {
       return new MockProvider(config);
     case "medusa":
       return new MedusaProvider(config);
+    case "stelorder":
+      return new StelOrderProvider(config);
     case "shopify":
       return new ShopifyProvider(config);
     case "bigcommerce":
@@ -9039,8 +10104,10 @@ export {
   ResourceNotFoundError,
   SHOPIFY_CAPABILITIES,
   SPREE_CAPABILITIES,
+  STELORDER_CAPABILITIES,
   ShopifyProvider,
   SpreeProvider,
+  StelOrderProvider,
   StorefrontConfigError2 as StorefrontConfigError,
   WOOCOMMERCE_CAPABILITIES,
   WooCommerceProvider,
@@ -9049,8 +10116,11 @@ export {
   buildChannelScopeMetadata,
   calculateDistance,
   createBackendMetadataAdapter,
+  createFetchWithRetry,
   createLogger,
   createProvider,
+  extractErrorMessage,
+  fetchWithRetry,
   filterByChannel,
   filterGlobalOnly,
   geocodeAddress,