core: do not update dateModified when setting synced=true

packages/core/src/api/sync/collector.ts

@@ -57,37 +57,34 @@ class Collector {
       const collection = this.db[collectionKey].collection;
       let pushTimestamp = Date.now();
       for await (const chunk of collection.unsynced(chunkSize, isForceSync)) {
-        const items = await this.prepareChunk(chunk, key);
+        const { ids, items: syncableItems } = filterSyncableItems(chunk);
+        if (!ids.length) continue;
+        const ciphers = await this.db
+          .storage()
+          .encryptMulti(key, syncableItems);
+        const items = toPushItem(ids, ciphers);
         if (!items) continue;
         yield { items, type: itemType };
 
-        await collection.update(
-          chunk.map((i) => i.id),
-          { synced: true },
-          {
-            sendEvent: false,
-            // EDGE CASE:
-            // Sometimes an item can get updated while it's being pushed.
-            // The result is that its `synced` property becomes true even
-            // though it's modification wasn't yet synced.
-            // In order to prevent that, we only set the `synced` property
-            // to true for items that haven't been modified since we last ran
-            // the push. Everything else will be collected again in the next
-            // push.
-            condition: (eb) => eb("dateModified", "<=", pushTimestamp)
-          }
-        );
+        await this.db
+          .sql()
+          .updateTable(collection.type)
+          .where("id", "in", ids)
+          // EDGE CASE:
+          // Sometimes an item can get updated while it's being pushed.
+          // The result is that its `synced` property becomes true even
+          // though it's modification wasn't yet synced.
+          // In order to prevent that, we only set the `synced` property
+          // to true for items that haven't been modified since we last ran
+          // the push. Everything else will be collected again in the next
+          // push.
+          .where("dateModified", "<=", pushTimestamp)
+          .set({ synced: true })
+          .execute();
         pushTimestamp = Date.now();
       }
     }
   }
-
-  async prepareChunk(chunk: MaybeDeletedItem<Item>[], key: SerializedKey) {
-    const { ids, items } = filterSyncableItems(chunk);
-    if (!ids.length) return;
-    const ciphers = await this.db.storage().encryptMulti(key, items);
-    return toPushItem(ids, ciphers);
-  }
 }
 export default Collector;
 

packages/core/src/database/index.ts

@@ -160,6 +160,7 @@ type AsyncOrSyncResult<Async extends boolean, Response> = Async extends true
   : Response;
 
 export interface DatabaseCollection<T, IsAsync extends boolean> {
+  type: keyof DatabaseSchema;
   clear(): Promise<void>;
   init(): Promise<void>;
   upsert(item: T): Promise<void>;

packages/core/src/database/sql-cached-collection.ts

@@ -38,7 +38,7 @@ export class SQLCachedCollection<
     startTransaction: (
       executor: (tr: Kysely<DatabaseSchema>) => Promise<void>
     ) => Promise<void>,
-    type: TCollectionType,
+    public type: TCollectionType,
     eventManager: EventManager,
     sanitizer: Sanitizer
   ) {

packages/core/src/database/sql-collection.ts

@@ -75,7 +75,7 @@ export class SQLCollection<
     _startTransaction: (
       executor: (tr: Kysely<DatabaseSchema>) => Promise<void>
     ) => Promise<void>,
-    private readonly type: TCollectionType,
+    public readonly type: TCollectionType,
     private readonly eventManager: EventManager,
     private readonly sanitizer: Sanitizer
   ) {}