@viu/emporix-sdk 1.0.0 → 2.0.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
@@ -1346,14 +1397,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 +1429,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 +1470,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 +1551,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 +1589,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 +1598,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) {