@powersync/service-core 0.0.2

package/test/src/slow_tests.test.ts

@@ -0,0 +1,257 @@
+import * as bson from 'bson';
+import * as mongo from 'mongodb';
+import { afterEach, describe, expect, test } from 'vitest';
+import { WalStream, WalStreamOptions } from '../../src/replication/WalStream.js';
+import { getClientCheckpoint } from '../../src/util/utils.js';
+import { env } from './env.js';
+import { MONGO_STORAGE_FACTORY, StorageFactory, TEST_CONNECTION_OPTIONS, connectPgPool } from './util.js';
+
+import * as pgwire from '@powersync/service-jpgwire';
+import { SqliteRow } from '@powersync/service-sync-rules';
+import { MongoBucketStorage } from '../../src/storage/MongoBucketStorage.js';
+import { PgManager } from '../../src/util/PgManager.js';
+
+describe('slow tests - mongodb', function () {
+  // These are slow, inconsistent tests.
+  // Not run on every test run, but we do run on CI, or when manually debugging issues.
+  if (env.CI || env.SLOW_TESTS) {
+    defineSlowTests(MONGO_STORAGE_FACTORY);
+  } else {
+    // Need something in this file.
+    test('no-op', () => {});
+  }
+});
+
+function defineSlowTests(factory: StorageFactory) {
+  let walStream: WalStream | undefined;
+  let connections: PgManager | undefined;
+  let abortController: AbortController | undefined;
+  let streamPromise: Promise<void> | undefined;
+
+  afterEach(async () => {
+    // This cleans up, similar to WalStreamTestContext.dispose().
+    // These tests are a little more complex than what is supported by WalStreamTestContext.
+    abortController?.abort();
+    await streamPromise;
+    streamPromise = undefined;
+    connections?.destroy();
+
+    connections = undefined;
+    walStream = undefined;
+    abortController = undefined;
+  });
+
+  const TEST_DURATION_MS = 15_000;
+  const TIMEOUT_MARGIN_MS = env.CI ? 30_000 : 15_000;
+
+  // Test repeatedly replicating inserts and deletes, then check that we get
+  // consistent data out at the end.
+  //
+  // Past issues that this could reproduce intermittently:
+  // * Skipping LSNs after a keepalive message
+  // * Skipping LSNs when source transactions overlap
+  test(
+    'repeated replication',
+    async () => {
+      const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
+      const replicationConnection = await connections.replicationConnection();
+      const pool = connections.pool;
+      const f = (await factory()) as MongoBucketStorage;
+
+      const syncRuleContent = `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test_data"
+`;
+      const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+      const storage = f.getInstance(syncRules.parsed());
+      abortController = new AbortController();
+      const options: WalStreamOptions = {
+        abort_signal: abortController.signal,
+        connections,
+        storage: storage,
+        factory: f
+      };
+      walStream = new WalStream(options);
+
+      await pool.query(`DROP TABLE IF EXISTS test_data`);
+      await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
+
+      await walStream.initReplication(replicationConnection);
+      await storage.autoActivate();
+      let abort = false;
+      streamPromise = walStream.streamChanges(replicationConnection).finally(() => {
+        abort = true;
+      });
+      const start = Date.now();
+
+      while (!abort && Date.now() - start < TEST_DURATION_MS) {
+        const bg = async () => {
+          for (let j = 0; j < 5 && !abort; j++) {
+            const n = Math.floor(Math.random() * 50);
+            let statements: pgwire.Statement[] = [];
+            for (let i = 0; i < n; i++) {
+              const description = `test${i}`;
+              statements.push({
+                statement: `INSERT INTO test_data(description) VALUES($1) returning id as test_id`,
+                params: [{ type: 'varchar', value: description }]
+              });
+            }
+            const results = await pool.query(...statements);
+            const ids = results.results.map((sub) => {
+              return sub.rows[0][0] as string;
+            });
+            await new Promise((resolve) => setTimeout(resolve, Math.random() * 30));
+
+            const deleteStatements: pgwire.Statement[] = ids.map((id) => {
+              return {
+                statement: `DELETE FROM test_data WHERE id = $1`,
+                params: [{ type: 'uuid', value: id }]
+              };
+            });
+            await pool.query(...deleteStatements);
+
+            await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
+          }
+        };
+
+        // Call the above loop multiple times concurrently
+        let promises = [1, 2, 3].map((i) => bg());
+        await Promise.all(promises);
+
+        // Wait for replication to finish
+        let checkpoint = await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
+
+        // Check that all inserts have been deleted again
+        const docs = await f.db.current_data.find().toArray();
+        const transformed = docs.map((doc) => {
+          return bson.deserialize((doc.data as mongo.Binary).buffer) as SqliteRow;
+        });
+        expect(transformed).toEqual([]);
+      }
+
+      abortController.abort();
+      await streamPromise;
+    },
+    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
+  );
+
+  // Test repeatedly performing initial replication.
+  //
+  // If the first LSN does not correctly match with the first replication transaction,
+  // we may miss some updates.
+  test(
+    'repeated initial replication',
+    async () => {
+      const pool = await connectPgPool();
+      const f = await factory();
+
+      const syncRuleContent = `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test_data"
+`;
+      const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+      const storage = f.getInstance(syncRules.parsed());
+
+      // 1. Setup some base data that will be replicated in initial replication
+      await pool.query(`DROP TABLE IF EXISTS test_data`);
+      await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
+
+      let statements: pgwire.Statement[] = [];
+
+      const n = Math.floor(Math.random() * 200);
+      for (let i = 0; i < n; i++) {
+        statements.push({
+          statement: `INSERT INTO test_data(description) VALUES('test_init')`
+        });
+      }
+      await pool.query(...statements);
+
+      const start = Date.now();
+      let i = 0;
+
+      while (Date.now() - start < TEST_DURATION_MS) {
+        // 2. Each iteration starts with a clean slate
+        await pool.query(`SELECT pg_drop_replication_slot(slot_name) FROM pg_replication_slots WHERE active = FALSE`);
+        i += 1;
+
+        const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
+        const replicationConnection = await connections.replicationConnection();
+
+        abortController = new AbortController();
+        const options: WalStreamOptions = {
+          abort_signal: abortController.signal,
+          connections,
+          storage: storage,
+          factory: f
+        };
+        walStream = new WalStream(options);
+
+        await storage.clear();
+
+        // 3. Start initial replication, then streaming, but don't wait for any of this
+        let initialReplicationDone = false;
+        streamPromise = (async () => {
+          await walStream.initReplication(replicationConnection);
+          await storage.autoActivate();
+          initialReplicationDone = true;
+          await walStream.streamChanges(replicationConnection);
+        })()
+          .catch((e) => {
+            initialReplicationDone = true;
+            throw e;
+          })
+          .then((v) => {
+            return v;
+          });
+
+        // 4. While initial replication is still running, write more changes
+        while (!initialReplicationDone) {
+          let statements: pgwire.Statement[] = [];
+          const n = Math.floor(Math.random() * 10) + 1;
+          for (let i = 0; i < n; i++) {
+            const description = `test${i}`;
+            statements.push({
+              statement: `INSERT INTO test_data(description) VALUES('test1') returning id as test_id`,
+              params: [{ type: 'varchar', value: description }]
+            });
+          }
+          const results = await pool.query(...statements);
+          const ids = results.results.map((sub) => {
+            return sub.rows[0][0] as string;
+          });
+          await new Promise((resolve) => setTimeout(resolve, Math.random() * 30));
+          const deleteStatements: pgwire.Statement[] = ids.map((id) => {
+            return {
+              statement: `DELETE FROM test_data WHERE id = $1`,
+              params: [{ type: 'uuid', value: id }]
+            };
+          });
+          await pool.query(...deleteStatements);
+          await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
+        }
+
+        // 5. Once initial replication is done, wait for the streaming changes to complete syncing.
+        // getClientCheckpoint() effectively waits for the above replication to complete
+        // Race with streamingPromise to catch replication errors here.
+        let checkpoint = await Promise.race([
+          getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS }),
+          streamPromise
+        ]);
+        if (typeof checkpoint == undefined) {
+          // This indicates an issue with the test setup - streamingPromise completed instead
+          // of getClientCheckpoint()
+          throw new Error('Test failure - streamingPromise completed');
+        }
+
+        abortController.abort();
+        await streamPromise;
+        await connections.end();
+      }
+    },
+    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
+  );
+}

package/test/src/sql_functions.test.ts

@@ -0,0 +1,254 @@
+import { SQL_FUNCTIONS_CALL, cast, jsonExtract } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+
+const fn = SQL_FUNCTIONS_CALL;
+describe('SQL functions', () => {
+  test('json extract', () => {
+    expect(fn.json_extract(JSON.stringify({ foo: 'bar' }), '$.foo')).toEqual('bar');
+    expect(fn.json_extract(JSON.stringify({ foo: 42 }), '$.foo')).toEqual(42n);
+    expect(fn.json_extract(JSON.stringify({ foo: true }), '$.foo')).toEqual(1n);
+    expect(fn.json_extract(`{"foo": 42.0}`, '$.foo')).toEqual(42.0);
+    expect(fn.json_extract(JSON.stringify({ foo: 42 }), '$.bar.baz')).toEqual(null);
+    expect(fn.json_extract(JSON.stringify({ foo: 42 }), '$')).toEqual('{"foo":42}');
+    expect(fn.json_extract(`{"foo": 42.0}`, '$')).toEqual('{"foo":42.0}');
+    expect(fn.json_extract(`{"foo": true}`, '$')).toEqual('{"foo":true}');
+  });
+
+  test('->>', () => {
+    expect(jsonExtract(JSON.stringify({ foo: 'bar' }), '$.foo', '->>')).toEqual('bar');
+    expect(jsonExtract(JSON.stringify({ foo: 42 }), '$.foo', '->>')).toEqual(42n);
+    expect(jsonExtract(`{"foo": 42.0}`, '$.foo', '->>')).toEqual(42.0);
+    expect(jsonExtract(JSON.stringify({ foo: 'bar' }), 'foo', '->>')).toEqual('bar');
+    expect(jsonExtract(JSON.stringify({ foo: 42 }), 'foo', '->>')).toEqual(42n);
+    expect(jsonExtract(`{"foo": 42.0}`, 'foo', '->>')).toEqual(42.0);
+    expect(jsonExtract(`{"foo": 42.0}`, '$', '->>')).toEqual(`{"foo":42.0}`);
+    expect(jsonExtract(`{"foo": true}`, '$.foo', '->>')).toEqual(1n);
+  });
+
+  test('->', () => {
+    expect(jsonExtract(JSON.stringify({ foo: 'bar' }), '$.foo', '->')).toEqual('"bar"');
+    expect(jsonExtract(JSON.stringify({ foo: 42 }), '$.foo', '->')).toEqual('42');
+    expect(jsonExtract(`{"foo": 42.0}`, '$.foo', '->')).toEqual('42.0');
+    expect(jsonExtract(JSON.stringify({ foo: 'bar' }), 'foo', '->')).toEqual('"bar"');
+    expect(jsonExtract(JSON.stringify({ foo: 42 }), 'foo', '->')).toEqual('42');
+    expect(jsonExtract(`{"foo": 42.0}`, 'foo', '->')).toEqual('42.0');
+    expect(jsonExtract(`{"foo": 42.0}`, '$', '->')).toEqual(`{"foo":42.0}`);
+    expect(jsonExtract(`{"foo": true}`, '$.foo', '->')).toEqual('true');
+  });
+
+  test('json_array_length', () => {
+    expect(fn.json_array_length(`[1,2,3,4]`)).toEqual(4n);
+    expect(fn.json_array_length(`[1,2,3,4]`, '$')).toEqual(4n);
+    expect(fn.json_array_length(`[1,2,3,4]`, '$.a')).toEqual(null);
+    expect(fn.json_array_length(`{"a":[1,2,3,4]}`, '$.a')).toEqual(4n);
+    expect(fn.json_array_length(`{"a":[1,2,3,4]}`)).toEqual(0n);
+  });
+
+  test('typeof', () => {
+    expect(fn.typeof(null)).toEqual('null');
+    expect(fn.typeof('test')).toEqual('text');
+    expect(fn.typeof('')).toEqual('text');
+    expect(fn.typeof(1n)).toEqual('integer');
+    expect(fn.typeof(1)).toEqual('real');
+    expect(fn.typeof(1.5)).toEqual('real');
+    expect(fn.typeof(Uint8Array.of(1, 2, 3))).toEqual('blob');
+  });
+
+  test('length', () => {
+    expect(fn.length(null)).toEqual(null);
+    expect(fn.length('abc')).toEqual(3n);
+    expect(fn.length(123n)).toEqual(3n);
+    expect(fn.length(123.4)).toEqual(5n);
+    expect(fn.length(Uint8Array.of(1, 2, 3))).toEqual(3n);
+  });
+
+  test('hex', () => {
+    expect(fn.hex(null)).toEqual('');
+    expect(fn.hex('abC')).toEqual('616243');
+    expect(fn.hex(Uint8Array.of(0x61, 0x62, 0x43))).toEqual('616243');
+    expect(fn.hex(123n)).toEqual('313233');
+    expect(fn.hex(123.4)).toEqual('3132332E34');
+  });
+
+  test('base64', () => {
+    expect(fn.base64(null)).toEqual('');
+    expect(fn.base64('abc')).toEqual('YWJj');
+    expect(fn.base64(Uint8Array.of(0x61, 0x62, 0x63))).toEqual('YWJj');
+    expect(fn.base64(123n)).toEqual('MTIz');
+    expect(fn.base64(123.4)).toEqual('MTIzLjQ=');
+  });
+
+  test('ifnull', () => {
+    expect(fn.ifnull(null, null)).toEqual(null);
+    expect(fn.ifnull('test', null)).toEqual('test');
+    expect(fn.ifnull(null, 'test')).toEqual('test');
+    expect(fn.ifnull('test1', 'test2')).toEqual('test1');
+  });
+
+  test('upper', () => {
+    expect(fn.upper(null)).toEqual(null);
+    expect(fn.upper('abc')).toEqual('ABC');
+    expect(fn.upper(123n)).toEqual('123');
+    expect(fn.upper(3e60)).toEqual('3E+60');
+    expect(fn.upper(Uint8Array.of(0x61, 0x62, 0x43))).toEqual('ABC');
+  });
+
+  test('lower', () => {
+    expect(fn.lower(null)).toEqual(null);
+    expect(fn.lower('ABC')).toEqual('abc');
+    expect(fn.lower(123n)).toEqual('123');
+    expect(fn.lower(3e60)).toEqual('3e+60');
+    expect(fn.lower(Uint8Array.of(0x61, 0x62, 0x43))).toEqual('abc');
+  });
+
+  test('cast', () => {
+    expect(cast(null, 'text')).toEqual(null);
+    expect(cast(null, 'integer')).toEqual(null);
+    expect(cast(null, 'numeric')).toEqual(null);
+    expect(cast(null, 'real')).toEqual(null);
+    expect(cast(null, 'blob')).toEqual(null);
+
+    expect(cast(1n, 'text')).toEqual('1');
+    expect(cast(1n, 'integer')).toEqual(1n);
+    expect(cast(1n, 'numeric')).toEqual(1n);
+    expect(cast(1n, 'real')).toEqual(1.0);
+    // We differ from SQLite here
+    expect(cast(1n, 'blob')).toEqual(Uint8Array.of(49));
+
+    expect(cast(1.2, 'text')).toEqual('1.2');
+    expect(cast(1.2, 'integer')).toEqual(1n);
+    expect(cast(1.2, 'numeric')).toEqual(1.2);
+    expect(cast(1.2, 'real')).toEqual(1.2);
+    // We differ from SQLite here
+    expect(cast(1.2, 'blob')).toEqual(Uint8Array.of(49, 46, 50));
+
+    expect(cast('abc', 'text')).toEqual('abc');
+    expect(cast('abc', 'integer')).toEqual(0n);
+    expect(cast('abc', 'numeric')).toEqual(0n);
+    expect(cast('abc', 'real')).toEqual(0.0);
+
+    expect(cast('1.2abc', 'integer')).toEqual(1n);
+    expect(cast('1.2abc', 'numeric')).toEqual(1.2);
+    expect(cast('1.2abc', 'real')).toEqual(1.2);
+    expect(cast('1.2e60abc', 'numeric')).toEqual(1.2e60);
+    expect(cast(' 1e60abc', 'numeric')).toEqual(1e60);
+
+    // We differ from SQLite here
+    expect(cast('abc', 'blob')).toEqual(Uint8Array.of(0x61, 0x62, 0x63));
+  });
+
+  test('unixepoch', () => {
+    // Differences from SQLite
+    // These versions are not supported
+    expect(fn.unixepoch()).toEqual(null);
+    expect(fn.unixepoch('now')).toEqual(null);
+    expect(fn.unixepoch('2023-06-28 14:12', 'auto')).toEqual(null);
+
+    // Same as SQLite
+    expect(fn.unixepoch('2023-06-28 14:12')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28 14:12:00')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28 14:12:00+00:00')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28 14:12:00Z')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28 14:12:00.999')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28 14:12:00.999Z')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28T14:12:00.999Z')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28T14:12:00+00:00')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28T14:12+00:00')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28T16:12+02:00')).toEqual(1687961520n);
+    expect(fn.unixepoch('2023-06-28T16:12+02')).toEqual(null);
+    expect(fn.unixepoch('2023-06-28')).toEqual(1687910400n);
+    expect(fn.unixepoch('0000-01-01T00:00')).toEqual(-62167219200n);
+    expect(fn.unixepoch('3000-01-01T00:00')).toEqual(32503680000n);
+    expect(fn.unixepoch('2023')).toEqual(-210691972800n);
+    expect(fn.unixepoch('2023.')).toEqual(-210691972800n);
+    expect(fn.unixepoch('2023.123')).toEqual(-210691962173n);
+    expect(fn.unixepoch(2023)).toEqual(-210691972800n);
+    expect(fn.unixepoch(2023n)).toEqual(-210691972800n);
+    expect(fn.unixepoch(2023.123)).toEqual(-210691962173n);
+    expect(fn.unixepoch(1687961520n, 'unixepoch')).toEqual(1687961520n);
+    expect(fn.unixepoch(1687961520, 'unixepoch')).toEqual(1687961520n);
+    expect(fn.unixepoch(1687961520.567, 'unixepoch')).toEqual(1687961520n);
+    expect(fn.unixepoch(1687961520.567, 'unixepoch', 'subsec')).toEqual(1687961520.567);
+    expect(fn.unixepoch(1687961520.567, 'unixepoch', 'subsecond')).toEqual(1687961520.567);
+
+    expect(fn.unixepoch('2023-06-28 14:12:00.999', 'subsec')).toEqual(1687961520.999);
+    expect(fn.unixepoch('2023-06-28 14:12:00.999', 'subsecond')).toEqual(1687961520.999);
+    expect(fn.unixepoch('2023-06-28 14:12:00.0', 'subsecond')).toEqual(1687961520.0);
+  });
+
+  test('datetime', () => {
+    // Differences from SQLite
+    // These versions are not supported
+    expect(fn.datetime()).toEqual(null);
+    expect(fn.datetime('now')).toEqual(null);
+    expect(fn.datetime('2023-06-28 14:12', 'auto')).toEqual(null);
+
+    // Same as SQLite
+    expect(fn.datetime('2023-06-28 14:12')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28 14:12:00')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28 14:12:00+00:00')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28 14:12:00Z')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28 14:12:00.999')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28 14:12:00.999Z')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28T14:12:00.999Z')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28T14:12:00+00:00')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28T14:12+00:00')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28T16:12+02:00')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime('2023-06-28T16:12+02')).toEqual(null);
+    expect(fn.datetime('2023-06-28')).toEqual('2023-06-28 00:00:00');
+    expect(fn.datetime('0000-01-01T00:00')).toEqual('0000-01-01 00:00:00');
+    expect(fn.datetime('3000-01-01T00:00')).toEqual('3000-01-01 00:00:00');
+    expect(fn.datetime('2023')).toEqual('-4707-06-08 12:00:00');
+    expect(fn.datetime('2023.')).toEqual('-4707-06-08 12:00:00');
+    expect(fn.datetime('2023.123')).toEqual('-4707-06-08 14:57:07');
+    expect(fn.datetime(2023)).toEqual('-4707-06-08 12:00:00');
+    expect(fn.datetime(2023n)).toEqual('-4707-06-08 12:00:00');
+    expect(fn.datetime(2023.123)).toEqual('-4707-06-08 14:57:07');
+    expect(fn.datetime(1687961520n, 'unixepoch')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime(1687961520, 'unixepoch')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime(1687961520.567, 'unixepoch')).toEqual('2023-06-28 14:12:00');
+    expect(fn.datetime(1687961520.567, 'unixepoch', 'subsec')).toEqual('2023-06-28 14:12:00.567');
+    expect(fn.datetime(1687961520.567, 'unixepoch', 'subsecond')).toEqual('2023-06-28 14:12:00.567');
+
+    expect(fn.datetime('2023-06-28 14:12:00.999', 'subsec')).toEqual('2023-06-28 14:12:00.999');
+    expect(fn.datetime('2023-06-28 14:12:00.999', 'subsecond')).toEqual('2023-06-28 14:12:00.999');
+    expect(fn.datetime('2023-06-28 14:12:00.0', 'subsecond')).toEqual('2023-06-28 14:12:00.000');
+  });
+
+  test('ST_AsGeoJSON', () => {
+    expect(fn.st_asgeojson(null)).toEqual(null);
+    expect(fn.st_asgeojson('0101000000029a081b9ede4340d7a3703d0a3f5ac0')).toEqual(
+      '{"type":"Point","coordinates":[39.7392,-104.985]}'
+    );
+    expect(
+      fn.st_asgeojson(
+        '01030000000100000005000000000000000000000000000000000000000000000000000000000000000000f03f000000000000f03f000000000000f03f000000000000f03f000000000000000000000000000000000000000000000000'
+      )
+    ).toEqual('{"type":"Polygon","coordinates":[[[0.0,0.0],[0.0,1.0],[1.0,1.0],[1.0,0.0],[0.0,0.0]]]}');
+  });
+
+  test('ST_X', () => {
+    expect(fn.st_x(null)).toEqual(null);
+    expect(fn.st_x('0101000000029a081b9ede4340d7a3703d0a3f5ac0')).toEqual(39.7392);
+    expect(
+      fn.st_x(
+        '01030000000100000005000000000000000000000000000000000000000000000000000000000000000000f03f000000000000f03f000000000000f03f000000000000f03f000000000000000000000000000000000000000000000000'
+      )
+    ).toEqual(null);
+  });
+
+  test('ST_Y', () => {
+    expect(fn.st_y(null)).toEqual(null);
+    expect(fn.st_y('0101000000029a081b9ede4340d7a3703d0a3f5ac0')).toEqual(-104.985);
+  });
+
+  test('ST_AsText', () => {
+    expect(fn.st_astext(null)).toEqual(null);
+    expect(fn.st_astext('0101000000029a081b9ede4340d7a3703d0a3f5ac0')).toEqual('POINT(39.7392 -104.985)');
+    expect(
+      fn.st_astext(
+        `01030000000100000005000000000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000F03F000000000000000000000000000000000000000000000000`
+      )
+    ).toEqual('POLYGON((0 0,0 1,1 1,1 0,0 0))');
+  });
+});

package/test/src/sql_operators.test.ts

@@ -0,0 +1,132 @@
+import { evaluateOperator } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+
+describe('SQL operators', () => {
+  test('=', () => {
+    expect(evaluateOperator('=', 1, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('=', 1.1, 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('=', '1', 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('=', '', 0n)).toStrictEqual(0n);
+    expect(evaluateOperator('=', 1, null)).toStrictEqual(null);
+    expect(evaluateOperator('=', 0, null)).toStrictEqual(null);
+    expect(evaluateOperator('=', null, '')).toStrictEqual(null);
+    expect(evaluateOperator('=', null, null)).toStrictEqual(null);
+  });
+
+  test('!=', () => {
+    expect(evaluateOperator('!=', 1, 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('!=', 1.1, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('!=', '1', 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('!=', '', 0n)).toStrictEqual(1n);
+    expect(evaluateOperator('!=', 1, null)).toStrictEqual(null);
+    expect(evaluateOperator('!=', 0, null)).toStrictEqual(null);
+    expect(evaluateOperator('!=', null, '')).toStrictEqual(null);
+    expect(evaluateOperator('!=', null, null)).toStrictEqual(null);
+  });
+
+  test('IS', () => {
+    expect(evaluateOperator('IS', 1, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('IS', 1.1, 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('IS', '1', 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('IS', '', 0n)).toStrictEqual(0n);
+    expect(evaluateOperator('IS', 1, null)).toStrictEqual(0n);
+    expect(evaluateOperator('IS', 0, null)).toStrictEqual(0n);
+    expect(evaluateOperator('IS', null, '')).toStrictEqual(0n);
+    expect(evaluateOperator('IS', null, null)).toStrictEqual(1n);
+  });
+
+  test('IS NOT', () => {
+    expect(evaluateOperator('IS NOT', 1, 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('IS NOT', 1.1, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('IS NOT', '1', 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('IS NOT', '', 0n)).toStrictEqual(1n);
+    expect(evaluateOperator('IS NOT', 1, null)).toStrictEqual(1n);
+    expect(evaluateOperator('IS NOT', 0, null)).toStrictEqual(1n);
+    expect(evaluateOperator('IS NOT', null, '')).toStrictEqual(1n);
+    expect(evaluateOperator('IS NOT', null, null)).toStrictEqual(0n);
+  });
+
+  test('>', () => {
+    expect(evaluateOperator('>', 1, 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('>', 2, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('>', 2n, 1)).toStrictEqual(1n);
+    expect(evaluateOperator('>', 'text', 1)).toStrictEqual(1n);
+    expect(evaluateOperator('>', 1, 'text')).toStrictEqual(0n);
+    expect(evaluateOperator('>', 1, null)).toStrictEqual(null);
+    expect(evaluateOperator('>', null, null)).toStrictEqual(null);
+  });
+
+  test('>=', () => {
+    expect(evaluateOperator('>=', 1, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('>=', 2, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('>=', 2n, 1)).toStrictEqual(1n);
+    expect(evaluateOperator('>=', 'text', 1)).toStrictEqual(1n);
+    expect(evaluateOperator('>=', 1, 'text')).toStrictEqual(0n);
+    expect(evaluateOperator('>=', 1, null)).toStrictEqual(null);
+    expect(evaluateOperator('>=', null, null)).toStrictEqual(null);
+  });
+
+  test('<', () => {
+    expect(evaluateOperator('<', 1, 1n)).toStrictEqual(0n);
+    expect(evaluateOperator('<', 1n, 2)).toStrictEqual(1n);
+    expect(evaluateOperator('<', 1, 2n)).toStrictEqual(1n);
+    expect(evaluateOperator('<', 'text', 1)).toStrictEqual(0n);
+    expect(evaluateOperator('<', 1, 'text')).toStrictEqual(1n);
+    expect(evaluateOperator('<', 1, null)).toStrictEqual(null);
+    expect(evaluateOperator('<', null, null)).toStrictEqual(null);
+  });
+
+  test('<=', () => {
+    expect(evaluateOperator('<=', 1, 1n)).toStrictEqual(1n);
+    expect(evaluateOperator('<=', 1n, 2)).toStrictEqual(1n);
+    expect(evaluateOperator('<=', 1, 2n)).toStrictEqual(1n);
+    expect(evaluateOperator('<=', 'text', 1)).toStrictEqual(0n);
+    expect(evaluateOperator('<=', 1, 'text')).toStrictEqual(1n);
+    expect(evaluateOperator('<=', 1, null)).toStrictEqual(null);
+    expect(evaluateOperator('<=', null, null)).toStrictEqual(null);
+  });
+
+  test('||', () => {
+    expect(evaluateOperator('||', 'test', null)).toStrictEqual(null);
+    expect(evaluateOperator('||', 'a', 31n)).toStrictEqual('a31');
+    expect(evaluateOperator('||', 3.1, 'a')).toStrictEqual('3.1a');
+  });
+
+  test('+', () => {
+    expect(evaluateOperator('+', 1n, null)).toStrictEqual(null);
+    expect(evaluateOperator('+', 1n, 2)).toStrictEqual(3);
+    expect(evaluateOperator('+', 1n, 2n)).toStrictEqual(3n);
+    expect(evaluateOperator('+', 1, 2)).toStrictEqual(3);
+    expect(evaluateOperator('+', 1n, '2')).toStrictEqual(3n);
+    expect(evaluateOperator('+', 1n, '2.0')).toStrictEqual(3.0);
+  });
+
+  test('/', () => {
+    expect(evaluateOperator('/', 1n, null)).toStrictEqual(null);
+    expect(evaluateOperator('/', 5n, 2)).toStrictEqual(2.5);
+    expect(evaluateOperator('/', 5n, 2n)).toStrictEqual(2n);
+    expect(evaluateOperator('/', 5, 2)).toStrictEqual(2.5);
+    expect(evaluateOperator('/', 5n, '2')).toStrictEqual(2n);
+    expect(evaluateOperator('/', 5n, '2.0')).toStrictEqual(2.5);
+  });
+
+  test('*', () => {
+    expect(evaluateOperator('*', 3n, null)).toStrictEqual(null);
+    expect(evaluateOperator('*', 3n, 2)).toStrictEqual(6);
+    expect(evaluateOperator('*', 3n, 2n)).toStrictEqual(6n);
+    expect(evaluateOperator('*', 3, 2)).toStrictEqual(6);
+    expect(evaluateOperator('*', 3n, '2')).toStrictEqual(6n);
+    expect(evaluateOperator('*', 3n, '2.0')).toStrictEqual(6.0);
+    expect(evaluateOperator('*', '3', '2.0')).toStrictEqual(6.0);
+  });
+
+  test('-', () => {
+    expect(evaluateOperator('-', 3n, null)).toStrictEqual(null);
+    expect(evaluateOperator('-', 3n, 2)).toStrictEqual(1);
+    expect(evaluateOperator('-', 3n, 2n)).toStrictEqual(1n);
+    expect(evaluateOperator('-', 3, 2)).toStrictEqual(1);
+    expect(evaluateOperator('-', 3n, '2')).toStrictEqual(1n);
+    expect(evaluateOperator('-', 3n, '2.0')).toStrictEqual(1.0);
+    expect(evaluateOperator('-', '3', '2.0')).toStrictEqual(1.0);
+  });
+});