webhoster 0.1.1 → 0.3.1

package/helpers/RequestHeaders.js

@@ -1,6 +1,6 @@
 import HeadersHandler from './HeadersParser.js';
 
-/** @typedef {import('../types').HttpRequest} HttpRequest */
+/** @typedef {import('../lib/HttpRequest.js').default} HttpRequest */
 
 /**
  * @param {string} cookieString
@@ -15,42 +15,50 @@ function getEntriesFromCookie(cookieString) {
       name = '';
       value = pair.trim();
     } else {
-      name = pair.substr(0, indexOfEquals).trim();
-      value = pair.substr(indexOfEquals + 1).trim();
+      name = pair.slice(0, indexOfEquals).trim();
+      value = pair.slice(indexOfEquals + 1).trim();
     }
     const firstQuote = value.indexOf('"');
     const lastQuote = value.lastIndexOf('"');
     if (firstQuote !== -1 && lastQuote !== -1) {
-      value = value.substring(firstQuote + 1, lastQuote);
+      value = value.slice(firstQuote + 1, lastQuote);
     }
     return [name, value];
   });
 }
 
+/** @type {WeakMap<HttpRequest, RequestHeaders>} */
+const instanceCache = new WeakMap();
+
 export default class RequestHeaders extends HeadersHandler {
-  /** @param {HttpRequest} req */
-  constructor(req) {
-    super(req.headers);
+  /** @param {HttpRequest} request */
+  constructor(request) {
+    const instance = instanceCache.get(request);
+    if (instance) return instance;
+    super(request.headers);
+    instanceCache.set(request, this);
+  }
+
+  /**
+   * @param {HttpRequest} request
+   * @return {{get:(name:string)=>string,all:(name:string)=>string[]}}
+   */
+  static cookies(request) {
+    const instance = new RequestHeaders(request);
+    return instance.cookies;
   }
 
   /** @type {Object<string,string[]>} */
   #cookiesProxy = null;
 
+  /** @return {{get:(name:string)=>string,all:(name:string)=>string[]}} */
   get cookies() {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const instance = this;
     return {
-      /**
-       * @param {string} name
-       * @return {string}
-       */
       get(name) {
         return instance.cookieEntries[name]?.[0];
       },
-      /**
-       * @param {string} name
-       * @return {string[]}
-       */
       all(name) {
         return instance.cookieEntries[name] ?? [];
       },
@@ -73,42 +81,41 @@ export default class RequestHeaders extends HeadersHandler {
           const cookieString = (instance.headers.cookie ?? '');
           const split = cookieString.split(';');
           const values = [];
-          for (let i = 0; i < split.length; i += 1) {
-            const [key, value] = split[i].split('=');
+          for (const element of split) {
+            const [key, value] = element.split('=');
             if (key.trim() === cookieName) values.push(value);
           }
           const arrayProxy = new Proxy(values, {
-            get: (arrayTarget, arrayProp, receiver) => {
-              if (typeof arrayProp !== 'string') {
-                return Reflect.get(arrayTarget, arrayProp, receiver);
+            get: (arrayTarget, arrayProperty, receiver) => {
+              if (typeof arrayProperty !== 'string') {
+                return Reflect.get(arrayTarget, arrayProperty, receiver);
               }
-              if (arrayProp === 'length') {
+              if (arrayProperty === 'length') {
                 return getEntriesFromCookie(instance.headers.cookie ?? '')
                   .filter(([key]) => (key === cookieName)).length;
               }
-              if (Number.isNaN(parseInt(arrayProp, 10))) {
-                return Reflect.get(arrayTarget, arrayProp, receiver);
+              if (Number.isNaN(Number.parseInt(arrayProperty, 10))) {
+                return Reflect.get(arrayTarget, arrayProperty, receiver);
               }
               const entries = getEntriesFromCookie(instance.headers.cookie ?? '');
               let count = 0;
-              for (let i = 0; i < entries.length; i += 1) {
-                const entry = entries[i];
+              for (const entry of entries) {
                 if (entry[0] === cookieName) {
-                  if (arrayProp === count.toString()) {
+                  if (arrayProperty === count.toString()) {
                     return entry[1];
                   }
                   count += 1;
                 }
               }
-              return Reflect.get(arrayTarget, arrayProp, receiver);
+              return Reflect.get(arrayTarget, arrayProperty, receiver);
             },
-            set: (arrayTarget, arrayProp, value, receiver) => {
-              Reflect.set(arrayTarget, arrayProp, value, receiver);
-              if (typeof arrayProp !== 'string') return true;
-              const result = getEntriesFromCookie(instance.headers.cookie ?? '').reduce((prev, curr) => {
-                if (!curr[0]) return prev;
-                if (curr[0] === cookieName) return prev;
-                return `${prev};${curr[0]}=${curr[1]}`;
+            set: (arrayTarget, arrayProperty, value, receiver) => {
+              Reflect.set(arrayTarget, arrayProperty, value, receiver);
+              if (typeof arrayProperty !== 'string') return true;
+              const result = getEntriesFromCookie(instance.headers.cookie ?? '').reduce((previous, current) => {
+                if (!current[0]) return previous;
+                if (current[0] === cookieName) return previous;
+                return `${previous};${current[0]}=${current[1]}`;
               }, arrayTarget.map((v) => `${cookieName}=${v}`).join(';'));
               instance.headers.cookie = result;
               return true;
@@ -122,8 +129,8 @@ export default class RequestHeaders extends HeadersHandler {
           const split = cookieString.split(';');
           /** @type {string[]} */
           const keys = [];
-          for (let i = 0; i < split.length; i += 1) {
-            const [key] = split[i].split('=');
+          for (const element of split) {
+            const [key] = element.split('=');
             const trimmed = key?.trim();
             if (trimmed && !keys.includes(trimmed)) {
               keys.push(trimmed);

package/helpers/RequestReader.js

@@ -1,6 +1,6 @@
 /** @typedef {import('../types').HttpRequest} HttpRequest */
 
-import { TextDecoder } from 'util';
+import { TextDecoder } from 'node:util';
 import AsyncObject from '../utils/AsyncObject.js';
 import { noop } from '../utils/function.js';
 import RequestHeaders from './RequestHeaders.js';
@@ -43,7 +43,7 @@ export default class RequestReader {
     if (this.#buffer.isBusy() || this.#buffer.hasValue()) return this.#buffer.get();
     this.#buffer.prepare();
     const hp = new RequestHeaders(this.request);
-    let data = Buffer.alloc(Math.min(BUFFER_SIZE, hp.contentLength || BUFFER_SIZE));
+    let data = Buffer.allocUnsafe(Math.min(BUFFER_SIZE, hp.contentLength || BUFFER_SIZE));
     let bytesWritten = 0;
     /** @type {NodeJS.Timeout} */
     let sendPingTimeout = null;
@@ -64,7 +64,7 @@ export default class RequestReader {
           while (newLength < buffer.length + data.length) {
             newLength *= 2;
           }
-          const newBuffer = Buffer.alloc(newLength);
+          const newBuffer = Buffer.allocUnsafe(newLength);
           data.copy(newBuffer);
           data = newBuffer;
         }
@@ -80,12 +80,13 @@ export default class RequestReader {
     this.request.stream.on('end', () => {
       clearTimeout(sendPingTimeout);
       if (data.length > bytesWritten) {
+        // Must partition to clear unsafe allocation
         data = data.subarray(0, bytesWritten);
       }
       this.#buffer.set(data);
     });
-    this.request.stream.on('error', (err) => {
-      this.#buffer.reset(err);
+    this.request.stream.on('error', (error) => {
+      this.#buffer.reset(error);
     });
     return this.#buffer.get();
   }
@@ -93,9 +94,9 @@ export default class RequestReader {
   /** @return {Promise<string>} */
   readString() {
     return this.readBuffer().then((buffer) => {
-      const reqHeaders = new RequestHeaders(this.request);
+      const requestHeaders = new RequestHeaders(this.request);
       // TODO: Compare TextDecoder, Buffer.from(), and StringDecoder performance
-      const decoder = new TextDecoder(reqHeaders.charset || 'utf-8');
+      const decoder = new TextDecoder(requestHeaders.charset || 'utf-8');
       return decoder.decode(buffer);
     });
   }
@@ -116,38 +117,38 @@ export default class RequestReader {
    */
   readUrlEncoded() {
     // https://url.spec.whatwg.org/#urlencoded-parsing
-    const reqHeaders = new RequestHeaders(this.request);
-    const decoder = new TextDecoder(reqHeaders.charset || 'utf-8');
+    const requestHeaders = new RequestHeaders(this.request);
+    const decoder = new TextDecoder(requestHeaders.charset || 'utf-8');
     return this.readBuffer().then((buffer) => {
       const sequences = [];
       let startIndex = 0;
-      for (let i = 0; i < buffer.length; i += 1) {
-        if (buffer[i] === 0x26) {
-          sequences.push(buffer.subarray(startIndex, i));
-          startIndex = i + 1;
+      for (let index = 0; index < buffer.length; index += 1) {
+        if (buffer[index] === 0x26) {
+          sequences.push(buffer.subarray(startIndex, index));
+          startIndex = index + 1;
         }
-        if (i === buffer.length - 1) {
-          sequences.push(buffer.subarray(startIndex, i));
+        if (index === buffer.length - 1) {
+          sequences.push(buffer.subarray(startIndex, index));
         }
       }
       /** @type {[string, string][]} */
       const output = [];
-      sequences.forEach((bytes) => {
-        if (!bytes.length) return;
+      for (const bytes of sequences) {
+        if (!bytes.length) continue;
 
         // Find 0x3D and replace 0x2B in one loop for better performance
         let indexOf0x3D = -1;
-        for (let i = 0; i < bytes.length; i += 1) {
-          switch (bytes[i]) {
+        for (let index = 0; index < bytes.length; index += 1) {
+          switch (bytes[index]) {
             case 0x3D:
               if (indexOf0x3D === -1) {
-                indexOf0x3D = i;
+                indexOf0x3D = index;
               }
               break;
             case 0x2B:
               // Replace bytes on original stream for memory conservation
               // eslint-disable-next-line no-param-reassign
-              bytes[i] = 0x20;
+              bytes[index] = 0x20;
               break;
             default:
           }
@@ -164,7 +165,7 @@ export default class RequestReader {
         const nameString = decodeURIComponent(decoder.decode(name));
         const valueString = decodeURIComponent(decoder.decode(value));
         output.push([nameString, valueString]);
-      });
+      }
       return output;
     });
   }
@@ -184,8 +185,8 @@ export default class RequestReader {
    * @return {Promise<Object<string, any>|null>}
    */
   readObject() {
-    const reqHeaders = new RequestHeaders(this.request);
-    const mediaType = reqHeaders.mediaType?.toLowerCase() ?? '';
+    const requestHeaders = new RequestHeaders(this.request);
+    const mediaType = requestHeaders.mediaType?.toLowerCase() ?? '';
     switch (mediaType) {
       case 'application/json':
         return this.readJSON();
@@ -201,8 +202,8 @@ export default class RequestReader {
    * @return {Promise<Object<string,any>|string|Buffer>}
    */
   read() {
-    const reqHeaders = new RequestHeaders(this.request);
-    const mediaType = reqHeaders.mediaType?.toLowerCase() ?? '';
+    const requestHeaders = new RequestHeaders(this.request);
+    const mediaType = requestHeaders.mediaType?.toLowerCase() ?? '';
     switch (mediaType) {
       case 'application/json':
         return this.readJSON();

package/helpers/ResponseHeaders.js

@@ -2,7 +2,7 @@ import CookieObject from '../data/CookieObject.js';
 
 import HeadersHandler from './HeadersParser.js';
 
-/** @typedef {import('../types').HttpResponse} HttpResponse */
+/** @typedef {import('../lib/HttpResponse.js').default} HttpResponse */
 /** @typedef {import('../types').CookieDetails} CookieDetails */
 
 /** @type {(keyof CookieDetails)[]} */
@@ -18,10 +18,23 @@ const COOKIE_DETAIL_KEYS = [
   'sameSite',
 ];
 
+/** @type {WeakMap<HttpResponse, ResponseHeaders>} */
+const instanceCache = new WeakMap();
+
 export default class ResponseHeaders extends HeadersHandler {
   /** @param {HttpResponse} res */
+  // @ts-ignore Cached constructor
   constructor(res) {
+    const instance = instanceCache.get(res);
+    if (instance) return instance;
     super(res.headers);
+    instanceCache.set(res, this);
+  }
+
+  /** @param {HttpResponse} res */
+  static cookies(res) {
+    const instance = new ResponseHeaders(res);
+    return instance.cookies;
   }
 
   /** @type {CookieObject[]} */
@@ -29,8 +42,8 @@ export default class ResponseHeaders extends HeadersHandler {
 
   /** @type {ProxyHandler<CookieObject>} */
   #cookieObjectProxyHandler = {
-    set: (cookieTarget, cookieProp, cookieValue, receiver) => {
-      Reflect.set(cookieTarget, cookieProp, cookieValue, receiver);
+    set: (cookieTarget, cookieProperty, cookieValue, receiver) => {
+      Reflect.set(cookieTarget, cookieProperty, cookieValue, receiver);
       const index = this.cookieEntries.findIndex((entry) => entry.toString() === cookieTarget.toString());
       if (index !== -1) {
         // Force reflection
@@ -94,9 +107,9 @@ export default class ResponseHeaders extends HeadersHandler {
       case 'utf-8':
       case 'utf8':
         return 'utf-8';
-      default:
       case 'base64':
       case 'hex':
+      default:
         return /** @type {BufferEncoding} */ (charset);
     }
   }
@@ -118,9 +131,9 @@ export default class ResponseHeaders extends HeadersHandler {
       case 'utf8':
         this.charset = 'utf-8';
         break;
-      default:
       case 'base64':
       case 'hex':
+      default:
         this.charset = bufferEncoding;
     }
   }
@@ -149,7 +162,7 @@ export default class ResponseHeaders extends HeadersHandler {
   }
 
   get cookies() {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
     const instance = this;
     return {
       /**
@@ -205,7 +218,7 @@ export default class ResponseHeaders extends HeadersHandler {
                 return details[key] === cookieObject[key];
             }
           }))
-          .sort((a, b) => (b?.path?.length ?? 0 - a?.path?.length ?? 0));
+          .sort((a, b) => ((b?.path?.length ?? 0) - (a?.path?.length ?? 0)));
       },
       /**
        * @param {string|CookieDetails} cookie
@@ -217,14 +230,14 @@ export default class ResponseHeaders extends HeadersHandler {
           path: '',
           ...details,
         });
-        if (!cookieObject) {
+        if (cookieObject) {
+          for (const key of COOKIE_DETAIL_KEYS) {
+            // @ts-expect-error Coerce
+            cookieObject[key] = details[key];
+          }
+        } else {
           cookieObject = new Proxy(new CookieObject(details), instance.#cookieObjectProxyHandler);
           instance.cookieEntries.push(cookieObject);
-        } else {
-          COOKIE_DETAIL_KEYS.forEach((key) => {
-            // @ts-ignore Coerce
-            cookieObject[key] = details[key];
-          });
         }
         return cookieObject;
       },
@@ -235,9 +248,9 @@ export default class ResponseHeaders extends HeadersHandler {
       remove(partial) {
         const items = this.getAll(partial);
         const count = items.length;
-        items.forEach((item) => {
+        for (const item of items) {
           instance.cookieEntries.splice(instance.cookieEntries.indexOf(item), 1);
-        });
+        }
         return count;
       },
       /**
@@ -262,13 +275,11 @@ export default class ResponseHeaders extends HeadersHandler {
        */
       expireAll(partial) {
         const items = this.getAll(partial);
-        items.forEach((item) => {
-          /* eslint-disable no-param-reassign */
+        for (const item of items) {
           item.expires = null;
           item.maxAge = 0;
           item.value = '';
-          /* eslint-enable no-param-reassign */
-        });
+        }
         return items;
       },
     };
@@ -289,37 +300,37 @@ export default class ResponseHeaders extends HeadersHandler {
           instance.#cookieObjectProxyHandler,
         ));
       this.#setCookiesProxy = new Proxy(values, {
-        get: (arrayTarget, arrayProp, receiver) => {
-          if (typeof arrayProp !== 'string') {
-            return Reflect.get(arrayTarget, arrayProp, receiver);
+        get: (arrayTarget, arrayProperty, receiver) => {
+          if (typeof arrayProperty !== 'string') {
+            return Reflect.get(arrayTarget, arrayProperty, receiver);
           }
-          if (arrayProp === 'length') {
+          if (arrayProperty === 'length') {
             return instance.headers['set-cookie'].length;
           }
-          if (Number.isNaN(parseInt(arrayProp, 10))) {
-            return Reflect.get(arrayTarget, arrayProp, receiver);
+          if (Number.isNaN(Number.parseInt(arrayProperty, 10))) {
+            return Reflect.get(arrayTarget, arrayProperty, receiver);
           }
-          const entry = instance.headers['set-cookie'][arrayProp];
-          if (typeof entry === 'undefined') {
+          const entry = instance.headers['set-cookie'][arrayProperty];
+          if (entry === undefined) {
             return entry;
           }
-          if (arrayProp in arrayTarget === false) {
+          if (arrayProperty in arrayTarget === false) {
             Reflect.set(
               arrayTarget,
-              arrayProp,
+              arrayProperty,
               new Proxy(new CookieObject(entry), instance.#cookieObjectProxyHandler),
             );
           }
-          return Reflect.get(arrayTarget, arrayProp, receiver);
+          return Reflect.get(arrayTarget, arrayProperty, receiver);
         },
-        set: (arrayTarget, arrayProp, value, receiver) => {
-          Reflect.set(arrayTarget, arrayProp, value, receiver);
-          if (typeof arrayProp !== 'string') return true;
-          if (arrayProp === 'length') {
-            Reflect.set(instance.headers['set-cookie'], arrayProp, value);
+        set: (arrayTarget, arrayProperty, value, receiver) => {
+          Reflect.set(arrayTarget, arrayProperty, value, receiver);
+          if (typeof arrayProperty !== 'string') return true;
+          if (arrayProperty === 'length') {
+            Reflect.set(instance.headers['set-cookie'], arrayProperty, value);
           }
           if (value instanceof CookieObject) {
-            instance.headers['set-cookie'][arrayProp] = value.toString();
+            instance.headers['set-cookie'][arrayProperty] = value.toString();
           }
           return true;
         },

package/jsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "checkJs": true,
     "noImplicitAny": true,
-    "target": "es2020",
+    "target": "es2022",
     "module": "esnext",
     "moduleResolution": "node"
   },