owebjs 1.4.8 → 1.5.0-dev

package/dist/index.d.ts

@@ -40,10 +40,12 @@ declare class _FastifyInstance {
 }
 declare class Oweb extends _FastifyInstance {
     _options: OwebOptions;
+    _internalKV: Map<string, any>;
     private hmrDirectory;
     private hmrMatchersDirectory;
     private directory;
     private matchersDirectory;
+    uServer: any;
     routes: Map<string, any>;
     constructor(options?: OwebOptions);
     /**
@@ -51,6 +53,7 @@ declare class Oweb extends _FastifyInstance {
      * Returns a fastify instance with the Oweb prototype methods
      */
     setup(): Promise<Oweb>;
+    ws(url: string, behavior: any, hooks?: any[]): void;
     /**
      * Loads routes from a directory.
      * @param options.directory The directory to load routes from.
@@ -92,4 +95,45 @@ declare interface Hook {
 declare abstract class Hook {
 }
 
-export { type Awaitable, Hook, type LoadRoutesOptions, Oweb, type OwebOptions, Route, Oweb as default };
+interface WebSocketAdapter {
+    send(message: string | ArrayBuffer, isBinary?: boolean, compress?: boolean): number;
+    close(code?: number, shortMessage?: string | ArrayBuffer): void;
+    end(code?: number, shortMessage?: string | ArrayBuffer): void;
+    cork(cb: () => void): void;
+    getUserData(): any;
+    getRemoteAddressAsText(): ArrayBuffer;
+    getRemoteAddress(): ArrayBuffer;
+    subscribe(topic: string): boolean;
+    unsubscribe(topic: string): boolean;
+    publish(topic: string, message: string | ArrayBuffer, isBinary?: boolean, compress?: boolean): boolean;
+}
+interface WebSocketRouteOptions {
+    compression?: number;
+    maxPayloadLength?: number;
+    idleTimeout?: number;
+    sendPingsAutomatically?: boolean;
+}
+declare abstract class WebSocketRoute {
+    _options: WebSocketRouteOptions;
+    constructor(options?: WebSocketRouteOptions);
+    /**
+     * Called when a client connects.
+     */
+    open?(ws: WebSocketAdapter, req: any): Awaitable<void>;
+    /**
+     * Called when a message is received.
+     */
+    message?(ws: WebSocketAdapter, message: ArrayBuffer, isBinary: boolean): Awaitable<void>;
+    /**
+     * Called when the connection is closed.
+     */
+    close?(ws: WebSocketAdapter, code: number, message: ArrayBuffer): Awaitable<void>;
+    /**
+     * Called when the socket buffer is empty (backpressure).
+     */
+    drain?(ws: WebSocketAdapter): Awaitable<void>;
+    ping?(ws: WebSocketAdapter, message: ArrayBuffer): Awaitable<void>;
+    pong?(ws: WebSocketAdapter, message: ArrayBuffer): Awaitable<void>;
+}
+
+export { type Awaitable, Hook, type LoadRoutesOptions, Oweb, type OwebOptions, Route, type WebSocketAdapter, WebSocketRoute, type WebSocketRouteOptions, Oweb as default };

package/dist/index.js

@@ -4,6 +4,7 @@ var index_default = Oweb;
 export * from './structures/Oweb.js';
 export * from './structures/Route.js';
 export * from './structures/Hook.js';
+export * from './structures/WebSocketRoute.js';
 export * from './types.js';
 export {
   index_default as default

package/dist/structures/FastifyWebSocketAdapter.js

@@ -0,0 +1,80 @@
+import {
+  __name
+} from "../chunk-SHUYVCID.js";
+const topicSubscribers = /* @__PURE__ */ new Map();
+class FastifyWebSocketAdapter {
+  static {
+    __name(this, "FastifyWebSocketAdapter");
+  }
+  ws;
+  req;
+  userData;
+  constructor(ws, req) {
+    this.ws = ws;
+    this.req = req;
+    this.userData = {};
+  }
+  send(message, isBinary, compress) {
+    if (this.ws.readyState === 1) {
+      this.ws.send(message, {
+        binary: isBinary,
+        compress
+      });
+      return 1;
+    }
+    return 0;
+  }
+  close(code, shortMessage) {
+    this.ws.close(code, shortMessage);
+  }
+  end(code, shortMessage) {
+    this.ws.close(code, shortMessage);
+  }
+  cork(cb) {
+    cb();
+  }
+  getUserData() {
+    return this.userData;
+  }
+  getRemoteAddressAsText() {
+    return Buffer.from(this.req.socket?.remoteAddress || "");
+  }
+  getRemoteAddress() {
+    return this.getRemoteAddressAsText();
+  }
+  subscribe(topic) {
+    if (!topicSubscribers.has(topic)) {
+      topicSubscribers.set(topic, /* @__PURE__ */ new Set());
+    }
+    topicSubscribers.get(topic).add(this);
+    return true;
+  }
+  unsubscribe(topic) {
+    const set = topicSubscribers.get(topic);
+    if (set) {
+      set.delete(this);
+      if (set.size === 0) topicSubscribers.delete(topic);
+      return true;
+    }
+    return false;
+  }
+  publish(topic, message, isBinary, compress) {
+    const set = topicSubscribers.get(topic);
+    if (!set) return false;
+    set.forEach((client) => {
+      if (client !== this && client.ws.readyState === 1) {
+        client.send(message, isBinary, compress);
+      }
+    });
+    return true;
+  }
+  cleanup() {
+    topicSubscribers.forEach((set, topic) => {
+      set.delete(this);
+      if (set.size === 0) topicSubscribers.delete(topic);
+    });
+  }
+}
+export {
+  FastifyWebSocketAdapter
+};

package/dist/structures/Oweb.js

@@ -5,6 +5,7 @@ import Fastify from "fastify";
 import { applyMatcherHMR, applyRouteHMR, assignRoutes } from '../utils/assignRoutes.js';
 import { watchDirectory } from '../utils/watcher.js';
 import { info, success, warn } from '../utils/logger.js';
+import websocketPlugin from "@fastify/websocket";
 let _FastifyInstance = class _FastifyInstance2 {
   static {
     __name(this, "_FastifyInstance");
@@ -15,10 +16,12 @@ class Oweb extends _FastifyInstance {
     __name(this, "Oweb");
   }
   _options = {};
+  _internalKV = /* @__PURE__ */ new Map();
   hmrDirectory;
   hmrMatchersDirectory;
   directory;
   matchersDirectory;
+  uServer = null;
   routes = /* @__PURE__ */ new Map();
   constructor(options) {
     super();
@@ -38,12 +41,18 @@ class Oweb extends _FastifyInstance {
     if (this._options.uWebSocketsEnabled) {
       const serverimp = (await import("../uwebsocket/server.js")).default;
       const server = await serverimp({});
+      this.uServer = server;
       this._options.serverFactory = (handler) => {
         server.on("request", handler);
         return server;
       };
+    } else {
+      this.uServer = null;
     }
     const fastify = Fastify(this._options);
+    if (!this._options.uWebSocketsEnabled) {
+      await fastify.register(websocketPlugin);
+    }
     fastify.addHook("onRequest", (_, res, done) => {
       res.header("X-Powered-By", "Oweb");
       done();
@@ -52,6 +61,17 @@ class Oweb extends _FastifyInstance {
       if (key === "constructor") continue;
       Object.defineProperty(fastify, key, Object.getOwnPropertyDescriptor(Oweb.prototype, key));
     }
+    Object.defineProperty(fastify, "_internalKV", {
+      value: this._internalKV,
+      writable: true,
+      enumerable: false
+    });
+    Object.defineProperty(fastify, "uServer", {
+      value: this.uServer,
+      writable: true,
+      enumerable: false,
+      configurable: false
+    });
     Object.defineProperty(fastify, "_options", {
       value: this._options,
       writable: true,
@@ -60,6 +80,13 @@ class Oweb extends _FastifyInstance {
     });
     return fastify;
   }
+  ws(url, behavior, hooks = []) {
+    if (this.uServer) {
+      this.uServer.ws(url, behavior, hooks);
+    } else {
+      warn("Oweb#ws is only available when uWebSockets is enabled. For Fastify instances, Oweb automatically handles registrations.");
+    }
+  }
   /**
    * Loads routes from a directory.
    * @param options.directory The directory to load routes from.
@@ -77,6 +104,7 @@ class Oweb extends _FastifyInstance {
     if (hmr?.enabled) {
       this.hmrDirectory = hmr.directory;
       this.hmrMatchersDirectory = hmr.matchersDirectory;
+      this._internalKV.set("hmr", true);
       success(`Hot Module Replacement enabled. Watching changes in ${hmr.directory}`, "HMR");
     } else {
       warn('Hot Module Replacement is disabled. Use "await app.loadRoutes({ hmr: { enabled: true, directory: path } })" to enable it.', "HMR");

package/dist/structures/WebSocketRoute.js

@@ -0,0 +1,19 @@
+import {
+  __name
+} from "../chunk-SHUYVCID.js";
+class WebSocketRoute {
+  static {
+    __name(this, "WebSocketRoute");
+  }
+  _options = {};
+  constructor(options) {
+    this._options = options ?? {
+      compression: 0,
+      maxPayloadLength: 16 * 1024 * 1024,
+      idleTimeout: 120
+    };
+  }
+}
+export {
+  WebSocketRoute
+};

package/dist/utils/assignRoutes.js

@@ -5,10 +5,15 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildRoutePath, buildRouteURL } from './utils.js';
 import { walk } from './walk.js';
-import { success, warn } from './logger.js';
+import { error, success, warn } from './logger.js';
 import { match } from "path-to-regexp";
 import generateFunctionFromTypescript from './generateFunctionFromTypescript.js';
 import { readdirSync } from "node:fs";
+import { WebSocketRoute } from '../structures/WebSocketRoute.js';
+import { FastifyWebSocketAdapter } from '../structures/FastifyWebSocketAdapter.js';
+import { formatSSE } from './utils.js';
+const websocketRoutes = {};
+const registeredWebSockets = /* @__PURE__ */ new Set();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 let matcherOverrides = {};
 let routeFunctions = {
@@ -37,6 +42,40 @@ function removeExtension(filePath) {
   return filePath;
 }
 __name(removeExtension, "removeExtension");
+function createWebSocketProxy(url) {
+  const getHandler = /* @__PURE__ */ __name(() => websocketRoutes[url], "getHandler");
+  return {
+    compression: getHandler()?._options.compression,
+    maxPayloadLength: getHandler()?._options.maxPayloadLength,
+    idleTimeout: getHandler()?._options.idleTimeout,
+    sendPingsAutomatically: getHandler()?._options.sendPingsAutomatically,
+    open: /* @__PURE__ */ __name((ws, req) => {
+      const handler = getHandler();
+      if (handler?.open) handler.open(ws, req);
+    }, "open"),
+    message: /* @__PURE__ */ __name((ws, message, isBinary) => {
+      const handler = getHandler();
+      if (handler?.message) handler.message(ws, message, isBinary);
+    }, "message"),
+    drain: /* @__PURE__ */ __name((ws) => {
+      const handler = getHandler();
+      if (handler?.drain) handler.drain(ws);
+    }, "drain"),
+    close: /* @__PURE__ */ __name((ws, code, message) => {
+      const handler = getHandler();
+      if (handler?.close) handler.close(ws, code, message);
+    }, "close"),
+    ping: /* @__PURE__ */ __name((ws, message) => {
+      const handler = getHandler();
+      if (handler?.ping) handler.ping(ws, message);
+    }, "ping"),
+    pong: /* @__PURE__ */ __name((ws, message) => {
+      const handler = getHandler();
+      if (handler?.pong) handler.pong(ws, message);
+    }, "pong")
+  };
+}
+__name(createWebSocketProxy, "createWebSocketProxy");
 const applyMatcherHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallbackDir, filePath, content) => {
   let def;
   const fileName = path.basename(filePath);
@@ -80,6 +119,12 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
     const routes = await generateRoutes(files, path2);
     routesCache = routes;
     const f = routes.find((x) => x.fileInfo.filePath == path2);
+    if (f?.fn?.prototype instanceof WebSocketRoute) {
+      assignSpecificRoute(oweb, f);
+      const end2 = Date.now() - start;
+      success(`WebSocket Route ${f.url} created in ${end2}ms`, "HMR");
+      return;
+    }
     temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
     const end = Date.now() - start;
     success(`Route ${f.method.toUpperCase()}:${f.url} created in ${end}ms`, "HMR");
@@ -89,6 +134,12 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
     const routes = await generateRoutes(files, path2);
     routesCache = routes;
     const f = routes.find((x) => x.fileInfo.filePath == path2);
+    if (f?.fn?.prototype instanceof WebSocketRoute) {
+      websocketRoutes[f.url] = new f.fn();
+      const end2 = Date.now() - start;
+      success(`WebSocket Route ${f.url} reloaded in ${end2}ms`, "HMR");
+      return;
+    }
     if (f.url in temporaryRequests[f.method.toLowerCase()]) {
       temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
     } else {
@@ -103,14 +154,22 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
     if (builded.url.endsWith("/index")) {
       builded.url = builded.url.slice(0, -"/index".length);
     }
+    if (websocketRoutes[builded.url]) {
+      delete websocketRoutes[builded.url];
+      const end = Date.now() - start;
+      success(`WebSocket Route ${builded.url} removed (shimmed) in ${end}ms`, "HMR");
+      return;
+    }
     const f = routesCache.find((x) => x.method == builded.method && x.url == builded.url);
-    if (f.url in temporaryRequests[f.method.toLowerCase()]) {
-      delete temporaryRequests[f.method.toLowerCase()][f.url];
-    } else {
-      delete routeFunctions[f.method.toLowerCase()][f.url];
+    if (f) {
+      if (f.url in temporaryRequests[f.method.toLowerCase()]) {
+        delete temporaryRequests[f.method.toLowerCase()][f.url];
+      } else {
+        delete routeFunctions[f.method.toLowerCase()][f.url];
+      }
+      const end = Date.now() - start;
+      success(`Route ${f.method.toUpperCase()}:${f.url} removed in ${end}ms`, "HMR");
     }
-    const end = Date.now() - start;
-    success(`Route ${f.method.toUpperCase()}:${f.url} removed in ${end}ms`, "HMR");
   }
 }, "applyRouteHMR");
 const generateRoutes = /* @__PURE__ */ __name(async (files, onlyGenerateFn) => {
@@ -153,7 +212,16 @@ function inner(oweb, route) {
   }
   const routeFunc = new route.fn();
   const matchers = route.matchers;
+  const isParametric = route.url.includes(":") || route.url.includes("*");
   return function(req, res) {
+    if (oweb._internalKV.get("hmr") && isParametric) {
+      const currentPath = req.raw.url.split("?")[0];
+      const method = req.method.toLowerCase();
+      const specificHandler = temporaryRequests[method]?.[currentPath];
+      if (specificHandler && specificHandler !== temporaryRequests[route.method][route.url]) {
+        return specificHandler(req, res);
+      }
+    }
     const checkMatchers = /* @__PURE__ */ __name(() => {
       for (const matcher of matchers) {
         const param = req.params[matcher.paramName];
@@ -164,31 +232,98 @@ function inner(oweb, route) {
       }
       return true;
     }, "checkMatchers");
-    const handle = /* @__PURE__ */ __name(() => {
-      if (routeFunc.handle.constructor.name == "AsyncFunction") {
-        routeFunc.handle(req, res).catch((error) => {
-          if (routeFunc?.handleError) {
-            routeFunc.handleError(req, res, error);
+    const handle = /* @__PURE__ */ __name(async () => {
+      let result;
+      try {
+        if (routeFunc.handle.constructor.name === "AsyncFunction") {
+          result = await routeFunc.handle(req, res);
+        } else {
+          result = routeFunc.handle(req, res);
+          if (result instanceof Promise) {
+            result = await result;
+          }
+        }
+      } catch (error2) {
+        if (routeFunc?.handleError) {
+          routeFunc.handleError(req, res, error2);
+        } else {
+          oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, error2);
+        }
+        return;
+      }
+      const isIterable = result && typeof result[Symbol.iterator] === "function";
+      const isAsyncIterable = result && typeof result[Symbol.asyncIterator] === "function";
+      if ((isIterable || isAsyncIterable) && !res.sent) {
+        const rawObj = res.raw;
+        const uwsRes = rawObj.res && typeof rawObj.res.cork === "function" ? rawObj.res : null;
+        const corkedOp = /* @__PURE__ */ __name((op) => {
+          if (uwsRes) {
+            uwsRes.cork(op);
           } else {
-            oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, error);
+            op();
+          }
+        }, "corkedOp");
+        corkedOp(() => {
+          res.raw.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Access-Control-Allow-Origin": "*"
+          });
+          if (res.raw.flushHeaders) {
+            res.raw.flushHeaders();
           }
         });
-      } else {
+        let aborted = false;
+        const onAborted = /* @__PURE__ */ __name(() => {
+          aborted = true;
+        }, "onAborted");
+        if (res.raw.on) {
+          res.raw.on("close", onAborted);
+          res.raw.on("aborted", onAborted);
+        } else if (rawObj["onAborted"]) {
+          rawObj["onAborted"](onAborted);
+        }
         try {
-          routeFunc.handle(req, res);
-        } catch (error) {
-          if (routeFunc?.handleError) {
-            routeFunc.handleError(req, res, error);
+          if (isAsyncIterable) {
+            for await (const chunk of result) {
+              if (aborted || res.raw.destroyed) break;
+              corkedOp(() => {
+                res.raw.write(formatSSE(chunk));
+              });
+            }
           } else {
-            oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, error);
+            for (const chunk of result) {
+              if (aborted || res.raw.destroyed) break;
+              corkedOp(() => {
+                res.raw.write(formatSSE(chunk));
+              });
+            }
+          }
+        } catch (err) {
+          error(`Error while streaming response for ${route.method.toUpperCase()}:${route.url} - ${err.message}`, "SSE");
+        } finally {
+          if (res.raw.off) {
+            res.raw.off("close", onAborted);
+            res.raw.off("aborted", onAborted);
+          }
+          if (!aborted && !res.raw.destroyed) {
+            corkedOp(() => {
+              res.raw.end();
+            });
           }
         }
+        return;
+      }
+      if (!res.sent && result !== void 0) {
+        res.send(result);
       }
     }, "handle");
     if (route.fileInfo.hooks.length) {
       for (let index = 0; index < route.fileInfo.hooks.length; index++) {
         const hookFun = route.fileInfo.hooks[index];
-        hookFun.prototype.handle(req, res, () => {
+        const hookInstance = typeof hookFun === "function" ? new hookFun() : hookFun;
+        hookInstance.handle(req, res, () => {
           if (index + 1 == route.fileInfo.hooks.length) {
             if (!checkMatchers()) {
               send404(req, res);
@@ -217,7 +352,107 @@ function send404(req, res) {
 }
 __name(send404, "send404");
 function assignSpecificRoute(oweb, route) {
-  if (!route.fn) return;
+  if (!route?.fn) return;
+  if (route?.fn?.prototype instanceof WebSocketRoute) {
+    const wsInstance = new route.fn();
+    websocketRoutes[route.url] = wsInstance;
+    if (!registeredWebSockets.has(route.url)) {
+      registeredWebSockets.add(route.url);
+      if (oweb._options.uWebSocketsEnabled && oweb.uServer) {
+        const proxy = createWebSocketProxy(route.url);
+        oweb.ws(route.url, proxy, route.fileInfo.hooks);
+      } else {
+        oweb.get(route.url, {
+          websocket: true
+        }, (arg1, arg2) => {
+          (async () => {
+            let socket;
+            let req;
+            if (arg1 && arg1.socket) {
+              socket = arg1.socket;
+              req = arg2;
+            } else if (arg1 && arg1.raw && arg1.raw.socket) {
+              socket = arg1.raw.socket;
+              req = arg1;
+            } else {
+              socket = arg1;
+              req = arg2 || {};
+            }
+            if (!socket || typeof socket.on !== "function") {
+              error(`Could not find underlying socket for route ${route.url}. Arg1 type: ${typeof arg1}`, "WS");
+              return;
+            }
+            const adapter = new FastifyWebSocketAdapter(socket, req.raw || req);
+            socket.on("error", (err) => {
+              error(`${route.url}: ${err.message}`, "WS");
+            });
+            const hooks = route.fileInfo.hooks || [];
+            try {
+              for (const HookClass of hooks) {
+                await new Promise((resolve, reject) => {
+                  const hookInstance = typeof HookClass === "function" ? new HookClass() : HookClass;
+                  hookInstance.handle(req, {
+                    status: /* @__PURE__ */ __name((c) => ({
+                      send: /* @__PURE__ */ __name((m) => {
+                        socket.close(c, m);
+                        reject("closed");
+                      }, "send")
+                    }), "status"),
+                    header: /* @__PURE__ */ __name(() => {
+                    }, "header"),
+                    send: /* @__PURE__ */ __name((m) => {
+                      socket.close(1e3, m);
+                      reject("closed");
+                    }, "send")
+                  }, (err) => {
+                    if (err) reject(err);
+                    else resolve();
+                  });
+                });
+              }
+            } catch (e) {
+              if (e !== "closed") {
+                error(`WebSocket Hook Error: ${e}`, "WS");
+                socket.close(1011);
+              }
+              return;
+            }
+            const getHandler = /* @__PURE__ */ __name(() => websocketRoutes[route.url], "getHandler");
+            socket.on("message", (message, isBinary) => {
+              const h = getHandler();
+              if (h?.message) h.message(adapter, message, isBinary);
+            });
+            socket.on("close", (code, reason) => {
+              const h = getHandler();
+              adapter.cleanup();
+              if (h?.close) h.close(adapter, code, reason);
+            });
+            socket.on("ping", (data) => {
+              const h = getHandler();
+              if (h?.ping) h.ping(adapter, data);
+            });
+            socket.on("pong", (data) => {
+              const h = getHandler();
+              if (h?.pong) h.pong(adapter, data);
+            });
+            const handler = getHandler();
+            if (handler?.open) {
+              await handler.open(adapter, req);
+            }
+          })().catch((err) => {
+            error(`Internaal Error on ${route.url}: ${err.message}`, "WS");
+            if (arg1 && arg1.socket) {
+              try {
+                arg1.socket.close(1011);
+              } catch {
+              }
+            }
+          });
+        });
+      }
+    }
+    return;
+  }
   const routeFunc = new route.fn();
   routeFunctions[route.method][route.url] = inner(oweb, route);
   oweb[route.method](route.url, routeFunc._options || {}, function(req, res) {

package/dist/utils/utils.js

@@ -12,6 +12,18 @@ const convertParamSyntax = /* @__PURE__ */ __name((path) => {
   return mergePaths(...subpaths);
 }, "convertParamSyntax");
 const convertCatchallSyntax = /* @__PURE__ */ __name((url) => url.replace(/:\.\.\.\w+/g, "*"), "convertCatchallSyntax");
+const formatSSE = /* @__PURE__ */ __name((chunk) => {
+  if (typeof chunk === "object") {
+    try {
+      chunk = JSON.stringify(chunk);
+    } catch (e) {
+      chunk = String(chunk);
+    }
+  }
+  return `data: ${chunk}
+
+`;
+}, "formatSSE");
 const buildRoutePath = /* @__PURE__ */ __name((parsedFile) => {
   const directory = parsedFile.dir === parsedFile.root ? "" : parsedFile.dir;
   const name = parsedFile.name.startsWith("index") ? parsedFile.name.replace("index", "") : `/${parsedFile.name}`;
@@ -64,5 +76,6 @@ export {
   buildRouteURL,
   convertCatchallSyntax,
   convertParamSyntax,
+  formatSSE,
   mergePaths
 };

package/dist/utils/walk.js

@@ -69,9 +69,14 @@ const walk = /* @__PURE__ */ __name(async (directory, tree = [], fallbackDir) =>
       }
       const hooksImport = useHook.map((hookPath) => {
         if (fallbackDir) {
-          const findLastPath = hookPath.replace(process.cwd(), "").split("\\").at(-1);
-          const additionNeeded = !fallbackDir.endsWith(`/${findLastPath}`);
-          return new URL(path.join(process.cwd(), fallbackDir, additionNeeded ? `/${findLastPath}` : "")).pathname.replaceAll("\\", "/") + "/_hooks.js";
+          const relativeToRoot = path.relative(process.cwd(), hookPath);
+          const normalizedFallback = fallbackDir.replace(/\\/g, "/").replace(/\/$/, "");
+          const normalizedRel = relativeToRoot.replace(/\\/g, "/");
+          let finalPath = normalizedRel;
+          if (!normalizedRel.startsWith(normalizedFallback)) {
+            finalPath = path.posix.join(normalizedFallback, normalizedRel);
+          }
+          return new URL(`file://${path.join(process.cwd(), finalPath)}`).pathname + "/_hooks.js";
         } else {
           return new URL(hookPath, `file://${__dirname}`).pathname.replaceAll("\\", "/") + "/_hooks.js";
         }

package/dist/uwebsocket/request.js

@@ -9,6 +9,7 @@ class HttpRequest extends Readable {
   }
   req;
   res;
+  uResponse;
   url;
   method;
   statusCode;
@@ -16,19 +17,31 @@ class HttpRequest extends Readable {
   body;
   headers;
   socket;
-  constructor(uRequest) {
-    super();
-    const q = uRequest.getQuery();
+  // https://nodejs.org/api/http.html#class-httpincomingmessage
+  complete = false;
+  connection;
+  constructor(uRequest, uResponse) {
+    super({
+      highWaterMark: 64 * 1024
+    });
+    this.uResponse = uResponse;
     this.req = uRequest;
+    const q = uRequest.getQuery();
     this.url = uRequest.getUrl() + (q ? "?" + q : "");
     this.method = uRequest.getMethod().toUpperCase();
-    this.statusCode = null;
-    this.statusMessage = null;
     this.body = {};
     this.headers = {};
-    this.socket = {};
+    this.socket = {
+      destroy: /* @__PURE__ */ __name(() => {
+      }, "destroy"),
+      on: /* @__PURE__ */ __name(() => {
+      }, "on"),
+      removeListener: /* @__PURE__ */ __name(() => {
+      }, "removeListener")
+    };
+    this.connection = this.socket;
     uRequest.forEach((header, value) => {
-      this.headers[header] = value;
+      this.headers[header.toLowerCase()] = value;
     });
   }
   getRawHeaders() {
@@ -41,8 +54,14 @@ class HttpRequest extends Readable {
   getRaw() {
     return this.req;
   }
-  _read(size) {
-    return this.slice(0, size);
+  _read(_) {
+    if (this.uResponse) {
+      setImmediate(() => {
+        if (this.uResponse && !this.uResponse.aborted) {
+          this.uResponse.resume();
+        }
+      });
+    }
   }
 }
 export {

package/dist/uwebsocket/response.js

@@ -71,8 +71,10 @@ class HttpResponse extends Writable {
   //@ts-ignore
   write(data) {
     if (this.finished) return;
-    this._flushHeaders();
-    this.res.write(data);
+    this.res.cork(() => {
+      this._flushHeaders();
+      this.res.write(data);
+    });
   }
   writeHead(statusCode) {
     if (this.finished) return;
@@ -93,17 +95,15 @@ class HttpResponse extends Writable {
   //@ts-ignore
   end(data) {
     if (this.finished) return;
-    const self = this;
-    function doWrite() {
-      self._flushHeaders();
-      self.finished = true;
-      self.res.end(data);
-    }
-    __name(doWrite, "doWrite");
-    if (!data) {
-      data = "";
-    }
-    return doWrite();
+    this.res.cork(() => {
+      this._flushHeaders();
+      this.finished = true;
+      if (!data) {
+        this.res.end();
+      } else {
+        this.res.end(data);
+      }
+    });
   }
   getRaw() {
     return this.res;

package/dist/uwebsocket/server.js

@@ -23,33 +23,51 @@ async function server_default({ cert_file_name, key_file_name }) {
   };
   const uServer = uWS[appType](config).any("/*", (res, req) => {
     res.finished = false;
-    const reqWrapper = new HttpRequest(req);
+    res.aborted = false;
+    res.isPaused = false;
+    res.onAborted(() => {
+      res.aborted = true;
+      res.finished = true;
+    });
+    const reqWrapper = new HttpRequest(req, res);
     const resWrapper = new HttpResponse(res, uServer);
     reqWrapper.res = resWrapper;
     resWrapper.req = reqWrapper;
     reqWrapper.socket = resWrapper.socket;
+    const originalResume = res.resume;
+    res.resume = function() {
+      if (res.isPaused && !res.finished && !res.aborted) {
+        res.isPaused = false;
+        originalResume.call(res);
+      }
+    };
+    handler(reqWrapper, resWrapper);
     const method = reqWrapper.method;
-    if (method !== "HEAD") {
+    if (method !== "HEAD" && method !== "GET" && !resWrapper.finished) {
       res.onData((bytes, isLast) => {
-        const chunk = Buffer.from(bytes);
+        if (res.finished || res.aborted) return;
+        const chunk = Buffer.from(bytes.slice(0));
+        const streamReady = reqWrapper.push(chunk);
         if (isLast) {
-          reqWrapper.push(chunk);
+          reqWrapper.complete = true;
           reqWrapper.push(null);
-          if (!res.finished) {
-            return handler(reqWrapper, resWrapper);
+        } else if (!streamReady) {
+          if (!res.isPaused) {
+            res.isPaused = true;
+            res.pause();
           }
-          return;
         }
-        return reqWrapper.push(chunk);
       });
-    } else if (!res.finished) {
-      handler(reqWrapper, resWrapper);
+    } else if (!resWrapper.finished) {
+      reqWrapper.complete = true;
+      reqWrapper.push(null);
     }
   });
   let uServerClass = class uServerClass extends EventEmitter {
     static {
       __name(this, "uServerClass");
     }
+    _socket;
     constructor() {
       super();
       const oldThisOn = this.on.bind(this);
@@ -113,6 +131,126 @@ async function server_default({ cert_file_name, key_file_name }) {
         }
       }
     }
+    ws(pattern, behaviors, hooks = []) {
+      uServer.ws(pattern, {
+        compression: behaviors.compression,
+        maxPayloadLength: behaviors.maxPayloadLength,
+        idleTimeout: behaviors.idleTimeout,
+        sendPingsAutomatically: behaviors.sendPingsAutomatically,
+        upgrade: /* @__PURE__ */ __name(async (res, req, context) => {
+          const url = req.getUrl();
+          const query = req.getQuery();
+          const method = req.getMethod().toUpperCase();
+          const headers = {};
+          req.forEach((key, value) => {
+            headers[key] = value;
+          });
+          const params = {};
+          if (pattern.includes(":") || pattern.includes("*")) {
+            const parts = pattern.split("/");
+            let paramIndex = 0;
+            for (const part of parts) {
+              if (part.startsWith(":")) {
+                const name = part.slice(1);
+                params[name] = req.getParameter(paramIndex);
+                paramIndex++;
+              } else if (part === "*") {
+                params["*"] = req.getParameter(paramIndex);
+                paramIndex++;
+              }
+            }
+          }
+          const secKey = headers["sec-websocket-key"];
+          const secProtocol = headers["sec-websocket-protocol"];
+          const secExtensions = headers["sec-websocket-extensions"];
+          let aborted = false;
+          res.onAborted(() => {
+            aborted = true;
+          });
+          const reqWrapper = {
+            url: url + (query ? "?" + query : ""),
+            routerPath: pattern,
+            query: new URLSearchParams(query),
+            headers,
+            method,
+            params,
+            raw: {
+              url,
+              method,
+              headers
+            }
+          };
+          const resWrapper = {
+            statusCode: 200,
+            _headers: {},
+            finished: false,
+            header(key, value) {
+              this._headers[key.toLowerCase()] = value;
+              return this;
+            },
+            status(code) {
+              this.statusCode = code;
+              return this;
+            },
+            send(payload) {
+              if (aborted || this.finished) return;
+              this.finished = true;
+              res.writeStatus(`${this.statusCode} Response`);
+              for (const [k, v] of Object.entries(this._headers)) {
+                res.writeHeader(k, String(v));
+              }
+              res.end(typeof payload === "object" ? JSON.stringify(payload) : String(payload));
+              return this;
+            }
+          };
+          try {
+            for (const HookClass of hooks) {
+              if (aborted || resWrapper.finished) return;
+              await new Promise((resolve, reject) => {
+                try {
+                  const hookInstance = typeof HookClass === "function" ? new HookClass() : HookClass;
+                  hookInstance.handle(reqWrapper, resWrapper, (err) => {
+                    if (err) reject(err);
+                    else resolve(true);
+                  });
+                } catch (err) {
+                  reject(err);
+                }
+              });
+            }
+          } catch (err) {
+            if (!aborted && !resWrapper.finished) {
+              console.error("WebSocket Hook Error:", err);
+              res.writeStatus("500 Internal Server Error");
+              res.end(JSON.stringify({
+                error: "Internal Server Error",
+                message: err.message
+              }));
+            }
+            return;
+          }
+          if (aborted || resWrapper.finished) return;
+          const reqData = {
+            ...reqWrapper,
+            query
+          };
+          res.upgrade({
+            req: reqData
+          }, secKey, secProtocol, secExtensions, context);
+        }, "upgrade"),
+        open: /* @__PURE__ */ __name((ws) => {
+          if (behaviors.open) {
+            const data = ws.getUserData();
+            behaviors.open(ws, data.req);
+          }
+        }, "open"),
+        message: behaviors.message,
+        drain: behaviors.drain,
+        close: behaviors.close,
+        ping: behaviors.ping,
+        pong: behaviors.pong
+      });
+    }
     get uwsApp() {
       return uServer;
     }

package/package.json

@@ -1,68 +1,70 @@
-{
-    "name": "owebjs",
-    "version": "1.4.8",
-    "description": "A flexible and modern web framework built on top of Fastify",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "publishConfig": {
-        "access": "public"
-    },
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js",
-            "default": "./dist/index.js"
-        },
-        "./dist/plugins": {
-            "types": "./dist/plugins/index.d.ts",
-            "import": "./dist/plugins/index.js",
-            "default": "./dist/plugins/index.js"
-        }
-    },
-    "scripts": {
-        "start": "node .",
-        "build": "tsup",
-        "dev": "tsup && node .",
-        "test": "tsup && node test/index.js",
-        "format": "prettier --write . --ignore-path .gitignore"
-    },
-    "homepage": "https://github.com/owebjs/oweb",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/owebjs/oweb"
-    },
-    "keywords": [],
-    "author": "owebjs",
-    "license": "MIT",
-    "dependencies": {
-        "@babel/core": "^7.28.0",
-        "@babel/generator": "^7.28.0",
-        "@babel/parser": "^7.28.0",
-        "@babel/preset-typescript": "^7.27.1",
-        "@babel/traverse": "^7.28.0",
-        "@babel/types": "^7.28.2",
-        "@fastify/websocket": "^11.2.0",
-        "chalk": "^5.4.1",
-        "fastify": "4.23.2",
-        "path-to-regexp": "^8.2.0",
-        "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.52.0"
-    },
-    "devDependencies": {
-        "@fastify/multipart": "^8.1.0",
-        "@swc/core": "^1.3.85",
-        "@types/chokidar": "^2.1.3",
-        "@types/node": "^24.1.0",
-        "chokidar": "^3.5.3",
-        "prettier": "^3.0.3",
-        "tslib": "^2.6.2",
-        "tsup": "^8.5.0",
-        "@fastify/cors": "^9.0.1",
-        "typescript": "^5.2.2"
-    },
-    "type": "module",
-    "pnpm": {
-        "onlyBuiltDependencies": [
-            "esbuild"
-        ]
-    }
-}
+{
+    "name": "owebjs",
+    "version": "1.5.0-dev",
+    "description": "A flexible and modern web framework built on top of Fastify",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./dist/plugins": {
+            "types": "./dist/plugins/index.d.ts",
+            "import": "./dist/plugins/index.js",
+            "default": "./dist/plugins/index.js"
+        }
+    },
+    "scripts": {
+        "start": "node .",
+        "build": "tsup",
+        "dev": "tsup && node .",
+        "test": "tsup && node test/index.js",
+        "format": "prettier --write . --ignore-path .gitignore"
+    },
+    "homepage": "https://github.com/owebjs/oweb",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/owebjs/oweb"
+    },
+    "keywords": [],
+    "author": "owebjs",
+    "license": "MIT",
+    "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/generator": "^7.28.0",
+        "@babel/parser": "^7.28.0",
+        "@babel/preset-typescript": "^7.27.1",
+        "@babel/traverse": "^7.28.0",
+        "@babel/types": "^7.28.2",
+        "@fastify/websocket": "^10.0.1",
+        "chalk": "^5.4.1",
+        "fastify": "4.23.2",
+        "path-to-regexp": "^8.2.0",
+        "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.52.0",
+        "ws": "^8.19.0"
+    },
+    "devDependencies": {
+        "@fastify/cors": "^9.0.1",
+        "@fastify/multipart": "^8.1.0",
+        "@swc/core": "^1.3.85",
+        "@types/chokidar": "^2.1.3",
+        "@types/node": "^24.1.0",
+        "@types/ws": "^8.18.1",
+        "chokidar": "^3.5.3",
+        "prettier": "^3.0.3",
+        "tslib": "^2.6.2",
+        "tsup": "^8.5.0",
+        "typescript": "^5.2.2"
+    },
+    "type": "module",
+    "pnpm": {
+        "onlyBuiltDependencies": [
+            "esbuild"
+        ]
+    }
+}