@prisma-next/cli 0.5.0-dev.3 → 0.5.0-dev.31

package/src/commands/contract-emit.ts

@@ -1,18 +1,13 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
 import { getEmittedArtifactPaths } from '@prisma-next/emitter';
 import { errorContractConfigMissing } from '@prisma-next/errors/control';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { dirname, relative, resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
-import { createControlClient } from '../control-api/client';
-import type { EmitFailure } from '../control-api/types';
-import {
-  CliStructuredError,
-  errorContractValidationFailed,
-  errorRuntime,
-  errorUnexpected,
-} from '../utils/cli-errors';
+import { executeContractEmit } from '../control-api/operations/contract-emit';
+import type { ContractEmitResult } from '../control-api/types';
+import { CliStructuredError, errorUnexpected } from '../utils/cli-errors';
 import {
   addGlobalOptions,
   setCommandDescriptions,
@@ -34,74 +29,29 @@ interface ContractEmitOptions extends CommonCommandOptions {
   readonly config?: string;
 }
 
-function mapDiagnosticsToIssues(
-  failure: EmitFailure,
-): ReadonlyArray<{ kind: string; message: string }> {
-  const diagnostics = failure.diagnostics?.diagnostics ?? [];
-  return diagnostics.map((diagnostic) => {
-    const location =
-      diagnostic.sourceId && diagnostic.span
-        ? ` (${diagnostic.sourceId}:${diagnostic.span.start.line}:${diagnostic.span.start.column})`
-        : diagnostic.sourceId
-          ? ` (${diagnostic.sourceId})`
-          : '';
-    return {
-      kind: diagnostic.code,
-      message: `${diagnostic.message}${location}`,
-    };
-  });
+interface HeaderPaths {
+  readonly displayConfigPath: string;
+  readonly outputJsonPath: string;
+  readonly outputDtsPath: string;
 }
 
 /**
- * Maps an EmitFailure to a CliStructuredError for consistent error handling.
+ * Pre-load the config just to compute display paths for the styled header. The
+ * actual emit work goes through `executeContractEmit`, which loads the config
+ * itself; the redundant load here is bounded and lets the header render before
+ * the emit spans start.
  */
-function mapEmitFailure(
-  failure: EmitFailure,
-  context?: { readonly configPath?: string },
-): CliStructuredError {
-  if (failure.code === 'CONTRACT_SOURCE_INVALID') {
-    const issues = mapDiagnosticsToIssues(failure);
-    return errorRuntime(failure.summary, {
-      why: failure.why ?? 'Contract source provider failed',
-      fix: 'Check your contract source provider in prisma-next.config.ts and ensure it returns Result<Contract, Diagnostics>',
-      ...(issues.length > 0 ? { meta: { issues } } : {}),
-    });
-  }
-
-  if (failure.code === 'CONTRACT_VALIDATION_FAILED') {
-    return errorContractValidationFailed(
-      failure.why ?? 'Contract validation failed while emitting',
-      context?.configPath ? { where: { path: context.configPath } } : undefined,
-    );
-  }
-
-  if (failure.code === 'EMIT_FAILED') {
-    return errorRuntime(failure.summary, {
-      why: failure.why ?? 'Failed to emit contract',
-      fix: 'Check your contract configuration and ensure the source is valid',
-    });
-  }
-
-  // Exhaustive check - TypeScript will error if a new code is added but not handled
-  const exhaustive: never = failure.code;
-  throw new Error(`Unhandled EmitFailure code: ${exhaustive}`);
-}
+async function resolveHeaderPaths(
+  configOption: string | undefined,
+): Promise<Result<HeaderPaths, CliStructuredError>> {
+  const displayConfigPath = configOption
+    ? relative(process.cwd(), resolve(configOption))
+    : 'prisma-next.config.ts';
 
-/**
- * Executes the contract emit command and returns a structured Result.
- */
-async function executeContractEmitCommand(
-  options: ContractEmitOptions,
-  flags: GlobalFlags,
-  ui: TerminalUI,
-  startTime: number,
-): Promise<Result<EmitContractResult, CliStructuredError>> {
-  // Load config
   let config: Awaited<ReturnType<typeof loadConfig>>;
   try {
-    config = await loadConfig(options.config);
+    config = await loadConfig(configOption);
   } catch (error) {
-    // Convert thrown CliStructuredError to Result
     if (error instanceof CliStructuredError) {
       return notOk(error);
     }
@@ -112,33 +62,19 @@ async function executeContractEmitCommand(
     );
   }
 
-  const configPath = options.config
-    ? relative(process.cwd(), resolve(options.config))
-    : 'prisma-next.config.ts';
-
-  // Resolve contract from config
-  if (!config.contract) {
+  if (!config.contract?.output) {
     return notOk(
       errorContractConfigMissing({
-        why: 'Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ... }',
+        why: 'Config.contract.output is required for emit. Define it in your config: contract: { source: ..., output: ... }',
       }),
     );
   }
 
-  // Contract config is already normalized by defineConfig() with defaults applied
-  const contractConfig = config.contract;
-
-  // Resolve artifact paths from config (already normalized by defineConfig() with defaults)
-  if (!contractConfig.output) {
-    return notOk(
-      errorContractConfigMissing({
-        why: 'Contract config must have output path. This should not happen if defineConfig() was used.',
-      }),
-    );
-  }
-  let outputPaths: ReturnType<typeof getEmittedArtifactPaths>;
   try {
-    outputPaths = getEmittedArtifactPaths(contractConfig.output);
+    const { jsonPath: outputJsonPath, dtsPath: outputDtsPath } = getEmittedArtifactPaths(
+      config.contract.output,
+    );
+    return ok({ displayConfigPath, outputJsonPath, outputDtsPath });
   } catch (error) {
     return notOk(
       errorContractConfigMissing({
@@ -146,96 +82,65 @@ async function executeContractEmitCommand(
       }),
     );
   }
-  const { jsonPath: outputJsonPath, dtsPath: outputDtsPath } = outputPaths;
+}
 
-  // Output header to stderr (decoration)
-  if (!flags.json && !flags.quiet) {
-    const contractPath = relative(process.cwd(), outputJsonPath);
-    const typesPath = relative(process.cwd(), outputDtsPath);
-    const header = formatStyledHeader({
-      command: 'contract emit',
-      description: 'Emit your contract artifacts',
-      url: 'https://pris.ly/contract-emit',
-      details: [
-        { label: 'config', value: configPath },
-        { label: 'contract', value: contractPath },
-        { label: 'types', value: typesPath },
-      ],
-      flags,
-    });
-    ui.stderr(header);
+async function executeContractEmitCommand(
+  options: ContractEmitOptions,
+  flags: GlobalFlags,
+  ui: TerminalUI,
+  startTime: number,
+): Promise<Result<EmitContractResult, CliStructuredError>> {
+  const headerPathsResult = await resolveHeaderPaths(options.config);
+  if (!headerPathsResult.ok) {
+    return headerPathsResult;
   }
+  const { displayConfigPath, outputJsonPath, outputDtsPath } = headerPathsResult.value;
 
-  // Create control client (no driver needed for emit)
-  const client = createControlClient({
-    family: config.family,
-    target: config.target,
-    adapter: config.adapter,
-    extensionPacks: config.extensionPacks ?? [],
-  });
+  if (!flags.json && !flags.quiet) {
+    ui.stderr(
+      formatStyledHeader({
+        command: 'contract emit',
+        description: 'Emit your contract artifacts',
+        url: 'https://pris.ly/contract-emit',
+        details: [
+          { label: 'config', value: displayConfigPath },
+          { label: 'contract', value: relative(process.cwd(), outputJsonPath) },
+          { label: 'types', value: relative(process.cwd(), outputDtsPath) },
+        ],
+        flags,
+      }),
+    );
+  }
 
-  // Create progress adapter
   const onProgress = createProgressAdapter({ ui, flags });
+  const configPath = options.config ? resolve(options.config) : 'prisma-next.config.ts';
 
+  let result: ContractEmitResult;
   try {
-    // Call emit with progress callback
-    const result = await client.emit({
-      contractConfig: {
-        source: contractConfig.source,
-        output: outputJsonPath,
-      },
-      onProgress,
-    });
-
-    // Handle failures by mapping to CLI structured error
-    if (!result.ok) {
-      return notOk(mapEmitFailure(result.failure, { configPath }));
-    }
-
-    // Create directories if needed
-    mkdirSync(dirname(outputJsonPath), { recursive: true });
-    mkdirSync(dirname(outputDtsPath), { recursive: true });
-
-    // Write the results to files
-    writeFileSync(outputJsonPath, result.value.contractJson, 'utf-8');
-    writeFileSync(outputDtsPath, result.value.contractDts, 'utf-8');
-
-    // Validate that contract.d.ts type imports are resolvable
-    const { validateContractDeps } = await import('../utils/validate-contract-deps');
-    const depsValidation = validateContractDeps(result.value.contractDts, dirname(outputDtsPath));
-    if (depsValidation.warning) {
-      ui.warn(depsValidation.warning);
-    }
-
-    // Convert success result to CLI output format
-    const emitResult: EmitContractResult = {
-      storageHash: result.value.storageHash,
-      ...(result.value.executionHash ? { executionHash: result.value.executionHash } : {}),
-      profileHash: result.value.profileHash,
-      outDir: dirname(outputJsonPath),
-      files: {
-        json: outputJsonPath,
-        dts: outputDtsPath,
-      },
-      timings: { total: Date.now() - startTime },
-    };
-
-    return ok(emitResult);
+    result = await executeContractEmit({ configPath, onProgress });
   } catch (error) {
-    // Use static type guard to work across module boundaries
     if (CliStructuredError.is(error)) {
       return notOk(error);
     }
-
-    // Wrap unexpected errors
     return notOk(
       errorUnexpected('Unexpected error during contract emit', {
         why: error instanceof Error ? error.message : String(error),
       }),
     );
-  } finally {
-    await client.close();
   }
+
+  if (result.validationWarning) {
+    ui.warn(result.validationWarning);
+  }
+
+  return ok({
+    storageHash: result.storageHash,
+    ...ifDefined('executionHash', result.executionHash),
+    profileHash: result.profileHash,
+    outDir: dirname(result.files.json),
+    files: result.files,
+    timings: { total: Date.now() - startTime },
+  });
 }
 
 export function createContractEmitCommand(): Command {
@@ -260,7 +165,6 @@ export function createContractEmitCommand(): Command {
 
       const result = await executeContractEmitCommand(options, flags, ui, startTime);
 
-      // Handle result - formats output and returns exit code
       const exitCode = handleResult(result, flags, ui, (emitResult) => {
         if (flags.json) {
           ui.output(formatEmitJson(emitResult));

package/src/commands/contract-infer.ts

@@ -1,12 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { errorRuntime } from '@prisma-next/errors/execution';
-import { printPsl, validatePrintableSqlSchemaIR } from '@prisma-next/psl-printer';
-import {
-  createPostgresDefaultMapping,
-  createPostgresTypeMap,
-  extractEnumInfo,
-  parseRawDefault,
-} from '@prisma-next/psl-printer/postgres';
+import { printPsl } from '@prisma-next/psl-printer';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { dirname, relative } from 'pathe';
@@ -59,26 +53,19 @@ async function executeContractInferCommand(
     return inspectResult;
   }
 
-  const { config, target, meta } = inspectResult.value;
+  const { config, target, meta, pslContractAst } = inspectResult.value;
 
-  if (target.familyId !== 'sql') {
+  if (!pslContractAst) {
     return notOk(
-      errorRuntime(`contract infer is not supported for family "${target.familyId}"`, {
-        why: 'contract infer currently supports SQL targets only',
-        fix: 'Use an SQL target (e.g. Postgres) with this command',
+      errorRuntime('contract infer is not supported for this family', {
+        why: 'The configured family does not implement the PslContractInferCapable capability, so an inferred PSL contract cannot be produced from the live database schema.',
+        fix: 'Use a family that supports contract inference (e.g. SQL/Postgres).',
       }),
     );
   }
 
-  const schema = validatePrintableSqlSchemaIR(inspectResult.value.schema);
   const outputPath = resolveContractInferOutputPath(options, config.contract?.output);
-  const enumInfo = extractEnumInfo(schema.annotations);
-  const pslContent = printPsl(schema, {
-    defaultMapping: createPostgresDefaultMapping(),
-    typeMap: createPostgresTypeMap(enumInfo.typeNames),
-    enumInfo,
-    parseRawDefault,
-  });
+  const pslContent = printPsl(pslContractAst);
 
   if (existsSync(outputPath) && !flags.json && !flags.quiet) {
     ui.stderr(`\u26A0 Overwriting existing file: ${relative(process.cwd(), outputPath)}`);

package/src/commands/db-init.ts

@@ -142,6 +142,7 @@ async function executeDbInitCommand(
           label: op.label,
           operationClass: op.operationClass,
         })),
+        ...ifDefined('preview', result.value.plan.preview),
       },
       ...(result.value.execution
         ? {

package/src/commands/db-update.ts

@@ -112,7 +112,7 @@ async function executeDbUpdateCommand(
           label: op.label,
           operationClass: op.operationClass,
         })),
-        ...ifDefined('sql', result.value.plan.sql),
+        ...ifDefined('preview', result.value.plan.preview),
       },
       ...ifDefined(
         'execution',

package/src/commands/init/detect-pnpm-catalog.ts

@@ -0,0 +1,141 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'pathe';
+
+/**
+ * Catalog entry detected in a `pnpm-workspace.yaml` that overrides one of
+ * the packages `init` installs. The `version` is the raw value as written
+ * in the workspace file (no normalisation), so the warning surfaces the
+ * exact text the user can search for if they want to find the override.
+ */
+export interface PnpmCatalogOverride {
+  readonly name: string;
+  readonly version: string;
+}
+
+/**
+ * Result of scanning for a pnpm workspace catalog that overrides any of
+ * the packages `init` is about to install. Returns `null` when no
+ * `pnpm-workspace.yaml` is found in `baseDir` or any ancestor; an empty
+ * `entries` array means a workspace exists but contains none of our
+ * packages.
+ */
+export interface PnpmCatalogScanResult {
+  /** Absolute path of the `pnpm-workspace.yaml` that was consulted. */
+  readonly workspaceFile: string;
+  readonly entries: readonly PnpmCatalogOverride[];
+}
+
+/**
+ * Walks up from `baseDir` looking for `pnpm-workspace.yaml`, then scans
+ * its top-level `catalog:` block for entries that match any of `packages`.
+ *
+ * Implements FR7.3 / Spec Decision 8 (honour-and-warn): when `init` runs
+ * inside a pnpm workspace whose catalog overrides one of the packages it
+ * installs, surface a structured warning so the user knows the catalog
+ * version (not the published `latest`) is what ended up in their
+ * `node_modules`. pnpm itself does this silently; the warning closes the
+ * "looks fine, must be wrong version six months later" gap.
+ *
+ * Notes / scope:
+ *
+ * - We only inspect the unnamed top-level `catalog:` block. pnpm also
+ *   supports `catalogs:` (plural — *named* catalogs referenced via
+ *   `catalog:foo` specifiers); those don't apply to a vanilla
+ *   `pnpm add prisma-next` invocation, so we skip them.
+ * - We don't validate YAML syntax exhaustively. The file format pnpm
+ *   ships is line-oriented and well-known; a minimal regex is more
+ *   robust than depending on a YAML parser for one warning.
+ * - We don't compare against the registry's `latest` — pnpm uses the
+ *   catalog version regardless, so the warning fires whenever a match
+ *   exists. The user-facing copy explains how to opt out.
+ */
+export function detectPnpmCatalogOverrides(
+  baseDir: string,
+  packages: readonly string[],
+): PnpmCatalogScanResult | null {
+  const workspaceFile = findNearestPnpmWorkspaceFile(baseDir);
+  if (workspaceFile === null) {
+    return null;
+  }
+
+  const contents = readFileSync(workspaceFile, 'utf-8');
+  const catalog = extractCatalogBlock(contents);
+  if (catalog === null) {
+    return { workspaceFile, entries: [] };
+  }
+
+  const wanted = new Set(packages);
+  const entries: PnpmCatalogOverride[] = [];
+  for (const [name, version] of catalog) {
+    if (wanted.has(name)) {
+      entries.push({ name, version });
+    }
+  }
+  return { workspaceFile, entries };
+}
+
+function findNearestPnpmWorkspaceFile(baseDir: string): string | null {
+  let dir = baseDir;
+  let prev = '';
+  while (dir !== prev) {
+    const candidate = join(dir, 'pnpm-workspace.yaml');
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    prev = dir;
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Returns the entries inside the top-level `catalog:` block as `[name, version]`
+ * pairs in document order, or `null` when no `catalog:` block exists.
+ *
+ * The parser is intentionally minimal: it reads line-by-line, locates the
+ * top-level `catalog:` line (no leading whitespace), then collects every
+ * subsequent indented line of the form `<key>: <value>` until the next
+ * top-level key (or end of file). Quotes around `<key>` and `<value>`
+ * are stripped; comments (`#…`) are ignored.
+ */
+function extractCatalogBlock(contents: string): Array<[string, string]> | null {
+  const lines = contents.split(/\r?\n/);
+  const startIdx = lines.findIndex((line) => /^catalog\s*:\s*$/.test(line));
+  if (startIdx === -1) {
+    return null;
+  }
+
+  const entries: Array<[string, string]> = [];
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const raw = lines[i] ?? '';
+    if (raw.trim() === '' || /^\s*#/.test(raw)) {
+      continue;
+    }
+    if (!/^\s/.test(raw)) {
+      // Hit the next top-level key — catalog block ended.
+      break;
+    }
+    const match = raw.match(/^\s+(?:'([^']+)'|"([^"]+)"|([^:\s'"]+))\s*:\s*(.*?)\s*(?:#.*)?$/);
+    if (!match) {
+      continue;
+    }
+    const name = match[1] ?? match[2] ?? match[3];
+    if (name === undefined) continue;
+    const rawValue = match[4] ?? '';
+    const version = stripQuotes(rawValue.trim());
+    if (version === '') continue;
+    entries.push([name, version]);
+  }
+  return entries;
+}
+
+function stripQuotes(value: string): string {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}