@viu/emporix-sdk 4.8.0 → 4.9.1

package/dist/index.js

@@ -948,7 +948,7 @@ var HttpClient = class {
 };
 
 // package.json
-var version = "4.8.0";
+var version = "4.9.1";
 
 // src/version.ts
 var SDK_VERSION = version;
@@ -5001,6 +5001,103 @@ var ImportService = class {
       auth: auth2
     });
   }
+  // ─── File queue (upstream release 2026-10-28) ──────────────────────────────
+  /**
+   * A file-based stream's queue: what it still has to import, in load order,
+   * and the files it already dealt with, newest first. `historyLimit` caps
+   * `history` only (1–500, default 100); `pending` comes back whole up to 2000
+   * files — see {@link ImportFileQueue}.
+   */
+  async listStreamFiles(streamId, opts = {}, auth2 = SERVICE23) {
+    const query = {};
+    if (opts.historyLimit !== void 0) query.historyLimit = opts.historyLimit;
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/streams/${encodeURIComponent(streamId)}/files`,
+      query,
+      auth: auth2
+    });
+  }
+  /**
+   * Queue a delimited file (CSV or one of its variants) for a file-based
+   * stream's next run. Nothing is imported by this call — trigger a run for
+   * that.
+   *
+   * `fileName` is required: the service displays it and infers the compression
+   * from it, and a bare `Blob` would otherwise arrive named «blob».
+   *
+   * The service recognises a file by the SHA-256 of its content, whatever its
+   * name, and answers `409` when the stream already imported or queued those
+   * bytes; a file that previously `FAILED` is accepted again. It also answers
+   * `409` when the stream does not read files, or when a run in flight uses
+   * bytes this upload would replace. `413`: the file is over the limit from
+   * {@link getStreamFileLimits}. `503`: uploading is not configured in this
+   * environment.
+   *
+   * Not retried on a 5xx: a request that timed out may have queued the file,
+   * and sending it again would then answer `409`. Check {@link listStreamFiles}
+   * instead.
+   */
+  async uploadStreamFile(streamId, file, fileName, auth2 = SERVICE23) {
+    const fd = new FormData();
+    fd.set("file", file, fileName);
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/streams/${encodeURIComponent(streamId)}/files`,
+      body: fd,
+      auth: auth2
+    });
+  }
+  /**
+   * The largest file this environment accepts, and whether uploading is
+   * available at all — check it to refuse an oversize file before sending it.
+   *
+   * When `gatewayLimited` is `true`, a larger file is refused by the API gateway
+   * with the gateway's own `413` body, before it reaches the service. Publish
+   * such a file at an HTTP(S) URL and set it as the connection's file URL
+   * instead.
+   */
+  async getStreamFileLimits(streamId, auth2 = SERVICE23) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/streams/${encodeURIComponent(streamId)}/files/limits`,
+      auth: auth2
+    });
+  }
+  /**
+   * Set the order in which a stream's waiting files are read, and resolve to
+   * the queue in that order. For an `INCREMENTAL` feed the order is the data: a
+   * later file's values win on a key an earlier one also carries, so place an
+   * older export first.
+   *
+   * Takes **every** waiting file's id, in load order — not a single file to
+   * move. A list that is not exactly the waiting set answers `400`. `409` means
+   * the job has a run in flight, or the queue is too long to reorder (the
+   * queue's `pendingTruncated`).
+   */
+  async setStreamFileOrder(streamId, fileIds, auth2 = SERVICE23) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/streams/${encodeURIComponent(streamId)}/files/order`,
+      body: fileIds,
+      auth: auth2
+    });
+  }
+  /**
+   * Remove a waiting file from the queue and delete its stored bytes.
+   *
+   * Only a `PENDING` file can go: a file a run has claimed or already imported
+   * answers `409`, and so does any file while the job has a run in flight. An
+   * imported file stays in the history on purpose — removing it would make the
+   * same bytes importable again.
+   */
+  async deleteStreamFile(streamId, fileId, auth2 = SERVICE23) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/streams/${encodeURIComponent(streamId)}/files/${encodeURIComponent(fileId)}`,
+      auth: auth2
+    });
+  }
 };
 
 // src/services/audit-log.ts