uql-orm 0.33.0 → 0.34.0

package/dist/bunSql/bunSqlQuerierPool.js

@@ -1,4 +1,5 @@
 import { SQL } from 'bun';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { MariaDialect } from '../maria/mariaDialect.js';
 import { MySqlDialect } from '../mysql/mysqlDialect.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
@@ -20,7 +21,7 @@ export class BunSqlQuerierPool extends AbstractSqlQuerierPool {
     sqlDialectName;
     constructor(config, extra) {
         const dialectName = inferDialectName(config);
-        super(new DialectMap[dialectName]({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new DialectMap[dialectName](dialectOptionsFrom(extra)), extra);
         this.config = config;
         this.sqlDialectName = dialectName;
         const opts = normalizeBunOpts(config, dialectName);

package/dist/cockroachdb/crdbQuerierPool.js

@@ -1,4 +1,5 @@
 import { Pool, types } from 'pg';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractPgQuerierPool } from '../postgres/abstractPgQuerierPool.js';
 import { numericTypes } from '../postgres/pgNumericTypes.js';
 import { CockroachDialect } from './cockroachDialect.js';
@@ -8,7 +9,7 @@ import { CrdbQuerier } from './crdbQuerier.js';
  */
 export class CrdbQuerierPool extends AbstractPgQuerierPool {
     constructor(opts, extra) {
-        super(new CockroachDialect({ namingStrategy: extra?.namingStrategy }), new Pool({ keepAlive: true, types: numericTypes(types), ...opts }), extra);
+        super(new CockroachDialect(dialectOptionsFrom(extra)), new Pool({ keepAlive: true, types: numericTypes(types), ...opts }), extra);
     }
     buildQuerier(connect) {
         return new CrdbQuerier(connect, this.dialect, this.extra);

package/dist/d1/d1QuerierPool.js

@@ -1,10 +1,11 @@
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import { D1Querier } from './d1Querier.js';
 import { D1SqliteDialect } from './d1SqliteDialect.js';
 export class D1QuerierPool extends AbstractSqlQuerierPool {
     db;
     constructor(db, extra) {
-        super(new D1SqliteDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new D1SqliteDialect(dialectOptionsFrom(extra)), extra);
         this.db = db;
     }
     async getQuerier() {

package/dist/dialect/abstractDialect.d.ts

@@ -1,11 +1,19 @@
-import type { DialectFeatures, DialectName, EntityMeta, FieldOptions, InsertIdSource, NamingStrategy, QueryOptions, QueryWhere, QueryWhereMap, Type } from '../type/index.js';
+import type { DialectFeatures, DialectName, EntityMeta, ExtraOptions, FieldOptions, InsertIdSource, NamingStrategy, QueryOptions, QueryWhere, QueryWhereMap } from '../type/index.js';
 /**
  * Options for initializing a dialect.
  */
 export interface DialectOptions {
     readonly namingStrategy?: NamingStrategy;
+    /** Default schema for entities naming none; unset leaves them unqualified. See {@link AbstractDialect.resolveSchema}. */
+    readonly schema?: string;
     readonly driverCapabilities?: Partial<DialectFeatures>;
 }
+/**
+ * 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
+ * each of the thirteen constructors.
+ */
+export declare function dialectOptionsFrom(extra: ExtraOptions | undefined): DialectOptions;
 /**
  * Base abstract class for all database dialects (SQL and NoSQL).
  */
@@ -34,9 +42,25 @@ export declare abstract class AbstractDialect {
      */
     get features(): DialectFeatures;
     /**
-     * Resolve the table name for an entity, applying naming strategy if necessary.
+     * The table's own name, unqualified, applying naming strategy if necessary. Also the alias the
+     * root table gets once {@link resolveTableName} qualifies it, so it has to stay a single
+     * identifier: columns are prefixed with it, and a dotted prefix escapes as one identifier that
+     * nothing declared.
+     */
+    resolveTableAlias<E>(meta: EntityMeta<E>): string;
+    /**
+     * Where the table lives: {@link resolveTableAlias} behind its schema, when one applies. The schema
+     * skips the naming strategy - it names an object the author wrote out, and snake_casing `myCrm`
+     * would point at one that does not exist.
+     */
+    resolveTableName<E>(meta: EntityMeta<E>): string;
+    /**
+     * Which schema an entity is read from: its own wins over the pool's default, the way its `name`
+     * wins over the naming strategy. `undefined` is an answer, not a gap - the table stays unqualified
+     * and resolves through the connection's `search_path`, which is what every deployment predating
+     * this option relies on.
      */
-    resolveTableName<E>(entity: Type<E>, meta: EntityMeta<E>): string;
+    resolveSchema<E>(meta: EntityMeta<E>): string | undefined;
     /**
      * Resolve the column/field name for a property, applying naming strategy if necessary.
      */

package/dist/dialect/abstractDialect.js

@@ -1,4 +1,12 @@
 import { applyFilters, buildQueryWhereAsMap } from '../util/dialect.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
+ * each of the thirteen constructors.
+ */
+export function dialectOptionsFrom(extra) {
+    return { namingStrategy: extra?.namingStrategy, schema: extra?.schema };
+}
 /**
  * Base abstract class for all database dialects (SQL and NoSQL).
  */
@@ -25,15 +33,38 @@ export class AbstractDialect {
         return this.#features;
     }
     /**
-     * Resolve the table name for an entity, applying naming strategy if necessary.
+     * The table's own name, unqualified, applying naming strategy if necessary. Also the alias the
+     * root table gets once {@link resolveTableName} qualifies it, so it has to stay a single
+     * identifier: columns are prefixed with it, and a dotted prefix escapes as one identifier that
+     * nothing declared.
      */
-    resolveTableName(entity, meta) {
-        const name = meta.name ?? entity.name;
-        if (name !== entity.name || !this.namingStrategy) {
+    resolveTableAlias(meta) {
+        const className = meta.entity.name;
+        const name = meta.name ?? className;
+        if (name !== className || !this.namingStrategy) {
             return name;
         }
         return this.namingStrategy.tableName(name);
     }
+    /**
+     * Where the table lives: {@link resolveTableAlias} behind its schema, when one applies. The schema
+     * skips the naming strategy - it names an object the author wrote out, and snake_casing `myCrm`
+     * 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;
+    }
+    /**
+     * Which schema an entity is read from: its own wins over the pool's default, the way its `name`
+     * wins over the naming strategy. `undefined` is an answer, not a gap - the table stays unqualified
+     * and resolves through the connection's `search_path`, which is what every deployment predating
+     * this option relies on.
+     */
+    resolveSchema(meta) {
+        return this.features.schemas ? (meta.schema ?? this.options.schema) : undefined;
+    }
     /**
      * Resolve the column/field name for a property, applying naming strategy if necessary.
      */

package/dist/dialect/abstractSqlDialect.d.ts

@@ -15,6 +15,12 @@ export declare abstract class AbstractSqlDialect extends IndexSqlDialect impleme
     abstract readonly beginTransactionCommand: string;
     abstract readonly commitTransactionCommand: string;
     abstract readonly rollbackTransactionCommand: string;
+    /**
+     * How this engine declares a namespace, so a generated migration creates the schemas its tables
+     * need before creating them. Only reached where {@link DialectFeatures.schemas} is on. MySQL and
+     * MariaDB accept the same statement, where it means a database.
+     */
+    createSchemaSql(schema: string): string;
     readonly isolationLevelStrategy: 'inline' | 'set-before' | 'none';
     readonly alterColumnStrategy: 'separate-clauses' | 'single-statement';
     readonly alterColumnSyntax: 'ALTER COLUMN' | 'MODIFY COLUMN' | 'none';
@@ -68,10 +74,24 @@ export declare abstract class AbstractSqlDialect extends IndexSqlDialect impleme
      */
     protected appendTextSearch<E>(_ctx: QueryContext, _entity: Type<E>, _meta: EntityMeta<E>, _search: QueryTextSearchOptions<E>): void;
     select<E>(ctx: QueryContext, entity: Type<E>, q: Query<E>, opts?: QueryOptions, joins?: QueryJoins): void;
+    /**
+     * The table as a statement writes it, each part escaped on its own rather than as one dotted
+     * string taken apart again by {@link escapeId}.
+     */
+    protected escapedTableName<E>(meta: EntityMeta<E>): string;
+    /**
+     * A FROM or JOIN operand plus the alias to prefix its columns by, aliased only once a schema puts
+     * something in front of the name. See {@link resolveTableAlias} for why the prefix cannot be the
+     * qualified path.
+     */
+    protected tableRef<E>(meta: EntityMeta<E>): {
+        alias: string;
+        ref: string;
+    };
     /** Columns are alias-qualified once anything else is in play: a join, or a to-many being filled. */
     private resolveRelationAwarePrefix;
     protected selectRelationFields(ctx: QueryContext, joins: QueryJoins): void;
-    protected selectRelationJoins<E>(ctx: QueryContext, meta: EntityMeta<E>, tableName: string, joins: QueryJoins): void;
+    protected selectRelationJoins<E>(ctx: QueryContext, meta: EntityMeta<E>, rootAlias: string, joins: QueryJoins): void;
     where<E>(ctx: QueryContext, entity: Type<E>, where?: QueryWhere<E>, opts?: QueryWhereOptions): void;
     /** Renders a `$where` tree without applying entity filters (used for same-scope `$and`/`$or` recursion). */
     protected renderWhere<E>(ctx: QueryContext, entity: Type<E>, where?: QueryWhere<E>, opts?: QueryWhereOptions): void;

package/dist/dialect/abstractSqlDialect.js

@@ -9,6 +9,14 @@ import { SqlQueryContext } from './queryContext.js';
 import { NO_JOINS, resolveQueryJoins, resolveSortableJoin, } from './queryJoins.js';
 import { isVectorFieldType, resolveVectorCast } from './vectorCast.js';
 export class AbstractSqlDialect extends IndexSqlDialect {
+    /**
+     * How this engine declares a namespace, so a generated migration creates the schemas its tables
+     * need before creating them. Only reached where {@link DialectFeatures.schemas} is on. MySQL and
+     * MariaDB accept the same statement, where it means a database.
+     */
+    createSchemaSql(schema) {
+        return `CREATE SCHEMA IF NOT EXISTS ${this.escapeId(schema, true)}`;
+    }
     isolationLevelStrategy = 'inline';
     alterColumnStrategy = 'single-statement';
     alterColumnSyntax = 'ALTER COLUMN';
@@ -89,8 +97,7 @@ export class AbstractSqlDialect extends IndexSqlDialect {
     }
     search(ctx, entity, q = {}, opts = {}, joins = NO_JOINS) {
         const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        const prefix = this.resolveRelationAwarePrefix(tableName, meta, opts, q.$populate, joins);
+        const prefix = this.resolveRelationAwarePrefix(this.resolveTableAlias(meta), meta, opts, q.$populate, joins);
         if (opts.prefix !== prefix) {
             opts = { ...opts, prefix };
         }
@@ -166,8 +173,8 @@ export class AbstractSqlDialect extends IndexSqlDialect {
     }
     select(ctx, entity, q, opts = {}, joins = NO_JOINS) {
         const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        const prefix = this.resolveRelationAwarePrefix(tableName, meta, opts, q.$populate, joins);
+        const { alias, ref } = this.tableRef(meta);
+        const prefix = this.resolveRelationAwarePrefix(alias, meta, opts, q.$populate, joins);
         ctx.append(q.$distinct ? 'SELECT DISTINCT ' : 'SELECT ');
         this.selectFields(ctx, entity, q.$select, { prefix }, q.$exclude);
         // Add related fields BEFORE FROM clause
@@ -179,9 +186,29 @@ export class AbstractSqlDialect extends IndexSqlDialect {
                 this.appendVectorProjection(ctx, meta, key, val);
             }
         }
-        ctx.append(` FROM ${this.escapeId(tableName)}`);
+        ctx.append(` FROM ${ref}`);
         // Add JOINs AFTER FROM clause
-        this.selectRelationJoins(ctx, meta, tableName, joins);
+        this.selectRelationJoins(ctx, meta, alias, joins);
+    }
+    /**
+     * The table as a statement writes it, each part escaped on its own rather than as one dotted
+     * 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;
+    }
+    /**
+     * A FROM or JOIN operand plus the alias to prefix its columns by, aliased only once a schema puts
+     * something in front of the name. See {@link resolveTableAlias} for why the prefix cannot be the
+     * qualified path.
+     */
+    tableRef(meta) {
+        const alias = this.resolveTableAlias(meta);
+        const name = this.escapedTableName(meta);
+        const schema = this.resolveSchema(meta);
+        return { alias, ref: schema ? `${name} ${this.escapeId(alias, true)}` : name };
     }
     /** Columns are alias-qualified once anything else is in play: a join, or a to-many being filled. */
     resolveRelationAwarePrefix(tableName, meta, opts, populate, joins) {
@@ -198,11 +225,11 @@ export class AbstractSqlDialect extends IndexSqlDialect {
             this.selectFields(ctx, join.entity, join.query.$select, { prefix: join.path, autoPrefixAlias: true }, join.query.$exclude);
         }
     }
-    selectRelationJoins(ctx, meta, tableName, joins) {
+    selectRelationJoins(ctx, meta, rootAlias, joins) {
         for (const join of joins.values()) {
             const joinAlias = this.escapeId(join.path, true);
-            const parentAlias = join.parent ? this.escapeId(join.parent.path, true) : this.escapeId(tableName);
-            ctx.append(` ${join.required ? 'INNER' : 'LEFT'} JOIN ${this.escapeId(this.resolveTableName(join.entity, join.meta))} ${joinAlias} ON `);
+            const parentAlias = join.parent ? this.escapeId(join.parent.path, true) : this.escapeId(rootAlias, true);
+            ctx.append(` ${join.required ? 'INNER' : 'LEFT'} JOIN ${this.escapedTableName(join.meta)} ${joinAlias} ON `);
             join.relation.references.forEach((reference, index) => {
                 if (index > 0)
                     ctx.append(' AND ');
@@ -264,11 +291,13 @@ export class AbstractSqlDialect extends IndexSqlDialect {
         if (val instanceof QueryRaw) {
             if (key === '$exists' || key === '$nexists') {
                 ctx.append(key === '$exists' ? 'EXISTS (' : 'NOT EXISTS (');
-                const tableName = this.resolveTableName(entity, meta);
+                // The alias: the enclosing statement declares one, and Postgres forbids reaching past it
+                // to the qualified name it aliased.
+                const alias = this.resolveTableAlias(meta);
                 this.getRawValue(ctx, {
                     value: val,
-                    prefix: tableName,
-                    escapedPrefix: this.escapeId(tableName, false, true),
+                    prefix: alias,
+                    escapedPrefix: this.escapeId(alias, true, true),
                 });
                 ctx.append(')');
                 return;
@@ -735,7 +764,8 @@ export class AbstractSqlDialect extends IndexSqlDialect {
         }
         this.assertLockSupported(entity, q, joins);
         const meta = getMeta(entity);
-        const target = joins.size > 0 ? ` OF ${this.escapeId(this.resolveTableName(entity, meta))}` : '';
+        // `OF` names the alias in the FROM, never the schema-qualified path it was aliased from.
+        const target = joins.size > 0 ? ` OF ${this.escapeId(this.resolveTableAlias(meta), true)}` : '';
         const suffix = wait === 'skip' ? ' SKIP LOCKED' : wait === 'nowait' ? ' NOWAIT' : '';
         ctx.append(` FOR UPDATE${target}${suffix}`);
     }
@@ -757,7 +787,7 @@ export class AbstractSqlDialect extends IndexSqlDialect {
     ]);
     aggregate(ctx, entity, q, opts = {}) {
         const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
+        const tableName = this.escapedTableName(meta);
         const groupKeys = [];
         const selectParts = [];
         // Every column the statement emits, mapped to the SQL that references it. `$having` and `$sort`
@@ -787,7 +817,7 @@ export class AbstractSqlDialect extends IndexSqlDialect {
         if (!selectParts.length) {
             throw new TypeError('aggregate requires at least one $group column or $agg function');
         }
-        ctx.append(`SELECT ${selectParts.join(', ')} FROM ${this.escapeId(tableName)}`);
+        ctx.append(`SELECT ${selectParts.join(', ')} FROM ${tableName}`);
         this.where(ctx, entity, q.$where, opts);
         if (groupKeys.length) {
             ctx.append(` GROUP BY ${groupKeys.join(', ')}`);
@@ -893,8 +923,8 @@ export class AbstractSqlDialect extends IndexSqlDialect {
             columns[i] = this.escapedColumnName(meta, key);
             kinds[i] = this.persistKind(field);
         }
-        const tableName = this.resolveTableName(entity, meta);
-        ctx.append(`INSERT INTO ${this.escapeId(tableName)} (${columns.join(', ')}) VALUES (`);
+        const tableName = this.escapedTableName(meta);
+        ctx.append(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (`);
         for (let r = 0; r < payloads.length; r++) {
             if (r > 0) {
                 ctx.append('), (');
@@ -931,8 +961,8 @@ export class AbstractSqlDialect extends IndexSqlDialect {
         const meta = getMeta(entity);
         const [filledPayload] = fillOnFields(meta, payload, 'onUpdate');
         const keys = filterFieldKeys(meta, filledPayload, 'onUpdate');
-        const tableName = this.resolveTableName(entity, meta);
-        ctx.append(`UPDATE ${this.escapeId(tableName)} SET `);
+        const tableName = this.escapedTableName(meta);
+        ctx.append(`UPDATE ${tableName} SET `);
         for (let i = 0; i < keys.length; i++) {
             if (i > 0) {
                 ctx.append(', ');
@@ -1014,14 +1044,14 @@ export class AbstractSqlDialect extends IndexSqlDialect {
     }
     delete(ctx, entity, q, opts = {}) {
         const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
+        const tableName = this.escapedTableName(meta);
         // Soft-delete (stamp only live rows) unless `hardDelete` is requested or the entity has no
         // soft-delete field (e.g. a cascade onto a non-soft-deletable child).
         if (!opts.hardDelete && meta.softDelete) {
             const field = meta.fields[meta.softDelete];
             if (field) {
                 const columnName = this.resolveColumnName(meta.softDelete, field);
-                ctx.append(`UPDATE ${this.escapeId(tableName)} SET ${this.escapeId(columnName)} = `);
+                ctx.append(`UPDATE ${tableName} SET ${this.escapeId(columnName)} = `);
                 this.formatPersistableValue(ctx, field, getSoftDeleteValue(field));
                 this.search(ctx, entity, q, opts);
                 return;
@@ -1029,7 +1059,7 @@ export class AbstractSqlDialect extends IndexSqlDialect {
         }
         // Hard delete removes matching rows regardless of soft-delete state (keeps other filters, e.g. tenant).
         // Only rewrite the filters when there is a soft-delete filter to disable.
-        ctx.append(`DELETE FROM ${this.escapeId(tableName)}`);
+        ctx.append(`DELETE FROM ${tableName}`);
         this.search(ctx, entity, q, meta.softDelete ? { ...opts, filters: withoutSoftDeleteFilter(opts.filters) } : opts);
     }
     escapeId(val, forbidQualified, addDot) {
@@ -1353,38 +1383,39 @@ export class AbstractSqlDialect extends IndexSqlDialect {
      */
     appendRelationSubquery(ctx, entity, rel, opts, projection, val) {
         const meta = getMeta(entity);
-        const parentTable = this.resolveTableName(entity, meta);
+        // Aliases, not paths, everywhere a column is prefixed; `tableRef` declares them in the FROM.
+        const parentAlias = this.resolveTableAlias(meta);
         const references = rel.references;
-        const escapedParentId = this.escapedParentColumn(parentTable, meta, opts, meta.id);
+        const escapedParentId = this.escapedParentColumn(parentAlias, meta, opts, meta.id);
         const relatedEntity = rel.entity();
         const relatedMeta = getMeta(relatedEntity);
-        const relatedTable = this.resolveTableName(relatedEntity, relatedMeta);
+        const { alias: relatedAlias, ref: relatedRef } = this.tableRef(relatedMeta);
         // Resolved before any SQL is emitted: it also decides whether the mm form reaches the target.
         const targetWhere = this.scopedWhereMap(relatedMeta, val);
         ctx.append(`(SELECT ${projection} FROM `);
         if (rel.cardinality === 'mm' && rel.through) {
             const throughEntity = rel.through();
             const throughMeta = getMeta(throughEntity);
-            const throughTable = this.resolveTableName(throughEntity, throughMeta);
-            ctx.append(this.escapeId(throughTable));
-            ctx.append(` WHERE ${this.escapedColumn(throughTable, throughMeta, references[0].local)} = ${escapedParentId}`);
+            const { alias: throughAlias, ref: throughRef } = this.tableRef(throughMeta);
+            ctx.append(throughRef);
+            ctx.append(` WHERE ${this.escapedColumn(throughAlias, throughMeta, references[0].local)} = ${escapedParentId}`);
             // The junction is a row being read too: a soft-deleted link is not a link.
-            this.where(ctx, throughEntity, {}, { prefix: throughTable, clause: 'AND' });
+            this.where(ctx, throughEntity, {}, { prefix: throughAlias, clause: 'AND' });
             if (hasKeys(targetWhere)) {
-                ctx.append(` AND ${this.escapedColumn(throughTable, throughMeta, references[1].local)} IN (`);
-                ctx.append(`SELECT ${this.escapedColumn(relatedTable, relatedMeta, relatedMeta.id)} FROM ${this.escapeId(relatedTable)}`);
-                this.renderWhere(ctx, relatedEntity, targetWhere, { prefix: relatedTable, clause: 'WHERE' });
+                ctx.append(` AND ${this.escapedColumn(throughAlias, throughMeta, references[1].local)} IN (`);
+                ctx.append(`SELECT ${this.escapedColumn(relatedAlias, relatedMeta, relatedMeta.id)} FROM ${relatedRef}`);
+                this.renderWhere(ctx, relatedEntity, targetWhere, { prefix: relatedAlias, clause: 'WHERE' });
                 ctx.append(')');
             }
         }
         else {
-            const joinLeft = this.escapedColumn(relatedTable, relatedMeta, references[0].foreign);
+            const joinLeft = this.escapedColumn(relatedAlias, relatedMeta, references[0].foreign);
             const joinRight = rel.cardinality === '1m'
                 ? escapedParentId
-                : this.escapedParentColumn(parentTable, meta, opts, references[0].local);
-            ctx.append(this.escapeId(relatedTable));
+                : this.escapedParentColumn(parentAlias, meta, opts, references[0].local);
+            ctx.append(relatedRef);
             ctx.append(` WHERE ${joinLeft} = ${joinRight}`);
-            this.renderWhere(ctx, relatedEntity, targetWhere, { prefix: relatedTable, clause: 'AND' });
+            this.renderWhere(ctx, relatedEntity, targetWhere, { prefix: relatedAlias, clause: 'AND' });
         }
         ctx.append(')');
     }

package/dist/dialect/mysqlLikeSqlDialect.js

@@ -23,6 +23,7 @@ export class MysqlLikeSqlDialect extends AbstractSqlDialect {
         supportsJsonb: false,
         ifNotExists: true,
         indexIfNotExists: false,
+        schemas: true,
         dropTableCascade: false,
         renameColumn: true,
         foreignKeyAlter: true,

package/dist/dialect/pgLikeSqlDialect.js

@@ -20,6 +20,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         supportsJsonb: true,
         ifNotExists: true,
         indexIfNotExists: true,
+        schemas: true,
         dropTableCascade: true,
         renameColumn: true,
         foreignKeyAlter: true,

package/dist/entity/metadata/definition.js

@@ -104,6 +104,14 @@ export function applyMembers(entity, specs) {
     }
 }
 export function defineEntity(entity, opts = {}) {
+    // Ahead of any registration, so a rejected definition leaves nothing half-written in the registry.
+    // A dotted name reads like a schema and is not one: it escapes as a single identifier, so the
+    // statement builds and then fails at the database. `schema` is the way to say it.
+    if (opts.name?.includes('.')) {
+        const [schema, ...rest] = opts.name.split('.');
+        throw new TypeError(`'${entity.name}' has a dotted name '${opts.name}'. Name the schema separately as ` +
+            `{ schema: '${schema}', name: '${rest.join('.')}' }.`);
+    }
     const meta = ensureMeta(entity);
     // Covers `defineEntity(Decorated)` called on a class whose members carry decorators. `@Entity()`
     // drains `context.metadata` itself, because TypeScript only attaches `Symbol.metadata` to the class
@@ -121,6 +129,7 @@ export function defineEntity(entity, opts = {}) {
         throw TypeError(`'${entity.name}' must have fields`);
     }
     meta.name = opts.name ?? entity.name;
+    meta.schema = opts.schema;
     let proto = Object.getPrototypeOf(entity.prototype);
     while (proto.constructor !== Object) {
         const parent = proto.constructor;

package/dist/http/handler.js

@@ -2,6 +2,11 @@ import { withContext } from '../context/context.js';
 import { getEntities, getMeta } from '../entity/index.js';
 import { entityPath, matchRoute, } from './contract.js';
 import { parseQueryParams } from './query.js';
+/** `Company (crm.Company)`: the class, and the table it maps, which is what tells two apart. */
+function tableOf(entity) {
+    const meta = getMeta(entity);
+    return `${entity.name} (${meta.schema ? `${meta.schema}.${meta.name}` : meta.name})`;
+}
 export function createRequestHandler(opts) {
     const { include, exclude, pre, preSave, preFilter, post, getContext, pool } = opts;
     let entities = include ?? getEntities();
@@ -11,8 +16,18 @@ export function createRequestHandler(opts) {
     if (!entities.length) {
         throw new TypeError('no entities for the uql middleware');
     }
+    // The route is the class name, so two entities mapping one table in different schemas collide here
+    // even though nothing else about them does. All of them at once, so fixing the first collision
+    // does not just reveal the next.
+    const byPath = Map.groupBy(entities, entityPath);
+    const collisions = [...byPath].filter(([, clashing]) => clashing.length > 1);
+    if (collisions.length) {
+        const lines = collisions.map(([path, clashing]) => `  /${path} <- ${clashing.map(tableOf).join(', ')}`);
+        throw new TypeError(`every entity below shares a route with another, so all but the first are unreachable:\n${lines.join('\n')}\n` +
+            "A route is the kebab-cased class name. Rename a class, or pass only one of them in 'include'.");
+    }
     // biome-ignore lint/suspicious/noExplicitAny: heterogeneous entity map
-    const entityByPath = new Map(entities.map((entity) => [entityPath(entity), entity]));
+    const entityByPath = new Map([...byPath].map(([path, [entity]]) => [path, entity]));
     return (req) => {
         const entity = entityByPath.get(req.entityPath);
         if (!entity) {

package/dist/libsql/libsqlQuerierPool.js

@@ -1,3 +1,4 @@
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import { LibsqlDialect } from './libsqlDialect.js';
 import { LibsqlQuerier } from './libsqlQuerier.js';
@@ -13,7 +14,7 @@ function remoteMigrationClientConfig(config) {
 export class LibsqlQuerierPool extends AbstractHranaQuerierPool {
     conf;
     constructor(conf, extra) {
-        super(new LibsqlDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new LibsqlDialect(dialectOptionsFrom(extra)), extra);
         this.conf = conf;
     }
     openClient() {

package/dist/maria/mariadbQuerierPool.js

@@ -1,4 +1,5 @@
 import { createPool } from 'mariadb';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import { attachPoolErrorHandler } from '../util/index.js';
 import { MariaDialect } from './mariaDialect.js';
@@ -6,7 +7,7 @@ import { MariadbQuerier } from './mariadbQuerier.js';
 export class MariadbQuerierPool extends AbstractSqlQuerierPool {
     pool;
     constructor(opts, extra) {
-        super(new MariaDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        super(new MariaDialect(dialectOptionsFrom(extra)), extra);
         // `mariadb` defaults to handing BIGINT back as a BigInt, and uql maps `type: Number` to BIGINT
         // (see `schema/canonicalType.ts`), so every auto-increment id reached a field declared `number`
         // as `9n` without this. Same trade as the pg pools: exact to 2^53, and `...opts` wins for a

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -22,18 +22,18 @@ 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];
@@ -132,7 +132,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' };
         }

package/dist/migrate/migrator.js

@@ -283,7 +283,7 @@ export class Migrator {
         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) {
@@ -299,7 +299,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,7 +13,7 @@ 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;
     resolveColumnName(key: string, field: FieldOptions): string;
     /**
      * Escape an identifier (table name, column name, etc.)
@@ -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 entities name, in first-seen order. `resolveSchema` is
+     * already `undefined` on an engine without schemas, so this is empty there, and empty in the
+     * ordinary case where nothing named one.
+     */
+    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

package/dist/migrate/schemaGenerator.js

@@ -23,8 +23,8 @@ 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);
     }
     resolveColumnName(key, field) {
         return this.dialect.resolveColumnName(key, field);
@@ -65,7 +65,10 @@ 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(entities);
+        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) {
@@ -82,6 +85,17 @@ export class SqlSchemaGenerator {
         }
         return statements;
     }
+    /**
+     * One statement per distinct schema the entities name, in first-seen order. `resolveSchema` is
+     * already `undefined` on an engine without schemas, so this is empty there, and empty in the
+     * ordinary case where nothing named one.
+     */
+    generateCreateSchemas(entities) {
+        const named = entities
+            .map((entity) => this.dialect.resolveSchema(getMeta(entity)))
+            .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));
     }
@@ -302,7 +316,7 @@ export class SqlSchemaGenerator {
         const meta = getMeta(entity);
         if (!currentTable) {
             return {
-                tableName: this.dialect.resolveTableName(entity, meta),
+                tableName: this.dialect.resolveTableName(meta),
                 type: 'create',
             };
         }
@@ -340,7 +354,7 @@ export class SqlSchemaGenerator {
             return undefined;
         }
         return {
-            tableName: this.dialect.resolveTableName(entity, meta),
+            tableName: this.dialect.resolveTableName(meta),
             type: 'alter',
             columnsToAdd: columnsToAdd.length > 0 ? columnsToAdd : undefined,
             columnsToAlter: columnsToAlter.length > 0 ? columnsToAlter : undefined,
@@ -581,7 +595,7 @@ export class SqlSchemaGenerator {
  */
 export function buildEntityAST(generator, entities, defaultForeignKeyAction) {
     return buildSchemaAST(entities, {
-        resolveTableName: (entity, meta) => generator.resolveTableName(entity, meta),
+        resolveTableName: (meta) => generator.resolveTableName(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/schemaASTBuilder.d.ts

@@ -14,7 +14,7 @@ import type { ForeignKeyAction } from './types.js';
  */
 export interface BuildSchemaASTOptions {
     /** Custom table name resolver */
-    resolveTableName?: (entity: Type<unknown>, meta: EntityMeta<unknown>) => string;
+    resolveTableName?: (meta: EntityMeta<unknown>) => string;
     /** Custom column name resolver */
     resolveColumnName?: (key: string, field: FieldOptions) => string;
     /** Naming strategy to use */

package/dist/schema/schemaASTBuilder.js

@@ -19,13 +19,14 @@ 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),
         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,8 +65,8 @@ function resolveColumnCanonicalType(field, seen = new Set()) {
 /**
  * Add a table from entity metadata.
  */
-function addTableFromEntity(ctx, entity, meta) {
-    const tableName = ctx.resolveTableName(entity, meta);
+function addTableFromEntity(ctx, meta) {
+    const tableName = ctx.resolveTableName(meta);
     const columns = new Map();
     const primaryKey = [];
     // Create placeholder table (will be fully initialized below)
@@ -115,8 +116,8 @@ function addTableFromEntity(ctx, entity, meta) {
 /**
  * Add relationships from entity relation decorators.
  */
-function addRelationshipsFromEntity(ctx, entity, meta) {
-    const tableName = ctx.resolveTableName(entity, meta);
+function addRelationshipsFromEntity(ctx, meta) {
+    const tableName = ctx.resolveTableName(meta);
     const table = ctx.ast.getTable(tableName);
     if (!table)
         return;
@@ -127,7 +128,7 @@ function addRelationshipsFromEntity(ctx, entity, meta) {
             continue;
         const relatedEntity = relation.entity();
         const relatedMeta = getMeta(relatedEntity);
-        const relatedTableName = ctx.resolveTableName(relatedEntity, relatedMeta);
+        const relatedTableName = ctx.resolveTableName(relatedMeta);
         const relatedTable = ctx.ast.getTable(relatedTableName);
         if (!relatedTable)
             continue;
@@ -171,8 +172,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);
+function addIndexesFromEntity(ctx, meta) {
+    const tableName = ctx.resolveTableName(meta);
     const table = ctx.ast.getTable(tableName);
     if (!table)
         return;

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;

package/dist/type/entity.d.ts

@@ -577,6 +577,8 @@ export type EntityIndexMeta = {
 export type EntityMeta<E> = {
     readonly entity: Type<E>;
     name?: string;
+    /** Set only when the entity named one; unset defers to the pool where it is used. See `AbstractDialect.resolveSchema`. */
+    schema?: string;
     id: IdKey<E>;
     softDelete?: FieldKey<E>;
     /** Named, default-on `$where` filters applied to every query unless bypassed. */
@@ -605,6 +607,11 @@ export type EntityMeta<E> = {
  */
 export type EntityOptions<E = unknown> = {
     readonly name?: string;
+    /**
+     * The schema (in MySQL terms, database) this table lives in, pinning it whichever pool reads it;
+     * unset follows the pool's own. Not in `name`: a dotted `name` is rejected.
+     */
+    readonly schema?: string;
     /** Named, default-on `$where` filters (soft-delete is auto-registered from `@Field({ softDelete })`). */
     readonly filters?: Record<string, FilterOptions<E>>;
     /** Scalar fields; use `isId: true` on exactly one field for the primary key. */

package/dist/type/migration.d.ts

@@ -245,7 +245,7 @@ export interface SchemaGenerator {
     /**
      * Resolve table name using entity and naming strategy
      */
-    resolveTableName<E>(entity: Type<E>, meta: EntityMeta<E>): string;
+    resolveTableName<E>(meta: EntityMeta<E>): string;
     /**
      * Resolve column name using field options and naming strategy
      */

package/dist/type/querier.d.ts

@@ -164,5 +164,10 @@ export type ExtraOptions = {
     /** Threshold in milliseconds - queries exceeding this are logged as slow. */
     readonly slowQuery?: number;
     readonly namingStrategy?: NamingStrategy;
+    /**
+     * Default schema (in MySQL terms, database) for entities naming none; unset leaves them
+     * unqualified. `@Entity({ schema })` overrides it.
+     */
+    readonly schema?: string;
     readonly listeners?: readonly QuerierListener[];
 };

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "JSON-native TypeScript ORM for Node.js, Bun and Deno. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "type": "module",
   "engines": {
     "node": ">=24"