rajt 0.0.28 → 0.0.30

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/action.ts

@@ -1,7 +1,8 @@
-import { Context, Handler, HonoRequest, MiddlewareHandler, Next, ValidationTargets } from 'hono'
-import { z, ZodObject, ZodRawShape } from 'zod'
-import { zValidator } from '@hono/zod-validator'
+// import { Context, Handler, HonoRequest, MiddlewareHandler, Next, ValidationTargets } from 'hono'
 // import { JSONValue } from 'hono/utils/types'
+import { Context, Handler, ValidationTargets } from 'hono'
+import { z, ZodObject } from 'zod'
+import { zValidator } from '@hono/zod-validator'
 import JsonResponse from './response'
 import { bufferToFormData } from 'hono/utils/buffer'
 import { HTTPException } from 'hono/http-exception'
@@ -16,15 +17,8 @@ type RuleDefinition = {
 }
 
 export default abstract class Action {
-  protected context!: Context
-  protected errorTarget!: string
-  protected rules(): RuleDefinition[] | RuleDefinition | null {
-    return null
-  }
-
   rule<T extends keyof ValidationTargets>(target: T): { schema: (schema: ZodObject<any>) => RuleDefinition }
   rule<T extends keyof ValidationTargets>(target: T, schema: ZodObject<any>): RuleDefinition
-
   rule<T extends keyof ValidationTargets>(target: T, schema?: ZodObject<any>):
     | { schema: (schema: ZodObject<any>) => RuleDefinition }
     | RuleDefinition
@@ -47,26 +41,26 @@ export default abstract class Action {
   }
 
   param(key: string) {
-    return this.context.req.param(key)
+    return this.cx.req.param(key)
   }
 
   query() {
-    return this.context.req.query()
+    return this.cx.req.query()
   }
 
   async form(cType?: string) {
-    cType ??= this.context.req.header('Content-Type')
+    cType ??= this.cx.req.header('Content-Type')
     if (!cType) return {}
 
     let formData: FormData
 
-    if (this.context.req.bodyCache.formData) {
-      formData = await this.context.req.bodyCache.formData
+    if (this.cx.req.bodyCache.formData) {
+      formData = await this.cx.req.bodyCache.formData
     } else {
       try {
-        const arrayBuffer = await this.context.req.arrayBuffer()
+        const arrayBuffer = await this.cx.req.arrayBuffer()
         formData = await bufferToFormData(arrayBuffer, cType)
-        this.context.req.bodyCache.formData = formData
+        this.cx.req.bodyCache.formData = formData
       } catch (e) {
         throw new HTTPException(400, {
           message: 'Malformed FormData request.'
@@ -93,14 +87,14 @@ export default abstract class Action {
 
   async json<E>() {
     try {
-      return await this.context.req.json<E>()
+      return await this.cx.req.json<E>()
     } catch {
       throw new HTTPException(400, { message: 'Malformed JSON in request body' })
     }
   }
 
   async body<E>() {
-    const cType = this.context.req.header('Content-Type')
+    const cType = this.cx.req.header('Content-Type')
     if (!cType) return {} as E
 
     if (/^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType)) {
@@ -118,14 +112,21 @@ export default abstract class Action {
   }
 
   get response() {
-    return this.context ? JsonResponse.setContext(this.context) : JsonResponse
+    return JsonResponse
+  }
+
+  get cx() {
+    return JsonResponse.cx
+  }
+
+  get cookie() {
+    return JsonResponse.cookie
   }
 
   validate() {
     const rules = this.rules()
     const h = async (c: Context) => {
-      this.context = c
-      return await this.handle(c)
+      return await this.handle(this.cx)
     }
     if (!rules) return [h]
 
@@ -138,17 +139,22 @@ export default abstract class Action {
       }))
 
     rulesArray.push(h)
-
     return rulesArray
   }
 
+  run() {
+    return this.validate()
+  }
+
+  // PUBLIC API
+
   get auth() {
-    const auth = this.context.get('#auth')
+    const auth = this.cx.get('#auth')
     return auth ? auth?.data : null
   }
 
   can(...abilities: string[]): boolean {
-    const auth = this.context.get('#auth')
+    const auth = this.cx.get('#auth')
     return auth ? auth.can(...abilities) : false
   }
 
@@ -157,12 +163,12 @@ export default abstract class Action {
   }
 
   hasRole(...roles: string[]): boolean {
-    const auth = this.context.get('#auth')
+    const auth = this.cx.get('#auth')
     return auth ? auth.hasRole(...roles) : false
   }
 
-  run() {
-    return this.validate()
+  rules(): RuleDefinition[] | RuleDefinition | null {
+    return null
   }
 
   abstract handle(c: Context): Promise<Response>

package/src/create-app.ts

@@ -38,11 +38,6 @@ const EHandler = async (e: Error | HTTPResponseError) => {
       // @ts-ignore
       return response.badRequest(undefined, e?.message)
 
-    // case e.message.includes('Not Found'):
-    // // @ts-ignore
-    // case e?.status === 404:
-    //   return json.notFound();
-
     default:
       return response.internalError(
         // @ts-ignore
@@ -54,14 +49,11 @@ const EHandler = async (e: Error | HTTPResponseError) => {
                   if (!path) return match
 
                   const nodeModulesIndex = path.indexOf('node_modules')
-                  if (nodeModulesIndex > -1) {
+                  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
+                  const relativePath = path.startsWith(projectRoot) ? path.slice(projectRoot.length + 1) : path
                   return `${method || ''}(${relativePath})`
                 }
               ).trim()
@@ -77,7 +69,7 @@ const EHandler = async (e: Error | HTTPResponseError) => {
   //   e.message || 'Internal Error'
   // )
   // error: e.message,
-  // cause: e.cause || 'Desconhecido',
+  // cause: e.cause || '???',
   // stack: isDev ? e.stack : undefined
 }
 
@@ -85,16 +77,12 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
   // const root = options?.root ?? '/'
   const app = options?.app ?? new Hono<E>()
 
-  const middlewares = [
-    async (c: Context, next: Next) => {
-      response.setContext(c)
-      await next()
-    },
-    ...getMiddlewares()
-  ]
-  middlewares.forEach(mw => {
-    // @ts-ignore
-    const h = resolveMiddleware(mw)
+  app.use(async (c: Context, next: Next) => {
+    response.setContext(c)
+    await next()
+  })
+  getMiddlewares().forEach(mw => {
+    const h = async (c: Context, next: Next) => await resolveMiddleware(mw)(response.cx, next)
     // @ts-ignore
     mw?.path ? app.use(String(mw.path), h) : app.use(h)
   })
@@ -102,18 +90,16 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
   app.onError(options?.onError || EHandler)
   app.notFound(options?.notFound || NFHandler)
 
-  if (options?.init)
-    options.init(app)
+  if (options?.init) options.init(app)
 
   const routes = options?.routes || []
   for (const route of routes) {
     if (Array.isArray(route)) {
-      const handle = getHandler(route[3])
       // @ts-ignore
-      app[route[0]](route[1], ...mw(route[2], route[3]), ...resolve(handle))
+      app[route[0]](route[1], ...mw(route[2], route[3]), ...resolve(getHandler(route[3]), route[3]))
     } else {
       // @ts-ignore
-      app[route.method](route.path, ...mw(route.middlewares, route.name), ...resolve(route.handle))
+      app[route.method](route.path, ...mw(route.middlewares, route.name), ...resolve(route.handle, route.name))
     }
   }
 

package/src/register.ts

@@ -1,24 +1,13 @@
-export const handlers = {}
+export const handlers: Record<string, Function> = {}
 
 export function registerHandler(id: string, handler: any) {
-  if (typeof handler === 'function') {
-    // @ts-ignore
-    handlers[id] = handler
-  } else if (handler.prototype?.handle) {
-    const instance = new handler()
-    // @ts-ignore
-    handlers[id] = instance.handle.bind(instance)
-  } else if (handler.run) {
-    const instance = new handler()
-    // @ts-ignore
-    handlers[id] = instance.run.bind(instance)
-  } else {
-    console.warn(`Handler ${id} could not be registered - unsupported type`)
-  }
+  if (id in handlers)
+    console.warn(`Handler "${id}" has already been registered`)
+
+  handlers[id] = handler
 }
 
 export function getHandler(id: string): Function {
-  // @ts-ignore
   const handler = handlers[id] || null
   if (!handler) throw new Error(`Handler ${id} not registered`)
   return handler

package/src/response.ts

@@ -1,43 +1,39 @@
 import { Context } from 'hono'
-import { ContentfulStatusCode, StatusCode } from 'hono/utils/http-status'
-import { ErrorResponse, Errors, LambdaResponse, ResponseOrInit } from './types'
-import { InvalidJSONValue, JSONValue } from 'hono/utils/types'
-
-class NullContext {
-  resp = new Response('Context not found. Use JsonResponse.setContext() first.', { status: 500 })
-
-  newResponse(body?: any, init?: ResponseOrInit<StatusCode>): Response {
-    return this.resp
-  }
-  json(json: JSONValue | {} | InvalidJSONValue, status: ContentfulStatusCode = 500): Response {
-    return this.resp
-  }
-  // overide do hono context
-  // newResponse(body?: any, init?: ResponseOrInit<StatusCode>): Response {
-  //   return new Response(body ?? null, typeof init === 'number' ? {status: init} : init ?? {status: 500})
-  // }
-  // json(json: JSONValue | {} | InvalidJSONValue, status: ContentfulStatusCode = 500): Response {
-  //   return new Response(JSON.stringify(json), {
-  //     status,
-  //     headers: { 'Content-Type': 'application/json' }
-  //   })
-  // }
-}
+import type { ContentfulStatusCode, StatusCode } from 'hono/utils/http-status'
+import { ErrorResponse, Errors } from './types'
+import { getCookie, getSignedCookie, setCookie, setSignedCookie, deleteCookie } from 'hono/cookie'
+import type { CookieOptions, CookiePrefixOptions } from 'hono/utils/cookie'
+
+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 JsonResponse {
-  static #c?: Context
+  static #c: Context
+  static #cookie: ReturnType<typeof cookieWrapper>
 
   static setContext(c: Context) {
     this.#c = c
+    this.#cookie = cookieWrapper(c)
     return this
   }
 
-  static #context(): Context | NullContext {
-    return this.#c ?? new NullContext()
+  static get cx(): Context {
+    return this.#c
+  }
+
+  static get cookie() {
+    return this.#cookie
   }
 
   static raw(status?: StatusCode, body?: string) {
-    return this.#context().newResponse(body ? body : null, { status })
+    return this.cx.newResponse(body ? body : null, { status })
   }
 
   static ok(): Response
@@ -46,7 +42,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(200)
 
-    return this.#context().json(data, 200)
+    return this.cx.json(data, 200)
   }
 
   static created(): Response
@@ -55,7 +51,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(201)
 
-    return this.#context().json(data, 201)
+    return this.cx.json(data, 201)
   }
 
   static accepted(): Response
@@ -64,12 +60,10 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(202)
 
-    return this.#context().json(data, 202)
+    return this.cx.json(data, 202)
   }
 
-  static deleted(): Response
-  static deleted<T>(data: T): Response
-  static deleted<T>(data?: T) {
+  static deleted() {
     return this.noContent()
   }
 
@@ -88,7 +82,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(401)
 
-    return this.#context().json(data, 401)
+    return this.cx.json(data, 401)
   }
 
   static forbidden(): Response
@@ -97,7 +91,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(403)
 
-    return this.#context().json(data, 403)
+    return this.cx.json(data, 403)
   }
 
   static notFound(): Response
@@ -122,9 +116,7 @@ export default class JsonResponse {
   }
 
   static error(errors?: Errors, msg?: string, status?: ContentfulStatusCode) {
-    const context = this.#context()
     status ??= 500
-
     if (!errors && !msg)
       return this.raw(status, msg)
 
@@ -132,6 +124,6 @@ export default class JsonResponse {
     if (msg) resp.m = msg
     if (errors) resp.e = errors
 
-    return context.json(resp, status)
+    return this.cx.json(resp, status)
   }
 }

package/src/utils/resolve.ts

@@ -1,21 +1,21 @@
 import Action, { ActionType } from '../action'
 import { MiddlewareType } from '../middleware'
 
-export function resolve(obj: ActionType) {
+export function resolve(obj: ActionType, id: string) {
   if (typeof obj === 'function' && obj?.length === 2)
     return [obj]
 
-  if (obj instanceof Action)
+  if (obj?.run)
     return obj.run()
 
   const instance = new (obj as new () => Action)()
-  if (Action.isPrototypeOf(obj))
+  if (obj?.prototype?.run)
     return instance.run()
 
   if (obj?.prototype?.handle)
     return [instance.handle]
 
-  throw new Error('Invalid action')
+  throw new Error(`Invalid action "${id}" - unsupported type`)
 }
 
 export function resolveMiddleware(obj: MiddlewareType) {