rajt 0.0.103 → 0.0.104

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.103",
+  "version": "0.0.104",
   "type": "module",
   "main": "./src/index.ts",
   "files": ["bin", "src"],

package/src/auth/ability.ts

@@ -1,21 +1,41 @@
-import { Routes } from '../types'
+import type { IRequest, Routes } from '../types'
 import { Roles, Abilities } from './types'
+import { verbAlias } from '../http'
 
 export class Ability {
   static #roles: Roles = {}
   static #abilities: Abilities = []
+  static #actions: Record<string, string> = {}
 
   static empty() {
     this.#roles = {}
     this.#abilities = []
   }
 
-  static fromRoutes(actions: Routes) {
-    if (!actions?.length) return
+  static fromRoutes(routes: Routes) {
+    if (!routes?.length) return
 
-    this.#abilities = Array.from(new Set(actions?.map(a => Array.isArray(a) ? a[3] : a.name) || []))
-      .map(a => this.format(a))
-      .filter(Boolean)
+    const actions: Record<string, string> = {}
+    const abilities = new Set()
+    for (const route of routes) {
+      const isArr = Array.isArray(route)
+      const name = isArr ? route[3] : route.name
+      if (!name || abilities.has(name)) continue
+
+      abilities.add(name)
+      actions[(isArr ? route[1] : route.path) +'$'+ verbAlias[isArr ? route[0] : route.method]] = name
+      const formatted = this.format(name)
+
+      if (formatted)
+        this.#abilities.push(formatted)
+    }
+
+    this.#actions = actions
+  }
+
+  static fromRequest(req: IRequest) {
+    const ability = this.#actions[`${req.routePath}$` + verbAlias[req.method.toLowerCase()]]
+    return ability ? this.format(ability) : ''
   }
 
   static fromAction(target: any): string {

package/src/auth/middlewares.ts

@@ -1,16 +1,11 @@
 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'
+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()]))
+  const ability = Ability.fromRequest(req)
 
   if (!req?.user || !ability || req.cant(ability))
     return response.unauthorized()

package/src/cli/utils.ts

@@ -142,7 +142,7 @@ export const build = async (platform: Platform, env: string = 'prd') => {
   const opts = {
     entryPoints: [join(_rajt, `prod${platform}.ts`)],
     bundle: true,
-    minify: true,
+    minify: false,
     outfile: join(_root, dist +'/index.js'),
     format: 'esm',
     target: isCF ? 'es2022' : 'node20',

package/src/config.ts

@@ -1,77 +1,4 @@
 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()
-  }
-
-  // @ts-ignore
-  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]()
-  }
-}
+const Config = new DataBag()
+export default Config

package/src/routes.ts

@@ -328,7 +328,7 @@ async function dependencyPath(lib: string) {
 export async function cacheRoutes() {
   const env = Object.entries(
     config({ path: join(_root, '.env.prod') })?.parsed || {}
-  ).filter(([key, val]) => key?.toLowerCase().startsWith('aws')) // prevent AWS credentials
+  ).filter(([key, val]) => !key?.toLowerCase().startsWith('aws')) // prevent AWS credentials
 
   const version = versionSHA('../../.git') // @ts-ignore
   env.push(['VERSION_SHA', process.env['VERSION_SHA'] = version]) // @ts-ignore
@@ -387,7 +387,6 @@ 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')}