duto 0.260808.0 → 0.260906.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025-present, ZUNQ.com
+Copyright (c) 2025-present, HUB.BI
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -23,4 +23,4 @@ This framework is fully geared towards the serverless world, specifically for st
 
 ## License
 
-This package is licensed under the [MIT license](https://github.com/attla/duto/blob/main/LICENSE) © [Zunq](https://zunq.com)
+This package is licensed under the [MIT license](https://github.com/attla/duto/blob/main/LICENSE) © [HUB](https://hub.bi)

package/package.json

@@ -1,50 +1,84 @@
 {
   "name": "duto",
-  "description": "Static framework for web artisans",
-  "version": "0.260808.0",
+  "description": "All-in-one serverless framework for web artisans",
+  "version": "0.260906.0",
   "type": "module",
   "main": "./src/index.ts",
+  "types": "./src/index.d.ts",
+  "bin": "./src/cli.ts",
   "files": ["src"],
-  "bin": "./src/cli/index.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./auth": "./src/server/auth/index.ts",
+    "./db": "./src/db/index.ts",
+    "./database": "./src/db/index.ts",
+    "./d1": "./src/server/db/d1.ts",
+    "./d1/types": "./src/server/db/d1.d.ts",
+    "./dynamodb": "./src/server/db/dynamodb.ts",
+    "./dynamodb/types": "./src/server/db/dynamodb.d.ts",
+    "./enum": "./src/enum.ts",
+    "./http": "./src/server/http.ts",
+    "./middleware": "./src/middleware.ts",
+    "./types": "./src/server/types.ts",
+    "./types/global": "./global.d.ts",
+    "./env": "./src/server/utils/environment.ts",
+    "./length": "./src/server/utils/length.ts"
   },
   "dependencies": {
+    "@hono/node-server": "^1.19.11",
+    "@hono/standard-validator": "^0.2.2",
+    "@hono/zod-validator": "^0.7.6",
+    "@scalar/hono-api-reference": "^0.12.0",
+    "@minify-html/node": "^0.18.1",
     "@preact/signals": "^2.9.2",
     "@swc/core": "^1.15.21",
     "chokidar": "^3.5.2",
     "citty": "^0.2.2",
     "consola": "^3.4.2",
+    "cripta": "0.x",
+    "dotenv": "^16.5.0",
+    "esbuild": "^0.25.2",
     "filesize": "^11.0",
+    "forj": "0.x",
+    "hono": "^4.13.7",
+    "hono-openapi": "^1.3.0",
+    "localflare-api": "^0.5.0",
+    "localflare-core": "^0.5.0",
+    "miniflare": "^4.20260730.0",
     "pathe": "^2.0",
     "preact": "^10.29.7",
     "preact-render-to-string": "^6.6.6",
+    "quansync": "^0.2.11",
     "t0n": "0.x",
-    "vite": "^8.0.0",
-    "wouter-preact": "^3.10.0"
+    "wouter-preact": "^3.10.0",
+    "wrangler": "^4.128.0",
+    "zod": "^4.3.6",
+    "zod-openapi": "^5.4.6"
   },
   "devDependencies": {
-    "@minify-html/node": "^0.18.1",
-    "@preact/preset-vite": "^2.10.5",
-    "@tailwindcss/vite": "^4.3.1",
-    "@types/node": "^25.9.0",
-    "bun-types": "^1.3.14",
+    "@cloudflare/workers-types": "^4.20260113.0",
+    "@types/node": "^26.4.1",
+    "bun-types": "^1.4.0",
     "typescript": "^5.9.3"
   },
-  "packageManager": "bun@1.3.14",
-  "engines": {
-    "node": ">=18.0.0"
+  "resolutions": {
+    "@smithy/types": "^4.3.0",
+    "zod": "^4.3.6"
   },
+  "sideEffects": false,
+  "packageManager": "bun@1.4.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
-  "author": "Zunq <open-source@zunq.com>",
+  "author": "HUB <foss@hub.bi>",
   "license": "MIT",
-  "homepage": "https://zunq.dev",
+  "homepage": "https://hub.bi/docs/duto",
   "repository": "git://github.com/attla/duto",
   "bugs": "https://github.com/attla/duto/issues",
   "keywords": [
     "SSG",
+    "app",
+    "http",
     "application",
     "framework",
     "router",
@@ -52,6 +86,7 @@
     "typescript",
     "cloudflare",
     "workers",
+    "workerd",
     "vercel",
     "bun"
   ]

package/src/cli.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+
+function exit(msg?: string, desc?: string) {
+  msg && console.error(msg)
+  desc && console.log(desc)
+  process.exit(0)
+}
+
+if (!import.meta.main)
+  exit('Error: Duto must be used directly as CLI command.')
+
+if (!process?.isBun || typeof Bun === 'undefined')
+  exit('Error: "Bun" is not available.', '  Try install: https://bun.sh/get')
+
+global.__st = performance.now()
+
+import { join } from 'pathe'
+import { cli } from 't0n/cli'
+import { Envir } from 't0n'
+import { version } from '!/package.json'
+import { _root, _duto } from './utils'
+
+let commands = {
+  // new:
+  // upgrade:
+}
+let pkg
+try {
+  pkg = await import(join(_root, 'package.json'))
+  if (!pkg || !pkg.duto || !pkg?.duto?.type || !['pages', 'server'].includes(pkg.duto.type))
+    exit('Error: invalid app type.')
+
+  Envir.set('duto', pkg.duto)
+  commands = (await import(join(_duto, pkg.duto.type, 'cli')))?.default
+} catch {}
+
+cli({
+  name: 'duto',
+  description: 'Duto',
+  version,
+  commands,
+})

package/src/enum.ts

@@ -0,0 +1,2 @@
+export { Enum } from 't0n'
+export type { EnumStatic, EnumValue, EnumType } from 't0n'

package/src/index.d.ts

@@ -0,0 +1,61 @@
+/// <reference types='bun-types' />
+/// <reference types='node' />
+
+// export { }
+
+import * as Duto from './'
+
+declare global {
+  // Duto
+  var __st: number
+  var __hmr: boolean
+
+  type Req = Duto.Req
+  type Res = Duto.Res
+  type $v = Duto.$v
+  type IRequest = Duto.IRequest
+  type IResponse = Duto.IResponse
+  type IValidator = Duto.IValidator
+
+  type Context = Duto.Context
+  type Next = Duto.Next
+
+  type Abilities = Duto.Abilities
+  type Roles = Duto.Roles
+
+  type EnumStatic = Duto.EnumStatic
+  type EnumValue = Duto.EnumValue
+  type EnumType = Duto.EnumType
+
+
+  // Bun:test
+  var test: typeof import('bun:test').test
+  var describe: typeof import('bun:test').describe
+  var it: typeof import('bun:test').it
+  var expect: typeof import('bun:test').expect
+  // Hooks
+  var beforeAll: typeof import('bun:test').beforeAll
+  var afterAll: typeof import('bun:test').afterAll
+  var beforeEach: typeof import('bun:test').beforeEach
+  var afterEach: typeof import('bun:test').afterEach
+  // Mocking
+  var mock: typeof import('bun:test').mock
+  var vi: typeof import('bun:test').vi
+  var jest: typeof import('bun:test').jest
+  var spyOn: typeof import('bun:test').spyOn
+  // Utils
+  var setSystemTime: typeof import('bun:test').setSystemTime
+  var setDefaultTimeout: typeof import('bun:test').setDefaultTimeout
+  // Types
+  var Test: typeof import('bun:test').Test
+  var Describe: typeof import('bun:test').Describe
+  var Expect: typeof import('bun:test').Expect
+  var Mock: typeof import('bun:test').Mock
+  var TestOptions: typeof import('bun:test').TestOptions
+  var Matchers: typeof import('bun:test').Matchers
+  // Namespace
+  namespace jest {
+    var fn: typeof import('bun:test').vi.fn
+    var mock: typeof import('bun:test').vi.mock
+  }
+}

package/src/index.ts

@@ -1,28 +1,19 @@
-export {
-  Redirect,
-  useLocation, useParams, useSearch, useSearchParams,
-  matchRoute,
-} from 'wouter-preact'
+export { default as Response } from './server/response'
+export { default as Config } from './server/config'
 
-export {
-  t, r, d,
-  getLocale, setLocale,
-  isPrefixed,
-} from './i18n/client'
+export { Enum, Envir } from 't0n'
+export type { EnumStatic, EnumValue, EnumType } from 't0n'
 
-export { local } from './client/storage'
+export type {
+  IRequest, IRequest as Req, IRequest as $req,
+  IResponse, IResponse as Res, IResponse as $res,
+  IValidator, IValidator as $v,
+  Context, Next,
+} from './server/types'
 
-export const navigate = <S = any>(
-  to: string | URL,
-  options?: { replace?: boolean; state?: S; transition?: boolean }
-) => {
-  if (window?.$duto?.sroutes?.has(to)) {
-    location.pathname = to
-    return
-  }
+// Auth
+export { Ability } from './server/auth/ability'
+export { Authnz } from './server/auth/authnz'
+export { Token } from './server/auth/token'
 
-  const n = window?.$duto?.navigate || useLocation()[1]
-  n(to, options)
-}
-
-export { Link } from './components/link'
+export type { Abilities, Roles } from './server/auth/types'

package/src/middleware.ts

@@ -0,0 +1,2 @@
+export { auth } from './server/middlewares/auth'
+// export { cors } from './server/middlewares/cors'

package/src/{compiler → pages/compiler}/vite-plugin.ts

@@ -9,7 +9,7 @@ import tailwind from '@tailwindcss/vite'
 
 import { EXT_RE } from './constants'
 import { setAsset, setChunk, setEntry } from './assets'
-import { renderPage } from './'
+import { renderPage } from '.'
 import { removeExports, resolveImport } from './ast'
 import { getMetadata } from './meta'
 

package/src/{i18n → pages/i18n}/client.ts

@@ -1,6 +1,6 @@
 import { h, type JSX } from 'preact'
 import { local } from '#/storage'
-import { navigate } from '../'
+import { navigate } from '..'
 
 const accepted = (lang: string | undefined, locales: string[] = [], fallback: string) => lang && locales.includes(lang) ? lang : fallback
 

package/src/pages/index.ts

@@ -0,0 +1,28 @@
+export {
+  Redirect,
+  useLocation, useParams, useSearch, useSearchParams,
+  matchRoute,
+} from 'wouter-preact'
+
+export {
+  t, r, d,
+  getLocale, setLocale,
+  isPrefixed,
+} from './i18n/client'
+
+export { local } from './client/storage'
+
+export const navigate = <S = any>(
+  to: string | URL,
+  options?: { replace?: boolean; state?: S; transition?: boolean }
+) => {
+  if (window?.$duto?.sroutes?.has(to)) {
+    location.pathname = to
+    return
+  }
+
+  const n = window?.$duto?.navigate || useLocation()[1]
+  n(to, options)
+}
+
+export { Link } from './components/link'

package/src/server/adapter/aws.ts

@@ -0,0 +1,4 @@
+import { handle } from 'hono/aws-lambda'
+import { app } from '$/entry'
+
+export const handler = handle(app)

package/src/server/adapter/workerd.ts

@@ -0,0 +1,4 @@
+import { app } from '$/entry'
+export default app
+
+// export { app as default } from '$/entry'

package/src/server/app.ts

@@ -0,0 +1,96 @@
+import { Hono } from 'hono'
+import { Envir } from 't0n'
+import type {
+  Env, Context, Next,
+  HTTPResponseError,
+  ServerOptions, Route
+} from './types'
+import request, { GET_REQUEST } from './request'
+import response from './response'
+import { isDev } from './utils/environment'
+import { getVerb } from './http'
+import { registerMiddleware, resolveHandle, resolveMw } from './handle'
+
+const NFHandler = () => response.notFound()
+const EHandler = async (e: Error | HTTPResponseError) => {
+  console.error(e)
+
+  switch (true) {
+    // case 'status' in e && e.status === 401:
+    case e?.status === 401:
+      return response.unauthorized()
+
+    // case 'status' in e && e.status === 400: // @ts-ignore
+    case e?.status === 400:
+      return response.badRequest(null, e?.message)
+
+    default:
+      return response.internalError(
+        // @ts-ignore
+        isDev() // TODO: remover ou migrar para um middleware / melhorar
+          ? e.stack?.split('\n').map(line =>
+              line.replace(
+                /at (.+ )?\(?([^)]+)\)?/g,
+                (match, method, path) => {
+                  if (!path) return match
+
+                  const nodeModulesIndex = path.indexOf('node_modules')
+                  if (nodeModulesIndex > -1)
+                    return `${method || ''}(node_modules${path.slice(nodeModulesIndex + 'node_modules'.length)})`
+
+                  const projectRoot = process.cwd()
+                  const relativePath = path.startsWith(projectRoot) ? path.slice(projectRoot.length + 1) : path
+                  return `${method || ''}(${relativePath})`
+                }
+              ).trim()
+            )
+          : undefined,
+        e.message || 'Internal Error'
+      )
+  }
+
+  // return json.internalError(
+  //   // @ts-ignore
+  //   isDev() ? e.stack?.split('\n    at ').map() : undefined,
+  //   e.message || 'Internal Error'
+  // )
+  // error: e.message,
+  // cause: e.cause || '???',
+  // stack: isDev (? e.stack : undefined
+}
+
+export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
+  // const root = options?.root ?? '/'
+  const app = options?.app ?? new Hono<E>()
+
+  app.use(async (c: Context, next: Next) => {
+    await request.toContext(c)
+    await next()
+  })
+
+  const middlewares = options?.middlewares || []
+  for (const mw of middlewares) { // @ts-ignore
+    registerMiddleware(mw[2], mw[1]) // @ts-ignore
+    mw[0] ? app.use(String(mw[0]), resolveMw(mw[1])) : app.use(resolveMw(mw[1]))
+  }
+
+  // @ts-ignore
+  app.onError(options?.onError || EHandler)
+  // @ts-ignore
+  app.notFound(options?.notFound || NFHandler)
+
+  if (options?.init) options.init(app)
+
+  const routes = options?.routes || [] // @ts-ignore
+  const routeRegister = options?.routeRegister ? options.routeRegister : (_: Hono, route: Route) => {
+    // @ts-ignore
+    _[getVerb[route[0]]](route[1], ...resolveHandle(route[2], route[3], route[4]))
+  }
+
+  for (const route of routes)
+    routeRegister(app, route)
+
+  return app
+}
+
+export default createApp

package/src/server/auth/ability.ts

@@ -0,0 +1,72 @@
+import { verbAlias } from '$/http'
+import type { IRequest, Routes } from '$/types'
+import type { Roles, Abilities } from './types'
+
+export class Ability {
+  static #roles: Roles = {}
+  static #abilities: Abilities = []
+  static #actions: Record<string, string> = {}
+
+  static empty() {
+    this.#roles = {}
+    this.#abilities = []
+  }
+
+  static fromRoutes(routes: Routes) {
+    if (!routes?.length) return
+
+    const actions: Record<string, string> = {}
+    const abilities = new Set()
+    for (const route of routes) {
+      const isArr = Array.isArray(route)
+      const name = isArr ? route[route.length-1] : route.name
+      if (!name || abilities.has(name)) continue
+
+      abilities.add(name)
+      actions[(isArr ? route[1] : route.path) +'$'+ verbAlias[isArr ? route[0] : route.method]] = name
+      const formatted = this.format(name)
+
+      if (formatted)
+        this.#abilities.push(formatted)
+    }
+
+    this.#actions = actions
+  }
+
+  static fromRequest(req: IRequest) {
+    const ability = this.#actions[`${req.routePath}$` + verbAlias[req.method.toLowerCase()]]
+    return ability ? this.format(ability) : ''
+  }
+
+  static fromAction(target: any): string {
+    return !target ? '' : this.format(typeof target === 'string' ? target : (target.name.length > 3 ? target.name : (target?.p || '')))
+  }
+
+  static format(path: string) {
+    return path === '/'
+      ? 'index'
+      : path.normalize('NFD')
+         .replace(/[\u0300-\u036f]/g, '')
+         .replace(/^\/*/, '')
+         .replace(/([a-z])([A-Z])/g, '$1-$2')
+         .replace(/[^a-zA-Z0-9/]|[\s\-.]/g, '_')
+         .replace(/_+/g, '_')
+         .replace(/\//g, '.')
+         .replace(/\._/g, '.')
+         .replace(/^[._-]+/, '')
+         .replace(/[._-]+$/, '')
+         .toLowerCase()
+  }
+
+  static get abilities() {
+    return this.#abilities
+  }
+
+  static get roles() {
+    return this.#roles
+  }
+
+  static set roles(roles: Roles) {
+    this.#roles = roles
+  }
+}

package/src/server/auth/authnz.ts

@@ -0,0 +1,86 @@
+import { Ability } from './ability'
+import type { Token } from 'cripta/token'
+
+export class Authnz<T extends object> {
+  #abilities: string[]
+  #roles: string[]
+  #data: T
+  #token: Token
+
+  constructor(token: Token, data: T, abilities: string[], roles: string[]) {
+    this.#abilities = abilities
+    this.#roles = roles
+    this.#token = token
+    this.#data = data
+  }
+
+  can(...abilities: string[]): boolean {
+    if (this.#abilities.includes('*')) return true
+
+    return abilities.flat().every(ability => {
+      if (this.#roles.includes(ability)) return true
+      return this.#abilities.some(rule => this.#match(rule, ability))
+    })
+  }
+  cant(...abilities: string[]): boolean {
+    return !this.can(...abilities)
+  }
+
+  hasRole(...roles: string[]): boolean {
+    return roles.flat().every(role => this.#roles.includes(role))
+  }
+
+  // has(prop: string, value: any = null): boolean {
+  //   return this.#token?.hasValue(prop, value) || false
+  // }
+  // hasValue(prop: string, value: any = null): boolean {
+  //   return this.has(prop, value)
+  // }
+
+  static fromToken<T extends object>(token: Token): Authnz<T> | null {
+    if (!token || !token?.valid) return null
+    const user = token.body
+    const roles = [...(user?.role ? [user.role] : []), ...(user?.roles ?? [])]
+
+    const combined = [...(user?.perms ?? []), ...roles.flatMap(role => {
+      const perms = Ability.roles[role]
+      if (!perms) return []
+      return perms === '*' ? ['*'] : perms
+    })]
+
+    const abilities = combined.includes('*') ? ['*'] : Array.from(new Set(combined))
+
+    return new Authnz<T>(token, user, abilities, roles)
+  }
+
+  #match(rule: string, ability: string): boolean {
+    if (rule === ability) return true
+    if (
+      this.#wildcardMatch(rule, ability, '_*')
+      || this.#wildcardMatch(rule, ability, '-*')
+      || this.#wildcardMatch(rule, ability, '.*')
+    ) return true
+
+    return false
+  }
+
+  #wildcardMatch(rule: string, ability: string, suffix: string) {
+    return rule.endsWith(suffix)
+      && (ability.startsWith(rule.slice(0, -2) + suffix[0]) || ability === rule.slice(0, -2))
+  }
+
+  get abilities() {
+    return this.#abilities
+  }
+
+  get roles() {
+    return this.#roles
+  }
+
+  get data() {
+    return this.#data
+  }
+  get user() {
+    return this.#data
+  }
+}

package/src/server/auth/index.ts

@@ -0,0 +1,5 @@
+export { Ability } from './ability'
+export { Authnz } from './authnz'
+export { Token } from './token'
+
+export * from './types'