@jasonshimmy/vite-plugin-cer-app 0.23.1 → 0.24.0

package/src/cli/commands/adapt.ts

@@ -1,84 +0,0 @@
-import { Command } from 'commander'
-import { resolve } from 'pathe'
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { pathToFileURL } from 'node:url'
-import { runVercelAdapter } from '../adapters/vercel.js'
-import { runNetlifyAdapter } from '../adapters/netlify.js'
-import { runCloudflareAdapter } from '../adapters/cloudflare.js'
-import type { CerAppConfig } from '../../types/config.js'
-
-async function loadCustomAdapter(root: string): Promise<((root: string) => Promise<void>) | null> {
-  const configPath = resolve(root, 'cer.config.ts')
-  const configPathJs = resolve(root, 'cer.config.js')
-  const filePath = existsSync(configPath) ? configPath : existsSync(configPathJs) ? configPathJs : null
-  if (!filePath) return null
-
-  try {
-    const { build: viteBuild } = await import('vite')
-    const cerDir = resolve(root, '.cer')
-    const cerTsconfig = resolve(cerDir, 'tsconfig.json')
-    if (!existsSync(cerTsconfig)) {
-      mkdirSync(cerDir, { recursive: true })
-      writeFileSync(cerTsconfig, '{"compilerOptions":{}}\n', 'utf-8')
-    }
-    await viteBuild({
-      build: {
-        lib: { entry: filePath, formats: ['es'], fileName: 'cer.config' },
-        outDir: resolve(root, 'node_modules/.cer-app-cache'),
-        write: true,
-        rollupOptions: { external: (id: string) => !id.startsWith('.') && !id.startsWith('/') },
-      },
-      logLevel: 'silent',
-    })
-    const outFile = resolve(root, 'node_modules/.cer-app-cache/cer.config.mjs')
-    if (existsSync(outFile)) {
-      const mod = await import(pathToFileURL(outFile).href + `?t=${Date.now()}`)
-      const cfg: CerAppConfig = mod.default ?? {}
-      return typeof cfg.adapter === 'function' ? cfg.adapter : null
-    }
-  } catch {
-    // ignore
-  }
-  return null
-}
-
-export function adaptCommand(): Command {
-  return new Command('adapt')
-    .description('Adapt the production build for a deployment platform')
-    .requiredOption(
-      '--platform <platform>',
-      'Target platform: vercel, netlify, cloudflare, or custom (reads adapter function from cer.config.ts)',
-    )
-    .option('--root <root>', 'Project root directory', process.cwd())
-    .action(async (options) => {
-      const root = resolve(options.root)
-      switch (options.platform) {
-        case 'vercel':
-          await runVercelAdapter(root)
-          break
-        case 'netlify':
-          await runNetlifyAdapter(root)
-          break
-        case 'cloudflare':
-          await runCloudflareAdapter(root)
-          break
-        case 'custom': {
-          const fn = await loadCustomAdapter(root)
-          if (!fn) {
-            console.error(
-              '[cer-app] No custom adapter function found in cer.config.ts. ' +
-              'Set `adapter: async (root) => { ... }` in your config.',
-            )
-            process.exit(1)
-          }
-          await fn(root)
-          break
-        }
-        default:
-          console.error(
-            `[cer-app] Unknown platform: "${options.platform}". Supported: vercel, netlify, cloudflare, custom`,
-          )
-          process.exit(1)
-      }
-    })
-}

package/src/cli/commands/build.ts

@@ -1,165 +0,0 @@
-import { Command } from 'commander'
-import { build } from 'vite'
-import { resolve, join } from 'pathe'
-import { pathToFileURL } from 'node:url'
-import { existsSync, renameSync, mkdirSync, writeFileSync } from 'node:fs'
-import { cerApp, resolveConfig } from '../../plugin/index.js'
-import { buildSSR, resolveClientEntry } from '../../plugin/build-ssr.js'
-import { buildSSG } from '../../plugin/build-ssg.js'
-import { writeGeneratedDir } from '../../plugin/generated-dir.js'
-import { runVercelAdapter } from '../adapters/vercel.js'
-import { runNetlifyAdapter } from '../adapters/netlify.js'
-import { runCloudflareAdapter } from '../adapters/cloudflare.js'
-import type { CerAppConfig } from '../../types/config.js'
-
-async function loadCerConfig(root: string): Promise<CerAppConfig> {
-  const configPath = resolve(root, 'cer.config.ts')
-  const configPathJs = resolve(root, 'cer.config.js')
-
-  const filePath = existsSync(configPath)
-    ? configPath
-    : existsSync(configPathJs)
-      ? configPathJs
-      : null
-
-  if (!filePath) return {}
-
-  try {
-    // Bootstrap .cer/tsconfig.json so rolldown can resolve it during cer.config.ts transform
-    const cerDir = resolve(root, '.cer')
-    const cerTsconfig = resolve(cerDir, 'tsconfig.json')
-    if (!existsSync(cerTsconfig)) {
-      mkdirSync(cerDir, { recursive: true })
-      writeFileSync(cerTsconfig, '{"compilerOptions":{}}\n', 'utf-8')
-    }
-
-    const { build: viteBuild } = await import('vite')
-    await viteBuild({
-      build: {
-        lib: {
-          entry: filePath,
-          formats: ['es'],
-          fileName: 'cer.config',
-        },
-        outDir: resolve(root, 'node_modules/.cer-app-cache'),
-        write: true,
-        rollupOptions: { external: (id: string) => !id.startsWith('.') && !id.startsWith('/') },
-      },
-      logLevel: 'silent',
-    })
-
-    const outFile = resolve(root, 'node_modules/.cer-app-cache/cer.config.mjs')
-    if (existsSync(outFile)) {
-      const mod = await import(pathToFileURL(outFile).href + `?t=${Date.now()}`)
-      return mod.default ?? {}
-    }
-  } catch {
-    // ignore
-  }
-
-  try {
-    const mod = await import(pathToFileURL(filePath).href + `?t=${Date.now()}`)
-    return mod.default ?? {}
-  } catch {
-    return {}
-  }
-}
-
-async function runAdapter(adapter: CerAppConfig['adapter'], root: string): Promise<void> {
-  if (!adapter) return
-  if (typeof adapter === 'function') {
-    await adapter(root)
-    return
-  }
-  switch (adapter) {
-    case 'vercel':
-      await runVercelAdapter(root)
-      break
-    case 'netlify':
-      await runNetlifyAdapter(root)
-      break
-    case 'cloudflare':
-      await runCloudflareAdapter(root)
-      break
-    default:
-      console.warn(`[cer-app] Unknown adapter "${adapter}" — skipping.`)
-  }
-}
-
-export function buildCommand(): Command {
-  return new Command('build')
-    .description('Build the application for production')
-    .option('--root <root>', 'Project root directory', process.cwd())
-    .option('--mode <mode>', 'Build mode: spa, ssr, or ssg (overrides cer.config.ts)')
-    .action(async (options) => {
-      const root = resolve(options.root)
-      const userConfig = await loadCerConfig(root)
-
-      // CLI --mode flag overrides config file
-      if (options.mode) {
-        userConfig.mode = options.mode as 'spa' | 'ssr' | 'ssg'
-      }
-
-      const config = resolveConfig(userConfig, root)
-
-      console.log(`[cer-app] Building in ${config.mode} mode...`)
-
-      switch (config.mode) {
-        case 'spa': {
-          // Write .cer/ files BEFORE resolveClientEntry checks for .cer/index.html.
-          writeGeneratedDir(config)
-          const spaEntry = resolveClientEntry(config)
-          const spaOutDir = resolve(root, 'dist')
-          await build({
-            root,
-            plugins: cerApp(userConfig),
-            build: {
-              outDir: spaOutDir,
-              rollupOptions: { input: spaEntry },
-            },
-          })
-          // If the entry was .cer/index.html, Vite outputs it as dist/.cer/index.html.
-          // Rename it to dist/index.html so the preview server can find it.
-          const generatedHtmlOut = join(spaOutDir, '.cer/index.html')
-          const rootHtmlOut = join(spaOutDir, 'index.html')
-          if (existsSync(generatedHtmlOut) && !existsSync(rootHtmlOut)) {
-            renameSync(generatedHtmlOut, rootHtmlOut)
-          }
-          console.log('[cer-app] SPA build complete.')
-          await runAdapter(userConfig.adapter, root)
-          // Force exit: Vite HTML builds may keep Node timers alive.
-          process.exit(0)
-          break
-        }
-
-        case 'ssr': {
-          const viteUserConfig = {
-            root,
-            plugins: cerApp(userConfig),
-          }
-          await buildSSR(config, viteUserConfig)
-          await runAdapter(userConfig.adapter, root)
-          // Force exit: the client (HTML) build may keep Node timers alive.
-          process.exit(0)
-          break
-        }
-
-        case 'ssg': {
-          const viteUserConfig = {
-            root,
-            plugins: cerApp(userConfig),
-          }
-          await buildSSG(config, viteUserConfig)
-          await runAdapter(userConfig.adapter, root)
-          // Force exit: the SSG path-enumeration Vite server may keep alive Node timers
-          process.exit(0)
-          break
-        }
-
-        default: {
-          console.error(`[cer-app] Unknown mode: ${config.mode}`)
-          process.exit(1)
-        }
-      }
-    })
-}

package/src/cli/commands/dev.ts

@@ -1,125 +0,0 @@
-import { Command } from 'commander'
-import { createServer } from 'vite'
-import { resolve } from 'pathe'
-import { pathToFileURL } from 'node:url'
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { cerApp } from '../../plugin/index.js'
-import type { CerAppConfig } from '../../types/config.js'
-
-/**
- * Loads cer.config.ts from the current working directory.
- * Returns an empty object if no config file is found.
- */
-async function loadCerConfig(root: string): Promise<CerAppConfig> {
-  const configPath = resolve(root, 'cer.config.ts')
-  const configPathJs = resolve(root, 'cer.config.js')
-
-  const filePath = existsSync(configPath)
-    ? configPath
-    : existsSync(configPathJs)
-      ? configPathJs
-      : null
-
-  if (!filePath) {
-    console.warn('[cer-app] No cer.config.ts found; using defaults.')
-    return {}
-  }
-
-  try {
-    const originalNodeEnv = process.env.NODE_ENV
-    const originalMode = process.env.MODE
-    // Bootstrap .cer/tsconfig.json so rolldown can resolve it during cer.config.ts transform
-    const cerDir = resolve(root, '.cer')
-    const cerTsconfig = resolve(cerDir, 'tsconfig.json')
-    if (!existsSync(cerTsconfig)) {
-      mkdirSync(cerDir, { recursive: true })
-      writeFileSync(cerTsconfig, '{"compilerOptions":{}}\n', 'utf-8')
-    }
-
-    // Use Vite's build to transpile TS config at runtime
-    try {
-      const { build } = await import('vite')
-      await build({
-        build: {
-          lib: {
-            entry: filePath,
-            formats: ['es'],
-            fileName: 'cer.config',
-          },
-          outDir: resolve(root, 'node_modules/.cer-app-cache'),
-          write: true,
-          rollupOptions: {
-            // Externalize all bare package imports (handles file: symlinks too)
-            external: (id: string) => !id.startsWith('.') && !id.startsWith('/'),
-          },
-        },
-        logLevel: 'silent',
-      })
-    } finally {
-      if (typeof originalNodeEnv === 'undefined') delete process.env.NODE_ENV
-      else process.env.NODE_ENV = originalNodeEnv
-      if (typeof originalMode === 'undefined') delete process.env.MODE
-      else process.env.MODE = originalMode
-    }
-
-    const outFile = resolve(root, 'node_modules/.cer-app-cache/cer.config.mjs')
-    if (existsSync(outFile)) {
-      const mod = await import(pathToFileURL(outFile).href + `?t=${Date.now()}`)
-      return mod.default ?? {}
-    }
-  } catch (err) {
-    console.warn('[cer-app] Could not load cer.config.ts via build, trying dynamic import:', err)
-  }
-
-  // Fallback: try direct import (works for .js configs)
-  try {
-    const mod = await import(pathToFileURL(filePath).href + `?t=${Date.now()}`)
-    return mod.default ?? {}
-  } catch {
-    return {}
-  }
-}
-
-export function devCommand(): Command {
-  return new Command('dev')
-    .description('Start the development server')
-    .option('-p, --port <port>', 'Port to listen on', '3000')
-    .option('--host <host>', 'Host to bind to', 'localhost')
-    .option('--root <root>', 'Project root directory', process.cwd())
-    .option('--mode <mode>', 'Dev mode: spa, ssr, or ssg (overrides cer.config.ts)')
-    .action(async (options) => {
-      const root = resolve(options.root)
-      const userConfig = await loadCerConfig(root)
-      process.env.NODE_ENV = 'development'
-      process.env.MODE = 'development'
-      // CLI --mode flag overrides config file (mirrors build command behaviour)
-      if (options.mode) {
-        userConfig.mode = options.mode as 'spa' | 'ssr' | 'ssg'
-      }
-      const port = options.port ? parseInt(options.port, 10) : (userConfig.port ?? 3000)
-
-      console.log('[cer-app] Starting dev server...')
-
-      const server = await createServer({
-        root,
-        server: {
-          port,
-          host: options.host,
-        },
-        plugins: cerApp(userConfig),
-      })
-
-      await server.listen()
-      server.printUrls()
-
-      // Handle graceful shutdown
-      process.on('SIGTERM', async () => {
-        await server.close()
-        process.exit(0)
-      })
-      process.on('SIGINT', async () => {
-        await server.close()
-        process.exit(0)
-      })
-    })
-}

package/src/cli/commands/generate.ts

@@ -1,91 +0,0 @@
-import { Command } from 'commander'
-import { resolve } from 'pathe'
-import { pathToFileURL } from 'node:url'
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { resolveConfig } from '../../plugin/index.js'
-import { buildSSG } from '../../plugin/build-ssg.js'
-import { cerApp } from '../../plugin/index.js'
-import type { CerAppConfig } from '../../types/config.js'
-
-async function loadCerConfig(root: string): Promise<CerAppConfig> {
-  const configPath = resolve(root, 'cer.config.ts')
-  const configPathJs = resolve(root, 'cer.config.js')
-
-  const filePath = existsSync(configPath)
-    ? configPath
-    : existsSync(configPathJs)
-      ? configPathJs
-      : null
-
-  if (!filePath) return {}
-
-  try {
-    // Bootstrap .cer/tsconfig.json so rolldown can resolve it during cer.config.ts transform
-    const cerDir = resolve(root, '.cer')
-    const cerTsconfig = resolve(cerDir, 'tsconfig.json')
-    if (!existsSync(cerTsconfig)) {
-      mkdirSync(cerDir, { recursive: true })
-      writeFileSync(cerTsconfig, '{"compilerOptions":{}}\n', 'utf-8')
-    }
-
-    const { build } = await import('vite')
-    await build({
-      build: {
-        lib: {
-          entry: filePath,
-          formats: ['es'],
-          fileName: 'cer.config',
-        },
-        outDir: resolve(root, 'node_modules/.cer-app-cache'),
-        write: true,
-        rollupOptions: { external: (id: string) => !id.startsWith('.') && !id.startsWith('/') },
-      },
-      logLevel: 'silent',
-    })
-
-    const outFile = resolve(root, 'node_modules/.cer-app-cache/cer.config.mjs')
-    if (existsSync(outFile)) {
-      const mod = await import(pathToFileURL(outFile).href + `?t=${Date.now()}`)
-      return mod.default ?? {}
-    }
-  } catch {
-    // ignore
-  }
-
-  try {
-    const mod = await import(pathToFileURL(filePath).href + `?t=${Date.now()}`)
-    return mod.default ?? {}
-  } catch {
-    return {}
-  }
-}
-
-/**
- * `cer-app generate` — runs the full SSG build pipeline.
- * Alias for `cer-app build --mode ssg`.
- */
-export function generateCommand(): Command {
-  return new Command('generate')
-    .description('Generate a static site (SSG build)')
-    .option('--root <root>', 'Project root directory', process.cwd())
-    .action(async (options) => {
-      const root = resolve(options.root)
-      const userConfig = await loadCerConfig(root)
-
-      // Force SSG mode
-      userConfig.mode = 'ssg'
-
-      const config = resolveConfig(userConfig, root)
-
-      console.log('[cer-app] Running SSG generation...')
-
-      const viteUserConfig = {
-        root,
-        plugins: cerApp(userConfig),
-      }
-
-      await buildSSG(config, viteUserConfig)
-      // Force exit: the SSG path-enumeration Vite server may keep alive Node timers.
-      process.exit(0)
-    })
-}

package/src/cli/commands/preview-isr.ts

@@ -1,172 +0,0 @@
-/**
- * ISR (Incremental Static Regeneration) helpers for the preview server.
- *
- * Extracted into their own module so they can be unit-tested independently
- * from the HTTP server wiring in preview.ts.
- */
-
-import { resolve, join } from 'pathe'
-import { Readable } from 'node:stream'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export interface IsrCacheEntry {
-  html: string
-  headers: Record<string, string>
-  statusCode: number
-  builtAt: number
-  revalidate: number
-  /** True while a background re-render is in flight (stale-while-revalidate). */
-  revalidating: boolean
-}
-
-export type IsrCacheStatus = 'HIT' | 'STALE' | 'MISS'
-
-export type SsrHandlerFn = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>
-
-// ─── Path traversal guard ─────────────────────────────────────────────────────
-
-/**
- * Returns `true` when `urlPath` joined onto `rootDir` resolves to a path that
- * is strictly inside (or equal to) `rootDir`. A traversal attempt such as
- * `../../../../etc/passwd` would resolve outside `rootDir` and return `false`.
- */
-export function isPathBounded(rootDir: string, urlPath: string): boolean {
-  const safeRoot = resolve(rootDir)
-  const resolved = resolve(join(rootDir, urlPath))
-  return resolved === safeRoot || resolved.startsWith(safeRoot + '/')
-}
-
-// ─── Route pattern matching ───────────────────────────────────────────────────
-
-/**
- * Tests whether a route path pattern matches a URL path string.
- * Normalises trailing slashes and supports `:param` and `:param*` (catch-all)
- * segments using a simple regex conversion — no external dependencies needed.
- *
- * @example
- * matchRoutePattern('/blog/:slug', '/blog/hello') // true
- * matchRoutePattern('/:all*', '/any/deep/path')   // true
- * matchRoutePattern('/about', '/contact')          // false
- */
-export function matchRoutePattern(pattern: string, urlPath: string): boolean {
-  const norm = (s: string): string => s.replace(/\/+$/, '') || '/'
-  if (norm(pattern) === norm(urlPath)) return true
-  const regexStr =
-    '^' +
-    norm(pattern)
-      .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // escape regex special chars in static segments
-      .replace(/:[^/]+\*/g, '.*')
-      .replace(/:[^/]+/g, '[^/]+') +
-    '$'
-  return new RegExp(regexStr).test(norm(urlPath))
-}
-
-/**
- * Returns the per-route `render` strategy ('static' | 'server' | 'spa') for
- * the route that best matches `urlPath`, or `null` when no route matches or
- * none declares a render mode.
- */
-export function findRenderMode(
-  routes: Array<{ path: string; meta?: Record<string, unknown> }>,
-  urlPath: string,
-): 'static' | 'server' | 'spa' | null {
-  for (const route of routes) {
-    if (matchRoutePattern(route.path, urlPath)) {
-      const render = route.meta?.render
-      if (render === 'static' || render === 'server' || render === 'spa') return render
-      return null
-    }
-  }
-  return null
-}
-
-/**
- * Looks up the `meta.ssg.revalidate` TTL (in seconds) for the route that best
- * matches `urlPath`. Returns `null` when no route matches or none defines
- * `revalidate`.
- */
-export function findRevalidate(
-  routes: Array<{ path: string; meta?: Record<string, unknown> }>,
-  urlPath: string,
-): number | null {
-  for (const route of routes) {
-    if (matchRoutePattern(route.path, urlPath)) {
-      const ssg = route.meta?.ssg as Record<string, unknown> | undefined
-      if (typeof ssg?.revalidate === 'number') return ssg.revalidate
-    }
-  }
-  return null
-}
-
-// ─── Response capture ─────────────────────────────────────────────────────────
-
-/**
- * Renders a URL path through `handler` using a synthetic IncomingMessage and a
- * fake ServerResponse that captures the output in memory.
- *
- * Returns an `IsrCacheEntry` on success, or `null` if the handler throws.
- */
-export async function renderForIsr(
-  urlPath: string,
-  handler: SsrHandlerFn,
-  revalidate: number,
-): Promise<IsrCacheEntry | null> {
-  const req = Object.assign(new Readable({ read() {} }), {
-    url: urlPath,
-    method: 'GET',
-    headers: {},
-    socket: null,
-  }) as unknown as IncomingMessage
-
-  return new Promise<IsrCacheEntry | null>((resolve) => {
-    const chunks: Buffer[] = []
-    const headers: Record<string, string> = {}
-    let capturedStatus = 200
-
-    const fakeRes = {
-      get statusCode() { return capturedStatus },
-      set statusCode(v: number) { capturedStatus = v },
-      headersSent: false,
-      setHeader(name: string, value: string | string[]) {
-        headers[name.toLowerCase()] = Array.isArray(value) ? value.join(', ') : String(value)
-        return this
-      },
-      getHeader(name: string) { return headers[name.toLowerCase()] },
-      write(chunk: string | Buffer) {
-        if (chunk != null) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)))
-        return true
-      },
-      end(chunk?: string | Buffer) {
-        if (chunk != null) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)))
-        const html = Buffer.concat(chunks).toString('utf-8')
-        resolve({ html, headers, statusCode: capturedStatus, builtAt: Date.now(), revalidate, revalidating: false })
-        return this
-      },
-    } as unknown as ServerResponse
-
-    // Use Promise.resolve().then() so synchronous throws in the handler are
-    // also caught by the .catch() handler.
-    Promise.resolve().then(() => handler(req, fakeRes)).catch(() => resolve(null))
-  })
-}
-
-// ─── Cache serving ────────────────────────────────────────────────────────────
-
-/**
- * Writes a cached ISR entry to the real HTTP response, forwarding all captured
- * headers and setting the `X-Cache` diagnostic header.
- */
-export function serveFromIsrCache(
-  entry: IsrCacheEntry,
-  res: ServerResponse,
-  cacheStatus: IsrCacheStatus,
-): void {
-  for (const [name, value] of Object.entries(entry.headers)) {
-    res.setHeader(name, value)
-  }
-  res.setHeader('X-Cache', cacheStatus)
-  res.statusCode = entry.statusCode
-  res.end(entry.html)
-}