uql-orm 0.33.0 → 0.34.1

package/dist/migrate/schemaGenerator.js

@@ -2,7 +2,8 @@ import { AbstractSqlDialect } from '../dialect/index.js';
 import { getMeta } from '../entity/index.js';
 import { areTypesEqual, canonicalToSql, fieldOptionsToCanonical, isVectorCategory, sqlToCanonical, } from '../schema/canonicalType.js';
 import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
-import { escapeSqlId, getKeys, isAutoIncrement } from '../util/index.js';
+import { getKeys, isAutoIncrement, qualifyName } from '../util/index.js';
+import { derivedForeignKeyName } from '../util/sql.util.js';
 import { formatDefaultValue } from './builder/expressions.js';
 import { fullColumnDefinitionToNode, tableDefinitionToNode } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
@@ -23,17 +24,21 @@ export class SqlSchemaGenerator {
     get features() {
         return this.dialect.features;
     }
-    resolveTableName(entity, meta) {
-        return this.dialect.resolveTableName(entity, meta);
+    resolveTableName(meta) {
+        return this.dialect.resolveTableName(meta);
+    }
+    resolveTableAlias(meta) {
+        return this.dialect.resolveTableAlias(meta);
+    }
+    resolveSchema(meta) {
+        return this.dialect.resolveSchema(meta);
     }
     resolveColumnName(key, field) {
         return this.dialect.resolveColumnName(key, field);
     }
-    /**
-     * Escape an identifier (table name, column name, etc.)
-     */
+    /** Escape an identifier (table name, column name, etc.) */
     escapeId(identifier) {
-        return escapeSqlId(identifier, this.dialect.escapeIdChar);
+        return this.dialect.escapeId(identifier);
     }
     /**
      * Primary key type for auto-increment integer IDs
@@ -65,14 +70,17 @@ export class SqlSchemaGenerator {
         // Inline only where a constraint cannot be added afterwards, which is what makes the cyclic case
         // work everywhere else.
         const inline = withForeignKeys && !this.features.foreignKeyAlter;
-        const statements = tables.flatMap((table) => this.generateCreateTableFromNode(inline ? table : { ...table, outgoingRelations: [] }, options));
+        // Namespaces first: a qualified `CREATE TABLE` fails against a schema nobody created, and the
+        // schema is the one part of the layout a migration cannot infer from the table it is making.
+        const statements = this.generateCreateSchemas(tables);
+        statements.push(...tables.flatMap((table) => this.generateCreateTableFromNode(inline ? table : { ...table, outgoingRelations: [] }, options)));
         if (withForeignKeys && !inline) {
             for (const table of tables) {
                 for (const rel of table.outgoingRelations) {
-                    statements.push(this.generateAddForeignKeySql(table.name, {
+                    statements.push(this.generateAddForeignKeySql(qualifyName(table.name, table.schema), {
                         name: rel.name,
                         columns: rel.from.columns.map((c) => c.name),
-                        referencesTable: rel.to.table.name,
+                        referencesTable: qualifyName(rel.to.table.name, rel.to.table.schema),
                         referencesColumns: rel.to.columns.map((c) => c.name),
                         onDelete: rel.onDelete ?? this.defaultForeignKeyAction,
                         onUpdate: rel.onUpdate ?? this.defaultForeignKeyAction,
@@ -82,8 +90,17 @@ export class SqlSchemaGenerator {
         }
         return statements;
     }
+    /**
+     * 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.
+     */
+    generateCreateSchemas(tables) {
+        const named = tables.map((table) => table.schema).filter((it) => it !== undefined);
+        return [...new Set(named)].map((schema) => this.dialect.createSchemaSql(schema));
+    }
     generateDropSchema(entities, options = {}) {
-        return this.orderedTables(entities, 'drop').map((table) => this.generateDropTable(table.name, options));
+        return this.orderedTables(entities, 'drop').map((table) => this.generateDropTable(qualifyName(table.name, table.schema), options));
     }
     /**
      * The tables of `entities` in dependency order, optionally narrowed to `only`. The AST always spans
@@ -97,7 +114,7 @@ export class SqlSchemaGenerator {
             return tables;
         }
         const wanted = new Set(only);
-        return tables.filter((table) => wanted.has(table.name));
+        return tables.filter((table) => wanted.has(qualifyName(table.name, table.schema)));
     }
     generateDropTable(tableName, options = {}) {
         const ifExists = options.ifExists ? 'IF EXISTS ' : '';
@@ -137,7 +154,7 @@ export class SqlSchemaGenerator {
         // Drop indexes
         if (diff.indexesToDrop?.length) {
             for (const indexName of diff.indexesToDrop) {
-                statements.push(this.generateDropIndex(diff.tableName, indexName));
+                statements.push(this.generateDropIndex(diff.tableName, indexName, diff.schema));
             }
         }
         return statements;
@@ -162,7 +179,7 @@ export class SqlSchemaGenerator {
         // Reverse index additions by dropping them
         if (diff.indexesToAdd?.length) {
             for (const index of diff.indexesToAdd) {
-                statements.push(this.generateDropIndex(diff.tableName, index.name));
+                statements.push(this.generateDropIndex(diff.tableName, index.name, diff.schema));
             }
         }
         if (diff.columnsToDrop?.length || diff.indexesToDrop?.length) {
@@ -173,11 +190,15 @@ export class SqlSchemaGenerator {
     generateCreateIndex(tableName, index, options = {}) {
         return this.dialect.getCreateIndexStatement(tableName, index, options);
     }
-    generateDropIndex(tableName, indexName) {
+    /**
+     * `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, indexName, schema) {
         if (this.dialect.dropIndexSyntax === 'on-table') {
             return `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)};`;
         }
-        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+        return `DROP INDEX IF EXISTS ${this.dialect.escapeQualifiedId(indexName, schema)};`;
     }
     /**
      * Generate a column definition from a {@link ColumnSchema}, whose type is the engine's own spelling
@@ -302,7 +323,8 @@ export class SqlSchemaGenerator {
         const meta = getMeta(entity);
         if (!currentTable) {
             return {
-                tableName: this.dialect.resolveTableName(entity, meta),
+                tableName: this.resolveTableName(meta),
+                schema: this.resolveSchema(meta),
                 type: 'create',
             };
         }
@@ -340,7 +362,8 @@ export class SqlSchemaGenerator {
             return undefined;
         }
         return {
-            tableName: this.dialect.resolveTableName(entity, meta),
+            tableName: this.resolveTableName(meta),
+            schema: this.resolveSchema(meta),
             type: 'alter',
             columnsToAdd: columnsToAdd.length > 0 ? columnsToAdd : undefined,
             columnsToAlter: columnsToAlter.length > 0 ? columnsToAlter : undefined,
@@ -357,7 +380,9 @@ export class SqlSchemaGenerator {
      * created deliberately outside the ORM, and dropping it is a decision for a reviewed migration.
      */
     missingIndexes(entity, currentTable) {
-        const desired = buildEntityAST(this, [entity]).getTable(currentTable.name)?.indexes ?? [];
+        // Keyed by the qualified name, so a table in a schema finds itself rather than reporting that
+        // the entity declares no indexes at all.
+        const desired = buildEntityAST(this, [entity]).getTable(qualifyName(currentTable.name, currentTable.schema))?.indexes ?? [];
         const present = new Set(currentTable.indexes.map((index) => index.name));
         return desired
             .filter((index) => !present.has(index.name) && !this.isInlineVectorIndex(index))
@@ -477,12 +502,12 @@ export class SqlSchemaGenerator {
                 const fromCols = rel.from.columns.map((c) => this.escapeId(c.name)).join(', ');
                 const toCols = rel.to.columns.map((c) => this.escapeId(c.name)).join(', ');
                 const constraintName = rel.name ? `CONSTRAINT ${this.escapeId(rel.name)} ` : '';
-                constraints.push(`${constraintName}FOREIGN KEY (${fromCols}) REFERENCES ${this.escapeId(rel.to.table.name)} (${toCols})` +
+                constraints.push(`${constraintName}FOREIGN KEY (${fromCols}) REFERENCES ${this.dialect.escapeQualifiedId(rel.to.table.name, rel.to.table.schema)} (${toCols})` +
                     ` ON DELETE ${rel.onDelete ?? this.defaultForeignKeyAction} ON UPDATE ${rel.onUpdate ?? this.defaultForeignKeyAction}`);
             }
         }
         const ifNotExists = options.ifNotExists && this.features.ifNotExists ? 'IF NOT EXISTS ' : '';
-        let createSql = `CREATE TABLE ${ifNotExists}${this.escapeId(table.name)} (\n`;
+        let createSql = `CREATE TABLE ${ifNotExists}${this.dialect.escapeQualifiedId(table.name, table.schema)} (\n`;
         createSql += columns.map((col) => `  ${col}`).join(',\n');
         if (constraints.length > 0) {
             createSql += ',\n';
@@ -528,7 +553,8 @@ export class SqlSchemaGenerator {
      * Delegates to `generateCreateIndex` for unified SQL assembly.
      */
     generateCreateIndexFromNode(index, options = { ifNotExists: false }) {
-        return this.generateCreateIndex(index.table.name, indexNodeToSchema(index), options);
+        // The index's own name stays unqualified: it is created in the schema of the table it is on.
+        return this.generateCreateIndex(qualifyName(index.table.name, index.table.schema), indexNodeToSchema(index), options);
     }
     generateCreateTableFromDefinition(table, options = {}) {
         const tableNode = tableDefinitionToNode(table);
@@ -559,7 +585,7 @@ export class SqlSchemaGenerator {
         const refCols = foreignKey.referencesColumns.map((c) => this.escapeId(c)).join(', ');
         const constraintName = foreignKey.name
             ? this.escapeId(foreignKey.name)
-            : this.escapeId(`fk_${tableName}_${foreignKey.columns.join('_')}`);
+            : this.escapeId(derivedForeignKeyName(tableName, foreignKey.columns));
         if (!this.features.foreignKeyAlter) {
             throw new TypeError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
         }
@@ -581,7 +607,10 @@ export class SqlSchemaGenerator {
  */
 export function buildEntityAST(generator, entities, defaultForeignKeyAction) {
     return buildSchemaAST(entities, {
-        resolveTableName: (entity, meta) => generator.resolveTableName(entity, meta),
+        // The alias, not `resolveTableName`: a node holds its schema separately, so that a name derived
+        // from it stays a single identifier.
+        resolveTableName: (meta) => generator.resolveTableAlias(meta),
+        resolveSchema: (meta) => generator.resolveSchema(meta),
         resolveColumnName: (key, field) => generator.resolveColumnName(key, field),
         defaultForeignKeyAction,
     });

package/dist/mongo/mongoDialect.js

@@ -11,6 +11,7 @@ export const mongoDialectFeatures = {
     supportsJsonb: false,
     ifNotExists: false,
     indexIfNotExists: false,
+    schemas: false, // the connection picks the database, and a collection name takes no dot
     dropTableCascade: false,
     renameColumn: false,
     foreignKeyAlter: false,
@@ -156,7 +157,7 @@ export class MongoDialect extends AbstractDialect {
             ? this.junctionLookup(relOpts, relMeta, relEntity, targetScope, temp, tail, opts)
             : {
                 $lookup: {
-                    from: this.resolveTableName(relEntity, relMeta),
+                    from: this.resolveTableName(relMeta),
                     ...this.joinKeys(meta, relMeta, relOpts),
                     pipeline: [...(hasKeys(targetScope) ? [{ $match: targetScope }] : []), ...tail],
                     as: temp,
@@ -177,14 +178,14 @@ export class MongoDialect extends AbstractDialect {
         const nested = MongoDialect.REL_NESTED_KEY;
         return {
             $lookup: {
-                from: this.resolveTableName(throughEntity, throughMeta),
+                from: this.resolveTableName(throughMeta),
                 localField: MongoDialect.ID_KEY,
                 foreignField: this.columnOf(throughMeta, relOpts.references[0].local),
                 pipeline: [
                     ...(hasKeys(junctionScope) ? [{ $match: junctionScope }] : []),
                     {
                         $lookup: {
-                            from: this.resolveTableName(relEntity, relMeta),
+                            from: this.resolveTableName(relMeta),
                             localField: this.columnOf(throughMeta, relOpts.references[1].local),
                             foreignField: MongoDialect.ID_KEY,
                             pipeline: [...(hasKeys(targetScope) ? [{ $match: targetScope }] : []), { $limit: 1 }],
@@ -575,7 +576,7 @@ export class MongoDialect extends AbstractDialect {
             ];
             pipeline.push({
                 $lookup: {
-                    from: this.resolveTableName(join.entity, join.meta),
+                    from: this.resolveTableName(join.meta),
                     ...this.joinKeys(parentMeta, join.meta, join.relation),
                     ...(lookupPipeline.length ? { pipeline: lookupPipeline } : {}),
                     as: join.key,

package/dist/mongo/mongodbQuerierPool.js

@@ -1,11 +1,12 @@
 import { MongoClient } from 'mongodb';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractQuerierPool } from '../querier/index.js';
 import { MongodbNativeDialect } from './mongodbNativeDialect.js';
 import { MongodbQuerier } from './mongodbQuerier.js';
 export class MongodbQuerierPool extends AbstractQuerierPool {
     client;
     constructor(uri, opts, extra) {
-        super(new MongodbNativeDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new MongodbNativeDialect(dialectOptionsFrom(extra)), extra);
         this.client = new MongoClient(uri, opts);
     }
     async getQuerier() {

package/dist/mysql/mysql2QuerierPool.js

@@ -1,11 +1,12 @@
 import { createPool } from 'mysql2/promise';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import { MySql2Dialect } from './mysql2Dialect.js';
 import { MySql2Querier } from './mysql2Querier.js';
 export class MySql2QuerierPool extends AbstractSqlQuerierPool {
     pool;
     constructor(opts, extra) {
-        super(new MySql2Dialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new MySql2Dialect(dialectOptionsFrom(extra)), extra);
         this.pool = createPool(opts);
     }
     async getQuerier() {

package/dist/neon/neonQuerierPool.js

@@ -1,4 +1,5 @@
 import { Pool, types } from '@neondatabase/serverless';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractPgQuerierPool } from '../postgres/abstractPgQuerierPool.js';
 import { numericTypes } from '../postgres/pgNumericTypes.js';
 import { NeonDialect } from './neonDialect.js';
@@ -6,7 +7,7 @@ import { NeonQuerier } from './neonQuerier.js';
 export class NeonQuerierPool extends AbstractPgQuerierPool {
     constructor(opts, extra) {
         // Neon's own `types`, not `pg`'s: this entry has to load on an edge runtime where `pg` is absent.
-        super(new NeonDialect({ namingStrategy: extra?.namingStrategy }), new Pool({ types: numericTypes(types), ...opts }), extra);
+        super(new NeonDialect(dialectOptionsFrom(extra)), new Pool({ types: numericTypes(types), ...opts }), extra);
     }
     buildQuerier(connect) {
         return new NeonQuerier(connect, this.dialect, this.extra);

package/dist/pglite/pgliteQuerierPool.js

@@ -1,3 +1,4 @@
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { PgliteDialect } from './pgliteDialect.js';
 import { PgliteQuerier } from './pgliteQuerier.js';
@@ -20,7 +21,7 @@ export class PgliteQuerierPool extends AbstractSharedHandleQuerierPool {
     dataDir;
     opts;
     constructor(dataDir = 'memory://', opts, extra) {
-        super(new PgliteDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new PgliteDialect(dialectOptionsFrom(extra)), extra);
         this.dataDir = dataDir;
         this.opts = opts;
     }

package/dist/postgres/pgQuerierPool.js

@@ -1,4 +1,5 @@
 import { Pool, types } from 'pg';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractPgQuerierPool } from './abstractPgQuerierPool.js';
 import { PgDialect } from './pgDialect.js';
 import { numericTypes } from './pgNumericTypes.js';
@@ -7,7 +8,7 @@ export class PgQuerierPool extends AbstractPgQuerierPool {
     constructor(opts, extra) {
         // keepAlive reduces (but can't eliminate) idle connections being silently
         // dropped by NATs/firewalls on long-lived remote connections.
-        super(new PgDialect({ namingStrategy: extra?.namingStrategy }), new Pool({ keepAlive: true, types: numericTypes(types), ...opts }), extra);
+        super(new PgDialect(dialectOptionsFrom(extra)), new Pool({ keepAlive: true, types: numericTypes(types), ...opts }), extra);
     }
     buildQuerier(connect) {
         return new PgQuerier(connect, this.dialect, this.extra);

package/dist/schema/schemaAST.d.ts

@@ -5,6 +5,12 @@
  * Provides graph operations like navigation, validation, and topological sorting.
  */
 import type { ColumnNode, IndexNode, SchemaAST as ISchemaAST, RelationshipNode, RelationshipType, TableNode, ValidationError } from './types.js';
+/**
+ * A table node with its collections empty, ready to be filled. Six places build one, and the fields
+ * that are pure boilerplate are exactly the ones a new field gets forgotten in: {@link TableNode.schema}
+ * was added and `SchemaAST.clone` kept rebuilding nodes without it.
+ */
+export declare function createTableNode(name: string, schema?: string, comment?: string): TableNode;
 /**
  * Schema AST - A graph representation of a database schema.
  *
@@ -20,7 +26,8 @@ export declare class SchemaAST implements ISchemaAST {
     readonly relationships: RelationshipNode[];
     readonly indexes: IndexNode[];
     /**
-     * Get a table by name.
+     * Get a table by the name it is keyed under: schema-qualified where it has one, so two tables of
+     * the same name in different schemas stay distinct. Build the key with `qualifyName`.
      */
     getTable(name: string): TableNode | undefined;
     /**

package/dist/schema/schemaAST.js

@@ -4,6 +4,24 @@
  * The main class for working with schema graphs.
  * Provides graph operations like navigation, validation, and topological sorting.
  */
+import { qualifyName } from '../util/sql.util.js';
+/**
+ * A table node with its collections empty, ready to be filled. Six places build one, and the fields
+ * that are pure boilerplate are exactly the ones a new field gets forgotten in: {@link TableNode.schema}
+ * was added and `SchemaAST.clone` kept rebuilding nodes without it.
+ */
+export function createTableNode(name, schema, comment) {
+    return {
+        name,
+        schema,
+        comment,
+        columns: new Map(),
+        primaryKey: [],
+        indexes: [],
+        incomingRelations: [],
+        outgoingRelations: [],
+    };
+}
 /**
  * Schema AST - A graph representation of a database schema.
  *
@@ -19,7 +37,8 @@ export class SchemaAST {
     relationships = [];
     indexes = [];
     /**
-     * Get a table by name.
+     * Get a table by the name it is keyed under: schema-qualified where it has one, so two tables of
+     * the same name in different schemas stay distinct. Build the key with `qualifyName`.
      */
     getTable(name) {
         return this.tables.get(name);
@@ -28,8 +47,7 @@ export class SchemaAST {
      * Add a table to the schema.
      */
     addTable(table) {
-        table.schema = this;
-        this.tables.set(table.name, table);
+        this.tables.set(qualifyName(table.name, table.schema), table);
     }
     /**
      * Remove a table from the schema.
@@ -353,16 +371,7 @@ export class SchemaAST {
         // back to it on creation - `columns` and `primaryKey` are readonly properties holding mutable
         // containers, so they are filled in afterwards without reassigning anything.
         for (const [name, table] of this.tables) {
-            const clonedTable = {
-                name,
-                columns: new Map(),
-                primaryKey: [],
-                indexes: [],
-                comment: table.comment,
-                schema: clone,
-                incomingRelations: [],
-                outgoingRelations: [],
-            };
+            const clonedTable = createTableNode(table.name, table.schema, table.comment);
             for (const [colName, col] of table.columns) {
                 clonedTable.columns.set(colName, { ...col, table: clonedTable, referencedBy: [], references: undefined });
             }

package/dist/schema/schemaASTBuilder.d.ts

@@ -8,13 +8,15 @@
 import type { EntityMeta, FieldOptions, Type } from '../type/index.js';
 import type { NamingStrategy } from '../type/namingStrategy.js';
 import { SchemaAST } from './schemaAST.js';
-import type { ForeignKeyAction } from './types.js';
+import { type ForeignKeyAction } from './types.js';
 /**
  * Options for building SchemaAST from entities.
  */
 export interface BuildSchemaASTOptions {
-    /** Custom table name resolver */
-    resolveTableName?: (entity: Type<unknown>, meta: EntityMeta<unknown>) => string;
+    /** Custom resolver for a table's own name, unqualified. */
+    resolveTableName?: (meta: EntityMeta<unknown>) => string;
+    /** Custom resolver for the schema a table lives in; `undefined` leaves it unqualified. */
+    resolveSchema?: (meta: EntityMeta<unknown>) => string | undefined;
     /** Custom column name resolver */
     resolveColumnName?: (key: string, field: FieldOptions) => string;
     /** Naming strategy to use */

package/dist/schema/schemaASTBuilder.js

@@ -6,9 +6,10 @@
  * - Database introspection results (TableSchema[])
  */
 import { getMeta } from '../entity/metadata/definition.js';
+import { derivedForeignKeyName, derivedIndexName, qualifyName } from '../util/sql.util.js';
 import { fieldOptionsToCanonical } from './canonicalType.js';
-import { SchemaAST } from './schemaAST.js';
-import { DEFAULT_FOREIGN_KEY_ACTION } from './types.js';
+import { createTableNode, SchemaAST } from './schemaAST.js';
+import { DEFAULT_FOREIGN_KEY_ACTION, } from './types.js';
 /**
  * Build a SchemaAST from entity classes (decorated with `@Entity`, `@Field`, etc.).
  *
@@ -19,13 +20,15 @@ export function buildSchemaAST(entities, options = {}) {
     const { namingStrategy } = options;
     const ctx = {
         ast: new SchemaAST(),
-        resolveTableName: options.resolveTableName ?? ((e, m) => namingStrategy?.tableName(m.name ?? e.name) ?? m.name ?? e.name),
+        resolveTableName: options.resolveTableName ??
+            ((m) => namingStrategy?.tableName(m.name ?? m.entity.name) ?? m.name ?? m.entity.name),
+        resolveSchema: options.resolveSchema ?? ((m) => m.schema),
         resolveColumnName: options.resolveColumnName ?? ((k, f) => namingStrategy?.columnName(f.name ?? k) ?? f.name ?? k),
         defaultForeignKeyAction: options.defaultForeignKeyAction ?? DEFAULT_FOREIGN_KEY_ACTION,
     };
     for (const pass of [addTableFromEntity, addRelationshipsFromEntity, addIndexesFromEntity]) {
         for (const entity of entities) {
-            pass(ctx, entity, getMeta(entity));
+            pass(ctx, getMeta(entity));
         }
     }
     return ctx.ast;
@@ -64,20 +67,10 @@ function resolveColumnCanonicalType(field, seen = new Set()) {
 /**
  * Add a table from entity metadata.
  */
-function addTableFromEntity(ctx, entity, meta) {
-    const tableName = ctx.resolveTableName(entity, meta);
-    const columns = new Map();
-    const primaryKey = [];
-    // Create placeholder table (will be fully initialized below)
-    const table = {
-        name: tableName,
-        columns,
-        primaryKey,
-        indexes: [],
-        schema: ctx.ast,
-        incomingRelations: [],
-        outgoingRelations: [],
-    };
+function addTableFromEntity(ctx, meta) {
+    const tableName = ctx.resolveTableName(meta);
+    const table = createTableNode(tableName, ctx.resolveSchema(meta));
+    const { columns, primaryKey } = table;
     // Add columns from fields
     const fields = meta.fields;
     for (const key of Object.keys(fields)) {
@@ -112,12 +105,15 @@ function addTableFromEntity(ctx, entity, meta) {
     }
     ctx.ast.addTable(table);
 }
+/** The node an entity maps to, found under the key {@link SchemaAST} stores it by. */
+function tableOf(ctx, meta) {
+    return ctx.ast.getTable(qualifyName(ctx.resolveTableName(meta), ctx.resolveSchema(meta)));
+}
 /**
  * Add relationships from entity relation decorators.
  */
-function addRelationshipsFromEntity(ctx, entity, meta) {
-    const tableName = ctx.resolveTableName(entity, meta);
-    const table = ctx.ast.getTable(tableName);
+function addRelationshipsFromEntity(ctx, meta) {
+    const table = tableOf(ctx, meta);
     if (!table)
         return;
     const relations = meta.relations;
@@ -125,10 +121,8 @@ function addRelationshipsFromEntity(ctx, entity, meta) {
         const relation = relations[key];
         if (!relation)
             continue;
-        const relatedEntity = relation.entity();
-        const relatedMeta = getMeta(relatedEntity);
-        const relatedTableName = ctx.resolveTableName(relatedEntity, relatedMeta);
-        const relatedTable = ctx.ast.getTable(relatedTableName);
+        const relatedMeta = getMeta(relation.entity());
+        const relatedTable = tableOf(ctx, relatedMeta);
         if (!relatedTable)
             continue;
         // Only the owning side gets the FK. `mappedBy` marks the inverse side of a one-to-one, whose
@@ -151,7 +145,7 @@ function addRelationshipsFromEntity(ctx, entity, meta) {
             const foreignColumn = relatedTable.columns.get(foreignColName);
             if (localColumn && foreignColumn) {
                 const relNode = {
-                    name: `fk_${tableName}_${localColName}`,
+                    name: derivedForeignKeyName(table.name, [localColName]),
                     type: relation.cardinality === 'm1' ? 'ManyToOne' : 'OneToOne',
                     from: { table, columns: [localColumn] },
                     to: { table: relatedTable, columns: [foreignColumn] },
@@ -171,9 +165,8 @@ function addRelationshipsFromEntity(ctx, entity, meta) {
  * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
  * in common beyond their target table.
  */
-function addIndexesFromEntity(ctx, entity, meta) {
-    const tableName = ctx.resolveTableName(entity, meta);
-    const table = ctx.ast.getTable(tableName);
+function addIndexesFromEntity(ctx, meta) {
+    const table = tableOf(ctx, meta);
     if (!table)
         return;
     for (const key of Object.keys(meta.fields)) {
@@ -184,7 +177,7 @@ function addIndexesFromEntity(ctx, entity, meta) {
         if (!column)
             continue;
         ctx.ast.addIndex({
-            name: typeof field.index === 'string' ? field.index : `idx_${tableName}_${column.name}`,
+            name: typeof field.index === 'string' ? field.index : derivedIndexName(table.name, [column.name]),
             table,
             entries: [{ column: column.name }],
             unique: field.unique ?? false,
@@ -223,7 +216,7 @@ function addCompositeIndex(ctx, table, meta, idxMeta) {
     // An index over expressions alone has no column names to build a default name from.
     const named = entries.map((entry, at) => (entry.expression ? `expr${at}` : entry.column));
     ctx.ast.addIndex({
-        name: idxMeta.name ?? `idx_${table.name}_${named.join('_')}`,
+        name: idxMeta.name ?? derivedIndexName(table.name, named),
         table,
         entries,
         include: idxMeta.include?.map((column) => resolveIncludeColumn(ctx, meta, column)),

package/dist/schema/types.d.ts

@@ -98,8 +98,17 @@ export interface ColumnNode {
  * Represents a database table with all its columns, indexes, and relationships.
  */
 export interface TableNode {
-    /** Table name in the database */
+    /**
+     * The table's own name, never qualified. Everything derived from a table reads this: an index or
+     * constraint name is a single identifier, and `idx_sales.Order_total` is a syntax error.
+     */
     readonly name: string;
+    /**
+     * The namespace the table lives in, absent where nothing named one and it resolves through the
+     * connection's own default. Joined onto {@link name} by `qualifyName`, which is the key a
+     * `SchemaAST` stores the table under and the operand a statement names it by.
+     */
+    readonly schema?: string;
     /** Map of column name to column node */
     readonly columns: Map<string, ColumnNode>;
     /** Primary key columns (supports composite keys) */
@@ -108,8 +117,6 @@ export interface TableNode {
     readonly indexes: IndexNode[];
     /** Optional table comment */
     readonly comment?: string;
-    /** Reference to the parent schema */
-    schema: SchemaAST;
     /** Relationships pointing TO this table (other tables referencing this one) */
     incomingRelations: RelationshipNode[];
     /** Relationships pointing FROM this table (this table referencing others) */

package/dist/sqlite/localSqliteQuerierPool.js

@@ -1,3 +1,4 @@
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { SqliteDialect } from './sqliteDialect.js';
 import { SqliteQuerier } from './sqliteQuerier.js';
@@ -11,7 +12,7 @@ import { SqliteQuerier } from './sqliteQuerier.js';
 export class AbstractLocalSqliteQuerierPool extends AbstractSharedHandleQuerierPool {
     opts;
     constructor(opts, extra) {
-        super(new SqliteDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new SqliteDialect(dialectOptionsFrom(extra)), extra);
         this.opts = opts;
     }
     async openDb() {

package/dist/sqlite/sqliteDialect.js

@@ -8,6 +8,7 @@ export class SqliteDialect extends AbstractSqlDialect {
         supportsJsonb: false,
         ifNotExists: true,
         indexIfNotExists: true,
+        schemas: false, // SQLite's namespaces are attached database files, not declared objects
         dropTableCascade: false,
         renameColumn: true,
         foreignKeyAlter: false, // SQLite does not support adding FKs to existing tables
@@ -70,7 +71,7 @@ export class SqliteDialect extends AbstractSqlDialect {
      */
     appendTextSearch(ctx, entity, meta, search) {
         const columns = search.$fields.map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
-        ctx.append(`${this.escapeId(this.resolveTableName(entity, meta))} MATCH {${columns.join(' ')}} : `);
+        ctx.append(`${this.escapedTableName(meta)} MATCH {${columns.join(' ')}} : `);
         ctx.addValue(search.$value);
     }
     /**

package/dist/turso/tursoLocalQuerierPool.js

@@ -1,3 +1,4 @@
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { TursoDialect } from './tursoDialect.js';
 import { TursoLocalQuerier } from './tursoLocalQuerier.js';
@@ -12,7 +13,7 @@ export class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool {
     filename;
     opts;
     constructor(filename = ':memory:', opts, extra) {
-        super(new TursoDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new TursoDialect(dialectOptionsFrom(extra)), extra);
         this.filename = filename;
         this.opts = opts;
     }

package/dist/turso/tursoQuerierPool.js

@@ -1,3 +1,4 @@
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import { TursoDialect } from './tursoDialect.js';
 import { TursoQuerier } from './tursoQuerier.js';
@@ -21,7 +22,7 @@ export class TursoQuerierPool extends AbstractHranaQuerierPool {
      * with the same shape: `@libsql/client/web`, `@libsql/client-wasm`, or a test double.
      */
     constructor(conf, extra) {
-        super(new TursoDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new TursoDialect(dialectOptionsFrom(extra)), extra);
         this.conf = conf;
         this.ownsClient = !isClient(conf);
     }

package/dist/type/dialect.d.ts

@@ -76,6 +76,12 @@ export type InsertIdSource = 'returning' | 'firstId' | 'lastId';
 export interface EngineFeatures {
     readonly ifNotExists: boolean;
     readonly indexIfNotExists: boolean;
+    /**
+     * Whether the engine has namespaces a table can sit behind. `false` leaves every table
+     * unqualified, whatever `schema` an entity or pool named: SQLite attaches database files and
+     * MongoDB takes its database from the connection, so neither has one to name.
+     */
+    readonly schemas: boolean;
     readonly dropTableCascade: boolean;
     readonly renameColumn: boolean;
     readonly foreignKeyAlter: boolean;