rajt 0.0.17 → 0.0.19

package/src/routes.ts

@@ -1,27 +1,31 @@
-import fs from 'node:fs'
-import path from 'node:path'
+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 = path.dirname(__filename)
+const __dirname = dirname(__filename)
 
-export default async function getRoutes(all: boolean = false, baseDir: string = 'actions'): Promise<Route[]> {
+export async function getRoutes(
+  all: boolean = false,
+  dirs: string[] = ['actions', 'features']
+): Promise<Route[]> {
   const routes: Route[] = []
 
-  const walk = async (dir: string, middlewares: Function[] = []): Promise<void> => {
-    const files = fs.readdirSync(dir)
+  const walk = async (dir: string, baseDir: string, middlewares: Function[] = []): Promise<void> => {
+    if (!existsSync(dir)) return
+    const files = readdirSync(dir)
 
     for (const file of files) {
-      const fullPath = path.join(dir, file)
-      const stat = fs.statSync(fullPath)
+      const fullPath = join(dir, file)
+      const stat = statSync(fullPath)
 
       if (stat.isDirectory()) {
-        const indexFile = path.join(fullPath, 'index.ts')
+        const indexFile = join(fullPath, 'index.ts')
 
-        if (fs.existsSync(indexFile)) {
+        if (existsSync(indexFile)) {
           const mod = await import(indexFile)
           const group = mod.default
           registerHandler(group.name, group)
@@ -37,11 +41,12 @@ export default async function getRoutes(all: boolean = false, baseDir: string =
           })
         }
 
-        await walk(fullPath, middlewares)
+        await walk(fullPath, baseDir, middlewares)
       } else if (file.endsWith('.ts')) {
         const mod = await import(fullPath)
         const handle = mod.default
 
+        if (handle?.gmw) return
         if (handle?.m) {
           registerHandler(handle.name, handle)
 
@@ -58,6 +63,57 @@ export default async function getRoutes(all: boolean = false, baseDir: string =
     }
   }
 
-  await walk(path.resolve(__dirname, '../../..', baseDir))
+  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[] = []
+
+  const walk = async (dir: string, baseDir: string, middlewares: Function[] = []): Promise<void> => {
+    if (!existsSync(dir)) return
+    const files = readdirSync(dir)
+
+    for (const file of files) {
+      const fullPath = join(dir, file)
+      const stat = statSync(fullPath)
+
+      if (stat.isDirectory()) {
+        const indexFile = join(fullPath, 'index.ts')
+
+        if (existsSync(indexFile)) {
+          const mod = await import(indexFile)
+          const group = mod.default
+
+          if (group?.gmw) {
+            // @ts-ignore
+            mw.push({
+              name: group.name.replace(/\.ts$/, ''),
+              file: baseDir + fullPath.split(baseDir)[1],
+              handle: group,
+            })
+          }
+        }
+
+        await walk(fullPath, baseDir, middlewares)
+      } else if (file.endsWith('.ts')) {
+        const mod = await import(fullPath)
+        const handle = mod.default
+
+        if (handle?.gmw) {
+          // @ts-ignore
+          mw.push({
+            name: handle.name.replace(/\.ts$/, ''),
+            file: baseDir + fullPath.split(baseDir)[1],
+            handle,
+          })
+        }
+      }
+    }
+  }
+
+  await Promise.all(dirs.map(dir => walk(resolve(__dirname, '../../..', dir), dir)))
+  return mw
+}

package/src/scripts/cache-routes.ts

@@ -1,9 +1,17 @@
-import { writeFileSync } from 'node:fs'
-import getRoutes from '../routes'
+import { existsSync, writeFileSync } from 'node:fs'
+import { config } from 'dotenv'
+import { getRoutes, getMiddlewares } from '../routes'
 import ensureDir from '../utils/ensuredir'
 
+config({ path: '../../.env.dev' })
+
 async function cacheRoutes() {
+  const rolePath = '../../roles.json'
+  if (!existsSync(rolePath))
+    writeFileSync(rolePath, '{}')
+
   const routes = await getRoutes(true)
+  const middlewares = await getMiddlewares()
 
   const iPath = '../../tmp/import-routes.mjs'
   ensureDir(iPath)
@@ -11,6 +19,7 @@ async function cacheRoutes() {
 import { registerHandler } 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()}}

package/src/utils/json-import.ts

@@ -0,0 +1,16 @@
+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)
+
+  try {
+    const fullPath = join(__dirname, filePath)
+    const fileContent = readFileSync(fullPath, 'utf-8')
+    return JSON.parse(fileContent) as T
+  } catch (error) {
+    return defaultValue
+  }
+}

package/src/utils/merge-middleware.ts

@@ -0,0 +1,9 @@
+import type { MiddlewareHandler } from 'hono'
+import { MiddlewareType } from '../middleware'
+import { resolveMiddleware } from './resolve'
+
+export default function mergeMiddleware(target: Function | any, ...handlers: MiddlewareType[]) {
+  const existingMiddlewares: MiddlewareHandler[] = target?.mw || []
+  const allMiddlewares = [...existingMiddlewares, ...handlers.flat().map(handler => resolveMiddleware(handler))]
+  target.mw = allMiddlewares
+}

package/src/utils/resolve.ts

@@ -1,6 +1,7 @@
 import Action, { ActionType } from '../action'
+import { MiddlewareType } from '../middleware'
 
-export default function resolve(obj: ActionType) {
+export function resolve(obj: ActionType) {
   if (typeof obj === 'function' && obj?.length === 2)
     return [obj]
 
@@ -16,3 +17,24 @@ export default function resolve(obj: ActionType) {
 
   throw new Error('Invalid action')
 }
+
+export function resolveMiddleware(obj: MiddlewareType) {
+  if (typeof obj === 'function' && obj.length === 2)
+    return obj
+
+  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')
+}