create-prisma 0.4.2-pr.53.196.1 → 0.4.2-pr.53.198.1

package/dist/cli.mjs

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

package/dist/{create-Bpm3olVB.mjs → create-BHcAcUH1.mjs}

@@ -40,7 +40,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.4.2-pr.53.196.1",
+		"cli-version": "0.4.2-pr.53.198.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch

package/dist/index.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, t as runCreateCommand } from "./create-Bpm3olVB.mjs";
+import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, t as runCreateCommand } from "./create-BHcAcUH1.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 import { z } from "zod";
 
 //#region src/index.ts
-const CLI_VERSION = "0.4.2-pr.53.196.1";
+const CLI_VERSION = "0.4.2-pr.53.198.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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.4.2-pr.53.196.1",
+  "version": "0.4.2-pr.53.198.1",
   "private": false,
   "description": "Create Prisma 8 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",

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

@@ -18,7 +18,7 @@ This builds the app and starts it with Composer. PostgreSQL projects get a local
 
 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 on the first database query. `{{runScriptCommand packageManager "db:seed"}}` can also seed an explicit `DATABASE_URL`; for local PostgreSQL it reuses the database created by `dev:composer`.
+The starter users are inserted idempotently on the first database query through the Composer service binding. `{{runScriptCommand packageManager "db:seed"}}` starts the app with Composer, seeds through its database route, and stops it again. If `DATABASE_URL` is set explicitly, the command seeds that database directly instead.
 
 {{#if (eq provider "mongo")}}
 MongoDB is not provisioned by Composer. Set `MONGODB_URL` before running Composer locally or deploying.

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

@@ -1,38 +1,97 @@
 import "dotenv/config";
-{{#if (eq provider "postgres")}}
-import { readFile } from "node:fs/promises";
+import { spawn, type ChildProcess } from "node:child_process";
+
+const seedPath = {{#if (eq template "astro")}}"/api/users"{{else if (eq template "nuxt")}}"/api/users"{{else if (eq template "hono")}}"/users"{{else if (eq template "elysia")}}"/users"{{else if (eq template "nest")}}"/users"{{else}}"/"{{/if}};
+
+async function seedExplicitDatabase(): Promise<void> {
+  const [{ db }, { seedStarterData }] = await Promise.all([
+    import("./db.ts"),
+    import("./starter-data.ts"),
+  ]);
 
-async function loadComposerDevDatabaseUrl(): Promise<string | undefined> {
   try {
-    const contents = await readFile(
-      new URL("../../.prisma-composer/dev/env.json", import.meta.url),
-      "utf8",
-    );
-    const env = JSON.parse(contents) as Record<string, unknown>;
-    const value = env.COMPOSER_APP_DATABASE_URL;
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-  } catch {
-    return undefined;
+    await seedStarterData();
+  } finally {
+    await db.close();
   }
 }
 
-process.env.DATABASE_URL ??= await loadComposerDevDatabaseUrl();
-{{/if}}
+function stopComposer(child: ChildProcess): void {
+  if (child.exitCode !== null || child.pid === undefined) return;
+  try {
+    if (process.platform === "win32") child.kill("SIGINT");
+    else process.kill(-child.pid, "SIGINT");
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) throw error;
+  }
+}
 
-if (!process.env.DATABASE_URL) {
-  throw new Error(
-    "DATABASE_URL is not set. Run dev:composer once to create the local database, or set DATABASE_URL explicitly.",
-  );
+async function requestStarterUsers(origin: string): Promise<void> {
+  let lastStatus = 0;
+  for (let attempt = 0; attempt < 30; attempt += 1) {
+    try {
+      const response = await fetch(new URL(seedPath, origin));
+      const body = await response.text();
+      lastStatus = response.status;
+      if (response.ok && ["Alice", "Bob", "Carol"].every((name) => body.includes(name))) return;
+    } catch {
+      // The service may still be accepting its first connection after Composer reports ready.
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1_000));
+  }
+  throw new Error(`The app's database route did not return the starter users (HTTP ${lastStatus}).`);
 }
 
-const [{ db }, { seedStarterData }] = await Promise.all([
-  import("./db.ts"),
-  import("./starter-data.ts"),
-]);
+async function seedThroughComposer(): Promise<void> {
+  const child = spawn("{{packageManager}}", ["run", "dev:composer"], {
+    cwd: new URL("../..", import.meta.url),
+    detached: process.platform !== "win32",
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
 
-try {
-  await seedStarterData();
-  console.log("Starter users are ready.");
-} finally {
-  await db.close();
+  let output = "";
+  let settled = false;
+  const ready = new Promise<string>((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("Timed out waiting for composer dev.")), 120_000);
+    const consume = (chunk: Buffer) => {
+      const text = chunk.toString();
+      output = `${output}${text}`.slice(-20_000);
+      if (!settled) process.stderr.write(text);
+      const url = output.match(/\bapp(?::|\s+)\s+(http:\/\/(?:127\.0\.0\.1|localhost):\d+)/)?.[1];
+      if (url && !settled) {
+        settled = true;
+        clearTimeout(timeout);
+        resolve(url);
+      }
+    };
+    child.stdout?.on("data", consume);
+    child.stderr?.on("data", consume);
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("exit", (code) => {
+      if (settled) return;
+      clearTimeout(timeout);
+      reject(new Error(`composer dev exited before the app was ready (code ${String(code)}).`));
+    });
+  });
+
+  const stopOnSignal = () => stopComposer(child);
+  process.once("SIGINT", stopOnSignal);
+  process.once("SIGTERM", stopOnSignal);
+  try {
+    const origin = await ready;
+    await requestStarterUsers(origin);
+  } finally {
+    process.removeListener("SIGINT", stopOnSignal);
+    process.removeListener("SIGTERM", stopOnSignal);
+    stopComposer(child);
+  }
 }
+
+if (process.env.DATABASE_URL) await seedExplicitDatabase();
+else await seedThroughComposer();
+
+console.log("Starter users are ready.");