lakesync 0.1.8 → 0.2.0

package/dist/client.js

@@ -6,7 +6,7 @@ import {
   decodeSyncResponse,
   encodeSyncPull,
   encodeSyncPush
-} from "./chunk-KVSWLIJR.js";
+} from "./chunk-YHYBLU6W.js";
 import {
   Err,
   HLC,
@@ -22,7 +22,7 @@ import {
   quoteIdentifier,
   toError,
   unwrapOrThrow
-} from "./chunk-LDFFCG2K.js";
+} from "./chunk-4SG66H5K.js";
 import "./chunk-DGUM43GV.js";
 
 // ../client/src/db/local-db.ts
@@ -654,7 +654,7 @@ var ActionProcessor = class {
    */
   async enqueue(params) {
     const hlc = this.hlc.now();
-    const { generateActionId } = await import("./src-ROW4XLO7.js");
+    const { generateActionId } = await import("./src-WU7IBVC4.js");
     const actionId = await generateActionId({
       clientId: this.clientId,
       hlc,
@@ -1001,6 +1001,36 @@ var AutoSyncScheduler = class {
   }
 };
 
+// ../client/src/sync/strategy.ts
+var PullFirstStrategy = class {
+  async execute(ctx) {
+    if (ctx.syncMode !== "pushOnly") {
+      if (ctx.isFirstSync) {
+        await ctx.initialSync();
+      }
+      await ctx.pull();
+    }
+    if (ctx.syncMode !== "pullOnly") {
+      await ctx.push();
+    }
+    await ctx.processActions();
+  }
+};
+var PushFirstStrategy = class {
+  async execute(ctx) {
+    if (ctx.syncMode !== "pullOnly") {
+      await ctx.push();
+    }
+    if (ctx.syncMode !== "pushOnly") {
+      if (ctx.isFirstSync) {
+        await ctx.initialSync();
+      }
+      await ctx.pull();
+    }
+    await ctx.processActions();
+  }
+};
+
 // ../client/src/sync/tracker.ts
 function rowWithoutId(row) {
   const result = {};
@@ -1204,6 +1234,10 @@ var SyncCoordinator = class {
   lastSyncedHlc = HLC.encode(0, 0);
   _lastSyncTime = null;
   syncing = false;
+  _online = true;
+  onlineHandler = null;
+  offlineHandler = null;
+  strategy;
   autoSyncScheduler;
   actionProcessor;
   listeners = {
@@ -1221,6 +1255,7 @@ var SyncCoordinator = class {
     this._clientId = config?.clientId ?? `client-${crypto.randomUUID()}`;
     this.maxRetries = config?.maxRetries ?? 10;
     this.syncMode = config?.syncMode ?? "full";
+    this.strategy = config?.strategy ?? new PullFirstStrategy();
     this.tracker = new SyncTracker(db, this.queue, this.hlc, this._clientId);
     const autoSyncIntervalMs = config?.autoSyncIntervalMs ?? AUTO_SYNC_INTERVAL_MS;
     const realtimeHeartbeatMs = config?.realtimeHeartbeatMs ?? REALTIME_HEARTBEAT_MS;
@@ -1252,9 +1287,8 @@ var SyncCoordinator = class {
   }
   /** Remove an event listener */
   off(event, listener) {
-    const arr = this.listeners[event];
-    const idx = arr.indexOf(listener);
-    if (idx !== -1) arr.splice(idx, 1);
+    const listeners = this.listeners;
+    listeners[event] = this.listeners[event].filter((fn) => fn !== listener);
   }
   emit(event, ...args) {
     for (const fn of this.listeners[event]) {
@@ -1272,6 +1306,10 @@ var SyncCoordinator = class {
       lastSyncedHlc: this.lastSyncedHlc
     };
   }
+  /** Whether the client believes it is online. */
+  get isOnline() {
+    return this._online;
+  }
   /** Push pending deltas to the gateway via the transport */
   async pushToGateway() {
     const peekResult = await this.queue.peek(100);
@@ -1374,10 +1412,13 @@ var SyncCoordinator = class {
   /**
    * Start auto-sync: periodic interval + visibility change handler.
    * Synchronises (push + pull) on tab focus and every N seconds.
+   * Registers online/offline listeners to skip sync when offline
+   * and trigger an immediate sync on reconnect.
    */
   startAutoSync() {
     this.transport.connect?.();
     this.autoSyncScheduler.start();
+    this.setupOnlineListeners();
   }
   /**
    * Perform initial sync via checkpoint download.
@@ -1399,22 +1440,25 @@ var SyncCoordinator = class {
     this.lastSyncedHlc = snapshotHlc;
     this._lastSyncTime = /* @__PURE__ */ new Date();
   }
+  /** Build a {@link SyncContext} exposing sync operations for the current cycle. */
+  createSyncContext() {
+    return {
+      isFirstSync: this.lastSyncedHlc === HLC.encode(0, 0),
+      syncMode: this.syncMode,
+      initialSync: () => this.initialSync(),
+      pull: () => this.pullFromGateway(),
+      push: () => this.pushToGateway(),
+      processActions: () => this.processActionQueue()
+    };
+  }
   /** Perform a single sync cycle (push + pull + actions, depending on syncMode). */
   async syncOnce() {
     if (this.syncing) return;
+    if (!this._online) return;
     this.syncing = true;
     this.emit("onSyncStart");
     try {
-      if (this.syncMode !== "pushOnly") {
-        if (this.lastSyncedHlc === HLC.encode(0, 0)) {
-          await this.initialSync();
-        }
-        await this.pullFromGateway();
-      }
-      if (this.syncMode !== "pullOnly") {
-        await this.pushToGateway();
-      }
-      await this.processActionQueue();
+      await this.strategy.execute(this.createSyncContext());
       this.emit("onSyncComplete");
     } catch (err) {
       this.emit("onError", err instanceof Error ? err : new Error(String(err)));
@@ -1480,8 +1524,40 @@ var SyncCoordinator = class {
   /** Stop auto-sync and clean up listeners */
   stopAutoSync() {
     this.autoSyncScheduler.stop();
+    this.teardownOnlineListeners();
     this.transport.disconnect?.();
   }
+  /**
+   * Register window online/offline event listeners.
+   * Guards all browser API access with typeof checks for Node/SSR safety.
+   */
+  setupOnlineListeners() {
+    if (typeof window === "undefined") return;
+    if (typeof navigator !== "undefined" && typeof navigator.onLine === "boolean") {
+      this._online = navigator.onLine;
+    }
+    this.onlineHandler = () => {
+      this._online = true;
+      void this.syncOnce();
+    };
+    this.offlineHandler = () => {
+      this._online = false;
+    };
+    window.addEventListener("online", this.onlineHandler);
+    window.addEventListener("offline", this.offlineHandler);
+  }
+  /** Remove online/offline listeners. */
+  teardownOnlineListeners() {
+    if (typeof window === "undefined") return;
+    if (this.onlineHandler) {
+      window.removeEventListener("online", this.onlineHandler);
+      this.onlineHandler = null;
+    }
+    if (this.offlineHandler) {
+      window.removeEventListener("offline", this.offlineHandler);
+      this.offlineHandler = null;
+    }
+  }
 };
 
 // ../client/src/sync/transport-http.ts
@@ -1489,29 +1565,52 @@ var HttpTransport = class {
   baseUrl;
   gatewayId;
   token;
+  getToken;
   _fetch;
   constructor(config) {
     this.baseUrl = config.baseUrl.replace(/\/+$/, "");
     this.gatewayId = config.gatewayId;
     this.token = config.token;
+    this.getToken = config.getToken;
     this._fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
   }
+  /** Resolve the current bearer token, preferring getToken callback over static token. */
+  async resolveToken() {
+    if (this.getToken) {
+      return this.getToken();
+    }
+    return this.token;
+  }
   /**
    * Push local deltas to the remote gateway.
    *
    * Sends a POST request with the push payload as BigInt-safe JSON.
+   * On 401, if `getToken` is configured, refreshes the token and retries once.
    */
   async push(msg) {
     const url = `${this.baseUrl}/sync/${this.gatewayId}/push`;
+    const body = JSON.stringify(msg, bigintReplacer);
     try {
-      const response = await this._fetch(url, {
+      let token = await this.resolveToken();
+      let response = await this._fetch(url, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${this.token}`
+          Authorization: `Bearer ${token}`
         },
-        body: JSON.stringify(msg, bigintReplacer)
+        body
       });
+      if (response.status === 401 && this.getToken) {
+        token = await this.getToken();
+        response = await this._fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body
+        });
+      }
       if (!response.ok) {
         const text = await response.text().catch(() => "Unknown error");
         return Err(new LakeSyncError(`Push failed (${response.status}): ${text}`, "TRANSPORT_ERROR"));
@@ -1528,6 +1627,7 @@ var HttpTransport = class {
    * Pull remote deltas from the gateway.
    *
    * Sends a GET request with query parameters for the pull cursor.
+   * On 401, if `getToken` is configured, refreshes the token and retries once.
    */
   async pull(msg) {
     const params = new URLSearchParams({
@@ -1540,12 +1640,22 @@ var HttpTransport = class {
     }
     const url = `${this.baseUrl}/sync/${this.gatewayId}/pull?${params}`;
     try {
-      const response = await this._fetch(url, {
+      let token = await this.resolveToken();
+      let response = await this._fetch(url, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${this.token}`
+          Authorization: `Bearer ${token}`
         }
       });
+      if (response.status === 401 && this.getToken) {
+        token = await this.getToken();
+        response = await this._fetch(url, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${token}`
+          }
+        });
+      }
       if (!response.ok) {
         const text = await response.text().catch(() => "Unknown error");
         return Err(new LakeSyncError(`Pull failed (${response.status}): ${text}`, "TRANSPORT_ERROR"));
@@ -1565,14 +1675,16 @@ var HttpTransport = class {
    */
   async executeAction(msg) {
     const url = `${this.baseUrl}/sync/${this.gatewayId}/action`;
+    const body = JSON.stringify(msg, bigintReplacer);
     try {
+      const token = await this.resolveToken();
       const response = await this._fetch(url, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${this.token}`
+          Authorization: `Bearer ${token}`
         },
-        body: JSON.stringify(msg, bigintReplacer)
+        body
       });
       if (!response.ok) {
         const text = await response.text().catch(() => "Unknown error");
@@ -1594,10 +1706,11 @@ var HttpTransport = class {
   async describeActions() {
     const url = `${this.baseUrl}/sync/${this.gatewayId}/actions`;
     try {
+      const token = await this.resolveToken();
       const response = await this._fetch(url, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${this.token}`
+          Authorization: `Bearer ${token}`
         }
       });
       if (!response.ok) {
@@ -1657,10 +1770,11 @@ var HttpTransport = class {
   async checkpoint() {
     const url = `${this.baseUrl}/sync/${this.gatewayId}/checkpoint`;
     try {
+      const token = await this.resolveToken();
       const response = await this._fetch(url, {
         method: "GET",
         headers: {
-          Authorization: `Bearer ${this.token}`,
+          Authorization: `Bearer ${token}`,
           Accept: "application/x-lakesync-checkpoint-stream"
         }
       });
@@ -2046,6 +2160,10 @@ var LocalTransport = class {
     }
     return Ok(this.gateway.describeActions());
   }
+  /** List available connector types — not supported by local transport. */
+  async listConnectorTypes() {
+    return Ok([]);
+  }
 };
 
 // ../client/src/sync/transport-ws.ts
@@ -2090,7 +2208,7 @@ var WebSocketTransport = class {
   connect() {
     if (this.ws) return;
     this.intentionalClose = false;
-    this.openWebSocket();
+    void this.openWebSocket();
   }
   /** Close the WebSocket connection and stop reconnecting. */
   disconnect() {
@@ -2161,8 +2279,9 @@ var WebSocketTransport = class {
   // -----------------------------------------------------------------------
   // Internal
   // -----------------------------------------------------------------------
-  openWebSocket() {
-    const url = `${this.config.url}?token=${encodeURIComponent(this.config.token)}`;
+  async openWebSocket() {
+    const token = this.config.getToken ? await this.config.getToken() : this.config.token;
+    const url = `${this.config.url}?token=${encodeURIComponent(token)}`;
     this.ws = new WebSocket(url);
     this.ws.binaryType = "arraybuffer";
     this.ws.onopen = () => {
@@ -2219,7 +2338,7 @@ var WebSocketTransport = class {
     this.reconnectAttempts++;
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
-      this.openWebSocket();
+      void this.openWebSocket();
     }, delay);
   }
   sendAndAwaitResponse(frame) {
@@ -2261,6 +2380,8 @@ export {
   MemoryActionQueue,
   MemoryOutbox,
   MemoryQueue,
+  PullFirstStrategy,
+  PushFirstStrategy,
   SchemaSynchroniser,
   SyncCoordinator,
   SyncTracker,