qcobjects 2.4.107-ts → 2.5.101-ts

package/.hintrc

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "development"
+  ]
+}

package/VERSION

@@ -1 +1 @@
-2.4.107-ts
+2.5.101-ts

package/build/ArrayCollection.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayCollection = exports.ArrayList = void 0;
+const ClassFactory_1 = require("./ClassFactory");
+const Logger_1 = require("./Logger");
+const New_1 = require("./New");
+const mathFunctions_1 = require("./mathFunctions");
+class ArrayList extends Array {
+    prototype;
+    unique() {
+        return this.filter(function (value, index, self) {
+            return self.indexOf(value) === index;
+        });
+    }
+    ;
+    table() {
+        console.table(this);
+    }
+    ;
+    sum() {
+        return this.reduce((prev, current) => {
+            return ((0, mathFunctions_1.__to_number)(prev)) + ((0, mathFunctions_1.__to_number)(current));
+        }, 0);
+    }
+    avg() {
+        return (this.length < 1) ? (0) : (this.reduce((prev, current) => {
+            return ((((0, mathFunctions_1.__to_number)(prev)) + ((0, mathFunctions_1.__to_number)(current))) / 2);
+        }));
+    }
+    min() {
+        return this.reduce((prev, current) => {
+            return ((0, mathFunctions_1.__to_number)(prev) <= (0, mathFunctions_1.__to_number)(current)) ? (prev) : (current);
+        }, Infinity);
+    }
+    max() {
+        return this.reduce((prev, current) => {
+            return ((0, mathFunctions_1.__to_number)(prev) >= (0, mathFunctions_1.__to_number)(current)) ? (prev) : (current);
+        }, 0);
+    }
+    sortBy(propName, sortAsc) {
+        const sort_function = (sortAsc) ? (function (prev, current) {
+            return current[propName] < prev[propName] ? 1 : -1;
+        }) : (function (prev, current) {
+            return current[propName] > prev[propName] ? 1 : -1;
+        });
+        return this.sort(sort_function);
+    }
+    matrix(length, fillValue) {
+        const x_func = () => {
+            return fillValue;
+        };
+        return Array.from({
+            length: length
+        }, x_func);
+    }
+    matrix2d(length, fillValue) {
+        const y_func = function () {
+            return fillValue;
+        };
+        const x_func = function () {
+            return Array.from({
+                length
+            }, y_func);
+        };
+        return Array.from({
+            length
+        }, x_func);
+    }
+    matrix3d(length, fillValue) {
+        const y_func = function () {
+            return Array.from({
+                length
+            }, function () {
+                return fillValue;
+            });
+        };
+        const x_func = function () {
+            return Array.from({
+                length
+            }, y_func);
+        };
+        return Array.from({
+            length
+        }, x_func);
+    }
+}
+exports.ArrayList = ArrayList;
+class ArrayCollection {
+    source = (0, New_1.New)(ArrayList, []);
+    changed(prop, value) {
+        Logger_1.logger.debug("VALUE CHANGED");
+        Logger_1.logger.debug(prop);
+        Logger_1.logger.debug(value);
+    }
+    push(value) {
+        const self = this;
+        Logger_1.logger.debug("VALUE ADDED");
+        Logger_1.logger.debug(value);
+        self.source.push(value);
+    }
+    pop() {
+        const self = this;
+        Logger_1.logger.debug("VALUE POPPED");
+        self.source.pop();
+    }
+    _new_(source) {
+        const self = this;
+        let _index = 0;
+        self.source = (0, New_1.New)((0, ClassFactory_1.ClassFactory)("ArrayList"), source);
+        for (const _k in self.source) {
+            if (!isNaN(_k)) {
+                Logger_1.logger.debug("binding " + _k.toString());
+                (function (_pname) {
+                    Object.defineProperty(self, _pname, {
+                        set(value) {
+                            Logger_1.logger.debug("setting " + _pname + "=" + value);
+                            self.source[_pname] = value;
+                            self.changed(_pname, value);
+                        },
+                        get() {
+                            return self.source[_pname];
+                        }
+                    });
+                })(_k);
+                _index++;
+            }
+        }
+        self.source.length = _index;
+        Object.defineProperty(self, "length", {
+            get() {
+                return self.source.length;
+            }
+        });
+    }
+}
+exports.ArrayCollection = ArrayCollection;

package/build/BackendMicroservice.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendMicroservice = void 0;
+const basePath_1 = require("./basePath");
+const DataStringify_1 = require("./DataStringify");
+const domain_1 = require("./domain");
+const InheritClass_1 = require("./InheritClass");
+const Logger_1 = require("./Logger");
+const Package_1 = require("./Package");
+class BackendMicroservice extends InheritClass_1.InheritClass {
+    stream;
+    route;
+    headers;
+    request;
+    constructor({ domain = domain_1._domain_, basePath = basePath_1._basePath_, body = null, stream = null, request = null }) {
+        super({
+            domain,
+            basePath,
+            body,
+            stream,
+            request
+        });
+        Logger_1.logger.debug("Initializing BackendMicroservice...");
+        const microservice = this;
+        if (typeof this.body === "undefined") {
+            this.body = null;
+        }
+        if (typeof body !== "undefined") {
+            this.body = body;
+        }
+        this.cors();
+        microservice.stream = stream;
+        stream?.on("data", (data) => {
+            // data from POST, GET
+            const requestMethod = request?.method.toLowerCase();
+            const supportedMethods = {
+                "post": microservice.post.bind(microservice),
+            };
+            if (Object.hasOwn(supportedMethods, requestMethod)) {
+                supportedMethods[requestMethod].call(microservice, data);
+            }
+        });
+        // data from POST, GET
+        const requestMethod = request?.method.toLowerCase();
+        const supportedMethods = {
+            "get": microservice.get.bind(microservice),
+            "head": microservice.head.bind(microservice),
+            "put": microservice.put.bind(microservice),
+            "delete": microservice.delete.bind(microservice),
+            "connect": microservice.connect.bind(microservice),
+            "options": microservice.options.bind(microservice),
+            "trace": microservice.trace.bind(microservice),
+            "patch": microservice.patch.bind(microservice)
+        };
+        if (Object.hasOwn(supportedMethods, requestMethod)) {
+            supportedMethods[requestMethod].call(microservice);
+        }
+    }
+    cors() {
+        if (this.route.cors) {
+            Logger_1.logger.debug("Validating CORS...");
+            const { allow_origins, allow_credentials, allow_methods, allow_headers } = this.route.cors;
+            const microservice = this;
+            if (typeof microservice.headers !== "object") {
+                microservice.headers = {};
+            }
+            if (typeof microservice.route.responseHeaders !== "object") {
+                microservice.route.responseHeaders = {};
+            }
+            if (typeof allow_origins !== "undefined") {
+                Logger_1.logger.debug("CORS: allow_origins available. Validating origins...");
+                // an example of allow_origins is ['https://example.com','http://www.example.com']
+                if (allow_origins === "*" || (typeof microservice.request.headers.origin === "undefined") || [...allow_origins].indexOf(microservice.request.headers.origin) !== -1) {
+                    // for compatibility with all browsers allways return a wildcard when the origin is allowed
+                    Logger_1.logger.debug("CORS: Adding header Access-Control-Allow-Origin=*");
+                    microservice.route.responseHeaders["Access-Control-Allow-Origin"] = "*";
+                }
+                else {
+                    Logger_1.logger.debug("CORS: Origin is not allowed: " + microservice.request.headers.origin);
+                    Logger_1.logger.debug("CORS: Forcing to finish the response...");
+                    this.body = {};
+                    try {
+                        this.done();
+                    }
+                    catch (e) {
+                        Logger_1.logger.debug(`It was not possible to finish the call to the microservice: ${e}`);
+                    }
+                }
+            }
+            else {
+                Logger_1.logger.debug("CORS: no allow_origins available. Allowing all origins...");
+                Logger_1.logger.debug("CORS: Adding header Access-Control-Allow-Origin=*");
+                microservice.route.responseHeaders["Access-Control-Allow-Origin"] = "*";
+            }
+            if (typeof allow_credentials !== "undefined") {
+                Logger_1.logger.debug(`CORS: allow_credentials present. Allowing ${allow_credentials}...`);
+                microservice.route.responseHeaders["Access-Control-Allow-Credentials"] = allow_credentials.toString();
+            }
+            else {
+                Logger_1.logger.debug("CORS: No allow_credentials present. Allowing all credentials.");
+                microservice.route.responseHeaders["Access-Control-Allow-Credentials"] = "true";
+            }
+            if (typeof allow_methods !== "undefined") {
+                Logger_1.logger.debug(`CORS: allow_methods present. Allowing ${allow_methods}...`);
+                microservice.route.responseHeaders["Access-Control-Allow-Methods"] = [...allow_methods].join(",");
+            }
+            else {
+                Logger_1.logger.debug("CORS: No allow_methods present. Allowing only GET, OPTIONS and POST");
+                microservice.route.responseHeaders["Access-Control-Allow-Methods"] = "GET, OPTIONS, POST";
+            }
+            if (typeof allow_headers !== "undefined") {
+                Logger_1.logger.debug(`CORS: allow_headers present. Allowing ${allow_headers}...`);
+                microservice.route.responseHeaders["Access-Control-Allow-Headers"] = [...allow_headers].join(",");
+            }
+            else {
+                Logger_1.logger.debug("CORS: No allow_headers present. Allowing all headers...");
+                microservice.route.responseHeaders["Access-Control-Allow-Headers"] = "*";
+            }
+        }
+        else {
+            Logger_1.logger.debug("No CORS validation available. You can specify cors in CONFIG.backend.routes[].cors");
+        }
+    }
+    head(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.head] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    get(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.get] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    post(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.post] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    put(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.put] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    delete(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.delete] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    connect(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.connect] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    options(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.options] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    trace(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.trace] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    patch(formData) {
+        Logger_1.logger.debug(`[BackendMicroservice.patch] Data received: ${(0, DataStringify_1._DataStringify)(formData)}`);
+        this.done();
+    }
+    finishWithBody(stream) {
+        try {
+            Logger_1.logger.debug("[BackendMicroservice.finishWithBody] Ending the stream...");
+            Logger_1.logger.debug(`[BackendMicroservice.finishWithBody] type of body is: ${typeof this.body}`);
+            if (typeof this.body !== "string") {
+                this.body = (0, DataStringify_1._DataStringify)(this.body);
+            }
+            Logger_1.logger.debug(`[BackendMicroservice.finishWithBody] \n body: ${this.body} `);
+            stream?.write(this.body);
+            stream?.end();
+            Logger_1.logger.debug("[BackendMicroservice.finishWithBody] Stream ended.");
+        }
+        catch (e) {
+            Logger_1.logger.debug(`[BackendMicroservice.finishWithBody] Something went wrong ending the stream: ${e}`);
+        }
+    }
+    done() {
+        Logger_1.logger.debug("[BackendMicroservice.done] Finalizing the response...");
+        const microservice = this;
+        const stream = microservice.stream;
+        try {
+            Logger_1.logger.debug("[BackendMicroservice.done] Sending response headers...");
+            if (microservice.route.responseHeaders) {
+                Logger_1.logger.debug(`[BackendMicroservice.done] Response headers present: ${Object.keys(microservice.route.responseHeaders).join(",")}`);
+                stream.respond(microservice.route.responseHeaders);
+            }
+            else {
+                throw Error("[BackendMicroservice.done] No headers present.");
+            }
+        }
+        catch (e) {
+            Logger_1.logger.debug(`[BackendMicroservice.done] Something went wrong sending response headers: ${e}`);
+        }
+        if (microservice.body !== null) {
+            try {
+                Logger_1.logger.debug("[BackendMicroservice.done] A body of message is present. Finalizing the response...");
+                microservice.finishWithBody.call(microservice, stream);
+            }
+            catch (e) {
+                Logger_1.logger.debug(`[BackendMicroservice.done] Something went wrong finalizing the response: ${e}`);
+            }
+        }
+        else {
+            Logger_1.logger.debug("[BackendMicroservice.done] No body present. Ending stream...");
+            stream.end();
+        }
+    }
+}
+exports.BackendMicroservice = BackendMicroservice;
+(0, Package_1.Package)("com.qcobjects.api", [
+    BackendMicroservice
+]);

package/build/Base64.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64 = void 0;
+exports.Base64 = {
+    _keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+    encode(e) {
+        let t = "";
+        let n, r, i, s, o, u, a;
+        let f = 0;
+        e = exports.Base64._utf8_encode(e);
+        while (f < e.length) {
+            n = e.charCodeAt(f++);
+            r = e.charCodeAt(f++);
+            i = e.charCodeAt(f++);
+            s = n >> 2;
+            o = (n & 3) << 4 | r >> 4;
+            u = (r & 15) << 2 | i >> 6;
+            a = i & 63;
+            if (isNaN(r)) {
+                u = a = 64;
+            }
+            else if (isNaN(i)) {
+                a = 64;
+            }
+            t = t + this._keyStr.charAt(s) + this._keyStr.charAt(o) + this._keyStr.charAt(u) + this._keyStr.charAt(a);
+        }
+        return t;
+    },
+    decode(e) {
+        let t = "";
+        let n, r, i;
+        let s, o, u, a;
+        let f = 0;
+        e = e.replace(/[^A-Za-z0-9+/=]/g, "");
+        while (f < e.length) {
+            s = this._keyStr.indexOf(e.charAt(f++));
+            o = this._keyStr.indexOf(e.charAt(f++));
+            u = this._keyStr.indexOf(e.charAt(f++));
+            a = this._keyStr.indexOf(e.charAt(f++));
+            n = s << 2 | o >> 4;
+            r = (o & 15) << 4 | u >> 2;
+            i = (u & 3) << 6 | a;
+            t = t + String.fromCharCode(n);
+            if (u !== 64) {
+                t = t + String.fromCharCode(r);
+            }
+            if (a !== 64) {
+                t = t + String.fromCharCode(i);
+            }
+        }
+        t = exports.Base64._utf8_decode(t);
+        return t;
+    },
+    _utf8_encode(e) {
+        e = e.replace(/rn/g, "n");
+        let t = "";
+        for (let n = 0; n < e.length; n++) {
+            const r = e.charCodeAt(n);
+            if (r < 128) {
+                t += String.fromCharCode(r);
+            }
+            else if (r > 127 && r < 2048) {
+                t += String.fromCharCode(r >> 6 | 192);
+                t += String.fromCharCode(r & 63 | 128);
+            }
+            else {
+                t += String.fromCharCode(r >> 12 | 224);
+                t += String.fromCharCode(r >> 6 & 63 | 128);
+                t += String.fromCharCode(r & 63 | 128);
+            }
+        }
+        return t;
+    },
+    _utf8_decode(e) {
+        let t = "";
+        let n = 0;
+        let r = 0;
+        let c2 = 0;
+        let c3;
+        while (n < e.length) {
+            r = e.charCodeAt(n);
+            if (r < 128) {
+                t += String.fromCharCode(r);
+                n++;
+            }
+            else if (r > 191 && r < 224) {
+                c2 = e.charCodeAt(n + 1);
+                t += String.fromCharCode((r & 31) << 6 | c2 & 63);
+                n += 2;
+            }
+            else {
+                c2 = e.charCodeAt(n + 1);
+                c3 = e.charCodeAt(n + 2);
+                t += String.fromCharCode((r & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
+                n += 3;
+            }
+        }
+        return t;
+    }
+};

package/build/CONFIG.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const basePath_1 = require("./basePath");
+const Cast_1 = require("./Cast");
+const Crypt_1 = require("./Crypt");
+const DataStringify_1 = require("./DataStringify");
+const Logger_1 = require("./Logger");
+const Processor_1 = require("./Processor");
+const secretKey_1 = require("./secretKey");
+const Package_1 = require("./Package");
+const InheritClass_1 = require("./InheritClass");
+const ConfigSettings_1 = require("./ConfigSettings");
+class CONFIG extends InheritClass_1.InheritClass {
+    get _CONFIG_ENC() {
+        return ConfigSettings_1.ConfigSettings.instance._CONFIG_ENC;
+    }
+    get _CONFIG() {
+        return ConfigSettings_1.ConfigSettings.instance._CONFIG;
+    }
+    set(name, value) {
+        Logger_1.logger.debug(`CONFIG.set  ${name}: ${value}`);
+        // hack to force update basePath from CONFIG
+        if (name === "basePath") {
+            (0, basePath_1.setBasePath)(value);
+        }
+        let _conf;
+        try {
+            _conf = (function (config) {
+                if (config._CONFIG_ENC === null) {
+                    config._CONFIG_ENC = Crypt_1._Crypt.encrypt((0, DataStringify_1._DataStringify)({}), secretKey_1._secretKey);
+                }
+                const _protectedEnc = config._CONFIG_ENC.valueOf();
+                const _protectedConf = config._CONFIG?.valueOf();
+                return (0, Cast_1._CastProps)(_protectedConf, (0, Crypt_1._DecryptObject)(_protectedEnc));
+            })(ConfigSettings_1.ConfigSettings.instance);
+        }
+        catch (e) {
+            _conf = {};
+            console.error(e);
+            Logger_1.logger.debug("failed to encrypt config");
+        }
+        _conf[name] = value;
+        ConfigSettings_1.ConfigSettings.instance._CONFIG_ENC = (0, Crypt_1._CryptObject)(_conf);
+        ConfigSettings_1.ConfigSettings.instance.set(name, value);
+    }
+    get(name, _default) {
+        let _value;
+        try {
+            const _conf = (function (config) {
+                if (config._CONFIG_ENC === null) {
+                    config._CONFIG_ENC = Crypt_1._Crypt.encrypt((0, DataStringify_1._DataStringify)({}), secretKey_1._secretKey);
+                }
+                const _protectedEnc = config._CONFIG_ENC.valueOf();
+                const _protectedConf = config._CONFIG.valueOf();
+                return (0, Cast_1._CastProps)(_protectedConf, (0, Crypt_1._DecryptObject)(_protectedEnc));
+            })(ConfigSettings_1.ConfigSettings.instance);
+            if (typeof _conf[name] !== "undefined") {
+                _value = _conf[name];
+            }
+        }
+        catch (e) {
+            console.error(e);
+            Logger_1.logger.debug("Something wrong when trying to get CONFIG values");
+            Logger_1.logger.debug("No config value for: " + name);
+            _value = _default;
+        }
+        return Processor_1.GlobalProcessor.processObject(_value) || _default;
+    }
+    static _instance;
+    static get instance() {
+        if (typeof CONFIG._instance === "undefined") {
+            CONFIG._instance = new CONFIG();
+        }
+        return CONFIG._instance;
+    }
+    static set(name, value) {
+        (CONFIG.instance.set(name, value));
+    }
+    static get(name, value) {
+        return (CONFIG.instance.get(name, value));
+    }
+}
+exports.CONFIG = CONFIG;
+(0, Package_1.Package)("com.qcobjects", [CONFIG]);

package/build/Cast.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._CastProps = exports._Cast = void 0;
+const Logger_1 = require("./Logger");
+/**
+ * Casts an object to another object class type
+ *
+ * @param {Object} obj_source
+ * @param {Object} obj_dest
+ */
+const _Cast = function (obj_source, obj_dest) {
+    for (const v in obj_source) {
+        if (typeof obj_source[v] !== "undefined") {
+            try {
+                obj_dest[v] = obj_source[v];
+            }
+            catch (e) {
+                Logger_1.logger.debug(`An error ocurred: ${e}.`);
+                Logger_1.logger.warn(`Unable to cast ${(typeof obj_source).toString()}.${typeof v.toString()} to ${(typeof obj_dest).toString()}.${typeof v.toString()}`);
+            }
+        }
+    }
+    return obj_dest;
+};
+exports._Cast = _Cast;
+/**
+ * Casts an object to another object class type. Only properties
+ *
+ * @param {Object} obj_source
+ * @param {Object} obj_dest
+ */
+const _CastProps = function (obj_source, obj_dest) {
+    for (const v in obj_source) {
+        if (typeof obj_source[v] !== "undefined" && typeof obj_source[v] !== "function") {
+            try {
+                obj_dest[v] = obj_source[v];
+            }
+            catch (e) {
+                Logger_1.logger.debug(`An error ocurred: ${e}.`);
+            }
+        }
+        else if (typeof obj_source[v] === "function") {
+            try {
+                obj_dest[v] = obj_source[v].bind(obj_dest);
+            }
+            catch (e) {
+                Logger_1.logger.warn(e);
+            }
+        }
+    }
+    return obj_dest;
+};
+exports._CastProps = _CastProps;