turbine-orm 0.65.0 → 0.66.0

package/dist/cjs/cli/index.js

@@ -74,6 +74,7 @@ exports.planEnvScaffold = planEnvScaffold;
 exports.scaffoldEnvForUrl = scaffoldEnvForUrl;
 exports.initEnvNotice = initEnvNotice;
 exports.resolveMigrateFromPrismaUrl = resolveMigrateFromPrismaUrl;
+exports.readPrismaSchemaSource = readPrismaSchemaSource;
 exports.buildMigrateDeployOptions = buildMigrateDeployOptions;
 exports.getSeedExecutionPlan = getSeedExecutionPlan;
 exports.isLoopbackHost = isLoopbackHost;
@@ -965,15 +966,21 @@ async function runInitPush(config, url) {
     }
     const schemaDef = await loadSchemaFile(config.schemaFile);
     const spinner = new ui_js_1.Spinner('Computing schema diff').start();
-    const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url);
+    const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url, { schema: config.schema });
     if (diff.statements.length === 0) {
         spinner.succeed('Database already in sync: nothing to push');
         return;
     }
     spinner.succeed(`Found ${(0, ui_js_1.bold)(String(diff.statements.length))} change(s) to apply`);
+    // Same as `push`: a type change carries a warning naming what it costs the
+    // existing rows, and it is worth no less here than on the standalone command.
+    if (diff.warnings && diff.warnings.length > 0) {
+        for (const w of diff.warnings)
+            (0, ui_js_1.warn)(w);
+    }
     const pushSpinner = new ui_js_1.Spinner('Applying schema').start();
     try {
-        const result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, { precomputedDiff: diff });
+        const result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, { precomputedDiff: diff, schema: config.schema });
         pushSpinner.succeed(`Applied ${(0, ui_js_1.bold)(String(result.statementsExecuted))} statement(s)`);
     }
     catch (err) {
@@ -984,7 +991,11 @@ async function runInitPush(config, url) {
             (0, ui_js_1.warn)('Push aborted: no schema changes were applied.');
             return;
         }
-        const result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, { allowDestructive: true, precomputedDiff: diff });
+        const result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, {
+            allowDestructive: true,
+            precomputedDiff: diff,
+            schema: config.schema,
+        });
         (0, ui_js_1.success)(`Applied ${(0, ui_js_1.bold)(String(result.statementsExecuted))} statement(s)`);
     }
 }
@@ -1459,19 +1470,57 @@ function resolveMigrateFromPrismaUrl(configUrl, ast, env) {
     }
     return { source: 'none', missingVariables: lookup.missingVariables };
 }
+/**
+ * Read a Prisma schema from a FILE or from a multi-file schema DIRECTORY
+ * (Prisma >= 5.15, GA). A directory used to reach `readFileSync` unchanged and
+ * die with a raw `EISDIR`, which is a stack trace rather than an answer.
+ *
+ * Prisma treats every `.prisma` file under the directory as one logical schema,
+ * so they are concatenated in sorted order (stable across machines) and parsed
+ * as a single source. Line numbers in any parse error then refer to that
+ * concatenation, so each file is introduced by a comment naming it.
+ */
+function readPrismaSchemaSource(path) {
+    if (!(0, node_fs_1.statSync)(path).isDirectory())
+        return (0, node_fs_1.readFileSync)(path, 'utf-8');
+    const files = (0, node_fs_1.readdirSync)(path)
+        .filter((f) => f.endsWith('.prisma'))
+        .sort();
+    if (files.length === 0) {
+        throw new Error(`No .prisma files found in directory ${path}.`);
+    }
+    return files.map((f) => `// file: ${f}\n${(0, node_fs_1.readFileSync)((0, node_path_1.join)(path, f), 'utf-8')}`).join('\n');
+}
 async function cmdMigrateFromPrisma(args, config) {
     (0, ui_js_1.banner)();
-    // `--schema` is the Prisma schema file path in this command.
-    const prismaPath = (0, node_path_1.resolve)(args.schema ?? 'prisma/schema.prisma');
+    // `--schema` is the Prisma schema file path in this command. It may also name
+    // a DIRECTORY (Prisma's multi-file schema, GA since 5.15), and the default
+    // `prisma/schema.prisma` falls back to `prisma/schema/` for the same reason.
+    const explicit = args.schema !== undefined;
+    let prismaPath = (0, node_path_1.resolve)(args.schema ?? 'prisma/schema.prisma');
+    if (!explicit && !(0, node_fs_1.existsSync)(prismaPath) && (0, node_fs_1.existsSync)((0, node_path_1.resolve)('prisma/schema'))) {
+        prismaPath = (0, node_path_1.resolve)('prisma/schema');
+    }
     if (!(0, node_fs_1.existsSync)(prismaPath)) {
-        (0, ui_js_1.error)(`Prisma schema file not found: ${(0, ui_js_1.cyan)(prismaPath)}`);
+        (0, ui_js_1.error)(`Prisma schema not found: ${(0, ui_js_1.cyan)(prismaPath)}`);
         (0, ui_js_1.newline)();
-        console.log(`  ${(0, ui_js_1.dim)('Point at it with')} ${(0, ui_js_1.cyan)('--schema <path/to/schema.prisma>')} ${(0, ui_js_1.dim)('(default: prisma/schema.prisma).')}`);
+        console.log(`  ${(0, ui_js_1.dim)('Point at it with')} ${(0, ui_js_1.cyan)('--schema <path>')} ${(0, ui_js_1.dim)('(a .prisma file, or a directory of them;')}`);
+        console.log(`  ${(0, ui_js_1.dim)('default: prisma/schema.prisma, then prisma/schema/).')}`);
         (0, ui_js_1.newline)();
         process.exit(1);
     }
     // Parse (fatal only on a construct we must understand).
-    const source = (0, node_fs_1.readFileSync)(prismaPath, 'utf-8');
+    let source;
+    try {
+        source = readPrismaSchemaSource(prismaPath);
+    }
+    catch (err) {
+        (0, ui_js_1.newline)();
+        (0, ui_js_1.error)(`Could not read ${(0, ui_js_1.cyan)(prismaPath)}`);
+        console.log(`  ${(0, ui_js_1.red)(err instanceof Error ? err.message : String(err))}`);
+        (0, ui_js_1.newline)();
+        process.exit(1);
+    }
     let ast;
     try {
         ast = (0, prisma_schema_js_1.parsePrismaSchema)(source);
@@ -1543,6 +1592,18 @@ async function cmdMigrateFromPrisma(args, config) {
         console.log(`  ${marker} ${line}`);
     }
     (0, ui_js_1.newline)();
+    // Parser notes on the CONSOLE, not only in the Markdown report.
+    //
+    // `--no-db` is the first command anyone runs and the one place a parse
+    // problem should surface, and it was the one place that could not: resolution
+    // is skipped, `hasUnresolved` is false by construction, so the run printed a
+    // clean summary and exited 0 no matter what the parser had thrown away.
+    if (result.parseWarnings.length > 0) {
+        (0, ui_js_1.header)('Parser notes');
+        for (const w of result.parseWarnings)
+            console.log(`  ${(0, ui_js_1.yellow)(ui_js_1.symbols.warning)} ${w}`);
+        (0, ui_js_1.newline)();
+    }
     // Write outputs into the generate outDir.
     const outDir = (0, node_path_1.resolve)(config.out);
     const rel = (0, node_path_1.relative)(process.cwd(), outDir);
@@ -1590,6 +1651,15 @@ async function cmdMigrateFromPrisma(args, config) {
         (0, ui_js_1.newline)();
         process.exit(1);
     }
+    // `--no-db` has no resolution to fail on, so parser notes are the ONLY signal
+    // it can carry. Treated like an unresolved item, and cleared by the same
+    // `--allow-partial` opt-in, so "exit 0" means the same thing in both modes.
+    if (args.noDb && result.parseWarnings.length > 0 && !args.allowPartial) {
+        (0, ui_js_1.warn)(`${result.parseWarnings.length} parser note(s) above (also in the report). ` +
+            'Re-run with --allow-partial to accept them.');
+        (0, ui_js_1.newline)();
+        process.exit(1);
+    }
     if (args.noDb) {
         (0, ui_js_1.info)(`Parse-only report written. Re-run without ${(0, ui_js_1.cyan)('--no-db')} against your database to resolve names.`);
     }
@@ -1612,7 +1682,7 @@ async function cmdPush(args, config) {
     (0, ui_js_1.info)(`Schema defines ${(0, ui_js_1.bold)(String(tableCount))} tables`);
     // Compute diff
     const diffSpinner = new ui_js_1.Spinner('Computing schema diff').start();
-    const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url);
+    const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url, { schema: config.schema });
     if (diff.statements.length === 0 && diff.drop.length === 0) {
         diffSpinner.succeed('Database is already in sync');
         (0, ui_js_1.newline)();
@@ -1687,7 +1757,11 @@ async function cmdPush(args, config) {
     const pushSpinner = new ui_js_1.Spinner('Applying changes').start();
     let result;
     try {
-        result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, { allowDestructive: args.allowDestructive, precomputedDiff: diff });
+        result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, {
+            allowDestructive: args.allowDestructive,
+            precomputedDiff: diff,
+            schema: config.schema,
+        });
     }
     catch (err) {
         if (!(err instanceof schema_sql_js_1.DestructivePushRefusal))
@@ -1699,7 +1773,11 @@ async function cmdPush(args, config) {
             process.exit(1);
         }
         pushSpinner.start();
-        result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, { allowDestructive: true, precomputedDiff: diff });
+        result = await (0, schema_sql_js_1.schemaPush)(schemaDef, url, {
+            allowDestructive: true,
+            precomputedDiff: diff,
+            schema: config.schema,
+        });
     }
     pushSpinner.succeed(`Applied ${(0, ui_js_1.bold)(String(result.statementsExecuted))} statement(s)`);
     if (result.tablesCreated.length > 0) {
@@ -1813,7 +1891,7 @@ async function cmdMigrateCreate(args, config) {
         (0, ui_js_1.newline)();
         const schemaDef = await loadSchemaFile(config.schemaFile);
         const diffSpinner = new ui_js_1.Spinner('Computing schema diff').start();
-        const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url);
+        const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url, { schema: config.schema });
         if (diff.statements.length === 0) {
             diffSpinner.succeed('Database is already in sync: nothing to migrate');
             (0, ui_js_1.newline)();
@@ -1890,7 +1968,7 @@ async function cmdMigrateCreate(args, config) {
         (0, ui_js_1.newline)();
         const schemaDef = await loadSchemaFile(config.schemaFile);
         const diffSpinner = new ui_js_1.Spinner('Computing schema diff').start();
-        const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url);
+        const diff = await (0, schema_sql_js_1.schemaDiff)(schemaDef, url, { schema: config.schema });
         if (diff.statements.length === 0) {
             diffSpinner.succeed('Database is already in sync: nothing to migrate');
             (0, ui_js_1.newline)();
@@ -2550,9 +2628,24 @@ const TIER_LABEL = {
     'take-deliberately': 'TAKE DELIBERATELY',
     scrutinize: 'SCRUTINIZE',
 };
-/** Build the `CREATE INDEX` for a finding, honoring the partial-null suggestion. */
+/**
+ * The `CREATE INDEX` for a finding (display / JSON only), honoring the
+ * partial-null suggestion. The migration writer uses
+ * {@link buildCreateIndexStatements} instead, which adds the preceding
+ * `DROP INDEX CONCURRENTLY IF EXISTS` that makes a rerun converge.
+ */
 function doctorCreateSql(f, opts) {
     return (0, index_advisor_js_1.buildCreateIndexSql)(f.missing.table, f.missing.columns, f.missing.indexName, {
+        concurrently: opts.concurrently,
+        // The report line is advice a human may copy into psql, where the
+        // guard is genuinely useful and there is no corpse to skip.
+        ifNotExists: true,
+        partialNotNull: f.score.partialNotNull,
+    });
+}
+/** The statements the fix migration's UP body runs for one finding. */
+function doctorCreateStatements(f, opts) {
+    return (0, index_advisor_js_1.buildCreateIndexStatements)(f.missing.table, f.missing.columns, f.missing.indexName, {
         concurrently: opts.concurrently,
         partialNotNull: f.score.partialNotNull,
     });
@@ -2565,13 +2658,17 @@ const CONCURRENTLY_RECIPE_COMMENT = [
     '--',
     '--   1. Idempotency is required. This migration is recorded only after ALL',
     '--      statements succeed; a mid-file failure leaves earlier indexes built and',
-    '--      the migration unrecorded, so a rerun must be safe. IF NOT EXISTS keeps',
-    '--      each CREATE idempotent.',
-    '--   2. The INVALID-index trap. A CREATE INDEX CONCURRENTLY that fails partway',
-    '--      leaves an INVALID index behind. On rerun, IF NOT EXISTS SKIPS that',
-    '--      corpse (the name already exists), so the index is never actually built.',
-    '--      Fix: DROP INDEX CONCURRENTLY the invalid index, then rerun. Run',
-    '--      "turbine doctor" to list invalid indexes.',
+    '--      the migration unrecorded, so a rerun must be safe.',
+    '--   2. The INVALID-index trap, and why each CREATE is preceded by a DROP.',
+    '--      A CREATE INDEX CONCURRENTLY that fails partway leaves an INVALID index',
+    '--      behind, under the name it was asked for. IF NOT EXISTS matches on the',
+    '--      NAME and not on validity, so with it a rerun SKIPS the corpse and the',
+    '--      index is never actually built: the migration records as applied while',
+    '--      the index doctor reported is still missing. The DROP INDEX',
+    '--      CONCURRENTLY IF EXISTS line ahead of each CREATE is a no-op on the',
+    '--      first run (the index does not exist yet, which is why it was',
+    '--      proposed) and clears the corpse on a rerun, so rerunning converges on',
+    '--      a VALID index. Run "turbine doctor" to list invalid indexes.',
     '--   3. Locking. CREATE INDEX CONCURRENTLY waits for every transaction that can',
     '--      see the table to finish. A long-running transaction makes it wait and',
     '--      makes "migrate up" look hung. For bounded waits, SET lock_timeout /',
@@ -3285,7 +3382,7 @@ function renderPlanDivergence(divergence, attached) {
 /** Write the --fix migration (CONCURRENTLY + directive by default; plain with --no-concurrently). */
 function renderFixMigration(findings, config, args) {
     const concurrently = args.noConcurrently !== true;
-    const up = findings.map((f) => doctorCreateSql(f, { concurrently })).join('\n');
+    const up = findings.flatMap((f) => doctorCreateStatements(f, { concurrently })).join('\n');
     const down = findings.map((f) => (0, index_advisor_js_1.buildDropIndexSql)(f.missing.indexName, { concurrently })).join('\n');
     let file;
     if (concurrently) {

package/dist/cjs/cli/mcp.d.ts

@@ -1,6 +1,6 @@
 import type { Readable, Writable } from 'node:stream';
 import pg from 'pg';
-import { type ColumnMetadata, type RelationDef } from '../schema.js';
+import { type ColumnMetadata, type IndexMetadata, type RelationDef } from '../schema.js';
 export interface McpServerOptions {
     url: string;
     schema: string;
@@ -31,6 +31,14 @@ export interface McpServerHandle {
 }
 export declare function startMcpServer(options: McpServerOptions, transport?: McpTransport): McpServerHandle;
 interface ForeignKeyRow {
+    /**
+     * `pg_constraint.oid` as text. THE grouping key: a constraint NAME is unique
+     * only per table (conrelid, conname), so two tables in one schema may both
+     * have a `shared_fk` and grouping on the name alone merges them, which loses
+     * one table's relation entirely and points the other at a column its target
+     * does not have. The OID is unique catalog-wide.
+     */
+    constraint_oid: string;
     source_table: string;
     source_column: string;
     target_table: string;
@@ -38,13 +46,25 @@ interface ForeignKeyRow {
     constraint_name: string;
 }
 /**
- * Group raw FK rows into constraint-level entries and delegate relation
- * naming to the SHARED introspection builder (`buildRelationsFromForeignKeys`
- * + `addAutoManyToManyRelations` in ../introspect.ts). MCP previously carried
- * a stale copy of a retired naming scheme, so `turbine mcp` and `turbine
- * generate` derived DIFFERENT relation names from the same database.
- * Exported for the parity unit test.
+ * Group raw FK rows into constraint-level entries and delegate relation naming
+ * to `deriveCatalogRelations` in ../introspect.ts, the SAME entry point
+ * `turbine generate` goes through. MCP introspects for itself (it cannot assume
+ * generated metadata exists), so any divergence here is a divergence a live MCP
+ * client trips over: it reads a relation name out of the MCP schema tool, passes
+ * it back in a query, and the core builder rejects it.
+ *
+ * MCP used to assemble the pipeline by hand and drifted twice over, both times
+ * by OMITTING an optional argument, which is silently type-correct and changes
+ * the answer: without `uniqueSetsByTable` a UNIQUE foreign key came back as
+ * `users.profiles` (hasMany) where generate said `users.profile` (hasOne), and
+ * without `uniqueIndexColsByTable` every Prisma-style PK-less junction lost its
+ * auto-m2m relations. Passing the whole input set to one shared function is what
+ * makes those two failures impossible rather than merely fixed.
+ *
+ * `uniqueByTable` and `indexesByTable` are therefore REQUIRED parameters, not
+ * optional ones: an optional catalog input is exactly how the hasOne flip went
+ * missing here in the first place. Exported for the parity unit test.
  */
-export declare function buildRelations(tableNames: string[], columnsByTable: Map<string, ColumnMetadata[]>, pkByTable: Map<string, string[]>, rows: ForeignKeyRow[], enums?: Record<string, string[]>): Map<string, Record<string, RelationDef>>;
+export declare function buildRelations(tableNames: string[], columnsByTable: Map<string, ColumnMetadata[]>, pkByTable: Map<string, string[]>, rows: ForeignKeyRow[], uniqueByTable: Map<string, string[][]>, indexesByTable: Map<string, IndexMetadata[]>, enums?: Record<string, string[]>): Map<string, Record<string, RelationDef>>;
 export declare function runMcpServer(options: McpServerOptions): Promise<void>;
 export {};