weifuwu 0.2.1 → 0.2.3

package/upload.ts

@@ -1,101 +0,0 @@
-import { writeFile, mkdir } from 'node:fs/promises'
-import { randomUUID } from 'node:crypto'
-import { join } from 'node:path'
-import type { Middleware } from './types.ts'
-
-export interface UploadedFile {
-  name: string
-  type: string
-  size: number
-  path?: string
-  buffer?: Buffer
-}
-
-export interface UploadOptions {
-  dir?: string
-  maxFileSize?: number
-  allowedTypes?: string[]
-}
-
-export function upload(options?: UploadOptions): Middleware {
-  const saveDir = options?.dir
-
-  return async (req, ctx, next) => {
-    const ct = req.headers.get('content-type') ?? ''
-    if (!ct.includes('multipart/form-data')) {
-      return next(req, ctx)
-    }
-
-    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i)
-    if (!match) {
-      return Response.json({ error: 'Missing boundary' }, { status: 400 })
-    }
-
-    const boundary = match[1] ?? match[2]!
-    const body = await req.text()
-    const rawParts = body.split(`--${boundary}`).filter((p) => p && !p.startsWith('--') && !p.startsWith('\r\n--'))
-
-    const files: Record<string, UploadedFile | UploadedFile[]> = {}
-    const fields: Record<string, string> = {}
-
-    for (const raw of rawParts) {
-      const trimmed = raw.replace(/^\r?\n/, '')
-      const lines = trimmed.split(/\r?\n/)
-      let i = 0
-      const headers: Record<string, string> = {}
-      while (i < lines.length && lines[i]!.length > 0) {
-        const sep = lines[i]!.indexOf(': ')
-        if (sep !== -1) headers[lines[i]!.slice(0, sep).toLowerCase()] = lines[i]!.slice(sep + 2)
-        i++
-      }
-      i++
-      const bodyValue = lines.slice(i).join('\r\n')
-
-      const disposition = headers['content-disposition'] ?? ''
-      const nameMatch = disposition.match(/name="([^"]*)"/)
-      if (!nameMatch) continue
-      const name = nameMatch[1]!
-      const filenameMatch = disposition.match(/filename="([^"]*)"/)
-      const filename = filenameMatch?.[1]
-
-      if (filename) {
-        const buf = Buffer.from(bodyValue.replace(/\r?\n$/, ''), 'binary')
-        if (options?.allowedTypes) {
-          const mime = headers['content-type'] ?? 'application/octet-stream'
-          if (!options.allowedTypes.includes(mime)) {
-            return Response.json({ error: `File type not allowed: ${mime}` }, { status: 415 })
-          }
-        }
-        if (options?.maxFileSize && buf.byteLength > options.maxFileSize) {
-          return Response.json({ error: `File too large: ${filename}` }, { status: 413 })
-        }
-
-        const uf: UploadedFile = {
-          name: filename,
-          type: headers['content-type'] ?? 'application/octet-stream',
-          size: buf.byteLength,
-          buffer: saveDir ? undefined : buf,
-        }
-
-        if (saveDir) {
-          const filePath = join(saveDir, `${randomUUID()}-${filename}`)
-          await mkdir(saveDir, { recursive: true })
-          await writeFile(filePath, buf)
-          uf.path = filePath
-        }
-
-        if (files[name]) {
-          const existing = files[name]
-          files[name] = Array.isArray(existing) ? [...existing, uf] : [existing, uf]
-        } else {
-          files[name] = uf
-        }
-      } else {
-        fields[name] = bodyValue.replace(/\r?\n$/, '')
-      }
-    }
-
-    ctx.parsed = { ...ctx.parsed, files, fields }
-    return next(req, ctx)
-  }
-}

package/validate.ts

@@ -1,88 +0,0 @@
-import type { ZodSchema } from 'zod'
-import type { Middleware } from './types.ts'
-
-export interface ValidationSchemas {
-  body?: ZodSchema
-  query?: ZodSchema
-  params?: ZodSchema
-  headers?: ZodSchema
-}
-
-export function validate(schemas: ValidationSchemas): Middleware {
-  return async (req, ctx, next) => {
-    const parsed: Record<string, unknown> = {}
-    const issues: { path: string[]; message: string }[] = []
-
-    if (schemas.params) {
-      const result = schemas.params.safeParse(ctx.params)
-      if (result.success) {
-        parsed.params = result.data
-      } else {
-        issues.push(...result.error.issues.map((i) => ({
-          path: ['params', ...i.path.map(String)],
-          message: i.message,
-        })))
-      }
-    }
-
-    if (schemas.query) {
-      const result = schemas.query.safeParse(ctx.query)
-      if (result.success) {
-        parsed.query = result.data
-      } else {
-        issues.push(...result.error.issues.map((i) => ({
-          path: ['query', ...i.path.map(String)],
-          message: i.message,
-        })))
-      }
-    }
-
-    if (schemas.headers) {
-      const rawHeaders: Record<string, string> = {}
-      req.headers.forEach((v, k) => { rawHeaders[k] = v })
-      const result = schemas.headers.safeParse(rawHeaders)
-      if (result.success) {
-        parsed.headers = result.data
-      } else {
-        issues.push(...result.error.issues.map((i) => ({
-          path: ['headers', ...i.path.map(String)],
-          message: i.message,
-        })))
-      }
-    }
-
-    if (schemas.body) {
-      if (req.body === null) {
-        issues.push({ path: ['body'], message: 'Request body is required' })
-      } else {
-        const bodyText = await req.text()
-        if (!bodyText && req.method !== 'GET' && req.method !== 'HEAD') {
-          issues.push({ path: ['body'], message: 'Request body is required' })
-        } else {
-          let bodyValue: unknown
-          try {
-            bodyValue = JSON.parse(bodyText)
-          } catch {
-            bodyValue = bodyText
-          }
-          const result = schemas.body.safeParse(bodyValue)
-          if (result.success) {
-            parsed.body = result.data
-          } else {
-            issues.push(...result.error.issues.map((i) => ({
-              path: ['body', ...i.path.map(String)],
-              message: i.message,
-            })))
-          }
-        }
-      }
-    }
-
-    if (issues.length > 0) {
-      return Response.json({ error: 'Validation failed', issues }, { status: 400 })
-    }
-
-    ctx.parsed = parsed
-    return next(req, ctx)
-  }
-}