@viu/emporix-sdk 2.18.0 → 2.20.0

package/dist/index.js

@@ -12,12 +12,12 @@ import { ProductService } from './chunk-FZMP5NQZ.js';
 export { ProductService } from './chunk-FZMP5NQZ.js';
 import { SegmentService } from './chunk-NE7MIZPR.js';
 export { SegmentService } from './chunk-NE7MIZPR.js';
-import { AvailabilityService } from './chunk-K3VQLW3P.js';
-export { AvailabilityService } from './chunk-K3VQLW3P.js';
+import { AvailabilityService } from './chunk-IVCCGJN5.js';
+export { AvailabilityService } from './chunk-IVCCGJN5.js';
 import { CartService } from './chunk-PAT4CS36.js';
 export { CartService } from './chunk-PAT4CS36.js';
-import { CategoryService } from './chunk-6XND7SYV.js';
-export { CategoryService } from './chunk-6XND7SYV.js';
+import { CategoryService } from './chunk-ZNLHLFQM.js';
+export { CategoryService } from './chunk-ZNLHLFQM.js';
 export { iterateAll } from './chunk-GWJ2U2CP.js';
 import { resolveQuery } from './chunk-S5HEIQDK.js';
 export { resolveQuery } from './chunk-S5HEIQDK.js';
@@ -296,6 +296,47 @@ function createNoopLogger() {
   return new NoopLogger();
 }
 
+// src/core/sse.ts
+function parseFrame(frame) {
+  const ev = { data: "" };
+  const dataLines = [];
+  let saw = false;
+  for (const line of frame.split("\n")) {
+    if (line === "" || line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "data") {
+      dataLines.push(value);
+      saw = true;
+    } else if (field === "event") {
+      ev.event = value;
+      saw = true;
+    } else if (field === "id") {
+      ev.id = value;
+      saw = true;
+    }
+  }
+  if (!saw) return void 0;
+  ev.data = dataLines.join("\n");
+  return ev;
+}
+async function* parseSseStream(chunks) {
+  let buf = "";
+  for await (const chunk of chunks) {
+    buf += chunk.replace(/\r\n/g, "\n");
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) !== -1) {
+      const ev = parseFrame(buf.slice(0, idx));
+      buf = buf.slice(idx + 2);
+      if (ev) yield ev;
+    }
+  }
+  const tail = parseFrame(buf);
+  if (tail) yield tail;
+}
+
 // src/core/http.ts
 var requestSeq = 0;
 function safeJson(text) {
@@ -485,10 +526,72 @@ var HttpClient = class {
       clearTimeout(timer);
     }
   }
+  /**
+   * Open a Server-Sent Events stream (`text/event-stream`) and yield parsed
+   * events. Unlike {@link request}, no overall read budget applies (streams are
+   * long-lived) — only `connectMs` bounds time-to-headers, and the consumer
+   * breaking the iterator aborts the fetch. Like {@link requestRaw}, it does
+   * NOT retry or re-auth on 401; a non-2xx maps to a typed error before the
+   * stream begins.
+   */
+  async *requestStream(o) {
+    const log = this.opts.logger.child({ requestId: `req-${++requestSeq}` });
+    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);
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), this.opts.timeouts.connectMs);
+    const headers = this.buildHeaders(o, token, false);
+    headers["Accept"] = "text/event-stream";
+    let res;
+    try {
+      res = await fetch(url, {
+        method: o.method,
+        headers,
+        signal: controller.signal,
+        ...o.body !== void 0 ? { body: JSON.stringify(o.body) } : {}
+      });
+    } catch (err) {
+      clearTimeout(connectTimer);
+      if (err.name === "AbortError") {
+        throw new EmporixTimeoutError(`${o.method} ${o.path} timed out opening stream`);
+      }
+      throw new EmporixNetworkError(
+        `${o.method} ${o.path} network failure: ${err.message}`
+      );
+    }
+    clearTimeout(connectTimer);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw errorFromResponse(
+        res.status,
+        `${o.method} ${o.path} \u2192 ${res.status}`,
+        text ? safeJson(text) : void 0
+      );
+    }
+    log.debug("http stream open", { status: res.status });
+    if (!res.body) return;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    async function* readChunks() {
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          yield decoder.decode(value, { stream: true });
+        }
+      } finally {
+        controller.abort();
+      }
+    }
+    yield* parseSseStream(readChunks());
+  }
 };
 
 // package.json
-var version = "2.18.0";
+var version = "2.20.0";
 
 // src/version.ts
 var SDK_VERSION = version;
@@ -903,6 +1006,8 @@ var RagIndexerService = class {
    * Schedule a full asynchronous re-index for `type` (default `"PRODUCT"`).
    * Resolves once the rebuild is *scheduled* (HTTP 204); there is no progress
    * to await or poll. Costly — avoid calling on a hot path.
+   * @deprecated since 2026-06-18, removal 2026-12-01 — use the indexing service:
+   * `client.indexing.createReindexJob({ entityType: "PRODUCT", rag: true })`.
    */
   async reindex(type = "PRODUCT", auth2 = SERVICE3) {
     await this.ctx.http.request({
@@ -1505,6 +1610,20 @@ var SchemaService = class {
       body: patch
     });
   }
+  /**
+   * Patch up to 200 custom instances of `type` in one call
+   * (`PATCH /custom-entities/{type}/instances/bulk`). Returns a 207 envelope:
+   * a per-item result array — a 207 is success, individual failures live in
+   * each item's `code`/`status`.
+   */
+  async bulkPatchInstances(type, items, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.instancesBase(type)}/bulk`,
+      auth: auth2,
+      body: items
+    });
+  }
   /** Delete an instance by id. */
   async deleteInstance(type, id, auth2 = SERVICE7) {
     await this.ctx.http.request({
@@ -1640,6 +1759,39 @@ var AiService = class {
       body: input
     });
   }
+  /**
+   * Streaming agent chat (`POST /agentic/chat-stream`, `text/event-stream`).
+   * Yields each SSE `data` payload verbatim — the upstream contract types the
+   * stream body as an opaque string, so chunks are raw strings, not parsed
+   * objects. Consume with `for await`.
+   */
+  async *chatStream(input, opts = {}, auth2 = SERVICE8) {
+    const events = this.ctx.http.requestStream({
+      method: "POST",
+      path: `${this.base()}/agentic/chat-stream`,
+      auth: auth2,
+      body: input,
+      ...opts.sessionId ? { headers: { "session-id": opts.sessionId } } : {}
+    });
+    for await (const ev of events) yield ev.data;
+  }
+  /** List stored agentic conversations (`GET /agentic/conversations`). */
+  async listConversations(auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/agentic/conversations`,
+      auth: auth2
+    });
+  }
+  /** Server-side conversation search (`POST /agentic/conversations/search`). */
+  async searchConversations(query, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/agentic/conversations/search`,
+      auth: auth2,
+      body: query
+    });
+  }
 };
 
 // src/services/tax.ts
@@ -2863,7 +3015,47 @@ var IndexingService = class {
       auth: auth2
     });
   }
-  /** Trigger a reindex. */
+  /**
+   * Create a reindex job (replaces {@link reindex}). A `FULL` reindex of the
+   * given `entityType`; set `rag: true` to also rebuild the RAG vector index
+   * (PRODUCT only). Resolves to the created job (`201`) or, when a job for that
+   * `entityType` is already `IN_PROGRESS`, that running job (`200`).
+   */
+  async createReindexJob(input, auth2 = SERVICE19) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/reindex-jobs`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** List reindex jobs (paginated). */
+  async listReindexJobs(opts = {}, auth2 = SERVICE19) {
+    const pageNumber = opts.pageNumber ?? 1;
+    const pageSize = opts.pageSize ?? 50;
+    const query = { pageNumber, pageSize };
+    if (opts.q !== void 0) query.q = opts.q;
+    const items = await this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/reindex-jobs`,
+      query,
+      auth: auth2
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  /** Fetch one reindex job by id. */
+  async getReindexJob(reindexJobId, auth2 = SERVICE19) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/reindex-jobs/${encodeURIComponent(reindexJobId)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Trigger a reindex.
+   * @deprecated since 2026-06-18, removal 2026-12-01 — use {@link createReindexJob}
+   * (`createReindexJob({ entityType: "PRODUCT" })`), which returns a trackable job.
+   */
   async reindex(input, auth2 = SERVICE19) {
     await this.ctx.http.request({ method: "POST", path: `${this.base()}/reindex`, auth: auth2, body: input });
   }