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

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@prisma-next/cli",
-  "version": "0.3.0-dev.3",
+  "version": "0.3.0-dev.5",
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "bin": {
     "prisma-next": "./dist/cli.js"
@@ -19,33 +20,32 @@
     "string-width": "^7.2.0",
     "strip-ansi": "^7.1.2",
     "wrap-ansi": "^9.0.2",
-    "@prisma-next/contract": "0.3.0-dev.3",
-    "@prisma-next/core-control-plane": "0.3.0-dev.3",
-    "@prisma-next/emitter": "0.3.0-dev.3",
-    "@prisma-next/utils": "0.3.0-dev.3"
+    "@prisma-next/contract": "0.3.0-dev.5",
+    "@prisma-next/emitter": "0.3.0-dev.5",
+    "@prisma-next/utils": "0.3.0-dev.5",
+    "@prisma-next/core-control-plane": "0.3.0-dev.5"
   },
   "devDependencies": {
     "@types/node": "24.10.4",
-    "@vitest/coverage-v8": "^4.0.0",
-    "tsup": "^8.3.0",
-    "typescript": "^5.9.3",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^4.0.16",
-    "@prisma-next/sql-contract": "0.3.0-dev.3",
-    "@prisma-next/sql-contract-emitter": "0.3.0-dev.3",
-    "@prisma-next/sql-contract-ts": "0.3.0-dev.3",
-    "@prisma-next/sql-operations": "0.3.0-dev.3",
-    "@prisma-next/sql-runtime": "0.3.0-dev.3",
+    "@vitest/coverage-v8": "4.0.16",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.16",
+    "@prisma-next/sql-contract": "0.3.0-dev.5",
+    "@prisma-next/sql-contract-emitter": "0.3.0-dev.5",
+    "@prisma-next/sql-contract-ts": "0.3.0-dev.5",
+    "@prisma-next/sql-operations": "0.3.0-dev.5",
+    "@prisma-next/sql-runtime": "0.3.0-dev.5",
     "@prisma-next/test-utils": "0.0.1"
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/exports/index.d.ts",
+      "import": "./dist/exports/index.js"
     },
     "./config-types": {
-      "types": "./dist/config-types.d.ts",
-      "import": "./dist/config-types.js"
+      "types": "./dist/exports/config-types.d.ts",
+      "import": "./dist/exports/config-types.js"
     },
     "./commands/db-init": {
       "types": "./dist/commands/db-init.d.ts",
@@ -77,7 +77,7 @@
     }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --project tsconfig.json --noEmit",

package/src/cli.ts

@@ -0,0 +1,260 @@
+import { Command } from 'commander';
+import { createContractEmitCommand } from './commands/contract-emit';
+import { createDbInitCommand } from './commands/db-init';
+import { createDbIntrospectCommand } from './commands/db-introspect';
+import { createDbSchemaVerifyCommand } from './commands/db-schema-verify';
+import { createDbSignCommand } from './commands/db-sign';
+import { createDbVerifyCommand } from './commands/db-verify';
+import { setCommandDescriptions } from './utils/command-helpers';
+import { parseGlobalFlags } from './utils/global-flags';
+import { formatCommandHelp, formatRootHelp } from './utils/output';
+
+const program = new Command();
+
+program.name('prisma-next').description('Prisma Next CLI').version('0.0.1');
+
+// Override version option description to match capitalization style
+const versionOption = program.options.find((opt) => opt.flags.includes('--version'));
+if (versionOption) {
+  versionOption.description = 'Output the version number';
+}
+
+program.configureOutput({
+  writeErr: () => {
+    // Suppress all default error output - we handle errors in exitOverride
+  },
+  writeOut: () => {
+    // Suppress all default output - our custom formatters handle everything
+  },
+});
+
+// Customize root help output to use our styled format
+const rootHelpFormatter = (cmd: Command) => {
+  const flags = parseGlobalFlags({});
+  return formatRootHelp({ program: cmd, flags });
+};
+
+program.configureHelp({
+  formatHelp: rootHelpFormatter,
+  subcommandDescription: () => '',
+});
+
+// Override exit to handle unhandled errors (fail fast cases)
+// Commands handle structured errors themselves via process.exit()
+program.exitOverride((err) => {
+  if (err) {
+    // Help requests are not errors - allow Commander to output help and exit normally
+    // Commander throws errors with codes like 'commander.help', 'commander.helpDisplayed', or 'outputHelp'
+    const errorCode = (err as { code?: string }).code;
+    const errorMessage = String(err.message ?? '');
+    const errorName = err.name ?? '';
+
+    // Check for unknown command errors first (before other checks)
+    // Commander.js uses code 'commander.unknownCommand' or error message contains 'unknown command'
+    const isUnknownCommandError =
+      errorCode === 'commander.unknownCommand' ||
+      errorCode === 'commander.unknownArgument' ||
+      (errorName === 'CommanderError' &&
+        (errorMessage.includes('unknown command') || errorMessage.includes('unknown argument')));
+    if (isUnknownCommandError) {
+      const flags = parseGlobalFlags({});
+      // Extract the command/subcommand name from the error message
+      // Error message format: "unknown command 'command-name'"
+      const match = errorMessage.match(/unknown command ['"]([^'"]+)['"]/);
+      const commandName = match ? match[1] : process.argv[3] || process.argv[2] || 'unknown';
+
+      // Determine which command context we're in
+      // Check if the first argument is a recognized parent command
+      const firstArg = process.argv[2];
+      const parentCommand = firstArg
+        ? program.commands.find((cmd) => cmd.name() === firstArg)
+        : undefined;
+
+      if (parentCommand && commandName !== firstArg) {
+        // Unrecognized subcommand - show parent command help
+        // eslint-disable-next-line no-console
+        console.error(`Unknown command: ${commandName}`);
+        // eslint-disable-next-line no-console
+        console.error('');
+        const helpText = formatCommandHelp({ command: parentCommand, flags });
+        // eslint-disable-next-line no-console
+        console.log(helpText);
+      } else {
+        // Unrecognized top-level command - show root help
+        // eslint-disable-next-line no-console
+        console.error(`Unknown command: ${commandName}`);
+        // eslint-disable-next-line no-console
+        console.error('');
+        const helpText = formatRootHelp({ program, flags });
+        // eslint-disable-next-line no-console
+        console.log(helpText);
+      }
+      process.exit(1);
+      return;
+    }
+    const isHelpError =
+      errorCode === 'commander.help' ||
+      errorCode === 'commander.helpDisplayed' ||
+      errorCode === 'outputHelp' ||
+      errorMessage === '(outputHelp)' ||
+      errorMessage.includes('outputHelp') ||
+      (errorName === 'CommanderError' && errorMessage.includes('outputHelp'));
+    if (isHelpError) {
+      process.exit(0);
+      return;
+    }
+    // Missing required arguments/subcommands - show help and exit with 0
+    // Commander throws errors with code 'commander.missingArgument' or 'commander.missingMandatoryOptionValue'
+    // or when a command with subcommands is called without a subcommand
+    const isMissingArgumentError =
+      errorCode === 'commander.missingArgument' ||
+      errorCode === 'commander.missingMandatoryOptionValue' ||
+      (errorName === 'CommanderError' &&
+        (errorMessage.includes('missing') || errorMessage.includes('required')));
+    if (isMissingArgumentError) {
+      // Help was already displayed by Commander.js, just exit with 0
+      process.exit(0);
+      return;
+    }
+    // Unhandled error - fail fast with exit code 1
+    // eslint-disable-next-line no-console
+    console.error(`Unhandled error: ${err.message}`);
+    if (err.stack) {
+      // eslint-disable-next-line no-console
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+  process.exit(0);
+});
+
+// Register contract subcommand
+const contractCommand = new Command('contract');
+setCommandDescriptions(
+  contractCommand,
+  'Contract management commands',
+  'Define and emit your application data contract. The contract describes your schema as a\n' +
+    'declarative data structure that can be signed and verified against your database.',
+);
+contractCommand.configureHelp({
+  formatHelp: (cmd) => {
+    const flags = parseGlobalFlags({});
+    return formatCommandHelp({ command: cmd, flags });
+  },
+  subcommandDescription: () => '',
+});
+
+// Add emit subcommand to contract
+const contractEmitCommand = createContractEmitCommand();
+contractCommand.addCommand(contractEmitCommand);
+
+// Register contract command
+program.addCommand(contractCommand);
+
+// Register db subcommand
+const dbCommand = new Command('db');
+setCommandDescriptions(
+  dbCommand,
+  'Database management commands',
+  'Verify and sign your database with your contract. Ensure your database schema matches\n' +
+    'your contract, and sign it to record the contract hash for future verification.',
+);
+dbCommand.configureHelp({
+  formatHelp: (cmd) => {
+    const flags = parseGlobalFlags({});
+    return formatCommandHelp({ command: cmd, flags });
+  },
+  subcommandDescription: () => '',
+});
+
+// Add verify subcommand to db
+const dbVerifyCommand = createDbVerifyCommand();
+dbCommand.addCommand(dbVerifyCommand);
+
+// Add init subcommand to db
+const dbInitCommand = createDbInitCommand();
+dbCommand.addCommand(dbInitCommand);
+
+// Add introspect subcommand to db
+const dbIntrospectCommand = createDbIntrospectCommand();
+dbCommand.addCommand(dbIntrospectCommand);
+
+// Add schema-verify subcommand to db
+const dbSchemaVerifyCommand = createDbSchemaVerifyCommand();
+dbCommand.addCommand(dbSchemaVerifyCommand);
+
+// Add sign subcommand to db
+const dbSignCommand = createDbSignCommand();
+dbCommand.addCommand(dbSignCommand);
+
+// Register db command
+program.addCommand(dbCommand);
+
+// Create help command
+const helpCommand = new Command('help')
+  .description('Show usage instructions')
+  .configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    },
+  })
+  .action(() => {
+    const flags = parseGlobalFlags({});
+    const helpText = formatRootHelp({ program, flags });
+    // eslint-disable-next-line no-console
+    console.log(helpText);
+    process.exit(0);
+  });
+
+program.addCommand(helpCommand);
+
+// Set help as the default action when no command is provided
+program.action(() => {
+  const flags = parseGlobalFlags({});
+  const helpText = formatRootHelp({ program, flags });
+  // eslint-disable-next-line no-console
+  console.log(helpText);
+  process.exit(0);
+});
+
+// Check if a command was invoked with no arguments (just the command name)
+// or if an unrecognized command was provided
+const args = process.argv.slice(2);
+if (args.length > 0) {
+  const commandName = args[0];
+  // Handle version option explicitly since we suppress default output
+  if (commandName === '--version' || commandName === '-V') {
+    // eslint-disable-next-line no-console
+    console.log(program.version());
+    process.exit(0);
+  }
+  // Skip command check for global options like --help, -h
+  const isGlobalOption = commandName === '--help' || commandName === '-h';
+  if (!isGlobalOption) {
+    // Check if this is a recognized command
+    const command = program.commands.find((cmd) => cmd.name() === commandName);
+
+    if (!command) {
+      // Unrecognized command - show error message and usage
+      const flags = parseGlobalFlags({});
+      // eslint-disable-next-line no-console
+      console.error(`Unknown command: ${commandName}`);
+      // eslint-disable-next-line no-console
+      console.error('');
+      const helpText = formatRootHelp({ program, flags });
+      // eslint-disable-next-line no-console
+      console.log(helpText);
+      process.exit(1);
+    } else if (command.commands.length > 0 && args.length === 1) {
+      // Parent command called with no subcommand - show help and exit with 0
+      const flags = parseGlobalFlags({});
+      const helpText = formatCommandHelp({ command, flags });
+      // eslint-disable-next-line no-console
+      console.log(helpText);
+      process.exit(0);
+    }
+  }
+}
+
+program.parse();

package/src/commands/contract-emit.ts

@@ -0,0 +1,189 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { errorContractConfigMissing } from '@prisma-next/core-control-plane/errors';
+import { Command } from 'commander';
+import { loadConfig } from '../config-loader';
+import { performAction } from '../utils/action';
+import { setCommandDescriptions } from '../utils/command-helpers';
+import { parseGlobalFlags } from '../utils/global-flags';
+import {
+  formatCommandHelp,
+  formatEmitJson,
+  formatEmitOutput,
+  formatStyledHeader,
+  formatSuccessMessage,
+} from '../utils/output';
+import { handleResult } from '../utils/result-handler';
+import { withSpinner } from '../utils/spinner';
+
+interface ContractEmitOptions {
+  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;
+}
+
+export function createContractEmitCommand(): Command {
+  const command = new Command('emit');
+  setCommandDescriptions(
+    command,
+    'Write your contract to JSON and sign it',
+    'Reads your contract source (TypeScript or Prisma schema) and emits contract.json and\n' +
+      'contract.d.ts. The contract.json contains the canonical contract structure, and\n' +
+      'contract.d.ts provides TypeScript types for type-safe query building.',
+  );
+  command
+    .configureHelp({
+      formatHelp: (cmd) => {
+        const flags = parseGlobalFlags({});
+        return formatCommandHelp({ command: cmd, flags });
+      },
+    })
+    .option('--config <path>', 'Path to prisma-next.config.ts')
+    .option('--json [format]', 'Output as JSON (object or ndjson)', 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: ContractEmitOptions) => {
+      const flags = parseGlobalFlags(options);
+
+      const result = await performAction(async () => {
+        // Load config
+        const config = await loadConfig(options.config);
+
+        // Resolve contract from config
+        if (!config.contract) {
+          throw errorContractConfigMissing({
+            why: 'Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ..., types: ... }',
+          });
+        }
+
+        // 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 || !contractConfig.types) {
+          throw errorContractConfigMissing({
+            why: 'Contract config must have output and types paths. This should not happen if defineConfig() was used.',
+          });
+        }
+        const outputJsonPath = resolve(contractConfig.output);
+        const outputDtsPath = resolve(contractConfig.types);
+
+        // Output header (only for human-readable output)
+        if (flags.json !== 'object' && !flags.quiet) {
+          // Normalize config path for display (match contract path format - no ./ prefix)
+          const configPath = options.config
+            ? relative(process.cwd(), resolve(options.config))
+            : 'prisma-next.config.ts';
+          // Convert absolute paths to relative paths for display
+          const contractPath = relative(process.cwd(), outputJsonPath);
+          const typesPath = relative(process.cwd(), outputDtsPath);
+          const header = formatStyledHeader({
+            command: 'contract emit',
+            description: 'Write your contract to JSON and sign it',
+            url: 'https://pris.ly/contract-emit',
+            details: [
+              { label: 'config', value: configPath },
+              { label: 'contract', value: contractPath },
+              { label: 'types', value: typesPath },
+            ],
+            flags,
+          });
+          console.log(header);
+        }
+
+        // Create family instance (assembles operation registry, type imports, extension IDs)
+        // Note: emit command doesn't need driver, but ControlFamilyDescriptor.create() requires it
+        // We'll need to provide a minimal driver descriptor or make driver optional for emit
+        // For now, we'll require driver to be present in config even for emit
+        if (!config.driver) {
+          throw errorContractConfigMissing({
+            why: 'Config.driver is required. Even though emit does not use the driver, it is required by ControlFamilyDescriptor.create()',
+          });
+        }
+        const familyInstance = config.family.create({
+          target: config.target,
+          adapter: config.adapter,
+          driver: config.driver,
+          extensionPacks: config.extensionPacks ?? [],
+        });
+
+        // Resolve contract source from config (user's config handles loading)
+        let contractRaw: unknown;
+        if (typeof contractConfig.source === 'function') {
+          contractRaw = await contractConfig.source();
+        } else {
+          contractRaw = contractConfig.source;
+        }
+
+        // Call emitContract on family instance (handles stripping mappings and validation internally)
+        const emitResult = await withSpinner(
+          () => familyInstance.emitContract({ contractIR: contractRaw }),
+          {
+            message: 'Emitting contract...',
+            flags,
+          },
+        );
+
+        // Create directories if needed
+        mkdirSync(dirname(outputJsonPath), { recursive: true });
+        mkdirSync(dirname(outputDtsPath), { recursive: true });
+
+        // Write the results to files
+        writeFileSync(outputJsonPath, emitResult.contractJson, 'utf-8');
+        writeFileSync(outputDtsPath, emitResult.contractDts, 'utf-8');
+
+        // Add blank line after all async operations if spinners were shown
+        if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
+          console.log('');
+        }
+
+        // Return result with file paths for output formatting
+        return {
+          coreHash: emitResult.coreHash,
+          profileHash: emitResult.profileHash,
+          outDir: dirname(outputJsonPath),
+          files: {
+            json: outputJsonPath,
+            dts: outputDtsPath,
+          },
+          timings: {
+            total: 0, // Timing is handled by emitContract internally if needed
+          },
+        };
+      });
+
+      // Handle result - formats output and returns exit code
+      const exitCode = handleResult(result, flags, (emitResult) => {
+        // Output based on flags
+        if (flags.json === 'object') {
+          // JSON output to stdout
+          console.log(formatEmitJson(emitResult));
+        } else {
+          // Human-readable output to stdout
+          const output = formatEmitOutput(emitResult, flags);
+          if (output) {
+            console.log(output);
+          }
+          // Output success message
+          if (!flags.quiet) {
+            console.log(formatSuccessMessage(flags));
+          }
+        }
+      });
+      process.exit(exitCode);
+    });
+
+  return command;
+}