@topgunbuild/client 0.2.0 → 0.2.1

package/dist/index.d.mts

@@ -357,6 +357,7 @@ declare class SyncEngine {
     private waitingForCapacity;
     private highWaterMarkEmitted;
     private backpressureListeners;
+    private pendingWriteConcernPromises;
     constructor(config: SyncEngineConfig);
     /**
      * Get the current connection state
@@ -424,6 +425,11 @@ declare class SyncEngine {
     releaseLock(name: string, requestId: string, fencingToken: number): Promise<boolean>;
     private handleServerMessage;
     getHLC(): HLC;
+    /**
+     * Helper method to apply a single server event to the local map.
+     * Used by both SERVER_EVENT and SERVER_BATCH_EVENT handlers.
+     */
+    private applyServerEvent;
     /**
      * Closes the WebSocket connection and cleans up resources.
      */
@@ -514,6 +520,26 @@ declare class SyncEngine {
      * Drop the oldest pending operation (used by 'drop-oldest' strategy).
      */
     private dropOldestOp;
+    /**
+     * Register a pending Write Concern promise for an operation.
+     * The promise will be resolved when the server sends an ACK with the operation result.
+     *
+     * @param opId - Operation ID
+     * @param timeout - Timeout in ms (default: 5000)
+     * @returns Promise that resolves with the Write Concern result
+     */
+    registerWriteConcernPromise(opId: string, timeout?: number): Promise<any>;
+    /**
+     * Resolve a pending Write Concern promise with the server result.
+     *
+     * @param opId - Operation ID
+     * @param result - Result from server ACK
+     */
+    private resolveWriteConcernPromise;
+    /**
+     * Cancel all pending Write Concern promises (e.g., on disconnect).
+     */
+    private cancelAllWriteConcernPromises;
 }
 
 interface ILock {

package/dist/index.d.ts

@@ -357,6 +357,7 @@ declare class SyncEngine {
     private waitingForCapacity;
     private highWaterMarkEmitted;
     private backpressureListeners;
+    private pendingWriteConcernPromises;
     constructor(config: SyncEngineConfig);
     /**
      * Get the current connection state
@@ -424,6 +425,11 @@ declare class SyncEngine {
     releaseLock(name: string, requestId: string, fencingToken: number): Promise<boolean>;
     private handleServerMessage;
     getHLC(): HLC;
+    /**
+     * Helper method to apply a single server event to the local map.
+     * Used by both SERVER_EVENT and SERVER_BATCH_EVENT handlers.
+     */
+    private applyServerEvent;
     /**
      * Closes the WebSocket connection and cleans up resources.
      */
@@ -514,6 +520,26 @@ declare class SyncEngine {
      * Drop the oldest pending operation (used by 'drop-oldest' strategy).
      */
     private dropOldestOp;
+    /**
+     * Register a pending Write Concern promise for an operation.
+     * The promise will be resolved when the server sends an ACK with the operation result.
+     *
+     * @param opId - Operation ID
+     * @param timeout - Timeout in ms (default: 5000)
+     * @returns Promise that resolves with the Write Concern result
+     */
+    registerWriteConcernPromise(opId: string, timeout?: number): Promise<any>;
+    /**
+     * Resolve a pending Write Concern promise with the server result.
+     *
+     * @param opId - Operation ID
+     * @param result - Result from server ACK
+     */
+    private resolveWriteConcernPromise;
+    /**
+     * Cancel all pending Write Concern promises (e.g., on disconnect).
+     */
+    private cancelAllWriteConcernPromises;
 }
 
 interface ILock {

package/dist/index.js

@@ -283,6 +283,8 @@ var SyncEngine = class {
     this.waitingForCapacity = [];
     this.highWaterMarkEmitted = false;
     this.backpressureListeners = /* @__PURE__ */ new Map();
+    // Write Concern state (Phase 5.01)
+    this.pendingWriteConcernPromises = /* @__PURE__ */ new Map();
     this.nodeId = config.nodeId;
     this.serverUrl = config.serverUrl;
     this.storageAdapter = config.storageAdapter;
@@ -684,6 +686,22 @@ var SyncEngine = class {
   }
   async handleServerMessage(message) {
     switch (message.type) {
+      case "BATCH": {
+        const batchData = message.data;
+        const view = new DataView(batchData.buffer, batchData.byteOffset, batchData.byteLength);
+        let offset = 0;
+        const count = view.getUint32(offset, true);
+        offset += 4;
+        for (let i = 0; i < count; i++) {
+          const msgLen = view.getUint32(offset, true);
+          offset += 4;
+          const msgData = batchData.slice(offset, offset + msgLen);
+          offset += msgLen;
+          const innerMsg = (0, import_core.deserialize)(msgData);
+          await this.handleServerMessage(innerMsg);
+        }
+        break;
+      }
       case "AUTH_REQUIRED":
         this.sendAuth();
         break;
@@ -715,8 +733,18 @@ var SyncEngine = class {
         this.authToken = null;
         break;
       case "OP_ACK": {
-        const { lastId } = message.payload;
-        logger.info({ lastId }, "Received ACK for ops");
+        const { lastId, achievedLevel, results } = message.payload;
+        logger.info({ lastId, achievedLevel, hasResults: !!results }, "Received ACK for ops");
+        if (results && Array.isArray(results)) {
+          for (const result of results) {
+            const op = this.opLog.find((o) => o.id === result.opId);
+            if (op && !op.synced) {
+              op.synced = true;
+              logger.debug({ opId: result.opId, achievedLevel: result.achievedLevel, success: result.success }, "Op ACK with Write Concern");
+            }
+            this.resolveWriteConcernPromise(result.opId, result);
+          }
+        }
         let maxSyncedId = -1;
         let ackedCount = 0;
         this.opLog.forEach((op) => {
@@ -777,18 +805,20 @@ var SyncEngine = class {
       }
       case "SERVER_EVENT": {
         const { mapName, eventType, key, record, orRecord, orTag } = message.payload;
-        const localMap = this.maps.get(mapName);
-        if (localMap) {
-          if (localMap instanceof import_core.LWWMap && record) {
-            localMap.merge(key, record);
-            await this.storageAdapter.put(`${mapName}:${key}`, record);
-          } else if (localMap instanceof import_core.ORMap) {
-            if (eventType === "OR_ADD" && orRecord) {
-              localMap.apply(key, orRecord);
-            } else if (eventType === "OR_REMOVE" && orTag) {
-              localMap.applyTombstone(orTag);
-            }
-          }
+        await this.applyServerEvent(mapName, eventType, key, record, orRecord, orTag);
+        break;
+      }
+      case "SERVER_BATCH_EVENT": {
+        const { events } = message.payload;
+        for (const event of events) {
+          await this.applyServerEvent(
+            event.mapName,
+            event.eventType,
+            event.key,
+            event.record,
+            event.orRecord,
+            event.orTag
+          );
         }
         break;
       }
@@ -991,6 +1021,25 @@ var SyncEngine = class {
   getHLC() {
     return this.hlc;
   }
+  /**
+   * Helper method to apply a single server event to the local map.
+   * Used by both SERVER_EVENT and SERVER_BATCH_EVENT handlers.
+   */
+  async applyServerEvent(mapName, eventType, key, record, orRecord, orTag) {
+    const localMap = this.maps.get(mapName);
+    if (localMap) {
+      if (localMap instanceof import_core.LWWMap && record) {
+        localMap.merge(key, record);
+        await this.storageAdapter.put(`${mapName}:${key}`, record);
+      } else if (localMap instanceof import_core.ORMap) {
+        if (eventType === "OR_ADD" && orRecord) {
+          localMap.apply(key, orRecord);
+        } else if (eventType === "OR_REMOVE" && orTag) {
+          localMap.applyTombstone(orTag);
+        }
+      }
+    }
+  }
   /**
    * Closes the WebSocket connection and cleans up resources.
    */
@@ -1005,6 +1054,7 @@ var SyncEngine = class {
       this.websocket.close();
       this.websocket = null;
     }
+    this.cancelAllWriteConcernPromises(new Error("SyncEngine closed"));
     this.stateMachine.transition("DISCONNECTED" /* DISCONNECTED */);
     logger.info("SyncEngine closed");
   }
@@ -1325,6 +1375,58 @@ var SyncEngine = class {
       });
     }
   }
+  // ============================================
+  // Write Concern Methods (Phase 5.01)
+  // ============================================
+  /**
+   * Register a pending Write Concern promise for an operation.
+   * The promise will be resolved when the server sends an ACK with the operation result.
+   *
+   * @param opId - Operation ID
+   * @param timeout - Timeout in ms (default: 5000)
+   * @returns Promise that resolves with the Write Concern result
+   */
+  registerWriteConcernPromise(opId, timeout = 5e3) {
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingWriteConcernPromises.delete(opId);
+        reject(new Error(`Write Concern timeout for operation ${opId}`));
+      }, timeout);
+      this.pendingWriteConcernPromises.set(opId, {
+        resolve,
+        reject,
+        timeoutHandle
+      });
+    });
+  }
+  /**
+   * Resolve a pending Write Concern promise with the server result.
+   *
+   * @param opId - Operation ID
+   * @param result - Result from server ACK
+   */
+  resolveWriteConcernPromise(opId, result) {
+    const pending = this.pendingWriteConcernPromises.get(opId);
+    if (pending) {
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle);
+      }
+      pending.resolve(result);
+      this.pendingWriteConcernPromises.delete(opId);
+    }
+  }
+  /**
+   * Cancel all pending Write Concern promises (e.g., on disconnect).
+   */
+  cancelAllWriteConcernPromises(error) {
+    for (const [opId, pending] of this.pendingWriteConcernPromises.entries()) {
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle);
+      }
+      pending.reject(error);
+    }
+    this.pendingWriteConcernPromises.clear();
+  }
 };
 
 // src/TopGunClient.ts