rajt 0.0.57 → 0.0.59

package/src/dev.ts

@@ -1,16 +1,20 @@
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
 import { config } from 'dotenv'
-import { serve } from '@hono/node-server'
+import { serve, type ServerType } from '@hono/node-server'
 import createApp from './create-app'
 import { getRoutes, getMiddlewares } from './routes'
 import { registerHandler, registerMiddleware } from './register'
 import { Ability } from './auth'
-import { getAvailablePort } from './utils/port'
 import jsonImport from './utils/json-import'
 import { setEnv, detectEnvironment } from './utils/environment'
+import shutdown from './utils/shutdown'
 
 setEnv(detectEnvironment())
 
-config({ path: '../../.env.dev' })
+const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../')
+
+config({ path: join(__dirname, '.env.dev') })
 
 let routes = await getRoutes()
 routes.forEach(r => registerHandler(r.name, r.handle))
@@ -20,18 +24,17 @@ const middlewares = await getMiddlewares()
 middlewares.forEach(mw => registerMiddleware(mw.handle))
 
 Ability.fromRoutes(routes)
-Ability.roles = jsonImport('../../../../roles.json')
+Ability.roles = jsonImport(join(__dirname, 'roles.json'))
 
 const fetch = createApp({ routes }).fetch
 
-const desiredPort = process.env?.PORT ? Number(process.env.PORT) : 3000
-getAvailablePort(desiredPort)
-  .then(port => {
-    if (port != desiredPort)
-      console.warn(`🟠 Port ${desiredPort} was in use, using ${port} as a fallback`)
-
-    console.log(`🚀 API running on http://localhost:${port}`)
-    serve({ fetch, port })
-  }).catch(err => {
-    console.error('Error finding available port:', err)
-  })
+const port = process.env?.PORT ? Number(process.env.PORT) : 3000
+
+let server: ServerType | null = serve({ fetch, port })
+
+shutdown(() => {
+  if (server) {
+    server?.close()
+    server = null
+  }
+})

package/src/enum.ts

@@ -1,75 +1,2 @@
-type EnumType<T> = T extends string[]
-  ? { [K in T[number]]: K }
-  : T extends Record<string, string | number>
-  ? T
-  : never
-
-type EnumValue<T> = T extends string[]
-  ? T[number]
-  : T extends Record<string, infer V>
-    ? V
-    : never
-
-type EnumStatic<T> = {
-  has(search: string | number): boolean
-  key(search: string | number): string | null
-  value(search: string | number): EnumValue<T> | null
-  readonly keys: string[]
-  readonly values: Array<EnumValue<T>>
-  toObject(): EnumType<T>
-} & EnumType<T>
-
-export default function Enum<T extends string[] | Record<string, string | number>>(definition: T): EnumStatic<T> {
-  const enumObj = Array.isArray(definition)
-    ? Object.fromEntries(definition.map(key => [key, key])) as EnumType<T>
-    : definition as EnumType<T>
-
-  const keyToValueMap = new Map<string | number, string | number>()
-  const valueToKeyMap = new Map<string | number, string>()
-
-  Object.entries(enumObj).forEach(([key, value]) => {
-    keyToValueMap.set(key, value)
-    valueToKeyMap.set(String(value), key)
-    if (typeof value === 'number') valueToKeyMap.set(value.toString(), key)
-  })
-
-  const GeneratedEnum = class {
-    static has(search: string | number): boolean {
-      return keyToValueMap.has(search as string) || valueToKeyMap.has(String(search))
-    }
-
-    static key(search: string | number): string | null {
-      if (keyToValueMap.has(search as string))
-        return search as string
-
-      return valueToKeyMap.get(String(search)) || null
-    }
-
-    static value(search: string | number): EnumValue<T> | null {
-      if (keyToValueMap.has(search as string))
-        return keyToValueMap.get(search as string) as EnumValue<T>
-
-      return valueToKeyMap.has(String(search))
-        ? keyToValueMap.get(valueToKeyMap.get(String(search))!) as EnumValue<T>
-        : null
-    }
-
-    static get keys(): string[] {
-      return Object.keys(enumObj)
-    }
-
-    static get values(): Array<EnumValue<T>> {
-      return Object.values(enumObj) as Array<EnumValue<T>>
-    }
-
-    static toObject(): EnumType<T> {
-      return { ...enumObj }
-    }
-  }
-
-  Object.entries(enumObj).forEach(([key, value]) => {
-    (GeneratedEnum as any)[key] = value
-  })
-
-  return GeneratedEnum as unknown as EnumStatic<T>
-}
+export { Enum } from 't0n'
+export type { EnumStatic, EnumValue, EnumType } from 't0n'

package/src/esbuild.mjs

@@ -34,7 +34,7 @@ const buildOptions = {
   bundle: true,
   minify: true,
   outfile: join(__dirname, '../../../dist/index.js'),
-  platform: isCF ? 'browser' : 'node20',
+  platform: isCF ? 'browser' : 'node',
   target: isCF ? 'es2022' : 'node20',
   conditions: isCF ? ['worker', 'browser'] : [],
   format: 'esm',
@@ -44,8 +44,8 @@ const buildOptions = {
     '@aws-sdk', '@smithy',
     ...(isCF ? [
       'cloudflare:workers',
-      'node:crypto',
-      'crypto',
+      'node:crypto', 'crypto',
+      'node:buffer', 'buffer',
     ] : []),
   ],
   metafile: true,
@@ -102,12 +102,14 @@ existsSync(distDir)
 for (const file of await readdirSync(distDir))
   await rmSync(join(distDir, file))
 
-for (let file of [
-  'wrangler.toml',
-]) {
-  file = join(cwd, file)
-  if (existsSync(file))
-    copyFileSync(file, join(cwd, 'dist', basename(file)))
+if (isCF) {
+  for (let file of [
+    'wrangler.toml',
+  ]) {
+    file = join(cwd, file)
+    if (existsSync(file))
+      copyFileSync(file, join(cwd, 'dist', basename(file)))
+  }
 }
 
 esbuild.build(buildOptions)

package/src/http.ts

@@ -1,14 +1,15 @@
 import type { Context, Next } from 'hono'
 import { MiddlewareType } from './middleware'
-import Response from './response'
-import { Ability, Auth as Gate } from './auth'
+import response from './response'
+import { Ability } from './auth'
 import mergeMiddleware from './utils/merge-middleware'
+import { IRequest } from './types'
 
 function method(method: string, ...args: any[]): void | ClassDecorator {
-  if (args.length === 1 && typeof args[0] === 'function')
+  if (args.length == 1 && typeof args[0] == 'function')
     return _method(method, '/', args[0])
 
-  const path = typeof args[0] === 'string' ? args[0] : '/'
+  const path = typeof args[0] == 'string' ? args[0] : '/'
   return (target: Function) => _method(method, path, target)
 }
 
@@ -93,7 +94,7 @@ export function Middlewares(...handlers: MiddlewareType[]) {
 export function Auth(target: Function): void
 export function Auth(): ClassDecorator
 export function Auth(...args: any[]): void | ClassDecorator {
-  if (args.length === 1 && typeof args[0] === 'function')
+  if (args.length == 1 && typeof args[0] == 'function')
     return _auth(args[0])
 
   return (target: any) => _auth(target)
@@ -101,11 +102,11 @@ export function Auth(...args: any[]): void | ClassDecorator {
 
 function _auth(target: Function | any) {
   mergeMiddleware(target, async (c: Context, next: Next) => {
-    const user = Gate.user
+    const req = c.get('_') as IRequest
     const ability = Ability.fromAction(target)
 
-    if (!user || !ability || Gate.cant(ability))
-      return Response.unauthorized()
+    if (!req?.user || !ability || req.cant(ability))
+      return response.unauthorized()
 
     await next()
   })

package/src/index.ts

@@ -1,6 +1,4 @@
 export { default as Action } from './action'
-export { Auth, Auth as Gate } from './auth/auth'
 export { default as Middleware } from './middleware'
-export { default as Request } from './request'
 export { default as Response } from './response'
-export { default as Enum } from './enum'
+export { Enum } from 't0n'

package/src/prod-aws.ts

@@ -1,19 +1,4 @@
 import { handle } from 'hono/aws-lambda'
-import createApp from './create-app'
-import { Ability } from './auth'
+import { app } from './prod'
 
-// @ts-ignore
-await import('../../../tmp/import-routes.mjs')
-
-// @ts-ignore
-const routes = (await import('../../../tmp/routes.json')).default
-
-// @ts-ignore
-Ability.roles = (await import('../../../roles.json')).default
-// @ts-ignore
-Ability.fromRoutes(routes)
-
-// @ts-ignore
-const app = createApp({ routes })
-
-export const handler = handle(app) // AWS Lambda (LLRT)
+export const handler = handle(app)

package/src/prod-cf.ts

@@ -1,18 +1 @@
-import createApp from './create-app'
-import { Ability } from './auth'
-
-// @ts-ignore
-await import('../../../tmp/import-routes.mjs')
-
-// @ts-ignore
-const routes = (await import('../../../tmp/routes.json')).default
-
-// @ts-ignore
-Ability.roles = (await import('../../../roles.json')).default
-// @ts-ignore
-Ability.fromRoutes(routes)
-
-// @ts-ignore
-const app = createApp({ routes })
-
-export default app
+export { app as default } from './prod'

package/src/prod.ts

@@ -0,0 +1,16 @@
+import createApp from './create-app'
+import { Ability } from './auth'
+
+// @ts-ignore
+await import('../../../tmp/import-routes.mjs')
+
+// @ts-ignore
+const routes = (await import('../../../tmp/routes.json')).default
+
+// @ts-ignore
+Ability.roles = (await import('../../../roles.json')).default
+// @ts-ignore
+Ability.fromRoutes(routes)
+
+// @ts-ignore
+export const app = createApp({ routes })

package/src/request-old.ts

@@ -0,0 +1,98 @@
+import { bufferToFormData } from 'hono/utils/buffer'
+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)}`)
+        })
+      }
+    }
+
+    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
+      }
+    })
+
+    return form
+  }
+
+  static async json<E>() {
+    try {
+      return await c.cx.req.json<E>()
+    } catch {
+      throw new HTTPException(400, { message: 'Malformed JSON in request body' })
+    }
+  }
+
+  static async body<E>() {
+    const cType = c.cx.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 (
+      /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/.test(cType)
+      && ! /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType)
+    ) {
+        return await Request.form() as E
+    }
+
+    return {} as E
+  }
+
+  static get response() {
+    return Response
+  }
+
+  static get cx() {
+    return c.cx
+  }
+
+  static get cookie() {
+    return c.cookie
+  }
+
+  static get ip() {
+    return c.ip
+  }
+
+  static get userAgent() {
+    return c.userAgent
+  }
+}

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()
   }
 }