@prisma-next/cli 0.12.0-dev.4 → 0.12.0-dev.40

package/src/utils/formatters/migration-list-styler.ts

@@ -1,6 +1,39 @@
 import { bold, cyan, cyanBright, dim, green, yellow } from 'colorette';
 import { IDENTITY_MIGRATION_LIST_STYLER, type MigrationListStyler } from './migration-list-render';
 
+export type MigrationListStylerWithMarkers = MigrationListStyler & {
+  markers(names: readonly string[]): string;
+};
+
+function hasMarkersFormatter(
+  styler: MigrationListStyler,
+): styler is MigrationListStylerWithMarkers {
+  return 'markers' in styler && typeof styler.markers === 'function';
+}
+
+function styleMarkerName(name: string): string {
+  return name === CONTRACT_MARKER_NAME ? bold(green(name)) : green(name);
+}
+
+function plainMarkers(names: readonly string[]): string {
+  return `<${names.join(', ')}>`;
+}
+
+export function formatContractNodeOverlays(
+  styler: MigrationListStyler,
+  markers: readonly string[],
+  refs: readonly string[],
+): string {
+  const parts: string[] = [];
+  if (markers.length > 0) {
+    parts.push(hasMarkersFormatter(styler) ? styler.markers(markers) : plainMarkers(markers));
+  }
+  if (refs.length > 0) {
+    parts.push(styler.refs(refs));
+  }
+  return parts.join(' ');
+}
+
 /**
  * The current contract overlay marker. Unlike user refs, this names the user's
  * declared desired state — the implicit base/target for `plan` / `migrate` —
@@ -10,7 +43,7 @@ import { IDENTITY_MIGRATION_LIST_STYLER, type MigrationListStyler } from './migr
 export const CONTRACT_MARKER_NAME = 'contract';
 
 function styleRefName(name: string): string {
-  return name === CONTRACT_MARKER_NAME ? bold(green(name)) : green(name);
+  return green(name);
 }
 
 /**
@@ -29,17 +62,21 @@ function styleRefName(name: string): string {
  * - `glyph` (`→` / `⟲` / `∅`): dim
  * - `lane` (graph gutter lines `│` and fan/join connectors `├─┐` / `├─┘`): dim
  * - `invariants` (`{...}`): yellow
- * - `refs` (`(...)`): green; the `contract` desired-state marker inside is
- *   green-bold (the active ref is bolded separately by the tree styler)
+ * - `markers` (`<...>`): green; the `contract` desired-state marker inside is
+ *   green-bold (`db` is plain green)
+ * - `refs` (`(...)`): green (the active ref is bolded separately by the tree styler)
  * - `spaceHeading` (`<spaceId>:`): bold
  * - `summary`: dim
  * - `emptyState`: dim
  */
 export function createAnsiMigrationListStyler(opts: {
   readonly useColor: boolean;
-}): MigrationListStyler {
+}): MigrationListStylerWithMarkers {
   if (!opts.useColor) {
-    return IDENTITY_MIGRATION_LIST_STYLER;
+    return {
+      ...IDENTITY_MIGRATION_LIST_STYLER,
+      markers: plainMarkers,
+    };
   }
   return {
     // Kind glyphs stay bright in both flat and graph views; lanes carry the dim gutter.
@@ -50,6 +87,12 @@ export function createAnsiMigrationListStyler(opts: {
     glyph: (text) => dim(text),
     lane: (text) => dim(text),
     invariants: (ids) => yellow(`{${ids.join(', ')}}`),
+    markers: (names) => {
+      const open = green('<');
+      const close = green('>');
+      const separator = green(', ');
+      return open + names.map(styleMarkerName).join(separator) + close;
+    },
     refs: (names) => {
       const open = green('(');
       const close = green(')');

package/src/utils/formatters/migration-log-table.ts

@@ -0,0 +1,200 @@
+import type { LedgerEntryRecord } from '@prisma-next/contract/types';
+import stringWidth from 'string-width';
+import type { GlyphMode } from '../glyph-mode';
+import {
+  abbreviateContractHash,
+  migrationListEmptySource,
+  migrationListForwardArrow,
+} from './migration-list-data-column';
+import { IDENTITY_MIGRATION_LIST_STYLER, type MigrationListStyler } from './migration-list-render';
+
+export type LedgerTimestampMode = 'local' | 'utc' | 'iso';
+
+export interface RenderMigrationLogTableOptions {
+  readonly utc?: boolean;
+  readonly styler?: MigrationListStyler;
+  readonly glyphMode?: GlyphMode;
+}
+
+export interface SerializedLedgerEntryRecord {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
+  readonly from: string | null;
+  readonly to: string;
+  readonly appliedAt: string;
+  readonly operationCount: number;
+}
+
+const HEADING_APPLIED_AT = 'Applied at';
+const HEADING_SPACE = 'Space';
+const HEADING_MIGRATION = 'Migration';
+const HEADING_CHANGE = 'Change';
+const HEADING_OPS = 'Ops';
+const COLUMN_SEPARATOR = ' ';
+const DIVIDER_CHAR = '─';
+const ASCII_DIVIDER_CHAR = '-';
+
+export function sortLedgerEntries(entries: readonly LedgerEntryRecord[]): LedgerEntryRecord[] {
+  return [...entries].sort((left, right) => {
+    const timeDiff = left.appliedAt.getTime() - right.appliedAt.getTime();
+    if (timeDiff !== 0) {
+      return timeDiff;
+    }
+    const spaceDiff = left.space.localeCompare(right.space);
+    if (spaceDiff !== 0) {
+      return spaceDiff;
+    }
+    return left.migrationName.localeCompare(right.migrationName);
+  });
+}
+
+function pad2(value: number): string {
+  return String(value).padStart(2, '0');
+}
+
+export function formatLedgerAppliedAt(date: Date, mode: LedgerTimestampMode): string {
+  if (mode === 'iso') {
+    return date.toISOString();
+  }
+  if (mode === 'utc') {
+    return `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())} ${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}:${pad2(date.getUTCSeconds())}Z`;
+  }
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? '+' : '-';
+  const absoluteOffset = Math.abs(offsetMinutes);
+  const offsetHours = pad2(Math.floor(absoluteOffset / 60));
+  const offsetMins = pad2(absoluteOffset % 60);
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())} ${sign}${offsetHours}:${offsetMins}`;
+}
+
+export function formatHashEndpoint(hash: string | null, glyphMode: GlyphMode = 'unicode'): string {
+  if (hash === null) {
+    return migrationListEmptySource(glyphMode);
+  }
+  return abbreviateContractHash(hash);
+}
+
+export function formatHashTransition(
+  from: string | null,
+  to: string,
+  glyphMode: GlyphMode = 'unicode',
+): string {
+  return `${formatHashEndpoint(from, glyphMode)} ${migrationListForwardArrow(glyphMode)} ${abbreviateContractHash(to)}`;
+}
+
+export function styleHashTransition(
+  from: string | null,
+  to: string,
+  styler: MigrationListStyler,
+  glyphMode: GlyphMode = 'unicode',
+): string {
+  const fromPart =
+    from === null
+      ? styler.glyph(migrationListEmptySource(glyphMode))
+      : styler.sourceHash(abbreviateContractHash(from));
+  const arrow = styler.glyph(migrationListForwardArrow(glyphMode));
+  const dest = styler.destHash(abbreviateContractHash(to));
+  return `${fromPart} ${arrow} ${dest}`;
+}
+
+function padVisible(text: string, targetWidth: number): string {
+  const padding = Math.max(0, targetWidth - stringWidth(text));
+  return text + ' '.repeat(padding);
+}
+
+function columnWidth(values: readonly string[]): number {
+  return values.reduce((max, value) => Math.max(max, stringWidth(value)), 0);
+}
+
+function padDividerCell(valueWidth: number, dividerChar: string): string {
+  return dividerChar.repeat(valueWidth + 2);
+}
+
+function padTextCell(value: string, valueWidth: number): string {
+  return ` ${padVisible(value, valueWidth)} `;
+}
+
+function padOpsCell(value: string, valueWidth: number): string {
+  const padding = Math.max(0, valueWidth - stringWidth(value));
+  return ` ${' '.repeat(padding)}${value} `;
+}
+
+export function renderMigrationLogTable(
+  entries: readonly LedgerEntryRecord[],
+  options: RenderMigrationLogTableOptions = {},
+): string {
+  const sorted = sortLedgerEntries(entries);
+  if (sorted.length === 0) {
+    return '';
+  }
+
+  const styler = options.styler ?? IDENTITY_MIGRATION_LIST_STYLER;
+  const glyphMode = options.glyphMode ?? 'unicode';
+  const dividerChar = glyphMode === 'ascii' ? ASCII_DIVIDER_CHAR : DIVIDER_CHAR;
+  const showSpace = new Set(sorted.map((entry) => entry.space)).size > 1;
+  const timestampMode: LedgerTimestampMode = options.utc ? 'utc' : 'local';
+  const rows = sorted.map((entry) => ({
+    appliedAt: formatLedgerAppliedAt(entry.appliedAt, timestampMode),
+    space: entry.space,
+    migrationName: entry.migrationName,
+    transition: formatHashTransition(entry.from, entry.to, glyphMode),
+    ops: `${entry.operationCount} ops`,
+    from: entry.from,
+    to: entry.to,
+  }));
+
+  const appliedAtWidth = columnWidth([HEADING_APPLIED_AT, ...rows.map((row) => row.appliedAt)]);
+  const spaceWidth = showSpace ? columnWidth([HEADING_SPACE, ...rows.map((row) => row.space)]) : 0;
+  const nameWidth = columnWidth([HEADING_MIGRATION, ...rows.map((row) => row.migrationName)]);
+  const transitionWidth = columnWidth([HEADING_CHANGE, ...rows.map((row) => row.transition)]);
+  const opsWidth = columnWidth([HEADING_OPS, ...rows.map((row) => row.ops)]);
+
+  const headingParts = [padTextCell(HEADING_APPLIED_AT, appliedAtWidth)];
+  if (showSpace) {
+    headingParts.push(padTextCell(HEADING_SPACE, spaceWidth));
+  }
+  headingParts.push(
+    padTextCell(HEADING_MIGRATION, nameWidth),
+    padTextCell(HEADING_CHANGE, transitionWidth),
+    padOpsCell(HEADING_OPS, opsWidth),
+  );
+  const heading = headingParts.join(COLUMN_SEPARATOR);
+
+  const dividerParts = [padDividerCell(appliedAtWidth, dividerChar)];
+  if (showSpace) {
+    dividerParts.push(padDividerCell(spaceWidth, dividerChar));
+  }
+  dividerParts.push(
+    padDividerCell(nameWidth, dividerChar),
+    padDividerCell(transitionWidth, dividerChar),
+    padDividerCell(opsWidth, dividerChar),
+  );
+  const divider = dividerParts.map((cell) => styler.summary(cell)).join(COLUMN_SEPARATOR);
+
+  const dataRows = rows.map((row) => {
+    const parts = [padTextCell(row.appliedAt, appliedAtWidth)];
+    if (showSpace) {
+      parts.push(padTextCell(row.space, spaceWidth));
+    }
+    parts.push(
+      padTextCell(styler.dirName(row.migrationName), nameWidth),
+      padTextCell(styleHashTransition(row.from, row.to, styler, glyphMode), transitionWidth),
+      padOpsCell(row.ops, opsWidth),
+    );
+    return parts.join(COLUMN_SEPARATOR);
+  });
+
+  return [heading, divider, ...dataRows].join('\n');
+}
+
+export function serializeLedgerEntriesForJson(
+  entries: readonly LedgerEntryRecord[],
+): SerializedLedgerEntryRecord[] {
+  return sortLedgerEntries(entries).map(({ appliedAt, ...rest }) => ({
+    ...rest,
+    appliedAt: formatLedgerAppliedAt(appliedAt, 'iso'),
+  }));
+}
+
+export const MIGRATION_LOG_EMPTY_MESSAGE = 'No migrations have been applied to this database.';

package/src/utils/formatters/migrations.ts

@@ -1,4 +1,7 @@
-import type { OperationPreview } from '@prisma-next/framework-components/control';
+import type {
+  MigrationPlannerConflict,
+  OperationPreview,
+} from '@prisma-next/framework-components/control';
 import { cyan, green, yellow } from 'colorette';
 
 import type { PerSpaceExecutionEntry } from '../../control-api/types';
@@ -85,11 +88,24 @@ export interface MigrationCommandResult {
   readonly advancedRef?: { readonly name: string; readonly hash: string } | null;
   readonly plannedAdvanceRef?: { readonly name: string; readonly hash: string } | null;
   readonly summary: string;
+  readonly warnings?: readonly MigrationPlannerConflict[];
   readonly timings: {
     readonly total: number;
   };
 }
 
+export function formatPlannerWarningsBlock(
+  warnings: readonly MigrationPlannerConflict[],
+  useColor: boolean,
+): readonly string[] {
+  const formatDimText = (text: string) => formatDim(useColor, text);
+  const lines: string[] = ['', 'Warnings:'];
+  for (const warning of warnings) {
+    lines.push(`  ${formatDimText(`- ${warning.summary}`)}`);
+  }
+  return lines;
+}
+
 /**
  * Render the shared per-space execution block consumed by the `db init`
  * / `db update` / `migrate` summaries. Always shows: space
@@ -165,6 +181,10 @@ export function formatMigrationPlanOutput(
     lines.push(`${formatGreen('✔')} Planned ${operationCount} operation(s)`);
   }
 
+  if (result.warnings && result.warnings.length > 0) {
+    lines.push(...formatPlannerWarningsBlock(result.warnings, useColor));
+  }
+
   const formatYellow = createColorFormatter(useColor, yellow);
 
   // Per-space breakdown takes precedence over the flat ops tree when
@@ -427,6 +447,10 @@ export function formatMigrationApplyOutput(
       lines.push(`${formatGreen('✔')} Applied ${executed} operation(s)`);
     }
 
+    if (result.warnings && result.warnings.length > 0) {
+      lines.push(...formatPlannerWarningsBlock(result.warnings, useColor));
+    }
+
     // Per-space breakdown — replaces the single ambiguous `Signature:`
     // line with a per-space marker + ops listing.
     if (result.perSpace && result.perSpace.length > 0) {

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/legend.ts

@@ -0,0 +1,38 @@
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { type CliStructuredError, errorLegendHumanOnly } from './cli-errors';
+import type { GlobalFlags } from './global-flags';
+
+export interface LegendCliOptions {
+  readonly legend?: boolean;
+  readonly dot?: boolean;
+}
+
+/**
+ * The legend is decoration printed alongside the command header on stderr, so
+ * it is suppressed for the machine-readable / silent paths (`--json`, `--dot`,
+ * `--quiet`) exactly as the header is.
+ */
+export function shouldShowLegend(options: LegendCliOptions, flags: GlobalFlags): boolean {
+  return (
+    options.legend === true && options.dot !== true && flags.json !== true && flags.quiet !== true
+  );
+}
+
+export function validateLegendOptions(
+  options: LegendCliOptions,
+  flags: GlobalFlags,
+): Result<void, CliStructuredError> {
+  if (options.legend !== true) {
+    return ok(undefined);
+  }
+  if (flags.json === true) {
+    return notOk(errorLegendHumanOnly('--json'));
+  }
+  if (flags.quiet === true) {
+    return notOk(errorLegendHumanOnly('--quiet'));
+  }
+  if (options.dot === true) {
+    return notOk(errorLegendHumanOnly('--dot'));
+  }
+  return ok(undefined);
+}

package/src/utils/migration-path-target.ts

@@ -0,0 +1,39 @@
+import type { OnDiskMigrationPackage } from '@prisma-next/migration-tools/package';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { isAbsolute, relative, resolve } from 'pathe';
+import { type CliStructuredError, errorRuntime } from './cli-errors';
+
+export function looksLikePath(target: string): boolean {
+  return target.includes('/') || target.includes('\\');
+}
+
+export function resolveAppTargetPath(
+  target: string,
+  appMigrationsDir: string,
+  appMigrationsRelative: string,
+): Result<string, CliStructuredError> {
+  const targetPath = resolve(target);
+  const relativeToApp = relative(appMigrationsDir, targetPath);
+  const isOutsideAppDir =
+    relativeToApp === '' ||
+    relativeToApp === '.' ||
+    relativeToApp.startsWith('..') ||
+    isAbsolute(relativeToApp);
+  if (isOutsideAppDir) {
+    return notOk(
+      errorRuntime('Target must point to an app-space migration', {
+        why: `Expected a path under ${appMigrationsRelative}, got ${target}`,
+        fix: 'Pass an app-space migration directory or use a hash prefix.',
+      }),
+    );
+  }
+  return ok(targetPath);
+}
+
+export function findPackageByDirPath(
+  packages: readonly OnDiskMigrationPackage[],
+  resolvedDirPath: string,
+): OnDiskMigrationPackage | undefined {
+  const normalized = resolve(resolvedDirPath);
+  return packages.find((p) => resolve(p.dirPath) === normalized);
+}

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,
-  });
-}