duto 0.260808.0 → 0.260915.0

package/src/server/validator.ts

@@ -0,0 +1,70 @@
+import { zValidator } from '@hono/zod-validator'
+import response from './response'
+import type * as z from 'zod'
+import type {
+  Rule, Rules, RuleFn,
+  ValidationTargets,
+  zObject,
+  MiddlewareHandler,
+} from './types'
+
+export default class $Validator {
+  private static cache = new Map<string, RuleFn>()
+
+  private static createRule<T extends keyof ValidationTargets>(
+    target: T,
+    schema: zObject
+  ): Rule {
+    return {
+      target,
+      schema,
+      eTarget: 'fieldErrors'
+    }
+  }
+
+  private static fn<T extends keyof ValidationTargets>(target: T) {
+    if (this.cache.has(target))
+      return this.cache.get(target)
+
+    const fn = (schema: zObject) => this.createRule(target, schema)
+    this.cache.set(target, fn)
+    return fn
+  }
+
+  static readonly json = $Validator.fn('json')!
+  static readonly form = $Validator.fn('form')!
+  static readonly query = $Validator.fn('query')!
+  static readonly param = $Validator.fn('param')!
+  static readonly header = $Validator.fn('header')!
+  static readonly cookie = $Validator.fn('cookie')!
+
+  static #parser = (rule: Rule) => zValidator(rule.target, rule.schema, (result, c) => {
+    if (!result.success) // @ts-ignore
+      return response.badRequest(formatZodErrors(result.error.issues || []))
+  })
+
+  static setParser(parser: (rule: Rule) => MiddlewareHandler) {
+    this.#parser = parser
+  }
+
+  static parse(rules: Rules): Function[] {
+    return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore
+      .flatMap(this.#parser)
+  }
+}
+
+function formatZodErrors(issues: z.ZodIssue[]): Record<string, string[]> {
+  const result: Record<string, string[]> = {}
+
+  for (const issue of issues) {
+    const path = issue.path.join('.')
+    const key = path || 'root'
+
+    if (!result[key])
+      result[key] = []
+
+    result[key].push(issue.message)
+  }
+
+  return result
+}

package/src/utils.ts

@@ -0,0 +1,15 @@
+import { getEnv } from 't0n'
+import { dirname, join } from 'pathe'
+
+export const _duto = dirname(new URL(import.meta.url).pathname)
+export const _pages = join(_duto, 'pages')
+export const _server = join(_duto, 'server')
+export const _root = getEnv('npm_config_local_prefix') || getEnv('PWD') || join(_duto, '../../')
+
+const UNITS = ['B', 'kB', 'MB', 'GB']
+export function filesize(bytes: number, decimals = 2) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return '0 B'
+
+  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), UNITS.length - 1)
+  return `${parseFloat((bytes / 1024 ** i).toFixed(decimals))} ${UNITS[i]}`
+}

package/src/cli/commands/dev-old.ts

@@ -1,213 +0,0 @@
-import { defineCommand } from 'citty'
-import { build, preview } from 'vite'
-import { withPort } from 't0n/port'
-import { error, event, log, rn, wait } from 't0n/log'
-import { getConfig } from '~/utils'
-import { _root } from '@/utils'
-import { watch } from 't0n/cli'
-import { spawn, type ChildProcess } from 'node:child_process'
-
-export const args = {
-  port: {
-    alias: 'p',
-    description: 'Port to listen on',
-    type: 'number',
-    default: 3000,
-  },
-  host: {
-    description: 'Host to forward requests to, defaults to the zone of project',
-    type: 'string',
-    default: 'localhost',
-  },
-}
-
-export default defineCommand({
-  meta: {
-		name: 'dev',
-		description: '🧪  Start dev server\n',
-	}, // @ts-ignore
-	args,
-  async run({ args }) {
-    const config = await getConfig()
-		const desiredPort = args.port ? Number(args.port) : (config?.preview?.port ? Number(config.preview.port) : 3000)
-    const host = args.host ? String(args.host) : (config?.preview?.host ? config.preview.host : 'localhost')
-
-    // const _build = async () => {
-    //   return await build(await getConfig())
-    // }
-
-    // let buildProcess: ChildProcess | null = null
-    // const _build = async () => {
-    //   if (buildProcess) await killProcess(buildProcess)
-
-    //   return new Promise<void>((resolve, reject) => {
-    //     let timeoutId: NodeJS.Timeout | null = null
-
-    //     buildProcess = spawn('duto', ['build'], {
-    //       // stdio: 'ignore',
-    //       stdio: ['inherit', 'ignore', 'inherit', 'ipc'],
-    //       shell: process.platform === 'win32'
-    //     })
-
-    //     buildProcess.on('close', (code) => {
-    //       if (timeoutId) clearTimeout(timeoutId)
-    //       buildProcess = null
-
-    //       if (code === 0) {
-    //         resolve()
-    //       } else {
-    //         reject(new Error(`Build failed with code ${code}`))
-    //       }
-    //     })
-
-    //     buildProcess.on('error', (error) => {
-    //       if (timeoutId) clearTimeout(timeoutId)
-    //       buildProcess = null
-    //       reject(error)
-    //     })
-    //   })
-    // }
-
-		// const killProcess = async (app: ChildProcess | null) => {
-		// 	if (!app) return null
-		// 	// event('Stopping..')
-		// 	try {
-		// 		if (!app?.killed) {
-		// 			app.kill('SIGTERM')
-		// 			await wait(1000)
-
-		// 			if (!app?.killed) { // force kill
-		// 				app.kill('SIGKILL')
-		// 				await wait(1000)
-		// 			}
-		// 		}
-
-		// 		return null
-		// 	} catch (e) {
-		// 		error('Error stopping:', e)
-		// 	}
-
-		// 	return null
-    // }
-
-    let buildProcess: Bun.Subprocess | null = null
-
-    const _build = async () => {
-      if (buildProcess) await killProcess(buildProcess)
-      buildProcess = Bun.spawn(['duto', 'build'], {stdin: 'inherit', stdout: 'ignore', stderr: 'inherit'})
-
-      try {
-        const code = await buildProcess.exited
-
-        if (code !== 0)
-          throw new Error(`Build failed with code ${code}`)
-      } finally {
-        buildProcess = null
-      }
-    }
-
-    const killProcess = async (proc: Bun.Subprocess | null) => {
-      if (!proc || proc.exitCode !== null) return
-
-      try {
-        proc.kill('SIGTERM')
-
-        const exited = await Promise.race([
-          proc.exited.then(() => true),
-          new Promise(r => setTimeout(r, 1000)).then(() => false),
-        ])
-
-        if (!exited && proc.exitCode === null) {
-          proc.kill('SIGKILL')
-          await proc.exited
-        }
-      } catch (e) {
-        error('Error stopping:', e)
-      }
-    }
-
-    withPort(desiredPort, async (port) => {
-      const ignore = [
-        /(^|[\/\\])\.(duto|git|cache|vscode|idea|next|nuxt|nyc_output)([\/\\]|$)/,
-        /(^|[\/\\])(node_modules|tmp|dist|build|out|coverage)([\/\\]|$)/,
-
-        /\.(DS_Store|localized|tmp|temp|log|pid|swp|swo)$/,
-        /(Thumbs\.db|desktop\.ini)$/,
-        /~$/,
-
-        /(^|[\/\\])\.(Spotlight-V100|Trashes)([\/\\]|$)/,
-        /(^|[\/\\])__MACOSX([\/\\]|$)/,
-      ]
-
-      try {
-        await _build()
-
-        const clients = new Set<ReadableStreamDefaultController<string>>()
-        const reload = () => {
-          for (const client of clients)
-            client.enqueue('data: reload\n\n')
-        }
-        Bun.serve({
-          port: 1322,
-
-          fetch(req) {
-            const headers = {
-             'Access-Control-Allow-Origin': '*',
-             'Access-Control-Allow-Methods': 'GET',
-             'Access-Control-Allow-Headers': '*',
-            }
-
-            if (req.method === 'OPTIONS')
-              return new Response(null, { status: 204, headers })
-
-            const { pathname } = new URL(req.url)
-
-            if (pathname !== '/events')
-              return new Response(null, { status: 404, headers })
-
-            const stream = new ReadableStream<string>({
-              start(controller) {
-                clients.add(controller)
-
-                req.signal.addEventListener('abort', () => {
-                  clients.delete(controller)
-                  controller.close()
-                })
-              },
-            })
-
-            return new Response(stream, {
-              headers: {
-                ...headers,
-               'Content-Type': 'text/event-stream',
-               'Cache-Control': 'no-cache',
-               'Connection': 'keep-alive',
-              },
-            })
-          },
-        })
-
-        await preview({ ...config, preview: { port, host } })
-
-        log(`Running on http://${host}:${port}`)
-
-				watch(async () => {
-          await _build()
-          reload()
-				}, '.', _root, (path: string) => {
-          for (const pattern of ignore)
-            if (pattern.test(path)) return true
-
-          return false
-        })
-
-      } catch (e: any) {
-        error(e)
-        process.exit(0)
-      } finally {
-        rn()
-      }
-    })
-
-	},
-})

package/src/cli/index.ts

@@ -1,28 +0,0 @@
-#!/usr/bin/env bun
-
-if (!process?.isBun || typeof Bun === 'undefined') {
-  console.error('Error: "Bun" is not available. Please install:')
-  console.log('  curl -fsSL https://bun.sh/install | bash')
-  process.exit(0)
-}
-
-global.__st = performance.now()
-
-import { join } from 'pathe'
-import { cli } from 't0n/cli'
-import { version } from '!/package.json'
-
-if (typeof document === 'undefined' && import.meta.main) {
-  const cmd = (c: string) => join(import.meta.dirname, 'commands', c)
-
-  cli({
-    name: 'duto',
-    description: 'Duto CLI',
-    version,
-    commands: {
-      dev: cmd('dev'),
-      build: cmd('build'),
-      preview: cmd('preview'),
-    }
-  })
-}

package/src/compiler/utils.ts

@@ -1,5 +0,0 @@
-import { Envir } from 't0n'
-import { dirname, join } from 'pathe'
-
-export const _duto = join(dirname(new URL(import.meta.url).pathname), '..')
-export const _root = Envir.get('npm_config_local_prefix') || Envir.get('PWD') || join(_duto, '../../../')