uql-orm 0.66.0 → 0.67.1

package/dist/entity/metadata/definition.js

@@ -175,11 +175,8 @@ export function defineEntity(entity, opts = {}) {
     if (!hasKeys(meta.fields)) {
         throw TypeError(`'${entity.name}' must have fields`);
     }
-    // A later call composes onto the entity, so saying nothing about the table retracts nothing - which
-    // is why `derivedName` is only ever *set*, never recomputed from what a previous call left.
-    // It records that the class name stood in, telling a naming strategy there is something to derive;
-    // comparing the two cannot, since an entity may name its table exactly what its class is called and
-    // a spec's minted class is named after its table.
+    // A later call composes onto the entity, so a name is only ever set, and `derivedName` records that
+    // the class name stood in, which is what a naming strategy derives from.
     if (opts.name !== undefined) {
         meta.name = opts.name;
         meta.derivedName = false;
@@ -251,27 +248,11 @@ export function relationOf(meta, key) {
     }
     return relation;
 }
-/**
- * Whether the caller named every column of the row's primary key, so {@link idOf} can name the row.
- *
- * `!= null` rather than falsiness: `0` and an empty string are ids a row can legitimately carry, and
- * reading them as "no id" is how a write of that row turned into a second insert. Distinct from
- * "does the row carry this column", which an insert asks of `undefined` alone because that is what
- * decides whether the column appears in its `VALUES` list at all.
- */
+/** Whether the row names every column of its primary key, `0` and `''` included. */
 export function namesKey(meta, row) {
     return meta.ids.every((key) => row[key] != null);
 }
-/**
- * A row's primary key: the value itself for a single key, an object carrying every key for a
- * composite - which is {@link WrittenId}, and reads as the {@link EntityId} a `$where` takes.
- *
- * What a settled write names its rows by, and what a write hands back. Naming a composite row by one
- * of its columns would address every row agreeing on that one.
- *
- * `WrittenId` does not reduce for an unresolved `E`, so which branch this entity is in cannot be
- * proven here, only checked - which is what `ids.length` does.
- */
+/** A row's primary key: its value, or a map of every column on a composite, checked at run time. */
 export function idOf(meta, row) {
     const { ids } = meta;
     const id = ids.length === 1 ? row[ids[0]] : Object.fromEntries(ids.map((key) => [key, row[key]]));
@@ -503,11 +484,8 @@ function getIdKeys(meta) {
     return getKeys(meta.fields).filter((key) => meta.fields[key]?.isId);
 }
 /**
- * Merges `ancestor` and its own ancestors into `meta`, nearest first, so a further one never overwrites
- * a nearer. An `abstract class BaseEntity` carrying `@Field`s but no `@Entity()` has nobody to drain
- * its registrations, so do it here. Walking the *class* prototype chain rather than the metadata
- * object's is what makes this work on every transformer: tsc and esbuild chain metadata across
- * `extends`, SWC does not.
+ * Merges `ancestor` and its ancestors into `meta`, nearest first, draining an undecorated base's
+ * registrations. Walks the class chain, since not every compiler chains decorator metadata.
  */
 function inheritFrom(meta, ancestor) {
     for (let parent = ancestor; parent && parent !== Object; parent = parentOf(parent)) {

package/dist/http/handler.d.ts

@@ -29,13 +29,7 @@ export type HookContext<E extends object, Ctx = unknown> = {
     readonly meta: EntityMeta<E>;
     readonly op: CrudOperation;
     readonly method: HttpMethod;
-    /**
-     * parsed query - mutate in place or reassign to shape it (e.g. force a `$select`, inject a
-     * `$sort`). For actual tenant/row-level scoping, prefer `@Filter(..., { security: true })` on
-     * the entity instead: unlike a hook mutation, it is AND-merged (a client `$where` on the same
-     * key cannot silently win), fails closed when its context is missing, and applies uniformly
-     * across every query path including joined relations.
-     */
+    /** The parsed query, to reshape in place. Scope rows with a `security` filter instead, which a client cannot override. */
     query: Query<E>;
     /**
      * request payload - reassignable for sanitization or field injection.
@@ -51,13 +45,7 @@ export type ResponseHook<Ctx = unknown> = <E extends object>(ctx: HookContext<E,
 export type RequestHandlerOptions<Ctx = unknown> = {
     include?: Type<object>[];
     exclude?: Type<object>[];
-    /**
-     * The URL segment an entity is addressed by, defaulting to its kebab-cased class name.
-     *
-     * State it where the default cannot serve: a build that minifies class names renames every route,
-     * and two entities mapping one table in different schemas collide on one. The browser client takes
-     * the same option, so both ends can read one map.
-     */
+    /** The URL segment an entity is addressed by, its kebab-cased class name by default; the browser client takes the same option. */
     entityPath?: (entity: Type<unknown>) => string;
     /**
      * Allow augment any kind of request before it runs. Hooks may be async

package/dist/index.d.ts

@@ -4,4 +4,7 @@ export * from './entity/index.js';
 export * from './namingStrategy/index.js';
 export * from './querier/index.js';
 export * from './type/index.js';
-export * from './util/index.js';
+export { withDeleted } from './util/filters.util.js';
+export type { HookContext } from './util/hook.util.js';
+export { DefaultLogger } from './util/logger.js';
+export { raw, refs } from './util/raw.js';

package/dist/index.js

@@ -4,4 +4,6 @@ export * from './entity/index.js';
 export * from './namingStrategy/index.js';
 export * from './querier/index.js';
 export * from './type/index.js';
-export * from './util/index.js';
+export { withDeleted } from './util/filters.util.js';
+export { DefaultLogger } from './util/logger.js';
+export { raw, refs } from './util/raw.js';

package/dist/libsql/libsqlDialect.d.ts

@@ -7,13 +7,6 @@ import type { VectorDistance, VectorMetric } from '../type/index.js';
  * functions, which `TursoDialect` inherits.
  */
 export declare class LibsqlDialect extends SqliteDialect {
-    /**
-     * libSQL has vector search built in, under its own names, so the sqlite-vec `vec_distance_*`
-     * functions this dialect would otherwise inherit are never present.
-     *
-     * @remarks `inner` and `l1` are left out: `vector_distance_dot` only exists in the newer Rust
-     * engine (see `TursoLocalDialect`) and no libSQL build has an L1 metric. Both raise the same
-     * "does not support vector distance metric" error as any other unsupported metric.
-     */
+    /** libSQL's built-in vector functions; no `inner` (only the Rust engine has it) and no `l1`. */
     readonly vectorMetrics: ReadonlyMap<VectorDistance, VectorMetric>;
 }

package/dist/libsql/libsqlDialect.js

@@ -6,14 +6,7 @@ import { SqliteDialect } from '../sqlite/sqliteDialect.js';
  * functions, which `TursoDialect` inherits.
  */
 export class LibsqlDialect extends SqliteDialect {
-    /**
-     * libSQL has vector search built in, under its own names, so the sqlite-vec `vec_distance_*`
-     * functions this dialect would otherwise inherit are never present.
-     *
-     * @remarks `inner` and `l1` are left out: `vector_distance_dot` only exists in the newer Rust
-     * engine (see `TursoLocalDialect`) and no libSQL build has an L1 metric. Both raise the same
-     * "does not support vector distance metric" error as any other unsupported metric.
-     */
+    /** libSQL's built-in vector functions; no `inner` (only the Rust engine has it) and no `l1`. */
     vectorMetrics = new Map([
         ['cosine', { fn: 'vector_distance_cos' }],
         ['l2', { fn: 'vector_distance_l2' }],

package/dist/maria/mariaDialect.d.ts

@@ -1,16 +1,14 @@
 import { type RelationRows } from '../dialect/abstractSqlDialect.js';
 import { MysqlLikeSqlDialect } from '../dialect/mysqlLikeSqlDialect.js';
-import type { DialectFeatures, EntityMeta, FieldOptions, Query, QueryContext, Type, VectorDistance, VectorMetric } from '../type/index.js';
+import type { EntityMeta, FieldOptions, Query, QueryContext, SqlDialectFeatures, Type, VectorDistance, VectorMetric } from '../type/index.js';
 export declare class MariaDialect extends MysqlLikeSqlDialect {
     readonly dialectName = "mariadb";
     readonly insertIdSource = "returning";
-    /** MariaDB has no `FOR ... OF`, so a lock cannot be narrowed to one table of a join. */
-    readonly supportsLockOf = false;
     /**
      * Unlike MySQL: `VECTOR(n)` takes its dimension, every column of a vector index has to be NOT NULL,
-     * and `CREATE INDEX` takes `IF NOT EXISTS` - which MySQL's grammar has no place for.
+     * `CREATE INDEX` takes `IF NOT EXISTS`, and a lock cannot be narrowed to one table of a join.
      */
-    protected readonly featureOverrides: Partial<DialectFeatures>;
+    readonly features: SqlDialectFeatures;
     /**
      * A derived table here reads no column of the statement around it, so the aggregate reads the
      * related table itself, and orders and pages inside `JSON_ARRAYAGG`, which takes both.

package/dist/maria/mariaDialect.js

@@ -1,6 +1,6 @@
 import { relationTermKey } from '../dialect/abstractSqlDialect.js';
 import { jsonPath } from '../dialect/jsonSql.js';
-import { MysqlLikeSqlDialect } from '../dialect/mysqlLikeSqlDialect.js';
+import { MYSQL_FEATURES, MysqlLikeSqlDialect } from '../dialect/mysqlLikeSqlDialect.js';
 import { getMeta } from '../entity/index.js';
 import { columnFamily } from '../util/field.util.js';
 import { MARIA_VECTOR_METRICS } from './mariaVectorMetrics.js';
@@ -8,16 +8,16 @@ export class MariaDialect extends MysqlLikeSqlDialect {
     dialectName = 'mariadb';
     // MariaDB 10.5+ has `INSERT ... RETURNING`, so ids come back exact per row - the upsert's too.
     insertIdSource = 'returning';
-    /** MariaDB has no `FOR ... OF`, so a lock cannot be narrowed to one table of a join. */
-    supportsLockOf = false;
     /**
      * Unlike MySQL: `VECTOR(n)` takes its dimension, every column of a vector index has to be NOT NULL,
-     * and `CREATE INDEX` takes `IF NOT EXISTS` - which MySQL's grammar has no place for.
+     * `CREATE INDEX` takes `IF NOT EXISTS`, and a lock cannot be narrowed to one table of a join.
      */
-    featureOverrides = {
+    features = {
+        ...MYSQL_FEATURES,
         vectorSupportsLength: true,
         vectorIndexRequiresNotNull: true,
         indexIfNotExists: true,
+        rowLockOf: false,
     };
     /**
      * A derived table here reads no column of the statement around it, so the aggregate reads the

package/dist/maria/mariadbQuerier.js

@@ -7,8 +7,8 @@ export class MariadbQuerier extends AbstractPoolQuerier {
     }
     async internalRun(query, values) {
         const res = await this.getConn().query(query, values);
-        // MariaDB may not set `affectedRows` when RETURNING is used; fall back to row count.
-        const changes = res.affectedRows ?? res.length ?? 0;
+        // An OK packet reports `affectedRows`; a `RETURNING` statement answers rows instead, and counts by them.
+        const changes = res.affectedRows ?? res.length;
         const rows = res.length ? Array.from(res, decodeBigInts) : [];
         return this.buildUpdateResult({ rows, changes, upsertStatus: res.affectedRows });
     }

package/dist/maria/mariadbQuerierPool.js

@@ -11,12 +11,7 @@ export class MariadbQuerierPool extends AbstractSqlQuerierPool {
         // BIGINT stays the driver's `bigint`, which `MariadbQuerier` decodes by the rule every driver here
         // shares (`decodeWideNumber`) - not `bigIntAsNumber`, which rounds past 2^53 without a word.
         this.pool = createPool(opts);
-        // `mariadb`'s own `createPool` already attaches a silent no-op 'error'
-        // listener (so a dropped connection can't crash the process), but its
-        // `Pool` type only declares `on` for 'acquire' | 'connection' | 'enqueue'
-        // | 'release' - 'error' genuinely fires at runtime (see `lib/pool.js`)
-        // but isn't in the declaration, hence the cast. Re-attaching our own
-        // listener here just makes the error visible instead of a silent no-op.
+        // `mariadb` fires 'error' at runtime without declaring it, hence the cast; this makes it visible.
         attachPoolErrorHandler(this.pool, 'Idle MariaDB pool connection encountered an error', extra?.logger);
     }
     async getQuerier() {

package/dist/migrate/builder/migrationBuilder.js

@@ -20,13 +20,7 @@ function createIndexOperation(tableName, columns, options = {}) {
         },
     };
 }
-/**
- * The one shape of an `addForeignKey` operation, `NO ACTION` defaults included.
- *
- * Three callers build it and differ only in what they do with the result: the table builder records
- * it through its parent, the recorder records it directly, and the executing builder also runs it.
- * Spelled out three times, a changed default would have had to be found in all three.
- */
+/** An `addForeignKey` operation, `NO ACTION` defaults included, for the three builders that record one. */
 function addForeignKeyOperation(tableName, columns, target, options = {}) {
     return {
         type: 'addForeignKey',
@@ -40,21 +34,11 @@ function addForeignKeyOperation(tableName, columns, target, options = {}) {
         },
     };
 }
-/**
- * Declare one column through the same vocabulary `createTable` uses. A throwaway {@link TableBuilder}
- * is that vocabulary: `addColumn`/`alterColumn` used to take a bare {@link IColumnBuilder}, which
- * cannot express a type, so every column they recorded was hard-coded `VARCHAR`.
- */
+/** One column declared through `createTable`'s vocabulary, a throwaway {@link TableBuilder}, so its type is stated. */
 function buildOneColumn(callback) {
     return callback(new TableBuilder('')).build();
 }
-/**
- * Collects the operations one `alterTable` callback declares, in the order it declared them.
- *
- * Collected rather than dispatched to the parent as they are made: the chaining methods are
- * synchronous by contract, so a builder that executes could only fire and forget, which returned from
- * `alterTable` with the statements still in flight and turned a failure into an unhandled rejection.
- */
+/** The operations one `alterTable` callback declares, collected in order, since its methods are synchronous. */
 class AlterTableBuilder {
     tableName;
     operations = [];

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

@@ -1,15 +1,2 @@
-/**
- * Splits a SQL blob on semicolons into separate statements.
- *
- * Uses a declarative Master-Regex scanner to rapidly
- * identify and skip "non-splittable" blocks (strings, comments, dollar-quotes) in a single pass.
- * This approach is $O(n)$, leverages native regex speed, and is trivially easy to audit.
- *
- * Handles:
- * - Single quotes: '...' (standard SQL, respects '' and \')
- * - Double quotes: "..." (identifiers or MySQL strings)
- * - Backticks: `...` (MySQL identifiers)
- * - Postgres Dollar quotes: $tag$...$tag$ or $$...$$
- * - Comments: -- and /* ... *\/
- */
+/** Splits SQL on semicolons, skipping strings, quoted identifiers, dollar-quoted blocks and comments in one regex pass. */
 export declare function splitSqlStatements(sql: string): string[];

package/dist/migrate/builder/splitSqlStatements.js

@@ -1,28 +1,8 @@
-/**
- * Splits a SQL blob on semicolons into separate statements.
- *
- * Uses a declarative Master-Regex scanner to rapidly
- * identify and skip "non-splittable" blocks (strings, comments, dollar-quotes) in a single pass.
- * This approach is $O(n)$, leverages native regex speed, and is trivially easy to audit.
- *
- * Handles:
- * - Single quotes: '...' (standard SQL, respects '' and \')
- * - Double quotes: "..." (identifiers or MySQL strings)
- * - Backticks: `...` (MySQL identifiers)
- * - Postgres Dollar quotes: $tag$...$tag$ or $$...$$
- * - Comments: -- and /* ... *\/
- */
+/** Splits SQL on semicolons, skipping strings, quoted identifiers, dollar-quoted blocks and comments in one regex pass. */
 export function splitSqlStatements(sql) {
     const statements = [];
     let lastIndex = 0;
-    // This regex matches:
-    // 1. Single quoted strings: '(?:''|\\['\\]|[^'])*(?:'|(?=$))
-    // 2. Double quoted identifiers: "(?:""|\\["\\]|[^"])*(?:"|(?=$))
-    // 3. Backticked identifiers: `(?:``|\\[`\\]|[^`])*(?:`|(?=$))
-    // 4. Postgres Dollar quoted blocks: \$(?<tag>[a-zA-Z0-9_]*)\$[\s\S]*?(?:\$\k<tag>|(?=$))
-    // 5. Single-line comments: --.*
-    // 6. Multi-line comments: \/\*[\s\S]*?(?:\*\/|(?=$))
-    // 7. Statement terminator: ;
+    // Quoted strings and identifiers, dollar quotes, comments, or a `;`: the one regex scanning them all.
     const masterRegex = /'(?:''|\\['\\]|[^'])*(?:'|(?=$))|"(?:""|\\["\\]|[^"])*(?:"|(?=$))|`(?:``|\\[`\\]|[^`])*(?:`|(?=$))|\$(?<tag>[a-zA-Z0-9_]*)\$[\s\S]*?(?:\$\k<tag>|(?=$))|--.*|\/\*[\s\S]*?(?:\*\/|(?=$))|;/g;
     for (const match of sql.matchAll(masterRegex)) {
         if (match[0] === ';') {

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

@@ -67,14 +67,7 @@ export interface VectorColumnOptions extends BaseColumnOptions {
     /** Number of dimensions */
     dimensions?: number;
 }
-/**
- * A column as the builder describes one: {@link ColumnNode} without the graph links a DTO cannot carry.
- *
- * Derived rather than restated, so the two cannot drift. A column gained `enum` and this shape was
- * simply missing it, which is why a hand-written `createTable` could never constrain one. A field
- * added to the node now reaches here, and failing to render it is a compile error rather than a
- * column that quietly loses half its declaration.
- */
+/** A column as the builder describes one: a {@link ColumnNode} without its graph links. */
 export type ColumnDefinition = Omit<ColumnNode, 'table' | 'referencedBy' | 'references'>;
 /**
  * The foreign key a single column declares: {@link ForeignKeySchema} without the local columns, which
@@ -260,13 +253,7 @@ export interface IForeignKeyBuilder extends IColumnBuilder {
     /** Set ON UPDATE action */
     onUpdate(action: ForeignKeyAction): this;
 }
-/**
- * The column vocabulary: every column type the builder can declare, name first.
- *
- * Split out of {@link ITableBuilder} so `addColumn`/`alterColumn` can hand it to their callback. They
- * used to take an {@link IColumnBuilder}, which has no way to say what type a column is - so the
- * builder hard-coded `VARCHAR`, and every column a generated migration added or altered was a string.
- */
+/** Every column type the builder can declare, name first, handed to `addColumn`/`alterColumn` callbacks too. */
 export interface IColumnFactory {
     /** Add an auto-incrementing primary key */
     id(name?: string, options?: BaseColumnOptions): IColumnBuilder;

package/dist/migrate/cli-config.js

@@ -2,17 +2,8 @@ import { stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 /**
- * Loads the config with a plain `import()`, leaving TypeScript to whatever runs the CLI.
- *
- * @remarks uql deliberately bundles no transpiler. The config imports the entity classes, so whoever
- * loads it decides which decorator spec their decorators are invoked with, and only the runtime knows
- * the project's `tsconfig.json`. Bun and `node --import tsx` both get it right; a bundled loader would
- * be guessing, and `jiti` guessed wrong (it hardcodes the legacy transform, so standard decorators were
- * called as `(prototype, key)` and every field was silently dropped).
- *
- * Node's own type stripping covers a config that is only types plus a plain object, which is why the
- * error below distinguishes the two cases: decorators are not erasable syntax, so a config that reaches
- * decorated entity classes needs a runtime that actually transforms them.
+ * Loads the config with a plain `import()`, leaving TypeScript to the runtime: uql bundles no transpiler,
+ * since only the project knows its decorator spec. Node's type stripping handles no decorators.
  */
 async function importConfig(path) {
     const mod = (await import(pathToFileURL(path).href).catch((cause) => {

package/dist/migrate/cli.js

@@ -76,11 +76,7 @@ export async function main(args = process.argv.slice(2)) {
                 printHelp();
                 process.exit(1);
         }
-        // Close the connection pool
-        const pool = config.pool;
-        if (pool.end) {
-            await pool.end();
-        }
+        await config.pool.end();
     }
     catch (error) {
         console.error('Error:', error.message);
@@ -202,8 +198,7 @@ export async function runSync(migrator, args, config) {
     const force = args.includes('--force');
     const safe = !args.includes('--unsafe');
     const options = { force, safe, drop: !safe };
-    // Ahead of the warning as well as of the run: `--dry-run` means the same thing whatever else was
-    // asked for, and it used to be ignored beside `--force`.
+    // Ahead of the warning and the run: `--dry-run` means the same whatever else was asked for, `--force` included.
     if (args.includes('--dry-run')) {
         const statements = await migrator.planSync(options);
         console.log(statements.length ? `\n${statements.join('\n')}` : '\nSchema is already in sync.');

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

@@ -1,14 +1,3 @@
-/**
- * Entity Code Generator
- *
- * Generates TypeScript entity files from SchemaAST.
- * Supports:
- * - ES Module syntax
- * - TypeScript types
- * - Relations with proper decorators
- * - Indexes
- * - JSDoc comments for sync-added fields
- */
 import type { SchemaAST } from '../../schema/schemaAST.js';
 /**
  * Options for entity code generation.
@@ -107,10 +96,6 @@ export declare class EntityCodeGenerator {
      * Build incoming relation (OneToMany where other tables have FK to this).
      */
     private buildIncomingRelation;
-    /**
-     * Get decorator name for relation type.
-     */
-    private getRelationDecoratorName;
     /**
      * Format type for description.
      */

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -1,20 +1,16 @@
-/**
- * Entity Code Generator
- *
- * Generates TypeScript entity files from SchemaAST.
- * Supports:
- * - ES Module syntax
- * - TypeScript types
- * - Relations with proper decorators
- * - Indexes
- * - JSDoc comments for sync-added fields
- */
 import { canonicalToTypeScript } from '../../schema/canonicalType.js';
 import { DEFAULT_FOREIGN_KEY_ACTION, } from '../../schema/types.js';
 import { camelCase, lowerFirst, pascalCase, singularize } from '../../util/string.util.js';
 import { buildFieldOptionsSource, fieldNeedsRaw } from './fieldOptionsSource.js';
 import { buildIndexDecoratorSource, indexNeedsRaw, isPlainFieldIndex } from './indexDecoratorSource.js';
 import { memberSource } from './sourceLiteral.js';
+/** The decorator on the other side of a relation. */
+const INVERSE_RELATION = {
+    OneToOne: 'OneToOne',
+    OneToMany: 'ManyToOne',
+    ManyToOne: 'OneToMany',
+    ManyToMany: 'ManyToMany',
+};
 /**
  * Generates TypeScript entity code from SchemaAST.
  */
@@ -87,7 +83,7 @@ export class EntityCodeGenerator {
         // Check for relation decorators
         if (this.options.includeRelations) {
             for (const rel of [...table.incomingRelations, ...table.outgoingRelations]) {
-                uqlImports.add(this.getRelationDecoratorName(rel.type));
+                uqlImports.add(rel.type);
                 const relatedTable = rel.from.table === table ? rel.to.table : rel.from.table;
                 const relatedClassName = this.options.classNameTransformer(relatedTable.name);
                 if (!relatedImports.includes(relatedClassName)) {
@@ -175,7 +171,7 @@ export class EntityCodeGenerator {
      * Build Field decorator options.
      */
     buildFieldOptions(col, propertyName) {
-        const indexes = this.options.includeIndexes ? this.ast.getTableIndexes(col.table.name) : [];
+        const indexes = this.options.includeIndexes ? col.table.indexes : [];
         const fieldIndex = indexes.find((idx) => isPlainFieldIndex(idx) && idx.entries[0]?.column === col.name);
         return buildFieldOptionsSource(col, propertyName, fieldIndex?.name);
     }
@@ -184,7 +180,7 @@ export class EntityCodeGenerator {
      * carry on its own.
      */
     declaredIndexes(table) {
-        return this.ast.getTableIndexes(table.name).filter((index) => !isPlainFieldIndex(index));
+        return table.indexes.filter((index) => !isPlainFieldIndex(index));
     }
     /**
      * Build relation definitions.
@@ -222,15 +218,11 @@ export class EntityCodeGenerator {
         else {
             propertyName = this.options.propertyNameTransformer(this.options.singularize(rel.to.table.name));
         }
-        const decoratorName = this.getRelationDecoratorName(rel.type);
         // JSDoc
         if (this.options.addSyncComments) {
             lines.push('  /**');
             lines.push(`   * @sync-added ${new Date().toISOString().split('T')[0]}`);
             lines.push(`   * Relation to ${rel.to.table.name} via ${rel.from.columns.map((c) => c.name).join(', ')}`);
-            if (rel.confidence !== undefined && rel.confidence < 1.0) {
-                lines.push(`   * Inferred (${(rel.confidence * 100).toFixed(0)}% confidence)`);
-            }
             lines.push('   */');
         }
         // Decorator. `onDelete`/`onUpdate` only when introspection found a real referential action, so a
@@ -243,7 +235,7 @@ export class EntityCodeGenerator {
             options.push(`onDelete: '${rel.onDelete}'`);
         if (rel.onUpdate && rel.onUpdate !== DEFAULT_FOREIGN_KEY_ACTION)
             options.push(`onUpdate: '${rel.onUpdate}'`);
-        lines.push(`  @${decoratorName}({ ${options.join(', ')} })`);
+        lines.push(`  @${rel.type}({ ${options.join(', ')} })`);
         // Property
         lines.push(`  ${propertyName}?: ${relatedClassName};`);
         return lines.join('\n');
@@ -274,8 +266,6 @@ export class EntityCodeGenerator {
         const lines = [];
         const relatedClassName = this.options.classNameTransformer(rel.from.table.name);
         const propertyName = this.options.propertyNameTransformer(rel.from.table.name);
-        const inverseType = this.ast.getInverseRelationType(rel.type);
-        const decoratorName = this.getRelationDecoratorName(inverseType);
         // JSDoc
         if (this.options.addSyncComments) {
             lines.push('  /**');
@@ -286,31 +276,12 @@ export class EntityCodeGenerator {
         // The inverse side, mapped by the related class's property that points back at this one.
         const param = lowerFirst(relatedClassName);
         const inverse = memberSource(param, this.options.propertyNameTransformer(this.options.singularize(table.name)));
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${inverse} })`);
-        // Property
-        if (inverseType === 'OneToMany' || inverseType === 'ManyToMany') {
-            lines.push(`  ${propertyName}?: ${relatedClassName}[];`);
-        }
-        else {
-            lines.push(`  ${propertyName}?: ${relatedClassName};`);
-        }
+        const inverseType = INVERSE_RELATION[rel.type];
+        lines.push(`  @${inverseType}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${inverse} })`);
+        const many = inverseType === 'OneToMany' || inverseType === 'ManyToMany';
+        lines.push(`  ${propertyName}?: ${relatedClassName}${many ? '[]' : ''};`);
         return lines.join('\n');
     }
-    /**
-     * Get decorator name for relation type.
-     */
-    getRelationDecoratorName(type) {
-        switch (type) {
-            case 'OneToOne':
-                return 'OneToOne';
-            case 'OneToMany':
-                return 'OneToMany';
-            case 'ManyToOne':
-                return 'ManyToOne';
-            case 'ManyToMany':
-                return 'ManyToMany';
-        }
-    }
     /**
      * Format type for description.
      */

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

@@ -1,12 +1,5 @@
 import type { ColumnNode } from '../../schema/types.js';
-/**
- * A column's `@Field({ ... })` options as source, or `''` when it needs none.
- *
- * Shared by the entity generator and the merger because they emit the same decorator. They each had
- * their own copy, and the copies had drifted: the merger's dropped `unique` and `defaultValue`, so
- * merging a column into an existing entity file quietly produced a weaker field than generating the
- * file from scratch.
- */
+/** A column's `@Field({ ... })` options as source, `''` where it needs none: shared by the generator and the merger. */
 export declare function buildFieldOptionsSource(col: ColumnNode, propertyName: string, indexName?: string): string;
 /** Whether the field's decorator needs `raw` imported, the way {@link indexNeedsRaw} does for an index. */
 export declare function fieldNeedsRaw(col: ColumnNode): boolean;

package/dist/migrate/codegen/fieldOptionsSource.js

@@ -1,14 +1,6 @@
 import { canonicalToColumnType } from '../../schema/canonicalType.js';
 import { quoted, rawTag } from './sourceLiteral.js';
-/**
- * What each field of a {@link ColumnNode} contributes to `@Field({ ... })`, in emit order, and `null`
- * where nothing does.
- *
- * The `satisfies` is the point: a field the node gains cannot reach here without someone answering
- * whether an entity generated from a database keeps it. Written as a hand-rolled `if` chain, this had
- * already dropped `comment` - introspection reads one on Postgres and MySQL, and regenerating an
- * entity threw it away.
- */
+/** What each field of a {@link ColumnNode} contributes to `@Field({ ... })`, in emit order; `satisfies` makes a new field answer. */
 const OPTION_SOURCE = {
     // Without this the entity maps to a column named after the property, which for anything the
     // transformer rewrote - every `user_id` - is a column the database does not have.
@@ -36,14 +28,7 @@ const OPTION_SOURCE = {
     references: null,
     referencedBy: null,
 };
-/**
- * A column's `@Field({ ... })` options as source, or `''` when it needs none.
- *
- * Shared by the entity generator and the merger because they emit the same decorator. They each had
- * their own copy, and the copies had drifted: the merger's dropped `unique` and `defaultValue`, so
- * merging a column into an existing entity file quietly produced a weaker field than generating the
- * file from scratch.
- */
+/** A column's `@Field({ ... })` options as source, `''` where it needs none: shared by the generator and the merger. */
 export function buildFieldOptionsSource(col, propertyName, indexName) {
     const context = { propertyName, indexName };
     const options = [
@@ -57,11 +42,7 @@ export function buildFieldOptionsSource(col, propertyName, indexName) {
 export function fieldNeedsRaw(col) {
     return col.generatedAs !== undefined;
 }
-/**
- * A default value as source. Strings stay single-quoted, expressions included: `defaultValue: 'now()'`
- * is what reaches the DDL. The generator used to branch on `CURRENT_TIMESTAMP`/`NEXTVAL`/`(` first, but
- * both branches emitted a quoted string and only the fallthrough escaped embedded quotes.
- */
+/** A default value as source, a string single-quoted and escaped, an expression included: `defaultValue: 'now()'`. */
 function defaultValueSource(value) {
     if (typeof value === 'string') {
         return quoted(value);

package/dist/migrate/ddl/indexDdl.d.ts

@@ -6,11 +6,8 @@ export declare function assertIndexType(index: IndexSchema, types: ReadonlySet<I
 /** Refuses an index asking for a feature `features` lacks. */
 export declare function assertIndexFeatures(index: IndexSchema, features: ReadonlySet<IndexFeature>, dialectName: string): void;
 /**
- * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
- * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
- * emits DDL - which is what keeps a `CAST(... ARRAY)` table out of every runtime consumer's entry.
- * The form here is the portable one, which SQLite (and so libSQL, Turso and D1) takes verbatim: no
- * access-method clause, no operator classes, no tuning parameters.
+ * `CREATE INDEX` in its portable form, which the SQLite family takes as is; the engines with more override
+ * the fragments. The migrator's own, so no runtime entry carries it.
  */
 export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect> {
     protected readonly dialect: D;

package/dist/migrate/ddl/indexDdl.js

@@ -32,11 +32,8 @@ export function assertIndexFeatures(index, features, dialectName) {
     }
 }
 /**
- * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
- * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
- * emits DDL - which is what keeps a `CAST(... ARRAY)` table out of every runtime consumer's entry.
- * The form here is the portable one, which SQLite (and so libSQL, Turso and D1) takes verbatim: no
- * access-method clause, no operator classes, no tuning parameters.
+ * `CREATE INDEX` in its portable form, which the SQLite family takes as is; the engines with more override
+ * the fragments. The migrator's own, so no runtime entry carries it.
  */
 export class IndexDdl {
     dialect;