@prisma-next/cli 0.5.0-dev.4 → 0.5.0-dev.41

package/src/commands/init/hygiene-package-scripts.ts

@@ -0,0 +1,91 @@
+/**
+ * The package.json `scripts` entries `init` adds idempotently (FR3.5).
+ * The script *name* mirrors the CLI subcommand path (`contract:emit` →
+ * `prisma-next contract emit`) so the script is greppable: a user
+ * encountering `npm run contract:emit` in CI logs can navigate
+ * straight to the equivalent CLI invocation.
+ *
+ * No watch-mode entry is included (Spec Decision 9) — file-watching is
+ * the build tool's job (Vite plugin, `tsc --watch`, etc.).
+ */
+export interface RequiredScript {
+  readonly name: string;
+  readonly command: string;
+}
+
+export const REQUIRED_SCRIPTS: readonly RequiredScript[] = [
+  { name: 'contract:emit', command: 'prisma-next contract emit' },
+];
+
+export interface PackageScriptsMergeResult {
+  /**
+   * The new package.json content. `null` when no changes are required
+   * (every required script is already present with the correct
+   * command).
+   */
+  readonly content: string | null;
+  /**
+   * Structured warnings raised when an existing script of the same
+   * name maps to a different command. Each warning names the script,
+   * the existing command, and the command we wanted to write — the
+   * user can decide whether to keep their override or update it.
+   */
+  readonly warnings: readonly string[];
+}
+
+/**
+ * Idempotent `package.json#scripts` merge with collision detection
+ * (FR3.5 / FR9.3):
+ *
+ * - If a required script is **missing**, append it.
+ * - If a required script is **already present and identical**, leave
+ *   the file alone (idempotency).
+ * - If a required script is **present but maps to a different command**,
+ *   skip the write for that script and surface a structured warning.
+ *   The user's override is sacred — `init` should never silently
+ *   overwrite a custom build pipeline.
+ *
+ * Preserves the existing key order (so a user who has alphabetised
+ * their scripts does not see them reshuffled) and appends new entries
+ * at the end.
+ *
+ * The `package.json` is parsed and re-stringified through `JSON` —
+ * comments are not preserved (package.json does not support them per
+ * spec). Trailing newline matches the original input's trailing
+ * newline behaviour.
+ */
+export function mergePackageScripts(
+  existing: string,
+  required: readonly RequiredScript[] = REQUIRED_SCRIPTS,
+): PackageScriptsMergeResult {
+  const parsed = JSON.parse(existing) as Record<string, unknown>;
+  const scripts: Record<string, string> =
+    typeof parsed['scripts'] === 'object' && parsed['scripts'] !== null
+      ? { ...(parsed['scripts'] as Record<string, string>) }
+      : {};
+
+  const warnings: string[] = [];
+  let mutated = false;
+
+  for (const { name, command } of required) {
+    const existingValue = scripts[name];
+    if (existingValue === undefined) {
+      scripts[name] = command;
+      mutated = true;
+      continue;
+    }
+    if (existingValue !== command) {
+      warnings.push(
+        `package.json already has a "${name}" script with a different command — keeping yours.\n  existing: ${existingValue}\n  expected: ${command}\nIf you want the default, remove your "${name}" script and re-run \`init\`.`,
+      );
+    }
+  }
+
+  if (!mutated) {
+    return { content: null, warnings };
+  }
+
+  parsed['scripts'] = scripts;
+  const trailingNewline = existing.endsWith('\n') ? '\n' : '';
+  return { content: `${JSON.stringify(parsed, null, 2)}${trailingNewline}`, warnings };
+}

package/src/commands/init/index.ts

@@ -1,5 +1,39 @@
 import { Command } from 'commander';
-import { setCommandDescriptions, setCommandExamples } from '../../utils/command-helpers';
+import {
+  addGlobalOptions,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../../utils/command-helpers';
+import { type CommonCommandOptions, parseGlobalFlags } from '../../utils/global-flags';
+import {
+  INIT_EXIT_EMIT_FAILED,
+  INIT_EXIT_INSTALL_FAILED,
+  INIT_EXIT_INTERNAL_ERROR,
+  INIT_EXIT_OK,
+  INIT_EXIT_PRECONDITION,
+  INIT_EXIT_USER_ABORTED,
+} from './exit-codes';
+
+/**
+ * Commander.js parsed options for `init`. The init-specific options live
+ * alongside the inherited `CommonCommandOptions` global flags.
+ *
+ * `target` and `authoring` are typed as plain `string` here because
+ * Commander.js does not enforce enums at parse time — the validation /
+ * normalisation happens in `inputs.ts::resolveInitInputs`, which can
+ * raise a structured `errorInitInvalidFlagValue` with the full set of
+ * allowed values.
+ */
+interface InitCommandOptions extends CommonCommandOptions {
+  readonly target?: string;
+  readonly authoring?: string;
+  readonly schemaPath?: string;
+  readonly force?: boolean;
+  readonly writeEnv?: boolean;
+  readonly probeDb?: boolean;
+  readonly strictProbe?: boolean;
+  readonly install?: boolean;
+}
 
 export function createInitCommand(): Command {
   const command = new Command('init');
@@ -7,15 +41,86 @@ export function createInitCommand(): Command {
     command,
     'Initialize a new Prisma Next project',
     'Scaffolds config, schema, and runtime files, installs dependencies,\n' +
-      'and emits the contract. Gets you from zero to typed queries in one step.',
+      'and emits the contract. Gets you from zero to typed queries in one step.\n' +
+      '\n' +
+      'Run interactively for a guided experience, or supply --target / --authoring\n' +
+      'and --yes for a fully scriptable run (CI, AI coding agents, automation).\n' +
+      '\n' +
+      'Exit codes (see CLI Style Guide § Exit Codes):\n' +
+      `  ${INIT_EXIT_OK}   OK                    Init succeeded.\n` +
+      `  ${INIT_EXIT_INTERNAL_ERROR}   INTERNAL_ERROR        Unexpected bug in prisma-next (please report).\n` +
+      `  ${INIT_EXIT_PRECONDITION}   PRECONDITION          Bad flags / missing prerequisite (e.g. no package.json).\n` +
+      `  ${INIT_EXIT_USER_ABORTED}   USER_ABORTED          User cancelled an interactive prompt.\n` +
+      `  ${INIT_EXIT_INSTALL_FAILED}   INSTALL_FAILED        Dependency installation failed (init-specific).\n` +
+      `  ${INIT_EXIT_EMIT_FAILED}   EMIT_FAILED           \`contract emit\` failed after install (init-specific).`,
   );
-  setCommandExamples(command, ['prisma-next init', 'prisma-next init --no-install']);
-  command
+  setCommandExamples(command, [
+    'prisma-next init',
+    'prisma-next init --yes --target postgres --authoring psl',
+    'prisma-next init --yes --target mongodb --authoring typescript --json',
+    'prisma-next init --yes --force --target postgres --authoring psl  # overwrite an existing scaffold',
+    'prisma-next init --no-install                                       # skip pnpm/npm install + emit',
+  ]);
+
+  return addGlobalOptions(command)
+    .option('--target <db>', 'Database target: postgres or mongodb')
+    .option('--authoring <style>', 'Schema authoring style: psl or typescript')
+    .option(
+      '--schema-path <path>',
+      'Where to write the starter schema (default: prisma/contract.prisma)',
+    )
+    .option('--force', 'Overwrite an existing scaffold without prompting')
+    .option(
+      '--write-env',
+      'Write a .env file from .env.example (gitignored; default: only .env.example)',
+    )
+    .option(
+      '--probe-db',
+      'Connect to DATABASE_URL once and check the server version against the target minimum (opt-in; off by default)',
+    )
+    .option(
+      '--strict-probe',
+      'Treat a failed --probe-db as fatal (no-op without --probe-db; init is offline-by-default)',
+    )
     .option('--no-install', 'Skip dependency installation and contract emission')
-    .action(async (options: { readonly install?: boolean }) => {
+    .action(async (options: InitCommandOptions) => {
       const { runInit } = await import('./init');
-      await runInit(process.cwd(), { noInstall: !options.install });
+      const flags = parseGlobalFlags(options);
+      const canPrompt = deriveCanPrompt({
+        flagsInteractive: flags.interactive,
+        optionInteractive: options.interactive,
+        stdinIsTTY: Boolean(process.stdin.isTTY),
+      });
+      const exitCode = await runInit(process.cwd(), { options, flags, canPrompt });
+      process.exit(exitCode);
     });
+}
 
-  return command;
+/**
+ * Bridges the action handler's two TTY checks (stdout via `flags`, stdin
+ * via `process.stdin.isTTY`) into the `canPrompt` boolean `runInit`
+ * consumes.
+ *
+ * Per the [Style Guide § Interactivity](../../../../../../../docs/CLI%20Style%20Guide.md#interactivity):
+ *
+ * - `flags.interactive` governs *decoration* (TerminalUI, intro/outro,
+ *   spinners) and is derived from stdout-TTY by `parseGlobalFlags`,
+ *   honouring `--interactive` / `--no-interactive`.
+ * - Prompting additionally requires a stdin TTY — closing stdin is a
+ *   common signal in CI / agent environments even when stdout stays
+ *   attached.
+ * - `--interactive` is the explicit override: when the user passes it,
+ *   we honour it (e.g. testing flows where stdin is stubbed).
+ *
+ * Exported so callers and tests can derive the same value without
+ * touching `process` globals — F14 of the M1/M2 review.
+ */
+export function deriveCanPrompt(opts: {
+  readonly flagsInteractive: boolean | undefined;
+  readonly optionInteractive: boolean | undefined;
+  readonly stdinIsTTY: boolean;
+}): boolean {
+  if (opts.optionInteractive === true) return true;
+  if (opts.flagsInteractive === false) return false;
+  return opts.stdinIsTTY;
 }