@anfenn/dync 1.1.1 → 1.2.1

package/dist/index.cjs

@@ -360,6 +360,174 @@ function cloneRecord(record) {
   return { ...record };
 }
 
+// src/core/SyncAwareWhereClause.ts
+var SyncAwareWhereClause = class {
+  constructor(inner, tableRef) {
+    this.inner = inner;
+    this.tableRef = tableRef;
+  }
+  wrap(col) {
+    return new SyncAwareCollection(col, this.tableRef);
+  }
+  equals(value) {
+    return this.wrap(this.inner.equals(value));
+  }
+  above(value) {
+    return this.wrap(this.inner.above(value));
+  }
+  aboveOrEqual(value) {
+    return this.wrap(this.inner.aboveOrEqual(value));
+  }
+  below(value) {
+    return this.wrap(this.inner.below(value));
+  }
+  belowOrEqual(value) {
+    return this.wrap(this.inner.belowOrEqual(value));
+  }
+  between(lower, upper, includeLower, includeUpper) {
+    return this.wrap(this.inner.between(lower, upper, includeLower, includeUpper));
+  }
+  inAnyRange(ranges, options) {
+    return this.wrap(this.inner.inAnyRange(ranges, options));
+  }
+  startsWith(prefix) {
+    return this.wrap(this.inner.startsWith(prefix));
+  }
+  startsWithIgnoreCase(prefix) {
+    return this.wrap(this.inner.startsWithIgnoreCase(prefix));
+  }
+  startsWithAnyOf(...args) {
+    return this.wrap(this.inner.startsWithAnyOf(...args));
+  }
+  startsWithAnyOfIgnoreCase(...args) {
+    return this.wrap(this.inner.startsWithAnyOfIgnoreCase(...args));
+  }
+  equalsIgnoreCase(value) {
+    return this.wrap(this.inner.equalsIgnoreCase(value));
+  }
+  anyOf(...args) {
+    return this.wrap(this.inner.anyOf(...args));
+  }
+  anyOfIgnoreCase(...args) {
+    return this.wrap(this.inner.anyOfIgnoreCase(...args));
+  }
+  noneOf(...args) {
+    return this.wrap(this.inner.noneOf(...args));
+  }
+  notEqual(value) {
+    return this.wrap(this.inner.notEqual(value));
+  }
+};
+
+// src/core/SyncAwareCollection.ts
+var SyncAwareCollection = class _SyncAwareCollection {
+  constructor(inner, tableRef) {
+    this.inner = inner;
+    this.tableRef = tableRef;
+  }
+  wrap(col) {
+    return new _SyncAwareCollection(col, this.tableRef);
+  }
+  // ---- read-only / pass-through ----
+  first() {
+    return this.inner.first();
+  }
+  last() {
+    return this.inner.last();
+  }
+  each(cb) {
+    return this.inner.each(cb);
+  }
+  eachKey(cb) {
+    return this.inner.eachKey(cb);
+  }
+  eachPrimaryKey(cb) {
+    return this.inner.eachPrimaryKey(cb);
+  }
+  eachUniqueKey(cb) {
+    return this.inner.eachUniqueKey(cb);
+  }
+  keys() {
+    return this.inner.keys();
+  }
+  primaryKeys() {
+    return this.inner.primaryKeys();
+  }
+  uniqueKeys() {
+    return this.inner.uniqueKeys();
+  }
+  count() {
+    return this.inner.count();
+  }
+  sortBy(key) {
+    return this.inner.sortBy(key);
+  }
+  toArray() {
+    return this.inner.toArray();
+  }
+  // ---- chaining — preserve sync-awareness ----
+  distinct() {
+    return this.wrap(this.inner.distinct());
+  }
+  clone(props) {
+    return this.wrap(this.inner.clone(props));
+  }
+  reverse() {
+    return this.wrap(this.inner.reverse());
+  }
+  offset(n) {
+    return this.wrap(this.inner.offset(n));
+  }
+  limit(n) {
+    return this.wrap(this.inner.limit(n));
+  }
+  toCollection() {
+    return this.wrap(this.inner.toCollection());
+  }
+  jsFilter(predicate) {
+    return this.wrap(this.inner.jsFilter(predicate));
+  }
+  or(index) {
+    return new SyncAwareWhereClause(this.inner.or(index), this.tableRef);
+  }
+  // ---- sync-aware mutations ----
+  async delete() {
+    const records = await this.inner.toArray();
+    if (records.length === 0) return 0;
+    const keys = records.map((r) => r._localId);
+    await this.tableRef.bulkDelete(keys);
+    return records.length;
+  }
+  async modify(changes) {
+    const records = await this.inner.toArray();
+    if (records.length === 0) return 0;
+    if (typeof changes === "function") {
+      const keysAndChanges = [];
+      for (const record of records) {
+        const draft = { ...record };
+        await changes(draft);
+        const delta = {};
+        const allKeys = /* @__PURE__ */ new Set([...Object.keys(record), ...Object.keys(draft)]);
+        for (const key of allKeys) {
+          if (draft[key] !== record[key]) {
+            delta[key] = draft[key];
+          }
+        }
+        if (Object.keys(delta).length > 0) {
+          keysAndChanges.push({ key: record._localId, changes: delta });
+        }
+      }
+      if (keysAndChanges.length > 0) {
+        await this.tableRef.bulkUpdate(keysAndChanges);
+      }
+    } else {
+      const keysAndChanges = records.map((r) => ({ key: r._localId, changes }));
+      await this.tableRef.bulkUpdate(keysAndChanges);
+    }
+    return records.length;
+  }
+};
+
 // src/core/tableEnhancers.ts
 function wrapWithMutationEmitter(table, tableName, emitMutation) {
   const rawAdd = table.raw.add;
@@ -730,6 +898,18 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
   table.bulkUpdate = wrappedBulkUpdate;
   table.bulkDelete = wrappedBulkDelete;
   table.clear = wrappedClear;
+  const originalWhere = table.where.bind(table);
+  const originalOrderBy = table.orderBy.bind(table);
+  const originalReverse = table.reverse.bind(table);
+  const originalOffset = table.offset.bind(table);
+  const originalLimit = table.limit.bind(table);
+  const originalJsFilter = table.jsFilter.bind(table);
+  table.where = (index) => new SyncAwareWhereClause(originalWhere(index), table);
+  table.orderBy = (index) => new SyncAwareCollection(originalOrderBy(index), table);
+  table.reverse = () => new SyncAwareCollection(originalReverse(), table);
+  table.offset = (n) => new SyncAwareCollection(originalOffset(n), table);
+  table.limit = (n) => new SyncAwareCollection(originalLimit(n), table);
+  table.jsFilter = (predicate) => new SyncAwareCollection(originalJsFilter(predicate), table);
   enhancedTables.add(tableName);
 }
 
@@ -1097,7 +1277,11 @@ async function processBatchPushResult(change, result, ctx) {
   const { action, tableName, localId } = change;
   if (!result.success) {
     if (action === "update" /* Update */) {
-      await handleMissingRemoteRecord(change, ctx);
+      if (!result.error) {
+        await handleMissingRemoteRecord(change, ctx);
+      } else {
+        ctx.logger.warn(`[dync] push:batch:update-failed tableName=${tableName} localId=${localId} error=${result.error}`);
+      }
     } else {
       ctx.logger.warn(`[dync] push:batch:failed tableName=${tableName} localId=${localId} error=${result.error}`);
     }
@@ -1105,10 +1289,10 @@ async function processBatchPushResult(change, result, ctx) {
   }
   switch (action) {
     case "remove" /* Remove */:
-      handleRemoveSuccess(change, ctx);
+      await handleRemoveSuccess(change, ctx);
       break;
     case "update" /* Update */:
-      handleUpdateSuccess(change, ctx);
+      await handleUpdateSuccess(change, ctx);
       break;
     case "create" /* Create */: {
       const serverResult = { id: result.id };
@@ -2556,22 +2740,9 @@ var normalizeComparableValue = (value) => {
 
 // src/storage/sqlite/SQLiteQueryContext.ts
 var SQLiteQueryContext = class {
-  constructor(driver, adapter) {
-    this.driver = driver;
+  constructor(adapter) {
     this.adapter = adapter;
   }
-  table(name) {
-    return this.adapter.table(name);
-  }
-  transaction(mode, tableNames, callback) {
-    return this.adapter.transaction(mode, tableNames, callback);
-  }
-  async execute(statement) {
-    return this.driver.execute(statement);
-  }
-  async run(statement, values) {
-    return this.driver.run(statement, values);
-  }
   async queryRows(statement, values) {
     return this.adapter.queryRows(statement, values);
   }
@@ -2740,8 +2911,7 @@ var SQLiteAdapter2 = class {
   }
   async query(arg1, arg2) {
     if (typeof arg1 === "function") {
-      const driver2 = await this.getDriver();
-      return arg1(new SQLiteQueryContext(driver2, this));
+      return arg1(new SQLiteQueryContext(this));
     }
     const statement = arg1;
     const values = arg2;
@@ -2821,12 +2991,8 @@ var SQLiteAdapter2 = class {
     if (!debug) {
       return;
     }
-    const hasParams = parameters && parameters.length;
-    if (typeof debug === "function") {
-      debug(statement, hasParams ? parameters : void 0);
-      return;
-    }
     if (debug === true) {
+      const hasParams = parameters && parameters.length;
       if (hasParams) {
         console.debug("[dync][sqlite]", statement, parameters);
       } else {