create-prisma 0.4.2-pr.39.99.1 → 0.4.2-pr.40.103.1

package/README.md

@@ -11,13 +11,13 @@ Scaffold a new app with Prisma Next already wired up.
 - runs `prisma-next init --no-install` to scaffold `prisma/contract.*`, `prisma-next.config.ts`, `prisma/db.ts`, `prisma-next.md`, and `.env.example`
 - writes a template-specific Prisma Next runtime helper
 - adds `contract:emit`, `db:init`, `db:update`, `db:verify`, `db:seed`, `migration:plan`, `migrate`, `migration:status`, and `migration:show` scripts
-- adds `db:up` / `db:down` / `db:reset` plus `scripts/mongo.mjs` when you opt into local MongoDB (`mongodb-memory-server`, each project gets its own port)
+- adds `db:up` / `db:down` and `docker-compose.yml` for default MongoDB projects
 - creates or updates `.env` with `DATABASE_URL`
 - can install dependencies and run `prisma-next contract emit`
 
 `db:init`, migrations, and seeding are never run automatically. PostgreSQL projects show
 `db:init` as a manual follow-up command; MongoDB projects show `db:up` plus the migration
-plan/apply path for initial schema setup. The generated `README.md` has a numbered `## Getting Started` section that lists the exact commands to run.
+plan/apply path for initial schema setup.
 
 ## Quick Start
 
@@ -93,6 +93,18 @@ Use Prisma Postgres auto-provisioning:
 create-prisma --name my-app --template nest --provider postgres --prisma-postgres
 ```
 
+Target a specific Prisma Next release (useful for regression / bisect work):
+
+```bash
+create-prisma --name my-app --template hono --prisma-next-version 0.10.0
+```
+
+Scaffold against an open PR via pkg.pr.new:
+
+```bash
+create-prisma --name my-app --template hono --prisma-next-version pkg-pr-new:bad6795
+```
+
 ## Supported Templates
 
 - `minimal` - script-first Prisma Next starter with no web framework
@@ -130,7 +142,10 @@ create-prisma --name my-app --template nest --provider postgres --prisma-postgre
 - `--no-install` scaffold only
 - `--no-emit` skip `prisma-next contract emit`
 - `--prisma-postgres` provision Prisma Postgres for PostgreSQL
-- `--local-mongo` scaffold the local `mongodb-memory-server` helper for MongoDB (default with `--yes`; pass `--no-local-mongo` to opt out)
+- `--prisma-next-version <spec>` target a specific Prisma Next release, npm dist-tag, or
+  pkg.pr.new PR preview. Accepts a published version (`0.10.0`, `0.11.0-dev.9`),
+  an npm dist-tag (`latest` (default), `dev`, `next`, …), or `pkg-pr-new:<sha|branch|pr-number>`
+  to install from `https://pkg.pr.new/prisma/prisma-next/<package>@<ref>`.
 - `--force` allow scaffolding into a non-empty directory
 - `--verbose` print full command output
 

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./create-BOeaiXBK.mjs";
+import "./create-CHVnIodq.mjs";
 import { createCreatePrismaCli } from "./index.mjs";
 
 //#region src/cli.ts

package/dist/{create-BOeaiXBK.mjs → create-CHVnIodq.mjs}

@@ -12,6 +12,88 @@ import { z } from "zod";
 import { execa } from "execa";
 import { styleText } from "node:util";
 
+//#region src/utils/runtime.ts
+function usesNodeStyleRuntime(packageManager) {
+	return packageManager !== void 0 && packageManager !== "bun" && packageManager !== "deno";
+}
+function requiresDotenvConfigImport(packageManager) {
+	return usesNodeStyleRuntime(packageManager);
+}
+
+//#endregion
+//#region src/constants/dependencies.ts
+const dependencyVersionMap = {
+	"@elysiajs/node": "^1.4.5",
+	"@types/node": "^25.6.2",
+	dotenv: "^17.4.2",
+	"mongodb-memory-server": "^11.1.0",
+	tsx: "^4.21.0"
+};
+const PRISMA_NEXT_DEFAULT_VERSION = "latest";
+const PKG_PR_NEW_PREFIX = "pkg-pr-new:";
+const PKG_PR_NEW_BASE_URL = "https://pkg.pr.new/prisma/prisma-next";
+const DEFAULT_PRISMA_NEXT_SPEC = {
+	kind: "npm",
+	spec: PRISMA_NEXT_DEFAULT_VERSION
+};
+function parsePrismaNextVersionSpec(input) {
+	if (input === void 0) return DEFAULT_PRISMA_NEXT_SPEC;
+	const trimmed = input.trim();
+	if (trimmed.length === 0) return DEFAULT_PRISMA_NEXT_SPEC;
+	if (trimmed.startsWith(PKG_PR_NEW_PREFIX)) {
+		const ref = trimmed.slice(11).trim();
+		if (ref.length === 0) throw new Error(`Invalid --prisma-next-version value: '${input}'. Expected 'pkg-pr-new:<sha|branch|pr-number>'.`);
+		return {
+			kind: "pkg-pr-new",
+			ref
+		};
+	}
+	return {
+		kind: "npm",
+		spec: trimmed
+	};
+}
+function isPrismaNextPackage(packageName) {
+	return packageName === "prisma-next" || packageName.startsWith("@prisma-next/");
+}
+function getPrismaNextPackageSpecifier(packageName, spec = DEFAULT_PRISMA_NEXT_SPEC) {
+	if (spec.kind === "pkg-pr-new") return `${PKG_PR_NEW_BASE_URL}/${packageName}@${spec.ref}`;
+	return `${packageName}@${spec.spec}`;
+}
+function getDependencyVersion(packageName, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	if (isPrismaNextPackage(packageName)) {
+		if (prismaNextSpec.kind === "pkg-pr-new") return `${PKG_PR_NEW_BASE_URL}/${packageName}@${prismaNextSpec.ref}`;
+		return prismaNextSpec.spec;
+	}
+	return dependencyVersionMap[packageName];
+}
+function usesViteDevServer(template) {
+	return template === "astro" || template === "nuxt" || template === "svelte" || template === "tanstack-start";
+}
+function getCreateTemplateDependencies(template, packageManager) {
+	const targets = [];
+	if (usesViteDevServer(template)) targets.push({
+		packageJsonPath: "package.json",
+		dependencies: [],
+		devDependencies: ["@prisma-next/vite-plugin-contract-emit"]
+	});
+	if (template === "minimal" || template === "hono" || template === "elysia" || template === "nest") {
+		const runtimeDevDependencies = usesNodeStyleRuntime(packageManager) ? ["tsx"] : [];
+		if (template === "elysia" && packageManager !== "deno") targets.push({
+			packageJsonPath: "package.json",
+			dependencies: ["@elysiajs/node"],
+			devDependencies: ["@types/node", ...runtimeDevDependencies]
+		});
+		else if (runtimeDevDependencies.length > 0) targets.push({
+			packageJsonPath: "package.json",
+			dependencies: [],
+			devDependencies: runtimeDevDependencies
+		});
+	}
+	return targets;
+}
+
+//#endregion
 //#region src/telemetry/client.ts
 const TELEMETRY_API_KEY = "";
 const TELEMETRY_HOST = "https://us.i.posthog.com";
@@ -40,7 +122,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.4.2-pr.39.99.1",
+		"cli-version": "0.4.2-pr.40.103.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -78,6 +160,16 @@ async function trackCliTelemetry(event, properties) {
 
 //#endregion
 //#region src/telemetry/create.ts
+function classifyPrismaNextSpec(spec) {
+	if (!spec || spec === DEFAULT_PRISMA_NEXT_SPEC) return "default";
+	if (spec.kind === "pkg-pr-new") return "pkg-pr-new";
+	if (spec.spec === PRISMA_NEXT_DEFAULT_VERSION) return "default";
+	return /^[0-9]/.test(spec.spec) ? "npm-version" : "npm-tag";
+}
+function getPrismaNextVersionSpecString(spec) {
+	if (!spec) return null;
+	return spec.kind === "pkg-pr-new" ? `pkg-pr-new:${spec.ref}` : spec.spec;
+}
 const CREATE_PRISMA_NEXT_COMPLETED_EVENT = "cli:create_prisma_next_command_completed";
 const CREATE_PRISMA_NEXT_FAILED_EVENT = "cli:create_prisma_next_command_failed";
 function getTargetDirectoryState(context) {
@@ -86,6 +178,7 @@ function getTargetDirectoryState(context) {
 	return "non_empty_directory";
 }
 function getBaseCreateProperties(input, context) {
+	const resolvedPrismaNextSpec = context?.prismaSetupContext.prismaNextSpec;
 	return {
 		command: "create",
 		"uses-defaults": input.yes === true,
@@ -98,7 +191,9 @@ function getBaseCreateProperties(input, context) {
 		"should-install": context?.prismaSetupContext.shouldInstall ?? input.install ?? null,
 		"should-emit": context?.prismaSetupContext.shouldEmit ?? input.emit ?? null,
 		"uses-prisma-postgres": context?.prismaSetupContext.shouldUsePrismaPostgres ?? input.prismaPostgres ?? null,
-		"target-directory-state": context ? getTargetDirectoryState(context) : null
+		"target-directory-state": context ? getTargetDirectoryState(context) : null,
+		"prisma-next-version-kind": classifyPrismaNextSpec(resolvedPrismaNextSpec),
+		"prisma-next-version-spec": getPrismaNextVersionSpecString(resolvedPrismaNextSpec) ?? input.prismaNextVersion ?? null
 	};
 }
 function getErrorName(error) {
@@ -174,10 +269,10 @@ const PrismaSetupOptionsSchema = z.object({
 	authoring: AuthoringStyleSchema.optional().describe("Contract authoring style"),
 	packageManager: PackageManagerSchema.optional().describe("Package manager used for dependency installation"),
 	prismaPostgres: z.boolean().optional().describe("Provision Prisma Postgres with create-db when target is postgres"),
-	localMongo: z.boolean().optional().describe("Scaffold an in-memory MongoDB replica set (mongodb-memory-server) when target is mongo"),
 	databaseUrl: DatabaseUrlSchema.optional().describe("DATABASE_URL value"),
 	install: z.boolean().optional().describe("Install dependencies with selected package manager"),
-	emit: z.boolean().optional().describe("Emit Prisma Next contract artifacts after scaffolding")
+	emit: z.boolean().optional().describe("Emit Prisma Next contract artifacts after scaffolding"),
+	prismaNextVersion: z.string().trim().min(1).optional().describe("Prisma Next version, npm dist-tag, or 'pkg-pr-new:<sha|branch|pr>' (default: latest)")
 });
 const PrismaSetupCommandInputSchema = CommonCommandOptionsSchema.extend(PrismaSetupOptionsSchema.shape);
 const CreateScaffoldOptionsSchema = z.object({
@@ -419,15 +514,6 @@ function getLocalPackageBinaryCommand(packageManager, binaryName, binaryArgs) {
 	return [execution.command, ...execution.args].join(" ");
 }
 
-//#endregion
-//#region src/utils/runtime.ts
-function usesNodeStyleRuntime(packageManager) {
-	return packageManager !== void 0 && packageManager !== "bun" && packageManager !== "deno";
-}
-function requiresDotenvConfigImport(packageManager) {
-	return usesNodeStyleRuntime(packageManager);
-}
-
 //#endregion
 //#region src/templates/shared.ts
 function getOptionalHashString(hash, key) {
@@ -513,21 +599,20 @@ function getCreateTemplateDir(template) {
 function getCreateSharedTemplateDir() {
 	return resolveTemplatesDir("templates/create/_shared");
 }
-function createTemplateContext(projectName, template, provider, authoring, packageManager, useLocalMongo) {
+function createTemplateContext(projectName, template, provider, authoring, packageManager) {
 	return {
 		projectName,
 		template,
 		provider,
 		authoring,
-		packageManager,
-		useLocalMongo
+		packageManager
 	};
 }
 async function scaffoldCreateTemplate(opts) {
-	const { projectDir, projectName, template, provider, authoring, packageManager, useLocalMongo } = opts;
+	const { projectDir, projectName, template, provider, authoring, packageManager } = opts;
 	const templateRoot = getCreateTemplateDir(template);
 	const sharedTemplateRoot = getCreateSharedTemplateDir();
-	const context = createTemplateContext(projectName, template, provider, authoring, packageManager, useLocalMongo);
+	const context = createTemplateContext(projectName, template, provider, authoring, packageManager);
 	await renderTemplateTree({
 		templateRoot: sharedTemplateRoot,
 		outputDir: projectDir,
@@ -540,52 +625,6 @@ async function scaffoldCreateTemplate(opts) {
 	});
 }
 
-//#endregion
-//#region src/constants/dependencies.ts
-const dependencyVersionMap = {
-	"@elysiajs/node": "^1.4.5",
-	"@types/node": "^25.6.2",
-	dotenv: "^17.4.2",
-	"mongodb-memory-server": "^11.1.0",
-	tsx: "^4.21.0"
-};
-const PRISMA_NEXT_PACKAGE_VERSION = "latest";
-function isPrismaNextPackage(packageName) {
-	return packageName === "prisma-next" || packageName.startsWith("@prisma-next/");
-}
-function getPrismaNextPackageSpecifier(packageName) {
-	return `${packageName}@${PRISMA_NEXT_PACKAGE_VERSION}`;
-}
-function getDependencyVersion(packageName) {
-	if (isPrismaNextPackage(packageName)) return PRISMA_NEXT_PACKAGE_VERSION;
-	return dependencyVersionMap[packageName];
-}
-function usesViteDevServer(template) {
-	return template === "astro" || template === "nuxt" || template === "svelte" || template === "tanstack-start";
-}
-function getCreateTemplateDependencies(template, packageManager) {
-	const targets = [];
-	if (usesViteDevServer(template)) targets.push({
-		packageJsonPath: "package.json",
-		dependencies: [],
-		devDependencies: ["@prisma-next/vite-plugin-contract-emit"]
-	});
-	if (template === "minimal" || template === "hono" || template === "elysia" || template === "nest") {
-		const runtimeDevDependencies = usesNodeStyleRuntime(packageManager) ? ["tsx"] : [];
-		if (template === "elysia" && packageManager !== "deno") targets.push({
-			packageJsonPath: "package.json",
-			dependencies: ["@elysiajs/node"],
-			devDependencies: ["@types/node", ...runtimeDevDependencies]
-		});
-		else if (runtimeDevDependencies.length > 0) targets.push({
-			packageJsonPath: "package.json",
-			dependencies: [],
-			devDependencies: runtimeDevDependencies
-		});
-	}
-	return targets;
-}
-
 //#endregion
 //#region src/constants/db-packages.ts
 function getDbPackages(provider, _packageManager) {
@@ -683,7 +722,7 @@ function getOrmTypePackages(provider) {
 	return ["@prisma-next/sql-orm-client"];
 }
 async function addPackageDependency(opts) {
-	const { dependencies = [], devDependencies = [], customDependencies = {}, scripts = {}, scriptMode, projectDir } = opts;
+	const { dependencies = [], devDependencies = [], customDependencies = {}, scripts = {}, scriptMode, projectDir, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC } = opts;
 	const pkgJsonPath = path.join(projectDir, "package.json");
 	if (!await fs.pathExists(pkgJsonPath)) throw new Error(`No package.json found in ${projectDir}. Run this command inside an existing JavaScript/TypeScript project.`);
 	const pkgJson = await fs.readJson(pkgJsonPath);
@@ -691,12 +730,12 @@ async function addPackageDependency(opts) {
 	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
 	if (!pkgJson.scripts) pkgJson.scripts = {};
 	for (const pkgName of unique(dependencies)) {
-		const version = getDependencyVersion(pkgName);
+		const version = getDependencyVersion(pkgName, prismaNextSpec);
 		if (version) pkgJson.dependencies[pkgName] = version;
 		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
 	}
 	for (const pkgName of unique(devDependencies)) {
-		const version = getDependencyVersion(pkgName);
+		const version = getDependencyVersion(pkgName, prismaNextSpec);
 		if (version) pkgJson.devDependencies[pkgName] = version;
 		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
 	}
@@ -712,7 +751,7 @@ async function addPackageDependency(opts) {
 	pkgJson.devDependencies = sortRecord(pkgJson.devDependencies);
 	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 }
-async function writePrismaDependencies(provider, packageManager, authoring, projectDir = process.cwd()) {
+async function writePrismaDependencies(provider, packageManager, authoring, projectDir = process.cwd(), prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
 	const dependencies = [getDbPackages(provider, packageManager), "dotenv"];
 	const devDependencies = [
 		"prisma-next",
@@ -727,11 +766,12 @@ async function writePrismaDependencies(provider, packageManager, authoring, proj
 		dependencies,
 		devDependencies,
 		scripts: getPrismaNextScriptMap(packageManager),
-		projectDir
+		projectDir,
+		prismaNextSpec
 	});
 }
 async function writeCreateTemplateDependencies(opts) {
-	const { template, packageManager, projectDir = process.cwd() } = opts;
+	const { template, packageManager, projectDir = process.cwd(), prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC } = opts;
 	const targets = getCreateTemplateDependencies(template, packageManager);
 	for (const dependencyTarget of targets) {
 		const targetDirectory = path.join(projectDir, path.dirname(dependencyTarget.packageJsonPath));
@@ -739,7 +779,8 @@ async function writeCreateTemplateDependencies(opts) {
 			dependencies: dependencyTarget.dependencies,
 			devDependencies: dependencyTarget.devDependencies,
 			customDependencies: dependencyTarget.customDependencies,
-			projectDir: targetDirectory
+			projectDir: targetDirectory,
+			prismaNextSpec
 		});
 	}
 }
@@ -817,10 +858,6 @@ const DEFAULT_INSTALL = true;
 const DEFAULT_EMIT = true;
 const DEFAULT_INTERACTIVE_PRISMA_POSTGRES = true;
 const DEFAULT_AUTOMATED_PRISMA_POSTGRES = false;
-const DEFAULT_INTERACTIVE_LOCAL_MONGO = true;
-const DEFAULT_AUTOMATED_LOCAL_MONGO = true;
-const LOCAL_MONGO_PORT_BASE = 27018;
-const LOCAL_MONGO_PORT_RANGE = 1e3;
 const MONGO_MEMORY_SERVER_SCRIPT = `import { spawn } from "node:child_process";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
@@ -877,8 +914,7 @@ function getChildCommand() {
 async function runServer() {
   mkdirSync(dbPath, { recursive: true });
   const config = getMongoConfig();
-  const specifier = process.versions.deno ? "npm:mongodb-memory-server" : "mongodb-memory-server";
-  const memoryServer = await import(specifier);
+  const memoryServer = await import("mongodb-memory-server");
   const { MongoMemoryReplSet } = memoryServer.default ?? memoryServer;
   const replSet = await MongoMemoryReplSet.create({
     replSet: { name: config.replSetName, count: 1 },
@@ -892,8 +928,6 @@ async function runServer() {
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  // Keep the event loop alive: Deno doesn't ref signal listeners.
-  await new Promise(() => {});
 }
 
 async function up() {
@@ -1085,19 +1119,6 @@ async function promptForPrismaPostgres() {
 	}
 	return Boolean(shouldUsePrismaPostgres);
 }
-async function promptForLocalMongo() {
-	const useLocalMongo = await confirm({
-		message: "Run a local MongoDB for development?",
-		active: "Yes, start an in-memory replica set with mongodb-memory-server",
-		inactive: "No, I'll set DATABASE_URL myself",
-		initialValue: DEFAULT_INTERACTIVE_LOCAL_MONGO
-	});
-	if (isCancel(useLocalMongo)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return Boolean(useLocalMongo);
-}
 function getPackageManagerHint(option, detected) {
 	const hint = {
 		npm: "Node.js default",
@@ -1171,29 +1192,26 @@ async function collectPrismaSetupContext(input, options = {}) {
 	const useDefaults = input.yes === true;
 	const verbose = input.verbose === true;
 	const shouldEmit = input.emit ?? DEFAULT_EMIT;
+	let prismaNextSpec;
+	try {
+		prismaNextSpec = parsePrismaNextVersionSpec(input.prismaNextVersion);
+	} catch (error) {
+		cancel(error instanceof Error ? error.message : String(error));
+		return;
+	}
 	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
 	if (!databaseProvider) return;
 	const databaseUrl = input.databaseUrl;
-	if (input.prismaPostgres === true && databaseProvider !== "postgres") {
+	const shouldUsePrismaPostgres = input.prismaPostgres ?? (databaseProvider === "postgres" && !databaseUrl && !useDefaults ? await promptForPrismaPostgres() : DEFAULT_AUTOMATED_PRISMA_POSTGRES);
+	if (shouldUsePrismaPostgres === void 0) return;
+	if (shouldUsePrismaPostgres && databaseProvider !== "postgres") {
 		cancel("--prisma-postgres is only supported with --provider postgres.");
 		return;
 	}
-	if (input.localMongo === true && databaseProvider !== "mongo") {
-		cancel("--local-mongo is only supported with --provider mongo.");
-		return;
-	}
-	if (input.prismaPostgres === true && databaseUrl) {
+	if (shouldUsePrismaPostgres && databaseUrl) {
 		cancel("Use either --database-url or --prisma-postgres, not both.");
 		return;
 	}
-	if (input.localMongo === true && databaseUrl) {
-		cancel("Use either --database-url or --local-mongo, not both.");
-		return;
-	}
-	const shouldUsePrismaPostgres = databaseProvider === "postgres" && !databaseUrl ? input.prismaPostgres ?? (useDefaults ? DEFAULT_AUTOMATED_PRISMA_POSTGRES : await promptForPrismaPostgres()) : false;
-	if (shouldUsePrismaPostgres === void 0) return;
-	const useLocalMongo = databaseProvider === "mongo" && !databaseUrl ? input.localMongo ?? (useDefaults ? DEFAULT_AUTOMATED_LOCAL_MONGO : await promptForLocalMongo()) : false;
-	if (useLocalMongo === void 0) return;
 	const authoring = input.authoring ?? (useDefaults ? DEFAULT_AUTHORING : await promptForAuthoringStyle());
 	if (!authoring) return;
 	const detectedPackageManager = await detectPackageManager(projectDir);
@@ -1209,26 +1227,15 @@ async function collectPrismaSetupContext(input, options = {}) {
 		authoring,
 		databaseUrl,
 		shouldUsePrismaPostgres,
-		useLocalMongo,
 		packageManager,
-		shouldInstall
+		shouldInstall,
+		prismaNextSpec
 	};
 }
-function hashStringToOffset(value, range) {
-	let hash = 0;
-	for (let i = 0; i < value.length; i++) hash = hash * 31 + value.charCodeAt(i) | 0;
-	return Math.abs(hash) % range;
-}
-function sanitizeMongoDbName(value) {
-	return value.toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "app";
-}
-function getLocalMongoDatabaseUrl(projectName) {
-	return `mongodb://localhost:${LOCAL_MONGO_PORT_BASE + hashStringToOffset(projectName, LOCAL_MONGO_PORT_RANGE)}/${sanitizeMongoDbName(projectName)}?replicaSet=rs0&directConnection=true`;
-}
-function getDefaultDatabaseUrl(provider, opts) {
+function getDefaultDatabaseUrl(provider) {
 	switch (provider) {
 		case "postgres": return "postgresql://user:password@localhost:5432/mydb";
-		case "mongo": return opts.useLocalMongo ? getLocalMongoDatabaseUrl(opts.projectName) : "mongodb://user:password@localhost:27017/mydb?replicaSet=rs0&directConnection=true";
+		case "mongo": return "mongodb://localhost:27017/mydb?replicaSet=rs0&directConnection=true";
 		default: {
 			const exhaustiveCheck = provider;
 			throw new Error(`Unsupported Prisma Next target: ${String(exhaustiveCheck)}`);
@@ -1331,7 +1338,7 @@ async function ensureMongoMemoryServerDevDependency(projectDir) {
 	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 }
 async function writeMongoLocalHelpersForContext(context, projectDir) {
-	if (!context.useLocalMongo) return true;
+	if (context.databaseProvider !== "mongo" || context.databaseUrl) return true;
 	try {
 		await ensureMongoMemoryServerScript(projectDir);
 		await ensureMongoMemoryServerDevDependency(projectDir);
@@ -1361,10 +1368,7 @@ async function ensureRequiredPrismaFiles(projectDir) {
 async function finalizePrismaFiles(options) {
 	const projectDir = options.projectDir ?? process.cwd();
 	await ensureRequiredPrismaFiles(projectDir);
-	await ensureEnvVarInEnv(projectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider, {
-		projectName: path.basename(projectDir),
-		useLocalMongo: options.useLocalMongo
-	}), {
+	await ensureEnvVarInEnv(projectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider), {
 		mode: options.databaseUrl ? "upsert" : "keep-existing",
 		comment: "Added by create-prisma"
 	});
@@ -1398,37 +1402,37 @@ async function provisionPrismaPostgresIfNeeded(context, projectDir) {
 }
 async function writeDependenciesForContext(context, projectDir) {
 	try {
-		await writePrismaDependencies(context.databaseProvider, context.packageManager, context.authoring, projectDir);
+		await writePrismaDependencies(context.databaseProvider, context.packageManager, context.authoring, projectDir, context.prismaNextSpec);
 		return true;
 	} catch (error) {
 		cancel(getCommandErrorMessage(error));
 		return false;
 	}
 }
-function getPrismaNextCliPackageSpecifier() {
-	return getPrismaNextPackageSpecifier("prisma-next");
+function getPrismaNextCliPackageSpecifier(prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	return getPrismaNextPackageSpecifier("prisma-next", prismaNextSpec);
 }
 function getPrismaNextInitTarget(provider) {
 	return provider === "mongo" ? "mongodb" : "postgres";
 }
-function getPrismaNextInitCliArgs(packageManager, prismaNextArgs) {
+function getPrismaNextInitCliArgs(packageManager, prismaNextArgs, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
 	if (packageManager === "npm") return {
 		command: "npx",
 		args: [
 			"--yes",
-			getPrismaNextCliPackageSpecifier(),
+			getPrismaNextCliPackageSpecifier(prismaNextSpec),
 			"init",
 			...prismaNextArgs
 		]
 	};
 	return getPackageExecutionArgs(packageManager, [
-		getPrismaNextCliPackageSpecifier(),
+		getPrismaNextCliPackageSpecifier(prismaNextSpec),
 		"init",
 		...prismaNextArgs
 	]);
 }
-function getPrismaNextInitCliCommand(packageManager, prismaNextArgs) {
-	const execution = getPrismaNextInitCliArgs(packageManager, prismaNextArgs);
+function getPrismaNextInitCliCommand(packageManager, prismaNextArgs, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	const execution = getPrismaNextInitCliArgs(packageManager, prismaNextArgs, prismaNextSpec);
 	return [execution.command, ...execution.args].join(" ");
 }
 async function runPrismaNextInitForContext(context, projectDir) {
@@ -1443,10 +1447,10 @@ async function runPrismaNextInitForContext(context, projectDir) {
 		getContractPath(context.authoring),
 		"--no-install"
 	];
-	const initCommand = getPrismaNextInitCliCommand(context.packageManager, initArgs);
+	const initCommand = getPrismaNextInitCliCommand(context.packageManager, initArgs, context.prismaNextSpec);
 	if (context.verbose) log.step(`Running ${initCommand}`);
 	try {
-		const initExecution = getPrismaNextInitCliArgs(context.packageManager, initArgs);
+		const initExecution = getPrismaNextInitCliArgs(context.packageManager, initArgs, context.prismaNextSpec);
 		await execa(initExecution.command, initExecution.args, {
 			cwd: projectDir,
 			stdio: context.verbose ? "inherit" : "pipe",
@@ -1482,7 +1486,6 @@ async function finalizePrismaFilesForContext(context, projectDir, provisionResul
 			provider: context.databaseProvider,
 			databaseUrl: provisionResult.databaseUrl,
 			claimUrl: provisionResult.claimUrl,
-			useLocalMongo: context.useLocalMongo,
 			projectDir
 		});
 		if (context.verbose) log.success("Prisma Next environment configured.");
@@ -1554,7 +1557,7 @@ function buildNextStepsForContext(opts) {
 		command: getRunScriptCommand(context.packageManager, "db:init"),
 		description: "Create the initial PostgreSQL database objects and sign the database."
 	});
-	if (context.useLocalMongo) nextSteps.push({
+	if (context.databaseProvider === "mongo" && !context.databaseUrl) nextSteps.push({
 		command: getRunScriptCommand(context.packageManager, "db:up"),
 		description: "Start the local MongoDB replica set with mongodb-memory-server. Stop with `db:down`, wipe with `db:reset`."
 	});
@@ -1568,7 +1571,7 @@ function buildNextStepsForContext(opts) {
 	});
 	nextSteps.push({
 		command: getRunScriptCommand(context.packageManager, "db:seed"),
-		description: "Insert the sample user and post data from prisma/seed.ts."
+		description: "Insert the sample users from prisma/seed.ts."
 	});
 	if (options.includeDevNextStep) nextSteps.push({
 		command: getRunScriptCommand(context.packageManager, "dev"),
@@ -1579,15 +1582,15 @@ function buildNextStepsForContext(opts) {
 function formatNextSteps(nextSteps) {
 	return nextSteps.map((step) => `${step.command}\n  ${step.description}`).join("\n\n");
 }
-function formatFirstSteps(prependNextSteps) {
-	const lines = [];
-	for (const step of prependNextSteps) lines.push(step.command);
-	lines.push("");
-	lines.push("Ask your agent:");
-	lines.push("What can I do with Prisma Next?");
-	lines.push("");
-	lines.push("See README.md for the full setup sequence and available scripts.");
-	return lines.join("\n");
+function formatAgentPrompt() {
+	return [
+		"Ask your agent:",
+		"What can I do with Prisma Next?",
+		"",
+		"Learn more:",
+		`Docs: prisma-next.md`,
+		"Skills: https://github.com/prisma/prisma-next/tree/main/skills"
+	].join("\n");
 }
 async function executePrismaSetupContext(context, options = {}) {
 	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
@@ -1635,8 +1638,8 @@ async function executePrismaSetupContext(context, options = {}) {
 	});
 	progressSpinner?.stop("Prisma Next project ready.");
 	if (warningLines.length > 0) note(warningLines.map((line) => line.replace(/^- /, "")).join("\n"), "Heads up");
-	note(formatFirstSteps(options.prependNextSteps ?? []), "Next steps");
-	if (context.verbose) note(formatNextSteps(nextSteps), "Full command reference");
+	note(formatAgentPrompt(), "Agent prompt");
+	if (context.verbose) note(formatNextSteps(nextSteps), "Next steps for Prisma Next");
 	outro("Prisma Next setup complete.");
 	return true;
 }
@@ -1837,8 +1840,7 @@ async function executeCreateContext(context) {
 			template: context.template,
 			provider: context.prismaSetupContext.databaseProvider,
 			authoring: context.prismaSetupContext.authoring,
-			packageManager: context.prismaSetupContext.packageManager,
-			useLocalMongo: context.prismaSetupContext.useLocalMongo
+			packageManager: context.prismaSetupContext.packageManager
 		});
 		if (context.prismaSetupContext.verbose) log.success("Starter files scaffolded.");
 	} catch (error) {
@@ -1853,7 +1855,8 @@ async function executeCreateContext(context) {
 		await writeCreateTemplateDependencies({
 			template: context.template,
 			packageManager: context.prismaSetupContext.packageManager,
-			projectDir: context.targetDirectory
+			projectDir: context.targetDirectory,
+			prismaNextSpec: context.prismaSetupContext.prismaNextSpec
 		});
 	} catch (error) {
 		createSpinner?.stop("Could not create Prisma Next project.");

package/dist/index.d.mts

@@ -227,10 +227,10 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     deno: "deno";
   }>>;
   prismaPostgres: z.ZodOptional<z.ZodBoolean>;
-  localMongo: z.ZodOptional<z.ZodBoolean>;
   databaseUrl: z.ZodOptional<z.ZodString>;
   install: z.ZodOptional<z.ZodBoolean>;
   emit: z.ZodOptional<z.ZodBoolean>;
+  prismaNextVersion: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   template: z.ZodOptional<z.ZodEnum<{
     minimal: "minimal";
@@ -270,10 +270,10 @@ declare const router: {
       deno: "deno";
     }>>;
     prismaPostgres: zod.ZodOptional<zod.ZodBoolean>;
-    localMongo: zod.ZodOptional<zod.ZodBoolean>;
     databaseUrl: zod.ZodOptional<zod.ZodString>;
     install: zod.ZodOptional<zod.ZodBoolean>;
     emit: zod.ZodOptional<zod.ZodBoolean>;
+    prismaNextVersion: zod.ZodOptional<zod.ZodString>;
     name: zod.ZodOptional<zod.ZodString>;
     template: zod.ZodOptional<zod.ZodEnum<{
       minimal: "minimal";

package/dist/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as DatabaseUrlSchema, r as CreateCommandInputSchema, s as PackageManagerSchema, t as runCreateCommand } from "./create-BOeaiXBK.mjs";
+import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as DatabaseUrlSchema, r as CreateCommandInputSchema, s as PackageManagerSchema, t as runCreateCommand } from "./create-CHVnIodq.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.4.2-pr.39.99.1";
+const CLI_VERSION = "0.4.2-pr.40.103.1";
 const router = os.router({ create: os.meta({
 	description: "Create a new project with Prisma setup",
 	default: true,