fauxbase 0.5.8 → 0.6.0

package/dist/index.cjs

@@ -1590,10 +1590,12 @@ var HttpDriver = class {
       const params = new URLSearchParams(options.query);
       url += `?${params.toString()}`;
     }
-    return this._fetch(url, {
+    const raw = await this._fetch(url, {
       method: options?.method ?? (options?.body !== void 0 ? "POST" : "GET"),
       body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
     });
+    const parsed = this.preset.response.single(raw);
+    return parsed.data ?? raw;
   }
   // Seed methods are no-ops for HTTP — backend owns data
   seed() {
@@ -1607,6 +1609,593 @@ var HttpDriver = class {
   }
 };
 
+// src/drivers/sync/sync-queue.ts
+var STORE_NAME = "queue";
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var SyncQueue = class {
+  db = null;
+  cache = [];
+  _ready;
+  constructor(dbName = "fauxbase-sync-queue") {
+    this._ready = this.open(dbName);
+  }
+  get ready() {
+    return this._ready;
+  }
+  open(dbName) {
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(dbName, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          const store = db.createObjectStore(STORE_NAME, { keyPath: "id" });
+          store.createIndex("resource_entity", ["resource", "entityId"]);
+          store.createIndex("status", "status");
+        }
+      };
+      req.onsuccess = async () => {
+        this.db = req.result;
+        await this.loadAll();
+        resolve();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async loadAll() {
+    const db = this.db;
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    return new Promise((resolve, reject) => {
+      const req = store.getAll();
+      req.onsuccess = () => {
+        this.cache = req.result.sort((a, b) => a.timestamp - b.timestamp);
+        resolve();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  persist(entry) {
+    if (!this.db) return;
+    const tx = this.db.transaction(STORE_NAME, "readwrite");
+    tx.objectStore(STORE_NAME).put(entry);
+  }
+  removeFromDb(id) {
+    if (!this.db) return;
+    const tx = this.db.transaction(STORE_NAME, "readwrite");
+    tx.objectStore(STORE_NAME).delete(id);
+  }
+  async enqueue(entry) {
+    const existing = this.cache.find(
+      (e) => e.resource === entry.resource && e.entityId === entry.entityId && (e.status === "pending" || e.status === "failed")
+    );
+    if (existing) {
+      if (existing.action === "create" && entry.action === "update") {
+        existing.data = { ...existing.data, ...entry.data };
+        this.persist(existing);
+        return;
+      }
+      if (existing.action === "create" && entry.action === "delete") {
+        this.cache = this.cache.filter((e) => e.id !== existing.id);
+        this.removeFromDb(existing.id);
+        return;
+      }
+      if (existing.action === "update" && entry.action === "update") {
+        existing.data = { ...existing.data, ...entry.data };
+        this.persist(existing);
+        return;
+      }
+      if (existing.action === "update" && entry.action === "delete") {
+        existing.action = "delete";
+        existing.data = null;
+        this.persist(existing);
+        return;
+      }
+    }
+    const full = {
+      ...entry,
+      id: generateId(),
+      status: "pending",
+      retries: 0
+    };
+    this.cache.push(full);
+    this.persist(full);
+  }
+  getPending() {
+    return this.cache.filter((e) => e.status === "pending" || e.status === "failed").sort((a, b) => a.timestamp - b.timestamp);
+  }
+  getPendingCount() {
+    return this.cache.filter((e) => e.status === "pending" || e.status === "failed").length;
+  }
+  async markSyncing(id) {
+    const entry = this.cache.find((e) => e.id === id);
+    if (entry) {
+      entry.status = "syncing";
+      this.persist(entry);
+    }
+  }
+  async remove(id) {
+    this.cache = this.cache.filter((e) => e.id !== id);
+    this.removeFromDb(id);
+  }
+  async markFailed(id, error) {
+    const entry = this.cache.find((e) => e.id === id);
+    if (entry) {
+      entry.status = "failed";
+      entry.retries++;
+      entry.error = error;
+      this.persist(entry);
+    }
+  }
+  getDeadLetters(maxRetries) {
+    return this.cache.filter((e) => e.status === "failed" && e.retries >= maxRetries);
+  }
+};
+
+// src/drivers/sync/sync-engine.ts
+var SyncEngine = class {
+  localDriver;
+  httpDriver;
+  queue;
+  config;
+  eventBus = null;
+  online = true;
+  syncing = false;
+  pullTimer = null;
+  pushTimer = null;
+  lastSynced = null;
+  registeredResources = /* @__PURE__ */ new Map();
+  // resource -> endpoint
+  _syncPromise = null;
+  constructor(localDriver, httpDriver, queue, syncConfig) {
+    this.localDriver = localDriver;
+    this.httpDriver = httpDriver;
+    this.queue = queue;
+    this.config = {
+      interval: syncConfig?.interval ?? 3e4,
+      retryDelay: syncConfig?.retryDelay ?? 5e3,
+      maxRetries: syncConfig?.maxRetries ?? 10,
+      conflictStrategy: syncConfig?.conflictStrategy ?? "last-write-wins",
+      resources: syncConfig?.resources ?? null,
+      pingUrl: syncConfig?.pingUrl ?? "/ping"
+    };
+  }
+  setEventBus(bus) {
+    this.eventBus = bus;
+  }
+  registerResource(resource, endpoint) {
+    this.registeredResources.set(resource, endpoint);
+  }
+  start() {
+    this.setupConnectivityListeners();
+    if (this.config.interval > 0) {
+      this.pullTimer = setInterval(() => {
+        this.sync().catch(() => {
+        });
+      }, this.config.interval);
+    }
+    this.sync().catch(() => {
+    });
+  }
+  stop() {
+    if (this.pullTimer) {
+      clearInterval(this.pullTimer);
+      this.pullTimer = null;
+    }
+    if (this.pushTimer) {
+      clearTimeout(this.pushTimer);
+      this.pushTimer = null;
+    }
+  }
+  async sync() {
+    if (this._syncPromise) return this._syncPromise;
+    this._syncPromise = this._doSync();
+    try {
+      return await this._syncPromise;
+    } finally {
+      this._syncPromise = null;
+    }
+  }
+  async _doSync() {
+    if (this.syncing) return { pushed: 0, pulled: 0 };
+    this.syncing = true;
+    this.emitSyncState();
+    this.emitEvent("sync:start");
+    let pushed = 0;
+    let pulled = 0;
+    try {
+      this.online = await this.checkOnline();
+      if (!this.online) {
+        this.emitEvent("sync:complete", { pushed: 0, pulled: 0 });
+        return { pushed: 0, pulled: 0 };
+      }
+      pushed = await this.push();
+      pulled = await this.pull();
+      this.lastSynced = Date.now();
+      this.emitEvent("sync:complete", { pushed, pulled });
+    } catch (err) {
+      this.emitEvent("sync:error", { error: err.message });
+    } finally {
+      this.syncing = false;
+      this.emitSyncState();
+    }
+    return { pushed, pulled };
+  }
+  // --- Push: replay queued mutations to remote ---
+  async push() {
+    const pending = this.queue.getPending();
+    let pushed = 0;
+    for (const entry of pending) {
+      if (entry.retries >= this.config.maxRetries) continue;
+      if (this.config.resources && !this.config.resources.includes(entry.resource)) continue;
+      await this.queue.markSyncing(entry.id);
+      try {
+        switch (entry.action) {
+          case "create": {
+            const result = await this.httpDriver.create(entry.resource, entry.data);
+            const serverData = result.data;
+            if (serverData && serverData.id) {
+              this.localDriver.getStorageBackend().set(entry.resource, serverData.id, serverData);
+              if (serverData.id !== entry.entityId) {
+                this.localDriver.getStorageBackend().remove(entry.resource, entry.entityId);
+              }
+            }
+            break;
+          }
+          case "update": {
+            const result = await this.httpDriver.update(entry.resource, entry.entityId, entry.data);
+            const serverData = result.data;
+            if (serverData) {
+              this.localDriver.getStorageBackend().set(entry.resource, entry.entityId, serverData);
+            }
+            break;
+          }
+          case "delete": {
+            await this.httpDriver.delete(entry.resource, entry.entityId);
+            break;
+          }
+        }
+        await this.queue.remove(entry.id);
+        pushed++;
+      } catch (err) {
+        if (err.status === 409 || err.code === "CONFLICT") {
+          await this.handleConflict(entry);
+        } else {
+          await this.queue.markFailed(entry.id, err.message ?? "Sync failed");
+          this.emitEvent("sync:error", {
+            resource: entry.resource,
+            action: entry.action,
+            error: err.message
+          });
+        }
+      }
+    }
+    return pushed;
+  }
+  // --- Pull: fetch updated data from remote ---
+  async pull() {
+    let totalPulled = 0;
+    for (const [resource] of this.registeredResources) {
+      if (this.config.resources && !this.config.resources.includes(resource)) continue;
+      try {
+        totalPulled += await this.pullResource(resource);
+      } catch {
+      }
+    }
+    return totalPulled;
+  }
+  async pullResource(resource) {
+    const storage = this.localDriver.getStorageBackend();
+    const lastPullKey = `_sync:lastPull:${resource}`;
+    const lastPull = storage.getMeta(lastPullKey);
+    const filter = {};
+    if (lastPull) {
+      filter.updatedAt__gt = lastPull;
+    }
+    let page = 1;
+    let pulled = 0;
+    let maxUpdatedAt = lastPull ?? "";
+    while (true) {
+      const result = await this.httpDriver.list(resource, {
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        size: 200,
+        page,
+        sort: { field: "updatedAt", direction: "asc" }
+      });
+      for (const item of result.items) {
+        const hasPending = this.queue.getPending().some(
+          (e) => e.resource === resource && e.entityId === item.id
+        );
+        if (hasPending && this.config.conflictStrategy !== "server-wins") continue;
+        storage.set(resource, item.id, item);
+        pulled++;
+        if (item.updatedAt && item.updatedAt > maxUpdatedAt) {
+          maxUpdatedAt = item.updatedAt;
+        }
+      }
+      if (result.items.length < 200 || page >= result.meta.totalPages) break;
+      page++;
+    }
+    if (maxUpdatedAt) {
+      storage.setMeta(lastPullKey, maxUpdatedAt);
+    }
+    if (pulled > 0 && this.eventBus) {
+      this.eventBus.emit({
+        action: "updated",
+        resource,
+        timestamp: Date.now(),
+        source: "remote"
+      });
+    }
+    return pulled;
+  }
+  // --- Conflict resolution ---
+  async handleConflict(entry) {
+    const strategy = this.config.conflictStrategy;
+    if (strategy === "server-wins") {
+      await this.queue.remove(entry.id);
+      try {
+        const result = await this.httpDriver.get(entry.resource, entry.entityId);
+        this.localDriver.getStorageBackend().set(entry.resource, entry.entityId, result.data);
+      } catch {
+      }
+    } else if (strategy === "client-wins" || strategy === "last-write-wins") {
+      try {
+        const serverResult = await this.httpDriver.get(entry.resource, entry.entityId);
+        const serverData = serverResult.data;
+        if (entry.action === "update" && entry.data) {
+          const merged = { ...serverData, ...entry.data };
+          await this.httpDriver.update(entry.resource, entry.entityId, merged);
+          this.localDriver.getStorageBackend().set(entry.resource, entry.entityId, merged);
+        }
+        await this.queue.remove(entry.id);
+      } catch {
+        await this.queue.markFailed(entry.id, "Conflict resolution failed");
+      }
+    }
+    this.emitEvent("sync:conflict", {
+      resource: entry.resource,
+      action: entry.action,
+      entityId: entry.entityId
+    });
+  }
+  // --- Connectivity ---
+  setupConnectivityListeners() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("online", () => this.handleOnline());
+    window.addEventListener("offline", () => this.handleOffline());
+  }
+  async checkOnline() {
+    if (typeof navigator !== "undefined" && !navigator.onLine) return false;
+    try {
+      const baseUrl = this.httpDriver.baseUrl;
+      const response = await fetch(`${baseUrl}${this.config.pingUrl}`, {
+        method: "HEAD",
+        cache: "no-store",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  handleOnline() {
+    if (this.online) return;
+    this.online = true;
+    this.emitEvent("online");
+    this.emitSyncState();
+    this.sync().catch(() => {
+    });
+  }
+  handleOffline() {
+    if (!this.online) return;
+    this.online = false;
+    this.emitEvent("offline");
+    this.emitSyncState();
+  }
+  // --- State ---
+  getSyncState() {
+    return {
+      isOnline: this.online,
+      isSyncing: this.syncing,
+      pendingCount: this.queue.getPendingCount(),
+      lastSynced: this.lastSynced
+    };
+  }
+  // --- Events ---
+  emitEvent(type, data) {
+    if (!this.eventBus) return;
+    this.eventBus.emit({
+      action: type,
+      resource: "__sync",
+      data: { type, ...data },
+      timestamp: Date.now(),
+      source: "local"
+    });
+  }
+  emitSyncState() {
+    this.emitEvent("state", this.getSyncState());
+  }
+};
+
+// src/drivers/sync/sync-driver.ts
+var SyncDriver = class {
+  localDriver;
+  httpDriver;
+  queue;
+  _syncEngine;
+  _ready;
+  _isReady = false;
+  constructor(config) {
+    this.localDriver = new LocalDriver({
+      type: "local",
+      persist: config.local.persist ?? "indexeddb",
+      dbName: config.local.dbName
+    });
+    this.httpDriver = new HttpDriver({
+      type: "http",
+      baseUrl: config.remote.baseUrl,
+      preset: config.remote.preset,
+      timeout: config.remote.timeout,
+      retry: config.remote.retry,
+      headers: config.remote.headers
+    });
+    this.queue = new SyncQueue(
+      config.local.dbName ? `${config.local.dbName}-sync-queue` : void 0
+    );
+    this._syncEngine = new SyncEngine(
+      this.localDriver,
+      this.httpDriver,
+      this.queue,
+      config.sync
+    );
+    this._ready = Promise.all([this.localDriver.ready, this.queue.ready]).then(() => {
+      this._isReady = true;
+    });
+  }
+  get ready() {
+    return this._ready;
+  }
+  get isReady() {
+    return this._isReady;
+  }
+  get syncEngine() {
+    return this._syncEngine;
+  }
+  /** @internal — exposed for createClient auth wiring */
+  get _httpDriver() {
+    return this.httpDriver;
+  }
+  // --- Reads: delegate to local ---
+  async list(resource, query) {
+    return this.localDriver.list(resource, query);
+  }
+  async get(resource, id) {
+    return this.localDriver.get(resource, id);
+  }
+  async count(resource, filter) {
+    return this.localDriver.count(resource, filter);
+  }
+  // --- Writes: local first, then enqueue ---
+  async create(resource, data) {
+    const result = await this.localDriver.create(resource, data);
+    await this.queue.enqueue({
+      resource,
+      action: "create",
+      entityId: result.data.id,
+      data: result.data,
+      timestamp: Date.now()
+    });
+    return result;
+  }
+  async update(resource, id, data) {
+    const result = await this.localDriver.update(resource, id, data);
+    await this.queue.enqueue({
+      resource,
+      action: "update",
+      entityId: id,
+      data,
+      timestamp: Date.now()
+    });
+    return result;
+  }
+  async delete(resource, id) {
+    const result = await this.localDriver.delete(resource, id);
+    await this.queue.enqueue({
+      resource,
+      action: "delete",
+      entityId: id,
+      data: null,
+      timestamp: Date.now()
+    });
+    return result;
+  }
+  // --- Bulk: delegate to local + enqueue each ---
+  async bulkCreate(resource, data) {
+    const results = [];
+    for (const item of data) {
+      const { data: created } = await this.create(resource, item);
+      results.push(created);
+    }
+    return { data: results };
+  }
+  async bulkUpdate(resource, updates) {
+    const results = [];
+    for (const { id, data } of updates) {
+      const { data: updated } = await this.update(resource, id, data);
+      results.push(updated);
+    }
+    return { data: results };
+  }
+  async bulkDelete(resource, ids) {
+    for (const id of ids) {
+      await this.delete(resource, id);
+    }
+    return { data: { count: ids.length } };
+  }
+  // --- Custom request: local handler offline, HTTP when online ---
+  async request(resource, path, options) {
+    try {
+      return await this.httpDriver.request(resource, path, options);
+    } catch {
+      if (options?.local) {
+        return options.local();
+      }
+      throw new Error(
+        "service.request() failed and no local handler provided. Provide a `local` callback for offline support."
+      );
+    }
+  }
+  // --- Seed/meta: delegate to local ---
+  seed(resource, data, entityClass) {
+    this.localDriver.seed(resource, data, entityClass);
+  }
+  getSeedVersion() {
+    return this.localDriver.getSeedVersion();
+  }
+  setSeedVersion(version) {
+    this.localDriver.setSeedVersion(version);
+  }
+  clear(resource) {
+    this.localDriver.clear(resource);
+  }
+  // --- Wiring methods (called by createClient) ---
+  setAuthProvider(provider) {
+    this.httpDriver.setAuthProvider(provider);
+    this.localDriver.setAuthProvider(() => {
+      const auth = provider();
+      if (!auth) return null;
+      try {
+        const payload = JSON.parse(atob(auth.token));
+        return { userId: payload.userId, userName: payload.email };
+      } catch {
+        return null;
+      }
+    });
+  }
+  setOnUnauthorized(handler) {
+    this.httpDriver.setOnUnauthorized(handler);
+  }
+  registerEndpoint(resource, endpoint) {
+    this.httpDriver.registerEndpoint(resource, endpoint);
+    this._syncEngine.registerResource(resource, endpoint);
+  }
+  registerEntity(resource, entityClass) {
+    this.localDriver.registerEntity(resource, entityClass);
+  }
+  getStorageBackend() {
+    return this.localDriver.getStorageBackend();
+  }
+};
+
 // src/events/event-bus.ts
 var EventBus = class {
   listeners = /* @__PURE__ */ new Map();
@@ -1804,6 +2393,10 @@ function createClient(config) {
     if (driver instanceof HttpDriver) {
       driver.registerEndpoint(name, instance.endpoint);
     }
+    if (driver instanceof SyncDriver) {
+      driver.registerEntity(name, instance.entity);
+      driver.registerEndpoint(name, instance.endpoint);
+    }
     client[name] = instance;
   }
   if (config.auth) {
@@ -1866,6 +2459,45 @@ function createClient(config) {
           return false;
         }
       });
+    } else if (defaultDriver instanceof SyncDriver) {
+      authInstance._init(defaultDriver, resourceName);
+      defaultDriver.registerEntity(resourceName, authInstance.entity);
+      defaultDriver.registerEndpoint(resourceName, authInstance.endpoint);
+      const hasLocalStorage = typeof localStorage !== "undefined";
+      const LS_AUTH_KEY = "fauxbase:auth";
+      let memoryAuthState = null;
+      authInstance._initAuth(
+        () => {
+          if (hasLocalStorage) {
+            const raw = localStorage.getItem(LS_AUTH_KEY);
+            return raw ? JSON.parse(raw) : null;
+          }
+          return memoryAuthState;
+        },
+        (state) => {
+          if (hasLocalStorage) {
+            if (state) {
+              localStorage.setItem(LS_AUTH_KEY, JSON.stringify(state));
+            } else {
+              localStorage.removeItem(LS_AUTH_KEY);
+            }
+          }
+          memoryAuthState = state;
+        }
+      );
+      authInstance._setHttpMode(defaultDriver._httpDriver);
+      defaultDriver.setAuthProvider(() => {
+        const token = authInstance.token;
+        return token ? { token } : null;
+      });
+      defaultDriver.setOnUnauthorized(async () => {
+        try {
+          await authInstance.refresh();
+          return true;
+        } catch {
+          return false;
+        }
+      });
     }
     client.auth = authInstance;
     for (const driver of overrideDrivers.values()) {
@@ -1922,8 +2554,14 @@ function createClient(config) {
         eventSource.reconnect();
       });
     }
+    if (defaultDriver instanceof SyncDriver) {
+      defaultDriver.syncEngine.setEventBus(eventBus);
+    }
     client.disconnect = () => {
       eventSource?.disconnect();
+      if (defaultDriver instanceof SyncDriver) {
+        defaultDriver.syncEngine.stop();
+      }
       eventBus.destroy();
     };
   }
@@ -1941,6 +2579,13 @@ function createClient(config) {
         }
       });
     }
+  } else if (defaultDriver instanceof SyncDriver) {
+    readyPromise = defaultDriver.ready.then(() => {
+      if (config.seeds) {
+        applySeedsIfNeeded(defaultDriver, config.seeds);
+      }
+      defaultDriver.syncEngine.start();
+    });
   } else {
     readyPromise = Promise.resolve();
   }
@@ -1958,6 +2603,8 @@ function createDriver(config) {
       return new LocalDriver(config);
     case "http":
       return new HttpDriver(config);
+    case "sync":
+      return new SyncDriver(config);
     default:
       throw new Error(`Unknown driver type: ${config.type}`);
   }
@@ -1984,6 +2631,7 @@ exports.LocalDriver = LocalDriver;
 exports.NetworkError = NetworkError;
 exports.NotFoundError = NotFoundError;
 exports.Service = Service;
+exports.SyncDriver = SyncDriver;
 exports.TimeoutError = TimeoutError;
 exports.ValidationError = ValidationError;
 exports.afterCreate = afterCreate;