@breeztech/breez-sdk-spark 0.14.0 → 0.15.1

package/nodejs/postgres-token-store/migrations.cjs

@@ -1,7 +1,7 @@
 /**
  * Database Migration Manager for Breez SDK PostgreSQL Token Store
  *
- * Uses a token_schema_migrations table + pg_advisory_xact_lock to safely run
+ * Uses a brz_token_schema_migrations table + pg_advisory_xact_lock to safely run
  * migrations from concurrent processes.
  */
 
@@ -39,9 +39,11 @@ class TokenStoreMigrationManager {
       // Transaction-level advisory lock — automatically released on COMMIT/ROLLBACK
       await client.query(`SELECT pg_advisory_xact_lock(${MIGRATION_LOCK_ID})`);
 
+      await this._applySchemaRenames(client);
+
       // Create the migrations tracking table if needed
       await client.query(`
-        CREATE TABLE IF NOT EXISTS token_schema_migrations (
+        CREATE TABLE IF NOT EXISTS brz_token_schema_migrations (
           version INTEGER PRIMARY KEY,
           applied_at TIMESTAMPTZ DEFAULT NOW()
         )
@@ -49,7 +51,7 @@ class TokenStoreMigrationManager {
 
       // Get current version
       const versionResult = await client.query(
-        "SELECT COALESCE(MAX(version), 0) AS version FROM token_schema_migrations"
+        "SELECT COALESCE(MAX(version), 0) AS version FROM brz_token_schema_migrations"
       );
       const currentVersion = versionResult.rows[0].version;
 
@@ -76,7 +78,7 @@ class TokenStoreMigrationManager {
         }
 
         await client.query(
-          "INSERT INTO token_schema_migrations (version) VALUES ($1)",
+          "INSERT INTO brz_token_schema_migrations (version) VALUES ($1)",
           [version]
         );
       }
@@ -94,6 +96,96 @@ class TokenStoreMigrationManager {
     }
   }
 
+  /**
+   * Pre-prefix rename. Canary-gated on the legacy `token_schema_migrations`
+   * table.
+   * @param {import('pg').PoolClient} client
+   */
+  async _applySchemaRenames(client) {
+    const canary = await client.query(
+      `SELECT EXISTS (
+         SELECT 1 FROM information_schema.tables
+         WHERE table_schema = current_schema()
+           AND table_name = 'token_schema_migrations'
+       ) AS exists`
+    );
+    if (!canary.rows[0].exists) {
+      return;
+    }
+
+    const tableRenames = [
+      ["token_metadata", "brz_token_metadata"],
+      ["token_reservations", "brz_token_reservations"],
+      ["token_outputs", "brz_token_outputs"],
+      ["token_spent_outputs", "brz_token_spent_outputs"],
+      ["token_swap_status", "brz_token_swap_status"],
+    ];
+    for (const [oldName, newName] of tableRenames) {
+      await client.query(`ALTER TABLE IF EXISTS ${oldName} RENAME TO ${newName}`);
+    }
+
+    const indexRenames = [
+      ["idx_token_metadata_user_issuer_pk", "brz_idx_token_metadata_user_issuer_pk"],
+      ["idx_token_outputs_user_identifier", "brz_idx_token_outputs_user_identifier"],
+      ["idx_token_outputs_user_reservation", "brz_idx_token_outputs_user_reservation"],
+      // Pre-multi-tenant indexes (dropped by the multi-tenant migration).
+      ["idx_token_metadata_issuer_pk", "brz_idx_token_metadata_issuer_pk"],
+      ["idx_token_outputs_identifier", "brz_idx_token_outputs_identifier"],
+      ["idx_token_outputs_reservation", "brz_idx_token_outputs_reservation"],
+    ];
+    for (const [oldName, newName] of indexRenames) {
+      await client.query(`ALTER INDEX IF EXISTS ${oldName} RENAME TO ${newName}`);
+    }
+
+    const constraintRenames = [
+      ["brz_token_metadata", "token_metadata_pkey", "brz_token_metadata_pkey"],
+      ["brz_token_reservations", "token_reservations_pkey", "brz_token_reservations_pkey"],
+      ["brz_token_outputs", "token_outputs_pkey", "brz_token_outputs_pkey"],
+      [
+        "brz_token_outputs",
+        "token_outputs_user_id_token_identifier_fkey",
+        "brz_token_outputs_user_id_token_identifier_fkey",
+      ],
+      [
+        "brz_token_outputs",
+        "token_outputs_user_id_reservation_id_fkey",
+        "brz_token_outputs_user_id_reservation_id_fkey",
+      ],
+      // Pre-multi-tenant FKs (single-column). Rename so the post-tenant
+      // migration's `DROP CONSTRAINT IF EXISTS brz_*_fkey` finds them.
+      [
+        "brz_token_outputs",
+        "token_outputs_token_identifier_fkey",
+        "brz_token_outputs_token_identifier_fkey",
+      ],
+      [
+        "brz_token_outputs",
+        "token_outputs_reservation_id_fkey",
+        "brz_token_outputs_reservation_id_fkey",
+      ],
+      ["brz_token_spent_outputs", "token_spent_outputs_pkey", "brz_token_spent_outputs_pkey"],
+      ["brz_token_swap_status", "token_swap_status_pkey", "brz_token_swap_status_pkey"],
+    ];
+    for (const [table, oldName, newName] of constraintRenames) {
+      await client.query(
+        `DO $$ BEGIN
+           IF EXISTS (
+             SELECT 1 FROM information_schema.table_constraints
+             WHERE table_schema = current_schema()
+               AND table_name = '${table}'
+               AND constraint_name = '${oldName}'
+           ) THEN
+             ALTER TABLE ${table} RENAME CONSTRAINT ${oldName} TO ${newName};
+           END IF;
+         END $$`
+      );
+    }
+
+    await client.query(
+      `ALTER TABLE IF EXISTS token_schema_migrations RENAME TO brz_token_schema_migrations`
+    );
+  }
+
   _log(level, message) {
     if (this.logger && typeof this.logger.log === "function") {
       this.logger.log({ line: message, level });
@@ -118,7 +210,7 @@ class TokenStoreMigrationManager {
       {
         name: "Create token store tables with race condition protection",
         sql: [
-          `CREATE TABLE IF NOT EXISTS token_metadata (
+          `CREATE TABLE IF NOT EXISTS brz_token_metadata (
             identifier TEXT PRIMARY KEY,
             issuer_public_key TEXT NOT NULL,
             name TEXT NOT NULL,
@@ -129,18 +221,18 @@ class TokenStoreMigrationManager {
             creation_entity_public_key TEXT
           )`,
 
-          `CREATE INDEX IF NOT EXISTS idx_token_metadata_issuer_pk
-            ON token_metadata (issuer_public_key)`,
+          `CREATE INDEX IF NOT EXISTS brz_idx_token_metadata_issuer_pk
+            ON brz_token_metadata (issuer_public_key)`,
 
-          `CREATE TABLE IF NOT EXISTS token_reservations (
+          `CREATE TABLE IF NOT EXISTS brz_token_reservations (
             id TEXT PRIMARY KEY,
             purpose TEXT NOT NULL,
             created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
           )`,
 
-          `CREATE TABLE IF NOT EXISTS token_outputs (
+          `CREATE TABLE IF NOT EXISTS brz_token_outputs (
             id TEXT PRIMARY KEY,
-            token_identifier TEXT NOT NULL REFERENCES token_metadata(identifier),
+            token_identifier TEXT NOT NULL REFERENCES brz_token_metadata(identifier),
             owner_public_key TEXT NOT NULL,
             revocation_commitment TEXT NOT NULL,
             withdraw_bond_sats BIGINT NOT NULL,
@@ -149,32 +241,32 @@ class TokenStoreMigrationManager {
             token_amount TEXT NOT NULL,
             prev_tx_hash TEXT NOT NULL,
             prev_tx_vout INTEGER NOT NULL,
-            reservation_id TEXT REFERENCES token_reservations(id) ON DELETE SET NULL,
+            reservation_id TEXT REFERENCES brz_token_reservations(id) ON DELETE SET NULL,
             added_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
           )`,
 
-          `CREATE INDEX IF NOT EXISTS idx_token_outputs_identifier
-            ON token_outputs (token_identifier)`,
+          `CREATE INDEX IF NOT EXISTS brz_idx_token_outputs_identifier
+            ON brz_token_outputs (token_identifier)`,
 
-          `CREATE INDEX IF NOT EXISTS idx_token_outputs_reservation
-            ON token_outputs (reservation_id) WHERE reservation_id IS NOT NULL`,
+          `CREATE INDEX IF NOT EXISTS brz_idx_token_outputs_reservation
+            ON brz_token_outputs (reservation_id) WHERE reservation_id IS NOT NULL`,
 
-          `CREATE TABLE IF NOT EXISTS token_spent_outputs (
+          `CREATE TABLE IF NOT EXISTS brz_token_spent_outputs (
             output_id TEXT PRIMARY KEY,
             spent_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
           )`,
 
-          `CREATE TABLE IF NOT EXISTS token_swap_status (
+          `CREATE TABLE IF NOT EXISTS brz_token_swap_status (
             id INTEGER PRIMARY KEY DEFAULT 1 CHECK (id = 1),
             last_completed_at TIMESTAMPTZ
           )`,
 
-          `INSERT INTO token_swap_status (id) VALUES (1) ON CONFLICT DO NOTHING`,
+          `INSERT INTO brz_token_swap_status (id) VALUES (1) ON CONFLICT DO NOTHING`,
         ],
       },
       {
         // Mirrors Rust migration 2 in spark-postgres/src/token_store.rs.
-        // Adds user_id to every token-store table (including token_metadata —
+        // Adds user_id to every token-store table (including brz_token_metadata —
         // per-tenant to avoid 0-balance leakage for tokens a tenant never
         // owned), backfills with the connecting tenant, and rewrites primary
         // keys / FKs / indexes to lead with user_id. Composite FKs use NO
@@ -185,62 +277,62 @@ class TokenStoreMigrationManager {
           // Drop dependent FKs FIRST so we can rebuild parent PKs they
           // reference. Inline `REFERENCES` clauses get auto-named
           // `<table>_<column>_fkey`.
-          `ALTER TABLE token_outputs
-             DROP CONSTRAINT IF EXISTS token_outputs_reservation_id_fkey`,
-          `ALTER TABLE token_outputs
-             DROP CONSTRAINT IF EXISTS token_outputs_token_identifier_fkey`,
-
-          // token_metadata: per-tenant scoping (privacy — see header).
-          `ALTER TABLE token_metadata ADD COLUMN user_id BYTEA`,
-          `UPDATE token_metadata SET user_id = ${idLit}`,
-          `ALTER TABLE token_metadata
+          `ALTER TABLE brz_token_outputs
+             DROP CONSTRAINT IF EXISTS brz_token_outputs_reservation_id_fkey`,
+          `ALTER TABLE brz_token_outputs
+             DROP CONSTRAINT IF EXISTS brz_token_outputs_token_identifier_fkey`,
+
+          // brz_token_metadata: per-tenant scoping (privacy — see header).
+          `ALTER TABLE brz_token_metadata ADD COLUMN user_id BYTEA`,
+          `UPDATE brz_token_metadata SET user_id = ${idLit}`,
+          `ALTER TABLE brz_token_metadata
              ALTER COLUMN user_id SET NOT NULL,
-             DROP CONSTRAINT IF EXISTS token_metadata_pkey,
+             DROP CONSTRAINT IF EXISTS brz_token_metadata_pkey,
              ADD PRIMARY KEY (user_id, identifier)`,
-          `DROP INDEX IF EXISTS idx_token_metadata_issuer_pk`,
-          `CREATE INDEX idx_token_metadata_user_issuer_pk
-             ON token_metadata (user_id, issuer_public_key)`,
-
-          // token_reservations: scope by user_id.
-          `ALTER TABLE token_reservations ADD COLUMN user_id BYTEA`,
-          `UPDATE token_reservations SET user_id = ${idLit}`,
-          `ALTER TABLE token_reservations
+          `DROP INDEX IF EXISTS brz_idx_token_metadata_issuer_pk`,
+          `CREATE INDEX brz_idx_token_metadata_user_issuer_pk
+             ON brz_token_metadata (user_id, issuer_public_key)`,
+
+          // brz_token_reservations: scope by user_id.
+          `ALTER TABLE brz_token_reservations ADD COLUMN user_id BYTEA`,
+          `UPDATE brz_token_reservations SET user_id = ${idLit}`,
+          `ALTER TABLE brz_token_reservations
              ALTER COLUMN user_id SET NOT NULL,
-             DROP CONSTRAINT IF EXISTS token_reservations_pkey,
+             DROP CONSTRAINT IF EXISTS brz_token_reservations_pkey,
              ADD PRIMARY KEY (user_id, id)`,
 
-          // token_outputs: scope by user_id, rekey, re-add composite FKs.
-          `ALTER TABLE token_outputs ADD COLUMN user_id BYTEA`,
-          `UPDATE token_outputs SET user_id = ${idLit}`,
-          `ALTER TABLE token_outputs
+          // brz_token_outputs: scope by user_id, rekey, re-add composite FKs.
+          `ALTER TABLE brz_token_outputs ADD COLUMN user_id BYTEA`,
+          `UPDATE brz_token_outputs SET user_id = ${idLit}`,
+          `ALTER TABLE brz_token_outputs
              ALTER COLUMN user_id SET NOT NULL,
-             DROP CONSTRAINT IF EXISTS token_outputs_pkey,
+             DROP CONSTRAINT IF EXISTS brz_token_outputs_pkey,
              ADD PRIMARY KEY (user_id, id),
              ADD FOREIGN KEY (user_id, token_identifier)
-                REFERENCES token_metadata(user_id, identifier),
+                REFERENCES brz_token_metadata(user_id, identifier),
              ADD FOREIGN KEY (user_id, reservation_id)
-                REFERENCES token_reservations(user_id, id)`,
-          `DROP INDEX IF EXISTS idx_token_outputs_identifier`,
-          `DROP INDEX IF EXISTS idx_token_outputs_reservation`,
-          `CREATE INDEX idx_token_outputs_user_identifier
-             ON token_outputs (user_id, token_identifier)`,
-          `CREATE INDEX idx_token_outputs_user_reservation
-             ON token_outputs (user_id, reservation_id)
+                REFERENCES brz_token_reservations(user_id, id)`,
+          `DROP INDEX IF EXISTS brz_idx_token_outputs_identifier`,
+          `DROP INDEX IF EXISTS brz_idx_token_outputs_reservation`,
+          `CREATE INDEX brz_idx_token_outputs_user_identifier
+             ON brz_token_outputs (user_id, token_identifier)`,
+          `CREATE INDEX brz_idx_token_outputs_user_reservation
+             ON brz_token_outputs (user_id, reservation_id)
              WHERE reservation_id IS NOT NULL`,
 
-          // token_spent_outputs: scope by user_id.
-          `ALTER TABLE token_spent_outputs ADD COLUMN user_id BYTEA`,
-          `UPDATE token_spent_outputs SET user_id = ${idLit}`,
-          `ALTER TABLE token_spent_outputs
+          // brz_token_spent_outputs: scope by user_id.
+          `ALTER TABLE brz_token_spent_outputs ADD COLUMN user_id BYTEA`,
+          `UPDATE brz_token_spent_outputs SET user_id = ${idLit}`,
+          `ALTER TABLE brz_token_spent_outputs
              ALTER COLUMN user_id SET NOT NULL,
-             DROP CONSTRAINT IF EXISTS token_spent_outputs_pkey,
+             DROP CONSTRAINT IF EXISTS brz_token_spent_outputs_pkey,
              ADD PRIMARY KEY (user_id, output_id)`,
 
-          // token_swap_status: drop the singleton id, rekey by user_id.
-          `ALTER TABLE token_swap_status DROP COLUMN id CASCADE`,
-          `ALTER TABLE token_swap_status ADD COLUMN user_id BYTEA`,
-          `UPDATE token_swap_status SET user_id = ${idLit}`,
-          `ALTER TABLE token_swap_status
+          // brz_token_swap_status: drop the singleton id, rekey by user_id.
+          `ALTER TABLE brz_token_swap_status DROP COLUMN id CASCADE`,
+          `ALTER TABLE brz_token_swap_status ADD COLUMN user_id BYTEA`,
+          `UPDATE brz_token_swap_status SET user_id = ${idLit}`,
+          `ALTER TABLE brz_token_swap_status
              ALTER COLUMN user_id SET NOT NULL,
              ADD PRIMARY KEY (user_id)`,
         ],

package/nodejs/postgres-tree-store/index.cjs

@@ -62,7 +62,7 @@ class PostgresTreeStore {
    *   identifying the tenant. All reads and writes are scoped by this.
    * @param {object} [logger]
    */
-  constructor(pool, identity, logger = null) {
+  constructor(pool, identity, logger = null, runMigration = true) {
     if (!identity || identity.length !== 33) {
       throw new TreeStoreError(
         "tenant identity (33-byte secp256k1 pubkey) is required"
@@ -72,6 +72,7 @@ class PostgresTreeStore {
     this.identity = Buffer.from(identity);
     this.lockKey = _identityLockKey(TREE_STORE_LOCK_PREFIX, identity);
     this.logger = logger;
+    this.runMigration = runMigration;
   }
 
   /**
@@ -79,8 +80,10 @@ class PostgresTreeStore {
    */
   async initialize() {
     try {
-      const migrationManager = new TreeStoreMigrationManager(this.logger);
-      await migrationManager.migrate(this.pool, this.identity);
+      if (this.runMigration) {
+        const migrationManager = new TreeStoreMigrationManager(this.logger);
+        await migrationManager.migrate(this.pool, this.identity);
+      }
       return this;
     } catch (error) {
       throw new TreeStoreError(
@@ -194,8 +197,8 @@ class PostgresTreeStore {
       const result = await this.pool.query(
         `
         SELECT COALESCE(SUM((l.data->>'value')::bigint), 0)::bigint AS balance
-        FROM tree_leaves l
-        LEFT JOIN tree_reservations r
+        FROM brz_tree_leaves l
+        LEFT JOIN brz_tree_reservations r
           ON l.reservation_id = r.id AND l.user_id = r.user_id
         WHERE l.user_id = $1
           AND (
@@ -220,8 +223,8 @@ class PostgresTreeStore {
         `
         SELECT l.id, l.status, l.is_missing_from_operators, l.data,
                l.reservation_id, r.purpose
-        FROM tree_leaves l
-        LEFT JOIN tree_reservations r
+        FROM brz_tree_leaves l
+        LEFT JOIN brz_tree_reservations r
           ON l.reservation_id = r.id AND l.user_id = r.user_id
         WHERE l.user_id = $1
       `,
@@ -292,12 +295,12 @@ class PostgresTreeStore {
           `
           SELECT
             EXISTS(
-              SELECT 1 FROM tree_reservations
+              SELECT 1 FROM brz_tree_reservations
               WHERE user_id = $1 AND purpose = 'Swap'
             ) AS has_active_swap,
             COALESCE(
               (SELECT last_completed_at >= $2
-               FROM tree_swap_status WHERE user_id = $1),
+               FROM brz_tree_swap_status WHERE user_id = $1),
               FALSE
             ) AS swap_completed_during_refresh
         `,
@@ -314,7 +317,7 @@ class PostgresTreeStore {
         await this._cleanupSpentMarkers(client, refreshTimestamp);
 
         const spentResult = await client.query(
-          "SELECT leaf_id FROM tree_spent_leaves WHERE user_id = $1 AND spent_at >= $2",
+          "SELECT leaf_id FROM brz_tree_spent_leaves WHERE user_id = $1 AND spent_at >= $2",
           [this.identity, refreshTimestamp]
         );
         const spentIds = new Set(spentResult.rows.map((r) => r.leaf_id));
@@ -324,7 +327,7 @@ class PostgresTreeStore {
         // _cleanupStaleReservations (which now NULLs reservation_id explicitly,
         // since the composite FK uses NO ACTION).
         await client.query(
-          "DELETE FROM tree_leaves WHERE user_id = $1 AND reservation_id IS NULL AND added_at < $2",
+          "DELETE FROM brz_tree_leaves WHERE user_id = $1 AND reservation_id IS NULL AND added_at < $2",
           [this.identity, refreshTimestamp]
         );
 
@@ -358,7 +361,7 @@ class PostgresTreeStore {
     try {
       await this._withTransaction(async (client) => {
         const res = await client.query(
-          "SELECT id FROM tree_reservations WHERE user_id = $1 AND id = $2",
+          "SELECT id FROM brz_tree_reservations WHERE user_id = $1 AND id = $2",
           [this.identity, id]
         );
 
@@ -367,12 +370,12 @@ class PostgresTreeStore {
         }
 
         await client.query(
-          "DELETE FROM tree_leaves WHERE user_id = $1 AND reservation_id = $2",
+          "DELETE FROM brz_tree_leaves WHERE user_id = $1 AND reservation_id = $2",
           [this.identity, id]
         );
 
         await client.query(
-          "DELETE FROM tree_reservations WHERE user_id = $1 AND id = $2",
+          "DELETE FROM brz_tree_reservations WHERE user_id = $1 AND id = $2",
           [this.identity, id]
         );
 
@@ -398,12 +401,12 @@ class PostgresTreeStore {
     try {
       // _withWriteTransaction acquires the advisory lock so this serializes
       // against `setLeaves`. Without it, a concurrent setLeaves could read
-      // tree_spent_leaves before our marker commits and re-insert the
+      // brz_tree_spent_leaves before our marker commits and re-insert the
       // just-spent leaf as Available.
       await this._withWriteTransaction(async (client) => {
         // Check if reservation exists and get purpose
         const res = await client.query(
-          "SELECT id, purpose FROM tree_reservations WHERE user_id = $1 AND id = $2",
+          "SELECT id, purpose FROM brz_tree_reservations WHERE user_id = $1 AND id = $2",
           [this.identity, id]
         );
 
@@ -412,17 +415,17 @@ class PostgresTreeStore {
         if (res.rows.length > 0) {
           isSwap = res.rows[0].purpose === "Swap";
           const leafResult = await client.query(
-            "SELECT id FROM tree_leaves WHERE user_id = $1 AND reservation_id = $2",
+            "SELECT id FROM brz_tree_leaves WHERE user_id = $1 AND reservation_id = $2",
             [this.identity, id]
           );
           reservedLeafIds = leafResult.rows.map((r) => r.id);
           await this._batchInsertSpentLeaves(client, reservedLeafIds);
           await client.query(
-            "DELETE FROM tree_leaves WHERE user_id = $1 AND reservation_id = $2",
+            "DELETE FROM brz_tree_leaves WHERE user_id = $1 AND reservation_id = $2",
             [this.identity, id]
           );
           await client.query(
-            "DELETE FROM tree_reservations WHERE user_id = $1 AND id = $2",
+            "DELETE FROM brz_tree_reservations WHERE user_id = $1 AND id = $2",
             [this.identity, id]
           );
         }
@@ -436,7 +439,7 @@ class PostgresTreeStore {
         // that joined after migration 3 (and thus has no row) gets one created.
         if (isSwap && newLeaves && newLeaves.length > 0) {
           await client.query(
-            `INSERT INTO tree_swap_status (user_id, last_completed_at)
+            `INSERT INTO brz_tree_swap_status (user_id, last_completed_at)
              VALUES ($1, NOW())
              ON CONFLICT (user_id) DO UPDATE
                SET last_completed_at = EXCLUDED.last_completed_at`,
@@ -472,7 +475,7 @@ class PostgresTreeStore {
         const totalResult = await client.query(
           `
           SELECT COALESCE(SUM((data->>'value')::bigint), 0)::bigint AS total
-          FROM tree_leaves
+          FROM brz_tree_leaves
           WHERE user_id = $1
             AND status = 'Available'
             AND is_missing_from_operators = FALSE
@@ -490,7 +493,7 @@ class PostgresTreeStore {
         const slimResult = await client.query(
           `
           SELECT id, (data->>'value')::bigint AS value
-          FROM tree_leaves
+          FROM brz_tree_leaves
           WHERE user_id = $1
             AND status = 'Available'
             AND is_missing_from_operators = FALSE
@@ -498,7 +501,7 @@ class PostgresTreeStore {
             AND (
               (data->>'value')::bigint <= $2
               OR id = (
-                SELECT id FROM tree_leaves
+                SELECT id FROM brz_tree_leaves
                 WHERE user_id = $1
                   AND status = 'Available'
                   AND is_missing_from_operators = FALSE
@@ -609,7 +612,7 @@ class PostgresTreeStore {
   async _fetchFullLeavesByIds(client, ids) {
     if (!ids || ids.length === 0) return [];
     const result = await client.query(
-      "SELECT data FROM tree_leaves WHERE user_id = $2 AND id = ANY($1)",
+      "SELECT data FROM brz_tree_leaves WHERE user_id = $2 AND id = ANY($1)",
       [ids, this.identity]
     );
     return result.rows.map((r) => r.data);
@@ -643,7 +646,7 @@ class PostgresTreeStore {
       return await this._withTransaction(async (client) => {
         // Check if reservation exists
         const res = await client.query(
-          "SELECT id FROM tree_reservations WHERE user_id = $1 AND id = $2",
+          "SELECT id FROM brz_tree_reservations WHERE user_id = $1 AND id = $2",
           [this.identity, reservationId]
         );
 
@@ -653,14 +656,14 @@ class PostgresTreeStore {
 
         // Get old reserved leaf IDs and mark as spent
         const oldLeavesResult = await client.query(
-          "SELECT id FROM tree_leaves WHERE user_id = $1 AND reservation_id = $2",
+          "SELECT id FROM brz_tree_leaves WHERE user_id = $1 AND reservation_id = $2",
           [this.identity, reservationId]
         );
         const oldLeafIds = oldLeavesResult.rows.map((r) => r.id);
 
         await this._batchInsertSpentLeaves(client, oldLeafIds);
         await client.query(
-          "DELETE FROM tree_leaves WHERE user_id = $1 AND reservation_id = $2",
+          "DELETE FROM brz_tree_leaves WHERE user_id = $1 AND reservation_id = $2",
           [this.identity, reservationId]
         );
 
@@ -676,7 +679,7 @@ class PostgresTreeStore {
 
         // Clear pending change amount
         await client.query(
-          "UPDATE tree_reservations SET pending_change_amount = 0 WHERE user_id = $1 AND id = $2",
+          "UPDATE brz_tree_reservations SET pending_change_amount = 0 WHERE user_id = $1 AND id = $2",
           [this.identity, reservationId]
         );
 
@@ -859,7 +862,7 @@ class PostgresTreeStore {
    */
   async _calculatePendingBalance(client) {
     const result = await client.query(
-      "SELECT COALESCE(SUM(pending_change_amount), 0)::BIGINT AS pending FROM tree_reservations WHERE user_id = $1",
+      "SELECT COALESCE(SUM(pending_change_amount), 0)::BIGINT AS pending FROM brz_tree_reservations WHERE user_id = $1",
       [this.identity]
     );
     return Number(result.rows[0].pending);
@@ -870,7 +873,7 @@ class PostgresTreeStore {
    */
   async _createReservation(client, reservationId, leaves, purpose, pendingChange) {
     await client.query(
-      "INSERT INTO tree_reservations (user_id, id, purpose, pending_change_amount) VALUES ($1, $2, $3, $4)",
+      "INSERT INTO brz_tree_reservations (user_id, id, purpose, pending_change_amount) VALUES ($1, $2, $3, $4)",
       [this.identity, reservationId, purpose, pendingChange]
     );
 
@@ -879,7 +882,7 @@ class PostgresTreeStore {
   }
 
   /**
-   * Batch upsert leaves into tree_leaves table.
+   * Batch upsert leaves into brz_tree_leaves table.
    */
   async _batchUpsertLeaves(client, leaves, isMissingFromOperators, skipIds) {
     if (!leaves || leaves.length === 0) return;
@@ -896,7 +899,7 @@ class PostgresTreeStore {
     const dataValues = filtered.map((l) => JSON.stringify(l));
 
     await client.query(
-      `INSERT INTO tree_leaves (user_id, id, status, is_missing_from_operators, data, added_at)
+      `INSERT INTO brz_tree_leaves (user_id, id, status, is_missing_from_operators, data, added_at)
        SELECT $5, id, status, missing, data::jsonb, NOW()
        FROM UNNEST($1::text[], $2::text[], $3::bool[], $4::text[])
            AS t(id, status, missing, data)
@@ -916,7 +919,7 @@ class PostgresTreeStore {
     if (leafIds.length === 0) return;
 
     await client.query(
-      "UPDATE tree_leaves SET reservation_id = $1 WHERE user_id = $3 AND id = ANY($2)",
+      "UPDATE brz_tree_leaves SET reservation_id = $1 WHERE user_id = $3 AND id = ANY($2)",
       [reservationId, leafIds, this.identity]
     );
   }
@@ -928,7 +931,7 @@ class PostgresTreeStore {
     if (leafIds.length === 0) return;
 
     await client.query(
-      `INSERT INTO tree_spent_leaves (user_id, leaf_id)
+      `INSERT INTO brz_tree_spent_leaves (user_id, leaf_id)
        SELECT $2, leaf_id FROM UNNEST($1::text[]) AS t(leaf_id)
        ON CONFLICT DO NOTHING`,
       [leafIds, this.identity]
@@ -942,7 +945,7 @@ class PostgresTreeStore {
     if (leafIds.length === 0) return;
 
     await client.query(
-      "DELETE FROM tree_spent_leaves WHERE user_id = $2 AND leaf_id = ANY($1)",
+      "DELETE FROM brz_tree_spent_leaves WHERE user_id = $2 AND leaf_id = ANY($1)",
       [leafIds, this.identity]
     );
   }
@@ -955,17 +958,17 @@ class PostgresTreeStore {
    */
   async _cleanupStaleReservations(client) {
     await client.query(
-      `UPDATE tree_leaves SET reservation_id = NULL
+      `UPDATE brz_tree_leaves SET reservation_id = NULL
        WHERE user_id = $2
          AND reservation_id IN (
-           SELECT id FROM tree_reservations
+           SELECT id FROM brz_tree_reservations
            WHERE user_id = $2
              AND created_at < NOW() - make_interval(secs => $1)
          )`,
       [RESERVATION_TIMEOUT_SECS, this.identity]
     );
     await client.query(
-      `DELETE FROM tree_reservations
+      `DELETE FROM brz_tree_reservations
        WHERE user_id = $2
          AND created_at < NOW() - make_interval(secs => $1)`,
       [RESERVATION_TIMEOUT_SECS, this.identity]
@@ -980,7 +983,7 @@ class PostgresTreeStore {
     const cleanupCutoff = new Date(refreshTimestamp.getTime() - thresholdMs);
 
     await client.query(
-      "DELETE FROM tree_spent_leaves WHERE user_id = $2 AND spent_at < $1",
+      "DELETE FROM brz_tree_spent_leaves WHERE user_id = $2 AND spent_at < $1",
       [cleanupCutoff, this.identity]
     );
   }
@@ -1005,7 +1008,12 @@ async function createPostgresTreeStore(config, identity, logger = null) {
     connectionTimeoutMillis: config.createTimeoutSecs * 1000,
     idleTimeoutMillis: config.recycleTimeoutSecs * 1000,
   });
-  return createPostgresTreeStoreWithPool(pool, identity, logger);
+  return createPostgresTreeStoreWithPool(
+    pool,
+    identity,
+    logger,
+    config.runMigration !== false
+  );
 }
 
 /**
@@ -1016,8 +1024,18 @@ async function createPostgresTreeStore(config, identity, logger = null) {
  * @param {object} [logger] - Optional logger
  * @returns {Promise<PostgresTreeStore>}
  */
-async function createPostgresTreeStoreWithPool(pool, identity, logger = null) {
-  const store = new PostgresTreeStore(pool, identity, logger);
+async function createPostgresTreeStoreWithPool(
+  pool,
+  identity,
+  logger = null,
+  runMigration = true
+) {
+  const store = new PostgresTreeStore(
+    pool,
+    identity,
+    logger,
+    runMigration
+  );
   await store.initialize();
   return store;
 }