uql-orm 0.79.0 → 0.81.0

package/dist/mssql/mssqlDialect.js

@@ -4,7 +4,7 @@ import { BYTES_PREFIX } from '../dialect/hydrateColumn.js';
 import { jsonArraySlotArgs, jsonPath, jsonSlotArgs } from '../dialect/jsonSql.js';
 import { MergeSqlDialect } from '../dialect/mergeSqlDialect.js';
 import { getMeta } from '../entity/index.js';
-import { fieldOptionsToCanonical } from '../schema/canonicalType.js';
+import { canonicalToSql, fieldOptionsToCanonical, resolveColumnCanonicalType } from '../schema/canonicalType.js';
 import { QueryRaw } from '../type/index.js';
 import { parseQueryLock } from '../type/index.js';
 import { isAutoIncrement } from '../util/field.util.js';
@@ -13,10 +13,8 @@ import { escapeSingleQuotes } from '../util/sqlLiteral.js';
 import { UqlUsageError } from '../util/uqlError.js';
 /** What SQL Server has. */
 const MSSQL_FEATURES = {
-    // Neither object takes an `IF NOT EXISTS`; both need a `sys` catalogue lookup around them, which
-    // the generator does not emit.
-    ifNotExists: false,
-    indexIfNotExists: false,
+    // No `IF NOT EXISTS` on an index, so `MsSqlIndexDdl` guards the create with a `sys.indexes` lookup.
+    indexIfNotExists: true,
     schemas: true,
     dropTableCascade: false,
     foreignKeyAlter: true,
@@ -40,6 +38,16 @@ const MSSQL_FEATURES = {
     narrowVectorTypes: false,
     vectorTuningNeedsTransaction: false,
     serialDeclaresPrimaryKey: false,
+    triggers: {
+        preamble: 'SET NOCOUNT ON;',
+        assignsRow: false,
+        body: 'inline',
+        guards: 'beginEnd',
+        layout: 'tableFirst',
+        rows: 'set',
+        scope: 'schema',
+        before: false,
+    },
 };
 /** The `type` `OPENJSON` reports for the JSON scalar an element is compared with; anything else binds as a string. */
 function openJsonType(value) {
@@ -48,6 +56,14 @@ function openJsonType(value) {
     }
     return typeof value === 'boolean' ? 3 : 1;
 }
+/** The table variable an `OUTPUT` fills, `_uql`-prefixed as every name uql invents is. */
+const OUTPUT_TABLE = '@_uql_output';
+/** The one key column and its field, or nothing on a composite key. */
+function soleId(meta) {
+    const [key] = meta.ids;
+    const field = meta.ids.length === 1 ? meta.fields[key] : undefined;
+    return field && { key, field };
+}
 /** Microsoft SQL Server 2017 and up. Identifiers are `"`-quoted, the ANSI spelling `tedious` enables. */
 export class MsSqlDialect extends MergeSqlDialect {
     features = MSSQL_FEATURES;
@@ -74,6 +90,8 @@ export class MsSqlDialect extends MergeSqlDialect {
     maxBindValues = 2100;
     /** `OUTPUT` has no trailing form: it sits between the column list and `VALUES`. */
     returningPosition = 'after-target';
+    /** `OUTPUT` reads the written row off the `INSERTED` pseudo-table. */
+    returnedRowPrefix = 'INSERTED.';
     insertIdSource = 'returning';
     /** Holds the update key lock across the insert; without it two concurrent upserts of one key race. */
     mergeTargetHint = ' WITH (HOLDLOCK)';
@@ -96,30 +114,20 @@ export class MsSqlDialect extends MergeSqlDialect {
         }
         super.pager(ctx, opts, sorted);
     }
-    /**
-     * `SET IDENTITY_INSERT` around an insert that states a key the engine would generate, which it otherwise
-     * refuses; turned off in the same batch, since one table per session may hold it.
-     */
     insert(ctx, entity, payload, opts) {
-        const table = this.identityInsertTarget(entity, payload);
-        if (table) {
-            ctx.append(`SET IDENTITY_INSERT ${table} ON; `);
-        }
-        super.insert(ctx, entity, payload, opts);
-        if (table) {
-            ctx.append(`; SET IDENTITY_INSERT ${table} OFF`);
-        }
+        this.writeRows(ctx, getMeta(entity), payload, () => {
+            super.insert(ctx, entity, payload, opts);
+            ctx.append(';');
+        });
     }
     /** The table to toggle, or nothing when no record writes a key the engine would have generated. */
-    identityInsertTarget(entity, payload) {
-        const meta = getMeta(entity);
-        const [idKey] = meta.ids;
-        const field = meta.ids.length === 1 ? meta.fields[idKey] : undefined;
-        if (!field || !isAutoIncrement(field, true)) {
+    identityInsertTarget(meta, payload) {
+        const id = soleId(meta);
+        if (!id || !isAutoIncrement(id.field, true)) {
             return undefined;
         }
         const records = Array.isArray(payload) ? payload : [payload];
-        const stated = records.some((record) => record[idKey] !== undefined);
+        const stated = records.some((record) => record[id.key] !== undefined);
         return stated ? this.escapedTableName(meta) : undefined;
     }
     /** A `DECIMAL` declared `String`, converted before it crosses the wire, where `tedious` would round it. */
@@ -151,17 +159,44 @@ export class MsSqlDialect extends MergeSqlDialect {
     placeholder(index) {
         return `@p${index}`;
     }
-    /** `OUTPUT` reads the written row out of the `INSERTED` pseudo-table rather than `RETURNING` it. */
+    /**
+     * `OUTPUT` reads the written row out of the `INSERTED` pseudo-table rather than `RETURNING` it, and
+     * always `INTO` a table variable: SQL Server refuses an `OUTPUT` straight back to the client on a table
+     * carrying a trigger, and through a table it works whether one is there or not.
+     */
     returningId(meta) {
         const expression = this.returningIdExpression(meta);
-        return expression ? `OUTPUT ${expression}` : '';
+        return expression ? `OUTPUT ${expression} INTO ${OUTPUT_TABLE}` : '';
+    }
+    upsert(ctx, entity, conflictPaths, payload, extraReturning = '') {
+        this.writeRows(ctx, getMeta(entity), payload, () => super.upsert(ctx, entity, conflictPaths, payload, extraReturning));
     }
-    returningIdExpression(meta) {
-        const [idKey] = meta.ids;
-        return meta.ids.length === 1 ? `INSERTED.${this.escapeId(this.columnOf(meta, idKey))} ${this.escapeId('id')}` : '';
+    /**
+     * A statement writing rows, `write`, wrapped in what SQL Server needs around one. The table variable its
+     * `OUTPUT` fills, typed as the id column is, and the read handing that back, uncounted so the batch
+     * reports the rows written alone; none on a composite key, which has no id to hand back. And `SET
+     * IDENTITY_INSERT` where a row states a key the engine would generate, turned off in the same batch.
+     */
+    writeRows(ctx, meta, payload, write) {
+        const id = soleId(meta);
+        const column = this.escapeId('id');
+        const identity = this.identityInsertTarget(meta, payload);
+        if (id) {
+            ctx.append(`DECLARE ${OUTPUT_TABLE} TABLE (${column} ${canonicalToSql(resolveColumnCanonicalType(id.field), this)}); `);
+        }
+        if (identity) {
+            ctx.append(`SET IDENTITY_INSERT ${identity} ON; `);
+        }
+        write();
+        if (identity) {
+            ctx.append(` SET IDENTITY_INSERT ${identity} OFF;`);
+        }
+        if (id) {
+            ctx.append(` SET NOCOUNT ON; SELECT ${column} FROM ${OUTPUT_TABLE}; SET NOCOUNT OFF;`);
+        }
     }
     mergeReturning(expression) {
-        return `OUTPUT ${expression}`;
+        return `OUTPUT ${expression} INTO ${OUTPUT_TABLE}`;
     }
     /** A row lock is a hint on the table here, which `rowLocks.placement` says instead of a trailing clause. */
     lockHint(q) {
@@ -217,9 +252,7 @@ export class MsSqlDialect extends MergeSqlDialect {
     }
     /** There is no `CREATE SCHEMA IF NOT EXISTS`, and `CREATE SCHEMA` has to be alone in its batch. */
     createSchemaSql(schema) {
-        const literal = escapeSingleQuotes(schema);
-        const quoted = escapeSingleQuotes(this.escapeId(schema, true));
-        return `IF SCHEMA_ID(N'${literal}') IS NULL EXEC(N'CREATE SCHEMA ${quoted}')`;
+        return `IF SCHEMA_ID(${this.escape(schema)}) IS NULL EXEC(${this.escape(`CREATE SCHEMA ${this.escapeId(schema, true)}`)})`;
     }
     /** The estimate the engine already keeps per partition, live without a stats refresh. */
     estimatedCount(ctx, entity) {
@@ -229,8 +262,19 @@ export class MsSqlDialect extends MergeSqlDialect {
             ` JOIN sys.schemas s ON s.schema_id = o.schema_id` +
             ` WHERE p.index_id IN (0, 1) AND o.name = `);
         ctx.addValue(this.resolveTableAlias(meta));
+        // The connection's own default schema where the entity names none, as the introspector reads it.
+        const schema = this.resolveSchema(meta);
         ctx.append(' AND s.name = ');
-        ctx.addValue(this.resolveSchema(meta) ?? 'dbo');
+        if (schema === undefined) {
+            ctx.append('SCHEMA_NAME()');
+        }
+        else {
+            ctx.addValue(schema);
+        }
+    }
+    /** Null-safe on every version, `EXCEPT` comparing NULLs as equal: `IS DISTINCT FROM` needs 2022. */
+    neExpr(field, ph) {
+        return `EXISTS (SELECT ${field} EXCEPT SELECT ${ph})`;
     }
     numericCast(expr) {
         return `TRY_CAST(${expr} AS FLOAT)`;

package/dist/mssql/mssqlQuerier.js

@@ -25,8 +25,8 @@ export class MsSqlQuerier extends AbstractPoolQuerier {
     async internalRun(query, values) {
         const res = await this.#request(values).query(query);
         return this.buildUpdateResult({
-            // `rowsAffected` carries one entry per statement, and a `MERGE` upsert emits its `OUTPUT`
-            // alongside the write, so the counts are summed rather than read at [0].
+            // `rowsAffected` carries one entry per statement, and a write runs in a batch of several - the table
+            // variable its ids go through, the read handing them back uncounted - so the counts are summed.
             changes: res.rowsAffected.reduce((total, count) => total + count, 0),
             rows: decodeWireTypes(res.recordset, res.recordset?.columns),
         });

package/dist/schema/canonicalType.d.ts

@@ -1,6 +1,6 @@
 import type { AbstractDialect } from '../dialect/abstractDialect.js';
 import type { VectorCast } from '../dialect/vectorCast.js';
-import type { ColumnType, FieldOptions } from '../type/entity.js';
+import type { ColumnType, EntityGetter, FieldMeta, FieldOptions } from '../type/entity.js';
 import type { CanonicalType, TypeCategory } from './types.js';
 /** Whether a category is one of the vector types, narrowing it to the cast pgvector names use. */
 export declare function isVectorCategory(category: TypeCategory | undefined): category is VectorCast;
@@ -51,3 +51,8 @@ export declare function isBreakingTypeChange(from: CanonicalType, to: CanonicalT
  * Get the UQL ColumnType that best matches a canonical type.
  */
 export declare function canonicalToColumnType(type: CanonicalType): ColumnType;
+/**
+ * A field's canonical type, taken from the referenced key where the field gave `references` and no
+ * `type` (`typeFromReference`), so a foreign key matches the key it points at; `columnType` always wins.
+ */
+export declare function resolveColumnCanonicalType(field: FieldMeta, seen?: Set<EntityGetter>): CanonicalType;

package/dist/schema/canonicalType.js

@@ -1,4 +1,5 @@
 // Canonical types, between an engine's SQL types and TypeScript's.
+import { fieldOf, getMeta, soleIdOf } from '../entity/metadata/definition.js';
 import { QueryRaw } from '../type/index.js';
 import { columnFamily, isIntegerColumn } from '../util/field.util.js';
 import { constantSql } from '../util/raw.js';
@@ -456,3 +457,16 @@ export function canonicalToColumnType(type) {
             return 'sparsevec';
     }
 }
+/**
+ * A field's canonical type, taken from the referenced key where the field gave `references` and no
+ * `type` (`typeFromReference`), so a foreign key matches the key it points at; `columnType` always wins.
+ */
+export function resolveColumnCanonicalType(field, seen = new Set()) {
+    const hasExplicitType = !!field.columnType || !field.typeFromReference;
+    if (!hasExplicitType && field.references && !seen.has(field.references)) {
+        seen.add(field.references);
+        const referencedMeta = getMeta(field.references());
+        return resolveColumnCanonicalType(fieldOf(referencedMeta, soleIdOf(referencedMeta, 'a foreign key')), seen);
+    }
+    return fieldOptionsToCanonical(field);
+}

package/dist/schema/indexDifferences.d.ts

@@ -1,10 +1,12 @@
+import type { IndexSchema } from '../type/index.js';
 import type { IndexNode } from './types.js';
 /**
  * What an introspector reports about an index, and so all a diff may compare; apart from `IndexFeature`, what an engine emits.
- * `vector` is whether it is a vector index at all, for an engine with one vector index whatever type declared it.
+ * `vector` is whether it is a vector index at all, for an engine with one vector index whatever type declared it;
+ * `distance` is the metric a vector index was built for.
  * `textIndex` is a text index's weights and language, kept by an engine that lists its fields in no declared order.
  */
-export type IndexFacet = 'order' | 'nulls' | 'opsClass' | 'accessMethod' | 'include' | 'vector' | 'textIndex';
+export type IndexFacet = 'order' | 'nulls' | 'opsClass' | 'accessMethod' | 'include' | 'vector' | 'distance' | 'textIndex';
 type ComparableIndex = Pick<IndexNode, 'name' | 'entries' | 'unique'>;
 /**
  * Whether the table has this index already, by shape rather than name, uniqueness included. An index
@@ -17,16 +19,30 @@ export declare function indexSignature(index: ComparableIndex): string;
  */
 export declare function indexNameStem(name: string): string;
 /**
- * The indexes a table lacks and the ones it no longer needs, matched by `keyOf`. Only an index uql
- * named, or whose name the entity claims, is dropped: any other may have been made outside the ORM.
+ * Pairs by name, then what is left by shape: an index the database has under another name is still
+ * the one asked for. What stays unpaired is created or dropped.
  */
-export declare function indexChanges<I extends ComparableIndex>(table: string, declared: readonly I[], current: readonly IndexNode[], keyOf?: (index: ComparableIndex) => string): {
+export declare function pairIndexes<S extends ComparableIndex, T extends ComparableIndex>(source: readonly S[], target: readonly T[], normalizeName?: (name: string) => string): {
+    created: S[];
+    dropped: T[];
+    matched: (readonly [S, T])[];
+};
+/**
+ * The indexes a table lacks, the ones it no longer needs, and the ones to rebuild, differing in what
+ * `facets` let the engine report. Only an unpaired index uql named, or whose name the entity claims, is
+ * dropped: any other may have been made outside the ORM.
+ */
+export declare function indexChanges<I extends IndexSchema>(table: string, declared: readonly I[], current: readonly IndexNode[], facets: ReadonlySet<IndexFacet>): {
     toAdd: I[];
     toDrop: IndexNode[];
+    toAlter: {
+        from: IndexNode;
+        to: I;
+    }[];
 };
 /**
  * What two indexes differ by, comparing only what both sides state structurally: an expression, a JSON
  * path or a predicate is reprinted by the engine, so never compared.
  */
-export declare function describeIndexDifferences(source: IndexNode, target: IndexNode, facets: ReadonlySet<IndexFacet>): string[];
+export declare function describeIndexDifferences(source: IndexSchema, target: IndexSchema, facets: ReadonlySet<IndexFacet>): string[];
 export {};

package/dist/schema/indexDifferences.js

@@ -1,6 +1,7 @@
-import { isVectorIndexType } from '../type/vector.js';
+import { indexDistance, isVectorIndexType } from '../type/vector.js';
 import { fulltextConfig } from '../util/dialect.util.js';
 import { derivedIndexName } from '../util/sql.util.js';
+import { matchByKey } from './matchByKey.js';
 /** An entry the engine reprints in its own words, so never compared as written. */
 function isReprinted(entry) {
     return Boolean(entry.expression || entry.jsonPath || entry.jsonArray);
@@ -26,17 +27,27 @@ export function indexNameStem(name) {
     return bare.replace(/__/g, '_');
 }
 /**
- * The indexes a table lacks and the ones it no longer needs, matched by `keyOf`. Only an index uql
- * named, or whose name the entity claims, is dropped: any other may have been made outside the ORM.
+ * Pairs by name, then what is left by shape: an index the database has under another name is still
+ * the one asked for. What stays unpaired is created or dropped.
  */
-export function indexChanges(table, declared, current, keyOf = indexSignature) {
-    const present = new Set(current.map(keyOf));
-    const wanted = new Set(declared.map(keyOf));
+export function pairIndexes(source, target, normalizeName = (name) => name) {
+    const byName = matchByKey(source, target, (index) => normalizeName(indexNameStem(index.name)));
+    const byShape = matchByKey(byName.created, byName.dropped, indexSignature);
+    return { created: byShape.created, dropped: byShape.dropped, matched: [...byName.matched, ...byShape.matched] };
+}
+/**
+ * The indexes a table lacks, the ones it no longer needs, and the ones to rebuild, differing in what
+ * `facets` let the engine report. Only an unpaired index uql named, or whose name the entity claims, is
+ * dropped: any other may have been made outside the ORM.
+ */
+export function indexChanges(table, declared, current, facets) {
+    const { created, dropped, matched } = pairIndexes(declared, current);
     const claimed = new Set(declared.map((index) => index.name));
     const owned = (index) => claimed.has(index.name) || hasDerivedName(table, index);
     return {
-        toAdd: declared.filter((index) => !present.has(keyOf(index))),
-        toDrop: current.filter((index) => !wanted.has(keyOf(index)) && owned(index)),
+        toAdd: created,
+        toDrop: dropped.filter(owned),
+        toAlter: matched.flatMap(([to, from]) => (describeIndexDifferences(to, from, facets).length ? [{ from, to }] : [])),
     };
 }
 /**
@@ -85,6 +96,10 @@ export function describeIndexDifferences(source, target, facets) {
     if (facets.has('accessMethod') && (source.type ?? 'btree') !== (target.type ?? 'btree')) {
         differences.push(`type: ${target.type ?? 'btree'} -> ${source.type ?? 'btree'}`);
     }
+    const bothVector = isVectorIndexType(source.type) && isVectorIndexType(target.type);
+    if (facets.has('distance') && bothVector && indexDistance(source) !== indexDistance(target)) {
+        differences.push(`distance: ${indexDistance(target)} -> ${indexDistance(source)}`);
+    }
     if (facets.has('vector') && isVectorIndexType(source.type) !== isVectorIndexType(target.type)) {
         const [expected, actual] = [source, target].map((index) => (isVectorIndexType(index.type) ? 'yes' : 'no'));
         differences.push(`vector index: ${actual} -> ${expected}`);

package/dist/schema/matchByKey.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The only three ways two keyed collections can differ, which is the shape of every comparison in
+ * the schema diff: tables, columns, indexes and relationships all key and then split the same way.
+ * One counterpart each, so two items sharing a key (a duplicate index) are not collapsed into one.
+ */
+export declare function matchByKey<S, T>(source: Iterable<S>, target: Iterable<T>, key: (item: S | T) => string): {
+    created: S[];
+    dropped: T[];
+    matched: (readonly [S, T])[];
+};

package/dist/schema/matchByKey.js

@@ -0,0 +1,18 @@
+/**
+ * The only three ways two keyed collections can differ, which is the shape of every comparison in
+ * the schema diff: tables, columns, indexes and relationships all key and then split the same way.
+ * One counterpart each, so two items sharing a key (a duplicate index) are not collapsed into one.
+ */
+export function matchByKey(source, target, key) {
+    const unpaired = Map.groupBy(target, key);
+    const created = [];
+    const matched = [];
+    for (const item of source) {
+        const counterpart = unpaired.get(key(item))?.shift();
+        if (counterpart === undefined)
+            created.push(item);
+        else
+            matched.push([item, counterpart]);
+    }
+    return { created, dropped: [...unpaired.values()].flat(), matched };
+}

package/dist/schema/schemaAST.d.ts

@@ -1,6 +1,10 @@
-import type { IndexNode, RelationshipNode, TableNode } from './types.js';
+import type { PrimaryKeySchema } from '../type/migration.js';
+import type { IndexFacet } from './indexDifferences.js';
+import type { ColumnNode, IndexNode, RelationshipNode, TableNode } from './types.js';
 /** A table node with its collections empty, ready to be filled. */
-export declare function createTableNode(name: string, schema?: string, comment?: string): TableNode;
+export declare function createTableNode(name: string, schema?: string, indexFacets?: ReadonlySet<IndexFacet>): TableNode;
+/** The key the columns' own flags say, in their order, for a source that reports no key of its own. */
+export declare function keyOfColumns(columns: Iterable<Pick<ColumnNode, 'name' | 'isPrimaryKey'>>): PrimaryKeySchema | undefined;
 /** A database schema as a graph: tables, the foreign keys between them, and their indexes. */
 export declare class SchemaAST {
     readonly tables: Map<string, TableNode>;

package/dist/schema/schemaAST.js

@@ -1,19 +1,23 @@
 import { qualifyName } from '../util/sql.util.js';
 import { createOrder, dropOrder } from './dependencyGraph.js';
 /** A table node with its collections empty, ready to be filled. */
-export function createTableNode(name, schema, comment) {
+export function createTableNode(name, schema, indexFacets = new Set()) {
     return {
         name,
         schema,
-        comment,
+        indexFacets,
         columns: new Map(),
-        primaryKey: [],
         indexes: [],
         checks: [],
         incomingRelations: [],
         outgoingRelations: [],
     };
 }
+/** The key the columns' own flags say, in their order, for a source that reports no key of its own. */
+export function keyOfColumns(columns) {
+    const keyColumns = [...columns].filter((column) => column.isPrimaryKey).map((column) => column.name);
+    return keyColumns.length ? { columns: keyColumns } : undefined;
+}
 /** A database schema as a graph: tables, the foreign keys between them, and their indexes. */
 export class SchemaAST {
     tables = new Map();

package/dist/schema/schemaASTBuilder.d.ts

@@ -1,8 +1,7 @@
-import type { EntityGetter } from '../type/entity.js';
-import type { EntityMeta, EntityWhereMeta, FieldMeta, FieldOptions, Type } from '../type/index.js';
+import type { EntityMeta, EntityWhereMeta, 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';
+import { type ForeignKeyAction } from './types.js';
 /**
  * Options for building SchemaAST from entities.
  */
@@ -26,6 +25,8 @@ export interface BuildSchemaASTOptions {
     compileIndexPredicate?: (where: EntityWhereMeta<object>, entity: Type<object>, indexName: string) => string;
     /** Whether a weighted fulltext index declares one of its own for each heavier column, as MySQL scores through one. */
     textScoreIndexes?: boolean;
+    /** Whether a column a vector index covers is `NOT NULL` whatever the entity declares, as MariaDB demands. */
+    vectorIndexRequiresNotNull?: boolean;
 }
 /**
  * Build a SchemaAST from entity classes (decorated with `@Entity`, `@Field`, etc.).
@@ -34,8 +35,3 @@ export interface BuildSchemaASTOptions {
  * resolves against a table another entity declares, and an index against the columns of its own.
  */
 export declare function buildSchemaAST(entities: readonly Type<object>[], options?: BuildSchemaASTOptions): SchemaAST;
-/**
- * A field's canonical type, taken from the referenced key where the field gave `references` and no
- * `type` (`typeFromReference`), so a foreign key matches the key it points at; `columnType` always wins.
- */
-export declare function resolveColumnCanonicalType(field: FieldMeta, seen?: Set<EntityGetter>): CanonicalType;

package/dist/schema/schemaASTBuilder.js

@@ -1,14 +1,12 @@
-import { fieldOf, foreignKeysOf, getMeta, soleIdOf } from '../entity/metadata/definition.js';
+import { fieldOf, foreignKeysOf, getMeta } from '../entity/metadata/definition.js';
 import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../util/ddlExpression.util.js';
 import { fulltextWeights, textWeightSteps } from '../util/dialect.util.js';
-import { isInlinedExpression } from '../util/field.util.js';
-import { isSoleIdField } from '../util/field.util.js';
-import { isAutoIncrement } from '../util/field.util.js';
+import { isAutoIncrement, isInlinedExpression, isSoleIdField } from '../util/field.util.js';
 import { definedEntries } from '../util/object.util.js';
 import { derivedForeignKeyName, derivedIndexName, qualifyName } from '../util/sql.util.js';
-import { fieldOptionsToCanonical } from './canonicalType.js';
-import { createTableNode, SchemaAST } from './schemaAST.js';
-import { DEFAULT_FOREIGN_KEY_ACTION, } from './types.js';
+import { resolveColumnCanonicalType } from './canonicalType.js';
+import { createTableNode, keyOfColumns, SchemaAST } from './schemaAST.js';
+import { DEFAULT_FOREIGN_KEY_ACTION } from './types.js';
 /**
  * Build a SchemaAST from entity classes (decorated with `@Entity`, `@Field`, etc.).
  *
@@ -28,6 +26,7 @@ export function buildSchemaAST(entities, options = {}) {
         compileDdl,
         compileIndexPredicate: options.compileIndexPredicate ?? compileDdl,
         textScoreIndexes: options.textScoreIndexes ?? false,
+        vectorIndexRequiresNotNull: options.vectorIndexRequiresNotNull ?? false,
     };
     for (const pass of [addTableFromEntity, addRelationshipsFromEntity, addIndexesFromEntity]) {
         for (const entity of entities) {
@@ -40,18 +39,11 @@ export function buildSchemaAST(entities, options = {}) {
 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');
 }
-/**
- * A field's canonical type, taken from the referenced key where the field gave `references` and no
- * `type` (`typeFromReference`), so a foreign key matches the key it points at; `columnType` always wins.
- */
-export function resolveColumnCanonicalType(field, seen = new Set()) {
-    const hasExplicitType = !!field.columnType || !field.typeFromReference;
-    if (!hasExplicitType && field.references && !seen.has(field.references)) {
-        seen.add(field.references);
-        const referencedMeta = getMeta(field.references());
-        return resolveColumnCanonicalType(fieldOf(referencedMeta, soleIdOf(referencedMeta, 'a foreign key')), seen);
-    }
-    return fieldOptionsToCanonical(field);
+/** The entries a vector index of `meta` covers: the members it names, and any expression. */
+function vectorIndexedEntries(meta) {
+    return new Set((meta.indexes ?? [])
+        .filter((index) => index.type === 'vector')
+        .flatMap((index) => index.columns.map((entry) => entry.column)));
 }
 /**
  * Add a table from entity metadata.
@@ -59,8 +51,9 @@ export function resolveColumnCanonicalType(field, seen = new Set()) {
 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 ?? []).map(({ name, where }) => ({ name, expression: ctx.compileDdl(where, meta.entity) })));
+    const { columns } = table;
+    table.checks.push(...(meta.checks ?? []).map(({ name, where }) => ({ name, expression: ctx.compileDdl(where, meta.entity) })));
+    const notNull = ctx.vectorIndexRequiresNotNull ? vectorIndexedEntries(meta) : new Set();
     // 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.
@@ -75,12 +68,13 @@ function addTableFromEntity(ctx, meta) {
             type,
             // A primary key is NOT NULL in every engine, whatever the entity's property says: `id?: number`
             // is optional because the database assigns it, not because the column accepts a null.
-            nullable: isPrimaryKey ? false : (field.nullable ?? true),
+            nullable: isPrimaryKey || notNull.has(key) ? false : (field.nullable ?? true),
             defaultValue: field.defaultValue,
             isPrimaryKey,
             isAutoIncrement: isAutoIncrement(field, isSoleKey),
             isUnique: field.unique ?? false,
-            generatedAs: field.computed && ctx.compileDdl(field.computed, meta.entity),
+            // A stamp is filled by a trigger, so it is a column like any other; only `stored: true` generates.
+            generatedAs: field.stored === true && field.computed ? ctx.compileDdl(field.computed, meta.entity) : undefined,
             comment: field.comment,
             enum: field.enum,
             table,
@@ -88,10 +82,8 @@ function addTableFromEntity(ctx, meta) {
             references: undefined,
         };
         columns.set(columnName, column);
-        if (field.isId) {
-            primaryKey.push(column);
-        }
     }
+    table.primaryKey = keyOfColumns(columns.values());
     ctx.ast.addTable(table);
 }
 /** The node an entity maps to, found under the key {@link SchemaAST} stores it by. */
@@ -171,11 +163,10 @@ function addForeignKeyIndexes(ctx, meta, table) {
         });
     }
 }
-/** Whether the key, a unique column or an index already leads with `columns`, which is all a lookup needs. */
+/** Whether the key or an index already leads with `columns`, which is all a lookup needs. */
 function isIndexedBy(table, columns) {
     const leads = (indexed) => columns.every((column, at) => indexed[at] === column);
-    return (leads(table.primaryKey.map((column) => column.name)) ||
-        (columns.length === 1 && table.columns.get(columns[0])?.isUnique === true) ||
+    return (leads(table.primaryKey?.columns ?? []) ||
         table.indexes.some((index) => leads(index.entries.map((entry) => entry.expression || entry.jsonPath || entry.jsonArray ? undefined : entry.column))));
 }
 /** An `include` column is named like any other, so a naming strategy has to reach it too. */

package/dist/schema/schemaASTDiffer.d.ts

@@ -1,4 +1,3 @@
-import { type IndexFacet } from './indexDifferences.js';
 import type { SchemaAST } from './schemaAST.js';
 import type { CanonicalType } from './types.js';
 import type { ColumnDiff, ForeignKeyAction, IndexDiff, RelationshipDiff, RelationshipNode, SchemaDiffResult, TableDiff, TableNode } from './types.js';
@@ -8,8 +7,6 @@ import type { ColumnDiff, ForeignKeyAction, IndexDiff, RelationshipDiff, Relatio
 export interface DiffOptions {
     /** Compare indexes */
     compareIndexes?: boolean;
-    /** What the target side can report about an index, normally an introspector's `indexFacets`. Anything left out is not compared. */
-    indexFacets?: ReadonlySet<IndexFacet>;
     /** Compare foreign keys/relationships */
     compareRelationships?: boolean;
     /** Ignore case differences in names */
@@ -38,3 +35,5 @@ export declare function referentialActions(rel: RelationshipNode): {
     readonly onDelete: ForeignKeyAction;
     readonly onUpdate: ForeignKeyAction;
 };
+/** Two defaults compared as written, where no dialect reprints them: `now()` and `CURRENT_TIMESTAMP` are one. */
+export declare function defaultsEqualAsWritten(expected: unknown, actual: unknown): boolean;