@prisma-next/cli 0.12.0 → 0.13.0-dev.1

package/src/commands/init/index.ts

@@ -4,8 +4,11 @@ import {
   setCommandDescriptions,
   setCommandExamples,
 } from '../../utils/command-helpers';
-import { type CommonCommandOptions, parseGlobalFlagsOrExit } from '../../utils/global-flags';
-import { fireTelemetryAfterInitConsent } from '../../utils/telemetry';
+import {
+  type CommonCommandOptions,
+  deriveCanPrompt,
+  parseGlobalFlagsOrExit,
+} from '../../utils/global-flags';
 import {
   INIT_EXIT_EMIT_FAILED,
   INIT_EXIT_INSTALL_FAILED,
@@ -93,7 +96,7 @@ export function createInitCommand(): Command {
       '--no-skill',
       'Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)',
     )
-    .action(async (options: InitCommandOptions, actionCommand: Command) => {
+    .action(async (options: InitCommandOptions) => {
       const { runInit } = await import('./init');
       const flags = parseGlobalFlagsOrExit(options);
       const canPrompt = deriveCanPrompt({
@@ -105,39 +108,7 @@ export function createInitCommand(): Command {
         options,
         flags,
         canPrompt,
-        afterFirstTelemetryConsent: (inputs) => {
-          fireTelemetryAfterInitConsent(actionCommand, { databaseTarget: inputs.target });
-        },
       });
       process.exit(exitCode);
     });
 }
-
-/**
- * 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.
- */
-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/commands/init/init.ts

@@ -113,11 +113,6 @@ export async function runInit(
      * mode) — see [Style Guide § Interactivity](../../../../../../../docs/CLI%20Style%20Guide.md#interactivity).
      */
     readonly canPrompt: boolean;
-    /**
-     * Called once after the first affirmative telemetry consent is persisted.
-     * Failures are swallowed by the caller; init success must not depend on telemetry.
-     */
-    readonly afterFirstTelemetryConsent?: (inputs: ResolvedInitInputs) => void | Promise<void>;
     /**
      * FR8.3 — test-only seam for the optional database version probe.
      * Production callers omit this; tests inject stub `probePostgres` /
@@ -129,7 +124,7 @@ export async function runInit(
     readonly probeOverrides?: ProbeOverrides;
   },
 ): Promise<number> {
-  const { options, flags, canPrompt, probeOverrides, afterFirstTelemetryConsent } = runOptions;
+  const { options, flags, canPrompt, probeOverrides } = runOptions;
   const ui = createTerminalUI(flags);
   const warnings: string[] = [];
   const filesWritten: string[] = [];
@@ -149,14 +144,6 @@ export async function runInit(
     throw error;
   }
 
-  if (inputs.enableTelemetry === true && afterFirstTelemetryConsent !== undefined) {
-    try {
-      await afterFirstTelemetryConsent(inputs);
-    } catch {
-      // telemetry is best-effort and must never affect init
-    }
-  }
-
   const pm = await detectPackageManager(baseDir);
   const pkgRun = formatRunCommand(pm, 'prisma-next', '').trimEnd();
 

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/inspect-live-schema.ts

@@ -1,3 +1,4 @@
+import type { AuthoringPslBlockDescriptorNamespace } from '@prisma-next/framework-components/authoring';
 import type { CoreSchemaView } from '@prisma-next/framework-components/control';
 import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
@@ -39,6 +40,13 @@ export interface InspectLiveSchemaResult {
    * support inference (e.g. Mongo today).
    */
   readonly pslContractAst: PslDocumentAst | undefined;
+  /**
+   * The assembled PSL block descriptors from the control stack — the full set of
+   * extension-contributed top-level block descriptors. Downstream commands pass
+   * this through to `printPsl` so contributed-block AST nodes round-trip back to
+   * source.
+   */
+  readonly pslBlockDescriptors: AuthoringPslBlockDescriptorNamespace;
   readonly target: {
     readonly familyId: string;
     readonly id: string;
@@ -134,6 +142,7 @@ export async function inspectLiveSchema(
     });
     const schemaView = client.toSchemaView(schema);
     const pslContractAst = client.inferPslContract(schema);
+    const pslBlockDescriptors = client.getPslBlockDescriptors();
 
     const dbUrl = typeof dbConnection === 'string' ? maskConnectionUrl(dbConnection) : undefined;
 
@@ -142,6 +151,7 @@ export async function inspectLiveSchema(
       schema,
       schemaView,
       pslContractAst,
+      pslBlockDescriptors,
       target: {
         familyId: config.family.familyId,
         id: config.target.targetId,

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;