create-prisma 0.7.2 → 0.8.0-pr.57.218.1

package/dist/index.d.mts

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import * as _orpc_server0 from "@orpc/server";
+import * as trpc_cli0 from "trpc-cli";
 import { z } from "zod";
 
 //#region node_modules/@orpc/client/dist/index.d.mts
@@ -173,13 +175,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";
@@ -187,11 +188,12 @@ declare const PackageManagerSchema: z.ZodEnum<{
   bun: "bun";
   deno: "deno";
 }>;
-declare const SchemaPresetSchema: z.ZodEnum<{
-  empty: "empty";
-  basic: "basic";
+declare const AuthoringStyleSchema: z.ZodEnum<{
+  psl: "psl";
+  typescript: "typescript";
 }>;
 declare const CreateTemplateSchema: z.ZodEnum<{
+  minimal: "minimal";
   hono: "hono";
   elysia: "elysia";
   nest: "nest";
@@ -200,18 +202,19 @@ declare const CreateTemplateSchema: z.ZodEnum<{
   astro: "astro";
   nuxt: "nuxt";
   "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>;
-  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";
@@ -220,17 +223,11 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     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";
-  }>>;
+  deploy: z.ZodOptional<z.ZodBoolean>;
+  workspace: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   template: z.ZodOptional<z.ZodEnum<{
+    minimal: "minimal";
     hono: "hono";
     elysia: "elysia";
     nest: "nest";
@@ -239,46 +236,38 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     astro: "astro";
     nuxt: "nuxt";
     "tanstack-start": "tanstack-start";
-    turborepo: "turborepo";
   }>>;
-  skills: z.ZodOptional<z.ZodBoolean>;
-  mcp: z.ZodOptional<z.ZodBoolean>;
-  extension: z.ZodOptional<z.ZodBoolean>;
-  deploy: z.ZodOptional<z.ZodBoolean>;
   force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
 //#endregion
 //#region src/index.d.ts
 declare const router: {
-  create: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, import("zod").ZodOptional<import("zod").ZodObject<{
-    yes: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    verbose: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    provider: import("zod").ZodOptional<import("zod").ZodEnum<{
+  create: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, z.ZodTuple<[z.ZodOptional<z.ZodString>, z.ZodObject<{
+    yes: z.ZodOptional<z.ZodBoolean>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    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: import("zod").ZodOptional<import("zod").ZodEnum<{
+    packageManager: z.ZodOptional<z.ZodEnum<{
       npm: "npm";
       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<{
+    deploy: z.ZodOptional<z.ZodBoolean>;
+    workspace: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodEnum<{
+      minimal: "minimal";
       hono: "hono";
       elysia: "elysia";
       nest: "nest";
@@ -287,16 +276,11 @@ declare const router: {
       astro: "astro";
       nuxt: "nuxt";
       "tanstack-start": "tanstack-start";
-      turborepo: "turborepo";
     }>>;
-    skills: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    mcp: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    extension: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    deploy: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    force: import("zod").ZodOptional<import("zod").ZodBoolean>;
-  }, import("zod/v4/core").$strip>>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+    force: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>], null>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
 };
-declare function createCreatePrismaCli(): import("trpc-cli").TrpcCli;
+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, PackageManagerSchema, create, createCreatePrismaCli, router };

package/dist/index.mjs

@@ -1,3 +1,36 @@
 #!/usr/bin/env node
-import { a as CreateTemplateSchema, c as PackageManagerSchema, i as CreateCommandInputSchema, l as SchemaPresetSchema, n as createCreatePrismaCli, o as DatabaseProviderSchema, r as router, s as DatabaseUrlSchema, t as create } from "./src-B3hRLZ0U.mjs";
-export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };
+import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, t as runCreateCommand } from "./create-BHt4J1kk.mjs";
+import { os } from "@orpc/server";
+import { createCli } from "trpc-cli";
+import { z } from "zod";
+
+//#region src/index.ts
+const CLI_VERSION = "0.8.0-pr.57.218.1";
+const CreateCliInputSchema = z.tuple([z.string().trim().min(1, "Please enter a valid project name").optional().describe("Project name / directory"), CreateCommandInputSchema]);
+function normalizeCreateCliInput(input) {
+	const [projectName, options] = input;
+	return {
+		...options,
+		name: options.name ?? projectName
+	};
+}
+const router = os.router({ create: os.meta({
+	description: "Create a new project with Prisma setup",
+	default: true,
+	negateBooleans: true
+}).input(CreateCliInputSchema).handler(async ({ input }) => {
+	await runCreateCommand(normalizeCreateCliInput(input));
+}) });
+function createCreatePrismaCli() {
+	return createCli({
+		router,
+		name: "create-prisma",
+		version: CLI_VERSION
+	});
+}
+async function create(input = {}) {
+	await runCreateCommand(input);
+}
+
+//#endregion
+export { AuthoringStyleSchema, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "create-prisma",
-  "version": "0.7.2",
+  "version": "0.8.0-pr.57.218.1",
   "private": false,
-  "description": "Create Prisma 7 projects with first-party templates and great DX.",
+  "description": "Create Prisma 8 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",
   "bugs": {
     "url": "https://github.com/prisma/create-prisma/issues"
@@ -33,9 +33,12 @@
     }
   },
   "scripts": {
-    "build": "tsdown --config-loader native",
-    "dev": "tsdown --config-loader native --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "start": "bun run ./dist/cli.mjs",
+    "test": "bun run test:unit && bun run test:e2e",
+    "test:unit": "bun test ./tests/dependencies.test.ts ./tests/deploy-with-composer.test.ts ./tests/install.test.ts ./tests/node-version.test.ts ./tests/setup-prisma.test.ts ./tests/telemetry.test.ts",
+    "test:e2e": "bun test --timeout 180000 ./tests/e2e/create-prisma.e2e.test.ts",
     "check": "bun run format:check && bun run lint",
     "lint": "oxlint . --deny-warnings",
     "lint:fix": "oxlint . --fix",
@@ -47,28 +50,30 @@
     "release-notes": "bunx changelogithub"
   },
   "dependencies": {
-    "@clack/prompts": "^1.6.0",
-    "@orpc/server": "^1.14.6",
+    "@clack/prompts": "^1.7.0",
+    "@orpc/server": "^1.13.5",
     "execa": "^9.6.1",
-    "fs-extra": "^11.3.5",
-    "handlebars": "^4.7.9",
-    "posthog-node": "^5.38.2",
-    "trpc-cli": "^0.15.1",
-    "zod": "^4.4.3"
+    "fs-extra": "^11.3.3",
+    "handlebars": "^4.7.8",
+    "posthog-node": "^5.28.2",
+    "trpc-cli": "^0.12.4",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.14",
+    "@prisma/dev": "0.24.7",
+    "@types/bun": "^1.3.9",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^26.0.0",
+    "@types/node": "^25.3.0",
     "changelogithub": "^14.0.0",
-    "oxfmt": "^0.56.0",
-    "oxlint": "^1.71.0",
-    "tsdown": "^0.22.3",
-    "typescript": "^6.0.3"
+    "mongodb-memory-server": "11.1.0",
+    "oxfmt": "^0.37.0",
+    "oxlint": "^1.52.0",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "bun": ">=1.3.0",
-    "node": ">=18.0.0"
+    "node": ">=22.18.0"
   },
-  "packageManager": "bun@1.3.14"
+  "packageManager": "bun@1.3.9"
 }

package/templates/create/_shared/.gitattributes.hbs

@@ -0,0 +1,11 @@
+{{#if (eq authoring "typescript")}}
+src/prisma/generated/contract.json linguist-generated
+src/prisma/generated/contract.d.ts linguist-generated
+{{else}}
+src/prisma/contract.json linguist-generated
+src/prisma/contract.d.ts linguist-generated
+{{/if}}
+src/prisma/ops.json linguist-generated
+src/prisma/migration.json linguist-generated
+migrations/snapshots/**/contract.json linguist-generated
+migrations/snapshots/**/contract.d.ts linguist-generated

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

@@ -0,0 +1,72 @@
+# {{projectName}}
+
+{{#if (eq packageManager "deno")}}
+A minimal Prisma 8 app for Deno and PostgreSQL.
+
+## Run locally
+
+Copy `.env.example` to `.env`, set `DATABASE_URL`, then initialize the database:
+
+```bash
+deno task db:init
+```
+
+Start the app:
+
+```bash
+deno task dev
+```
+
+The starter users are inserted idempotently from `src/prisma/seed.ts` on the first database query.
+
+## Prisma
+
+- Contract: `src/prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}`
+- Prisma config: `prisma-next.config.ts`
+
+After changing the contract, run:
+
+```bash
+deno task contract:emit
+```
+
+Prisma Compute does not support Deno deployments yet.
+{{else}}
+A minimal {{template}} app with Prisma 8 and Prisma Composer.
+
+## Run locally
+
+```bash
+{{runScriptCommand packageManager "dev:composer"}}
+```
+
+This builds the app and starts it with Composer. PostgreSQL projects get a local Prisma Postgres database and apply the contract automatically.
+
+## Deploy
+
+```bash
+{{runScriptCommand packageManager "deploy"}}
+```
+
+The deploy script builds the framework output, provisions Prisma Postgres when selected, applies migrations, and deploys the app to Prisma Compute.
+
+The starter users are inserted idempotently from `src/prisma/seed.ts` on the first database query through the Composer service binding.
+
+{{#if (eq provider "mongo")}}
+MongoDB is not provisioned by Composer. Set `MONGODB_URL` before running Composer locally or deploying.
+{{/if}}
+
+## Prisma
+
+- Contract: `src/prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}`
+- Prisma and Composer config: `prisma.config.ts`
+- Composer app: `module.ts` and `service.ts`
+
+After changing the contract, run:
+
+```bash
+{{runScriptCommand packageManager "contract:emit"}}
+```
+
+To use the framework's development server directly, run `{{runScriptCommand packageManager "dev"}}`. This direct mode requires `DATABASE_URL`.
+{{/if}}

package/templates/create/_shared/module.ts.hbs

@@ -0,0 +1,30 @@
+{{#unless (eq packageManager "deno")}}
+import { module } from "@prisma/composer";
+{{#if (eq provider "postgres")}}
+import { pnPostgres } from "@prisma/composer-prisma-cloud/prisma-next";
+
+import { appContract } from "./src/prisma/composer.ts";
+{{else}}
+import { envSecret } from "@prisma/composer-prisma-cloud";
+{{/if}}
+import app from "./service.ts";
+
+export default module("{{projectName}}", ({ provision }) => {
+{{#if (eq provider "postgres")}}
+  const database = provision(
+    pnPostgres({
+      name: "database",
+      contract: appContract,
+      config: "./prisma.config.ts",
+    }),
+    { id: "database" },
+  );
+
+  provision(app, { deps: { database } });
+{{else}}
+  provision(app, {
+    input: { databaseUrl: envSecret("MONGODB_URL") },
+  });
+{{/if}}
+});
+{{/unless}}

package/templates/create/_shared/pnpm-workspace.yaml.hbs

@@ -0,0 +1,16 @@
+{{#if (eq packageManager "pnpm")}}
+allowBuilds:
+  esbuild: true
+  msgpackr-extract: true
+{{#if (eq template "next")}}
+  sharp: true
+  unrs-resolver: true
+{{else if (eq template "astro")}}
+  sharp: true
+{{/if}}
+  workerd: true
+minimumReleaseAgeExclude:
+  - "@prisma/*"
+overrides:
+  effect: "4.0.0-beta.103"
+{{/if}}

package/templates/create/_shared/prisma-composer.config.ts.hbs

@@ -0,0 +1,13 @@
+{{#unless (eq packageManager "deno")}}
+import { defineConfig } from "@prisma/composer/config";
+import { nodeBuild } from "@prisma/composer/node/control";
+{{#if (eq template "next")}}
+import { nextjsBuild } from "@prisma/composer/nextjs/control";
+{{/if}}
+import { prismaCloud, prismaState } from "@prisma/composer-prisma-cloud/control";
+
+export default defineConfig({
+  extensions: [prismaCloud(), nodeBuild(){{#if (eq template "next")}}, nextjsBuild(){{/if}}],
+  state: prismaState(),
+});
+{{/unless}}

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

@@ -0,0 +1,19 @@
+{{#unless (eq packageManager "deno")}}
+import { definePrismaConfig } from "@prisma/cli-engine";
+import { defineConfig as ormConfig } from "@prisma/orm-{{#if (eq provider "postgres")}}postgres{{else}}mongo{{/if}}/config";
+
+export default definePrismaConfig({
+  orm: ormConfig({
+    contract: "./src/prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}",
+{{#if (eq authoring "typescript")}}
+    output: "./src/prisma/generated",
+{{/if}}
+    db: {
+      connection: process.env.{{#if (eq provider "postgres")}}DATABASE_URL{{else}}MONGODB_URL{{/if}}!,
+    },
+  }),
+  composer: {
+    configPath: "./prisma-composer.config.ts",
+  },
+});
+{{/unless}}

package/templates/create/_shared/service.ts.hbs

@@ -0,0 +1,44 @@
+{{#unless (eq packageManager "deno")}}
+{{#if (eq template "next")}}
+import nextjs from "@prisma/composer/nextjs";
+{{else}}
+import node from "@prisma/composer/node";
+{{/if}}
+{{#if (eq provider "mongo")}}
+import { secretString } from "@prisma/composer/arktype";
+import { type } from "arktype";
+{{/if}}
+import { compute } from "@prisma/composer-prisma-cloud";
+{{#if (eq provider "postgres")}}
+import { pnPostgres } from "@prisma/composer-prisma-cloud/prisma-next";
+
+import { appContract } from "./src/prisma/composer.ts";
+{{/if}}
+
+export default compute({
+  name: "app",
+  deps: {
+{{#if (eq provider "postgres")}}
+    database: pnPostgres(appContract),
+{{/if}}
+  },
+{{#if (eq provider "mongo")}}
+  input: type({
+    databaseUrl: secretString(),
+  }),
+{{/if}}
+{{#if (eq template "next")}}
+  build: nextjs({ module: import.meta.url, appDir: "." }),
+{{else if (eq template "svelte")}}
+  build: node({ module: import.meta.url, dir: "./build", entry: "index.js" }),
+{{else if (eq template "astro")}}
+  build: node({ module: import.meta.url, dir: "./dist", entry: "server/entry.mjs" }),
+{{else if (eq template "nuxt")}}
+  build: node({ module: import.meta.url, dir: "./.output", entry: "server/index.mjs" }),
+{{else if (eq template "tanstack-start")}}
+  build: node({ module: import.meta.url, dir: "./.output", entry: "server/index.mjs" }),
+{{else}}
+  build: node({ module: import.meta.url, entry: "./dist/server.mjs" }),
+{{/if}}
+});
+{{/unless}}

package/templates/create/_shared/src/prisma/composer.ts.hbs

@@ -0,0 +1,10 @@
+{{#unless (eq packageManager "deno")}}
+{{#if (eq provider "postgres")}}
+import { pnContract } from "@prisma/composer-prisma-cloud/prisma-next";
+
+import type { Contract } from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.d.ts";
+import contractJson from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.json" with { type: "json" };
+
+export const appContract = pnContract<Contract>(contractJson);
+{{/if}}
+{{/unless}}

package/templates/create/_shared/src/prisma/db.ts.hbs

@@ -0,0 +1,63 @@
+{{#if (eq provider "postgres")}}
+import postgres from "@prisma/orm-postgres/runtime";
+
+{{#if (eq packageManager "deno")}}
+import type { Contract } from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.d.ts";
+import contractJson from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.json" with { type: "json" };
+
+const databaseUrl = Deno.env.get("DATABASE_URL");
+if (!databaseUrl) {
+  throw new Error("DATABASE_URL is not set. Add it to .env before starting the app.");
+}
+
+export const db = postgres<Contract>({ contractJson, url: databaseUrl });
+{{else}}
+import service from "../../service.ts";
+import type { Contract } from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.d.ts";
+import contractJson from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.json" with { type: "json" };
+
+function loadComposerDatabase() {
+  try {
+    return service.load().database.client;
+  } catch {
+    return undefined;
+  }
+}
+
+export const db =
+  loadComposerDatabase() ??
+  (process.env.DATABASE_URL
+    ? postgres<Contract>({ contractJson, url: process.env.DATABASE_URL })
+    : postgres<Contract>({ contractJson }));
+{{/if}}
+{{else}}
+import mongo from "@prisma/orm-mongo/runtime";
+
+import service from "../../service.ts";
+import type { Contract } from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.d.ts";
+import contractJson from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.json" with { type: "json" };
+
+function getDatabaseUrl(): string | undefined {
+  try {
+    return service.input().databaseUrl.expose();
+  } catch {
+    return process.env.DATABASE_URL;
+  }
+}
+
+const databaseUrl = getDatabaseUrl();
+
+export const db = databaseUrl
+  ? mongo<Contract>({ contractJson, url: databaseUrl })
+  : mongo<Contract>({ contractJson });
+{{/if}}
+
+let connection: Promise<void> | undefined;
+
+export function connectDatabase(): Promise<void> {
+  connection ??= db.connect().then(() => undefined).catch((error: unknown) => {
+    connection = undefined;
+    throw error;
+  });
+  return connection;
+}

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

@@ -0,0 +1,36 @@
+import { connectDatabase, db } from "./db.ts";
+
+const users = [
+  { email: "alice@prisma.io", username: "alice", name: "Alice" },
+  { email: "bob@prisma.io", username: "bob", name: "Bob" },
+  { email: "carol@prisma.io", username: "carol", name: "Carol" },
+];
+
+let pendingSeed: Promise<void> | undefined;
+
+async function runSeed(): Promise<void> {
+  await connectDatabase();
+
+{{#if (eq provider "mongo")}}
+  for (const user of users) {
+    const existingUser = await db.orm.users.where({ email: user.email }).first();
+    if (!existingUser) await db.orm.users.create(user);
+  }
+{{else}}
+  for (const user of users) {
+    await db.orm.public.User.upsert({
+      create: user,
+      update: {},
+      conflictOn: { email: user.email },
+    });
+  }
+{{/if}}
+}
+
+export function seed(): Promise<void> {
+  pendingSeed ??= runSeed().catch((error: unknown) => {
+    pendingSeed = undefined;
+    throw error;
+  });
+  return pendingSeed;
+}

package/templates/create/_shared/src/prisma/users.ts.hbs

@@ -0,0 +1,35 @@
+import { db } from "./db.ts";
+import { seed } from "./seed.ts";
+
+export { db };
+
+export async function listUsers(limit = 10) {
+  await seed();
+{{#if (eq provider "mongo")}}
+  const users = [];
+
+  for await (const user of db.orm.users.select("_id", "email", "username", "name").take(limit).all()) {
+    users.push({
+      id: String(user._id),
+      email: user.email,
+      username: user.username ?? null,
+      name: user.name ?? null,
+      createdAt: null as Date | null,
+    });
+  }
+
+  return users;
+{{else}}
+  const users = await db.orm.public.User.select("id", "email", "username", "name", "createdAt").take(limit).all();
+
+  return users.map((user) => ({
+    id: String(user.id),
+    email: user.email,
+    username: user.username ?? null,
+    name: user.name ?? null,
+    createdAt: user.createdAt,
+  }));
+{{/if}}
+}
+
+export type StarterUser = Awaited<ReturnType<typeof listUsers>>[number];

package/templates/create/astro/{astro.config.mjs.hbs → astro.config.mjs}

@@ -1,10 +1,9 @@
 // @ts-check
-import { defineConfig } from "astro/config";
 import node from "@astrojs/node";
+import { defineConfig } from "astro/config";
 
 // https://astro.build/config
 export default defineConfig({
   output: "server",
   adapter: node({ mode: "standalone" }),
-  server: { host: true },
 });