qcobjects 2.4.105-ts → 2.4.108-ts

package/spec/helpers/mock-sdk.helper.ts

@@ -0,0 +1,5 @@
+const path = require('path');
+const mockSDK = require(path.resolve(__dirname, '../mocks/qcobjects-sdk.mock'));
+
+// Mock the module in the require cache
+

package/spec/mocks/qcobjects-sdk.mock.ts

@@ -0,0 +1 @@
+export default {}

package/spec/support/jasmine.json

@@ -2,12 +2,12 @@
   "spec_dir": "spec",
 
   "spec_files": [
-    "**/*[sS]pec.js",
-    "!**/*nospec.js"
+    "**/*[sS]pec.ts",
+    "!**/*nospec.ts"
   ],
 
   "helpers": [
-    "helpers/**/*.js"
+    "helpers/**/*.helper.ts"
   ],
 
   "stopSpecOnExpectationFailure": true,

package/spec/testsClassFactorySpec.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/* eslint-disable no-undef */
+import {Class, ClassFactory, logger, Package, __make_global__, _top, _QC_PACKAGES, _QC_CLASSES, global} from "./../src/QCObjects";
+
+describe("qcobjects", function () {
+    logger.debugEnabled=true;
+    logger.infoEnabled=true;
+    logger.warnEnabled=true;
+  
+    it("Class Factory using Class Function, no parent class Spec",  () => {
+        const MyClass = Class ("MyClass", class {}, {});
+
+
+        expect(ClassFactory("MyClass")).toBe( MyClass );
+        logger.debug("Class Factory using Class Function, no parent class Spec... OK");
+    });
+
+    it("Global Class Factory using Class Function, no parent class Spec", () => {
+        const classFactory = Class ("MyClass", class {}, {});
+        Package("com.qcobjects", [classFactory]);
+
+        expect((global as any).MyClass).toBe( classFactory );
+        logger.debug("Global Class Factory using Class Function, no parent class Spec... OK");
+    });
+
+    it("Class Factory inside a package, no parent class Spec",  () => {
+        Package("com.qcobjects.tests",[
+            Class("MyNewClass",class {},{
+                propertyName1:"propertyValue1",
+            })
+        ]);
+
+        const classFactory = ClassFactory("com.qcobjects.tests.MyNewClass");
+
+        expect(ClassFactory("MyNewClass")).toBe( classFactory );
+        logger.debug("Class Factory inside a package, no parent class Spec... OK");
+    });
+    
+  });
+  

package/spec/{testsConfigSpec.js → testsConfigSpec.ts}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /* eslint-disable no-undef */
+import {CONFIG, logger} from "./../src/QCObjects";
 
-describe("QCObjects Config", function () {
-  require("../src/QCObjects.js");
+describe("qcobjects", function () {
   logger.debugEnabled=true;
   logger.infoEnabled=true;
   logger.warnEnabled=true;

package/spec/{testsGlobalFeaturesSpec.js → testsGlobalFeaturesSpec.ts}

@@ -1,28 +1,30 @@
 #!/usr/bin/env node
+
+import { __getType__, logger, global } from "../src/QCObjects";
+
 /* eslint-disable no-undef */
 
-describe("Global Features Spec", function () {
-    require("../src/QCObjects.js");
-    logger.debugEnabled=true;
-    logger.infoEnabled=true;
-    logger.warnEnabled=true;
+describe("qcobjects", function () {
   
     it("Existence of global.ClassesList Spec", function () {
-        let classesList = global.ClassesList;
+        logger.debugEnabled=true;
+        logger.infoEnabled=true;
+        logger.warnEnabled=true;
+        let classesList:any[] = global.ClassesList;
         expect(__getType__(classesList)).toBe("Array");
   
         logger.debug("Existence of global.ClassesList Spec... OK");
     });
   
     it("Existence of global.PackagesNameList Spec", function () {
-        let packagesNameList = global.PackagesNameList;
+        let packagesNameList:any[] = global.PackagesNameList;
         expect(__getType__(packagesNameList)).toBe("Array");
   
         logger.debug("Existence of global.PackagesNameList Spec... OK");
     });
 
     it("Existence of global.PackagesList Spec", function () {
-        let packagesList = global.PackagesList;
+        let packagesList:any[] = global.PackagesList;
         expect(__getType__(packagesList)).toBe("Array");
   
         logger.debug("Existence of global.PackagesList Spec... OK");

package/spec/{testsSpec.js → testsSpec.ts}

@@ -1,14 +1,18 @@
 #!/usr/bin/env node
+
+import { _DataStringify, Class, ClassFactory, Component, CONFIG, Effect, logger, New, global, InheritClass, __getType__ } from "../src/QCObjects";
+
+
 /* eslint-disable no-undef */
 
-describe("QCObjects Main Test", function () {
-  require("../src/QCObjects.js");
+
+describe("qcobjects", function () {
   logger.debugEnabled=true;
   logger.infoEnabled=true;
   logger.warnEnabled=true;
 
   it("Class Declaration Test Spec", function () {
-    Class("Main", Object, {
+    const Main = Class("Main", Object, {
       _new_: () => {
       }
     });
@@ -18,6 +22,7 @@ describe("QCObjects Main Test", function () {
   });
 
   it("Main intance Test Spec", function () {
+    class Main extends InheritClass {}
     let __main__ = New(Main, {});
     expect(typeof __main__.__instanceID).toEqual("number");
     expect(__main__.__classType).toEqual("Main");
@@ -25,7 +30,7 @@ describe("QCObjects Main Test", function () {
   });
 
   it("Existence of Component Class", function () {
-    expect(Component).toEqual(ClassFactory("Component"));
+    expect(Component as unknown as InheritClass).toEqual(ClassFactory("Component"));
     logger.debug("Existence of Component Class... OK");
   });
 
@@ -40,18 +45,14 @@ describe("QCObjects Main Test", function () {
   });
 
   it("Existence of CONFIG global Class", function () {
-    expect(typeof CONFIG.__definition).toEqual("object");
+    expect(__getType__(CONFIG)).toEqual("CONFIG");
     logger.debug("Existence of CONFIG global Class... OK");
   });
 
   it("global as QCObjects global", function () {
-    expect(typeof global.__definition).toEqual("object");
+    expect(__getType__(global)).not.toEqual("");
     logger.debug("global as QCObjects global... OK");
   });
 
-  it("Existence of QCObjects SDK", function () {
-    expect(!!global._sdk_).toEqual(true);
-    logger.debug("Existence of QCObjects SDK... OK");
-  });
 
 });

package/spec/{testsTypeSpec.js → testsTypeSpec.ts}

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
+
+import { __getType__, Class, ClassFactory, logger } from "../src/QCObjects";
+
 /* eslint-disable no-undef */
 
-describe("Type Spec", function () {
-  require("../src/QCObjects");
+describe("qcobjects", function () {
   logger.debugEnabled=true;
   logger.infoEnabled=true;
   logger.warnEnabled=true;
@@ -13,8 +15,8 @@ describe("Type Spec", function () {
         return "method1";
       }
     }
-    
     Class("Main", CustomType, {});
+    const Main = ClassFactory("Main");
     class CustomMain extends Main {}
     var main = new CustomMain();
 

package/src/ArrayCollection.ts

@@ -0,0 +1,143 @@
+import { IArrayCollection, IArrayList } from "types";
+import { ClassFactory } from "./ClassFactory";
+import { logger } from "./Logger";
+import { New } from "./New";
+import { __to_number } from "./mathFunctions";
+
+
+export class ArrayList extends Array implements IArrayList {
+  prototype: any;
+
+  unique ():any[] {
+    return this.filter(function (value:any, index:any, self:any) {
+      return self.indexOf(value) === index;
+    });
+  };
+
+  table(): void {
+      console.table(this);
+  };
+  sum(): number {
+    return this.reduce( (prev:any, current:any):number => {
+      return (__to_number(prev)) + (__to_number(current));
+    }, 0) as number;
+  }
+  avg(): number {
+    return (this.length < 1) ? (0) : (this.reduce( (prev:any, current:any):number => {
+      return (((__to_number(prev)) + (__to_number(current))) / 2);
+    })) as number;
+  }
+  min(): number {
+    return this.reduce( (prev:any, current:any):number => {
+      return (__to_number(prev) <= __to_number(current)) ? (prev) : (current);
+    }, Infinity) as number;
+  }
+  max(): number {
+    return this.reduce( (prev:any, current:any):number => {
+      return (__to_number(prev) >= __to_number(current)) ? (prev) : (current);
+    }, 0) as number;
+  }
+  sortBy(propName: string, sortAsc?: boolean): any[] {
+    const sort_function = (sortAsc) ? (
+      function (prev:any, current:any) {
+        return current[propName] < prev[propName] ? 1 : -1;
+      }
+    ) : (
+      function (prev:any, current:any) {
+        return current[propName] > prev[propName] ? 1 : -1;
+      }
+    );
+    return this.sort(sort_function);
+  }
+  matrix(length: number, fillValue?: number): any[] {
+    const x_func = () => {
+      return fillValue;
+    };
+    return Array.from({
+      length: length
+    }, x_func);
+  }
+  matrix2d(length: number, fillValue?: number): any[][] {
+    const y_func = function () {
+      return fillValue;
+    };
+    const x_func = function () {
+      return Array.from({
+        length
+      }, y_func);
+    };
+    return Array.from({
+      length
+    }, x_func);
+  }
+  matrix3d(length: number, fillValue?: number): any[][][] {
+    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);
+  }
+
+
+}
+
+export class ArrayCollection implements IArrayCollection {
+  source :ArrayList = New(ArrayList, []);
+  changed(prop: string, value: any) {
+    logger.debug("VALUE CHANGED");
+    logger.debug(prop);
+    logger.debug(value);
+  }
+  push(value: any) {
+    const self = this;
+    logger.debug("VALUE ADDED");
+    logger.debug(value);
+    self.source.push(value);
+  }
+  pop() {
+    const self = this;
+    logger.debug("VALUE POPPED");
+    self.source.pop();
+  }
+  _new_(source: ArrayList) {
+    const self = this;
+    let _index = 0;
+    self.source = New(ClassFactory("ArrayList"), source);
+    for (const _k in self.source) {
+      if (!isNaN(_k as any)) {
+        logger.debug("binding " + _k.toString());
+        (function (_pname:any) {
+          Object.defineProperty(self, _pname, {
+            set(value) {
+              logger.debug("setting " + _pname + "=" + value);
+              self.source[_pname] = value;
+              self.changed(_pname, value);
+            },
+            get():unknown {
+              return self.source[_pname];
+            }
+          });
+        })(_k);
+        _index++;
+      }
+
+    }
+    self.source.length = _index;
+    Object.defineProperty(self, "length", {
+      get() {
+        return self.source.length;
+      }
+    });
+  }
+}
+

package/src/BackendMicroservice.ts

@@ -0,0 +1,229 @@
+import { Http2Stream } from "http2";
+import { Stream } from "stream";
+import { _basePath_ } from "./basePath";
+import { _DataStringify } from "./DataStringify";
+import { _domain_ } from "./domain";
+import { InheritClass } from "./InheritClass";
+import { logger } from "./Logger";
+import { Package } from "./Package";
+
+export class BackendMicroservice extends InheritClass {
+  stream: any;
+  route: any;
+  headers: any;
+  request: any;
+
+  constructor({
+    domain = _domain_,
+    basePath = _basePath_,
+    body = null,
+    stream = null,
+    request = null
+  }) {
+    super({
+      domain,
+      basePath,
+      body,
+      stream,
+      request
+    });
+    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 as any)?.on("data", (data: any) => {
+      // data from POST, GET
+      const requestMethod = (request as any)?.method.toLowerCase();
+      const supportedMethods = {
+        "post": microservice.post.bind(microservice),
+      };
+      if (Object.hasOwn(supportedMethods, requestMethod)) {
+        (supportedMethods as any)[requestMethod].call(microservice, data);
+      }
+    });
+
+    // data from POST, GET
+    const requestMethod = (request as any)?.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 as any)[requestMethod].call(microservice);
+    }
+
+
+  }
+
+  cors() {
+    if (this.route.cors) {
+      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.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.debug("CORS: Adding header Access-Control-Allow-Origin=*");
+          microservice.route.responseHeaders["Access-Control-Allow-Origin"] = "*";
+        } else {
+          logger.debug("CORS: Origin is not allowed: " + microservice.request.headers.origin);
+          logger.debug("CORS: Forcing to finish the response...");
+          this.body = {};
+          try {
+            this.done();
+          } catch (e:any) {
+            logger.debug(`It was not possible to finish the call to the microservice: ${e}`);
+          }
+        }
+      } else {
+        logger.debug("CORS: no allow_origins available. Allowing all origins...");
+        logger.debug("CORS: Adding header Access-Control-Allow-Origin=*");
+        microservice.route.responseHeaders["Access-Control-Allow-Origin"] = "*";
+      }
+      if (typeof allow_credentials !== "undefined") {
+        logger.debug(`CORS: allow_credentials present. Allowing ${allow_credentials}...`);
+        microservice.route.responseHeaders["Access-Control-Allow-Credentials"] = allow_credentials.toString();
+      } else {
+        logger.debug("CORS: No allow_credentials present. Allowing all credentials.");
+        microservice.route.responseHeaders["Access-Control-Allow-Credentials"] = "true";
+      }
+      if (typeof allow_methods !== "undefined") {
+        logger.debug(`CORS: allow_methods present. Allowing ${allow_methods}...`);
+        microservice.route.responseHeaders["Access-Control-Allow-Methods"] = [...allow_methods].join(",");
+      } else {
+        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.debug(`CORS: allow_headers present. Allowing ${allow_headers}...`);
+        microservice.route.responseHeaders["Access-Control-Allow-Headers"] = [...allow_headers].join(",");
+      } else {
+        logger.debug("CORS: No allow_headers present. Allowing all headers...");
+        microservice.route.responseHeaders["Access-Control-Allow-Headers"] = "*";
+      }
+    } else {
+      logger.debug("No CORS validation available. You can specify cors in CONFIG.backend.routes[].cors");
+    }
+  }
+
+
+  head(formData: any) {
+    logger.debug(`[BackendMicroservice.head] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  get(formData: any) {
+    logger.debug(`[BackendMicroservice.get] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  post(formData: any) {
+    logger.debug(`[BackendMicroservice.post] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  put(formData: any) {
+    logger.debug(`[BackendMicroservice.put] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  delete(formData: any) {
+    logger.debug(`[BackendMicroservice.delete] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  connect(formData: any) {
+    logger.debug(`[BackendMicroservice.connect] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  options(formData: any) {
+    logger.debug(`[BackendMicroservice.options] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  trace(formData: any) {
+    logger.debug(`[BackendMicroservice.trace] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  patch(formData: any) {
+    logger.debug(`[BackendMicroservice.patch] Data received: ${_DataStringify(formData)}`);
+    this.done();
+  }
+
+  finishWithBody(stream?: Http2Stream | Stream) {
+    try {
+      logger.debug("[BackendMicroservice.finishWithBody] Ending the stream...");
+      logger.debug(`[BackendMicroservice.finishWithBody] type of body is: ${typeof this.body}`);
+      if (typeof this.body !== "string") {
+        this.body = _DataStringify(this.body);
+      }
+      logger.debug(`[BackendMicroservice.finishWithBody] \n body: ${this.body} `);
+      (stream as any)?.write(this.body);
+      (stream as any)?.end();
+      logger.debug("[BackendMicroservice.finishWithBody] Stream ended.");
+    } catch (e:any) {
+      logger.debug(`[BackendMicroservice.finishWithBody] Something went wrong ending the stream: ${e}`);
+    }
+  }
+
+  done() {
+    logger.debug("[BackendMicroservice.done] Finalizing the response...");
+    const microservice = this;
+    const stream = microservice.stream;
+    try {
+      logger.debug("[BackendMicroservice.done] Sending response headers...");
+      if (microservice.route.responseHeaders) {
+        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:any) {
+      logger.debug(`[BackendMicroservice.done] Something went wrong sending response headers: ${e}`);
+    }
+    if (microservice.body !== null) {
+      try {
+        logger.debug("[BackendMicroservice.done] A body of message is present. Finalizing the response...");
+        microservice.finishWithBody.call(microservice, stream);
+      } catch (e:any) {
+        logger.debug(`[BackendMicroservice.done] Something went wrong finalizing the response: ${e}`);
+      }
+    } else {
+      logger.debug("[BackendMicroservice.done] No body present. Ending stream...");
+      stream.end();
+    }
+  }
+
+
+}
+
+Package("com.qcobjects.api", [
+  BackendMicroservice
+]);

package/src/Base64.ts

@@ -0,0 +1,92 @@
+export const Base64 = {
+    _keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+    encode(e: string) {
+      let t = "";
+      let n: number, r: number, i: number, s: number, o: number, u: number, a: number;
+      let f = 0;
+      e = 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: string) {
+      let t = "";
+      let n: number, r: number, i: number;
+      let s: number, o: number, u: number, a: number;
+      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 = Base64._utf8_decode(t);
+      return t;
+    },
+    _utf8_encode(e: string) {
+      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: string) {
+      let t = "";
+      let n = 0;
+      let r = 0;
+      let c2 = 0;
+      let c3: number;
+      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;
+    }
+  };