rajt 0.0.18 → 0.0.20

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.18",
+  "version": "0.0.20",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/auth/token.ts

@@ -7,14 +7,7 @@ export class Token {
   static #prefix: string = 'bearer'
 
   static fromRequest(c: Context) {
-    // const token = this.fromHeader(c.req)
-    // Mock user
-    const token = this.create(c.req, {
-      name: 'Nicolau',
-      email: 'nicolau@zunq.com',
-      role: 'user',
-    }).get()
-
+    const token = this.fromHeader(c.req)
     return token ? this.parse(c.req, token) : null
   }
 

package/src/create-app.ts

@@ -9,7 +9,7 @@ import { Routes } from './types'
 import { BadRequest, Unauthorized } from './exceptions'
 import response from './response'
 import { resolve, resolveMiddleware } from './utils/resolve'
-import { getGlobalMiddlewares, getHandler } from './register'
+import { getMiddlewares, getHandler } from './register'
 import env from './utils/environment'
 
 type InitFunction<E extends Env = Env> = (app: Hono<E>) => void
@@ -90,13 +90,13 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
       response.setContext(c)
       await next()
     },
-    ...getGlobalMiddlewares()
+    ...getMiddlewares()
   ]
   middlewares.forEach(mw => {
     // @ts-ignore
     const h = resolveMiddleware(mw)
     // @ts-ignore
-    mw?.p ? app.use(String(mw.p), h) : app.use(h)
+    mw?.path ? app.use(String(mw.path), h) : app.use(h)
   })
 
   app.onError(options?.onError || EHandler)

package/src/dev.ts

@@ -1,14 +1,21 @@
 import { config } from 'dotenv'
 import { serve } from '@hono/node-server'
 import createApp from './create-app'
-import getRoutes from './routes'
+import { getRoutes, getMiddlewares } from './routes'
+import { registerHandler, registerMiddleware } from './register'
 import { Ability } from './auth'
 import { getAvailablePort } from './utils/port'
 import jsonImport from './utils/json-import'
 
 config({ path: '../../.env.dev' })
 
-const routes = await getRoutes()
+let routes = await getRoutes()
+routes.forEach(r => registerHandler(r.name, r.handle))
+routes = routes.filter(r => r?.path)
+
+const middlewares = await getMiddlewares()
+middlewares.forEach(mw => registerMiddleware(mw.handle))
+
 Ability.fromRoutes(routes)
 Ability.roles = jsonImport('../../../../.rolefile')
 

package/src/http.ts

@@ -2,7 +2,6 @@ import type { Context, Next } from 'hono'
 import { MiddlewareType } from './middleware'
 import JsonResponse from './response'
 import { Ability, Authnz, Token } from './auth'
-import { registerGlobalMiddleware } from './register'
 import mergeMiddleware from './utils/merge-middleware'
 
 function method(method: string, path = '/') {
@@ -42,17 +41,6 @@ export function Middlewares(...handlers: MiddlewareType[]) {
   return Middleware(...handlers)
 }
 
-type MiddlewareOpt = string | RegExp
-export function GlobalMiddleware(): ClassDecorator
-export function GlobalMiddleware(target: Function): void
-export function GlobalMiddleware(opt?: MiddlewareOpt): ClassDecorator
-export function GlobalMiddleware(...args: any[]): void | ClassDecorator {
-  if (typeof args[0] === 'function')
-    return _globalmw(args[0])
-
-  return (target: any) => _globalmw(target, ...args)
-}
-
 export function Auth(target: Function): void
 export function Auth(): ClassDecorator
 export function Auth(...args: any[]): void | ClassDecorator {
@@ -76,9 +64,3 @@ function _auth(target: Function | any) {
     await next()
   })
 }
-
-function _globalmw(target: Function | any, path?: string) {
-  target.gmw = true
-  target.p = path
-  registerGlobalMiddleware(target)
-}

package/src/middleware.ts

@@ -1,12 +1,11 @@
 import type { Context, MiddlewareHandler, Next } from 'hono'
 
-export type IMiddleware = {
-  handle(c: Context, next: Next): Promise<void> | void
-}
-
-export default abstract class Middleware implements IMiddleware {
-  abstract handle(c: Context, next: Next): Promise<void> | void
-}
-
-// export type MiddlewareHandler = (c: Context, next: Next) => Promise<void> | void
 export type MiddlewareType = MiddlewareHandler | Middleware | (new () => Middleware)
+export default abstract class Middleware {
+  static factory?: Function
+  static opts?: object | any[]
+  static path: string = '*'
+  static async handle(c: Context, next: Next): Promise<void> {
+    await next()
+  }
+}

package/src/register.ts

@@ -25,7 +25,7 @@ export function getHandler(id: string): Function {
 }
 
 export const _mw: Function[] = []
-export const getGlobalMiddlewares = () => _mw
-export function registerGlobalMiddleware(handler: any) {
+export const getMiddlewares = () => _mw
+export function registerMiddleware(handler: any) {
   _mw.push(handler)
 }

package/src/routes.ts

@@ -2,67 +2,86 @@ import { existsSync, readdirSync, statSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { Route } from './types'
-import { registerHandler } from './register'
 import { isAnonFn } from './utils/func'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
-export default async function getRoutes(
-  all: boolean = false,
-  dirs: string[] = ['actions', 'features', 'errors', 'middlewares']
-): Promise<Route[]> {
-  const routes: Route[] = []
+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
+  const files = readdirSync(dir)
 
-  const walk = async (dir: string, baseDir: string, middlewares: Function[] = []): Promise<void> => {
-    if (!existsSync(dir)) return
-    const files = readdirSync(dir)
+  const currentMw = [...parentMw]
+  const indexFile = join(dir, 'index.ts')
 
-    for (const file of files) {
-      const fullPath = join(dir, file)
-      const stat = statSync(fullPath)
+  if (existsSync(indexFile)) {
+    const mod = await import(indexFile)
+    const group = mod.default
+
+    !isAnonFn(group) && group?.mw?.length && currentMw.push(group?.name)
+    fn(indexFile, baseDir, group, currentMw)
+  }
 
-      if (stat.isDirectory()) {
-        const indexFile = join(fullPath, 'index.ts')
+  for (const file of files) {
+    const fullPath = join(dir, file)
+    const stat = statSync(fullPath)
 
-        if (existsSync(indexFile)) {
-          const mod = await import(indexFile)
-          const group = mod.default
-          registerHandler(group.name, group)
-          !isAnonFn(group) && middlewares.push(group.name)
+    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)
+      fn(fullPath, baseDir, mod.default, currentMw)
+    }
+  }
+}
 
-          all && routes.push({
-            method: '',
-            path: '',
-            name: group.name.replace(/\.ts$/, ''),
-            file: baseDir + indexFile.split(baseDir)[1],
-            middlewares,
-            handle: group,
-          })
-        }
 
-        await walk(fullPath, baseDir, middlewares)
-      } else if (file.endsWith('.ts')) {
-        const mod = await import(fullPath)
-        const handle = mod.default
+export async function getRoutes(
+  dirs: string[] = ['actions', 'features']
+): Promise<Route[]> {
+  const routes: Route[] = []
+  let mw: string[] = []
 
-        if (handle?.gmw) return
-        if (handle?.m) {
-          registerHandler(handle.name, handle)
+  await Promise.all(dirs.map(dir => walk(
+    resolve(__dirname, '../../..', dir),
+    dir,
+    (fullPath: string, baseDir: string, handle: any, middlewares: string[]) => {
+      const name = importName(handle?.name)
+      const file = baseDir + fullPath.split(baseDir)[1]
 
-          routes.push({
-            method: handle.m.toLowerCase(),
-            path: handle.p,
-            name: handle.name.replace(/\.ts$/, ''),
-            file: baseDir + fullPath.split(baseDir)[1],
-            middlewares,
-            handle,
-          })
-        }
-      }
+      routes.push({
+        method: handle?.m?.toLowerCase() || '',
+        path: handle?.p || '',
+        name,
+        file,
+        // @ts-ignore
+        middlewares,
+        handle,
+      })
     }
-  }
+  )))
 
-  await Promise.all(dirs.map(dir => walk(resolve(__dirname, '../../..', dir), dir)))
   return routes
 }
+
+export async function getMiddlewares(
+  dirs: string[] = ['middlewares']
+): Promise<Route[]> {
+  const mw: Route[] = []
+
+  await Promise.all(dirs.map(dir => walk(
+    resolve(__dirname, '../../..', dir),
+    dir,
+    (fullPath: string, baseDir: string, handle: any) => {
+      // @ts-ignore
+      mw.push({
+        name: importName(handle?.name),
+        file: baseDir + fullPath.split(baseDir)[1],
+        handle,
+      })
+    }
+  )))
+
+  return mw
+}

package/src/scripts/cache-routes.ts

@@ -1,6 +1,6 @@
 import { existsSync, writeFileSync } from 'node:fs'
 import { config } from 'dotenv'
-import getRoutes from '../routes'
+import { getRoutes, getMiddlewares } from '../routes'
 import ensureDir from '../utils/ensuredir'
 
 config({ path: '../../.env.dev' })
@@ -10,14 +10,16 @@ async function cacheRoutes() {
   if (!existsSync(rolePath))
     writeFileSync(rolePath, '{}')
 
-  const routes = await getRoutes(true)
+  const routes = await getRoutes()
+  const middlewares = await getMiddlewares()
 
   const iPath = '../../tmp/import-routes.mjs'
   ensureDir(iPath)
   writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
-import { registerHandler } from '../node_modules/rajt/src/register'
+import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
 
 ${routes.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
+${middlewares.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
 
 try {
   const handlers = {${routes.map(r => r.name).join()}}
@@ -27,6 +29,12 @@ try {
       registerHandler(name, handler)
     }
   }
+
+  const middlewares = {${middlewares.map(r => r.name).join()}}
+
+  for (const [name, mw] of Object.entries(handlers)) {
+    registerMiddleware(mw)
+  }
 } catch (e) {
   console.error('Failed to register handlers:', e)
 }

package/src/utils/environment.ts

@@ -1,22 +1,15 @@
 export default function getEnvironment() {
-  if (process.env?.npm_lifecycle_event === 'dev')
-    return 'dev'
-
-  if (
-    process.argv?.includes('--dev')
-    || process.execArgv?.includes('--watch')
-    || import.meta.url?.includes('localhost')
-  )
-    return 'dev'
-
-  // @ts-ignore
-  if (typeof Bun === 'undefined') return 'prod'
-
-  // @ts-ignore
-  if (Bun.argv.includes('--prod')) return 'prod'
-  // @ts-ignore
-  if (Bun.argv.includes('--dev') || Bun.main.endsWith('.ts')) return 'dev'
-
+  try {
+    if (
+      process.env?.npm_lifecycle_event === 'dev'
+      || process.env?.AWS_SAM_LOCAL
+      || process?.argv?.includes('--dev')
+      || process?.execArgv?.includes('--watch')
+      || import.meta.url?.includes('localhost')
+    ) {
+      return 'dev'
+    }
+  } catch (e) { }
 
   return 'prod'
 }

package/src/utils/resolve.ts

@@ -22,19 +22,14 @@ export function resolveMiddleware(obj: MiddlewareType) {
   if (typeof obj === 'function' && obj.length === 2)
     return obj
 
+  if (obj?.factory)
+    return obj?.opts ? obj.factory(...Array.isArray(obj.opts) ? obj.opts : [obj.opts]) : obj.factory()
+
   if (obj?.handle)
     return obj.handle
 
   if (obj.prototype?.handle)
     return (new obj()).handle
 
-  // if (obj instanceof BaseMiddleware)
-  //   return obj.handle
-
-  // if (BaseMiddleware.isPrototypeOf(obj)) {
-  //   const instance = new (obj as new () => BaseMiddleware)()
-  //   return instance.handle
-  // }
-
   throw new Error('Invalid middleware provided. Must be a Hono middleware function or MiddlewareClass instance/constructor')
 }