@topgunbuild/client 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -232,6 +232,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;
@@ -633,6 +635,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 = deserialize(msgData);
+          await this.handleServerMessage(innerMsg);
+        }
+        break;
+      }
       case "AUTH_REQUIRED":
         this.sendAuth();
         break;
@@ -664,8 +682,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) => {
@@ -726,18 +754,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 LWWMap && record) {
-            localMap.merge(key, record);
-            await this.storageAdapter.put(`${mapName}:${key}`, record);
-          } else if (localMap instanceof 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;
       }
@@ -940,6 +970,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 LWWMap && record) {
+        localMap.merge(key, record);
+        await this.storageAdapter.put(`${mapName}:${key}`, record);
+      } else if (localMap instanceof 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.
    */
@@ -954,6 +1003,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");
   }
@@ -1274,6 +1324,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