snowpipe-streaming 1.7.0 → 1.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snowpipe-streaming",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Snowflake Streaming Ingest SDK for Node.js",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -27,11 +27,11 @@
     "typedoc": "^0.28.19"
   },
   "optionalDependencies": {
-    "snowpipe-streaming-linux-x64-gnu": "1.7.0",
-    "snowpipe-streaming-linux-x64-musl": "1.7.0",
-    "snowpipe-streaming-linux-arm64-gnu": "1.7.0",
-    "snowpipe-streaming-linux-arm64-musl": "1.7.0",
-    "snowpipe-streaming-darwin-arm64": "1.7.0",
-    "snowpipe-streaming-win32-x64-msvc": "1.7.0"
+    "snowpipe-streaming-linux-x64-gnu": "1.7.1",
+    "snowpipe-streaming-linux-x64-musl": "1.7.1",
+    "snowpipe-streaming-linux-arm64-gnu": "1.7.1",
+    "snowpipe-streaming-linux-arm64-musl": "1.7.1",
+    "snowpipe-streaming-darwin-arm64": "1.7.1",
+    "snowpipe-streaming-win32-x64-msvc": "1.7.1"
   }
 }

package/src/elastic_channel.js

@@ -43,6 +43,12 @@ class StreamingIngestElasticChannel {
     }
     this._native = nativeChannel;
     this._pendingFutures = pendingFutures;
+    // Per-channel future id counter; the wrapper allocates ids so it can register
+    // the promise before the row becomes ack-eligible. The single-threaded event
+    // loop makes the plain increment safe. The id is a JS number (a safe integer,
+    // exact to 2^53) marshaled to the Rust i64.
+    // Starts at 1; 0 is reserved as the "no future id" sentinel, matching the other SDKs.
+    this._nextFutureId = 1;
   }
 
   /** @returns {string} The channel name (always "ELASTIC") */
@@ -93,10 +99,10 @@ class StreamingIngestElasticChannel {
   /**
    * Append multiple rows into the elastic channel.
    *
-   * The native call is synchronous: it buffers the rows and returns a future id,
-   * which is registered in the shared pending map before returning to the event
-   * loop. The Promise resolves later when the mark-complete callback fires with
-   * the server acknowledgement (or rejects on error / channel invalidation).
+   * The wrapper allocates the future id and registers its promise in the shared
+   * pending map before the synchronous native append, so the ack can never
+   * precede registration. The Promise resolves later when the mark-complete
+   * callback fires with the server acknowledgement (or rejects on error).
    *
    * @param {Object[]} rows - Array of row objects
    * @returns {Promise<void>} Resolves when Snowflake acknowledges the batch
@@ -111,18 +117,13 @@ class StreamingIngestElasticChannel {
     // Empty arrays are validated by the Rust core, which throws a proper error.
     const buffer =
       rows.length === 0 ? Buffer.alloc(0) : serializeRowsToNdjson(rows, this.binaryInputFormat);
-    let futureId;
-    try {
-      futureId = Number(this._native.appendRows(buffer, rows.length));
-    } catch (e) {
-      throw StreamingIngestError.from(e);
-    }
 
-    // Build the promise out-of-line so we can stash {resolve, reject} into the
-    // shared map synchronously — the single-threaded event loop guarantees this
-    // happens-before any queued threadsafe-function callback runs. Map and
-    // resolve are then visible to mark_complete_callback.js (the JS owner of
-    // resolution) and the invalidate-all path on channel teardown.
+    // Allocate the id and register the promise BEFORE the native append, so the
+    // row cannot become ack-eligible before its promise is in the pending map.
+    // Building the promise out-of-line lets us stash {resolve, reject} into the
+    // shared map synchronously; the single-threaded event loop guarantees this
+    // happens-before any queued threadsafe-function callback runs.
+    const futureId = this._nextFutureId++;
     let resolveFn;
     let rejectFn;
     const promise = new Promise((resolve, reject) => {
@@ -132,10 +133,7 @@ class StreamingIngestElasticChannel {
     const previous = this._pendingFutures.get(futureId);
     this._pendingFutures.set(futureId, { resolve: resolveFn, reject: rejectFn });
     if (previous !== undefined) {
-      // Mirrors Java/Python: a duplicate future id from Rust means the SDK
-      // and the core have drifted, which is fatal. Reject the displaced
-      // promise, invalidate the channel, and throw to the caller so the
-      // new promise we just stashed isn't left hanging either.
+      // Monotonic per-channel ids make this a should-never-happen invariant.
       const errMsg = `Duplicate future_id=${futureId} in pendingFutures`;
       const err = new StreamingIngestError("Fatal", errMsg, 500, "Internal Server Error");
       previous.reject(err);
@@ -147,6 +145,14 @@ class StreamingIngestElasticChannel {
       }
       throw err;
     }
+
+    try {
+      this._native.appendRows(buffer, rows.length, futureId);
+    } catch (e) {
+      // Never enqueued (not ack-eligible), so no ack can arrive; drop the promise.
+      this._pendingFutures.delete(futureId);
+      throw StreamingIngestError.from(e);
+    }
     return promise;
   }
 
@@ -162,6 +168,15 @@ class StreamingIngestElasticChannel {
     }
   }
 
+  /**
+   * Wait for this channel to flush.
+   * @param {{timeoutMs?: number}} [options]
+   * @returns {Promise<void>}
+   */
+  async waitForFlush(options) {
+    return callFFI(() => this._native.waitForFlush(options?.timeoutMs));
+  }
+
   /**
    * Get the current status of this channel.
    * @returns {Promise<ChannelStatus>}

package/src/index.d.ts

@@ -380,6 +380,18 @@ export class StreamingIngestElasticChannel {
    */
   initiateFlush(): void;
 
+  /**
+   * Wait for all buffered data in this channel to be flushed to Snowflake.
+   *
+   * @param options - Wait options
+   * @throws StreamingIngestError If waiting for the flush fails
+   * @throws Error If the timeout is reached
+   */
+  waitForFlush(options?: {
+    /** Optional timeout in milliseconds. */
+    timeoutMs?: number;
+  }): Promise<void>;
+
   /**
    * Get the current status of this channel.
    *