duto 0.260808.0 → 0.260915.0

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

@@ -0,0 +1,114 @@
+import { STATUS_CODES } from 'node:http'
+import { generateSpecs, resolver } from 'hono-openapi'
+import { array, object, string } from 'zod/mini'
+import { getEnv } 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 = getEnv('APP_VERSION') || getEnv('VERSION_HASH') || '1.0.0',
+    description = getEnv('APP_DESCRIPTION', ''),
+    auth = {},
+    ...docs
+  } = opts?.docs ?? {}
+
+  return {
+    disable,
+    path,
+    auth,
+    agent: !!agent,
+    name: name || title || getEnv('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,
+      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'
+      ],
+    })
+  )
+
+  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,265 @@
+import { getCookie, getSignedCookie, setCookie, setSignedCookie, deleteCookie } from 'hono/cookie'
+import { HTTPException } from 'hono/http-exception'
+import { Authnz, Token } from './auth'
+import { addEnv } 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'
+
+// 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: $Cookie
+  // #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 = new $Cookie(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) addEnv(c.env)
+  }
+
+  async setAuth() {
+    this.#u = Authnz.fromToken(await 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)
+  }
+}