@powersync/common 1.47.0 → 1.49.0

package/dist/bundle.node.cjs

@@ -105,6 +105,21 @@ class Index {
     }
 }
 
+/**
+ * @internal Not exported from `index.ts`.
+ */
+function encodeTableOptions(options) {
+    const trackPrevious = options.trackPrevious;
+    return {
+        local_only: options.localOnly,
+        insert_only: options.insertOnly,
+        include_old: trackPrevious && (trackPrevious.columns ?? true),
+        include_old_only_when_changed: typeof trackPrevious == 'object' && trackPrevious.onlyWhenChanged == true,
+        include_metadata: options.trackMetadata,
+        ignore_empty_update: options.ignoreEmptyUpdates
+    };
+}
+
 const DEFAULT_TABLE_OPTIONS = {
     indexes: [],
     insertOnly: false,
@@ -294,18 +309,12 @@ class Table {
         }
     }
     toJSON() {
-        const trackPrevious = this.trackPrevious;
         return {
             name: this.name,
             view_name: this.viewName,
-            local_only: this.localOnly,
-            insert_only: this.insertOnly,
-            include_old: trackPrevious && (trackPrevious.columns ?? true),
-            include_old_only_when_changed: typeof trackPrevious == 'object' && trackPrevious.onlyWhenChanged == true,
-            include_metadata: this.trackMetadata,
-            ignore_empty_update: this.ignoreEmptyUpdates,
             columns: this.columns.map((c) => c.toJSON()),
-            indexes: this.indexes.map((e) => e.toJSON(this))
+            indexes: this.indexes.map((e) => e.toJSON(this)),
+            ...encodeTableOptions(this)
         };
     }
 }
@@ -1523,6 +1532,49 @@ var Logger = /*@__PURE__*/getDefaultExportFromCjs(loggerExports);
  * Set of generic interfaces to allow PowerSync compatibility with
  * different SQLite DB implementations.
  */
+/**
+ * Implements {@link DBGetUtils} on a {@link SqlRunner}.
+ */
+function DBGetUtilsDefaultMixin(Base) {
+    return class extends Base {
+        async getAll(sql, parameters) {
+            const res = await this.execute(sql, parameters);
+            return res.rows?._array ?? [];
+        }
+        async getOptional(sql, parameters) {
+            const res = await this.execute(sql, parameters);
+            return res.rows?.item(0) ?? null;
+        }
+        async get(sql, parameters) {
+            const res = await this.execute(sql, parameters);
+            const first = res.rows?.item(0);
+            if (!first) {
+                throw new Error('Result set is empty');
+            }
+            return first;
+        }
+        async executeBatch(query, params = []) {
+            // If this context can run batch statements natively, use that.
+            // @ts-ignore
+            if (super.executeBatch) {
+                // @ts-ignore
+                return super.executeBatch(query, params);
+            }
+            // Emulate executeBatch by running statements individually.
+            let lastInsertId;
+            let rowsAffected = 0;
+            for (const set of params) {
+                const result = await this.execute(query, set);
+                lastInsertId = result.insertId;
+                rowsAffected += result.rowsAffected;
+            }
+            return {
+                rowsAffected,
+                insertId: lastInsertId
+            };
+        }
+    };
+}
 /**
  * Update table operation numbers from SQLite
  */
@@ -1532,6 +1584,89 @@ exports.RowUpdateType = void 0;
     RowUpdateType[RowUpdateType["SQLITE_DELETE"] = 9] = "SQLITE_DELETE";
     RowUpdateType[RowUpdateType["SQLITE_UPDATE"] = 23] = "SQLITE_UPDATE";
 })(exports.RowUpdateType || (exports.RowUpdateType = {}));
+/**
+ * A mixin to implement {@link DBAdapter} by delegating to {@link ConnectionPool.readLock} and
+ * {@link ConnectionPool.writeLock}.
+ */
+function DBAdapterDefaultMixin(Base) {
+    return class extends Base {
+        readTransaction(fn, options) {
+            return this.readLock((ctx) => TransactionImplementation.runWith(ctx, fn), options);
+        }
+        writeTransaction(fn, options) {
+            return this.writeLock((ctx) => TransactionImplementation.runWith(ctx, fn), options);
+        }
+        getAll(sql, parameters) {
+            return this.readLock((ctx) => ctx.getAll(sql, parameters));
+        }
+        getOptional(sql, parameters) {
+            return this.readLock((ctx) => ctx.getOptional(sql, parameters));
+        }
+        get(sql, parameters) {
+            return this.readLock((ctx) => ctx.get(sql, parameters));
+        }
+        execute(query, params) {
+            return this.writeLock((ctx) => ctx.execute(query, params));
+        }
+        executeRaw(query, params) {
+            return this.writeLock((ctx) => ctx.executeRaw(query, params));
+        }
+        executeBatch(query, params) {
+            return this.writeTransaction((tx) => tx.executeBatch(query, params));
+        }
+    };
+}
+class BaseTransaction {
+    inner;
+    finalized = false;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    async commit() {
+        if (this.finalized) {
+            return { rowsAffected: 0 };
+        }
+        this.finalized = true;
+        return this.inner.execute('COMMIT');
+    }
+    async rollback() {
+        if (this.finalized) {
+            return { rowsAffected: 0 };
+        }
+        this.finalized = true;
+        return this.inner.execute('ROLLBACK');
+    }
+    execute(query, params) {
+        return this.inner.execute(query, params);
+    }
+    executeRaw(query, params) {
+        return this.inner.executeRaw(query, params);
+    }
+    executeBatch(query, params) {
+        return this.inner.executeBatch(query, params);
+    }
+}
+class TransactionImplementation extends DBGetUtilsDefaultMixin(BaseTransaction) {
+    static async runWith(ctx, fn) {
+        let tx = new TransactionImplementation(ctx);
+        try {
+            await ctx.execute('BEGIN IMMEDIATE');
+            const result = await fn(tx);
+            await tx.commit();
+            return result;
+        }
+        catch (ex) {
+            try {
+                await tx.rollback();
+            }
+            catch (ex2) {
+                // In rare cases, a rollback may fail.
+                // Safe to ignore.
+            }
+            throw ex;
+        }
+    }
+}
 function isBatchedUpdateNotification(update) {
     return 'tables' in update;
 }
@@ -7926,7 +8061,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.47.0";
+var version = "1.49.0";
 var PACKAGE = {
 	version: version};
 
@@ -9959,7 +10094,7 @@ class TriggerManagerImpl {
     }
     async createDiffTrigger(options) {
         await this.db.waitForReady();
-        const { source, destination, columns, when, hooks, 
+        const { source, destination, columns, when, hooks, setupContext, 
         // Fall back to the provided default if not given on this level
         useStorage = this.defaultConfig.useStorageByDefault } = options;
         const operations = Object.keys(when);
@@ -10014,13 +10149,20 @@ class TriggerManagerImpl {
          * we need to ensure we can cleanup the created resources.
          * We unfortunately cannot rely on transaction rollback.
          */
-        const cleanup = async () => {
+        const cleanup = async (options) => {
+            const { context } = options ?? {};
             disposeWarningListener();
-            return this.db.writeLock(async (tx) => {
+            const doCleanup = async (tx) => {
                 await this.removeTriggers(tx, triggerIds);
-                await tx.execute(/* sql */ `DROP TABLE IF EXISTS ${destination};`);
+                await tx.execute(`DROP TABLE IF EXISTS ${destination};`);
                 await releaseStorageClaim?.();
-            });
+            };
+            if (context) {
+                await doCleanup(context);
+            }
+            else {
+                await this.db.writeLock(doCleanup);
+            }
         };
         const setup = async (tx) => {
             // Allow user code to execute in this lock context before the trigger is created.
@@ -10094,12 +10236,17 @@ class TriggerManagerImpl {
             }
         };
         try {
-            await this.db.writeLock(setup);
+            if (setupContext) {
+                await setup(setupContext);
+            }
+            else {
+                await this.db.writeLock(setup);
+            }
             return cleanup;
         }
         catch (error) {
             try {
-                await cleanup();
+                await cleanup(setupContext ? { context: setupContext } : undefined);
             }
             catch (cleanupError) {
                 throw new AggregateError([error, cleanupError], 'Error during operation and cleanup');
@@ -11607,39 +11754,6 @@ class ConnectionClosedError extends Error {
     }
 }
 
-/**
- * Instructs PowerSync to sync data into a "raw" table.
- *
- * Since raw tables are not backed by JSON, running complex queries on them may be more efficient. Further, they allow
- * using client-side table and column constraints.
- *
- * To collect local writes to raw tables with PowerSync, custom triggers are required. See
- * {@link https://docs.powersync.com/usage/use-case-examples/raw-tables the documentation} for details and an example on
- * using raw tables.
- *
- * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
- *
- * @experimental Please note that this feature is experimental at the moment, and not covered by PowerSync semver or
- * stability guarantees.
- */
-class RawTable {
-    /**
-     * The name of the table.
-     *
-     * This does not have to match the actual table name in the schema - {@link put} and {@link delete} are free to use
-     * another table. Instead, this name is used by the sync client to recognize that operations on this table (as it
-     * appears in the source / backend database) are to be handled specially.
-     */
-    name;
-    put;
-    delete;
-    constructor(name, type) {
-        this.name = name;
-        this.put = type.put;
-        this.delete = type.delete;
-    }
-}
-
 /**
  * A schema is a collection of tables. It is used to define the structure of a database.
  */
@@ -11684,7 +11798,7 @@ class Schema {
      */
     withRawTables(tables) {
         for (const [name, rawTableDefinition] of Object.entries(tables)) {
-            this.rawTables.push(new RawTable(name, rawTableDefinition));
+            this.rawTables.push({ name, ...rawTableDefinition });
         }
     }
     validate() {
@@ -11695,9 +11809,31 @@ class Schema {
     toJSON() {
         return {
             tables: this.tables.map((t) => t.toJSON()),
-            raw_tables: this.rawTables
+            raw_tables: this.rawTables.map(Schema.rawTableToJson)
         };
     }
+    /**
+     * Returns a representation of the raw table that is understood by the PowerSync SQLite core extension.
+     *
+     * The output of this can be passed through `JSON.serialize` and then used in `powersync_create_raw_table_crud_trigger`
+     * to define triggers for this table.
+     */
+    static rawTableToJson(table) {
+        const serialized = {
+            name: table.name,
+            put: table.put,
+            delete: table.delete,
+            clear: table.clear
+        };
+        if ('schema' in table) {
+            // We have schema options, those are flattened into the outer JSON object for the core extension.
+            const schema = table.schema;
+            serialized.table_name = schema.tableName ?? table.name;
+            serialized.synced_columns = schema.syncedColumns;
+            Object.assign(serialized, encodeTableOptions(table.schema));
+        }
+        return serialized;
+    }
 }
 
 /**
@@ -11875,6 +12011,8 @@ exports.ControlledExecutor = ControlledExecutor;
 exports.CrudBatch = CrudBatch;
 exports.CrudEntry = CrudEntry;
 exports.CrudTransaction = CrudTransaction;
+exports.DBAdapterDefaultMixin = DBAdapterDefaultMixin;
+exports.DBGetUtilsDefaultMixin = DBGetUtilsDefaultMixin;
 exports.DEFAULT_CRUD_BATCH_LIMIT = DEFAULT_CRUD_BATCH_LIMIT;
 exports.DEFAULT_CRUD_UPLOAD_THROTTLE_MS = DEFAULT_CRUD_UPLOAD_THROTTLE_MS;
 exports.DEFAULT_INDEX_COLUMN_OPTIONS = DEFAULT_INDEX_COLUMN_OPTIONS;
@@ -11909,7 +12047,6 @@ exports.MEMORY_TRIGGER_CLAIM_MANAGER = MEMORY_TRIGGER_CLAIM_MANAGER;
 exports.OnChangeQueryProcessor = OnChangeQueryProcessor;
 exports.OpType = OpType;
 exports.OplogEntry = OplogEntry;
-exports.RawTable = RawTable;
 exports.Schema = Schema;
 exports.SqliteBucketStorage = SqliteBucketStorage;
 exports.SyncDataBatch = SyncDataBatch;