@koeroesi86/node-worker-express 20.10.7-db6bdc3 → 22.3.12-fd2e588

package/README.md

@@ -1,4 +1,4 @@
-# Node Worker Express [![Build status](https://travis-ci.org/Koeroesi86/node-worker-express.svg?branch=master)](https://travis-ci.org/Koeroesi86/node-worker-express)
+# Node Worker Express [![Build Status](https://app.travis-ci.com/Koeroesi86/node-worker-express.svg?branch=master)](https://app.travis-ci.com/Koeroesi86/node-worker-express)
 
 Express JS library for [@koeroesi86/node-worker](https://www.npmjs.com/package/@koeroesi86/node-worker)
 

package/constants/index.js

@@ -2,7 +2,9 @@ const WORKER_EVENT = {
   REQUEST: 'WORKER_REQUEST',
   REQUEST_ACKNOWLEDGE: 'WORKER_REQUEST_ACK',
   RESPONSE: 'WORKER_RESPONSE',
+  RESPONSE_EMIT: 'WORKER_RESPONSE_EMIT',
   RESPONSE_ACKNOWLEDGE: 'WORKER_RESPONSE_ACK',
+  WS_MESSAGE_RECEIVE: 'WS_MESSAGE_RECEIVE',
   WS_MESSAGE_SEND: 'WS_MESSAGE_SEND',
   WS_CONNECTION_CLOSE: 'WS_CONNECTION_CLOSE',
   WS_CONNECTION_CLOSE_ACKNOWLEDGE: 'WS_CONNECTION_CLOSE_ACK',

package/examples/public/websocket/worker.js

@@ -9,7 +9,7 @@ const createDigest = key => createHash('sha1')
   .digest('base64');
 
 module.exports = (event, callback) => {
-  if (event.protocol === 'WS') {
+  if (event.protocol === 'WS' && event.frame === undefined) {
     const key = (event.headers['sec-websocket-key'] || '').trim();
     const digest = createDigest(key);
 
@@ -32,15 +32,22 @@ module.exports = (event, callback) => {
       });
 
       timers[key] = setInterval(() => {
+        const frame = JSON.stringify({ now: Date.now() })
+        console.log('outgoing message:', frame);
         callback({
           sendWsMessage: true,
-          frame: JSON.stringify({ now: Date.now() }),
+          frame,
         });
       }, 1000);
       return;
     }
   }
 
+  if (event.protocol === 'WS' && event.frame !== undefined) {
+    console.log('incoming message:', event.frame);
+    return;
+  }
+
   callback({
     statusCode: 400,
     headers: {

package/examples/staticWorker.js

@@ -2,9 +2,14 @@ const path = require('path');
 const fs = require('fs');
 const crypto = require('crypto');
 const { execSync } = require('child_process');
+const { Writable } = require('stream');
 
 let timer;
 
+const features = {
+  enableEmit: false,
+};
+
 function debounce(fn = () => {}, timeout = 0) {
   if (timer) clearTimeout(timer);
   timer = setTimeout(() => {
@@ -133,8 +138,7 @@ function getCharset(body, fileName) {
     return 'iso-8859-1';
 
   try {
-    const out = execSync(`file -b --mime-encoding ${fileName}`).toString('utf8').trim();
-    return out;
+    return execSync(`file -b --mime-encoding ${fileName}`).toString('utf8').trim();
   } catch (e) {
     //
   }
@@ -169,19 +173,54 @@ const staticWorker = (event, callback = () => {}) => {
         isModified = false;
       }
     }
-
-    callback({
+    const response = {
       statusCode: isModified ? 200 : 304,
       headers: {
         'Content-Type': `${contentType}${charset ? `; charset=${charset}` : ''}`,
         'Cache-Control': 'public, max-age=0',
-        'Content-Length': bodyBuffer.length,
+        'Content-Length': bodyBuffer.byteLength,
         'ETag': currentEtag,
         ...(stats.mtime && { 'Last-Modified': lastModified.toUTCString() }),
       },
-      body: bodyBuffer.toString('base64'),
+      body: isModified ? bodyBuffer.toString('base64') : '',
       isBase64Encoded: true,
-    });
+    };
+
+    if (features.enableEmit && isModified) {
+      const writer = new Writable({
+        /**
+         * @param {Buffer} chunk
+         * @param {string} encoding
+         * @param {Function} next
+         */
+        write(chunk, encoding, next) {
+          response.emit = true;
+          response.isBase64Encoded = true;
+          response.body = chunk.toString('base64');
+          // console.log('sending', chunk.length, 'bytes')
+          callback(response);
+          next();
+        },
+        destroy() {
+          response.isBase64Encoded = false;
+          response.emit = true;
+          response.body = null;
+          callback(response);
+        },
+      });
+
+      fs.createReadStream(fileName, {
+        // encoding: 'binary',
+        // encoding: 'utf-8',
+        emitClose: false,
+        autoClose: false,
+        // highWaterMark: 16,
+        start: 0,
+        end: Infinity,
+      }).pipe(writer);
+    } else {
+      callback(response);
+    }
   } else {
     callback({
       statusCode: 404,

package/index.d.ts

@@ -25,6 +25,8 @@ declare namespace Middleware {
     remoteAddress: string;
     body: string;
     rootPath: string;
+    closed?: boolean;
+    frame?: string;
   }
 
   type WorkerInputEvent = {
@@ -43,6 +45,7 @@ declare namespace Middleware {
     statusCode: number;
     headers?: { [key: string]: string };
     isBase64Encoded?: boolean;
+    emit?: boolean;
     body?: string;
   }
 
@@ -51,7 +54,7 @@ declare namespace Middleware {
     frame: string;
   }
 
-  function InvokableWorker(event: RequestEvent, callback: (e: ResponseEvent) => void): void;
+  type InvokableWorker = (event: RequestEvent, callback: (e: ResponseEvent) => void) => void;
 }
 
 declare module '@koeroesi86/node-worker-express' {

package/middleware/bodyParser.js

@@ -1,5 +1,14 @@
-const bodyParser = (config = { limitRequestBody: 1000000 }) => (request, response, next) => {
+const ignoredMethods = ['get', 'delete', 'options', 'head'];
+
+const bodyParser = (config = { limitRequestBody: 1000000, shouldError: true }) => (request, response, next) => {
   let body = '';
+
+  if (ignoredMethods.includes(request.method.toLowerCase())) {
+    request.body = body;
+    next();
+    return;
+  }
+
   request.on('data', data => {
     body += data;
 
@@ -7,12 +16,17 @@ const bodyParser = (config = { limitRequestBody: 1000000 }) => (request, respons
     // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
     if (body.length > (config.limitRequestBody || 1000000)) {
       body = "";
-      response.writeHead(413, { 'Content-Type': 'text/plain' });
-      response.end();
-      request.connection.destroy();
-      // next();
+
+      if (config.shouldError) {
+        response.writeHead(413, { 'Content-Type': 'text/plain' });
+        response.end();
+        request.connection.destroy();
+      } else {
+        next();
+      }
     }
   });
+
   request.on('end', () => {
     request.body = body;
     next();

package/middleware/index.js

@@ -4,149 +4,22 @@ const fs = require('fs');
 const url = require('url');
 const { WORKER_EVENT } = require('../constants');
 const WorkerPool = require('../utils/workerPool');
-const bodyParser = require('./bodyParser');
+const isWebSocket = require('../utils/isWebSocket');
+const parseWsMessage = require('../utils/parseWsMessage');
+const constructWsMessage = require('../utils/constructWsMessage');
+const getClientIp = require('../utils/getClientIp');
+const createBodyParser = require('./bodyParser');
 
-const FORBIDDEN_PATHS = [
+const ForbiddenPaths = [
   '..'
 ];
 
-const PROTOCOLS = {
-  HTTP: 'HTTP',
-  WEBSOCKET: 'WS',
+const Protocols = {
+  http: 'HTTP',
+  websocket: 'WS',
 };
 
-const isWebSocket = request => {
-  if (request.method !== 'GET') return false;
-
-  const connection = request.headers.connection || '';
-  const upgrade = request.headers.upgrade || '';
-
-  return request.method === 'GET' &&
-    connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
-    upgrade.toLowerCase() === 'websocket';
-};
-
-/**
- * TODO: improve
- * @param {Buffer} data
- * @returns {string}
- */
-const parseWsMessage = data => {
-  const dl = data[1] & 127;
-  let ifm = 2;
-  if (dl === 126) {
-    ifm = 4;
-  } else if (dl === 127) {
-    ifm = 10;
-  }
-  let i = ifm + 4;
-  const masks = data.slice(ifm, i);
-  let index = 0;
-  let output = "";
-  const l = data.length;
-  while (i < l) {
-    output += String.fromCharCode(data[i++] ^ masks[index++ % 4]);
-  }
-  return output;
-};
-
-/**
- * TODO: improve
- * @param {String} text
- * @returns {Buffer}
- */
-const constructWsMessage = text => {
-  const jsonByteLength = Buffer.byteLength(text);
-  // Note: we're not supporting > 65535 byte payloads at this stage
-  const lengthByteCount = jsonByteLength < 126 ? 0 : 2;
-  const payloadLength = lengthByteCount === 0 ? jsonByteLength : 126;
-  const buffer = Buffer.alloc(2 + lengthByteCount + jsonByteLength);
-  // Write out the first byte, using opcode `1` to indicate that the message
-  // payload contains text data
-  buffer.writeUInt8(0b10000001, 0);
-  buffer.writeUInt8(payloadLength, 1);
-  // Write the length of the JSON payload to the second byte
-  let payloadOffset = 2;
-  if (lengthByteCount > 0) {
-    buffer.writeUInt16BE(jsonByteLength, 2);
-    payloadOffset += lengthByteCount;
-  }
-  // Write the JSON data to the data buffer
-  buffer.write(text, payloadOffset);
-  return buffer;
-};
-
-/**
- * @param {module:http~IncomingMessage} request
- * @returns {string}
- */
-const getClientIp = request => {
-  if (request.headers['x-client-ip']) {
-    return request.headers['x-client-ip'];
-  }
-
-  if (request.headers['x-forwarded-for']) {
-    return request.headers['x-forwarded-for'];
-  }
-
-  if (request.headers['cf-connecting-ip']) {
-    return request.headers['cf-connecting-ip'];
-  }
-
-  if (request.headers['fastly-client-ip']) {
-    return request.headers['fastly-client-ip'];
-  }
-
-  if (request.headers['true-client-ip']) {
-    return request.headers['true-client-ip'];
-  }
-
-  if (request.headers['x-real-ip']) {
-    return request.headers['x-real-ip'];
-  }
-
-  if (request.headers['x-cluster-client-ip']) {
-    return request.headers['x-cluster-client-ip'];
-  }
-
-  if (request.headers['x-forwarded']) {
-    return request.headers['x-forwarded'];
-  }
-
-  if (request.headers['forwarded-for']) {
-    return request.headers['forwarded-for'];
-  }
-
-  if (request.headers.forwarded) {
-    return request.headers.forwarded;
-  }
-
-  if (request.connection) {
-    if (request.connection.remoteAddress) {
-      return request.connection.remoteAddress;
-    }
-
-    if (request.connection.socket && request.connection.socket.remoteAddress) {
-      return request.connection.socket.remoteAddress;
-    }
-  }
-
-  if (request.socket && request.socket.remoteAddress) {
-    return request.socket.remoteAddress;
-  }
-
-  if (request.info && request.info.remoteAddress) {
-    return request.info.remoteAddress;
-  }
-
-  if (request.requestContext && request.requestContext.identity && request.requestContext.identity.sourceIp) {
-    return request.requestContext.identity.sourceIp;
-  }
-
-  return '';
-};
-
-const DEFAULT_OPTIONS = {
+const DefaultOptions = {
   root: null,
   limit: 0,
   limitPerPath: 0,
@@ -159,6 +32,11 @@ const DEFAULT_OPTIONS = {
   },
   onExit: () => {
   },
+  onForbiddenPath: (request, response) => {
+    response.writeHead(500, { 'Content-Type': 'text/plain' });
+    response.end();
+    request.connection.destroy();
+  },
   index: [],
   env: {},
   staticWorker: path.resolve(__dirname, '../examples/staticWorker.js'),
@@ -172,7 +50,7 @@ const DEFAULT_OPTIONS = {
  */
 const workerMiddleware = (options) => {
   const config = {
-    ...DEFAULT_OPTIONS,
+    ...DefaultOptions,
     ...(options && options),
   };
   if (!config.root) {
@@ -184,39 +62,51 @@ const workerMiddleware = (options) => {
     onExit: config.onExit,
     idleCheckTimeout: config.idleCheckTimeout,
   });
+  const bodyParser = createBodyParser({ limitRequestBody: config.limitRequestBody });
+  const aliasCache = {};
+  const workerCache = {};
 
-  return (request, response, next) => {
+  return async (request, response, next) => {
     const {
       query: queryStringParameters,
       pathname
     } = url.parse(request.url, true);
-
-    Promise.resolve()
-      .then(() => Promise.race([
-        new Promise(r => setTimeout(r, config.limitRequestTimeout)),
-        new Promise(r => bodyParser({ limitRequestBody: config.limitRequestBody })(request, response, r)),
-      ]))
-      .then(() => {
-        let isIndex = false;
-        const pathFragments = pathname.split(/\//gi).filter(Boolean);
-        let currentPathFragments = pathFragments.slice();
-
-        if (currentPathFragments.find(p => FORBIDDEN_PATHS.includes(p))) {
-          response.writeHead(500, { 'Content-Type': 'text/plain' });
-          response.end();
-          request.connection.destroy();
-          return next();
+    request.pathFragments = pathname.split(/\//gi).filter(Boolean);
+
+    try {
+      let isWorker = false;
+      const pathFragments = pathname.split(/\//gi).filter(Boolean);
+      let currentPathFragments = pathFragments.slice(0);
+      let pathExists = false;
+
+      await new Promise((resolve, reject) => {
+        if (request.pathFragments.find(p => ForbiddenPaths.includes(p))) {
+          config.onForbiddenPath(request, response);
+          reject();
         }
+        resolve();
+      });
 
-        let pathExists = false;
-        let indexPath = path.join(rootPath, ...currentPathFragments);
-
-        for (let i = currentPathFragments.length; i >= 0; i--) {
+      await Promise.race([
+        new Promise((res, rej) => setTimeout(rej, config.limitRequestTimeout)),
+        new Promise(res => bodyParser(request, response, res)),
+      ]);
+      let indexPath;
+
+      if (aliasCache[pathname] && fs.existsSync(aliasCache[pathname])) {
+        isWorker = true;
+        indexPath = aliasCache[pathname];
+      } else if (workerCache[pathname] && fs.existsSync(workerCache[pathname])) {
+        isWorker = true;
+        indexPath = workerCache[pathname];
+      } else {
+        indexPath = path.join(rootPath, ...currentPathFragments)
+
+        for (let i = currentPathFragments.length; i >= 0 && !pathExists; i--) {
           if (pathExists) continue;
           currentPathFragments.splice(i);
           const currentPath = path.join(rootPath, ...currentPathFragments);
           pathExists = fs.existsSync(currentPath);
-
           if (!pathExists) continue;
           const currentStats = fs.statSync(currentPath);
 
@@ -225,138 +115,173 @@ const workerMiddleware = (options) => {
             pathExists = !!config.index.find(indexFile => {
               const checkIndexFilePath = path.join(currentPath, indexFile);
               if (fs.existsSync(checkIndexFilePath)) {
-                isIndex = true;
+                isWorker = true;
                 indexPath = checkIndexFilePath;
+                aliasCache[pathname] = checkIndexFilePath;
+                setTimeout(() => {
+                  aliasCache[pathname] = null;
+                  delete aliasCache[pathname];
+                }, 5000);
                 return true;
               }
             });
             if (pathExists) break;
           } else if (pathExists && currentStats.isFile()) {
             if (config.index.includes(currentPathFragments[currentPathFragments.length - 1])) {
-              isIndex = true;
+              isWorker = true;
+              workerCache[pathname] = currentPath;
+              setTimeout(() => {
+                workerCache[pathname] = null;
+                delete workerCache[pathname];
+              }, 5000);
             }
           }
         }
+      }
+
+      /** @type {RequestEvent} */
+      const event = {
+        httpMethod: request.method.toUpperCase(),
+        protocol: isWebSocket(request) ? Protocols.websocket : Protocols.http,
+        path: pathname,
+        pathFragments: pathFragments,
+        queryStringParameters: JSON.parse(JSON.stringify(queryStringParameters)),
+        headers: request.headers,
+        remoteAddress: getClientIp(request),
+        body: `${request.body}`,
+        rootPath: rootPath,
+      };
+
+      const worker = isWorker ? await workerPool.getWorker(
+        indexPath,
+        {
+          stdio: [ 'pipe', 'pipe', 'pipe', 'ipc' ],
+          env: { ...process.env, ...config.env },
+          cwd: config.cwd,
+        },
+        typeof config.limitPerPath === "function" ? config.limitPerPath(indexPath) : config.limitPerPath
+      ) : await workerPool.getWorker(
+        config.staticWorker,
+        {
+          cwd: process.cwd(),
+          stdio: [ 'pipe', 'pipe', 'pipe', 'ipc' ],
+        },
+        1
+      );
+
+      const requestId = uuid();
+
+      let firstReceived = false;
+      const requestSocketListener = data => {
+        const frame = parseWsMessage(data);
+
+        // TODO: filter open frame better
+        if (data.length === 8 && !firstReceived) {
+          firstReceived = true;
+          return;
+        }
 
-        /** @type {RequestEvent} */
-        const event = {
-          httpMethod: request.method.toUpperCase(),
-          protocol: isWebSocket(request) ? PROTOCOLS.WEBSOCKET : PROTOCOLS.HTTP,
-          path: pathname,
-          pathFragments: pathFragments,
-          queryStringParameters: JSON.parse(JSON.stringify(queryStringParameters)),
-          headers: request.headers,
-          remoteAddress: getClientIp(request),
-          body: `${request.body}`,
-          rootPath: rootPath,
-        };
-
-        Promise.resolve()
-          .then(() => isIndex
-            ? workerPool.getWorker(
-              indexPath,
-              {
-                stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-                env: { PATH: process.env.PATH, ...config.env },
-                cwd: config.cwd,
-              },
-              typeof config.limitPerPath === "function" ? config.limitPerPath(indexPath) : config.limitPerPath
-            )
-            : workerPool.getWorker(
-              config.staticWorker,
-              {
-                cwd: process.cwd(),
-                stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-              },
-              1
-            )
-          )
-          .then(worker => {
-            // worker.busy = true;
-            const requestId = uuid();
-
-            const requestSocketListener = data => {
-              console.info(`[${requestId}] [ws data in] ${parseWsMessage(data)}`);
-            };
-            if (event.protocol === PROTOCOLS.WEBSOCKET) {
-              request.socket.on('data', requestSocketListener);
-            }
-
-            worker.instance.stdout.off('data', config.onStdout);
-            worker.instance.stdout.on('data', config.onStdout);
-
-            worker.instance.stderr.off('data', config.onStderr);
-            worker.instance.stderr.on('data', config.onStderr);
+        firstReceived = true;
 
-            const messageListener = responseEvent => {
-              if (responseEvent.requestId === requestId) {
-                if (responseEvent.type === WORKER_EVENT.RESPONSE) {
-                  worker.postMessage({
-                    type: WORKER_EVENT.RESPONSE_ACKNOWLEDGE,
-                    requestId,
-                  });
-                  /** @type {ResponseEvent|WSFrameEvent} event */
-                  const { event } = responseEvent;
-                  const bufferEncoding = event.isBase64Encoded ? 'base64' : 'utf8';
+        worker.postMessage({
+          type: WORKER_EVENT.WS_MESSAGE_RECEIVE,
+          requestId,
+          event: { ...event, frame }
+        });
+      };
+      if (event.protocol === Protocols.websocket) {
+        request.socket.on('data', requestSocketListener);
+      }
 
-                  response.writeHead(event.statusCode, event.headers);
-                  response.write(Buffer.from(event.body, bufferEncoding));
-                  response.end();
-                }
+      worker.instance.stdout.off('data', config.onStdout);
+      worker.instance.stdout.on('data', config.onStdout);
 
-                if (responseEvent.type === WORKER_EVENT.WS_MESSAGE_SEND) {
-                  console.info(`[${requestId}] [ws data out] ${responseEvent.event.frame}`);
-                  request.socket.write(constructWsMessage(responseEvent.event.frame));
-                }
+      worker.instance.stderr.off('data', config.onStderr);
+      worker.instance.stderr.on('data', config.onStderr);
 
-                if (responseEvent.type === WORKER_EVENT.REQUEST_ACKNOWLEDGE) {
-                  worker.busy = false;
-                }
-              }
-            };
+      const messageListener = responseEvent => {
+        if (responseEvent.requestId === requestId) {
+          if (responseEvent.type === WORKER_EVENT.RESPONSE) {
+            worker.postMessage({
+              type: WORKER_EVENT.RESPONSE_ACKNOWLEDGE,
+              requestId,
+            });
+            /** @type {ResponseEvent|WSFrameEvent} event */
+            const { event } = responseEvent;
+            const bufferEncoding = event.isBase64Encoded ? 'base64' : 'utf8';
 
-            const requestCloseListener = () => {
-              worker.postMessage({
-                type: WORKER_EVENT.WS_CONNECTION_CLOSE,
-                requestId,
-                event
-              });
-              if (request.socket && request.socket.off) request.socket.off('close', requestCloseListener);
-              worker.removeEventListener('message', messageListener);
-            };
-            request.socket.on('close', requestCloseListener);
+            response.writeHead(event.statusCode, event.headers);
+            response.write(Buffer.from(event.body, bufferEncoding));
+            response.end();
+          }
 
-            worker.addEventListener('message', messageListener);
+          if (responseEvent.type === WORKER_EVENT.RESPONSE_EMIT) {
             worker.postMessage({
-              type: WORKER_EVENT.REQUEST,
+              type: WORKER_EVENT.RESPONSE_ACKNOWLEDGE,
               requestId,
-              event,
             });
+            /** @type {ResponseEvent|WSFrameEvent} event */
+            const { event } = responseEvent;
+            const bufferEncoding = event.isBase64Encoded ? 'base64' : 'utf8';
 
-            const cleanupConnection = () => {
-              worker.removeEventListener('message', messageListener);
-              if (request && request.off) {
-                request.off('close', cleanupConnection);
-                request.off('aborted', cleanupConnection);
-              }
-
-              if (request.socket && request.socket.off) {
-                request.socket.off('data', requestSocketListener);
-                request.socket.off('close', requestCloseListener);
-              }
-            };
-            request.on('aborted', cleanupConnection);
-            if (event.protocol === PROTOCOLS.HTTP) {
-              request.on('close', cleanupConnection);
-              response.on('finish', cleanupConnection)
+            if (!response.headersSent) {
+              response.writeHead(event.statusCode, event.headers);
             }
-          });
-      })
-      .catch(e => {
-        response.writeHead(500, { 'Content-Type': 'text/plain' });
-        response.write(`${e}`);
-        response.end();
+            if (event.body !== null) {
+              response.write(Buffer.from(event.body, bufferEncoding).toString());
+            } else {
+              response.end();
+            }
+          }
+
+          if (responseEvent.type === WORKER_EVENT.WS_MESSAGE_SEND) {
+            request.socket.write(constructWsMessage(responseEvent.event.frame));
+          }
+
+          if (responseEvent.type === WORKER_EVENT.REQUEST_ACKNOWLEDGE) {
+            worker.busy = false;
+          }
+        }
+      };
+
+      const requestCloseListener = () => {
+        worker.postMessage({
+          type: WORKER_EVENT.WS_CONNECTION_CLOSE,
+          requestId,
+          event
+        });
+        if (request.socket && request.socket.off) request.socket.off('close', requestCloseListener);
+        worker.removeEventListener('message', messageListener);
+      };
+      request.socket.on('close', requestCloseListener);
+
+      worker.addEventListener('message', messageListener);
+      worker.postMessage({
+        type: WORKER_EVENT.REQUEST,
+        requestId,
+        event,
       });
+
+      const cleanupConnection = () => {
+        worker.removeEventListener('message', messageListener);
+        if (request && request.off) {
+          request.off('close', cleanupConnection);
+          request.off('aborted', cleanupConnection);
+        }
+
+        if (request.socket && request.socket.off) {
+          request.socket.off('data', requestSocketListener);
+          request.socket.off('close', requestCloseListener);
+        }
+      };
+      request.on('aborted', cleanupConnection);
+      if (event.protocol === Protocols.http) {
+        request.on('close', cleanupConnection);
+        response.on('finish', cleanupConnection)
+      }
+    } catch (e) {
+      next(e);
+    }
   };
 };
 

package/middleware/workerInvoke.js

@@ -15,7 +15,22 @@ function messageListener(message) {
     const callback = responseEvent => {
       /** @type {WorkerOutputEvent} e */
       const e = {
-        type: responseEvent.sendWsMessage ? WORKER_EVENT.WS_MESSAGE_SEND : WORKER_EVENT.RESPONSE,
+        type: WORKER_EVENT.RESPONSE,
+        requestId: message.requestId,
+        event: responseEvent,
+      };
+      if (responseEvent.sendWsMessage) e.type = WORKER_EVENT.WS_MESSAGE_SEND;
+      if (responseEvent.emit) e.type = WORKER_EVENT.RESPONSE_EMIT;
+      process.send(e);
+    };
+    worker(message.event, callback);
+  }
+
+  if (message.type === WORKER_EVENT.WS_MESSAGE_RECEIVE) {
+    const callback = responseEvent => {
+      /** @type {WorkerOutputEvent} e */
+      const e = {
+        type: WORKER_EVENT.WS_MESSAGE_SEND,
         requestId: message.requestId,
         event: responseEvent,
       }
@@ -23,6 +38,7 @@ function messageListener(message) {
     };
     worker(message.event, callback);
   }
+
   if (message.type === WORKER_EVENT.WS_CONNECTION_CLOSE) {
     /** @type {ResponseEvent} responseEvent */
     worker({ ...message.event, closed: true }, responseEvent => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koeroesi86/node-worker-express",
-  "version": "v20.10.7-db6bdc3",
+  "version": "v22.03.12-fd2e588",
   "description": "",
   "main": "index.js",
   "author": {
@@ -19,12 +19,12 @@
   "license": "MIT",
   "dependencies": {
     "@koeroesi86/node-worker": "^1.0.3-6bc3bc7",
-    "uuid": "^7.0.3"
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@types/express": "^4.17.6",
-    "@types/node": "^13.11.1",
-    "express": "^4.17.1",
-    "nodemon": "^2.0.3"
+    "@types/express": "^4.17.13",
+    "@types/node": "^17.0.21",
+    "express": "^4.17.3",
+    "nodemon": "^2.0.15"
   }
 }

package/utils/constructWsMessage.js

@@ -0,0 +1,27 @@
+/**
+ * TODO: improve
+ * @param {String} text
+ * @returns {Buffer}
+ */
+const constructWsMessage = text => {
+  const jsonByteLength = Buffer.byteLength(text);
+  // Note: we're not supporting > 65535 byte payloads at this stage
+  const lengthByteCount = jsonByteLength < 126 ? 0 : 2;
+  const payloadLength = lengthByteCount === 0 ? jsonByteLength : 126;
+  const buffer = Buffer.alloc(2 + lengthByteCount + jsonByteLength);
+  // Write out the first byte, using opcode `1` to indicate that the message
+  // payload contains text data
+  buffer.writeUInt8(0b10000001, 0);
+  buffer.writeUInt8(payloadLength, 1);
+  // Write the length of the JSON payload to the second byte
+  let payloadOffset = 2;
+  if (lengthByteCount > 0) {
+    buffer.writeUInt16BE(jsonByteLength, 2);
+    payloadOffset += lengthByteCount;
+  }
+  // Write the JSON data to the data buffer
+  buffer.write(text, payloadOffset);
+  return buffer;
+};
+
+module.exports = constructWsMessage;

package/utils/getClientIp.js

@@ -0,0 +1,71 @@
+/**
+ * @param {module:http~IncomingMessage} request
+ * @returns {string}
+ */
+const getClientIp = request => {
+  if (request.headers['x-client-ip']) {
+    return request.headers['x-client-ip'];
+  }
+
+  if (request.headers['x-forwarded-for']) {
+    return request.headers['x-forwarded-for'];
+  }
+
+  if (request.headers['cf-connecting-ip']) {
+    return request.headers['cf-connecting-ip'];
+  }
+
+  if (request.headers['fastly-client-ip']) {
+    return request.headers['fastly-client-ip'];
+  }
+
+  if (request.headers['true-client-ip']) {
+    return request.headers['true-client-ip'];
+  }
+
+  if (request.headers['x-real-ip']) {
+    return request.headers['x-real-ip'];
+  }
+
+  if (request.headers['x-cluster-client-ip']) {
+    return request.headers['x-cluster-client-ip'];
+  }
+
+  if (request.headers['x-forwarded']) {
+    return request.headers['x-forwarded'];
+  }
+
+  if (request.headers['forwarded-for']) {
+    return request.headers['forwarded-for'];
+  }
+
+  if (request.headers.forwarded) {
+    return request.headers.forwarded;
+  }
+
+  if (request.connection) {
+    if (request.connection.remoteAddress) {
+      return request.connection.remoteAddress;
+    }
+
+    if (request.connection.socket && request.connection.socket.remoteAddress) {
+      return request.connection.socket.remoteAddress;
+    }
+  }
+
+  if (request.socket && request.socket.remoteAddress) {
+    return request.socket.remoteAddress;
+  }
+
+  if (request.info && request.info.remoteAddress) {
+    return request.info.remoteAddress;
+  }
+
+  if (request.requestContext && request.requestContext.identity && request.requestContext.identity.sourceIp) {
+    return request.requestContext.identity.sourceIp;
+  }
+
+  return '';
+};
+
+module.exports = getClientIp;

package/utils/isWebSocket.js

@@ -0,0 +1,16 @@
+/**
+ * @param {module:http~IncomingMessage} request
+ * @returns {boolean}
+ */
+const isWebSocket = request => {
+  if (request.method !== 'GET') return false;
+
+  const connection = request.headers.connection || '';
+  const upgrade = request.headers.upgrade || '';
+
+  return request.method === 'GET' &&
+    connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
+    upgrade.toLowerCase() === 'websocket';
+};
+
+module.exports = isWebSocket;

package/utils/parseWsMessage.js

@@ -0,0 +1,25 @@
+/**
+ * TODO: improve
+ * @param {Buffer} data
+ * @returns {string}
+ */
+const parseWsMessage = data => {
+  const dl = data[1] & 127;
+  let ifm = 2;
+  if (dl === 126) {
+    ifm = 4;
+  } else if (dl === 127) {
+    ifm = 10;
+  }
+  let i = ifm + 4;
+  const masks = data.slice(ifm, i);
+  let index = 0;
+  let output = "";
+  const l = data.length;
+  while (i < l) {
+    output += String.fromCharCode(data[i++] ^ masks[index++ % 4]);
+  }
+  return output;
+};
+
+module.exports = parseWsMessage;

package/utils/workerPool.js

@@ -14,7 +14,7 @@ const createWorkerCommand = workerPath => {
   switch (ext) {
     case '.js':
     default:
-      return `node ${path.resolve(__dirname, '../middleware/workerInvoke.js')} ${workerPath}`;
+      return `node --expose-gc ${path.resolve(__dirname, '../middleware/workerInvoke.js')} ${workerPath}`;
   }
 };
 
@@ -67,36 +67,34 @@ class WorkerPool {
       || (this.overallLimit > 0 && this.getWorkerCount() >= this.overallLimit);
   }
 
-  getWorker(workerPath, options = {}, limit = 0) {
+  async getWorker(workerPath, options = {}, limit = 0) {
     const nonBusyId = this.getNonBusyId(workerPath);
     // TODO: tidy up
     if (nonBusyId !== undefined) {
-      return Promise.resolve(this.workers[workerPath][nonBusyId]);
+      return this.workers[workerPath][nonBusyId];
     } else if (this.isBeyondLimit(workerPath, limit) || this._creating) {
-      return Promise.resolve()
-        .then(() => new Promise(r => setTimeout(r, this.idleCheckTimeout)))
-        .then(() => this.getWorker(workerPath, options, limit));
+      await new Promise(r => setTimeout(r, this.idleCheckTimeout));
+      return this.getWorker(workerPath, options, limit);
     }
 
     this._creating = true;
-    return Promise.resolve()
-      .then(() => {
-        const id = uuid();
-        const instance = new Worker(createWorkerCommand(workerPath), options);
-
-        instance.addEventListenerOnce('close', code => {
-          this.workers[workerPath][id] = null;
-          delete this.workers[workerPath][id];
-          this.onExit(code, workerPath, id);
-        });
-        this.workers[workerPath] = {
-          ...(this.workers[workerPath] && this.workers[workerPath]),
-          [id]: instance,
-        };
-
-        this._creating = false;
-        return Promise.resolve(instance);
-      });
+    const id = uuid();
+    const instance = new Worker(createWorkerCommand(workerPath), options);
+
+    if (!this.workers[workerPath]) {
+      this.workers[workerPath] = {};
+    }
+
+    instance.addEventListenerOnce('close', code => {
+      this.workers[workerPath][id] = null;
+      delete this.workers[workerPath][id];
+      this.onExit(code, workerPath, id);
+    });
+
+    this.workers[workerPath][id] = instance;
+
+    this._creating = false;
+    return instance;
   }
 }