rajt 0.0.98 → 0.0.100

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.98",
+  "version": "0.0.100",
   "type": "module",
   "main": "./src/index.ts",
   "files": ["bin", "src"],
@@ -37,27 +37,28 @@
   "dependencies": {
     "@hono/node-server": "^1.19.9",
     "@hono/standard-validator": "^0.2.2",
+    "@hono/zod-validator": "^0.7.6",
     "@scalar/hono-api-reference": "^0.9.40",
     "chokidar": "^3.5.2",
     "citty": "^0.1.6",
     "consola": "^3.4.2",
-    "cripta": "~0.1.10",
+    "cripta": "^0.1.11",
     "dotenv": "^16.5.0",
     "esbuild": "^0.25.2",
-    "forj": "~0.1.8",
+    "forj": "^0.1.8",
     "hono": "^4.11.7",
-    "hono-openapi": "^1.2.0",
+    "hono-openapi": "^1.3.0",
     "localflare-api": "^0.4.2",
     "localflare-core": "^0.4.2",
     "miniflare": "^4.20260301.1",
     "pathe": "^2.0",
     "quansync": "^0.2.11",
-    "t0n": "~0.1.11",
+    "t0n": "^0.1.12",
     "tiny-glob": "^0.2",
     "tsx": "^4.19.4",
     "wrangler": "^4.61.0",
     "zod": "^4.3.6",
-    "zod-openapi": "4"
+    "zod-openapi": "^5.4.6"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20260113.0",
@@ -70,7 +71,8 @@
     "node": ">=18.0.0"
   },
   "resolutions": {
-    "@smithy/types": "^4.3.0"
+    "@smithy/types": "^4.3.0",
+    "zod": "^4.3.6"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/src/auth/ability.ts

@@ -19,7 +19,7 @@ export class Ability {
   }
 
   static fromAction(target: any): string {
-    return !target ? '' : this.format(target.name.length > 3 ? target.name : (target?.p || ''))
+    return !target ? '' : this.format(typeof target == 'string' ? target : (target.name.length > 3 ? target.name : (target?.p || '')))
   }
 
   static format(path: string) {

package/src/auth/index.ts

@@ -1,5 +1,6 @@
 export { Ability } from './ability'
 export { Authnz } from './authnz'
 export { Token } from './token'
+export { Autorized } from './middlewares'
 
 export * from './types'

package/src/auth/middlewares.ts

@@ -0,0 +1,23 @@
+import { Ability } from './ability'
+import response from '../response'
+import { GET_REQUEST } from '../request'
+import Config from '../config'
+import { verbAlias } from '../http'
+import type {
+  Context, Next,
+  IRequest,
+} from '../types'
+
+export async function Autorized(c: Context, next: Next) {
+  const req = c.get(GET_REQUEST as unknown as string) as IRequest
+  const ability = Ability.fromAction(Config.get(`routes.${req.routePath}$`+ verbAlias[req.method.toLowerCase()]))
+
+  if (!req?.user || !ability || req.cant(ability))
+    return response.unauthorized()
+
+  await next()
+}
+
+// export function Unautorized() {
+
+// }

package/src/cli/commands/dev.ts

@@ -3,6 +3,7 @@ import { spawn, type ChildProcess } from 'node:child_process'
 
 import { defineCommand } from 'citty'
 import type { Miniflare } from 'miniflare'
+import type { WranglerConfig } from 'localflare-core'
 import {
 	build, wait, watch, normalizePlatform, platformError, getRuntime,
 	wranglerConfig, createMiniflare, localflareManifest,
@@ -161,21 +162,12 @@ export default defineCommand({
 				})
 			case 'cf':
 				return withPort(desiredPort, async (port) => {
-					started(port)
-					let worker: Miniflare | null = null
-					let localflare: Miniflare | null = null
-					const startWorker = async () => {
-						if (worker) await worker.dispose()
-            if (localflare) await localflare.dispose()
+          started(port)
 
-            // await wait(500)
+          let localflare: Miniflare | null = null
+          const startLocalflare = async (workerConfig: WranglerConfig) => {
+            if (localflare) return
 
-						const workerConfig = await wranglerConfig()
-						workerConfig.host = host
-						workerConfig.liveReload = false
-
-						worker = createMiniflare({ ...workerConfig, port })
-						await worker.ready
 						localflare = createMiniflare({
 							...workerConfig,
 							vars: {
@@ -185,8 +177,23 @@ export default defineCommand({
 							main: '.rajt/localfire.js',
 							port: 8788,
 							inspectorPort: 9230,
-						})
+            })
+
 						await localflare.ready
+          }
+
+					let worker: Miniflare | null = null
+					const startWorker = async () => {
+						if (worker) await worker.dispose()
+
+						const workerConfig = await wranglerConfig() // @ts-ignore
+						workerConfig.host = host // @ts-ignore
+						workerConfig.liveReload = false
+
+						worker = createMiniflare({ ...workerConfig, port })
+            await worker.ready
+
+            if (!localflare) await startLocalflare(workerConfig)
 					}
 
 					await startApp(startWorker)

package/src/cli/commands/migrate.ts

@@ -31,7 +31,7 @@ export default defineCommand({
 		try {
 			const migrations = await Migrator.dir(database).queue()
 			const pending = migrations.pending
-			const migrated = migrations.migrated
+      const migrated = migrations.migrated
 
 			switch (action) {
 				case 'migrate':

package/src/cli/utils.ts

@@ -1,3 +1,4 @@
+import ts from 'typescript'
 import esbuild from 'esbuild'
 import { Miniflare } from 'miniflare'
 import { mkdirSync, existsSync, statSync, readdirSync, rmSync, unlinkSync, copyFileSync, writeFileSync } from 'node:fs'
@@ -69,6 +70,52 @@ const nodeModules = [
   'async_hooks', 'console', 'fsevents',
 ].flatMap(lib => ['node:'+ lib, lib])
 
+const printer = ts.createPrinter()
+function stripDecorators(source: string) {
+  const sourceFile = ts.createSourceFile(
+    'tmp.ts', source, ts.ScriptTarget.ESNext, false
+  )
+
+  const transformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
+    const visit: ts.Visitor = (node) => {
+      if (ts.isClassDeclaration(node) && node.modifiers?.length) {
+        let hasDecorator = false
+        const modifiers = []
+
+        for (const m of node.modifiers) {
+          if (m.kind === ts.SyntaxKind.Decorator) {
+            hasDecorator = true
+            continue
+          }
+          modifiers.push(m)
+        }
+
+        if (hasDecorator) {
+          return ts.factory.updateClassDeclaration(
+            node,
+            modifiers.length ? modifiers : undefined,
+            node.name,
+            node.typeParameters,
+            node.heritageClauses,
+            node.members
+          )
+        }
+      }
+
+      return ts.visitEachChild(node, visit, context)
+    }
+
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile
+  }
+
+  const result = ts.transform(sourceFile, [transformer])
+  const code = printer.printFile(result.transformed[0])
+
+  result.dispose()
+
+  return code
+}
+
 const dist = '.rajt/dist'
 export const build = async (platform: Platform) => {
   const startTime = Date.now()
@@ -86,6 +133,10 @@ export const build = async (platform: Platform) => {
 
   if (['bun', 'vercel'].includes(platform)) platform = 'cf'
 
+  const USE_STRICT_RE = /(["'`])\s*use strict\s*\1;?/g
+  const decoder = new TextDecoder()
+  const encoder = new TextEncoder()
+
   // @ts-ignore
   platform = platform != 'node' ? '-'+ platform : ''
   const opts = {
@@ -112,54 +163,45 @@ export const build = async (platform: Platform) => {
     // define: {
     //   'process.env.NODE_ENV': '"development"'
     // },
-    // loader: {
-    //   '.ts': 'ts',
-    //   '.js': 'js'
-    // },
     // tsconfig: join(_root, 'tsconfig.json'),
     // sourcemap: true,
     // logLevel: 'info',
     plugins: [
       {
-        name: 'rajt-resolver',
+        name: 'rajt',
         setup(build) {
           build.onResolve({ filter: /\.rajt[\/\\]/ }, args => ({ path: join(_root, args.path) }))
-        }
-      },
-      {
-        name: 'preserve-class-names',
-        setup(build) {
-          build.onLoad(
-            { filter: /(actions|features|routes)\/.*\.ts$/ },
-            async (args) => {
-              const contents = await readFile(args.path, 'utf8')
-              const result = await esbuild.transform(contents, {
-                loader: 'ts',
-                minify: true,
-                keepNames: true
-              })
-              return { contents: result.code, loader: 'ts' }
-            }
-          )
-        },
-      },
-      {
-        name: 'remove-use-strict',
-        setup(build) {
+
+          // strip decorators
+          build.onLoad({ filter: /\.ts$/ }, async (args) => {
+            const source = await readFile(args.path, 'utf8')
+            return { contents: stripDecorators(source), loader: 'ts' }
+          })
+
+          // remove "use strict"
+          const write = build.initialOptions.write
           build.onEnd(async (result) => {
-            if (!result.outputFiles) return
-
-            const files = result.outputFiles.filter(file => file.path.endsWith('.js'))
-            await Promise.all(files.map(async file => {
-              if (!file.path.endsWith('.js')) return
-
-              await writeFile(
-                file.path,
-                new TextDecoder()
-                  .decode(file.contents)
-                  .replace(/(["'`])\s*use strict\s*\1;?|`use strict`;?/g, '')
-              )
-            }))
+            const files = result.outputFiles
+            if (!files) return
+
+            const tasks: Promise<void>[] = []
+
+            for (const file of files) {
+              if (!file.path.endsWith('.js')) continue
+
+              let code = decoder.decode(file.contents)
+
+              if (USE_STRICT_RE.test(code))
+                code = code.replace(USE_STRICT_RE, '')
+
+              if (write) {
+                file.contents = encoder.encode(code)
+              } else {
+                tasks.push(writeFile(file.path, code))
+              }
+            }
+
+            if (tasks.length) await Promise.all(tasks)
           })
         }
       },

package/src/create-app.ts

@@ -1,7 +1,6 @@
 import { Hono } from 'hono'
 import { logger } from 'hono/logger'
 import { matchedRoutes } from 'hono/route'
-import { describeRoute } from 'hono-openapi'
 import { Envir, Datte } from 't0n'
 import type {
   Env, Context, Next,
@@ -9,11 +8,13 @@ import type {
   ServerOptions,
 } from './types'
 import { resolve, resolveMiddleware } from './utils/resolve'
-import { getMiddlewares, getHandler } from './register'
+import { getMiddlewares } from './register'
 import request, { GET_REQUEST } from './request'
 import response from './response'
 import { isDev } from './utils/environment'
 import { gray } from 't0n/color'
+import { Route } from './types'
+import { getVerb } from './http'
 
 const NFHandler = () => response.notFound()
 const EHandler = async (e: Error | HTTPResponseError) => {
@@ -96,11 +97,14 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
     if (c.env) Envir.add(c.env)
     await next()
   })
-  getMiddlewares().forEach(mw => {
+
+  const middlewares = getMiddlewares()
+  for (const mw of middlewares) {
     const h = async (c: Context, next: Next) => await resolveMiddleware(mw)(c.get(GET_REQUEST as unknown as string), next)
     // @ts-ignore
     mw?.path ? app.use(String(mw.path), h) : app.use(h)
-  })
+  }
+
   // @ts-ignore
   app.onError(options?.onError || EHandler)
   // @ts-ignore
@@ -108,24 +112,19 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
 
   if (options?.init) options.init(app)
 
-  const routes = options?.routes || []
-  for (const route of routes) {
+  const routes = options?.routes || [] // @ts-ignore
+  const routeRegister = options?.routeRegister ? options.routeRegister : (_: Hono, route: Route) => { // @ts0ignore
     if (Array.isArray(route)) { // @ts-ignore
-      app[route[0]](route[1], ...mw(route[2], route[3]), ...resolve(getHandler(route[3]), route[3]))
+      _[getVerb[route[0]]](route[1], ...resolve(...route[2], route[3]))
     } else { // @ts-ignore
-      app[route.method](route.path, describeRoute(route.desc), ...mw(route.middlewares, route.name), ...resolve(route.handle, route.name))
+      _[route.method](route.path, ...resolve(...route.middlewares), route.handle)
     }
   }
 
-  return app
-}
+  for (const route of routes)
+    routeRegister(app, route)
 
-function mw(...objs: string[]): Function[] {
-  return objs.flatMap(obj => {
-    if (typeof obj != 'string') return null
-    // @ts-ignore
-    return getHandler(obj)?.mw || null
-  }).flat().filter(Boolean)
+  return app
 }
 
 export default createApp

package/src/dev.ts

@@ -3,16 +3,15 @@ import { config } from 'dotenv'
 import { getRoutes, getMiddlewares, getConfigs } from './routes'
 import { registerHandler, registerMiddleware } from './register'
 import Config from './config'
-import { registerOpenAPI } from './oas'
+import { registerOpenAPI } from './open-api/register'
 import createApp from './create-app'
 import { Ability } from 'rajt/auth'
 import { setEnv, detectEnvironment } from 'rajt/env'
+import { _root } from './utils/paths'
 
 setEnv(detectEnvironment())
 
-const __dirname = join(dirname(new URL(import.meta.url).pathname), '../../../')
-
-config({ path: join(__dirname, '.env.dev') })
+config({ path: join(_root, '.env.dev') })
 
 Config.add(await getConfigs())
 

package/src/http.ts

@@ -1,14 +1,33 @@
-import { MiddlewareType } from './middleware'
-import response from './response'
-import { GET_REQUEST } from './request'
-import { Ability } from './auth'
-import mergeMiddleware from './utils/merge-middleware'
+import { Autorized } from './auth'
+import { type MiddlewareType, mergeMiddleware } from './middleware'
 import type {
-  Context, Next,
-  IRequest,
   DescribeRouteOptions,
 } from './types'
 
+export const verbAlias = {
+  get: 0,
+  post: 1,
+  put: 2,
+  patch: 3,
+  delete: 4,
+  head: 5,
+  options: 6,
+  connect: 7,
+  trace: 8,
+} as Record<string, number>
+
+export const getVerb = [
+  'get',
+  'post',
+  'put',
+  'patch',
+  'delete',
+  'head',
+  'options',
+  'connect',
+  'trace',
+]
+
 function method(method: string, ...args: any[]): void | ClassDecorator {
   if (args.length == 1 && typeof args[0] == 'function')
     return _method(method, '/', args[0])
@@ -112,15 +131,7 @@ function _auth(target: Function | any) {
   if (!target.d?.responses) target.d.responses = {}
   target.d.responses[401] = {description: 'Unauthorized'}
 
-  mergeMiddleware(target, async (c: Context, next: Next) => {
-    const req = c.get(GET_REQUEST as unknown as string) as IRequest
-    const ability = Ability.fromAction(target)
-
-    if (!req?.user || !ability || req.cant(ability))
-      return response.unauthorized()
-
-    await next()
-  })
+  mergeMiddleware(target, Autorized)
 }
 
 function _describe(spec: DescribeRouteOptions): ClassDecorator{

package/src/middleware.ts

@@ -15,3 +15,7 @@ export class Middleware {
 }
 
 export const toHonoMiddleware = (mw: MiddlewareHandler) => async (req: IRequest, next: Next) => await mw(req.cx, next)
+
+export function mergeMiddleware(target: Function | any, ...handlers: MiddlewareType[]) {
+  target.mw = [...target?.mw, ...handlers.flat()]
+}

package/src/{oas.ts → open-api/register.ts}

@@ -1,12 +1,9 @@
-import { STATUS_CODES } from 'node:http'
 import { basicAuth } from 'hono/basic-auth'
 import { Scalar } from '@scalar/hono-api-reference'
-import { generateSpecs, resolver } from 'hono-openapi'
 import { Envir } from 't0n'
-import z from 'zod'
-import response from './response'
-import { getHandler } from './register'
-import type { Hono } from './types'
+import response from '../response'
+import { getHandler } from '../register'
+import type { Hono } from '../types'
 
 export function config(opts: any) {
   const docs = opts?.docs ?? {}
@@ -68,38 +65,3 @@ export function registerOpenAPI(app: Hono, conf: any) {
     })
   )
 }
-
-export async function generateOpenAPI(app: Hono, conf: any) {
-  const opts = config(conf)
-  if (opts.disable) return {}
-
-  return await generateSpecs(app, {
-    documentation: {
-      info: {
-        title: opts.appName,
-        version: opts.appVersion,
-        description: Envir.get('APP_DESCRIPTION', ''),
-      },
-      components: {
-        securitySchemes: {
-          JWT: {
-            type: 'http',
-            scheme: 'bearer',
-            bearerFormat: 'JWT',
-          },
-        },
-        responses: {
-          500: {
-            description: STATUS_CODES[500],
-            content: { // @ts-ignore
-              'application/json': await resolver(z.object({
-                m: z.array(z.string()),
-              })).toOpenAPISchema(),
-            },
-          },
-          ...opts?.responses,
-        },
-      },
-    },
-  })
-}

package/src/open-api/spec.ts

@@ -0,0 +1,41 @@
+import { STATUS_CODES } from 'node:http'
+import { generateSpecs, resolver } from 'hono-openapi'
+import { array, object, string } from 'zod/mini'
+import { Envir } from 't0n'
+import type { Hono } from '../types'
+import { config } from './register'
+
+export async function generateOpenAPI(app: Hono, conf: any) {
+  const opts = config(conf)
+  if (opts.disable) return {}
+
+  return await generateSpecs(app, {
+    documentation: {
+      info: {
+        title: opts.appName,
+        version: opts.appVersion,
+        description: Envir.get('APP_DESCRIPTION', ''),
+      },
+      components: {
+        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,
+        },
+      },
+    },
+  })
+}

package/src/prod.ts

@@ -1,5 +1,5 @@
 import Config from './config'
-import { registerOpenAPI } from './oas'
+import { registerOpenAPI } from './open-api/register'
 import { Ability } from './auth'
 import createApp from './create-app'
 

package/src/register.ts

@@ -1,9 +1,6 @@
 export const handlers: Record<string, Function> = {}
 
 export function registerHandler(id: string, handler: any) {
-  // if (id in handlers)
-  //   console.warn(`Handler "${id}" has already been registered`)
-
   handlers[id] = handler
 }
 

package/src/request.ts

@@ -27,7 +27,7 @@ export default class $Request {
   #u: Authnz<any> | null = null
 
   #host: string
-  #routePath: string
+  #routePath?: string
   #matchedRoutes: RouterRoute[]
 
   constructor(c: Context) {
@@ -38,7 +38,6 @@ export default class $Request {
     const url = new URL(c.req.raw.url)
     this.#host = url.protocol +'//'+ url.host
 
-    this.#routePath = routePath(c)
     this.#matchedRoutes = matchedRoutes(c)
   }
 
@@ -91,10 +90,6 @@ export default class $Request {
     return this.#c.req.header('user-agent')
   }
 
-  get routePath() {
-    return this.#routePath
-  }
-
   get url() {
     return this.#c.req.raw.url
   }
@@ -116,6 +111,15 @@ export default class $Request {
     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
   }

package/src/routes.ts

@@ -1,27 +1,27 @@
 import { copyFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'node:fs'
 import { join, resolve, relative } from 'pathe'
 
+import { IMPORT } from 't0n'
 import glob from 'tiny-glob'
 import { config } from 'dotenv'
-
-import { IMPORT } from 't0n'
+import { describeRoute, resolver } from 'hono-openapi'
+import { mimes } from 'hono/utils/mime'
+import { STATUS_CODES } from 'node:http'
 import { registerHandler, registerMiddleware } from './register'
 import createApp from './create-app'
 import { isAnonFn } from './utils/func'
 import ensureDir from './utils/ensuredir'
 import versionSHA from './utils/version-sha'
-import type { Routes, StandardSchemaV1 } from './types'
 import { rn, substep, warn } from './utils/log'
-import { _root } from './utils/paths'
-
-import { generateOpenAPI } from './oas'
-import z from 'zod'
-import { resolver } from 'hono-openapi'
-import { mimes } from 'hono/utils/mime'
-import { STATUS_CODES } from 'node:http'
-
+import { _root, _rajt } from './utils/paths'
+import { generateOpenAPI } from './open-api/spec'
+import { verbAlias } from './http'
+import { resolve as _resolve } from './utils/resolve'
 import { highlightedMethod, highlightedURI } from './cli/utils'
 
+import type * as z from 'zod'
+import type { Routes, StandardSchemaV1 } from './types'
+
 const importName = (name?: string) => (name || 'Fn'+ Math.random().toString(36).substring(2)).replace(/\.ts$/, '')
 const walk = async (dir: string, baseDir: string, fn: Function, parentMw: string[] = []): Promise<void> => {
   if (!existsSync(dir)) return
@@ -61,7 +61,7 @@ function isZodSchema(obj: any): obj is z.ZodType {
 }
 
 function ResolveDescribeSchema(obj: any, deep: boolean = false) {
-  if (!obj || typeof obj !== 'object') return obj
+  if (!obj || typeof obj != 'object') return obj
   if (isZodSchema(obj))
     return { content: {'application/json': { schema: resolver(obj as unknown as StandardSchemaV1) }} }
 
@@ -134,12 +134,16 @@ export async function getRoutes(
         }
       }
 
+      const mw = (handle.mw?.length ? [...handle.mw, ...middlewares] : middlewares).flatMap(obj => {
+        return typeof obj == 'string' ? obj : obj?.name || null
+      }).filter(Boolean) as Function[]
+
       routes.push({
         method, path: uri,
         name,
         file,
         // @ts-ignore
-        middlewares,
+        middlewares: mw,
         handle,
         desc,
       })
@@ -339,12 +343,25 @@ export async function cacheRoutes() {
 
   const middlewares = await getMiddlewares()
   const configs = await getConfigs()
+  const handlers = [
+    ['auth/middlewares', 'Autorized', 'Autorized'],
+  ]
 
-  routes.forEach(r => registerHandler(r.name, r.handle))
-  middlewares.forEach(mw => registerMiddleware(mw.handle))
+  for (const r of routes)
+    registerHandler(r.name, r.handle)
+
+  for (const mw of middlewares)
+    registerMiddleware(mw.handle)
+
+  for (const h of handlers) {
+    const mod = await IMPORT(join(_rajt, h[0]))
+    registerHandler(h[1], mod[h[1]])
+  }
 
   // @ts-ignore
-  const openApi = await generateOpenAPI(createApp({ routes }), configs?.rajt || {})
+  const openApi = await generateOpenAPI(createApp({ routes, routeRegister: (app: Hono, route: Route) => {
+    app[route.method](route.path, describeRoute(route.desc), ..._resolve(...route.middlewares), route.handle)
+  } }), configs?.rajt || {})
 
   const iPath = join(_root, '.rajt/imports.mjs')
   ensureDir(iPath)
@@ -353,13 +370,18 @@ export async function cacheRoutes() {
   copyFileSync(localfireEntry, join(_root, '.rajt/localfire.js'))
 
   const _rajtDir = await dependencyPath('rajt')
+
+  stringifyToJS(Object.fromEntries(routes.map(r => ([r.path + r.method, r.name]))))
+
   writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
 ${env?.length ? `import { Envir } from '${await dependencyPath('t0n')}/dist/index'\nEnvir.add({${env.map(([key, val]) => key +':'+ stringifyToJS(val)).join(',')}})` : ''}
 ${Object.entries(configs)?.length ? `import Config from '${_rajtDir}/src/config'\nConfig.add(${stringifyToJS(configs)})` : ''}
 
 import { registerHandler, registerMiddleware } from '${_rajtDir}/src/register'
+${handlers.map(([file, name, _export]) => `\nimport ${_export ? `{ ${name} }` : name} from '${_rajtDir}/src/${file}'\nregisterHandler('${name}', ${name})`).join('\n')}
 
 ${Object.entries(openApi)?.length ? `registerHandler('RAJT_OPENAPI', ${stringifyToJS(openApi)})` : ''}
+Config.set('routes', ${stringifyToJS(Object.fromEntries(routes.map(r => ([r.path+'$'+verbAlias[r.method], r.name]))))})
 
 ${routes.map(r => `import ${r.name} from '../${normalizeImportPath(r.file)}'`).join('\n')}
 ${middlewares.map(r => `import ${r.name} from '../${normalizeImportPath(r.file)}'`).join('\n')}
@@ -368,9 +390,7 @@ 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)
-    }
+    registerHandler(name, handler)
   }
 
   const middlewares = {${middlewares.map(r => r.name).join()}}
@@ -386,7 +406,7 @@ try {
   const rPath = join(_root, '.rajt/routes.json')
   ensureDir(rPath)
   writeFileSync(rPath, JSON.stringify(routes.filter(r => r.method && r.path).map(route => [
-    route.method,
+    verbAlias[route.method],
     route.path,
     route.middlewares,
     route.name,

package/src/types.ts

@@ -10,7 +10,8 @@ import { mimes, type BaseMime } from 'hono/utils/mime'
 import type { OpenAPIV3_1, OpenAPIV3 } from 'openapi-types'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type { DescribeRouteOptions as RawDescribeRouteOptions, ResolverReturnType } from 'hono-openapi'
-import z from 'zod'
+import type * as z from 'zod'
+import type zm from 'zod/mini'
 import Action from './action'
 import request from './request'
 import response from './response'
@@ -33,6 +34,7 @@ export type {
 } from 'hono/utils/http-status'
 export type { BaseMime, StandardSchemaV1 }
 
+export type zObject = z.ZodTypeAny | zm.ZodMiniObject
 type PublicMethods<T> = {
   [K in keyof T]: K extends `#${string}` | `$${string}` | symbol | 'prototype' ? never : K
 }[keyof T]
@@ -42,11 +44,12 @@ 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>
+  schema: zObject
   target: keyof ValidationTargets
   eTarget?: 'fieldErrors' | 'formErrors'
 }
 export type Rules = Rule[] | Rule | null
+export type RuleFn = (schema: zObject) => Rule
 
 export type StandardSchema = StandardSchemaV1 | OpenAPIV3_1.ReferenceObject
 export type DescribeRouteOptions = Omit<RawDescribeRouteOptions, 'responses'> & {

package/src/utils/resolve.ts

@@ -1,21 +1,36 @@
-export function resolve(obj: any, id: string) {
-  if (typeof obj == 'function' && obj?.length == 2)
-    return [obj]
-
-  if (obj?.run)
-    return obj.run()
-
-  if (obj?.handle)
-    return obj.handle()
-
-  const instance = new obj()
-  if (obj?.prototype?.run)
-    return instance.run()
-
-  if (obj?.prototype?.handle)
-    return [instance.handle]
-
-  throw new Error(`Invalid action "${id}" - unsupported type`)
+import { getHandler } from '../register'
+
+export function resolve(...objs: any[]) {
+  const _ = []
+  for (let obj of objs) {
+    if (typeof obj == 'string')
+      obj = getHandler(obj)
+
+    if (typeof obj == 'function' && obj?.length == 2) {
+
+    } else if (obj?.run) {
+      _.push(...obj.run())
+      continue
+    } else if (obj?.handle) {
+      obj = obj.handle
+    } else if (obj?.factory) {
+      obj = obj?.opts ? obj.factory(...Array.isArray(obj.opts) ? obj.opts : [obj.opts]) : obj.factory()
+    } else {
+      const instance = new obj()
+      if (obj?.prototype?.run) {
+        _.push(...instance.run())
+        continue
+      } else if (obj?.prototype?.handle) {
+        obj = instance.handle
+      }
+
+      throw new Error(`Invalid action "${obj?.name || String(obj)}" - unsupported type`)
+    }
+
+   obj &&  _.push(obj)
+  }
+
+  return _
 }
 
 export function resolveMiddleware(obj: any) {

package/src/validator.ts

@@ -1,17 +1,17 @@
-import type { ZodObject } from 'zod'
-import { validator } from 'hono-openapi'
+import { zValidator } from '@hono/zod-validator'
 import response from './response'
 import type {
-  Rule, Rules,
+  Rule, Rules, RuleFn,
   ValidationTargets,
+  zObject,
 } from './types'
 
 export default class $Validator {
-  private static cache = new Map<string, (schema: ZodObject<any>) => Rule>()
+  private static cache = new Map<string, RuleFn>()
 
   private static createRule<T extends keyof ValidationTargets>(
     target: T,
-    schema: ZodObject<any>
+    schema: zObject
   ): Rule {
     return {
       target,
@@ -24,7 +24,7 @@ export default class $Validator {
     if (this.cache.has(target))
       return this.cache.get(target)
 
-    const fn = (schema: ZodObject<any>) => this.createRule(target, schema)
+    const fn = (schema: zObject) => this.createRule(target, schema)
     this.cache.set(target, fn)
     return fn
   }
@@ -38,9 +38,9 @@ export default class $Validator {
 
   static parse(rules: Rules): Function[] {
     return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore
-      .flatMap(rule => validator(rule.target, rule.schema, (result, c) => {
+      .flatMap(rule => zValidator(rule.target, rule.schema, (result, c) => {
         if (!result.success) // @ts-ignore
-          return response.badRequest(result.error)
+          return response.badRequest({ ...result.error.flatten()[rule.eTarget] })
       }))
   }
 }

package/src/utils/json-import.ts

@@ -1,14 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { dirname, join } from 'pathe'
-
-export default function jsonImport<T = any>(filePath: string, defaultValue: T = {} as T): T {
-  const __dirname = dirname(new URL(import.meta.url).pathname)
-
-  try {
-    const fullPath = join(__dirname, filePath)
-    const fileContent = readFileSync(fullPath, 'utf-8')
-    return JSON.parse(fileContent) as T
-  } catch (error) {
-    return defaultValue
-  }
-}

package/src/utils/merge-middleware.ts

@@ -1,9 +0,0 @@
-import type { MiddlewareHandler } from 'hono'
-import { MiddlewareType } from '../middleware'
-import { resolveMiddleware } from './resolve'
-
-export default function mergeMiddleware(target: Function | any, ...handlers: MiddlewareType[]) {
-  const existingMiddlewares: MiddlewareHandler[] = target?.mw || []
-  const allMiddlewares = [...existingMiddlewares, ...handlers.flat().map(handler => resolveMiddleware(handler))]
-  target.mw = allMiddlewares
-}