duto 0.260906.0 → 0.261001.0

package/src/server/auth/token.ts

@@ -1,5 +1,5 @@
-import { Envir, parseUA } from 't0n'
-import { sha256, toString, type Config } from 'cripta'
+import { bytesToHex, getEnv, parseUA } from 't0n'
+import { sha256, type Config } from 'cripta'
 import { config, create, parse } from 'cripta/token'
 import type { IRequest } from '$/types'
 
@@ -76,12 +76,12 @@ export class Token {
     if (this.#cripta)
       return this.#cripta
 
-    return this.#cripta = await config({ key: Envir.get<string>('KEY') })
+    return this.#cripta = await config({ key: getEnv('KEY') })
   }
 
   static async parse(req: IRequest, token: string) {
     const host = this.host(req)
-    const serveHost = Envir.get('FLOW_SERVER', host) as string
+    const serveHost = getEnv('FLOW_SERVER', host) as string
 
     return parse(await this.cripta(), token, {
       iss: serveHost,
@@ -130,7 +130,7 @@ export class Token {
   static async fingerprint(req: IRequest) {
     const ua = parseUA(req.header('user-agent'))
 
-    const id = toString(await sha256(
+    const id = bytesToHex(await sha256(
       // (req.header('accept-language') || '')
       this.ip(req)
       + ua.browser.name + ua.browser.version.split('.')[0]

package/src/server/cli/commands/build.ts

@@ -1,4 +1,4 @@
-import { Envir } from 't0n'
+import { getEnv } from 't0n'
 import { command } from 't0n/cli'
 import { gray } from 't0n/color'
 import { wait, error, rn } from 't0n/log'
@@ -23,7 +23,7 @@ export default command({
 		},
 	},
 	async run({ args }) {
-    const platform = normalizePlatform(args.p || args.platform || Envir.get('duto.platform') || args._[0] || 'node')
+    const platform = normalizePlatform(args.p || args.platform || getEnv('duto.platform') || args._[0] || 'node')
 		if (!platform)
 			return platformError()
 

package/src/server/cli/commands/deploy.ts

@@ -1,5 +1,4 @@
 import { spawn } from 'node:child_process'
-import { Envir } from 't0n'
 import { command } from 't0n/cli'
 import { error } from 't0n/log'
 import { getRuntime } from 't0n/cli'
@@ -28,7 +27,7 @@ export default command({
 		},
 	},
 	async run({ args }) { // @ts-ignore
-		const platform = normalizePlatform(args.p || args.platform || args._[0] || Envir.get('duto.platform'))
+		const platform = normalizePlatform(args.p || args.platform || args._[0] || getEnv('duto.platform'))
 		if (!platform)
 			return platformError()
 

package/src/server/cli/commands/dev.ts

@@ -16,7 +16,7 @@ import {
 } from '../utils'
 import { _root } from '@/utils'
 import { withPort } from 't0n/port'
-import { Envir } from 't0n'
+import { getEnv } from 't0n'
 import { $dev, setEnv } from '$/utils/environment'
 
 export default command({
@@ -50,13 +50,15 @@ export default command({
 	},
   async run({ args }) {
     setEnv($dev)
-    const duto = Envir.get('duto', {})
+    const duto = getEnv('duto', {})
 		const platform = normalizePlatform(args.p || args.platform || duto.platform || args._[0] || 'node')
 		if (!platform)
 			return platformError()
 
-		const desiredPort = args.port ? Number(args.port) : duto?.dev?.port || 3000
-		const host = args.host ? String(args.host) : duto?.dev?.host || 'localhost'
+		const desiredPort = Number(args.port || duto?.dev?.port || 3000)
+		const host = String(args.host || duto?.dev?.host || 'localhost')
+		// const desiredPort = args.port ? Number(args.port) : duto?.dev?.port || 3000
+		// const host = args.host ? String(args.host) : duto?.dev?.host || 'localhost'
 
 		let isBuilding = false
 		const startApp = async (start: Function, stop: Function|undefined = undefined, building: boolean = true) => {

package/src/server/cli/commands/routes.ts

@@ -1,6 +1,5 @@
 import { command } from 't0n/cli'
 import { rn } from 't0n/log'
-import { _duto } from '@/utils'
 import { highlightedURI, highlightedMethod } from '../utils'
 import { getRoutes } from '$/routes'
 

package/src/server/cli/utils.ts

@@ -4,7 +4,6 @@ import { mkdirSync, existsSync, statSync, readdirSync, rmSync, unlinkSync, copyF
 import { stat } from 'node:fs/promises'
 import { basename, dirname, join } from 'pathe'
 import { createHash, createHmac } from 'node:crypto'
-import { filesize } from 'filesize'
 
 import { findWranglerConfig, parseWranglerConfig, WRANGLER_CONFIG_FILES } from 'localflare-core'
 import type { WranglerConfig, LocalflareManifest } from 'localflare-core'
@@ -13,7 +12,7 @@ import { gray, bold, italic, purple, yellow, red } from 't0n/color'
 import { substep, event, error, warn } from 't0n/log'
 
 import { cacheRoutes } from '$/routes'
-import { _duto, _root } from '@/utils'
+import { _root, _server, filesize } from '@/utils'
 
 import type { Platform } from './types'
 
@@ -137,17 +136,12 @@ export const build = async ({
   if (!silent) event('Routes cached')
 
   const result = await Bun.build({
-    entrypoints: [join(_duto, 'server', 'adapter', `${platform}.ts`)],
+    entrypoints: [join(_server, 'adapter', `${platform}.ts`)],
     outdir,
     format: 'esm',
     target: 'bun',
     conditions: isWorkerd ? ['worker', 'browser'] : [],
     minify: !!minify,
-    // minify: {
-    //   whitespace: true,
-    //   syntax: true,
-    //   identifiers: true,
-    // },
 
     treeShaking: true,
     legalComments: 'none',

package/src/server/config.ts

@@ -1,4 +1,19 @@
-import { DataBag } from 't0n'
 
-const Config = new DataBag()
-export default Config
+import { get, set } from 't0n'
+
+const obj: Record<string, unknown> = {}
+
+export function getConfig<T = unknown>(key: string, defaultValue: T): T
+export function getConfig<T = unknown>(key: string, defaultValue?: T): T | undefined
+export function getConfig<T = unknown>(key: string, defaultValue?: T) {
+  return get<T>(obj, key, defaultValue)
+}
+export const setConfig = (key: string, val: unknown) => set(obj, key, val)
+export function addConfig<T = unknown>(data: Record<string, T>) {
+  Object.assign(obj, data)
+}
+// export const getConfig = <T = unknown>(key: string, defaultValue?: T) => get<T>(obj, key, defaultValue)
+// import { DataBag } from 't0n'
+
+// const Config = new DataBag()
+// export default Config

package/src/server/entry.ts

@@ -1,4 +1,4 @@
-import Config from '$/config'
+import { getConfig } from '$/config'
 import { registerOpenAPI } from '$/open-api/register'
 import { Ability } from '$/auth'
 import $ from '$/app'
@@ -10,10 +10,10 @@ import { routes, middlewares } from '.duto/imports.mjs'
 
 // @ts-ignore
 Ability.fromRoutes(routes)
-Ability.roles = Config.get('roles', {})
+Ability.roles = getConfig('roles', {})
 
 // @ts-ignore
 const app = $({ routes, middlewares })
-registerOpenAPI(app, Config.get('duto.docs', {}))
+registerOpenAPI(app, getConfig('duto.docs', {}))
 
 export { app }

package/src/server/open-api/register.ts

@@ -1,6 +1,6 @@
 import { basicAuth } from 'hono/basic-auth'
 import response from '$/response'
-import Config from '$/config'
+import { getConfig } from '$/config'
 import type { Hono } from '$/types'
 
 export function registerOpenAPI(app: Hono, opts: any) {
@@ -24,6 +24,6 @@ export function registerOpenAPI(app: Hono, opts: any) {
     })
   }
 
-  app.get(opts.path, async () => response.html(Config.get('DUTO_OAC')))
-  app.get(opts.path +'/openapi', async () => response.raw(200, Config.get('DUTO_OAS'), 'application/json'))
+  app.get(opts.path, async () => response.html(getConfig('DUTO_OAC')))
+  app.get(opts.path +'/openapi', async () => response.raw(200, getConfig('DUTO_OAS'), 'application/json'))
 }

package/src/server/open-api/spec.ts

@@ -1,7 +1,7 @@
 import { STATUS_CODES } from 'node:http'
 import { generateSpecs, resolver } from 'hono-openapi'
 import { array, object, string } from 'zod/mini'
-import { Envir } from 't0n'
+import { getEnv } from 't0n'
 import { Scalar } from '@scalar/hono-api-reference'
 import { minify } from '@minify-html/node'
 import type { Hono } from '$/types'
@@ -14,8 +14,8 @@ export function openAPIConfig(opts: any) {
     agent = false,
     name = '',
     title = '',
-    version = Envir.get('APP_VERSION') || Envir.get('VERSION_HASH') || '1.0.0',
-    description = Envir.get('APP_DESCRIPTION', ''),
+    version = getEnv('APP_VERSION') || getEnv('VERSION_HASH') || '1.0.0',
+    description = getEnv('APP_DESCRIPTION', ''),
     auth = {},
     ...docs
   } = opts?.docs ?? {}
@@ -25,7 +25,7 @@ export function openAPIConfig(opts: any) {
     path,
     auth,
     agent: !!agent,
-    name: name || title || Envir.get('APP_NAME', 'API Docs'),
+    name: name || title || getEnv('APP_NAME', 'API Docs'),
     version,
     desc: description,
     ...docs,
@@ -91,6 +91,13 @@ export async function generateOpenAPIClient(app: Hono, opts?: any) {
       // onLoaded: () => document?.querySelectorAll('[href="https://www.scalar.com"]')?.forEach(el => el.remove()),
       // favicon: 'https://example.com/favicon.png',
       // hideDownloadButton: true,
+      defaultHttpClient: {
+        targetKey: 'shell',
+        clientKey: 'curl',
+      },
+      hiddenClients: [
+        'c', 'clojure', 'csharp', 'dart', 'fsharp', 'go', 'http', 'java', 'julia', 'kotlin', 'node', 'objc', 'ocaml', 'php', 'python', 'powershell', 'r', 'ruby', 'rust', 'swift'
+      ],
     })
   )
 

package/src/server/request.ts

@@ -1,7 +1,7 @@
 import { getCookie, getSignedCookie, setCookie, setSignedCookie, deleteCookie } from 'hono/cookie'
 import { HTTPException } from 'hono/http-exception'
 import { Authnz, Token } from './auth'
-import { Envir } from 't0n'
+import { addEnv } from 't0n'
 
 import type { Context } from 'hono'
 import { routePath, matchedRoutes } from 'hono/route'
@@ -10,21 +10,52 @@ import type { CookieOptions, CookiePrefixOptions } from 'hono/utils/cookie'
 import type { CustomHeader, RequestHeader } from 'hono/utils/headers'
 import type { BodyData, ParseBodyOptions } from 'hono/utils/body'
 
-const cookieWrapper = (c: Context) => ({
-  all: () => getCookie(c),
-  allSigned: (secret: string) => getSignedCookie(c, secret),
-  get: (name: string, prefixOptions?: CookiePrefixOptions) => prefixOptions ? getCookie(c, name, prefixOptions) : getCookie(c, name),
-  getSigned: (secret: string, name: string, prefixOptions?: CookiePrefixOptions) => prefixOptions ? getSignedCookie(c, secret, name, prefixOptions) : getSignedCookie(c, secret, name),
-  set: (name: string, value: string, opt?: CookieOptions) => setCookie(c, name, value, opt),
-  setSigned: (name: string, value: string, secret: string, opt?: CookieOptions) => setSignedCookie(c, name, value, secret, opt),
-  delete: (name: string, opt?: CookieOptions) => deleteCookie(c, name, opt)
-})
+// function cookieWrapper(c: Context) {
+//   return {
+//     all: () => getCookie(c),
+//     allSigned: (secret: string) => getSignedCookie(c, secret),
+//     get: (name: string, prefixOptions?: CookiePrefixOptions) => prefixOptions ? getCookie(c, name, prefixOptions) : getCookie(c, name),
+//     getSigned: (secret: string, name: string, prefixOptions?: CookiePrefixOptions) => prefixOptions ? getSignedCookie(c, secret, name, prefixOptions) : getSignedCookie(c, secret, name),
+//     set: (name: string, value: string, opt?: CookieOptions) => setCookie(c, name, value, opt),
+//     setSigned: (name: string, value: string, secret: string, opt?: CookieOptions) => setSignedCookie(c, name, value, secret, opt),
+//     delete: (name: string, opt?: CookieOptions) => deleteCookie(c, name, opt)
+//   }
+// }
+class $Cookie {
+  #c!: Context
+  constructor(c: Context) {
+    this.#c = c
+  }
+
+  all() {
+    return getCookie(this.#c)
+  }
+  allSigned(secret: string) {
+    return getSignedCookie(this.#c, secret)
+  }
+  get(name: string, prefixOptions?: CookiePrefixOptions) {
+    return prefixOptions ? getCookie(this.#c, name, prefixOptions) : getCookie(this.#c, name)
+  }
+  getSigned(secret: string, name: string, prefixOptions?: CookiePrefixOptions) {
+    return prefixOptions ? getSignedCookie(this.#c, secret, name, prefixOptions) : getSignedCookie(this.#c, secret, name)
+  }
+  set(name: string, value: string, opt?: CookieOptions) {
+    setCookie(this.#c, name, value, opt)
+  }
+  setSigned(name: string, value: string, secret: string, opt?: CookieOptions) {
+    setSignedCookie(this.#c, name, value, secret, opt)
+  }
+  delete(name: string, opt?: CookieOptions) {
+    deleteCookie(this.#c, name, opt)
+  }
+}
 
 export const GET_REQUEST: unique symbol = Symbol()
 
 export default class $Request {
   #c!: Context
-  #cookie: ReturnType<typeof cookieWrapper>
+  #cookie: $Cookie
+  // #cookie: ReturnType<typeof cookieWrapper>
   #u: Authnz<any> | null = null
 
   #host: string
@@ -34,7 +65,8 @@ export default class $Request {
 
   constructor(c: Context) {
     this.#c = c
-    this.#cookie = cookieWrapper(c)
+    this.#cookie = new $Cookie(c)
+    // this.#cookie = cookieWrapper(c)
 
     const url = new URL(c.req.raw.url)
     this.#host = url.protocol +'//'+ url.host
@@ -47,11 +79,11 @@ export default class $Request {
     const req = new $Request(c)
     await req.setAuth()
     c.set(GET_REQUEST as unknown as string, req)
-    if (c.env) Envir.add(c.env)
+    if (c.env) addEnv(c.env)
   }
 
   async setAuth() {
-    this.#u = Authnz.fromToken(Token.fromRequest(this))
+    this.#u = Authnz.fromToken(await Token.fromRequest(this))
   }
 
   get user() {

package/src/server/routes.ts

@@ -1,4 +1,4 @@
-import { Glob, file, write } from 'bun'
+import { file, write } from 'bun'
 
 import { copyFileSync } from 'node:fs'
 import { join, relative } from 'pathe'
@@ -12,38 +12,15 @@ import { STATUS_CODES } from 'node:http'
 import $ from './app'
 import _response from './response'
 import _validator from './validator'
-import { _root, _duto } from '@/utils'
-import { getLastCommitHash, ensureDir, nextId } from './utils'
+import { _root, _server, scan } from '@/utils'
+import { getLastCommitHash, ensureDir, nextId, verbAlias } from './utils'
 import { generateOpenAPI, generateOpenAPIClient, openAPIConfig } from './open-api/spec'
-import { verbAlias } from './http'
 import { highlightedMethod, highlightedURI } from './cli/utils'
 
 import type { Routes, Rule, StandardSchemaV1 } from './types'
 import { autorizedPath } from './middlewares/auth'
 import { isDev } from './utils/environment'
 
-export async function* scan(
-  dir: string | string[],
-  ext: string | string[],
-  ignore: string[] = ['*.d.*'],
-  cwd?: string,
-): AsyncGenerator<[string, string, any]> {
-  if (typeof dir !== 'string')
-    dir = ext.length === 1 ? dir[0] : `{${dir.join(',')}}`
-
-  if (typeof ext !== 'string')
-    ext = ext.length === 1 ? ext[0] : `{${ext.join(',')}}`
-
-  cwd ??= _root
-  for await (const file of new Glob(dir +'/**/*.'+ ext).scan({
-    cwd,
-    absolute: true,
-    onlyFiles: true, // @ts-ignore
-    ignore,
-  })) {
-    yield [file, file.split(cwd as string)[1], await IMPORT(file)]
-  }
-}
 
 const importName = (name: string | undefined, dirs: string[]) => (name || nextId()).replace(/\.ts$/, '')
 
@@ -406,12 +383,12 @@ export async function cacheRoutes() {
   const configs = await getConfigs()
   const middlewares = await getMiddlewares()
   if (isDev()) {
-    const _file = join(_duto, 'server', 'middlewares', 'logger.ts')
+    const _file = join(_server, 'middlewares', 'logger.ts')
     const _mod = await IMPORT(_file) // @ts-ignore
-    middlewares.unshift({
+    middlewares.unshift({ // @ts-ignore
       path: _mod?.path || '*',
       name: 'dev_logger',
-      file: _file,
+      file: _file, // @ts-ignore
       handle: _mod.handle,
     })
   }
@@ -447,8 +424,8 @@ export async function cacheRoutes() {
   const _dutoDir = await dependencyPath('duto')
 
   await write(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
-${env?.length ? `import { Envir } from '${await dependencyPath('t0n')}/src/envir'\nEnvir.add(${JSJSON(Object.fromEntries(env))})` : ''}
-${Object.entries(configs)?.length ? `import Config from '${_dutoDir}/src/server/config'\nConfig.add(${JSJSON(configs)})` : ''}
+${env?.length ? `import { addEnv } from '${await dependencyPath('t0n')}/src/env'\naddEnv(${JSJSON(Object.fromEntries(env))})` : ''}
+${Object.entries(configs)?.length ? `import { addConfig } from '${_dutoDir}/src/server/config'\naddConfig(${JSJSON(configs)})` : ''}
 
 ${middlewares.map(r => `import { handle as MW${r.name} } from '../${normalizeImportPath(r.file)}'`).join('\n')}
 export const middlewares = [[${middlewares.map(mw => [

package/src/server/utils.ts

@@ -44,3 +44,28 @@ export const nextId = () => {
 
   return id = 'a' + chars.join('')
 }
+
+export const verbAlias = {
+  get: 0,
+  post: 1,
+  put: 2,
+  patch: 3,
+  delete: 4,
+  head: 5,
+  options: 6,
+  connect: 7,
+  trace: 8,
+} as Record<string, number>
+
+export const getVerb = [
+  'get',
+  'post',
+  'put',
+  'patch',
+  'delete',
+  'head',
+  'options',
+  'connect',
+  'trace',
+]
+

package/src/utils.ts

@@ -1,5 +1,46 @@
-import { Envir } from 't0n'
+import { IMPORT } from 't0n'
 import { dirname, join } from 'pathe'
 
 export const _duto = dirname(new URL(import.meta.url).pathname)
-export const _root = Envir.get('npm_config_local_prefix') || Envir.get('PWD') || join(_duto, '../../')
+export const _pages = join(_duto, 'pages')
+export const _server = join(_duto, 'server') //@ts-ignore
+export const _root = process.env?.npm_config_local_prefix || process.env?.PWD || process.stdin?.path || process.cwd() // || join(_duto, '../../')s
+
+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]}`
+}
+
+export const formatTime = (ms: number) => {
+  if (ms < 0.001) return `${(ms * 1_000_000).toFixed(2)}ns`
+  if (ms < 1) return `${(ms * 1000).toFixed(2)}µs`
+  if (ms < 1000) return `${ms.toFixed(2)}ms`
+  if (ms < 60000) return `${(ms / 1000).toFixed(2)}s`
+  return `${Math.floor(ms / 60000)}m ${((ms % 60000) / 1000).toFixed(1)}s`
+}
+
+export async function* scan(
+  dir: string | string[],
+  ext: string | string[],
+  ignore: string[] = ['*.d.*'],
+  cwd?: string,
+): AsyncGenerator<[string, string, any]> {
+  if (typeof dir !== 'string')
+    dir = ext.length === 1 ? dir[0] : `{${dir.join(',')}}`
+
+  if (typeof ext !== 'string')
+    ext = ext.length === 1 ? ext[0] : `{${ext.join(',')}}`
+
+  cwd ??= _root
+  for await (const file of new Bun.Glob(dir +'/**/*.'+ ext).scan({
+    cwd,
+    absolute: true,
+    onlyFiles: true, // @ts-ignore
+    ignore,
+  })) {
+    yield [file, file.split(cwd as string)[1], await IMPORT(file)]
+  }
+}