@powersync/common 1.44.0 → 1.46.0

package/src/client/AbstractPowerSyncDatabase.ts

@@ -40,7 +40,8 @@ import {
 } from './sync/stream/AbstractStreamingSyncImplementation.js';
 import { CoreSyncStatus, coreStatusToJs } from './sync/stream/core-instruction.js';
 import { SyncStream } from './sync/sync-streams.js';
-import { TriggerManager } from './triggers/TriggerManager.js';
+import { MEMORY_TRIGGER_CLAIM_MANAGER } from './triggers/MemoryTriggerClaimManager.js';
+import { TriggerManager, TriggerManagerConfig } from './triggers/TriggerManager.js';
 import { TriggerManagerImpl } from './triggers/TriggerManagerImpl.js';
 import { DEFAULT_WATCH_THROTTLE_MS, WatchCompatibleQuery } from './watched/WatchedQuery.js';
 import { OnChangeQueryProcessor } from './watched/processors/OnChangeQueryProcessor.js';
@@ -222,6 +223,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Allows creating SQLite triggers which can be used to track various operations on SQLite tables.
    */
   readonly triggers: TriggerManager;
+  protected triggersImpl: TriggerManagerImpl;
 
   logger: ILogger;
 
@@ -296,9 +298,10 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
     this._isReadyPromise = this.initialize();
 
-    this.triggers = new TriggerManagerImpl({
+    this.triggers = this.triggersImpl = new TriggerManagerImpl({
       db: this,
-      schema: this.schema
+      schema: this.schema,
+      ...this.generateTriggerManagerConfig()
     });
   }
 
@@ -334,6 +337,16 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    */
   protected abstract openDBAdapter(options: PowerSyncDatabaseOptionsWithSettings): DBAdapter;
 
+  /**
+   * Generates a base configuration for {@link TriggerManagerImpl}.
+   * Implementations should override this if necessary.
+   */
+  protected generateTriggerManagerConfig(): TriggerManagerConfig {
+    return {
+      claimManager: MEMORY_TRIGGER_CLAIM_MANAGER
+    };
+  }
+
   protected abstract generateSyncStreamImplementation(
     connector: PowerSyncBackendConnector,
     options: CreateSyncImplementationOptions & RequiredAdditionalConnectionOptions
@@ -416,15 +429,16 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   protected async initialize() {
     await this._initialize();
     await this.bucketStorageAdapter.init();
-    await this._loadVersion();
+    await this.loadVersion();
     await this.updateSchema(this.options.schema);
     await this.resolveOfflineSyncStatus();
     await this.database.execute('PRAGMA RECURSIVE_TRIGGERS=TRUE');
+    await this.triggersImpl.cleanupResources();
     this.ready = true;
     this.iterateListeners((cb) => cb.initialized?.());
   }
 
-  private async _loadVersion() {
+  protected async loadVersion() {
     try {
       const { version } = await this.database.get<{ version: string }>('SELECT powersync_rs_version() as version');
       this.sdkVersion = version;
@@ -560,7 +574,6 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
     const { clearLocal } = options;
 
-    // TODO DB name, verify this is necessary with extension
     await this.database.writeTransaction(async (tx) => {
       await tx.execute('SELECT powersync_clear(?)', [clearLocal ? 1 : 0]);
     });
@@ -597,6 +610,8 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
       return;
     }
 
+    this.triggersImpl.dispose();
+
     await this.iterateAsyncListeners(async (cb) => cb.closing?.());
 
     const { disconnect } = options;

package/src/client/ConnectionManager.ts

@@ -1,4 +1,5 @@
 import { ILogger } from 'js-logger';
+import { SyncStatus } from '../db/crud/SyncStatus.js';
 import { BaseListener, BaseObserver } from '../utils/BaseObserver.js';
 import { PowerSyncBackendConnector } from './connection/PowerSyncBackendConnector.js';
 import {
@@ -13,7 +14,6 @@ import {
   SyncStreamSubscribeOptions,
   SyncStreamSubscription
 } from './sync/sync-streams.js';
-import { SyncStatus } from '../db/crud/SyncStatus.js';
 
 /**
  * @internal

package/src/client/sync/stream/AbstractRemote.ts

@@ -573,7 +573,11 @@ export abstract class AbstractRemote {
 
     const stream = new DataStream<T, string>({
       logger: this.logger,
-      mapLine: mapLine
+      mapLine: mapLine,
+      pressure: {
+        highWaterMark: 20,
+        lowWaterMark: 10
+      }
     });
 
     abortSignal?.addEventListener('abort', () => {
@@ -585,46 +589,54 @@ export abstract class AbstractRemote {
     let buffer = '';
 
 
+    const consumeStream = async () => {
+      while (!stream.closed && !abortSignal?.aborted && !readerReleased) {
+        const { done, value } = await reader.read();
+        if (done) {
+          const remaining = buffer.trim();
+          if (remaining.length != 0) {
+            stream.enqueueData(remaining);
+          }
 
-    const l = stream.registerListener({
-      lowWater: async () => {
-        if (stream.closed || abortSignal?.aborted || readerReleased) {
-          return
-        } 
-        try {
-          let didCompleteLine = false;
-          while (!didCompleteLine) {
-            const { done, value } = await reader.read();
-            if (done) {
-              const remaining = buffer.trim();
-              if (remaining.length != 0) {
-                stream.enqueueData(remaining);
-              }
+          stream.close();
+          await closeReader();
+          return;
+        }
 
-              stream.close();
-              await closeReader();
-              return;
-            }
+        const data = decoder.decode(value, { stream: true });
+        buffer += data;
 
-            const data = decoder.decode(value, { stream: true });
-            buffer += data;
+        const lines = buffer.split('\n');
+        for (var i = 0; i < lines.length - 1; i++) {
+          var l = lines[i].trim();
+          if (l.length > 0) {
+            stream.enqueueData(l);
+          }
+        }
 
-            const lines = buffer.split('\n');
-            for (var i = 0; i < lines.length - 1; i++) {
-              var l = lines[i].trim();
-              if (l.length > 0) {
-                stream.enqueueData(l);
-                didCompleteLine = true;
+        buffer = lines[lines.length - 1];
+
+        // Implement backpressure by waiting for the low water mark to be reached
+        if (stream.dataQueue.length > stream.highWatermark) {
+          await new Promise<void>((resolve) => {
+            const dispose = stream.registerListener({
+              lowWater: async () => {
+                resolve();
+                dispose();
+              },
+              closed: () => {
+                resolve();
+                dispose();
               }
-            }
-
-            buffer = lines[lines.length - 1];
-          }
-        } catch (ex) {
-          stream.close();
-          throw ex;
+            })
+          })
         }
-      },
+      }
+    }
+
+    consumeStream().catch(ex => this.logger.error('Error consuming stream', ex));
+
+    const l = stream.registerListener({
       closed: () => {
         closeReader();
         l?.();

package/src/client/sync/stream/AbstractStreamingSyncImplementation.ts

@@ -47,18 +47,17 @@ export enum SyncClientImplementation {
    *
    * This is the default option.
    *
-   * @deprecated Don't use {@link SyncClientImplementation.JAVASCRIPT} directly. Instead, use
-   * {@link DEFAULT_SYNC_CLIENT_IMPLEMENTATION} or omit the option. The explicit choice to use
-   * the JavaScript-based sync implementation will be removed from a future version of the SDK.
+   * @deprecated We recommend the {@link RUST} client implementation for all apps. If you have issues with
+   * the Rust client, please file an issue or reach out to us. The JavaScript client will be removed in a future
+   * version of the PowerSync SDK.
    */
   JAVASCRIPT = 'js',
   /**
    * This implementation offloads the sync line decoding and handling into the PowerSync
    * core extension.
    *
-   * @experimental
-   * While this implementation is more performant than {@link SyncClientImplementation.JAVASCRIPT},
-   * it has seen less real-world testing and is marked as __experimental__ at the moment.
+   * This option is more performant than the {@link JAVASCRIPT} client, enabled by default and the
+   * recommended client implementation for all apps.
    *
    * ## Compatibility warning
    *
@@ -77,13 +76,9 @@ export enum SyncClientImplementation {
 }
 
 /**
- * The default {@link SyncClientImplementation} to use.
- *
- * Please use this field instead of {@link SyncClientImplementation.JAVASCRIPT} directly. A future version
- * of the PowerSync SDK will enable {@link SyncClientImplementation.RUST} by default and remove the JavaScript
- * option.
+ * The default {@link SyncClientImplementation} to use, {@link SyncClientImplementation.RUST}.
  */
-export const DEFAULT_SYNC_CLIENT_IMPLEMENTATION = SyncClientImplementation.JAVASCRIPT;
+export const DEFAULT_SYNC_CLIENT_IMPLEMENTATION = SyncClientImplementation.RUST;
 
 /**
  * Abstract Lock to be implemented by various JS environments
@@ -194,8 +189,7 @@ export interface RequiredAdditionalConnectionOptions extends Required<Additional
 }
 
 export interface StreamingSyncImplementation
-  extends BaseObserverInterface<StreamingSyncImplementationListener>,
-    Disposable {
+  extends BaseObserverInterface<StreamingSyncImplementationListener>, Disposable {
   /**
    * Connects to the sync service
    */
@@ -693,6 +687,9 @@ The next upload iteration will be delayed.`);
     if (rawTables != null && rawTables.length) {
       this.logger.warn('Raw tables require the Rust-based sync client. The JS client will ignore them.');
     }
+    if (this.activeStreams.length) {
+      this.logger.error('Sync streams require `clientImplementation: SyncClientImplementation.RUST` when connecting.');
+    }
 
     this.logger.debug('Streaming sync iteration started');
     this.options.adapter.startSession();
@@ -1241,7 +1238,6 @@ The next upload iteration will be delayed.`);
         resolve();
         return;
       }
-
       const { retryDelayMs } = this.options;
 
       let timeoutId: ReturnType<typeof setTimeout> | undefined;

package/src/client/triggers/MemoryTriggerClaimManager.ts

@@ -0,0 +1,25 @@
+import { TriggerClaimManager } from './TriggerManager.js';
+
+const CLAIM_STORE = new Map<string, () => Promise<void>>();
+
+/**
+ * @internal
+ * @experimental
+ */
+export const MEMORY_TRIGGER_CLAIM_MANAGER: TriggerClaimManager = {
+  async obtainClaim(identifier: string): Promise<() => Promise<void>> {
+    if (CLAIM_STORE.has(identifier)) {
+      throw new Error(`A claim is already present for ${identifier}`);
+    }
+    const release = async () => {
+      CLAIM_STORE.delete(identifier);
+    };
+    CLAIM_STORE.set(identifier, release);
+
+    return release;
+  },
+
+  async checkClaim(identifier: string): Promise<boolean> {
+    return CLAIM_STORE.has(identifier);
+  }
+};

package/src/client/triggers/TriggerManager.ts

@@ -47,8 +47,9 @@ export interface BaseTriggerDiffRecord<TOperationId extends string | number = nu
  * This record contains the new value and optionally the previous value.
  * Values are stored as JSON strings.
  */
-export interface TriggerDiffUpdateRecord<TOperationId extends string | number = number>
-  extends BaseTriggerDiffRecord<TOperationId> {
+export interface TriggerDiffUpdateRecord<
+  TOperationId extends string | number = number
+> extends BaseTriggerDiffRecord<TOperationId> {
   operation: DiffTriggerOperation.UPDATE;
   /**
    * The updated state of the row in JSON string format.
@@ -65,8 +66,9 @@ export interface TriggerDiffUpdateRecord<TOperationId extends string | number =
  * Represents a diff record for a SQLite INSERT operation.
  * This record contains the new value represented as a JSON string.
  */
-export interface TriggerDiffInsertRecord<TOperationId extends string | number = number>
-  extends BaseTriggerDiffRecord<TOperationId> {
+export interface TriggerDiffInsertRecord<
+  TOperationId extends string | number = number
+> extends BaseTriggerDiffRecord<TOperationId> {
   operation: DiffTriggerOperation.INSERT;
   /**
    * The value of the row, at the time of INSERT, in JSON string format.
@@ -79,8 +81,9 @@ export interface TriggerDiffInsertRecord<TOperationId extends string | number =
  * Represents a diff record for a SQLite DELETE operation.
  * This record contains the new value represented as a JSON string.
  */
-export interface TriggerDiffDeleteRecord<TOperationId extends string | number = number>
-  extends BaseTriggerDiffRecord<TOperationId> {
+export interface TriggerDiffDeleteRecord<
+  TOperationId extends string | number = number
+> extends BaseTriggerDiffRecord<TOperationId> {
   operation: DiffTriggerOperation.DELETE;
   /**
    * The value of the row, before the DELETE operation, in JSON string format.
@@ -201,6 +204,12 @@ interface BaseCreateDiffTriggerOptions {
    * Hooks which allow execution during the trigger creation process.
    */
   hooks?: TriggerCreationHooks;
+
+  /**
+   * Use storage-backed (non-TEMP) tables and triggers that persist across sessions.
+   * These resources are still automatically disposed when no longer claimed.
+   */
+  useStorage?: boolean;
 }
 
 /**
@@ -449,3 +458,38 @@ export interface TriggerManager {
    */
   trackTableDiff(options: TrackDiffOptions): Promise<TriggerRemoveCallback>;
 }
+
+/**
+ * @experimental
+ * @internal
+ * Manages claims on persisted SQLite triggers and destination tables to enable proper cleanup
+ * when they are no longer actively in use.
+ *
+ * When using persisted triggers (especially for OPFS multi-tab scenarios), we need a reliable way to determine which resources are still actively in use across different connections/tabs so stale resources can be safely cleaned up without interfering with active triggers.
+ *
+ * A cleanup process runs
+ * on database creation (and every 2 minutes) that:
+ * 1. Queries for existing managed persisted resources
+ * 2. Checks with the claim manager if any consumer is actively using those resources
+ * 3. Deletes unused resources
+ */
+
+export interface TriggerClaimManager {
+  /**
+   * Obtains or marks a claim on a certain identifier.
+   * @returns a callback to release the claim.
+   */
+  obtainClaim: (identifier: string) => Promise<() => Promise<void>>;
+  /**
+   * Checks if a claim is present for an identifier.
+   */
+  checkClaim: (identifier: string) => Promise<boolean>;
+}
+
+/**
+ * @experimental
+ * @internal
+ */
+export interface TriggerManagerConfig {
+  claimManager: TriggerClaimManager;
+}

package/src/client/triggers/TriggerManagerImpl.ts

@@ -1,24 +1,62 @@
 import { LockContext } from '../../db/DBAdapter.js';
 import { Schema } from '../../db/schema/Schema.js';
-import { type AbstractPowerSyncDatabase } from '../AbstractPowerSyncDatabase.js';
+import type { AbstractPowerSyncDatabase } from '../AbstractPowerSyncDatabase.js';
 import { DEFAULT_WATCH_THROTTLE_MS } from '../watched/WatchedQuery.js';
 import {
   CreateDiffTriggerOptions,
   DiffTriggerOperation,
   TrackDiffOptions,
   TriggerManager,
+  TriggerManagerConfig,
   TriggerRemoveCallback,
   WithDiffOptions
 } from './TriggerManager.js';
 
-export type TriggerManagerImplOptions = {
+export type TriggerManagerImplOptions = TriggerManagerConfig & {
   db: AbstractPowerSyncDatabase;
   schema: Schema;
 };
 
+export type TriggerManagerImplConfiguration = {
+  useStorageByDefault: boolean;
+};
+
+export const DEFAULT_TRIGGER_MANAGER_CONFIGURATION: TriggerManagerImplConfiguration = {
+  useStorageByDefault: false
+};
+
+/**
+ * A record of persisted table/trigger information.
+ * This is used for fail-safe cleanup.
+ */
+type TrackedTableRecord = {
+  /**
+   * The id of the trigger. This is used in the SQLite trigger name
+   */
+  id: string;
+  /**
+   * The destination table name for the trigger
+   */
+  table: string;
+  /**
+   * Array of actual trigger names found for this table/id combo
+   */
+  triggerNames: string[];
+};
+
+const TRIGGER_CLEANUP_INTERVAL_MS = 120_000; // 2 minutes
+
+/**
+ * @internal
+ * @experimental
+ */
 export class TriggerManagerImpl implements TriggerManager {
   protected schema: Schema;
 
+  protected defaultConfig: TriggerManagerImplConfiguration;
+  protected cleanupTimeout: ReturnType<typeof setTimeout> | null;
+  protected isDisposed: boolean;
+
   constructor(protected options: TriggerManagerImplOptions) {
     this.schema = options.schema;
     options.db.registerListener({
@@ -26,6 +64,32 @@ export class TriggerManagerImpl implements TriggerManager {
         this.schema = schema;
       }
     });
+    this.isDisposed = false;
+
+    /**
+     * Configure a cleanup to run on an interval.
+     * The interval is configured using setTimeout to take the async
+     * execution time of the callback into account.
+     */
+    this.defaultConfig = DEFAULT_TRIGGER_MANAGER_CONFIGURATION;
+    const cleanupCallback = async () => {
+      this.cleanupTimeout = null;
+      if (this.isDisposed) {
+        return;
+      }
+      try {
+        await this.cleanupResources();
+      } catch (ex) {
+        this.db.logger.error(`Caught error while attempting to cleanup triggers`, ex);
+      } finally {
+        // if not closed, set another timeout
+        if (this.isDisposed) {
+          return;
+        }
+        this.cleanupTimeout = setTimeout(cleanupCallback, TRIGGER_CLEANUP_INTERVAL_MS);
+      }
+    };
+    this.cleanupTimeout = setTimeout(cleanupCallback, TRIGGER_CLEANUP_INTERVAL_MS);
   }
 
   protected get db() {
@@ -48,14 +112,111 @@ export class TriggerManagerImpl implements TriggerManager {
     }
   }
 
+  dispose() {
+    this.isDisposed = true;
+    if (this.cleanupTimeout) {
+      clearTimeout(this.cleanupTimeout);
+    }
+  }
+
+  /**
+   * Updates default config settings for platform specific use-cases.
+   */
+  updateDefaults(config: TriggerManagerImplConfiguration) {
+    this.defaultConfig = {
+      ...this.defaultConfig,
+      ...config
+    };
+  }
+
+  protected generateTriggerName(operation: DiffTriggerOperation, destinationTable: string, triggerId: string) {
+    return `__ps_temp_trigger_${operation.toLowerCase()}__${destinationTable}__${triggerId}`;
+  }
+
+  /**
+   * Cleanup any SQLite triggers or tables that are no longer in use.
+   */
+  async cleanupResources() {
+    // we use the database here since cleanupResources is called during the PowerSyncDatabase initialization
+    await this.db.database.writeLock(async (ctx) => {
+      /**
+       * Note: We only cleanup persisted triggers. These are tracked in the sqlite_master table.
+       * temporary triggers will not be affected by this.
+       * Query all triggers that match our naming pattern
+       */
+      const triggers = await ctx.getAll<{ name: string }>(/* sql */ `
+        SELECT
+          name
+        FROM
+          sqlite_master
+        WHERE
+          type = 'trigger'
+          AND name LIKE '__ps_temp_trigger_%'
+      `);
+
+      /** Use regex to extract table names and IDs from trigger names
+       * Trigger naming convention: __ps_temp_trigger_<operation>__<destination_table>__<id>
+       */
+      const triggerPattern = /^__ps_temp_trigger_(?:insert|update|delete)__(.+)__([a-f0-9_]{36})$/i;
+      const trackedItems = new Map<string, TrackedTableRecord>();
+
+      for (const trigger of triggers) {
+        const match = trigger.name.match(triggerPattern);
+        if (match) {
+          const [, table, id] = match;
+          // Collect all trigger names for each id combo
+          const existing = trackedItems.get(id);
+          if (existing) {
+            existing.triggerNames.push(trigger.name);
+          } else {
+            trackedItems.set(id, { table, id, triggerNames: [trigger.name] });
+          }
+        }
+      }
+
+      for (const trackedItem of trackedItems.values()) {
+        // check if there is anything holding on to this item
+        const hasClaim = await this.options.claimManager.checkClaim(trackedItem.id);
+        if (hasClaim) {
+          // This does not require cleanup
+          continue;
+        }
+
+        this.db.logger.debug(`Clearing resources for trigger ${trackedItem.id} with table ${trackedItem.table}`);
+
+        // We need to delete the triggers and table
+        for (const triggerName of trackedItem.triggerNames) {
+          await ctx.execute(`DROP TRIGGER IF EXISTS ${triggerName}`);
+        }
+        await ctx.execute(`DROP TABLE IF EXISTS ${trackedItem.table}`);
+      }
+    });
+  }
+
   async createDiffTrigger(options: CreateDiffTriggerOptions) {
     await this.db.waitForReady();
-    const { source, destination, columns, when, hooks } = options;
+    const {
+      source,
+      destination,
+      columns,
+      when,
+      hooks,
+      // Fall back to the provided default if not given on this level
+      useStorage = this.defaultConfig.useStorageByDefault
+    } = options;
     const operations = Object.keys(when) as DiffTriggerOperation[];
     if (operations.length == 0) {
       throw new Error('At least one WHEN operation must be specified for the trigger.');
     }
 
+    /**
+     * The clause to use when executing
+     * CREATE ${tableTriggerTypeClause} TABLE
+     * OR
+     * CREATE ${tableTriggerTypeClause} TRIGGER
+     */
+    const tableTriggerTypeClause = !useStorage ? 'TEMP' : '';
+
     const whenClauses = Object.fromEntries(
       Object.entries(when).map(([operation, filter]) => [operation, `WHEN ${filter}`])
     );
@@ -76,6 +237,8 @@ export class TriggerManagerImpl implements TriggerManager {
 
     const id = await this.getUUID();
 
+    const releaseStorageClaim = useStorage ? await this.options.claimManager.obtainClaim(id) : null;
+
     /**
      * We default to replicating all columns if no columns array is provided.
      */
@@ -110,6 +273,7 @@ export class TriggerManagerImpl implements TriggerManager {
       return this.db.writeLock(async (tx) => {
         await this.removeTriggers(tx, triggerIds);
         await tx.execute(/* sql */ `DROP TABLE IF EXISTS ${destination};`);
+        await releaseStorageClaim?.();
       });
     };
 
@@ -117,22 +281,22 @@ export class TriggerManagerImpl implements TriggerManager {
       // Allow user code to execute in this lock context before the trigger is created.
       await hooks?.beforeCreate?.(tx);
       await tx.execute(/* sql */ `
-        CREATE TEMP TABLE ${destination} (
+        CREATE ${tableTriggerTypeClause} TABLE ${destination} (
           operation_id INTEGER PRIMARY KEY AUTOINCREMENT,
           id TEXT,
           operation TEXT,
           timestamp TEXT,
           value TEXT,
           previous_value TEXT
-        );
+        )
       `);
 
       if (operations.includes(DiffTriggerOperation.INSERT)) {
-        const insertTriggerId = `ps_temp_trigger_insert_${id}`;
+        const insertTriggerId = this.generateTriggerName(DiffTriggerOperation.INSERT, destination, id);
         triggerIds.push(insertTriggerId);
 
         await tx.execute(/* sql */ `
-          CREATE TEMP TRIGGER ${insertTriggerId} AFTER INSERT ON ${internalSource} ${whenClauses[
+          CREATE ${tableTriggerTypeClause} TRIGGER ${insertTriggerId} AFTER INSERT ON ${internalSource} ${whenClauses[
             DiffTriggerOperation.INSERT
           ]} BEGIN
           INSERT INTO
@@ -145,16 +309,16 @@ export class TriggerManagerImpl implements TriggerManager {
               ${jsonFragment('NEW')}
             );
 
-          END;
+          END
         `);
       }
 
       if (operations.includes(DiffTriggerOperation.UPDATE)) {
-        const updateTriggerId = `ps_temp_trigger_update_${id}`;
+        const updateTriggerId = this.generateTriggerName(DiffTriggerOperation.UPDATE, destination, id);
         triggerIds.push(updateTriggerId);
 
         await tx.execute(/* sql */ `
-          CREATE TEMP TRIGGER ${updateTriggerId} AFTER
+          CREATE ${tableTriggerTypeClause} TRIGGER ${updateTriggerId} AFTER
           UPDATE ON ${internalSource} ${whenClauses[DiffTriggerOperation.UPDATE]} BEGIN
           INSERT INTO
             ${destination} (id, operation, timestamp, value, previous_value)
@@ -172,12 +336,12 @@ export class TriggerManagerImpl implements TriggerManager {
       }
 
       if (operations.includes(DiffTriggerOperation.DELETE)) {
-        const deleteTriggerId = `ps_temp_trigger_delete_${id}`;
+        const deleteTriggerId = this.generateTriggerName(DiffTriggerOperation.DELETE, destination, id);
         triggerIds.push(deleteTriggerId);
 
         // Create delete trigger for basic JSON
         await tx.execute(/* sql */ `
-          CREATE TEMP TRIGGER ${deleteTriggerId} AFTER DELETE ON ${internalSource} ${whenClauses[
+          CREATE ${tableTriggerTypeClause} TRIGGER ${deleteTriggerId} AFTER DELETE ON ${internalSource} ${whenClauses[
             DiffTriggerOperation.DELETE
           ]} BEGIN
           INSERT INTO
@@ -227,7 +391,7 @@ export class TriggerManagerImpl implements TriggerManager {
     const contextColumns = columns ?? sourceDefinition.columns.map((col) => col.name);
 
     const id = await this.getUUID();
-    const destination = `ps_temp_track_${source}_${id}`;
+    const destination = `__ps_temp_track_${source}_${id}`;
 
     // register an onChange before the trigger is created
     const abortController = new AbortController();