rajt 0.0.34 → 0.0.36

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.34",
+  "version": "0.0.36",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -12,13 +12,15 @@
     "./http": "./src/http.ts",
     "./types": "./src/types.ts"
   },
-  "files": ["src"],
+  "files": [
+    "src"
+  ],
   "scripts": {
     "dev": "tsx watch src/dev.ts",
     "local": "bun run --silent build && bun run --silent sam:local",
     "build": "bun run --silent cache:routes && bun run --silent export && bun run --silent clean:temp",
     "build:watch": "chokidar \"../../{actions,configs,models,utils}/**/*.ts\" -c \"bun run --silent build\" --initial",
-    "export": "esbuild --bundle --minify --outfile=../../dist/index.js --platform=node --target=node20 --format=esm --tree-shaking=true --legal-comments=none --external:@aws-sdk --external:@smithy src/prod.ts",
+    "export": "node src/esbuild.mjs",
     "package": "bun run --silent build && bun run --silent sam:package",
     "deploy": "bun run --silent build && bun run --silent sam:package && bun run --silent sam:deploy",
     "update": "bun run --silent build && bun run --silent zip && bun run --silent sam:update",
@@ -83,4 +85,4 @@
     "bun",
     "nodejs"
   ]
-}
+}

package/src/auth/ability.ts

@@ -13,28 +13,35 @@ export class Ability {
   static fromRoutes(actions: Routes) {
     if (!actions?.length) return
 
-    const paths = actions?.map(a => Array.isArray(a) ? a[0]+a[1] : a.method+a.path) || []
+    const paths = actions?.map(a => Array.isArray(a) ? a[0] + a[1] : a.method + a.path) || []
     const items = new Set(paths)
 
     if (items.size !== actions.length)
       throw new Error(`Duplicate routes detected: "${paths.filter((path, index) => paths.indexOf(path) !== index).join('", "')}"`)
 
-    this.#abilities = Array.from(items).map(a => this.format(a)).filter(Boolean)
+    this.#abilities = Array.from(new Set(actions?.map(a => Array.isArray(a) ? a[3] : a.name) || []))
+      .map(a => this.format(a))
+      .filter(Boolean)
   }
 
-  static fromAction(target: any): string | null {
-    return !target || !target?.p ? null : this.format(target.p)
+  static fromAction(target: any): string {
+    return !target ? '' : this.format(target.name.length > 3 ? target.name : (target?.p || ''))
   }
 
   static format(path: string) {
-    return path.normalize('NFD')
-      .replace(/[\u0300-\u036f]/g, '')
-      .replace(/^\/*/, '')
-      .replace(/[^a-zA-Z0-9/]|[\s_.]/g, '-')
-      .replace(/([a-z])([A-Z])/g, '$1-$2')
-      .replace(/\//g, '.')
-      .replace(/-+/g, '-')
-      .toLowerCase()
+    return path == '/'
+      ? 'index'
+      : path.normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/^\/*/, '')
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9/]|[\s_.]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/\//g, '.')
+        .replace(/\.-/g, '.')
+        .replace(/^[._-]+/, '')
+        .replace(/[._-]+$/, '')
+        .toLowerCase()
   }
 
   static get abilities() {

package/src/auth/auth.ts

@@ -23,4 +23,11 @@ export class Auth {
   static hasRole(...roles: string[]): boolean {
     return this.#u ? this.#u.hasRole(...roles) : false
   }
+
+  static has(prop: string, value: any = null): boolean {
+    return this.#u ? this.#u.has(prop, value) : false
+  }
+  static hasValue(prop: string, value: any = null): boolean {
+    return this.has(prop, value)
+  }
 }

package/src/auth/authnz.ts

@@ -4,10 +4,12 @@ export class Authnz<T extends object> {
   #abilities: string[]
   #roles: string[]
   #data: T
+  #token: any
 
-  constructor(data: T, abilities: string[], roles: string[]) {
+  constructor(token: any, data: T, abilities: string[], roles: string[]) {
     this.#abilities = abilities
     this.#roles = roles
+    this.#token = token
     this.#data = data
   }
 
@@ -27,20 +29,27 @@ export class Authnz<T extends object> {
     return roles.flat().every(role => this.#roles.includes(role))
   }
 
-  static fromToken<T extends object>(user: any): Authnz<T> | null {
-    if (!user || user?.isInvalid()) return null
-    user = user.get()
+  has(prop: string, value: any = null): boolean {
+    return this.#token?.hasValue(prop, value) || false
+  }
+  hasValue(prop: string, value: any = null): boolean {
+    return this.has(prop, value)
+  }
+
+  static fromToken<T extends object>(token: any): Authnz<T> | null {
+    if (!token || !token?.isValid()) return null
+    const user = token.get()
     const roles = [...(user?.role ? [user.role] : []), ...(user?.roles ?? [])]
 
     const combined = [...(user?.perms ?? []), ...roles.flatMap(role => {
       const perms = Ability.roles[role]
       if (!perms) return []
-      return perms === '*' ? ['*'] : perms;
+      return perms === '*' ? ['*'] : perms
     })]
 
     const abilities = combined.includes('*') ? ['*'] : Array.from(new Set(combined))
 
-    return new Authnz(user as T, abilities, roles)
+    return new Authnz<T>(token, user, abilities, roles)
   }
 
   #match(rule: string, ability: string): boolean {

package/src/dynamodb/compact.ts

@@ -121,7 +121,7 @@ export default class Compact {
     if (!key) return undefined
 
     if (typeof key == 'string')
-      return [key, value]
+      return [key, value || null]
 
     const mainKey = Object.keys(key)[0]
     const subKeys = key[mainKey]
@@ -135,7 +135,7 @@ export default class Compact {
         : [mainKey, this.withSchema(value, subKeys)]
     }
 
-    return [mainKey, value]
+    return [mainKey, value || null]
   }
 
   static memo(val: any, seen: any[]): any {

package/src/esbuild.mjs

@@ -0,0 +1,66 @@
+import esbuild from 'esbuild'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import fs from 'fs/promises'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const formatSize = (bytes) => {
+  if (bytes < 1024) return `${bytes}b`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)}kb`
+  return `${(bytes / (1024 * 1024)).toFixed(2)}mb`
+}
+const formatTime = (ms) => {
+  if (ms < 1000) return `${ms}ms`
+  return `${(ms / 1000).toFixed(2)}s`
+}
+
+const buildOptions = {
+  entryPoints: [path.join(__dirname, 'prod.ts')],
+  bundle: true,
+  minify: true,
+  outfile: path.join(__dirname, '../../../dist/index.js'),
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  treeShaking: true,
+  legalComments: 'none',
+  external: ['@aws-sdk', '@smithy'],
+  metafile: true,
+  plugins: [{
+    name: 'preserve-class-names',
+    setup(build) {
+      build.onLoad(
+        { filter: /(actions|features)\/.*\.ts$/ },
+        async (args) => {
+          const contents = await fs.readFile(args.path, 'utf8')
+          const result = await esbuild.transform(contents, {
+            loader: 'ts',
+            minify: true,
+            keepNames: true
+          })
+          return { contents: result.code, loader: 'ts' }
+        }
+      )
+    },
+  }]
+}
+
+try {
+  const startTime = Date.now()
+  const result = await esbuild.build(buildOptions)
+
+  const cwd = path.join(__dirname, '../../..')
+
+  const outputFile = buildOptions.outfile
+  const stats = await fs.stat(outputFile)
+  const size = formatSize(stats.size)
+
+  console.log(`\n⚡️ Done in ${formatTime(Date.now() - startTime)}`)
+  console.log(`    ${path.relative(path.join(cwd, 'node_modules/rajt/src'), buildOptions.entryPoints[0])} → ${path.relative(cwd, outputFile)}`)
+  console.log(`    Size: ${size}`)
+  console.log(`    Files: ${Object.keys(result.metafile.outputs).length}`)
+} catch (error) {
+  console.error('❌ Build failed:', error)
+  process.exit(1)
+}

package/src/http.ts

@@ -52,10 +52,10 @@ export function Auth(...args: any[]): void | ClassDecorator {
 
 function _auth(target: Function | any) {
   mergeMiddleware(target, async (c: Context, next: Next) => {
-    const auth = Gate.user()
+    const user = Gate.user
     const ability = Ability.fromAction(target)
 
-    if (!auth || !ability || auth.cant(ability))
+    if (!user || !ability || Gate.cant(ability))
       return Response.unauthorized()
 
     await next()