rajt 0.0.58 → 0.0.60

package/src/request.ts

@@ -1,98 +1,179 @@
-import { bufferToFormData } from 'hono/utils/buffer'
+import { getCookie, getSignedCookie, setCookie, setSignedCookie, deleteCookie } from 'hono/cookie'
 import { HTTPException } from 'hono/http-exception'
-import type { BodyData } from 'hono/utils/body'
-import Response from './response'
-import c from './context'
-
-export default class Request {
-  static param(key: string) {
-    return c.cx.req.param(key)
-  }
-
-  static query() {
-    return c.cx.req.query()
-  }
-
-  static async form(cType?: string) {
-    cType ??= c.cx.req.header('Content-Type')
-    if (!cType) return {}
-
-    let formData: FormData
-
-    if (c.cx.req.bodyCache.formData) {
-      formData = await c.cx.req.bodyCache.formData
-    } else {
-      try {
-        const arrayBuffer = await c.cx.req.arrayBuffer()
-        formData = await bufferToFormData(arrayBuffer, cType)
-        c.cx.req.bodyCache.formData = formData
-      } catch (e) {
-        throw new HTTPException(400, {
-          message: 'Malformed FormData request.'
-                   + (e instanceof Error ? ` ${e.message}` : ` ${String(e)}`)
-        })
-      }
-    }
+import { Authnz, Token } from './auth'
+
+import type { Context } from 'hono'
+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 default class $Request {
+  #c!: Context
+  #cookie: ReturnType<typeof cookieWrapper>
+  #u: Authnz<any> | null = null
+
+  constructor(c: Context) {
+    this.#c = c
+    this.#cookie = cookieWrapper(c)
+    this.#u = Authnz.fromToken(Token.fromRequest(this))
+  }
 
-    const form: BodyData<{ all: true }> = {}
-    formData.forEach((value, key) => {
-      if (key.endsWith('[]')) {
-        ;((form[key] ??= []) as unknown[]).push(value)
-      } else if (Array.isArray(form[key])) {
-        ;(form[key] as unknown[]).push(value)
-      } else if (key in form) {
-        form[key] = [form[key] as string | File, value]
-      } else {
-        form[key] = value
-      }
-    })
+  get user() {
+    return this.#u ? this.#u?.data : null
+  }
 
-    return form
+  get auth() {
+    return this.#u
   }
 
-  static async json<E>() {
-    try {
-      return await c.cx.req.json<E>()
-    } catch {
-      throw new HTTPException(400, { message: 'Malformed JSON in request body' })
-    }
+  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
+  }
+
+  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)
+  }
+
+  get cx() {
+    return this.#c
+  }
+
+  get cookie() {
+    return this.#cookie
+  }
+
+  get ip(): string | undefined {
+    return this.#c.req.header('cf-connecting-ip')
+      || this.#c.req.header('x-forwarded-for')?.split(',')[0]?.trim()
+      || this.#c.env?.aws?.lambda?.event?.requestContext?.identity?.sourceIp
+      || this.#c.req.header('x-real-ip')
+      || this.#c.env?.remoteAddr?.hostname
+  }
+
+  get userAgent(): string | undefined {
+    return this.#c.req.header('user-agent')
+  }
+
+  get routePath() {
+    return this.#c.req.routePath
+  }
+
+  get path() {
+    return this.#c.req.path
   }
 
-  static async body<E>() {
-    const cType = c.cx.req.header('Content-Type')
+  get url() {
+    return this.#c.req.raw.url
+  }
+
+  get method() {
+    return this.#c.req.raw.method
+  }
+
+  get matchedRoutes() {
+    return this.#c.req.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 Request.json<E>()
-    }
+    if (/^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType))
+      return await this.json<E>()
 
     if (
-      /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/.test(cType)
-      && ! /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType)
+      cType?.startsWith('multipart/form-data')
+      || cType?.startsWith('application/x-www-form-urlencoded')
     ) {
-        return await Request.form() as E
+      return await this.parseBody() as E
     }
 
     return {} as E
   }
 
-  static get response() {
-    return Response
+  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' })
+    }
   }
 
-  static get cx() {
-    return c.cx
+  text() {
+    return this.#c.req.text()
   }
 
-  static get cookie() {
-    return c.cookie
+  arrayBuffer() {
+    return this.#c.req.arrayBuffer()
   }
 
-  static get ip() {
-    return c.ip
+  blob() {
+    return this.#c.req.blob()
   }
 
-  static get userAgent() {
-    return c.userAgent
+  formData() {
+    return this.#c.req.formData()
   }
 }

package/src/response.ts

@@ -1,37 +1,88 @@
-import type { ContentfulStatusCode, StatusCode } from 'hono/utils/http-status'
+import type { ContentfulStatusCode, RedirectStatusCode, StatusCode } from 'hono/utils/http-status'
+import type { BaseMime } from 'hono/utils/mime'
+import type { ResponseHeader } from 'hono/utils/headers'
 import type { ErrorResponse, Errors } from './types'
-import c from './context'
+import { HtmlEscapedCallbackPhase, resolveCallback } from 'hono/utils/html'
 
-export default class Response {
-  static raw(status?: StatusCode, body?: string) {
-    return c.cx.newResponse(body ? body : null, { status })
+type HeaderRecord =
+  | Record<'Content-Type', BaseMime>
+  | Record<ResponseHeader, string | string[]>
+  | Record<string, string | string[]>
+
+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(data?: string, status?: StatusCode) {
+    return this.raw(status, data, 'text/plain; charset=UTF-8' as BaseMime)
+  }
+
+  static json<T>(data?: T, status?: StatusCode, headers?: HeaderRecord) {
+    if (data == null)
+      return this.raw(status)
+
+    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): Response
   static ok<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(200)
-
-    return c.cx.json(data, 200)
+    return this.json(data, 200)
   }
 
   static created(): Response
   static created<T>(data: T): Response
   static created<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(201)
-
-    return c.cx.json(data, 201)
+    return this.json(data, 201)
   }
 
   static accepted(): Response
   static accepted<T>(data: T): Response
   static accepted<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(202)
-
-    return c.cx.json(data, 202)
+    return this.json(data, 202)
   }
 
   static deleted() {
@@ -50,19 +101,13 @@ export default class Response {
   static unauthorized(): Response
   static unauthorized<T>(data: T): Response
   static unauthorized<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(401)
-
-    return c.cx.json(data, 401)
+    return this.json(data, 401)
   }
 
   static forbidden(): Response
   static forbidden<T>(data: T): Response
   static forbidden<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(403)
-
-    return c.cx.json(data, 403)
+    return this.json(data, 403)
   }
 
   static notFound(): Response
@@ -95,6 +140,6 @@ export default class Response {
     if (msg) resp.m = msg
     if (errors) resp.e = errors
 
-    return c.cx.json(resp, status)
+    return this.json(resp, status)
   }
 }

package/src/routes.ts

@@ -4,6 +4,11 @@ import { fileURLToPath } from 'node:url'
 import { Route } from './types'
 import { isAnonFn } from './utils/func'
 
+import { writeFileSync } from 'node:fs'
+import { config } from 'dotenv'
+import ensureDir from './utils/ensuredir'
+import versionSHA from './utils/version-sha'
+
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
@@ -29,7 +34,7 @@ const walk = async (dir: string, baseDir: string, fn: Function, parentMw: string
 
     if (stat.isDirectory()) {
       await walk(fullPath, baseDir, fn, currentMw)
-    } else if (file !== 'index.ts' && file.endsWith('.ts') && !file.endsWith('.d.ts')) {
+    } else if (file != 'index.ts' && file.endsWith('.ts') && !file.endsWith('.d.ts')) {
       const mod = await import(fullPath)
       fn(fullPath, baseDir, mod.default, currentMw)
     }
@@ -65,7 +70,7 @@ export async function getRoutes(
 }
 
 function sortRoutes(routes: Route[]) {
-  const metas = new Map<string, { score: number; segmentsCount: number }>()
+  const metas = new Map<string, { score: number, segmentsCount: number }>()
 
   for (const route of routes)
     metas.set(route.path, computeRouteMeta(route.path))
@@ -118,3 +123,62 @@ export async function getMiddlewares(
 
   return mw
 }
+
+const env = Object.entries(
+  config({ path: '../../.env.prod' })?.parsed || {}
+).filter(([key, val]) => key?.toLowerCase().indexOf('aws') != 0) // prevent AWS credentials
+
+const version = versionSHA('../../.git') // @ts-ignore
+env.push(['VERSION_SHA', process.env['VERSION_SHA'] = version]) // @ts-ignore
+env.push(['VERSION_HASH', process.env['VERSION_HASH'] = version?.substring(0, 7)])
+
+export async function cacheRoutes() {
+  const rolePath = join(__dirname, '../../../roles.json')
+  if (!existsSync(rolePath))
+    writeFileSync(rolePath, '{}')
+
+  const routes = await getRoutes()
+  const middlewares = await getMiddlewares()
+
+  const iPath = join(__dirname, '../../../tmp/import-routes.mjs')
+  ensureDir(iPath)
+  writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
+${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key + ':' + JSON.stringify(val)).join(',')}})` : ''}
+
+import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
+
+${routes.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
+${middlewares.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
+
+try {
+  const handlers = {${routes.map(r => r.name).join()}}
+
+  for (const [name, handler] of Object.entries(handlers)) {
+    if (typeof handler == 'function' || handler.prototype?.handle) {
+      registerHandler(name, handler)
+    }
+  }
+
+  const middlewares = {${middlewares.map(r => r.name).join()}}
+
+  for (const [name, mw] of Object.entries(middlewares)) {
+    registerMiddleware(mw)
+  }
+} catch (e) {
+  console.error('Failed to register handlers:', e)
+}
+`)
+
+  const rPath = join(__dirname, '../../../tmp/routes.json')
+  ensureDir(rPath)
+  writeFileSync(rPath, JSON.stringify(routes.filter(r => r.method && r.path).map(route => [
+    route.method,
+    route.path,
+    route.middlewares,
+    route.name,
+  ])))
+}
+
+function normalizePath(file: string) {
+  return file.replace(/\.tsx?$/i, '').replace(/(\/index)+$/i, '').replace(/\/+$/g, '')
+}

package/src/scripts/cache-routes.ts

@@ -1,67 +1,4 @@
-import { existsSync, writeFileSync } from 'node:fs'
-import { config } from 'dotenv'
-import { getRoutes, getMiddlewares } from '../routes'
-import ensureDir from '../utils/ensuredir'
-import versionSHA from '../utils/version-sha'
-
-const env = Object.entries(
-  config({ path: '../../.env.prod' })?.parsed || {}
-).filter(([key, val]) => key?.toLowerCase().indexOf('aws') != 0) // prevent AWS credentials
-
-const version = versionSHA('../../.git')
-env.push(['VERSION_SHA', process.env['VERSION_SHA'] = version])
-env.push(['VERSION_HASH', process.env['VERSION_HASH'] = version?.substring(0, 7)])
-
-async function cacheRoutes() {
-  const rolePath = '../../roles.json'
-  if (!existsSync(rolePath))
-    writeFileSync(rolePath, '{}')
-
-  const routes = await getRoutes()
-  const middlewares = await getMiddlewares()
-
-  const iPath = '../../tmp/import-routes.mjs'
-  ensureDir(iPath)
-  writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
-${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key + ':' + JSON.stringify(val)).join(',')}})` : ''}
-
-import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
-
-${routes.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
-${middlewares.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
-
-try {
-  const handlers = {${routes.map(r => r.name).join()}}
-
-  for (const [name, handler] of Object.entries(handlers)) {
-    if (typeof handler == 'function' || handler.prototype?.handle) {
-      registerHandler(name, handler)
-    }
-  }
-
-  const middlewares = {${middlewares.map(r => r.name).join()}}
-
-  for (const [name, mw] of Object.entries(middlewares)) {
-    registerMiddleware(mw)
-  }
-} catch (e) {
-  console.error('Failed to register handlers:', e)
-}
-`)
-
-  const rPath = '../../tmp/routes.json'
-  ensureDir(rPath)
-  writeFileSync(rPath, JSON.stringify(routes.filter(r => r.method && r.path).map(route => [
-    route.method,
-    route.path,
-    route.middlewares,
-    route.name,
-  ])))
-}
-
-function normalizePath(file: string) {
-  return file.replace(/\.tsx?$/i, '').replace(/(\/index)+$/i, '').replace(/\/+$/g, '')
-}
+import { cacheRoutes } from '../routes'
 
 cacheRoutes()
   .then(() => {

package/src/types.ts

@@ -1,8 +1,29 @@
-import { Handler } from 'hono'
+import type { Handler, ValidationTargets } from 'hono'
 import { ResponseHeader } from 'hono/utils/headers'
 import { StatusCode } from 'hono/utils/http-status'
 import { BaseMime } from 'hono/utils/mime'
+import z from 'zod'
 import Action from './action'
+import request from './request'
+import response from './response'
+import validator from './validator'
+
+export type { Context, Next } from 'hono'
+
+type PublicMethods<T> = {
+  [K in keyof T]: K extends `#${string}` | `$${string}` | symbol | 'prototype' ? never : K
+}[keyof T]
+
+export type IRequest = Pick<request, PublicMethods<request>>
+export type IResponse = Pick<typeof response, PublicMethods<typeof response>>
+
+export type IValidator = Pick<typeof validator, PublicMethods<typeof validator>>
+export type Rule = {
+  schema: z.ZodObject<any>
+  target: keyof ValidationTargets
+  eTarget?: 'fieldErrors' | 'formErrors'
+}
+export type Rules = Rule[] | Rule | null
 
 export type Route = {
   method: string,
@@ -13,6 +34,8 @@ export type Route = {
   handle: Handlers,
 }
 
+export type ActionType = Function | Handler | Action | (new () => Action)
+
 export type Handlers = (Function | Handler | (new () => Action))[]
 
 export type Routes = Route[]
@@ -45,6 +68,3 @@ export type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T>
 //   | null
 //   | { [key: string]: JSONValue }
 //   | JSONValue[]
-
-
-export type { Context, Next } from 'hono'

package/src/utils/func.ts

@@ -4,5 +4,5 @@ export const isAsyncFn = (fn: any) => {
 }
 
 export const isAnonFn = (fn: any) => {
-    return fn?.name === '' || fn?.name == 'anonymous'
+    return fn?.name == '' || fn?.name == 'anonymous'
 }

package/src/utils/resolve.ts

@@ -1,5 +1,6 @@
-import Action, { ActionType } from '../action'
+import Action from '../action'
 import { MiddlewareType } from '../middleware'
+import type { ActionType } from '../types'
 
 export function resolve(obj: ActionType, id: string) {
   if (typeof obj == 'function' && obj?.length == 2)

package/src/validator.ts

@@ -0,0 +1,68 @@
+import { ZodObject } from 'zod'
+import { zValidator } from '@hono/zod-validator'
+import type { ValidationTargets } from 'hono'
+import type { Rule, Rules } from './types'
+import response from './response'
+
+export default class $Validator {
+  private static cache = new Map<string, any>()
+
+  private static createRule<T extends keyof ValidationTargets>(
+    target: T,
+    schema?: ZodObject<any>
+  ):
+    | { schema: (schema: ZodObject<any>) => Rule }
+    | Rule
+  {
+    if (schema != null) {
+      return {
+        target,
+        schema,
+        eTarget: 'fieldErrors'
+      } satisfies Rule
+    }
+
+    return {
+      schema: (schema: ZodObject<any>) => ({
+        target,
+        schema,
+        eTarget: 'fieldErrors'
+      })
+    }
+  }
+
+  private static getOrCreateAlias<T extends keyof ValidationTargets>(target: T) {
+    if (this.cache.has(target))
+      return this.cache.get(target)
+
+    const aliasFunc = (schema?: ZodObject<any>) => {
+      if (schema != null)
+        return this.createRule(target, schema)
+
+      return this.createRule(target)
+    }
+
+    const typedAlias = aliasFunc as {
+      (): { schema: (schema: ZodObject<any>) => Rule },
+      (schema: ZodObject<any>): Rule,
+    }
+
+    this.cache.set(target, typedAlias)
+    return typedAlias
+  }
+
+  static readonly json = $Validator.getOrCreateAlias('json')
+  static readonly form = $Validator.getOrCreateAlias('form')
+  static readonly query = $Validator.getOrCreateAlias('query')
+  static readonly param = $Validator.getOrCreateAlias('param')
+  static readonly header = $Validator.getOrCreateAlias('header')
+  static readonly cookie = $Validator.getOrCreateAlias('cookie')
+
+  static parse(rules: Rules): Function[] {
+    return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore
+      .flatMap(rule => zValidator(rule.target, rule.schema, (result, c) => {
+        if (!result.success) // @ts-ignore
+          return response.badRequest({ ...result.error.flatten()[rule.eTarget] })
+      }))
+  }
+}