create-prisma 0.4.1 → 0.4.2-next.37.79.1

package/templates/create/tanstack-start/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/tanstack-start/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/tanstack-start/src/lib/prisma.server.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 = process.env.DATABASE_URL ?? "file:./dev.db";
+{{#if (eq provider "mongo")}}
+import mongo from "@prisma-next/mongo/runtime";
 {{else}}
-const databaseUrl = 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 { prisma };
-export default prisma;
+export default db;

package/templates/create/tanstack-start/src/routes/__root.tsx.hbs

@@ -18,7 +18,7 @@ export const Route = createRootRoute({
       },
       {
         name: "description",
-        content: "TanStack Start + Prisma starter generated by create-prisma.",
+        content: "TanStack Start + Prisma Next starter generated by create-prisma.",
       },
     ],
     links: [
@@ -42,7 +42,7 @@ function RootDocument({ children }: { children: ReactNode }) {
           <header className="topbar">
             <div>
               <p className="eyebrow">create-prisma</p>
-              <h1>TanStack Start + Prisma</h1>
+              <h1>TanStack Start + Prisma Next</h1>
             </div>
 
             <nav className="nav">
@@ -68,4 +68,3 @@ function RootDocument({ children }: { children: ReactNode }) {
     </html>
   );
 }
-

package/templates/create/tanstack-start/src/routes/index.tsx.hbs

@@ -1,34 +1,19 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { createServerFn } from "@tanstack/react-start";
 {{#if (eq schemaPreset "basic")}}
-import { prisma } from "../lib/prisma.server";
+import { listUsers as listStarterUsers } from "../lib/prisma.server";
 {{/if}}
 
 {{#if (eq schemaPreset "basic")}}
-function isBootstrapQueryError(error: unknown): error is { code?: string } {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    (error as { code?: string }).code === "P2021"
-  );
-}
-
 const listUsers = createServerFn({ method: "GET" }).handler(async () => {
-  try {
-    return await prisma.user.findMany({
-      take: 10,
-      orderBy: {
-        createdAt: "desc",
-      },
-    });
-  } catch (error) {
-    if (isBootstrapQueryError(error)) {
-      return undefined;
-    }
-
-    throw error;
-  }
+  return listStarterUsers(10)
+    .then((rows) =>
+      rows.map((user) => ({
+        ...user,
+        createdAt: user.createdAt?.toISOString() ?? null,
+      }))
+    )
+    .catch(() => undefined);
 });
 {{/if}}
 
@@ -52,11 +37,11 @@ function Home() {
   return (
     <main className="shell">
       <div className="hero">
-        <p className="eyebrow">TanStack Start + Prisma 7</p>
+        <p className="eyebrow">TanStack Start + Prisma Next</p>
 {{#if (eq schemaPreset "basic")}}
         <h1>Users from your database, loaded through a server function.</h1>
         <p className="lede">
-          This route uses TanStack Start&apos;s server function API and the Prisma client in{" "}
+          This route uses TanStack Start&apos;s server function API and the Prisma Next helper in{" "}
           <code>src/lib/prisma.server.ts</code>.
         </p>
       </div>
@@ -69,11 +54,11 @@ function Home() {
 
         {!users ? (
           <p className="empty">
-            Could not query users yet. Run <code>db:migrate</code>, then <code>db:seed</code>,
+            Could not query users yet. Run <code>contract:emit</code> and apply your schema,
             then refresh.
           </p>
         ) : users.length === 0 ? (
-          <p className="empty">No users yet. Run <code>db:seed</code> after your first migration.</p>
+          <p className="empty">No users yet. Run db:seed after applying your first migration.</p>
         ) : (
           <ul className="users">
             {users.map((user) => (
@@ -82,9 +67,13 @@ function Home() {
                   <strong>{user.name ?? "Unnamed user"}</strong>
                   <p>{user.email}</p>
                 </div>
-                <time dateTime={user.createdAt.toISOString()}>
-                  {formatter.format(user.createdAt)}
-                </time>
+                {user.createdAt ? (
+                  <time dateTime={user.createdAt}>
+                    {formatter.format(new Date(user.createdAt))}
+                  </time>
+                ) : (
+                  <span className="empty">No timestamp</span>
+                )}
               </li>
             ))}
           </ul>
@@ -93,8 +82,8 @@ function Home() {
 {{else}}
         <h1>Your TanStack Start app is ready.</h1>
         <p className="lede">
-          Edit <code>prisma/schema.prisma</code>, run <code>db:migrate</code>, then query your
-          database from server functions or route loaders.
+          Edit your Prisma Next contract, run <code>contract:emit</code>, then query your database
+          from server functions or route loaders.
         </p>
       </div>
 
@@ -113,14 +102,14 @@ function Home() {
           </li>
           <li>
             <div>
-              <strong>Prisma client</strong>
-              <p>Use the shared instance from <code>src/lib/prisma.server.ts</code>.</p>
+              <strong>Prisma Next runtime</strong>
+              <p>Use the shared helper from <code>src/lib/prisma.server.ts</code>.</p>
             </div>
           </li>
           <li>
             <div>
-              <strong>Seed script</strong>
-              <p>Run <code>db:seed</code> after your first migration.</p>
+              <strong>Manual database setup</strong>
+              <p>Run the schema setup commands when you are ready.</p>
             </div>
           </li>
         </ul>
@@ -133,7 +122,7 @@ function Home() {
         </div>
 
         <ul className="steps">
-          <li>Run <code>db:generate</code> after schema changes.</li>
+          <li>Run <code>contract:emit</code> after contract changes.</li>
           <li>Use TanStack Start server functions for server-only logic.</li>
           <li>Preview production output with <code>preview</code>.</li>
         </ul>

package/templates/create/tanstack-start/tsconfig.json

@@ -4,6 +4,7 @@
     "jsx": "react-jsx",
     "module": "ESNext",
     "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
     "allowImportingTsExtensions": true,
     "strict": true,
     "noEmit": true,

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

@@ -5,25 +5,36 @@ Generated by `create-prisma` with the Turborepo template.
 ## Structure
 
 - `apps/api` - Hono API app
-- `packages/db` - shared Prisma package
+- `packages/db` - shared Prisma Next package
 
 ## Scripts
 
 - `{{runScriptCommand packageManager "dev"}}` - run API dev server through Turborepo
 - `{{runScriptCommand packageManager "build"}}` - run package builds through Turborepo
 - `{{runScriptCommand packageManager "typecheck"}}` - run TypeScript checks through Turborepo
-- `{{runScriptCommand packageManager "db:generate"}}` - generate Prisma Client in `packages/db`
-- `{{runScriptCommand packageManager "db:migrate"}}` - create/apply migrations in `packages/db`
-- `{{runScriptCommand packageManager "db:seed"}}` - run seed script in `packages/db`
-
-## Prisma
-
-Prisma is scaffolded inside `packages/db`:
-
-- `packages/db/prisma/schema.prisma`
-- `packages/db/prisma/seed.ts`
+- `{{runScriptCommand packageManager "contract:emit"}}` - emit Prisma Next contract artifacts in `packages/db`
+{{#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 in `packages/db`
+- `{{runScriptCommand packageManager "migration:apply"}}` - apply the planned MongoDB migration in `packages/db`
+{{else}}
+- `{{runScriptCommand packageManager "db:init"}}` - initialize database state manually in `packages/db`
+- `{{runScriptCommand packageManager "migration:plan"}}` - create a migration plan in `packages/db`
+- `{{runScriptCommand packageManager "migration:apply"}}` - apply a planned migration in `packages/db`
+{{/if}}
+{{#if (eq schemaPreset "basic")}}
+- `{{runScriptCommand packageManager "db:seed"}}` - insert sample users manually in `packages/db`
+{{/if}}
+
+## Prisma Next
+
+Prisma Next is scaffolded inside `packages/db`:
+
+- `packages/db/prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}`
+- `packages/db/prisma-next.config.ts`
 - `packages/db/src/client.ts`
-- `packages/db/prisma.config.ts`
-- `packages/db/src/generated/prisma`
 
-`apps/api/src/index.ts` imports the shared Prisma client from `@repo/db`.
+`apps/api/src/index.ts` imports the shared Prisma Next helper from `@repo/db`.
+
+Node-based Prisma Next projects expect Node.js 24 LTS or newer.

package/templates/create/turborepo/apps/api/deno.json.hbs

@@ -0,0 +1,6 @@
+{{#if (eq packageManager "deno")}}
+{
+  "name": "@repo/api",
+  "exports": "./src/index.ts"
+}
+{{/if}}

package/templates/create/turborepo/apps/api/package.json.hbs

@@ -3,10 +3,17 @@
   "private": true,
   "type": "module",
   "scripts": {
+    {{#if (eq packageManager "deno")}}
+    "dev": "deno run -A --env-file=.env --watch src/index.ts",
+    "build": "deno check src/index.ts",
+    "start": "deno run -A --env-file=.env src/index.ts",
+    "typecheck": "deno check src/index.ts"
+    {{else}}
     "dev": "tsx watch src/index.ts",
     "build": "tsc",
     "start": "node dist/src/index.js",
     "typecheck": "tsc --noEmit"
+    {{/if}}
   },
   "dependencies": {
     "@hono/node-server": "^1.19.9",

package/templates/create/turborepo/apps/api/src/index.ts.hbs

@@ -4,7 +4,7 @@ import "dotenv/config";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 {{#if (eq schemaPreset "basic")}}
-import { prisma } from "@repo/db";
+import { listUsers } from "@repo/db";
 {{/if}}
 
 const app = new Hono();
@@ -18,22 +18,15 @@ app.get("/", (c) => {
 {{#if (eq schemaPreset "basic")}}
 
 app.get("/users", async (c) => {
-  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 c.json(
       {
-        error: "Could not query users yet. Run db:migrate and db:seed first.",
+        error: "Could not query users yet. Run contract:emit and apply your schema first.",
       },
       500
     );

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

@@ -1,5 +1,9 @@
 {{#if (eq packageManager "deno")}}
 {
-  "nodeModulesDir": "auto"
+  "nodeModulesDir": "manual",
+  "workspace": [
+    "apps/*",
+    "packages/*"
+  ]
 }
 {{/if}}

package/templates/create/turborepo/package.json.hbs

@@ -10,13 +10,21 @@
     "packages/*"
   ],
   "scripts": {
+    {{#if (eq packageManager "deno")}}
+    "build": "deno task --filter=@repo/db build && deno task --filter=@repo/api build",
+    "dev": "deno task --filter=@repo/api dev",
+    "typecheck": "deno task --filter=@repo/db typecheck && deno task --filter=@repo/api typecheck",
+    {{else}}
     "build": "turbo run build",
     "dev": "turbo run dev --filter=@repo/api",
     "typecheck": "turbo run typecheck",
-    "db:generate": "turbo run db:generate --filter=@repo/db",
-    "db:push": "turbo run db:push --filter=@repo/db",
-    "db:migrate": "turbo run db:migrate --filter=@repo/db",
-    "db:seed": "turbo run db:seed --filter=@repo/db"
+    {{/if}}
+    "contract:emit": "{{runScriptInDirectoryCommand packageManager "packages/db" "contract:emit"}}",
+    "db:init": "{{runScriptInDirectoryCommand packageManager "packages/db" "db:init"}}",
+    "db:update": "{{runScriptInDirectoryCommand packageManager "packages/db" "db:update"}}",
+    "db:seed": "{{runScriptInDirectoryCommand packageManager "packages/db" "db:seed"}}",
+    "migration:plan": "{{runScriptInDirectoryCommandWithArgsPassthrough packageManager "packages/db" "migration:plan"}}",
+    "migration:apply": "{{runScriptInDirectoryCommand packageManager "packages/db" "migration:apply"}}"
   },
   "devDependencies": {
     "turbo": "^2.5.6"

package/templates/create/turborepo/packages/db/deno.json.hbs

@@ -0,0 +1,6 @@
+{{#if (eq packageManager "deno")}}
+{
+  "name": "@repo/db",
+  "exports": "./src/index.ts"
+}
+{{/if}}

package/templates/create/turborepo/packages/db/package.json.hbs

@@ -6,8 +6,13 @@
     ".": "./src/index.ts"
   },
   "scripts": {
+    {{#if (eq packageManager "deno")}}
+    "build": "deno check src/index.ts",
+    "typecheck": "deno check src/index.ts"
+    {{else}}
     "build": "tsc",
     "typecheck": "tsc --noEmit"
+    {{/if}}
   },
   "devDependencies": {
     "@types/node": "^24.3.0",

package/templates/create/turborepo/packages/db/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/turborepo/packages/db/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}}