@adonis-agora/durable 1.0.0-rc.14 → 1.0.0-rc.16

package/dist/src/sql-schema.js

@@ -0,0 +1,145 @@
+import { createHash } from 'node:crypto';
+/**
+ * The database schema the durable tables live in (`schema` on the store, the db transport and the
+ * worker-key store). Every statement names it, so the tables can sit in their own schema while the
+ * connection's default (its `search_path`, or its database on MySQL) stays the app's. Never done by
+ * moving the connection's `search_path`: behind PgBouncer in transaction mode a `SET search_path`
+ * leaks to other clients' sessions.
+ *
+ * Postgres: a schema. MySQL/MariaDB: a database. Any other dialect (SQLite) has no schemas, and a
+ * `schema` there fails instead of being ignored.
+ */
+const SCHEMA_NAME = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+const SCHEMA_NAME_MAX = 63;
+/** `schema` when it is a valid schema name, else throws naming `owner` (the option that set it). */
+export function validateSchemaName(schema, owner) {
+    if (schema === undefined)
+        return undefined;
+    if (typeof schema !== 'string' || !SCHEMA_NAME.test(schema) || schema.length > SCHEMA_NAME_MAX) {
+        throw new Error(`@adonis-agora/durable: ${owner} schema ${JSON.stringify(schema)} is not a valid schema name: use letters, digits, _ and $, starting with a letter or _, at most ${SCHEMA_NAME_MAX} characters.`);
+    }
+    return schema;
+}
+/** Whether `client`'s dialect has schemas `schema` can name (Postgres schemas, MySQL databases). */
+function supportsSchemas(client) {
+    const name = client.dialect.name;
+    return name === 'postgres' || name === 'mysql';
+}
+/**
+ * Throw when `schema` is set on a connection whose dialect has no schemas (SQLite), so the tables
+ * never silently land in the default one.
+ */
+export function assertSchemaSupported(client, schema, owner) {
+    if (schema === undefined || supportsSchemas(client))
+        return;
+    throw new Error(`@adonis-agora/durable: ${owner} sets schema "${schema}", but the ${client.dialect.name} connection${client.connectionName ? ` "${client.connectionName}"` : ''} has no schemas. Remove \`schema\`, or use a Postgres or MySQL connection.`);
+}
+/**
+ * `table` qualified with `schema` for Knex (`schema.table`, which Knex quotes part by part as
+ * `"schema"."table"`), or `table` alone without one. Also right for a `??` binding in raw SQL.
+ */
+export function qualify(schema, table) {
+    return schema ? `${schema}.${table}` : table;
+}
+/** Every value of `tables` qualified with `schema` (see {@link qualify}). */
+export function qualifyAll(tables, schema) {
+    return Object.fromEntries(Object.entries(tables).map(([key, table]) => [key, qualify(schema, table)]));
+}
+/** `client.schema`, scoped to `schema` when set. A fresh builder per call (Knex's is stateful). */
+export function schemaBuilder(client, schema) {
+    return schema ? client.schema.withSchema(schema) : client.schema;
+}
+/** Whether `table` exists in `schema` (the connection's current schema when unset). */
+export async function hasTable(client, schema, table) {
+    return schemaBuilder(client, schema).hasTable(table);
+}
+/**
+ * Whether `table` in `schema` has `column`. Not `withSchema().hasColumn()`: Knex's MySQL `hasColumn`
+ * ignores the schema and looks in the connection's database.
+ */
+export async function hasColumn(client, schema, table, column) {
+    if (!schema)
+        return client.schema.hasColumn(table, column);
+    const rows = await client
+        .query()
+        .from('information_schema.columns')
+        .select('column_name')
+        .where('table_schema', schema)
+        .andWhere('table_name', table)
+        .andWhere('column_name', column)
+        .limit(1);
+    return rows.length > 0;
+}
+/**
+ * The `information_schema` filter on `column` for `schema`: the configured one, else the
+ * connection's current schema (`current_schema()` on Postgres, `database()` on MySQL).
+ */
+export function whereSchema(q, client, column, schema) {
+    if (schema) {
+        q.where(column, schema);
+        return q;
+    }
+    const current = client.dialect.name === 'mysql' ? 'database()' : 'current_schema()';
+    q.whereRaw(`${column} = ${current}`);
+    return q;
+}
+/**
+ * Create `schema` when it does not exist (`CREATE SCHEMA` on Postgres, `CREATE DATABASE` on MySQL),
+ * for the boots that create the tables. Checked first, so a role without the right to create one
+ * boots fine against a schema that is already there; when it is missing and cannot be created, the
+ * error names the schema and the grant it needs.
+ */
+export async function ensureSchemaExists(client, schema) {
+    if (!schema)
+        return;
+    if (await schemaExists(client, schema))
+        return;
+    const isMysql = client.dialect.name === 'mysql';
+    try {
+        await client.rawQuery(isMysql ? 'create database if not exists ??' : 'create schema if not exists ??', [schema]);
+    }
+    catch (error) {
+        // Another process created it first (the IF NOT EXISTS race on Postgres).
+        if (await schemaExists(client, schema))
+            return;
+        const grant = isMysql
+            ? `the connection's user needs CREATE on \`${schema}\`.* (GRANT CREATE ON \`${schema}\`.* TO <user>), or create it once: CREATE DATABASE \`${schema}\``
+            : `the connection's role needs CREATE on the database (GRANT CREATE ON DATABASE <database> TO <role>), or create it once: CREATE SCHEMA "${schema}"`;
+        throw new Error(`@adonis-agora/durable: could not create the ${isMysql ? 'database' : 'schema'} "${schema}" for the durable tables: ${error instanceof Error ? error.message : String(error)}. To fix it, ${grant}.`);
+    }
+}
+/** Whether `schema` exists (a Postgres schema, a MySQL database). */
+export async function schemaExists(client, schema) {
+    const rows = await client
+        .query()
+        .from('information_schema.schemata')
+        .select('schema_name')
+        .where('schema_name', schema)
+        .limit(1);
+    return rows.length > 0;
+}
+/**
+ * A lock key for `schema`: `base` without one (today's key, unchanged), else a key derived from both,
+ * so two installs in two schemas of one database don't wait on each other. A positive bigint that
+ * fits a JS number.
+ */
+export function schemaLockKey(base, schema) {
+    if (!schema)
+        return base;
+    const digest = createHash('sha256').update(`${base}:${schema}`).digest();
+    return digest.readUIntBE(0, 6);
+}
+/**
+ * A MySQL `GET_LOCK` name for `schema` under `prefix`: `prefix` + the schema, or + a hash of it when
+ * that would pass MySQL's 64-character limit on lock names.
+ */
+export function mysqlLockName(prefix, schema) {
+    const name = `${prefix}${schema}`;
+    if (name.length <= 64)
+        return name;
+    return `${prefix}${createHash('sha256')
+        .update(schema)
+        .digest('hex')
+        .slice(0, 64 - prefix.length)}`;
+}
+//# sourceMappingURL=sql-schema.js.map

package/dist/src/sql-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-schema.js","sourceRoot":"","sources":["../../src/sql-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;;;;;;GASG;AAEH,MAAM,WAAW,GAAG,2BAA2B,CAAC;AAChD,MAAM,eAAe,GAAG,EAAE,CAAC;AAE3B,oGAAoG;AACpG,MAAM,UAAU,kBAAkB,CAAC,MAA0B,EAAE,KAAa;IAC1E,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3C,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,eAAe,EAAE,CAAC;QAC/F,MAAM,IAAI,KAAK,CACb,0BAA0B,KAAK,WAAW,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,mGAAmG,eAAe,cAAc,CACjM,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,oGAAoG;AACpG,SAAS,eAAe,CAAC,MAA2B;IAClD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;IACjC,OAAO,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,OAAO,CAAC;AACjD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAA2B,EAC3B,MAA0B,EAC1B,KAAa;IAEb,IAAI,MAAM,KAAK,SAAS,IAAI,eAAe,CAAC,MAAM,CAAC;QAAE,OAAO;IAC5D,MAAM,IAAI,KAAK,CACb,0BAA0B,KAAK,iBAAiB,MAAM,cAAc,MAAM,CAAC,OAAO,CAAC,IAAI,cACrF,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC,EAC1D,4EAA4E,CAC7E,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAC,MAA0B,EAAE,KAAa;IAC/D,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/C,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,UAAU,CACxB,MAAS,EACT,MAA0B;IAE1B,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAC9C,CAAC;AAClC,CAAC;AAED,mGAAmG;AACnG,MAAM,UAAU,aAAa,CAC3B,MAA2B,EAC3B,MAA0B;IAE1B,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;AACnE,CAAC;AAED,uFAAuF;AACvF,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,MAA2B,EAC3B,MAA0B,EAC1B,KAAa;IAEb,OAAO,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACvD,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,MAA2B,EAC3B,MAA0B,EAC1B,KAAa,EACb,MAAc;IAEd,IAAI,CAAC,MAAM;QAAE,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC3D,MAAM,IAAI,GAAG,MAAM,MAAM;SACtB,KAAK,EAAE;SACP,IAAI,CAAC,4BAA4B,CAAC;SAClC,MAAM,CAAC,aAAa,CAAC;SACrB,KAAK,CAAC,cAAc,EAAE,MAAM,CAAC;SAC7B,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC;SAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;SAC/B,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CACzB,CAAI,EACJ,MAA2B,EAC3B,MAAc,EACd,MAA0B;IAE1B,IAAI,MAAM,EAAE,CAAC;QACX,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACxB,OAAO,CAAC,CAAC;IACX,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,kBAAkB,CAAC;IACnF,CAAmD,CAAC,QAAQ,CAAC,GAAG,MAAM,MAAM,OAAO,EAAE,CAAC,CAAC;IACxF,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,MAA2B,EAC3B,MAA0B;IAE1B,IAAI,CAAC,MAAM;QAAE,OAAO;IACpB,IAAI,MAAM,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC;QAAE,OAAO;IAC/C,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC;IAChD,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,QAAQ,CACnB,OAAO,CAAC,CAAC,CAAC,kCAAkC,CAAC,CAAC,CAAC,gCAAgC,EAC/E,CAAC,MAAM,CAAC,CACT,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,yEAAyE;QACzE,IAAI,MAAM,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC;YAAE,OAAO;QAC/C,MAAM,KAAK,GAAG,OAAO;YACnB,CAAC,CAAC,2CAA2C,MAAM,2BAA2B,MAAM,yDAAyD,MAAM,IAAI;YACvJ,CAAC,CAAC,yIAAyI,MAAM,GAAG,CAAC;QACvJ,MAAM,IAAI,KAAK,CACb,+CAA+C,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,6BACvF,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,gBAAgB,KAAK,GAAG,CACzB,CAAC;IACJ,CAAC;AACH,CAAC;AAED,qEAAqE;AACrE,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,MAA2B,EAAE,MAAc;IAC5E,MAAM,IAAI,GAAG,MAAM,MAAM;SACtB,KAAK,EAAE;SACP,IAAI,CAAC,6BAA6B,CAAC;SACnC,MAAM,CAAC,aAAa,CAAC;SACrB,KAAK,CAAC,aAAa,EAAE,MAAM,CAAC;SAC5B,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,MAA0B;IACpE,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,IAAI,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IACzE,OAAO,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACjC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,MAAc,EAAE,MAAc;IAC1D,MAAM,IAAI,GAAG,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;IAClC,IAAI,IAAI,CAAC,MAAM,IAAI,EAAE;QAAE,OAAO,IAAI,CAAC;IACnC,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC;SACpC,MAAM,CAAC,MAAM,CAAC;SACd,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;AACpC,CAAC"}

package/dist/src/stores/factory.d.ts

@@ -28,6 +28,12 @@ export interface LucidStoreConfig {
      * prepared statements (PgBouncer in transaction mode before 1.21 does not). Default off.
      */
     preparedStatements?: boolean;
+    /**
+     * The database schema the durable tables live in (a database on MySQL): every statement names it,
+     * and `autoSchema` creates it. Defaults to the top-level `schema`, else the connection's current
+     * schema. Not supported on SQLite.
+     */
+    schema?: string;
 }
 /**
  * The store factory namespace used in `config/durable.ts`:

package/dist/src/stores/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/stores/factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,gBAAgB,CAAC;AAE5C;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAEtE,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM;IACjB,4EAA4E;IAC5E,KAAK,UAAS,gBAAgB,GAAQ,YAAY;CAanD,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/stores/factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,gBAAgB,CAAC;AAE5C;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAEtE,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM;IACjB,4EAA4E;IAC5E,KAAK,UAAS,gBAAgB,GAAQ,YAAY;CAgBnD,CAAC"}

package/dist/src/stores/factory.js

@@ -29,6 +29,9 @@ export const stores = {
                 ...(config.preparedStatements !== undefined
                     ? { preparedStatements: config.preparedStatements }
                     : {}),
+                ...((config.schema ?? ctx.schema) !== undefined
+                    ? { schema: config.schema ?? ctx.schema }
+                    : {}),
             });
         };
     },

package/dist/src/stores/factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../src/stores/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAmC9D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,4EAA4E;IAC5E,KAAK,CAAC,MAAM,GAAqB,EAAE;QACjC,OAAO,KAAK,EAAE,GAAG,EAAE,EAAE;YACnB,MAAM,EAAE,GAAG,CAAC,MAAM,oBAAoB,CAAC,GAAG,CAAC,CAAa,CAAC;YACzD,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,CAAC;YACvD,OAAO,IAAI,eAAe,CAAC,EAAE,EAAE;gBAC7B,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACjF,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1E,GAAG,CAAC,MAAM,CAAC,kBAAkB,KAAK,SAAS;oBACzC,CAAC,CAAC,EAAE,kBAAkB,EAAE,MAAM,CAAC,kBAAkB,EAAE;oBACnD,CAAC,CAAC,EAAE,CAAC;aACR,CAAC,CAAC;QACL,CAAC,CAAC;IACJ,CAAC;CACF,CAAC"}
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../src/stores/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAyC9D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,4EAA4E;IAC5E,KAAK,CAAC,MAAM,GAAqB,EAAE;QACjC,OAAO,KAAK,EAAE,GAAG,EAAE,EAAE;YACnB,MAAM,EAAE,GAAG,CAAC,MAAM,oBAAoB,CAAC,GAAG,CAAC,CAAa,CAAC;YACzD,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,CAAC;YACvD,OAAO,IAAI,eAAe,CAAC,EAAE,EAAE;gBAC7B,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACjF,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1E,GAAG,CAAC,MAAM,CAAC,kBAAkB,KAAK,SAAS;oBACzC,CAAC,CAAC,EAAE,kBAAkB,EAAE,MAAM,CAAC,kBAAkB,EAAE;oBACnD,CAAC,CAAC,EAAE,CAAC;gBACP,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,SAAS;oBAC7C,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE;oBACzC,CAAC,CAAC,EAAE,CAAC;aACR,CAAC,CAAC;QACL,CAAC,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/src/stores/lucid-schema.d.ts

@@ -39,6 +39,12 @@ export interface CreateDurableTablesOptions {
      * {@link DURABLE_SCHEMA_META_TABLE}). For a database whose durable tables were changed by hand.
      */
     force?: boolean;
+    /**
+     * The database schema the tables live in (a database on MySQL), created when missing. Every
+     * statement names it, so the connection's own default schema is left alone. Omit for the
+     * connection's current schema. Not supported on SQLite.
+     */
+    schema?: string | undefined;
 }
 /**
  * The table where {@link createDurableTables} records which schema it last applied: one row
@@ -85,6 +91,9 @@ export declare const DURABLE_JSON_COLUMNS: Record<string, {
  * prefer the published migration (`node ace configure @adonis-agora/durable`); this helper is for standalone
  * use, tests, and `ensureSchema`.
  *
+ * Pass `options.schema` to put the tables in their own database schema (created when missing): every
+ * statement names it, on any connection. It must match the store's `schema`.
+ *
  * Pass `connectionName` to provision the tables on a dedicated Lucid connection — it must match the
  * connection the store reads/writes on, or `ensureSchema` would create the tables where the store
  * never looks. Omit it to use the `Database` default connection.
@@ -103,7 +112,12 @@ export declare function createDurableTables(db: Database, connectionName?: strin
 export declare function widenMysqlLongtextColumns(client: QueryClientContract, spec: Record<string, {
     columns: string[];
     notNull?: string[];
-}>): Promise<string[]>;
-/** Drop every durable table (reverse FK order). Used by tests and migration `down`. */
-export declare function dropDurableTables(db: Database, connectionName?: string): Promise<void>;
+}>, schema?: string | undefined): Promise<string[]>;
+/**
+ * Drop every durable table (reverse FK order), in `options.schema` when set (the schema itself is
+ * left). Used by tests and migration `down`.
+ */
+export declare function dropDurableTables(db: Database, connectionName?: string, options?: {
+    schema?: string | undefined;
+}): Promise<void>;
 //# sourceMappingURL=lucid-schema.d.ts.map

package/dist/src/stores/lucid-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lucid-schema.d.ts","sourceRoot":"","sources":["../../../src/stores/lucid-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,cAAc;aACzB,IAAI,EAAE,uBAAuB;aAC7B,WAAW,EAAE,0BAA0B;aACvC,UAAU,EAAE,wBAAwB;aACpC,aAAa,EAAE,wBAAwB;aACvC,eAAe,EAAE,0BAA0B;aAC3C,cAAc,EAAE,yBAAyB;aACzC,SAAS,EAAE,mBAAmB;CACtB,CAAC;AAEX;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAUzC;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAQ1F,CAAC;AAsLF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,QAAQ,EACZ,cAAc,CAAC,EAAE,MAAM,EACvB,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,IAAI,CAAC,CAcf;AAgWD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GAC9D,OAAO,CAAC,MAAM,EAAE,CAAC,CAyBnB;AAuCD,uFAAuF;AACvF,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,QAAQ,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU5F"}
+{"version":3,"file":"lucid-schema.d.ts","sourceRoot":"","sources":["../../../src/stores/lucid-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAa1E;;;;GAIG;AACH,eAAO,MAAM,cAAc;aACzB,IAAI,EAAE,uBAAuB;aAC7B,WAAW,EAAE,0BAA0B;aACvC,UAAU,EAAE,wBAAwB;aACpC,aAAa,EAAE,wBAAwB;aACvC,eAAe,EAAE,0BAA0B;aAC3C,cAAc,EAAE,yBAAyB;aACzC,SAAS,EAAE,mBAAmB;CACtB,CAAC;AAEX;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAUzC;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAQ1F,CAAC;AAgMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,QAAQ,EACZ,cAAc,CAAC,EAAE,MAAM,EACvB,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAsWD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,EAC/D,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAC1B,OAAO,CAAC,MAAM,EAAE,CAAC,CA6BnB;AA4CD;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,QAAQ,EACZ,cAAc,CAAC,EAAE,MAAM,EACvB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAO,GAC5C,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/src/stores/lucid-schema.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { assertSchemaSupported, ensureSchemaExists, hasColumn, mysqlLockName, qualify, schemaBuilder, schemaLockKey, validateSchemaName, whereSchema, } from '../sql-schema.js';
 /**
  * The canonical durable table names. They match the cross-adapter snake_case contract the other
  * Agora/aviary stores use (Drizzle is the reference), so a dashboard or migration can be pointed at
@@ -65,12 +66,12 @@ function schemaFingerprint(collation) {
         .update(`rev=${DURABLE_SCHEMA_REVISION}|collation=${collation ?? ''}`)
         .digest('hex');
 }
-async function readSchemaFingerprint(client) {
-    if (!(await client.schema.hasTable(DURABLE_SCHEMA_META_TABLE)))
+async function readSchemaFingerprint(client, schema) {
+    if (!(await schemaBuilder(client, schema).hasTable(DURABLE_SCHEMA_META_TABLE)))
         return undefined;
     const q = client
         .query()
-        .from(DURABLE_SCHEMA_META_TABLE)
+        .from(qualify(schema, DURABLE_SCHEMA_META_TABLE))
         .select('fingerprint')
         .where('id', SCHEMA_META_ROW);
     // A locking read on MySQL: under REPEATABLE READ a plain read could answer from a snapshot older
@@ -80,9 +81,9 @@ async function readSchemaFingerprint(client) {
     const row = (await q.first());
     return row?.fingerprint ?? undefined;
 }
-async function writeSchemaFingerprint(client, fingerprint) {
-    if (!(await client.schema.hasTable(DURABLE_SCHEMA_META_TABLE))) {
-        await client.schema.createTable(DURABLE_SCHEMA_META_TABLE, (table) => {
+async function writeSchemaFingerprint(client, schema, fingerprint) {
+    if (!(await schemaBuilder(client, schema).hasTable(DURABLE_SCHEMA_META_TABLE))) {
+        await schemaBuilder(client, schema).createTable(DURABLE_SCHEMA_META_TABLE, (table) => {
             table.string('id', 32).primary();
             table.string('fingerprint', 64).notNullable();
             table.bigInteger('applied_at').notNullable();
@@ -90,7 +91,7 @@ async function writeSchemaFingerprint(client, fingerprint) {
     }
     await client
         .insertQuery()
-        .table(DURABLE_SCHEMA_META_TABLE)
+        .table(qualify(schema, DURABLE_SCHEMA_META_TABLE))
         .knexQuery.insert({ id: SCHEMA_META_ROW, fingerprint, applied_at: Date.now() })
         .onConflict('id')
         .merge();
@@ -102,17 +103,29 @@ async function writeSchemaFingerprint(client, fingerprint) {
  * (its DDL commits implicitly, the lock is the session's) and releases it after. SQLite, and any
  * other dialect, runs `work` without a lock.
  */
-async function withSchemaLock(connection, logger, work) {
+async function withSchemaLock(connection, schema, logger, work) {
+    // With a schema, the lock is that schema's: two installs in two schemas of one database heal
+    // independently. Without one, the keys are unchanged.
     switch (connection.dialect.name) {
         case 'postgres':
             await connection.transaction(async (trx) => {
-                await trx.rawQuery('select pg_advisory_xact_lock(?)', [PG_SCHEMA_LOCK_KEY]);
+                await trx.rawQuery('select pg_advisory_xact_lock(?)', [
+                    schemaLockKey(PG_SCHEMA_LOCK_KEY, schema),
+                ]);
                 await work(trx);
             });
             return;
         case 'mysql':
             await connection.transaction(async (trx) => {
-                const result = (await trx.rawQuery("select get_lock(concat('durable_schema:', database()), ?) as got", [MYSQL_SCHEMA_LOCK_TIMEOUT_S]));
+                // The lock is named after the database the tables are in: the configured one, else the
+                // connection's.
+                const lockName = schema
+                    ? { sql: '?', bindings: [mysqlLockName('durable_schema:', schema)] }
+                    : { sql: "concat('durable_schema:', database())", bindings: [] };
+                const result = (await trx.rawQuery(`select get_lock(${lockName.sql}, ?) as got`, [
+                    ...lockName.bindings,
+                    MYSQL_SCHEMA_LOCK_TIMEOUT_S,
+                ]));
                 const got = Number(result[0]?.[0]?.got) === 1;
                 if (!got) {
                     logger.warn(`@adonis-agora/durable: waited ${MYSQL_SCHEMA_LOCK_TIMEOUT_S}s for the durable schema lock; checking the schema without it.`);
@@ -123,7 +136,7 @@ async function withSchemaLock(connection, logger, work) {
                 finally {
                     if (got) {
                         await trx
-                            .rawQuery("select release_lock(concat('durable_schema:', database()))")
+                            .rawQuery(`select release_lock(${lockName.sql})`, lockName.bindings)
                             .catch(() => undefined);
                     }
                 }
@@ -155,7 +168,7 @@ function repairWarning(repairs) {
     ].join(' ');
 }
 /**
- * Does an index with this name exist in the connection's current schema? Returns `null` for
+ * Does an index with this name exist in `schema` (the connection's current schema when unset)? Returns `null` for
  * dialects outside the store's three declared targets (SQLite / Postgres / MySQL), which the
  * caller handles by falling back to the legacy best-effort create.
  *
@@ -167,15 +180,11 @@ function repairWarning(repairs) {
  * catalog `SELECT` can never fail that way, so the repair never touches the database unless the
  * index is genuinely missing.
  */
-async function indexExists(connection, indexName) {
+async function indexExists(connection, schema, indexName) {
     switch (connection.dialect.name) {
         case 'postgres': {
-            const rows = await connection
-                .query()
-                .from('pg_indexes')
-                .where('indexname', indexName)
-                .andWhereRaw('schemaname = current_schema()')
-                .limit(1);
+            const q = connection.query().from('pg_indexes').where('indexname', indexName);
+            const rows = await whereSchema(q, connection, 'schemaname', schema).limit(1);
             return rows.length > 0;
         }
         case 'sqlite3':
@@ -190,12 +199,11 @@ async function indexExists(connection, indexName) {
             return rows.length > 0;
         }
         case 'mysql': {
-            const rows = await connection
+            const q = connection
                 .query()
                 .from('information_schema.statistics')
-                .where('index_name', indexName)
-                .andWhereRaw('table_schema = database()')
-                .limit(1);
+                .where('index_name', indexName);
+            const rows = await whereSchema(q, connection, 'table_schema', schema).limit(1);
             return rows.length > 0;
         }
         default:
@@ -222,6 +230,9 @@ async function indexExists(connection, indexName) {
  * prefer the published migration (`node ace configure @adonis-agora/durable`); this helper is for standalone
  * use, tests, and `ensureSchema`.
  *
+ * Pass `options.schema` to put the tables in their own database schema (created when missing): every
+ * statement names it, on any connection. It must match the store's `schema`.
+ *
  * Pass `connectionName` to provision the tables on a dedicated Lucid connection — it must match the
  * connection the store reads/writes on, or `ensureSchema` would create the tables where the store
  * never looks. Omit it to use the `Database` default connection.
@@ -233,26 +244,31 @@ async function indexExists(connection, indexName) {
  */
 export async function createDurableTables(db, connectionName, options = {}) {
     const connection = db.connection(connectionName);
+    const schema = validateSchemaName(options.schema, 'createDurableTables');
+    assertSchemaSupported(connection, schema, 'createDurableTables');
     const logger = options.logger ?? console;
     const collation = connection.dialect.name === 'mysql' ? configuredCollation(connection, options) : undefined;
     const expected = schemaFingerprint(collation);
     // The steady-state boot: one catalog probe and one PK read, no per-table checks.
-    if (!options.force && (await readSchemaFingerprint(connection)) === expected)
+    if (!options.force && (await readSchemaFingerprint(connection, schema)) === expected)
         return;
-    await withSchemaLock(connection, logger, async (client) => {
+    // Outside the lock's transaction: a failed CREATE SCHEMA would abort it.
+    await ensureSchemaExists(connection, schema);
+    await withSchemaLock(connection, schema, logger, async (client) => {
         // A sibling may have healed while this process waited for the lock.
-        if (!options.force && (await readSchemaFingerprint(client)) === expected)
+        if (!options.force && (await readSchemaFingerprint(client, schema)) === expected)
             return;
-        await healDurableTables(client, collation, logger);
-        await writeSchemaFingerprint(client, expected);
+        await healDurableTables(client, schema, collation, logger);
+        await writeSchemaFingerprint(client, schema, expected);
     });
 }
 /** The additive check-and-repair behind {@link createDurableTables}, on one client (or transaction). */
-async function healDurableTables(client, collation, logger) {
+async function healDurableTables(client, schema, collation, logger) {
     // Knex's schema builder is stateful — operations chained on one instance run together. Take a FRESH
     // `client.schema` for every hasTable/createTable so each DDL statement executes exactly once, all on
-    // the store's own connection (or the lock-holding transaction).
-    const conn = () => client.schema;
+    // the store's own connection (or the lock-holding transaction), scoped to the configured schema.
+    const conn = () => schemaBuilder(client, schema);
+    const columnExists = (table, column) => hasColumn(client, schema, table, column);
     const isMysql = client.dialect.name === 'mysql';
     // MySQL: create new tables with the configured collation (CONVERT below aligns existing ones).
     const charset = collation?.split('_')[0];
@@ -271,7 +287,7 @@ async function healDurableTables(client, collation, logger) {
     // best-effort path stays — still transaction-unsafe, but only outside the store's declared
     // targets.
     const ensureIndex = async (table, columns, indexName) => {
-        const known = await indexExists(client, indexName);
+        const known = await indexExists(client, schema, indexName);
         if (known === true)
             return;
         if (known === null) {
@@ -327,14 +343,14 @@ async function healDurableTables(client, collation, logger) {
         // Auto-migrate an older runs table by adding any columns introduced after its creation. Each is
         // applied independently so a table missing several catches up. Mirrors the in-place pattern other
         // adapters use; new columns are nullable / carry a DEFAULT so existing rows read back unchanged.
-        if (!(await conn().hasColumn(DURABLE_TABLES.runs, 'priority'))) {
+        if (!(await columnExists(DURABLE_TABLES.runs, 'priority'))) {
             // Nullable (no default) so existing rows read back as "unprioritised" and the FIFO path is unchanged.
             await conn().alterTable(DURABLE_TABLES.runs, (table) => {
                 table.integer('priority');
             });
             repairs.push(`${DURABLE_TABLES.runs}.priority`);
         }
-        if (!(await conn().hasColumn(DURABLE_TABLES.runs, 'namespace'))) {
+        if (!(await columnExists(DURABLE_TABLES.runs, 'namespace'))) {
             // DEFAULT 'default' so every pre-namespace row reads back in the reserved 'default' partition —
             // byte-identical behavior for a single-pool deploy that adds the column.
             await conn().alterTable(DURABLE_TABLES.runs, (table) => {
@@ -343,14 +359,14 @@ async function healDurableTables(client, collation, logger) {
             });
             repairs.push(`${DURABLE_TABLES.runs}.namespace`);
         }
-        if (!(await conn().hasColumn(DURABLE_TABLES.runs, 'origin'))) {
+        if (!(await columnExists(DURABLE_TABLES.runs, 'origin'))) {
             // Origin attribution wave: nullable, so an app-own/legacy run reads back with no origin.
             await conn().alterTable(DURABLE_TABLES.runs, (table) => {
                 table.string('origin');
             });
             repairs.push(`${DURABLE_TABLES.runs}.origin`);
         }
-        if (!(await conn().hasColumn(DURABLE_TABLES.runs, 'awaiting_decision_task_id'))) {
+        if (!(await columnExists(DURABLE_TABLES.runs, 'awaiting_decision_task_id'))) {
             // Remote-turn decision marker (multi-instance decisions): nullable, so an existing run reads back
             // as "not awaiting a dispatched turn". TEXT: it embeds the run id plus a UUID.
             await conn().alterTable(DURABLE_TABLES.runs, (table) => {
@@ -358,7 +374,7 @@ async function healDurableTables(client, collation, logger) {
             });
             repairs.push(`${DURABLE_TABLES.runs}.awaiting_decision_task_id`);
         }
-        if (!(await conn().hasColumn(DURABLE_TABLES.runs, 'wake_requested_at'))) {
+        if (!(await columnExists(DURABLE_TABLES.runs, 'wake_requested_at'))) {
             // Refused-wake marker (a wake that found another instance's lease): nullable, so an existing
             // run reads back as "no turn requested".
             await conn().alterTable(DURABLE_TABLES.runs, (table) => {
@@ -367,7 +383,7 @@ async function healDurableTables(client, collation, logger) {
             });
             repairs.push(`${DURABLE_TABLES.runs}.wake_requested_at`);
         }
-        if (!(await conn().hasColumn(DURABLE_TABLES.runs, 'tenant_id'))) {
+        if (!(await columnExists(DURABLE_TABLES.runs, 'tenant_id'))) {
             // Tenancy: nullable, so an existing run reads back with no tenant.
             await conn().alterTable(DURABLE_TABLES.runs, (table) => {
                 table.string('tenant_id');
@@ -410,7 +426,7 @@ async function healDurableTables(client, collation, logger) {
         });
     }
     else {
-        if (!(await conn().hasColumn(DURABLE_TABLES.checkpoints, 'parallel_group'))) {
+        if (!(await columnExists(DURABLE_TABLES.checkpoints, 'parallel_group'))) {
             // Auto-migrate an older checkpoints table: add the nullable `parallel_group` column in place.
             // Nullable (no default) so a legacy (non-parallel) checkpoint reads back untagged.
             await conn().alterTable(DURABLE_TABLES.checkpoints, (table) => {
@@ -418,7 +434,7 @@ async function healDurableTables(client, collation, logger) {
             });
             repairs.push(`${DURABLE_TABLES.checkpoints}.parallel_group`);
         }
-        if (!(await conn().hasColumn(DURABLE_TABLES.checkpoints, 'last_heartbeat_at'))) {
+        if (!(await columnExists(DURABLE_TABLES.checkpoints, 'last_heartbeat_at'))) {
             // Heartbeat-persistence wave: nullable, so a step whose handler never beats reads back with
             // no liveness claim (absent ≠ silent-since-epoch).
             await conn().alterTable(DURABLE_TABLES.checkpoints, (table) => {
@@ -429,7 +445,7 @@ async function healDurableTables(client, collation, logger) {
             // not the statement count.
             repairs.push(`${DURABLE_TABLES.checkpoints}.last_heartbeat_at`, `${DURABLE_TABLES.checkpoints}.heartbeat_progress`);
         }
-        if (!(await conn().hasColumn(DURABLE_TABLES.checkpoints, 'queue'))) {
+        if (!(await columnExists(DURABLE_TABLES.checkpoints, 'queue'))) {
             // Durable flow-control release: the admitted queue is persisted on the pending checkpoint so
             // ANY instance receiving the result can free the slot. Nullable — a non-queued step reads back
             // with no slot to release.
@@ -469,7 +485,7 @@ async function healDurableTables(client, collation, logger) {
         });
     }
     else {
-        if (!(await conn().hasColumn(DURABLE_TABLES.signalWaiters, 'parallel_group'))) {
+        if (!(await columnExists(DURABLE_TABLES.signalWaiters, 'parallel_group'))) {
             // Auto-migrate an older signal_waiters table: add the nullable `parallel_group` column in
             // place. Nullable (no default) so a legacy (non-fan) waiter reads back untagged and the await
             // is unchanged.
@@ -499,11 +515,12 @@ async function healDurableTables(client, collation, logger) {
             [DURABLE_TABLES.signalWaiters, 'durable_signal_waiters_token_prefix_idx'],
             [DURABLE_TABLES.bufferedSignals, 'durable_buffered_signals_token_prefix_idx'],
         ]) {
-            if (await indexExists(client, indexName))
+            if (await indexExists(client, schema, indexName))
                 continue;
+            // The index lands in its table's schema: `create index "i" on "s"."t"`.
             await client.rawQuery('create index ?? on ?? (?? varchar_pattern_ops)', [
                 indexName,
-                table,
+                qualify(schema, table),
                 'token',
             ]);
             if (!created.has(table))
@@ -546,7 +563,7 @@ async function healDurableTables(client, collation, logger) {
             table.index(['paused', 'next_fire_at'], 'durable_schedules_due_idx');
         });
     }
-    else if (!(await conn().hasColumn(DURABLE_TABLES.schedules, 'tenant_id'))) {
+    else if (!(await columnExists(DURABLE_TABLES.schedules, 'tenant_id'))) {
         // Tenancy: nullable, so an existing schedule (and every run it fires) has no tenant.
         await conn().alterTable(DURABLE_TABLES.schedules, (table) => {
             table.string('tenant_id');
@@ -558,9 +575,9 @@ async function healDurableTables(client, collation, logger) {
     // an operator needs to know their schema was behind and by what, and a burst of lines is easier to
     // lose than a single one.
     if (isMysql) {
-        repairs.push(...(await widenMysqlJsonColumns(client)));
+        repairs.push(...(await widenMysqlJsonColumns(client, schema)));
         if (collation && charset) {
-            repairs.push(...(await alignMysqlCollation(client, charset, collation, logger)));
+            repairs.push(...(await alignMysqlCollation(client, schema, charset, collation, logger)));
         }
     }
     if (repairs.length > 0) {
@@ -573,22 +590,22 @@ async function healDurableTables(client, collation, logger) {
  * since MySQL rebuilds the table for each; a table already widened is not touched. Returns the
  * columns it changed.
  */
-async function widenMysqlJsonColumns(client) {
-    return widenMysqlLongtextColumns(client, DURABLE_JSON_COLUMNS);
+async function widenMysqlJsonColumns(client, schema) {
+    return widenMysqlLongtextColumns(client, DURABLE_JSON_COLUMNS, schema);
 }
 /**
  * MySQL: `MODIFY` to `longtext` every column of `spec` that exists and isn't `longtext` yet, one
  * `ALTER` per table. Shared by the store schema and the db transport's (`createDurableTransportTables`).
  * Returns the columns it changed.
  */
-export async function widenMysqlLongtextColumns(client, spec) {
+export async function widenMysqlLongtextColumns(client, spec, schema) {
     const tables = Object.keys(spec);
-    const rows = (await client
+    const q = client
         .query()
         .from('information_schema.columns')
         .select('table_name as t', 'column_name as c', 'data_type as d')
-        .whereRaw('table_schema = database()')
-        .whereIn('table_name', tables));
+        .whereIn('table_name', tables);
+    const rows = (await whereSchema(q, client, 'table_schema', schema));
     const widened = [];
     for (const [table, columns] of Object.entries(spec)) {
         const narrow = columns.columns.filter((column) => {
@@ -600,7 +617,7 @@ export async function widenMysqlLongtextColumns(client, spec) {
         const modify = narrow
             .map((column) => `modify \`${column}\` longtext ${columns.notNull?.includes(column) ? 'not null' : 'null'}`)
             .join(', ');
-        await client.rawQuery(`alter table \`${table}\` ${modify}`);
+        await client.rawQuery(`alter table ?? ${modify}`, [qualify(schema, table)]);
         widened.push(...narrow.map((column) => `${table}.${column} (longtext)`));
     }
     return widened;
@@ -610,20 +627,20 @@ export async function widenMysqlLongtextColumns(client, spec) {
  * version, or before the option was set, carry the server default). A failed `CONVERT` is warned and
  * left for the next forced check rather than failing the boot. Returns the tables it converted.
  */
-async function alignMysqlCollation(client, charset, collation, logger) {
+async function alignMysqlCollation(client, schema, charset, collation, logger) {
     const tables = [...Object.values(DURABLE_TABLES), DURABLE_SCHEMA_META_TABLE];
-    const rows = (await client
+    const q = client
         .query()
         .from('information_schema.tables')
         .select('table_name as t', 'table_collation as c')
-        .whereRaw('table_schema = database()')
-        .whereIn('table_name', tables));
+        .whereIn('table_name', tables);
+    const rows = (await whereSchema(q, client, 'table_schema', schema));
     const converted = [];
     for (const row of rows) {
         if (row.c == null || row.c === collation)
             continue;
         try {
-            await client.rawQuery(`alter table \`${row.t}\` convert to character set ${charset} collate ${collation}`);
+            await client.rawQuery(`alter table ?? convert to character set ${charset} collate ${collation}`, [qualify(schema, row.t)]);
             converted.push(`${row.t} (collation ${collation})`);
         }
         catch (err) {
@@ -632,9 +649,14 @@ async function alignMysqlCollation(client, charset, collation, logger) {
     }
     return converted;
 }
-/** Drop every durable table (reverse FK order). Used by tests and migration `down`. */
-export async function dropDurableTables(db, connectionName) {
-    const conn = () => db.connection(connectionName).schema;
+/**
+ * Drop every durable table (reverse FK order), in `options.schema` when set (the schema itself is
+ * left). Used by tests and migration `down`.
+ */
+export async function dropDurableTables(db, connectionName, options = {}) {
+    const schema = validateSchemaName(options.schema, 'dropDurableTables');
+    assertSchemaSupported(db.connection(connectionName), schema, 'dropDurableTables');
+    const conn = () => schemaBuilder(db.connection(connectionName), schema);
     await conn().dropTableIfExists(DURABLE_SCHEMA_META_TABLE);
     await conn().dropTableIfExists(DURABLE_TABLES.schedules);
     await conn().dropTableIfExists(DURABLE_TABLES.bufferedEvents);