@prisma-next/cli 0.12.0-dev.2 → 0.12.0-dev.20

package/src/utils/formatters/migration-list-graph-topology.ts

@@ -30,10 +30,30 @@ function bumpDegree(map: Map<string, number>, key: string): void {
   map.set(key, (map.get(key) ?? 0) + 1);
 }
 
-function forwardRootsForDepth(
+function compareNodesRootFirst(a: string, b: string): number {
+  if (a === EMPTY_CONTRACT_HASH) return -1;
+  if (b === EMPTY_CONTRACT_HASH) return 1;
+  return a.localeCompare(b);
+}
+
+/**
+ * Shortest-path distance of each node from the forward roots, over the given
+ * candidate edges. Roots are the in-degree-0 nodes (baseline first, then lex);
+ * a rooted component therefore distances every node by how many forward steps
+ * it sits from a root. A component with no root (a pure cycle) is seeded from
+ * its single lexically-smallest node so the cycle still gets a stable layering.
+ *
+ * Crucially this is *shortest* path, not longest: a backward (rollback) edge
+ * `deep → shallow` never offers a shorter route to the already-shallower
+ * target, so it is inert here. Distances are thus stable whether or not the
+ * rollbacks are still in the candidate set — which is what lets the peel below
+ * tell a genuine back-edge (target strictly shallower than source) apart from a
+ * forward edge that merely happens to share the back-edge's cycle.
+ */
+function forwardDistances(
   nodes: ReadonlySet<string>,
   candidates: readonly NormalizedEdge[],
-): readonly string[] {
+): Map<string, number> {
   const inDegree = new Map<string, number>();
   for (const node of nodes) {
     inDegree.set(node, 0);
@@ -42,44 +62,24 @@ function forwardRootsForDepth(
     bumpDegree(inDegree, edge.to);
   }
 
-  const roots: string[] = [];
-  for (const node of nodes) {
-    if ((inDegree.get(node) ?? 0) === 0) {
-      roots.push(node);
-    }
-  }
-  roots.sort((a, b) => {
-    if (a === EMPTY_CONTRACT_HASH) return -1;
-    if (b === EMPTY_CONTRACT_HASH) return 1;
-    return a.localeCompare(b);
-  });
-  if (roots.length > 0) return roots;
+  const roots = [...nodes].filter((node) => (inDegree.get(node) ?? 0) === 0);
+  roots.sort(compareNodesRootFirst);
+  const seeds = roots.length > 0 ? roots : [...nodes].sort(compareNodesRootFirst).slice(0, 1);
 
-  return [...nodes].sort((a, b) => {
-    if (a === EMPTY_CONTRACT_HASH) return -1;
-    if (b === EMPTY_CONTRACT_HASH) return 1;
-    return a.localeCompare(b);
-  });
-}
-
-function longestPathDepths(
-  nodes: ReadonlySet<string>,
-  candidates: readonly NormalizedEdge[],
-): Map<string, number> {
-  const depth = new Map<string, number>();
-  for (const root of forwardRootsForDepth(nodes, candidates)) {
-    depth.set(root, 0);
+  const dist = new Map<string, number>();
+  for (const seed of seeds) {
+    dist.set(seed, 0);
   }
 
   const maxPasses = nodes.size;
   for (let pass = 0; pass < maxPasses; pass++) {
     let changed = false;
     for (const edge of candidates) {
-      const base = depth.get(edge.from);
+      const base = dist.get(edge.from);
       if (base === undefined) continue;
       const next = base + 1;
-      if (next > (depth.get(edge.to) ?? -1)) {
-        depth.set(edge.to, next);
+      if (next < (dist.get(edge.to) ?? Number.POSITIVE_INFINITY)) {
+        dist.set(edge.to, next);
         changed = true;
       }
     }
@@ -87,12 +87,12 @@ function longestPathDepths(
   }
 
   for (const node of nodes) {
-    if (!depth.has(node)) {
-      depth.set(node, 0);
+    if (!dist.has(node)) {
+      dist.set(node, 0);
     }
   }
 
-  return depth;
+  return dist;
 }
 
 function canReachForward(
@@ -126,45 +126,24 @@ function canReachForward(
   return false;
 }
 
-function isMarginalForwardEdge(
-  nodes: ReadonlySet<string>,
-  candidates: readonly NormalizedEdge[],
-  edge: NormalizedEdge,
-): boolean {
-  const without = candidates.filter((candidate) => candidate !== edge);
-  const depthWithout = longestPathDepths(nodes, without);
-  const depthWith = longestPathDepths(nodes, candidates);
-  const fromDepth = depthWithout.get(edge.from) ?? 0;
-  const toWith = depthWith.get(edge.to) ?? 0;
-  return toWith > fromDepth;
-}
-
-// The first branch is the load-bearing one: a forward edge `from → to` is a
-// disguised node-skipping rollback when, after removing it, `to` can still
-// reach `from` and `from` sits strictly deeper than `to + 1` (a longer path
-// already connects them). This branch fires on every cycle-closing edge, and
-// the caller peels exactly one edge (dirName-max) per iteration before
-// recomputing — so cycles are broken deterministically regardless of edge
-// order. `isMarginalForwardEdge` is only a fallback for the residual case and
-// is reached only while the candidate set is still cyclic.
-function shouldPeelForwardEdge(
-  nodes: ReadonlySet<string>,
-  candidates: readonly NormalizedEdge[],
-  edge: NormalizedEdge,
-): boolean {
-  const without = candidates.filter((candidate) => candidate !== edge);
-  const depthWithout = longestPathDepths(nodes, without);
-  const fromDepth = depthWithout.get(edge.from) ?? 0;
-  const toWithout = depthWithout.get(edge.to) ?? 0;
-
-  if (canReachForward(edge.to, edge.from, without) && fromDepth > toWithout + 1) {
-    return true;
-  }
-
-  return !isMarginalForwardEdge(nodes, candidates, edge);
-}
-
-function peelNonMarginalForwardEdges(
+/**
+ * Demote node-skipping rollbacks left forward by the DFS. An edge `from → to`
+ * is a rollback exactly when both hold:
+ *   1. `to` is a forward-ancestor of `from` — `to` can still reach `from` over
+ *      the other forward edges, so the edge closes a cycle; and
+ *   2. `to` is strictly shallower than `from` (smaller forward distance) — the
+ *      edge points back toward the root rather than advancing history.
+ *
+ * Condition 2 is the discriminator: in a cycle created by a rollback every edge
+ * satisfies condition 1, but only the rollback itself runs deep → shallow. The
+ * forward chain edges run shallow → deep and are never peeled, however many
+ * rollbacks converge on the same target. Tight back-edges whose source and
+ * target sit at the same distance (mutual two-node cycles) are already resolved
+ * by the DFS immediate-parent rule, so they never reach this pass. One edge is
+ * peeled per iteration (dirName-descending tie-break) and distances/reachability
+ * are recomputed, making the outcome independent of edge input order.
+ */
+function peelNodeSkippingRollbacks(
   nodes: ReadonlySet<string>,
   kindByMigrationHash: Map<string, MigrationEdgeKind>,
   nonSelf: readonly NormalizedEdge[],
@@ -172,13 +151,18 @@ function peelNonMarginalForwardEdges(
   let candidates = nonSelf.filter((edge) => kindByMigrationHash.get(edge.hash) === 'forward');
 
   while (candidates.length > 0) {
-    const rollbackCandidates = candidates.filter((edge) =>
-      shouldPeelForwardEdge(nodes, candidates, edge),
-    );
-    if (rollbackCandidates.length === 0) break;
-
-    rollbackCandidates.sort(compareDirNameDesc);
-    const rollback = rollbackCandidates[0];
+    const dist = forwardDistances(nodes, candidates);
+    const backEdges = candidates.filter((edge) => {
+      const toDist = dist.get(edge.to) ?? 0;
+      const fromDist = dist.get(edge.from) ?? 0;
+      if (toDist >= fromDist) return false;
+      const without = candidates.filter((candidate) => candidate !== edge);
+      return canReachForward(edge.to, edge.from, without);
+    });
+    if (backEdges.length === 0) break;
+
+    backEdges.sort(compareDirNameDesc);
+    const rollback = backEdges[0];
     if (rollback === undefined) break;
 
     kindByMigrationHash.set(rollback.hash, 'rollback');
@@ -189,8 +173,8 @@ function peelNonMarginalForwardEdges(
 /**
  * DFS with dirName-descending traversal. A GRAY target is a rollback only when it
  * is the immediate DFS parent of the source — cross-links to other GRAY nodes
- * stay forward. A follow-up peel pass drops node-skipping rollbacks (target can
- * reach the source on the forward subgraph and sits more than one rank below).
+ * stay forward. A follow-up peel pass demotes node-skipping rollbacks (target is
+ * a forward-ancestor of the source and sits strictly shallower than it).
  */
 function classifyNormalizedEdges(edges: readonly NormalizedEdge[]): MigrationListGraphTopology {
   const nodes = new Set<string>();
@@ -307,7 +291,7 @@ function classifyNormalizedEdges(edges: readonly NormalizedEdge[]): MigrationLis
     runDfsFrom(root);
   }
 
-  peelNonMarginalForwardEdges(nodes, kindByMigrationHash, nonSelf);
+  peelNodeSkippingRollbacks(nodes, kindByMigrationHash, nonSelf);
 
   const forwardInDegree = new Map<string, number>();
   const forwardOutDegree = new Map<string, number>();

package/src/utils/global-flags.ts

@@ -180,3 +180,38 @@ export function parseGlobalFlags(options: CommonCommandOptions): GlobalFlags {
 
   return flags as GlobalFlags;
 }
+
+/**
+ * Bridges the two TTY checks (stdout via `flags`, stdin via
+ * `process.stdin.isTTY`) into the `canPrompt` boolean the interactive
+ * `init` flow 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).
+ *
+ * Single source of truth for the interactive-prompt decision: both the
+ * `init` action handler and the preAction telemetry bridge derive
+ * prompt-eligibility from this helper so they cannot drift. Lives in
+ * `global-flags` (alongside `parseGlobalFlags`) to keep
+ * `utils/telemetry` and `commands/init/index` free of an import cycle.
+ *
+ * Exported so callers and tests can derive the same value without
+ * touching `process` globals.
+ */
+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;
+}

package/src/utils/telemetry.ts

@@ -2,13 +2,14 @@ import { fileURLToPath } from 'node:url';
 import {
   type CommanderOptionShape,
   type CommanderResultShape,
+  ensureInstallationId,
   readUserConfig,
   resolveGating,
   runTelemetry,
   type TelemetryRunOutcome,
   type UserConfig,
+  userConfigPath,
 } from '@prisma-next/cli-telemetry';
-import { ifDefined } from '@prisma-next/utils/defined';
 import type { Command } from 'commander';
 import { version as CLI_VERSION } from '../../package.json' with { type: 'json' };
 import { isCI } from './is-ci';
@@ -78,11 +79,7 @@ function senderPath(): string {
   return fileURLToPath(new URL(import.meta.resolve('@prisma-next/cli-telemetry/sender')));
 }
 
-function fireTelemetry(
-  actionCommand: Command,
-  userConfig: UserConfig,
-  overrides: { readonly databaseTarget?: string } = {},
-): TelemetryRunOutcome {
+function fireTelemetry(actionCommand: Command, userConfig: UserConfig): TelemetryRunOutcome {
   return runTelemetry({
     command: commanderSnapshotForTelemetry(actionCommand),
     version: CLI_VERSION,
@@ -91,7 +88,6 @@ function fireTelemetry(
     isCI: isCI(),
     env: process.env,
     userConfig,
-    ...ifDefined('databaseTarget', overrides.databaseTarget),
   });
 }
 
@@ -107,35 +103,75 @@ function fireTelemetry(
  * config touches disk. The child loading user TS code is acceptable
  * only because it's gated behind the same resolved-enabled signal.
  */
+/**
+ * Builds the one-time first-run disclosure. The resolved absolute path to
+ * the user-level config file is substituted in so the user can see exactly
+ * which file to edit (it must not be confused with `prisma-next.config.ts`).
+ * `prisma-next telemetry disable` is named as the primary, friendliest
+ * opt-out, alongside the env vars and the config edit.
+ */
+function firstRunNotice(configPath: string): string {
+  return [
+    'Prisma Next collects anonymous CLI usage data, enabled by default.',
+    "What's collected and why: https://prisma-next.dev/docs/cli/telemetry.",
+    'Opt out: run "prisma-next telemetry disable", set DO_NOT_TRACK=1 or',
+    `PRISMA_NEXT_DISABLE_TELEMETRY=1, or set "enableTelemetry": false in ${configPath}.`,
+  ].join(' ');
+}
+
+/**
+ * Best-effort first-run disclosure + installationId mint. Runs only on the
+ * gating-enabled path. Prints the notice to stderr (never stdout) and mints
+ * a persistent id without touching `enableTelemetry`, so the opt-out default
+ * stays intact and no unasked-for consent is recorded.
+ *
+ * Every step is wrapped so an un-writable config dir (or any other failure)
+ * never throws and never blocks the command. Returns the minted (or
+ * pre-existing) id so the caller can forward it to `runTelemetry` without a
+ * redundant disk read. On mint failure it returns `undefined`: the notice may
+ * reprint next run, and `runTelemetry` no-ops on the missing id.
+ */
+function discloseAndMintOnFirstRun(): string | undefined {
+  try {
+    process.stderr.write(`${firstRunNotice(userConfigPath())}\n`);
+  } catch {}
+  try {
+    return ensureInstallationId();
+  } catch {}
+  return undefined;
+}
+
+/**
+ * True when the run is the `telemetry` command (or one of its
+ * subcommands). The usage-telemetry preAction fire is exempted for it:
+ * it would be absurd for `telemetry disable` to send a usage event before
+ * disabling, or for `telemetry status` to mint an id + send while merely
+ * reporting state. This is the only command-specific exemption.
+ *
+ * The check is rooted at the program: the path must be
+ * `['prisma-next', 'telemetry', …]`, so it matches the top-level
+ * `telemetry` command and its subcommands without matching a hypothetical
+ * nested `… telemetry` elsewhere.
+ */
+function isTelemetryCommand(actionCommand: Command): boolean {
+  return commandPathFor(actionCommand)[1] === 'telemetry';
+}
+
 export function fireTelemetryFromPreAction(actionCommand: Command): TelemetryRunOutcome {
+  if (isTelemetryCommand(actionCommand)) {
+    return { spawned: false, reason: 'gated-off' };
+  }
   const gate = resolveTelemetryGate();
   if (!gate.enabled) {
     return gate.outcome;
   }
+  const storedId = gate.userConfig.installationId;
+  if (typeof storedId !== 'string' || storedId.length === 0) {
+    const installationId = discloseAndMintOnFirstRun();
+    return fireTelemetry(
+      actionCommand,
+      installationId === undefined ? gate.userConfig : { ...gate.userConfig, installationId },
+    );
+  }
   return fireTelemetry(actionCommand, gate.userConfig);
 }
-
-/**
- * Manual one-shot telemetry path for the first `init` run where the user
- * explicitly answers Yes to the consent prompt. The preAction hook for
- * that same run has already resolved before consent existed, so it is
- * default-off. After consent is persisted, `runInit` calls this helper
- * exactly for that first affirmative answer; subsequent init runs skip
- * it because the prompt is not shown again.
- *
- * The child's c12 load would return `databaseTarget: null` for this
- * specific invocation because `prisma-next.config.*` is not yet on
- * disk (init writes it later in the same run). To preserve the
- * prompt-chosen target in the first-init telemetry event, this
- * helper forwards the value as a parent-side IPC override on
- * `ParentToSenderPayload.databaseTarget` — the child consults the
- * override first and falls back to its c12 result when absent.
- */
-export function fireTelemetryAfterInitConsent(
-  actionCommand: Command,
-  inputs: { readonly databaseTarget: string },
-): TelemetryRunOutcome {
-  return fireTelemetry(actionCommand, readUserConfig(), {
-    databaseTarget: inputs.databaseTarget,
-  });
-}