uql-orm 0.61.0 → 0.62.0

package/dist/dialect/queryContext.js

@@ -8,6 +8,7 @@
 export class SqlQueryContext {
     dialect;
     statement;
+    inlineValues;
     sqlChunks = [];
     params;
     tableAliases = new Set();
@@ -19,14 +20,16 @@ export class SqlQueryContext {
      * than needing to be reconciled after the fact.
      * @param statement The context this one renders a fragment of, which owns the claimed aliases: a
      * fragment is part of one statement, so its aliases have to be unique across the whole of it.
+     * @param inlineValues See {@link QueryContext.inlineValues}; a fragment takes its statement's.
      */
-    constructor(dialect, params = [], statement) {
+    constructor(dialect, params = [], statement, inlineValues = false) {
         this.dialect = dialect;
         this.statement = statement;
+        this.inlineValues = inlineValues;
         this.params = params;
     }
     createFragment() {
-        return new SqlQueryContext(this.dialect, this.params, this.statement ?? this);
+        return new SqlQueryContext(this.dialect, this.params, this.statement ?? this, this.inlineValues);
     }
     /**
      * Appends raw SQL string fragments to the query.
@@ -41,14 +44,11 @@ export class SqlQueryContext {
         return this;
     }
     /**
-     * Adds a value to the query parameters and appends its corresponding placeholder to the SQL.
-     * The placeholder format is determined by the dialect (e.g., '?' or '$1').
-     *
-     * @param value The value to be parameterized.
-     * @returns The current context instance for method chaining.
+     * Appends the SQL the dialect writes for `value`: a placeholder for the value bound, or its literal
+     * where this context inlines values.
      */
     addValue(value) {
-        this.sqlChunks.push(this.dialect.addValue(this.params, value));
+        this.sqlChunks.push(this.dialect.addValue(this, value));
         return this;
     }
     /**

package/dist/entity/decorator/entity.d.ts

@@ -12,7 +12,7 @@ export declare function Entity<E>(opts?: EntityOptions<E>): (entity: Type<E>, co
 /**
  * Registers a named `$where` filter, applied to every query unless bypassed via `QueryOptions.filters`.
  *
- * @example `@Filter('active', { condition: { status: 'active' }, default: false })`
+ * @example `@Filter('active', { where: { status: 'active' }, default: false })`
  */
 export declare function Filter<E>(name: string, opts: FilterOptions<E>): (entity: Type<E>) => void;
 /**
@@ -22,6 +22,6 @@ export declare function Filter<E>(name: string, opts: FilterOptions<E>): (entity
  *
  * @example `@Index((user) => [user.lastName, user.firstName], { name: 'users_fullname_idx' })`
  * @example `@Index((user) => [user.email], { unique: true })`
- * @example `@Index((user) => [user.status], { where: "status = 'active'" })`
+ * @example `@Index((user) => [user.email], { unique: true, where: { deletedAt: null } })`
  */
-export declare function Index<E>(columns: (keys: KeyMap<E>) => readonly IndexColumnInput<FieldKey<NoInfer<E>>, NoInfer<E>>[], options?: EntityIndexOptions<NoInfer<E>>): (entity: Type<E>) => void;
+export declare function Index<E>(columns: (keys: KeyMap<E>) => readonly IndexColumnInput<FieldKey<E>, E>[], options?: EntityIndexOptions<E>): (entity: Type<E>) => void;

package/dist/entity/decorator/entity.js

@@ -20,7 +20,7 @@ export function Entity(opts) {
 /**
  * Registers a named `$where` filter, applied to every query unless bypassed via `QueryOptions.filters`.
  *
- * @example `@Filter('active', { condition: { status: 'active' }, default: false })`
+ * @example `@Filter('active', { where: { status: 'active' }, default: false })`
  */
 export function Filter(name, opts) {
     return (entity) => {
@@ -34,7 +34,7 @@ export function Filter(name, opts) {
  *
  * @example `@Index((user) => [user.lastName, user.firstName], { name: 'users_fullname_idx' })`
  * @example `@Index((user) => [user.email], { unique: true })`
- * @example `@Index((user) => [user.status], { where: "status = 'active'" })`
+ * @example `@Index((user) => [user.email], { unique: true, where: { deletedAt: null } })`
  */
 export function Index(columns, options = {}) {
     return (entity) => {

package/dist/entity/decorator/members.d.ts

@@ -40,12 +40,13 @@ type EnumValue<Members, Declared> = Declared extends Members ? {
  *
  * @example `@Field({ type: String }) name?: string;`
  * @example `@Field({ references: () => User }) userId?: string;` (where `User.id` is a `uuid`)
+ * @example `@Field({ type: Number, computed: (line) => raw`${line.qty} * ${line.price}` }) total?: number;`
  */
-export declare function Field<O extends FieldOptions<DeclaredValue<O>> & ({
+export declare function Field<This, O extends FieldOptions<DeclaredValue<O>, This> & ({
     type: FieldType;
 } | {
     references: EntityGetter;
-}) & RejectUnknown<O, FieldOptions> & RejectIncompatible<O>>(opts: O): MemberDecorator<DeclaredValue<O> | undefined>;
+}) & RejectUnknown<O, FieldOptions> & RejectIncompatible<O>>(opts: O): MemberDecorator<DeclaredValue<O> | undefined, This>;
 /**
  * A key the type level cannot name, reported on each `@Id` that leaves it unnamed. Where no `idKey`
  * brand and no conventional name applies, `IdKey` falls back to every field, and `IdValue`,

package/dist/entity/decorator/members.js

@@ -8,6 +8,7 @@ import { memberRegistrations } from './bag.js';
  *
  * @example `@Field({ type: String }) name?: string;`
  * @example `@Field({ references: () => User }) userId?: string;` (where `User.id` is a `uuid`)
+ * @example `@Field({ type: Number, computed: (line) => raw`${line.qty} * ${line.price}` }) total?: number;`
  */
 export function Field(opts) {
     return (_value, context) => {

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, 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) {
@@ -94,7 +100,7 @@ export function defineIndex(entity, index) {
     (meta.indexes ??= []).push({
         ...index,
         unique: index.unique ?? false,
-        where: ddlText(index.where, 'a partial-index predicate'),
+        where: index.where && entityWhere(index.where),
         columns: index.columns(keys).map(normalizeIndexColumn),
         include: index.include?.(keys),
     });
@@ -161,7 +167,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);
@@ -204,7 +210,7 @@ export function defineEntity(entity, opts = {}) {
         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) {

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/indexDecoratorSource.js

@@ -89,7 +89,9 @@ export function indexNeedsRaw(index) {
 }
 function indexEntrySource(entry, propertyName, param) {
     if (entry.expression) {
-        return rawTag(entry.column);
+        const expression = `() => ${rawTag(entry.column)}`;
+        const modifiers = significantModifiers(entry);
+        return modifiers.length === 0 ? expression : `{ column: ${expression}, ${modifiers.join(', ')} }`;
     }
     const column = memberSource(param, propertyName(entry.column));
     const modifiers = significantModifiers(entry);

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');
         }
     }

package/dist/mssql/mssqlDialect.js

@@ -273,8 +273,7 @@ export class MsSqlDialect extends MergeSqlDialect {
      * scalar - which is why reading and writing need the two different binders here.
      */
     jsonScalarParam(ctx, value) {
-        return (this.#jsonCompound(ctx, value) ??
-            this.addValue(ctx.values, typeof value === 'boolean' ? JSON.stringify(value) : value));
+        return (this.#jsonCompound(ctx, value) ?? this.addValue(ctx, typeof value === 'boolean' ? JSON.stringify(value) : value));
     }
     /**
      * A value being *written* to a JSON path, which takes the type the driver sent: a `BIT` becomes a
@@ -286,7 +285,7 @@ export class MsSqlDialect extends MergeSqlDialect {
         if (compound) {
             return compound;
         }
-        const placeholder = this.addValue(ctx.values, value);
+        const placeholder = this.addValue(ctx, value);
         return typeof value === 'boolean' ? `CAST(${placeholder} AS BIT)` : placeholder;
     }
     /**
@@ -300,8 +299,7 @@ export class MsSqlDialect extends MergeSqlDialect {
         if (value === null || typeof value !== 'object') {
             return undefined;
         }
-        ctx.pushValue(JSON.stringify(value));
-        return `JSON_QUERY(${this.placeholder(ctx.values.length)})`;
+        return `JSON_QUERY(${this.addValue(ctx, JSON.stringify(value))})`;
     }
     /** An exploded element compares as text here, so `$elemMatch` always expands per field. */
     jsonContainmentIsPartial = false;

package/dist/schema/schemaASTBuilder.d.ts

@@ -6,7 +6,7 @@
  * - Database introspection results (TableSchema[])
  */
 import type { EntityGetter } from '../type/entity.js';
-import type { EntityMeta, FieldMeta, FieldOptions, Type } from '../type/index.js';
+import type { EntityMeta, EntityWhereMeta, FieldMeta, FieldOptions, Type } from '../type/index.js';
 import type { NamingStrategy } from '../type/namingStrategy.js';
 import { SchemaAST } from './schemaAST.js';
 import { type CanonicalType, type ForeignKeyAction } from './types.js';
@@ -24,6 +24,11 @@ export interface BuildSchemaASTOptions {
     namingStrategy?: NamingStrategy;
     /** Default action for foreign key ON DELETE and ON UPDATE clauses */
     defaultForeignKeyAction?: ForeignKeyAction;
+    /**
+     * The text of SQL an entity declares - a check, a stored computed column, an index expression or
+     * predicate - which only a dialect can render. `buildEntityAST` supplies it from the generator.
+     */
+    compileDdl?: (sql: EntityWhereMeta<object>, entity: Type<object>) => string;
 }
 /**
  * Build a SchemaAST from entity classes (decorated with `@Entity`, `@Field`, etc.).

package/dist/schema/schemaASTBuilder.js

@@ -6,7 +6,7 @@
  * - Database introspection results (TableSchema[])
  */
 import { getMeta, soleIdOf } from '../entity/metadata/definition.js';
-import { ddlText } from '../util/ddlExpression.util.js';
+import { indexNameParts, renderIndexColumn } from '../util/ddlExpression.util.js';
 import { isInlinedExpression } from '../util/field.util.js';
 import { isSoleIdField } from '../util/field.util.js';
 import { isAutoIncrement } from '../util/field.util.js';
@@ -30,6 +30,7 @@ export function buildSchemaAST(entities, options = {}) {
         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,
+        compileDdl: options.compileDdl ?? refuseDdl,
     };
     for (const pass of [addTableFromEntity, addRelationshipsFromEntity, addIndexesFromEntity]) {
         for (const entity of entities) {
@@ -38,6 +39,10 @@ export function buildSchemaAST(entities, options = {}) {
     }
     return ctx.ast;
 }
+/** The `compileDdl` of a build given no dialect, which has nothing to render an entity's SQL with. */
+function refuseDdl() {
+    throw new TypeError('building the schema of an entity that declares SQL (a check, a stored computed column, an index expression or predicate) needs a dialect to render it: pass `compileDdl`, as `buildEntityAST` does');
+}
 /**
  * Resolve the canonical type for a field, inheriting from the referenced
  * entity's primary key when the field is a foreign-key reference
@@ -78,7 +83,7 @@ function addTableFromEntity(ctx, meta) {
     const tableName = ctx.resolveTableName(meta);
     const table = createTableNode(tableName, ctx.resolveSchema(meta));
     const { columns, primaryKey } = table;
-    table.checks?.push(...(meta.checks ?? []));
+    table.checks?.push(...(meta.checks ?? []).map(({ name, where }) => ({ name, expression: ctx.compileDdl(where, meta.entity) })));
     // Add columns from fields
     for (const [key, field] of definedEntries(meta.fields)) {
         // An inlined expression has no column; a stored one is a column like any other.
@@ -98,7 +103,7 @@ function addTableFromEntity(ctx, meta) {
             isPrimaryKey,
             isAutoIncrement: isAutoIncrement(field, isSoleKey),
             isUnique: field.unique ?? false,
-            generatedAs: ddlText(field.computed, `the computed column '${columnName}'`),
+            generatedAs: field.computed && ctx.compileDdl(field.computed, meta.entity),
             comment: field.comment,
             enum: field.enum,
             table,
@@ -237,27 +242,23 @@ function resolveIncludeColumn(ctx, meta, column) {
 function addCompositeIndex(ctx, table, meta, idxMeta) {
     // An entry survives if it is an expression (nothing to resolve) or names a column that exists;
     // an index left with none is dropped, the same as one naming only unknown columns always was.
-    const entries = idxMeta.columns
-        .map((entry) => {
-        if (entry.expression)
-            return entry;
+    const resolved = idxMeta.columns.flatMap((entry) => {
+        if (typeof entry.column !== 'string')
+            return [entry];
         const field = meta.fields[entry.column];
         const column = field && ctx.resolveColumnName(entry.column, field);
-        return column && table.columns.has(column) ? { ...entry, column } : undefined;
-    })
-        .filter((entry) => entry !== undefined);
-    if (!entries.length)
+        return column && table.columns.has(column) ? [{ ...entry, column }] : [];
+    });
+    if (!resolved.length)
         return;
-    // 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 ?? derivedIndexName(table.name, named),
+        name: idxMeta.name ?? derivedIndexName(table.name, indexNameParts(resolved)),
         table,
-        entries,
+        entries: resolved.map((entry) => renderIndexColumn(entry, (sql) => ctx.compileDdl(sql, meta.entity))),
         include: idxMeta.include?.map((column) => resolveIncludeColumn(ctx, meta, column)),
         unique: idxMeta.unique ?? false,
         type: idxMeta.type,
-        where: idxMeta.where,
+        where: idxMeta.where && ctx.compileDdl(idxMeta.where, meta.entity),
         distance: idxMeta.distance,
         m: idxMeta.m,
         efConstruction: idxMeta.efConstruction,