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

package/src/commands/db-sign.ts

@@ -0,0 +1,279 @@
+import { readFile } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+import type {
+  SignDatabaseResult,
+  VerifyDatabaseSchemaResult,
+} from '@prisma-next/core-control-plane/types';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { Command } from 'commander';
+import { loadConfig } from '../config-loader';
+import { createControlClient } from '../control-api/client';
+import {
+  CliStructuredError,
+  errorContractValidationFailed,
+  errorDatabaseConnectionRequired,
+  errorDriverRequired,
+  errorFileNotFound,
+  errorJsonFormatNotSupported,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import { setCommandDescriptions } from '../utils/command-helpers';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import {
+  formatCommandHelp,
+  formatSchemaVerifyJson,
+  formatSchemaVerifyOutput,
+  formatSignJson,
+  formatSignOutput,
+  formatStyledHeader,
+} from '../utils/output';
+import { createProgressAdapter } from '../utils/progress-adapter';
+import { handleResult } from '../utils/result-handler';
+
+interface DbSignOptions {
+  readonly db?: string;
+  readonly config?: string;
+  readonly json?: string | boolean;
+  readonly quiet?: boolean;
+  readonly q?: boolean;
+  readonly verbose?: boolean;
+  readonly v?: boolean;
+  readonly vv?: boolean;
+  readonly trace?: boolean;
+  readonly timestamps?: boolean;
+  readonly color?: boolean;
+  readonly 'no-color'?: boolean;
+}
+
+/**
+ * Failure type for db sign command.
+ * Either an infrastructure error (CliStructuredError) or a logical failure (schema verification failed).
+ */
+type DbSignFailure = CliStructuredError | VerifyDatabaseSchemaResult;
+
+/**
+ * Executes the db sign command and returns a structured Result.
+ * Success: SignDatabaseResult (sign happened)
+ * Failure: CliStructuredError (infra error) or VerifyDatabaseSchemaResult (schema mismatch)
+ */
+async function executeDbSignCommand(
+  options: DbSignOptions,
+  flags: GlobalFlags,
+): Promise<Result<SignDatabaseResult, DbSignFailure>> {
+  // Load config
+  const config = await loadConfig(options.config);
+  const configPath = options.config
+    ? relative(process.cwd(), resolve(options.config))
+    : 'prisma-next.config.ts';
+  const contractPathAbsolute = config.contract?.output
+    ? resolve(config.contract.output)
+    : resolve('src/prisma/contract.json');
+  const contractPath = relative(process.cwd(), contractPathAbsolute);
+
+  // Output header
+  if (flags.json !== 'object' && !flags.quiet) {
+    const details: Array<{ label: string; value: string }> = [
+      { label: 'config', value: configPath },
+      { label: 'contract', value: contractPath },
+    ];
+    if (options.db) {
+      details.push({ label: 'database', value: options.db });
+    }
+    const header = formatStyledHeader({
+      command: 'db sign',
+      description: 'Sign the database with your contract so you can safely run queries',
+      url: 'https://pris.ly/db-sign',
+      details,
+      flags,
+    });
+    console.log(header);
+  }
+
+  // Load contract file
+  let contractJsonContent: string;
+  try {
+    contractJsonContent = await readFile(contractPathAbsolute, 'utf-8');
+  } catch (error) {
+    if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
+      return notOk(
+        errorFileNotFound(contractPathAbsolute, {
+          why: `Contract file not found at ${contractPathAbsolute}`,
+          fix: `Run \`prisma-next contract emit\` to generate ${contractPath}, or update \`config.contract.output\` in ${configPath}`,
+        }),
+      );
+    }
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  }
+
+  let contractJson: Record<string, unknown>;
+  try {
+    contractJson = JSON.parse(contractJsonContent) as Record<string, unknown>;
+  } catch (error) {
+    return notOk(
+      errorContractValidationFailed(
+        `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,
+        { where: { path: contractPathAbsolute } },
+      ),
+    );
+  }
+
+  // Resolve database connection (--db flag or config.db.connection)
+  const dbConnection = options.db ?? config.db?.connection;
+  if (!dbConnection) {
+    return notOk(
+      errorDatabaseConnectionRequired({
+        why: `Database connection is required for db sign (set db.connection in ${configPath}, or pass --db <url>)`,
+      }),
+    );
+  }
+
+  // Check for driver
+  if (!config.driver) {
+    return notOk(errorDriverRequired({ why: 'Config.driver is required for db sign' }));
+  }
+
+  // Create control client
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    driver: config.driver,
+    extensionPacks: config.extensionPacks ?? [],
+  });
+
+  // Create progress adapter
+  const onProgress = createProgressAdapter({ flags });
+
+  try {
+    // Step 1: Schema verification - connect here
+    const schemaVerifyResult = await client.schemaVerify({
+      contractIR: contractJson,
+      strict: false,
+      connection: dbConnection,
+      onProgress,
+    });
+
+    // If schema verification failed, return as failure
+    if (!schemaVerifyResult.ok) {
+      // Add blank line after all async operations if spinners were shown
+      if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
+        console.log('');
+      }
+      return notOk(schemaVerifyResult);
+    }
+
+    // Step 2: Sign (already connected from schemaVerify)
+    const signResult = await client.sign({
+      contractIR: contractJson,
+      contractPath,
+      configPath,
+      onProgress,
+    });
+
+    // Add blank line after all async operations if spinners were shown
+    if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
+      console.log('');
+    }
+
+    return ok(signResult);
+  } catch (error) {
+    // Driver already throws CliStructuredError for connection failures
+    if (error instanceof CliStructuredError) {
+      return notOk(error);
+    }
+
+    // Wrap unexpected errors
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Unexpected error during db sign: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  } finally {
+    await client.close();
+  }
+}
+
+export function createDbSignCommand(): Command {
+  const command = new Command('sign');
+  setCommandDescriptions(
+    command,
+    'Sign the database with your contract so you can safely run queries',
+    'Verifies that your database schema satisfies the emitted contract, and if so, writes or\n' +
+      'updates the contract marker in the database. This command is idempotent and safe to run\n' +
+      'in CI/deployment pipelines. The marker records that this database instance is aligned\n' +
+      'with a specific contract version.',
+  );
+  command
+    .configureHelp({
+      formatHelp: (cmd) => {
+        const flags = parseGlobalFlags({});
+        return formatCommandHelp({ command: cmd, flags });
+      },
+    })
+    .option('--db <url>', 'Database connection string')
+    .option('--config <path>', 'Path to prisma-next.config.ts')
+    .option('--json [format]', 'Output as JSON (object)', false)
+    .option('-q, --quiet', 'Quiet mode: errors only')
+    .option('-v, --verbose', 'Verbose output: debug info, timings')
+    .option('-vv, --trace', 'Trace output: deep internals, stack traces')
+    .option('--timestamps', 'Add timestamps to output')
+    .option('--color', 'Force color output')
+    .option('--no-color', 'Disable color output')
+    .action(async (options: DbSignOptions) => {
+      const flags = parseGlobalFlags(options);
+
+      // Validate JSON format option
+      if (flags.json === 'ndjson') {
+        const result = notOk(
+          errorJsonFormatNotSupported({
+            command: 'db sign',
+            format: 'ndjson',
+            supportedFormats: ['object'],
+          }),
+        );
+        const exitCode = handleResult(result, flags);
+        process.exit(exitCode);
+      }
+
+      const result = await executeDbSignCommand(options, flags);
+
+      if (result.ok) {
+        // Success - format sign output
+        if (flags.json === 'object') {
+          console.log(formatSignJson(result.value));
+        } else {
+          const output = formatSignOutput(result.value, flags);
+          if (output) {
+            console.log(output);
+          }
+        }
+        process.exit(0);
+      }
+
+      // Failure - determine type and handle appropriately
+      const failure = result.failure;
+
+      if (failure instanceof CliStructuredError) {
+        // Infrastructure error - use standard handler
+        const exitCode = handleResult(result as Result<never, CliStructuredError>, flags);
+        process.exit(exitCode);
+      }
+
+      // Schema verification failed - format and print schema verification output
+      if (flags.json === 'object') {
+        console.log(formatSchemaVerifyJson(failure));
+      } else {
+        const output = formatSchemaVerifyOutput(failure, flags);
+        if (output) {
+          console.log(output);
+        }
+      }
+      process.exit(1);
+    });
+
+  return command;
+}

package/src/commands/db-verify.ts

@@ -0,0 +1,258 @@
+import { readFile } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+import type { VerifyDatabaseResult } from '@prisma-next/core-control-plane/types';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { Command } from 'commander';
+import { loadConfig } from '../config-loader';
+import { createControlClient } from '../control-api/client';
+import {
+  CliStructuredError,
+  errorContractValidationFailed,
+  errorDatabaseConnectionRequired,
+  errorDriverRequired,
+  errorFileNotFound,
+  errorHashMismatch,
+  errorJsonFormatNotSupported,
+  errorMarkerMissing,
+  errorRuntime,
+  errorTargetMismatch,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import { setCommandDescriptions } from '../utils/command-helpers';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import {
+  formatCommandHelp,
+  formatStyledHeader,
+  formatVerifyJson,
+  formatVerifyOutput,
+} from '../utils/output';
+import { createProgressAdapter } from '../utils/progress-adapter';
+import { handleResult } from '../utils/result-handler';
+
+interface DbVerifyOptions {
+  readonly db?: string;
+  readonly config?: string;
+  readonly json?: string | boolean;
+  readonly quiet?: boolean;
+  readonly q?: boolean;
+  readonly verbose?: boolean;
+  readonly v?: boolean;
+  readonly vv?: boolean;
+  readonly trace?: boolean;
+  readonly timestamps?: boolean;
+  readonly color?: boolean;
+  readonly 'no-color'?: boolean;
+}
+
+/**
+ * Maps a VerifyDatabaseResult failure to a CliStructuredError.
+ */
+function mapVerifyFailure(verifyResult: VerifyDatabaseResult): CliStructuredError {
+  if (!verifyResult.ok && verifyResult.code) {
+    if (verifyResult.code === 'PN-RTM-3001') {
+      return errorMarkerMissing();
+    }
+    if (verifyResult.code === 'PN-RTM-3002') {
+      return errorHashMismatch({
+        expected: verifyResult.contract.coreHash,
+        ...(verifyResult.marker?.coreHash ? { actual: verifyResult.marker.coreHash } : {}),
+      });
+    }
+    if (verifyResult.code === 'PN-RTM-3003') {
+      return errorTargetMismatch(
+        verifyResult.target.expected,
+        verifyResult.target.actual ?? 'unknown',
+      );
+    }
+    // Unknown code - fall through to runtime error
+  }
+  return errorRuntime(verifyResult.summary);
+}
+
+/**
+ * Executes the db verify command and returns a structured Result.
+ */
+async function executeDbVerifyCommand(
+  options: DbVerifyOptions,
+  flags: GlobalFlags,
+): Promise<Result<VerifyDatabaseResult, CliStructuredError>> {
+  // Load config
+  const config = await loadConfig(options.config);
+  const configPath = options.config
+    ? relative(process.cwd(), resolve(options.config))
+    : 'prisma-next.config.ts';
+  const contractPathAbsolute = config.contract?.output
+    ? resolve(config.contract.output)
+    : resolve('src/prisma/contract.json');
+  const contractPath = relative(process.cwd(), contractPathAbsolute);
+
+  // Output header
+  if (flags.json !== 'object' && !flags.quiet) {
+    const details: Array<{ label: string; value: string }> = [
+      { label: 'config', value: configPath },
+      { label: 'contract', value: contractPath },
+    ];
+    if (options.db) {
+      details.push({ label: 'database', value: options.db });
+    }
+    const header = formatStyledHeader({
+      command: 'db verify',
+      description: 'Check whether the database has been signed with your contract',
+      url: 'https://pris.ly/db-verify',
+      details,
+      flags,
+    });
+    console.log(header);
+  }
+
+  // Load contract file
+  let contractJsonContent: string;
+  try {
+    contractJsonContent = await readFile(contractPathAbsolute, 'utf-8');
+  } catch (error) {
+    if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
+      return notOk(
+        errorFileNotFound(contractPathAbsolute, {
+          why: `Contract file not found at ${contractPathAbsolute}`,
+          fix: `Run \`prisma-next contract emit\` to generate ${contractPath}, or update \`config.contract.output\` in ${configPath}`,
+        }),
+      );
+    }
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  }
+
+  let contractJson: Record<string, unknown>;
+  try {
+    contractJson = JSON.parse(contractJsonContent) as Record<string, unknown>;
+  } catch (error) {
+    return notOk(
+      errorContractValidationFailed(
+        `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,
+        { where: { path: contractPathAbsolute } },
+      ),
+    );
+  }
+
+  // Resolve database connection (--db flag or config.db.connection)
+  const dbConnection = options.db ?? config.db?.connection;
+  if (!dbConnection) {
+    return notOk(
+      errorDatabaseConnectionRequired({
+        why: `Database connection is required for db verify (set db.connection in ${configPath}, or pass --db <url>)`,
+      }),
+    );
+  }
+
+  // Check for driver
+  if (!config.driver) {
+    return notOk(errorDriverRequired({ why: 'Config.driver is required for db verify' }));
+  }
+
+  // Create control client
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    driver: config.driver,
+    extensionPacks: config.extensionPacks ?? [],
+  });
+
+  // Create progress adapter
+  const onProgress = createProgressAdapter({ flags });
+
+  try {
+    const verifyResult = await client.verify({
+      contractIR: contractJson,
+      connection: dbConnection,
+      onProgress,
+    });
+
+    // Add blank line after all async operations if spinners were shown
+    if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
+      console.log('');
+    }
+
+    // If verification failed, map to CLI structured error
+    if (!verifyResult.ok) {
+      return notOk(mapVerifyFailure(verifyResult));
+    }
+
+    return ok(verifyResult);
+  } catch (error) {
+    // Driver already throws CliStructuredError for connection failures
+    if (error instanceof CliStructuredError) {
+      return notOk(error);
+    }
+
+    // Wrap unexpected errors
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Unexpected error during db verify: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  } finally {
+    await client.close();
+  }
+}
+
+export function createDbVerifyCommand(): Command {
+  const command = new Command('verify');
+  setCommandDescriptions(
+    command,
+    'Check whether the database has been signed with your contract',
+    'Verifies that your database schema matches the emitted contract. Checks table structures,\n' +
+      'column types, constraints, and codec coverage. Reports any mismatches or missing codecs.',
+  );
+  command
+    .configureHelp({
+      formatHelp: (cmd) => {
+        const flags = parseGlobalFlags({});
+        return formatCommandHelp({ command: cmd, flags });
+      },
+    })
+    .option('--db <url>', 'Database connection string')
+    .option('--config <path>', 'Path to prisma-next.config.ts')
+    .option('--json [format]', 'Output as JSON (object)', false)
+    .option('-q, --quiet', 'Quiet mode: errors only')
+    .option('-v, --verbose', 'Verbose output: debug info, timings')
+    .option('-vv, --trace', 'Trace output: deep internals, stack traces')
+    .option('--timestamps', 'Add timestamps to output')
+    .option('--color', 'Force color output')
+    .option('--no-color', 'Disable color output')
+    .action(async (options: DbVerifyOptions) => {
+      const flags = parseGlobalFlags(options);
+
+      // Validate JSON format option
+      if (flags.json === 'ndjson') {
+        const result = notOk(
+          errorJsonFormatNotSupported({
+            command: 'db verify',
+            format: 'ndjson',
+            supportedFormats: ['object'],
+          }),
+        );
+        const exitCode = handleResult(result, flags);
+        process.exit(exitCode);
+      }
+
+      const result = await executeDbVerifyCommand(options, flags);
+
+      const exitCode = handleResult(result, flags, (verifyResult) => {
+        if (flags.json === 'object') {
+          console.log(formatVerifyJson(verifyResult));
+        } else {
+          const output = formatVerifyOutput(verifyResult, flags);
+          if (output) {
+            console.log(output);
+          }
+        }
+      });
+      process.exit(exitCode);
+    });
+
+  return command;
+}

package/src/config-loader.ts

@@ -0,0 +1,76 @@
+import { dirname, resolve } from 'node:path';
+import type { PrismaNextConfig } from '@prisma-next/core-control-plane/config-types';
+import { validateConfig } from '@prisma-next/core-control-plane/config-validation';
+import { errorConfigFileNotFound, errorUnexpected } from '@prisma-next/core-control-plane/errors';
+import { loadConfig as loadConfigC12 } from 'c12';
+
+/**
+ * Loads the Prisma Next config from a TypeScript file.
+ * Supports both default export and named export.
+ * Uses c12 to automatically handle TypeScript compilation and config file discovery.
+ *
+ * @param configPath - Optional path to config file. Defaults to `./prisma-next.config.ts` in current directory.
+ * @returns The loaded config object.
+ * @throws Error if config file doesn't exist or is invalid.
+ */
+export async function loadConfig(configPath?: string): Promise<PrismaNextConfig> {
+  try {
+    const cwd = process.cwd();
+    // Resolve config path to absolute path and set cwd to config directory when path is provided
+    const resolvedConfigPath = configPath ? resolve(cwd, configPath) : undefined;
+    const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
+
+    const result = await loadConfigC12<PrismaNextConfig>({
+      name: 'prisma-next',
+      ...(resolvedConfigPath ? { configFile: resolvedConfigPath } : {}),
+      cwd: configCwd,
+    });
+
+    // When a specific config file was requested, verify it was actually loaded
+    // (c12 falls back to searching by name if the specified file doesn't exist)
+    if (resolvedConfigPath && result.configFile !== resolvedConfigPath) {
+      throw errorConfigFileNotFound(resolvedConfigPath);
+    }
+
+    // Check if config is missing or empty (c12 may return empty object when file doesn't exist)
+    if (!result.config || Object.keys(result.config).length === 0) {
+      // Use c12's configFile if available, otherwise use explicit configPath, otherwise omit path
+      const displayPath = result.configFile || resolvedConfigPath || configPath;
+      throw errorConfigFileNotFound(displayPath);
+    }
+
+    // Validate config structure
+    validateConfig(result.config);
+
+    return result.config;
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (
+      error instanceof Error &&
+      'code' in error &&
+      typeof (error as { code: string }).code === 'string'
+    ) {
+      throw error;
+    }
+
+    if (error instanceof Error) {
+      // Check for file not found errors
+      if (
+        error.message.includes('not found') ||
+        error.message.includes('Cannot find') ||
+        error.message.includes('ENOENT')
+      ) {
+        // Use resolved path if available, otherwise use original configPath
+        const displayPath = configPath ? resolve(process.cwd(), configPath) : undefined;
+        throw errorConfigFileNotFound(displayPath, {
+          why: error.message,
+        });
+      }
+      // For other errors, wrap in unexpected error
+      throw errorUnexpected(error.message, {
+        why: `Failed to load config: ${error.message}`,
+      });
+    }
+    throw errorUnexpected(String(error));
+  }
+}