rajt 0.0.99 → 0.0.101

package/bin/rajt.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
-import { join, dirname } from 'node:path';
+import { join, dirname, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 
-const __dirname = dirname(new URL(import.meta.url).pathname);
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const ERR_NODE_VERSION = '18.0.0';
 const MIN_NODE_VERSION = '18.0.0';
 
-let rajtProcess;
-
 function runRajt() {
   if (process?.versions?.node && semiver(process.versions.node, ERR_NODE_VERSION) < 0) {
     console.error(
@@ -21,58 +20,70 @@ Consider using a Node.js version manager such as https://volta.sh or https://git
     return;
   }
 
-  const isBun = process?.isBun || typeof Bun != 'undefined';
-  let tsxPath;
-
-  if (!isBun) {
-    const _tsxPath = 'node_modules/.bin/tsx'
-    const tsxPaths = [
-      // join(__dirname, '../node_modules/.bin/tsx'),
-      // join(__dirname, '../../.bin/tsx'),
-      join(__dirname, '../'+ _tsxPath),
-      join(__dirname, '../../'+ _tsxPath),
-      join(process.cwd(), _tsxPath),
-      'tsx',
-    ];
-
-    for (const pathOption of tsxPaths) {
-      if (pathOption == 'tsx' || existsSync(pathOption)) {
-        tsxPath = pathOption;
-        break;
-      }
-    }
+  const isBun = process?.isBun || typeof Bun !== 'undefined';
+  const targetScript = resolve(__dirname, '../src/cli/index.ts');
+
+  let executor = process.execPath;
+  let args = [];
+
+  if (isBun) {
+    args = [targetScript, ...process.argv.slice(2)];
+  } else {
+    const tsxBin = findTsx();
 
-    if (!tsxPath) {
-      console.error('TypeScript file found but tsx is not available. Please install tsx:');
+    if (!tsxBin) {
+      console.error('Error: "tsx" is not available. Please install tsx:');
       console.error('  npm i -D tsx');
       console.error('  or');
       console.error('  bun i -D tsx');
       process.exit(1);
-      return;
     }
-  }
 
-  return spawn(
-    process.execPath,
-    [
+    args = [
       '--no-warnings',
-      ...process.execArgv,
-      tsxPath,
-      join(__dirname, '../src/cli/index.ts').replace(/^\\/, ''),
-      ...process.argv.slice(2),
-    ].filter(arg => arg && !arg.includes('experimental-vm-modules') && !arg.includes('loader')),
-    {
-      stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-      env: {
-        ...process.env,
-        NODE_ENV: process.env.NODE_ENV || 'development',
-        TSX_DISABLE_CACHE: process.env.TSX_DISABLE_CACHE || '1',
-      }
+      tsxBin,
+      targetScript,
+      ...process.argv.slice(2)
+    ].filter(arg => !arg.includes('experimental-vm-modules') && !arg.includes('loader'));
+  }
+
+  return execute(executor, args)
+}
+
+function findTsx() {
+  const relativePaths = [
+    join(__dirname, '../node_modules/tsx/dist/cli.mjs'),
+    join(process.cwd(), 'node_modules/tsx/dist/cli.mjs'),
+    join(__dirname, '../node_modules/.bin/tsx'),
+    join(process.cwd(), 'node_modules/.bin/tsx'),
+  ];
+
+  for (const p of relativePaths) {
+    if (existsSync(p)) return p;
+    if (existsSync(`${p}.exe`)) return `${p}.exe`;
+    if (existsSync(`${p}.cmd`)) return `${p}.cmd`;
+  }
+
+  return null
+}
+
+function execute(command, args) {
+  const child = spawn(command, args, {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    env: {
+      ...process.env,
+      NODE_ENV: process.env.NODE_ENV || 'development',
+      TSX_DISABLE_CACHE: '1',
     }
-  )
-  .on('exit', code => process.exit(code == null ? 0 : code))
-  .on('message', message => process.send && process.send(message))
-  .on('disconnect', () => process.disconnect && process.disconnect());
+  });
+
+  process.on('SIGINT', () => child.kill('SIGINT'))
+    .on('SIGTERM', () => child.kill('SIGTERM'));
+
+  return child
+    .on('exit', code => process.exit(code ?? 0))
+    .on('message', msg => process.send?.(msg))
+    .on('disconnect', () => process.disconnect?.())
 }
 
 var fn = new Intl.Collator(0, { numeric: 1 }).compare;
@@ -101,7 +112,5 @@ function directly() {
 }
 
 if (directly()) {
-  rajtProcess = runRajt();
-  process.on('SIGINT', () => rajtProcess && rajtProcess.kill())
-    .on('SIGTERM', () => rajtProcess && rajtProcess.kill());
+  runRajt()
 }

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.99",
+  "version": "0.0.101",
   "type": "module",
   "main": "./src/index.ts",
   "files": ["bin", "src"],
@@ -35,25 +35,25 @@
     "zip": "zip -j ../../lambda.zip ../../.rajt/dist/index.js"
   },
   "dependencies": {
-    "@hono/node-server": "^1.19.9",
+    "@hono/node-server": "^1.19.11",
     "@hono/standard-validator": "^0.2.2",
     "@hono/zod-validator": "^0.7.6",
-    "@scalar/hono-api-reference": "^0.9.40",
+    "@scalar/hono-api-reference": "^0.10.3",
     "chokidar": "^3.5.2",
     "citty": "^0.1.6",
     "consola": "^3.4.2",
-    "cripta": "^0.1.10",
+    "cripta": "^0.1.12",
     "dotenv": "^16.5.0",
     "esbuild": "^0.25.2",
-    "forj": "^0.1.8",
-    "hono": "^4.11.7",
+    "forj": "^0.1.10",
+    "hono": "^4.12.8",
     "hono-openapi": "^1.3.0",
-    "localflare-api": "^0.4.2",
-    "localflare-core": "^0.4.2",
-    "miniflare": "^4.20260301.1",
+    "localflare-api": "^0.5.0",
+    "localflare-core": "^0.5.0",
+    "miniflare": "^4.20260312.0",
     "pathe": "^2.0",
     "quansync": "^0.2.11",
-    "t0n": "^0.1.12",
+    "t0n": "^0.1.13",
     "tiny-glob": "^0.2",
     "tsx": "^4.19.4",
     "wrangler": "^4.61.0",

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,
@@ -53,7 +54,7 @@ export default defineCommand({
 				event('Building..')
 			}
 			const fn = async () => {
-				building && await build(platform)
+				building && await build(platform, 'dev')
 				await start()
 			}
 
@@ -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/index.ts

@@ -19,8 +19,8 @@ import make from './commands/make'
 const directly = () => {
   try {
     // @ts-ignore
-    return typeof vitest == 'undefined'
-      && import.meta.url == `file://${process.argv[1].replace(/\\/g, '/')}`
+    return typeof vitest === 'undefined'
+      && import.meta.url?.endsWith(process.argv[1].replace(/\\/g, '/'))
 	} catch {
 		return false
 	}

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,8 +70,54 @@ 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) => {
+export const build = async (platform: Platform, env: string = 'prd') => {
   const startTime = Date.now()
 
   const isCF = platform == 'cf'
@@ -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 = {
@@ -109,57 +160,49 @@ export const build = async (platform: Platform) => {
     ],
     metafile: true,
     write: false,
-    // define: {
-    //   'process.env.NODE_ENV': '"development"'
-    // },
-    // loader: {
-    //   '.ts': 'ts',
-    //   '.js': 'js'
-    // },
+    define: {
+      'process.env.RAJT_ENV': env,
+      //  'process.env.NODE_ENV': '"development"',
+    },
     // 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

@@ -7,13 +7,14 @@ import type {
   HTTPResponseError,
   ServerOptions,
 } from './types'
-import { resolve, resolveMiddleware, mw } from './utils/resolve'
-import { getMiddlewares, getHandler } from './register'
+import { resolve, resolveMiddleware } from './utils/resolve'
+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
@@ -109,11 +113,11 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
   if (options?.init) options.init(app)
 
   const routes = options?.routes || [] // @ts-ignore
-  const routeRegister = options?.routeRegister ? options.routeRegister : (_: Hono, route: Route) => { // @ts0ignore
+  const routeRegister = options?.routeRegister ? options.routeRegister : (_: Hono, route: Route) => {
     if (Array.isArray(route)) { // @ts-ignore
-      _[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
-      _[route.method](route.path, ...mw(route.middlewares, route.name), ...resolve(route.handle, route.name))
+      _[route.method](route.path, ...resolve(...route.middlewares, route.handle))
     }
   }
 

package/src/dev.ts

@@ -7,12 +7,11 @@ 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/open-api/register.ts

@@ -61,7 +61,8 @@ export function registerOpenAPI(app: Hono, conf: any) {
       slug: opts.appName?.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w\s_-]/g, '').replace(/[\s_-]+/g, '_').replace(/[^\x00-\x7F]/g, '') +'_'+ opts.appVersion,
       // hideDownloadButton: true,
       // onLoaded: () => document?.querySelectorAll('[href="https://www.scalar.com"]')?.forEach(el => el.remove()),
-      customCss: `[href="https://www.scalar.com"]{display:none}`,
+      customCss: `[href="https://www.scalar.com"],.scalar-mcp-layer{display:none!important}`,
+      // favicon: 'https://example.com/favicon.png',
     })
   )
 }

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,8 @@ export default class $Request {
   #u: Authnz<any> | null = null
 
   #host: string
-  #routePath: string
+  #protocol: string
+  #routePath?: string
   #matchedRoutes: RouterRoute[]
 
   constructor(c: Context) {
@@ -37,8 +38,8 @@ export default class $Request {
 
     const url = new URL(c.req.raw.url)
     this.#host = url.protocol +'//'+ url.host
+    this.#protocol = url.protocol
 
-    this.#routePath = routePath(c)
     this.#matchedRoutes = matchedRoutes(c)
   }
 
@@ -69,6 +70,13 @@ export default class $Request {
     return this.has(prop, value)
   }
 
+  createToken(data: any, exp: number) {
+    return Token.create(this, data, exp)
+  }
+  parseToken(token: string) {
+    return Token.parse(this, token)
+  }
+
   get cx() {
     return this.#c
   }
@@ -91,8 +99,8 @@ export default class $Request {
     return this.#c.req.header('user-agent')
   }
 
-  get routePath() {
-    return this.#routePath
+  get protocol() {
+    return this.#protocol
   }
 
   get url() {
@@ -116,6 +124,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,29 @@
 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, validator } 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 _response from './response'
+import _validator from './validator'
 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 { _root, _rajt } from './utils/paths'
 import { generateOpenAPI } from './open-api/spec'
-import type * as z from 'zod'
-import { describeRoute, resolver } from 'hono-openapi'
-import { mimes } from 'hono/utils/mime'
-import { STATUS_CODES } from 'node:http'
-import { mw, resolve as _resolve } from './utils/resolve'
-
+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, Rule, 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 +63,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 +136,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,13 +345,28 @@ 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]])
+  }
+
+  _validator.setParser((rule: Rule) => validator(rule.target, rule.schema, (result, c) => {
+    if (!result.success) // @ts-ignore
+      return _response.badRequest(result.error)
+  }))
   // @ts-ignore
   const openApi = await generateOpenAPI(createApp({ routes, routeRegister: (app: Hono, route: Route) => {
-    app[route.method](route.path, describeRoute(route.desc), ...mw(route.middlewares, route.name), ..._resolve(route.handle, route.name))
+    app[route.method](route.path, describeRoute(route.desc), ..._resolve(...route.middlewares, route.handle))
   } }), configs?.rajt || {})
 
   const iPath = join(_root, '.rajt/imports.mjs')
@@ -355,13 +376,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(',')}})` : ''}
+${env?.length ? `import { Envir } from '${await dependencyPath('t0n')}/src/envir'\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')}
@@ -370,9 +396,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()}}
@@ -388,7 +412,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

@@ -11,6 +11,7 @@ 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 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/environment.ts

@@ -1,16 +1,17 @@
 const prd = Symbol('prd')
 const dev = Symbol('dev')
 
-let env = prd
+// @ts-ignore
+let env = process.env.RAJT_ENV || prd
 
-export const getEnv = () => env
+export const getEnv = () => env // @ts-ignore
 export const setEnv = (e: symbol) => env = e
 
-export function detectEnvironment() {
+export function detectEnvironment(): symbol {
   try {
     if (
-      process.env?.npm_lifecycle_event == 'dev'
-      || process.env?.npm_lifecycle_script == 'rajt'
+      process.env?.npm_lifecycle_event === 'dev'
+      || process.env?.npm_lifecycle_script === 'rajt'
       || process.env?.AWS_SAM_LOCAL
       // || process?.argv?.includes('--dev')
       || process?.argv?.some(arg => ['-port', '-platform', '--dev', '--development', '--watch'].includes(arg))
@@ -24,10 +25,11 @@ export function detectEnvironment() {
   return prd
 }
 
-export const isEnv = (e: symbol) => env == e
+export const isEnv = (e: symbol) => env === e
 
-export const isDev = () => env == dev
-export const isProd = () => env == prd
+// @ts-ignore
+export const isDev = () => env === dev
+export const isProd = () => env === prd
 
 export const isDevelopment = isDev
 export const isProduction = isProd

package/src/utils/resolve.ts

@@ -1,23 +1,36 @@
 import { getHandler } from '../register'
 
-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`)
+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) {
@@ -35,11 +48,3 @@ export function resolveMiddleware(obj: any) {
 
   throw new Error('Invalid middleware provided. Must be a Hono middleware function or MiddlewareClass instance/constructor')
 }
-
-export 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)
-}

package/src/validator.ts

@@ -1,17 +1,19 @@
-import type * as z from 'zod'
 import { zValidator } from '@hono/zod-validator'
 import response from './response'
+import type * as z from 'zod'
 import type {
-  Rule, Rules,
+  Rule, Rules, RuleFn,
   ValidationTargets,
+  zObject,
+  MiddlewareHandler,
 } from './types'
 
 export default class $Validator {
-  private static cache = new Map<string, (schema: z.ZodObject<any>) => Rule>()
+  private static cache = new Map<string, RuleFn>()
 
   private static createRule<T extends keyof ValidationTargets>(
     target: T,
-    schema: z.ZodObject<any>
+    schema: zObject
   ): Rule {
     return {
       target,
@@ -24,7 +26,7 @@ export default class $Validator {
     if (this.cache.has(target))
       return this.cache.get(target)
 
-    const fn = (schema: z.ZodObject<any>) => this.createRule(target, schema)
+    const fn = (schema: zObject) => this.createRule(target, schema)
     this.cache.set(target, fn)
     return fn
   }
@@ -36,11 +38,33 @@ export default class $Validator {
   static readonly header = $Validator.fn('header')!
   static readonly cookie = $Validator.fn('cookie')!
 
+  static #parser = (rule: Rule) => zValidator(rule.target, rule.schema, (result, c) => {
+    if (!result.success) // @ts-ignore
+      return response.badRequest(formatZodErrors(result.error.issues || []))
+  })
+
+  static setParser(parser: (rule: Rule) => MiddlewareHandler) {
+    this.#parser = parser
+  }
+
   static parse(rules: Rules): Function[] {
     return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore
-      .flatMap(rule => zValidator(rule.target, rule.schema, (result, c) => {
-        if (!result.success) // @ts-ignore
-          return response.badRequest({ ...result.error.flatten()[rule.eTarget] })
-      }))
+      .flatMap(this.#parser)
+  }
+}
+
+function formatZodErrors(issues: z.ZodIssue[]): Record<string, string[]> {
+  const result: Record<string, string[]> = {}
+
+  for (const issue of issues) {
+    const path = issue.path.join('.')
+    const key = path || 'root'
+
+    if (!result[key])
+      result[key] = []
+
+    result[key].push(issue.message)
   }
+
+  return result
 }

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