rajt 0.0.59 → 0.0.61

package/README.md

@@ -1,7 +1,12 @@
 <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/>
 
-> 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/{src/bin → bin}/rajt.js

@@ -56,7 +56,7 @@ Consider using a Node.js version manager such as https://volta.sh or https://git
       "--no-warnings",
       ...process.execArgv,
       tsxPath,
-      join(__dirname, "../rajt/src/cli/index.ts"),
+      join(__dirname, "../cli/index.ts"),
       ...process.argv.slice(2),
     ].filter(arg =>
       !arg.includes('experimental-vm-modules') &&
@@ -103,10 +103,8 @@ function semiver(a, b, bool) {
 
 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)
+    return process.env?.npm_lifecycle_script == 'rajt'
+      && process.argv[1]?.endsWith('node_modules/.bin/rajt')
   } catch {
     return false
   }

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.59",
+  "version": "0.0.61",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "rajt": "./src/bin/rajt.js"
+    "rajt": "./bin/rajt.js"
   },
   "exports": {
     ".": "./src/index.ts",
     "./auth": "./src/auth/index.ts",
     "./d1": "./src/db/d1.ts",
-    "./d1/types": "./src/db.d.ts",
+    "./d1/types": "./src/db/d1.d.ts",
     "./dynamodb": "./src/db/dynamodb.ts",
     "./dynamodb/types": "./src/db/dynamodb.d.ts",
     "./enum": "./src/enum.ts",
@@ -21,6 +21,7 @@
     "./length": "./src/utils/length.ts"
   },
   "files": [
+    "bin",
     "src"
   ],
   "scripts": {
@@ -53,9 +54,9 @@
   "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",
     "ua-parser-js": "^2.0.4"
   },
   "devDependencies": {
@@ -79,6 +80,7 @@
     "esbuild": "^0.25.2",
     "miniflare": "^4.20251217.0",
     "picocolors": "^1.1.1",
+    "tiny-glob": "^0.2",
     "tsx": "^4.19.3",
     "typescript": "^5.8.3",
     "wrangler": "^4.56.0"

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

@@ -228,13 +228,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

@@ -79,7 +79,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/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/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.ts

@@ -3,8 +3,9 @@ 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 Config from './config'
 import { Ability } from './auth'
 import jsonImport from './utils/json-import'
 import { setEnv, detectEnvironment } from './utils/environment'
@@ -16,15 +17,17 @@ const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../')
 
 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'))
+Ability.roles = Config.get('roles', {})
 
 const fetch = createApp({ routes }).fetch
 

package/src/esbuild.mjs

@@ -55,7 +55,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/index.ts

@@ -1,4 +1,5 @@
 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'

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/routes.ts

@@ -1,16 +1,18 @@
-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 __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 +23,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 +37,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 +73,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 +134,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 +149,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 +187,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 +252,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())
+}