prisma-next 0.10.0 → 0.11.0-dev.10

package/dist/cli.mjs

@@ -1,27 +1,397 @@
 #!/usr/bin/env node
-import { _ as parseGlobalFlags, d as setCommandDescriptions, f as setCommandExamples, t as addGlobalOptions, v as formatCommandHelp, y as formatRootHelp } from "./command-helpers-D3vL5yi8.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-C3STUIBg.mjs";
-import { n as installShutdownHandlers } from "./terminal-ui-XtOQsqe9.mjs";
-import { t as createContractInferCommand } from "./contract-infer-Cnj8G1E2.mjs";
+import { a as isCI, n as installShutdownHandlers } from "./terminal-ui-BiB_8KNo.mjs";
+import { _ as parseGlobalFlags, b as formatCommandHelp, d as setCommandDescriptions, f as setCommandExamples, t as addGlobalOptions, v as parseGlobalFlagsOrExit, x as formatRootHelp } from "./command-helpers-CRfjbZRz.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-mqXmapxB.mjs";
+import { t as createContractInferCommand } from "./contract-infer-C4jxc1aZ.mjs";
 import { createDbInitCommand } from "./commands/db-init.mjs";
 import { createDbSchemaCommand } from "./commands/db-schema.mjs";
 import { createDbSignCommand } from "./commands/db-sign.mjs";
 import { createDbUpdateCommand } from "./commands/db-update.mjs";
-import { t as createDbVerifyCommand } from "./db-verify-D7cyH_zz.mjs";
+import { t as createDbVerifyCommand } from "./db-verify-1d8tDoFN.mjs";
 import { createMigrateCommand } from "./commands/migrate.mjs";
 import { createMigrationCheckCommand } from "./commands/migration-check.mjs";
 import { createMigrationGraphCommand } from "./commands/migration-graph.mjs";
 import { createMigrationListCommand } from "./commands/migration-list.mjs";
 import { createMigrationLogCommand } from "./commands/migration-log.mjs";
 import { createMigrationNewCommand } from "./commands/migration-new.mjs";
-import { t as createMigrationPlanCommand } from "./migration-plan-CHyUlBV0.mjs";
+import { t as createMigrationPlanCommand } from "./migration-plan-jdAHg_gK.mjs";
 import { createMigrationShowCommand } from "./commands/migration-show.mjs";
 import { createMigrationStatusCommand } from "./commands/migration-status.mjs";
 import { createRefCommand } from "./commands/ref.mjs";
 import { Command } from "commander";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { DEFAULT_CONTRACT_SOURCE_DIR } from "@prisma-next/config/config-types";
+import { fileURLToPath } from "node:url";
+import { readUserConfig, resolveGating, runTelemetry } from "@prisma-next/cli-telemetry";
 import { distance } from "closest-match";
 //#region package.json
-var version = "0.10.0";
+var version = "0.11.0-dev.10";
+//#endregion
+//#region src/utils/telemetry.ts
+/**
+* Resolve the commander command path from a leaf `Command`, walking up
+* the parent chain. Result is rooted at the program name and ends at
+* the leaf — `['prisma-next', 'migration', 'new']` for
+* `prisma-next migration new …`.
+*/
+function commandPathFor(actionCommand) {
+	const path = [];
+	let cursor = actionCommand;
+	while (cursor !== null) {
+		path.unshift(cursor.name());
+		cursor = cursor.parent;
+	}
+	return path;
+}
+function commanderOptionSnapshots(actionCommand) {
+	return actionCommand.options.map((option) => {
+		const attributeName = option.attributeName();
+		return {
+			attributeName,
+			longName: option.long ?? null,
+			source: actionCommand.getOptionValueSource(attributeName) ?? null
+		};
+	});
+}
+/**
+* Project commander's leaf `Command` into the wire-shape snapshot the
+* telemetry sanitiser consumes. Pure projection — no env, no I/O.
+*/
+function commanderSnapshotForTelemetry(actionCommand) {
+	return {
+		commandPath: commandPathFor(actionCommand),
+		positionalArgs: actionCommand.args,
+		options: commanderOptionSnapshots(actionCommand)
+	};
+}
+function resolveTelemetryGate() {
+	if (isCI()) return {
+		enabled: false,
+		outcome: {
+			spawned: false,
+			reason: "ci"
+		}
+	};
+	const userConfig = readUserConfig();
+	if (!resolveGating({
+		env: process.env,
+		config: userConfig
+	}).enabled) return {
+		enabled: false,
+		outcome: {
+			spawned: false,
+			reason: "gated-off"
+		}
+	};
+	return {
+		enabled: true,
+		userConfig
+	};
+}
+/**
+* Path to the compiled sender script inside `@prisma-next/cli-telemetry`'s
+* `dist/`. Resolved off this module's `import.meta.url` via the package
+* specifier `@prisma-next/cli-telemetry/sender`, so the consumer pays
+* no attention to internal package layout.
+*/
+function senderPath() {
+	return fileURLToPath(new URL(import.meta.resolve("@prisma-next/cli-telemetry/sender")));
+}
+function fireTelemetry(actionCommand, userConfig, overrides = {}) {
+	return runTelemetry({
+		command: commanderSnapshotForTelemetry(actionCommand),
+		version,
+		projectRoot: process.cwd(),
+		senderPath: senderPath(),
+		isCI: isCI(),
+		env: process.env,
+		userConfig,
+		...ifDefined("databaseTarget", overrides.databaseTarget)
+	});
+}
+/**
+* preAction-stage entry point. Synchronous by construction: resolve
+* env/CI/user-consent gates (cheap, all in-memory and a single tiny
+* user-config read), then — only when enabled — `fork()` the detached
+* sender script. The forked child loads `prisma-next.config.*` via
+* c12 on its own (see `loadProjectConfig` in cli-telemetry); the
+* parent does no project-config I/O on the command's hot path.
+*
+* Privacy invariant: gate resolution always happens before any project
+* config touches disk. The child loading user TS code is acceptable
+* only because it's gated behind the same resolved-enabled signal.
+*/
+function fireTelemetryFromPreAction(actionCommand) {
+	const gate = resolveTelemetryGate();
+	if (!gate.enabled) return gate.outcome;
+	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.
+*/
+function fireTelemetryAfterInitConsent(actionCommand, inputs) {
+	return fireTelemetry(actionCommand, readUserConfig(), { databaseTarget: inputs.databaseTarget });
+}
+//#endregion
+//#region src/commands/init/templates/code-templates.ts
+function targetPackageName(target) {
+	return target === "postgres" ? "@prisma-next/postgres" : "@prisma-next/mongo";
+}
+function targetLabel(target) {
+	return target === "postgres" ? "PostgreSQL" : "MongoDB";
+}
+function defaultSchemaPath(authoring) {
+	if (authoring === "typescript") return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.ts`;
+	return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.prisma`;
+}
+function starterSchema(target, authoring) {
+	if (authoring === "typescript") return target === "mongo" ? starterSchemaTsMongo() : starterSchemaTsPostgres();
+	return target === "mongo" ? starterSchemaPslMongo() : starterSchemaPslPostgres();
+}
+/**
+* Renders a short authoring-appropriate schema sample (FR5.1) for embedding
+* in `prisma-next.md`. Returns a complete fenced markdown code block.
+*
+* The sample intentionally shows just one model: it's illustrative, not
+* a substitute for the full scaffolded contract file. The TS samples use
+* the same outer shape as `starterSchemaTs*` (FR5.3) so a user reading
+* the doc and the file side-by-side sees the same structure.
+*/
+function schemaSample(target, authoring) {
+	if (authoring === "typescript") return target === "mongo" ? schemaSampleTsMongo() : schemaSampleTsPostgres();
+	return target === "mongo" ? schemaSamplePslMongo() : schemaSamplePslPostgres();
+}
+function schemaSamplePslPostgres() {
+	return `\`\`\`prisma
+model User {
+  id       Int     @id @default(autoincrement())
+  email    String  @unique
+  username String?
+  name     String?
+}
+\`\`\``;
+}
+function schemaSamplePslMongo() {
+	return `\`\`\`prisma
+model User {
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
+  @@map("users")
+}
+\`\`\``;
+}
+function schemaSampleTsPostgres() {
+	return `\`\`\`typescript
+import { defineContract } from '@prisma-next/postgres/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7(),
+          email: field.text().unique(),
+          username: field.text().optional(),
+          name: field.text().optional(),
+        },
+      }),
+    },
+  }),
+);
+\`\`\``;
+}
+function schemaSampleTsMongo() {
+	return `\`\`\`typescript
+import { defineContract } from '@prisma-next/mongo/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model }) => ({
+    models: {
+      User: model('User', {
+        collection: 'users',
+        fields: {
+          _id: field.objectId(),
+          email: field.string(),
+          username: field.string().optional(),
+          name: field.string().optional(),
+        },
+      }),
+    },
+  }),
+);
+\`\`\``;
+}
+function starterSchemaPslPostgres() {
+	return `// use prisma-next
+
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  username  String?
+  name      String?
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt temporal.updatedAt()
+}
+
+model Post {
+  id        Int      @id @default(autoincrement())
+  title     String
+  content   String?
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  Int
+  createdAt DateTime @default(now())
+  updatedAt temporal.updatedAt()
+}
+`;
+}
+function starterSchemaPslMongo() {
+	return `// use prisma-next
+
+model User {
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
+  posts    Post[]
+  @@map("users")
+}
+
+model Post {
+  id       ObjectId @id @map("_id")
+  title    String
+  content  String?
+  author   User     @relation(fields: [authorId], references: [id])
+  authorId ObjectId
+  @@map("posts")
+}
+`;
+}
+function starterSchemaTsPostgres() {
+	return `import { defineContract } from '@prisma-next/postgres/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model, rel }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7(),
+          email: field.text().unique(),
+          username: field.text().optional(),
+          name: field.text().optional(),
+          createdAt: field.temporal.createdAt(),
+          updatedAt: field.temporal.updatedAt(),
+        },
+        relations: {
+          posts: rel.hasMany('Post', { by: 'authorId' }),
+        },
+      }),
+
+      Post: model('Post', {
+        fields: {
+          id: field.id.uuidv7(),
+          title: field.text(),
+          content: field.text().optional(),
+          authorId: field.uuid(),
+          createdAt: field.temporal.createdAt(),
+          updatedAt: field.temporal.updatedAt(),
+        },
+        relations: {
+          author: rel.belongsTo('User', { from: 'authorId', to: 'id' }),
+        },
+      }),
+    },
+  }),
+);
+`;
+}
+function starterSchemaTsMongo() {
+	return `import { defineContract } from '@prisma-next/mongo/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model, rel }) => ({
+    models: {
+      User: model('User', {
+        collection: 'users',
+        fields: {
+          _id: field.objectId(),
+          email: field.string(),
+          username: field.string().optional(),
+          name: field.string().optional(),
+        },
+        relations: {
+          posts: rel.hasMany('Post', { from: '_id', to: 'authorId' }),
+        },
+      }),
+
+      Post: model('Post', {
+        collection: 'posts',
+        fields: {
+          _id: field.objectId(),
+          title: field.string(),
+          content: field.string().optional(),
+          authorId: field.objectId(),
+        },
+        relations: {
+          author: rel.belongsTo('User', { from: 'authorId', to: '_id' }),
+        },
+      }),
+    },
+  }),
+);
+`;
+}
+function configFile(target, contractPath) {
+	return `import 'dotenv/config';
+import { defineConfig } from '${targetPackageName(target)}/config';
+
+export default defineConfig({
+  contract: ${JSON.stringify(contractPath)},
+  db: {
+    connection: process.env['DATABASE_URL']!,
+  },
+});
+`;
+}
+function dbFile(target) {
+	if (target === "postgres") return `import postgres from '@prisma-next/postgres/runtime';
+import type { Contract } from './contract.d';
+import contractJson from './contract.json' with { type: 'json' };
+
+export const db = postgres<Contract>({
+  contractJson,
+  url: process.env['DATABASE_URL']!,
+});
+`;
+	return `import mongo from '@prisma-next/mongo/runtime';
+import type { Contract } from './contract.d';
+import contractJson from './contract.json' with { type: 'json' };
+
+export const db = mongo<Contract>({
+  contractJson,
+  url: process.env['DATABASE_URL']!,
+});
+`;
+}
 //#endregion
 //#region src/commands/init/index.ts
 function createInitCommand() {
@@ -40,11 +410,11 @@ Exit codes (see CLI Style Guide § Exit Codes):
 		"prisma-next init --yes --target mongodb --authoring typescript --json",
 		"prisma-next init --yes --force --target postgres --authoring psl  # overwrite an existing scaffold",
 		"prisma-next init --no-install                                       # skip pnpm/npm install + emit",
-		"prisma-next init --no-skill                                         # skip the agent-skill install (air-gapped / restricted env)"
+		"prisma-next init --no-skill                                         # skip the skills install (air-gapped / restricted env)"
 	]);
-	return addGlobalOptions(command).option("--target <db>", "Database target: postgres or mongodb").option("--authoring <style>", "Schema authoring style: psl or typescript").option("--schema-path <path>", "Where to write the starter schema (default: prisma/contract.prisma)").option("--force", "Overwrite an existing scaffold without prompting").option("--write-env", "Write a .env file from .env.example (gitignored; default: only .env.example)").option("--probe-db", "Connect to DATABASE_URL once and check the server version against the target minimum (opt-in; off by default)").option("--strict-probe", "Treat a failed --probe-db as fatal (no-op without --probe-db; init is offline-by-default)").option("--no-install", "Skip dependency installation and contract emission").option("--no-skill", "Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)").action(async (options) => {
-		const { runInit } = await import("./init-eh2z5Tl6.mjs");
-		const flags = parseGlobalFlags(options);
+	return addGlobalOptions(command).option("--target <db>", "Database target: postgres or mongodb").option("--authoring <style>", "Schema authoring style: psl or typescript").option("--schema-path <path>", `Where to write the starter schema (default: ${defaultSchemaPath("psl")})`).option("--force", "Overwrite an existing scaffold without prompting").option("--write-env", "Write a .env file from .env.example (gitignored; default: only .env.example)").option("--probe-db", "Connect to DATABASE_URL once and check the server version against the target minimum (opt-in; off by default)").option("--strict-probe", "Treat a failed --probe-db as fatal (no-op without --probe-db; init is offline-by-default)").option("--no-install", "Skip dependency installation and contract emission").option("--no-skill", "Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)").action(async (options, actionCommand) => {
+		const { runInit } = await import("./init-ByoeQphC.mjs");
+		const flags = parseGlobalFlagsOrExit(options);
 		const canPrompt = deriveCanPrompt({
 			flagsInteractive: flags.interactive,
 			optionInteractive: options.interactive,
@@ -53,7 +423,10 @@ Exit codes (see CLI Style Guide § Exit Codes):
 		const exitCode = await runInit(process.cwd(), {
 			options,
 			flags,
-			canPrompt
+			canPrompt,
+			afterFirstTelemetryConsent: (inputs) => {
+				fireTelemetryAfterInitConsent(actionCommand, { databaseTarget: inputs.target });
+			}
 		});
 		process.exit(exitCode);
 	});
@@ -137,6 +510,11 @@ function formatSuggestion(input, candidates) {
 }
 const program = new Command();
 program.name("prisma-next").description("Prisma Next CLI").version(version);
+program.hook("preAction", (_thisCommand, actionCommand) => {
+	try {
+		fireTelemetryFromPreAction(actionCommand);
+	} catch {}
+});
 const versionOption = program.options.find((opt) => opt.flags.includes("--version"));
 if (versionOption) versionOption.description = "Output the version number";
 program.configureOutput({
@@ -272,6 +650,15 @@ program.addCommand(contractCommand);
 program.addCommand(dbCommand);
 program.addCommand(migrationCommand);
 program.addCommand(refCommand);
+const TELEMETRY_CRASH_TEST_SLEEP_MS = 200;
+if (process.env["PRISMA_NEXT_ENABLE_TEST_COMMANDS"] === "1") {
+	const telemetryCrashTestCommand = new Command("__telemetry-crash-test").description("Internal: deliberately throw for the telemetry e2e suite.").action(async () => {
+		await new Promise((settle) => setTimeout(settle, TELEMETRY_CRASH_TEST_SLEEP_MS));
+		throw new Error("__telemetry-crash-test: intentional crash for e2e coverage");
+	});
+	telemetryCrashTestCommand.configureHelp({ visibleCommands: () => [] });
+	program.addCommand(telemetryCrashTestCommand, { hidden: true });
+}
 const helpCommand = new Command("help").description("Show usage instructions").configureHelp({ formatHelp: (cmd) => {
 	return formatCommandHelp({
 		command: cmd,
@@ -342,6 +729,6 @@ if (args.length > 0) {
 }
 program.parse();
 //#endregion
-export { version as t };
+export { starterSchema as a, version as c, schemaSample as i, dbFile as n, targetLabel as o, defaultSchemaPath as r, targetPackageName as s, configFile as t };
 
 //# sourceMappingURL=cli.mjs.map