odac 1.0.1 → 1.2.0

package/src/Route.js

@@ -1,4 +1,5 @@
 const fs = require('fs')
+const fsPromises = fs.promises
 
 const Cron = require('./Route/Cron.js')
 const Internal = require('./Route/Internal.js')
@@ -68,13 +69,16 @@ class Route {
   routes = {}
   middlewares = {}
   _pendingMiddlewares = []
+  _pendingRouteLoads = []
   #wsServer = new WebSocketServer()
+  #configCache = {}
+  #publicCache = {}
   auth = {
     page: (path, authFile, file) => this.authPage(path, authFile, file),
     post: (path, authFile, file) => this.authPost(path, authFile, file),
     get: (path, authFile, file) => this.authGet(path, authFile, file),
     ws: (path, handler, options) => this.authWs(path, handler, options),
-    use: (...middlewares) => new MiddlewareChain(this, [...middlewares.flat()])
+    use: (...middlewares) => new MiddlewareChain(this, [...middlewares.flat()], true)
   }
 
   async #runMiddlewares(Odac, middlewares) {
@@ -90,8 +94,13 @@ class Route {
 
       const result = await middleware(Odac)
 
+      if (Odac.Request.res.finished) {
+        return false
+      }
+
       if (result === false) {
-        return Odac.Request.abort(403)
+        await Odac.Request.abort(403)
+        return false
       }
 
       if (result !== undefined && result !== true) {
@@ -101,15 +110,30 @@ class Route {
   }
 
   async #executeController(Odac, controller) {
-    const middlewareResult = await this.#runMiddlewares(Odac, controller.middlewares)
-    if (middlewareResult !== undefined) return middlewareResult
-
     if (controller.params) {
       for (let key in controller.params) {
         Odac.Request.data.url[key] = controller.params[key]
       }
     }
 
+    const middlewareResult = await this.#runMiddlewares(Odac, controller.middlewares)
+    if (middlewareResult !== undefined) return middlewareResult
+
+    if (controller.action) {
+      const ControllerClass = controller.cache
+      try {
+        const instance = new ControllerClass(Odac)
+        if (typeof instance[controller.action] === 'function') {
+          return instance[controller.action](Odac)
+        }
+      } catch {
+        if (typeof ControllerClass[controller.action] === 'function') {
+          return ControllerClass[controller.action](Odac)
+        }
+      }
+      return Odac.Request.abort(500)
+    }
+
     if (typeof controller.cache === 'function') {
       return controller.cache(Odac)
     }
@@ -126,6 +150,7 @@ class Route {
     if (['post', 'put', 'patch', 'delete'].includes(Odac.Request.method)) {
       const formToken = await Odac.request('_odac_form_token')
       if (formToken) {
+        Odac.Request.setSession()
         await Internal.processForm(Odac)
       }
     }
@@ -152,21 +177,40 @@ class Route {
       Odac.Request.isAjaxLoad = true
       Odac.Request.clientSkeleton = Odac.Request.header('X-Odac-Skeleton')
     }
-    if (Odac.Config && Odac.Config.route && Odac.Config.route[url]) {
-      Odac.Config.route[url] = Odac.Config.route[url].replace('${odac}', `${__dir}/node_modules/odac`)
-      if (fs.existsSync(Odac.Config.route[url])) {
-        let stat = fs.lstatSync(Odac.Config.route[url])
-        if (stat.isFile()) {
-          let type = 'text/html'
-          if (Odac.Config.route[url].includes('.')) {
-            let arr = Odac.Config.route[url].split('.')
-            type = mime[arr[arr.length - 1]]
+    if (Odac.Config?.route?.[url]) {
+      // PROD CACHE HIT
+      if (!Odac.Config.debug && this.#configCache[url]) {
+        const cached = this.#configCache[url]
+        Odac.Request.header('Content-Type', cached.type)
+        Odac.Request.header('Cache-Control', 'public, max-age=31536000')
+        Odac.Request.header('Content-Length', cached.size)
+        return cached.content
+      }
+
+      const filePath = Odac.Config.route[url]
+      try {
+        const content = await fsPromises.readFile(filePath)
+        let type = 'text/html'
+        if (filePath.includes('.')) {
+          let arr = filePath.split('.')
+          type = mime[arr[arr.length - 1]]
+        }
+
+        // PROD CACHE SET
+        if (!Odac.Config.debug) {
+          this.#configCache[url] = {
+            content,
+            type,
+            size: content.length
           }
-          Odac.Request.header('Content-Type', type)
-          Odac.Request.header('Cache-Control', 'public, max-age=31536000')
-          Odac.Request.header('Content-Length', stat.size)
-          return fs.readFileSync(Odac.Config.route[url])
         }
+
+        Odac.Request.header('Content-Type', type)
+        Odac.Request.header('Cache-Control', 'public, max-age=31536000')
+        Odac.Request.header('Content-Length', content.length)
+        return content
+      } catch {
+        // File not found or error, continue routing
       }
     }
     for (let method of ['#' + Odac.Request.method, Odac.Request.method]) {
@@ -174,6 +218,10 @@ class Route {
       if (controller) {
         if (!method.startsWith('#') || (await Odac.Auth.check())) {
           Odac.Request.header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
+          Odac.Request.setSession()
+          const page = controller.cache?.file || controller.file
+          if (typeof page === 'string') Odac.Request.page = page
+
           if (
             ['post', 'get'].includes(Odac.Request.method) &&
             controller.token &&
@@ -187,28 +235,57 @@ class Route {
     }
     let authPageController = this.#controller(Odac.Request.route, '#page', url)
     if (authPageController && (await Odac.Auth.check())) {
-      Odac.Request.page = authPageController.cache?.file || authPageController.file
+      Odac.Request.setSession()
+      const page = authPageController.cache?.file || authPageController.file
+      if (typeof page === 'string') Odac.Request.page = page
       return await this.#executeController(Odac, authPageController)
     }
     let pageController = this.#controller(Odac.Request.route, 'page', url)
     if (pageController) {
-      Odac.Request.page = pageController.cache?.file || pageController.file
+      Odac.Request.setSession()
+      const page = pageController.cache?.file || pageController.file
+      if (typeof page === 'string') Odac.Request.page = page
       return await this.#executeController(Odac, pageController)
     }
-    if (url && !url.includes('/../') && fs.existsSync(`${__dir}/public${url}`)) {
-      let stat = fs.lstatSync(`${__dir}/public${url}`)
-      if (stat.isFile()) {
-        let type = 'text/html'
-        if (url.includes('.')) {
-          let arr = url.split('.')
-          type = mime[arr[arr.length - 1]]
-        }
-        Odac.Request.header('Content-Type', type)
+    if (url && !url.includes('/../')) {
+      const publicPath = `${__dir}/public${url}`
+
+      // PROD CACHE HIT (Metadata)
+      if (!Odac.Config.debug && this.#publicCache[publicPath]) {
+        const cached = this.#publicCache[publicPath]
+        Odac.Request.header('Content-Type', cached.type)
         Odac.Request.header('Cache-Control', 'public, max-age=31536000')
-        Odac.Request.header('Content-Length', stat.size)
-        return fs.readFileSync(`${__dir}/public${url}`)
+        Odac.Request.header('Content-Length', cached.size)
+        return fs.createReadStream(publicPath)
+      }
+
+      try {
+        const stat = await fsPromises.stat(publicPath)
+        if (stat.isFile()) {
+          let type = 'text/html'
+          if (url.includes('.')) {
+            let arr = url.split('.')
+            type = mime[arr[arr.length - 1]]
+          }
+
+          // PROD CACHE SET (Metadata Only)
+          if (!Odac.Config.debug) {
+            this.#publicCache[publicPath] = {
+              type,
+              size: stat.size
+            }
+          }
+
+          Odac.Request.header('Content-Type', type)
+          Odac.Request.header('Cache-Control', 'public, max-age=31536000')
+          Odac.Request.header('Content-Length', stat.size)
+          return fs.createReadStream(publicPath)
+        }
+      } catch {
+        // File not found in public
       }
     }
+
     return Odac.Request.abort(404)
   }
 
@@ -237,21 +314,28 @@ class Route {
           params: params,
           cache: this.routes[route][method][key].cache,
           token: this.routes[route][method][key].token,
-          middlewares: this.routes[route][method][key].middlewares
+          middlewares: this.routes[route][method][key].middlewares,
+          file: this.routes[route][method][key].file
         }
     }
     return false
   }
 
-  #loadMiddlewares() {
+  async #loadMiddlewares() {
     const middlewareDir = `${__dir}/middleware/`
-    if (!fs.existsSync(middlewareDir)) return
+    try {
+      await fsPromises.access(middlewareDir)
+    } catch {
+      return
+    }
 
-    for (const file of fs.readdirSync(middlewareDir)) {
+    const files = await fsPromises.readdir(middlewareDir)
+    for (const file of files) {
       if (!file.endsWith('.js')) continue
       const name = file.replace('.js', '')
       const path = `${middlewareDir}${file}`
-      const mtime = fs.statSync(path).mtimeMs
+      const stat = await fsPromises.stat(path)
+      const mtime = stat.mtimeMs
 
       if (this.middlewares[name] && this.middlewares[name].mtime >= mtime - 1000) continue
 
@@ -264,63 +348,123 @@ class Route {
     }
   }
 
-  #init() {
+  async #init() {
     if (this.loading) return
     this.loading = true
-    this.#loadMiddlewares()
-    for (const file of fs.readdirSync(`${__dir}/controller/`)) {
-      if (!file.endsWith('.js')) continue
-      let name = file.replace('.js', '')
-      if (!Odac.Route.class) Odac.Route.class = {}
-      if (Odac.Route.class[name]) {
-        if (Odac.Route.class[name].mtime >= fs.statSync(Odac.Route.class[name].path).mtimeMs + 1000) continue
-        delete require.cache[require.resolve(Odac.Route.class[name].path)]
-      }
-      Odac.Route.class[name] = {
-        path: `${__dir}/controller/${file}`,
-        mtime: fs.statSync(`${__dir}/controller/${file}`).mtimeMs,
-        module: require(`${__dir}/controller/${file}`)
+    await this.#loadMiddlewares()
+    const classDir = `${__dir}/class/`
+    try {
+      await fsPromises.access(classDir)
+      const files = await fsPromises.readdir(classDir)
+      for (const file of files) {
+        if (!file.endsWith('.js')) continue
+        let name = file.replace('.js', '')
+        if (!Odac.Route.class) Odac.Route.class = {}
+        const filePath = `${__dir}/class/${file}`
+
+        let shouldLoad = true
+        let stat = null
+
+        if (Odac.Route.class[name]) {
+          stat = await fsPromises.stat(Odac.Route.class[name].path)
+          if (Odac.Route.class[name].mtime >= stat.mtimeMs || Date.now() < stat.mtimeMs + 1000) {
+            shouldLoad = false
+          } else {
+            delete require.cache[require.resolve(Odac.Route.class[name].path)]
+          }
+        } else {
+          stat = await fsPromises.stat(filePath)
+        }
+
+        if (shouldLoad) {
+          Odac.Route.class[name] = {
+            path: filePath,
+            mtime: stat.mtimeMs,
+            module: require(filePath)
+          }
+        }
       }
+    } catch {
+      // Class dir might not exist
     }
-    let dir = fs.readdirSync(`${__dir}/route/`)
-    for (const file of dir) {
-      if (!file.endsWith('.js')) continue
-      let mtime = fs.statSync(`${__dir}/route/${file}`).mtimeMs
-      Odac.Route.buff = file.replace('.js', '')
-      if (!routes2[Odac.Route.buff] || routes2[Odac.Route.buff] < mtime - 1000) {
-        delete require.cache[require.resolve(`${__dir}/route/${file}`)]
-        routes2[Odac.Route.buff] = mtime
-        require(`${__dir}/route/${file}`)
-      }
-      for (const type of ['page', '#page', 'post', '#post', 'get', '#get', 'error']) {
-        if (!this.routes[Odac.Route.buff]) continue
-        if (!this.routes[Odac.Route.buff][type]) continue
-        for (const route in this.routes[Odac.Route.buff][type]) {
-          if (routes2[Odac.Route.buff] > this.routes[Odac.Route.buff][type][route].loaded) {
-            delete require.cache[require.resolve(this.routes[Odac.Route.buff][type][route].path)]
-            delete this.routes[Odac.Route.buff][type][route]
-          } else if (this.routes[Odac.Route.buff][type][route]) {
-            if (typeof this.routes[Odac.Route.buff][type][route].type === 'function') continue
-            if (this.routes[Odac.Route.buff][type][route].mtime < fs.statSync(this.routes[Odac.Route.buff][type][route].path).mtimeMs) {
-              delete require.cache[require.resolve(this.routes[Odac.Route.buff][type][route].path)]
-              this.routes[Odac.Route.buff][type][route].cache = require(this.routes[Odac.Route.buff][type][route].path)
-              this.routes[Odac.Route.buff][type][route].mtime = fs.statSync(this.routes[Odac.Route.buff][type][route].path).mtimeMs
+
+    try {
+      const dir = await fsPromises.readdir(`${__dir}/route/`)
+      for (const file of dir) {
+        if (!file.endsWith('.js')) continue
+        const filePath = `${__dir}/route/${file}`
+        const stat = await fsPromises.stat(filePath)
+        let mtime = stat.mtimeMs
+        Odac.Route.buff = file.replace('.js', '')
+
+        if (!routes2[Odac.Route.buff] || routes2[Odac.Route.buff] < mtime - 1000) {
+          delete require.cache[require.resolve(filePath)]
+          routes2[Odac.Route.buff] = mtime
+          const routeModule = require(filePath)
+          if (typeof routeModule === 'function') {
+            // routeModule calls .set(), which pushes promises to _pendingRouteLoads
+            routeModule(Odac)
+          }
+        }
+
+        // Wait for all route sets to complete for this file
+        await Promise.all(this._pendingRouteLoads)
+        this._pendingRouteLoads = []
+
+        // Clean up deleted routes logic
+        for (const type of ['page', '#page', 'post', '#post', 'get', '#get', 'error']) {
+          if (!this.routes[Odac.Route.buff]) continue
+          if (!this.routes[Odac.Route.buff][type]) continue
+          for (const route in this.routes[Odac.Route.buff][type]) {
+            const routeObj = this.routes[Odac.Route.buff][type][route]
+            if (!routeObj) continue
+
+            if (routes2[Odac.Route.buff] > routeObj.loaded) {
+              if (routeObj.path) {
+                try {
+                  delete require.cache[require.resolve(routeObj.path)]
+                } catch {
+                  // Silently fail
+                }
+              }
+              delete this.routes[Odac.Route.buff][type][route]
+            } else if (routeObj) {
+              if (typeof routeObj.type === 'function') continue
+              // Check if controller file modified
+              try {
+                const cStat = await fsPromises.stat(routeObj.path)
+                if (routeObj.mtime < cStat.mtimeMs) {
+                  delete require.cache[require.resolve(routeObj.path)]
+                  routeObj.cache = require(routeObj.path)
+                  routeObj.mtime = cStat.mtimeMs
+                }
+              } catch {
+                // Controller file might have been deleted?
+              }
             }
           }
         }
+        delete Odac.Route.buff
       }
-      delete Odac.Route.buff
+    } catch (e) {
+      // route dir issue?
+      console.error(e)
     }
+
     Cron.init()
     this.loading = false
   }
 
-  init() {
-    this.#init()
+  async init() {
+    await this.#init()
     this.#registerInternalRoutes()
-    setInterval(() => {
-      this.#init()
-    }, 5000)
+
+    // Hot Reload only in Debug Mode
+    if (Odac.Config.debug) {
+      setInterval(async () => {
+        await this.#init()
+      }, 5000)
+    }
   }
 
   #registerInternalRoutes() {
@@ -354,7 +498,7 @@ class Route {
     )
 
     this.set(
-      ['POST', 'GET', 'PUT', 'PATCH', 'DELETE'],
+      'POST',
       '/_odac/form',
       async Odac => {
         const csrfToken = await Odac.request('_token')
@@ -375,6 +519,28 @@ class Route {
       {token: true}
     )
 
+    this.set(
+      'POST',
+      '/_odac/magic-login',
+      async Odac => {
+        const csrfToken = await Odac.request('_token')
+        if (!csrfToken || !Odac.token(csrfToken)) {
+          return Odac.Request.abort(401)
+        }
+        return await Internal.magicLogin(Odac)
+      },
+      {token: true}
+    )
+
+    this.set(
+      'GET',
+      '/_odac/magic-verify',
+      async Odac => {
+        return await Internal.magicVerify(Odac)
+      },
+      {token: false}
+    )
+
     delete Odac.Route.buff
   }
 
@@ -387,6 +553,11 @@ class Route {
       if (result instanceof Promise) result = await result
       const Stream = require('./Stream.js')
       if (result instanceof Stream) return
+      if (result && typeof result.pipe === 'function') {
+        param.Request.print()
+        result.pipe(param.Request.res)
+        return
+      }
       if (param.Request.res.finished || param.Request.res.writableEnded) {
         param.cleanup()
         return
@@ -408,6 +579,8 @@ class Route {
   }
 
   set(type, url, file, options = {}) {
+    const capturedMiddlewares = this._pendingMiddlewares.length > 0 ? [...this._pendingMiddlewares] : undefined
+
     if (Array.isArray(type)) {
       type = type.map(t => t.toLowerCase())
       for (const t of type) {
@@ -425,43 +598,89 @@ class Route {
     const isFunction = typeof file === 'function'
     let path = `${__dir}/route/${Odac.Route.buff}.js`
 
+    let action = null
+
     if (!isFunction && file) {
-      path = `${__dir}/controller/${type.replace('#', '')}/${file}.js`
-      if (typeof file === 'string' && file.includes('.')) {
-        let arr = file.split('.')
-        path = `${__dir}/controller/${arr[0]}/${type.replace('#', '')}/${arr.slice(1).join('.')}.js`
+      if (typeof file === 'string' && file.includes('@')) {
+        let arr = file.split('@')
+        file = arr[0]
+        action = arr[1]
+        path = `${__dir}/controller/${file.replace(/\./g, '/')}.js`
+      } else {
+        path = `${__dir}/controller/${type.replace('#', '')}/${file}.js`
+        if (typeof file === 'string' && file.includes('.')) {
+          let arr = file.split('.')
+          path = `${__dir}/controller/${arr[0]}/${type.replace('#', '')}/${arr.slice(1).join('.')}.js`
+        }
       }
     }
 
     if (!this.routes[Odac.Route.buff]) this.routes[Odac.Route.buff] = {}
     if (!this.routes[Odac.Route.buff][type]) this.routes[Odac.Route.buff][type] = {}
 
-    if (this.routes[Odac.Route.buff][type][url]) {
-      this.routes[Odac.Route.buff][type][url].loaded = routes2[Odac.Route.buff]
-      if (!isFunction && this.routes[Odac.Route.buff][type][url].mtime < fs.statSync(path).mtimeMs) {
-        delete this.routes[Odac.Route.buff][type][url]
-        delete require.cache[require.resolve(path)]
-      } else return this
-    }
+    const task = async () => {
+      if (this.routes[Odac.Route.buff][type][url]) {
+        this.routes[Odac.Route.buff][type][url].loaded = routes2[Odac.Route.buff]
+        if (!isFunction) {
+          try {
+            const stat = await fsPromises.stat(path)
+            if (this.routes[Odac.Route.buff][type][url].mtime < stat.mtimeMs) {
+              delete this.routes[Odac.Route.buff][type][url]
+              delete require.cache[require.resolve(path)]
+            } else {
+              return
+            }
+          } catch {
+            // File error, proceed to reload or re-set
+          }
+        } else {
+          return
+        }
+      }
 
-    if (isFunction || fs.existsSync(path)) {
-      if (!this.routes[Odac.Route.buff][type][url]) this.routes[Odac.Route.buff][type][url] = {}
-      this.routes[Odac.Route.buff][type][url].cache = isFunction ? file : require(path)
-      this.routes[Odac.Route.buff][type][url].type = isFunction ? 'function' : 'controller'
-      this.routes[Odac.Route.buff][type][url].file = file
-      this.routes[Odac.Route.buff][type][url].mtime = isFunction ? Date.now() : fs.statSync(path).mtimeMs
-      this.routes[Odac.Route.buff][type][url].path = path
-      this.routes[Odac.Route.buff][type][url].loaded = routes2[Odac.Route.buff]
-      this.routes[Odac.Route.buff][type][url].token = options.token ?? true
-      this.routes[Odac.Route.buff][type][url].middlewares = this._pendingMiddlewares.length > 0 ? [...this._pendingMiddlewares] : undefined
+      if (isFunction) {
+        if (!this.routes[Odac.Route.buff][type][url]) this.routes[Odac.Route.buff][type][url] = {}
+        this.routes[Odac.Route.buff][type][url].cache = file
+        this.routes[Odac.Route.buff][type][url].type = 'function'
+        this.routes[Odac.Route.buff][type][url].file = file
+        this.routes[Odac.Route.buff][type][url].mtime = Date.now()
+        this.routes[Odac.Route.buff][type][url].path = path
+        this.routes[Odac.Route.buff][type][url].loaded = routes2[Odac.Route.buff]
+        this.routes[Odac.Route.buff][type][url].token = options.token ?? true
+        this.routes[Odac.Route.buff][type][url].action = action
+
+        this.routes[Odac.Route.buff][type][url].middlewares = capturedMiddlewares
+      } else {
+        try {
+          const stat = await fsPromises.stat(path)
+          if (!this.routes[Odac.Route.buff][type][url]) this.routes[Odac.Route.buff][type][url] = {}
+          this.routes[Odac.Route.buff][type][url].cache = require(path)
+          this.routes[Odac.Route.buff][type][url].type = 'controller'
+          this.routes[Odac.Route.buff][type][url].file = file
+          this.routes[Odac.Route.buff][type][url].mtime = stat.mtimeMs
+          this.routes[Odac.Route.buff][type][url].path = path
+          this.routes[Odac.Route.buff][type][url].loaded = routes2[Odac.Route.buff]
+          this.routes[Odac.Route.buff][type][url].token = options.token ?? true
+          this.routes[Odac.Route.buff][type][url].action = action
+
+          this.routes[Odac.Route.buff][type][url].middlewares = capturedMiddlewares
+        } catch {
+          if (file && typeof file === 'string') {
+            console.error(`\x1b[31m[Odac]\x1b[0m Controller not found: \x1b[33m${path}\x1b[0m`)
+          }
+        }
+      }
     }
 
+    this._pendingRouteLoads.push(task())
+
     return this
   }
 
   page(path, file) {
     if (typeof file === 'object' && !Array.isArray(file)) {
       this.set('page', path, _odac => {
+        _odac.set(file)
         _odac.View.set(file)
         return
       })
@@ -482,16 +701,20 @@ class Route {
   }
 
   authPage(path, authFile, file) {
-    if (typeof authFile === 'object' && !Array.isArray(authFile)) {
+    if (typeof authFile === 'object' && authFile !== null && !Array.isArray(authFile)) {
       this.set('#page', path, _odac => {
+        _odac.set(authFile)
         _odac.View.set(authFile)
         return
       })
       if (typeof file === 'object' && !Array.isArray(file)) {
         this.set('page', path, _odac => {
+          _odac.set(file)
           _odac.View.set(file)
           return
         })
+      } else if (file) {
+        this.set('page', path, file)
       }
       return this
     }
@@ -499,6 +722,7 @@ class Route {
     if (file) {
       if (typeof file === 'object' && !Array.isArray(file)) {
         this.set('page', path, _odac => {
+          _odac.set(file)
           _odac.View.set(file)
           return
         })
@@ -509,15 +733,31 @@ class Route {
     return this
   }
 
-  authPost(path, authFile, file) {
-    if (authFile) this.set('#post', path, authFile)
-    if (file) this.post(path, file)
+  authPost(path, authFile, file, options) {
+    let opts = options
+    let publicFile = file
+
+    if (publicFile && typeof publicFile === 'object' && !opts) {
+      opts = publicFile
+      publicFile = undefined
+    }
+
+    if (authFile) this.set('#post', path, authFile, opts)
+    if (publicFile) this.post(path, publicFile, opts)
     return this
   }
 
-  authGet(path, authFile, file) {
-    if (authFile) this.set('#get', path, authFile)
-    if (file) this.get(path, file)
+  authGet(path, authFile, file, options) {
+    let opts = options
+    let publicFile = file
+
+    if (publicFile && typeof publicFile === 'object' && !opts) {
+      opts = publicFile
+      publicFile = undefined
+    }
+
+    if (authFile) this.set('#get', path, authFile, opts)
+    if (publicFile) this.get(path, publicFile, opts)
     return this
   }
 
@@ -546,6 +786,26 @@ class Route {
     const {token = true} = options
     const requireAuth = type === '#ws'
 
+    if (typeof handler !== 'function') {
+      let path = `${__dir}/controller/${type.replace('#', '')}/${handler}.js`
+      if (typeof handler === 'string' && handler.includes('.')) {
+        let arr = handler.split('.')
+        path = `${__dir}/controller/${arr[0]}/${type.replace('#', '')}/${arr.slice(1).join('.')}.js`
+      }
+
+      if (fs.existsSync(path)) {
+        handler = require(path)
+      } else {
+        console.error(`\x1b[31m[Odac]\x1b[0m WebSocket Controller not found: \x1b[33m${path}\x1b[0m`)
+        return
+      }
+    }
+
+    if (typeof handler !== 'function') {
+      console.error(`\x1b[31m[Odac]\x1b[0m Invalid WebSocket handler (not a function).`)
+      return
+    }
+
     const wrappedHandler = async (ws, Odac) => {
       Odac.ws = ws
 
@@ -603,7 +863,10 @@ class Route {
           }
         }
       }
-      return handler(Odac)
+      const res = handler(Odac)
+      if (res instanceof Promise) await res
+      ws.resume()
+      return res
     }
 
     this.#wsServer.route(path, wrappedHandler)