@prisma-next/cli 0.12.0-dev.5 → 0.12.0-dev.50

package/src/commands/init/inputs.ts

@@ -1,9 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import * as clack from '@clack/prompts';
-import { readUserConfig, resolveGating, writeUserConfig } from '@prisma-next/cli-telemetry';
 import { extname, join, normalize } from 'pathe';
 import type { GlobalFlags } from '../../utils/global-flags';
-import { isCI } from '../../utils/is-ci';
 import {
   errorInitAuthoringSchemaPathMismatch,
   errorInitInvalidFlagValue,
@@ -71,18 +69,6 @@ export interface ResolvedInitInputs {
    * is added separately via the install step.
    */
   readonly removePreviousFacade: string | null;
-  /**
-   * Telemetry consent answer recorded during this `init` run, or `null`
-   * when no prompt was shown. The prompt fires only on the
-   * canPrompt + !autoAcceptPrompts + no env/CI opt-out +
-   * `enableTelemetry === undefined` intersection; outside that window
-   * the field is `null` and the stored preference (if any) stays
-   * unchanged. The answer has already been persisted to
-   * `$XDG_CONFIG_HOME/prisma-next/config.json` by
-   * the time `runInit` sees this value — it's surfaced here purely so
-   * the post-init summary can mention what the user chose.
-   */
-  readonly enableTelemetry: boolean | null;
   /**
    * Whether to run `npx skills add prisma/prisma-next#v<version>` at the
    * project level after install + emit. True by default; `--no-skill`
@@ -106,12 +92,6 @@ const AUTHORING_VALUES: ReadonlyMap<string, AuthoringId> = new Map([
   ['ts', 'typescript'],
 ]);
 
-export const TELEMETRY_CONSENT_MESSAGE = [
-  'Help us prioritize features by sharing anonymous CLI usage data?',
-  'The telemetry implementation is open source and fully transparent.',
-  '(packages/1-framework/3-tooling/cli-telemetry and apps/telemetry-backend).',
-].join(' ');
-
 /**
  * Resolves every required input for `runInit`. In interactive mode, missing
  * inputs are prompted via clack; in non-interactive mode, missing required
@@ -197,11 +177,6 @@ export async function resolveInitInputs(ctx: {
     autoAcceptPrompts,
   });
 
-  const enableTelemetry = await resolveTelemetryConsent({
-    canPrompt,
-    autoAcceptPrompts,
-  });
-
   // Skill-install gating. `--no-skill` (commander parses
   // `options.skill === false`) is the only escape hatch; otherwise
   // project-level install is unconditional. The skill is always
@@ -219,60 +194,10 @@ export async function resolveInitInputs(ctx: {
     strictProbe: Boolean(options.strictProbe),
     reinit,
     removePreviousFacade,
-    enableTelemetry,
     installProjectSkill,
   };
 }
 
-/**
- * The interactive telemetry consent prompt. Shown as the last
- * question of the `init` sequence iff:
- *   1. `canPrompt === true` (interactive stdin / stdout combo),
- *   2. `autoAcceptPrompts === false` (the user did not pass `--yes`),
- *   3. neither telemetry env opt-out is active,
- *   4. the process is not running in CI,
- *   5. the stored `enableTelemetry` value is `undefined` (the user
- *      has never been asked, or skipped the prompt previously).
- *
- * Outside that intersection the function returns `null` and leaves the
- * stored preference untouched. Inside it, the user's answer is
- * persisted via `writeUserConfig({ enableTelemetry })` before this
- * function returns; on an affirmative answer `writeUserConfig`
- * generates and stores the v4 `installationId` in the same write.
- *
- * The wording names CLI usage data and points to the open-source
- * client/backend paths. Default value is `true` to match precedent
- * and to make the consent answer a single keystroke once it's been
- * disclosed.
- */
-async function resolveTelemetryConsent(opts: {
-  readonly canPrompt: boolean;
-  readonly autoAcceptPrompts: boolean;
-}): Promise<boolean | null> {
-  if (!opts.canPrompt || opts.autoAcceptPrompts || isCI()) {
-    return null;
-  }
-  const config = readUserConfig();
-  const gating = resolveGating({ env: process.env, config });
-  if (!gating.enabled && gating.reason === 'env-override') {
-    return null;
-  }
-  const stored = config.enableTelemetry;
-  if (stored !== undefined) {
-    return null;
-  }
-  const result = await clack.confirm({
-    message: TELEMETRY_CONSENT_MESSAGE,
-    initialValue: true,
-    output: process.stderr,
-  });
-  if (clack.isCancel(result)) {
-    throw errorInitUserAborted();
-  }
-  writeUserConfig({ enableTelemetry: Boolean(result) });
-  return Boolean(result);
-}
-
 async function resolveWriteEnv(opts: {
   readonly flag: boolean | undefined;
   readonly canPrompt: boolean;

package/src/commands/json/schemas.ts

@@ -0,0 +1,195 @@
+import { type } from 'arktype';
+
+export const migrationEntrySchema = type({
+  name: 'string',
+  hash: 'string',
+  fromContract: 'string | null',
+  toContract: 'string',
+  operationCount: 'number',
+  createdAt: 'string',
+  refs: 'string[]',
+  providedInvariants: 'string[]',
+});
+
+export type MigrationEntry = typeof migrationEntrySchema.infer;
+
+export const contractRefSchema = type({
+  hash: 'string',
+  refs: 'string[]',
+});
+
+export type ContractRef = typeof contractRefSchema.infer;
+
+export const successEnvelopeBaseSchema = type({
+  ok: 'true',
+  summary: 'string',
+});
+
+export type SuccessEnvelopeBase = typeof successEnvelopeBaseSchema.infer;
+
+export const migrationSpaceListEntrySchema = type({
+  space: 'string',
+  migrations: migrationEntrySchema.array(),
+});
+
+export type MigrationSpaceListEntry = typeof migrationSpaceListEntrySchema.infer;
+
+export const migrationListResultSchema = successEnvelopeBaseSchema.and(
+  type({
+    spaces: migrationSpaceListEntrySchema.array(),
+  }),
+);
+
+export type MigrationListResult = typeof migrationListResultSchema.infer;
+
+export const graphMigrationSchema = type({
+  name: 'string',
+  hash: 'string',
+  fromContract: 'string | null',
+  toContract: 'string',
+});
+
+export type GraphMigration = typeof graphMigrationSchema.infer;
+
+export const migrationSpaceGraphEntrySchema = type({
+  space: 'string',
+  contracts: contractRefSchema.array(),
+  migrations: graphMigrationSchema.array(),
+});
+
+export type MigrationSpaceGraphEntry = typeof migrationSpaceGraphEntrySchema.infer;
+
+export const migrationGraphJsonResultSchema = successEnvelopeBaseSchema.and(
+  type({
+    spaces: migrationSpaceGraphEntrySchema.array(),
+  }),
+);
+
+export type MigrationGraphJsonResult = typeof migrationGraphJsonResultSchema.infer;
+
+export const migrationStatusEntrySchema = migrationEntrySchema.and(
+  type({
+    status: '"applied" | "pending" | null',
+  }),
+);
+
+export type MigrationStatusEntry = typeof migrationStatusEntrySchema.infer;
+
+const contractUnreadableDiagnosticSchema = type({
+  code: '"CONTRACT.UNREADABLE"',
+  severity: '"warn" | "info"',
+  message: 'string',
+  hints: 'string[]',
+});
+
+const markerNotInHistoryDiagnosticSchema = type({
+  code: '"MIGRATION.MARKER_NOT_IN_HISTORY"',
+  severity: '"warn" | "info"',
+  message: 'string',
+  hints: 'string[]',
+});
+
+const missingInvariantsDiagnosticSchema = type({
+  code: '"MIGRATION.MISSING_INVARIANTS"',
+  'ref?': 'string',
+  invariants: 'string[]',
+  message: 'string',
+});
+
+export const statusDiagnosticSchema = contractUnreadableDiagnosticSchema
+  .or(markerNotInHistoryDiagnosticSchema)
+  .or(missingInvariantsDiagnosticSchema);
+
+export type StatusDiagnosticJson = typeof statusDiagnosticSchema.infer;
+
+export const migrationStatusSpaceSchema = type({
+  space: 'string',
+  currentContract: 'string | null',
+  targetContract: 'string',
+  migrations: migrationStatusEntrySchema.array(),
+});
+
+export type MigrationStatusSpace = typeof migrationStatusSpaceSchema.infer;
+
+export const migrationStatusJsonResultSchema = successEnvelopeBaseSchema.and(
+  type({
+    spaces: migrationStatusSpaceSchema.array(),
+    diagnostics: statusDiagnosticSchema.array(),
+  }),
+);
+
+export type MigrationStatusResult = typeof migrationStatusJsonResultSchema.infer;
+
+export const ledgerRecordSchema = type({
+  space: 'string',
+  name: 'string',
+  hash: 'string',
+  fromContract: 'string | null',
+  toContract: 'string',
+  appliedAt: 'string',
+  operationCount: 'number',
+});
+
+export type LedgerRecord = typeof ledgerRecordSchema.infer;
+
+export const migrationLogResultSchema = successEnvelopeBaseSchema.and(
+  type({
+    records: ledgerRecordSchema.array(),
+  }),
+);
+
+export type MigrationLogResult = typeof migrationLogResultSchema.infer;
+
+export const showOperationSchema = type({
+  id: 'string',
+  label: 'string',
+  operationClass: 'string',
+});
+
+export type ShowOperation = typeof showOperationSchema.infer;
+
+export const showPreviewStatementSchema = type({
+  text: 'string',
+  language: 'string',
+});
+
+export const showMigrationSchema = type({
+  space: 'string',
+  name: 'string',
+  hash: 'string',
+  fromContract: 'string | null',
+  toContract: 'string',
+  createdAt: 'string',
+  operations: showOperationSchema.array(),
+  preview: type({
+    statements: showPreviewStatementSchema.array(),
+  }),
+});
+
+export type ShowMigration = typeof showMigrationSchema.infer;
+
+export const migrationShowResultSchema = successEnvelopeBaseSchema.and(
+  type({
+    migration: showMigrationSchema,
+  }),
+);
+
+export type MigrationShowResult = typeof migrationShowResultSchema.infer;
+
+export const checkFailureSchema = type({
+  space: 'string',
+  code: 'string',
+  where: 'string',
+  why: 'string',
+  fix: 'string',
+});
+
+export type CheckFailure = typeof checkFailureSchema.infer;
+
+export const migrationCheckResultSchema = type({
+  ok: 'boolean',
+  failures: checkFailureSchema.array(),
+  summary: 'string',
+});
+
+export type MigrationCheckResult = typeof migrationCheckResultSchema.infer;

package/src/commands/migrate.ts

@@ -11,8 +11,8 @@ import { Command } from 'commander';
 import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import type {
-  MigrationApplyFailure,
-  MigrationApplyPathDecision,
+  MigrateFailure,
+  MigratePathDecision,
   PerSpaceExecutionEntry,
 } from '../control-api/types';
 import {
@@ -76,14 +76,14 @@ export interface MigrateResult {
   }[];
   readonly summary: string;
   readonly perSpace: readonly PerSpaceExecutionEntry[];
-  readonly pathDecision?: MigrationApplyPathDecision;
+  readonly pathDecision?: MigratePathDecision;
   readonly timings: {
     readonly total: number;
   };
   readonly advancedRef?: { readonly name: string; readonly hash: string } | null;
 }
 
-function mapApplyFailure(failure: MigrationApplyFailure): CliStructuredErrorType {
+function mapApplyFailure(failure: MigrateFailure): CliStructuredErrorType {
   if (failure.code === 'MIGRATION_PATH_NOT_FOUND') {
     return errorPathUnreachable(failure);
   }
@@ -136,7 +136,7 @@ async function executeMigrateCommand(
 
   // Construct the family instance up-front so the on-disk contract read
   // crosses the serializer seam (`familyInstance.deserializeContract`) at
-  // the read site. The downstream `client.migrationApply({ contract })`
+  // the read site. The downstream `client.migrate({ contract })`
   // re-validates internally (no harm — validation is idempotent), but
   // closing the gap at the read site is what makes the cast-pattern
   // lint enforceable and matches the other CLI commands. See TML-2536.
@@ -312,7 +312,7 @@ async function executeMigrateCommand(
       }
     }
 
-    const applyResult = await client.migrationApply({
+    const applyResult = await client.migrate({
       contract: applyContract,
       migrationsDir,
       ...ifDefined('refHash', refEntry?.hash),