uql-orm 0.34.0 → 0.35.0

package/README.md

@@ -7,7 +7,7 @@
   </picture>
 </a>
 
-<h3>The JSON-native TypeScript ORM</h3>
+<h3>The JSON-native ORM</h3>
 
 <p>Queries are plain JSON, typed to the leaf. Unified across SQL databases and MongoDB.</p>
 

package/dist/dialect/abstractDialect.js

@@ -1,4 +1,5 @@
 import { applyFilters, buildQueryWhereAsMap } from '../util/dialect.util.js';
+import { qualifyName } from '../util/sql.util.js';
 /**
  * The dialect's share of a pool's {@link ExtraOptions}: what changes the SQL rather than the
  * connection. Every pool builds its dialect through this, so a new option lands here instead of in
@@ -52,9 +53,7 @@ export class AbstractDialect {
      * would point at one that does not exist.
      */
     resolveTableName(meta) {
-        const name = this.resolveTableAlias(meta);
-        const schema = this.resolveSchema(meta);
-        return schema ? `${schema}.${name}` : name;
+        return qualifyName(this.resolveTableAlias(meta), this.resolveSchema(meta));
     }
     /**
      * Which schema an entity is read from: its own wins over the pool's default, the way its `name`

package/dist/dialect/abstractSqlDialect.d.ts

@@ -301,6 +301,12 @@ export declare abstract class AbstractSqlDialect extends IndexSqlDialect impleme
     protected getUpsertConflictPathsStr<E>(meta: EntityMeta<E>, conflictPaths: QueryConflictPaths<E>): string;
     delete<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;
     escapeId(val: string | undefined, forbidQualified?: boolean, addDot?: boolean): string;
+    /**
+     * A name behind its schema, each part escaped on its own rather than as one dotted string taken
+     * apart again by {@link escapeId}. Tables and their indexes both use it, since an index lives in
+     * the schema of the table it is on.
+     */
+    escapeQualifiedId(name: string, schema: string | undefined): string;
     /**
      * Bind one persisted value, classifying its column on the spot. Dialects override
      * {@link appendJsonValue} and {@link appendVectorValue} rather than this, so the chain runs once per

package/dist/dialect/abstractSqlDialect.js

@@ -195,9 +195,7 @@ export class AbstractSqlDialect extends IndexSqlDialect {
      * string taken apart again by {@link escapeId}.
      */
     escapedTableName(meta) {
-        const alias = this.escapeId(this.resolveTableAlias(meta), true);
-        const schema = this.resolveSchema(meta);
-        return schema ? `${this.escapeId(schema, true)}.${alias}` : alias;
+        return this.escapeQualifiedId(this.resolveTableAlias(meta), this.resolveSchema(meta));
     }
     /**
      * A FROM or JOIN operand plus the alias to prefix its columns by, aliased only once a schema puts
@@ -1065,6 +1063,15 @@ export class AbstractSqlDialect extends IndexSqlDialect {
     escapeId(val, forbidQualified, addDot) {
         return escapeSqlId(val, this.escapeIdChar, forbidQualified, addDot);
     }
+    /**
+     * A name behind its schema, each part escaped on its own rather than as one dotted string taken
+     * apart again by {@link escapeId}. Tables and their indexes both use it, since an index lives in
+     * the schema of the table it is on.
+     */
+    escapeQualifiedId(name, schema) {
+        const escaped = this.escapeId(name, true);
+        return schema ? `${this.escapeId(schema, true)}.${escaped}` : escaped;
+    }
     /**
      * Bind one persisted value, classifying its column on the spot. Dialects override
      * {@link appendJsonValue} and {@link appendVectorValue} rather than this, so the chain runs once per

package/dist/migrate/builder/expressions.d.ts

@@ -2,7 +2,7 @@
  * SQL Expressions
  *
  * Type-safe SQL expressions for default values and other uses.
- * Provides a `t` helper with common expressions.
+ * Provides an `expr` helper with common expressions.
  */
 /**
  * Represents a raw SQL expression (not a literal value).
@@ -18,11 +18,11 @@ export declare class SqlExpression {
 }
 /**
  * Helper object for common SQL expressions.
- * Use in migrations: `table.timestamp('createdAt').defaultValue(t.now())`
+ * Use in migrations: `t.timestamp('createdAt').defaultValue(expr.now())`
  */
-export declare const t: {
+export declare const expr: {
     /**
-     * Current timestamp (NOW() or CURRENT_TIMESTAMP depending on dialect).
+     * Current timestamp (CURRENT_TIMESTAMP).
      */
     now(): SqlExpression;
     /**
@@ -34,23 +34,11 @@ export declare const t: {
      */
     currentTime(): SqlExpression;
     /**
-     * NULL value.
-     */
-    null(): SqlExpression;
-    /**
-     * Boolean true.
-     */
-    true(): SqlExpression;
-    /**
-     * Boolean false.
-     */
-    false(): SqlExpression;
-    /**
-     * Generate UUID (Postgres: gen_random_uuid(), MySQL: UUID()).
+     * Generate a UUID. Postgres only - use `expr.mysqlUuid()` on MySQL/MariaDB.
      */
     uuid(): SqlExpression;
     /**
-     * Auto-generate UUID for MySQL.
+     * Generate a UUID on MySQL/MariaDB.
      */
     mysqlUuid(): SqlExpression;
     /**
@@ -59,19 +47,11 @@ export declare const t: {
      */
     raw(sql: string): SqlExpression;
     /**
-     * String literal with proper escaping.
-     */
-    literal(value: string): SqlExpression;
-    /**
-     * Numeric literal.
-     */
-    number(value: number): SqlExpression;
-    /**
-     * Empty JSON object.
+     * Empty JSON object. Postgres only - the `::jsonb` cast is not portable.
      */
     emptyObject(): SqlExpression;
     /**
-     * Empty JSON array.
+     * Empty JSON array. Postgres only - the `::jsonb` cast is not portable.
      */
     emptyArray(): SqlExpression;
     /**

package/dist/migrate/builder/expressions.js

@@ -2,7 +2,7 @@
  * SQL Expressions
  *
  * Type-safe SQL expressions for default values and other uses.
- * Provides a `t` helper with common expressions.
+ * Provides an `expr` helper with common expressions.
  */
 /**
  * Represents a raw SQL expression (not a literal value).
@@ -24,11 +24,11 @@ export class SqlExpression {
 }
 /**
  * Helper object for common SQL expressions.
- * Use in migrations: `table.timestamp('createdAt').defaultValue(t.now())`
+ * Use in migrations: `t.timestamp('createdAt').defaultValue(expr.now())`
  */
-export const t = {
+export const expr = {
     /**
-     * Current timestamp (NOW() or CURRENT_TIMESTAMP depending on dialect).
+     * Current timestamp (CURRENT_TIMESTAMP).
      */
     now() {
         return new SqlExpression('CURRENT_TIMESTAMP');
@@ -46,31 +46,13 @@ export const t = {
         return new SqlExpression('CURRENT_TIME');
     },
     /**
-     * NULL value.
-     */
-    null() {
-        return new SqlExpression('NULL');
-    },
-    /**
-     * Boolean true.
-     */
-    true() {
-        return new SqlExpression('TRUE');
-    },
-    /**
-     * Boolean false.
-     */
-    false() {
-        return new SqlExpression('FALSE');
-    },
-    /**
-     * Generate UUID (Postgres: gen_random_uuid(), MySQL: UUID()).
+     * Generate a UUID. Postgres only - use `expr.mysqlUuid()` on MySQL/MariaDB.
      */
     uuid() {
         return new SqlExpression('gen_random_uuid()');
     },
     /**
-     * Auto-generate UUID for MySQL.
+     * Generate a UUID on MySQL/MariaDB.
      */
     mysqlUuid() {
         return new SqlExpression('UUID()');
@@ -83,27 +65,13 @@ export const t = {
         return new SqlExpression(sql);
     },
     /**
-     * String literal with proper escaping.
-     */
-    literal(value) {
-        // Escape single quotes by doubling them
-        const escaped = value.replace(/'/g, "''");
-        return new SqlExpression(`'${escaped}'`);
-    },
-    /**
-     * Numeric literal.
-     */
-    number(value) {
-        return new SqlExpression(String(value));
-    },
-    /**
-     * Empty JSON object.
+     * Empty JSON object. Postgres only - the `::jsonb` cast is not portable.
      */
     emptyObject() {
         return new SqlExpression("'{}'::jsonb");
     },
     /**
-     * Empty JSON array.
+     * Empty JSON array. Postgres only - the `::jsonb` cast is not portable.
      */
     emptyArray() {
         return new SqlExpression("'[]'::jsonb");

package/dist/migrate/builder/migrationBuilder.js

@@ -6,6 +6,7 @@
  * - MigrationBuilder: Execute DDL operations (for integration tests/runtime)
  */
 import { normalizeIndexColumn } from '../../util/index.js';
+import { derivedIndexName } from '../../util/sql.util.js';
 import { createSchemaGenerator } from '../schemaGenerator.js';
 import { splitSqlStatements } from './splitSqlStatements.js';
 import { TableBuilder } from './tableBuilder.js';
@@ -26,7 +27,8 @@ function createIndexOperation(tableName, columns, options = {}) {
         tableName,
         index: {
             ...index,
-            name: name ?? `idx_${tableName}_${entries.map((entry) => entry.column).join('_')}`,
+            name: name ??
+                derivedIndexName(tableName, entries.map((entry) => entry.column)),
             entries,
             unique: unique ?? false,
         },

package/dist/migrate/builder/tableBuilder.js

@@ -4,8 +4,9 @@
  * Fluent API for defining tables in migrations.
  */
 import { normalizeIndexColumn } from '../../util/index.js';
+import { derivedIndexName } from '../../util/sql.util.js';
 import { ColumnBuilder } from './columnBuilder.js';
-import { t } from './expressions.js';
+import { expr } from './expressions.js';
 /**
  * Builder for table-level foreign keys.
  */
@@ -136,10 +137,10 @@ export class TableBuilder {
         return column;
     }
     createdAt() {
-        return this.add('createdAt', { category: 'timestamp' }, { defaultValue: t.now() });
+        return this.add('createdAt', { category: 'timestamp' }, { defaultValue: expr.now() });
     }
     updatedAt() {
-        return this.add('updatedAt', { category: 'timestamp' }, { defaultValue: t.now() });
+        return this.add('updatedAt', { category: 'timestamp' }, { defaultValue: expr.now() });
     }
     timestamps() {
         this.createdAt();
@@ -190,7 +191,7 @@ export class TableBuilder {
         // Collect column-level indexes
         for (const col of columns) {
             if (col.index) {
-                const indexName = typeof col.index === 'string' ? col.index : `idx_${this._name}_${col.name}`;
+                const indexName = typeof col.index === 'string' ? col.index : derivedIndexName(this._name, [col.name]);
                 // Only add if not already in table-level indexes
                 if (!this._indexes.some((idx) => idx.name === indexName)) {
                     this._indexes.push({

package/dist/migrate/generator/definitionToNode.js

@@ -1,3 +1,4 @@
+import { derivedForeignKeyName } from '../../util/sql.util.js';
 /**
  * A migration builder's table definition as the AST nodes the generators render from, so a hand-written
  * `createTable` and an entity reach `generateCreateTableFromNode` in the same shape. Free functions and
@@ -11,7 +12,6 @@ export function tableDefinitionToNode(def) {
         columns,
         primaryKey: [], // placeholder
         indexes: [],
-        schema: { tables: new Map(), relationships: [], indexes: [] },
         incomingRelations: [],
         outgoingRelations: [],
         comment: def.comment,
@@ -33,7 +33,7 @@ export function tableDefinitionToNode(def) {
     }
     for (const fkDef of def.foreignKeys) {
         const relNode = {
-            name: fkDef.name ?? `fk_${def.name}_${fkDef.columns.join('_')}`,
+            name: fkDef.name ?? derivedForeignKeyName(def.name, fkDef.columns),
             type: 'ManyToOne', // Builder default
             from: {
                 table,
@@ -64,7 +64,7 @@ export function fullColumnDefinitionToNode(col, tableName) {
         referencedBy: [],
         references: col.foreignKey
             ? {
-                name: `fk_${tableName}_${col.name}`,
+                name: derivedForeignKeyName(tableName, [col.name]),
                 type: 'ManyToOne',
                 from: { table: { name: tableName }, columns: [] },
                 to: {

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -2,6 +2,7 @@ import { AbstractDialect } from '../../dialect/abstractDialect.js';
 import { getMeta } from '../../entity/index.js';
 import { mongoDialectFeatures } from '../../mongo/mongoDialect.js';
 import { getKeys } from '../../util/index.js';
+import { derivedIndexName } from '../../util/sql.util.js';
 import { indexNodeToSchema } from './indexNodeToSchema.js';
 import { serializeMongoCommand } from './mongoCommand.js';
 export class MongoSchemaGenerator extends AbstractDialect {
@@ -39,7 +40,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
             const field = meta.fields[key];
             if (field?.index) {
                 const columnName = this.resolveColumnName(key, field);
-                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                const indexName = typeof field.index === 'string' ? field.index : derivedIndexName(collectionName, [columnName]);
                 indexes.push({
                     name: indexName,
                     entries: [{ column: columnName }],
@@ -142,7 +143,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
             const field = meta.fields[key];
             if (field?.index) {
                 const columnName = this.resolveColumnName(key, field);
-                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                const indexName = typeof field.index === 'string' ? field.index : derivedIndexName(collectionName, [columnName]);
                 if (!existingIndexes.has(indexName)) {
                     indexesToAdd.push({
                         name: indexName,

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.d.ts

@@ -36,7 +36,18 @@ export type TableRowReader = <T extends RawRow>(sql: string, params?: unknown[])
  */
 export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector implements SchemaIntrospector {
     protected readonly pool: QuerierPool;
-    constructor(pool: QuerierPool);
+    constructor(pool: QuerierPool, schema?: string);
+    /**
+     * The schema every catalogue query filters on, as SQL: the one that was asked for, or the engine's
+     * expression for the connection's default. A literal rather than a bind parameter because these
+     * queries are assembled as text and several use it more than once.
+     */
+    protected get schemaExpr(): string;
+    /**
+     * How this engine names the connection's current schema (Postgres) or database (MySQL). Empty on
+     * an engine with no schemas, whose catalogue queries never reference one.
+     */
+    protected readonly defaultSchemaExpr: string;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     getTableNames(): Promise<string[]>;
     tableExists(tableName: string): Promise<boolean>;

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -1,4 +1,5 @@
 import { isSqlQuerier } from '../../type/index.js';
+import { escapeAnsiSqlLiteral } from '../../util/sqlLiteral.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /**
  * Abstract base class for SQL schema introspectors.
@@ -21,10 +22,23 @@ import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
  */
 export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     pool;
-    constructor(pool) {
-        super(pool.dialect);
+    constructor(pool, schema) {
+        super(pool.dialect, schema);
         this.pool = pool;
     }
+    /**
+     * The schema every catalogue query filters on, as SQL: the one that was asked for, or the engine's
+     * expression for the connection's default. A literal rather than a bind parameter because these
+     * queries are assembled as text and several use it more than once.
+     */
+    get schemaExpr() {
+        return this.schema === undefined ? this.defaultSchemaExpr : escapeAnsiSqlLiteral(this.schema);
+    }
+    /**
+     * How this engine names the connection's current schema (Postgres) or database (MySQL). Empty on
+     * an engine with no schemas, whose catalogue queries never reference one.
+     */
+    defaultSchemaExpr = '';
     async getTableSchema(tableName) {
         return this.withSqlQuerier(async (querier) => {
             const read = createTableRowReader(querier);

package/dist/migrate/introspection/baseSqlIntrospector.d.ts

@@ -7,9 +7,15 @@ import type { TableSchema } from '../../type/migration.js';
  */
 export declare abstract class BaseSqlIntrospector {
     protected readonly dialect: AbstractSqlDialect;
+    readonly schema?: string | undefined;
     /** Columns and uniqueness only; each introspector opts in to what its catalogue queries report. */
     readonly indexFacets: ReadonlySet<IndexFacet>;
-    constructor(dialect: AbstractSqlDialect);
+    /**
+     * The one schema these queries read, `undefined` for the connection's own default. Every table
+     * reported is stamped with it, so a diff compares like with like: entity and database both say
+     * `undefined` for "wherever the connection points", and name a schema only when one was asked for.
+     */
+    constructor(dialect: AbstractSqlDialect, schema?: string | undefined);
     protected escapeId(identifier: string): string;
     /**
      * Introspect entire database schema and return SchemaAST.

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -1,15 +1,22 @@
 import { canonicalColumnType } from '../../schema/canonicalType.js';
-import { SchemaAST } from '../../schema/schemaAST.js';
+import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
 import { escapeSqlId } from '../../util/index.js';
 /**
  * Base class for SQL introspectors with shared AST building logic.
  */
 export class BaseSqlIntrospector {
     dialect;
+    schema;
     /** Columns and uniqueness only; each introspector opts in to what its catalogue queries report. */
     indexFacets = new Set();
-    constructor(dialect) {
+    /**
+     * The one schema these queries read, `undefined` for the connection's own default. Every table
+     * reported is stamped with it, so a diff compares like with like: entity and database both say
+     * `undefined` for "wherever the connection points", and name a schema only when one was asked for.
+     */
+    constructor(dialect, schema) {
         this.dialect = dialect;
+        this.schema = schema;
     }
     escapeId(identifier) {
         return escapeSqlId(identifier, this.dialect.escapeIdChar);
@@ -41,16 +48,8 @@ export class BaseSqlIntrospector {
     }
     buildTables(ast, tableNodes, tableSchemas) {
         for (const schema of tableSchemas) {
-            const columns = new Map();
-            const table = {
-                name: schema.name,
-                columns,
-                primaryKey: [],
-                indexes: [],
-                schema: ast,
-                incomingRelations: [],
-                outgoingRelations: [],
-            };
+            const table = createTableNode(schema.name, this.schema);
+            const { columns } = table;
             for (const col of schema.columns) {
                 const column = {
                     name: col.name,

package/dist/migrate/introspection/mongoIntrospector.js

@@ -22,7 +22,6 @@ export class MongoSchemaIntrospector {
                     columns,
                     primaryKey: [],
                     indexes: [],
-                    schema: ast,
                     incomingRelations: [],
                     outgoingRelations: [],
                 };

package/dist/migrate/introspection/mysqlIntrospector.d.ts

@@ -5,6 +5,7 @@ import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSq
  * Works with both MySQL and MariaDB as they share the same information_schema structure.
  */
 export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    protected readonly defaultSchemaExpr = "DATABASE()";
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult(results: {

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -4,11 +4,13 @@ import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.j
  * Works with both MySQL and MariaDB as they share the same information_schema structure.
  */
 export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    // A MySQL "schema" is a database, so the connection's own is what `DATABASE()` reports.
+    defaultSchemaExpr = 'DATABASE()';
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT TABLE_NAME as table_name
       FROM information_schema.TABLES
-      WHERE TABLE_SCHEMA = DATABASE()
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
         AND TABLE_TYPE = 'BASE TABLE'
       ORDER BY TABLE_NAME
     `;
@@ -17,7 +19,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return /*sql*/ `
       SELECT COUNT(*) as count
       FROM information_schema.TABLES
-      WHERE TABLE_SCHEMA = DATABASE()
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
         AND TABLE_NAME = ?
     `;
     }
@@ -43,7 +45,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         EXTRA as extra,
         COLUMN_COMMENT as column_comment
       FROM information_schema.COLUMNS
-      WHERE TABLE_SCHEMA = DATABASE()
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
         AND TABLE_NAME = ?
       ORDER BY ORDINAL_POSITION
     `;
@@ -55,7 +57,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
         NOT NON_UNIQUE as is_unique
       FROM information_schema.STATISTICS
-      WHERE TABLE_SCHEMA = DATABASE()
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
         AND TABLE_NAME = ?
         AND INDEX_NAME != 'PRIMARY'
       GROUP BY INDEX_NAME, NON_UNIQUE
@@ -75,7 +77,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
       JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
         ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
         AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
-      WHERE kcu.TABLE_SCHEMA = DATABASE()
+      WHERE kcu.TABLE_SCHEMA = ${this.schemaExpr}
         AND kcu.TABLE_NAME = ?
         AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
       GROUP BY kcu.CONSTRAINT_NAME, kcu.REFERENCED_TABLE_NAME, rc.DELETE_RULE, rc.UPDATE_RULE
@@ -86,7 +88,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return /*sql*/ `
       SELECT COLUMN_NAME as column_name
       FROM information_schema.KEY_COLUMN_USAGE
-      WHERE TABLE_SCHEMA = DATABASE()
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
         AND TABLE_NAME = ?
         AND CONSTRAINT_NAME = 'PRIMARY'
       ORDER BY ORDINAL_POSITION

package/dist/migrate/introspection/postgresIntrospector.d.ts

@@ -5,6 +5,7 @@ import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSq
  * PostgreSQL schema introspector
  */
 export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    protected readonly defaultSchemaExpr = "current_schema()";
     /**
      * Expressions and predicates are read back too, for `generate:from-db`, but they are text the
      * database reprints in its own words, so they are not comparable and are not claimed here.

package/dist/migrate/introspection/postgresIntrospector.js

@@ -4,6 +4,7 @@ import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.j
  * PostgreSQL schema introspector
  */
 export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    defaultSchemaExpr = 'current_schema()';
     /**
      * Expressions and predicates are read back too, for `generate:from-db`, but they are text the
      * database reprints in its own words, so they are not comparable and are not claimed here.
@@ -19,7 +20,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return /*sql*/ `
       SELECT table_name
       FROM information_schema.tables
-      WHERE table_schema = 'public'
+      WHERE table_schema = ${this.schemaExpr}
         AND table_type = 'BASE TABLE'
       ORDER BY table_name
     `;
@@ -28,7 +29,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return /*sql*/ `
       SELECT EXISTS (
         SELECT FROM information_schema.tables
-        WHERE table_schema = 'public'
+        WHERE table_schema = ${this.schemaExpr}
           AND table_name = $1
       ) AS exists
     `;
@@ -74,7 +75,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
           c.ordinal_position
         ) AS column_comment
       FROM information_schema.columns c
-      WHERE c.table_schema = 'public'
+      WHERE c.table_schema = ${this.schemaExpr}
         AND c.table_name = $1
       ORDER BY c.ordinal_position
     `;
@@ -152,7 +153,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         AND rc.constraint_schema = tc.table_schema
       WHERE tc.constraint_type = 'FOREIGN KEY'
         AND tc.table_name = $1
-        AND tc.table_schema = 'public'
+        AND tc.table_schema = ${this.schemaExpr}
       GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule
       ORDER BY tc.constraint_name
     `;
@@ -166,7 +167,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         AND tc.table_schema = kcu.table_schema
       WHERE tc.constraint_type = 'PRIMARY KEY'
         AND tc.table_name = $1
-        AND tc.table_schema = 'public'
+        AND tc.table_schema = ${this.schemaExpr}
       ORDER BY kcu.ordinal_position
     `;
     }

package/dist/migrate/migrator.d.ts

@@ -25,7 +25,8 @@ export declare class Migrator {
      * Set the schema generator for DDL operations
      */
     setSchemaGenerator(generator: SchemaGenerator): void;
-    protected createIntrospector(): SchemaIntrospector | undefined;
+    /** `schema` reads one namespace instead of the connection's own; see {@link BaseSqlIntrospector.schema}. */
+    protected createIntrospector(schema?: string): SchemaIntrospector | undefined;
     protected createGenerator(): SchemaGenerator | undefined;
     /**
      * Get all discovered migrations from the migrations directory
@@ -77,6 +78,14 @@ export declare class Migrator {
      * Get all schema differences between entities and database
      */
     getDiffs(): Promise<SchemaDiff[]>;
+    /**
+     * One AST spanning every schema the entities claim, each table stamped with the schema it was read
+     * from. Read per schema rather than all at once, so a table comes back keyed exactly as the entity
+     * that wants it spells the key: `undefined` on both sides for the connection's default, a name on
+     * both sides otherwise. Ordinarily that is one schema and one pass, as before, and that pass keeps
+     * {@link schemaIntrospector} so a caller that replaced it still wins.
+     */
+    private introspectClaimedSchemas;
     findEntityForTable(tableName: string): Promise<Type<unknown> | undefined>;
     /**
      * Sync schema directly (for development only - not for production!)
@@ -189,10 +198,10 @@ export interface BuilderMigrationDefinition {
  * ```ts
  * export default defineBuilderMigration({
  *   async up(m) {
- *     await m.createTable('users', (table) => {
- *       table.id();
- *       table.string('email', 255).unique();
- *       table.timestamps();
+ *     await m.createTable('users', (t) => {
+ *       t.id();
+ *       t.string('email', { length: 255 }).unique();
+ *       t.timestamps();
  *     });
  *   },
  *   async down(m) {