@ferricstore/ferricstore 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -55,6 +55,7 @@ __export(index_exports, {
   QueueClient: () => QueueClient,
   QueueWorker: () => QueueWorker,
   RawCodec: () => RawCodec,
+  ReconnectingExecutor: () => ReconnectingExecutor,
   SetStore: () => SetStore,
   SortedSetStore: () => SortedSetStore,
   StaleLeaseError: () => StaleLeaseError,
@@ -69,6 +70,7 @@ __export(index_exports, {
   classifyServerError: () => classifyServerError,
   complete: () => complete,
   fail: () => fail,
+  isReconnectableClosedConnectionError: () => isReconnectableClosedConnectionError,
   mapException: () => mapException,
   retry: () => retry,
   transition: () => transition
@@ -1470,15 +1472,21 @@ var NativeAdapter = class _NativeAdapter {
   maxChunkBytes;
   requestId = 0n;
   protocolLanes;
+  heartbeatIntervalMs;
+  heartbeatInFlight = false;
+  heartbeatTimer;
+  lastActivityMs = Date.now();
   timeoutMs;
-  constructor(socket, timeoutMs, protocolLanes, maxChunkBytes) {
+  constructor(socket, timeoutMs, protocolLanes, maxChunkBytes, heartbeatIntervalMs) {
     this.socket = socket;
     this.maxChunkBytes = Math.max(1, Math.trunc(maxChunkBytes));
     this.timeoutMs = timeoutMs;
     this.protocolLanes = Math.max(1, Math.trunc(protocolLanes));
+    this.heartbeatIntervalMs = normalizeHeartbeatInterval(heartbeatIntervalMs);
     this.socket.on("data", (chunk) => this.onData(chunk));
     this.socket.on("error", (error) => this.failAll(error));
     this.socket.on("close", () => this.failAll(new FerricStoreError("FerricStore connection closed")));
+    this.startHeartbeat();
   }
   static async fromUrl(url, options = {}) {
     const parsed = parseFerricUrl(url);
@@ -1487,7 +1495,8 @@ var NativeAdapter = class _NativeAdapter {
       socket,
       options.timeoutMs ?? 3e4,
       options.protocolLanes ?? 8,
-      options.maxChunkBytes ?? 64 * 1024 * 1024
+      options.maxChunkBytes ?? 64 * 1024 * 1024,
+      options.heartbeatIntervalMs
     );
     await adapter.startup(options.clientName);
     const password = options.password ?? parsed.password;
@@ -1511,6 +1520,7 @@ var NativeAdapter = class _NativeAdapter {
       return;
     }
     this.closed = true;
+    this.stopHeartbeat();
     this.socket.end();
   }
   async startup(clientName) {
@@ -1532,6 +1542,7 @@ var NativeAdapter = class _NativeAdapter {
     if (this.closed) {
       throw new FerricStoreError("FerricStore connection is closed");
     }
+    this.lastActivityMs = Date.now();
     const requestId = this.nextRequestId();
     const frame = encodeRequest(this.assignLane(command), requestId);
     return await new Promise((resolve, reject) => {
@@ -1545,10 +1556,12 @@ var NativeAdapter = class _NativeAdapter {
         opcode: command.opcode,
         reject: (reason) => {
           clearTimeout(timer);
+          this.lastActivityMs = Date.now();
           reject(reason instanceof Error ? reason : classifyServerError(String(reason), reason));
         },
         resolve: (value) => {
           clearTimeout(timer);
+          this.lastActivityMs = Date.now();
           resolve(value);
         }
       });
@@ -1557,11 +1570,43 @@ var NativeAdapter = class _NativeAdapter {
           this.pending.delete(requestId);
           this.cleanupChunksForRequest(requestId);
           clearTimeout(timer);
+          this.lastActivityMs = Date.now();
           reject(error);
         }
       });
     });
   }
+  startHeartbeat() {
+    if (this.heartbeatIntervalMs == null) {
+      return;
+    }
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendHeartbeat();
+    }, this.heartbeatIntervalMs);
+    this.heartbeatTimer.unref?.();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer == null) {
+      return;
+    }
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = void 0;
+  }
+  async sendHeartbeat() {
+    if (this.closed || this.heartbeatInFlight || this.pending.size > 0 || this.heartbeatIntervalMs == null) {
+      return;
+    }
+    if (Date.now() - this.lastActivityMs < this.heartbeatIntervalMs) {
+      return;
+    }
+    this.heartbeatInFlight = true;
+    try {
+      await this.request(buildProtocolCommand(["PING"]));
+    } catch {
+    } finally {
+      this.heartbeatInFlight = false;
+    }
+  }
   onData(chunk) {
     try {
       this.buffer = this.buffer.byteLength === 0 ? chunk : import_node_buffer2.Buffer.concat([this.buffer, chunk]);
@@ -1620,6 +1665,7 @@ var NativeAdapter = class _NativeAdapter {
       return;
     }
     this.closed = true;
+    this.stopHeartbeat();
     const error = reason instanceof Error ? reason : classifyServerError(String(reason), reason);
     for (const pending of this.pending.values()) {
       pending.reject(error);
@@ -1652,6 +1698,74 @@ var NativeAdapter = class _NativeAdapter {
     return { ...command, laneId: this.dataLane };
   }
 };
+var ReconnectingExecutor = class {
+  constructor(createExecutor, options = {}) {
+    this.createExecutor = createExecutor;
+    this.maxRetries = Math.max(0, Math.trunc(options.maxRetries ?? 1));
+    this.executorPromise = createExecutor();
+  }
+  createExecutor;
+  closed = false;
+  maxRetries;
+  executorPromise;
+  reconnectPromise;
+  async executeCommand(...args) {
+    return await this.withReconnect((executor) => executor.executeCommand(...args));
+  }
+  async executePipeline(commands, options = {}) {
+    return await this.withReconnect(async (executor) => {
+      if (executor.executePipeline != null) {
+        return await executor.executePipeline(commands, options);
+      }
+      return await Promise.all(commands.map((command) => executor.executeCommand(...command)));
+    });
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    const executor = await this.executorPromise.catch(() => void 0);
+    await Promise.resolve(executor?.close?.());
+  }
+  async withReconnect(operation) {
+    let executor = await this.executorPromise;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await operation(executor);
+      } catch (error) {
+        if (this.closed || attempt >= this.maxRetries || !isReconnectableClosedConnectionError(error)) {
+          throw error;
+        }
+        executor = await this.reconnect(executor);
+      }
+    }
+  }
+  async reconnect(staleExecutor) {
+    if (this.closed) {
+      throw new FerricStoreError("FerricStore client is closed");
+    }
+    if (this.reconnectPromise != null) {
+      return await this.reconnectPromise;
+    }
+    const currentExecutor = await this.executorPromise.catch(() => void 0);
+    if (currentExecutor != null && currentExecutor !== staleExecutor) {
+      return currentExecutor;
+    }
+    this.reconnectPromise = (async () => {
+      await Promise.resolve(staleExecutor.close?.()).catch(() => void 0);
+      const nextExecutor = await this.createExecutor();
+      this.executorPromise = Promise.resolve(nextExecutor);
+      return nextExecutor;
+    })().finally(() => {
+      this.reconnectPromise = void 0;
+    });
+    return await this.reconnectPromise;
+  }
+};
+function isReconnectableClosedConnectionError(error) {
+  return error instanceof Error && error.message === "FerricStore connection is closed";
+}
 function parseFerricUrl(value) {
   const url = new URL(value);
   if (url.protocol !== "ferric:" && url.protocol !== "ferrics:") {
@@ -1675,6 +1789,7 @@ async function connect(parsed, options) {
     }, timeoutMs);
     timer.unref?.();
     socket.setNoDelay(true);
+    socket.setKeepAlive(options.keepAlive ?? true, normalizeKeepAliveInitialDelay(options.keepAliveInitialDelayMs));
     socket.once("connect", () => {
       clearTimeout(timer);
       resolve(socket);
@@ -1685,6 +1800,15 @@ async function connect(parsed, options) {
     });
   });
 }
+function normalizeHeartbeatInterval(value) {
+  if (value != null && value <= 0) {
+    return void 0;
+  }
+  return Math.trunc(value ?? 6e4);
+}
+function normalizeKeepAliveInitialDelay(value) {
+  return Math.max(0, Math.trunc(value ?? 3e4));
+}
 
 // src/codecs.ts
 var RawCodec = class {
@@ -3075,7 +3199,10 @@ var FerricStoreClient = class _FerricStoreClient {
     this.zset = new SortedSetStore(this);
   }
   static async fromUrl(url, options = {}) {
-    return new _FerricStoreClient(await NativeAdapter.fromUrl(url, options.nativeOptions), options);
+    const reconnectOptions = options.reconnect ?? options.nativeOptions?.autoReconnect ?? true;
+    const createExecutor = async () => await NativeAdapter.fromUrl(url, options.nativeOptions);
+    const executor = reconnectOptions === false ? await createExecutor() : new ReconnectingExecutor(createExecutor, reconnectOptions === true ? {} : reconnectOptions);
+    return new _FerricStoreClient(executor, options);
   }
   async command(...args) {
     return await this.executor.executeCommand(...args);
@@ -5198,6 +5325,7 @@ function valueRefToString(value) {
   QueueClient,
   QueueWorker,
   RawCodec,
+  ReconnectingExecutor,
   SetStore,
   SortedSetStore,
   StaleLeaseError,
@@ -5212,6 +5340,7 @@ function valueRefToString(value) {
   classifyServerError,
   complete,
   fail,
+  isReconnectableClosedConnectionError,
   mapException,
   retry,
   transition