barehttp 0.3.1 → 0.4.2

package/README.md

@@ -49,7 +49,7 @@ yarn add barehttp
 ```typescript
 import { BareHttp, logMe } from 'barehttp';
 
-const app = new BareHttp({ logging: false });
+const app = new BareHttp();
 
 app.get({
   route: '/route',
@@ -88,7 +88,7 @@ app.start((address) => {
 ```typescript
 import { BareHttp, logMe } from 'barehttp';
 
-const app = new BareHttp({ logging: false });
+const app = new BareHttp({ logging: true });
 
 app.get({
   route:'/route',
@@ -186,12 +186,16 @@ Default `false`
 
 Exposes a basic report with the routes usage under `GET /_report` route
 
-### `BareServer.use` ((flow: BareRequest) => Promise<void> | void)
+---
+
+## `BareServer.use` ((flow: BareRequest) => Promise<void> | void)
 
 Attach a middleware `after` the middlewares optional array.
 The order of the middlewares is followed by code declarations order.
 
-### `BareServer.get | post | patch | put | delete | options | head | declare` (Function)
+---
+
+## `BareServer.get | post | patch | put | delete | options | head | declare` (Function)
 
 To set a route for `get | post | patch | put | delete | options | head` with following parameters:
 
@@ -219,7 +223,7 @@ app.declare({
 });
 ```
 
-### `BareServer.runtimeRoute.get | post | patch | put | delete | options | head | declare` (Function)
+## `BareServer.runtimeRoute.get | post | patch | put | delete | options | head | declare` (Function)
 
 Same as the above routes API, but you can only declare them when the server is `listening`
 
@@ -241,10 +245,6 @@ app.runtimeRoute
   });
 ```
 
-### `BareServer.ws` (WebSocketServer)
-
-Refer to [external WebSocketServer](https://github.com/websockets/ws#external-https-server) for documentation.
-
 #### `RouteOptions` (Object)
 
 If set, provide per-route options for behavior handling
@@ -261,6 +261,54 @@ If set, provides a granular cache headers handling per route.
 
 Request timeout value in `ms`. This will cancel the request _only_ for this route if time expired
 
+---
+
+## `BareServer.ws?` (WebSocketServer)
+
+Based on `ws` package, for internals please refer to [external WebSocketServer](https://github.com/websockets/ws#external-https-server) for documentation.
+
+This particular implementation works out easily for WebSockets interaction for pushing data to server from the clients and waiting for some answer in async.
+
+Also exposes an way to keep pushing messages to the Client from the Server on server handle through internal clients list. (WIP optimizing this)
+
+### `WebSocketServer.declareReceiver` ((Data, UserClient, WSClient, MessageEvent) => Promise\<M> | M)
+
+This is the main 'handler' function for any kind of Client request. If there's a response to that push from the client the return should contain it, otherwise if the response is `void` there will be no answer to the client side.
+
+- `Data`: is the data received from the client for this exact `Type`
+- `UserClient`: is an optional client defined on the stage of `Upgrade` to provide some closured client data to be able to know what Client is exactly making the request to the Server
+- `WSClient`: raw instance of `ws.Client & { userClient: UC }`
+- `MessageEvent`: raw instance of `ws.MessageClient`
+
+Code Example:
+
+```ts
+app.ws?.declareReceiver<{ ok: string }>({
+  type: 'BASE_TYPE',
+  handler: async (data, client) => {
+    // do your async or sync operations here
+    // return the response if you need to send an answer
+    return { cool: 'some answer', client };
+  },
+});
+```
+
+### `WebSocketServer.defineUpgrade` ((IncomingRequest) => Promise\<M> | M)
+
+To de able to handle authorization or any other previous operation before opening and upgrading an incoming client's request.
+**If this function is not initialized with the callback, all incoming connections will be accepted by default**
+
+```ts
+app.ws?.defineUpgrade(async (req) => {
+  // you can do some async or sync operation here
+  // the returning of this function will be
+  // defined as the `UserClient` and attached to the `ws.Client` instance
+  return { access: true, client: {...properties of the client} };
+});
+```
+
+---
+
 ## `BareRequest` (Class)
 
 An instance of the request passed through to middlewares and handlers
@@ -297,13 +345,21 @@ Imperatively disables cache, does the same as `disableCache: true` in `RouteOpti
 
 Imperatively sets the cache, does the same as `cache: CacheOptions` in `RouteOptions`
 
+### `addHeader` (Function)
+
+Adds a header outgoing header string as a (key, value) `addHeader(header, value)`. Can **not** overwrite.
+
+### `addHeaders` (Function)
+
+Adds outgoing headers in a "batch", merges provided headers object `{ [header: string]: value }` to already existing headers. Can **not** overwrite.
+
 ### `setHeader` (Function)
 
-Set outgoing header as a (key, value) arguments `setHeader(header, value)`. Can overwrite
+Does the same as `addHeader` but overrides the value.
 
 ### `setHeaders` (Function)
 
-Set outgoing headers in a "batch", merges provided headers object `{ [header: string]: value }` to already existing headers. Can overwrite
+Does the same as `addHeaders` but overrides the value.
 
 ### `status` (Function)
 
@@ -332,6 +388,7 @@ Some of the features are in progress.
 - [x] Request wide context storage and incorporated tracing (ready for cloud)
 - [x] UID (adopted or generated)
 - [x] WebSocket server exposure
+- [x] handy WebSocket interaction tools, for authorization, etc.
 - [x] Request-Processing-Time header and value
 - [x] Promised or conventional middlewares
 - [x] Logging and serialized with `pino`
@@ -342,6 +399,13 @@ Some of the features are in progress.
 - [x] Request execution cancellation by timeout
 - [x] Bulk/chaining routes declaration
 - [x] Runtime routes hot swapping
+- [ ] middlewares per route
+- [ ] swagger OpenAPI 3.0 on `/docs` endpoint
+- [ ] swagger OpenAPI 3.0 scheme on `/docs_raw` endpoint
+- [ ] optional export of generated schema to a location (yaml, json)
+- [ ] streaming/receiving of chunked multipart
+- [ ] runtime validation schema generation per route response types (on project compile/on launch)
+- [ ] runtime route params or query validation upon declared types (on project compile/on launch)
 
 ## Benchmarks
 

package/lib/context/execution.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Execution = void 0;
 const hyperid_1 = __importDefault(require("hyperid"));
-const generateId = hyperid_1.default();
+const generateId = (0, hyperid_1.default)();
 class Execution {
     id;
     type;

package/lib/logger/index.js

@@ -23,7 +23,7 @@ exports.logMe = exports.logHttp = void 0;
 const pino_1 = __importStar(require("pino"));
 const serializers_1 = require("./serializers");
 const env_1 = require("../env");
-const asyncDest = env_1.envs.isProd ? [pino_1.destination({ sync: false })] : [];
+const asyncDest = env_1.envs.isProd ? [(0, pino_1.destination)({ sync: false })] : [];
 const pinoCommonOptions = {
     timestamp: () => `,"time":"${new Date()[env_1.envs.isProd ? 'toISOString' : 'toLocaleTimeString']()}"`,
     formatters: {
@@ -32,36 +32,18 @@ const pinoCommonOptions = {
     messageKey: 'message',
     prettyPrint: !env_1.envs.isProd,
 };
-const logger = pino_1.default(pinoCommonOptions, asyncDest[0]);
-if (env_1.envs.isProd) {
-    setInterval(function () {
-        logger.flush();
-    }, 10000).unref();
-    const handler = pino_1.default.final(logger, (err, finalLogger, evt) => {
-        finalLogger.info(`${evt} caught`);
-        if (err)
-            finalLogger.error(err, 'error caused exit');
-        process.exit(err ? 1 : 0);
-    });
-    // catch all the ways node might exit
-    process.on('beforeExit', () => handler(null, 'beforeExit'));
-    process.on('exit', () => handler(null, 'exit'));
-    process.on('uncaughtException', (err) => handler(err, 'uncaughtException'));
-    process.on('SIGINT', () => handler(null, 'SIGINT'));
-    process.on('SIGQUIT', () => handler(null, 'SIGQUIT'));
-    process.on('SIGTERM', () => handler(null, 'SIGTERM'));
-}
+const logger = (0, pino_1.default)(pinoCommonOptions, asyncDest[0]);
 const logHttp = (...params) => {
-    const { level, logObject } = serializers_1.serializeHttp(...params);
+    const { level, logObject } = (0, serializers_1.serializeHttp)(...params);
     logger[level](logObject);
 };
 exports.logHttp = logHttp;
 // TODO: remove the test condition
 exports.logMe = {
-    debug: (...args) => !env_1.envs.isTest && logger.debug(serializers_1.serializeLog(...args)),
-    info: (...args) => !env_1.envs.isTest && logger.info(serializers_1.serializeLog(...args)),
-    warn: (...args) => !env_1.envs.isTest && logger.warn(serializers_1.serializeLog(...args)),
-    error: (...args) => !env_1.envs.isTest && logger.error(serializers_1.serializeLog(...args)),
-    fatal: (...args) => !env_1.envs.isTest && logger.fatal(serializers_1.serializeLog(...args)),
-    trace: (...args) => !env_1.envs.isTest && logger.trace(serializers_1.serializeLog(...args)),
+    debug: (...args) => !env_1.envs.isTest && logger.debug((0, serializers_1.serializeLog)(...args)),
+    info: (...args) => !env_1.envs.isTest && logger.info((0, serializers_1.serializeLog)(...args)),
+    warn: (...args) => !env_1.envs.isTest && logger.warn((0, serializers_1.serializeLog)(...args)),
+    error: (...args) => !env_1.envs.isTest && logger.error((0, serializers_1.serializeLog)(...args)),
+    fatal: (...args) => !env_1.envs.isTest && logger.fatal((0, serializers_1.serializeLog)(...args)),
+    trace: (...args) => !env_1.envs.isTest && logger.trace((0, serializers_1.serializeLog)(...args)),
 };

package/lib/logger/serializers.js

@@ -26,7 +26,7 @@ const parseArgs = (argSlice) => argSlice.map((arg) => {
     return arg;
 });
 function serializeLog(...args) {
-    const site = callsites_1.default()[2];
+    const site = (0, callsites_1.default)()[2];
     const meta = {
         timestamp: Date.now(),
         location: `${site.getFileName()}:${site.getLineNumber()}:${site.getColumnNumber()}`,

package/lib/middlewares/cookies/cookie-manager.js

@@ -16,7 +16,7 @@ class CookiesManager {
         this.flow = flow;
         const secret = this.options.secret || '';
         const enableRotation = Array.isArray(secret);
-        this.signer = typeof secret === 'string' || enableRotation ? signer_1.secretsOperator(secret) : null;
+        this.signer = typeof secret === 'string' || enableRotation ? (0, signer_1.secretsOperator)(secret) : null;
     }
     setCookie(name, value, options, signer) {
         const localSigner = signer || this.signer;

package/lib/request.d.ts

@@ -23,6 +23,9 @@ export declare class BareRequest {
     params: {
         [k: string]: string | undefined;
     };
+    query: {
+        [k: string]: string | undefined;
+    };
     remoteIp?: string;
     requestBody?: any;
     requestHeaders: {
@@ -32,22 +35,24 @@ export declare class BareRequest {
     cm?: CookiesManager;
     sent: boolean;
     private cache;
-    private startTime;
+    private startTime?;
     private startDate;
     private remoteClient;
-    private countTimeFormat;
+    private requestTimeFormat?;
     private headers;
     private cookies;
     private contentType?;
     private timeout?;
-    constructor(_originalRequest: IncomingMessage, _originalResponse: ServerResponse, logging?: boolean);
+    constructor(_originalRequest: IncomingMessage, _originalResponse: ServerResponse, options?: {
+        logging?: boolean;
+        requestTimeFormat?: 'ms' | 's';
+    });
     private readBody;
     private attachCookieManager;
     private populateCookies;
     private classifyRequestBody;
     private setRemoteClient;
     private setRequestTime;
-    private setTimeFormat;
     private cleanHeader;
     private attachTimeout;
     private setParams;
@@ -58,10 +63,14 @@ export declare class BareRequest {
     };
     disableCache(): void;
     setCache(cacheOpts: CacheOpts): void;
+    addHeader(header: string, value: string | number | string[] | number[]): void;
     setHeader(header: string, value: string | number | string[] | number[]): void;
     setHeaders(headers: {
         [header: string]: string | number | string[] | number[];
     }): void;
+    addHeaders(headers: {
+        [header: string]: string | number | string[] | number[];
+    }): void;
     status(status: StatusCodesUnion): this;
     sendStatus(status: StatusCodesUnion): void;
     stream<T extends NodeJS.WritableStream>(stream: T): void;

package/lib/request.js

@@ -11,7 +11,8 @@ const logger_1 = require("./logger");
 const cookie_manager_1 = require("./middlewares/cookies/cookie-manager");
 const util_1 = require("util");
 const stream_1 = require("stream");
-const generateId = hyperid_1.default();
+const url_1 = __importDefault(require("url"));
+const generateId = (0, hyperid_1.default)();
 const statusTuples = Object.entries(utils_1.StatusCodes).reduce((acc, [name, status]) => {
     acc[status] = utils_1.StatusPhrases[name];
     return acc;
@@ -21,6 +22,7 @@ class BareRequest {
     _originalResponse;
     ID;
     params = {};
+    query = {};
     remoteIp;
     requestBody;
     requestHeaders;
@@ -31,24 +33,33 @@ class BareRequest {
     startTime;
     startDate = new Date();
     remoteClient = '';
-    countTimeFormat = 's';
+    requestTimeFormat;
     headers = {};
     cookies = {};
     contentType;
     timeout;
-    constructor(_originalRequest, _originalResponse, logging) {
+    constructor(_originalRequest, _originalResponse, options) {
         this._originalRequest = _originalRequest;
         this._originalResponse = _originalResponse;
         this.ID = { code: _originalRequest.headers['x-request-id'] || generateId() };
         this.remoteIp = _originalRequest.socket.remoteAddress;
         this.contentType = this._originalRequest.headers['content-type'];
         this.requestHeaders = this._originalRequest.headers;
-        _originalRequest['flow'] = this; // to receive an id later on in the route handler
-        this.setHeaders({ 'Content-Type': 'text/plain', 'X-Request-Id': this.ID.code });
-        this.startTime = process.hrtime();
+        // this is a placeholder URL base that we need to make class working
+        new url_1.default.URL(`http://localhost/${this._originalRequest.url}`).searchParams.forEach((value, name) => (this.query[name] = value));
+        // parsed;
+        _originalRequest['flow'] = this; // to receive flow object later on in the route handler
+        this.addHeaders({
+            'Content-Type': 'text/plain; charset=utf-8',
+            'X-Request-Id': this.ID.code,
+        });
+        if (options?.requestTimeFormat) {
+            this.startTime = process.hrtime();
+            this.requestTimeFormat = options.requestTimeFormat;
+        }
         // call logging section
-        if (logging === true) {
-            _originalResponse.on('close', () => logger_1.logHttp(this.headers, this.startDate, this.remoteClient, _originalRequest, _originalResponse));
+        if (options?.logging === true) {
+            _originalResponse.on('close', () => (0, logger_1.logHttp)(this.headers, this.startDate, this.remoteClient, _originalRequest, _originalResponse));
         }
     }
     readBody() {
@@ -79,7 +90,7 @@ class BareRequest {
             case 'text/plain':
                 return wholeChunk.toString();
             case 'application/json':
-                return safe_json_1.JSONParse(wholeChunk.toString());
+                return (0, safe_json_1.JSONParse)(wholeChunk.toString());
             case 'application/x-www-form-urlencoded':
                 const store = {};
                 for (const curr of wholeChunk.toString().split('&')) {
@@ -97,17 +108,16 @@ class BareRequest {
         this.remoteClient = remoteClient;
     }
     setRequestTime() {
+        if (!this.requestTimeFormat)
+            return;
         const diff = process.hrtime(this.startTime);
-        const time = diff[0] * (this.countTimeFormat === 's' ? 1 : 1e3) +
-            diff[1] * (this.countTimeFormat === 's' ? 1e-9 : 1e-6);
+        const time = diff[0] * (this.requestTimeFormat === 's' ? 1 : 1e3) +
+            diff[1] * (this.requestTimeFormat === 's' ? 1e-9 : 1e-6);
         this.setHeaders({
             'X-Processing-Time': time,
-            'X-Processing-Time-Mode': this.countTimeFormat === 's' ? 'seconds' : 'milliseconds',
+            'X-Processing-Time-Mode': this.requestTimeFormat === 's' ? 'seconds' : 'milliseconds',
         });
     }
-    setTimeFormat(format) {
-        this.countTimeFormat = format;
-    }
     cleanHeader(header) {
         delete this.headers[header];
     }
@@ -148,7 +158,7 @@ class BareRequest {
         if (cacheHeader.length > 0)
             this.setHeader(directive, cacheHeader);
     }
-    setHeader(header, value) {
+    addHeader(header, value) {
         const old = this.headers[header];
         const parsedVal = Array.isArray(value) ? value.join(', ') : '' + value;
         if (old) {
@@ -158,11 +168,20 @@ class BareRequest {
             this.headers[header] = parsedVal;
         }
     }
+    setHeader(header, value) {
+        const parsedVal = Array.isArray(value) ? value.join(', ') : '' + value;
+        this.headers[header] = parsedVal;
+    }
     setHeaders(headers) {
         for (const [header, value] of Object.entries(headers)) {
             this.setHeader(header, value);
         }
     }
+    addHeaders(headers) {
+        for (const [header, value] of Object.entries(headers)) {
+            this.addHeader(header, value);
+        }
+    }
     status(status) {
         this.statusToSend = status;
         return this;
@@ -175,7 +194,7 @@ class BareRequest {
     }
     json(data) {
         // to generate with fast-json-stringify schema issue #1
-        const jsoned = safe_json_1.JSONStringify(data);
+        const jsoned = (0, safe_json_1.JSONStringify)(data);
         this.setHeader('Content-Type', 'application/json');
         this._send(jsoned ? jsoned : undefined);
     }
@@ -184,7 +203,7 @@ class BareRequest {
             logger_1.logMe.error("Tying to send into closed client's stream");
             return;
         }
-        if (this._originalResponse.headersSent) {
+        if (this._originalResponse.headersSent || this.sent) {
             logger_1.logMe.error('Trying to send with the headers already sent');
             return;
         }

package/lib/server.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
-import { Server as WServer, ServerOptions } from 'ws';
+import { ServerOptions } from 'ws';
 import { BareRequest, CacheOpts } from './request';
 import { CookiesManagerOptions } from './middlewares/cookies/cookie-manager';
 import { HttpMethodsUnion, StatusCodesUnion } from './utils';
 import { CorsOptions } from './middlewares/cors/cors';
+import { WebSocketServer } from './websocket';
 import { Server } from 'http';
 declare type Middleware = (flow: BareRequest) => Promise<void> | void;
 declare type Handler = (flow: BareRequest) => any;
@@ -38,7 +39,7 @@ declare type BareOptions<A extends IP> = {
     errorHandlerMiddleware?: ErrorHandler;
     /**
      * Request time format in `seconds` or `milliseconds`
-     * Default 's' - seconds
+     * Default - disabled
      */
     requestTimeFormat?: 's' | 'ms';
     /**
@@ -61,7 +62,7 @@ declare type BareOptions<A extends IP> = {
      */
     ws?: boolean;
     wsOptions?: Omit<ServerOptions, 'host' | 'port' | 'server' | 'noServer'> & {
-        closeHandler?: (server: WServer) => Promise<void>;
+        closeHandler?: (server: WebSocketServer) => Promise<void>;
     };
     /**
      * Enable Cors
@@ -96,7 +97,7 @@ export declare class BareServer<A extends IP> {
     #private;
     private bareOptions;
     server: Server;
-    ws?: WServer;
+    ws?: WebSocketServer;
     constructor(bareOptions?: BareOptions<A>);
     private mainOptionsSetter;
     private applyMiddlewares;

package/lib/server.js

@@ -5,13 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BareHttp = exports.BareServer = void 0;
 const find_my_way_1 = __importDefault(require("find-my-way"));
-const ws_1 = require("ws");
 const request_1 = require("./request");
 const logger_1 = require("./logger");
 const context_1 = require("./context");
 const report_1 = require("./report");
 const utils_1 = require("./utils");
 const cors_1 = require("./middlewares/cors/cors");
+const websocket_1 = require("./websocket");
 const dns_1 = __importDefault(require("dns"));
 const http_1 = require("http");
 class BareServer {
@@ -21,7 +21,7 @@ class BareServer {
     #middlewares = [];
     #routes = new Map();
     #routesLib = new Map();
-    #router = find_my_way_1.default({ ignoreTrailingSlash: true });
+    #router = (0, find_my_way_1.default)({ ignoreTrailingSlash: true });
     #errorHandler = this.basicErrorHandler;
     #corsInstance;
     #port = 3000;
@@ -30,7 +30,7 @@ class BareServer {
     constructor(bareOptions = {}) {
         this.bareOptions = bareOptions;
         // init
-        this.server = http_1.createServer(this.#listener.bind(this));
+        this.server = (0, http_1.createServer)(this.#listener.bind(this));
         this.attachGracefulHandlers();
         this.attachRoutesDeclarator();
         this.mainOptionsSetter();
@@ -38,14 +38,12 @@ class BareServer {
     }
     #listener = (request, response) => {
         const { requestTimeFormat, logging } = this.bareOptions;
-        const flow = new request_1.BareRequest(request, response, logging);
+        const flow = new request_1.BareRequest(request, response, { logging, requestTimeFormat });
         // init and attach request uuid to the context
         if (this.bareOptions.context) {
-            context_1.newContext('request');
+            (0, context_1.newContext)('request');
             context_1.context.current?.store.set('id', flow.ID.code);
         }
-        if (requestTimeFormat)
-            flow['setTimeFormat'](requestTimeFormat);
         // attach a flow to the flow memory storage
         this.applyMiddlewares(flow).catch((e) => this.#errorHandler(e, flow, 400));
     };
@@ -73,13 +71,10 @@ class BareServer {
         this.#host = typeof bo.serverAddress === 'string' ? bo.serverAddress : '0.0.0.0';
         // context setting
         if (bo.context)
-            context_1.enableContext();
+            (0, context_1.enableContext)();
         // ws attachment
         if (bo.ws) {
-            const wsOpts = { server: this.server };
-            if (bo.wsOptions)
-                Object.assign(wsOpts, bo.wsOptions);
-            this.ws = new ws_1.Server(wsOpts);
+            this.ws = new websocket_1.WebSocketServer(this.server, bo.wsOptions);
         }
         // middlewares settings
         if (bo.errorHandlerMiddleware) {
@@ -155,8 +150,8 @@ class BareServer {
     }
     registerReport() {
         this.setRoute('GET', '/_report', false, (flow) => {
-            flow.setHeader('content-type', 'text/html');
-            flow.send(report_1.generateReport(this.#routes));
+            flow.setHeader('Content-Type', 'text/html');
+            flow.send((0, report_1.generateReport)(this.#routes));
         });
     }
     handleRoute(req, routeParams, handle, encodedRoute, opts) {
@@ -217,7 +212,7 @@ class BareServer {
         if (this.bareOptions.wsOptions?.closeHandler) {
             await this.bareOptions.wsOptions.closeHandler(this.ws);
         }
-        this.ws.close();
+        this.ws._internal.close();
     }
     attachGracefulHandlers() {
         const graceful = async (code = 0) => {
@@ -285,6 +280,7 @@ class BareServer {
     }
     start(cb) {
         this.#writeMiddlewares();
+        this.ws?.['_start']();
         return new Promise((res) => 
         // https://nodejs.org/api/net.html#net_server_listen_port_host_backlog_callback
         this.server.listen(this.#port, this.#host, undefined, () => {

package/lib/utils/safe-json.d.ts

@@ -1,2 +1,2 @@
 export declare const JSONStringify: (data: any) => string | null;
-export declare const JSONParse: (data: any) => any;
+export declare const JSONParse: <R = any>(data: any) => R | null;

package/lib/websocket.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import Client, { MessageEvent, Server as WServer, ServerOptions } from 'ws';
+import { IncomingMessage, Server } from 'http';
+declare type UserClient = {
+    secId: string;
+    [k: string]: any;
+};
+declare type AuthAccess<T> = {
+    access: boolean;
+    message?: string;
+    client?: T;
+};
+export declare type WsMessageHandler<D = any, UC extends UserClient = UserClient, M = any> = (data: D, client: UC, _ws: ClientWS<UC>, _event: MessageEvent) => Promise<M> | M;
+declare type ClientWS<UC extends UserClient = UserClient> = Client & {
+    userClient: UC;
+};
+export declare class WebSocketServer {
+    #private;
+    private opts;
+    _internal: WServer;
+    private customUpgradeDone;
+    constructor(server: Server, opts?: ServerOptions);
+    private _start;
+    defineUpgrade<T>(fn: (request: IncomingMessage) => Promise<AuthAccess<T>> | AuthAccess<T>): void;
+    private doUpgrade;
+    private rejectUpgrade;
+    private attachTypesHandling;
+    private send;
+    declareReceiver<D = any, C extends UserClient = UserClient>(receiver: {
+        type: string;
+        handler: WsMessageHandler<D, C>;
+    }): void;
+    getClientById<T extends UserClient>(id: string): ClientWS<T> | undefined;
+    getClientByCriteria<T extends UserClient>(criteria: string, value: any, criteriaFunction?: (client: ClientWS<T>) => boolean): Client | undefined;
+    handleManualConnect<T extends UserClient>(fn: (socket: ClientWS<T>, client: T) => Promise<void> | void): void;
+}
+export {};

package/lib/websocket.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServer = void 0;
+const ws_1 = require("ws");
+const callsites_1 = __importDefault(require("callsites"));
+const hyperid_1 = __importDefault(require("hyperid"));
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const generateId = (0, hyperid_1.default)();
+class WebSocketServer {
+    opts;
+    _internal;
+    #httpServer;
+    #types = new Map();
+    customUpgradeDone = false;
+    constructor(server, opts = {}) {
+        this.opts = opts;
+        this.#httpServer = server;
+    }
+    _start() {
+        if (!this._internal) {
+            this.#createWServer({ server: this.#httpServer });
+        }
+    }
+    #createWServer(newOptions = {}) {
+        const opts = Object.assign({}, this.opts, newOptions);
+        this._internal = new ws_1.Server(opts);
+        this.attachTypesHandling();
+    }
+    defineUpgrade(fn) {
+        if (this.customUpgradeDone) {
+            throw new Error('Cannot redeclare again a custom upgrade.');
+        }
+        const newOptions = Object.assign({}, this.opts, { noServer: true });
+        this.#createWServer(newOptions);
+        this.#httpServer.on('upgrade', (request, socket, head) => {
+            try {
+                const response = fn(request);
+                if (response instanceof Promise) {
+                    response
+                        .then((answer) => this.doUpgrade(answer, request, socket, head))
+                        .catch((e) => this.rejectUpgrade(request, socket, e?.message, e));
+                }
+                else {
+                    this.doUpgrade(response, request, socket, head);
+                }
+            }
+            catch (e) {
+                this.rejectUpgrade(request, socket, e?.message, e);
+            }
+        });
+        this.customUpgradeDone = true;
+    }
+    doUpgrade(answer, request, socket, head) {
+        if (!answer.access)
+            this.rejectUpgrade(request, socket, answer.message);
+        else {
+            this._internal.handleUpgrade(request, socket, head, (ws) => {
+                const userClient = {
+                    secId: request.headers['sec-websocket-key'] || generateId(),
+                    ...(answer.client || {}),
+                };
+                ws.userClient = userClient;
+                this._internal.emit('connection', ws, request, userClient);
+            });
+        }
+    }
+    rejectUpgrade(request, socket, message = 'Not Authorized', data) {
+        logger_1.logMe.warn(message || `Upgrade rejected for the client from ${request.socket.remoteAddress}`, data);
+        socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n'); // TODO: enhance to be able to personalize this
+        socket.destroy();
+    }
+    attachTypesHandling() {
+        this._internal.on('connection', (ws, _, client) => {
+            ws.onmessage = (event) => {
+                const decode = (0, utils_1.JSONParse)(event.data);
+                if (decode === null) {
+                    logger_1.logMe.error('Incorrect data received from the client', {
+                        data: event.data,
+                        client: client ?? 'UNDEFINED_CLIENT',
+                    });
+                }
+                else if (!decode.type) {
+                    logger_1.logMe.error(`Data from the client does not contain 'type' field`, {
+                        data: event.data,
+                        client: client ?? 'UNDEFINED_CLIENT',
+                    });
+                }
+                else {
+                    const procedure = this.#types.get(decode.type);
+                    if (!procedure || typeof procedure.handler !== 'function') {
+                        logger_1.logMe.error(`There's no correct procedure for type "${decode.type}"`, {
+                            data: event.data,
+                            client: client ?? 'UNDEFINED_CLIENT',
+                        });
+                    }
+                    else {
+                        try {
+                            const response = procedure.handler(decode, client, ws, event);
+                            if (response instanceof Promise) {
+                                response
+                                    .then((resolvedResponse) => {
+                                    if (!resolvedResponse)
+                                        return;
+                                    this.send({ ws, client }, (0, utils_1.JSONStringify)({ type: `${decode.type}_RESPONSE`, ...resolvedResponse }));
+                                })
+                                    .catch((e) => logger_1.logMe.error(`Error working out a handler for type ${decode.type}`, {
+                                    error: e,
+                                    client,
+                                    data: decode,
+                                }));
+                            }
+                            else {
+                                if (!response)
+                                    return;
+                                this.send({ ws, client }, (0, utils_1.JSONStringify)({ type: `${decode.type}_RESPONSE`, ...response }));
+                            }
+                        }
+                        catch (e) {
+                            logger_1.logMe.error(`Error working out a handler for type ${decode.type}`, {
+                                error: e,
+                                client,
+                                data: decode,
+                            });
+                        }
+                    }
+                }
+            };
+        });
+    }
+    send(ctx, data) {
+        if (ctx.ws.readyState === ws_1.OPEN) {
+            ctx.ws.send(data);
+        }
+        else {
+            logger_1.logMe.error('Could not send data for the client', { client: ctx.client });
+        }
+    }
+    declareReceiver(receiver) {
+        const previousDeclaration = this.#types.get(receiver.type);
+        if (previousDeclaration) {
+            throw new Error(`Can not redeclare a type ${receiver.type} for the WS Server, already declared at ${previousDeclaration.loc}`);
+        }
+        if (typeof receiver.handler !== 'function') {
+            throw new Error(`Can't declare a handler with type ${typeof receiver.handler}, should be a function with following signature: WsMessageHandler<T,?>`);
+        }
+        const place = (0, callsites_1.default)()[2];
+        const loc = `${place.getFileName()}:${place.getLineNumber()}:${place.getColumnNumber()}`;
+        this.#types.set(receiver.type, { loc, handler: receiver.handler });
+    }
+    getClientById(id) {
+        for (const client of this._internal.clients.values()) {
+            if (client.userClient.secId === id) {
+                return client;
+            }
+        }
+    }
+    getClientByCriteria(criteria, value, criteriaFunction) {
+        for (const client of this._internal.clients.values()) {
+            if (typeof criteriaFunction === 'function') {
+                if (criteriaFunction(client)) {
+                    return client;
+                }
+            }
+            if (client.userClient[criteria] === value) {
+                return client;
+            }
+        }
+    }
+    handleManualConnect(fn) {
+        this._internal.on('connection', (ws, _, client) => fn(ws, client));
+    }
+}
+exports.WebSocketServer = WebSocketServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barehttp",
-  "version": "0.3.1",
+  "version": "0.4.2",
   "description": "Lightweight and fast Node.js web server",
   "main": "lib/index.js",
   "directories": {
@@ -15,7 +15,7 @@
     "build:dev": "rm -rf ./dev-lib && tsc -p tsconfig.dev.json",
     "test": "jest --runInBand --coverage",
     "lint": "eslint ./src --fix",
-    "release": "semantic-release"
+    "release": "semantic-release -e ./.releaserc.json"
   },
   "keywords": [
     "nodejs",
@@ -36,34 +36,36 @@
     "callsites": "^3.1.0",
     "cookie": "^0.4.1",
     "cookie-signature": "^1.1.0",
-    "find-my-way": "^4.3.0",
-    "hyperid": "^2.1.0",
-    "pino": "^6.11.3",
-    "pino-pretty": "^5.0.2",
-    "ws": "^7.4.6"
+    "find-my-way": "^5.0.0",
+    "hyperid": "^2.3.1",
+    "pino": "^7.5.1",
+    "pino-pretty": "^7.2.0",
+    "ws": "^8.3.0"
   },
   "devDependencies": {
-    "@ts-morph/bootstrap": "^0.9.1",
-    "@types/cookie": "^0.4.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^8.0.2",
+    "@ts-morph/bootstrap": "^0.12.2",
+    "@types/cookie": "^0.4.1",
     "@types/cookie-signature": "^1.0.3",
-    "@types/jest": "^26.0.23",
-    "@types/node": "^15.0.2",
-    "@types/pino": "^6.3.8",
-    "@types/ws": "^7.4.7",
-    "@typescript-eslint/eslint-plugin": "^4.22.1",
-    "@typescript-eslint/parser": "^4.22.1",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^14.17.0",
+    "@types/pino": "^7.0.5",
+    "@types/ws": "^8.2.1",
+    "@typescript-eslint/eslint-plugin": "^5.5.0",
+    "@typescript-eslint/parser": "^5.5.0",
     "axios": "^0.21.1",
-    "eslint": "^7.26.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jest": "^24.3.6",
+    "eslint": "^8.3.0",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-jest": "^25.3.0",
     "express": "^4.17.1",
-    "fastify": "^3.15.1",
-    "jest": "^26.6.3",
-    "semantic-release": "^17.4.2",
+    "fastify": "^3.24.1",
+    "jest": "^27.4.3",
+    "semantic-release": "^18.0.1",
     "supertest": "^6.1.3",
-    "ts-jest": "^26.5.6",
+    "ts-jest": "^27.0.7",
     "ts-node-dev": "^1.1.6",
-    "typescript": "^4.3.2"
+    "typescript": "^4.5.2"
   },
   "optionalDependencies": {
     "bufferutil": "^4.0.3",