rajt 0.0.60 → 0.0.62

package/README.md

@@ -1,7 +1,15 @@
 <h1 align="left">λ Rajt<br/><a href="https://pr.new/attla/rajt"><img align="right" src="https://developer.stackblitz.com/img/start_pr_dark_small.svg" alt="Start new PR in StackBlitz Codeflow"></a><a href="https://npmjs.com/package/rajt"><img align="right" src="https://img.shields.io/npm/v/rajt.svg" alt="npm package"></a></h1>
+
+> *Runtime-Agnostic for Javascript and TypeScript*.
+
+> *From Hungarian **`[ˈrɒjt]`** (meaning "start") and Russian **`Райт`** (meaning "wright").*
+
+<br/>
+
+> ⚠️ Rajt is under ALFA development — expect updates, rough edges, and occasional breack changes.
 <br/>
 
-> This framework is fully geared towards the serverless world, specifically AWS Lambda (Node.js, Bun and LLRT runtime) / Cloudflare Workers.
+This framework is fully geared towards the serverless world, specifically AWS Lambda (Node.js, Bun and LLRT runtime) / Cloudflare Workers.
 
 - 💡 Instant Server Start
 - ⚡️ Fast Cold Start

package/bin/rajt.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { join, dirname } from "node:path";
+import { existsSync } from "node:fs";
+
+const __dirname = dirname(new URL(import.meta.url).pathname);
+
+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(
+      `Rajt requires at least Node.js v${MIN_NODE_VERSION}. You are using v${process.versions.node}. Please update your version of Node.js.
+
+Consider using a Node.js version manager such as https://volta.sh or https://github.com/nvm-sh/nvm.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const isBun = process?.isBun || typeof Bun != 'undefined';
+  let tsxPath;
+  // const params = isBun ? bunParams() : nodeParams();
+
+  if (!isBun) {
+    const tsxPaths = [
+      // join(__dirname, "../node_modules/.bin/tsx"),
+      // join(__dirname, "../../.bin/tsx"),
+      join(__dirname, "../node_modules/.bin/tsx"),
+      join(__dirname, "../../node_modules/.bin/tsx"),
+      join(process.cwd(), "node_modules/.bin/tsx"),
+      "tsx",
+    ];
+
+    for (const pathOption of tsxPaths) {
+      if (pathOption == "tsx" || existsSync(pathOption)) {
+        tsxPath = pathOption;
+        break;
+      }
+    }
+
+    if (!tsxPath) {
+      console.error("TypeScript file found but 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,
+    [
+      "--no-warnings",
+      ...process.execArgv,
+      tsxPath,
+      join(__dirname, "../src/cli/index.ts"),
+      ...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',
+      }
+    }
+  ).on("exit", (code) =>
+    process.exit(code == null ? 0 : code)
+  ).on("message", (message) => {
+    if (process.send) {
+      process.send(message);
+    }
+  }).on("disconnect", () => {
+    if (process.disconnect) {
+      process.disconnect();
+    }
+  });
+}
+
+var fn = new Intl.Collator(0, { numeric: 1 }).compare;
+
+function semiver(a, b, bool) {
+  a = a.split(".");
+  b = b.split(".");
+
+  return (
+    fn(a[0], b[0]) ||
+    fn(a[1], b[1]) ||
+    ((b[2] = b.slice(2).join(".")),
+      (bool = /[.-]/.test((a[2] = a.slice(2).join(".")))),
+      bool == /[.-]/.test(b[2]) ? fn(a[2], b[2]) : bool ? -1 : 1)
+  );
+}
+
+function directly() {
+  try {
+    return process.env?.npm_lifecycle_script == 'rajt'
+      && (
+        process.argv[1]?.endsWith('node_modules/.bin/rajt')
+        || process.argv[1]?.endsWith('node_modules/rajt/bin/rajt.js')
+      )
+  } catch {
+    return false
+  }
+}
+
+if (directly()) {
+  rajtProcess = runRajt();
+  process.on("SIGINT", () => {
+    rajtProcess && rajtProcess.kill();
+  });
+  process.on("SIGTERM", () => {
+    rajtProcess && rajtProcess.kill();
+  });
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.60",
+  "version": "0.0.62",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "rajt": "./src/bin/rajt.js"
+    "rajt": "./bin/rajt.js"
   },
   "exports": {
     ".": "./src/index.ts",
@@ -21,6 +21,7 @@
     "./length": "./src/utils/length.ts"
   },
   "files": [
+    "bin",
     "src"
   ],
   "scripts": {
@@ -53,9 +54,10 @@
   "dependencies": {
     "@hono/zod-validator": "^0.4.3",
     "cripta": "^0.1",
-    "forj": "^0.0.2",
+    "forj": "^0.0.4",
     "hono": "^4.7.6",
-    "t0n": "^0.1.5",
+    "t0n": "^0.1",
+    "tiny-glob": "^0.2",
     "ua-parser-js": "^2.0.4"
   },
   "devDependencies": {

package/src/action.ts

@@ -1,11 +1,12 @@
 import response from './response'
 import validator from './validator'
+import { GET_REQUEST } from './request'
 import type { Context, IRequest, IResponse, IValidator, Rules } from './types'
 
 export default class Action {
   static run() {
     const rules = this.rules(validator)
-    const h = async (c: Context) => await this.handle(c.get('_'), response)
+    const h = async (c: Context) => await this.handle(c.get(GET_REQUEST as unknown as string), response)
     if (!rules) return [h]
 
     const pipe = validator.parse(rules)

package/src/cli/commands/dev/index.ts

@@ -1,10 +1,9 @@
 import { existsSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
 import { dirname, join, relative } from 'node:path'
 import { spawn, type ChildProcess } from 'node:child_process'
 
 import chokidar from 'chokidar'
-import colors from 'picocolors'
+// import colors from 'picocolors'
 import { defineCommand } from 'citty'
 import type { ChokidarEventName } from '../../types'
 
@@ -13,7 +12,7 @@ import { build, createMiniflare } from './utils'
 import { getAvailablePort } from '../../../utils/port'
 import shutdown from '../../../utils/shutdown'
 
-const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../../../../')
+const __dirname = join(dirname(new URL(import.meta.url).pathname), '../../../../../../')
 
 export default defineCommand({
 	meta: {
@@ -36,7 +35,7 @@ export default defineCommand({
 			description: 'Environment platform',
 			type: 'enum',
 			options: ['aws', 'cf', 'node'] as const,
-			required: true,
+			// required: true,
 		},
 	},
 	async run({ args }) {
@@ -93,7 +92,7 @@ export default defineCommand({
 								'local', 'start-api',
 								'--warm-containers', 'LAZY',
 								'--debug', '--template-file', join(__dirname, 'template-dev.yaml'),
-								'--port', args.port,
+								'--port', String(port),
 							],
 							{
 								stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
@@ -168,30 +167,43 @@ export default defineCommand({
 						logger.step('Server restarted')
 					})
 				})
+			default:
 			case 'node':
 				return withPort(desiredPort, async (port) => {
 					logger.step(`API running on http://${host}:${port}`)
+					const isBun = process?.isBun || typeof Bun != 'undefined'
+					const params = isBun
+						? ['run', '--port='+ port, '--hot', '--silent', '--no-clear-screen', '--no-summary', join(__dirname, 'node_modules/rajt/src/dev.ts')]
+						: [join(__dirname, 'node_modules/.bin/tsx'), 'watch', join(__dirname, 'node_modules/rajt/src/dev-node.ts')]
 
-					spawn(
+					const child = spawn(
 						process.execPath,
-						[
-							join(__dirname, 'node_modules/.bin/tsx'), 'watch', join(__dirname, 'node_modules/rajt/src/dev.ts'),
-						],
+						params,
 						{
-							stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-							env: {...process.env, PORT: args.port},
+							stdio: ['inherit', isBun ? 'pipe' : 'inherit', 'inherit', 'ipc'],
+							env: {...process.env, PORT: port},
 						}
-					).on('exit', code => process.exit(code ?? 0))
-					.on('message', msg => {
-						if (process.send) process.send(msg)
-					}).on('disconnect', () => {
-						if (process.disconnect) process.disconnect()
-					})
+					)
+
+					if (isBun && child?.stdout) {
+						child.stdout?.on('data', data => {
+							const output = data.toString()
+							if (!output.includes('Started development server'))
+									process.stdout.write(output)
+						})
+					}
+
+					child.on('exit', code => process.exit(code ?? 0))
+						.on('message', msg => {
+							if (process.send) process.send(msg)
+						}).on('disconnect', () => {
+							if (process.disconnect) process.disconnect()
+						})
 				})
-			default:
-				return logger.warn(
-					`🟠 Provide a valid platform: ${['aws', 'cf', 'node'].map(p => colors.blue(p)).join(', ')}.\n`
-				)
+			// default:
+			// 	return logger.warn(
+			// 		`🟠 Provide a valid platform: ${['aws', 'cf', 'node'].map(p => colors.blue(p)).join(', ')}.\n`
+			// 	)
     }
 	},
 })
@@ -228,13 +240,7 @@ function getAssetChangeMessage(
 
 async function watch(cb: (e: ChokidarEventName | string, file: string) => Promise<void>) {
 	const codeWatcher = chokidar.watch([
-		join(__dirname, 'actions/**/*.ts'),
-		join(__dirname, 'configs/**/*.ts'),
-		join(__dirname, 'enums/**/*.ts'),
-		join(__dirname, 'locales/**/*.ts'),
-		join(__dirname, 'middlewares/**/*.ts'),
-		join(__dirname, 'models/**/*.ts'),
-		join(__dirname, 'utils/**/*.ts'),
+		join(__dirname, '{actions,features,routes,configs,enums,locales,middlewares,models,utils}/**/*.ts'),
 		join(__dirname, '.env.dev'),
 		join(__dirname, '.env.prod'),
 		join(__dirname, 'package.json'),

package/src/cli/commands/dev/utils.ts

@@ -1,14 +1,13 @@
 import esbuild from 'esbuild'
 import TOML from '@iarna/toml'
 import { Miniflare } from 'miniflare'
-import { fileURLToPath } from 'node:url'
 import { mkdirSync, existsSync, readdirSync, rmSync, copyFileSync } from 'node:fs'
 import { readFile, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative } from 'node:path'
 
 import { cacheRoutes } from '../../../routes'
 
-const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../../../../')
+const __dirname = join(dirname(new URL(import.meta.url).pathname), '../../../../../../')
 const __rajt = join(__dirname, 'node_modules/rajt/src')
 
 export const formatSize = (bytes: number) => {
@@ -79,7 +78,7 @@ export const build = async (platform: 'aws' | 'cf' | 'node') => {
         name: 'preserve-class-names',
         setup(build) {
           build.onLoad(
-            { filter: /(actions|features)\/.*\.ts$/ },
+            { filter: /(actions|features|routes)\/.*\.ts$/ },
             async (args) => {
               const contents = await readFile(args.path, 'utf8')
               const result = await esbuild.transform(contents, {

package/src/cli/index.ts

@@ -25,11 +25,9 @@ console.error = () => {}
 const directly = () => {
   try {
     // @ts-ignore
-		return typeof vitest == 'undefined'
-			&& (
-				![typeof require, typeof module].includes('undefined') && require.main == module
-				|| import.meta.url == `file://${process.argv[1]}`
-			)
+    return typeof vitest == 'undefined'
+      && process.env?.npm_lifecycle_script == 'rajt'
+      && import.meta.url == `file://${process.argv[1]}`
 	} catch {
 		return false
 	}

package/src/config.ts

@@ -0,0 +1,76 @@
+import { DataBag } from 't0n'
+
+export default class Config {
+  static #c: DataBag
+
+  static {
+    this.#c = new DataBag()
+  }
+
+  static all<T = any>(): Record<string, T> {
+    return this.#c.all()
+  }
+
+  static has(key: string): boolean {
+    return this.#c.has(key)
+  }
+
+  static add<T = any>(data: Record<string, T> = {}) {
+    this.#c.add(data)
+  }
+
+  static replace<T = any>(data: Record<string, T> = {}) {
+    this.#c.replace(data)
+  }
+
+  static get<T = any>(key: string, defaultValue?: T): T {
+    return this.#c.get(key, defaultValue)
+  }
+
+  static set<T = any>(key: string, value: T) {
+    this.#c.set(key, value)
+  }
+
+  static remove(key: string) {
+    this.#c.remove(key)
+  }
+
+  static clear() {
+    this.#c.clear()
+  }
+
+  static get length(): number {
+    return this.#c.length
+  }
+  static get size(): number {
+    return this.#c.length
+  }
+
+  static keys(): string[] {
+    return this.#c.keys()
+  }
+
+  static values<T = any>(): T[] {
+    return this.#c.values()
+  }
+
+  static entries<T = any>(): [string, T][] {
+    return this.#c.entries()
+  }
+
+  static toArray<T = any>(): [string, T][] {
+    return this.#c.entries()
+  }
+
+  static jsonSerialize<T = any>(): Record<string, T> {
+    return this.#c.all()
+  }
+
+  static toJson(options: number = 0): string {
+    return this.#c.toJson(options)
+  }
+
+  static [Symbol.iterator](): IterableIterator<[string, any]> {
+    return this.#c[Symbol.iterator]()
+  }
+}

package/src/create-app.ts

@@ -6,7 +6,8 @@ import type { Env, Context, ErrorHandler, NotFoundHandler, Next } from 'hono'
 // import { createMiddleware } from 'hono/factory'
 // import type { H, Handler, HandlerResponse } from 'hono/types'
 import type { HTTPResponseError } from 'hono/types'
-import colors from 'picocolors'
+import { createColors } from 'picocolors'
+import { getColorEnabledAsync } from 'hono/utils/color'
 import { Envir } from 't0n'
 import type { Routes } from './types'
 import { BadRequest, Unauthorized } from './exceptions'
@@ -14,9 +15,11 @@ import { resolve, resolveMiddleware } from './utils/resolve'
 import { getMiddlewares, getHandler } from './register'
 import { isDev } from './utils/environment'
 import localDate from './utils/local-date'
-import request from './request'
+import request, { GET_REQUEST } from './request'
 import response from './response'
 
+const colors = createColors(await getColorEnabledAsync())
+
 type InitFunction<E extends Env = Env> = (app: Hono<E>) => void
 
 export type ServerOptions<E extends Env = Env> = Partial<{
@@ -85,12 +88,12 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
     app.use('*', logger((...args: any[]) => console.log(colors.gray(localDate()), ...args)))
 
   app.use(async (c: Context, next: Next) => {
-    c.set('_', new request(c))
+    c.set(GET_REQUEST as unknown as string, new request(c))
     if (c.env) Envir.add(c.env)
     await next()
   })
   getMiddlewares().forEach(mw => {
-    const h = async (c: Context, next: Next) => await resolveMiddleware(mw)(c.get('_'), next)
+    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)
   })

package/src/db/dynamodb.d.ts

@@ -0,0 +1 @@
+export * from 'forj/dynamodb/types'

package/src/db/dynamodb.ts

@@ -0,0 +1 @@
+export * from 'forj/dynamodb'

package/src/dev-node.ts

@@ -0,0 +1,16 @@
+import { serve, type ServerType } from '@hono/node-server'
+import app from './dev'
+import shutdown from './utils/shutdown'
+
+const fetch = app.fetch
+
+const port = process.env?.PORT ? Number(process.env.PORT) : 3000
+
+let server: ServerType | null = serve({ fetch, port })
+
+shutdown(() => {
+  if (server) {
+    server?.close()
+    server = null
+  }
+})

package/src/dev.ts

@@ -1,40 +1,30 @@
-import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
 import { config } from 'dotenv'
-import { serve, type ServerType } from '@hono/node-server'
 import createApp from './create-app'
-import { getRoutes, getMiddlewares } from './routes'
+import { getRoutes, getMiddlewares, getConfigs } from './routes'
 import { registerHandler, registerMiddleware } from './register'
-import { Ability } from './auth'
-import jsonImport from './utils/json-import'
-import { setEnv, detectEnvironment } from './utils/environment'
-import shutdown from './utils/shutdown'
+import Config from './config'
+import { Ability } from 'rajt/auth'
+import { setEnv, detectEnvironment } from 'rajt/env'
 
 setEnv(detectEnvironment())
 
-const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../')
+const __dirname = join(dirname(new URL(import.meta.url).pathname), '../../../')
 
 config({ path: join(__dirname, '.env.dev') })
 
+Config.add(await getConfigs())
+
 let routes = await getRoutes()
 routes.forEach(r => registerHandler(r.name, r.handle))
-routes = routes.filter(r => r?.path)
+routes = routes.filter(r => r?.method && r?.path)
 
 const middlewares = await getMiddlewares()
 middlewares.forEach(mw => registerMiddleware(mw.handle))
 
 Ability.fromRoutes(routes)
-Ability.roles = jsonImport(join(__dirname, 'roles.json'))
-
-const fetch = createApp({ routes }).fetch
-
-const port = process.env?.PORT ? Number(process.env.PORT) : 3000
+Ability.roles = Config.get('roles', {})
 
-let server: ServerType | null = serve({ fetch, port })
+const app = createApp({ routes })
 
-shutdown(() => {
-  if (server) {
-    server?.close()
-    server = null
-  }
-})
+export default app

package/src/esbuild.mjs

@@ -1,6 +1,5 @@
 import esbuild from 'esbuild'
 import { basename, dirname, join, relative } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { mkdirSync, existsSync, readdirSync, rmSync, copyFileSync } from 'node:fs'
 import { readFile, stat, writeFile } from 'node:fs/promises'
 
@@ -16,7 +15,7 @@ const platforms = ['aws', 'cf']
 if (!platform || !platforms.includes(platform))
   fail()
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
+const __dirname = dirname(new URL(import.meta.url).pathname)
 
 const formatSize = (bytes) => {
   if (bytes < 1024) return `${bytes}b`
@@ -55,7 +54,7 @@ const buildOptions = {
       name: 'preserve-class-names',
       setup(build) {
         build.onLoad(
-          { filter: /(actions|features)\/.*\.ts$/ },
+          { filter: /(actions|features|routes)\/.*\.ts$/ },
           async (args) => {
             const contents = await readFile(args.path, 'utf8')
             const result = await esbuild.transform(contents, {

package/src/http.ts

@@ -1,6 +1,7 @@
 import type { Context, Next } from 'hono'
 import { MiddlewareType } from './middleware'
 import response from './response'
+import { GET_REQUEST } from './request'
 import { Ability } from './auth'
 import mergeMiddleware from './utils/merge-middleware'
 import { IRequest } from './types'
@@ -102,7 +103,7 @@ export function Auth(...args: any[]): void | ClassDecorator {
 
 function _auth(target: Function | any) {
   mergeMiddleware(target, async (c: Context, next: Next) => {
-    const req = c.get('_') as IRequest
+    const req = c.get(GET_REQUEST as unknown as string) as IRequest
     const ability = Ability.fromAction(target)
 
     if (!req?.user || !ability || req.cant(ability))

package/src/index.ts

@@ -1,4 +1,7 @@
 export { default as Action } from './action'
 export { default as Middleware } from './middleware'
 export { default as Response } from './response'
-export { Enum } from 't0n'
+export { default as Config } from './config'
+
+export { Enum, Envir } from 't0n'
+export type { EnumStatic, EnumValue, EnumType } from 't0n'

package/src/prod.ts

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

package/src/request.ts

@@ -17,6 +17,8 @@ const cookieWrapper = (c: Context) => ({
   delete: (name: string, opt?: CookieOptions) => deleteCookie(c, name, opt)
 })
 
+export const GET_REQUEST: unique symbol = Symbol()
+
 export default class $Request {
   #c!: Context
   #cookie: ReturnType<typeof cookieWrapper>

package/src/routes.ts

@@ -1,16 +1,17 @@
-import { existsSync, readdirSync, statSync } from 'node:fs'
+import { existsSync, readdirSync, statSync, writeFileSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { Route } from './types'
-import { isAnonFn } from './utils/func'
 
-import { writeFileSync } from 'node:fs'
+import glob from 'tiny-glob'
 import { config } from 'dotenv'
+
+import IMPORT from './utils/import'
+import { isAnonFn } from './utils/func'
 import ensureDir from './utils/ensuredir'
 import versionSHA from './utils/version-sha'
+import type { Route } from './types'
 
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
+const __filename = new URL(import.meta.url).pathname
+const __root = resolve(dirname(__filename), '../../..')
 
 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> => {
@@ -21,7 +22,7 @@ const walk = async (dir: string, baseDir: string, fn: Function, parentMw: string
   const indexFile = join(dir, 'index.ts')
 
   if (existsSync(indexFile)) {
-    const mod = await import(indexFile)
+    const mod = await IMPORT(indexFile)
     const group = mod.default
 
     !isAnonFn(group) && group?.mw?.length && currentMw.push(group?.name)
@@ -35,28 +36,30 @@ const walk = async (dir: string, baseDir: string, fn: Function, parentMw: string
     if (stat.isDirectory()) {
       await walk(fullPath, baseDir, fn, currentMw)
     } else if (file != 'index.ts' && file.endsWith('.ts') && !file.endsWith('.d.ts')) {
-      const mod = await import(fullPath)
+      const mod = await IMPORT(fullPath)
       fn(fullPath, baseDir, mod.default, currentMw)
     }
   }
 }
 
 export async function getRoutes(
-  dirs: string[] = ['actions', 'features']
+  dirs: string[] = ['actions', 'features', 'routes']
 ): Promise<Route[]> {
   const routes: Route[] = []
   let mw: string[] = []
 
   await Promise.all(dirs.map(dir => walk(
-    resolve(__dirname, '../../..', dir),
+    resolve(__root, dir),
     dir,
-    (fullPath: string, baseDir: string, handle: any, middlewares: string[]) => {
+    (path: string, baseDir: string, handle: any, middlewares: string[]) => {
       const name = importName(handle?.name)
-      const file = baseDir + fullPath.split(baseDir)[1]
+      path = path.split(baseDir)[1]
+      const file = baseDir + path
 
+      const m = handle?.m?.toLowerCase()
+      const [method, uri] = m ? [m, handle?.p] : [extractHttpVerb(path), extractHttpPath(path)]
       routes.push({
-        method: handle?.m?.toLowerCase() || '',
-        path: handle?.p || '',
+        method, path: uri,
         name,
         file,
         // @ts-ignore
@@ -69,6 +72,27 @@ export async function getRoutes(
   return sortRoutes(routes)
 }
 
+function extractHttpVerb(file: string) {
+  if (!file) return 'get'
+  const match = file.match(/\.(get|post|put|patch|delete|head|options)\.(?=[jt]s$)/i)
+  return match && match[1] ? match[1].toLowerCase() : 'get'
+}
+
+function extractHttpPath(file: string) {
+  const route = '/'+ file.replace(/\\/g, '/')
+    // .replace(/^(actions|features|routes)\//, '')
+    .replace(/\.[jt]s$/, '')
+    .replace(/\.(get|post|put|patch|delete|head|options)$/i, '')
+    .replace(/\/index$/, '')
+    .split('/')
+    .filter(Boolean)
+    .filter(part => !(part.startsWith('(') && part.endsWith(')')))
+    .map(part => part.startsWith('[') && part.endsWith(']') ? ':'+ part.slice(1, -1) : part)
+    .join('/')
+
+  return route == '/' ? '/' : route.replace(/\/$/, '')
+}
+
 function sortRoutes(routes: Route[]) {
   const metas = new Map<string, { score: number, segmentsCount: number }>()
 
@@ -109,7 +133,7 @@ export async function getMiddlewares(
   const mw: Route[] = []
 
   await Promise.all(dirs.map(dir => walk(
-    resolve(__dirname, '../../..', dir),
+    resolve(__root, dir),
     dir,
     (fullPath: string, baseDir: string, handle: any) => {
       // @ts-ignore
@@ -124,6 +148,36 @@ export async function getMiddlewares(
   return mw
 }
 
+function extractName(file: string) {
+  return file.replace(/\.[^/.]+$/, '').split('/').slice(1).join('.')
+}
+
+export async function getConfigs(
+  dirs: string[] = ['configs']
+): Promise<Record<string, any>> {
+  if (!dirs?.length) return {}
+  const configs: Record<string, any> = {}
+
+  const files = await glob(join(__root, dirs?.length > 1 ? `{${dirs.join(',')}}` : dirs[0], '/**/*.{ts,js,json}'))
+
+  for (const file of files) {
+    const mod = await IMPORT(join(__root, file))
+    const keyPath = extractName(file).split('.')
+
+    keyPath.reduce((acc, key, index) => {
+      if (index == keyPath.length - 1) {
+        acc[key] = mod.default
+      } else if (!acc[key] || typeof acc[key] != 'object') {
+        acc[key] = {}
+      }
+
+      return acc[key]
+    }, configs)
+  }
+
+  return configs
+}
+
 const env = Object.entries(
   config({ path: '../../.env.prod' })?.parsed || {}
 ).filter(([key, val]) => key?.toLowerCase().indexOf('aws') != 0) // prevent AWS credentials
@@ -132,18 +186,46 @@ const version = versionSHA('../../.git') // @ts-ignore
 env.push(['VERSION_SHA', process.env['VERSION_SHA'] = version]) // @ts-ignore
 env.push(['VERSION_HASH', process.env['VERSION_HASH'] = version?.substring(0, 7)])
 
+const IDENTIFIER_RE = /^[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*$/u
+function stringifyToJS(value: unknown): string {
+  if (value === null) return 'null'
+  if (value === undefined) return 'undefined'
+
+  const type = typeof value
+
+  if (type == 'string') return JSON.stringify(value)
+  if (type == 'number' || type == 'boolean') return String(value)
+  if (type == 'bigint') return `${value}n`
+  if (type == 'function') return value.toString()
+
+  if (Array.isArray(value))
+    return `[${value.map(stringifyToJS).join(',')}]`
+
+  if (type == 'object') {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .map(([key, val]) => `${IDENTIFIER_RE.test(key) ? key : JSON.stringify(key)}:${stringifyToJS(val)}`)
+
+    return `{${entries.join(',')}}`
+  }
+
+  return 'undefined'
+}
+
 export async function cacheRoutes() {
-  const rolePath = join(__dirname, '../../../roles.json')
+  const rolePath = join(__root, 'configs/roles.ts')
+  ensureDir(rolePath)
   if (!existsSync(rolePath))
-    writeFileSync(rolePath, '{}')
+    writeFileSync(rolePath, `export default {\n\n}`)
 
   const routes = await getRoutes()
   const middlewares = await getMiddlewares()
+  const configs = Object.entries(await getConfigs())
 
-  const iPath = join(__dirname, '../../../tmp/import-routes.mjs')
+  const iPath = join(__root, 'tmp/import-routes.mjs')
   ensureDir(iPath)
   writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
-${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key + ':' + JSON.stringify(val)).join(',')}})` : ''}
+${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key +':'+ stringifyToJS(val)).join(',')}})` : ''}
+${configs?.length ? `import Config from '../node_modules/rajt/src/config'\nConfig.add({${configs.map(([key, val]) => key +':'+ stringifyToJS(val)).join(',')}})` : ''}
 
 import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
 
@@ -169,7 +251,7 @@ try {
 }
 `)
 
-  const rPath = join(__dirname, '../../../tmp/routes.json')
+  const rPath = join(__root, 'tmp/routes.json')
   ensureDir(rPath)
   writeFileSync(rPath, JSON.stringify(routes.filter(r => r.method && r.path).map(route => [
     route.method,

package/src/utils/import.ts

@@ -0,0 +1,3 @@
+export default async function importUncached(path: string) {
+  return import(path +'?v='+ Date.now())
+}

package/src/utils/json-import.ts

@@ -1,10 +1,8 @@
 import { readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
 
 export default function jsonImport<T = any>(filePath: string, defaultValue: T = {} as T): T {
-  const __filename = fileURLToPath(import.meta.url)
-  const __dirname = dirname(__filename)
+  const __dirname = dirname(new URL(import.meta.url).pathname)
 
   try {
     const fullPath = join(__dirname, filePath)

package/src/utils/logger.ts

@@ -13,17 +13,18 @@ export interface ILogger {
   // custom
   step(...data: any[]): void;
   substep(...data: any[]): void;
+  stepWarn(...data: any[]): void;
   ln(): void;
 }
 
 export const logger = {
-	step(...args: any[]) {
-		if (args?.length && args.length < 2) return _console.log(colors.blue('⁕') +` ${args[0]}\n`)
+  $step(color: Function, ...args: any[]) {
+    if (args?.length && args.length < 2) return _console.log(color('⁕') +` ${args[0]}\n`)
 		const length = args.length - 1
 		args.forEach((arg, index) => {
 				switch (index) {
 					case 0:
-						return _console.log(colors.blue('⁕') + ' ' + arg)
+						return _console.log(color('⁕') + ' ' + arg)
 						// return _console.log(colors.blue('⁕') +` ${arg} \n`)
 					case length:
 						return _console.log(`   ${colors.gray('⁕')} ${arg}\n`)
@@ -31,6 +32,12 @@ export const logger = {
 						return _console.log(`   ${colors.gray('⁕')} ` + arg)
 				}
     })
+  },
+	step(...args: any[]) {
+		this.$step(colors.blue, ...args)
+	},
+	stepWarn(...args: any[]) {
+		this.$step(colors.yellow, ...args)
 	},
 	substep(...args: any[]) {
 		args.forEach(arg => _console.log(`   ${colors.gray('⁕')} ` + arg))

package/src/bin/rajt.js

@@ -1,123 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { join, dirname } from "node:path";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const ERR_NODE_VERSION = "18.0.0";
-const MIN_NODE_VERSION = "18.0.0";
-
-let rajtProcess;
-
-// Executes ../src/cli/index.ts
-function runRajt() {
-  if (semiver(process.versions.node, ERR_NODE_VERSION) < 0) {
-    console.error(
-      `Rajt requires at least Node.js v${MIN_NODE_VERSION}. You are using v${process.versions.node}. Please update your version of Node.js.
-
-Consider using a Node.js version manager such as https://volta.sh or https://github.com/nvm-sh/nvm.`
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  const tsxPaths = [
-    // join(__dirname, "../node_modules/.bin/tsx"),
-    // join(__dirname, "../../.bin/tsx"),
-    join(__dirname, "../node_modules/.bin/tsx"),
-    join(__dirname, "../../node_modules/.bin/tsx"),
-    join(process.cwd(), "node_modules/.bin/tsx"),
-    "tsx",
-  ];
-
-  let tsxPath;
-  for (const pathOption of tsxPaths) {
-    if (pathOption == "tsx" || existsSync(pathOption)) {
-      tsxPath = pathOption;
-      break;
-    }
-  }
-
-  if (!tsxPath) {
-    console.error("TypeScript file found but 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,
-    [
-      "--no-warnings",
-      ...process.execArgv,
-      tsxPath,
-      join(__dirname, "../rajt/src/cli/index.ts"),
-      ...process.argv.slice(2),
-    ].filter(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',
-      }
-    }
-  )
-    .on("exit", (code) =>
-      process.exit(code == null ? 0 : code)
-    )
-    .on("message", (message) => {
-      if (process.send) {
-        process.send(message);
-      }
-    })
-    .on("disconnect", () => {
-      if (process.disconnect) {
-        process.disconnect();
-      }
-    });
-}
-
-var fn = new Intl.Collator(0, { numeric: 1 }).compare;
-
-function semiver(a, b, bool) {
-  a = a.split(".");
-  b = b.split(".");
-
-  return (
-    fn(a[0], b[0]) ||
-    fn(a[1], b[1]) ||
-    ((b[2] = b.slice(2).join(".")),
-      (bool = /[.-]/.test((a[2] = a.slice(2).join(".")))),
-      bool == /[.-]/.test(b[2]) ? fn(a[2], b[2]) : bool ? -1 : 1)
-  );
-}
-
-function directly() {
-  try {
-    return ![typeof require, typeof module].includes('undefined') && require.main == module
-      || import.meta.url == `file://${process.argv[1]}`
-      || process.argv[1].endsWith(process.env?.npm_package_bin_rajt)
-      || import.meta?.url?.endsWith(process.env?.npm_package_bin_rajt)
-  } catch {
-    return false
-  }
-}
-
-if (directly()) {
-  rajtProcess = runRajt();
-  process.on("SIGINT", () => {
-    rajtProcess && rajtProcess.kill();
-  });
-  process.on("SIGTERM", () => {
-    rajtProcess && rajtProcess.kill();
-  });
-}