create-nifra 0.1.0-alpha.1

package/dist/db.js

@@ -0,0 +1,467 @@
+/**
+ * `--db <preset>` — wire a Drizzle data layer into a freshly scaffolded app, so a human (or a coding
+ * agent) starts from a correct, production-grade DB setup instead of inventing one. nifra ships NO DB
+ * abstraction (that belongs to Drizzle/libSQL, not a web framework) — this just bundles the existing
+ * tool, the Redwood-style "batteries available" move: a starter schema, a typed client, a migration
+ * config, scripts, and env, all rip-out-able.
+ *
+ * Three presets, by runtime fit:
+ *   - drizzle-libsql   — SQLite that runs EVERYWHERE incl. the edge (local file, or Turso). The default
+ *                        cross-runtime answer.
+ *   - drizzle-postgres — Postgres (postgres.js) on Bun/Node/Deno.
+ *   - drizzle-sqlite   — Bun's built-in `bun:sqlite` (sync, local file). Bun-only.
+ *
+ * The starter `notes` table follows the production-grade DB defaults for its dialect; what a dialect
+ * can't express inline (CHECK constraints, RLS, uuidv7) is called out in a comment, per those rules.
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const DB_CHOICES = [
+    "drizzle-libsql",
+    "drizzle-postgres",
+    "drizzle-sqlite",
+    "prisma-postgres",
+    "prisma-sqlite",
+    "kysely-postgres",
+];
+const DRIZZLE_ORM = "^0.38.3";
+const DRIZZLE_KIT = "^0.30.4";
+const SCRIPTS = {
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:studio": "drizzle-kit studio",
+};
+// --- starter schemas (one production-grade `notes` table per dialect) -------------------------------
+const PG_SCHEMA = `import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+
+// Production-grade starter table. Postgres: UUID PK, TIMESTAMPTZ stamps, NOT NULL by default,
+// soft-delete via deleted_at. Deferred to a migration (Drizzle can't express these inline; add them in
+// the generated SQL): CHECK constraints (e.g. char_length(title) BETWEEN 1 AND 200), RLS for tenancy,
+// and gen_uuidv7() for insert locality on hot tables (defaultRandom() = gen_random_uuid() for now).
+export const notes = pgTable("notes", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  title: text("title").notNull(),
+  body: text("body").notNull().default(""),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  deletedAt: timestamp("deleted_at", { withTimezone: true }),
+})
+
+export type Note = typeof notes.$inferSelect
+export type NewNote = typeof notes.$inferInsert
+`;
+// SQLite has no UUID/TIMESTAMPTZ/RLS — so: text id (app-generated UUID), millisecond-epoch timestamps
+// (timestamp_ms mode → JS Date), NOT NULL by default, soft-delete via deleted_at. Shared by the
+// bun:sqlite and libSQL presets (same dialect). CHECK constraints are deferred to the migration.
+const SQLITE_SCHEMA = `import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core"
+
+// Production-grade starter table (SQLite dialect — see the comment in your DB defaults for what the
+// dialect can't enforce inline: CHECK constraints go in the generated migration).
+export const notes = sqliteTable("notes", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  title: text("title").notNull(),
+  body: text("body").notNull().default(""),
+  createdAt: integer("created_at", { mode: "timestamp_ms" })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  deletedAt: integer("deleted_at", { mode: "timestamp_ms" }),
+})
+
+export type Note = typeof notes.$inferSelect
+export type NewNote = typeof notes.$inferInsert
+`;
+// --- typed clients (export \`db\` + re-export the schema) --------------------------------------------
+// Each prints the same usage header so an agent sees how to wire it (decorate) and query it.
+const WIRE_DOC = `// Wire it into your backend ONCE, then read \`c.db\` in handlers:
+//   import { server } from "@nifrajs/core"
+//   import { db, notes } from "./db"
+//   export const app = server().decorate("db", db)
+//     .get("/notes", async (c) => c.db.select().from(notes))
+// Never top-level-import this into a routes/ page file (server-only) — reach it via c.db / ctx.api.`;
+const PG_CLIENT = `import { drizzle } from "drizzle-orm/postgres-js"
+import postgres from "postgres"
+import * as schema from "./schema.ts"
+
+${WIRE_DOC}
+
+const url = process.env.DATABASE_URL
+if (url === undefined || url === "") {
+  throw new Error("DATABASE_URL is not set — copy .env.example to .env and fill it in.")
+}
+
+// One pooled client per process (per instance in a multi-instance deploy — fine for Postgres).
+export const db = drizzle(postgres(url), { schema })
+export * from "./schema.ts"
+`;
+const SQLITE_CLIENT = `import { Database } from "bun:sqlite"
+import { drizzle } from "drizzle-orm/bun-sqlite"
+import * as schema from "./schema.ts"
+
+${WIRE_DOC}
+
+// Bun's built-in SQLite — sync + fast, local file. (Bun-only; for Node/Deno/edge use the libsql preset.)
+export const db = drizzle(new Database(process.env.DATABASE_URL ?? "local.db"), { schema })
+export * from "./schema.ts"
+`;
+const LIBSQL_CLIENT = `import { createClient } from "@libsql/client"
+import { drizzle } from "drizzle-orm/libsql"
+import * as schema from "./schema.ts"
+
+${WIRE_DOC}
+
+// libSQL runs everywhere — a local file (file:local.db), a remote Turso URL (libsql://…) with an auth
+// token, or an embedded replica. The one SQLite client that also works on the edge (Cloudflare Workers).
+const token = process.env.DATABASE_AUTH_TOKEN
+export const db = drizzle(
+  createClient({
+    url: process.env.DATABASE_URL ?? "file:local.db",
+    ...(token !== undefined && token !== "" ? { authToken: token } : {}),
+  }),
+  { schema },
+)
+export * from "./schema.ts"
+`;
+// --- drizzle-kit config (per dialect) ---------------------------------------------------------------
+const PG_CONFIG = `import { defineConfig } from "drizzle-kit"
+
+export default defineConfig({
+  schema: "./db/schema.ts",
+  out: "./db/migrations",
+  dialect: "postgresql",
+  // biome-ignore lint/style/noNonNullAssertion: drizzle-kit reads this from .env (Bun auto-loads it).
+  dbCredentials: { url: process.env.DATABASE_URL! },
+})
+`;
+const SQLITE_CONFIG = `import { defineConfig } from "drizzle-kit"
+
+export default defineConfig({
+  schema: "./db/schema.ts",
+  out: "./db/migrations",
+  dialect: "sqlite",
+  dbCredentials: { url: process.env.DATABASE_URL ?? "local.db" },
+})
+`;
+const LIBSQL_CONFIG = `import { defineConfig } from "drizzle-kit"
+
+export default defineConfig({
+  schema: "./db/schema.ts",
+  out: "./db/migrations",
+  dialect: "turso",
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? "file:local.db",
+    authToken: process.env.DATABASE_AUTH_TOKEN,
+  },
+})
+`;
+// --- .env examples ----------------------------------------------------------------------------------
+const PG_ENV = `# Postgres connection string (postgres.js). Never commit the real .env.
+DATABASE_URL="postgres://user:password@localhost:5432/app"
+`;
+const SQLITE_ENV = `# Path to the local SQLite file (Bun's bun:sqlite). Never commit the real .env.
+DATABASE_URL="local.db"
+`;
+const LIBSQL_ENV = `# Local file by default; point at Turso for a hosted/edge DB. Never commit the real .env.
+DATABASE_URL="file:local.db"
+# For Turso (or any remote libSQL):
+# DATABASE_URL="libsql://your-db.turso.io"
+# DATABASE_AUTH_TOKEN="your-token"
+`;
+// --- Prisma presets ---------------------------------------------------------------------------------
+// Prisma owns its schema DSL (prisma/schema.prisma), client codegen, and migration engine — so the
+// scaffold is schema + a singleton client + the prisma scripts (no drizzle-kit equivalent needed).
+const PRISMA_CLIENT_VERSION = "^6.5.0";
+const PRISMA_SCRIPTS = {
+    "db:generate": "prisma generate",
+    "db:migrate": "prisma migrate dev",
+    "db:studio": "prisma studio",
+};
+const PRISMA_PG_SCHEMA = `datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+// Production-grade starter model. Postgres: UUID PK, TIMESTAMPTZ stamps (@db.Timestamptz), NOT NULL by
+// default, soft-delete via deletedAt. Add in a migration what the DSL can't express inline: CHECK
+// constraints (e.g. length caps on title), RLS for tenancy, and gen_uuidv7() for insert locality on hot
+// tables (uuid() = gen_random_uuid() for now).
+model Note {
+  id        String    @id @default(uuid()) @db.Uuid
+  title     String
+  body      String    @default("")
+  createdAt DateTime  @default(now()) @map("created_at") @db.Timestamptz(6)
+  updatedAt DateTime  @updatedAt @map("updated_at") @db.Timestamptz(6)
+  deletedAt DateTime? @map("deleted_at") @db.Timestamptz(6)
+
+  @@map("notes")
+}
+`;
+const PRISMA_SQLITE_SCHEMA = `datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+// Production-grade starter model (SQLite dialect — no native UUID/TIMESTAMPTZ/RLS; Prisma stores the
+// String id + DateTime stamps for you). NOT NULL by default, soft-delete via deletedAt. CHECK
+// constraints are deferred to the generated migration SQL.
+model Note {
+  id        String    @id @default(uuid())
+  title     String
+  body      String    @default("")
+  createdAt DateTime  @default(now()) @map("created_at")
+  updatedAt DateTime  @updatedAt @map("updated_at")
+  deletedAt DateTime? @map("deleted_at")
+
+  @@map("notes")
+}
+`;
+const PRISMA_CLIENT = `import { PrismaClient } from "@prisma/client"
+
+// Wire it into your backend ONCE, then read \`c.db\` in handlers:
+//   import { server } from "@nifrajs/core"
+//   import { db } from "./db"
+//   export const app = server().decorate("db", db)
+//     .get("/notes", async (c) => c.db.note.findMany({ where: { deletedAt: null } }))
+// Never top-level-import this into a routes/ page file (server-only) — reach it via c.db / ctx.api.
+
+// One PrismaClient per process. The globalThis guard stops dev hot-reload from opening a new connection
+// pool on every reload (which exhausts the DB); production gets a single fresh instance.
+const globalForPrisma = globalThis as unknown as { prisma?: PrismaClient }
+export const db = globalForPrisma.prisma ?? new PrismaClient()
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db
+`;
+const PRISMA_PG_ENV = `# Postgres connection string (Prisma). Never commit the real .env.
+DATABASE_URL="postgresql://user:password@localhost:5432/app"
+`;
+const PRISMA_SQLITE_ENV = `# Local SQLite file (Prisma). Never commit the real .env.
+DATABASE_URL="file:./local.db"
+`;
+// --- Kysely preset ----------------------------------------------------------------------------------
+// Kysely is a typed query builder, not an ORM: you describe the DB shape (db/schema.ts) and own the
+// migrations. It ships no CLI, so the scaffold includes a Migrator runner (db/migrate.ts) + a starter
+// migration. Postgres via the official PostgresDialect + node-postgres.
+const KYSELY_VERSION = "^0.27.4";
+const KYSELY_SCRIPTS = {
+    "db:migrate": "bun run db/migrate.ts",
+};
+const KYSELY_PG_SCHEMA = `import type { ColumnType, Generated } from "kysely"
+
+// Kysely is types-only: describe the DB shape and keep it in sync with db/migrations (or generate it
+// with \`kysely-codegen\`). There is no runtime schema object.
+export interface NotesTable {
+  id: Generated<string> // uuid PK, DB-defaulted (gen_random_uuid())
+  title: string
+  body: Generated<string> // defaults to ''
+  // DB-managed stamps: never written by the app (never on insert/update), read back as Date.
+  created_at: ColumnType<Date, never, never>
+  updated_at: ColumnType<Date, never, Date>
+  deleted_at: Date | null // soft delete
+}
+
+export interface DB {
+  notes: NotesTable
+}
+`;
+const KYSELY_PG_CLIENT = `import { Kysely, PostgresDialect } from "kysely"
+import { Pool } from "pg"
+import type { DB } from "./schema.ts"
+
+// Wire it into your backend ONCE, then read \`c.db\` in handlers:
+//   import { server } from "@nifrajs/core"
+//   import { db } from "./db"
+//   export const app = server().decorate("db", db)
+//     .get("/notes", async (c) =>
+//       c.db.selectFrom("notes").selectAll().where("deleted_at", "is", null).execute())
+// Never top-level-import this into a routes/ page file (server-only) — reach it via c.db / ctx.api.
+
+const url = process.env.DATABASE_URL
+if (url === undefined || url === "") {
+  throw new Error("DATABASE_URL is not set — copy .env.example to .env and fill it in.")
+}
+
+// One pooled client per process (per instance in a multi-instance deploy — fine for Postgres).
+export const db = new Kysely<DB>({
+  dialect: new PostgresDialect({ pool: new Pool({ connectionString: url }) }),
+})
+export type { DB } from "./schema.ts"
+`;
+const KYSELY_MIGRATION = `import { type Kysely, sql } from "kysely"
+
+// Production-grade starter table. Postgres: UUID PK (gen_random_uuid — swap to gen_uuidv7() for insert
+// locality on hot tables once available), TIMESTAMPTZ stamps, NOT NULL by default, soft-delete via
+// deleted_at. Add CHECK constraints (e.g. length caps) and RLS here per your DB defaults.
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable("notes")
+    .addColumn("id", "uuid", (c) => c.primaryKey().defaultTo(sql\`gen_random_uuid()\`))
+    .addColumn("title", "text", (c) => c.notNull())
+    .addColumn("body", "text", (c) => c.notNull().defaultTo(""))
+    .addColumn("created_at", sql\`timestamptz\`, (c) => c.notNull().defaultTo(sql\`now()\`))
+    .addColumn("updated_at", sql\`timestamptz\`, (c) => c.notNull().defaultTo(sql\`now()\`))
+    .addColumn("deleted_at", sql\`timestamptz\`)
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable("notes").execute()
+}
+`;
+const KYSELY_MIGRATE_RUNNER = `import { promises as fs } from "node:fs"
+import * as path from "node:path"
+import { FileMigrationProvider, Migrator } from "kysely"
+import { db } from "./index.ts"
+
+// Kysely ships no migration CLI, so this is the runner: it applies every pending migration in
+// db/migrations (in filename order, each in its own transaction). Run with \`bun run db:migrate\`.
+const migrator = new Migrator({
+  db,
+  provider: new FileMigrationProvider({
+    fs,
+    path,
+    migrationFolder: path.join(import.meta.dir, "migrations"),
+  }),
+})
+
+const { error, results } = await migrator.migrateToLatest()
+for (const r of results ?? []) {
+  console.log(r.status === "Success" ? \`✓ \${r.migrationName}\` : \`✗ \${r.migrationName}\`)
+}
+await db.destroy()
+if (error !== undefined) {
+  console.error("migration failed:", error)
+  process.exit(1)
+}
+`;
+export const DB_PRESETS = {
+    "drizzle-libsql": {
+        label: "Drizzle + libSQL",
+        orm: "drizzle",
+        dialect: "sqlite",
+        note: "libSQL runs on every runtime incl. the edge (local file or Turso).",
+        deps: { "drizzle-orm": DRIZZLE_ORM, "@libsql/client": "^0.14.0" },
+        devDeps: { "drizzle-kit": DRIZZLE_KIT },
+        scripts: SCRIPTS,
+        files: {
+            "db/schema.ts": SQLITE_SCHEMA,
+            "db/index.ts": LIBSQL_CLIENT,
+            "drizzle.config.ts": LIBSQL_CONFIG,
+            ".env.example": LIBSQL_ENV,
+        },
+    },
+    "drizzle-postgres": {
+        label: "Drizzle + Postgres",
+        orm: "drizzle",
+        dialect: "postgres",
+        note: "Postgres (postgres.js) on Bun/Node/Deno — not the edge.",
+        deps: { "drizzle-orm": DRIZZLE_ORM, postgres: "^3.4.5" },
+        devDeps: { "drizzle-kit": DRIZZLE_KIT },
+        scripts: SCRIPTS,
+        files: {
+            "db/schema.ts": PG_SCHEMA,
+            "db/index.ts": PG_CLIENT,
+            "drizzle.config.ts": PG_CONFIG,
+            ".env.example": PG_ENV,
+        },
+    },
+    "drizzle-sqlite": {
+        label: "Drizzle + SQLite (bun:sqlite)",
+        orm: "drizzle",
+        dialect: "sqlite",
+        note: "Bun's built-in SQLite — local file, Bun-only.",
+        deps: { "drizzle-orm": DRIZZLE_ORM },
+        devDeps: { "drizzle-kit": DRIZZLE_KIT },
+        scripts: SCRIPTS,
+        files: {
+            "db/schema.ts": SQLITE_SCHEMA,
+            "db/index.ts": SQLITE_CLIENT,
+            "drizzle.config.ts": SQLITE_CONFIG,
+            ".env.example": SQLITE_ENV,
+        },
+    },
+    "prisma-postgres": {
+        label: "Prisma + Postgres",
+        orm: "prisma",
+        dialect: "postgres",
+        note: "Prisma ORM on Postgres (Bun/Node/Deno) — own schema DSL, migrate engine, and Studio.",
+        deps: { "@prisma/client": PRISMA_CLIENT_VERSION },
+        devDeps: { prisma: PRISMA_CLIENT_VERSION },
+        scripts: PRISMA_SCRIPTS,
+        files: {
+            "prisma/schema.prisma": PRISMA_PG_SCHEMA,
+            "db/index.ts": PRISMA_CLIENT,
+            ".env.example": PRISMA_PG_ENV,
+        },
+    },
+    "prisma-sqlite": {
+        label: "Prisma + SQLite",
+        orm: "prisma",
+        dialect: "sqlite",
+        note: "Prisma ORM on a local SQLite file — fastest start; migrate to Postgres later by swapping the datasource.",
+        deps: { "@prisma/client": PRISMA_CLIENT_VERSION },
+        devDeps: { prisma: PRISMA_CLIENT_VERSION },
+        scripts: PRISMA_SCRIPTS,
+        files: {
+            "prisma/schema.prisma": PRISMA_SQLITE_SCHEMA,
+            "db/index.ts": PRISMA_CLIENT,
+            ".env.example": PRISMA_SQLITE_ENV,
+        },
+    },
+    "kysely-postgres": {
+        label: "Kysely + Postgres",
+        orm: "kysely",
+        dialect: "postgres",
+        note: "Kysely typed query builder on Postgres (node-postgres) — you own the schema types + migrations.",
+        deps: { kysely: KYSELY_VERSION, pg: "^8.13.1" },
+        devDeps: { "@types/pg": "^8.11.10" },
+        scripts: KYSELY_SCRIPTS,
+        files: {
+            "db/schema.ts": KYSELY_PG_SCHEMA,
+            "db/index.ts": KYSELY_PG_CLIENT,
+            "db/migrate.ts": KYSELY_MIGRATE_RUNNER,
+            "db/migrations/0001_create_notes.ts": KYSELY_MIGRATION,
+            ".env.example": PG_ENV,
+        },
+    },
+};
+const GITIGNORE_BLOCK = `
+# database (added by --db)
+.env
+local.db
+*.db-shm
+*.db-wal
+db/migrations/meta
+`;
+/** Write a DB preset's files into `target` and ensure local DB artifacts + .env are gitignored. */
+export async function writeDbFiles(target, choice) {
+    const preset = DB_PRESETS[choice];
+    for (const [rel, content] of Object.entries(preset.files)) {
+        const path = join(target, rel);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content);
+    }
+    // Append DB ignores once (the template's .gitignore already exists post-rename; never clobber it).
+    const gitignorePath = join(target, ".gitignore");
+    let current = "";
+    try {
+        current = await readFile(gitignorePath, "utf8");
+    }
+    catch {
+        // No .gitignore in this template — create one with just the DB block.
+    }
+    if (!current.includes("local.db")) {
+        await writeFile(gitignorePath, `${current}${GITIGNORE_BLOCK}`);
+    }
+}
+//# sourceMappingURL=db.js.map

package/dist/db.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.js","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "create-nifra",
+  "version": "0.1.0-alpha.1",
+  "description": "Scaffold a new nifra app — `bun create nifra <dir>`.",
+  "keywords": [
+    "bun",
+    "typescript",
+    "nifra",
+    "web-framework",
+    "full-stack",
+    "edge",
+    "ssr",
+    "scaffold",
+    "create",
+    "starter",
+    "template",
+    "cli"
+  ],
+  "type": "module",
+  "bin": {
+    "create-nifra": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "template",
+    "template-site",
+    "template-site-vue",
+    "template-site-preact",
+    "template-site-solid",
+    "template-site-svelte",
+    "template-isr"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && bun run ../../scripts/fix-dts.ts dist"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nifrajs/nifra.git",
+    "directory": "packages/create-nifra"
+  },
+  "bugs": {
+    "url": "https://github.com/nifrajs/nifra/issues"
+  },
+  "homepage": "https://github.com/nifrajs/nifra#readme"
+}

package/template/README.md

@@ -0,0 +1,24 @@
+# nifra-app
+
+A starter [nifra](https://github.com/nifra) app, scaffolded with `create-nifra`.
+
+```sh
+bun install
+bun run dev        # watch + serve on http://localhost:3000
+bun test           # run the tests
+bun run typecheck  # type-check
+```
+
+- `src/app.ts` — your routes (exported without `listen`, so tests drive it via `app.fetch`).
+- `src/index.ts` — boots the server.
+- `src/app.test.ts` — an example test.
+
+Add a typed client from `typeof app`:
+
+```ts
+import { client } from "@nifrajs/client"
+import type { App } from "./src/app.ts"
+
+const api = client<App>("http://localhost:3000")
+const { data } = await api.users({ id: "42" }).get()
+```

package/template/gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+*.log
+.env
+.env.*
+!.env.example

package/template/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "nifra-app",
+  "version": "0.0.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "bun --watch run src/index.ts",
+    "start": "bun run src/index.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@nifrajs/client": "^0.1.0",
+    "@nifrajs/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^6.0.3"
+  }
+}

package/template/src/app.test.ts

@@ -0,0 +1,8 @@
+import { expect, test } from "bun:test"
+import { app } from "./app.ts"
+
+test("GET /users/:id echoes the id", async () => {
+  const res = await app.fetch(new Request("http://localhost/users/42"))
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual({ id: "42" })
+})

package/template/src/app.ts

@@ -0,0 +1,8 @@
+import { server } from "@nifrajs/core"
+
+/** Your app. Exported (without `listen`) so tests can drive it via `app.fetch`. */
+export const app = server()
+  .get("/", () => ({ hello: "nifra" }))
+  .get("/users/:id", (c) => ({ id: c.params.id }))
+
+export type App = typeof app

package/template/src/index.ts

@@ -0,0 +1,5 @@
+import { app } from "./app.ts"
+
+const port = Number(process.env.PORT ?? 3000)
+app.listen(port)
+console.log(`▲ nifra listening on http://localhost:${port}`)

package/template/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "types": ["bun"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}

package/template-isr/README.md

@@ -0,0 +1,46 @@
+# nifra + ISR
+
+A nifra + React app with **Incremental Static Regeneration** — pages are cached and served
+stale-while-revalidate, backed by **Workers KV** in production (so the cache and on-demand purges hold
+across instances) and an in-memory store for local dev.
+
+## Develop
+
+On real workerd with a local KV (no Cloudflare account needed):
+
+```sh
+bun install
+bun run build      # buildClient → public/assets, buildServer → dist-server/worker.js
+bun run dev        # bunx wrangler dev
+```
+
+Or a plain Bun server with an in-memory store:
+
+```sh
+bun run build
+bun run dev:bun    # http://localhost:3000
+```
+
+Watch the `x-nifra-isr` response header as you reload: `miss` (rendered + stored) → `hit` (fresh, from
+cache) → `stale` (served instantly while it regenerates). The page shows a server-render counter that
+holds across `hit`s and bumps on a `miss`/regeneration.
+
+## How it works
+
+- `withISR(app, { store, revalidate, now })` wraps the app's `fetch`. Only full-document `text/html`
+  `GET` `200`s are cached; assets, soft-nav data fetches, redirects, and errors pass through.
+- A route sets its freshness with `export const revalidate = <seconds>` (see `routes/index.tsx`).
+- `KVCacheStore(env.ISR_CACHE)` is the shared, durable store (production); `MemoryCacheStore` is dev.
+- `revalidateEndpoint({ store, secret })` is the on-demand purge handler:
+
+  ```sh
+  curl -X POST 'http://localhost:3000/__velo/revalidate?path=/' -H 'x-nifra-revalidate-token: dev-secret'
+  ```
+
+## Deploy
+
+```sh
+bunx wrangler kv namespace create ISR_CACHE   # paste the id into wrangler.toml
+bunx wrangler secret put REVALIDATE_SECRET     # set a real purge secret
+bun run build && bunx wrangler deploy
+```