uql-orm 0.64.0 → 0.65.1

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, entitySql, entityWhere, fieldOptionConflict, getKeys, hasKeys, isToManyRelation, lowerFirst, memberRefs, normalizeIndexColumn, upperFirst, definedEntries, } from '../../util/index.js';
+import { entitySql, entityWhere, fieldOptionConflict, getKeys, hasKeys, isToManyRelation, lowerFirst, memberRefs, normalizeIndexColumn, upperFirst, definedEntries, } from '../../util/index.js';
 import { ownRegistrations } from '../decorator/bag.js';
 /**
  * A map held on `globalThis` through the global symbol registry, so a single one survives multiple
@@ -54,10 +54,11 @@ export function defineRelation(entity, key, opts) {
  * exist, and the registry holds data alone.
  */
 export function relationRegistration({ mappedBy, references, ...opts }) {
+    const joined = references?.(keyMap(), keyMap());
     return {
         ...opts,
         ...(mappedBy && { mappedBy: mappedBy(keyMap()) }),
-        ...(references && { references: [...references(keyMap(), keyMap())] }),
+        ...(joined && { references: typeof joined === 'string' ? joined : [...joined] }),
     };
 }
 /** Every entity's key map: a callback only reads one property off it, and that property is its own key. */
@@ -70,8 +71,8 @@ function addRelation(entity, key, registration) {
         throw new TypeError(`'${entity.name}.${key}' needs an 'entity' getter, e.g. '@ManyToOne({ entity: () => Company })'.`);
     }
     if (registration.through && registration.references) {
-        throw new TypeError(`'${entity.name}.${key}' joins through a junction, whose columns follow the convention; 'references' ` +
-            "pairs the declaring entity's columns with the target's instead.");
+        throw new TypeError(`'${entity.name}.${key}' joins through a junction, whose column referencing each side is the join; ` +
+            "'references' pairs the declaring entity's columns with the target's instead.");
     }
     const meta = ensureWritableMeta(entity);
     // Registration writes into a map declared as resolved: `getMeta` runs `fillRelations`, which settles
@@ -305,77 +306,109 @@ function ensureMeta(entity) {
     return meta;
 }
 export function getMeta(entity) {
+    const meta = registeredMeta(entity);
+    // Stamped once finalizing succeeds, so a read after a failure reports the same mistake again. Finalizing
+    // reads other entities without resolving them, so no entity is ever read half resolved.
+    if (meta.processedAt !== meta.revision) {
+        fillRelations(meta);
+        meta.processedAt = meta.revision;
+    }
+    return meta;
+}
+/** The metadata `entity` registered, however much of it is resolved. */
+function registeredMeta(entity) {
     const meta = metas.get(entity);
     if (!meta) {
         throw TypeError(`'${entity.name}' is not an entity`);
     }
-    if (meta.processedAt === meta.revision) {
-        return meta;
-    }
-    // Stamped before finalizing, not after: `fillInverseSide` reads the other side through `getMeta`,
-    // and with each side mapped by the other that recursion has to find this half-filled meta rather
-    // than run again. Finalizing twice is harmless anyway - every step of it skips what it settled.
-    meta.processedAt = meta.revision;
-    return fillRelations(meta);
+    return meta;
 }
 function fillRelations(meta) {
     for (const [relKey, relation] of definedEntries(meta.relations)) {
-        // The registered view: `references` may be unset until this settles it.
-        const relOpts = relation;
         const at = `'${meta.entity.name}.${relKey}'`;
-        if (relOpts.mappedBy) {
-            fillInverseSide(at, meta, relOpts, relOpts.mappedBy);
-        }
-        else if (!relOpts.references) {
-            fillOwningSide(at, meta, relKey, relOpts);
-        }
-        if (!relOpts.references?.length) {
+        if (!settledReferences(at, meta, relKey, relation).length) {
             throw new TypeError(`${at} has no columns to join on.`);
         }
-        // Hand-written `references` land here too: naming the columns says which they are, not that they exist.
-        if (relOpts.through) {
-            const junction = getMeta(relOpts.through());
-            for (const { local } of relOpts.references) {
-                if (junction.fields[local])
-                    continue;
-                throw new TypeError(`${at} joins through '${junction.entity.name}', which has no '${local}' field: a junction's ` +
-                    'columns are named after the entities it joins. Declare it.');
-            }
+    }
+    // A column `references` names is a foreign key with or without a relation over it, and one cannot point
+    // at a composite key: refused on first read, as a relation that cannot join is, not at the schema build.
+    foreignKeysOf(meta);
+}
+/**
+ * The pairs a relation joins on, settled on first read, whether its own entity is being resolved or another
+ * needs it. Never resolving an entity is what keeps it from recursing, and the one column a to-one names is
+ * paired with its target's key only here, since registration can run before the target has one.
+ */
+function settledReferences(at, meta, relKey, relOpts) {
+    const { references, mappedBy, through } = relOpts;
+    if (typeof references === 'string') {
+        const target = ensureMeta(relOpts.entity());
+        if (mappedBy || isToManyRelation(relOpts) || target.ids.length > 1) {
+            throw new TypeError(`${at} names one column, '${references}', which only a to-one holding a foreign key to a one-column key ` +
+                'can: pair the columns, [{ local, foreign }].');
         }
+        relOpts.references = [{ local: references, foreign: soleIdOf(target, 'a foreign key') }];
+        return relOpts.references;
     }
-    fillForeignKeyRelations(meta);
-    return meta;
+    if (references)
+        return references;
+    if (mappedBy)
+        return fillInverseSide(at, meta, relOpts, mappedBy);
+    if (through)
+        return fillThrough(at, meta, relOpts, through);
+    return fillOwningSide(at, meta, relKey, relOpts);
 }
-function fillOwningSide(at, meta, relKey, relOpts) {
-    const relMeta = ensureMeta(relOpts.entity());
-    if (relOpts.through) {
-        // Both columns live on the junction, whatever the cardinality: `deleteRelations` and every dialect
-        // read them as junction columns. A composite key contributes one pair per column of it, which is
-        // what makes the join address a whole key rather than part.
-        relOpts.references = [
-            ...meta.ids.map((key) => ({ local: junctionColumn(meta, key), foreign: key })),
-            ...relMeta.ids.map((key) => ({ local: junctionColumn(relMeta, key), foreign: key })),
-        ];
-        return;
+/**
+ * Settles each relation joining on its own entity's columns, every one but an inverse side and a `through`:
+ * the columns they create and the foreign keys they hold are what another entity reads off this one.
+ */
+function settleOwnColumns(meta) {
+    for (const [relKey, relation] of definedEntries(meta.relations)) {
+        if (!relation.mappedBy && !relation.through) {
+            settledReferences(`'${meta.entity.name}.${relKey}'`, meta, relKey, relation);
+        }
     }
+}
+/**
+ * Each key of this entity, then each of the target, paired with the junction's one column referencing it.
+ * Both groups live on the junction whatever the cardinality, as `deleteRelations` and every dialect read
+ * them, and a composite key gives a pair per column, which is what makes a join address a whole key.
+ */
+function fillThrough(at, meta, relOpts, through) {
+    const junction = registeredMeta(through());
+    relOpts.references = [
+        ...junctionReferences(at, junction, meta),
+        ...junctionReferences(at, junction, ensureMeta(relOpts.entity())),
+    ];
+    return relOpts.references;
+}
+function fillOwningSide(at, meta, relKey, relOpts) {
     if (isToManyRelation(relOpts)) {
         throw new TypeError(`${at} is a to-many relation with no way to join: it needs 'mappedBy' (the field on the other side), ` +
             "'through' (a junction entity), or 'references' (the columns).");
     }
+    const relMeta = ensureMeta(relOpts.entity());
     // `<rel>Id` for the one-key case it has always been; `<rel><Key>` per column otherwise. Both name a
     // property, so both are spelled from the referenced *property* - a column name is what the naming
     // strategy makes of this afterwards.
     const sole = relMeta.ids.length === 1;
-    relOpts.references = relMeta.ids.map((key) => ({
+    const references = relMeta.ids.map((key) => ({
         local: sole ? `${relKey}Id` : `${relKey}${upperFirst(key)}`,
         foreign: key,
     }));
+    // A column the entity declares would be joined by its name alone, so renaming either one would leave
+    // the other behind, still compiling.
+    const fields = meta.fields;
+    if (references.some(({ local }) => fields[local])) {
+        const own = lowerFirst(meta.entity.name);
+        throw new TypeError(`${at} joins ${references.map(({ local }) => `'${local}'`).join(', ')} by name, which a rename does not ` +
+            `follow: link them with ${sole ? `'references: (${own}) => ${own}.${references[0].local}'` : "'references' pairs"}.`);
+    }
     // `typeFromReference` so schema generation resolves the referenced primary key's exact type
     // (columnType, length, chained keys) rather than trusting the fallback, as it does for an
     // explicit `@Field({ references })`.
-    const fields = meta.fields;
-    for (const { local, foreign } of relOpts.references) {
-        fields[local] ??= {
+    for (const { local, foreign } of references) {
+        fields[local] = {
             name: local,
             type: fieldOf(relMeta, foreign).type ?? Number,
             references: relOpts.entity,
@@ -383,80 +416,87 @@ function fillOwningSide(at, meta, relKey, relOpts) {
             typeFromReference: true,
         };
     }
+    relOpts.references = references;
+    return references;
 }
 function fillInverseSide(at, meta, relOpts, mappedBy) {
-    const relEntity = relOpts.entity();
-    const relMeta = getMeta(relEntity);
-    if (relOpts.references)
-        return;
+    const relMeta = registeredMeta(relOpts.entity());
+    const other = `'${relMeta.entity.name}.${mappedBy}'`;
+    // The other side's own columns first: they declare, or create, what this side is mapped by.
+    settleOwnColumns(relMeta);
     if (relMeta.fields[mappedBy]) {
         if (meta.ids.length > 1) {
-            throw new TypeError(`${at} is mapped by '${relEntity.name}.${mappedBy}', one column, but the primary key of ` +
+            throw new TypeError(`${at} is mapped by ${other}, one column, but the primary key of ` +
                 `'${meta.entity.name}' is composite (${meta.ids.join(', ')}). Map it by the relation on the other side ` +
                 'instead, which joins every column of the key.');
         }
         // `local` is this entity's own key, as in every other pair.
         relOpts.references = [{ local: meta.ids[0], foreign: mappedBy }];
-        return;
+        return relOpts.references;
     }
-    // Authored view again: with each side mapped by the other, the target is still mid-resolution here and
-    // its own `references` are unset, which is what the second throw reports.
     const owner = relMeta.relations[mappedBy];
     if (!owner) {
-        throw new TypeError(`${at} is mapped by '${mappedBy}', which is neither a field nor a relation of '${relEntity.name}'.`);
+        throw new TypeError(`${at} is mapped by '${mappedBy}', which is neither a field nor a relation of '${relMeta.entity.name}'.`);
     }
-    if (!owner.references?.length) {
-        throw new TypeError(`${at} is mapped by '${relEntity.name}.${mappedBy}', an inverse side too, so neither owns the foreign key.`);
+    if (owner.mappedBy) {
+        throw new TypeError(`${at} is mapped by ${other}, an inverse side too, so neither owns the foreign key.`);
     }
+    const ownerReferences = settledReferences(other, relMeta, mappedBy, owner);
     // Two different flips: a junction's pairs are the owner's group followed by ours, so the two groups
     // swap - `toReversed` would also reverse each group, pairing a composite's columns crosswise. A
     // plain foreign key is one pair per key whose ends swap.
     relOpts.references =
         relOpts.cardinality === 'm1' || relOpts.cardinality === 'mm'
-            ? [...owner.references.slice(relMeta.ids.length), ...owner.references.slice(0, relMeta.ids.length)]
-            : owner.references.map(({ local, foreign }) => ({ local: foreign, foreign: local }));
+            ? [...ownerReferences.slice(relMeta.ids.length), ...ownerReferences.slice(0, relMeta.ids.length)]
+            : ownerReferences.map(({ local, foreign }) => ({ local: foreign, foreign: local }));
     relOpts.through = owner.through;
+    return relOpts.references;
 }
 /**
- * A field carrying `references` is a foreign key, and a foreign key is a many-to-one whether or not
- * anyone declared the relation. Deriving it everywhere is what lets a junction be written as two plain
- * columns: it needs the relations for `$populate` and for its DDL constraints, and it used to get them
- * only because some *other* entity pointed `through` at it. Gaps only, so a declared relation keeps its
- * own cardinality and `cascade`.
+ * The foreign keys an entity holds: each owning to-one's columns, and each `@Field({ references })` no
+ * relation joins on, as the many-to-one it describes, once its target has registered a key. What the
+ * schema build constrains and a junction joins by, read once the relations holding them are settled.
  */
-function fillForeignKeyRelations(meta) {
-    const joined = new Set(definedEntries(meta.relations).flatMap(([, relation]) => relation.references.map(({ local }) => local)));
-    for (const [fieldKey, { references }] of definedEntries(meta.fields)) {
-        if (!references || joined.has(fieldKey))
-            continue;
-        const target = ensureMeta(references());
-        // Nothing to derive from an entity that has not registered its own fields yet.
+export function foreignKeysOf(meta) {
+    settleOwnColumns(meta);
+    const owning = definedEntries(meta.relations)
+        .map(([, relation]) => relation)
+        .filter((relation) => !relation.mappedBy && !relation.through && !isToManyRelation(relation));
+    const joined = new Set(owning.flatMap(({ references }) => references.map(({ local }) => local)));
+    const columns = definedEntries(meta.fields).flatMap(([key, field]) => {
+        if (!field.references || joined.has(key))
+            return [];
+        const target = ensureMeta(field.references());
         if (!target.ids.length)
-            continue;
+            return [];
         if (target.ids.length > 1) {
-            throw new TypeError(`'${meta.entity.name}.${fieldKey}' cannot reference '${target.entity.name}', whose primary key is composite ` +
+            throw new TypeError(`'${meta.entity.name}.${key}' cannot reference '${target.entity.name}', whose primary key is composite ` +
                 `(${target.ids.join(', ')}): a column points at one. Use ` +
                 `'@ManyToOne({ entity: () => ${target.entity.name} })', which declares one column per key.`);
         }
-        const [foreign] = target.ids;
-        // The relation takes the column's name minus the key it points at (`itemId` -> `item`); a column
-        // named anything else has no name to take, so it stays a plain foreign key.
-        const suffix = upperFirst(foreign);
-        if (!fieldKey.endsWith(suffix))
-            continue;
-        const relKey = fieldKey.slice(0, -suffix.length);
-        if (!relKey || meta.fields[relKey] || meta.relations[relKey])
-            continue;
-        meta.relations[relKey] = {
-            entity: references,
-            cardinality: 'm1',
-            references: [{ local: fieldKey, foreign }],
-        };
-    }
-}
-/** `<entityName><IdColumn>`, not the `<relationKey>Id` an owning to-one derives: a junction row has no relation key to borrow from. */
-function junctionColumn(meta, idKey) {
-    return lowerFirst(entityName(meta)) + upperFirst(fieldOf(meta, idKey).name ?? idKey);
+        return [{ entity: field.references, cardinality: 'm1', references: [{ local: key, foreign: target.ids[0] }] }];
+    });
+    return [...owning, ...columns];
+}
+/** Each key of `side`, paired with the one column of `junction` referencing it: a rename of either follows. */
+function junctionReferences(at, junction, side) {
+    const pairs = foreignKeysOf(junction).flatMap(({ entity, references }) => entity() === side.entity ? references : []);
+    return side.ids.map((key) => {
+        const [pair, ...others] = pairs.filter(({ foreign }) => foreign === key);
+        const referenced = `'${side.entity.name}.${key}'`;
+        if (!pair) {
+            const declare = side.ids.length > 1
+                ? `@ManyToOne({ entity: () => ${side.entity.name} })`
+                : `@Field({ references: () => ${side.entity.name} })`;
+            throw new TypeError(`${at} joins through '${junction.entity.name}', which has no column referencing ${referenced}: declare one, '${declare}'.`);
+        }
+        if (others.length) {
+            const columns = [pair, ...others].map(({ local }) => `'${local}'`).join(' and ');
+            throw new TypeError(`${at} joins through '${junction.entity.name}', where ${columns} each reference ${referenced}: a junction ` +
+                'needs exactly one column per key of each side.');
+        }
+        return { local: pair.local, foreign: key };
+    });
 }
 /** Every key the entity marks, in declaration order. More than one is a composite primary key. */
 function getIdKeys(meta) {
@@ -490,7 +530,12 @@ function extendMeta(target, source) {
         }
     }
     target.fields = { ...sourceFields, ...target.fields };
-    target.relations = { ...source.relations, ...target.relations };
+    // A copy of each relation per entity: resolving one writes the columns it joins on into it, and those
+    // columns are the resolving entity's, so one shared object left every later entity without them.
+    target.relations = {
+        ...Object.fromEntries(definedEntries(source.relations).map(([key, relation]) => [key, { ...relation }])),
+        ...target.relations,
+    };
     // Inherit user-defined filters from the parent (child overrides by name). The built-in soft-delete
     // filter + `meta.softDelete` are (re)derived from the merged fields in `defineEntity`.
     if (source.filters) {

package/dist/migrate/cli.d.ts

@@ -14,5 +14,5 @@ export declare function runGenerateFromEntities(migrator: Migrator, args: string
  */
 export declare function runTypes(migrator: Migrator, args: string[]): void;
 export declare function runSync(migrator: Migrator, args: string[], config: Partial<Config>): Promise<void>;
-export declare function runGenerateFromDb(migrator: Migrator, args: string[], config: Partial<Config>): Promise<void>;
+export declare function runGenerateFromDb(migrator: Migrator, args: string[]): Promise<void>;
 export declare function runDriftCheck(migrator: Migrator, config: Partial<Config>): Promise<void>;

package/dist/migrate/cli.js

@@ -56,7 +56,7 @@ export async function main(args = process.argv.slice(2)) {
                 break;
             case 'generate:from-db':
             case 'generate-from-db':
-                await runGenerateFromDb(migrator, filteredArgs.slice(1), config);
+                await runGenerateFromDb(migrator, filteredArgs.slice(1));
                 break;
             case 'sync':
                 await runSync(migrator, filteredArgs.slice(1), config);
@@ -197,7 +197,7 @@ function readOutput(args) {
 export async function runSync(migrator, args, config) {
     // Pulling the database into entity files is what `generate:from-db` does; one implementation.
     if (args.includes('--pull')) {
-        return runGenerateFromDb(migrator, args, config);
+        return runGenerateFromDb(migrator, args);
     }
     const force = args.includes('--force');
     const safe = !args.includes('--unsafe');
@@ -216,46 +216,32 @@ export async function runSync(migrator, args, config) {
     await migrator.sync({ ...options, logging: true });
     console.log('\nSchema sync completed.');
 }
-export async function runGenerateFromDb(migrator, args, config) {
+export async function runGenerateFromDb(migrator, args) {
     const outputDir = readOutput(args) ?? './src/entities';
-    if (!migrator.schemaIntrospector) {
-        console.error('No introspector available. Check your pool configuration.');
-        process.exit(1);
-    }
-    else {
-        console.log('\nAnalyzing database schema...');
-        const ast = await migrator.schemaIntrospector.introspect();
-        const tableCount = ast.tables.size;
-        console.log(`Found ${tableCount} table(s): ${Array.from(ast.tables.keys()).join(', ')}`);
-        console.log('\nGenerating entities...');
-        const generator = createEntityCodeGenerator(ast, {
-            addSyncComments: true,
-            includeRelations: true,
-            includeIndexes: true,
-        });
-        const entities = generator.generateAll();
-        // Ensure output directory exists
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
-        }
-        // Write entity files
-        for (const entity of entities) {
-            const filePath = path.join(outputDir, entity.fileName);
-            fs.writeFileSync(filePath, entity.code, 'utf-8');
-            console.log(`  ✓ ${entity.className} -> ${filePath}`);
-        }
-        console.log(`\nGenerated ${entities.length} entities to ${outputDir}`);
+    console.log('\nAnalyzing database schema...');
+    const ast = await migrator.schemaIntrospector.introspect();
+    const tableCount = ast.tables.size;
+    console.log(`Found ${tableCount} table(s): ${Array.from(ast.tables.keys()).join(', ')}`);
+    console.log('\nGenerating entities...');
+    const generator = createEntityCodeGenerator(ast, {
+        addSyncComments: true,
+        includeRelations: true,
+        includeIndexes: true,
+    });
+    const entities = generator.generateAll();
+    fs.mkdirSync(outputDir, { recursive: true });
+    for (const entity of entities) {
+        const filePath = path.join(outputDir, entity.fileName);
+        fs.writeFileSync(filePath, entity.code, 'utf-8');
+        console.log(`  ✓ ${entity.className} -> ${filePath}`);
     }
+    console.log(`\nGenerated ${entities.length} entities to ${outputDir}`);
 }
 export async function runDriftCheck(migrator, config) {
     if (!config.entities || config.entities.length === 0) {
         console.error('No entities configured. Add entities to your uql config.');
         process.exit(1);
     }
-    else if (!migrator.schemaIntrospector) {
-        console.error('No introspector available. Check your pool configuration.');
-        process.exit(1);
-    }
     else {
         console.log('\nChecking for schema drift...');
         const expectedAST = buildEntityAST(await migrator.getSchemaGenerator(), config.entities);

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

@@ -98,6 +98,11 @@ export declare class EntityCodeGenerator {
      * Build outgoing relation (ManyToOne or OneToOne where this table has FK).
      */
     private buildOutgoingRelation;
+    /**
+     * The `references` callback of a to-one: its foreign key column where that is the target's whole primary
+     * key, column pairs otherwise, and nothing when the columns do not pair up.
+     */
+    private referencesSource;
     /**
      * Build incoming relation (OneToMany where other tables have FK to this).
      */

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -14,6 +14,7 @@ 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';
 /**
  * Generates TypeScript entity code from SchemaAST.
  */
@@ -234,17 +235,38 @@ export class EntityCodeGenerator {
         }
         // Decorator. `onDelete`/`onUpdate` only when introspection found a real referential action, so a
         // round-trip through an unconstrained column stays as terse as before.
-        const fkActions = [];
+        const options = [`entity: () => ${relatedClassName}`];
+        const references = this.referencesSource(rel, relatedClassName);
+        if (references)
+            options.push(`references: ${references}`);
         if (rel.onDelete && rel.onDelete !== DEFAULT_FOREIGN_KEY_ACTION)
-            fkActions.push(`onDelete: '${rel.onDelete}'`);
+            options.push(`onDelete: '${rel.onDelete}'`);
         if (rel.onUpdate && rel.onUpdate !== DEFAULT_FOREIGN_KEY_ACTION)
-            fkActions.push(`onUpdate: '${rel.onUpdate}'`);
-        const fkActionsSource = fkActions.length ? `, ${fkActions.join(', ')}` : '';
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}${fkActionsSource} })`);
+            options.push(`onUpdate: '${rel.onUpdate}'`);
+        lines.push(`  @${decoratorName}({ ${options.join(', ')} })`);
         // Property
         lines.push(`  ${propertyName}?: ${relatedClassName};`);
         return lines.join('\n');
     }
+    /**
+     * The `references` callback of a to-one: its foreign key column where that is the target's whole primary
+     * key, column pairs otherwise, and nothing when the columns do not pair up.
+     */
+    referencesSource(rel, relatedClassName) {
+        if (!rel.from.columns.length || rel.from.columns.length !== rel.to.columns.length) {
+            return undefined;
+        }
+        const member = (param, column) => memberSource(param, this.options.propertyNameTransformer(column.name));
+        const own = lowerFirst(this.options.classNameTransformer(rel.from.table.name));
+        const key = rel.to.table.primaryKey;
+        if (rel.from.columns.length === 1 && key.length === 1 && rel.to.columns[0].name === key[0].name) {
+            return `(${own}) => ${member(own, rel.from.columns[0])}`;
+        }
+        const target = lowerFirst(relatedClassName);
+        const [local, foreign] = own === target ? ['local', 'foreign'] : [own, target];
+        const pairs = rel.from.columns.map((column, i) => `{ local: ${member(local, column)}, foreign: ${member(foreign, rel.to.columns[i])} }`);
+        return `(${local}, ${foreign}) => [${pairs.join(', ')}]`;
+    }
     /**
      * Build incoming relation (OneToMany where other tables have FK to this).
      */
@@ -262,9 +284,9 @@ export class EntityCodeGenerator {
             lines.push('   */');
         }
         // The inverse side, mapped by the related class's property that points back at this one.
-        const inverseProp = this.options.propertyNameTransformer(this.options.singularize(table.name));
         const param = lowerFirst(relatedClassName);
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${param}.${inverseProp} })`);
+        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}[];`);

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,5 +1,5 @@
 import { isVectorIndexType } from '../../type/index.js';
-import { isIdentifierName, quoted, rawTag } from './sourceLiteral.js';
+import { memberSource, rawTag } from './sourceLiteral.js';
 /**
  * A vector index carries its metric in the operator class pgvector names after it
  * (`vector_cosine_ops`), which is the only place introspection can recover it from. `@Index` requires
@@ -93,7 +93,3 @@ function indexEntrySource(entry, propertyName, param) {
     const modifiers = significantModifiers(entry);
     return modifiers.length === 0 ? column : `{ column: ${column}, ${modifiers.join(', ')} }`;
 }
-/** `user.email`, or `user['first-name']` for a property name that is no identifier. */
-function memberSource(param, property) {
-    return isIdentifierName(property) ? `${param}.${property}` : `${param}[${quoted(property)}]`;
-}

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

@@ -6,6 +6,8 @@ export declare function isIdentifierName(text: string): boolean;
  * parsing.
  */
 export declare function quoted(text: string): string;
+/** `user.email`, or `user['first-name']` for a property name that is no identifier. */
+export declare function memberSource(param: string, property: string): string;
 /**
  * SQL as a `raw` tagged template. A database reprints an expression as arbitrary text, and exactly
  * three sequences can end or interpolate a template literal, so escaping those is the whole job.

package/dist/migrate/codegen/sourceLiteral.js

@@ -10,6 +10,10 @@ export function isIdentifierName(text) {
 export function quoted(text) {
     return `'${text.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
 }
+/** `user.email`, or `user['first-name']` for a property name that is no identifier. */
+export function memberSource(param, property) {
+    return isIdentifierName(property) ? `${param}.${property}` : `${param}[${quoted(property)}]`;
+}
 /**
  * SQL as a `raw` tagged template. A database reprints an expression as arbitrary text, and exactly
  * three sequences can end or interpolate a template literal, so escaping those is the whole job.

package/dist/migrate/index.d.ts

@@ -10,7 +10,7 @@ export * from './drift/index.js';
 export * from './introspection/index.js';
 export { migrationBuilderFor } from './migrationTarget.js';
 export { type BuilderMigrationDefinition, defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
-export { createSchemaGenerator, SqlSchemaGenerator } from './schemaGenerator.js';
+export { SqlSchemaGenerator } from './schemaGenerator.js';
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';
 export { MongoMigrationStorage } from './storage/mongoStorage.js';

package/dist/migrate/index.js

@@ -16,7 +16,7 @@ export * from './introspection/index.js';
 export { migrationBuilderFor } from './migrationTarget.js';
 export { defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
 // Schema generators
-export { createSchemaGenerator, SqlSchemaGenerator } from './schemaGenerator.js';
+export { SqlSchemaGenerator } from './schemaGenerator.js';
 // Storage implementations
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';

package/dist/migrate/introspection/registry.d.ts

@@ -1,3 +1,3 @@
 import type { QuerierPool, SchemaIntrospector } from '../../type/index.js';
-/** The introspector for `dialectName`, or `undefined` where the migrator has none for it. */
-export declare function introspectorFor(dialectName: string, pool: QuerierPool, schema?: string): SchemaIntrospector | undefined;
+/** The introspector for the engine `pool` runs on, reading `schema` where the engine has schemas to read. */
+export declare function introspectorFor(pool: QuerierPool, schema?: string): SchemaIntrospector;

package/dist/migrate/introspection/registry.js

@@ -4,12 +4,9 @@ import { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntro
 import { CockroachSchemaIntrospector, PostgresSchemaIntrospector } from './postgresIntrospector.js';
 import { SqliteSchemaIntrospector } from './sqliteIntrospector.js';
 /**
- * Which introspector each engine gets. A table rather than a `switch` so `Migrator` names no
- * constructor and adding an engine touches one line, not a control flow.
- *
- * Every entry is statically imported, so `uql-orm/migrate` still carries all of them; making the
- * table's values dynamic imports would shrink that entry, at the cost of an async
- * `createIntrospector` the constructor cannot await.
+ * Which introspector each engine gets; SQLite and MongoDB have no schemas, so they ignore the argument.
+ * Statically imported, so `uql-orm/migrate` carries every one: dynamic imports would shrink that entry,
+ * but `Migrator` builds its introspector in its constructor, which cannot await.
  */
 const INTROSPECTORS = {
     postgres: (pool, schema) => new PostgresSchemaIntrospector(pool, schema),
@@ -17,12 +14,10 @@ const INTROSPECTORS = {
     mysql: (pool, schema) => new MysqlSchemaIntrospector(pool, schema),
     mariadb: (pool, schema) => new MariadbSchemaIntrospector(pool, schema),
     mssql: (pool, schema) => new MsSqlSchemaIntrospector(pool, schema),
-    // Neither has schemas to read: SQLite attaches database files and MongoDB takes its database from
-    // the connection, so both ignore the argument rather than filtering on it.
     sqlite: (pool) => new SqliteSchemaIntrospector(pool),
     mongodb: (pool) => new MongoSchemaIntrospector(pool),
 };
-/** The introspector for `dialectName`, or `undefined` where the migrator has none for it. */
-export function introspectorFor(dialectName, pool, schema) {
-    return INTROSPECTORS[dialectName]?.(pool, schema);
+/** The introspector for the engine `pool` runs on, reading `schema` where the engine has schemas to read. */
+export function introspectorFor(pool, schema) {
+    return INTROSPECTORS[pool.dialect.dialectName](pool, schema);
 }

package/dist/migrate/migrationTarget.d.ts

@@ -10,14 +10,14 @@ export type MigrationSession = {
     /** `work` in one transaction where the engine takes DDL in one; MongoDB creates collections outside any. */
     transaction(work: () => Promise<void>): Promise<void>;
 };
-/** Everything a migrator does differently per engine family, chosen once from its dialect. */
+/** Everything a migrator does differently per engine family, chosen once from its pool. */
 export type MigrationTarget = {
     readonly source: MigrationSource;
-    storage(pool: QuerierPool, tableName: string | undefined): MigrationStorage;
-    /** The schema generator, `undefined` for a dialect with none. Async because MongoDB's loads its optional peer. */
-    generator(dialect: MigratorDialect, defaultForeignKeyAction?: ForeignKeyAction): Promise<SchemaGenerator | undefined>;
-    withSession<T>(pool: QuerierPool, task: (session: MigrationSession) => Promise<T>): Promise<T>;
+    storage(tableName: string | undefined): MigrationStorage;
+    /** The dialect's schema generator. Async because MongoDB's loads its optional peer. */
+    generator(): Promise<SchemaGenerator>;
+    withSession<T>(task: (session: MigrationSession) => Promise<T>): Promise<T>;
 };
-export declare function migrationTargetFor(dialect: MigratorDialect): MigrationTarget;
+export declare function migrationTargetFor(pool: QuerierPool<Querier, MigratorDialect>, defaultForeignKeyAction?: ForeignKeyAction): MigrationTarget;
 /** A builder running each operation on `querier`, as SQL or as MongoDB driver commands. */
 export declare function migrationBuilderFor(querier: Querier): Promise<MigrationBuilder>;