@prisma-next/cli 0.3.0-dev.6 → 0.3.0-dev.63

package/src/commands/db-introspect.ts

@@ -1,27 +1,27 @@
-import { readFile } from 'node:fs/promises';
 import { relative, resolve } from 'node:path';
-import {
-  errorDatabaseUrlRequired,
-  errorDriverRequired,
-  errorRuntime,
-  errorUnexpected,
-} from '@prisma-next/core-control-plane/errors';
 import type { CoreSchemaView } from '@prisma-next/core-control-plane/schema-view';
 import type { IntrospectSchemaResult } 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 { performAction } from '../utils/action';
-import { setCommandDescriptions } from '../utils/command-helpers';
-import { assertContractRequirementsSatisfied } from '../utils/framework-components';
-import { parseGlobalFlags } from '../utils/global-flags';
+import { createControlClient } from '../control-api/client';
+import {
+  CliStructuredError,
+  errorDatabaseConnectionRequired,
+  errorDriverRequired,
+  errorJsonFormatNotSupported,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import { maskConnectionUrl, setCommandDescriptions } from '../utils/command-helpers';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
   formatCommandHelp,
   formatIntrospectJson,
   formatIntrospectOutput,
   formatStyledHeader,
 } from '../utils/output';
+import { createProgressAdapter } from '../utils/progress-adapter';
 import { handleResult } from '../utils/result-handler';
-import { withSpinner } from '../utils/spinner';
 
 interface DbIntrospectOptions {
   readonly db?: string;
@@ -38,6 +38,128 @@ interface DbIntrospectOptions {
   readonly 'no-color'?: boolean;
 }
 
+interface DbIntrospectCommandResult {
+  readonly introspectResult: IntrospectSchemaResult<unknown>;
+  readonly schemaView: CoreSchemaView | undefined;
+}
+
+/**
+ * Executes the db introspect command and returns a structured Result.
+ */
+async function executeDbIntrospectCommand(
+  options: DbIntrospectOptions,
+  flags: GlobalFlags,
+  startTime: number,
+): Promise<Result<DbIntrospectCommandResult, CliStructuredError>> {
+  // Load config
+  const config = await loadConfig(options.config);
+  const configPath = options.config
+    ? relative(process.cwd(), resolve(options.config))
+    : 'prisma-next.config.ts';
+
+  // Output header
+  if (flags.json !== 'object' && !flags.quiet) {
+    const details: Array<{ label: string; value: string }> = [
+      { label: 'config', value: configPath },
+    ];
+    if (options.db) {
+      details.push({ label: 'database', value: maskConnectionUrl(options.db) });
+    } else if (config.db?.connection && typeof config.db.connection === 'string') {
+      details.push({ label: 'database', value: maskConnectionUrl(config.db.connection) });
+    }
+    const header = formatStyledHeader({
+      command: 'db introspect',
+      description: 'Inspect the database schema',
+      url: 'https://pris.ly/db-introspect',
+      details,
+      flags,
+    });
+    console.log(header);
+  }
+
+  // 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 introspect (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 introspect' }));
+  }
+
+  // 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 {
+    // Introspect with connection and progress
+    const schemaIR = await client.introspect({
+      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('');
+    }
+
+    // Call toSchemaView to convert schema IR to CoreSchemaView for tree rendering
+    const schemaView = client.toSchemaView(schemaIR);
+
+    const totalTime = Date.now() - startTime;
+
+    // Get masked connection URL for meta (only for string connections)
+    const connectionForMeta =
+      typeof dbConnection === 'string' ? maskConnectionUrl(dbConnection) : undefined;
+
+    const introspectResult: IntrospectSchemaResult<unknown> = {
+      ok: true,
+      summary: 'Schema introspected successfully',
+      target: {
+        familyId: config.family.familyId,
+        id: config.target.targetId,
+      },
+      schema: schemaIR,
+      meta: {
+        ...(configPath ? { configPath } : {}),
+        ...(connectionForMeta ? { dbUrl: connectionForMeta } : {}),
+      },
+      timings: {
+        total: totalTime,
+      },
+    };
+
+    return ok({ introspectResult, schemaView });
+  } 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 introspect: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  } finally {
+    await client.close();
+  }
+}
+
 export function createDbIntrospectCommand(): Command {
   const command = new Command('introspect');
   setCommandDescriptions(
@@ -56,7 +178,7 @@ export function createDbIntrospectCommand(): Command {
     })
     .option('--db <url>', 'Database connection string')
     .option('--config <path>', 'Path to prisma-next.config.ts')
-    .option('--json [format]', 'Output as JSON (object or ndjson)', false)
+    .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')
@@ -65,188 +187,29 @@ export function createDbIntrospectCommand(): Command {
     .option('--no-color', 'Disable color output')
     .action(async (options: DbIntrospectOptions) => {
       const flags = parseGlobalFlags(options);
+      const startTime = Date.now();
 
-      const result = await performAction(async () => {
-        const startTime = Date.now();
-
-        // Load config (file I/O)
-        const config = await loadConfig(options.config);
-        // 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';
-
-        // Optionally load contract if contract config exists
-        let contractIR: unknown | undefined;
-        if (config.contract?.output) {
-          const contractPath = resolve(config.contract.output);
-          try {
-            const contractJsonContent = await readFile(contractPath, 'utf-8');
-            contractIR = JSON.parse(contractJsonContent);
-          } catch (error) {
-            // Contract file is optional for introspection - don't fail if it doesn't exist
-            if (error instanceof Error && (error as { code?: string }).code !== 'ENOENT') {
-              throw errorUnexpected(error.message, {
-                why: `Failed to read contract file: ${error.message}`,
-              });
-            }
-          }
-        }
-
-        // Output header (only for human-readable output)
-        if (flags.json !== 'object' && !flags.quiet) {
-          const details: Array<{ label: string; value: string }> = [
-            { label: 'config', value: configPath },
-          ];
-          if (options.db) {
-            // Mask password in URL for security
-            const maskedUrl = options.db.replace(/:([^:@]+)@/, ':****@');
-            details.push({ label: 'database', value: maskedUrl });
-          } else if (config.db?.url) {
-            // Mask password in URL for security
-            const maskedUrl = config.db.url.replace(/:([^:@]+)@/, ':****@');
-            details.push({ label: 'database', value: maskedUrl });
-          }
-          const header = formatStyledHeader({
+      // Validate JSON format option
+      if (flags.json === 'ndjson') {
+        const result = notOk(
+          errorJsonFormatNotSupported({
             command: 'db introspect',
-            description: 'Inspect the database schema',
-            url: 'https://pris.ly/db-introspect',
-            details,
-            flags,
-          });
-          console.log(header);
-        }
-
-        // Resolve database URL
-        const dbUrl = options.db ?? config.db?.url;
-        if (!dbUrl) {
-          throw errorDatabaseUrlRequired();
-        }
+            format: 'ndjson',
+            supportedFormats: ['object'],
+          }),
+        );
+        const exitCode = handleResult(result, flags);
+        process.exit(exitCode);
+      }
 
-        // Check for driver
-        if (!config.driver) {
-          throw errorDriverRequired();
-        }
-
-        // Store driver descriptor after null check
-        const driverDescriptor = config.driver;
-
-        // Create driver
-        const driver = await withSpinner(() => driverDescriptor.create(dbUrl), {
-          message: 'Connecting to database...',
-          flags,
-        });
-
-        try {
-          // Create family instance
-          const familyInstance = config.family.create({
-            target: config.target,
-            adapter: config.adapter,
-            driver: driverDescriptor,
-            extensionPacks: config.extensionPacks ?? [],
-          });
-
-          // Validate contract IR if we loaded it
-          if (contractIR) {
-            const validatedContract = familyInstance.validateContractIR(contractIR);
-            assertContractRequirementsSatisfied({
-              contract: validatedContract,
-              family: config.family,
-              target: config.target,
-              adapter: config.adapter,
-              extensionPacks: config.extensionPacks,
-            });
-            contractIR = validatedContract;
-          }
-
-          // Call family instance introspect method
-          let schemaIR: unknown;
-          try {
-            schemaIR = await withSpinner(
-              () =>
-                familyInstance.introspect({
-                  driver,
-                  contractIR,
-                }),
-              {
-                message: 'Introspecting database schema...',
-                flags,
-              },
-            );
-          } catch (error) {
-            // Wrap errors from introspect() in structured error
-            throw errorRuntime(error instanceof Error ? error.message : String(error), {
-              why: `Failed to introspect database: ${error instanceof Error ? error.message : String(error)}`,
-            });
-          }
-
-          // Optionally call toSchemaView if available
-          let schemaView: CoreSchemaView | undefined;
-          if (familyInstance.toSchemaView) {
-            try {
-              schemaView = familyInstance.toSchemaView(schemaIR);
-            } catch (error) {
-              // Schema view projection is optional - log but don't fail
-              if (flags.verbose) {
-                console.error(
-                  `Warning: Failed to project schema to view: ${error instanceof Error ? error.message : String(error)}`,
-                );
-              }
-            }
-          }
-
-          const totalTime = Date.now() - startTime;
-
-          // Add blank line after all async operations if spinners were shown
-          if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
-            console.log('');
-          }
-
-          // Build result envelope
-          const introspectResult: IntrospectSchemaResult<unknown> = {
-            ok: true,
-            summary: 'Schema introspected successfully',
-            target: {
-              familyId: config.family.familyId,
-              id: config.target.targetId,
-            },
-            schema: schemaIR,
-            ...(configPath || options.db || config.db?.url
-              ? {
-                  meta: {
-                    ...(configPath ? { configPath } : {}),
-                    ...(options.db || config.db?.url
-                      ? {
-                          dbUrl: (options.db ?? config.db?.url ?? '').replace(
-                            /:([^:@]+)@/,
-                            ':****@',
-                          ),
-                        }
-                      : {}),
-                  },
-                }
-              : {}),
-            timings: {
-              total: totalTime,
-            },
-          };
-
-          return { introspectResult, schemaView };
-        } finally {
-          // Ensure driver connection is closed
-          await driver.close();
-        }
-      });
+      const result = await executeDbIntrospectCommand(options, flags, startTime);
 
       // Handle result - formats output and returns exit code
       const exitCode = handleResult(result, flags, (value) => {
         const { introspectResult, schemaView } = value;
-        // Output based on flags
         if (flags.json === 'object') {
-          // JSON output to stdout
           console.log(formatIntrospectJson(introspectResult));
         } else {
-          // Human-readable output to stdout
           const output = formatIntrospectOutput(introspectResult, schemaView, flags);
           if (output) {
             console.log(output);