owebjs 1.5.5-dev → 1.5.8-dev

package/dist/utils/watcher.js

@@ -19,20 +19,32 @@ function watchDirectory(dir, ignoreInitial = true, onUpdate) {
     ".js",
     ".ts"
   ];
-  watcher.on("add", async (filePath) => {
+  let operationQueue = Promise.resolve();
+  const enqueueUpdate = /* @__PURE__ */ __name((op, filePath) => {
     if (!supportedExtensions.includes(extname(filePath))) return;
-    const content = readFileSync(filePath, "utf-8");
-    onUpdate("new-file", filePath, content);
+    operationQueue = operationQueue.then(() => {
+      let content = "";
+      if (op !== "delete-file") {
+        try {
+          content = readFileSync(filePath, "utf-8");
+        } catch {
+          return;
+        }
+      }
+      return onUpdate(op, filePath, content);
+    }).catch(() => {
+    });
+  }, "enqueueUpdate");
+  watcher.on("add", (filePath) => {
+    enqueueUpdate("new-file", filePath);
   });
-  watcher.on("change", async (filePath) => {
-    if (!supportedExtensions.includes(extname(filePath))) return;
-    const content = readFileSync(filePath, "utf-8");
-    onUpdate("modify-file", filePath, content);
+  watcher.on("change", (filePath) => {
+    enqueueUpdate("modify-file", filePath);
   });
   watcher.on("unlink", (filePath) => {
-    if (!supportedExtensions.includes(extname(filePath))) return;
-    onUpdate("delete-file", filePath, "");
+    enqueueUpdate("delete-file", filePath);
   });
+  return watcher;
 }
 __name(watchDirectory, "watchDirectory");
 export {

package/dist/uwebsocket/request.js

@@ -3,6 +3,14 @@ import {
 } from "../chunk-SHUYVCID.js";
 import { Readable } from "stream";
 import { forEach } from './utils/object.js';
+const NOOP_SOCKET = Object.freeze({
+  destroy: /* @__PURE__ */ __name(() => {
+  }, "destroy"),
+  on: /* @__PURE__ */ __name(() => {
+  }, "on"),
+  removeListener: /* @__PURE__ */ __name(() => {
+  }, "removeListener")
+});
 class HttpRequest extends Readable {
   static {
     __name(this, "HttpRequest");
@@ -15,34 +23,55 @@ class HttpRequest extends Readable {
   statusCode;
   statusMessage;
   body;
-  headers;
-  socket;
   // https://nodejs.org/api/http.html#class-httpincomingmessage
   complete = false;
   connection;
-  constructor(uRequest, uResponse) {
+  resumeScheduled = false;
+  _headers = null;
+  _socket = NOOP_SOCKET;
+  _socketFactory;
+  get socket() {
+    if (this._socketFactory && this._socket === NOOP_SOCKET) {
+      this._socket = this._socketFactory();
+      this.connection = this._socket;
+    }
+    return this._socket;
+  }
+  set socket(value) {
+    this._socket = value || NOOP_SOCKET;
+    this.connection = this._socket;
+    this._socketFactory = void 0;
+  }
+  bindSocketFactory(factory) {
+    this._socketFactory = factory;
+    this._socket = NOOP_SOCKET;
+    this.connection = this._socket;
+  }
+  get headers() {
+    if (!this._headers) {
+      const headers = {};
+      this.req.forEach((header, value) => {
+        headers[header.toLowerCase()] = value;
+      });
+      this._headers = headers;
+    }
+    return this._headers;
+  }
+  set headers(value) {
+    this._headers = value;
+  }
+  constructor(uRequest, uResponse, prefetched) {
     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();
+    const query = prefetched?.query ?? uRequest.getQuery();
+    const url = prefetched?.url ?? uRequest.getUrl();
+    this.url = url + (query ? "?" + query : "");
+    this.method = prefetched?.method ?? uRequest.getMethod().toUpperCase();
     this.body = {};
-    this.headers = {};
-    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.toLowerCase()] = value;
-    });
+    this.connection = this._socket;
   }
   getRawHeaders() {
     const raw = [];
@@ -55,13 +84,17 @@ class HttpRequest extends Readable {
     return this.req;
   }
   _read(_) {
-    if (this.uResponse) {
-      setImmediate(() => {
-        if (this.uResponse && !this.uResponse.aborted) {
-          this.uResponse.resume();
-        }
-      });
-    }
+    const uRes = this.uResponse;
+    if (!uRes || uRes.aborted || uRes.finished || !uRes.isPaused) return;
+    if (this.resumeScheduled) return;
+    this.resumeScheduled = true;
+    setImmediate(() => {
+      this.resumeScheduled = false;
+      const res = this.uResponse;
+      if (res && !res.aborted && !res.finished && res.isPaused) {
+        res.resume();
+      }
+    });
   }
 }
 export {

package/dist/uwebsocket/response.js

@@ -16,9 +16,10 @@ class HttpResponse extends Writable {
   statusMessage;
   __headers;
   headersSent;
-  socket;
   finished;
-  constructor(uResponse, uServer) {
+  staticHeaders;
+  _socket = null;
+  constructor(uResponse, uServer, staticHeaders) {
     super();
     this.res = uResponse;
     this.server = uServer;
@@ -26,13 +27,20 @@ class HttpResponse extends Writable {
     this.statusMessage = null;
     this.__headers = {};
     this.headersSent = false;
-    this.socket = new HttpResponseSocket(uResponse);
-    this.res.onAborted(() => {
-      this.finished = this.res.finished = true;
-    });
+    this.finished = false;
+    this.staticHeaders = staticHeaders;
+  }
+  get socket() {
+    if (!this._socket) {
+      this._socket = new HttpResponseSocket(this.res);
+    }
+    return this._socket;
+  }
+  isClosed() {
+    return this.finished || this.res.aborted || this.res.finished;
   }
   get sent() {
-    return this.finished;
+    return this.isClosed();
   }
   setHeader(name, value) {
     this.__headers[toLowerCase(name)] = value;
@@ -53,9 +61,21 @@ class HttpResponse extends Writable {
     delete this.__headers[toLowerCase(name)];
   }
   _flushHeaders() {
-    if (this.headersSent) return;
+    if (this.headersSent || this.isClosed()) return;
     const message = this.statusMessage || http.STATUS_CODES[this.statusCode] || "Unknown";
     this.res.writeStatus(`${this.statusCode} ${message}`);
+    if (this.staticHeaders?.length) {
+      for (let i = 0; i < this.staticHeaders.length; i++) {
+        const [key, value] = this.staticHeaders[i];
+        if (key === "content-length" || key === "transfer-encoding") {
+          continue;
+        }
+        if (this.__headers[key] !== void 0) {
+          continue;
+        }
+        this.res.writeHeader(key, value);
+      }
+    }
     const keys = Object.keys(this.__headers);
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
@@ -75,14 +95,16 @@ class HttpResponse extends Writable {
   }
   //@ts-ignore
   write(data) {
-    if (this.finished) return;
+    if (this.isClosed()) return;
     this.res.cork(() => {
       this._flushHeaders();
-      this.res.write(data);
+      if (!this.isClosed()) {
+        this.res.write(data);
+      }
     });
   }
   writeHead(statusCode) {
-    if (this.finished) return;
+    if (this.isClosed()) return;
     this.statusCode = statusCode;
     let headers;
     if (arguments.length === 2) {
@@ -99,7 +121,7 @@ class HttpResponse extends Writable {
   }
   //@ts-ignore
   end(data) {
-    if (this.finished) return;
+    if (this.isClosed()) return;
     this.res.cork(() => {
       this._flushHeaders();
       this.finished = true;

package/dist/uwebsocket/responseSocket.js

@@ -6,11 +6,15 @@ class HttpResponseSocket {
     __name(this, "HttpResponseSocket");
   }
   uResponse;
+  _remoteAddress;
   constructor(uResponse) {
     this.uResponse = uResponse;
   }
   get remoteAddress() {
-    return Buffer.from(this.uResponse.getRemoteAddressAsText()).toString();
+    if (this._remoteAddress === void 0) {
+      this._remoteAddress = Buffer.from(this.uResponse.getRemoteAddressAsText()).toString();
+    }
+    return this._remoteAddress;
   }
   destroy() {
     return this.uResponse.end();

package/dist/uwebsocket/server.js

@@ -6,7 +6,7 @@ const REQUEST_EVENT = "request";
 import HttpRequest from './request.js';
 import HttpResponse from './response.js';
 import http from "node:http";
-async function server_default({ cert_file_name, key_file_name }) {
+async function server_default({ cert_file_name, key_file_name, staticResponseHeaders }) {
   let uWS;
   uWS = (await import("uWebSockets.js")).default;
   let appType = "App";
@@ -22,41 +22,60 @@ async function server_default({ cert_file_name, key_file_name }) {
     cert_file_name,
     key_file_name
   };
+  const normalizedStaticHeaders = staticResponseHeaders ? Object.entries(staticResponseHeaders).map(([k, v]) => [
+    k.toLowerCase(),
+    String(v)
+  ]) : void 0;
+  const copyArrayBufferToBuffer = /* @__PURE__ */ __name((bytes) => {
+    const src = new Uint8Array(bytes);
+    const out = Buffer.allocUnsafe(src.byteLength);
+    out.set(src);
+    return out;
+  }, "copyArrayBufferToBuffer");
   const uServer = uWS[appType](config).any("/*", (res, req) => {
+    const method = req.getMethod().toUpperCase();
+    const query = req.getQuery();
+    const url = req.getUrl();
+    const requiresBody = method !== "HEAD" && method !== "GET";
     res.finished = false;
     res.aborted = false;
-    res.isPaused = false;
+    if (requiresBody) {
+      res.isPaused = false;
+    }
     res.onAborted(() => {
       res.aborted = true;
       res.finished = true;
     });
-    const reqWrapper = new HttpRequest(req, res);
-    const resWrapper = new HttpResponse(res, uServer);
+    const reqWrapper = new HttpRequest(req, res, {
+      method,
+      query,
+      url
+    });
+    const resWrapper = new HttpResponse(res, uServer, normalizedStaticHeaders);
     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);
-      }
-    };
+    reqWrapper.bindSocketFactory(() => resWrapper.socket);
     handler(reqWrapper, resWrapper);
-    const method = reqWrapper.method;
-    if (method !== "HEAD" && method !== "GET" && !resWrapper.finished) {
+    if (requiresBody && !resWrapper.finished) {
+      const originalResume = res.resume;
+      res.resume = function() {
+        if (res.isPaused && !res.finished && !res.aborted) {
+          res.isPaused = false;
+          originalResume.call(res);
+        }
+      };
       res.onData((bytes, isLast) => {
-        if (res.finished || res.aborted) return;
-        const chunk = Buffer.from(bytes.slice(0));
+        if (res.finished || res.aborted || reqWrapper.destroyed) return;
+        const chunk = copyArrayBufferToBuffer(bytes);
         const streamReady = reqWrapper.push(chunk);
         if (isLast) {
           reqWrapper.complete = true;
           reqWrapper.push(null);
-        } else if (!streamReady) {
-          if (!res.isPaused) {
-            res.isPaused = true;
-            res.pause();
-          }
+          return;
+        }
+        if (!streamReady && !res.isPaused) {
+          res.isPaused = true;
+          res.pause();
         }
       });
     } else if (!resWrapper.finished) {
@@ -208,40 +227,52 @@ async function server_default({ cert_file_name, key_file_name }) {
               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);
-                }
-              });
+          const sendUpgradeError = /* @__PURE__ */ __name((hookError) => {
+            if (aborted || resWrapper.finished) return;
+            const normalizedError = hookError instanceof Error ? hookError : new Error(String(hookError));
+            console.error("WebSocket Hook Error:", normalizedError);
+            res.writeStatus("500 Internal Server Error");
+            res.end(JSON.stringify({
+              error: "Internal Server Error",
+              message: normalizedError.message
+            }));
+          }, "sendUpgradeError");
+          const finishUpgrade = /* @__PURE__ */ __name(() => {
+            if (aborted || resWrapper.finished) return;
+            const reqData = {
+              ...reqWrapper,
+              query
+            };
+            res.upgrade({
+              req: reqData
+            }, secKey, secProtocol, secExtensions, context);
+          }, "finishUpgrade");
+          let hookIndex = 0;
+          const runNextHook = /* @__PURE__ */ __name((hookError) => {
+            if (hookError) {
+              sendUpgradeError(hookError);
+              return;
             }
-          } 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
-              }));
+            if (aborted || resWrapper.finished) return;
+            if (hookIndex >= hooks.length) {
+              finishUpgrade();
+              return;
             }
-            return;
-          }
-          if (aborted || resWrapper.finished) return;
-          const reqData = {
-            ...reqWrapper,
-            query
-          };
-          res.upgrade({
-            req: reqData
-          }, secKey, secProtocol, secExtensions, context);
+            const HookClass = hooks[hookIndex++];
+            const hookInstance = typeof HookClass === "function" ? new HookClass() : HookClass;
+            let doneCalled = false;
+            const done = /* @__PURE__ */ __name((doneError) => {
+              if (doneCalled) return;
+              doneCalled = true;
+              runNextHook(doneError);
+            }, "done");
+            try {
+              hookInstance.handle(reqWrapper, resWrapper, done);
+            } catch (err) {
+              done(err);
+            }
+          }, "runNextHook");
+          runNextHook();
         }, "upgrade"),
         open: /* @__PURE__ */ __name((ws) => {
           if (behaviors.open) {

package/express.js

@@ -0,0 +1,14 @@
+import express from 'express';
+
+const app = express();
+const port = 3000;
+
+// Define a route for the root URL
+app.get('/', (req, res) => {
+    res.send('Hello World from Express!');
+});
+
+// Start the server
+app.listen(port, () => {
+    console.log(`Express app listening at http://localhost:${port}`);
+});

package/fasti.js

@@ -0,0 +1,14 @@
+import fastify from 'fastify';
+
+const app = fastify();
+
+app.get('/', async (request, reply) => {
+    return 'Hello, World!';
+});
+
+app.listen({ port: 3000, host: '0.0.0.0' }, (err) => {
+    if (err) {
+        console.error(err);
+        process.exit(1);
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "owebjs",
-    "version": "1.5.5-dev",
+    "version": "1.5.8-dev",
     "description": "A flexible and modern web framework built on top of Fastify",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -22,8 +22,9 @@
     "scripts": {
         "start": "node .",
         "build": "tsup",
-        "dev": "tsup && node .",
-        "test": "tsup && node test/index.js",
+        "dev": "tsup && node test/index.js",
+        "test": "tsup && vitest run --config test/vitest.config.mts",
+        "test:watch": "tsup && vitest --config test/vitest.config.mts",
         "format": "prettier --write . --ignore-path .gitignore"
     },
     "homepage": "https://github.com/owebjs/oweb",
@@ -59,7 +60,8 @@
         "prettier": "^3.0.3",
         "tslib": "^2.6.2",
         "tsup": "^8.5.0",
-        "typescript": "^5.2.2"
+        "typescript": "^5.2.2",
+        "vitest": "^3.2.4"
     },
     "type": "module",
     "pnpm": {

package/purehttp.js

@@ -0,0 +1,19 @@
+import http from 'node:http';
+
+const hostname = '127.0.0.1';
+const port = 3000;
+
+// Create the server instance
+const server = http.createServer((req, res) => {
+    // Set the response header with HTTP status and Content-Type
+    res.statusCode = 200;
+    res.setHeader('Content-Type', 'text/plain');
+
+    // Send the response body
+    res.end('Hello, World!\n');
+});
+
+// Start listening for requests
+server.listen(port, hostname, () => {
+    console.log(`Server running at http://${hostname}:${port}/`);
+});

package/uws.js

@@ -0,0 +1,16 @@
+import uWS from 'uwebsockets.js';
+
+uWS.App()
+    .get('/', (res, req) => {
+        res.writeStatus('200 OK')
+            .writeHeader('Content-Type', 'text/plain; charset=utf-8')
+            .end('Hello, World!');
+    })
+    .listen('0.0.0.0', 3000, (listenSocket) => {
+        if (listenSocket) {
+            console.log('uWebSockets.js listening on http://localhost:3000');
+        } else {
+            console.error('Failed to listen on port 3000');
+            process.exit(1);
+        }
+    });