weifuwu 0.2.2 → 0.2.3

package/test/upload.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFile, rm, mkdir } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import { tmpdir } from 'node:os'
-import { Router } from '../router.ts'
-import { upload } from '../upload.ts'
-
-function createFormData(fields?: Record<string, string>, files?: Record<string, { name: string; data: string; type?: string }>): [Request, string] {
-  const boundary = '----boundary123'
-  const parts: string[] = []
-
-  for (const [key, value] of Object.entries(fields ?? {})) {
-    parts.push(`--${boundary}`)
-    parts.push(`Content-Disposition: form-data; name="${key}"`)
-    parts.push('')
-    parts.push(value)
-  }
-
-  for (const [key, file] of Object.entries(files ?? {})) {
-    parts.push(`--${boundary}`)
-    parts.push(`Content-Disposition: form-data; name="${key}"; filename="${file.name}"`)
-    if (file.type) parts.push(`Content-Type: ${file.type}`)
-    parts.push('')
-    parts.push(file.data)
-  }
-
-  parts.push(`--${boundary}--`)
-  const body = parts.join('\r\n')
-
-  const req = new Request('http://localhost/upload', {
-    method: 'POST',
-    headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}` },
-    body,
-  })
-
-  return [req, boundary]
-}
-
-describe('upload', () => {
-  it('parses fields from multipart form', async () => {
-    const r = new Router()
-      .post('/upload', upload(), (req, ctx) => Response.json(ctx.parsed?.fields))
-
-    const [req] = createFormData({ title: 'hello', desc: 'world' })
-    const res = await r.handler()(req, { params: {}, query: {} })
-    assert.equal(res.status, 200)
-    const data = await res.json() as Record<string, string>
-    assert.deepEqual(data, { title: 'hello', desc: 'world' })
-  })
-
-  it('parses files in memory', async () => {
-    const r = new Router()
-      .post('/upload', upload(), (req, ctx) => {
-        const files = ctx.parsed?.files as Record<string, unknown>
-        return Response.json(files)
-      })
-
-    const [req] = createFormData({}, {
-      avatar: { name: 'photo.png', data: 'fakeimagedata', type: 'image/png' },
-    })
-    const res = await r.handler()(req, { params: {}, query: {} })
-    assert.equal(res.status, 200)
-    const data = await res.json() as Record<string, any>
-    const file = data.avatar
-    assert.equal(file.name, 'photo.png')
-    assert.equal(file.type, 'image/png')
-    assert.ok(file.size)
-    assert.ok(file.buffer)
-  })
-
-  it('saves files to disk when dir is set', async () => {
-    const uploadDir = resolve(tmpdir(), 'weifuwu-upload-test')
-    await mkdir(uploadDir, { recursive: true })
-
-    const r = new Router()
-      .post('/upload', upload({ dir: uploadDir }), (req, ctx) => {
-        const files = ctx.parsed?.files as Record<string, any>
-        return Response.json(files)
-      })
-
-    const [req] = createFormData({}, {
-      doc: { name: 'test.txt', data: 'file content' },
-    })
-    const res = await r.handler()(req, { params: {}, query: {} })
-    const data = await res.json() as Record<string, any>
-    assert.ok(data.doc.path)
-    const saved = await readFile(data.doc.path, 'utf-8')
-    assert.equal(saved, 'file content')
-    await rm(uploadDir, { recursive: true, force: true })
-  })
-
-  it('rejects oversized files', async () => {
-    const r = new Router()
-      .post('/upload', upload({ maxFileSize: 5 }), () => new Response('ok'))
-
-    const [req] = createFormData({}, {
-      big: { name: 'big.txt', data: 'too large content' },
-    })
-    const res = await r.handler()(req, { params: {}, query: {} })
-    assert.equal(res.status, 413)
-  })
-
-  it('rejects disallowed file types', async () => {
-    const r = new Router()
-      .post('/upload', upload({ allowedTypes: ['image/png'] }), () => new Response('ok'))
-
-    const [req] = createFormData({}, {
-      bad: { name: 'script.exe', data: 'evil', type: 'application/x-msdownload' },
-    })
-    const res = await r.handler()(req, { params: {}, query: {} })
-    assert.equal(res.status, 415)
-  })
-
-  it('passes through non-multipart requests', async () => {
-    let reached = false
-    const r = new Router()
-      .post('/upload', upload(), (req, ctx, next) => {
-        reached = true
-        return next(req, ctx)
-      }, () => new Response('ok'))
-
-    const res = await r.handler()(
-      new Request('http://localhost/upload', { method: 'POST', body: 'plain text' }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.status, 200)
-    assert.equal(reached, true)
-  })
-})

package/test/validate.test.ts

@@ -1,133 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { z } from 'zod'
-import { Router } from '../router.ts'
-import { validate } from '../validate.ts'
-
-describe('validate', () => {
-  it('validates body with Zod schema', async () => {
-    const r = new Router()
-      .post('/users',
-        validate({ body: z.object({ name: z.string(), age: z.number() }) }),
-        async (req, ctx) => Response.json(ctx.parsed?.body),
-      )
-
-    const res = await r.handler()(
-      new Request('http://localhost/users', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: 'Alice', age: 30 }),
-      }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.status, 200)
-    const data = await res.json() as Record<string, unknown>
-    assert.deepEqual(data, { name: 'Alice', age: 30 })
-  })
-
-  it('rejects invalid body with 400', async () => {
-    const r = new Router()
-      .post('/users',
-        validate({ body: z.object({ name: z.string().min(1) }) }),
-        () => new Response('ok'),
-      )
-
-    const res = await r.handler()(
-      new Request('http://localhost/users', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: '' }),
-      }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.status, 400)
-    const data = await res.json() as Record<string, unknown>
-    assert.ok((data as any).issues)
-  })
-
-  it('validates query params', async () => {
-    const r = new Router()
-      .get('/search',
-        validate({ query: z.object({ q: z.string(), page: z.coerce.number().optional() }) }),
-        (req, ctx) => Response.json(ctx.parsed?.query),
-      )
-
-    const res = await r.handler()(
-      new Request('http://localhost/search?q=hello&page=2'),
-      { params: {}, query: { q: 'hello', page: '2' } },
-    )
-    assert.equal(res.status, 200)
-    const data = await res.json() as Record<string, unknown>
-    assert.deepEqual(data, { q: 'hello', page: 2 })
-  })
-
-  it('validates params', async () => {
-    const r = new Router()
-      .get('/:id',
-        validate({ params: z.object({ id: z.string().length(24) }) }),
-        (req, ctx) => Response.json(ctx.parsed?.params),
-      )
-
-    const res = await r.handler()(
-      new Request('http://localhost/507f1f77bcf86cd799439011'),
-      { params: { id: '507f1f77bcf86cd799439011' }, query: {} },
-    )
-    assert.equal(res.status, 200)
-    const data = await res.json() as Record<string, unknown>
-    assert.deepEqual(data, { id: '507f1f77bcf86cd799439011' })
-  })
-
-  it('rejects invalid params with 400', async () => {
-    const r = new Router()
-      .get('/:id',
-        validate({ params: z.object({ id: z.string().length(24) }) }),
-        () => new Response('ok'),
-      )
-
-    const res = await r.handler()(
-      new Request('http://localhost/bad-id'),
-      { params: { id: 'bad-id' }, query: {} },
-    )
-    assert.equal(res.status, 400)
-  })
-
-  it('validates both body and query simultaneously', async () => {
-    const r = new Router()
-      .post('/data',
-        validate({
-          body: z.object({ value: z.number() }),
-          query: z.object({ token: z.string() }),
-        }),
-        (req, ctx) => Response.json(ctx.parsed),
-      )
-
-    const res = await r.handler()(
-      new Request('http://localhost/data?token=abc', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ value: 42 }),
-      }),
-      { params: {}, query: { token: 'abc' } },
-    )
-    assert.equal(res.status, 200)
-    const data = await res.json() as Record<string, unknown>
-    assert.deepEqual(data, { body: { value: 42 }, query: { token: 'abc' } })
-  })
-
-  it('passes through when no schemas provided', async () => {
-    const r = new Router()
-      .post('/data',
-        validate({}),
-        () => new Response('ok'),
-      )
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', {
-        method: 'POST',
-        body: JSON.stringify({ x: 1 }),
-      }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.status, 200)
-  })
-})

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-    "skipLibCheck": true,
-    "allowImportingTsExtensions": true
-  },
-  "include": ["*.ts", "test/**/*.ts"]
-}

package/tsx.ts

@@ -1,374 +0,0 @@
-import { createElement, createContext, useContext } from 'react'
-import { renderToReadableStream } from 'react-dom/server'
-import * as esbuild from 'esbuild'
-import { readdirSync, statSync, existsSync, mkdirSync } from 'node:fs'
-import { join, relative, resolve, sep, dirname } from 'node:path'
-import { pathToFileURL } from 'node:url'
-import { createHash } from 'node:crypto'
-import { Router } from './router.ts'
-import type { Context, Handler } from './types.ts'
-
-export interface TsxOptions {
-  dir: string
-}
-
-export const TsxContext = createContext<{
-  params: Record<string, string>
-  query: Record<string, string>
-  user?: unknown
-  parsed?: Record<string, unknown>
-}>({ params: {}, query: {} })
-
-export function useTsx() {
-  return useContext(TsxContext)
-}
-
-type PageEntry = {
-  route: string
-  entryPath: string
-  loadPath?: string
-  layouts: string[]
-  routePath?: string
-}
-
-// ── helpers ────────────────────────────────────────────────────────────────
-
-function id(s: string): string {
-  return createHash('md5').update(s).digest('hex').slice(0, 8)
-}
-
-function concatUint8(chunks: Uint8Array[]): Uint8Array {
-  const len = chunks.reduce((a, c) => a + c.length, 0)
-  const out = new Uint8Array(len)
-  let off = 0
-  for (const c of chunks) {
-    out.set(c, off)
-    off += c.length
-  }
-  return out
-}
-
-async function readStream(stream: ReadableStream): Promise<string> {
-  const chunks: Uint8Array[] = []
-  const reader = stream.getReader()
-  while (true) {
-    const { done, value } = await reader.read()
-    if (done) break
-    chunks.push(value)
-  }
-  return new TextDecoder().decode(concatUint8(chunks))
-}
-
-// ── file scanning ──────────────────────────────────────────────────────────
-
-function scanPages(dir: string): PageEntry[] {
-  const pages: PageEntry[] = []
-
-  function walk(current: string) {
-    let entries: string[]
-    try {
-      entries = readdirSync(current)
-    } catch {
-      return
-    }
-
-    const dirs: string[] = []
-    for (const name of entries) {
-      const full = join(current, name)
-      const st = statSync(full)
-      if (st.isDirectory()) {
-        if (!name.startsWith('.')) dirs.push(full)
-      }
-    }
-
-    // Check for page.tsx in this directory
-    const pagePath = join(current, 'page.tsx')
-    const tsPagePath = join(current, 'page.ts')
-    let entryPath = ''
-    if (existsSync(pagePath)) {
-      entryPath = pagePath
-    } else if (existsSync(tsPagePath)) {
-      entryPath = tsPagePath
-    }
-
-    if (entryPath) {
-      let relPath = relative(dir, entryPath).replace(sep, '/')
-      // Remove page.tsx / page.ts suffix
-      relPath = relPath.replace(/\/page\.tsx?$/, '')
-      relPath = relPath.replace(/^page\.tsx?$/, '')
-
-      const route = filePathToRoute(relPath)
-      const layouts = resolveLayouts(current, dir)
-      const loadPath = existsSync(join(current, 'load.ts'))
-        ? join(current, 'load.ts') : undefined
-      const rPath = existsSync(join(current, 'route.ts'))
-        ? join(current, 'route.ts') : undefined
-
-      pages.push({
-        route,
-        entryPath,
-        loadPath,
-        layouts,
-        routePath: rPath,
-      })
-    }
-
-    for (const d of dirs) walk(d)
-  }
-
-  walk(dir)
-  return pages
-}
-
-function filePathToRoute(relPath: string): string {
-  let route = relPath.replace(/\\/g, '/')
-  // Remove page.tsx suffix => already done in scanPages
-  // [...rest] → *
-  route = route.replace(/\[\.\.\.(\w+)\]/g, '*')
-  // [slug] → :slug
-  route = route.replace(/\[(\w+)\]/g, ':$1')
-  return route.startsWith('/') ? route : '/' + route
-}
-
-function resolveLayouts(dir: string, pagesDir: string): string[] {
-  const layouts: string[] = []
-  let current = dir
-
-  while (current.startsWith(pagesDir)) {
-    const p = join(current, 'layout.tsx')
-    if (existsSync(p)) {
-      layouts.push(p)
-    }
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-
-  // Return outermost first
-  return layouts.reverse()
-}
-
-// ── compilation ────────────────────────────────────────────────────────────
-
-const esbId = '__weifuwu_tsx_build'
-
-async function compileAll(
-  files: string[],
-  outDir: string,
-  platform: 'node' | 'browser',
-): Promise<void> {
-  const entryPoints: Record<string, string> = {}
-  for (const f of files) {
-    entryPoints[id(f)] = f
-  }
-
-  await esbuild.build({
-    entryPoints,
-    outdir: outDir,
-    format: 'esm',
-    platform: platform === 'node' ? 'node' : 'browser',
-    jsx: 'automatic',
-    jsxImportSource: 'react',
-    bundle: platform === 'browser',
-    write: true,
-    allowOverwrite: true,
-  })
-}
-
-function compiledUrl(filePath: string, outDir: string): string {
-  const hash = id(join(outDir, id(filePath)))
-  const p = join(outDir, id(filePath) + '.js')
-  return pathToFileURL(p).href
-}
-
-// ── client bundle (lazy) ───────────────────────────────────────────────────
-
-const clientBundleCache = new Map<string, Uint8Array>()
-const clientRouteLog = new WeakMap<object, Set<string>>()
-
-async function getOrBuildClientBundle(
-  entryPath: string,
-  layoutPaths: string[],
-  pagesDir: string,
-  router: Router,
-): Promise<{ url: string } | null> {
-  const key = id(entryPath)
-  const url = `/__wfw/client/${key}.js`
-
-  if (!clientRouteLog.get(router)?.has(url)) {
-    let buf = clientBundleCache.get(key)
-
-    if (!buf) {
-      try {
-        const nested = layoutPaths.slice(1)
-        const layoutsImport = nested.map((p, i) =>
-          `import L${i} from${JSON.stringify(p)};`,
-        ).join('')
-        const layoutsWrap = nested.map((_, i) => {
-          const idx = nested.length - 1 - i
-          return `el=createElement(L${idx},null,el);`
-        }).join('')
-
-        const code = [
-          `import{hydrateRoot}from'react-dom/client';`,
-          `import{createElement}from'react';`,
-          `import P from${JSON.stringify(entryPath)};`,
-          layoutsImport,
-          `const p=window.__WEIFUWU_PROPS;`,
-          `let el=createElement(P,p);`,
-          layoutsWrap,
-          `hydrateRoot(document.getElementById('__weifuwu_root'),el);`,
-        ].join('')
-
-        const result = await esbuild.build({
-          stdin: { contents: code, loader: 'tsx', resolveDir: pagesDir },
-          bundle: true,
-          format: 'esm',
-          jsx: 'automatic',
-          jsxImportSource: 'react',
-          write: false,
-          minify: true,
-        })
-
-        buf = result.outputFiles[0].contents
-        clientBundleCache.set(key, buf)
-      } catch (err) {
-        console.error('hydration bundle failed:', err)
-        return null
-      }
-    }
-
-    router.get(url, () => new Response(buf! as BodyInit, {
-      headers: { 'content-type': 'application/javascript; charset=utf-8' },
-    }))
-
-    const set = clientRouteLog.get(router) ?? new Set()
-    set.add(url)
-    clientRouteLog.set(router, set)
-  }
-
-  return { url }
-}
-
-// ── SSR handler ────────────────────────────────────────────────────────────
-
-function makeSsrHandler(
-  Component: any,
-  loadFn: any | undefined,
-  layouts: any[],
-  entryPath: string,
-  layoutPaths: string[],
-  pagesDir: string,
-  router: Router,
-): Handler {
-  return async (req, ctx) => {
-    const loadProps = loadFn ? await loadFn({ params: ctx.params, query: ctx.query }) : {}
-    const allProps = { ...loadProps, params: ctx.params, query: ctx.query }
-
-    let element = createElement(Component, allProps)
-    for (let i = layouts.length - 1; i >= 0; i--) {
-      const isRoot = i === 0
-      element = createElement(
-        layouts[i],
-        isRoot ? { children: element, req, ctx } : { children: element },
-      )
-    }
-
-    element = createElement(TsxContext.Provider, {
-      value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed },
-    }, element)
-
-    const stream = await renderToReadableStream(element)
-    const body = await readStream(stream)
-
-    const scripts: string[] = []
-    scripts.push(`<script>window.__WEIFUWU_PROPS=${JSON.stringify(allProps)}</script>`)
-
-    const bundle = await getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router)
-    if (bundle) {
-      scripts.push(`<script type="module" src="${bundle.url}"></script>`)
-    }
-
-    const html = `<!DOCTYPE html>\n${body}\n${scripts.join('\n')}`
-
-    return new Response(html, {
-      headers: { 'content-type': 'text/html; charset=utf-8' },
-    })
-  }
-}
-
-// ── main export ────────────────────────────────────────────────────────────
-
-export async function tsx(options: TsxOptions): Promise<Router> {
-  const pagesDir = resolve(options.dir)
-  const outDir = join(pagesDir, '..', '.weifuwu', 'ssr')
-  const clientDir = join(pagesDir, '..', '.weifuwu', 'client')
-
-  // 1. Scan
-  const pages = scanPages(pagesDir)
-  if (pages.length === 0) return new Router()
-
-  // 2. Collect all files to compile
-  const allFiles = new Set<string>()
-  const loadMap = new Map<string, string>()
-  const layoutMap = new Map<string, string[]>()
-
-  for (const p of pages) {
-    allFiles.add(p.entryPath)
-    if (p.loadPath) {
-      allFiles.add(p.loadPath)
-      loadMap.set(p.entryPath, p.loadPath)
-    }
-    for (const lp of p.layouts) allFiles.add(lp)
-    layoutMap.set(p.entryPath, [...p.layouts])
-
-    if (p.routePath) allFiles.add(p.routePath)
-  }
-
-  // 3. Compile for SSR
-  mkdirSync(outDir, { recursive: true })
-  await compileAll([...allFiles], outDir, 'node')
-
-  // 4. Import and register routes
-  const router = new Router()
-
-  for (const p of pages) {
-    const url = compiledUrl(p.entryPath, outDir)
-    const mod = await import(url)
-    const Component = mod.default
-
-    let loadFn: any
-    if (p.loadPath) {
-      const loadUrl = compiledUrl(p.loadPath, outDir)
-      const modLoad = await import(loadUrl)
-      loadFn = modLoad.default
-    }
-
-    const layoutComponents: any[] = []
-    for (const lp of p.layouts) {
-      const lUrl = compiledUrl(lp, outDir)
-      const modL = await import(lUrl)
-      layoutComponents.push(modL.default)
-    }
-
-    const handler = makeSsrHandler(
-      Component, loadFn, layoutComponents,
-      p.entryPath, p.layouts, pagesDir, router,
-    )
-    router.get(p.route, handler)
-
-    // route.ts — skip GET (handled by page.tsx SSR)
-    if (p.routePath) {
-      const rUrl = compiledUrl(p.routePath, outDir)
-      const modR = await import(rUrl)
-      const methods = (['POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'] as const)
-      for (const method of methods) {
-        if (modR[method]) {
-          router.route(method, p.route, modR[method])
-        }
-      }
-    }
-  }
-
-  return router
-}

package/types.ts

@@ -1,23 +0,0 @@
-export interface Context {
-  params: Record<string, string>
-  query: Record<string, string>
-  user?: unknown
-  parsed?: Record<string, unknown>
-}
-
-export type Handler = (
-  req: Request,
-  ctx: Context,
-) => Response | Promise<Response>
-
-export type Middleware = (
-  req: Request,
-  ctx: Context,
-  next: Handler,
-) => Response | Promise<Response>
-
-export type ErrorHandler = (
-  error: Error,
-  req: Request,
-  ctx: Context,
-) => Response