turbine-orm 0.40.1 → 0.41.0

package/dist/cli/prisma-report.js

@@ -0,0 +1,211 @@
+/**
+ * Render a {@link ResolutionResult} into the `prisma-migration-report.md`
+ * artifact and a short console summary. Pure leaf - string in, string out.
+ */
+const CHECK = 'OK';
+const CROSS = 'UNRESOLVED';
+function modelDisplayStatus(m) {
+    if (m.status === 'parsed')
+        return 'parsed';
+    if (m.status === 'unresolved')
+        return CROSS;
+    return m.viaMap ? `${CHECK} (@@map)` : CHECK;
+}
+/**
+ * Build the full Markdown migration report.
+ */
+export function formatPrismaReport(result, options = {}) {
+    const L = [];
+    L.push('# Prisma to Turbine migration report');
+    L.push('');
+    if (options.schemaPath)
+        L.push(`Source: \`${options.schemaPath}\``);
+    if (!options.noTimestamp)
+        L.push(`Generated: ${new Date().toISOString()}`);
+    L.push(`Mode: ${result.noDb ? 'parse-only (--no-db, no database resolution)' : 'resolved against live database'}`);
+    L.push('');
+    // ---- Summary ----------------------------------------------------------
+    const modelCount = result.models.length;
+    const resolvedModels = result.models.filter((m) => m.status === 'resolved').length;
+    const unresolvedModels = result.models.filter((m) => m.status === 'unresolved').length;
+    L.push('## Summary');
+    L.push('');
+    if (result.noDb) {
+        L.push(`- Parsed ${modelCount} model(s), ${result.enums.length} enum(s).`);
+        L.push('- No database URL provided - names were not resolved. Re-run without `--no-db` to resolve.');
+    }
+    else {
+        L.push(`- Models: ${resolvedModels}/${modelCount} resolved${unresolvedModels ? `, ${unresolvedModels} UNRESOLVED` : ''}.`);
+        L.push(`- Enums: ${result.enums.filter((e) => e.status === 'resolved').length}/${result.enums.length} resolved.`);
+        L.push(`- Overall: ${result.hasUnresolved ? 'INCOMPLETE (some items unresolved)' : 'complete (all items resolved)'}.`);
+    }
+    L.push('');
+    // ---- Model resolution table ------------------------------------------
+    L.push('## Models');
+    L.push('');
+    L.push('| Prisma model | Turbine accessor | Table | Status |');
+    L.push('| --- | --- | --- | --- |');
+    for (const m of result.models) {
+        L.push(`| ${m.prismaName} | ${m.accessor ?? '-'} | ${m.table ?? '-'} | ${modelDisplayStatus(m)} |`);
+    }
+    L.push('');
+    // ---- Per-model detail -------------------------------------------------
+    for (const m of result.models) {
+        L.push(`### ${m.prismaName}`);
+        L.push('');
+        if (m.status === 'unresolved') {
+            L.push(`> UNRESOLVED: ${m.reason ?? 'no matching table'}`);
+            L.push('');
+        }
+        if (m.fields.length > 0) {
+            L.push('Fields:');
+            L.push('');
+            for (const f of m.fields) {
+                if (f.status === 'resolved') {
+                    L.push(`- \`${f.prismaName}\` -> \`${f.turbineField}\` (column \`${f.column}\`)`);
+                }
+                else if (f.status === 'parsed') {
+                    L.push(`- \`${f.prismaName}\` (parsed)`);
+                }
+                else {
+                    L.push(`- \`${f.prismaName}\` UNRESOLVED: ${f.reason}`);
+                }
+            }
+            L.push('');
+        }
+        if (m.relations.length > 0) {
+            L.push('Relations:');
+            L.push('');
+            for (const r of m.relations) {
+                if (r.status === 'resolved') {
+                    const j = r.junction ? `, junction \`${r.junction}\`` : '';
+                    L.push(`- \`${r.prismaName}\` -> \`${r.turbineName}\` (${r.cardinality}${j})`);
+                }
+                else if (r.status === 'parsed') {
+                    L.push(`- \`${r.prismaName}\` -> ${r.targetModel} (parsed)`);
+                }
+                else {
+                    L.push(`- \`${r.prismaName}\` -> ${r.targetModel} UNRESOLVED: ${r.reason}`);
+                }
+            }
+            L.push('');
+        }
+        if (m.compoundUniques.length > 0) {
+            L.push('Compound unique / id selectors:');
+            L.push('');
+            for (const c of m.compoundUniques) {
+                if (c.status === 'resolved') {
+                    L.push(`- \`${c.selector}\` (@@${c.kind}) -> [${c.turbineFields.join(', ')}]`);
+                }
+                else if (c.status === 'parsed') {
+                    L.push(`- \`${c.selector}\` (@@${c.kind}, parsed): [${c.prismaFields.join(', ')}]`);
+                }
+                else {
+                    L.push(`- \`${c.selector}\` (@@${c.kind}) UNRESOLVED: ${c.reason}`);
+                }
+            }
+            L.push('');
+        }
+    }
+    // ---- Junction tables --------------------------------------------------
+    const junctions = new Set();
+    for (const m of result.models) {
+        for (const r of m.relations)
+            if (r.junction)
+                junctions.add(r.junction);
+    }
+    if (junctions.size > 0) {
+        L.push('## Junction tables (implicit m2m)');
+        L.push('');
+        for (const j of [...junctions].sort())
+            L.push(`- \`${j}\``);
+        L.push('');
+    }
+    // ---- Enums ------------------------------------------------------------
+    if (result.enums.length > 0) {
+        L.push('## Enums');
+        L.push('');
+        for (const e of result.enums) {
+            if (e.status === 'resolved')
+                L.push(`- \`${e.prismaName}\` -> \`${e.turbineName}\``);
+            else if (e.status === 'parsed')
+                L.push(`- \`${e.prismaName}\` (parsed)`);
+            else
+                L.push(`- \`${e.prismaName}\` UNRESOLVED: ${e.reason}`);
+        }
+        L.push('');
+    }
+    // ---- Unresolved roll-up ----------------------------------------------
+    const unresolved = collectUnresolved(result);
+    if (unresolved.length > 0) {
+        L.push('## Unresolved items');
+        L.push('');
+        for (const u of unresolved)
+            L.push(`- ${u}`);
+        L.push('');
+    }
+    // ---- Parser warnings --------------------------------------------------
+    if (result.parseWarnings.length > 0) {
+        L.push('## Parser notes');
+        L.push('');
+        for (const w of result.parseWarnings)
+            L.push(`- ${w}`);
+        L.push('');
+    }
+    // ---- Fixed semantic-divergence section --------------------------------
+    L.push(SEMANTIC_DIVERGENCE);
+    return `${L.join('\n')}\n`;
+}
+/** Flat list of unresolved item descriptions across the whole result. */
+export function collectUnresolved(result) {
+    const out = [];
+    for (const m of result.models) {
+        if (m.status === 'unresolved')
+            out.push(`Model ${m.prismaName}: ${m.reason ?? 'no matching table'}`);
+        for (const f of m.fields) {
+            if (f.status === 'unresolved')
+                out.push(`${m.prismaName}.${f.prismaName} (field): ${f.reason}`);
+        }
+        for (const r of m.relations) {
+            if (r.status === 'unresolved')
+                out.push(`${m.prismaName}.${r.prismaName} (relation): ${r.reason}`);
+        }
+        for (const c of m.compoundUniques) {
+            if (c.status === 'unresolved')
+                out.push(`${m.prismaName}.${c.selector} (@@${c.kind}): ${c.reason}`);
+        }
+    }
+    for (const e of result.enums) {
+        if (e.status === 'unresolved')
+            out.push(`Enum ${e.prismaName}: ${e.reason}`);
+    }
+    return out;
+}
+/** Static section documenting known Prisma-vs-Turbine behavior differences. */
+const SEMANTIC_DIVERGENCE = `## Behavior notes (Prisma vs Turbine)
+
+These are deliberate semantic differences to keep in mind when porting queries.
+Phase 1 ships no runtime; it produces this report plus a typed name map. The
+phase-2 \`turbine-orm/prisma-compat\` adapter handles most of these translations.
+
+- Cursor pagination. Turbine cursors are EXCLUSIVE and the comparison direction
+  follows the \`orderBy\` entry for the cursor field. Prisma cursors are
+  INCLUSIVE and idiomatically paired with \`skip: 1\`. Port \`{ cursor, skip: n }\`
+  (n >= 1) to a Turbine cursor plus \`offset: n - 1\`.
+- Aggregate / groupBy \`_count\`. Prisma returns \`_count\` as a record
+  (\`{ _all: n }\` / per-field counts). Turbine's scalar \`_count: true\` returns a
+  number. Reshape as needed (the phase-2 adapter does this both directions).
+- Relation-array order. Without an \`orderBy\` on a \`with\`/\`include\` clause, the
+  order of a to-many relation array is unspecified in Turbine (\`json_agg\` order).
+  Add an explicit \`orderBy\` where order matters.
+- Connection URL. Prefer an explicit \`sslmode\` in the connection URL (or the
+  future-proof \`uselibpqcompat\` form) to avoid a per-boot pg SSL security
+  warning.`;
+/** A one-line-per-model console summary for the CLI. */
+export function summaryLines(result) {
+    return result.models.map((m) => {
+        const status = modelDisplayStatus(m);
+        const target = m.accessor ? `${m.accessor} (${m.table})` : '-';
+        return `${m.prismaName} -> ${target}  [${status}]`;
+    });
+}

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

@@ -0,0 +1,87 @@
+/**
+ * Resolve a parsed Prisma schema against live introspected Turbine metadata.
+ *
+ * Consumes a {@link PrismaSchemaAst} (from `cli/prisma-schema.ts`) plus a
+ * {@link SchemaMetadata} (from `introspect()`), and produces a
+ * {@link ResolutionResult}: a per-model/field/relation/compound-unique
+ * resolution report AND the typed {@link PrismaCompatMap} that only ever
+ * contains VERIFIED mappings. Anything that cannot be matched against the live
+ * database is reported UNRESOLVED with a reason and left out of the map - the
+ * database is the authority, and an ambiguous guess is worse than an honest gap.
+ *
+ * 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 { type PrismaCompatMap, type SchemaMetadata } from '../schema.js';
+import type { PrismaSchemaAst } from './prisma-schema.js';
+export { DEFAULT_EXCLUDED_TABLES } from '../introspect.js';
+export type ResolveStatus = 'resolved' | 'unresolved' | 'parsed';
+export interface ResolvedField {
+    prismaName: string;
+    /** Resolved Turbine field (camelCase), or null. */
+    turbineField: string | null;
+    /** Resolved snake_case database column, or null. */
+    column: string | null;
+    status: ResolveStatus;
+    reason?: string;
+}
+export interface ResolvedRelation {
+    prismaName: string;
+    /** Turbine relation name, or null. */
+    turbineName: string | null;
+    cardinality: 'one' | 'many' | null;
+    /** Target Prisma model this relation points at. */
+    targetModel: string;
+    /** Junction table for an m2m relation, if resolved. */
+    junction?: string;
+    status: ResolveStatus;
+    reason?: string;
+}
+export interface ResolvedCompoundUnique {
+    /** Prisma selector name (explicit `name:`, else the field-name underscore-join). */
+    selector: string;
+    /** Prisma field names participating. */
+    prismaFields: string[];
+    /** Resolved Turbine field names (in order), or null. */
+    turbineFields: string[] | null;
+    kind: 'id' | 'unique';
+    status: ResolveStatus;
+    reason?: string;
+}
+export interface ResolvedModel {
+    prismaName: string;
+    kind: 'model' | 'view' | 'type';
+    /** Resolved snake_case table name, or null. */
+    table: string | null;
+    /** camelCase client accessor, or null. */
+    accessor: string | null;
+    /** True when the table name came from an explicit `@@map`. */
+    viaMap: boolean;
+    status: ResolveStatus;
+    reason?: string;
+    fields: ResolvedField[];
+    relations: ResolvedRelation[];
+    compoundUniques: ResolvedCompoundUnique[];
+}
+export interface ResolvedEnum {
+    prismaName: string;
+    turbineName: string | null;
+    status: ResolveStatus;
+    reason?: string;
+}
+export interface ResolutionResult {
+    models: ResolvedModel[];
+    enums: ResolvedEnum[];
+    /** The verified name map. Empty `models`/`enums` in `--no-db` mode. */
+    map: PrismaCompatMap;
+    /** True if any model/field/relation/compound-unique/enum is UNRESOLVED. */
+    hasUnresolved: boolean;
+    /** Non-fatal parser notes (skipped blocks/attributes). */
+    parseWarnings: string[];
+    /** True when resolution was skipped (`--no-db`): the report is parse-only. */
+    noDb: boolean;
+}
+/**
+ * Resolve `ast` against introspected `schema` (or `null` for parse-only).
+ */
+export declare function resolvePrismaSchema(ast: PrismaSchemaAst, schema: SchemaMetadata | null): ResolutionResult;

package/dist/cli/prisma-resolve.js

@@ -0,0 +1,330 @@
+/**
+ * Resolve a parsed Prisma schema against live introspected Turbine metadata.
+ *
+ * Consumes a {@link PrismaSchemaAst} (from `cli/prisma-schema.ts`) plus a
+ * {@link SchemaMetadata} (from `introspect()`), and produces a
+ * {@link ResolutionResult}: a per-model/field/relation/compound-unique
+ * resolution report AND the typed {@link PrismaCompatMap} that only ever
+ * contains VERIFIED mappings. Anything that cannot be matched against the live
+ * database is reported UNRESOLVED with a reason and left out of the map - the
+ * database is the authority, and an ambiguous guess is worse than an honest gap.
+ *
+ * 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';
+export { DEFAULT_EXCLUDED_TABLES } from '../introspect.js';
+// ---------------------------------------------------------------------------
+// Name-candidate helpers
+// ---------------------------------------------------------------------------
+/** PascalCase model → snake_case: lower the first letter, then camelToSnake. */
+function pascalToSnake(name) {
+    if (name === '')
+        return name;
+    return camelToSnake(name[0].toLowerCase() + name.slice(1));
+}
+/** Naive pluralize for the snake candidate: mirrors `singularize` in schema.ts. */
+function pluralize(s) {
+    if (/[^aeiou]y$/.test(s))
+        return `${s.slice(0, -1)}ies`;
+    if (/(s|x|z|ch|sh)$/.test(s))
+        return `${s}es`;
+    return `${s}s`;
+}
+function singularize(s) {
+    if (s.endsWith('ies'))
+        return `${s.slice(0, -3)}y`;
+    if (s.endsWith('ses') || s.endsWith('xes') || s.endsWith('zes'))
+        return s.slice(0, -2);
+    if (s.endsWith('s') && !s.endsWith('ss'))
+        return s.slice(0, -1);
+    return s;
+}
+/** Ordered, de-duplicated table-name candidates for a model without `@@map`. */
+function tableCandidates(modelName) {
+    const snake = pascalToSnake(modelName);
+    const raw = modelName;
+    const set = new Set([
+        raw,
+        raw.toLowerCase(),
+        snake,
+        pluralize(snake),
+        singularize(snake),
+        pluralize(raw.toLowerCase()),
+    ]);
+    return [...set].filter((s) => s !== '');
+}
+// ---------------------------------------------------------------------------
+// Field/column resolution
+// ---------------------------------------------------------------------------
+/** The database column a Prisma field maps to (`@map` wins, else the field name). */
+function fieldColumn(model, fieldName) {
+    const f = model.fields.find((x) => x.name === fieldName);
+    if (!f)
+        return fieldName;
+    const mapAttr = f.attrs.find((a) => a.name === 'map');
+    const arg = mapAttr?.args.find((a) => a.key === undefined);
+    return arg?.kind === 'string' && arg.value ? arg.value : f.name;
+}
+/** True when a field's type names a parsed model (so it is a relation/object field). */
+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;
+    const modelNames = new Set(ast.models.map((m) => m.name));
+    const tableNames = schema ? new Set(Object.keys(schema.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) {
+        modelTable.set(model.name, resolveTable(model, tableNames, noDb));
+    }
+    const result = {
+        models: [],
+        enums: [],
+        map: { models: {}, enums: {} },
+        hasUnresolved: false,
+        parseWarnings: ast.warnings,
+        noDb,
+    };
+    // Pass 2 - resolve fields, relations, and compound uniques.
+    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 accessor = table ? snakeToCamel(table) : null;
+        const status = noDb ? 'parsed' : table ? 'resolved' : 'unresolved';
+        const resolved = {
+            prismaName: model.name,
+            kind: model.kind,
+            table,
+            accessor,
+            viaMap: rt.viaMap,
+            status,
+            reason: rt.reason,
+            fields: [],
+            relations: [],
+            compoundUniques: [],
+        };
+        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));
+            }
+            else {
+                resolved.fields.push(resolveScalarField(model, field.name, tableMeta, noDb));
+            }
+        }
+        for (const key of model.compoundKeys) {
+            // Prisma only synthesizes a compound selector object for multi-field keys
+            // or an explicitly named one; single-field keys are addressed flat.
+            if (key.fields.length < 2 && !key.name)
+                continue;
+            resolved.compoundUniques.push(resolveCompoundUnique(model, key, tableMeta, noDb));
+        }
+        result.models.push(resolved);
+        // Build the verified map entry (skip in --no-db and for unresolved tables).
+        if (!noDb && table && accessor) {
+            const fields = {};
+            for (const f of resolved.fields) {
+                if (f.status === 'resolved' && f.turbineField)
+                    fields[f.prismaName] = f.turbineField;
+            }
+            const relations = {};
+            for (const r of resolved.relations) {
+                if (r.status === 'resolved' && r.turbineName && r.cardinality) {
+                    relations[r.prismaName] = { name: r.turbineName, cardinality: r.cardinality };
+                }
+            }
+            const compoundUniques = {};
+            for (const c of resolved.compoundUniques) {
+                if (c.status === 'resolved' && c.turbineFields)
+                    compoundUniques[c.selector] = c.turbineFields;
+            }
+            result.map.models[model.name] = { table, accessor, fields, relations, compoundUniques };
+        }
+    }
+    // Enums.
+    for (const en of ast.enums) {
+        const r = resolveEnum(en.name, en.map, schema, noDb);
+        result.enums.push(r);
+        if (!noDb && r.status === 'resolved' && r.turbineName)
+            result.map.enums[en.name] = r.turbineName;
+    }
+    result.hasUnresolved = computeHasUnresolved(result);
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Per-construct resolvers
+// ---------------------------------------------------------------------------
+function resolveTable(model, tableNames, noDb) {
+    if (model.kind === 'type') {
+        return { table: null, viaMap: false, reason: 'composite/embedded type - not a table' };
+    }
+    if (noDb)
+        return { table: null, viaMap: !!model.map };
+    if (model.map) {
+        if (tableNames.has(model.map))
+            return { table: model.map, viaMap: true };
+        return { table: null, viaMap: true, reason: `@@map("${model.map}") target table not found in the database` };
+    }
+    const candidates = tableCandidates(model.name);
+    const matches = candidates.filter((c) => tableNames.has(c));
+    const distinct = [...new Set(matches)];
+    if (distinct.length === 1)
+        return { table: distinct[0], viaMap: false };
+    if (distinct.length > 1) {
+        return {
+            table: null,
+            viaMap: false,
+            reason: `ambiguous - multiple tables match (${distinct.join(', ')}); add @@map("<table>") to disambiguate`,
+        };
+    }
+    return {
+        table: null,
+        viaMap: false,
+        reason: `no table matched (tried ${candidates.join(', ')}); add @@map("<table>")`,
+    };
+}
+function resolveScalarField(model, fieldName, tableMeta, noDb) {
+    const column = fieldColumn(model, fieldName);
+    if (noDb || !tableMeta) {
+        return { prismaName: fieldName, turbineField: null, column: null, status: noDb ? 'parsed' : 'unresolved' };
+    }
+    const turbineField = tableMeta.reverseColumnMap[column];
+    if (turbineField) {
+        return { prismaName: fieldName, turbineField, column, status: 'resolved' };
+    }
+    return {
+        prismaName: fieldName,
+        turbineField: null,
+        column: null,
+        status: 'unresolved',
+        reason: `column "${column}" not found on table "${tableMeta.name}"`,
+    };
+}
+function resolveRelation(model, fieldName, targetModelName, isList, modelTable, schema, tableMeta, noDb) {
+    const cardinality = isList ? 'many' : 'one';
+    const base = {
+        prismaName: fieldName,
+        turbineName: null,
+        cardinality: noDb ? null : cardinality,
+        targetModel: targetModelName,
+        status: noDb ? 'parsed' : 'unresolved',
+    };
+    if (noDb)
+        return base;
+    if (!schema || !tableMeta) {
+        return { ...base, reason: 'model table unresolved' };
+    }
+    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;
+    const candidates = Object.values(tableMeta.relations).filter((def) => {
+        if (targetTable && def.to !== targetTable)
+            return false;
+        if (cardinality === 'many')
+            return def.type === 'hasMany' || def.type === 'manyToMany';
+        return def.type === 'belongsTo' || def.type === 'hasOne';
+    });
+    let picked = candidates;
+    if (fkColumns && fkColumns.length > 0) {
+        const want = [...fkColumns].sort().join(',');
+        const byFk = candidates.filter((def) => {
+            const fk = Array.isArray(def.foreignKey) ? def.foreignKey : [def.foreignKey];
+            return [...fk].sort().join(',') === want;
+        });
+        if (byFk.length > 0)
+            picked = byFk;
+    }
+    if (picked.length === 1) {
+        const def = picked[0];
+        return {
+            ...base,
+            turbineName: def.name,
+            cardinality,
+            junction: def.type === 'manyToMany' ? def.through?.table : undefined,
+            status: 'resolved',
+        };
+    }
+    if (picked.length > 1) {
+        return {
+            ...base,
+            reason: `ambiguous - ${picked.length} candidate relations match (${picked.map((d) => d.name).join(', ')})`,
+        };
+    }
+    const targetNote = targetTable ? `table "${targetTable}"` : `model "${targetModelName}" (table unresolved)`;
+    return { ...base, reason: `no ${cardinality} relation to ${targetNote} on table "${tableMeta.name}"` };
+}
+function resolveCompoundUnique(model, key, tableMeta, noDb) {
+    const selector = key.name ?? key.fields.join('_');
+    const base = {
+        selector,
+        prismaFields: key.fields,
+        turbineFields: null,
+        kind: key.kind,
+        status: noDb ? 'parsed' : 'unresolved',
+    };
+    if (noDb || !tableMeta)
+        return base;
+    const columns = key.fields.map((f) => fieldColumn(model, f));
+    const missing = columns.filter((c) => !tableMeta.reverseColumnMap[c]);
+    if (missing.length > 0) {
+        return { ...base, reason: `column(s) not found: ${missing.join(', ')}` };
+    }
+    const turbineFields = columns.map((c) => tableMeta.reverseColumnMap[c]);
+    const want = [...columns].sort().join(',');
+    const matches = (setList) => setList.some((s) => [...s].sort().join(',') === want);
+    if (key.kind === 'id') {
+        if (matches([tableMeta.primaryKey]))
+            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))
+        return { ...base, turbineFields, status: 'resolved' };
+    return { ...base, reason: `no unique constraint on "${tableMeta.name}" matches (${columns.join(', ')})` };
+}
+function resolveEnum(name, map, schema, noDb) {
+    if (noDb || !schema)
+        return { prismaName: name, turbineName: null, status: noDb ? 'parsed' : 'unresolved' };
+    // An explicit @@map names the database enum type outright.
+    const candidates = map ? [map] : [name, name.toLowerCase(), pascalToSnake(name)];
+    const matches = [...new Set(candidates.filter((c) => Object.hasOwn(schema.enums, c)))];
+    if (matches.length === 1)
+        return { prismaName: name, turbineName: matches[0], status: 'resolved' };
+    if (matches.length > 1) {
+        return {
+            prismaName: name,
+            turbineName: null,
+            status: 'unresolved',
+            reason: `ambiguous enum match (${matches.join(', ')})`,
+        };
+    }
+    return { prismaName: name, turbineName: null, status: 'unresolved', reason: 'no matching database enum type' };
+}
+function computeHasUnresolved(result) {
+    if (result.noDb)
+        return false;
+    for (const m of result.models) {
+        if (m.status === 'unresolved')
+            return true;
+        if (m.fields.some((f) => f.status === 'unresolved'))
+            return true;
+        if (m.relations.some((r) => r.status === 'unresolved'))
+            return true;
+        if (m.compoundUniques.some((c) => c.status === 'unresolved'))
+            return true;
+    }
+    if (result.enums.some((e) => e.status === 'unresolved'))
+        return true;
+    return false;
+}