@prisma-next/cli-telemetry 0.10.0 → 0.11.0

package/src/payload.ts

@@ -2,11 +2,29 @@ import { type } from 'arktype';
 
 /**
  * Wire-shape payload the parent IPC-sends to the forked child sender.
- * Mirrors the fields the parent has naturally in hand at command start
- * (installation id, sanitised command + flags, CLI version, db target,
- * extension-pack ids, project root for TS-version lookup). The child
- * fills in the rest (runtime/os/arch, package manager, ts version,
- * agent) on its side.
+ * Mirrors only the fields the parent has naturally in hand at command
+ * start: installation id, sanitised command + flags, CLI version, and
+ * the project root the child uses to discover everything else. The
+ * child probes its own process (runtime/os/arch, package manager, ts
+ * version, agent) and reads the user's `prisma-next.config.*` via
+ * c12 to derive `databaseTarget` and `extensions`.
+ *
+ * Loading c12 on the parent side would put a `loadConfig()` await on
+ * the command's hot path between gate resolution and `fork()`,
+ * opening a race against any CLI command that throws synchronously
+ * before that await resolves (the parent exits before forking the
+ * sender, and the telemetry event is lost). Moving the load into the
+ * detached child eliminates that race; the trade is that the child
+ * now evaluates user TS config code, so it's gated behind the same
+ * privacy checks the parent already resolved before forking.
+ *
+ * `databaseTarget` is an optional parent-side override for the
+ * c12-derived value: the first-`init` invocation supplies the
+ * prompt-chosen target via this field because the config file does
+ * not yet exist on disk at that moment. Every other invocation
+ * leaves it unset (`undefined`) and the child's c12 load determines
+ * the value — there is no third state, so the field's type is
+ * `string | undefined`, not `string | null | undefined`.
  *
  * Both sides version-couple on this shape because the IPC carrier is
  * structured-cloned by Node and there's no on-wire compat to maintain.
@@ -16,12 +34,26 @@ export interface ParentToSenderPayload {
   readonly version: string;
   readonly command: string;
   readonly flags: readonly string[];
-  readonly databaseTarget: string | null;
-  readonly extensions: readonly string[];
-  /** Absolute path of the user's project. The child reads `<projectRoot>/package.json` for `tsVersion`. */
+  /**
+   * Absolute path of the user's project. The child reads
+   * `<projectRoot>/package.json` for `tsVersion` and loads
+   * `<projectRoot>/prisma-next.config.*` via c12 for `databaseTarget`
+   * + `extensions`.
+   */
   readonly projectRoot: string;
   /** Resolved endpoint URL (already includes the `/events` path). */
   readonly endpoint: string;
+  /**
+   * Optional parent-side override for the c12-derived database target.
+   * Set by `fireTelemetryAfterInitConsent` (the first-`init` path,
+   * where the config file is about to be written but doesn't exist
+   * yet); left undefined by `fireTelemetryFromPreAction` (steady
+   * state, child resolves the value via c12). The wire-format
+   * `TelemetryEvent.databaseTarget: string | null` keeps `null` as
+   * the on-the-wire "no target known" marker, but the IPC override
+   * channel only needs two states so it's `string | undefined`.
+   */
+  readonly databaseTarget?: string;
 }
 
 /**
@@ -30,10 +62,11 @@ export interface ParentToSenderPayload {
  * cannot silently produce a degraded telemetry event downstream.
  *
  * Mirrors the backend's own arktype schema in spirit: required scalars
- * must be non-empty strings; `databaseTarget` is `string | null`; the
- * two string arrays are validated element-by-element. Size caps are
- * enforced by the backend, not here — IPC is structured-cloned and
- * the parent/child agree on the schema by version-coupling.
+ * must be non-empty strings; the optional `databaseTarget` override is
+ * `string` when present (no `null` — see the type's doc-block); the
+ * string array is validated element-by-element. Size caps are enforced
+ * by the backend, not here — IPC is structured-cloned and the
+ * parent/child agree on the schema by version-coupling.
  */
 const requiredString = type.string.moreThanLength(0);
 const stringArray = type.string.array();
@@ -43,10 +76,9 @@ export const parentToSenderPayloadSchema = type({
   version: requiredString,
   command: requiredString,
   flags: stringArray,
-  databaseTarget: type.string.or('null'),
-  extensions: stringArray,
   projectRoot: requiredString,
   endpoint: requiredString,
+  'databaseTarget?': type.string,
 });
 
 export function isParentToSenderPayload(value: unknown): value is ParentToSenderPayload {

package/src/sender.ts

@@ -33,7 +33,7 @@ function debugLog(message: string, error?: unknown): void {
 }
 
 async function postEvent(payload: ParentToSenderPayload): Promise<void> {
-  const event = buildTelemetryEventFromProcess(payload);
+  const event = await buildTelemetryEventFromProcess(payload);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
   try {

package/src/spawn.ts

@@ -1,5 +1,6 @@
 import { fork } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { resolveTelemetryEndpoint } from './endpoint';
 import { resolveGating } from './gating';
 import type { ParentToSenderPayload } from './payload';
@@ -8,22 +9,33 @@ import { readUserConfig, type UserConfig } from './user-config';
 
 /**
  * Inputs the CLI entry point hands the telemetry layer at command
- * start. The CLI is responsible for stitching commander's result, the
- * loaded config, and the project root together; the telemetry module
- * does no I/O of its own except for the user-config read (skipped when
- * `userConfig` is provided).
+ * start. The CLI is responsible for stitching commander's result and
+ * the project root together; the telemetry module does no I/O of its
+ * own except for the user-config read (skipped when `userConfig` is
+ * provided). `extensions` is deliberately absent: the detached child
+ * loads `prisma-next.config.*` via c12 itself and derives the
+ * extension-pack ids from the validated config — see the rationale
+ * on `ParentToSenderPayload` for why c12 lives in the child rather
+ * than on the parent's hot path.
+ *
+ * `databaseTarget` is an optional parent-side override forwarded to
+ * the child. Set by `fireTelemetryAfterInitConsent` (where the
+ * config file does not yet exist on disk); left unset by the
+ * preAction-hook path so the child's c12 load supplies the value.
  */
 export interface RunTelemetryInputs {
   /** Sanitised commander snapshot — see `CommanderResultShape`. */
   readonly command: CommanderResultShape;
   /** This CLI's own version (from its `package.json`). */
   readonly version: string;
-  /** Resolved `config.target.targetId`, or `null` when the config could not be loaded. */
-  readonly databaseTarget: string | null;
-  /** Declared extension-pack IDs, in any deterministic order. */
-  readonly extensions: readonly string[];
   /** Absolute path of the project root (typically `process.cwd()`). */
   readonly projectRoot: string;
+  /**
+   * Optional parent-side override for the c12-derived database target,
+   * forwarded verbatim to the child sender. Wins over the child's
+   * c12-derived value when present; `undefined` means "no override".
+   */
+  readonly databaseTarget?: string;
   /**
    * Path to the sender entry compiled into this package's `dist/`.
    * Resolved by the caller because the compiled sender lives at
@@ -85,10 +97,9 @@ export function runTelemetry(inputs: RunTelemetryInputs): TelemetryRunOutcome {
     version: inputs.version,
     command: sanitised.command,
     flags: sanitised.flags,
-    databaseTarget: inputs.databaseTarget,
-    extensions: inputs.extensions,
     projectRoot: inputs.projectRoot,
     endpoint: resolveTelemetryEndpoint(env),
+    ...ifDefined('databaseTarget', inputs.databaseTarget),
   };
 
   try {