@breeztech/breez-sdk-spark 0.14.0 → 0.15.1

package/nodejs/mysql-tree-store/migrations.cjs

@@ -4,17 +4,19 @@
 
 const { TreeStoreError } = require("./errors.cjs");
 
-const TREE_MIGRATIONS_TABLE = "tree_schema_migrations";
+const TREE_MIGRATIONS_TABLE = "brz_tree_schema_migrations";
 const MIGRATION_LOCK_NAME = "breez_mysql_tree_store_migration_lock";
 const MIGRATION_LOCK_TIMEOUT = 60;
 
 /**
  * Runs a single migration step. Plain strings are run as-is; tagged objects
- * (`{ op: 'dropPrimaryKey', table }`) are guarded against partial-apply replay
- * by checking `information_schema` first. MySQL DDL implicitly commits, so
- * if the migration crashes between two DDL statements the version row never
- * gets recorded — and on retry, an unguarded DROP PRIMARY KEY would fail
- * (`ER_CANT_DROP_FIELD_OR_KEY`) because the PK is already gone.
+ * (`{ op: 'dropPrimaryKey', table }`, `{ op: 'dropForeignKey', table, name }`)
+ * are guarded against partial-apply replay (and against the `Disabled`
+ * foreign-key mode where the FK was never created) by checking
+ * `information_schema` first. MySQL DDL implicitly commits, so if the
+ * migration crashes between two DDL statements the version row never gets
+ * recorded — and on retry, an unguarded DROP would fail because the
+ * constraint is already gone.
  */
 async function runMigrationStep(conn, step) {
   if (typeof step === "string") {
@@ -34,12 +36,45 @@ async function runMigrationStep(conn, step) {
     }
     return;
   }
+  if (step.op === "dropForeignKey") {
+    const [rows] = await conn.query(
+      `SELECT COUNT(*) AS c FROM information_schema.table_constraints
+       WHERE table_schema = DATABASE()
+         AND table_name = ?
+         AND constraint_type = 'FOREIGN KEY'
+         AND constraint_name = ?`,
+      [step.table, step.name]
+    );
+    if (rows[0].c > 0) {
+      await conn.query(
+        `ALTER TABLE \`${step.table}\` DROP FOREIGN KEY \`${step.name}\``
+      );
+    }
+    return;
+  }
+  if (step.op === "addForeignKey") {
+    const [rows] = await conn.query(
+      `SELECT COUNT(*) AS c FROM information_schema.table_constraints
+       WHERE table_schema = DATABASE()
+         AND table_name = ?
+         AND constraint_type = 'FOREIGN KEY'
+         AND constraint_name = ?`,
+      [step.table, step.name]
+    );
+    if (rows[0].c === 0) {
+      await conn.query(
+        `ALTER TABLE \`${step.table}\` ADD CONSTRAINT \`${step.name}\` ${step.definition}`
+      );
+    }
+    return;
+  }
   throw new Error(`Unknown migration step op: ${JSON.stringify(step)}`);
 }
 
 class MysqlTreeStoreMigrationManager {
-  constructor(logger = null) {
+  constructor(logger = null, foreignKeyMode = "Enforced") {
     this.logger = logger;
+    this.foreignKeyMode = foreignKeyMode;
   }
 
   async migrate(pool, identity) {
@@ -56,6 +91,8 @@ class MysqlTreeStoreMigrationManager {
       }
 
       try {
+        await this._applySchemaRenames(conn);
+
         await conn.query("START TRANSACTION");
 
         await conn.query(`
@@ -106,116 +143,262 @@ class MysqlTreeStoreMigrationManager {
     }
   }
 
+  /**
+   * Pre-prefix rename. Canary-gated on the legacy `tree_schema_migrations`
+   * table.
+   * @param {import('mysql2/promise').PoolConnection} conn
+   */
+  async _applySchemaRenames(conn) {
+    if (!(await _mysqlTableExists(conn, "tree_schema_migrations"))) {
+      return;
+    }
+
+    const tableRenames = [
+      ["tree_reservations", "brz_tree_reservations"],
+      ["tree_leaves", "brz_tree_leaves"],
+      ["tree_spent_leaves", "brz_tree_spent_leaves"],
+      ["tree_swap_status", "brz_tree_swap_status"],
+    ];
+    for (const [oldName, newName] of tableRenames) {
+      if (
+        (await _mysqlTableExists(conn, oldName)) &&
+        !(await _mysqlTableExists(conn, newName))
+      ) {
+        await conn.query(`RENAME TABLE \`${oldName}\` TO \`${newName}\``);
+      }
+    }
+
+    const indexRenames = [
+      ["brz_tree_leaves", "idx_tree_leaves_user_available", "brz_idx_tree_leaves_user_available"],
+      [
+        "brz_tree_leaves",
+        "idx_tree_leaves_user_reservation",
+        "brz_idx_tree_leaves_user_reservation",
+      ],
+      ["brz_tree_leaves", "idx_tree_leaves_user_added_at", "brz_idx_tree_leaves_user_added_at"],
+      ["brz_tree_leaves", "idx_tree_leaves_user_slim", "brz_idx_tree_leaves_user_slim"],
+      // Pre-multi-tenant indexes (dropped by the multi-tenant migration).
+      ["brz_tree_leaves", "idx_tree_leaves_available", "brz_idx_tree_leaves_available"],
+      ["brz_tree_leaves", "idx_tree_leaves_reservation", "brz_idx_tree_leaves_reservation"],
+      ["brz_tree_leaves", "idx_tree_leaves_added_at", "brz_idx_tree_leaves_added_at"],
+      ["brz_tree_leaves", "idx_tree_leaves_slim", "brz_idx_tree_leaves_slim"],
+    ];
+    for (const [table, oldName, newName] of indexRenames) {
+      if (
+        (await _mysqlIndexExists(conn, table, oldName)) &&
+        !(await _mysqlIndexExists(conn, table, newName))
+      ) {
+        await conn.query(
+          `ALTER TABLE \`${table}\` RENAME INDEX \`${oldName}\` TO \`${newName}\``
+        );
+      }
+    }
+
+    // MySQL has no RENAME CONSTRAINT for foreign keys: drop the legacy FK
+    // and re-add it under the brz_ name.
+    const fkRenames = [
+      {
+        table: "brz_tree_leaves",
+        oldName: "fk_tree_leaves_reservation_user",
+        newName: "brz_fk_tree_leaves_reservation_user",
+        definition:
+          "FOREIGN KEY (user_id, reservation_id) REFERENCES `brz_tree_reservations`(user_id, id)",
+      },
+      // Pre-multi-tenant FK (single-column). Rename so the post-tenant
+      // migration's drop-foreign-key step finds it.
+      {
+        table: "brz_tree_leaves",
+        oldName: "fk_tree_leaves_reservation",
+        newName: "brz_fk_tree_leaves_reservation",
+        definition:
+          "FOREIGN KEY (reservation_id) REFERENCES `brz_tree_reservations`(id) ON DELETE SET NULL",
+      },
+    ];
+    for (const fk of fkRenames) {
+      if (await _mysqlForeignKeyExists(conn, fk.table, fk.newName)) {
+        continue;
+      }
+      if (!(await _mysqlForeignKeyExists(conn, fk.table, fk.oldName))) {
+        continue;
+      }
+      await conn.query(
+        `ALTER TABLE \`${fk.table}\`` +
+          ` DROP FOREIGN KEY \`${fk.oldName}\`,` +
+          ` ADD CONSTRAINT \`${fk.newName}\` ${fk.definition}`
+      );
+    }
+
+    if (
+      (await _mysqlTableExists(conn, "tree_schema_migrations")) &&
+      !(await _mysqlTableExists(conn, TREE_MIGRATIONS_TABLE))
+    ) {
+      await conn.query(
+        `RENAME TABLE \`tree_schema_migrations\` TO \`${TREE_MIGRATIONS_TABLE}\``
+      );
+    }
+  }
+
   _getMigrations(identity) {
     const idHex = Buffer.from(identity).toString("hex");
     const idLit = `UNHEX('${idHex}')`;
+    const foreignKeyModeEnforced = this.foreignKeyMode === "Enforced";
 
-    return [
-      {
-        name: "Create tree store tables",
-        sql: [
-          `CREATE TABLE IF NOT EXISTS tree_reservations (
+    const initialSql = [
+          `CREATE TABLE IF NOT EXISTS brz_tree_reservations (
             id VARCHAR(255) NOT NULL PRIMARY KEY,
             purpose VARCHAR(64) NOT NULL,
             pending_change_amount BIGINT NOT NULL DEFAULT 0,
             created_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6)
           )`,
-          `CREATE TABLE IF NOT EXISTS tree_leaves (
+          `CREATE TABLE IF NOT EXISTS brz_tree_leaves (
             id VARCHAR(255) NOT NULL PRIMARY KEY,
             status VARCHAR(64) NOT NULL,
             is_missing_from_operators TINYINT(1) NOT NULL DEFAULT 0,
             reservation_id VARCHAR(255) NULL,
             data JSON NOT NULL,
             created_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
-            added_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
-            CONSTRAINT fk_tree_leaves_reservation FOREIGN KEY (reservation_id)
-                REFERENCES tree_reservations(id) ON DELETE SET NULL
+            added_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6)
           )`,
-          `CREATE TABLE IF NOT EXISTS tree_spent_leaves (
+          `CREATE TABLE IF NOT EXISTS brz_tree_spent_leaves (
             leaf_id VARCHAR(255) NOT NULL PRIMARY KEY,
             spent_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6)
           )`,
-          `CREATE INDEX idx_tree_leaves_available
-            ON tree_leaves(status, is_missing_from_operators)`,
-          `CREATE INDEX idx_tree_leaves_reservation ON tree_leaves(reservation_id)`,
-          `CREATE INDEX idx_tree_leaves_added_at ON tree_leaves(added_at)`,
-        ],
+          `CREATE INDEX brz_idx_tree_leaves_available
+            ON brz_tree_leaves(status, is_missing_from_operators)`,
+          `CREATE INDEX brz_idx_tree_leaves_reservation ON brz_tree_leaves(reservation_id)`,
+          `CREATE INDEX brz_idx_tree_leaves_added_at ON brz_tree_leaves(added_at)`,
+    ];
+    if (foreignKeyModeEnforced) {
+      initialSql.push({
+        op: "addForeignKey",
+        table: "brz_tree_leaves",
+        name: "brz_fk_tree_leaves_reservation",
+        definition: `FOREIGN KEY (reservation_id) REFERENCES brz_tree_reservations(id) ON DELETE SET NULL`,
+      });
+    }
+
+    return [
+      {
+        name: "Create tree store tables",
+        sql: initialSql,
       },
       {
         name: "Add swap status tracking",
         sql: [
-          `CREATE TABLE IF NOT EXISTS tree_swap_status (
+          `CREATE TABLE IF NOT EXISTS brz_tree_swap_status (
             id INT NOT NULL PRIMARY KEY DEFAULT 1,
             last_completed_at DATETIME(6) NULL,
             CHECK (id = 1)
           )`,
-          `INSERT INTO tree_swap_status (id) VALUES (1)
+          `INSERT INTO brz_tree_swap_status (id) VALUES (1)
             ON DUPLICATE KEY UPDATE id = id`,
         ],
       },
       {
         name: "Promote leaf value to BIGINT column with covering index",
         sql: [
-          `ALTER TABLE tree_leaves
+          `ALTER TABLE brz_tree_leaves
             ADD COLUMN value BIGINT NOT NULL DEFAULT 0`,
-          `UPDATE tree_leaves
+          `UPDATE brz_tree_leaves
             SET value = CAST(JSON_UNQUOTE(JSON_EXTRACT(data, '$.value')) AS UNSIGNED)
             WHERE value = 0`,
-          `CREATE INDEX idx_tree_leaves_slim
-            ON tree_leaves(status, is_missing_from_operators, reservation_id, value)`,
+          `CREATE INDEX brz_idx_tree_leaves_slim
+            ON brz_tree_leaves(status, is_missing_from_operators, reservation_id, value)`,
         ],
       },
       {
         name: "Multi-tenant scoping: add user_id and rewrite primary keys / FKs",
         sql: [
-          // Drop the existing FK so we can rewrite the parent PK.
-          `ALTER TABLE tree_leaves DROP FOREIGN KEY fk_tree_leaves_reservation`,
-
-          // tree_reservations: scope by user_id.
-          `ALTER TABLE tree_reservations ADD COLUMN user_id VARBINARY(33) NULL`,
-          `UPDATE tree_reservations SET user_id = ${idLit} WHERE user_id IS NULL`,
-          `ALTER TABLE tree_reservations MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
-          `ALTER TABLE tree_reservations DROP PRIMARY KEY, ADD PRIMARY KEY (user_id, id)`,
-
-          // tree_leaves: scope by user_id, rekey, re-add composite FK.
-          `ALTER TABLE tree_leaves ADD COLUMN user_id VARBINARY(33) NULL`,
-          `UPDATE tree_leaves SET user_id = ${idLit} WHERE user_id IS NULL`,
-          `ALTER TABLE tree_leaves MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
-          `ALTER TABLE tree_leaves DROP PRIMARY KEY, ADD PRIMARY KEY (user_id, id)`,
-          `ALTER TABLE tree_leaves
-             ADD CONSTRAINT fk_tree_leaves_reservation_user
-             FOREIGN KEY (user_id, reservation_id)
-             REFERENCES tree_reservations(user_id, id)`,
-          `DROP INDEX idx_tree_leaves_available ON tree_leaves`,
-          `DROP INDEX idx_tree_leaves_reservation ON tree_leaves`,
-          `DROP INDEX idx_tree_leaves_added_at ON tree_leaves`,
-          `DROP INDEX idx_tree_leaves_slim ON tree_leaves`,
-          `CREATE INDEX idx_tree_leaves_user_available
-             ON tree_leaves(user_id, status, is_missing_from_operators)`,
-          `CREATE INDEX idx_tree_leaves_user_reservation
-             ON tree_leaves(user_id, reservation_id)`,
-          `CREATE INDEX idx_tree_leaves_user_added_at ON tree_leaves(user_id, added_at)`,
-          `CREATE INDEX idx_tree_leaves_user_slim
-             ON tree_leaves(user_id, status, is_missing_from_operators, reservation_id, value)`,
-
-          // tree_spent_leaves: scope by user_id.
-          `ALTER TABLE tree_spent_leaves ADD COLUMN user_id VARBINARY(33) NULL`,
-          `UPDATE tree_spent_leaves SET user_id = ${idLit} WHERE user_id IS NULL`,
-          `ALTER TABLE tree_spent_leaves MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
-          `ALTER TABLE tree_spent_leaves DROP PRIMARY KEY, ADD PRIMARY KEY (user_id, leaf_id)`,
-
-          // tree_swap_status was a singleton (PK id=1, CHECK id=1). Drop the PK
+          // Drop the existing FK so we can rewrite the parent PK. Guarded so
+          // that databases created with `Disabled` foreign-key mode (where the
+          // FK was never created) skip the DROP rather than erroring.
+          {
+            op: "dropForeignKey",
+            table: "brz_tree_leaves",
+            name: "brz_fk_tree_leaves_reservation",
+          },
+
+          // brz_tree_reservations: scope by user_id.
+          `ALTER TABLE brz_tree_reservations ADD COLUMN user_id VARBINARY(33) NULL`,
+          `UPDATE brz_tree_reservations SET user_id = ${idLit} WHERE user_id IS NULL`,
+          `ALTER TABLE brz_tree_reservations MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
+          `ALTER TABLE brz_tree_reservations DROP PRIMARY KEY, ADD PRIMARY KEY (user_id, id)`,
+
+          // brz_tree_leaves: scope by user_id, rekey, optionally re-add composite FK.
+          `ALTER TABLE brz_tree_leaves ADD COLUMN user_id VARBINARY(33) NULL`,
+          `UPDATE brz_tree_leaves SET user_id = ${idLit} WHERE user_id IS NULL`,
+          `ALTER TABLE brz_tree_leaves MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
+          `ALTER TABLE brz_tree_leaves DROP PRIMARY KEY, ADD PRIMARY KEY (user_id, id)`,
+          ...(foreignKeyModeEnforced
+            ? [
+                {
+                  op: "addForeignKey",
+                  table: "brz_tree_leaves",
+                  name: "brz_fk_tree_leaves_reservation_user",
+                  definition: `FOREIGN KEY (user_id, reservation_id) REFERENCES brz_tree_reservations(user_id, id)`,
+                },
+              ]
+            : []),
+          `DROP INDEX brz_idx_tree_leaves_available ON brz_tree_leaves`,
+          `DROP INDEX brz_idx_tree_leaves_reservation ON brz_tree_leaves`,
+          `DROP INDEX brz_idx_tree_leaves_added_at ON brz_tree_leaves`,
+          `DROP INDEX brz_idx_tree_leaves_slim ON brz_tree_leaves`,
+          `CREATE INDEX brz_idx_tree_leaves_user_available
+             ON brz_tree_leaves(user_id, status, is_missing_from_operators)`,
+          `CREATE INDEX brz_idx_tree_leaves_user_reservation
+             ON brz_tree_leaves(user_id, reservation_id)`,
+          `CREATE INDEX brz_idx_tree_leaves_user_added_at ON brz_tree_leaves(user_id, added_at)`,
+          `CREATE INDEX brz_idx_tree_leaves_user_slim
+             ON brz_tree_leaves(user_id, status, is_missing_from_operators, reservation_id, value)`,
+
+          // brz_tree_spent_leaves: scope by user_id.
+          `ALTER TABLE brz_tree_spent_leaves ADD COLUMN user_id VARBINARY(33) NULL`,
+          `UPDATE brz_tree_spent_leaves SET user_id = ${idLit} WHERE user_id IS NULL`,
+          `ALTER TABLE brz_tree_spent_leaves MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
+          `ALTER TABLE brz_tree_spent_leaves DROP PRIMARY KEY, ADD PRIMARY KEY (user_id, leaf_id)`,
+
+          // brz_tree_swap_status was a singleton (PK id=1, CHECK id=1). Drop the PK
           // and the id column, then re-key by user_id.
-          { op: "dropPrimaryKey", table: "tree_swap_status" },
-          `ALTER TABLE tree_swap_status DROP COLUMN id`,
-          `ALTER TABLE tree_swap_status ADD COLUMN user_id VARBINARY(33) NULL`,
-          `UPDATE tree_swap_status SET user_id = ${idLit} WHERE user_id IS NULL`,
-          `ALTER TABLE tree_swap_status MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
-          `ALTER TABLE tree_swap_status ADD PRIMARY KEY (user_id)`,
+          { op: "dropPrimaryKey", table: "brz_tree_swap_status" },
+          `ALTER TABLE brz_tree_swap_status DROP COLUMN id`,
+          `ALTER TABLE brz_tree_swap_status ADD COLUMN user_id VARBINARY(33) NULL`,
+          `UPDATE brz_tree_swap_status SET user_id = ${idLit} WHERE user_id IS NULL`,
+          `ALTER TABLE brz_tree_swap_status MODIFY COLUMN user_id VARBINARY(33) NOT NULL`,
+          `ALTER TABLE brz_tree_swap_status ADD PRIMARY KEY (user_id)`,
         ],
       },
     ];
   }
 }
 
+async function _mysqlTableExists(conn, tableName) {
+  const [rows] = await conn.query(
+    `SELECT COUNT(*) AS c FROM information_schema.tables
+     WHERE table_schema = DATABASE() AND table_name = ?`,
+    [tableName]
+  );
+  return Number(rows[0].c) > 0;
+}
+
+async function _mysqlIndexExists(conn, tableName, indexName) {
+  const [rows] = await conn.query(
+    `SELECT COUNT(*) AS c FROM information_schema.statistics
+     WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ?`,
+    [tableName, indexName]
+  );
+  return Number(rows[0].c) > 0;
+}
+
+async function _mysqlForeignKeyExists(conn, tableName, constraintName) {
+  const [rows] = await conn.query(
+    `SELECT COUNT(*) AS c FROM information_schema.table_constraints
+     WHERE table_schema = DATABASE()
+       AND table_name = ?
+       AND constraint_type = 'FOREIGN KEY'
+       AND constraint_name = ?`,
+    [tableName, constraintName]
+  );
+  return Number(rows[0].c) > 0;
+}
+
 module.exports = { MysqlTreeStoreMigrationManager };

package/nodejs/postgres-session-manager/index.cjs

@@ -7,7 +7,7 @@
  * `setSession(serviceIdentityKey, session)` upserts a session.
  *
  * Tenant identity is bound at construction so multiple tenants can share
- * a single Postgres database without leaking sessions across tenants.
+ * a single Postgres database without leaking brz_sessions across tenants.
  */
 
 let pg;
@@ -39,7 +39,7 @@ class PostgresSessionManager {
    *   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 SessionManagerError(
         "tenant identity (33-byte secp256k1 pubkey) is required"
@@ -48,12 +48,15 @@ class PostgresSessionManager {
     this.pool = pool;
     this.identity = Buffer.from(identity);
     this.logger = logger;
+    this.runMigration = runMigration;
   }
 
   async initialize() {
     try {
-      const migrationManager = new SessionManagerMigrationManager(this.logger);
-      await migrationManager.migrate(this.pool);
+      if (this.runMigration) {
+        const migrationManager = new SessionManagerMigrationManager(this.logger);
+        await migrationManager.migrate(this.pool);
+      }
       return this;
     } catch (error) {
       throw new SessionManagerError(
@@ -81,7 +84,7 @@ class PostgresSessionManager {
     const serviceKey = _decodePubkey(serviceIdentityKey);
     try {
       const { rows } = await this.pool.query(
-        `SELECT token, expiration FROM sessions
+        `SELECT token, expiration FROM brz_sessions
          WHERE user_id = $1 AND service_identity_key = $2`,
         [this.identity, serviceKey]
       );
@@ -110,7 +113,7 @@ class PostgresSessionManager {
     const serviceKey = _decodePubkey(serviceIdentityKey);
     try {
       await this.pool.query(
-        `INSERT INTO sessions (user_id, service_identity_key, token, expiration)
+        `INSERT INTO brz_sessions (user_id, service_identity_key, token, expiration)
          VALUES ($1, $2, $3, $4)
          ON CONFLICT (user_id, service_identity_key)
          DO UPDATE SET token = EXCLUDED.token, expiration = EXCLUDED.expiration`,
@@ -142,7 +145,12 @@ function _decodePubkey(hex) {
  */
 async function createPostgresSessionManager(poolConfig, identity, logger = null) {
   const pool = new pg.Pool(poolConfig);
-  const manager = new PostgresSessionManager(pool, identity, logger);
+  const manager = new PostgresSessionManager(
+    pool,
+    identity,
+    logger,
+    poolConfig.runMigration !== false
+  );
   await manager.initialize();
   return manager;
 }
@@ -151,8 +159,18 @@ async function createPostgresSessionManager(poolConfig, identity, logger = null)
  * Wraps an existing pool — useful when sharing the pool with the storage,
  * tree store, and token store implementations.
  */
-async function createPostgresSessionManagerWithPool(pool, identity, logger = null) {
-  const manager = new PostgresSessionManager(pool, identity, logger);
+async function createPostgresSessionManagerWithPool(
+  pool,
+  identity,
+  logger = null,
+  runMigration = true
+) {
+  const manager = new PostgresSessionManager(
+    pool,
+    identity,
+    logger,
+    runMigration
+  );
   await manager.initialize();
   return manager;
 }

package/nodejs/postgres-session-manager/migrations.cjs

@@ -1,7 +1,7 @@
 /**
  * Database Migration Manager for Breez SDK PostgreSQL Session Manager.
  *
- * Uses a session_schema_migrations table + pg_advisory_xact_lock to safely
+ * Uses a brz_session_schema_migrations table + pg_advisory_xact_lock to safely
  * run migrations from concurrent processes. Mirrors the schema produced by
  * the Rust `PostgresSessionManager`.
  */
@@ -32,15 +32,17 @@ class SessionManagerMigrationManager {
       await client.query("BEGIN");
       await client.query(`SELECT pg_advisory_xact_lock(${MIGRATION_LOCK_ID})`);
 
+      await this._applySchemaRenames(client);
+
       await client.query(`
-        CREATE TABLE IF NOT EXISTS session_schema_migrations (
+        CREATE TABLE IF NOT EXISTS brz_session_schema_migrations (
           version INTEGER PRIMARY KEY,
           applied_at TIMESTAMPTZ DEFAULT NOW()
         )
       `);
 
       const versionResult = await client.query(
-        "SELECT COALESCE(MAX(version), 0) AS version FROM session_schema_migrations"
+        "SELECT COALESCE(MAX(version), 0) AS version FROM brz_session_schema_migrations"
       );
       const currentVersion = versionResult.rows[0].version;
 
@@ -73,7 +75,7 @@ class SessionManagerMigrationManager {
         }
 
         await client.query(
-          "INSERT INTO session_schema_migrations (version) VALUES ($1)",
+          "INSERT INTO brz_session_schema_migrations (version) VALUES ($1)",
           [version]
         );
       }
@@ -94,6 +96,43 @@ class SessionManagerMigrationManager {
     }
   }
 
+  /**
+   * Pre-prefix rename. Canary-gated on the legacy `session_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 = 'session_schema_migrations'
+       ) AS exists`
+    );
+    if (!canary.rows[0].exists) {
+      return;
+    }
+
+    // Rename data tables first, then their auto-named PK constraints, then
+    // the migrations tracking table (which doubles as the rename canary).
+    await client.query(`ALTER TABLE IF EXISTS sessions RENAME TO brz_sessions`);
+    await client.query(
+      `DO $$ BEGIN
+         IF EXISTS (
+           SELECT 1 FROM information_schema.table_constraints
+           WHERE table_schema = current_schema()
+             AND table_name = 'brz_sessions'
+             AND constraint_name = 'sessions_pkey'
+         ) THEN
+           ALTER TABLE brz_sessions RENAME CONSTRAINT sessions_pkey TO brz_sessions_pkey;
+         END IF;
+       END $$`
+    );
+    await client.query(
+      `ALTER TABLE IF EXISTS session_schema_migrations RENAME TO brz_session_schema_migrations`
+    );
+  }
+
   _log(level, message) {
     if (this.logger && typeof this.logger.log === "function") {
       this.logger.log({ line: message, level });
@@ -108,9 +147,9 @@ class SessionManagerMigrationManager {
   _getMigrations() {
     return [
       {
-        name: "Create sessions table",
+        name: "Create brz_sessions table",
         sql: [
-          `CREATE TABLE IF NOT EXISTS sessions (
+          `CREATE TABLE IF NOT EXISTS brz_sessions (
             user_id BYTEA NOT NULL,
             service_identity_key BYTEA NOT NULL,
             token TEXT NOT NULL,