@brust/create-app 2.0.0-alpha.2 → 2.0.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brust/create-app",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-alpha.3",
   "description": "Scaffold a brust v2 app — bun create @brust/app <name>",
   "license": "MIT",
   "repository": {

package/src/dep.ts

@@ -2,7 +2,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { dirname, join, relative, resolve } from 'node:path'
 
-/** = scripts/release-bump.ts PLATS. */
+/** = scripts/release-files.ts PLATS. */
 export const PLATS = ['darwin-x64', 'darwin-arm64', 'linux-x64-gnu', 'linux-arm64-gnu', 'linux-x64-musl', 'linux-arm64-musl'] as const
 
 export interface BrustDep {
@@ -44,6 +44,7 @@ export function resolveBrustDep(o: { explicit?: string; targetDir: string; pkgRo
     if (inWorkspace(root, o.targetDir)) return { kind: 'workspace', spec: 'workspace:*' }
     // `file:` alone fails: core's own workspace:* deps do not resolve outside the workspace globs, so override them.
     const overrides: Record<string, string> = { '@brust/runtime-dom': `file:${root}/packages/runtime-dom` }
+    overrides['@brust/core-cf'] = `file:${root}/npm/core-cf`
     for (const p of PLATS) overrides[`@brust/native-${p}`] = `file:${root}/npm/${p}`
     return { kind: 'file', spec: `file:${root}/packages/brust`, overrides }
   }

package/templates/blank/README.md.tmpl

@@ -9,7 +9,7 @@ bun install
 bun run dev        # brust build routes.tsx && brust start  ->  http://127.0.0.1:1337
 ```
 
-Scripts: `dev` (build then start), `build`, `start`, `typecheck`.
+Scripts: `dev` (build then start), `build`, `start`, `typecheck`, `dev:cf` (build for Cloudflare Workers and run `wrangler dev`), `deploy:cf` (build and `wrangler deploy`).
 
 ## Layout
 
@@ -18,6 +18,7 @@ Scripts: `dev` (build then start), `build`, `start`, `typecheck`.
 - `components/Counter.tsx` — a `useState` counter; the compiler makes it a native component (no React in the browser).
 - `actions.ts` — an Elysia 2 app on `brust()`, served by Rust under `/_brust/action` (enabled by `[actions]` in `brust.toml`).
 - `public/` — static files, served at `/public/...`.
+- `wrangler.jsonc` — your Cloudflare bindings (D1, KV, vars); brust owns `main`, `assets` and `compatibility_date`.
 
 ## The hello action
 

package/templates/blank/_gitignore

@@ -1,2 +1,3 @@
 node_modules/
 dist/
+.wrangler/

package/templates/blank/package.json.tmpl

@@ -7,7 +7,9 @@
     "dev": "brust build routes.tsx && brust start",
     "build": "brust build routes.tsx",
     "start": "brust start",
-    "typecheck": "bun check"
+    "typecheck": "bun check",
+    "dev:cf": "brust dev routes.tsx --target cloudflare",
+    "deploy:cf": "brust build routes.tsx --target cloudflare && wrangler deploy -c dist/cf/wrangler.jsonc"
   },
   "dependencies": {
     "@brust/core": __BRUST_DEP__,
@@ -19,6 +21,7 @@
   "devDependencies": {
     "@types/bun": "^1.4.0",
     "@types/react": "^19.2.0",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "wrangler": "^4.149.0"
   }
 }

package/templates/blank/wrangler.jsonc.tmpl

@@ -0,0 +1,9 @@
+// Your Cloudflare config for `bun run dev:cf` / `bun run deploy:cf`.
+// `brust build --target cloudflare` merges this file into dist/cf/wrangler.jsonc and owns these keys:
+// main, assets (the ASSETS binding), compatibility_date, no_bundle, build, rules, site.
+{
+  "name": "__PROJECT_NAME__"
+  // "d1_databases": [{ "binding": "DB", "database_name": "__PROJECT_NAME__", "database_id": "<id>" }],
+  // "kv_namespaces": [{ "binding": "KV", "id": "<id>" }],
+  // "vars": { "GREETING": "hello" }
+}

package/templates/pokedex/README.md.tmpl

@@ -26,10 +26,25 @@ at most 6 members and a seventh add answers `409` (`TeamFull`). The team store (
 
 - `routes.tsx` — `/`, `/pokedex`, `/pokemon/{name}` (L1 60 s, `?nocache` bypass), `/type-chart` (L1 1 h), `/unified`, and a
   root-level `*` 404 outside the layout. Pages that show the team carry the cache tag `team`.
-- `lib/` — loaders over the snapshot, `team-db.ts` (sqlite, server-only), `team-client.ts` + `api.ts` (the typed actions client).
+- `lib/` — loaders over the snapshot, `team-db.ts` (the team interface: sqlite natively, D1 on Cloudflare via `[cloudflare.alias]`; server-only), `team-client.ts` + `api.ts` (the typed actions client).
 - `actions.ts` — the Elysia 2 team app on `brust()`; `stores/` — `team` and `unified` (`defineStore`).
 - `components/`, `pages/` — plain React functions.
 
+## Cloudflare Workers (preview)
+
+```bash
+bun run cf:migrate:local   # create the local D1 table (state in .wrangler/)
+bun run dev:cf             # build for Workers and run `wrangler dev` (rebuilds on change)
+```
+
+`brust build --target cloudflare` swaps `lib/team-db.ts` for the D1 version (`lib/team-db.d1.ts`) through `[cloudflare.alias]`
+in `brust.toml`; your bindings live in `wrangler.jsonc`. To deploy: `wrangler d1 create __PROJECT_NAME__-team`, paste the
+`database_id` into the **app-root** `wrangler.jsonc` (not `dist/cf/`, which is regenerated), `bun run cf:migrate:remote`,
+then `bun run deploy:cf`.
+
+Preview note: a team change refreshes cached team pages only in the isolate that served the action; other isolates catch up
+within the route `ttl` (60 s for `/pokemon/*`, 1 h for `/type-chart`) until the cross-isolate invalidation lands.
+
 ## Regenerating the stylesheet (never hand-edit `public/app.css`)
 
 ```bash

package/templates/pokedex/_gitignore

@@ -1,3 +1,5 @@
 node_modules/
 dist/
 data/team.sqlite*
+.wrangler/
+.dev.vars*

package/templates/pokedex/actions.ts

@@ -13,21 +13,21 @@ export interface TeamDeps {
 }
 
 export function teamApp({ db, invalidate }: TeamDeps = { db: teamDb, invalidate: cache.invalidate }) {
-  const reply = () => ({ team: db().list(), max: MAX_TEAM })
+  const reply = async () => ({ team: await db().list(), max: MAX_TEAM })
   // R5: cached pages that render the team carry the tag `team`; drop them after a real change.
   const changed = () => invalidate({ tags: ['team'] })
   return new Elysia({ adapter: brust() })
     .get('/team', () => reply())
-    .post('/team', { body: t.Object({ id: t.Integer({ minimum: 1 }) }) }, ({ body }) => {
+    .post('/team', { body: t.Object({ id: t.Integer({ minimum: 1 }) }) }, async ({ body }) => {
       const p = pokemonById(body.id)
       if (!p) return problem(404, { title: 'UnknownPokemon', detail: `no Pokémon #${body.id}` })
-      const r = db().add(p)
+      const r = await db().add(p)
       if (r === 'full') return problem(409, { title: 'TeamFull', detail: `the team already has ${MAX_TEAM} members`, max: MAX_TEAM })
       if (r === 'added') changed()
       return reply()
     })
-    .delete('/team/:id', { params: t.Object({ id: t.Integer({ minimum: 1 }) }) }, ({ params }) => {
-      if (db().remove(params.id)) changed()
+    .delete('/team/:id', { params: t.Object({ id: t.Integer({ minimum: 1 }) }) }, async ({ params }) => {
+      if (await db().remove(params.id)) changed()
       return reply()
     })
 }

package/templates/pokedex/brust.toml

@@ -3,6 +3,26 @@ address = "127.0.0.1"
 port = 1337
 
 [build]
-server_only = ["lib/team-db.ts"]
+server_only = ["lib/team-db"]
 
 [actions]
+
+# `brust build --target cloudflare` swaps the sqlite roster for the D1 one (the whole facade module).
+[cloudflare.alias]
+"lib/team-db.ts" = "lib/team-db.d1.ts"
+
+# A shared second cache tier (needs `bun add @brust/cache-redis`; see the brust docs, "Redis / Dragonfly"):
+# [cache]
+# adapter = "redis"   # or "dragonfly"
+# [cache.redis]
+# url = "env:REDIS_URL"
+
+# Or, on Cloudflare Workers: a shared second cache tier (KV bodies + a Durable Object invalidation broadcast). Off by default.
+# Needs: bun add @brust/cache-cloudflare, plus the KV and Durable Object bindings in wrangler.jsonc (see the comment there).
+# [cache]
+# adapter = "cloudflare-kv"
+# broadcast = "cloudflare-do"
+# epoch_interval_ms = 5000
+#
+# [cache.cloudflare]
+# kv_min_ttl_s = 300

package/templates/pokedex/lib/cloudflare.d.ts

@@ -0,0 +1,24 @@
+// Ambient types for the Cloudflare Workers surface this example uses (lib/team-db.d1.ts): just the subset of D1 that
+// is called, so `bun check` needs no @cloudflare/workers-types (whose global Request/Response clash with lib DOM).
+interface D1Meta {
+  changes: number
+  last_row_id: number
+}
+interface D1Result<T = unknown> {
+  success: boolean
+  results: T[]
+  meta: D1Meta
+}
+interface D1PreparedStatement {
+  bind(...values: unknown[]): D1PreparedStatement
+  all<T = Record<string, unknown>>(): Promise<D1Result<T>>
+  first<T = Record<string, unknown>>(): Promise<T | null>
+  run(): Promise<D1Result>
+}
+interface D1Database {
+  prepare(query: string): D1PreparedStatement
+  batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>
+}
+declare module 'cloudflare:workers' {
+  export const env: { TEAM_DB?: D1Database }
+}

package/templates/pokedex/lib/loaders.ts

@@ -9,8 +9,8 @@ import type { BrowseData, DetailData, HomeData, TypeChartCellVM, TypeChartData,
 
 const FEATURED = [{ id: 1, name: 'bulbasaur' }, { id: 4, name: 'charmander' }, { id: 7, name: 'squirtle' }, { id: 25, name: 'pikachu' }, { id: 39, name: 'jigglypuff' }, { id: 94, name: 'gengar' }, { id: 143, name: 'snorlax' }, { id: 150, name: 'mewtwo' }]
 /** Layout loader: seeds the request's store scope, so every layout page paints the DB roster (D4/E7). */
-export function layoutLoader(): void {
-  team.members.set(teamDb().list())
+export async function layoutLoader(): Promise<void> {
+  team.members.set(await teamDb().list())
   team.max.set(MAX_TEAM)
 }
 const NAV = [{ href: '/', label: 'Home' }, { href: '/pokedex', label: 'Pokédex' }, { href: '/type-chart', label: 'Type chart' }, { href: '/unified', label: 'Unified' }]

package/templates/pokedex/lib/team-db.d1.ts

@@ -0,0 +1,47 @@
+// examples/pokedex/lib/team-db.d1.ts — the TeamDb on Cloudflare D1. `brust.toml` [cloudflare.alias] swaps lib/team-db.ts for
+// this file in `brust build --target cloudflare`. The binding is read per call (never at import: the build smoke-imports the
+// bundle with an empty env) and nothing is cached across requests.
+import { env } from 'cloudflare:workers'
+import { MAX_TEAM } from './team'
+import type { AddResult, TeamDb } from './team-db'
+import type { TeamMember } from './types'
+
+export type { AddResult, TeamDb }
+
+interface Row { id: number; name: string; display_name: string; num: string; types: string; artwork: string }
+
+const LIST = 'SELECT id, name, display_name, num, types, artwork FROM team ORDER BY added_at, rowid'
+// ONE statement decides the cap: the count check and the insert cannot be split across awaits on D1 (no transaction handle),
+// so the insert is conditional. added_at is a clock that never repeats, as in the sqlite twin.
+const INSERT =
+  'INSERT INTO team (id, name, display_name, num, types, artwork, added_at) ' +
+  'SELECT ?1, ?2, ?3, ?4, ?5, ?6, MAX(?7, (SELECT COALESCE(MAX(added_at), 0) + 1 FROM team)) ' +
+  'WHERE (SELECT COUNT(*) FROM team) < ?8 ON CONFLICT(id) DO NOTHING'
+const HAS = 'SELECT 1 AS one FROM team WHERE id = ?1'
+
+export function openTeamDb(d1: D1Database): TeamDb {
+  return {
+    async list() {
+      const { results } = await d1.prepare(LIST).all<Row>()
+      return results.map((r) => ({ id: r.id, name: r.name, displayName: r.display_name, types: JSON.parse(r.types) as string[], artwork: r.artwork, num: r.num }))
+    },
+    async add(m: TeamMember): Promise<AddResult> {
+      // One batch = one transaction: added (1 row) | present (the id exists, even when full) | full.
+      const [ins, has] = await d1.batch([
+        d1.prepare(INSERT).bind(m.id, m.name, m.displayName, m.num, JSON.stringify(m.types), m.artwork, Date.now(), MAX_TEAM),
+        d1.prepare(HAS).bind(m.id),
+      ])
+      if (ins!.meta.changes === 1) return 'added'
+      return has!.results.length > 0 ? 'present' : 'full'
+    },
+    async remove(id: number) {
+      return (await d1.prepare('DELETE FROM team WHERE id = ?1').bind(id).run()).meta.changes > 0
+    },
+  }
+}
+
+export function teamDb(): TeamDb {
+  const d1 = env.TEAM_DB
+  if (!d1) throw new Error('TEAM_DB D1 binding missing: add it to wrangler.jsonc (see README)')
+  return openTeamDb(d1)
+}

package/templates/pokedex/lib/team-db.sqlite.ts

@@ -0,0 +1,49 @@
+// examples/pokedex/lib/team-db.sqlite.ts — the native TeamDb (server-only via brust.toml [build] server_only = lib/team-db).
+// The team is ONE shared roster, as in 0.1.x, but persisted: every worker thread opens the same file (WAL), so workers never
+// diverge (M3-F E7). Methods return Promises so the interface matches D1 (lib/team-db.d1.ts); the work itself stays synchronous.
+import { Database } from 'bun:sqlite'
+import { mkdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { MAX_TEAM } from './team'
+import type { AddResult, TeamDb } from './team-db'
+import type { TeamMember } from './types'
+
+export type SqliteTeamDb = TeamDb & { close(): void }
+
+export const TEAM_DDL =
+  'CREATE TABLE IF NOT EXISTS team (id INTEGER PRIMARY KEY, name TEXT NOT NULL, display_name TEXT NOT NULL, num TEXT NOT NULL, types TEXT NOT NULL, artwork TEXT NOT NULL, added_at INTEGER NOT NULL)'
+
+interface Row { id: number; name: string; display_name: string; num: string; types: string; artwork: string }
+
+export function openTeamDb(file: string): SqliteTeamDb {
+  if (file !== ':memory:') mkdirSync(dirname(file), { recursive: true })
+  const db = new Database(file, { create: true })
+  db.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000')
+  db.exec(TEAM_DDL)
+  const listQ = db.query<Row, []>('SELECT id, name, display_name, num, types, artwork FROM team ORDER BY added_at, rowid')
+  const hasQ = db.query<{ one: number }, [number]>('SELECT 1 AS one FROM team WHERE id = ?')
+  const countQ = db.query<{ n: number }, []>('SELECT COUNT(*) AS n FROM team')
+  const insertQ = db.query('INSERT INTO team (id, name, display_name, num, types, artwork, added_at) VALUES (?, ?, ?, ?, ?, ?, MAX(?, (SELECT COALESCE(MAX(added_at), 0) + 1 FROM team)))')
+  const deleteQ = db.query('DELETE FROM team WHERE id = ?')
+  // added_at is a clock that never repeats (MAX(now, last + 1)): rowid IS the Pokémon id, so it cannot break same-ms ties.
+  // count check + insert under ONE write lock (.immediate): two workers adding at five members cannot both succeed.
+  const addTx = db.transaction((m: TeamMember): AddResult => {
+    if (hasQ.get(m.id)) return 'present'
+    if ((countQ.get()?.n ?? 0) >= MAX_TEAM) return 'full'
+    insertQ.run(m.id, m.name, m.displayName, m.num, JSON.stringify(m.types), m.artwork, Date.now())
+    return 'added'
+  })
+  return {
+    list: async () => listQ.all().map((r) => ({ id: r.id, name: r.name, displayName: r.display_name, types: JSON.parse(r.types) as string[], artwork: r.artwork, num: r.num })),
+    add: async (m) => addTx.immediate(m),
+    remove: async (id) => deleteQ.run(id).changes > 0,
+    close: () => db.close(),
+  }
+}
+
+let shared: SqliteTeamDb | null = null
+export const teamDbPath = (): string => process.env.POKEDEX_TEAM_DB || join(process.cwd(), 'data/team.sqlite')
+/** Opened lazily on first use: `brust build` imports routes.tsx, and building must not create the file. */
+export function teamDb(): SqliteTeamDb {
+  return (shared ??= openTeamDb(teamDbPath()))
+}

package/templates/pokedex/lib/team-db.ts

@@ -1,52 +1,13 @@
-// examples/pokedex/lib/team-db.ts — server-only (brust.toml [build] server_only). The team is ONE shared roster, as in
-// 0.1.x, but persisted: every worker thread opens the same file (WAL), so workers never diverge (M3-F E7).
-import { Database } from 'bun:sqlite'
-import { mkdirSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { MAX_TEAM } from './team'
+// examples/pokedex/lib/team-db.ts — the TeamDb interface (async: D1 has no sync API) and the native default.
+// `brust build --target cloudflare` swaps this whole module for lib/team-db.d1.ts via brust.toml [cloudflare.alias],
+// so app imports (`./lib/team-db`) never change. Server-only (brust.toml [build] server_only = lib/team-db).
 import type { TeamMember } from './types'
 
 export type AddResult = 'added' | 'present' | 'full'
 export interface TeamDb {
-  list(): TeamMember[]
-  add(m: TeamMember): AddResult
-  remove(id: number): boolean
-  close(): void
+  list(): Promise<TeamMember[]>
+  add(m: TeamMember): Promise<AddResult>
+  remove(id: number): Promise<boolean>
 }
 
-interface Row { id: number; name: string; display_name: string; num: string; types: string; artwork: string }
-
-export function openTeamDb(file: string): TeamDb {
-  if (file !== ':memory:') mkdirSync(dirname(file), { recursive: true })
-  const db = new Database(file, { create: true })
-  db.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000')
-  db.exec(
-    'CREATE TABLE IF NOT EXISTS team (id INTEGER PRIMARY KEY, name TEXT NOT NULL, display_name TEXT NOT NULL, num TEXT NOT NULL, types TEXT NOT NULL, artwork TEXT NOT NULL, added_at INTEGER NOT NULL)',
-  )
-  const listQ = db.query<Row, []>('SELECT id, name, display_name, num, types, artwork FROM team ORDER BY added_at, rowid')
-  const hasQ = db.query<{ one: number }, [number]>('SELECT 1 AS one FROM team WHERE id = ?')
-  const countQ = db.query<{ n: number }, []>('SELECT COUNT(*) AS n FROM team')
-  const insertQ = db.query('INSERT INTO team (id, name, display_name, num, types, artwork, added_at) VALUES (?, ?, ?, ?, ?, ?, MAX(?, (SELECT COALESCE(MAX(added_at), 0) + 1 FROM team)))')
-  const deleteQ = db.query('DELETE FROM team WHERE id = ?')
-  // added_at is a clock that never repeats (MAX(now, last + 1)): rowid IS the Pokémon id, so it cannot break same-ms ties.
-  // count check + insert under ONE write lock (.immediate): two workers adding at five members cannot both succeed.
-  const addTx = db.transaction((m: TeamMember): AddResult => {
-    if (hasQ.get(m.id)) return 'present'
-    if ((countQ.get()?.n ?? 0) >= MAX_TEAM) return 'full'
-    insertQ.run(m.id, m.name, m.displayName, m.num, JSON.stringify(m.types), m.artwork, Date.now())
-    return 'added'
-  })
-  return {
-    list: () => listQ.all().map((r) => ({ id: r.id, name: r.name, displayName: r.display_name, types: JSON.parse(r.types) as string[], artwork: r.artwork, num: r.num })),
-    add: (m) => addTx.immediate(m),
-    remove: (id) => deleteQ.run(id).changes > 0,
-    close: () => db.close(),
-  }
-}
-
-let shared: TeamDb | null = null
-export const teamDbPath = (): string => process.env.POKEDEX_TEAM_DB || join(process.cwd(), 'data/team.sqlite')
-/** Opened lazily on first use: `brust build` imports routes.tsx, and building must not create the file. */
-export function teamDb(): TeamDb {
-  return (shared ??= openTeamDb(teamDbPath()))
-}
+export { openTeamDb, type SqliteTeamDb, teamDb, teamDbPath } from './team-db.sqlite'

package/templates/pokedex/migrations/0001_team.sql

@@ -0,0 +1,2 @@
+-- pokedex team roster (lib/team-db.sqlite.ts TEAM_DDL; the same table on D1)
+CREATE TABLE IF NOT EXISTS team (id INTEGER PRIMARY KEY, name TEXT NOT NULL, display_name TEXT NOT NULL, num TEXT NOT NULL, types TEXT NOT NULL, artwork TEXT NOT NULL, added_at INTEGER NOT NULL);

package/templates/pokedex/package.json.tmpl

@@ -6,6 +6,10 @@
   "scripts": {
     "dev": "brust build routes.tsx && brust start",
     "build": "brust build routes.tsx",
+    "dev:cf": "wrangler d1 migrations apply TEAM_DB --local --persist-to .wrangler/state && brust dev routes.tsx --target cloudflare",
+    "deploy:cf": "brust build routes.tsx --target cloudflare && wrangler deploy -c dist/cf/wrangler.jsonc",
+    "cf:migrate:local": "wrangler d1 migrations apply TEAM_DB --local --persist-to .wrangler/state",
+    "cf:migrate:remote": "wrangler d1 migrations apply TEAM_DB --remote",
     "start": "brust start",
     "snapshot": "bun scripts/snapshot.ts",
     "typecheck": "bun check"
@@ -20,6 +24,7 @@
   "devDependencies": {
     "@types/bun": "^1.4.0",
     "@types/react": "^19.2.0",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "wrangler": "^4.149.0"
   }
 }

package/templates/pokedex/wrangler.jsonc

@@ -0,0 +1,9 @@
+// Bindings for `brust build --target cloudflare` (merged into dist/cf/wrangler.jsonc).
+// brust owns main, assets and compatibility_date. Add the database_id from `wrangler d1 create pokedex-team` before deploy.
+{
+  // To enable the shared cache tier (brust.toml [cache]), add these beside d1_databases:
+  //   "kv_namespaces": [{ "binding": "BRUST_CACHE", "id": "<wrangler kv namespace create brust-cache>" }],
+  //   "durable_objects": { "bindings": [{ "name": "BRUST_CACHE_DO", "class_name": "BrustCacheDO" }] },
+  //   "migrations": [{ "tag": "brust-cache-v1", "new_sqlite_classes": ["BrustCacheDO"] }],
+  "d1_databases": [{ "binding": "TEAM_DB", "database_name": "pokedex-team", "migrations_dir": "migrations" }]
+}