node-pluginsmanager-plugin 4.8.8 → 5.0.2

package/lib/cjs/main.d.cts

@@ -0,0 +1,30 @@
+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 };
+import DescriptorUser, { tLogType, tLogger } from "./components/DescriptorUser";
+import Mediator, { iUrlParameters, iBodyParameters } from "./components/Mediator";
+import MediatorUser from "./components/MediatorUser";
+import NotFoundError from "./components/NotFoundError";
+import Orchestrator from "./components/Orchestrator";
+import Server, { iClient, iIncomingMessage, iServerResponse } from "./components/Server";
+export { tLogType, tLogger, iUrlParameters, iBodyParameters, iClient, iIncomingMessage, iServerResponse };
+export { DescriptorUser, Mediator, MediatorUser, NotFoundError, Orchestrator, Server };

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

@@ -0,0 +1 @@
+export default function cleanSendedError(data: any): string;

package/lib/cjs/utils/cleanSendedError.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function cleanSendedError(data) {
+    if ("object" === typeof data) {
+        if (data instanceof Error) {
+            return data.message;
+        }
+        else if (data.message) {
+            return data.message instanceof Error ? data.message.message : data.message;
+        }
+        else if (data.error) { // 1 level recursive for "error" data (avoid too deep recursive analyse)
+            if (data.error instanceof Error) {
+                return data.error.message;
+            }
+            else if (data.error.message) {
+                return data.error.message instanceof Error ? data.error.message.message : data.error.message;
+            }
+            else {
+                return data.error;
+            }
+        }
+        else if (data.err) { // 1 level recursive for "err" data (avoid too deep recursive analyse)
+            if (data.err instanceof Error) {
+                return data.err.message;
+            }
+            else if (data.err.message) {
+                return data.err.message instanceof Error ? data.err.message.message : data.err.message;
+            }
+            else {
+                return data.err;
+            }
+        }
+        else {
+            return data;
+        }
+    }
+    else {
+        return data;
+    }
+}
+exports.default = cleanSendedError;
+;

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

@@ -0,0 +1,3 @@
+export default function extractParams(patternPath: string, realPath: string): {
+    [key: string]: any;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// locals
+const removeFirstSlash_1 = __importDefault(require("../removeFirstSlash"));
+// module
+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]) {
+            params[patternPathSplitted[i].replace("{", "").replace("}", "")] = decodeURI(p);
+        }
+    });
+    return params;
+}
+exports.default = extractParams;
+;

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+// module
+function extractPathMethodByOperationId(paths, operationId) {
+    // no paths in this Descriptor
+    if ("object" !== typeof paths || null === paths) {
+        return null;
+    }
+    // no operationId given
+    else if ("string" !== typeof operationId || "" === operationId.trim()) {
+        return null;
+    }
+    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;
+            }
+        }
+        return result;
+    }
+}
+exports.default = extractPathMethodByOperationId;
+;

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

@@ -0,0 +1,2 @@
+import { OpenApiDocument } from "express-openapi-validate";
+export default function extractPattern(paths: OpenApiDocument["paths"], pathname: string, method: string): string;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// locals
+const removeFirstSlash_1 = __importDefault(require("../removeFirstSlash"));
+// module
+function extractPattern(paths, pathname, method) {
+    return "object" !== typeof paths ? "" : Object.keys(paths).filter((p) => {
+        return "undefined" !== typeof paths[p][method];
+    }).find((p) => {
+        const pathnameSplitted = (0, removeFirstSlash_1.default)(pathname).split("/");
+        const pathSplitted = (0, removeFirstSlash_1.default)(p).split("/");
+        if (pathnameSplitted.length !== pathSplitted.length) {
+            return false;
+        }
+        for (let i = 0; i < pathnameSplitted.length; ++i) {
+            if ("{" !== pathSplitted[i][0] && pathSplitted[i] !== pathnameSplitted[i]) {
+                return false;
+            }
+        }
+        return true;
+    }) || "";
+}
+exports.default = extractPattern;
+;

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function extractSchemaType(schema, schemas) {
+    let result = "string";
+    if (schema.type) {
+        result = schema.type;
+    }
+    else if (schema.$ref) {
+        const ref = schema.$ref.replace("#/components/schemas/", "");
+        if (schemas[ref] && schemas[ref].type) {
+            result = schemas[ref].type;
+        }
+    }
+    return result;
+}
+exports.default = extractSchemaType;
+;

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

@@ -0,0 +1 @@
+export default function checkFile(filename: string): Promise<void>;

package/lib/cjs/utils/file/checkFile.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// locals
+const isFile_1 = __importDefault(require("./isFile"));
+// module
+function checkFile(filename) {
+    return (0, isFile_1.default)(filename).then((exists) => {
+        return exists ? Promise.resolve() :
+            Promise.reject(new Error("\"" + filename + "\" does not exist."));
+    });
+}
+exports.default = checkFile;
+;

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

@@ -0,0 +1 @@
+export default function isFile(filename: string): Promise<boolean>;

package/lib/cjs/utils/file/isFile.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// natives
+const fs_1 = require("fs");
+// locals
+const checkNonEmptyString_1 = require("../../checkers/RangeError/checkNonEmptyString");
+// module
+function isFile(filename) {
+    return (0, checkNonEmptyString_1.checkNonEmptyString)("filename", filename).then(() => {
+        return new Promise((resolve) => {
+            (0, fs_1.lstat)(filename, (err, stats) => {
+                return resolve(Boolean(!err && stats.isFile()));
+            });
+        });
+    });
+}
+exports.default = isFile;
+;

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

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

package/lib/cjs/utils/file/readJSONFile.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// natives
+const fs_1 = require("fs");
+// locals
+const checkFile_1 = __importDefault(require("./checkFile"));
+// module
+function readJSONFile(file) {
+    return (0, checkFile_1.default)(file).then(() => {
+        return new Promise((resolve, reject) => {
+            (0, fs_1.readFile)(file, "utf8", (err, content) => {
+                return err ? reject(err) : resolve(content);
+            });
+        });
+    }).then((content) => {
+        return Promise.resolve(JSON.parse(content));
+    });
+}
+exports.default = readJSONFile;
+;

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

@@ -0,0 +1 @@
+export default function getUniqueID(): string;

package/lib/cjs/utils/getUniqueID.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// private
+// methods
+/**
+* @return {string} formated random id fragment
+*/
+function _s4() {
+    return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
+}
+// module
+function getUniqueID() {
+    return _s4() + _s4() + "-" + _s4();
+}
+exports.default = getUniqueID;
+;

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

@@ -0,0 +1 @@
+export default function removeFirstSlash(path: string): string;

package/lib/cjs/utils/removeFirstSlash.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function removeFirstSlash(path) {
+    return "string" === typeof path && "/" === path[0] ? path.substring(1, path.length) : String(path);
+}
+exports.default = removeFirstSlash;
+;

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

@@ -0,0 +1,7 @@
+import { iIncomingMessage } from "../../components/Server";
+interface iResult {
+    "value": string;
+    "parsed": any;
+}
+export default function extractBody(req: iIncomingMessage): Promise<iResult>;
+export {};

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// locals
+const checkInteger_1 = require("../../checkers/TypeError/checkInteger");
+const checkFunction_1 = require("../../checkers/TypeError/checkFunction");
+const checkNonEmptyObject_1 = require("../../checkers/RangeError/checkNonEmptyObject");
+// module
+function extractBody(req) {
+    return (0, checkNonEmptyObject_1.checkNonEmptyObject)("req", req).then(() => {
+        return (0, checkFunction_1.checkFunction)("req.on", req.on);
+    }).then(() => {
+        return (0, checkNonEmptyObject_1.checkNonEmptyObject)("req.headers", req.headers);
+    }).then(() => {
+        return (0, checkInteger_1.checkInteger)("req.headers[\"content-length\"]", req.headers["content-length"]);
+    }).then(() => {
+        return new Promise((resolve, reject) => {
+            let queryData = "";
+            req.on("data", (data) => {
+                queryData += data.toString("utf8");
+            }).on("end", () => {
+                if ("" === queryData || "null" === queryData) {
+                    resolve({
+                        "value": "",
+                        "parsed": {}
+                    });
+                }
+                else {
+                    req.headers["content-length"] = parseInt(req.headers["content-length"], 10);
+                    if (req.headers["content-length"] !== 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."));
+                    }
+                    else {
+                        try {
+                            resolve({
+                                "value": queryData,
+                                "parsed": JSON.parse(queryData)
+                            });
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }
+                }
+            });
+        });
+    });
+}
+exports.default = extractBody;
+;

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

@@ -0,0 +1,4 @@
+import { iIncomingMessage } from "../../components/Server";
+export default function extractCookies(req: iIncomingMessage): {
+    [key: string]: string;
+};

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// private
+// methods
+/**
+* Extract cookies from string
+* @param {string} cookies: data string to parse
+* @returns {object} Parsed data
+*/
+function _parseCookies(cookies) {
+    if ("string" !== typeof cookies) {
+        return {};
+    }
+    else {
+        const result = {};
+        cookies.split(";").forEach((cookie) => {
+            const parts = cookie.split("=");
+            result[parts[0]] = decodeURI(parts[1]);
+        });
+        return result;
+    }
+}
+// module
+function extractCookies(req) {
+    if ("object" !== typeof req) {
+        return {};
+    }
+    else if ("object" === typeof req.cookies) {
+        return req.cookies;
+    }
+    else if (req.headers) {
+        if (req.headers.cookie) {
+            return _parseCookies(req.headers.cookie);
+        }
+        else if (req.headers.Cookie) {
+            return _parseCookies(req.headers.Cookie);
+        }
+        else if (req.headers.cookies) {
+            return _parseCookies(req.headers.cookies);
+        }
+        else if (req.headers.Cookies) {
+            return _parseCookies(req.headers.Cookies);
+        }
+        else {
+            return {};
+        }
+    }
+    else {
+        return {};
+    }
+}
+exports.default = extractCookies;
+;

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

@@ -0,0 +1 @@
+export default function extractIp(req: any): string;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function extractIp(req) {
+    if ("object" !== typeof req) {
+        return "";
+    }
+    else {
+        let result = "";
+        if (req.ip) {
+            result = req.ip;
+        }
+        else if (req.headers && req.headers["x-forwarded-for"]) {
+            result = req.headers["x-forwarded-for"].split(",").pop();
+        }
+        else if (req.socket && req.socket.remoteAddress) {
+            result = req.socket.remoteAddress;
+        }
+        else if (req.connection) {
+            if (req.connection.remoteAddress) {
+                result = req.connection.remoteAddress;
+            }
+            else if (req.connection.socket && req.connection.socket.remoteAddress) {
+                result = req.connection.socket.remoteAddress;
+            }
+            else {
+                result = "";
+            }
+        }
+        else {
+            result = "";
+        }
+        return result
+            .replace("::ffff:", "")
+            .replace("localhost", "127.0.0.1")
+            .replace("::1", "127.0.0.1");
+    }
+}
+exports.default = extractIp;
+;

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

@@ -0,0 +1,2 @@
+import { iIncomingMessage, iServerResponse } from "../components/Server";
+export default function send(req: iIncomingMessage, res: iServerResponse, code: number, content: any, apiVersion: string, cors: boolean): Promise<void>;

package/lib/cjs/utils/send.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function send(req, res, code, content, apiVersion, cors) {
+    return new Promise((resolve) => {
+        // formate content
+        if ("undefined" !== typeof content) {
+            res.body = JSON.stringify(content);
+        }
+        // force data for checking
+        res.statusCode = code;
+        res.headers = Object.assign({
+            "Content-Type": "application/json; charset=utf-8",
+            "Content-Length": res.body ? Buffer.byteLength(res.body) : 0,
+            "Status-Code-Url-Cat": "https://http.cat/" + code,
+            "API-Version": apiVersion
+        }, 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"] : [
+                "GET",
+                "POST",
+                "PUT",
+                "DELETE",
+                "PATCH",
+                "OPTIONS"
+            ].join(", "),
+            "Access-Control-Allow-Headers": req.headers["access-control-request-headers"] ? req.headers["access-control-request-headers"] : [
+                "Origin",
+                "Accept",
+                "Accept-Version",
+                "Content-Length",
+                "Content-MD5",
+                "Content-Type",
+                "Date",
+                "X-Api-Version",
+                "X-File-Name",
+                "X-CSRF-Token",
+                "X-Requested-With"
+            ].join(", ")
+        } : {});
+        // send data
+        res.writeHead(res.statusCode, res.headers);
+        if (res.body) {
+            res.end(res.body, "utf-8", () => {
+                resolve();
+            });
+        }
+        else {
+            res.end(() => {
+                resolve();
+            });
+        }
+    });
+}
+exports.default = send;
+;

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

@@ -0,0 +1,14 @@
+declare const _default: {
+    OK: number;
+    OK_PUT: number;
+    OK_NO_CONTENT: number;
+    MISSING_PARAMETER: number;
+    WRONG_TYPE_PARAMETER: number;
+    EMPTY_OR_RANGE_OR_ENUM_PARAMETER: number;
+    JSON_PARSE: number;
+    NOT_FOUND: number;
+    MISSING_HEADER: number;
+    INTERNAL_SERVER_ERROR: number;
+    NOT_IMPLEMENTED: number;
+};
+export default _default;

package/lib/cjs/utils/serverCodes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    "OK": 200,
+    "OK_PUT": 201,
+    "OK_NO_CONTENT": 204,
+    "MISSING_PARAMETER": 400,
+    "WRONG_TYPE_PARAMETER": 400,
+    "EMPTY_OR_RANGE_OR_ENUM_PARAMETER": 400,
+    "JSON_PARSE": 400,
+    "NOT_FOUND": 404,
+    "MISSING_HEADER": 411,
+    "INTERNAL_SERVER_ERROR": 500,
+    "NOT_IMPLEMENTED": 501
+};