turbine-orm 0.41.0 → 0.42.0

package/dist/cli/index.js

@@ -1035,11 +1035,12 @@ async function cmdMigrateFromPrisma(args, config) {
     label('Enums', String(ast.enums.length));
     // Resolve against the live database, unless --no-db (parse-only).
     let schemaMeta = null;
+    let url;
     if (args.noDb) {
         info('Parse-only mode (--no-db): names will not be resolved.');
     }
     else {
-        const url = requireUrl(config);
+        url = requireUrl(config);
         label('Database', redactUrl(url));
         const spinner = new Spinner('Introspecting database schema').start();
         schemaMeta = await introspect({
@@ -1055,7 +1056,10 @@ async function cmdMigrateFromPrisma(args, config) {
         spinner.succeed(`Introspected ${bold(String(Object.keys(schemaMeta.tables).length))} tables`);
     }
     newline();
-    const result = resolvePrismaSchema(ast, schemaMeta);
+    // `--keep-column-names` makes the generated client key fields by raw DB column
+    // names; resolve the name map against the same transformed schema so the
+    // emitted PRISMA_MAP field values agree with the client (D).
+    const result = resolvePrismaSchema(ast, schemaMeta, { keepColumnNames: config.keepColumnNames });
     // Console summary.
     header('Resolution');
     for (const line of summaryLines(result)) {
@@ -1075,10 +1079,26 @@ async function cmdMigrateFromPrisma(args, config) {
     const reportPath = join(outDir, 'prisma-migration-report.md');
     writeFileSync(reportPath, formatPrismaReport(result, { schemaPath: prismaPath, noTimestamp: args.noTimestamp }), 'utf-8');
     console.log(`  ${dim(symbols.teeEnd)} ${cyan(reportPath)} ${dim('(report)')}`);
-    if (!args.noDb) {
+    if (!args.noDb && schemaMeta) {
         const mapPath = join(outDir, 'prisma-map.ts');
         writeFileSync(mapPath, generatePrismaMap(result.map, { noTimestamp: args.noTimestamp }), 'utf-8');
         console.log(`  ${dim(symbols.teeEnd)} ${cyan(mapPath)} ${dim('(typed name map)')}`);
+        // Always emit the standard generated client alongside the report + name map.
+        // It is built from the live introspected metadata, so unresolved Prisma
+        // items never block it; a partially resolved run (--allow-partial) still
+        // gets a working client (C). `--keep-column-names` flows through so the
+        // client's field names match the name map (D).
+        const gen = generate({
+            schema: schemaMeta,
+            outDir: config.out,
+            connectionString: url,
+            noTimestamp: args.noTimestamp,
+            importExtension: config.importExtension,
+            keepColumnNames: config.keepColumnNames,
+        });
+        for (const file of gen.files) {
+            console.log(`  ${dim(symbols.teeEnd)} ${cyan(join(outDir, file))} ${dim('(client)')}`);
+        }
     }
     newline();
     // Exit non-zero when anything is UNRESOLVED, unless --allow-partial.

package/dist/cli/prisma-resolve.d.ts

@@ -81,7 +81,20 @@ export interface ResolutionResult {
     /** True when resolution was skipped (`--no-db`): the report is parse-only. */
     noDb: boolean;
 }
+/** Options controlling how names are resolved. */
+export interface ResolveOptions {
+    /**
+     * Resolve field names against the raw database column names instead of the
+     * camelCase default, matching a client generated with `--keep-column-names`.
+     * Applied by running the introspected metadata through {@link withDbFieldNames}
+     * up front, so every resolved `turbineField` (and compound-unique
+     * `turbineFields`) is the DB column spelling and the emitted PRISMA_MAP agrees
+     * with the generated client. Table names, accessors, and relations are
+     * unaffected (those never carry camelCased column names).
+     */
+    keepColumnNames?: boolean;
+}
 /**
  * Resolve `ast` against introspected `schema` (or `null` for parse-only).
  */
-export declare function resolvePrismaSchema(ast: PrismaSchemaAst, schema: SchemaMetadata | null): ResolutionResult;
+export declare function resolvePrismaSchema(ast: PrismaSchemaAst, schema: SchemaMetadata | null, options?: ResolveOptions): ResolutionResult;

package/dist/cli/prisma-resolve.js

@@ -12,7 +12,7 @@
  * Pure leaf: no filesystem, database, or process access. Passing `schema: null`
  * yields a parse-only report (every item `parsed`, no map) for `--no-db`.
  */
-import { camelToSnake, snakeToCamel } from '../schema.js';
+import { camelToSnake, snakeToCamel, withDbFieldNames } from '../schema.js';
 export { DEFAULT_EXCLUDED_TABLES } from '../introspect.js';
 // ---------------------------------------------------------------------------
 // Name-candidate helpers
@@ -70,16 +70,18 @@ function fieldColumn(model, fieldName) {
 function isRelationField(typeName, modelNames) {
     return modelNames.has(typeName);
 }
-// ---------------------------------------------------------------------------
-// Main entry
-// ---------------------------------------------------------------------------
 /**
  * Resolve `ast` against introspected `schema` (or `null` for parse-only).
  */
-export function resolvePrismaSchema(ast, schema) {
-    const noDb = schema === null;
+export function resolvePrismaSchema(ast, schema, options = {}) {
+    // Under keep-column-names the generated client keys fields by raw DB column
+    // names; resolve against the same transformed metadata so the name map's
+    // field values match the client (D).
+    const resolvedSchema = schema && options.keepColumnNames ? withDbFieldNames(schema) : schema;
+    const noDb = resolvedSchema === null;
     const modelNames = new Set(ast.models.map((m) => m.name));
-    const tableNames = schema ? new Set(Object.keys(schema.tables)) : new Set();
+    const modelsByName = new Map(ast.models.map((m) => [m.name, m]));
+    const tableNames = resolvedSchema ? new Set(Object.keys(resolvedSchema.tables)) : new Set();
     // Pass 1 - resolve each model to a table so relation targets are known.
     const modelTable = new Map();
     for (const model of ast.models) {
@@ -97,7 +99,7 @@ export function resolvePrismaSchema(ast, schema) {
     for (const model of ast.models) {
         const rt = modelTable.get(model.name);
         const table = rt.table;
-        const tableMeta = table && schema ? schema.tables[table] : undefined;
+        const tableMeta = table && resolvedSchema ? resolvedSchema.tables[table] : undefined;
         const accessor = table ? snakeToCamel(table) : null;
         const status = noDb ? 'parsed' : table ? 'resolved' : 'unresolved';
         const resolved = {
@@ -114,7 +116,7 @@ export function resolvePrismaSchema(ast, schema) {
         };
         for (const field of model.fields) {
             if (isRelationField(field.type, modelNames)) {
-                resolved.relations.push(resolveRelation(model, field.name, field.type, field.isList, modelTable, schema, tableMeta, noDb));
+                resolved.relations.push(resolveRelation(model, field.name, field.type, field.isList, modelTable, modelsByName, resolvedSchema, tableMeta, noDb));
             }
             else {
                 resolved.fields.push(resolveScalarField(model, field.name, tableMeta, noDb));
@@ -151,7 +153,7 @@ export function resolvePrismaSchema(ast, schema) {
     }
     // Enums.
     for (const en of ast.enums) {
-        const r = resolveEnum(en.name, en.map, schema, noDb);
+        const r = resolveEnum(en.name, en.map, resolvedSchema, noDb);
         result.enums.push(r);
         if (!noDb && r.status === 'resolved' && r.turbineName)
             result.map.enums[en.name] = r.turbineName;
@@ -208,7 +210,28 @@ function resolveScalarField(model, fieldName, tableMeta, noDb) {
         reason: `column "${column}" not found on table "${tableMeta.name}"`,
     };
 }
-function resolveRelation(model, fieldName, targetModelName, isList, modelTable, schema, tableMeta, noDb) {
+/**
+ * The `@relation("Name")` name on a field, from the `name:` argument or the
+ * first positional string argument. Absent when the field has no `@relation`
+ * attribute or the attribute carries no name.
+ */
+function relationNameOf(field) {
+    const relAttr = field?.attrs.find((a) => a.name === 'relation');
+    if (!relAttr)
+        return undefined;
+    const named = relAttr.args.find((a) => a.key === 'name' && a.kind === 'string');
+    if (named?.value)
+        return named.value;
+    const positional = relAttr.args.find((a) => a.key === undefined && a.kind === 'string');
+    return positional?.value;
+}
+/** The FK column list a field pins via `@relation(fields: [...])`, resolved to columns. */
+function relationFkColumns(model, field) {
+    const relAttr = field?.attrs.find((a) => a.name === 'relation');
+    const fieldsArg = relAttr?.args.find((a) => a.key === 'fields' && a.kind === 'array');
+    return fieldsArg?.items?.map((pf) => fieldColumn(model, pf)) ?? null;
+}
+function resolveRelation(model, fieldName, targetModelName, isList, modelTable, modelsByName, schema, tableMeta, noDb) {
     const cardinality = isList ? 'many' : 'one';
     const base = {
         prismaName: fieldName,
@@ -225,9 +248,24 @@ function resolveRelation(model, fieldName, targetModelName, isList, modelTable,
     const targetTable = modelTable.get(targetModelName)?.table ?? null;
     // Explicit @relation(fields: [...]) names the FK columns on THIS side.
     const field = model.fields.find((f) => f.name === fieldName);
-    const relAttr = field?.attrs.find((a) => a.name === 'relation');
-    const fieldsArg = relAttr?.args.find((a) => a.key === 'fields' && a.kind === 'array');
-    const fkColumns = fieldsArg?.items?.map((pf) => fieldColumn(model, pf)) ?? null;
+    let fkColumns = relationFkColumns(model, field);
+    // Inverse side (no fields on this side) with a @relation("Name"): pair by that
+    // name FIRST. Find the opposing model's field carrying the same relation name
+    // AND the FK (fields: [...]), and resolve through ITS foreign key. This is how
+    // Prisma disambiguates two or more relations to the same target model. Only
+    // fall back to the ambiguity handling below when there is no relation name or
+    // the named pair cannot be found.
+    if (!fkColumns || fkColumns.length === 0) {
+        const relName = relationNameOf(field);
+        const targetModel = modelsByName.get(targetModelName);
+        if (relName && targetModel) {
+            const opposing = targetModel.fields.find((f) => f.type === model.name &&
+                relationNameOf(f) === relName &&
+                (relationFkColumns(targetModel, f)?.length ?? 0) > 0);
+            if (opposing)
+                fkColumns = relationFkColumns(targetModel, opposing);
+        }
+    }
     const candidates = Object.values(tableMeta.relations).filter((def) => {
         if (targetTable && def.to !== targetTable)
             return false;
@@ -288,10 +326,25 @@ function resolveCompoundUnique(model, key, tableMeta, noDb) {
             return { ...base, turbineFields, status: 'resolved' };
         return { ...base, reason: `no compound primary key on "${tableMeta.name}" matches (${columns.join(', ')})` };
     }
-    // Introspected metadata carries composite unique constraints in uniqueColumns.
-    if (matches(tableMeta.uniqueColumns))
+    // A composite unique can surface EITHER as a unique constraint (uniqueColumns)
+    // OR as a plain UNIQUE INDEX (Prisma creates unique indexes, not table
+    // constraints), so accept a matching unique index too. A partial unique index
+    // does not enforce uniqueness across the whole table, so it never satisfies a
+    // @@unique; skip it defensively (the marker may be added to IndexMetadata).
+    const uniqueIndexMatches = tableMeta.indexes.some((idx) => {
+        if (!idx.unique)
+            return false;
+        if (idx.partial)
+            return false;
+        return [...idx.columns].sort().join(',') === want;
+    });
+    if (matches(tableMeta.uniqueColumns) || uniqueIndexMatches) {
         return { ...base, turbineFields, status: 'resolved' };
-    return { ...base, reason: `no unique constraint on "${tableMeta.name}" matches (${columns.join(', ')})` };
+    }
+    return {
+        ...base,
+        reason: `no unique constraint or unique index on "${tableMeta.name}" matches (${columns.join(', ')})`,
+    };
 }
 function resolveEnum(name, map, schema, noDb) {
     if (noDb || !schema)

package/dist/generate.js

@@ -448,13 +448,23 @@ export function generateTypes(schema, options) {
             for (const uc of table.uniqueColumns)
                 addCompound(uc);
             for (const idx of table.indexes) {
-                if (idx.unique && !idx.docPath)
+                // A partial unique index does not guarantee table-wide row uniqueness,
+                // so it must not become a compound-unique selector (matches the runtime
+                // exclusion in query/compound-unique.ts).
+                if (idx.unique && !idx.docPath && !idx.partial)
                     addCompound(idx.columns);
             }
             const selectorEntries = compoundSets.map((cols) => {
                 const members = cols.map(memberType);
                 return {
-                    selectorName: members.map((m) => m.field).join('_'),
+                    // The selector NAME is the underscore-join of the member FIELD names.
+                    // It is normally a valid identifier (`orgId_userId`), but a
+                    // junction-style column that is not a valid identifier (e.g. a quoted
+                    // uppercase `"A"` / `"B"`) would join into a broken object key. Emit
+                    // any non-identifier name as ONE quoted string-literal key so the
+                    // generated types.ts always parses; the runtime selector map in
+                    // query/compound-unique.ts registers the same name spelling.
+                    selectorName: quoteIfNeeded(members.map((m) => m.field).join('_')),
                     memberType: `{ ${members.map((m) => `${quoteIfNeeded(m.field)}: ${m.tsType}`).join('; ')} }`,
                 };
             });
@@ -713,7 +723,11 @@ export function generateMetadata(schema, options) {
         // indexes
         lines.push('      indexes: [');
         for (const idx of table.indexes) {
-            lines.push(`        { name: '${escSQ(idx.name)}', columns: [${idx.columns.map((c) => `'${escSQ(c)}'`).join(', ')}], unique: ${idx.unique}, definition: ${JSON.stringify(idx.definition)} },`);
+            // `partial` must round-trip: the runtime compound-unique derivation reads
+            // the GENERATED metadata, so dropping the flag here would re-arm a
+            // partial-unique selector that types.ts correctly excludes.
+            const partialSeg = idx.partial ? ', partial: true' : '';
+            lines.push(`        { name: '${escSQ(idx.name)}', columns: [${idx.columns.map((c) => `'${escSQ(c)}'`).join(', ')}], unique: ${idx.unique}${partialSeg}, definition: ${JSON.stringify(idx.definition)} },`);
         }
         lines.push('      ],');
         // checks: introspected named CHECK constraints. Emitted only when present

package/dist/introspect.d.ts

@@ -108,6 +108,30 @@ export declare function introspect(options: IntrospectOptions): Promise<SchemaMe
  * `postgresDialect.introspector`; call {@link introspect} for dialect routing.
  */
 export declare function introspectPostgresCatalog(options: IntrospectOptions): Promise<SchemaMetadata>;
+/**
+ * Parse the indexed column names out of a `pg_indexes.indexdef` string.
+ *
+ * `indexdef` always reads `CREATE [UNIQUE] INDEX name ON tbl USING method
+ * (col, ...) [WHERE predicate]`. We anchor on the `USING` clause's parenthesised
+ * column list (the same precedent as `describeIndexDefMismatch` in
+ * schema-sql.ts) so a PARTIAL index's trailing `WHERE (...)` parentheses are
+ * never mistaken for the column list. The older greedy `/\((.+)\)/` swallowed
+ * `) WHERE (` and spliced a raw predicate fragment into the column names, which
+ * then leaked into generated compound-unique selector names.
+ *
+ * Each column is de-quoted (Postgres quotes non-lowercase identifiers such as a
+ * Prisma implicit m2m junction's `"A"` / `"B"`), so the names match the
+ * unquoted column names carried elsewhere in the metadata. Expression columns
+ * (anything containing a parenthesis) are dropped conservatively: a functional
+ * index does not name a plain column.
+ */
+export declare function parseIndexColumns(indexdef: string): string[];
+/**
+ * Whether an `indexdef` carries a top-level `WHERE` predicate (a PARTIAL index).
+ * pg_indexes only ever emits `WHERE` as the partial predicate, so a keyword
+ * match is sufficient (matches the `describeIndexDefMismatch` precedent).
+ */
+export declare function indexHasWhere(indexdef: string): boolean;
 /**
  * Recover the raw check expression from `pg_get_constraintdef` output, which
  * wraps it as `CHECK ((expr))`. Strips the leading `CHECK ` keyword and one
@@ -213,11 +237,15 @@ export declare function buildRelationsFromForeignKeys(foreignKeys: ForeignKeyEnt
  * IDENTICAL relation names for the same logical schema.
  *
  * A table J is a PURE junction only when ALL of these hold:
- *   1. J's primary key is exactly two columns.
+ *   1. J's junction KEY is exactly two columns: either a two-column primary
+ *      key, OR (Prisma implicit m2m junctions have NO primary key) a two-column
+ *      UNIQUE index over exactly the two FK columns, supplied via the optional
+ *      `uniqueIndexColsByTable`. When that map is absent the behavior is
+ *      unchanged: only a two-column PK qualifies.
  *   2. J has exactly two FKs, each single-column.
- *   3. Each FK's source column is one of J's two PK columns.
+ *   3. Each FK's source column is one of J's two key columns.
  *   4. The two FKs target two DISTINCT tables (A and B).
- *   5. J has no payload columns beyond the two FK/PK columns.
+ *   5. J has no payload columns beyond the two FK/key columns.
  *
  * For such a J linking A and B this ADDS a `manyToMany` on A → B and B → A
  * routed `through` J. It never removes or renames an existing relation:
@@ -228,7 +256,7 @@ export declare function buildRelationsFromForeignKeys(foreignKeys: ForeignKeyEnt
  *   - a shadowed concrete-typed column → deterministic `Rel` suffix + warn
  *     instead of silently dropping the relation.
  */
-export declare function addAutoManyToManyRelations(tableNames: Iterable<string>, foreignKeys: ForeignKeyEntry[], pkByTable: Map<string, string[]>, columnNamesByTable: Map<string, string[]>, relationsByTable: Map<string, Record<string, RelationDef>>, columnFieldsByTable?: Map<string, Set<string>>, unknownTypedFieldsByTable?: Map<string, Set<string>>): void;
+export declare function addAutoManyToManyRelations(tableNames: Iterable<string>, foreignKeys: ForeignKeyEntry[], pkByTable: Map<string, string[]>, columnNamesByTable: Map<string, string[]>, relationsByTable: Map<string, Record<string, RelationDef>>, columnFieldsByTable?: Map<string, Set<string>>, unknownTypedFieldsByTable?: Map<string, Set<string>>, uniqueIndexColsByTable?: Map<string, string[][]>): void;
 /**
  * One-stop relation derivation for the engine introspectors (SQLite / MySQL /
  * MSSQL): filters the FK list to the introspected table set, seeds the

package/dist/introspect.js

@@ -395,15 +395,15 @@ export async function introspectPostgresCatalog(options) {
                 continue;
             if (!indexesByTable.has(row.tablename))
                 indexesByTable.set(row.tablename, []);
-            const isUnique = row.indexdef.includes('UNIQUE');
-            // Extract column names from indexdef (e.g. "CREATE INDEX idx ON tbl USING btree (col1, col2)")
-            const colMatch = row.indexdef.match(/\((.+)\)/);
-            const columns = colMatch ? colMatch[1].split(',').map((c) => c.trim().replace(/ (ASC|DESC)/i, '')) : [];
+            const indexdef = row.indexdef;
+            const isUnique = indexdef.includes('UNIQUE');
+            const isPartial = indexHasWhere(indexdef);
             indexesByTable.get(row.tablename).push({
                 name: row.indexname,
-                columns,
+                columns: parseIndexColumns(indexdef),
                 unique: isUnique,
-                definition: row.indexdef,
+                definition: indexdef,
+                ...(isPartial ? { partial: true } : {}),
             });
         }
         // ----- Group check constraints by table -----
@@ -492,7 +492,17 @@ export async function introspectPostgresCatalog(options) {
         // hasMany relations derived from J's FKs are left untouched — this block
         // never removes or renames anything. Naming/collision handling lives in the
         // shared addAutoManyToManyRelations helper.
-        addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, new Map(Array.from(columnsByTable, ([tbl, cols]) => [tbl, cols.map((c) => c.name)])), relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable);
+        //
+        // Prisma's implicit m2m junctions have no primary key (just a two-column
+        // UNIQUE index over the FK columns), so pass the introspected two-column
+        // unique indexes as the fallback junction-key source.
+        const uniqueIndexColsByTable = new Map();
+        for (const [tbl, idxs] of indexesByTable) {
+            const twoColUniques = idxs.filter((idx) => idx.unique && idx.columns.length === 2).map((idx) => idx.columns);
+            if (twoColUniques.length > 0)
+                uniqueIndexColsByTable.set(tbl, twoColUniques);
+        }
+        addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, new Map(Array.from(columnsByTable, ([tbl, cols]) => [tbl, cols.map((c) => c.name)])), relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable, uniqueIndexColsByTable);
         // ----- Assemble TableMetadata for each table -----
         const tables = {};
         for (const tableName of tableNames) {
@@ -537,6 +547,50 @@ export async function introspectPostgresCatalog(options) {
         await pool.end();
     }
 }
+/**
+ * Parse the indexed column names out of a `pg_indexes.indexdef` string.
+ *
+ * `indexdef` always reads `CREATE [UNIQUE] INDEX name ON tbl USING method
+ * (col, ...) [WHERE predicate]`. We anchor on the `USING` clause's parenthesised
+ * column list (the same precedent as `describeIndexDefMismatch` in
+ * schema-sql.ts) so a PARTIAL index's trailing `WHERE (...)` parentheses are
+ * never mistaken for the column list. The older greedy `/\((.+)\)/` swallowed
+ * `) WHERE (` and spliced a raw predicate fragment into the column names, which
+ * then leaked into generated compound-unique selector names.
+ *
+ * Each column is de-quoted (Postgres quotes non-lowercase identifiers such as a
+ * Prisma implicit m2m junction's `"A"` / `"B"`), so the names match the
+ * unquoted column names carried elsewhere in the metadata. Expression columns
+ * (anything containing a parenthesis) are dropped conservatively: a functional
+ * index does not name a plain column.
+ */
+export function parseIndexColumns(indexdef) {
+    const m = indexdef.match(/USING\s+\w+\s*\(([^)]*)\)/i) ?? indexdef.match(/\(([^)]*)\)/);
+    if (!m)
+        return [];
+    return m[1]
+        .split(',')
+        .map((c) => unquoteIndexIdent(c
+        .trim()
+        .replace(/\s+(ASC|DESC)$/i, '')
+        .trim()))
+        .filter((c) => c.length > 0 && !c.includes('(') && !c.includes(')'));
+}
+/** Strip one pair of surrounding double quotes and unescape doubled `""`. */
+function unquoteIndexIdent(col) {
+    if (col.length >= 2 && col.startsWith('"') && col.endsWith('"')) {
+        return col.slice(1, -1).replace(/""/g, '"');
+    }
+    return col;
+}
+/**
+ * Whether an `indexdef` carries a top-level `WHERE` predicate (a PARTIAL index).
+ * pg_indexes only ever emits `WHERE` as the partial predicate, so a keyword
+ * match is sufficient (matches the `describeIndexDefMismatch` precedent).
+ */
+export function indexHasWhere(indexdef) {
+    return /\bWHERE\b/i.test(indexdef);
+}
 /**
  * Recover the raw check expression from `pg_get_constraintdef` output, which
  * wraps it as `CHECK ((expr))`. Strips the leading `CHECK ` keyword and one
@@ -881,11 +935,15 @@ export function buildRelationsFromForeignKeys(foreignKeys, columnFieldsByTable,
  * IDENTICAL relation names for the same logical schema.
  *
  * A table J is a PURE junction only when ALL of these hold:
- *   1. J's primary key is exactly two columns.
+ *   1. J's junction KEY is exactly two columns: either a two-column primary
+ *      key, OR (Prisma implicit m2m junctions have NO primary key) a two-column
+ *      UNIQUE index over exactly the two FK columns, supplied via the optional
+ *      `uniqueIndexColsByTable`. When that map is absent the behavior is
+ *      unchanged: only a two-column PK qualifies.
  *   2. J has exactly two FKs, each single-column.
- *   3. Each FK's source column is one of J's two PK columns.
+ *   3. Each FK's source column is one of J's two key columns.
  *   4. The two FKs target two DISTINCT tables (A and B).
- *   5. J has no payload columns beyond the two FK/PK columns.
+ *   5. J has no payload columns beyond the two FK/key columns.
  *
  * For such a J linking A and B this ADDS a `manyToMany` on A → B and B → A
  * routed `through` J. It never removes or renames an existing relation:
@@ -896,11 +954,8 @@ export function buildRelationsFromForeignKeys(foreignKeys, columnFieldsByTable,
  *   - a shadowed concrete-typed column → deterministic `Rel` suffix + warn
  *     instead of silently dropping the relation.
  */
-export function addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, columnNamesByTable, relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable) {
+export function addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, columnNamesByTable, relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable, uniqueIndexColsByTable) {
     for (const tableName of tableNames) {
-        const pk = pkByTable.get(tableName) ?? [];
-        if (pk.length !== 2)
-            continue;
         // FKs whose source is this table — both must be single-column.
         const tableFks = foreignKeys.filter((fk) => fk.sourceTable === tableName);
         if (tableFks.length !== 2)
@@ -908,20 +963,35 @@ export function addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, c
         if (tableFks.some((fk) => fk.sourceColumns.length !== 1))
             continue;
         const fkCols = tableFks.map((fk) => fk.sourceColumns[0]);
-        const pkSet = new Set(pk);
-        // Both FK columns must be the PK columns (and vice-versa).
-        if (!fkCols.every((c) => pkSet.has(c)))
-            continue;
         if (new Set(fkCols).size !== 2)
             continue;
+        const fkSet = new Set(fkCols);
+        // The junction KEY is normally the two-column PK. Prisma's implicit m2m
+        // junctions have NO primary key, so accept instead a two-column UNIQUE
+        // index that covers exactly the two FK columns. Only a PK-less table is
+        // eligible for the unique-index fallback, so a real entity that happens to
+        // carry a two-column unique index is never mistaken for a junction.
+        const pk = pkByTable.get(tableName) ?? [];
+        let keyCols;
+        if (pk.length === 2 && pk.every((c) => fkSet.has(c))) {
+            keyCols = pk;
+        }
+        else if (pk.length === 0) {
+            const uniques = uniqueIndexColsByTable?.get(tableName) ?? [];
+            keyCols = uniques.find((u) => u.length === 2 && u.every((c) => fkSet.has(c)));
+        }
+        if (!keyCols)
+            continue;
         // Two DISTINCT target tables.
         const [fkA, fkB] = tableFks;
         if (fkA.targetTable === fkB.targetTable)
             continue;
-        // No payload columns: J's columns are exactly the two FK/PK columns.
+        // No payload columns: J's columns are exactly the two FK/key columns.
         const jCols = columnNamesByTable.get(tableName) ?? [];
         if (jCols.length !== 2)
             continue;
+        if (!jCols.every((c) => fkSet.has(c)))
+            continue;
         // For each direction, the m2m `referenceKey` is the *targeted* table's
         // referenced column(s); the junction's sourceKey is the FK column pointing
         // to that table; the targetKey is the FK column pointing to the OTHER table.