create-lumen 2.0.0-beta.1 → 2.0.0-beta.2

package/src/engine/composition.js

@@ -41,10 +41,13 @@ export const TOOLING_ORDER = [
   "router",
   "icons",
   "api",
+  "database",
   "testing",
   "linter",
   "feature-script",
   "next-config",
+  "route-groups",
+  "docker",
   "formatter",
 ];
 
@@ -174,6 +177,19 @@ export function resolveFragments(responses = {}, templatesDir) {
     sourceDir: archSrcDir,
     targetDir: "src",
     action: async ({ projectPath }) => {
+      if (fw.name === "next") {
+        if (fw.variant === "pages-router") {
+          try { await fsp.rm(path.join(projectPath, "src", "app"), { recursive: true, force: true }); } catch {}
+        } else {
+          // Next App Router: preserve file-system routes; purge React/Vite-specific application layer
+          try { await fsp.rm(path.join(projectPath, "src", "app", "App.tsx"), { force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "App.jsx"), { force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "hooks"), { recursive: true, force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "contexts"), { recursive: true, force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "providers"), { recursive: true, force: true }); } catch {}
+        }
+        return;
+      }
       // Copy architecture main entry
       try {
         await fsp.access(archMainSrc);
@@ -204,6 +220,16 @@ export function resolveFragments(responses = {}, templatesDir) {
       id: `styling:${cssFramework}:components`,
       sourceDir: componentStylesDir,
       targetDir: "src",
+      action: async ({ projectPath }) => {
+        if (fw.name === "next") {
+          if (fw.variant === "pages-router") {
+            try { await fsp.rm(path.join(projectPath, "src", "app"), { recursive: true, force: true }); } catch {}
+          } else {
+            try { await fsp.rm(path.join(projectPath, "src", "app", "App.tsx"), { force: true }); } catch {}
+            try { await fsp.rm(path.join(projectPath, "src", "app", "App.jsx"), { force: true }); } catch {}
+          }
+        }
+      },
     });
   }
 
@@ -220,6 +246,7 @@ export function resolveFragments(responses = {}, templatesDir) {
       sourceDir: path.join(templatesDir, "conditional", "state", "redux", architecture, "src"),
       targetDir: "src",
       action: async ({ projectPath }) => {
+        if (fw.name === "next") return;
         await updateMainWithProvider(projectPath, "redux", architecture, ext);
       },
     });
@@ -316,6 +343,106 @@ export function resolveFragments(responses = {}, templatesDir) {
       id: `tooling:api:${responses.apiClient}`,
       sourceDir: apiDir,
       targetDir: "src",
+      action: async ({ projectPath }) => {
+        if (fw.name === "next") {
+          const configCandidates = [
+            path.join(projectPath, "src", "config", `axios.config.${extConfig}`),
+            path.join(projectPath, "src", "shared", "lib", "axios", `api.config.${extConfig}`),
+            path.join(projectPath, "src", "config", `api.config.${extConfig}`),
+            path.join(projectPath, "src", "shared", "api", `api.config.${extConfig}`),
+          ];
+          for (const cfgPath of configCandidates) {
+            try {
+              let content = await fsp.readFile(cfgPath, "utf8");
+              if (content.includes("import.meta.env.VITE_API_URL")) {
+                content = content.replace(
+                  /import\.meta\.env\.VITE_API_URL/g,
+                  "process.env.NEXT_PUBLIC_API_URL"
+                );
+                await fsp.writeFile(cfgPath, content, "utf8");
+              }
+            } catch {}
+          }
+        }
+      },
+    });
+  }
+
+  // 5.45 Database (Prisma)
+  if (responses.database === "prisma") {
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "database",
+      id: "tooling:database:prisma",
+      scripts: {
+        "db:generate": "prisma generate",
+        "db:push": "prisma db push",
+        "db:seed": "prisma db seed",
+        "db:studio": "prisma studio",
+      },
+      action: async ({ projectPath, templatesDir: tDir }) => {
+        const prismaTplDir = path.join(tDir, "conditional", "database", "prisma");
+        const prismaDir = path.join(projectPath, "prisma");
+        await fsp.mkdir(prismaDir, { recursive: true });
+
+        // Copy schema.prisma
+        const schemaSrc = path.join(prismaTplDir, "schema.prisma");
+        const schemaDest = path.join(prismaDir, "schema.prisma");
+        try {
+          await fsp.access(schemaSrc);
+          await fsp.copyFile(schemaSrc, schemaDest);
+        } catch {}
+
+        // Copy seed file: prisma/seed.ts or prisma/seed.js
+        const seedFileName = language === "ts" ? "seed.ts" : "seed.js";
+        const seedSrc = path.join(prismaTplDir, seedFileName);
+        const seedDest = path.join(prismaDir, seedFileName);
+        try {
+          await fsp.access(seedSrc);
+          await fsp.copyFile(seedSrc, seedDest);
+        } catch {}
+
+        // Copy client singleton: src/lib/db.ts or src/lib/db.js
+        const libDir = path.join(projectPath, "src", "lib");
+        await fsp.mkdir(libDir, { recursive: true });
+        const dbFileName = language === "ts" ? "db.ts" : "db.js";
+        const dbSrc = path.join(prismaTplDir, dbFileName);
+        const dbDest = path.join(libDir, dbFileName);
+        try {
+          await fsp.access(dbSrc);
+          await fsp.copyFile(dbSrc, dbDest);
+        } catch {}
+
+        // Configure prisma.seed in package.json
+        const pkgPath = path.join(projectPath, "package.json");
+        try {
+          const content = await fsp.readFile(pkgPath, "utf8");
+          const pkg = JSON.parse(content);
+          pkg.prisma = {
+            seed: language === "ts" ? "tsx prisma/seed.ts" : "node prisma/seed.js",
+          };
+          await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+        } catch {}
+
+        // Append DATABASE_URL and DIRECT_URL to .env.example
+        const envExamplePath = path.join(projectPath, ".env.example");
+        const envLines = [
+          "",
+          "# Database (Prisma + PostgreSQL / Supabase)",
+          'DATABASE_URL="postgresql://postgres:[YOUR-PASSWORD]@db.[YOUR-PROJECT-REF].supabase.co:5432/postgres"',
+          'DIRECT_URL="postgresql://postgres:[YOUR-PASSWORD]@db.[YOUR-PROJECT-REF].supabase.co:5432/postgres"',
+        ].join("\n");
+        try {
+          let envContent = "";
+          try {
+            envContent = await fsp.readFile(envExamplePath, "utf8");
+          } catch {}
+          if (!envContent.includes("DATABASE_URL")) {
+            envContent = envContent.trimEnd() + "\n" + envLines.trimStart() + "\n";
+            await writeFileRecursive(envExamplePath, envContent);
+          }
+        } catch {}
+      },
     });
   }
 
@@ -335,11 +462,26 @@ export function resolveFragments(responses = {}, templatesDir) {
       scripts: testScripts,
       action: async ({ projectPath }) => {
         // Config file to project root
-        const configSrc = path.join(testingDir, `${testingFramework}.config.${extConfig}`);
-        try {
-          await fsp.access(configSrc);
-          await fsp.copyFile(configSrc, path.join(projectPath, `${testingFramework}.config.${extConfig}`));
-        } catch {}
+        if (testingFramework === "jest" && fw.name === "next") {
+          const nextConfigExt = language === "ts" ? "ts" : "mjs";
+          const configSrc = path.join(testingDir, "next", `jest.config.${nextConfigExt}`);
+          try {
+            await fsp.access(configSrc);
+            await fsp.copyFile(configSrc, path.join(projectPath, `jest.config.${nextConfigExt}`));
+          } catch {}
+        } else if (testingFramework === "vitest" && fw.name === "next") {
+          const configSrc = path.join(testingDir, "next", `vitest.config.${extConfig}`);
+          try {
+            await fsp.access(configSrc);
+            await fsp.copyFile(configSrc, path.join(projectPath, `vitest.config.${extConfig}`));
+          } catch {}
+        } else {
+          const configSrc = path.join(testingDir, `${testingFramework}.config.${extConfig}`);
+          try {
+            await fsp.access(configSrc);
+            await fsp.copyFile(configSrc, path.join(projectPath, `${testingFramework}.config.${extConfig}`));
+          } catch {}
+        }
 
         // Setup file to src/test/setup.*
         const setupSrc = path.join(testingDir, `src/test/setup.${extConfig}`);
@@ -355,20 +497,39 @@ export function resolveFragments(responses = {}, templatesDir) {
             await fsp.access(jestSetupSrc);
             await fsp.copyFile(jestSetupSrc, path.join(projectPath, `jest.setup.${extConfig}`));
           } catch {}
-          const babelSrc = path.join(testingDir, "babel.config.cjs");
+          if (fw.name !== "next") {
+            const babelSrc = path.join(testingDir, "babel.config.cjs");
+            try {
+              await fsp.access(babelSrc);
+              await fsp.copyFile(babelSrc, path.join(projectPath, "babel.config.cjs"));
+            } catch {}
+          }
+        }
+
+        if (fw.name === "next") {
+          const testFileName = fw.variant === "pages-router" ? "index" : "page";
+          const testSrc = path.join(
+            testingDir,
+            "next",
+            fw.variant,
+            "src",
+            "__tests__",
+            `${testFileName}.test.${ext}`
+          );
+          try {
+            await fsp.access(testSrc);
+            const testDest = path.join(projectPath, "src", "__tests__", `${testFileName}.test.${ext}`);
+            await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
+          } catch {}
+        } else {
+          // Architecture-scoped test file
+          const testSrc = path.join(testingDir, architecture, `src/__tests__/App.test.${ext}`);
           try {
-            await fsp.access(babelSrc);
-            await fsp.copyFile(babelSrc, path.join(projectPath, "babel.config.cjs"));
+            await fsp.access(testSrc);
+            const testDest = path.join(projectPath, "src", "__tests__", `App.test.${ext}`);
+            await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
           } catch {}
         }
-
-        // Architecture-scoped test file
-        const testSrc = path.join(testingDir, architecture, `src/__tests__/App.test.${ext}`);
-        try {
-          await fsp.access(testSrc);
-          const testDest = path.join(projectPath, "src", "__tests__", `App.test.${ext}`);
-          await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
-        } catch {}
       },
     });
   }
@@ -525,11 +686,75 @@ export function resolveFragments(responses = {}, templatesDir) {
             }
           } catch {}
         }
+
+        // Apply standalone output to next.config if docker is enabled
+        if (responses.docker === true) {
+          const targetConfigPath = path.join(projectPath, `next.config.${configExt}`);
+          try {
+            let content = await fsp.readFile(targetConfigPath, "utf8");
+            if (!content.includes('"standalone"') && !content.includes("'standalone'")) {
+              content = content.replace(
+                /const nextConfig(?::\s*NextConfig)?\s*=\s*\{/,
+                (match) => `${match}\n  output: "standalone",`
+              );
+              await fsp.writeFile(targetConfigPath, content, "utf8");
+            }
+          } catch {}
+        }
+      },
+    });
+  }
+
+  // 5.8 Route Groups Preset & Auth Proxy Template (#64)
+  if (responses.routeGroups === true && fw.name === "next" && fw.variant === "app-router") {
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "route-groups",
+      id: "tooling:next:route-groups",
+      sourceDir: path.join(templatesDir, "conditional", "next", "route-groups", language),
+      targetDir: "",
+      action: async ({ projectPath }) => {
+        // Remove colliding root page so it does not collide with (public)/page
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", `page.${ext}`), { force: true });
+        } catch {}
+        const oppositeExt = language === "ts" ? "jsx" : "tsx";
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", `page.${oppositeExt}`), { force: true });
+        } catch {}
+        // Also remove page.js / page.tsx in case base provider was named page.js
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", "page.js"), { force: true });
+        } catch {}
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", "page.tsx"), { force: true });
+        } catch {}
+      },
+    });
+  }
+
+  // 5.9 Docker (Multi-stage Dockerfile and docker-compose for Next.js standalone)
+  if (responses.docker === true && hasCapability(fw, CAPABILITIES.DOCKER)) {
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "docker",
+      id: "tooling:docker",
+      action: async ({ projectPath }) => {
+        const dockerSrcDir = path.join(templatesDir, "conditional", "docker");
+        const filesToCopy = ["Dockerfile", ".dockerignore", "docker-compose.yml"];
+        for (const file of filesToCopy) {
+          const srcFile = path.join(dockerSrcDir, file);
+          const destFile = path.join(projectPath, file);
+          try {
+            await fsp.access(srcFile);
+            await fsp.copyFile(srcFile, destFile);
+          } catch {}
+        }
       },
     });
   }
 
-  // 5.8 Formatter
+  // 5.10 Formatter
   if (responses.formatter && responses.formatter !== "none") {
     const isPrettier = responses.formatter === "prettier";
     const configFile = isPrettier ? ".prettierrc" : ".oxfmtrc.json";

package/src/env.js

@@ -1,5 +1,6 @@
 import path from "path";
 import { promises as fsp } from "fs";
+import { normalizeFramework } from "./engine/capabilities.js";
 
 const ENV_GITIGNORE = `
 # Environment variables
@@ -8,12 +9,29 @@ const ENV_GITIGNORE = `
 !.env.example
 `;
 
-export async function copyEnvExample(projectPath, templatesDir) {
-  const src = path.join(templatesDir, ".env.example");
-  try {
-    await fsp.access(src);
-    await fsp.copyFile(src, path.join(projectPath, ".env.example"));
-  } catch {}
+const NEXT_ENV_EXAMPLE = `# Copy this file to \`.env.local\` (or \`.env\`) and fill in your values.
+# See https://nextjs.org/docs/app/building-your-application/configuring/environment-variables for details.
+
+NEXT_PUBLIC_API_URL=https://api.example.com
+`;
+
+export async function copyEnvExample(projectPath, templatesDir, responses = {}) {
+  const fw = normalizeFramework(
+    responses.framework || {
+      name: responses.frameworkName,
+      variant: responses.frameworkVariant,
+    }
+  );
+
+  if (fw.name === "next") {
+    await fsp.writeFile(path.join(projectPath, ".env.example"), NEXT_ENV_EXAMPLE, "utf8");
+  } else {
+    const src = path.join(templatesDir, ".env.example");
+    try {
+      await fsp.access(src);
+      await fsp.copyFile(src, path.join(projectPath, ".env.example"));
+    } catch {}
+  }
 
   // Ensure the project gitignore excludes env files but keeps .env.example.
   const gitignore = path.join(projectPath, ".gitignore");

package/src/main.js

@@ -257,7 +257,7 @@ export async function main(options = {}) {
   await cleanupBoilerplate(projectPath);
 
   // 12.5 Copy .env.example into the project
-  await copyEnvExample(projectPath, TEMPLATES_DIR);
+  await copyEnvExample(projectPath, TEMPLATES_DIR, responses);
 
   // 12.6 Emit lumen.config.json (manifest v2) — byte-deterministic, Zod-validated
   const manifestSpin = spinner();
@@ -270,15 +270,15 @@ export async function main(options = {}) {
     throw err;
   }
 
-  // 12.7 Emit .lumen agent context dir (only when agentDocs is enabled)
+  // 12.7 Emit AGENTS.md at root (only when agentDocs is enabled)
   if (responses.agentDocs === true || responses._manifestSource?.agentDocs === true) {
     const agentSpin = spinner();
-    agentSpin.start("Writing .lumen agent context...");
+    agentSpin.start("Writing AGENTS.md...");
     try {
       await emitAgentContext(projectPath, responses._manifestSource ?? responses);
-      agentSpin.stop(chalk.green(".lumen agent context written."));
+      agentSpin.stop(chalk.green("AGENTS.md written."));
     } catch (err) {
-      agentSpin.stop(chalk.red("Failed to write .lumen agent context."));
+      agentSpin.stop(chalk.red("Failed to write AGENTS.md."));
       throw err;
     }
   }

package/src/manifest/emit.js

@@ -117,8 +117,18 @@ export function buildManifest(responses, opts = {}) {
   };
 
   // Optional cross-cutting flags — only include if explicitly set (keeps minimal manifest byte-stable)
+  if (responses.database && responses.database !== "none") {
+    manifest.database = {
+      orm: responses.database,
+      provider: "postgresql",
+    };
+  }
+  if (typeof responses.docker === "boolean") manifest.docker = responses.docker;
+  if (typeof responses.routeGroups === "boolean") manifest.routeGroups = responses.routeGroups;
   if (typeof responses.reactCompiler === "boolean") manifest.reactCompiler = responses.reactCompiler;
+  if (typeof responses.routeGroups === "boolean") manifest.routeGroups = responses.routeGroups;
   if (typeof responses.agentDocs === "boolean") manifest.agentDocs = responses.agentDocs;
+  if (typeof responses.docker === "boolean") manifest.docker = responses.docker;
 
   // Enforce stable top-level key order for determinism (like formatter pass)
   const ordered = {};
@@ -133,6 +143,9 @@ export function buildManifest(responses, opts = {}) {
     "docs",
     "paths",
     "tooling",
+    "database",
+    "docker",
+    "routeGroups",
     "reactCompiler",
     "agentDocs",
   ];

package/src/manifest/schema.js

@@ -23,6 +23,8 @@ export const DOCS_LANGUAGES = ["en", "es"];
 export const TOOLING_LANGUAGES = ["ts", "js"];
 export const TOOLING_LINTERS = ["eslint", "oxlint", "biome", "none"];
 export const TOOLING_FORMATTERS = ["prettier", "oxfmt", "none"];
+export const DATABASE_ORMS = ["prisma", "none"];
+export const DATABASE_PROVIDERS = ["postgresql"];
 
 // ---------------------------------------------------------------------------
 // Sub-schemas
@@ -121,6 +123,13 @@ const toolingSchema = z
   })
   .strict();
 
+const databaseSchema = z
+  .object({
+    orm: z.enum(DATABASE_ORMS),
+    provider: z.enum(DATABASE_PROVIDERS).optional().default("postgresql"),
+  })
+  .strict();
+
 // ---------------------------------------------------------------------------
 // Top-level manifest v2 - strict, no extra keys except $schema
 // ---------------------------------------------------------------------------
@@ -136,6 +145,9 @@ export const manifestSchemaV2 = z
     docs: docsSchema,
     paths: pathsSchema,
     tooling: toolingSchema,
+    database: databaseSchema.optional(),
+    docker: z.boolean().optional(),
+    routeGroups: z.boolean().optional(),
     reactCompiler: z.boolean().optional(),
     agentDocs: z.boolean().optional(),
   })
@@ -177,6 +189,24 @@ export const manifestSchemaV2 = z
       });
     }
 
+    // database only for Next.js (#62)
+    if (val.database !== undefined && val.database.orm !== "none" && framework.name !== "next") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["database", "orm"],
+        message: `database is only valid when framework.name is "next"`,
+      });
+    }
+
+    // routeGroups only for Next.js App Router (#64)
+    if (val.routeGroups === true && (framework.name !== "next" || framework.variant !== "app-router")) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["routeGroups"],
+        message: `routeGroups is only valid when framework is "next:app-router"`,
+      });
+    }
+
     // architecture scoping per framework (#34) — canonical `preset`, legacy `type` fallback
     const archValue = architecture.preset ?? architecture.type;
     const allowedByFramework =

package/src/prompts.js

@@ -1,4 +1,4 @@
-import { isCancel, note, select } from "@clack/prompts";
+import { isCancel, note, select } from "@clack/prompts";
 import chalk from "chalk";
 import { configExists, loadConfig, saveConfig } from "@/config-cache.js";
 import {
@@ -71,9 +71,18 @@ export function formatConfig(responses) {
   if (responses.adapter && responses.adapter !== "none") {
     lines.push(`• ${chalk.bold("Adapter:")} ${chalk.cyan(responses.adapter)}`);
   }
+  if (responses.database && responses.database !== "none") {
+    lines.push(`• ${chalk.bold("Database:")} ${chalk.cyan(responses.database === "prisma" ? "Prisma ORM" : responses.database)}`);
+  }
   if (responses.reactCompiler !== undefined) {
     lines.push(`• ${chalk.bold("React Compiler:")} ${responses.reactCompiler ? chalk.green("Yes") : chalk.red("No")}`);
   }
+  if (responses.routeGroups !== undefined) {
+    lines.push(`• ${chalk.bold("Route Groups:")} ${responses.routeGroups ? chalk.green("Yes") : chalk.red("No")}`);
+  }
+  if (responses.docker !== undefined) {
+    lines.push(`• ${chalk.bold("Docker:")} ${responses.docker ? chalk.green("Yes") : chalk.red("No")}`);
+  }
   lines.push(
     `• ${chalk.bold("State:")} ${chalk.blue(state)}`,
     `• ${chalk.bold("Icons:")} ${chalk.blue(responses.iconLibrary === "none" ? "None" : responses.iconLibrary === "lucide" ? "Lucide" : "Huge")}`,
@@ -410,7 +419,15 @@ export async function getUserInputs(
         { label: "Jest", value: "jest" },
         { label: "None", value: "none" },
       ],
-      defaultInitial: "vitest",
+      defaultInitial: (ans) => {
+        const fw = normalizeFramework(
+          ans.framework || {
+            name: ans.frameworkName,
+            variant: ans.frameworkVariant,
+          }
+        );
+        return fw.name === "next" ? "none" : "vitest";
+      },
     },
     {
       id: "router",
@@ -456,6 +473,24 @@ export async function getUserInputs(
         ]),
       defaultInitial: "none",
     },
+    {
+      id: "database",
+      skip: () => !isPromptVisible(framework, "database"),
+      onSkip: (ans) => {
+        ans.database = "none";
+      },
+      message: "Which database ORM do you want to use?",
+      getOptions: () =>
+        filterCompatibleChoices(framework, "database", [
+          {
+            label: "Prisma ORM",
+            value: "prisma",
+            hint: "PostgreSQL schema, client singleton, seed script",
+          },
+          { label: "None", value: "none" },
+        ]),
+      defaultInitial: "none",
+    },
     {
       id: "reactCompiler",
       skip: () => !isPromptVisible(framework, "reactCompiler"),
@@ -469,6 +504,32 @@ export async function getUserInputs(
       ],
       defaultInitial: false,
     },
+    {
+      id: "routeGroups",
+      skip: () => !isPromptVisible(framework, "routeGroups"),
+      onSkip: (ans) => {
+        ans.routeGroups = false;
+      },
+      message: "Include route groups preset (public, auth, private, admin)?",
+      getOptions: () => [
+        { label: "No (default)", value: false },
+        { label: "Yes", value: true },
+      ],
+      defaultInitial: false,
+    },
+    {
+      id: "docker",
+      skip: () => !isPromptVisible(framework, "docker"),
+      onSkip: (ans) => {
+        ans.docker = false;
+      },
+      message: "Include Docker setup?",
+      getOptions: () => [
+        { label: "No (default)", value: false },
+        { label: "Yes", value: true, hint: "Multi-stage Dockerfile and docker-compose" },
+      ],
+      defaultInitial: false,
+    },
     {
       id: "stateManagement",
       message: "Which state management library do you want to use?",
@@ -560,10 +621,10 @@ export async function getUserInputs(
     },
     {
       id: "agentDocs",
-      message: "Generate .lumen/ agent context for AI assistants?",
+      message: "Generate AGENTS.md for AI assistants?",
       getOptions: () => [
         { label: "No (default)", value: false },
-        { label: "Yes", value: true, hint: "Emits .lumen/ with project, architecture and conventions" },
+        { label: "Yes", value: true, hint: "Emits AGENTS.md referencing lumen.config.json (SSOT)" },
       ],
       defaultInitial: false,
     },
@@ -620,8 +681,11 @@ export async function getUserInputs(
     quickSetup: _quickSetup,
     bundler,
     adapter,
+    database,
     reactCompiler,
+    routeGroups,
     agentDocs,
+    docker,
     ...picked
   } = responses;
   // Final safety net: BACK-navigation can reselect the framework after other
@@ -638,12 +702,21 @@ export async function getUserInputs(
   if (adapter !== undefined && adapter !== "none") {
     finalResponses.adapter = adapter;
   }
+  if (database !== undefined && database !== "none") {
+    finalResponses.database = database;
+  }
   if (reactCompiler !== undefined) {
     finalResponses.reactCompiler = reactCompiler;
   }
+  if (routeGroups !== undefined) {
+    finalResponses.routeGroups = routeGroups;
+  }
   if (agentDocs !== undefined) {
     finalResponses.agentDocs = agentDocs;
   }
+  if (docker !== undefined) {
+    finalResponses.docker = docker;
+  }
 
   // No config cache write until final confirm!
   await saveConfigFn(finalResponses);

package/templates/conditional/database/prisma/db.js

@@ -0,0 +1,14 @@
+import { PrismaClient } from "@prisma/client";
+
+const globalForPrisma = globalThis;
+
+export const db =
+  globalForPrisma.prisma ||
+  new PrismaClient({
+    log:
+      process.env.NODE_ENV === "development"
+        ? ["query", "error", "warn"]
+        : ["error"],
+  });
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db;

package/templates/conditional/database/prisma/db.ts

@@ -0,0 +1,16 @@
+import { PrismaClient } from "@prisma/client";
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const db =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log:
+      process.env.NODE_ENV === "development"
+        ? ["query", "error", "warn"]
+        : ["error"],
+  });
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db;

package/templates/conditional/database/prisma/schema.prisma

@@ -0,0 +1,9 @@
+datasource db {
+  provider  = "postgresql"
+  url       = env("DATABASE_URL")
+  directUrl = env("DIRECT_URL")
+}
+
+generator client {
+  provider = "prisma-client-js"
+}