duto 0.0.0 → 0.260906.0

package/src/server/entry.ts

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

package/src/server/handle.ts

@@ -0,0 +1,30 @@
+import res from './response'
+import $v from './validator'
+import { GET_REQUEST } from './request'
+import type { Context, Next, RuleFactory } from './types'
+
+export const _mw: Record<string, Function> = {}
+export const getMiddlewares = () => _mw
+export function getMiddleware(id: string | Function): Function {
+  if (typeof id === 'function') return id
+  const mw = _mw[id] || null
+  if (!mw) throw new Error(`Handler ${id} not registered`)
+  return mw
+}
+export function registerMiddleware(id: string, handler: Function) {
+  _mw[id] = handler
+}
+
+export const resolveMw = (mw: Function) => {
+  return mw.length < 3 ? mw : async (c: Context, next: Next) => await getMiddleware(mw)(c.get(GET_REQUEST as unknown as string), res, next, c)
+}
+
+export const resolveHandle = (mw: (string | Function)[], handle: Function, ruleFn?: RuleFactory) => {
+  const h = async (c: Context) => await handle(c.get(GET_REQUEST as unknown as string), res)
+  mw = mw?.length ? mw.map(getMiddleware) : []
+
+  const rules = typeof ruleFn === 'function' ? ruleFn($v) : null
+  if (!rules) return [...mw, h]
+
+  return [...mw, ...$v.parse(rules), h]
+}

package/src/server/http.ts

@@ -0,0 +1,23 @@
+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/server/middlewares/auth.ts

@@ -0,0 +1,40 @@
+import { Ability } from '$/auth'
+import type { Req, Res, Next } from '@/.'
+
+import { RegExpRouter } from 'hono/router/reg-exp-router'
+import { SmartRouter } from 'hono/router/smart-router'
+import { TrieRouter } from 'hono/router/trie-router'
+
+let used = false
+export const useAuth = () => used
+
+const whiteList = new SmartRouter({
+  routers: [new RegExpRouter(), new TrieRouter()],
+})
+
+export function autorizedPath(path: string, method = 'ALL'){
+  return used ? whiteList.match(method, path)[0][0]?.[0] !== undefined : true
+}
+
+export function auth(publicPaths: (string | [string, string])[]) {
+  if (!used) {
+    used = true
+    for (const route of publicPaths) {
+      const str = typeof route === 'string'
+      const path = str ? route : route[1]
+
+      whiteList.add(str ? 'ALL' : route[0], path, path)
+    }
+  }
+
+  return async (req: Req, res: Res, next: Next) => {
+    if (!autorizedPath(req.path, req.method)) {
+      const ability = Ability.fromRequest(req)
+
+      if (!req?.user || !ability || req.cant(ability))
+        return res.unauthorized()
+    }
+
+    await next()
+  }
+}

package/src/server/middlewares/logger.ts

@@ -0,0 +1,30 @@
+import { logger } from 'hono/logger'
+import { matchedRoutes } from 'hono/route'
+import { Datte } from 't0n'
+import { gray } from 't0n/color'
+import type { Req, Res, Context, Next } from '@/.'
+
+export const path = '*'
+export async function handle(req: Req, res: Res, next: Next, c: Context) {
+  const method = c.req.method
+  const route = matchedRoutes(c).find(route => route.method === method)?.path
+  const logWithRoute = (args: string[]) => {
+    if (!route || !args.length) return args
+    return args.map(arg => {
+      if (!arg) return arg
+      const split = arg?.split(' ')
+      if (split.length < 3 || split[2] === route)
+        return arg
+
+      split.splice(Math.min(3, split.length), 0, gray(route))
+      return split.join(' ')
+    })
+  }
+
+  const devLogger = logger((...args: any[]) => {
+    const timestamp = gray(Datte.dateTime())
+    console.log(timestamp, ...logWithRoute(args))
+  })
+
+  await devLogger(c, next)
+}

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

@@ -0,0 +1,29 @@
+import { basicAuth } from 'hono/basic-auth'
+import response from '$/response'
+import Config from '$/config'
+import type { Hono } from '$/types'
+
+export function registerOpenAPI(app: Hono, opts: any) {
+  if (!opts.path) return
+
+  if (opts?.auth?.username && opts?.auth?.password) {
+    app.use(opts.path +'/*', async (c, next) => {
+      const realm = opts.auth?.realm || 'Docs'
+      const unauthorized = response.unauthorized(
+        null,
+        {'WWW-Authenticate': `Basic realm="${realm.replace(/"/g, '\\"')}", charset="UTF-8"`}
+      )
+      if (!c.req.raw.headers.get('Authorization')) return unauthorized
+      const auth = basicAuth({ username: opts.auth.username, password: opts.auth.password, realm })
+
+      try {
+        await auth(c, next)
+      } catch {
+        return unauthorized
+      }
+    })
+  }
+
+  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'))
+}

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

@@ -0,0 +1,107 @@
+import { STATUS_CODES } from 'node:http'
+import { generateSpecs, resolver } from 'hono-openapi'
+import { array, object, string } from 'zod/mini'
+import { Envir } from 't0n'
+import { Scalar } from '@scalar/hono-api-reference'
+import { minify } from '@minify-html/node'
+import type { Hono } from '$/types'
+import { useAuth } from '$/middlewares/auth'
+
+export function openAPIConfig(opts: any) {
+  const {
+    disable = false,
+    path = '/docs',
+    agent = false,
+    name = '',
+    title = '',
+    version = Envir.get('APP_VERSION') || Envir.get('VERSION_HASH') || '1.0.0',
+    description = Envir.get('APP_DESCRIPTION', ''),
+    auth = {},
+    ...docs
+  } = opts?.docs ?? {}
+
+  return {
+    disable,
+    path,
+    auth,
+    agent: !!agent,
+    name: name || title || Envir.get('APP_NAME', 'API Docs'),
+    version,
+    desc: description,
+    ...docs,
+  }
+}
+
+export async function generateOpenAPI(app: Hono, opts?: any) {
+  return await generateSpecs(app, {
+    documentation: {
+      info: {
+        title: opts.name,
+        version: opts.version,
+        description: opts.desc,
+        contact: opts.contact,
+        termsOfService: opts.terms || opts.termsOfService,
+        license: opts.license,
+      },
+      externalDocs: opts.externalDocs,
+      servers: opts.servers,
+      security: useAuth() ? [{'JWT':[]}] : opts.security,
+      tags: opts.tags,
+      components: {
+        ...(useAuth() ? { securitySchemes: {
+          JWT: {
+            type: 'http',
+            scheme: 'bearer',
+            bearerFormat: 'JWT',
+          },
+        } } : {}),
+        responses: {
+          500: {
+            description: STATUS_CODES[500],
+            content: { // @ts-ignore
+              'application/json': await resolver(object({
+                m: array(string()),
+              })).toOpenAPISchema(),
+            },
+          },
+          ...opts?.responses,
+        },
+      },
+    },
+  })
+}
+
+export async function generateOpenAPIClient(app: Hono, opts?: any) {
+  const customCss = `[href="https://www.scalar.com"],.scalar-mcp-layer{display:none!important}`
+  app.get(
+    opts.path,
+    Scalar({
+      theme: 'saturn',
+      url: opts.path +'/openapi',
+      showDeveloperTools: 'never',
+      telemetry: false,
+      documentDownloadType: 'json', //'direct',
+      isLoading: true,
+      persistAuth: true,
+      hideClientButton: true,
+      pageTitle: opts.name,
+      agent: { disabled: !opts.agent },
+      slug: opts.name?.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w\s_-]/g, '').replace(/[\s_-]+/g, '_').replace(/[^\x00-\x7F]/g, '') +'_'+ opts.version,
+      customCss,
+      // onLoaded: () => document?.querySelectorAll('[href="https://www.scalar.com"]')?.forEach(el => el.remove()),
+      // favicon: 'https://example.com/favicon.png',
+      // hideDownloadButton: true,
+    })
+  )
+
+  const html = await (await app.request('/docs')).text()
+  const result = minify(Buffer.from(html), {
+    minify_css: true,
+    minify_js: true,
+    keep_comments: false,
+  })
+
+  return result.toString()
+    .replace(',customCss:`' + customCss + '`', '')
+    .replace('_integration:`hono`,', '')
+}

package/src/server/request.ts

@@ -0,0 +1,233 @@
+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 type { Context } from 'hono'
+import { routePath, matchedRoutes } from 'hono/route'
+import type { RouterRoute } from 'hono/types'
+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)
+})
+
+export const GET_REQUEST: unique symbol = Symbol()
+
+export default class $Request {
+  #c!: Context
+  #cookie: ReturnType<typeof cookieWrapper>
+  #u: Authnz<any> | null = null
+
+  #host: string
+  #protocol: string
+  #routePath?: string
+  #matchedRoutes: RouterRoute[]
+
+  constructor(c: Context) {
+    this.#c = c
+    this.#cookie = cookieWrapper(c)
+
+    const url = new URL(c.req.raw.url)
+    this.#host = url.protocol +'//'+ url.host
+    this.#protocol = url.protocol
+
+    this.#matchedRoutes = matchedRoutes(c)
+  }
+
+  static async toContext(c: Context) {
+    const req = new $Request(c)
+    await req.setAuth()
+    c.set(GET_REQUEST as unknown as string, req)
+    if (c.env) Envir.add(c.env)
+  }
+
+  async setAuth() {
+    this.#u = Authnz.fromToken(Token.fromRequest(this))
+  }
+
+  get user() {
+    return this.#u ? this.#u?.data : null
+  }
+
+  get auth() {
+    return this.#u
+  }
+
+  can(...abilities: string[]) {
+    return this.#u ? this.#u.can(...abilities) : false
+  }
+
+  cant(...abilities: string[]) {
+    return !this.can(...abilities)
+  }
+
+  hasRole(...roles: string[]) {
+    return this.#u ? this.#u.hasRole(...roles) : false
+  }
+
+  // TODO: fazer funcionar dnv..
+  // has(prop: string, value: any = null) {
+  //   return this.#u ? this.#u.has(prop, value) : false
+  // }
+  // hasValue(prop: string, value: any = null) {
+  //   return this.has(prop, value)
+  // }
+
+  // createToken(data: any, exp: number) {
+  //   return Token.create(this, data, exp)
+  // }
+  // parseToken(token: string) {
+  //   return Token.parse(this, token)
+  // }
+
+  get cx() {
+    return this.#c
+  }
+
+  get cookie() {
+    return this.#cookie
+  }
+
+  get ip(): string | undefined {
+    return this.#c.req.header('cf-connecting-ip') // cf
+      || this.#c.req.header('x-forwarded-for')?.split(',').at(-1)?.trim() // aws lambda
+      || this.#c.env?.aws?.lambda?.event?.requestContext?.identity?.sourceIp
+      || this.#c.env?.event?.Records[0]?.cf?.request?.clientIp // aws lambda@edge
+      || this.#c.req.header('x-real-ip') // vercel
+      || this.#c.env?.context?.ip // netlify
+      || this.#c.env?.remoteAddr?.hostname // deno
+  }
+
+  get userAgent(): string | undefined {
+    return this.#c.req.header('user-agent')
+  }
+
+  get protocol() {
+    return this.#protocol
+  }
+
+  get url() {
+    return this.#c.req.raw.url
+  }
+
+  get host() {
+    return this.#host
+  }
+
+  get path() {
+    return this.#c.req.path
+  }
+
+  get fullPath() {
+    const url = this.url
+    return url.slice(url.indexOf('/', 8))
+  }
+
+  get method() {
+    return this.#c.req.raw.method
+  }
+
+  get routePath() {
+    this.#routePath ??= routePath(this.#c)
+    return this.#routePath
+  }
+
+  get routeIndex() {
+    return this.#c.req.routeIndex
+  }
+
+  get matchedRoutes() {
+    return this.#matchedRoutes
+  }
+
+  get raw() {
+    return this.#c.req.raw
+  }
+
+  header(name: RequestHeader): string | undefined
+  header(name: string): string | undefined
+  header(): Record<RequestHeader | (string & CustomHeader), string>
+  header(name?: string) { // @ts-ignore
+    return this.#c.req.header(name)
+  }
+
+  param(key?: string) { // @ts-ignore
+    return this.#c.req.param(key)
+  }
+
+  query(): Record<string, string>
+  query(key: string): string | undefined
+  query(key?: string) { // @ts-ignore
+    return this.#c.req.query(key)
+  }
+
+  queries(): Record<string, string[]>
+  queries(key: string):string[] | undefined
+  queries(key?: string) { // @ts-ignore
+    return this.#c.req.queries(key)
+  }
+
+  async body<E>() {
+    const cType = this.#c.req.header('Content-Type')
+    if (!cType) return {} as E
+
+    if (/^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType))
+      return await this.json<E>()
+
+    if (
+      cType?.startsWith('multipart/form-data')
+      || cType?.startsWith('application/x-www-form-urlencoded')
+    ) {
+      return await this.parseBody() as E
+    }
+
+    return {} as E
+  }
+
+  async parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(
+    options?: Options
+  ): Promise<T>
+  async parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>
+  async parseBody(options?: Partial<ParseBodyOptions>) {
+    try {
+      return await this.#c.req.parseBody(options)
+    } catch (e) {
+      throw new HTTPException(400, {
+        message: 'Malformed FormData request.'+ (e instanceof Error ? ` ${e.message}` : ` ${String(e)}`)
+      })
+    }
+  }
+
+  async json<E>() {
+    try {
+      return await this.#c.req.json<E>()
+    } catch {
+      throw new HTTPException(400, { message: 'Malformed JSON in request body' })
+    }
+  }
+
+  text() {
+    return this.#c.req.text()
+  }
+
+  arrayBuffer() {
+    return this.#c.req.arrayBuffer()
+  }
+
+  blob() {
+    return this.#c.req.blob()
+  }
+
+  formData() {
+    return this.#c.req.formData()
+  }
+}

package/src/server/response.ts

@@ -0,0 +1,142 @@
+import { HtmlEscapedCallbackPhase, resolveCallback } from 'hono/utils/html'
+import type {
+  ContentfulStatusCode, RedirectStatusCode, StatusCode,
+  BaseMime, HeaderRecord,
+  ErrorResponse, Errors,
+} from './types'
+
+type RBag = {
+  status?: StatusCode,
+  headers?: HeaderRecord,
+}
+
+export default class $Response {
+  static raw(
+    status?: StatusCode,
+    body?: any,
+    cType?: BaseMime,
+    headers?: HeaderRecord
+  ) {
+    const b: RBag = { status: status || 200 }
+
+    if (cType || headers) {
+      headers ??= {}
+      if (cType) headers['Content-Type'] = cType
+      b.headers = headers
+    }
+
+    return new Response(body ?? null, b)
+  }
+
+  static text(str?: string, status?: StatusCode, headers?: HeaderRecord) {
+    return this.raw(status, str, 'text/plain; charset=UTF-8' as BaseMime, headers)
+  }
+
+  static json<T>(data?: T, status?: StatusCode, headers?: HeaderRecord) {
+    if (data == null)
+      return this.raw(status, null, undefined, headers)
+
+    return this.raw(status, JSON.stringify(data), 'application/json', headers)
+  }
+
+  static redirect(
+    location: string | URL,
+    status?: RedirectStatusCode,
+    headers?: HeaderRecord
+  ) {
+    const loc = String(location)
+
+    return new Response(null, {
+      status: status || 302,
+      headers: { ...headers, 'Location': /[^\x00-\xFF]/.test(loc) ? encodeURI(loc) : loc }
+    })
+  }
+
+  static html(
+    html: string | Promise<string>,
+    status?: ContentfulStatusCode,
+    headers?: HeaderRecord
+  ): Response | Promise<Response> {
+    const res = (html: string) => this.raw(status, html, 'text/html; charset=UTF-8' as BaseMime, headers)
+    return typeof html === 'string'
+      ? res(html)
+      : resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res)
+  }
+
+  static ok(): Response
+  static ok<T>(data: T, headers?: HeaderRecord): Response
+  static ok<T>(data?: T, headers?: HeaderRecord) {
+    return this.json(data, 200, headers)
+  }
+
+  static created(): Response
+  static created<T>(data: T, headers?: HeaderRecord): Response
+  static created<T>(data?: T, headers?: HeaderRecord) {
+    return this.json(data, 201, headers)
+  }
+
+  static accepted(): Response
+  static accepted<T>(data: T, headers?: HeaderRecord): Response
+  static accepted<T>(data?: T, headers?: HeaderRecord) {
+    return this.json(data, 202, headers)
+  }
+
+  static deleted(headers?: HeaderRecord) {
+    return this.noContent(headers)
+  }
+
+  static noContent(headers?: HeaderRecord) {
+    return this.json(null, 204, headers)
+  }
+
+  static badRequest(): Response
+  static badRequest(errors?: Errors | null, msg?: string, headers?: HeaderRecord): Response
+  static badRequest(errors?: Errors | null, msg?: string, headers?: HeaderRecord) {
+    return this.error(errors, msg, 400, headers)
+  }
+
+  static unauthorized(): Response
+  static unauthorized<T>(data: T, headers?: HeaderRecord): Response
+  static unauthorized<T>(data?: T, headers?: HeaderRecord) {
+    return this.json(data, 401, headers)
+  }
+
+  static forbidden(): Response
+  static forbidden<T>(data: T, headers?: HeaderRecord): Response
+  static forbidden<T>(data?: T, headers?: HeaderRecord) {
+    return this.json(data, 403, headers)
+  }
+
+  static notFound(): Response
+  static notFound<T>(msg: T, headers?: HeaderRecord): Response
+  static notFound<T>(msg?: T, headers?: HeaderRecord) {
+    return this.json(msg, 404, headers)
+  }
+
+  static conflict(): Response
+  static conflict(errors?: Errors | null, msg?: string, headers?: HeaderRecord) {
+    return this.error(errors, msg, 409, headers)
+  }
+
+  static unsupportedMediaType(): Response
+  static unsupportedMediaType(errors?: Errors | null, msg?: string, headers?: HeaderRecord) {
+    return this.error(errors, msg, 415, headers)
+  }
+
+  static internalError(): Response
+  static internalError(errors?: Errors | null, msg?: string, headers?: HeaderRecord) {
+    return this.error(errors, msg, 500, headers)
+  }
+
+  static error(errors?: Errors | null, msg?: string, status?: ContentfulStatusCode, headers?: HeaderRecord) {
+    status ??= 500
+    if (!errors && !msg)
+      return this.raw(status, msg)
+
+    const resp: ErrorResponse = {}
+    if (msg) resp.m = msg
+    if (errors) resp.e = errors
+
+    return this.json(resp, status, headers)
+  }
+}