uql-orm 0.61.0 → 0.63.0

package/dist/entity/metadata/definition.js

@@ -1,6 +1,6 @@
 import { SOFT_DELETE_FILTER } from '../../type/index.js';
 import { isInlinedExpression } from '../../util/field.util.js';
-import { entityName, fieldOptionConflict, getKeys, ddlText, hasKeys, isToManyRelation, lowerFirst, normalizeIndexColumn, upperFirst, definedEntries, } from '../../util/index.js';
+import { entityName, entitySql, entityWhere, fieldOptionConflict, getKeys, hasKeys, isToManyRelation, lowerFirst, memberRefs, normalizeIndexColumn, upperFirst, definedEntries, } from '../../util/index.js';
 import { ownRegistrations } from '../decorator/bag.js';
 /**
  * A map held on `globalThis` through the global symbol registry, so a single one survives multiple
@@ -31,8 +31,14 @@ export function defineField(entity, key, opts = {}) {
     // Flagged when the author gave `references` but no `type`, so schema generation knows to resolve the
     // column from the referenced primary key (picking up its `columnType`, length and chained keys)
     // instead of treating whatever ends up in `type` as deliberate.
-    const resolved = opts.type ? opts : { ...opts, typeFromReference: true };
-    meta.fields[fieldKey] = { ...meta.fields[fieldKey], name: key, ...resolved };
+    const { computed, ...rest } = opts;
+    const resolved = rest.type ? rest : { ...rest, typeFromReference: true };
+    meta.fields[fieldKey] = {
+        ...meta.fields[fieldKey],
+        name: key,
+        ...resolved,
+        ...(computed && { computed: entitySql(computed) }),
+    };
     return meta;
 }
 export function defineId(entity, key, opts) {
@@ -50,8 +56,8 @@ export function defineRelation(entity, key, opts) {
 export function relationRegistration({ mappedBy, references, ...opts }) {
     return {
         ...opts,
-        ...(mappedBy ? { mappedBy: mappedBy(keyMap()) } : {}),
-        ...(references ? { references: [...references(keyMap(), keyMap())] } : {}),
+        ...(mappedBy && { mappedBy: mappedBy(keyMap()) }),
+        ...(references && { references: [...references(keyMap(), keyMap())] }),
     };
 }
 /** Every entity's key map: a callback only reads one property off it, and that property is its own key. */
@@ -77,26 +83,22 @@ function addRelation(entity, key, registration) {
 }
 export function defineHook(entity, methodName, event) {
     const meta = ensureWritableMeta(entity);
-    if (!meta.hooks)
-        meta.hooks = {};
-    if (!meta.hooks[event])
-        meta.hooks[event] = [];
-    meta.hooks[event].push({ methodName });
+    ((meta.hooks ??= {})[event] ??= []).push({ methodName });
     return meta;
 }
 /**
- * Declares a composite index, its columns read off the key map. `unique` and the authored column sugar
- * are normalized here, which is what lets the dialects render one shape instead of re-parsing it.
+ * Declares a composite index, its columns read off the entity's refs. `unique` and the authored column
+ * sugar are normalized here, which is what lets the dialects render one shape instead of re-parsing it.
  */
 export function defineIndex(entity, index) {
     const meta = ensureWritableMeta(entity);
-    const keys = keyMap();
+    const refs = memberRefs();
     (meta.indexes ??= []).push({
         ...index,
         unique: index.unique ?? false,
-        where: ddlText(index.where, 'a partial-index predicate'),
-        columns: index.columns(keys).map(normalizeIndexColumn),
-        include: index.include?.(keys),
+        where: index.where && entityWhere(index.where),
+        columns: index.columns(refs).map(normalizeIndexColumn),
+        include: index.include?.(refs).map((ref) => ref.key),
     });
     return meta;
 }
@@ -108,9 +110,7 @@ export function defineFilter(entity, name, opts) {
     if (opts.security && opts.onMissing === 'skip') {
         throw TypeError(`'${entity.name}' security filter '${name}' cannot use onMissing: 'skip' (it must fail closed)`);
     }
-    if (!meta.filters)
-        meta.filters = {};
-    meta.filters[name] = opts;
+    (meta.filters ??= {})[name] = opts;
     return meta;
 }
 /**
@@ -161,7 +161,7 @@ export function defineEntity(entity, opts = {}) {
     });
     // Unnamed checks are named by the generator, as unnamed indexes are.
     for (const check of opts.checks ?? []) {
-        (meta.checks ??= []).push({ name: check.name, expression: ddlText(check.expression, 'a check constraint') });
+        (meta.checks ??= []).push({ name: check.name, where: entityWhere(check.where) });
     }
     for (const index of opts.indexes ?? []) {
         defineIndex(entity, index);
@@ -202,9 +202,7 @@ export function defineEntity(entity, opts = {}) {
     }
     if (softDeleteKeys.length) {
         meta.softDelete = softDeleteKeys[0];
-        if (!meta.filters)
-            meta.filters = {};
-        meta.filters[SOFT_DELETE_FILTER] = { condition: { [meta.softDelete]: null }, default: true };
+        (meta.filters ??= {})[SOFT_DELETE_FILTER] = { where: { [meta.softDelete]: null }, default: true };
     }
     const ids = getIdKeys(meta);
     if (!ids.length) {
@@ -500,10 +498,9 @@ function extendMeta(target, source) {
     }
     // Merge hooks from parent entity (parent hooks execute first)
     if (source.hooks) {
-        if (!target.hooks)
-            target.hooks = {};
+        const hooks = (target.hooks ??= {});
         for (const [event, sourceList] of definedEntries(source.hooks)) {
-            target.hooks[event] = [...sourceList, ...(target.hooks[event] ?? [])];
+            hooks[event] = [...sourceList, ...(hooks[event] ?? [])];
         }
     }
 }

package/dist/libsql/libsqlDialect.d.ts

@@ -12,7 +12,7 @@ export declare class LibsqlDialect extends SqliteDialect {
      * functions this dialect would otherwise inherit are never present.
      *
      * @remarks `inner` and `l1` are left out: `vector_distance_dot` only exists in the newer Rust
-     * engine (see `TursoDialect`) and no libSQL build has an L1 metric. Both raise the same
+     * engine (see `TursoLocalDialect`) and no libSQL build has an L1 metric. Both raise the same
      * "does not support vector distance metric" error as any other unsupported metric.
      */
     readonly vectorMetrics: ReadonlyMap<VectorDistance, VectorMetric>;

package/dist/libsql/libsqlDialect.js

@@ -11,7 +11,7 @@ export class LibsqlDialect extends SqliteDialect {
      * functions this dialect would otherwise inherit are never present.
      *
      * @remarks `inner` and `l1` are left out: `vector_distance_dot` only exists in the newer Rust
-     * engine (see `TursoDialect`) and no libSQL build has an L1 metric. Both raise the same
+     * engine (see `TursoLocalDialect`) and no libSQL build has an L1 metric. Both raise the same
      * "does not support vector distance metric" error as any other unsupported metric.
      */
     vectorMetrics = new Map([

package/dist/libsql/libsqlQuerierPool.d.ts

@@ -1,19 +1,28 @@
 import type { Config } from '@libsql/client';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { type HranaClient, HranaQuerier } from '../sqlite/hranaQuerier.js';
-import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import type { ExtraOptions } from '../type/index.js';
 import { LibsqlDialect } from './libsqlDialect.js';
-/** Embedded replica: local `file:` DB + `syncUrl` remote - DDL should run on the remote (sqld). */
-export declare function libsqlUseRemoteForMigrations(config: Pick<Config, 'url' | 'syncUrl'>): boolean;
-export declare class LibsqlQuerierPool extends AbstractHranaQuerierPool<LibsqlDialect> {
+/**
+ * Pool for libSQL. One client serves every querier, since Hrana keeps no per-connection state: a
+ * transaction takes its own session handle. The pool builds that client from `@libsql/client`'s
+ * `Config`, or shares one the caller built (`@libsql/client/web`, `@libsql/client-wasm`), which stays
+ * theirs to close.
+ */
+export declare class LibsqlQuerierPool extends AbstractSharedHandleQuerierPool<HranaClient, HranaQuerier, LibsqlDialect> {
     private readonly conf;
-    constructor(conf: Config, extra?: ExtraOptions);
-    protected openClient(): Promise<HranaClient>;
+    constructor(conf: Config | HranaClient, extra?: ExtraOptions);
+    protected openDb(): Promise<HranaClient>;
+    protected buildQuerier(client: HranaClient): HranaQuerier;
+    end(): Promise<void>;
     /**
-     * For embedded replicas (`file:` + `syncUrl`), returns a querier connected to `syncUrl` so migrations hit sqld.
-     * Otherwise same as `getQuerier`. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
+     * For an embedded replica - a `file:` url with a `syncUrl` - a querier on the sync url, so migrations
+     * reach sqld, its client closing with it. Anything else migrates like any other querier.
      */
     getMigrationQuerier(): Promise<HranaQuerier>;
-    /** Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed. */
+    /**
+     * Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed.
+     * Integers read as `bigint` whatever the config asks, so the querier decodes one past 2^53 exactly.
+     */
     private createClient;
 }

package/dist/libsql/libsqlQuerierPool.js

@@ -1,39 +1,51 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { HranaQuerier } from '../sqlite/hranaQuerier.js';
-import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import { LibsqlDialect } from './libsqlDialect.js';
-/** Embedded replica: local `file:` DB + `syncUrl` remote - DDL should run on the remote (sqld). */
-export function libsqlUseRemoteForMigrations(config) {
-    return Boolean(config.syncUrl && config.url.startsWith('file:'));
-}
-/** Remote-only client: same options as the replica, but `url` is `syncUrl` and embedded-replica fields are dropped. */
-function remoteMigrationClientConfig(config) {
-    const { syncUrl, url: _localUrl, ...rest } = config;
-    return { ...rest, url: syncUrl };
-}
-export class LibsqlQuerierPool extends AbstractHranaQuerierPool {
+/**
+ * Pool for libSQL. One client serves every querier, since Hrana keeps no per-connection state: a
+ * transaction takes its own session handle. The pool builds that client from `@libsql/client`'s
+ * `Config`, or shares one the caller built (`@libsql/client/web`, `@libsql/client-wasm`), which stays
+ * theirs to close.
+ */
+export class LibsqlQuerierPool extends AbstractSharedHandleQuerierPool {
     conf;
     constructor(conf, extra) {
         super(new LibsqlDialect(dialectOptionsFrom(extra)), extra);
         this.conf = conf;
     }
-    openClient() {
-        return this.createClient(this.conf);
+    async openDb() {
+        return 'execute' in this.conf ? this.conf : this.createClient(this.conf);
+    }
+    buildQuerier(client) {
+        return new HranaQuerier(client, this.dialect, this.extra);
+    }
+    async end() {
+        if (!('execute' in this.conf)) {
+            await super.end();
+        }
     }
     /**
-     * For embedded replicas (`file:` + `syncUrl`), returns a querier connected to `syncUrl` so migrations hit sqld.
-     * Otherwise same as `getQuerier`. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
+     * For an embedded replica - a `file:` url with a `syncUrl` - a querier on the sync url, so migrations
+     * reach sqld, its client closing with it. Anything else migrates like any other querier.
      */
     async getMigrationQuerier() {
-        if (!libsqlUseRemoteForMigrations(this.conf)) {
+        if ('execute' in this.conf) {
             return this.getQuerier();
         }
-        const remote = await this.createClient(remoteMigrationClientConfig(this.conf));
-        return new HranaQuerier(remote, this.dialect, this.extra, { closeClientOnRelease: true });
+        const { syncUrl, url, ...remote } = this.conf;
+        if (!syncUrl || !url.startsWith('file:')) {
+            return this.getQuerier();
+        }
+        const client = await this.createClient({ ...remote, url: syncUrl });
+        return new HranaQuerier(client, this.dialect, this.extra, { closeClientOnRelease: true });
     }
-    /** Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed. */
+    /**
+     * Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed.
+     * Integers read as `bigint` whatever the config asks, so the querier decodes one past 2^53 exactly.
+     */
     async createClient(conf) {
         const { createClient } = await import('@libsql/client');
-        return createClient(conf);
+        return createClient({ ...conf, intMode: 'bigint' });
     }
 }

package/dist/migrate/builder/migrationBuilder.js

@@ -5,7 +5,7 @@
  * - OperationRecorder: Record operations only (for code generation)
  * - MigrationBuilder: Execute DDL operations (for integration tests/runtime)
  */
-import { ddlText, normalizeIndexColumn } from '../../util/index.js';
+import { indexNameParts, normalizeIndexColumn } from '../../util/index.js';
 import { derivedIndexName } from '../../util/sql.util.js';
 import { createSchemaGenerator } from '../schemaGenerator.js';
 import { splitSqlStatements } from './splitSqlStatements.js';
@@ -23,9 +23,7 @@ function createIndexOperation(tableName, columns, options = {}) {
         tableName,
         index: {
             ...index,
-            name: name ??
-                derivedIndexName(tableName, entries.map((entry) => entry.column)),
-            where: ddlText(index.where, 'a partial-index predicate'),
+            name: name ?? derivedIndexName(tableName, indexNameParts(entries)),
             entries,
             unique: unique ?? false,
         },
@@ -310,7 +308,7 @@ export class MigrationBuilder extends OperationRecorder {
             case 'alterColumn':
                 return this.sqlGenerator.generateAlterColumnSql(operation.tableName, operation.columnName, operation.changes);
             case 'createIndex':
-                return this.sqlGenerator.generateCreateIndex(operation.tableName, operation.index);
+                return this.sqlGenerator.generateCreateIndexFromDefinition(operation.tableName, operation.index);
             case 'dropIndex':
                 return this.sqlGenerator.generateDropIndex(operation.tableName, operation.indexName);
             case 'addForeignKey':

package/dist/migrate/builder/tableBuilder.js

@@ -3,7 +3,7 @@
  *
  * Fluent API for defining tables in migrations.
  */
-import { ddlText, normalizeIndexColumn } from '../../util/index.js';
+import { indexNameParts, normalizeIndexColumn } from '../../util/index.js';
 import { derivedIndexName } from '../../util/sql.util.js';
 import { columnForeignKey, columnIndex } from '../generator/definitionToNode.js';
 import { ColumnBuilder } from './columnBuilder.js';
@@ -171,9 +171,7 @@ export class TableBuilder {
         const entries = columns.map(normalizeIndexColumn);
         this._indexes.push({
             ...rest,
-            name: name ??
-                derivedIndexName(this._name, entries.map((entry) => entry.column), unique),
-            where: ddlText(rest.where, 'a partial-index predicate'),
+            name: name ?? derivedIndexName(this._name, indexNameParts(entries), unique),
             entries,
             unique,
         });

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

@@ -5,7 +5,7 @@
  * Enables type-safe migrations without raw SQL.
  */
 import type { ColumnNode, EnumValues, ForeignKeyAction } from '../../schema/types.js';
-import type { IndexColumnInput, IndexOptions, IndexSchema } from '../../type/index.js';
+import type { EntityIndexColumn, Except, IndexColumnInput, IndexOptions, IndexSchema, QueryRaw } from '../../type/index.js';
 import type { ForeignKeySchema } from '../../type/migration.js';
 /**
  * Foreign key reference options.
@@ -91,6 +91,14 @@ export interface FullColumnDefinition extends ColumnDefinition {
     /** Index name (if indexed) */
     index?: string | boolean;
 }
+/**
+ * An index as the builder records it, with the entries and options `@Index` takes: its SQL kept as `raw`
+ * until a generator renders it for the engine the migration runs on.
+ */
+export type IndexDefinition = Except<IndexSchema, 'entries' | 'where'> & {
+    readonly entries: readonly EntityIndexColumn[];
+    readonly where?: QueryRaw;
+};
 /**
  * Complete table definition.
  */
@@ -102,7 +110,7 @@ export interface TableDefinition {
     /** Primary key columns (for composite keys) */
     primaryKey?: string[];
     /** Index definitions */
-    indexes: IndexSchema[];
+    indexes: IndexDefinition[];
     /** Foreign key definitions at table level */
     foreignKeys: ForeignKeySchema[];
     /** Table comment */
@@ -183,7 +191,7 @@ export interface RenameColumnOperation extends MigrationOperation {
 export interface CreateIndexOperation extends MigrationOperation {
     type: 'createIndex';
     tableName: string;
-    index: IndexSchema;
+    index: IndexDefinition;
     ifNotExists?: boolean;
 }
 /**

package/dist/migrate/codegen/index.d.ts

@@ -5,4 +5,4 @@
  */
 export { createEntityCodeGenerator, EntityCodeGenerator, type EntityCodeGeneratorOptions, type GeneratedEntity, } from './entityCodeGenerator.js';
 export { entityTypesSource } from './entityTypes.js';
-export { buildMigrationModule, buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, type MigrationModuleOptions, type MigrationQuerierType, type SqlMigrationModuleOptions, } from './migrationFile.js';
+export { buildMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, type MigrationModuleOptions, type MigrationQuerierType, } from './migrationFile.js';

package/dist/migrate/codegen/index.js

@@ -6,4 +6,4 @@
 // Entity code generator
 export { createEntityCodeGenerator, EntityCodeGenerator, } from './entityCodeGenerator.js';
 export { entityTypesSource } from './entityTypes.js';
-export { buildMigrationModule, buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';
+export { buildMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitMongoCommandCalls, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';

package/dist/migrate/codegen/indexDecoratorSource.d.ts

@@ -7,7 +7,7 @@ import type { IndexNode } from '../../schema/types.js';
 export declare function isPlainFieldIndex(index: IndexNode): boolean;
 /**
  * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
- * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * refs `param` names. Emits `raw` for an expression entry, so callers import `raw` when
  * {@link indexNeedsRaw} holds.
  */
 export declare function buildIndexDecoratorSource(index: IndexNode, propertyName: (column: string) => string, param: string): string;

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,3 +1,4 @@
+import { isVectorIndexType } from '../../type/index.js';
 import { isIdentifierName, quoted, rawTag } from './sourceLiteral.js';
 /**
  * A vector index carries its metric in the operator class pgvector names after it
@@ -54,12 +55,12 @@ export function isPlainFieldIndex(index) {
 }
 /**
  * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
- * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * refs `param` names. Emits `raw` for an expression entry, so callers import `raw` when
  * {@link indexNeedsRaw} holds.
  */
 export function buildIndexDecoratorSource(index, propertyName, param) {
     const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName, param)).join(', ');
-    const isVector = index.type === 'hnsw' || index.type === 'ivfflat';
+    const isVector = isVectorIndexType(index.type);
     const distance = isVector ? vectorDistance(index) : undefined;
     const options = [];
     if (index.name)
@@ -88,10 +89,7 @@ export function indexNeedsRaw(index) {
     return Boolean(index.where) || index.entries.some((entry) => entry.expression);
 }
 function indexEntrySource(entry, propertyName, param) {
-    if (entry.expression) {
-        return rawTag(entry.column);
-    }
-    const column = memberSource(param, propertyName(entry.column));
+    const column = entry.expression ? rawTag(entry.column) : memberSource(param, propertyName(entry.column));
     const modifiers = significantModifiers(entry);
     return modifiers.length === 0 ? column : `{ column: ${column}, ${modifiers.join(', ')} }`;
 }

package/dist/migrate/codegen/migrationFile.d.ts

@@ -15,8 +15,6 @@ export type MigrationModuleOptions = {
     /** Indented body inside `async down` (including newlines). */
     downInner: string;
 };
-/** @deprecated Use {@link MigrationModuleOptions}. */
-export type SqlMigrationModuleOptions = MigrationModuleOptions;
 /**
  * Emit one `await querier.run(...)` line for entity-generated migrations.
  * Uses `JSON.stringify` so SQL with backticks (SQLite/LibSQL), quotes, `${`, etc. stays valid TS source.
@@ -47,5 +45,3 @@ export declare const migrationSource: {
  * Full contents of a `export default { async up/down(querier) { ... } }` migration module.
  */
 export declare function buildMigrationModule(options: MigrationModuleOptions): string;
-/** @deprecated Use {@link buildMigrationModule}. */
-export declare const buildSqlQuerierMigrationModule: typeof buildMigrationModule;

package/dist/migrate/codegen/migrationFile.js

@@ -65,5 +65,3 @@ ${options.downInner}
 };
 `;
 }
-/** @deprecated Use {@link buildMigrationModule}. */
-export const buildSqlQuerierMigrationModule = buildMigrationModule;

package/dist/migrate/generator/definitionToNode.d.ts

@@ -1,12 +1,13 @@
 import type { ColumnNode, TableNode } from '../../schema/types.js';
 import type { ForeignKeySchema, IndexSchema } from '../../type/migration.js';
-import type { FullColumnDefinition, TableDefinition } from '../builder/types.js';
+import type { QueryRaw } from '../../type/queryRaw.js';
+import type { FullColumnDefinition, IndexDefinition, TableDefinition } from '../builder/types.js';
 /**
  * A migration builder's table definition as the AST nodes the generators render from, so a hand-written
- * `createTable` and an entity reach `generateCreateTableFromNode` in the same shape. Free functions and
- * not generator methods: nothing here consults the dialect.
+ * `createTable` and an entity reach `generateCreateTableFromNode` in the same shape, its SQL rendered by
+ * `render`. Free functions and not generator methods: the dialect reaches them only through `render`.
  */
-export declare function tableDefinitionToNode(def: TableDefinition): TableNode;
+export declare function tableDefinitionToNode(def: TableDefinition, render: (sql: QueryRaw) => string): TableNode;
 /**
  * A builder's column as the AST node the generators render from.
  *
@@ -25,6 +26,8 @@ export declare function fullColumnDefinitionToNode(col: FullColumnDefinition, ta
  * Shared with `TableBuilder.build`, which lifts these into the table it is creating: written twice,
  * `addColumn` had no lift at all and silently emitted a column with no index.
  */
-export declare function columnIndex(tableName: string, col: FullColumnDefinition): IndexSchema | undefined;
+export declare function columnIndex(tableName: string, col: FullColumnDefinition): Pick<IndexSchema, 'name' | 'entries' | 'unique'> | undefined;
+/** An index the builder recorded, its SQL rendered by `render` into the text the schema holds. */
+export declare function renderIndexDefinition(index: IndexDefinition, render: (sql: QueryRaw) => string): IndexSchema;
 /** The foreign key a column-level `references` declares, or nothing. Shared for the same reason. */
 export declare function columnForeignKey(col: FullColumnDefinition): ForeignKeySchema | undefined;

package/dist/migrate/generator/definitionToNode.js

@@ -1,3 +1,4 @@
+import { renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { derivedForeignKeyName, derivedIndexName } from '../../util/sql.util.js';
 /**
  * A table the builder names but has not seen.
@@ -12,10 +13,10 @@ function unresolvedTable(name) {
 }
 /**
  * A migration builder's table definition as the AST nodes the generators render from, so a hand-written
- * `createTable` and an entity reach `generateCreateTableFromNode` in the same shape. Free functions and
- * not generator methods: nothing here consults the dialect.
+ * `createTable` and an entity reach `generateCreateTableFromNode` in the same shape, its SQL rendered by
+ * `render`. Free functions and not generator methods: the dialect reaches them only through `render`.
  */
-export function tableDefinitionToNode(def) {
+export function tableDefinitionToNode(def, render) {
     const columns = new Map();
     const pkNodes = [];
     const table = {
@@ -40,7 +41,7 @@ export function tableDefinitionToNode(def) {
         : pkNodes;
     table.primaryKey = finalPrimaryKey;
     for (const idxDef of def.indexes) {
-        table.indexes.push({ ...idxDef, table });
+        table.indexes.push({ ...renderIndexDefinition(idxDef, render), table });
     }
     for (const fkDef of def.foreignKeys) {
         const relNode = {
@@ -92,6 +93,14 @@ export function columnIndex(tableName, col) {
         unique: col.isUnique,
     };
 }
+/** An index the builder recorded, its SQL rendered by `render` into the text the schema holds. */
+export function renderIndexDefinition(index, render) {
+    return {
+        ...index,
+        entries: index.entries.map((entry) => renderIndexColumn(entry, render)),
+        where: index.where && render(index.where),
+    };
+}
 /** The foreign key a column-level `references` declares, or nothing. Shared for the same reason. */
 export function columnForeignKey(col) {
     if (!col.foreignKey) {

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -8,6 +8,8 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
     protected readonly featureDefaults: import("../../type/dialect.js").DialectFeatures;
     readonly insertIdSource: InsertIdSource;
     constructor(namingStrategy?: NamingStrategy, defaultForeignKeyAction?: ForeignKeyAction | undefined);
+    /** A collection has no SQL to render a check, a computed column or an index expression into. */
+    compileDdl(): string;
     /**
      * A document store has no cross-collection constraint, so unlike the SQL generator there is nothing to
      * defer and no order to respect: this is each collection and nothing more. `foreignKeys` is accepted

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -3,6 +3,7 @@ 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 { renderIndexDefinition } from './definitionToNode.js';
 import { indexNodeToSchema } from './indexNodeToSchema.js';
 import { serializeMongoCommand } from './mongoCommand.js';
 export class MongoSchemaGenerator extends AbstractDialect {
@@ -14,6 +15,10 @@ export class MongoSchemaGenerator extends AbstractDialect {
         super({ namingStrategy });
         this.defaultForeignKeyAction = defaultForeignKeyAction;
     }
+    /** A collection has no SQL to render a check, a computed column or an index expression into. */
+    compileDdl() {
+        throw new TypeError('mongodb has no SQL to render a check, a computed column or an index expression into');
+    }
     /**
      * A document store has no cross-collection constraint, so unlike the SQL generator there is nothing to
      * defer and no order to respect: this is each collection and nothing more. `foreignKeys` is accepted
@@ -135,7 +140,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
     generateCreateTableFromDefinition(table, _options) {
         return [
             serializeMongoCommand({ action: 'createCollection', name: table.name }),
-            ...table.indexes.map((index) => this.generateCreateIndex(table.name, index)),
+            ...table.indexes.map((index) => this.generateCreateIndex(table.name, renderIndexDefinition(index, () => this.compileDdl()))),
         ];
     }
     generateRenameTableSql(oldName, newName) {

package/dist/migrate/schemaGenerator.d.ts

@@ -2,8 +2,8 @@ import type { AbstractSqlDialect } from '../dialect/index.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
 import { type DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
-import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, MigratorDialect, NamingStrategy, SchemaDiff, SchemaGenerator, SqlDdlGenerator, Type } from '../type/index.js';
-import type { FullColumnDefinition, TableDefinition } from './builder/types.js';
+import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, EntityWhereMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, MigratorDialect, NamingStrategy, SchemaDiff, SchemaGenerator, SqlDdlGenerator, Type } from '../type/index.js';
+import type { FullColumnDefinition, IndexDefinition, TableDefinition } from './builder/types.js';
 import { type IndexDdl, type TableDdl } from './ddl/index.js';
 /**
  * Unified SQL schema generator.
@@ -23,6 +23,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     resolveTableAlias<E>(meta: EntityMeta<E>): string;
     resolveSchema<E>(meta: EntityMeta<E>): string | undefined;
     resolveColumnName(key: string, field: FieldOptions): string;
+    compileDdl(sql: EntityWhereMeta<object>, entity: Type<object>): string;
     /** Escape an identifier (table name, column name, etc.) */
     protected escapeId(identifier: string): string;
     /**
@@ -165,6 +166,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     generateCreateTableFromDefinition(table: TableDefinition, options?: {
         ifNotExists?: boolean;
     }): string[];
+    generateCreateIndexFromDefinition(tableName: string, index: IndexDefinition): string;
     generateRenameTableSql(oldName: string, newName: string): string;
     /**
      * `ADD COLUMN`, plus the constraint and index the column declares.
@@ -217,7 +219,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, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName'>, entities: readonly Type<object>[], defaultForeignKeyAction?: ForeignKeyAction): SchemaAST;
+export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName' | 'compileDdl'>, entities: readonly Type<object>[], 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.

package/dist/migrate/schemaGenerator.js

@@ -8,7 +8,7 @@ import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName } from '
 import { formatDefaultValue, SqlExpression } from './builder/expressions.js';
 import { indexDdlFor, tableDdlFor } from './ddl/index.js';
 import { sizedType } from './ddl/tableDdl.js';
-import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, tableDefinitionToNode, } from './generator/definitionToNode.js';
+import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, renderIndexDefinition, tableDefinitionToNode, } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 /**
  * Unified SQL schema generator.
@@ -45,6 +45,9 @@ export class SqlSchemaGenerator {
     resolveColumnName(key, field) {
         return this.dialect.resolveColumnName(key, field);
     }
+    compileDdl(sql, entity) {
+        return this.dialect.compileDdl(sql, entity);
+    }
     /** Escape an identifier (table name, column name, etc.) */
     escapeId(identifier) {
         return this.dialect.escapeId(identifier);
@@ -565,9 +568,12 @@ export class SqlSchemaGenerator {
         return this.generateCreateIndex(qualifyName(index.table.name, index.table.schema), indexNodeToSchema(index), options);
     }
     generateCreateTableFromDefinition(table, options = {}) {
-        const tableNode = tableDefinitionToNode(table);
+        const tableNode = tableDefinitionToNode(table, (sql) => this.dialect.compileDdl(sql));
         return this.generateCreateTableFromNode(tableNode, options);
     }
+    generateCreateIndexFromDefinition(tableName, index) {
+        return this.generateCreateIndex(tableName, renderIndexDefinition(index, (sql) => this.dialect.compileDdl(sql)));
+    }
     generateRenameTableSql(oldName, newName) {
         return this.tableDdl.renameTable(oldName, newName);
     }
@@ -719,6 +725,7 @@ export function buildEntityAST(generator, entities, defaultForeignKeyAction) {
         resolveTableName: (meta) => generator.resolveTableAlias(meta),
         resolveSchema: (meta) => generator.resolveSchema(meta),
         resolveColumnName: (key, field) => generator.resolveColumnName(key, field),
+        compileDdl: (sql, entity) => generator.compileDdl(sql, entity),
         defaultForeignKeyAction,
     });
 }

package/dist/mongo/mongoDialect.js

@@ -263,7 +263,7 @@ export class MongoDialect extends AbstractDialect {
      * lock silently removes the mutual exclusion the caller asked for.
      */
     assertNoLock(q) {
-        if (q.$lock !== undefined) {
+        if (q.$lock) {
             throw new TypeError('$lock (row-level locking) is not supported on MongoDB');
         }
     }