@codeyam/codeyam-cli 0.1.0-staging.8421896 → 0.1.0-staging.8778565

package/codeyam-cli/templates/nextjs-prisma-sqlite/DATABASE.md

@@ -0,0 +1,112 @@
+# Database
+
+This project uses **Prisma 7 with SQLite** for local development. No external services needed.
+
+All application code imports from `@/app/lib/prisma` — this is the only file that changes when you upgrade to a hosted database.
+
+## Quick Reference
+
+```bash
+# Edit your schema
+vim prisma/schema.prisma
+
+# Push schema changes (also regenerates Prisma client)
+npm run db:push
+
+# Seed demo data
+npm run db:seed
+
+# Reset database (delete + recreate + seed)
+npm run db:reset
+
+# Browse data visually
+npx prisma studio
+```
+
+## Using the Database
+
+```typescript
+import { prisma } from '@/app/lib/prisma';
+
+// In API routes or server components:
+const items = await prisma.todo.findMany();
+const item = await prisma.todo.create({ data: { title: 'New item' } });
+```
+
+## Important: Do NOT Change These Settings
+
+- **Generator must be `prisma-client-js`** (not `prisma-client`). The `prisma-client` generator requires a custom output path that breaks Turbopack.
+- **Do NOT add an `output` field** to the generator.
+- **Do NOT add `url` to the datasource block** in `schema.prisma`. Prisma 7 moved the URL to `prisma.config.ts`.
+- **Keep `serverExternalPackages: ["better-sqlite3"]`** in `next.config.ts`.
+- **Keep `turbopack: { root: "." }`** in `next.config.ts`.
+- **Always run `npx prisma generate`** after `npx prisma db push` (or use `npm run db:push` which does both).
+- **Database file is at project root** (`./dev.db`), not in `prisma/`.
+
+## Upgrading to a Hosted Database
+
+When you're ready for production, you'll want a hosted database. SQLite is great for prototyping, but doesn't support concurrent connections or run in serverless environments (Vercel, etc.).
+
+### Option 1: Supabase (PostgreSQL)
+
+Free tier available. Gives you PostgreSQL + auth + realtime + storage.
+
+1. Create a project at https://supabase.com/dashboard
+2. Get your credentials from Project Settings > Database > Connection string (URI)
+3. Replace packages:
+   ```bash
+   npm uninstall better-sqlite3 @prisma/adapter-better-sqlite3 @types/better-sqlite3
+   npm install @prisma/adapter-pg pg @supabase/supabase-js
+   npm install -D @types/pg
+   ```
+4. Update `prisma/schema.prisma`:
+   ```prisma
+   datasource db {
+     provider = "postgresql"
+   }
+   ```
+5. Update `app/lib/prisma.ts`:
+
+   ```typescript
+   import { PrismaClient } from '@prisma/client';
+   import { PrismaPg } from '@prisma/adapter-pg';
+
+   const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+   const connectionString = process.env.DATABASE_URL!;
+   const adapter = new PrismaPg({ connectionString });
+   export const prisma =
+     globalForPrisma.prisma ?? new PrismaClient({ adapter });
+   if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+   export default prisma;
+   ```
+
+6. Create `.env`:
+   ```
+   DATABASE_URL=postgresql://postgres.YOUR_PROJECT_ID:YOUR_PASSWORD@aws-0-us-east-1.pooler.supabase.com:6543/postgres
+   ```
+7. Remove `serverExternalPackages` from `next.config.ts`
+8. Run `npm run db:push` to create tables in Supabase
+9. Update `prisma/seed.ts` to use the new adapter (same pattern as `prisma.ts`)
+
+### Option 2: Other PostgreSQL Hosts (Neon, Railway, etc.)
+
+Same steps as Supabase above (steps 3-9), just use your provider's connection string.
+
+### Option 3: PlanetScale / MySQL
+
+1. Replace packages:
+   ```bash
+   npm uninstall better-sqlite3 @prisma/adapter-better-sqlite3 @types/better-sqlite3
+   npm install @prisma/adapter-planetscale @planetscale/database
+   ```
+2. Update `schema.prisma` datasource to `provider = "mysql"`
+3. Update `app/lib/prisma.ts` to use `PrismaPlanetScale` adapter
+4. Follow PlanetScale setup docs for connection string
+
+### What Stays the Same
+
+Your application code doesn't change at all. Every file that uses the database already imports from `@/app/lib/prisma`, which is the only file that gets updated. Your Prisma schema models, API routes, and server components all work identically regardless of which database backs them.
+
+## Writing Seed Scripts
+
+Seed scripts run outside of Next.js, so they must create their own PrismaClient with the adapter (they cannot import from `@/app/lib/prisma`). See `prisma/seed.ts` for the correct pattern.

package/codeyam-cli/templates/nextjs-prisma-sqlite/FEATURE_PATTERNS.md

@@ -0,0 +1,37 @@
+# Feature Patterns
+
+When the feature you're building involves any of the patterns below, **read the linked doc before writing code**. These patterns are designed for the local SQLite dev environment and upgrade cleanly to production services later.
+
+## Authentication (login, sign-up, user sessions)
+
+**Read:** `AUTH_PATTERNS.md`
+
+Use the cookie + DB auth abstraction in `app/lib/auth.ts`. All consumer code imports from this single file. DO NOT use NextAuth, Clerk, better-auth, Supabase Auth, or any external auth provider during prototyping — they require infrastructure unavailable locally.
+
+**For scenarios:** Include User and Session seed rows. Add `"session": {"cookieValue": "<token>"}` at the scenario top level to auto-log the user in. Omit `session` for a logged-out scenario.
+
+**Upgrade path:** See `AUTH_UPGRADE.md` — only `app/lib/auth.ts` internals change; consumer code stays the same.
+
+## External Services (payments, email, maps, weather APIs, etc.)
+
+If the user has dev/test credentials (e.g., Stripe test keys):
+
+- Store them in `.codeyam/config.json` under `environmentVariables`
+- Restart the dev server — credentials are injected into `process.env`
+
+If no credentials are available:
+
+- Build with real API calls in the code
+- Mock responses per scenario using `externalApis` in scenario registration (Step 8)
+
+## File Storage / Uploads
+
+For local prototyping, store files in the `public/uploads/` directory and serve them as static assets. Use `fs.writeFile` in API routes. For production, swap to S3/Cloudflare R2/Supabase Storage.
+
+## Email / Notifications
+
+For prototyping, log emails to the console or write them to a `/api/dev/sent-emails` endpoint that stores in the database. For production, swap to Resend/SendGrid/Postmark.
+
+---
+
+_This list will grow as new patterns are added. Each pattern follows the same principle: build with a simple local implementation, upgrade to a production service later by swapping one file._

package/codeyam-cli/templates/nextjs-prisma-sqlite/app/api/todos/route.ts

@@ -0,0 +1,17 @@
+// Example API route using Prisma.
+// Import prisma from the singleton — do NOT create a new PrismaClient here.
+
+import { prisma } from '@/app/lib/prisma';
+
+export async function GET() {
+  const todos = await prisma.todo.findMany({
+    orderBy: { createdAt: 'desc' },
+  });
+  return Response.json(todos);
+}
+
+export async function POST(request: Request) {
+  const { title } = await request.json();
+  const todo = await prisma.todo.create({ data: { title } });
+  return Response.json(todo);
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/app/codeyam-isolate/layout.tsx

@@ -0,0 +1,12 @@
+import { notFound } from 'next/navigation';
+
+export default function CodeYamIsolateLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  if (process.env.NODE_ENV === 'production') {
+    notFound();
+  }
+  return <>{children}</>;
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/app/globals.css

@@ -0,0 +1,26 @@
+@import "tailwindcss";
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --background: #0a0a0a;
+    --foreground: #ededed;
+  }
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: Arial, Helvetica, sans-serif;
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/app/layout.tsx

@@ -0,0 +1,34 @@
+import type { Metadata } from 'next';
+import { Geist, Geist_Mono } from 'next/font/google';
+import './globals.css';
+
+const geistSans = Geist({
+  variable: '--font-geist-sans',
+  subsets: ['latin'],
+});
+
+const geistMono = Geist_Mono({
+  variable: '--font-geist-mono',
+  subsets: ['latin'],
+});
+
+export const metadata: Metadata = {
+  title: 'CodeYam App',
+  description: 'Built with CodeYam Editor',
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body
+        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+      >
+        {children}
+      </body>
+    </html>
+  );
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/app/lib/prisma.ts

@@ -0,0 +1,24 @@
+// Database connection singleton.
+// This is the ONLY file that changes when upgrading to a hosted database.
+// All application code imports from here — API routes, server components, etc.
+//
+// Usage:
+//   import { prisma } from "@/app/lib/prisma";
+//   const items = await prisma.todo.findMany();
+//
+// To upgrade to a hosted database (e.g., Supabase PostgreSQL), see DATABASE.md.
+
+import { PrismaClient } from '@prisma/client';
+import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';
+
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+
+const adapter = new PrismaBetterSqlite3({
+  url: process.env.DATABASE_URL || 'file:./dev.db',
+});
+
+export const prisma = globalForPrisma.prisma ?? new PrismaClient({ adapter });
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+
+export default prisma;

package/codeyam-cli/templates/nextjs-prisma-sqlite/app/page.tsx

@@ -0,0 +1,10 @@
+export default function Home() {
+  return (
+    <main className="min-h-screen flex items-center justify-center">
+      <div className="text-center">
+        <h1 className="text-4xl font-bold mb-4">Welcome</h1>
+        <p className="text-gray-600">Your app is ready. Start building!</p>
+      </div>
+    </main>
+  );
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/env

@@ -0,0 +1,4 @@
+# Local SQLite database (no external services needed)
+# This is used by Prisma CLI commands (db push, migrate, etc.)
+# The app code in app/lib/prisma.ts also uses this path.
+DATABASE_URL=file:./dev.db

package/codeyam-cli/templates/nextjs-prisma-sqlite/eslint.config.mjs

@@ -0,0 +1,11 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  globalIgnores([".next/**", "out/**", "build/**", "next-env.d.ts"]),
+]);
+
+export default eslintConfig;

package/codeyam-cli/templates/nextjs-prisma-sqlite/gitignore

@@ -0,0 +1,64 @@
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files
+.env*.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# database
+dev.db
+dev.db-journal
+
+# CodeYam - local only (not shared)
+.codeyam/db.sqlite3
+.codeyam/db.sqlite3-wal
+.codeyam/db.sqlite3-shm
+.codeyam/secrets.json
+.codeyam/server.json
+.codeyam/server-state.json
+.codeyam/queue.json
+.codeyam/active-scenario.json
+.codeyam/editor-step.json
+.codeyam/editor-user-prompt.txt
+.codeyam/editor-mode-context.md
+.codeyam/dev-mode-context.md
+.codeyam/logs/
+.codeyam/llm-calls/
+.codeyam/captures/
+.codeyam/results/
+.codeyam/tmp/
+.codeyam/rules/
+.codeyam/bin/

package/codeyam-cli/templates/nextjs-prisma-sqlite/next.config.ts

@@ -0,0 +1,14 @@
+import type { NextConfig } from 'next';
+
+const nextConfig: NextConfig = {
+  // Required: better-sqlite3 is a native module that can't be bundled
+  serverExternalPackages: ['better-sqlite3'],
+
+  turbopack: {
+    // Required: prevents Turbopack from inferring a parent directory as root
+    // when .codeyam/ exists above the project (which breaks import resolution)
+    root: '.',
+  },
+};
+
+export default nextConfig;

package/codeyam-cli/templates/nextjs-prisma-sqlite/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "codeyam-project",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "db:push": "npx prisma db push && npx prisma generate",
+    "db:seed": "npx tsx prisma/seed.ts",
+    "db:reset": "rm -f dev.db && npm run db:push && npx tsx prisma/seed.ts"
+  },
+  "dependencies": {
+    "@prisma/adapter-better-sqlite3": "^7.4.1",
+    "@prisma/client": "^7.4.1",
+    "better-sqlite3": "^12.6.2",
+    "next": "^15.3.3",
+    "prisma": "^7.4.1",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "^15.3.3",
+    "tailwindcss": "^4",
+    "tsx": "^4.19.4",
+    "typescript": "^5",
+    "vitest": "^3"
+  }
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/codeyam-cli/templates/nextjs-prisma-sqlite/prisma/schema.prisma

@@ -0,0 +1,27 @@
+// Prisma 7 with SQLite via better-sqlite3 driver adapter.
+//
+// IMPORTANT: Use "prisma-client-js" (NOT "prisma-client").
+// The "prisma-client" generator requires a custom output path which
+// breaks Turbopack import resolution and seed script imports.
+// "prisma-client-js" outputs to node_modules/@prisma/client which
+// works everywhere with standard imports.
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+}
+
+// ──────────────────────────────────────────────
+// Replace these placeholder models with your own.
+// After editing, run: npx prisma db push
+// ──────────────────────────────────────────────
+
+model Todo {
+  id        Int      @id @default(autoincrement())
+  title     String
+  completed Boolean  @default(false)
+  createdAt DateTime @default(now())
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/prisma/seed.ts

@@ -0,0 +1,40 @@
+// Seed script for populating the database with demo data.
+//
+// Run with: npx tsx prisma/seed.ts
+// Or:       npm run db:seed
+//
+// IMPORTANT: This file must use the same adapter pattern as app/lib/prisma.ts.
+// Do NOT use `new PrismaClient()` without the adapter — Prisma 7 requires it.
+
+import 'dotenv/config';
+import { PrismaClient } from '@prisma/client';
+import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';
+
+const adapter = new PrismaBetterSqlite3({
+  url: process.env.DATABASE_URL || 'file:./dev.db',
+});
+const prisma = new PrismaClient({ adapter });
+
+async function main() {
+  // Clear existing data
+  await prisma.todo.deleteMany();
+
+  // Seed with demo data
+  await prisma.todo.createMany({
+    data: [
+      { title: 'Set up the project', completed: true },
+      { title: 'Build the first feature' },
+      { title: 'Add more scenarios' },
+    ],
+  });
+
+  const count = await prisma.todo.count();
+  console.log(`Seeded ${count} todos`);
+}
+
+main()
+  .then(() => prisma.$disconnect())
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

package/codeyam-cli/templates/nextjs-prisma-sqlite/prisma.config.ts

@@ -0,0 +1,12 @@
+import 'dotenv/config';
+import { defineConfig } from 'prisma/config';
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  migrations: {
+    path: 'prisma/migrations',
+  },
+  datasource: {
+    url: process.env['DATABASE_URL'],
+  },
+});

package/codeyam-cli/templates/nextjs-prisma-sqlite/seed-adapter.ts

@@ -0,0 +1,92 @@
+/**
+ * CodeYam Seed Adapter for Prisma + SQLite.
+ *
+ * Reads a JSON seed data file (path passed as CLI arg), wipes all tables,
+ * then inserts the seed data using Prisma.
+ *
+ * Usage: npx tsx .codeyam/seed-adapter.ts <path-to-seed-data.json>
+ *
+ * The JSON file has the format:
+ * {
+ *   "type": "application",
+ *   "seed": {
+ *     "tableName": [{ "column": "value", ... }, ...]
+ *   },
+ *   "externalApis": { ... }  // optional, not used by this adapter
+ * }
+ */
+
+import 'dotenv/config';
+import { PrismaClient } from '@prisma/client';
+import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';
+import * as fs from 'fs';
+
+const adapter = new PrismaBetterSqlite3({
+  url: process.env.DATABASE_URL || 'file:./dev.db',
+});
+const prisma = new PrismaClient({ adapter });
+
+async function main() {
+  const seedDataPath = process.argv[2];
+  if (!seedDataPath) {
+    console.error('Usage: npx tsx .codeyam/seed-adapter.ts <seed-data.json>');
+    process.exit(1);
+  }
+
+  const raw = fs.readFileSync(seedDataPath, 'utf-8');
+  const data = JSON.parse(raw);
+  const seed = data.seed || data;
+
+  console.log(`Seeding tables: ${Object.keys(seed).join(', ')}`);
+
+  // Wipe all tables in reverse order (to respect foreign keys)
+  const tableNames = Object.keys(seed);
+  for (const table of [...tableNames].reverse()) {
+    try {
+      await (prisma as any)[table].deleteMany();
+      console.log(`  Cleared ${table}`);
+    } catch (err) {
+      console.warn(
+        `  Could not clear ${table}: ${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
+
+  // Reset auto-increment counters so IDs start from 1 after each re-seed.
+  // Without this, SQLite IDs keep climbing (1, 2, ... then 9, 10, ...)
+  // across scenario switches, causing hardcoded URLs like /drinks/1 to 404.
+  for (const table of tableNames) {
+    try {
+      // Prisma uses PascalCase model names; sqlite_sequence stores the actual table name.
+      // Try both the seed key (which matches the Prisma model) and common casings.
+      await prisma.$executeRawUnsafe(
+        `DELETE FROM sqlite_sequence WHERE name = '${table}' OR name = '${table.charAt(0).toUpperCase() + table.slice(1)}'`,
+      );
+    } catch {
+      // sqlite_sequence may not exist if no autoincrement columns — safe to ignore
+    }
+  }
+
+  // Insert seed data
+  for (const [table, rows] of Object.entries(seed)) {
+    if (!Array.isArray(rows) || rows.length === 0) continue;
+    try {
+      await (prisma as any)[table].createMany({ data: rows });
+      console.log(`  Seeded ${rows.length} rows into ${table}`);
+    } catch (err) {
+      console.error(
+        `  Failed to seed ${table}: ${err instanceof Error ? err.message : err}`,
+      );
+      process.exit(1);
+    }
+  }
+
+  console.log('Seed complete');
+}
+
+main()
+  .then(() => prisma.$disconnect())
+  .catch((e) => {
+    console.error('Seed adapter error:', e);
+    process.exit(1);
+  });

package/codeyam-cli/templates/nextjs-prisma-sqlite/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

package/codeyam-cli/templates/nextjs-prisma-sqlite/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, '.'),
+    },
+  },
+});