@quatrain/core 1.1.18 → 1.1.21

package/lib/Core.d.ts

@@ -2,18 +2,18 @@ import { User } from './components/User';
 import { DataObjectClass } from './components/types/DataObjectClass';
 import { AbstractLoggerAdapter, LogLevel } from '@quatrain/log';
 export declare class Core {
-    static me: string;
-    static storage: any;
-    static storagePrefix: string;
-    static userClass: typeof User;
-    static classRegistry: {
+    static readonly me: string;
+    static readonly storage: any;
+    static readonly storagePrefix = "core";
+    static readonly userClass: typeof User;
+    static readonly classRegistry: {
         [key: string]: any;
     };
-    static logLevel: LogLevel;
-    static logger: AbstractLoggerAdapter;
+    static readonly logLevel = LogLevel.DEBUG;
+    static readonly logger: AbstractLoggerAdapter;
     static addLogger(alias?: string): any;
     static setLogLevel(level: LogLevel): void;
-    static timestamp: () => string;
+    static readonly timestamp: () => string;
     static definition(key: string): {
         manifest: {
             type: StringConstructor;
@@ -24,6 +24,16 @@ export declare class Core {
     static getConfig(key: string): Promise<any>;
     static addClass(name: string, obj: any): void;
     static getClass(name: string): any;
+    /**
+     * Execute an external command in a promise
+     * @see https://stackoverflow.com/questions/46289682/how-to-wait-for-child-process-spawn-execution-with-async-await
+     * @see https://dzone.com/articles/understanding-execfile-spawn-exec-and-fork-in-node
+     * @param string command
+     * @param array args
+     * @return Promise
+     */
+    static readonly execPromise: (command: string, args?: any[], cwd?: string) => Promise<any>;
+    static readonly getSystemCommandPath: (command: string) => Promise<string>;
     /**
      * Returns the class to use for a data object
      * This is currently just a stub that will be implemented from config in the future

package/lib/Core.js

@@ -8,12 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
 const DataObject_1 = require("./components/DataObject");
 const User_1 = require("./components/User");
 const log_1 = require("@quatrain/log");
+const child_process_1 = require("child_process");
+const which_1 = __importDefault(require("which"));
 class Core {
     static addLogger(alias = this.name) {
         return log_1.Log.addLogger('@' + alias, new log_1.DefaultLoggerAdapter(alias, this.logLevel), true);
@@ -89,3 +94,37 @@ Core.logLevel = log_1.LogLevel.DEBUG;
 Core.logger = _a.addLogger();
 // How timestamp are formatted
 Core.timestamp = () => new Date().toISOString();
+/**
+ * Execute an external command in a promise
+ * @see https://stackoverflow.com/questions/46289682/how-to-wait-for-child-process-spawn-execution-with-async-await
+ * @see https://dzone.com/articles/understanding-execfile-spawn-exec-and-fork-in-node
+ * @param string command
+ * @param array args
+ * @return Promise
+ */
+Core.execPromise = (command, args = [], cwd = process.cwd()) => {
+    try {
+        _a.info(`Executing command ${command} in ${cwd} with arguments:`);
+        args.forEach((arg) => console.log(`\t${arg}`));
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(command, args, { cwd });
+            child.stdout.on('data', (data) => _a.debug(data.toString()));
+            child.stderr.on('data', (data) => _a.debug(data.toString()));
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    _a.error(`Command execution failed with code: ${code}`);
+                    reject(new Error(`Process failed and returned code: ${code}`));
+                }
+                else {
+                    _a.info(`Command execution completed with code: ${code}`);
+                    resolve(undefined);
+                }
+            });
+        });
+    }
+    catch (err) {
+        _a.error(err.message);
+        throw err;
+    }
+};
+Core.getSystemCommandPath = (command) => (0, which_1.default)(command);

package/lib/components/DataObject.js

@@ -247,11 +247,10 @@ class DataObject {
         const data = {};
         Object.keys(this._properties).forEach((key) => {
             const prop = Reflect.get(this._properties, key);
-            if (ignoreNulls && !prop.val())
+            if (ignoreNulls && (prop.val() === null || prop.val() === undefined))
                 return;
             if (ignoreUnchanged && prop.hasChanged === false)
                 return;
-            //   console.log(prop.constructor.name);
             switch (prop.constructor.name) {
                 case 'CollectionProperty':
                     // ignore

package/lib/components/User.js

@@ -39,7 +39,6 @@ const HashProperty_1 = require("../properties/HashProperty");
 const StringProperty_1 = require("../properties/StringProperty");
 const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
 const BaseObjectProperties_1 = require("./BaseObjectProperties");
-const Entity_1 = require("./Entity");
 /**
  * Callback function to populate the 'name' property
  * @param dao DataObject
@@ -118,7 +117,7 @@ exports.UserProperties = [
         name: 'entity',
         mandatory: false,
         type: properties_1.ObjectProperty.TYPE,
-        instanceOf: Entity_1.Entity,
+        instanceOf: 'Entity',
     },
 ];
 class User extends BaseObject_1.BaseObject {

package/lib/properties/BaseProperty.js

@@ -18,7 +18,7 @@ class BaseProperty {
             typeof config.defaultValue === 'function'
                 ? config.defaultValue()
                 : config.defaultValue;
-        this._value = config.defaultValue;
+        this._value = this._defaultValue;
         this._hasChanged = false;
         this._htmlType = config.htmlType || 'off';
         if (typeof config.onChange === 'function') {
@@ -56,7 +56,8 @@ class BaseProperty {
             this._protected === true) {
             throw new Error(`Value '${this._name}' already defined as '${this._value}' and protected from change`);
         }
-        if (value !== this._value) {
+        if (JSON.stringify({ value: value }) !==
+            JSON.stringify({ value: this._value })) {
             this._value = value;
             this._hasChanged = setChanged;
         }

package/lib/properties/HashProperty.d.ts

@@ -17,7 +17,7 @@ export declare class HashProperty extends StringProperty {
     constructor(config: HashPropertyType);
     _hash(value: string): string;
     /**
-     * Never return the password which is hashed anyway
+     * Never return the value which is hashed anyway
      * @param transform
      * @returns
      */

package/lib/properties/HashProperty.js

@@ -35,7 +35,7 @@ class HashProperty extends StringProperty_1.StringProperty {
         return hash;
     }
     /**
-     * Never return the password which is hashed anyway
+     * Never return the value which is hashed anyway
      * @param transform
      * @returns
      */

package/lib/properties/ObjectProperty.js

@@ -23,51 +23,56 @@ class ObjectProperty extends BaseProperty_1.BaseProperty {
         return this._instanceOf;
     }
     val(transform = undefined) {
-        if (typeof this._instanceOf === 'string') {
-            this._instanceOf = Core_1.Core.getClass(this._instanceOf);
-        }
-        if (!this._value) {
-            return this._defaultValue;
-        }
-        switch (transform) {
-            case returnAs.AS_DATAOBJECTS:
-                if (this._value instanceof DataObject_1.DataObject) {
-                    Core_1.Core.log(`Returning already existing dataObject`);
+        try {
+            if (typeof this._instanceOf === 'string') {
+                this._instanceOf = Core_1.Core.getClass(this._instanceOf);
+            }
+            if (!this._value) {
+                return this._defaultValue;
+            }
+            switch (transform) {
+                case returnAs.AS_DATAOBJECTS:
+                    if (this._value instanceof DataObject_1.DataObject) {
+                        Core_1.Core.debug(`Returning already existing dataObject`);
+                        return this._value;
+                    }
+                    else if (this._value instanceof ObjectUri_1.ObjectUri) {
+                        Core_1.Core.debug(`Converting objectUri -> dataObject`);
+                        return DataObject_1.DataObject.factory({
+                            properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
+                            uri: this._value,
+                        });
+                    }
+                    else {
+                        Core_1.Core.debug(`Converting instance -> dataObject`);
+                        return this._value.dataObject;
+                    }
+                case returnAs.AS_INSTANCES:
+                    if (this._value instanceof DataObject_1.DataObject) {
+                        Core_1.Core.debug(`Converting dataObject -> instance`);
+                        return Reflect.construct(this._instanceOf, [this._value]);
+                    }
+                    else if (this._value instanceof ObjectUri_1.ObjectUri) {
+                        Core_1.Core.debug(`Converting objectUri -> dataObject -> instance`);
+                        const dao = DataObject_1.DataObject.factory({
+                            properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
+                            uri: this._value,
+                        });
+                        return Reflect.construct(this._instanceOf, [dao]);
+                    }
+                    else {
+                        Core_1.Core.log(`Returning already existing instance`);
+                        return this._value;
+                    }
+                case returnAs.AS_OBJECTURIS:
+                default:
                     return this._value;
-                }
-                else if (this._value instanceof ObjectUri_1.ObjectUri) {
-                    Core_1.Core.log(`Converting objectUri -> dataObject`);
-                    return DataObject_1.DataObject.factory({
-                        properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
-                        uri: this._value,
-                    });
-                }
-                else {
-                    Core_1.Core.log(`Converting instance -> dataObject`);
-                    return this._value.dataObject;
-                }
-            case returnAs.AS_INSTANCES:
-                if (this._value instanceof DataObject_1.DataObject) {
-                    Core_1.Core.log(`Converting dataObject -> instance`);
-                    return Reflect.construct(this._instanceOf, [this._value]);
-                }
-                else if (this._value instanceof ObjectUri_1.ObjectUri) {
-                    // console.log('ObjectProperty', this)
-                    Core_1.Core.log(`Converting objectUri -> dataObject -> instance`);
-                    // console.log(this._instanceOf)
-                    const dao = DataObject_1.DataObject.factory({
-                        properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
-                        uri: this._value,
-                    });
-                    return Reflect.construct(this._instanceOf, [dao]);
-                }
-                else {
-                    Core_1.Core.log(`Returning already existing instance`);
-                    return this._value;
-                }
-            case returnAs.AS_OBJECTURIS:
-            default:
-                return this._value;
+            }
+        }
+        catch (err) {
+            Core_1.Core.error(`Error in ObjectProperty.val() for property ${this._name}: ${err}`);
+            console.log(err);
+            return undefined;
         }
     }
     set(value, setChanged = true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/core",
-  "version": "1.1.18",
+  "version": "1.1.21",
   "description": "Core objects for business apps",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -12,21 +12,21 @@
   "license": "MIT",
   "devDependencies": {
     "@tsconfig/recommended": "^1.0.1",
-    "@types/jest": "^27.0.3",
+    "@types/jest": "^30.0.0",
     "@types/node": "^22.10.1",
     "@types/node-persist": "^3.1.8",
-    "jest": "^27.4.7",
-    "jest-node-exports-resolver": "^1.1.6",
+    "@types/which": "^3.0.4",
+    "jest": "^30.1.1",
     "trace-unhandled": "^2.0.1",
-    "ts-jest": "^27.1.2",
+    "ts-jest": "^29.4.1",
     "ts-node": "^10.4.0",
     "typescript": "^5.1.5"
   },
   "dependencies": {
     "@faker-js/faker": "^7.6.0",
-    "@quatrain/log": "^0.1.3",
-    "loglevel": "^1.9.2",
-    "node-persist": "^4.0.3"
+    "@quatrain/log": "^1.0.2",
+    "node-persist": "^4.0.4",
+    "which": "^5.0.0"
   },
   "scripts": {
     "test-ci": "jest --runInBand",