create-prisma 0.7.1-pr.52.181.1 → 0.7.2

package/README.md

@@ -8,12 +8,12 @@ Scaffold a new app with Prisma already wired up.
 
 - creates a new app from a supported template
 - adds Prisma 7 dependencies for your database
-- scaffolds `prisma/schema.prisma`, `prisma/seed.ts`, `prisma.config.ts`, and a Composer application graph for supported templates
+- scaffolds `prisma/schema.prisma`, `prisma/seed.ts`, `prisma.config.ts`, and Compute deploy defaults for Compute-ready templates
 - writes a Prisma client singleton in the right place for the selected template
-- adds `db:generate`, `db:migrate`, `db:migrate:deploy`, and `db:seed` scripts
-- creates an env example for databases managed outside Composer
-- installs dependencies when requested, then generates Prisma Client and an initial migration automatically
-- can deploy the finished app and its Prisma Postgres database with Prisma Composer
+- adds `db:generate`, `db:migrate`, and `db:seed` scripts
+- creates or updates the template env file with `DATABASE_URL`
+- can install dependencies and run `prisma generate` for you
+- can deploy the finished app to Prisma Compute and return a live URL
 
 ## Quick Start
 
@@ -35,6 +35,10 @@ yarn dlx create-prisma@latest
 bunx create-prisma@latest
 ```
 
+```bash
+deno run -A npm:create-prisma@latest
+```
+
 If you already have it available locally:
 
 ```bash
@@ -67,19 +71,19 @@ Create a monorepo with a shared Prisma package:
 create-prisma --name my-monorepo --template turborepo --provider postgresql
 ```
 
-Use Prisma Postgres auto-provisioning, which is the PostgreSQL default:
+Use Prisma Postgres auto-provisioning:
 
 ```bash
-create-prisma --name my-app --template nest --provider postgresql
+create-prisma --name my-app --template nest --provider postgresql --prisma-postgres
 ```
 
-Deploy a supported app with Prisma Composer:
+Deploy a supported app to Prisma Compute:
 
 ```bash
 create-prisma --name my-api --template hono --provider postgresql --deploy
 ```
 
-PostgreSQL always includes Prisma Postgres in the Composer application graph. The generated deploy script provisions it with the app, applies the generated migration with `prisma migrate deploy`, seeds it, and removes the temporary direct connection used for setup.
+With PostgreSQL and no `--database-url`, the Compute flow asks whether to use Prisma Postgres. If accepted, or if `--prisma-postgres` is passed, it creates a Prisma Compute project, creates a `main` Prisma Postgres database on the `main` branch, writes `DATABASE_URL` to the template env file, and deploys the app with the env file configured in `prisma.compute.ts`. Pass `--no-prisma-postgres` to deploy without provisioning a database.
 
 ## Supported Templates
 
@@ -93,13 +97,12 @@ PostgreSQL always includes Prisma Postgres in the Composer application graph. Th
 - `tanstack-start`
 - `turborepo`
 
-Prisma Composer files are included by default, and deployment is supported for:
+Prisma Compute deployment is currently supported for:
 
 - `hono`
 - `elysia`
 - `nest`
 - `next`
-- `svelte`
 - `astro`
 - `nuxt`
 - `tanstack-start`
@@ -119,8 +122,7 @@ Prisma Composer files are included by default, and deployment is supported for:
 - `pnpm`
 - `yarn`
 - `bun`
-
-Every package manager receives the same Composer-ready templates and deploy scripts.
+- `deno`
 
 ## Useful Flags
 
@@ -128,9 +130,12 @@ Every package manager receives the same Composer-ready templates and deploy scri
 - `--template` choose the template
 - `--provider` choose the database provider
 - `--package-manager` choose the package manager/runtime
-- `--deploy` deploy supported templates with Prisma Composer
+- `--schema-preset empty|basic`
+- `--deploy` deploy supported templates to Prisma Compute
 - `--yes` accept defaults and skip prompts
 - `--no-install` scaffold only
+- `--no-generate` skip `prisma generate`
+- `--prisma-postgres` provision Prisma Postgres for PostgreSQL
 - `--skills --mcp --extension` enable optional add-ons
 - `--force` allow scaffolding into a non-empty directory
 - `--verbose` print full command output
@@ -144,10 +149,11 @@ Every package manager receives the same Composer-ready templates and deploy scri
 - Prisma IDE extension install
 
 These can be selected interactively or enabled with flags.
+When Prisma Compute deploy is selected, the skills add-on recommends the `prisma-compute` skill too.
 
-## Deploy with Prisma Composer
+## Deploy to Prisma Compute
 
-Supported templates include Composer by default: `module.ts` declares the application graph, `service.ts` declares the Compute service and its dependencies, and `prisma-composer.config.ts` selects the Prisma Cloud target. The generated project is ready to deploy whether or not you deploy during creation.
+After scaffolding, `create-prisma` can deploy your app to [Prisma Compute](https://www.prisma.io/docs/compute), the serverless hosting for TypeScript apps that runs next to your Prisma Postgres database. It is offered for the templates the Prisma CLI can deploy today: `hono`, `elysia`, `nest`, `next`, `astro`, `nuxt`, `tanstack-start`, and `turborepo`.
 
 Accept the deploy prompt when it appears, or pass the flag:
 
@@ -155,11 +161,11 @@ Accept the deploy prompt when it appears, or pass the flag:
 create-prisma --name my-api --template hono --provider postgresql --deploy
 ```
 
-Deployment runs through `@prisma/cli@next` and reuses either your active Prisma browser-login session or `PRISMA_SERVICE_TOKEN` in CI. If you are not signed in, create-prisma opens the Prisma login flow before deploying from an interactive terminal. You can also sign in ahead of time with `npx @prisma/cli@next auth login`. PostgreSQL always provisions Prisma Postgres and passes its connection through `service.load()`. For other providers, copy `.env.example` to `.env`, set `DATABASE_URL`, and Composer will pass it to the application as a secret input.
+The deploy step signs you in with the Prisma CLI if you are not signed in yet. With PostgreSQL and no `--database-url`, create-prisma asks whether to use Prisma Postgres. If accepted, or if `--prisma-postgres` is passed, setup creates a Prisma Compute project, creates a `main` Prisma Postgres database on the `main` branch, writes `DATABASE_URL` to the template env file, runs the requested Prisma setup, then deploys the app with the env file configured in `prisma.compute.ts`. Pass `--no-prisma-postgres` to deploy without provisioning a database.
 
-A `deploy` script is generated for every supported package manager. It builds and deploys the Composer application. For PostgreSQL it then resolves the Composer-managed database, applies the committed migration with `prisma migrate deploy`, seeds the database, and removes the temporary direct connection. No database URL is written back to the project.
+A `prisma.compute.ts` file is generated with the app framework, runtime port, target, and env-file defaults. When deployment is selected, a `compute:deploy` script is added to the generated project so you can redeploy app changes later. That script runs `@prisma/cli@latest app deploy` using `prisma.compute.ts`; it does not create a new project, create a new database, run migrations, or seed data.
 
-The only Composer-specific prompt asks whether to deploy immediately. It is skipped in `--yes` runs unless you pass `--deploy`; the Composer files are still generated. Prisma Client generation is automatic, and PostgreSQL uses Prisma Postgres by default without additional prompts.
+The deploy prompt is skipped in `--yes` runs unless you pass `--deploy`. Browser sign-in may still need a person at the keyboard if no Prisma CLI session exists.
 
 ## Local Development
 

package/dist/cli.mjs

@@ -1,36 +1,6 @@
 #!/usr/bin/env node
-//#endregion
-//#region src/utils/node-version.ts
-const supportedNodeVersionRange = {
-	"bun": ">=1.3.0",
-	"node": ">=24.0.0"
-}.node;
-function getMinimumNodeMajor() {
-	const match = /^>=(\d+)(?:\.\d+){0,2}$/.exec(supportedNodeVersionRange);
-	if (!match) throw new Error(`Unsupported Node.js engine range: ${supportedNodeVersionRange}`);
-	return Number(match[1]);
-}
-function getNodeVersionCompatibilityError(nodeVersion) {
-	const majorMatch = /^v?(\d+)(?:\.|$)/.exec(nodeVersion);
-	const currentMajor = majorMatch ? Number(majorMatch[1]) : NaN;
-	const minimumMajor = getMinimumNodeMajor();
-	if (Number.isFinite(currentMajor) && currentMajor >= minimumMajor) return;
-	return [
-		`Node.js ${nodeVersion} is unsupported.`,
-		"",
-		`create-prisma requires Node.js ${minimumMajor} LTS or newer.`,
-		"Update Node.js, then run create-prisma again."
-	].join("\n");
-}
-//#endregion
+import { n as createCreatePrismaCli } from "./src-B3hRLZ0U.mjs";
 //#region src/cli.ts
-const nodeVersionError = getNodeVersionCompatibilityError(process.versions.node);
-if (nodeVersionError) {
-	process.stderr.write(`${nodeVersionError}\n`);
-	process.exit(1);
-}
-const { createCreatePrismaCli } = await import("./index.mjs");
-await createCreatePrismaCli().run({ formatError: (error) => error instanceof Error ? error.message : String(error) });
-if (process.exitCode && process.exitCode !== 0) process.exit(process.exitCode);
+createCreatePrismaCli().run();
 //#endregion
 export {};

package/dist/index.d.mts

@@ -185,6 +185,11 @@ declare const PackageManagerSchema: z.ZodEnum<{
   pnpm: "pnpm";
   yarn: "yarn";
   bun: "bun";
+  deno: "deno";
+}>;
+declare const SchemaPresetSchema: z.ZodEnum<{
+  empty: "empty";
+  basic: "basic";
 }>;
 declare const CreateTemplateSchema: z.ZodEnum<{
   hono: "hono";
@@ -197,6 +202,7 @@ declare const CreateTemplateSchema: z.ZodEnum<{
   "tanstack-start": "tanstack-start";
   turborepo: "turborepo";
 }>;
+declare const DatabaseUrlSchema: z.ZodString;
 declare const CreateCommandInputSchema: z.ZodObject<{
   yes: z.ZodOptional<z.ZodBoolean>;
   verbose: z.ZodOptional<z.ZodBoolean>;
@@ -212,8 +218,17 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     pnpm: "pnpm";
     yarn: "yarn";
     bun: "bun";
+    deno: "deno";
   }>>;
+  prismaPostgres: z.ZodOptional<z.ZodBoolean>;
+  databaseUrl: z.ZodOptional<z.ZodString>;
   install: z.ZodOptional<z.ZodBoolean>;
+  generate: z.ZodOptional<z.ZodBoolean>;
+  migrateAndSeed: z.ZodOptional<z.ZodBoolean>;
+  schemaPreset: z.ZodOptional<z.ZodEnum<{
+    empty: "empty";
+    basic: "basic";
+  }>>;
   name: z.ZodOptional<z.ZodString>;
   template: z.ZodOptional<z.ZodEnum<{
     hono: "hono";
@@ -251,8 +266,17 @@ declare const router: {
       pnpm: "pnpm";
       yarn: "yarn";
       bun: "bun";
+      deno: "deno";
     }>>;
+    prismaPostgres: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    databaseUrl: import("zod").ZodOptional<import("zod").ZodString>;
     install: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    generate: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    migrateAndSeed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    schemaPreset: import("zod").ZodOptional<import("zod").ZodEnum<{
+      empty: "empty";
+      basic: "basic";
+    }>>;
     name: import("zod").ZodOptional<import("zod").ZodString>;
     template: import("zod").ZodOptional<import("zod").ZodEnum<{
       hono: "hono";
@@ -275,4 +299,4 @@ declare const router: {
 declare function createCreatePrismaCli(): import("trpc-cli").TrpcCli;
 declare function create(input?: CreateCommandInput): Promise<void>;
 //#endregion
-export { type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };
+export { type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };