node-pluginsmanager-plugin 6.5.0 → 7.0.1

package/lib/cjs/main.cjs

@@ -4,15 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LockedError = exports.NotFoundError = exports.UnauthorizedError = exports.Server = exports.Orchestrator = exports.MediatorUser = exports.Mediator = exports.DescriptorUser = exports.checkArrayLengthBetweenSync = exports.checkArrayLengthBetween = exports.checkArrayLengthSync = exports.checkArrayLength = exports.checkIntegerBetweenSync = exports.checkIntegerBetween = exports.checkStringLengthBetweenSync = exports.checkStringLengthBetween = exports.checkStringLengthSync = exports.checkStringLength = exports.checkObjectLengthBetweenSync = exports.checkObjectLengthBetween = exports.checkObjectLengthSync = exports.checkObjectLength = exports.checkNumberBetweenSync = exports.checkNumberBetween = exports.checkNonEmptyStringSync = exports.checkNonEmptyString = exports.checkNonEmptyObjectSync = exports.checkNonEmptyObject = exports.checkNonEmptyNumberSync = exports.checkNonEmptyNumber = exports.checkNonEmptyIntegerSync = exports.checkNonEmptyInteger = exports.checkNonEmptyArraySync = exports.checkNonEmptyArray = exports.checkIntegerSync = exports.checkInteger = exports.checkArraySync = exports.checkArray = exports.checkStringSync = exports.checkString = exports.checkObjectSync = exports.checkObject = exports.checkNumberSync = exports.checkNumber = exports.checkFunctionSync = exports.checkFunction = exports.checkBooleanSync = exports.checkBoolean = exports.checkExistsSync = exports.checkExists = void 0;
+exports.LockedError = exports.NotFoundError = exports.UnauthorizedError = exports.Server = exports.Orchestrator = exports.MediatorUser = exports.Mediator = exports.DescriptorUser = exports.checkNonEmptyStringSync = exports.checkNonEmptyString = exports.checkNonEmptyObjectSync = exports.checkNonEmptyObject = exports.checkNonEmptyNumberSync = exports.checkNonEmptyNumber = exports.checkIntegerSync = exports.checkInteger = exports.checkStringSync = exports.checkString = exports.checkObjectSync = exports.checkObject = exports.checkNumberSync = exports.checkNumber = exports.checkFunctionSync = exports.checkFunction = exports.checkExistsSync = exports.checkExists = void 0;
 // undefined
 const checkExists_1 = require("./checkers/ReferenceError/checkExists");
 Object.defineProperty(exports, "checkExists", { enumerable: true, get: function () { return checkExists_1.checkExists; } });
 Object.defineProperty(exports, "checkExistsSync", { enumerable: true, get: function () { return checkExists_1.checkExistsSync; } });
 // native
-const checkBoolean_1 = require("./checkers/TypeError/checkBoolean");
-Object.defineProperty(exports, "checkBoolean", { enumerable: true, get: function () { return checkBoolean_1.checkBoolean; } });
-Object.defineProperty(exports, "checkBooleanSync", { enumerable: true, get: function () { return checkBoolean_1.checkBooleanSync; } });
 const checkFunction_1 = require("./checkers/TypeError/checkFunction");
 Object.defineProperty(exports, "checkFunction", { enumerable: true, get: function () { return checkFunction_1.checkFunction; } });
 Object.defineProperty(exports, "checkFunctionSync", { enumerable: true, get: function () { return checkFunction_1.checkFunctionSync; } });
@@ -26,19 +23,10 @@ const checkString_1 = require("./checkers/TypeError/checkString");
 Object.defineProperty(exports, "checkString", { enumerable: true, get: function () { return checkString_1.checkString; } });
 Object.defineProperty(exports, "checkStringSync", { enumerable: true, get: function () { return checkString_1.checkStringSync; } });
 // abstract
-const checkArray_1 = require("./checkers/TypeError/checkArray");
-Object.defineProperty(exports, "checkArray", { enumerable: true, get: function () { return checkArray_1.checkArray; } });
-Object.defineProperty(exports, "checkArraySync", { enumerable: true, get: function () { return checkArray_1.checkArraySync; } });
 const checkInteger_1 = require("./checkers/TypeError/checkInteger");
 Object.defineProperty(exports, "checkInteger", { enumerable: true, get: function () { return checkInteger_1.checkInteger; } });
 Object.defineProperty(exports, "checkIntegerSync", { enumerable: true, get: function () { return checkInteger_1.checkIntegerSync; } });
 // empty
-const checkNonEmptyArray_1 = require("./checkers/RangeError/checkNonEmptyArray");
-Object.defineProperty(exports, "checkNonEmptyArray", { enumerable: true, get: function () { return checkNonEmptyArray_1.checkNonEmptyArray; } });
-Object.defineProperty(exports, "checkNonEmptyArraySync", { enumerable: true, get: function () { return checkNonEmptyArray_1.checkNonEmptyArraySync; } });
-const checkNonEmptyInteger_1 = require("./checkers/RangeError/checkNonEmptyInteger");
-Object.defineProperty(exports, "checkNonEmptyInteger", { enumerable: true, get: function () { return checkNonEmptyInteger_1.checkNonEmptyInteger; } });
-Object.defineProperty(exports, "checkNonEmptyIntegerSync", { enumerable: true, get: function () { return checkNonEmptyInteger_1.checkNonEmptyIntegerSync; } });
 const checkNonEmptyNumber_1 = require("./checkers/RangeError/checkNonEmptyNumber");
 Object.defineProperty(exports, "checkNonEmptyNumber", { enumerable: true, get: function () { return checkNonEmptyNumber_1.checkNonEmptyNumber; } });
 Object.defineProperty(exports, "checkNonEmptyNumberSync", { enumerable: true, get: function () { return checkNonEmptyNumber_1.checkNonEmptyNumberSync; } });
@@ -48,33 +36,6 @@ Object.defineProperty(exports, "checkNonEmptyObjectSync", { enumerable: true, ge
 const checkNonEmptyString_1 = require("./checkers/RangeError/checkNonEmptyString");
 Object.defineProperty(exports, "checkNonEmptyString", { enumerable: true, get: function () { return checkNonEmptyString_1.checkNonEmptyString; } });
 Object.defineProperty(exports, "checkNonEmptyStringSync", { enumerable: true, get: function () { return checkNonEmptyString_1.checkNonEmptyStringSync; } });
-// range
-// native
-const checkNumberBetween_1 = require("./checkers/RangeError/checkNumberBetween");
-Object.defineProperty(exports, "checkNumberBetween", { enumerable: true, get: function () { return checkNumberBetween_1.checkNumberBetween; } });
-Object.defineProperty(exports, "checkNumberBetweenSync", { enumerable: true, get: function () { return checkNumberBetween_1.checkNumberBetweenSync; } });
-const checkObjectLength_1 = require("./checkers/RangeError/checkObjectLength");
-Object.defineProperty(exports, "checkObjectLength", { enumerable: true, get: function () { return checkObjectLength_1.checkObjectLength; } });
-Object.defineProperty(exports, "checkObjectLengthSync", { enumerable: true, get: function () { return checkObjectLength_1.checkObjectLengthSync; } });
-const checkObjectLengthBetween_1 = require("./checkers/RangeError/checkObjectLengthBetween");
-Object.defineProperty(exports, "checkObjectLengthBetween", { enumerable: true, get: function () { return checkObjectLengthBetween_1.checkObjectLengthBetween; } });
-Object.defineProperty(exports, "checkObjectLengthBetweenSync", { enumerable: true, get: function () { return checkObjectLengthBetween_1.checkObjectLengthBetweenSync; } });
-const checkStringLength_1 = require("./checkers/RangeError/checkStringLength");
-Object.defineProperty(exports, "checkStringLength", { enumerable: true, get: function () { return checkStringLength_1.checkStringLength; } });
-Object.defineProperty(exports, "checkStringLengthSync", { enumerable: true, get: function () { return checkStringLength_1.checkStringLengthSync; } });
-const checkStringLengthBetween_1 = require("./checkers/RangeError/checkStringLengthBetween");
-Object.defineProperty(exports, "checkStringLengthBetween", { enumerable: true, get: function () { return checkStringLengthBetween_1.checkStringLengthBetween; } });
-Object.defineProperty(exports, "checkStringLengthBetweenSync", { enumerable: true, get: function () { return checkStringLengthBetween_1.checkStringLengthBetweenSync; } });
-// abstract
-const checkIntegerBetween_1 = require("./checkers/RangeError/checkIntegerBetween");
-Object.defineProperty(exports, "checkIntegerBetween", { enumerable: true, get: function () { return checkIntegerBetween_1.checkIntegerBetween; } });
-Object.defineProperty(exports, "checkIntegerBetweenSync", { enumerable: true, get: function () { return checkIntegerBetween_1.checkIntegerBetweenSync; } });
-const checkArrayLength_1 = require("./checkers/RangeError/checkArrayLength");
-Object.defineProperty(exports, "checkArrayLength", { enumerable: true, get: function () { return checkArrayLength_1.checkArrayLength; } });
-Object.defineProperty(exports, "checkArrayLengthSync", { enumerable: true, get: function () { return checkArrayLength_1.checkArrayLengthSync; } });
-const checkArrayLengthBetween_1 = require("./checkers/RangeError/checkArrayLengthBetween");
-Object.defineProperty(exports, "checkArrayLengthBetween", { enumerable: true, get: function () { return checkArrayLengthBetween_1.checkArrayLengthBetween; } });
-Object.defineProperty(exports, "checkArrayLengthBetweenSync", { enumerable: true, get: function () { return checkArrayLengthBetween_1.checkArrayLengthBetweenSync; } });
 // components
 const DescriptorUser_1 = __importDefault(require("./components/DescriptorUser"));
 exports.DescriptorUser = DescriptorUser_1.default;

package/lib/cjs/main.d.cts

@@ -1,32 +1,20 @@
 import { checkExists, checkExistsSync } from "./checkers/ReferenceError/checkExists";
-import { checkBoolean, checkBooleanSync } from "./checkers/TypeError/checkBoolean";
 import { checkFunction, checkFunctionSync } from "./checkers/TypeError/checkFunction";
 import { checkNumber, checkNumberSync } from "./checkers/TypeError/checkNumber";
 import { checkObject, checkObjectSync } from "./checkers/TypeError/checkObject";
 import { checkString, checkStringSync } from "./checkers/TypeError/checkString";
-import { checkArray, checkArraySync } from "./checkers/TypeError/checkArray";
 import { checkInteger, checkIntegerSync } from "./checkers/TypeError/checkInteger";
-import { checkNonEmptyArray, checkNonEmptyArraySync } from "./checkers/RangeError/checkNonEmptyArray";
-import { checkNonEmptyInteger, checkNonEmptyIntegerSync } from "./checkers/RangeError/checkNonEmptyInteger";
 import { checkNonEmptyNumber, checkNonEmptyNumberSync } from "./checkers/RangeError/checkNonEmptyNumber";
 import { checkNonEmptyObject, checkNonEmptyObjectSync } from "./checkers/RangeError/checkNonEmptyObject";
 import { checkNonEmptyString, checkNonEmptyStringSync } from "./checkers/RangeError/checkNonEmptyString";
-import { checkNumberBetween, checkNumberBetweenSync } from "./checkers/RangeError/checkNumberBetween";
-import { checkObjectLength, checkObjectLengthSync } from "./checkers/RangeError/checkObjectLength";
-import { checkObjectLengthBetween, checkObjectLengthBetweenSync } from "./checkers/RangeError/checkObjectLengthBetween";
-import { checkStringLength, checkStringLengthSync } from "./checkers/RangeError/checkStringLength";
-import { checkStringLengthBetween, checkStringLengthBetweenSync } from "./checkers/RangeError/checkStringLengthBetween";
-import { checkIntegerBetween, checkIntegerBetweenSync } from "./checkers/RangeError/checkIntegerBetween";
-import { checkArrayLength, checkArrayLengthSync } from "./checkers/RangeError/checkArrayLength";
-import { checkArrayLengthBetween, checkArrayLengthBetweenSync } from "./checkers/RangeError/checkArrayLengthBetween";
-export { checkExists, checkExistsSync, checkBoolean, checkBooleanSync, checkFunction, checkFunctionSync, checkNumber, checkNumberSync, checkObject, checkObjectSync, checkString, checkStringSync, checkArray, checkArraySync, checkInteger, checkIntegerSync, checkNonEmptyArray, checkNonEmptyArraySync, checkNonEmptyInteger, checkNonEmptyIntegerSync, checkNonEmptyNumber, checkNonEmptyNumberSync, checkNonEmptyObject, checkNonEmptyObjectSync, checkNonEmptyString, checkNonEmptyStringSync, checkNumberBetween, checkNumberBetweenSync, checkObjectLength, checkObjectLengthSync, checkObjectLengthBetween, checkObjectLengthBetweenSync, checkStringLength, checkStringLengthSync, checkStringLengthBetween, checkStringLengthBetweenSync, checkIntegerBetween, checkIntegerBetweenSync, checkArrayLength, checkArrayLengthSync, checkArrayLengthBetween, checkArrayLengthBetweenSync };
+export { checkExists, checkExistsSync, checkFunction, checkFunctionSync, checkNumber, checkNumberSync, checkObject, checkObjectSync, checkString, checkStringSync, checkInteger, checkIntegerSync, checkNonEmptyNumber, checkNonEmptyNumberSync, checkNonEmptyObject, checkNonEmptyObjectSync, checkNonEmptyString, checkNonEmptyStringSync };
 import DescriptorUser, { type iDescriptorUserOptions, type tLogType, type tLogger, type iEventsMinimal } from "./components/DescriptorUser";
 import Mediator, { type iUrlAllowedParameters } from "./components/Mediator";
 import MediatorUser, { type iMediatorUserOptions } from "./components/MediatorUser";
 import Orchestrator, { type iOrchestratorOptions } from "./components/Orchestrator";
-import Server, { type iClient, type iServerResponse } from "./components/Server";
+import Server, { type iClient } from "./components/Server";
 import UnauthorizedError from "./components/errors/UnauthorizedError";
 import NotFoundError from "./components/errors/NotFoundError";
 import LockedError from "./components/errors/LockedError";
-export type { tLogType, tLogger, iEventsMinimal, iUrlAllowedParameters, iClient, iServerResponse };
+export type { tLogType, tLogger, iEventsMinimal, iUrlAllowedParameters, iClient };
 export { DescriptorUser, type iDescriptorUserOptions, Mediator, MediatorUser, type iMediatorUserOptions, Orchestrator, type iOrchestratorOptions, Server, UnauthorizedError, NotFoundError, LockedError };

package/lib/cjs/openAPITypes.d.ts

@@ -0,0 +1,5 @@
+import type { OpenApiDocument } from "express-openapi-validate";
+export type PathsObject = OpenApiDocument["paths"];
+export type PathItemObject = PathsObject[string];
+export type tMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+export type OperationObject = NonNullable<PathItemObject[tMethod]>;

package/lib/cjs/openAPITypes.js

@@ -0,0 +1,3 @@
+"use strict";
+// types & interfaces
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/utils/cleanSendedError.d.ts

@@ -1 +1 @@
-export default function cleanSendedError(data: Error | Record<string, any> | string | null): Record<string, any> | string | null;
+export default function cleanSendedError(data: unknown): unknown;

package/lib/cjs/utils/cleanSendedError.js

@@ -12,12 +12,10 @@ function cleanSendedError(data) {
         }
         else {
             Object.keys(data).forEach((key) => {
-                data[key] = cleanSendedError(data[key]);
+                data[key] = cleanSendedError(data[key]); // in practice, it's unknown, had to specify the type for linter
             });
             return data;
         }
     }
-    else {
-        return data;
-    }
+    return data;
 }

package/lib/cjs/utils/descriptor/extractParams.d.ts

@@ -1 +1 @@
-export default function extractParams(patternPath: string, realPath: string): Record<string, any>;
+export default function extractParams(patternPath: string, realPath: string): Record<string, string | number | boolean>;

package/lib/cjs/utils/descriptor/extractParams.js

@@ -12,7 +12,7 @@ function extractParams(patternPath, realPath) {
     const params = {};
     const patternPathSplitted = (0, removeFirstSlash_1.default)(patternPath).split("/");
     (0, removeFirstSlash_1.default)(realPath).split("/").forEach((p, i) => {
-        if ("{" === patternPathSplitted[i][0]) {
+        if (i < patternPathSplitted.length && "{" === patternPathSplitted[i][0]) {
             params[patternPathSplitted[i].replace("{", "").replace("}", "")] = decodeURI(p);
         }
     });

package/lib/cjs/utils/descriptor/extractPathMethodByOperationId.d.ts

@@ -1,8 +1,7 @@
-import type { OpenApiDocument } from "express-openapi-validate";
-export type tMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+import type { PathsObject, tMethod } from "../../openAPITypes";
 export interface iPathMethod {
     "path": string;
     "method": tMethod;
     "operationId": string;
 }
-export default function extractPathMethodByOperationId(paths: OpenApiDocument["paths"], operationId: string): iPathMethod | null;
+export default function extractPathMethodByOperationId(paths: PathsObject | null | undefined, operationId: string): iPathMethod | undefined;

package/lib/cjs/utils/descriptor/extractPathMethodByOperationId.js

@@ -6,28 +6,28 @@ exports.default = extractPathMethodByOperationId;
 function extractPathMethodByOperationId(paths, operationId) {
     // no paths in this Descriptor
     if ("object" !== typeof paths || null === paths) {
-        return null;
+        return undefined;
     }
     // no operationId given
     else if ("string" !== typeof operationId || "" === operationId.trim()) {
-        return null;
+        return undefined;
     }
     else {
-        let result = null;
         for (let i = 0, pathnames = Object.keys(paths); i < pathnames.length; ++i) {
             const pathname = pathnames[i];
-            const method = Object.keys(paths[pathname]).find((m) => {
-                return Boolean(paths[pathname][m]) && paths[pathname][m].operationId === operationId;
-            });
-            if ("undefined" !== typeof method) {
-                result = {
-                    "path": pathname,
-                    method,
-                    operationId
-                };
-                break;
+            if ("object" === typeof paths[pathname]) {
+                const method = Object.keys(paths[pathname]).find((m) => {
+                    return paths[pathname][m]?.operationId === operationId;
+                });
+                if ("undefined" !== typeof method) {
+                    return {
+                        "path": pathname,
+                        method,
+                        operationId
+                    };
+                }
             }
         }
-        return result;
+        return undefined;
     }
 }

package/lib/cjs/utils/descriptor/extractPattern.d.ts

@@ -1,2 +1,2 @@
-import type { OpenApiDocument } from "express-openapi-validate";
-export default function extractPattern(paths: OpenApiDocument["paths"], pathname: string, method: string): string;
+import type { PathsObject, PathItemObject } from "../../openAPITypes";
+export default function extractPattern(paths: PathsObject, pathname: string, method: keyof PathItemObject): string;

package/lib/cjs/utils/descriptor/extractPattern.js

@@ -9,10 +9,10 @@ exports.default = extractPattern;
 const removeFirstSlash_1 = __importDefault(require("../removeFirstSlash"));
 // module
 function extractPattern(paths, pathname, method) {
-    var _a;
-    return "object" !== typeof paths ? "" : (_a = Object.keys(paths).filter((p) => {
-        return "undefined" !== typeof paths[p][method];
-    }).find((p) => {
+    return "object" !== typeof paths ? "" : Object.keys(paths).find((p) => {
+        if ("undefined" === typeof paths[p][method]) {
+            return false;
+        }
         const pathnameSplitted = (0, removeFirstSlash_1.default)(pathname).split("/");
         const pathSplitted = (0, removeFirstSlash_1.default)(p).split("/");
         if (pathnameSplitted.length !== pathSplitted.length) {
@@ -24,5 +24,5 @@ function extractPattern(paths, pathname, method) {
             }
         }
         return true;
-    })) !== null && _a !== void 0 ? _a : "";
+    }) ?? "";
 }

package/lib/cjs/utils/descriptor/extractSchemaType.d.ts

@@ -1,2 +1,2 @@
 import type { OpenAPIV3_1 } from "openapi-types";
-export default function extractSchemaType(schema: OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject, schemas: Record<string, any>): "boolean" | "object" | "number" | "string" | "integer" | "array";
+export default function extractSchemaType(schema: unknown, schemas: Record<string, OpenAPIV3_1.SchemaObject>): OpenAPIV3_1.SchemaObject["type"];

package/lib/cjs/utils/descriptor/extractSchemaType.js

@@ -1,18 +1,23 @@
 "use strict";
-// types & interfaces
+/*
+    eslint-disable camelcase
+*/
+// => camelcase is disabled because of "openapi-types" types
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = extractSchemaType;
 // module
 function extractSchemaType(schema, schemas) {
-    let result = "string";
-    if (schema.type) {
-        result = schema.type;
+    if ("object" !== typeof schema || null === schema) {
+        return "string";
     }
-    else if (schema.$ref) {
+    if ("string" === typeof schema.type) {
+        return schema.type;
+    }
+    if ("string" === typeof schema.$ref) {
         const ref = schema.$ref.replace("#/components/schemas/", "");
-        if (schemas[ref] && schemas[ref].type) {
-            result = schemas[ref].type;
+        if ("object" === typeof schemas[ref] && "string" === typeof schemas[ref].type) {
+            return schemas[ref].type;
         }
     }
-    return result;
+    return "string";
 }

package/lib/cjs/utils/file/readJSONFile.d.ts

@@ -1 +1 @@
-export default function readJSONFile(file: string): Promise<any>;
+export default function readJSONFile(file: string): Promise<unknown>;

package/lib/cjs/utils/request/extractBody.js

@@ -1,9 +1,13 @@
 "use strict";
-// deps
+/*
+    eslint-disable @typescript-eslint/unbound-method
+*/
+// => @typescript-eslint/unbound-method is disabled to allow check on req.headers (no need for js context)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = extractBody;
+// deps
 // locals
-const checkInteger_1 = require("../../checkers/TypeError/checkInteger");
+const checkString_1 = require("../../checkers/TypeError/checkString");
 const checkFunction_1 = require("../../checkers/TypeError/checkFunction");
 const checkNonEmptyObject_1 = require("../../checkers/RangeError/checkNonEmptyObject");
 // module
@@ -13,7 +17,7 @@ function extractBody(req) {
     }).then(() => {
         return (0, checkNonEmptyObject_1.checkNonEmptyObject)("req.headers", req.headers);
     }).then(() => {
-        return (0, checkInteger_1.checkInteger)("req.headers[\"content-length\"]", req.headers["content-length"]);
+        return (0, checkString_1.checkString)("req.headers[\"content-length\"]", req.headers["content-length"]);
     }).then(() => {
         return new Promise((resolve, reject) => {
             let queryData = "";
@@ -24,8 +28,8 @@ function extractBody(req) {
                     resolve("");
                 }
                 else {
-                    req.headers["content-length"] = parseInt(req.headers["content-length"], 10);
-                    if (req.headers["content-length"] !== Buffer.byteLength(queryData)) {
+                    const contentLength = Number.parseInt(req.headers["content-length"], 10);
+                    if (contentLength !== Buffer.byteLength(queryData)) {
                         reject(new Error("\"Content-Length\" header (" + Buffer.byteLength(queryData) + ")"
                             + " is not as expected (" + req.headers["content-length"] + ")."
                             + " Do not forget the fact that it is a 8-bit bytes number."));

package/lib/cjs/utils/request/extractCookies.d.ts

@@ -1,2 +1,2 @@
 import type { iIncomingMessage } from "../../components/Server";
-export default function extractCookies(req: iIncomingMessage): Record<string, string>;
+export default function extractCookies(req: iIncomingMessage): Record<string, unknown>;

package/lib/cjs/utils/request/extractCookies.js

@@ -17,7 +17,7 @@ function _parseCookies(cookies) {
         const result = {};
         cookies.split(";").forEach((cookie) => {
             const parts = cookie.split("=");
-            result[parts[0]] = decodeURI(parts[1]);
+            result[parts[0]] = parts[1] ? decodeURI(parts[1]) : "";
         });
         return result;
     }
@@ -30,17 +30,17 @@ function extractCookies(req) {
     else if ("object" === typeof req.cookies) {
         return req.cookies;
     }
-    else if (req.headers) {
-        if (req.headers.cookie) {
+    else if ("object" === typeof req.headers) {
+        if ("undefined" !== typeof req.headers.cookie) {
             return _parseCookies(req.headers.cookie);
         }
-        else if (req.headers.Cookie) {
+        else if ("undefined" !== typeof req.headers.Cookie) {
             return _parseCookies(req.headers.Cookie);
         }
-        else if (req.headers.cookies) {
+        else if ("undefined" !== typeof req.headers.cookies) {
             return _parseCookies(req.headers.cookies);
         }
-        else if (req.headers.Cookies) {
+        else if ("undefined" !== typeof req.headers.Cookies) {
             return _parseCookies(req.headers.Cookies);
         }
         else {

package/lib/cjs/utils/request/extractIp.d.ts

@@ -1 +1 @@
-export default function extractIp(req: any): string;
+export default function extractIp(_req: unknown): string;

package/lib/cjs/utils/request/extractIp.js

@@ -1,28 +1,37 @@
 "use strict";
-// module
+// types & interfaces
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = extractIp;
-function extractIp(req) {
-    if ("object" !== typeof req) {
+// module
+function extractIp(_req) {
+    if ("object" !== typeof _req || null === _req) {
         return "";
     }
     else {
+        const req = _req;
         let result = "";
         if (req.ip) {
             result = req.ip;
         }
-        else if (req.headers && req.headers["x-forwarded-for"]) {
+        else if ("object" === typeof req.headers && "string" === typeof req.headers["x-forwarded-for"]) {
             result = req.headers["x-forwarded-for"].split(",").pop();
         }
-        else if (req.socket && req.socket.remoteAddress) {
+        else if ("object" === typeof req.socket && "string" === typeof req.socket.remoteAddress) {
             result = req.socket.remoteAddress;
         }
-        else if (req.connection) {
-            if (req.connection.remoteAddress) {
-                result = req.connection.remoteAddress;
+        else if ("object" === typeof req.connection) {
+            const { connection } = req;
+            if ("string" === typeof connection.remoteAddress) {
+                result = connection.remoteAddress;
             }
-            else if (req.connection.socket && req.connection.socket.remoteAddress) {
-                result = req.connection.socket.remoteAddress;
+            else if ("object" === typeof connection.socket) {
+                const { socket } = connection;
+                if (socket.remoteAddress) {
+                    result = socket.remoteAddress;
+                }
+                else {
+                    result = "";
+                }
             }
             else {
                 result = "";

package/lib/cjs/utils/request/extractMime.d.ts

@@ -1,4 +1 @@
-export default function extractMime(contentType: string, code: number, responses: Record<string, {
-    "description": string;
-    "content"?: Record<string, any>;
-}>): string;
+export default function extractMime(contentType: string, code: number, responses: unknown): string;

package/lib/cjs/utils/request/extractMime.js

@@ -10,30 +10,34 @@ const checkObject_1 = require("../../checkers/TypeError/checkObject");
 const DEFAULT_MIME = "text/plain";
 // module
 function extractMime(contentType, code, responses) {
-    var _a, _b;
-    const err = (_b = (_a = (0, checkString_1.checkStringSync)("contentType", contentType)) !== null && _a !== void 0 ? _a : (0, checkNonEmptyNumber_1.checkNonEmptyNumberSync)("code", code)) !== null && _b !== void 0 ? _b : (0, checkObject_1.checkObjectSync)("responses", responses);
+    const err = (0, checkString_1.checkStringSync)("contentType", contentType)
+        ?? (0, checkNonEmptyNumber_1.checkNonEmptyNumberSync)("code", code)
+        ?? (0, checkObject_1.checkObjectSync)("responses", responses);
     if (err) {
         throw err;
     }
     else {
         const stringifiedCode = String(code);
-        if (!responses[stringifiedCode] && !responses.default && "" !== contentType.trim()) {
+        const res = responses; // mandatory for typing, convert "unknown" response to controlled and typed one
+        if ("undefined" === typeof res[stringifiedCode] && "undefined" === typeof res.default && "" !== contentType.trim()) {
             return contentType;
         }
         else {
-            let descriptorContent;
-            if (responses[stringifiedCode]) {
-                if (responses[stringifiedCode].content) {
-                    descriptorContent = responses[stringifiedCode].content;
+            let descriptorContent = {};
+            if ("object" === typeof res[stringifiedCode]) {
+                if ("object" === typeof res[stringifiedCode].content) {
+                    descriptorContent = res[stringifiedCode].content;
                 }
             }
-            else if (responses.default && responses.default.content) {
-                descriptorContent = responses.default.content;
+            else if ("object" === typeof res.default) {
+                if ("object" === typeof res.default.content) {
+                    descriptorContent = res.default.content;
+                }
             }
             else {
                 return DEFAULT_MIME;
             }
-            const possibleMimes = descriptorContent ? Object.keys(descriptorContent) : [];
+            const possibleMimes = Object.keys(descriptorContent);
             const [mimeRequest, charsetRequest] = contentType.split(";").map((content) => {
                 return content.trim().toLowerCase();
             });
@@ -47,7 +51,7 @@ function extractMime(contentType, code, responses) {
                 }
             }
             else if (1 === possibleMimes.length) { // only one possible option
-                result = possibleMimes[0];
+                [result] = possibleMimes;
             }
             else {
                 result = mimeRequest && possibleMimes.includes(mimeRequest) ? mimeRequest : DEFAULT_MIME;

package/lib/cjs/utils/send.d.ts

@@ -1,7 +1,7 @@
-import type { IncomingMessage } from "node:http";
-import type { iServerResponse } from "../components/Server";
-export default function send(req: IncomingMessage, res: iServerResponse, code: number, content: any, options: {
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { iFormatedServerResponseForValidation } from "../components/Server";
+export default function send(req: IncomingMessage, res: ServerResponse, code: number, content: unknown, options: {
     "apiVersion": string;
     "cors": boolean;
     "mime": string;
-}): Promise<void>;
+}): Promise<iFormatedServerResponseForValidation>;

package/lib/cjs/utils/send.js

@@ -1,5 +1,8 @@
 "use strict";
-// types & interfaces
+/*
+    eslint-disable @typescript-eslint/no-base-to-string
+*/
+// => @typescript-eslint/no-base-to-string is disabled to allow stringification of unattented content ('[object Object]' for example)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = send;
 // module
@@ -14,45 +17,39 @@ function send(req, res, code, content, options) {
         else if ("string" === typeof content && "" === content) {
             return "";
         }
-        else {
+        else if (options.mime.includes("application/json")) {
             let result = "";
-            if (options.mime.includes("application/json")) {
-                if ("string" === typeof content) {
-                    try {
-                        JSON.parse(content); // is content json & parseable ?
-                        result = content; // yes => valid JSON string, send it as it is
-                    }
-                    catch (e) {
-                        result = JSON.stringify(content); // no => not JSON string, send formatted one
-                    }
+            if ("string" === typeof content) {
+                try {
+                    JSON.parse(content); // is content json & parseable ?
+                    result = content; // yes => valid JSON string, send it as it is
                 }
-                else {
-                    const stringified = JSON.stringify(content);
-                    if (stringified !== content) {
-                        result = stringified;
-                    }
+                catch {
+                    result = JSON.stringify(content); // no => not JSON string, send formatted one
                 }
             }
             else {
-                result = content;
+                const stringified = JSON.stringify(content);
+                if (stringified !== content) {
+                    result = stringified;
+                }
             }
             return result;
         }
+        return String(content);
     }).then((formattedContent) => {
         return new Promise((resolve) => {
             // force data for checking
             res.statusCode = code;
-            res.headers = Object.assign({
+            res.headers = {
                 "Content-Type": options.mime,
                 "Content-Length": 0 < formattedContent.length ? Buffer.byteLength(formattedContent) : 0,
                 "Status-Code-Url-Cat": "https://http.cat/" + code,
-                "API-Version": options.apiVersion
-            }, options.cors ? {
-                "Access-Control-Allow-Origin": "*",
-                "Access-Control-Allow-Credentials": true,
-                "Access-Control-Allow-Methods": req.headers["access-control-request-method"]
-                    ? req.headers["access-control-request-method"]
-                    : [
+                "API-Version": options.apiVersion,
+                ...options.cors ? {
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Credentials": true,
+                    "Access-Control-Allow-Methods": req.headers["access-control-request-method"] ?? [
                         "GET",
                         "POST",
                         "PUT",
@@ -60,9 +57,7 @@ function send(req, res, code, content, options) {
                         "PATCH",
                         "OPTIONS"
                     ].join(", "),
-                "Access-Control-Allow-Headers": req.headers["access-control-request-headers"]
-                    ? req.headers["access-control-request-headers"]
-                    : [
+                    "Access-Control-Allow-Headers": req.headers["access-control-request-headers"] ?? [
                         "Origin",
                         "Accept",
                         "Accept-Version",
@@ -75,7 +70,8 @@ function send(req, res, code, content, options) {
                         "X-CSRF-Token",
                         "X-Requested-With"
                     ].join(", ")
-            } : {});
+                } : {}
+            };
             // send data
             res.writeHead(res.statusCode, res.headers);
             if ("string" === typeof formattedContent) {
@@ -95,5 +91,7 @@ function send(req, res, code, content, options) {
                 });
             }
         });
+    }).then(() => {
+        return res;
     });
 }

package/lib/cjs/utils/server/getServerTypeFromServer.d.ts

@@ -0,0 +1,4 @@
+import type { Server as WebSocketServer } from "ws";
+import type { Server as SocketIOServer } from "socket.io";
+import type { Server as SocketIOServerV2 } from "../../../@types/socket.io-v2";
+export default function getServerTypeFromServer(server: WebSocketServer | SocketIOServer | SocketIOServerV2 | null | undefined): "NO_SERVER" | "WEBSOCKET" | "SOCKETIO" | "UNKNOWN";