Add tests for created triggers

simolus3 · simolus3 · commit 60ed658d30b5 · 2026-02-11T12:05:02.000+01:00
diff --git a/crates/core/src/schema/common.rs b/crates/core/src/schema/common.rs
@@ -6,6 +6,8 @@ use crate::schema::{
     Column, CommonTableOptions, RawTable, Table, raw_table::InferredTableStructure,
 };
 
+/// Utility to wrap both PowerSync-managed JSON tables and raw tables (with their schema snapshot
+/// inferred from reading `pragma_table_info`) into a common implementation.
 pub enum SchemaTable<'a> {
     Json(&'a Table),
     Raw {
@@ -25,6 +27,7 @@ impl<'a> SchemaTable<'a> {
         }
     }
 
+    /// Iterates over defined column names in this table (not including the `id` column).
     pub fn column_names(&self) -> impl Iterator<Item = &'a str> {
         match self {
             Self::Json(table) => SchemaTableColumnIterator::Json(table.columns.iter()),
diff --git a/crates/core/src/schema/mod.rs b/crates/core/src/schema/mod.rs
@@ -15,7 +15,9 @@ pub use table_info::{
 };
 
 use crate::{
-    error::PowerSyncError, schema::raw_table::generate_raw_table_trigger, state::DatabaseState,
+    error::{PSResult, PowerSyncError},
+    schema::raw_table::generate_raw_table_trigger,
+    state::DatabaseState,
     utils::WriteType,
 };
 
@@ -43,7 +45,7 @@ pub fn register(db: *mut sqlite::sqlite3, state: Rc<DatabaseState>) -> Result<()
             let db = context.db_handle();
             let create_trigger_stmt =
                 generate_raw_table_trigger(db, &table, trigger_name, write_type)?;
-            db.exec_safe(&create_trigger_stmt)?;
+            db.exec_safe(&create_trigger_stmt).into_db_result(db)?;
             Ok(())
         }
 
diff --git a/crates/core/src/schema/raw_table.rs b/crates/core/src/schema/raw_table.rs
@@ -1,4 +1,4 @@
-use core::fmt::from_fn;
+use core::fmt::{self, Formatter, from_fn};
 
 use alloc::{
     format,
@@ -105,6 +105,20 @@ pub fn generate_raw_table_trigger(
             None
         };
 
+        let write_data = from_fn(|f: &mut Formatter| -> fmt::Result {
+            write!(f, "json(powersync_diff(")?;
+
+            if let Some(ref old) = json_fragment_old {
+                f.write_str(old)?;
+            } else {
+                // We don't have OLD values for inserts, we diff from an empty JSON object
+                // instead.
+                f.write_str("'{}'")?;
+            };
+
+            write!(f, ", {json_fragment_new}))")
+        });
+
         buffer.insert_into_powersync_crud(InsertIntoCrud {
             op: write,
             table: &as_schema_table,
@@ -114,32 +128,11 @@ pub fn generate_raw_table_trigger(
                 "NEW.id"
             },
             type_name: &table.name,
-            data: Some(&from_fn(|f| {
-                match write {
-                    WriteType::Insert => {}
-                    WriteType::Update => todo!(),
-                    WriteType::Delete => {
-                        // There is no data for deleted rows, don't emit anything.
-                    }
-                }
-
-                if write == WriteType::Delete {
-                    // There is no data for deleted rows.
-                    return Ok(());
-                }
-
-                write!(f, "json(powersync_diff(")?;
-
-                if let Some(ref old) = json_fragment_old {
-                    f.write_str(old)?;
-                } else {
-                    // We don't have OLD values for inserts, we diff from an empty JSON object
-                    // instead.
-                    f.write_str("'{}'")?;
-                };
-
-                write!(f, ", {json_fragment_new}))")
-            })),
+            data: match write {
+                // There is no data for deleted rows.
+                WriteType::Delete => None,
+                _ => Some(&write_data),
+            },
             metadata: None::<&'static str>,
         })?;
     }
diff --git a/crates/core/src/utils/sql_buffer.rs b/crates/core/src/utils/sql_buffer.rs
@@ -127,7 +127,9 @@ impl SqlBuffer {
                         include_old.column_filter(),
                     )?;
 
-                    if options.flags.include_old_only_when_changed() {
+                    if insert.op == WriteType::Update
+                        && options.flags.include_old_only_when_changed()
+                    {
                         // When include_old_only_when_changed is combined with a column filter, make sure we
                         // only include the powersync_diff of columns matched by the filter.
                         let filtered_new_fragment = table_columns_to_json_object_with_filter(
diff --git a/dart/test/crud_test.dart b/dart/test/crud_test.dart
@@ -4,6 +4,7 @@ import 'package:sqlite3/common.dart';
 import 'package:test/test.dart';
 
 import 'utils/native_test_utils.dart';
+import 'utils/test_utils.dart';
 
 void main() {
   group('crud tests', () {
@@ -774,5 +775,176 @@ void main() {
         expect(db.select('SELECT * FROM ps_crud'), isEmpty);
       });
     });
+
+    group('raw tables', () {
+      void createRawTableTriggers(Object table,
+          {bool insert = true, bool update = true, bool delete = true}) {
+        db.execute('SELECT powersync_init()');
+
+        if (insert) {
+          db.execute('SELECT powersync_create_raw_table_crud_trigger(?, ?, ?)',
+              [json.encode(table), 'test_trigger_insert', 'INSERT']);
+        }
+        if (update) {
+          db.execute('SELECT powersync_create_raw_table_crud_trigger(?, ?, ?)',
+              [json.encode(table), 'test_trigger_update', 'UPDATE']);
+        }
+        if (delete) {
+          db.execute('SELECT powersync_create_raw_table_crud_trigger(?, ?, ?)',
+              [json.encode(table), 'test_trigger_delete', 'DELETE']);
+        }
+      }
+
+      Object rawTableDescription(Map<String, Object?> options) {
+        return {
+          'name': 'row_type',
+          'put': {'sql': '', 'params': []},
+          'delete': {'sql': '', 'params': []},
+          ...options,
+        };
+      }
+
+      test('missing id column', () {
+        db.execute('CREATE TABLE users (name TEXT);');
+        expect(
+          () => createRawTableTriggers(
+              rawTableDescription({'table_name': 'users'})),
+          throwsA(isSqliteException(
+              3091, contains('Table users has no id column'))),
+        );
+      });
+
+      test('missing local table name', () {
+        db.execute('CREATE TABLE users (name TEXT);');
+        expect(
+          () => createRawTableTriggers(rawTableDescription({})),
+          throwsA(isSqliteException(3091, contains('Table has no local name'))),
+        );
+      });
+
+      test('missing local table', () {
+        expect(
+          () => createRawTableTriggers(
+              rawTableDescription({'table_name': 'users'})),
+          throwsA(isSqliteException(
+              3091, contains('Could not find users in local schema'))),
+        );
+      });
+
+      test('default options', () {
+        db.execute('CREATE TABLE users (id TEXT, name TEXT) STRICT;');
+        createRawTableTriggers(rawTableDescription({'table_name': 'users'}));
+
+        db
+          ..execute(
+              'INSERT INTO users (id, name) VALUES (?, ?)', ['id', 'name'])
+          ..execute('UPDATE users SET name = ?', ['new name'])
+          ..execute('DELETE FROM users WHERE id = ?', ['id']);
+
+        final psCrud = db.select('SELECT * FROM ps_crud');
+        expect(psCrud, [
+          {
+            'id': 1,
+            'tx_id': 1,
+            'data': json.encode({
+              'op': 'PUT',
+              'id': 'id',
+              'type': 'row_type',
+              'data': {'name': 'name'}
+            }),
+          },
+          {
+            'id': 2,
+            'tx_id': 2,
+            'data': json.encode({
+              'op': 'PATCH',
+              'id': 'id',
+              'type': 'row_type',
+              'data': {'name': 'new name'}
+            }),
+          },
+          {
+            'id': 3,
+            'tx_id': 3,
+            'data':
+                json.encode({'op': 'DELETE', 'id': 'id', 'type': 'row_type'}),
+          },
+        ]);
+      });
+
+      test('insert only', () {
+        db.execute('CREATE TABLE users (id TEXT, name TEXT) STRICT;');
+        createRawTableTriggers(
+            rawTableDescription({'table_name': 'users', 'insert_only': true}));
+
+        db.execute(
+            'INSERT INTO users (id, name) VALUES (?, ?)', ['id', 'name']);
+        expect(db.select('SELECT * FROM ps_crud'), hasLength(1));
+
+        // Should not update the $local bucket
+        expect(db.select('SELECT * FROM ps_buckets'), hasLength(0));
+
+        // The trigger should prevent other writes.
+        expect(
+            () => db.execute('UPDATE users SET name = ?', ['new name']),
+            throwsA(isSqliteException(
+                1811, contains('Unexpected update on insert-only table'))));
+        expect(
+            () => db.execute('DELETE FROM users WHERE id = ?', ['id']),
+            throwsA(isSqliteException(
+                1811, contains('Unexpected update on insert-only table'))));
+      });
+
+      test('tracking old values', () {
+        db.execute(
+            'CREATE TABLE users (id TEXT, name TEXT, email TEXT) STRICT;');
+        createRawTableTriggers(rawTableDescription({
+          'table_name': 'users',
+          'include_old': ['name'],
+          'include_old_only_when_changed': true,
+        }));
+
+        db
+          ..execute('INSERT INTO users (id, name, email) VALUES (?, ?, ?)',
+              ['id', 'name', 'test@example.org'])
+          ..execute('UPDATE users SET name = ?, email = ?',
+              ['new name', 'newmail@example.org'])
+          ..execute('DELETE FROM users WHERE id = ?', ['id']);
+
+        final psCrud = db.select(
+            r"SELECT id, data->>'$.op' AS op, data->>'$.old' as old FROM ps_crud");
+        expect(psCrud, [
+          {
+            'id': 1,
+            'op': 'PUT',
+            'old': null,
+          },
+          {
+            'id': 2,
+            'op': 'PATCH',
+            'old': json.encode({'name': 'name'}),
+          },
+          {
+            'id': 3,
+            'op': 'DELETE',
+            'old': json.encode({'name': 'new name'}),
+          },
+        ]);
+      });
+
+      test('skipping empty updates', () {
+        db.execute('CREATE TABLE users (id TEXT, name TEXT) STRICT;');
+        createRawTableTriggers(rawTableDescription(
+            {'table_name': 'users', 'ignore_empty_update': true}));
+
+        db.execute(
+            'INSERT INTO users (id, name) VALUES (?, ?)', ['id', 'name']);
+        expect(db.select('SELECT * FROM ps_crud'), hasLength(1));
+
+        // Empty update should not be recorded
+        db.execute('UPDATE users SET name = ?', ['name']);
+        expect(db.select('SELECT * FROM ps_crud'), hasLength(1));
+      });
+    });
   });
 }

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@ use crate::schema::{`
`6`	`6`	`Column, CommonTableOptions, RawTable, Table, raw_table::InferredTableStructure,`
`7`	`7`	`};`
`8`	`8`
	`9`	`+/// Utility to wrap both PowerSync-managed JSON tables and raw tables (with their schema snapshot`
	`10`	+/// inferred from reading `pragma_table_info`) into a common implementation.
`9`	`11`	`pub enum SchemaTable<'a> {`
`10`	`12`	`Json(&'a Table),`
`11`	`13`	`Raw {`
`@@ -25,6 +27,7 @@ impl<'a> SchemaTable<'a> {`
`25`	`27`	`}`
`26`	`28`	`}`
`27`	`29`
	`30`	+ /// Iterates over defined column names in this table (not including the `id` column).
`28`	`31`	`pub fn column_names(&self) -> impl Iterator<Item = &'a str> {`
`29`	`32`	`match self {`
`30`	`33`	`Self::Json(table) => SchemaTableColumnIterator::Json(table.columns.iter()),`