@viu/emporix-sdk 1.0.0 → 2.1.0

package/dist/index.cjs

@@ -634,6 +634,57 @@ var HttpClient = class {
       throw errorFromResponse(res.status, `${o.method} ${o.path} \u2192 ${res.status}`, parsed);
     }
   }
+  /**
+   * Single-shot fetch that returns the raw {@link Response} unparsed. Used by
+   * endpoints whose responses are not JSON (binary downloads, redirect-only
+   * endpoints). Skips the retry-on-5xx and 401-reauth-once paths intentionally
+   * — those depend on parsing the JSON error body, which a raw consumer must
+   * handle itself if needed. Auth resolution + timeout + logging are still
+   * applied.
+   *
+   * `extra.redirect` is forwarded to `fetch` so callers can use `'manual'` to
+   * capture 30x responses with their `Location` header (Node fetch exposes
+   * the header in this mode; browser fetch returns an opaque response).
+   */
+  async requestRaw(o, extra) {
+    const requestId = `req-${++requestSeq}`;
+    const log = this.opts.logger.child({ requestId });
+    const url = new URL(this.opts.host + o.path);
+    for (const [k, v] of Object.entries(o.query ?? {})) {
+      if (v !== void 0) url.searchParams.set(k, String(v));
+    }
+    const token = await resolveToken(o.auth, this.opts.provider);
+    log.debug("http requestRaw", {
+      authKind: o.auth.kind,
+      method: o.method,
+      url: url.pathname,
+      redirect: extra?.redirect ?? "follow"
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      o.timeoutMs ?? this.opts.timeouts.readMs
+    );
+    const isFormData = typeof FormData !== "undefined" && o.body instanceof FormData;
+    const init = {
+      method: o.method,
+      headers: {
+        ...o.headers ?? {},
+        Authorization: `Bearer ${token}`,
+        ...o.body !== void 0 && !isFormData ? { "Content-Type": "application/json" } : {}
+      },
+      signal: controller.signal,
+      ...extra?.redirect ? { redirect: extra.redirect } : {}
+    };
+    if (o.body !== void 0) {
+      init.body = isFormData ? o.body : JSON.stringify(o.body);
+    }
+    try {
+      return await fetch(url, init);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
 };
 
 // src/core/require-customer.ts
@@ -945,6 +996,29 @@ var ProductService = class {
     );
     return pages.flat();
   }
+  /**
+   * Streams the VARIANT children of a PARENT_VARIANT product, page by page,
+   * via the search query `productType:VARIANT parentVariantId:<id>`. Default
+   * pageSize 200. The query syntax (space-separated fields = implicit AND) is
+   * encapsulated here so consumers don't build it themselves.
+   */
+  listVariantChildrenAll(parentVariantId, params = {}, auth2 = ANON) {
+    const pageSize = params.pageSize ?? 200;
+    const q = `productType:VARIANT parentVariantId:${parentVariantId}`;
+    return iterateAll((pageNumber) => this.search(q, { pageNumber, pageSize }, auth2));
+  }
+  /**
+   * Resolves ALL VARIANT children of a PARENT_VARIANT product into a flat
+   * array (loads every page). Default pageSize 200. Returns `[]` when there are
+   * no children — never throws.
+   */
+  async listVariantChildren(parentVariantId, params = {}, auth2 = ANON) {
+    const out = [];
+    for await (const child of this.listVariantChildrenAll(parentVariantId, params, auth2)) {
+      out.push(child);
+    }
+    return out;
+  }
 };
 
 // src/services/category.ts
@@ -1311,6 +1385,50 @@ var PriceService = class {
       body: input
     });
   }
+  /**
+   * Chunked variant of {@link matchByContext} for large `items` arrays. The
+   * Emporix backend handles only a limited number of items per request
+   * (production limit ~50), so this splits `input.items` into chunks and runs
+   * `matchByContext` with bounded concurrency.
+   *
+   * By default a failing chunk is skipped (its items are absent from the
+   * result) and `opts.onChunkError` is called once for it; pass
+   * `throwOnAnyChunkError: true` to reject on the first failure instead.
+   *
+   * **Result order is not guaranteed** — match entries back to your items by
+   * `priceId` / `itemRef.id`.
+   */
+  async matchByContextChunked(input, opts = {}, auth2) {
+    const chunkSize = opts.chunkSize ?? 50;
+    const concurrency = opts.concurrency ?? 4;
+    if (chunkSize < 1) throw new Error("chunkSize must be >= 1");
+    if (concurrency < 1) throw new Error("concurrency must be >= 1");
+    const items = input.items ?? [];
+    if (items.length === 0) return [];
+    const chunks = [];
+    for (let i = 0; i < items.length; i += chunkSize) {
+      chunks.push({ ...input, items: items.slice(i, i + chunkSize) });
+    }
+    const results = new Array(chunks.length);
+    let cursor = 0;
+    const worker = async () => {
+      for (; ; ) {
+        const idx = cursor++;
+        const chunk = chunks[idx];
+        if (chunk === void 0) return;
+        try {
+          results[idx] = await this.matchByContext(chunk, auth2);
+        } catch (err) {
+          if (opts.throwOnAnyChunkError) throw err;
+          results[idx] = [];
+          opts.onChunkError?.(err, idx);
+        }
+      }
+    };
+    const workerCount = Math.min(concurrency, chunks.length);
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    return results.flat();
+  }
 };
 
 // src/services/media.ts
@@ -1346,14 +1464,29 @@ var MediaService = class {
       body: input.body
     });
   }
-  /** List assets. Optional `query` is passed through to Emporix verbatim. */
-  async list(query, auth2 = SERVICE2) {
-    return this.ctx.http.request({
+  /**
+   * List assets, wrapped in the shared {@link PaginatedItems} envelope so
+   * callers can iterate over pages consistently with the rest of the SDK.
+   * `hasNextPage` is the standard SDK heuristic: `true` when the returned
+   * page is full (`items.length === requested pageSize`). Pagination
+   * defaults match Emporix's server defaults (`pageNumber: 1`,
+   * `pageSize: 60`) so an empty `query` produces stable expectations.
+   */
+  async list(query = {}, auth2 = SERVICE2) {
+    const pageNumber = query.pageNumber ?? 1;
+    const pageSize = query.pageSize ?? 60;
+    const items = await this.ctx.http.request({
       method: "GET",
       path: this.base(),
       auth: auth2,
-      ...query ? { query } : {}
+      query: { ...query, pageNumber, pageSize }
     });
+    return {
+      items,
+      pageNumber,
+      pageSize,
+      hasNextPage: items.length === pageSize
+    };
   }
   /** Fetch an asset by id. */
   async get(assetId, auth2 = SERVICE2) {
@@ -1363,13 +1496,37 @@ var MediaService = class {
       auth: auth2
     });
   }
-  /** Update an asset (e.g. swap `refIds` or `access`). */
-  async update(assetId, patch, auth2 = SERVICE2) {
+  /**
+   * Update an asset. The input is a discriminated union mirroring
+   * {@link create}:
+   * - `{ kind: "json", body }` — metadata-only patch (BLOB or LINK).
+   *   Sends `application/json`. Used for `refIds`, `details`, `metadata`,
+   *   or `url` changes.
+   * - `{ kind: "blob", file, body }` — replaces the BLOB file content
+   *   (max 10MB) AND patches metadata in the same request. Sends
+   *   `multipart/form-data`.
+   *
+   * `type` and `access` are immutable per Emporix — they must match the
+   * existing asset's values. Optimistic-locking is via `body.metadata.version`;
+   * the server returns 409 Conflict on a stale version.
+   */
+  async update(assetId, input, auth2 = SERVICE2) {
+    if (input.kind === "blob") {
+      const fd = new FormData();
+      fd.set("file", input.file);
+      fd.set("body", JSON.stringify(input.body));
+      return this.ctx.http.request({
+        method: "PUT",
+        path: `${this.base()}/${assetId}`,
+        auth: auth2,
+        body: fd
+      });
+    }
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/${assetId}`,
       auth: auth2,
-      body: patch
+      body: input.body
     });
   }
   /** Remove an asset. */
@@ -1380,6 +1537,72 @@ var MediaService = class {
       auth: auth2
     });
   }
+  /**
+   * Download an asset by id. Returns a discriminated union:
+   * - `{ kind: "redirect", url }` for `PUBLIC` assets (server-side 30x with
+   *   the storage URL in `Location`).
+   * - `{ kind: "bytes", data }` for `PRIVATE` assets (server-side 200 with
+   *   the asset bytes; `etag` + `contentType` headers are exposed for
+   *   caching). When the server reports `text/plain` Content-Type (the
+   *   OpenAPI-documented format), the SDK decodes the base64 stream into
+   *   an `ArrayBuffer` transparently; binary Content-Types are passed
+   *   through verbatim.
+   *
+   * Implementation note: uses `redirect: "manual"` so the redirect-location
+   * is observable. In Node.js this works; in a browser the redirect Location
+   * is intentionally hidden by fetch — there, `PUBLIC` downloads will
+   * surface as an opaque-redirect and the SDK throws. Browser code should
+   * use the asset's `url` field from `get()` for `LINK` assets, or the
+   * direct storage URL for `PUBLIC` `BLOB` assets (typically delivered via
+   * an `<img>` tag rather than `download()`).
+   */
+  async download(assetId, auth2 = SERVICE2) {
+    const path = `${this.base()}/${assetId}/download`;
+    const res = await this.ctx.http.requestRaw(
+      { method: "GET", path, auth: auth2 },
+      { redirect: "manual" }
+    );
+    if (res.status >= 300 && res.status < 400) {
+      const url = res.headers.get("location");
+      if (!url) {
+        throw new EmporixError(
+          `media.download: ${res.status} response without a Location header`,
+          res.status
+        );
+      }
+      return { kind: "redirect", url };
+    }
+    if (res.ok) {
+      const etag = res.headers.get("etag") ?? void 0;
+      const contentType = res.headers.get("content-type") ?? void 0;
+      let data;
+      if (contentType?.startsWith("text/plain")) {
+        const text2 = await res.text();
+        const bin = atob(text2);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i);
+        data = arr.buffer;
+      } else {
+        data = await res.arrayBuffer();
+      }
+      return {
+        kind: "bytes",
+        data,
+        ...etag !== void 0 ? { etag } : {},
+        ...contentType !== void 0 ? { contentType } : {}
+      };
+    }
+    const text = await res.text();
+    let parsed = void 0;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    throw errorFromResponse(res.status, `GET ${path} \u2192 ${res.status}`, parsed);
+  }
   /** Multipart upload sugar: builds `AssetCreateBlob` from input. */
   async uploadFile(input, auth2 = SERVICE2) {
     const body = {
@@ -1395,6 +1618,27 @@ var MediaService = class {
     };
     return this.create({ kind: "blob", file: input.file, body }, auth2);
   }
+  /**
+   * Replace the file content of an existing BLOB asset. Sugar over
+   * {@link update} with `kind: "blob"`. `access` is required because the
+   * field is immutable and the server validates that the patch matches.
+   * Pass `version` from `asset.metadata.version` if you want optimistic
+   * locking (recommended when concurrent writers are possible).
+   */
+  async replaceFile(assetId, input, auth2 = SERVICE2) {
+    const body = {
+      type: "BLOB",
+      access: input.access,
+      ...input.filename || input.mimeType ? {
+        details: {
+          ...input.filename ? { filename: input.filename } : {},
+          ...input.mimeType ? { mimeType: input.mimeType } : {}
+        }
+      } : {},
+      ...input.version !== void 0 ? { metadata: { version: input.version } } : {}
+    };
+    return this.update(assetId, { kind: "blob", file: input.file, body }, auth2);
+  }
   /** External-URL sugar: builds `AssetCreateLink`. */
   async link(input, auth2 = SERVICE2) {
     const body = {
@@ -1412,7 +1656,7 @@ var MediaService = class {
     if (refIds.some((r) => isProductRef(r, productId))) return a;
     const next = [...refIds, { type: "PRODUCT", id: productId }];
     const patch = { type: a.type, refIds: next };
-    return this.update(assetId, patch, auth2);
+    return this.update(assetId, { kind: "json", body: patch }, auth2);
   }
   /** Remove a PRODUCT refId from an asset (no-op if absent). */
   async detachFromProduct(assetId, productId, auth2 = SERVICE2) {
@@ -1421,7 +1665,7 @@ var MediaService = class {
     const next = refIds.filter((r) => !isProductRef(r, productId));
     if (next.length === refIds.length) return a;
     const patch = { type: a.type, refIds: next };
-    return this.update(assetId, patch, auth2);
+    return this.update(assetId, { kind: "json", body: patch }, auth2);
   }
   /** Convenience: list assets attached to a product (server-side filter). */
   async listForProduct(productId, auth2 = SERVICE2) {
@@ -1933,6 +2177,61 @@ var SalesOrdersService = class {
   }
 };
 
+// src/services/availability.ts
+var ANON6 = { kind: "anonymous" };
+var AvailabilityService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /**
+   * Single product. Resolves the availability record, or — when
+   * `opts.defaultAvailableOnNotFound` is set — a default available record on 404.
+   */
+  async get(productId, siteCode, auth2 = ANON6, opts = {}) {
+    try {
+      return await this.ctx.http.request({
+        method: "GET",
+        path: `/availability/${this.ctx.tenant}/availability/${encodeURIComponent(
+          productId
+        )}/${encodeURIComponent(siteCode)}`,
+        auth: auth2
+      });
+    } catch (err) {
+      if (err instanceof EmporixNotFoundError && opts.defaultAvailableOnNotFound) {
+        return { productId, site: siteCode, available: true };
+      }
+      throw err;
+    }
+  }
+  /**
+   * Batch read via `POST .../availability/search` (one request). Products with
+   * no availability record are absent from the response; each is synthesized as
+   * `{ available: false }` (or `{ available: true }` when
+   * `opts.defaultAvailableOnNotFound` is set). The result preserves input order
+   * and length. An empty `productIds` resolves to `[]` without a request.
+   */
+  async getMany(productIds, siteCode, auth2 = ANON6, opts = {}) {
+    if (productIds.length === 0) return [];
+    const found = await this.ctx.http.request({
+      method: "POST",
+      path: `/availability/${this.ctx.tenant}/availability/search`,
+      auth: auth2,
+      query: { site: siteCode, pageSize: productIds.length },
+      body: productIds
+    });
+    const byId = /* @__PURE__ */ new Map();
+    for (const a of found) if (a.productId) byId.set(a.productId, a);
+    return productIds.map(
+      (id) => byId.get(id) ?? {
+        productId: id,
+        site: siteCode,
+        available: Boolean(opts.defaultAvailableOnNotFound)
+      }
+    );
+  }
+};
+
 // src/client.ts
 var SDK_VERSION = "0.0.0";
 var EmporixClient = class {
@@ -1953,6 +2252,7 @@ var EmporixClient = class {
   customerGroups;
   orders;
   salesOrders;
+  availability;
   /** The validated tenant this client is bound to. */
   tenant;
   /**
@@ -2022,6 +2322,7 @@ var EmporixClient = class {
     this.customerGroups = new CustomerGroupsService(mk("iam"));
     this.orders = new OrdersService(mk("orders"));
     this.salesOrders = new SalesOrdersService(mk("sales-orders"));
+    this.availability = new AvailabilityService(mk("availability"));
   }
   /** Sets the runtime log level globally or for one service. */
   setLogLevel(level, opts = {}) {
@@ -2033,6 +2334,7 @@ var EmporixClient = class {
   }
 };
 
+exports.AvailabilityService = AvailabilityService;
 exports.CartService = CartService;
 exports.CategoryService = CategoryService;
 exports.CheckoutService = CheckoutService;