Support column filters

Author: simolus3

packages/common/src/db/schema/Table.ts

@@ -14,11 +14,23 @@ interface SharedTableOptions {
   localOnly?: boolean;
   insertOnly?: boolean;
   viewName?: string;
-  includeOld?: boolean | 'when-changed';
+  includeOld?: boolean | IncludeOldOptions;
   includeMetadata?: boolean;
   ignoreEmptyUpdate?: boolean;
 }
 
+/** Whether to include old columns when PowerSync tracks local changes.
+ *
+ * Including old columns may be helpful for some backend connector implementations, which is
+ * why it can be enabled on per-table or per-columm basis.
+ */
+export interface IncludeOldOptions {
+  /** When defined, a list of column names for which old values should be tracked. */
+  columns?: string[];
+  /** When enabled, only include values that have actually been changed by an update. */
+  onlyWhenChanged?: boolean;
+}
+
 export interface TableOptions extends SharedTableOptions {
   /**
    * The synced table name, matching sync rules
@@ -329,13 +341,15 @@ export class Table<Columns extends ColumnsType = ColumnsType> {
   }
 
   toJSON() {
+    const includeOld = this.includeOld;
+
     return {
       name: this.name,
       view_name: this.viewName,
       local_only: this.localOnly,
       insert_only: this.insertOnly,
-      include_old: this.includeOld != false,
-      include_old_only_when_changed: this.includeOld == 'when-changed',
+      include_old: includeOld && ((includeOld as any).columns ?? true),
+      include_old_only_when_changed: typeof includeOld == 'object' && includeOld.onlyWhenChanged == true,
       include_metadata: this.includeMetadata,
       ignore_empty_update: this.ignoreEmptyUpdate,
       columns: this.columns.map((c) => c.toJSON()),

packages/common/tests/db/schema/Table.test.ts

@@ -140,8 +140,13 @@ describe('Table', () => {
 
     expect(createTable({ includeOld: true }).toJSON().include_old).toBe(true);
     expect(createTable({ includeOld: true }).toJSON().include_old_only_when_changed).toBe(false);
-    expect(createTable({ includeOld: 'when-changed' }).toJSON().include_old).toBe(true);
-    expect(createTable({ includeOld: 'when-changed' }).toJSON().include_old_only_when_changed).toBe(true);
+
+    const complexIncldueOld = createTable({ includeOld: {
+      columns: ['foo', 'bar'],
+      onlyWhenChanged: true,
+    } });
+    expect(complexIncldueOld.toJSON().include_old).toStrictEqual(['foo', 'bar']);
+    expect(complexIncldueOld.toJSON().include_old_only_when_changed).toBe(true);
 
     expect(createTable({ ignoreEmptyUpdate: true }).toJSON().ignore_empty_update).toBe(true);
   });
@@ -220,7 +225,7 @@ describe('Table', () => {
           {
             name: column.text
           },
-          { localOnly: true, includeOld: 'when-changed' }
+          { localOnly: true, includeOld: { onlyWhenChanged: false } }
         ).validate()
       ).toThrowError("Can't include old values for local-only tables.");
     });

packages/node/tests/crud.test.ts

@@ -38,6 +38,26 @@ databaseTest('include old values', async ({ database }) => {
   expect(batch?.crud[0].oldData).toStrictEqual({name: 'entry'});
 });
 
+databaseTest('include old values with column filter', async ({ database }) => {
+  await database.init();
+  const schema = new Schema({
+    lists: new Table(
+      {
+        name: column.text,
+        content: column.text
+      },
+      { includeOld: { columns: ['name'] } }
+    )
+  });
+  await database.updateSchema(schema);
+  await database.execute('INSERT INTO lists (id, name, content) VALUES (uuid(), ?, ?);', ['name', 'content']);
+  await database.execute('DELETE FROM ps_crud;');
+  await database.execute('UPDATE lists SET name = ?, content = ?', ['new name', 'new content']);
+ 
+  const batch = await database.getNextCrudTransaction();
+  expect(batch?.crud[0].oldData).toStrictEqual({name: 'name'});
+});
+
 databaseTest('include old values when changed', async ({ database }) => {
   await database.init();
   const schema = new Schema({
@@ -46,7 +66,7 @@ databaseTest('include old values when changed', async ({ database }) => {
         name: column.text,
         content: column.text
       },
-      { includeOld: 'when-changed' }
+      { includeOld: { onlyWhenChanged: true } }
     )
   });
   await database.updateSchema(schema);