create-prisma 0.4.1 → 0.4.2-next.37.79.1

package/dist/index.d.mts

@@ -177,13 +177,12 @@ type ErrorMap = { [key in ORPCErrorCode]?: ErrorMapItem<AnySchema> };
 type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
 //#endregion
 //#region src/types.d.ts
-declare const DatabaseProviderSchema: z.ZodEnum<{
+declare const DatabaseProviderSchema: z.ZodPipe<z.ZodEnum<{
+  postgres: "postgres";
   postgresql: "postgresql";
-  mysql: "mysql";
-  sqlite: "sqlite";
-  sqlserver: "sqlserver";
-  cockroachdb: "cockroachdb";
-}>;
+  mongo: "mongo";
+  mongodb: "mongodb";
+}>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>;
 declare const PackageManagerSchema: z.ZodEnum<{
   npm: "npm";
   pnpm: "pnpm";
@@ -195,6 +194,10 @@ declare const SchemaPresetSchema: z.ZodEnum<{
   empty: "empty";
   basic: "basic";
 }>;
+declare const AuthoringStyleSchema: z.ZodEnum<{
+  psl: "psl";
+  typescript: "typescript";
+}>;
 declare const CreateTemplateSchema: z.ZodEnum<{
   hono: "hono";
   elysia: "elysia";
@@ -210,12 +213,15 @@ declare const DatabaseUrlSchema: z.ZodString;
 declare const CreateCommandInputSchema: z.ZodObject<{
   yes: z.ZodOptional<z.ZodBoolean>;
   verbose: z.ZodOptional<z.ZodBoolean>;
-  provider: z.ZodOptional<z.ZodEnum<{
+  provider: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+    postgres: "postgres";
     postgresql: "postgresql";
-    mysql: "mysql";
-    sqlite: "sqlite";
-    sqlserver: "sqlserver";
-    cockroachdb: "cockroachdb";
+    mongo: "mongo";
+    mongodb: "mongodb";
+  }>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
+  authoring: z.ZodOptional<z.ZodEnum<{
+    psl: "psl";
+    typescript: "typescript";
   }>>;
   packageManager: z.ZodOptional<z.ZodEnum<{
     npm: "npm";
@@ -227,7 +233,7 @@ declare const CreateCommandInputSchema: z.ZodObject<{
   prismaPostgres: z.ZodOptional<z.ZodBoolean>;
   databaseUrl: z.ZodOptional<z.ZodString>;
   install: z.ZodOptional<z.ZodBoolean>;
-  generate: z.ZodOptional<z.ZodBoolean>;
+  emit: z.ZodOptional<z.ZodBoolean>;
   schemaPreset: z.ZodOptional<z.ZodEnum<{
     empty: "empty";
     basic: "basic";
@@ -244,9 +250,6 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     "tanstack-start": "tanstack-start";
     turborepo: "turborepo";
   }>>;
-  skills: z.ZodOptional<z.ZodBoolean>;
-  mcp: z.ZodOptional<z.ZodBoolean>;
-  extension: z.ZodOptional<z.ZodBoolean>;
   force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
@@ -256,12 +259,15 @@ declare const router: {
   create: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, zod.ZodOptional<zod.ZodObject<{
     yes: zod.ZodOptional<zod.ZodBoolean>;
     verbose: zod.ZodOptional<zod.ZodBoolean>;
-    provider: zod.ZodOptional<zod.ZodEnum<{
+    provider: zod.ZodOptional<zod.ZodPipe<zod.ZodEnum<{
+      postgres: "postgres";
       postgresql: "postgresql";
-      mysql: "mysql";
-      sqlite: "sqlite";
-      sqlserver: "sqlserver";
-      cockroachdb: "cockroachdb";
+      mongo: "mongo";
+      mongodb: "mongodb";
+    }>, zod.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
+    authoring: zod.ZodOptional<zod.ZodEnum<{
+      psl: "psl";
+      typescript: "typescript";
     }>>;
     packageManager: zod.ZodOptional<zod.ZodEnum<{
       npm: "npm";
@@ -273,7 +279,7 @@ declare const router: {
     prismaPostgres: zod.ZodOptional<zod.ZodBoolean>;
     databaseUrl: zod.ZodOptional<zod.ZodString>;
     install: zod.ZodOptional<zod.ZodBoolean>;
-    generate: zod.ZodOptional<zod.ZodBoolean>;
+    emit: zod.ZodOptional<zod.ZodBoolean>;
     schemaPreset: zod.ZodOptional<zod.ZodEnum<{
       empty: "empty";
       basic: "basic";
@@ -290,13 +296,10 @@ declare const router: {
       "tanstack-start": "tanstack-start";
       turborepo: "turborepo";
     }>>;
-    skills: zod.ZodOptional<zod.ZodBoolean>;
-    mcp: zod.ZodOptional<zod.ZodBoolean>;
-    extension: zod.ZodOptional<zod.ZodBoolean>;
     force: zod.ZodOptional<zod.ZodBoolean>;
   }, zod_v4_core0.$strip>>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
 };
 declare function createCreatePrismaCli(): trpc_cli0.TrpcCli;
 declare function create(input?: CreateCommandInput): Promise<void>;
 //#endregion
-export { type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };

package/dist/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { a as DatabaseUrlSchema, i as DatabaseProviderSchema, n as CreateCommandInputSchema, o as PackageManagerSchema, r as CreateTemplateSchema, s as SchemaPresetSchema, t as runCreateCommand } from "./create-H6Tk0JlE.mjs";
+import { a as DatabaseProviderSchema, c as SchemaPresetSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as DatabaseUrlSchema, r as CreateCommandInputSchema, s as PackageManagerSchema, t as runCreateCommand } from "./create-Btn7yJR3.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.4.1";
+const CLI_VERSION = "0.4.2-next.37.79.1";
 const router = os.router({ create: os.meta({
 	description: "Create a new project with Prisma setup",
 	default: true,
@@ -24,4 +24,4 @@ async function create(input = {}) {
 }
 
 //#endregion
-export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "create-prisma",
-  "version": "0.4.1",
+  "version": "0.4.2-next.37.79.1",
   "private": false,
-  "description": "Create Prisma 7 projects with first-party templates and great DX.",
+  "description": "Create Prisma Next projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",
   "bugs": {
     "url": "https://github.com/prisma/create-prisma/issues"

package/templates/create/_shared/packages/db/prisma/seed.ts.hbs

@@ -0,0 +1,43 @@
+{{#if (eq template "turborepo")}}
+{{#if (eq schemaPreset "basic")}}
+import { db } from "../src/client{{#if (eq packageManager "deno")}}.ts{{/if}}";
+
+const seedUsers = [
+  { email: "alice@prisma.io", name: "Alice" },
+  { email: "bob@prisma.io", name: "Bob" },
+  { email: "carol@prisma.io", name: "Carol" },
+];
+
+let createdCount = 0;
+
+{{#if (eq provider "mongo")}}
+try {
+  for (const user of seedUsers) {
+    const existingUser = await db.orm.users.where({ email: user.email }).first();
+    if (!existingUser) {
+      createdCount += await db.orm.users.createCount([user]);
+    }
+  }
+
+  console.log(`Seeded ${createdCount} user${createdCount === 1 ? "" : "s"}.`);
+} finally {
+  await db.close();
+}
+{{else}}
+try {
+  for (const user of seedUsers) {
+    const existingUser = await db.orm.User.where({ email: user.email }).first();
+    if (!existingUser) {
+      createdCount += await db.orm.User.createCount([user]);
+    }
+  }
+
+  console.log(`Seeded ${createdCount} user${createdCount === 1 ? "" : "s"}.`);
+} finally {
+  await db.runtime().close();
+}
+{{/if}}
+{{else}}
+console.log("No seed data for the empty schema preset.");
+{{/if}}
+{{/if}}

package/templates/create/_shared/prisma/seed.ts.hbs

@@ -0,0 +1,55 @@
+{{#unless (eq template "turborepo")}}
+{{#if (eq schemaPreset "basic")}}
+{{#if (eq template "nuxt")}}
+import { db } from "../server/utils/prisma{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{else}}
+{{#if (eq template "svelte")}}
+import { db } from "../src/lib/server/prisma{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{else}}
+{{#if (eq template "tanstack-start")}}
+import { db } from "../src/lib/prisma.server{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{else}}
+import { db } from "../src/lib/prisma{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{/if}}
+{{/if}}
+{{/if}}
+
+const seedUsers = [
+  { email: "alice@prisma.io", name: "Alice" },
+  { email: "bob@prisma.io", name: "Bob" },
+  { email: "carol@prisma.io", name: "Carol" },
+];
+
+let createdCount = 0;
+
+{{#if (eq provider "mongo")}}
+try {
+  for (const user of seedUsers) {
+    const existingUser = await db.orm.users.where({ email: user.email }).first();
+    if (!existingUser) {
+      createdCount += await db.orm.users.createCount([user]);
+    }
+  }
+
+  console.log(`Seeded ${createdCount} user${createdCount === 1 ? "" : "s"}.`);
+} finally {
+  await db.close();
+}
+{{else}}
+try {
+  for (const user of seedUsers) {
+    const existingUser = await db.orm.User.where({ email: user.email }).first();
+    if (!existingUser) {
+      createdCount += await db.orm.User.createCount([user]);
+    }
+  }
+
+  console.log(`Seeded ${createdCount} user${createdCount === 1 ? "" : "s"}.`);
+} finally {
+  await db.runtime().close();
+}
+{{/if}}
+{{else}}
+console.log("No seed data for the empty schema preset.");
+{{/if}}
+{{/unless}}

package/templates/create/astro/README.md.hbs

@@ -9,27 +9,38 @@ Generated by `create-prisma` with the Astro template.
 - `{{runScriptCommand packageManager "preview"}}` - preview the production build
 - `{{runScriptCommand packageManager "astro"}}` - run Astro CLI commands
 
-## Prisma
+## Prisma Next
 
-Prisma setup is scaffolded automatically in:
+Prisma Next setup is scaffolded in:
 
-- `prisma/schema.prisma`
-- `prisma/seed.ts`
+- `prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}`
+- `prisma-next.config.ts`
 - `src/lib/prisma.ts`
 - `src/pages/api/users.ts`
-- `prisma.config.ts`
-- `src/generated/prisma`
 
 Database helper scripts are added to `package.json`:
 
-- `db:generate`
-- `db:push`
-- `db:migrate`
-- `db:seed`
+- `{{runScriptCommand packageManager "contract:emit"}}` - emit contract artifacts after contract changes
+{{#if (eq provider "mongo")}}
+- `{{runScriptCommand packageManager "db:up"}}` - start the local MongoDB replica set
+- `{{runScriptCommand packageManager "db:down"}}` - stop the local MongoDB replica set
+- `{{runScriptCommand packageManager "migration:plan"}}` - create a MongoDB migration plan
+- `{{runScriptCommand packageManager "migration:apply"}}` - apply the planned MongoDB migration
+{{else}}
+- `{{runScriptCommand packageManager "db:init"}}` - initialize database state manually
+- `{{runScriptCommand packageManager "db:update"}}` - update database state manually
+- `{{runScriptCommand packageManager "migration:plan"}}` - create a migration plan
+- `{{runScriptCommand packageManager "migration:apply"}}` - apply a planned migration
+{{/if}}
+{{#if (eq schemaPreset "basic")}}
+- `{{runScriptCommand packageManager "db:seed"}}` - insert sample users manually
+{{/if}}
+
+Node-based Prisma Next projects expect Node.js 24 LTS or newer.
 {{#if (eq schemaPreset "basic")}}
 
-The starter page queries a basic `User` model in `src/pages/index.astro`, and `src/pages/api/users.ts` shows an Astro API route backed by the same Prisma client.
+The starter page queries a basic `User` model in `src/pages/index.astro`, and `src/pages/api/users.ts` shows an Astro API route backed by the same Prisma Next helper.
 {{else}}
 
-The starter page keeps the official Astro minimal structure and points you to `prisma/schema.prisma` for your first model.
+The starter page keeps the official Astro minimal structure and points you to your Prisma Next contract for the first model.
 {{/if}}

package/templates/create/astro/deno.json.hbs

@@ -1,5 +1,5 @@
 {{#if (eq packageManager "deno")}}
 {
-  "nodeModulesDir": "auto"
+  "nodeModulesDir": "manual"
 }
 {{/if}}

package/templates/create/astro/prisma/contract.prisma.hbs

@@ -0,0 +1,44 @@
+{{#if (eq authoring "psl")}}
+// use prisma-next
+{{#if (eq schemaPreset "basic")}}
+{{#if (eq provider "mongo")}}
+
+model User {
+  id    ObjectId @id @map("_id")
+  email String   @unique
+  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")
+}
+{{else}}
+
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  name      String?
+  posts     Post[]
+  createdAt DateTime @default(now())
+}
+
+model Post {
+  id        Int      @id @default(autoincrement())
+  title     String
+  content   String?
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  Int
+  createdAt DateTime @default(now())
+}
+{{/if}}
+{{/if}}
+{{/if}}

package/templates/create/astro/prisma/contract.ts.hbs

@@ -0,0 +1,85 @@
+{{#if (eq authoring "typescript")}}
+{{#if (eq provider "mongo")}}
+import mongoFamily from "@prisma-next/family-mongo/pack";
+import { defineContract } from "@prisma-next/mongo-contract-ts/contract-builder";
+import mongoTarget from "@prisma-next/target-mongo/pack";
+
+export const contract = defineContract(
+  { family: mongoFamily, target: mongoTarget },
+  ({ field, index, model, rel }) => ({
+    models: {
+{{#if (eq schemaPreset "basic")}}
+      User: model("User", {
+        collection: "users",
+        fields: {
+          _id: field.objectId(),
+          email: field.string(),
+          name: field.string().optional(),
+        },
+        indexes: [
+          index({ email: 1 }, { unique: true }),
+        ],
+        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(),
+        },
+        indexes: [
+          index({ authorId: 1 }),
+        ],
+        relations: {
+          author: rel.belongsTo("User", { from: "authorId", to: "_id" }),
+        },
+      }),
+{{/if}}
+    },
+  }),
+);
+{{else}}
+import sqlFamily from "@prisma-next/family-sql/pack";
+import { defineContract } from "@prisma-next/sql-contract-ts/contract-builder";
+import postgresPack from "@prisma-next/target-postgres/pack";
+
+export const contract = defineContract(
+  { family: sqlFamily, target: postgresPack },
+  ({ field, model, rel }) => ({
+    models: {
+{{#if (eq schemaPreset "basic")}}
+      User: model("User", {
+        fields: {
+          id: field.id.uuidv7(),
+          email: field.text().unique(),
+          name: field.text().optional(),
+          createdAt: field.createdAt(),
+        },
+        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.createdAt(),
+        },
+        relations: {
+          author: rel.belongsTo("User", { from: "authorId", to: "id" }),
+        },
+      }),
+{{/if}}
+    },
+  }),
+);
+{{/if}}
+{{/if}}

package/templates/create/astro/prisma-next.config.ts.hbs

@@ -0,0 +1,13 @@
+import "dotenv/config";
+{{#if (eq provider "mongo")}}
+import { defineConfig } from "@prisma-next/mongo/config";
+{{else}}
+import { defineConfig } from "@prisma-next/postgres/config";
+{{/if}}
+
+export default defineConfig({
+  contract: "./prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}",
+  db: {
+    connection: process.env["DATABASE_URL"],
+  },
+});

package/templates/create/astro/src/lib/prisma.ts.hbs

@@ -1,53 +1,59 @@
 import "dotenv/config";
-import { PrismaClient } from "../generated/prisma/client";
-{{#if (eq provider "postgresql")}}
-import { PrismaPg } from "@prisma/adapter-pg";
-{{/if}}
-{{#if (eq provider "cockroachdb")}}
-import { PrismaPg } from "@prisma/adapter-pg";
-{{/if}}
-{{#if (eq provider "mysql")}}
-import { PrismaMariaDb } from "@prisma/adapter-mariadb";
-{{/if}}
-{{#if (eq provider "sqlite")}}
-import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
-{{/if}}
-{{#if (eq provider "sqlserver")}}
-import { PrismaMssql } from "@prisma/adapter-mssql";
-{{/if}}
-
-{{#if (eq provider "sqlite")}}
-const databaseUrl =
-  import.meta.env?.DATABASE_URL ?? process.env.DATABASE_URL ?? "file:./dev.db";
+{{#if (eq provider "mongo")}}
+import mongo from "@prisma-next/mongo/runtime";
 {{else}}
-const databaseUrl = import.meta.env?.DATABASE_URL ?? process.env.DATABASE_URL;
-if (!databaseUrl) {
-  throw new Error("DATABASE_URL is required");
-}
+import postgres from "@prisma-next/postgres/runtime";
 {{/if}}
+import type { Contract } from "../../prisma/contract.d";
+import contractJson from "../../prisma/contract.json" with { type: "json" };
 
-{{#if (eq provider "postgresql")}}
-const adapter = new PrismaPg({
-  connectionString: databaseUrl,
+{{#if (eq provider "mongo")}}
+export const db = mongo<Contract>({
+  contractJson,
+  url: process.env["DATABASE_URL"],
 });
-{{/if}}
-{{#if (eq provider "cockroachdb")}}
-const adapter = new PrismaPg({
-  connectionString: databaseUrl,
+{{else}}
+export const db = postgres<Contract>({
+  contractJson,
+  url: process.env["DATABASE_URL"],
 });
 {{/if}}
-{{#if (eq provider "mysql")}}
-const adapter = new PrismaMariaDb(databaseUrl);
-{{/if}}
-{{#if (eq provider "sqlite")}}
-const adapter = new PrismaBetterSqlite3({
-  url: databaseUrl,
-});
+
+export type StarterUser = {
+  id: string;
+  email: string;
+  name: string | null;
+  createdAt: Date | null;
+};
+
+export async function listUsers(limit = 10): Promise<StarterUser[]> {
+{{#if (eq schemaPreset "basic")}}
+{{#if (eq provider "mongo")}}
+  const users: StarterUser[] = [];
+
+  for await (const user of db.orm.users.select("_id", "email", "name").take(limit).all()) {
+    users.push({
+      id: String(user._id),
+      email: user.email,
+      name: user.name ?? null,
+      createdAt: null,
+    });
+  }
+
+  return users;
+{{else}}
+  const users = await db.orm.User.select("id", "email", "name", "createdAt").take(limit).all();
+
+  return users.map((user) => ({
+    id: String(user.id),
+    email: user.email,
+    name: user.name ?? null,
+    createdAt: user.createdAt,
+  }));
 {{/if}}
-{{#if (eq provider "sqlserver")}}
-const adapter = new PrismaMssql(databaseUrl);
+{{else}}
+  return [];
 {{/if}}
+}
 
-const prisma = new PrismaClient({ adapter });
-
-export default prisma;
+export default db;

package/templates/create/astro/src/pages/api/users.ts.hbs

@@ -1,19 +1,12 @@
 import type { APIRoute } from "astro";
 {{#if (eq schemaPreset "basic")}}
-import prisma from "../../lib/prisma";
+import { listUsers } from "../../lib/prisma";
 
 export const GET: APIRoute = async () => {
-  const users = await prisma.user
-    .findMany({
-      take: 10,
-      orderBy: {
-        createdAt: "desc",
-      },
-    })
-    .catch((error) => {
-      console.error("Failed to query users:", error);
-      return undefined;
-    });
+  const users = await listUsers(10).catch((error) => {
+    console.error("Failed to query users:", error);
+    return undefined;
+  });
 
   if (!users) {
     return new Response(JSON.stringify({ error: "Could not query users yet." }), {