uql-orm 0.33.0 → 0.34.1

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 {
@@ -22,24 +23,24 @@ export class MongoSchemaGenerator extends AbstractDialect {
         return this.selected(entities, options?.only).flatMap((entity) => this.generateCreateTable(entity, options));
     }
     generateDropSchema(entities) {
-        return this.selected(entities).map((entity) => this.generateDropTable(this.resolveTableName(entity, getMeta(entity))));
+        return this.selected(entities).map((entity) => this.generateDropTable(this.resolveTableName(getMeta(entity))));
     }
     selected(entities, only) {
         if (!only) {
             return entities;
         }
         const wanted = new Set(only);
-        return entities.filter((entity) => wanted.has(this.resolveTableName(entity, getMeta(entity))));
+        return entities.filter((entity) => wanted.has(this.resolveTableName(getMeta(entity))));
     }
     generateCreateTable(entity, _options) {
         const meta = getMeta(entity);
-        const collectionName = this.resolveTableName(entity, meta);
+        const collectionName = this.resolveTableName(meta);
         const indexes = [];
         for (const key of getKeys(meta.fields)) {
             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 }],
@@ -132,7 +133,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
     }
     diffSchema(entity, currentTable) {
         const meta = getMeta(entity);
-        const collectionName = this.resolveTableName(entity, meta);
+        const collectionName = this.resolveTableName(meta);
         if (!currentTable) {
             return { tableName: collectionName, type: 'create' };
         }
@@ -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!)

package/dist/migrate/migrator.js

@@ -2,7 +2,7 @@ import { mkdir, readdir, writeFile } from 'node:fs/promises';
 import { basename, extname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { getEntities, getMeta } from '../entity/index.js';
-import { introspectSchema } from '../schema/index.js';
+import { introspectSchema, SchemaAST } from '../schema/index.js';
 import { isKnownMigratorDialect, isSqlQuerier } from '../type/index.js';
 import { LoggerWrapper } from '../util/index.js';
 import { withQuerierForMigrations, withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
@@ -71,19 +71,20 @@ export class Migrator {
     setSchemaGenerator(generator) {
         this.schemaGenerator = generator;
     }
-    createIntrospector() {
+    /** `schema` reads one namespace instead of the connection's own; see {@link BaseSqlIntrospector.schema}. */
+    createIntrospector(schema) {
         const d = this.dialectName;
         if (!isKnownMigratorDialect(d)) {
             return undefined;
         }
         switch (d) {
             case 'postgres':
-                return new PostgresSchemaIntrospector(this.pool);
+                return new PostgresSchemaIntrospector(this.pool, schema);
             case 'cockroachdb':
-                return new CockroachSchemaIntrospector(this.pool);
+                return new CockroachSchemaIntrospector(this.pool, schema);
             case 'mysql':
             case 'mariadb':
-                return new MysqlSchemaIntrospector(this.pool);
+                return new MysqlSchemaIntrospector(this.pool, schema);
             case 'sqlite':
                 return new SqliteSchemaIntrospector(this.pool);
             case 'mongodb':
@@ -279,11 +280,11 @@ export class Migrator {
         if (!this.schemaGenerator || !this.schemaIntrospector) {
             throw new TypeError('Schema generator and introspector must be set');
         }
-        const ast = await introspectSchema(this.schemaIntrospector);
+        const ast = await this.introspectClaimedSchemas();
         const diffs = [];
         for (const entity of this.entities) {
             const meta = getMeta(entity);
-            const tableName = this.schemaGenerator.resolveTableName(entity, meta);
+            const tableName = this.schemaGenerator.resolveTableName(meta);
             const currentTable = ast.getTable(tableName);
             const diff = this.schemaGenerator.diffSchema(entity, currentTable);
             if (diff) {
@@ -292,6 +293,27 @@ export class Migrator {
         }
         return diffs;
     }
+    /**
+     * 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.
+     */
+    async introspectClaimedSchemas() {
+        const claimed = new Set(this.entities.map((entity) => this.pool.dialect.resolveSchema(getMeta(entity))));
+        const merged = new SchemaAST();
+        for (const schema of claimed) {
+            const introspector = schema === undefined ? this.schemaIntrospector : this.createIntrospector(schema);
+            if (!introspector) {
+                continue;
+            }
+            for (const table of (await introspectSchema(introspector)).getTables()) {
+                merged.addTable(table);
+            }
+        }
+        return merged;
+    }
     async findEntityForTable(tableName) {
         await this.ensureSchemaGenerator();
         if (!this.schemaGenerator) {
@@ -299,7 +321,7 @@ export class Migrator {
         }
         for (const entity of this.entities) {
             const meta = getMeta(entity);
-            const name = this.schemaGenerator.resolveTableName(entity, meta);
+            const name = this.schemaGenerator.resolveTableName(meta);
             if (name === tableName) {
                 return entity;
             }

package/dist/migrate/schemaGenerator.d.ts

@@ -13,11 +13,11 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     constructor(dialect: AbstractSqlDialect, defaultForeignKeyAction?: ForeignKeyAction);
     get namingStrategy(): NamingStrategy | undefined;
     get features(): DialectFeatures;
-    resolveTableName<E>(entity: Type<E>, meta: EntityMeta<E>): string;
+    resolveTableName<E>(meta: EntityMeta<E>): string;
+    resolveTableAlias<E>(meta: EntityMeta<E>): string;
+    resolveSchema<E>(meta: EntityMeta<E>): string | undefined;
     resolveColumnName(key: string, field: FieldOptions): string;
-    /**
-     * Escape an identifier (table name, column name, etc.)
-     */
+    /** Escape an identifier (table name, column name, etc.) */
     protected escapeId(identifier: string): string;
     /**
      * Primary key type for auto-increment integer IDs
@@ -38,6 +38,12 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
      * foreign key in, but it resolves targets lazily, so a forward reference is fine there.
      */
     generateCreateSchema(entities: readonly Type<unknown>[], options?: CreateSchemaOptions): string[];
+    /**
+     * One statement per distinct schema the tables being created live in, in first-seen order. Only
+     * the tables actually being created, so a narrowed `only` does not declare namespaces it is not
+     * about to fill. Empty on an engine without schemas, whose tables are never qualified.
+     */
+    private generateCreateSchemas;
     generateDropSchema(entities: readonly Type<unknown>[], options?: DropSchemaOptions): string[];
     /**
      * The tables of `entities` in dependency order, optionally narrowed to `only`. The AST always spans
@@ -51,7 +57,11 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     generateCreateIndex(tableName: string, index: IndexSchema, options?: {
         ifNotExists?: boolean;
     }): string;
-    generateDropIndex(tableName: string, indexName: string): string;
+    /**
+     * `schema` is the table's, because that is where its indexes live. MySQL takes it from the table
+     * operand instead, which is already qualified.
+     */
+    generateDropIndex(tableName: string, indexName: string, schema?: string): string;
     /**
      * Generate a column definition from a {@link ColumnSchema}, whose type is the engine's own spelling
      * and may already carry its precision (or even `PRIMARY KEY`, for a serial).
@@ -156,7 +166,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
  * other way and the table is created under one name and compared under another, which reports every
  * table of a project using a naming strategy as both missing and unexpected.
  */
-export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableName' | 'resolveColumnName'>, entities: readonly Type<unknown>[], defaultForeignKeyAction?: ForeignKeyAction): SchemaAST;
+export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName'>, entities: readonly Type<unknown>[], defaultForeignKeyAction?: ForeignKeyAction): SchemaAST;
 /**
  * Synchronous factory for SQL schema generators only.
  * For MongoDB, use `createSchemaGeneratorAsync` from `./schemaGeneratorAsync.js` so the optional `mongodb` peer is not loaded at import time.