cry-synced-db-client 0.1.1

package/dist/index.js

@@ -0,0 +1,1339 @@
+// src/index.ts
+import Dexie2 from "dexie";
+
+// src/db/SyncedDb.ts
+import { ObjectId } from "bson";
+
+// src/utils/conflictResolution.ts
+function resolveConflict(local, external) {
+  if (local._rev !== undefined && external._rev !== undefined) {
+    if (external._rev <= local._rev) {
+      return local;
+    }
+  }
+  return mergeObjects(local, external);
+}
+function mergeObjects(local, external) {
+  const result = { ...local };
+  for (const key of Object.keys(external)) {
+    if (key === "_id" || key === "_dirty" || key === "_localChangedAt") {
+      continue;
+    }
+    const localValue = local[key];
+    const externalValue = external[key];
+    if (localValue === undefined) {
+      result[key] = externalValue;
+      continue;
+    }
+    if (externalValue === undefined) {
+      continue;
+    }
+    if (Array.isArray(localValue) && Array.isArray(externalValue)) {
+      result[key] = mergeArrays(localValue, externalValue);
+    } else if (isPlainObject(localValue) && isPlainObject(externalValue)) {
+      result[key] = mergeObjects(localValue, externalValue);
+    }
+  }
+  return result;
+}
+function mergeArrays(local, external) {
+  if (local.length === 0) {
+    return [...external];
+  }
+  const firstLocal = local[0];
+  const firstExternal = external[0];
+  if (typeof firstLocal === "string" || typeof firstExternal === "string") {
+    return [...new Set([...local, ...external])];
+  }
+  if (isPlainObject(firstLocal) || isPlainObject(firstExternal)) {
+    return mergeObjectArrays(local, external);
+  }
+  return [...new Set([...local, ...external])];
+}
+function mergeObjectArrays(local, external) {
+  const result = [...local];
+  const localIds = new Map;
+  for (let i = 0;i < local.length; i++) {
+    const item = local[i];
+    if (item && typeof item === "object" && "_id" in item) {
+      localIds.set(String(item._id), i);
+    }
+  }
+  for (const extItem of external) {
+    if (!extItem || typeof extItem !== "object") {
+      result.push(extItem);
+      continue;
+    }
+    if ("_id" in extItem) {
+      const localIndex = localIds.get(String(extItem._id));
+      if (localIndex !== undefined) {
+        result[localIndex] = mergeObjects(result[localIndex], extItem);
+      } else {
+        result.push(extItem);
+      }
+    } else {
+      result.push(extItem);
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+
+// src/utils/localQuery.ts
+function matchesQuery(item, query) {
+  for (const [key, condition] of Object.entries(query)) {
+    if (!matchesCondition(item, key, condition)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchesCondition(item, key, condition) {
+  const value = getNestedValue(item, key);
+  if (condition === null || typeof condition !== "object") {
+    return value === condition;
+  }
+  if (condition instanceof Date) {
+    if (value instanceof Date) {
+      return value.getTime() === condition.getTime();
+    }
+    return false;
+  }
+  if (Array.isArray(condition)) {
+    return condition.includes(value);
+  }
+  for (const [op, opValue] of Object.entries(condition)) {
+    if (!matchesOperator(value, op, opValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchesOperator(value, operator, operand) {
+  switch (operator) {
+    case "$eq":
+      return equals(value, operand);
+    case "$ne":
+      return !equals(value, operand);
+    case "$gt":
+      return value > operand;
+    case "$gte":
+      return value >= operand;
+    case "$lt":
+      return value < operand;
+    case "$lte":
+      return value <= operand;
+    case "$in":
+      if (!Array.isArray(operand))
+        return false;
+      return operand.some((item) => equals(value, item));
+    case "$nin":
+      if (!Array.isArray(operand))
+        return true;
+      return !operand.some((item) => equals(value, item));
+    case "$exists":
+      return operand ? value !== undefined : value === undefined;
+    case "$regex": {
+      if (typeof value !== "string")
+        return false;
+      const regex = operand instanceof RegExp ? operand : new RegExp(operand);
+      return regex.test(value);
+    }
+    case "$elemMatch":
+      if (!Array.isArray(value))
+        return false;
+      return value.some((elem) => {
+        if (typeof operand === "object" && operand !== null) {
+          for (const [k, v] of Object.entries(operand)) {
+            if (!matchesCondition(elem, k, v)) {
+              return false;
+            }
+          }
+          return true;
+        }
+        return equals(elem, operand);
+      });
+    case "$size":
+      return Array.isArray(value) && value.length === operand;
+    case "$all":
+      if (!Array.isArray(value) || !Array.isArray(operand))
+        return false;
+      return operand.every((item) => value.some((v) => equals(v, item)));
+    default:
+      if (typeof value === "object" && value !== null) {
+        return matchesCondition(value, operator, operand);
+      }
+      return false;
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined) {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function equals(a, b) {
+  if (a === b)
+    return true;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a && b && typeof a.toString === "function" && typeof b.toString === "function") {
+    if (a.constructor?.name === "ObjectId" || b.constructor?.name === "ObjectId") {
+      return String(a) === String(b);
+    }
+  }
+  return false;
+}
+function filterByQuery(items, query) {
+  if (!query || Object.keys(query).length === 0) {
+    return items;
+  }
+  return items.filter((item) => matchesQuery(item, query));
+}
+
+// src/utils/crashRecovery.ts
+var STORAGE_PREFIX = "synced-db-pending:";
+function savePendingWrite(tenant, collection, id, data) {
+  if (typeof localStorage === "undefined")
+    return;
+  const key = `${STORAGE_PREFIX}${tenant}:${collection}:${String(id)}`;
+  const pending = {
+    tenant,
+    collection,
+    id: String(id),
+    data,
+    timestamp: Date.now()
+  };
+  try {
+    localStorage.setItem(key, JSON.stringify(pending));
+  } catch {
+    console.warn("Failed to save pending write to localStorage");
+  }
+}
+function clearPendingWrite(tenant, collection, id) {
+  if (typeof localStorage === "undefined")
+    return;
+  const key = `${STORAGE_PREFIX}${tenant}:${collection}:${String(id)}`;
+  try {
+    localStorage.removeItem(key);
+  } catch {}
+}
+function getPendingWrites(tenant) {
+  if (typeof localStorage === "undefined")
+    return [];
+  const pending = [];
+  const prefix = `${STORAGE_PREFIX}${tenant}:`;
+  try {
+    for (let i = 0;i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key && key.startsWith(prefix)) {
+        const value = localStorage.getItem(key);
+        if (value) {
+          try {
+            const parsed = JSON.parse(value);
+            pending.push(parsed);
+          } catch {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    }
+  } catch {}
+  return pending.sort((a, b) => a.timestamp - b.timestamp);
+}
+
+// src/db/SyncedDb.ts
+var DEFAULT_DEBOUNCE_MS = 1000;
+var DEFAULT_REST_TIMEOUT_MS = 1e4;
+var DEFAULT_SYNC_TIMEOUT_MS = 30000;
+var MAX_RETRY_COUNT = 3;
+
+class SyncedDb {
+  tenant;
+  collections = new Map;
+  dexieDb;
+  inMemDb;
+  restInterface;
+  serverUpdateNotifier;
+  restTimeoutMs;
+  syncTimeoutMs;
+  debounceMs;
+  onForcedOffline;
+  onSync;
+  online = false;
+  syncing = false;
+  syncLock = false;
+  initialized = false;
+  pendingChanges = new Map;
+  unsubscribeServerUpdates;
+  beforeUnloadHandler;
+  updaterId;
+  constructor(config) {
+    this.tenant = config.tenant;
+    this.dexieDb = config.dexieDb;
+    this.inMemDb = config.inMemDb;
+    this.restInterface = config.restInterface;
+    this.serverUpdateNotifier = config.serverUpdateNotifier;
+    this.restTimeoutMs = config.restTimeoutMs ?? DEFAULT_REST_TIMEOUT_MS;
+    this.syncTimeoutMs = config.syncTimeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS;
+    this.debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.onForcedOffline = config.onForcedOffline;
+    this.onSync = config.onSync;
+    this.updaterId = Math.random().toString(36).substring(2, 15);
+    for (const col of config.collections) {
+      this.collections.set(col.name, col);
+    }
+  }
+  async init() {
+    if (this.initialized)
+      return;
+    await this.recoverPendingWrites();
+    for (const [name] of this.collections) {
+      const data = await this.dexieDb.getAll(name);
+      const activeData = data.filter((item) => !item._deleted);
+      this.inMemDb.saveCollection(name, activeData);
+    }
+    if (this.serverUpdateNotifier) {
+      this.unsubscribeServerUpdates = this.serverUpdateNotifier.subscribe((payload) => this.handleServerUpdate(payload));
+    }
+    if (typeof window !== "undefined") {
+      this.beforeUnloadHandler = () => {
+        if (this.initialized && this.pendingChanges.size > 0) {
+          console.warn(`SyncedDb: ${this.pendingChanges.size} pending changes not flushed. ` + `Call close() before page unload to ensure data is saved.`);
+        }
+      };
+      window.addEventListener("beforeunload", this.beforeUnloadHandler);
+    }
+    this.initialized = true;
+  }
+  async close() {
+    await this.flushAllPendingChanges();
+    if (this.unsubscribeServerUpdates) {
+      this.unsubscribeServerUpdates();
+      this.unsubscribeServerUpdates = undefined;
+    }
+    if (typeof window !== "undefined" && this.beforeUnloadHandler) {
+      window.removeEventListener("beforeunload", this.beforeUnloadHandler);
+      this.beforeUnloadHandler = undefined;
+    }
+    this.initialized = false;
+  }
+  isOnline() {
+    return this.online;
+  }
+  setOnline(online) {
+    const wasOffline = !this.online;
+    if (online && wasOffline && this.initialized) {
+      this.tryGoOnline().catch((err) => {
+        console.error("Failed to go online:", err);
+      });
+    } else {
+      this.online = online;
+    }
+  }
+  goOffline(reason) {
+    this.online = false;
+    if (this.onForcedOffline) {
+      try {
+        this.onForcedOffline(reason);
+      } catch (err) {
+        console.error("onForcedOffline callback failed:", err);
+      }
+    }
+  }
+  async tryGoOnline() {
+    try {
+      const pingResult = await this.withSyncTimeout(this.restInterface.ping(), "ping");
+      if (!pingResult) {
+        console.warn("Ping failed - staying offline");
+        return;
+      }
+      this.online = true;
+      await this.sync();
+    } catch (err) {
+      console.warn("Failed to go online (ping failed or timed out):", err);
+      this.online = false;
+    }
+  }
+  withRestTimeout(promise, operation) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`REST timeout: ${operation} took longer than ${this.restTimeoutMs}ms`));
+      }, this.restTimeoutMs);
+      promise.then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+      }).catch((err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+  withSyncTimeout(promise, operation) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Sync timeout: ${operation} took longer than ${this.syncTimeoutMs}ms`));
+      }, this.syncTimeoutMs);
+      promise.then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+      }).catch((err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+  async findById(collection, id) {
+    this.assertCollection(collection);
+    const item = await this.dexieDb.getById(collection, id);
+    if (!item || item._deleted)
+      return null;
+    return this.stripLocalFields(item);
+  }
+  async findByIds(collection, ids) {
+    this.assertCollection(collection);
+    const items = await Promise.all(ids.map((id) => this.dexieDb.getById(collection, id)));
+    const results = [];
+    for (const item of items) {
+      if (item && !item._deleted) {
+        results.push(this.stripLocalFields(item));
+      }
+    }
+    return results;
+  }
+  async findOne(collection, query) {
+    this.assertCollection(collection);
+    const all = await this.dexieDb.getAll(collection);
+    const active = all.filter((item) => !item._deleted);
+    const filtered = filterByQuery(active, query);
+    if (filtered.length === 0)
+      return null;
+    return this.stripLocalFields(filtered[0]);
+  }
+  async find(collection, query) {
+    this.assertCollection(collection);
+    const all = await this.dexieDb.getAll(collection);
+    const active = all.filter((item) => !item._deleted);
+    const filtered = query ? filterByQuery(active, query) : active;
+    return filtered.map((item) => this.stripLocalFields(item));
+  }
+  async aggregate(collection, pipeline, opts) {
+    this.assertCollection(collection);
+    if (!this.online) {
+      return [];
+    }
+    return this.withRestTimeout(this.restInterface.aggregate(collection, pipeline, opts), "aggregate");
+  }
+  async save(collection, id, update) {
+    this.assertCollection(collection);
+    const existing = await this.dexieDb.getById(collection, id);
+    if (!existing) {
+      console.warn(`SyncedDb.save: Object ${String(id)} not found in ${collection}, creating new`);
+    }
+    const newData = {
+      ...update,
+      _dirty: true,
+      _localChangedAt: new Date,
+      _lastUpdaterId: this.updaterId
+    };
+    this.schedulePendingChange(collection, id, newData);
+    if (existing?._deleted) {} else {
+      this.inMemDb.save(collection, id, update);
+    }
+    const merged = { ...existing || { _id: id }, ...update };
+    return this.stripLocalFields(merged);
+  }
+  async upsert(collection, query, update) {
+    this.assertCollection(collection);
+    const existing = await this.findOne(collection, query);
+    if (existing) {
+      return this.save(collection, existing._id, update);
+    } else {
+      const id = new ObjectId;
+      const newDoc = { _id: id, ...update };
+      return this.insert(collection, newDoc);
+    }
+  }
+  async insert(collection, data) {
+    this.assertCollection(collection);
+    const id = data._id || new ObjectId;
+    const existing = await this.dexieDb.getById(collection, id);
+    if (existing && !existing._deleted) {
+      console.warn(`SyncedDb.insert: Object ${String(id)} already exists in ${collection}, overwriting`);
+    }
+    const newData = {
+      _id: id,
+      ...data,
+      _dirty: true,
+      _localChangedAt: new Date,
+      _lastUpdaterId: this.updaterId
+    };
+    this.schedulePendingChange(collection, id, newData);
+    this.inMemDb.insert(collection, this.stripLocalFields(newData));
+    return this.stripLocalFields(newData);
+  }
+  async deleteOne(collection, id) {
+    this.assertCollection(collection);
+    const existing = await this.dexieDb.getById(collection, id);
+    if (!existing || existing._deleted) {
+      return null;
+    }
+    const deleteUpdate = {
+      _deleted: new Date,
+      _dirty: true,
+      _localChangedAt: new Date,
+      _lastUpdaterId: this.updaterId
+    };
+    this.schedulePendingChange(collection, id, deleteUpdate);
+    this.inMemDb.deleteOne(collection, id);
+    return this.stripLocalFields(existing);
+  }
+  async deleteMany(collection, query) {
+    this.assertCollection(collection);
+    const items = await this.find(collection, query);
+    if (items.length === 0)
+      return 0;
+    const existingItems = await Promise.all(items.map((item) => this.dexieDb.getById(collection, item._id)));
+    const now = new Date;
+    let count = 0;
+    for (let i = 0;i < items.length; i++) {
+      const item = items[i];
+      const existing = existingItems[i];
+      if (!item || !existing || existing._deleted)
+        continue;
+      const deleteUpdate = {
+        _deleted: now,
+        _dirty: true,
+        _localChangedAt: now,
+        _lastUpdaterId: this.updaterId
+      };
+      this.schedulePendingChange(collection, item._id, deleteUpdate);
+      this.inMemDb.deleteOne(collection, item._id);
+      count++;
+    }
+    return count;
+  }
+  async hardDeleteOne(collection, id) {
+    this.assertCollection(collection);
+    if (!this.online) {
+      throw new Error("hardDeleteOne requires online connection");
+    }
+    const existing = await this.dexieDb.getById(collection, id);
+    if (!existing) {
+      return null;
+    }
+    await this.withRestTimeout(this.restInterface.deleteOne(collection, { _id: id }), "hardDeleteOne");
+    await this.dexieDb.deleteOne(collection, id);
+    this.inMemDb.deleteOne(collection, id);
+    return this.stripLocalFields(existing);
+  }
+  async hardDelete(collection, query) {
+    this.assertCollection(collection);
+    if (!this.online) {
+      throw new Error("hardDelete requires online connection");
+    }
+    const items = await this.find(collection, query);
+    if (items.length === 0)
+      return 0;
+    const existingItems = await Promise.all(items.map((item) => this.dexieDb.getById(collection, item._id)));
+    const toDelete = [];
+    for (let i = 0;i < items.length; i++) {
+      const item = items[i];
+      const existing = existingItems[i];
+      if (item && existing) {
+        toDelete.push({ id: item._id, existing });
+      }
+    }
+    if (toDelete.length === 0)
+      return 0;
+    const maxConcurrency = 10;
+    const queue = [...toDelete];
+    const results = [];
+    await Promise.all(Array.from({ length: Math.min(maxConcurrency, queue.length) }, async () => {
+      while (queue.length > 0) {
+        const item = queue.pop();
+        if (!item)
+          break;
+        try {
+          await this.withRestTimeout(this.restInterface.deleteOne(collection, { _id: item.id }), "hardDelete");
+          await this.dexieDb.deleteOne(collection, item.id);
+          this.inMemDb.deleteOne(collection, item.id);
+          results.push(true);
+        } catch (err) {
+          console.error(`Failed to hard delete ${String(item.id)}:`, err);
+          results.push(false);
+        }
+      }
+    }));
+    return results.filter(Boolean).length;
+  }
+  async ping(timeoutMs) {
+    const timeout = timeoutMs ?? this.restTimeoutMs;
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error(`Ping timeout after ${timeout}ms`));
+        }, timeout);
+        this.restInterface.ping().then((result2) => {
+          clearTimeout(timer);
+          resolve(result2);
+        }).catch((err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
+      });
+      return result;
+    } catch {
+      return false;
+    }
+  }
+  async sync() {
+    if (!this.online || this.syncLock)
+      return;
+    this.syncLock = true;
+    this.syncing = true;
+    const startTime = Date.now();
+    let receivedCount = 0;
+    let sentCount = 0;
+    let conflictsResolved = 0;
+    try {
+      await this.flushAllPendingChanges();
+      const syncSpecs = [];
+      const configMap = new Map;
+      for (const [collectionName, config] of this.collections) {
+        const meta = await this.dexieDb.getSyncMeta(collectionName);
+        syncSpecs.push({
+          collection: collectionName,
+          timestamp: meta?.lastSyncTs || 0,
+          query: config.query,
+          opts: { returnDeleted: true }
+        });
+        configMap.set(collectionName, config);
+      }
+      const allServerData = await this.withSyncTimeout(this.restInterface.findNewerMany(syncSpecs), "findNewerMany");
+      for (const [collectionName, config] of this.collections) {
+        const serverData = allServerData[collectionName] || [];
+        receivedCount += serverData.length;
+        const stats = await this.syncCollectionWithData(collectionName, config, serverData);
+        sentCount += stats.sentCount;
+        conflictsResolved += stats.conflictsResolved;
+      }
+      if (this.onSync) {
+        try {
+          this.onSync({
+            durationMs: Date.now() - startTime,
+            receivedCount,
+            sentCount,
+            conflictsResolved,
+            success: true
+          });
+        } catch (err) {
+          console.error("onSync callback failed:", err);
+        }
+      }
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      console.error("Sync failed, going offline:", err);
+      this.goOffline(`Sync failed: ${reason}`);
+      if (this.onSync) {
+        try {
+          this.onSync({
+            durationMs: Date.now() - startTime,
+            receivedCount,
+            sentCount,
+            conflictsResolved,
+            success: false,
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        } catch (callbackErr) {
+          console.error("onSync callback failed:", callbackErr);
+        }
+      }
+      throw err;
+    } finally {
+      this.syncing = false;
+      this.syncLock = false;
+    }
+  }
+  isSyncing() {
+    return this.syncing;
+  }
+  async upsertBatch(collection, batch) {
+    this.assertCollection(collection);
+    if (!this.online) {
+      throw new Error("upsertBatch requires online connection");
+    }
+    return this.withRestTimeout(this.restInterface.upsertBatch(collection, batch), "upsertBatch");
+  }
+  getMemoryCollection(collection) {
+    this.assertCollection(collection);
+    return this.inMemDb.getAll(collection);
+  }
+  getDebounceMs() {
+    return this.debounceMs;
+  }
+  assertCollection(name) {
+    if (!this.collections.has(name)) {
+      throw new Error(`Collection "${name}" not configured`);
+    }
+  }
+  stripLocalFields(item) {
+    const { _dirty, _localChangedAt, ...rest } = item;
+    return rest;
+  }
+  getPendingKey(collection, id) {
+    return `${collection}:${String(id)}`;
+  }
+  schedulePendingChange(collection, id, data, retryCount = 0) {
+    const key = this.getPendingKey(collection, id);
+    const existing = this.pendingChanges.get(key);
+    if (existing) {
+      clearTimeout(existing.timer);
+    }
+    const fullData = existing ? { ...existing.data, ...data } : { _id: id, ...data };
+    savePendingWrite(this.tenant, collection, id, fullData);
+    const timer = setTimeout(() => {
+      this.executePendingChange(key);
+    }, this.debounceMs);
+    const newRetryCount = retryCount > 0 ? retryCount : existing?.retryCount ?? 0;
+    this.pendingChanges.set(key, {
+      collection,
+      id,
+      data: fullData,
+      timer,
+      retryCount: newRetryCount
+    });
+  }
+  async executePendingChange(key) {
+    const pending = this.pendingChanges.get(key);
+    if (!pending)
+      return;
+    this.pendingChanges.delete(key);
+    try {
+      const existing = await this.dexieDb.getById(pending.collection, pending.id);
+      if (existing) {
+        await this.dexieDb.save(pending.collection, pending.id, pending.data);
+      } else {
+        await this.dexieDb.insert(pending.collection, {
+          _id: pending.id,
+          ...pending.data
+        });
+      }
+      clearPendingWrite(this.tenant, pending.collection, pending.id);
+    } catch (err) {
+      console.error("Failed to write to Dexie:", err);
+      const newRetryCount = pending.retryCount + 1;
+      if (newRetryCount >= MAX_RETRY_COUNT) {
+        console.error(`Max retry count (${MAX_RETRY_COUNT}) reached for pending change ${key}. ` + `Data remains in localStorage for crash recovery.`);
+        return;
+      }
+      this.schedulePendingChange(pending.collection, pending.id, pending.data, newRetryCount);
+    }
+  }
+  async flushAllPendingChanges() {
+    const promises = [];
+    for (const [key, pending] of this.pendingChanges) {
+      clearTimeout(pending.timer);
+      promises.push(this.executePendingChange(key));
+    }
+    await Promise.all(promises);
+  }
+  async recoverPendingWrites() {
+    const pending = getPendingWrites(this.tenant);
+    for (const write of pending) {
+      try {
+        const existing = await this.dexieDb.getById(write.collection, write.id);
+        if (existing) {
+          await this.dexieDb.save(write.collection, write.id, write.data);
+        } else {
+          await this.dexieDb.insert(write.collection, write.data);
+        }
+        clearPendingWrite(this.tenant, write.collection, write.id);
+      } catch (err) {
+        console.error("Failed to recover pending write:", err);
+      }
+    }
+  }
+  async syncSingleCollection(collectionName) {
+    const config = this.collections.get(collectionName);
+    if (!config)
+      return;
+    const meta = await this.dexieDb.getSyncMeta(collectionName);
+    const serverData = await this.restInterface.findNewer(collectionName, meta?.lastSyncTs || 0, config.query, { returnDeleted: true });
+    await this.syncCollectionWithData(collectionName, config, serverData);
+  }
+  async syncCollectionWithData(collectionName, config, serverData) {
+    let maxTs;
+    let conflictsResolved = 0;
+    const dexieBatch = [];
+    const inMemSaveBatch = [];
+    const inMemDeleteIds = [];
+    for (const serverItem of serverData) {
+      const localItem = await this.dexieDb.getById(collectionName, serverItem._id);
+      if (serverItem._ts) {
+        if (!maxTs || this.compareTimestamps(serverItem._ts, maxTs) > 0) {
+          maxTs = serverItem._ts;
+        }
+      }
+      if (localItem) {
+        if (localItem._dirty) {
+          conflictsResolved++;
+          const resolved = this.resolveCollectionConflict(collectionName, config, localItem, serverItem);
+          dexieBatch.push({
+            ...resolved,
+            _dirty: true,
+            _localChangedAt: localItem._localChangedAt
+          });
+          if (!resolved._deleted) {
+            inMemSaveBatch.push(this.stripLocalFields(resolved));
+          } else {
+            inMemDeleteIds.push(serverItem._id);
+          }
+        } else {
+          dexieBatch.push({
+            ...serverItem,
+            _dirty: false
+          });
+          if (!serverItem._deleted) {
+            inMemSaveBatch.push(this.stripLocalFields(serverItem));
+          } else {
+            inMemDeleteIds.push(serverItem._id);
+          }
+        }
+      } else {
+        dexieBatch.push({
+          ...serverItem,
+          _dirty: false
+        });
+        if (!serverItem._deleted) {
+          inMemSaveBatch.push(this.stripLocalFields(serverItem));
+        }
+      }
+    }
+    if (dexieBatch.length > 0) {
+      await this.dexieDb.saveMany(collectionName, dexieBatch);
+    }
+    if (inMemSaveBatch.length > 0) {
+      this.inMemDb.saveMany(collectionName, inMemSaveBatch);
+    }
+    for (const id of inMemDeleteIds) {
+      this.inMemDb.deleteOne(collectionName, id);
+    }
+    const dirtyItems = await this.dexieDb.getDirty(collectionName);
+    const deletedItems = dirtyItems.filter((item) => item._deleted);
+    const saveItems = dirtyItems.filter((item) => !item._deleted);
+    let sentCount = 0;
+    for (const item of deletedItems) {
+      try {
+        await this.restInterface.deleteOne(collectionName, { _id: item._id });
+        await this.dexieDb.deleteOne(collectionName, item._id);
+        sentCount++;
+      } catch (err) {
+        console.error(`Failed to sync deleted item ${String(item._id)}:`, err);
+      }
+    }
+    for (const item of saveItems) {
+      try {
+        const saved = await this.restInterface.save(collectionName, this.stripLocalFields(item), item._id);
+        await this.dexieDb.save(collectionName, item._id, {
+          ...saved,
+          _dirty: false
+        });
+        this.inMemDb.save(collectionName, item._id, this.stripLocalFields(saved));
+        if (saved._ts) {
+          if (!maxTs || this.compareTimestamps(saved._ts, maxTs) > 0) {
+            maxTs = saved._ts;
+          }
+        }
+        sentCount++;
+      } catch (err) {
+        console.error(`Failed to sync item ${String(item._id)}:`, err);
+      }
+    }
+    if (maxTs) {
+      await this.dexieDb.setSyncMeta(collectionName, maxTs);
+    }
+    return { conflictsResolved, sentCount };
+  }
+  resolveCollectionConflict(collectionName, config, local, external) {
+    if (config.resolveSyncConflict) {
+      return config.resolveSyncConflict(local, external);
+    }
+    return resolveConflict(local, external);
+  }
+  compareTimestamps(a, b) {
+    const aT = typeof a === "object" && "t" in a ? a.t : 0;
+    const bT = typeof b === "object" && "t" in b ? b.t : 0;
+    if (aT !== bT)
+      return aT - bT;
+    const aI = typeof a === "object" && "i" in a ? a.i : 0;
+    const bI = typeof b === "object" && "i" in b ? b.i : 0;
+    return aI - bI;
+  }
+  async handleServerUpdate(payload) {
+    const collectionName = payload.collection;
+    if (!this.collections.has(collectionName))
+      return;
+    switch (payload.operation) {
+      case "insert":
+      case "update": {
+        const items = await this.restInterface.findNewer(collectionName, 0, { _id: payload._id });
+        const serverItem = items[0];
+        if (serverItem) {
+          await this.handleServerItemUpdate(collectionName, serverItem);
+        }
+        break;
+      }
+      case "delete": {
+        await this.handleServerItemDelete(collectionName, payload._id);
+        break;
+      }
+      case "updateMany":
+      case "deleteMany": {
+        await this.syncSingleCollection(collectionName);
+        break;
+      }
+      case "batch": {
+        const deleteIds = [];
+        const updateIds = [];
+        for (const item of payload.data) {
+          if (item.operation === "delete") {
+            deleteIds.push(item._id);
+          } else {
+            updateIds.push(item._id);
+          }
+        }
+        if (deleteIds.length > 0) {
+          await Promise.all(deleteIds.map((id) => this.handleServerItemDelete(collectionName, id)));
+        }
+        if (updateIds.length > 0) {
+          const serverItems = await Promise.all(updateIds.map((id) => this.restInterface.findNewer(collectionName, 0, { _id: id }).then((items) => items[0])));
+          await Promise.all(serverItems.filter((item) => !!item).map((serverItem) => this.handleServerItemUpdate(collectionName, serverItem)));
+        }
+        break;
+      }
+    }
+  }
+  async handleServerItemUpdate(collectionName, serverItem) {
+    const localItem = await this.dexieDb.getById(collectionName, serverItem._id);
+    const pendingKey = this.getPendingKey(collectionName, serverItem._id);
+    const pendingChange = this.pendingChanges.get(pendingKey);
+    const hasPendingChanges = !!pendingChange;
+    if (hasPendingChanges) {
+      const currentMemItem = this.inMemDb.getById(collectionName, serverItem._id);
+      if (currentMemItem) {
+        const config = this.collections.get(collectionName);
+        const resolved = this.resolveCollectionConflict(collectionName, config, currentMemItem, serverItem);
+        if (!resolved._deleted) {
+          this.inMemDb.save(collectionName, serverItem._id, this.stripLocalFields(resolved));
+        }
+        pendingChange.data = {
+          ...pendingChange.data,
+          ...this.getNewFieldsFromServer(currentMemItem, serverItem)
+        };
+      }
+      return;
+    }
+    if (localItem) {
+      if (serverItem._lastUpdaterId === this.updaterId && serverItem._rev !== undefined && localItem._rev !== undefined && serverItem._rev === localItem._rev + 1) {
+        await this.dexieDb.save(collectionName, serverItem._id, {
+          _rev: serverItem._rev,
+          _ts: serverItem._ts,
+          _dirty: false
+        });
+        return;
+      }
+      if (localItem._dirty) {
+        const config = this.collections.get(collectionName);
+        const resolved = this.resolveCollectionConflict(collectionName, config, localItem, serverItem);
+        await this.dexieDb.save(collectionName, serverItem._id, {
+          ...resolved,
+          _dirty: true
+        });
+        if (!resolved._deleted) {
+          this.inMemDb.save(collectionName, serverItem._id, this.stripLocalFields(resolved));
+        }
+      } else {
+        await this.dexieDb.save(collectionName, serverItem._id, {
+          ...serverItem,
+          _dirty: false
+        });
+        if (!serverItem._deleted) {
+          this.inMemDb.save(collectionName, serverItem._id, this.stripLocalFields(serverItem));
+        } else {
+          this.inMemDb.deleteOne(collectionName, serverItem._id);
+        }
+      }
+    } else {
+      await this.dexieDb.insert(collectionName, {
+        ...serverItem,
+        _dirty: false
+      });
+      if (!serverItem._deleted) {
+        this.inMemDb.insert(collectionName, this.stripLocalFields(serverItem));
+      }
+    }
+  }
+  getNewFieldsFromServer(local, server) {
+    const newFields = {};
+    for (const key of Object.keys(server)) {
+      if (key !== "_id" && key !== "_dirty" && key !== "_localChangedAt" && local[key] === undefined) {
+        newFields[key] = server[key];
+      }
+    }
+    return newFields;
+  }
+  async handleServerItemDelete(collectionName, id) {
+    const localItem = await this.dexieDb.getById(collectionName, id);
+    if (!localItem)
+      return;
+    if (localItem._dirty) {
+      await this.dexieDb.save(collectionName, id, {
+        _deleted: new Date
+      });
+    } else {
+      await this.dexieDb.deleteOne(collectionName, id);
+    }
+    this.inMemDb.deleteOne(collectionName, id);
+  }
+}
+// src/db/DexieDb.ts
+import Dexie from "dexie";
+var SYNC_META_TABLE = "_sync_meta";
+
+class DexieDb extends Dexie {
+  tenant;
+  collections = new Map;
+  syncMeta;
+  constructor(tenant, collectionConfigs) {
+    super(`synced-db-${tenant}`);
+    this.tenant = tenant;
+    const schema = {};
+    schema[SYNC_META_TABLE] = "[tenant+collection]";
+    for (const config of collectionConfigs) {
+      const additionalIndexes = config.indexes || [];
+      const indexes = ["_id", "_dirty", ...additionalIndexes.map(String)];
+      schema[config.name] = indexes.join(", ");
+    }
+    this.version(1).stores(schema);
+    this.syncMeta = this.table(SYNC_META_TABLE);
+    for (const config of collectionConfigs) {
+      this.collections.set(config.name, this.table(config.name));
+    }
+  }
+  getTable(collection) {
+    const table = this.collections.get(collection);
+    if (!table) {
+      throw new Error(`Collection "${collection}" not configured`);
+    }
+    return table;
+  }
+  idToString(id) {
+    return String(id);
+  }
+  async save(collection, id, data) {
+    const table = this.getTable(collection);
+    const key = this.idToString(id);
+    const existing = await table.get(key);
+    if (existing) {
+      await table.update(key, {
+        ...data,
+        _dirty: true,
+        _localChangedAt: new Date
+      });
+    } else {
+      await table.put({
+        _id: id,
+        ...data,
+        _dirty: true,
+        _localChangedAt: new Date
+      });
+    }
+  }
+  async insert(collection, data) {
+    const table = this.getTable(collection);
+    await table.put({
+      ...data,
+      _dirty: true,
+      _localChangedAt: new Date
+    });
+  }
+  async saveMany(collection, items) {
+    if (items.length === 0)
+      return;
+    const table = this.getTable(collection);
+    await table.bulkPut(items);
+  }
+  async deleteOne(collection, id) {
+    const table = this.getTable(collection);
+    const key = this.idToString(id);
+    await table.delete(key);
+  }
+  async saveCollection(collection, data) {
+    const table = this.getTable(collection);
+    await table.clear();
+    if (data.length > 0) {
+      await table.bulkPut(data);
+    }
+  }
+  async deleteCollection(collection) {
+    const table = this.getTable(collection);
+    await table.clear();
+  }
+  async getById(collection, id) {
+    const table = this.getTable(collection);
+    const key = this.idToString(id);
+    return await table.get(key);
+  }
+  async getAll(collection) {
+    const table = this.getTable(collection);
+    return await table.toArray();
+  }
+  async count(collection) {
+    const table = this.getTable(collection);
+    return await table.count();
+  }
+  async getDirty(collection) {
+    const table = this.getTable(collection);
+    return await table.filter((item) => item._dirty === true).toArray();
+  }
+  async markDirty(collection, id) {
+    const table = this.getTable(collection);
+    const key = this.idToString(id);
+    await table.update(key, {
+      _dirty: true,
+      _localChangedAt: new Date
+    });
+  }
+  async markClean(collection, id) {
+    const table = this.getTable(collection);
+    const key = this.idToString(id);
+    await table.update(key, {
+      _dirty: false
+    });
+  }
+  async getSyncMeta(collection) {
+    return await this.syncMeta.get([this.tenant, collection]);
+  }
+  async setSyncMeta(collection, lastSyncTs) {
+    await this.syncMeta.put({
+      tenant: this.tenant,
+      collection,
+      lastSyncTs
+    });
+  }
+  async deleteSyncMeta(collection) {
+    await this.syncMeta.delete([this.tenant, collection]);
+  }
+  getTenant() {
+    return this.tenant;
+  }
+}
+// src/db/RestProxy.ts
+import { serialize } from "cry-helpers";
+import { encode, decode } from "notepack.io";
+var pack = (x) => encode(serialize.encode(x));
+var toBuffer = (x) => {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(x);
+  }
+  return x;
+};
+var unpack = (x) => serialize.decode(decode(toBuffer(x)));
+var DEFAULT_TIMEOUT = 5000;
+var DEFAULT_PROGRESS_CHUNK_SIZE = 16384;
+
+class RestProxy {
+  endpoint;
+  tenant;
+  apiKey;
+  defaultTimeoutMs;
+  audit;
+  timeRequests;
+  timeRequestsPrint;
+  onProgressCallback;
+  progressChunkSize;
+  globalSignal;
+  _lastRequestMs = 0;
+  _totalRequestMs = 0;
+  _requestCount = 0;
+  constructor(config) {
+    this.endpoint = config.endpoint;
+    this.tenant = config.tenant;
+    this.apiKey = config.apiKey;
+    this.defaultTimeoutMs = config.defaultTimeoutMs ?? DEFAULT_TIMEOUT;
+    this.audit = config.audit ?? {};
+    this.timeRequestsPrint = config.timeRequestsPrint ?? false;
+    this.timeRequests = config.timeRequests ?? this.timeRequestsPrint;
+    this.onProgressCallback = config.onProgressCallback;
+    this.progressChunkSize = config.progressChunkSize ?? DEFAULT_PROGRESS_CHUNK_SIZE;
+    this.globalSignal = config.signal;
+  }
+  setSignal(signal) {
+    this.globalSignal = signal;
+  }
+  async close() {}
+  setAudit(audit) {
+    this.audit = audit;
+  }
+  getLastRequestMs() {
+    return this._lastRequestMs;
+  }
+  getTotalRequestMs() {
+    return this._totalRequestMs;
+  }
+  getRequestCount() {
+    return this._requestCount;
+  }
+  resetTimingStats() {
+    this._lastRequestMs = 0;
+    this._totalRequestMs = 0;
+    this._requestCount = 0;
+  }
+  async restCall(operation, payload = {}, options) {
+    const timeout = options?.timeoutMs ?? this.defaultTimeoutMs;
+    const externalSignal = options?.signal ?? this.globalSignal;
+    const onProgress = options?.onProgress ?? this.onProgressCallback;
+    const startTime = this.timeRequests ? performance.now() : 0;
+    const data = {
+      payload: {
+        ...payload,
+        db: this.tenant,
+        operation
+      },
+      audit: {
+        tenant: this.tenant,
+        user: this.audit.user,
+        naprava: this.audit.device
+      }
+    };
+    const body = pack(data);
+    const totalBytes = body.byteLength;
+    const requestUrl = this.apiKey ? `${this.endpoint}?apikey=${this.apiKey}` : this.endpoint;
+    if (onProgress) {
+      onProgress(0, totalBytes);
+    }
+    if (onProgress) {
+      const numChunks = Math.ceil(totalBytes / this.progressChunkSize);
+      for (let i = 1;i <= numChunks; i++) {
+        const sentBytes = Math.min(i * this.progressChunkSize, totalBytes);
+        onProgress(sentBytes, totalBytes);
+      }
+    }
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const combinedSignal = externalSignal ? this.combineSignals(externalSignal, controller.signal) : controller.signal;
+    try {
+      const response = await fetch(requestUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/octet-stream"
+        },
+        body,
+        signal: combinedSignal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`REST call failed: ${response.status} - ${errorText}`);
+      }
+      const buffer = await response.arrayBuffer();
+      const result = unpack(new Uint8Array(buffer));
+      if (this.timeRequests) {
+        const elapsed = performance.now() - startTime;
+        this._lastRequestMs = elapsed;
+        this._totalRequestMs += elapsed;
+        this._requestCount++;
+        if (this.timeRequestsPrint) {
+          console.log(`[RestProxy] ${operation}: ${elapsed.toFixed(2)}ms (total: ${this._totalRequestMs.toFixed(2)}ms, count: ${this._requestCount})`);
+        }
+      }
+      return result;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err.name === "AbortError") {
+        if (controller.signal.aborted && !externalSignal?.aborted) {
+          throw new Error(`REST call timeout after ${timeout}ms: ${operation}`);
+        }
+        throw new Error(`REST call aborted: ${operation}`);
+      }
+      throw err;
+    }
+  }
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController;
+    const abort = () => controller.abort();
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+      return controller.signal;
+    }
+    signal1.addEventListener("abort", abort, { once: true });
+    signal2.addEventListener("abort", abort, { once: true });
+    return controller.signal;
+  }
+  async ping() {
+    try {
+      const result = await this.restCall("ping", {}, { timeoutMs: 100 });
+      return result !== undefined && result !== null;
+    } catch {
+      return false;
+    }
+  }
+  async findNewer(collection, timestamp, query, opts) {
+    return await this.restCall("findNewer", {
+      collection,
+      timestamp,
+      query,
+      opts
+    });
+  }
+  async findNewerMany(spec) {
+    return await this.restCall("findNewerMany", { spec });
+  }
+  async latestTimestamp(collection) {
+    return await this.restCall("latestTimestamp", {
+      collection
+    });
+  }
+  async latestTimestamps(collections) {
+    return await this.restCall("latestTimestamps", {
+      collections
+    });
+  }
+  async save(collection, update, id) {
+    return await this.restCall("save", {
+      collection,
+      update,
+      id: id ? String(id) : undefined
+    });
+  }
+  async insert(collection, insert) {
+    return await this.restCall("insert", { collection, insert });
+  }
+  async deleteOne(collection, query) {
+    return await this.restCall("deleteOne", { collection, query });
+  }
+  async aggregate(collection, pipeline, opts) {
+    return await this.restCall("aggregate", { collection, pipeline, opts });
+  }
+  async upsertBatch(collection, batch) {
+    return await this.restCall("upsertBatch", { collection, batch });
+  }
+}
+export {
+  resolveConflict,
+  matchesQuery,
+  filterByQuery,
+  SyncedDb,
+  RestProxy,
+  DexieDb,
+  Dexie2 as Dexie
+};