@pyreon/zero 0.12.1 → 0.12.3

package/src/actions.ts

@@ -34,7 +34,6 @@ export interface Action<T = unknown> {
 // ─── Registry ────────────────────────────────────────────────────────────────
 
 const actionRegistry = new Map<string, RegisteredAction>()
-let actionCounter = 0
 
 /**
  * Define a server action. Returns a callable function that:
@@ -53,7 +52,7 @@ let actionCounter = 0
  * const result = await createPost({ title: 'Hello', body: '...' })
  */
 export function defineAction<T = unknown>(handler: ActionHandler<T>): Action<T> {
-  const id = `action_${actionCounter++}`
+  const id = `action_${crypto.randomUUID().slice(0, 8)}`
 
   actionRegistry.set(id, { id, handler: handler as ActionHandler })
 
@@ -100,7 +99,6 @@ export function getRegisteredActions(): Map<string, RegisteredAction> {
  */
 export function _resetActions(): void {
   actionRegistry.clear()
-  actionCounter = 0
 }
 
 // ─── Server handler ──────────────────────────────────────────────────────────

package/src/adapters/bun.ts

@@ -1,4 +1,5 @@
 import type { Adapter, AdapterBuildOptions } from '../types'
+import { validateBuildInputs } from './validate'
 
 /**
  * Bun adapter — generates a standalone Bun.serve() entry.
@@ -7,6 +8,7 @@ export function bunAdapter(): Adapter {
   return {
     name: 'bun',
     async build(options: AdapterBuildOptions) {
+      await validateBuildInputs(options)
       const { writeFile, cp, mkdir } = await import('node:fs/promises')
       const { join } = await import('node:path')
 

package/src/adapters/cloudflare.ts

@@ -0,0 +1,84 @@
+import type { Adapter, AdapterBuildOptions } from '../types'
+import { validateBuildInputs } from './validate'
+
+/**
+ * Cloudflare Pages adapter — generates output for Cloudflare Pages with Functions.
+ *
+ * Produces:
+ * - Client assets in the output directory root (served as static)
+ * - `_worker.js` — Cloudflare Pages Function for SSR
+ *
+ * Note: Cloudflare Pages Functions have a ~1MB module size limit.
+ * For large apps, configure Vite's SSR build to bundle server code:
+ * `ssr: { noExternal: true }` in vite.config.ts.
+ *
+ * Deploy with: `npx wrangler pages deploy ./dist`
+ *
+ * @example
+ * ```ts
+ * // zero.config.ts
+ * import { defineConfig } from "@pyreon/zero"
+ *
+ * export default defineConfig({
+ *   adapter: "cloudflare",
+ * })
+ * ```
+ */
+export function cloudflareAdapter(): Adapter {
+  return {
+    name: 'cloudflare',
+    async build(options: AdapterBuildOptions) {
+      await validateBuildInputs(options)
+      const { writeFile, cp, mkdir } = await import('node:fs/promises')
+      const { join } = await import('node:path')
+
+      const outDir = options.outDir
+      await mkdir(outDir, { recursive: true })
+
+      // Copy client assets to root (Cloudflare serves static files from root)
+      await cp(options.clientOutDir, outDir, { recursive: true })
+
+      // Copy server build
+      await cp(join(options.serverEntry, '..'), join(outDir, '_server'), {
+        recursive: true,
+      })
+
+      // Generate Cloudflare Pages _worker.js (ES module format)
+      const workerEntry = `
+import handler from "./_server/entry-server.js"
+
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url)
+
+    // Let Cloudflare serve static assets (files with extensions)
+    // This check is a fallback — Pages routes static files automatically
+    const ext = url.pathname.split(".").pop()
+    if (ext && ext !== url.pathname && !url.pathname.endsWith("/")) {
+      // Cloudflare Pages handles static assets automatically via its asset binding
+      // Only reach here if the file doesn't exist — fall through to SSR
+    }
+
+    // SSR handler
+    try {
+      return await handler(request)
+    } catch (err) {
+      return new Response("Internal Server Error", { status: 500 })
+    }
+  },
+}
+`.trimStart()
+
+      await writeFile(join(outDir, '_worker.js'), workerEntry)
+
+      // Cloudflare Pages config — _routes.json for routing
+      const routesConfig = {
+        version: 1,
+        include: ['/*'],
+        exclude: ['/assets/*', '/favicon.*', '/site.webmanifest', '/robots.txt', '/sitemap.xml'],
+      }
+
+      await writeFile(join(outDir, '_routes.json'), JSON.stringify(routesConfig, null, 2))
+    },
+  }
+}

package/src/adapters/index.ts

@@ -1,11 +1,17 @@
 export { bunAdapter } from './bun'
+export { cloudflareAdapter } from './cloudflare'
+export { netlifyAdapter } from './netlify'
 export { nodeAdapter } from './node'
 export { staticAdapter } from './static'
+export { vercelAdapter } from './vercel'
 
 import type { Adapter, ZeroConfig } from '../types'
 import { bunAdapter } from './bun'
+import { cloudflareAdapter } from './cloudflare'
+import { netlifyAdapter } from './netlify'
 import { nodeAdapter } from './node'
 import { staticAdapter } from './static'
+import { vercelAdapter } from './vercel'
 
 /**
  * Resolve the adapter from config.
@@ -21,7 +27,13 @@ export function resolveAdapter(config: ZeroConfig): Adapter {
       return bunAdapter()
     case 'static':
       return staticAdapter()
+    case 'vercel':
+      return vercelAdapter()
+    case 'cloudflare':
+      return cloudflareAdapter()
+    case 'netlify':
+      return netlifyAdapter()
     default:
-      throw new Error(`[zero] Unknown adapter: "${name}". Use "node", "bun", or "static".`)
+      throw new Error(`[zero] Unknown adapter: "${name}". Use "node", "bun", "static", "vercel", "cloudflare", or "netlify".`)
   }
 }

package/src/adapters/netlify.ts

@@ -0,0 +1,86 @@
+import type { Adapter, AdapterBuildOptions } from '../types'
+import { validateBuildInputs } from './validate'
+
+/**
+ * Netlify adapter — generates output for Netlify Functions (v2).
+ *
+ * Produces:
+ * - Client assets in `publish/` directory
+ * - `netlify/functions/ssr.mjs` — Netlify Function for SSR
+ * - `netlify.toml` — routing configuration
+ *
+ * @example
+ * ```ts
+ * // zero.config.ts
+ * import { defineConfig } from "@pyreon/zero"
+ *
+ * export default defineConfig({
+ *   adapter: "netlify",
+ * })
+ * ```
+ */
+export function netlifyAdapter(): Adapter {
+  return {
+    name: 'netlify',
+    async build(options: AdapterBuildOptions) {
+      await validateBuildInputs(options)
+      const { writeFile, cp, mkdir } = await import('node:fs/promises')
+      const { join } = await import('node:path')
+
+      const outDir = options.outDir
+      const publishDir = join(outDir, 'publish')
+      const functionsDir = join(outDir, 'netlify', 'functions')
+
+      await mkdir(publishDir, { recursive: true })
+      await mkdir(functionsDir, { recursive: true })
+
+      // Copy client assets to publish/
+      await cp(options.clientOutDir, publishDir, { recursive: true })
+
+      // Copy server build to functions directory
+      await cp(join(options.serverEntry, '..'), join(functionsDir, '_server'), {
+        recursive: true,
+      })
+
+      // Generate Netlify Function (v2 format — ESM, Web-standard Request/Response)
+      const funcEntry = `
+import handler from "./_server/entry-server.js"
+
+export default async function(req, context) {
+  try {
+    return await handler(req)
+  } catch (err) {
+    return new Response("Internal Server Error", { status: 500 })
+  }
+}
+
+export const config = {
+  path: "/*",
+  preferStatic: true,
+}
+`.trimStart()
+
+      await writeFile(join(functionsDir, 'ssr.mjs'), funcEntry)
+
+      // Generate netlify.toml
+      const toml = `
+[build]
+  publish = "publish"
+  functions = "netlify/functions"
+
+[[headers]]
+  for = "/assets/*"
+  [headers.values]
+    Cache-Control = "public, max-age=31536000, immutable"
+
+[[redirects]]
+  from = "/*"
+  to = "/.netlify/functions/ssr"
+  status = 200
+  conditions = {Role = ["admin", "user", ""]}
+`.trimStart()
+
+      await writeFile(join(outDir, 'netlify.toml'), toml)
+    },
+  }
+}

package/src/adapters/node.ts

@@ -1,4 +1,5 @@
 import type { Adapter, AdapterBuildOptions } from '../types'
+import { validateBuildInputs } from './validate'
 
 /**
  * Node.js adapter — generates a standalone server entry using node:http.
@@ -7,6 +8,7 @@ export function nodeAdapter(): Adapter {
   return {
     name: 'node',
     async build(options: AdapterBuildOptions) {
+      await validateBuildInputs(options)
       const { writeFile, cp, mkdir } = await import('node:fs/promises')
       const { join } = await import('node:path')
 

package/src/adapters/validate.ts

@@ -0,0 +1,16 @@
+import type { AdapterBuildOptions } from '../types'
+
+/**
+ * Validate that adapter build inputs exist before copying.
+ * Throws with a clear error message if directories are missing.
+ * @internal
+ */
+export async function validateBuildInputs(options: AdapterBuildOptions): Promise<void> {
+  const { existsSync } = await import('node:fs')
+  if (!existsSync(options.clientOutDir)) {
+    throw new Error(`[zero:adapter] Client build output not found: ${options.clientOutDir}. Run "vite build" first.`)
+  }
+  if (!existsSync(options.serverEntry)) {
+    throw new Error(`[zero:adapter] Server entry not found: ${options.serverEntry}. Run "vite build --ssr" first.`)
+  }
+}

package/src/adapters/vercel.ts

@@ -0,0 +1,86 @@
+import type { Adapter, AdapterBuildOptions } from '../types'
+import { validateBuildInputs } from './validate'
+
+/**
+ * Vercel adapter — generates output for Vercel's Build Output API v3.
+ *
+ * Produces a `.vercel/output` directory with:
+ * - `static/` — client-side assets (JS, CSS, images)
+ * - `functions/ssr.func/` — serverless function for SSR
+ * - `config.json` — routing configuration
+ *
+ * @example
+ * ```ts
+ * // zero.config.ts
+ * import { defineConfig } from "@pyreon/zero"
+ *
+ * export default defineConfig({
+ *   adapter: "vercel",
+ * })
+ * ```
+ */
+export function vercelAdapter(): Adapter {
+  return {
+    name: 'vercel',
+    async build(options: AdapterBuildOptions) {
+      await validateBuildInputs(options)
+      const { writeFile, cp, mkdir } = await import('node:fs/promises')
+      const { join } = await import('node:path')
+
+      const vercelDir = join(options.outDir, '.vercel', 'output')
+      const staticDir = join(vercelDir, 'static')
+      const funcDir = join(vercelDir, 'functions', 'ssr.func')
+
+      await mkdir(staticDir, { recursive: true })
+      await mkdir(funcDir, { recursive: true })
+
+      // Copy client assets to static/
+      await cp(options.clientOutDir, staticDir, { recursive: true })
+
+      // Copy server build to function directory
+      await cp(join(options.serverEntry, '..'), funcDir, { recursive: true })
+
+      // Generate serverless function entry
+      const funcEntry = `
+export default async function handler(req) {
+  const handler = (await import("./entry-server.js")).default
+  return handler(req)
+}
+`.trimStart()
+
+      await writeFile(join(funcDir, 'index.js'), funcEntry)
+
+      // Function config
+      await writeFile(
+        join(funcDir, '.vc-config.json'),
+        JSON.stringify(
+          {
+            runtime: 'nodejs20.x',
+            handler: 'index.js',
+            launcherType: 'Nodejs',
+          },
+          null,
+          2,
+        ),
+      )
+
+      // Vercel Build Output config
+      const config = {
+        version: 3,
+        routes: [
+          // Serve static assets directly
+          {
+            src: '/assets/(.*)',
+            headers: { 'Cache-Control': 'public, max-age=31536000, immutable' },
+          },
+          // Favicon and manifest
+          { src: '/(favicon\\..*|site\\.webmanifest|robots\\.txt|sitemap\\.xml)', dest: '/$1' },
+          // All other routes → SSR function
+          { src: '/(.*)', dest: '/ssr' },
+        ],
+      }
+
+      await writeFile(join(vercelDir, 'config.json'), JSON.stringify(config, null, 2))
+    },
+  }
+}