rajt 0.0.0 → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present, ZUNQ.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="left">
+  <a href="https://npmjs.com/package/rajt"><img src="https://img.shields.io/npm/v/rajt.svg" alt="npm package"></a>
+  <a href="https://pr.new/attla/rajt"><img src="https://developer.stackblitz.com/img/start_pr_dark_small.svg" alt="Start new PR in StackBlitz Codeflow"></a>
+</p>
+<br/>
+
+# Rajt λ
+
+> This framework is fully geared towards the serverless world, specifically AWS Lambda (Node.js and LLRT) / Cloudflare Workers.
+
+- 💡 Instant Server Start
+- ⚡️ Fast Cold Start
+- 📦 Optimized Build
+
+[Read the Docs to Learn More](DOCS.md).
+
+## Packages
+
+| Package                                         | Version (click for changelogs)                                                                                                    |
+| ----------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
+| [rajt](https://github.com/attla/rajt)                           | [![rajt version](https://img.shields.io/npm/v/rajt.svg?label=%20)](https://github.com/attla/rajt/CHANGELOG.md)                                    |
+| [create-rajt](https://github.com/attla/create-rajt)             | [![create-rajt version](https://img.shields.io/npm/v/create-rajt.svg?label=%20)](https://github.com/attla/create-rajt/CHANGELOG.md)               |
+
+## License
+
+This package is licensed under the [MIT license](LICENSE) © [Zunq](https://zunq.com).

package/package.json

@@ -1 +1,45 @@
-{"name":"rajt","version":"0.0.0"}
+{
+  "name": "rajt",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./src/index.ts",
+    "./http": "./src/http.ts",
+    "./types": "./src/types.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "sam": "sam local start-api --warm-containers LAZY --debug",
+    "dev": "tsx watch src/dev.ts",
+    "prod": "bun run build && bun run sam",
+    "build": "bun run cache:routes && bun run export && bun run clean:temp",
+    "build:watch": "chokidar \"{actions,src,models,utils,configs}/**/*.ts\" -c \"bun run build\" --initial",
+    "export": "esbuild --bundle --minify --outfile=dist/index.js --platform=node --target=node20 --format=esm --tree-shaking=true --legal-comments=none src/prod.ts",
+    "cache:routes": "tsx src/scripts/cache-routes.ts",
+    "ensure-dirs": "rm -rf dist tmp && mkdir -p ./tmp && chmod 755 ./tmp && mkdir -p ./dist && chmod 755 ./dist",
+    "clean": "rm -rf dist tmp",
+    "clean:build": "rm -rf dist",
+    "clean:temp": "rm -rf tmp",
+    "zip": "zip -j lambda.zip dist/index.js",
+    "update": "aws lambda update-function-code --zip-file fileb://lambda.zip --function-name hello",
+    "deploy": "run-s build zip update",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@hono/zod-validator": "^0.4.3",
+    "dotenv": "^16.5.0",
+    "hono": "^4.7.6"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^1.14.1",
+    "@types/node": "^20.11.0",
+    "chokidar-cli": "^3.0.0",
+    "esbuild": "^0.25.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
+  }
+}

package/src/action.ts

@@ -0,0 +1,151 @@
+import { Context, Handler, HonoRequest, MiddlewareHandler, Next, ValidationTargets } from 'hono'
+import { z, ZodObject, ZodRawShape } from 'zod'
+import { zValidator } from '@hono/zod-validator'
+// import { JSONValue } from 'hono/utils/types'
+import json from './response'
+import JsonResponse from './response'
+import { bufferToFormData } from 'hono/utils/buffer'
+import { HTTPException } from 'hono/http-exception'
+import { BodyData } from 'hono/utils/body'
+
+export type ActionType = Function | Handler | Action | (new () => Action)
+
+type RuleDefinition = {
+  schema: z.ZodObject<any>
+  target: keyof ValidationTargets
+  eTarget?: 'fieldErrors' | 'formErrors'
+}
+
+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
+
+  public rule<T extends keyof ValidationTargets>(target: T, schema?: ZodObject<any>):
+    | { schema: (schema: ZodObject<any>) => RuleDefinition }
+    | RuleDefinition
+  {
+    if (schema !== undefined) {
+      return {
+        target,
+        schema,
+        eTarget: 'fieldErrors' // | 'formErrors'
+      } satisfies RuleDefinition
+    }
+
+    return {
+      schema: (schema: ZodObject<any>) => ({
+        target,
+        schema,
+        eTarget: 'fieldErrors' // | 'formErrors'
+      })
+    }
+  }
+
+  public param(key: string) {
+    return this.context.req.param(key)
+  }
+
+  public query() {
+    return this.context.req.query()
+  }
+
+  public async form(cType?: string) {
+    cType ??= this.context.req.header('Content-Type')
+    if (!cType) return {}
+
+    let formData: FormData
+
+    if (this.context.req.bodyCache.formData) {
+      formData = await this.context.req.bodyCache.formData
+    } else {
+      try {
+        const arrayBuffer = await this.context.req.arrayBuffer()
+        formData = await bufferToFormData(arrayBuffer, cType)
+        this.context.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
+  }
+
+  public async json<E>() {
+    try {
+      return await this.context.req.json<E>()
+    } catch {
+      throw new HTTPException(400, { message: 'Malformed JSON in request body' })
+    }
+  }
+
+  public async body<E>() {
+    const cType = this.context.req.header('Content-Type')
+    if (!cType) return {}
+
+    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)
+    ) {
+        return await this.form() as E
+    }
+
+    return {}
+  }
+
+  public get response() {
+    return this.context ? JsonResponse.setContext(this.context) : JsonResponse
+  }
+
+  public validate() {
+    const rules = this.rules()
+    const h = async (c: Context) => {
+      this.context = c
+      return await this.handle(c)
+    }
+    if (!rules) return [h]
+
+    const rulesArray = (Array.isArray(rules) ? rules : [rules])
+      .map(rule => zValidator(rule.target, rule.schema, (result, c) => {
+        if (!result.success) {
+          // @ts-ignore
+          return json.badRequest({ ...result.error.flatten()[rule.eTarget] })
+        }
+      }))
+
+    rulesArray.push(h)
+
+    return rulesArray
+  }
+
+  public run() {
+    return this.validate()
+  }
+
+  abstract handle(c: Context): Promise<Response>
+}

package/src/create-app.ts

@@ -0,0 +1,124 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Hono } from 'hono'
+import type { Env, Context, ErrorHandler, NotFoundHandler, Next } from 'hono'
+// import type { Env, Context, ErrorHandler, MiddlewareHandler, NotFoundHandler, Next } from 'hono'
+// import { createMiddleware } from 'hono/factory'
+// import type { H, Handler, HandlerResponse } from 'hono/types'
+import { HTTPResponseError } from 'hono/types'
+import { Routes } from './types'
+import { BadRequest, Unauthorized } from './exceptions'
+import response from './response'
+import resolve from './utils/resolve'
+import { getHandler } from './register'
+import env from './utils/environment'
+
+type InitFunction<E extends Env = Env> = (app: Hono<E>) => void
+
+export type ServerOptions<E extends Env = Env> = Partial<{
+  routes: Routes,
+  notFound: NotFoundHandler<E>,
+  onError: ErrorHandler<E>,
+  root: string,
+  app?: Hono<E>,
+  init?: InitFunction<E>,
+}>
+
+const isDev = env() === 'dev'
+const NFHandler = () => response.notFound()
+const EHandler = async (e: Error | HTTPResponseError) => {
+  console.error(e)
+
+  switch (true) {
+    case e instanceof Unauthorized:
+    case 'status' in e && e.status === 401:
+      return response.unauthorized()
+
+    case e instanceof BadRequest:
+    case 'status' in e && e.status === 400:
+      // @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
+        isDev
+          ? e.stack?.split('\n').map(line =>
+              line.replace(
+                /at (.+ )?\(?([^)]+)\)?/g,
+                (match, method, path) => {
+                  if (!path) return match
+
+                  const nodeModulesIndex = path.indexOf('node_modules')
+                  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
+                  return `${method || ''}(${relativePath})`
+                }
+              ).trim()
+            )
+          : undefined,
+        e.message || 'Internal Error'
+      )
+  }
+
+  // return json.internalError(
+  //   // @ts-ignore
+  //   isDev ? e.stack?.split('\n    at ').map() : undefined,
+  //   e.message || 'Internal Error'
+  // )
+  // error: e.message,
+  // cause: e.cause || 'Desconhecido',
+  // stack: isDev ? e.stack : undefined
+}
+
+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()
+    },
+  ]
+  middlewares.forEach(middleware => app.use(middleware))
+
+  app.onError(options?.onError || EHandler)
+  app.notFound(options?.notFound || NFHandler)
+
+  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))
+    } else {
+      // @ts-ignore
+      app[route.method](route.path, ...mw(route.middlewares, route.name), ...resolve(route.handle))
+    }
+  }
+
+  return app
+}
+
+function mw(...objs: string[]): Function[] {
+  return objs.flatMap(obj => {
+    // @ts-ignore
+    return getHandler(obj)?.mw || null
+  }).flat().filter(Boolean)
+}
+
+export default createApp

package/src/dev.ts

@@ -0,0 +1,22 @@
+import { config } from 'dotenv'
+import { serve } from '@hono/node-server'
+import createApp from './create-app'
+import getRoutes from './routes'
+import { getAvailablePort } from './utils/port'
+
+config({ path: '.env.dev' })
+
+const routes = await getRoutes()
+const fetch = createApp({ routes }).fetch
+
+const desiredPort = process.env?.PORT ? Number(process.env.PORT) : 3000
+getAvailablePort(desiredPort)
+  .then(port => {
+    if (port != desiredPort)
+      console.log(`🟨 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)
+  })

package/src/exceptions.ts

@@ -0,0 +1,15 @@
+export class Unauthorized extends Error {
+  status = 401
+  constructor(message = 'Unauthorized') {
+    super(message)
+    this.name = 'UnauthorizedError'
+  }
+}
+
+export class BadRequest extends Error {
+  status = 400
+  constructor(message = 'Bad Request') {
+    super(message)
+    this.name = 'BadRequestError'
+  }
+}

package/src/http.ts

@@ -0,0 +1,57 @@
+import type { MiddlewareHandler } from 'hono'
+import BaseMiddleware, { MiddlewareType } from './middleware'
+
+function method(method: string, path = '/') {
+  return function (target: any) {
+    target.m = method
+    target.p = path
+    target.mw = []
+  }
+}
+
+export function Get(path = '/') {
+  return method('get', path)
+}
+
+export function Post(path = '/') {
+  return method('post', path)
+}
+
+export function Put(path = '/') {
+  return method('put', path)
+}
+
+export function Patch(path = '/') {
+  return method('patch', path)
+}
+
+export function Delete(path = '/') {
+  return method('delete', path)
+}
+
+export function Middleware(...handlers: MiddlewareType[]) {
+  return function (target: any) {
+    const middlewareHandlers = handlers.map(handler => {
+      if (typeof handler === 'function' && handler.length === 2)
+        return handler
+
+      if (handler instanceof BaseMiddleware)
+        return handler.handle
+
+      if (BaseMiddleware.isPrototypeOf(handler)) {
+        const instance = new (handler as new () => BaseMiddleware)()
+        return instance.handle
+      }
+
+      throw new Error('Invalid middleware provided. Must be a Hono middleware function or MiddlewareClass instance/constructor')
+    })
+
+    const existingMiddlewares: MiddlewareHandler[] = target?.mw || []
+    const allMiddlewares = [...existingMiddlewares, ...middlewareHandlers]
+
+    target.mw = allMiddlewares
+  }
+}
+export function Middlewares(...handlers: MiddlewareType[]) {
+  return Middleware(...handlers)
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { default as Action } from './action'
+export { default as Middleware } from './middleware'
+export { default as JsonResponse } from './response'

package/src/middleware.ts

@@ -0,0 +1,12 @@
+import type { Context, MiddlewareHandler, Next } from 'hono'
+
+export type IMiddleware = {
+  handle(c: Context, next: Next): Promise<void> | void
+}
+
+export default abstract class Middleware implements IMiddleware {
+  public abstract handle(c: Context, next: Next): Promise<void> | void
+}
+
+// export type MiddlewareHandler = (c: Context, next: Next) => Promise<void> | void
+export type MiddlewareType = MiddlewareHandler | Middleware | (new () => Middleware)

package/src/prod.ts

@@ -0,0 +1,16 @@
+import { config } from 'dotenv'
+import { handle } from 'hono/aws-lambda'
+import createApp from './create-app'
+
+config({ path: '.env.prod' })
+
+// @ts-ignore
+await import('../tmp/import-routes.mjs')
+
+// @ts-ignore
+const routes = (await import('../tmp/routes.json')).default
+// @ts-ignore
+const app = createApp({ routes })
+
+// export default app // AWS Lambda & Cloudflare Workers
+export const handler = handle(app) // AWS Lambda (LLRT)

package/src/register.ts

@@ -0,0 +1,25 @@
+export const handlers = {}
+
+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`)
+  }
+}
+
+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

@@ -0,0 +1,137 @@
+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' }
+  //   })
+  // }
+}
+
+export default class JsonResponse {
+  private static _c?: Context
+
+  static setContext(c: Context) {
+    this._c = c
+    return this
+  }
+
+  private static context(): Context | NullContext {
+    return this._c ?? new NullContext()
+  }
+
+  static raw(status?: StatusCode, body?: string) {
+    return this.context().newResponse(body ? body : null, { status })
+  }
+
+  static ok(): Response
+  static ok<T>(data: T): Response
+  static ok<T>(data?: T) {
+    if (data === undefined)
+      return this.raw(200)
+
+    return this.context().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 this.context().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 this.context().json(data, 202)
+  }
+
+  static deleted(): Response
+  static deleted<T>(data: T): Response
+  static deleted<T>(data?: T) {
+    return this.noContent()
+  }
+
+  static noContent() {
+    return this.raw(204)
+  }
+
+  static badRequest(): Response
+  static badRequest(errors?: Errors, msg?: string) {
+    return this.error(errors, msg, 400)
+  }
+
+  static unauthorized(): Response
+  static unauthorized<T>(data: T): Response
+  static unauthorized<T>(data?: T) {
+    if (data === undefined)
+      return this.raw(401)
+
+    return this.context().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 this.context().json(data, 403)
+  }
+
+  static notFound(): Response
+  static notFound(msg: string): Response
+  static notFound(msg?: string) {
+    return this.raw(404, msg)
+  }
+
+  static conflict(): Response
+  static conflict(errors?: Errors, msg?: string) {
+    return this.error(errors, msg, 409)
+  }
+
+  static unsupportedMediaType(): Response
+  static unsupportedMediaType(errors?: Errors, msg?: string) {
+    return this.error(errors, msg, 415)
+  }
+
+  static internalError(): Response
+  static internalError(errors?: Errors, msg?: string) {
+    return this.error(errors, msg, 500)
+  }
+
+  static error(errors?: Errors, msg?: string, status?: ContentfulStatusCode) {
+    const context = this.context()
+    status ??= 500
+
+    if (!errors && !msg)
+      return this.raw(status, msg)
+
+    const resp: ErrorResponse = {}
+    if (msg) resp.m = msg
+    if (errors) resp.e = errors
+
+    return context.json(resp, status)
+  }
+}

package/src/routes.ts

@@ -0,0 +1,63 @@
+import fs from 'node:fs'
+import path, { relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Route } from './types'
+import { registerHandler } from './register'
+import { isAnonFn } from './utils/func'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default async function getRoutes(all: boolean = false, baseDir: string = 'actions'): Promise<Route[]> {
+  const routes: Route[] = []
+
+  const walk = async (dir: string, middlewares: Function[] = []): Promise<void> => {
+    const files = fs.readdirSync(dir)
+
+    for (const file of files) {
+      const fullPath = path.join(dir, file)
+      const stat = fs.statSync(fullPath)
+
+      if (stat.isDirectory()) {
+        const indexFile = path.join(fullPath, 'index.ts')
+
+        if (fs.existsSync(indexFile)) {
+          const mod = await import(indexFile)
+          const group = mod.default
+          registerHandler(group.name, group)
+          !isAnonFn(group) && middlewares.push(group.name)
+
+          all && routes.push({
+            method: '',
+            path: '',
+            name: group.name.replace(/\.ts$/, ''),
+            file: relative(process.cwd(), indexFile),
+            middlewares,
+            handle: group,
+          })
+        }
+
+        await walk(fullPath, middlewares)
+      } else if (file.endsWith('.ts')) {
+        const mod = await import(fullPath)
+        const handle = mod.default
+
+        if (handle?.m) {
+          registerHandler(handle.name, handle)
+
+          routes.push({
+            method: handle.m.toLowerCase(),
+            path: handle.p,
+            name: handle.name.replace(/\.ts$/, ''),
+            file: relative(process.cwd(), fullPath),
+            middlewares,
+            handle,
+          })
+        }
+      }
+    }
+  }
+
+  await walk(path.resolve(__dirname, '..', baseDir))
+  return routes
+}

package/src/scripts/cache-routes.ts

@@ -0,0 +1,49 @@
+import { writeFileSync } from 'node:fs'
+import getRoutes from '../routes'
+import ensureDir from '../utils/ensuredir'
+
+async function cacheRoutes() {
+  const routes = await getRoutes(true)
+
+  const iPath = './tmp/import-routes.mjs'
+  ensureDir(iPath)
+  writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
+import { registerHandler } from '../src/register'
+
+${routes.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)
+    }
+  }
+} catch (error) {
+  console.error('Failed to register handlers:', error)
+}
+`)
+
+  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, '')
+}
+
+cacheRoutes()
+  .then(() => {
+    console.log('✅ Routes cached!')
+    process.exit(0)
+  }).catch(e => {
+    console.error('❌ Error: ', e)
+    process.exit(1)
+  })

package/src/types.ts

@@ -0,0 +1,54 @@
+import { Handler } from 'hono'
+import { ResponseHeader } from 'hono/utils/headers'
+import { StatusCode } from 'hono/utils/http-status'
+import { BaseMime } from 'hono/utils/mime'
+import Action from './action'
+
+export type Route = {
+  method: string,
+  path: string,
+  name: string,
+  file: string,
+  middlewares: Function[],
+  handle: Handlers,
+}
+
+export type Handlers = (Function | Handler | (new () => Action))[]
+
+export type Routes = Route[]
+
+export type LambdaResponse = {
+  statusCode: StatusCode,
+  body: string,
+}
+
+export type Errors = Record<string, string | string[]>
+export type ErrorResponse = {
+  m?: string, // message
+  // c?: number, // http code
+  e?: Errors, // error bag
+  // e?: Record<string, string | string[]>, // error bag
+}
+
+// export type Response<E> = E | ErrorResponse
+
+export type ResponseHeadersInit = [
+    string,
+    string
+][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers
+export type ResponseInit<T extends StatusCode = StatusCode> = {
+    headers?: ResponseHeadersInit,
+    status?: T,
+    statusText?: string,
+}
+export type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response
+// export type JSONValue =
+//   | string
+//   | number
+//   | boolean
+//   | null
+//   | { [key: string]: JSONValue }
+//   | JSONValue[]
+
+
+export type { Context, Next } from 'hono'

package/src/utils/ensuredir.ts

@@ -0,0 +1,7 @@
+import { mkdirSync, existsSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export default function ensureDirectoryExists(filePath: string) {
+  const dir = dirname(filePath)
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+}

package/src/utils/environment.ts

@@ -0,0 +1,22 @@
+export default function getEnvironment() {
+  if (process.env?.npm_lifecycle_event === 'dev')
+    return 'dev'
+
+  if (
+    process.argv?.includes('--dev')
+    || process.execArgv?.includes('--watch')
+    || import.meta.url?.includes('localhost')
+  )
+    return 'dev'
+
+  // @ts-ignore
+  if (typeof Bun === 'undefined') return 'prod'
+
+  // @ts-ignore
+  if (Bun.argv.includes('--prod')) return 'prod'
+  // @ts-ignore
+  if (Bun.argv.includes('--dev') || Bun.main.endsWith('.ts')) return 'dev'
+
+
+  return 'prod'
+}

package/src/utils/func.ts

@@ -0,0 +1,8 @@
+export const isAsyncFn = (fn: any) => {
+  return fn?.constructor?.name === 'AsyncFunction'
+    || fn.toString().toLowerCase().trim().startsWith('async')
+}
+
+export const isAnonFn = (fn: any) => {
+    return fn?.name === '' || fn?.name === 'anonymous'
+}

package/src/utils/port.ts

@@ -0,0 +1,30 @@
+import net from 'node:net'
+
+export async function isPortInUse(port: number) {
+  return new Promise(resolve => {
+    const server = net.createServer()
+      .once('error', () => resolve(true))
+      .once('listening', () => {
+        server.close(() => resolve(false))
+      })
+      .listen(port)
+  })
+}
+
+export async function getAvailablePort(startPort: number, maxAttempts = 100) {
+  let port = startPort
+  let attempts = 0
+
+  while (attempts < maxAttempts) {
+    const inUse = await isPortInUse(port)
+
+    if (!inUse) {
+      return port
+    }
+
+    port++
+    attempts++
+  }
+
+  throw new Error(`No available ports found after ${maxAttempts} attempts`)
+}

package/src/utils/resolve.ts

@@ -0,0 +1,56 @@
+import Action, { ActionType } from '../action'
+// import BaseMiddleware, { MiddlewareType } from '../middleware'
+
+export default function resolve(obj: ActionType) {
+  if (typeof obj === 'function' && obj?.length === 2)
+    return [obj]
+
+  if (obj instanceof Action)
+    return obj.run()
+
+  const instance = new (obj as new () => Action)()
+  if (Action.isPrototypeOf(obj))
+    return instance.run()
+
+  if (obj?.prototype?.handle)
+    return [instance.handle]
+
+  throw new Error('Invalid action')
+}
+
+// export function resolveMiddleware(obj: MiddlewareType) {
+//   if (typeof obj === 'function' && obj.length === 2)
+//     return obj
+
+//   if (obj instanceof BaseMiddleware)
+//     return obj.handle
+
+//   if (BaseMiddleware.isPrototypeOf(obj)) {
+//     const instance = new (obj as new () => BaseMiddleware)()
+//     return instance.handle
+//   }
+
+//   throw new Error('Invalid middleware provided. Must be a Hono middleware function or MiddlewareClass instance/constructor')
+// }
+
+// // import Action, { ActionType } from '../action'
+
+// export default function resolve(obj: any) {
+//   if (typeof obj === 'function' && obj?.length === 2)
+//     return [obj]
+
+//   // if (obj instanceof Action)
+//   //   return obj.run()
+
+//   // const instance = new (obj as new () => Action)()
+//   // @ts-ignore
+//   const instance = new obj()
+//   // if (Action.isPrototypeOf(obj))
+//   if (obj?.prototype?.run)
+//     return instance.run()
+
+//   if (obj?.prototype?.handle)
+//     return [instance.handle]
+
+//   throw new Error('Invalid action')
+// }