uql-orm 0.60.0 → 0.62.0

package/dist/dialect/pgLikeSqlDialect.js

@@ -126,7 +126,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
             .map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])))
             .join(` || ' ' || `);
         // The config is bound once and its numbered placeholder reused by both calls.
-        const config = search.$config ? `${this.addValue(ctx.values, search.$config)}::regconfig, ` : '';
+        const config = search.$config ? `${this.addValue(ctx, search.$config)}::regconfig, ` : '';
         ctx.append(`TO_TSVECTOR(${config}${fields}) @@ WEBSEARCH_TO_TSQUERY(${config}`);
         ctx.addValue(search.$value);
         ctx.append(')');
@@ -158,10 +158,11 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
     get neOp() {
         return 'IS DISTINCT FROM';
     }
+    /** One array parameter, which a context that inlines values has none of: it lists them instead. */
     formatIn(ctx, values, negate) {
-        if (values.length === 0)
-            return negate ? ' NOT IN (NULL)' : ' IN (NULL)';
-        const ph = this.addValue(ctx.values, values);
+        if (values.length === 0 || ctx.inlineValues)
+            return super.formatIn(ctx, values, negate);
+        const ph = this.addValue(ctx, values);
         return negate ? ` <> ALL(${ph})` : ` = ANY(${ph})`;
     }
     numericCast(expr) {
@@ -210,7 +211,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         }, expr);
     }
     jsonUnset(ctx, expr, unset) {
-        return `(${expr}) - ${this.addValue(ctx.values, [...unset])}::text[]`;
+        return `(${expr}) - ${this.addValue(ctx, [...unset])}::text[]`;
     }
     /** Postgres binds JSON with a numbered placeholder and an explicit cast, per driver capability. */
     jsonScalarParam(ctx, value) {
@@ -223,9 +224,9 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         if (value instanceof QueryRaw)
             return this.rawFragment(ctx, value);
         if (value == null)
-            return `${this.addValue(ctx.values, null)}::${type}`;
+            return `${this.addValue(ctx, null)}::${type}`;
         const json = JSON.stringify(value);
-        const ph = this.addValue(ctx.values, json);
+        const ph = this.addValue(ctx, json);
         return this.features.explicitJsonCast ? `(${ph}::text)::${type}` : `${ph}::${type}`;
     }
 }

package/dist/dialect/queryContext.d.ts

@@ -9,6 +9,7 @@ import type { QueryContext, QueryDialect } from '../type/index.js';
 export declare class SqlQueryContext implements QueryContext {
     readonly dialect: QueryDialect;
     private readonly statement?;
+    readonly inlineValues: boolean;
     private readonly sqlChunks;
     private readonly params;
     private readonly tableAliases;
@@ -20,8 +21,9 @@ export declare class SqlQueryContext implements QueryContext {
      * 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: QueryDialect, params?: unknown[], statement?: SqlQueryContext | undefined);
+    constructor(dialect: QueryDialect, params?: unknown[], statement?: SqlQueryContext | undefined, inlineValues?: boolean);
     createFragment(): QueryContext;
     /**
      * Appends raw SQL string fragments to the query.
@@ -31,11 +33,8 @@ export declare class SqlQueryContext implements QueryContext {
      */
     append(sql: string): 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: unknown): this;
     /**

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/http/contract.d.ts

@@ -86,7 +86,7 @@ export type RequestErrorResponse = {
 };
 /**
  * Map a thrown error to the wire error envelope. Honors a numeric `status` on the error
- * (e.g. hooks throwing 403), defaults to 500; `code` mirrors the HTTP status.
+ * (e.g. hooks throwing 403), then a constraint violation (409/400), defaults to 500; `code` mirrors the HTTP status.
  */
 export declare function toErrorResponse(err: unknown): {
     status: number;

package/dist/http/contract.js

@@ -1,3 +1,4 @@
+import { queryErrorKind } from '../querier/queryError.js';
 // the specific util modules, not the barrel, so the browser bundle does not pull in entity metadata
 import { getKeys } from '../util/object.util.js';
 import { kebabCase } from '../util/string.util.js';
@@ -59,12 +60,23 @@ export function matchRoute(method, subPath) {
     }
     return idOp && subPath !== undefined ? { op: idOp, method: CRUD_ROUTES[idOp].method, id: subPath } : undefined;
 }
+/** Generic on purpose: a driver's constraint message names tables and constraints, and Postgres echoes the value. */
+const CONSTRAINT_ERRORS = new Map([
+    ['uniqueViolation', { message: 'Conflict', code: 409 }],
+    ['foreignKeyViolation', { message: 'Conflict', code: 409 }],
+    ['notNullViolation', { message: 'Bad Request', code: 400 }],
+    ['checkViolation', { message: 'Bad Request', code: 400 }],
+]);
 /**
  * Map a thrown error to the wire error envelope. Honors a numeric `status` on the error
- * (e.g. hooks throwing 403), defaults to 500; `code` mirrors the HTTP status.
+ * (e.g. hooks throwing 403), then a constraint violation (409/400), defaults to 500; `code` mirrors the HTTP status.
  */
 export function toErrorResponse(err) {
-    const status = err instanceof Error && 'status' in err && typeof err.status === 'number' ? err.status : 500;
-    const message = err instanceof Error ? err.message : 'Internal Server Error';
-    return { status, body: { error: { message, code: status } } };
+    const error = err instanceof Error && 'status' in err && typeof err.status === 'number'
+        ? { message: err.message, code: err.status }
+        : (CONSTRAINT_ERRORS.get(queryErrorKind(err)) ?? {
+            message: err instanceof Error ? err.message : 'Internal Server Error',
+            code: 500,
+        });
+    return { status: error.code, body: { error } };
 }

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;