vrack2-core 0.0.1 → 1.0.0

package/lib/validator/types/NumberType.d.ts

@@ -1,19 +1,54 @@
 import BasicType from "./BasicType";
-import IValidationRule from "../IValidationRule";
 import IValidationSubrule from "../IValidationSubrule";
 export default class NumberType extends BasicType {
     constructor();
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex: number): this;
+    /**
+     * Setting the default value
+    */
     default(def: number): this;
+    /**
+     * Adds an integer check
+    */
     integer(): this;
+    /**
+     * Defines the maximum value for the rule
+    */
     max(max: number): this;
+    /**
+     * Defines the minimal value for the rule
+    */
     min(min: number): this;
-    static validate(obj: {
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
         [key: string]: any;
-    }, key: string, rule: IValidationRule): boolean;
-    protected static checkMax(obj: {
+    }, key: string): boolean;
+    /**
+     *  Checking the maximum value
+    */
+    protected checkMax(obj: {
         [key: string]: any;
     }, key: string, sub: IValidationSubrule): void;
-    protected static checkMin(obj: {
+    /**
+     *  Checking the minimal value
+    */
+    protected checkMin(obj: {
         [key: string]: any;
     }, key: string, sub: IValidationSubrule): void;
+    /**
+     * Integer check
+    */
+    protected checkInteger(obj: {
+        [key: string]: any;
+    }, key: string): void;
 }

package/lib/validator/types/NumberType.js

@@ -14,50 +14,89 @@ class NumberType extends BasicType_1.default {
         super();
         this.rule.type = 'number';
     }
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex) {
+        this.rule.example = ex;
+        return this;
+    }
+    /**
+     * Setting the default value
+    */
     default(def) {
         this.rule.default = def;
         return this;
     }
+    /**
+     * Adds an integer check
+    */
     integer() {
         this.rule.rules.push({ name: 'integer', args: {} });
         return this;
     }
+    /**
+     * Defines the maximum value for the rule
+    */
     max(max) {
         this.rule.rules.push({ name: 'max', args: max });
         return this;
     }
+    /**
+     * Defines the minimal value for the rule
+    */
     min(min) {
-        this.rule.rules.push({ name: 'max', args: min });
+        this.rule.rules.push({ name: 'min', args: min });
         return this;
     }
-    static validate(obj, key, rule) {
-        BasicType_1.default.validate(obj, key, rule);
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
+        this.basicValidate(obj, key);
         if (typeof obj[key] !== 'number')
             throw ErrorManager_1.default.make('VR_IS_NOT_NUMBER', { key });
-        if (!Number.isInteger(obj[key]))
-            throw ErrorManager_1.default.make('VR_NUMBER_INTEGER', {});
-        for (const subrule of rule.rules) {
+        for (const subrule of this.rule.rules) {
             switch (subrule.name) {
+                case 'integer':
+                    this.checkInteger(obj, key);
+                    break;
                 case 'max':
-                    NumberType.checkMax(obj, key, subrule);
+                    this.checkMax(obj, key, subrule);
                     break;
                 case 'min':
-                    NumberType.checkMin(obj, key, subrule);
+                    this.checkMin(obj, key, subrule);
                     break;
             }
         }
         return true;
     }
-    static checkMax(obj, key, sub) {
-        const val = obj[key];
-        if (val.length > sub.args)
+    /**
+     *  Checking the maximum value
+    */
+    checkMax(obj, key, sub) {
+        if (obj[key] > sub.args)
             throw ErrorManager_1.default.make('VR_NUMBER_MAX', { limit: sub.args });
     }
-    static checkMin(obj, key, sub) {
-        const val = obj[key];
-        if (val.length < sub.args)
+    /**
+     *  Checking the minimal value
+    */
+    checkMin(obj, key, sub) {
+        if (obj[key] < sub.args)
             throw ErrorManager_1.default.make('VR_NUMBER_MIN', { limit: sub.args });
     }
+    /**
+     * Integer check
+    */
+    checkInteger(obj, key) {
+        if (!Number.isInteger(obj[key]))
+            throw ErrorManager_1.default.make('VR_NUMBER_INTEGER', {});
+    }
 }
 exports.default = NumberType;
 ErrorManager_1.default.register('Validator', 'pn7B9po1UGRp', 'VR_IS_NOT_NUMBER', 'Value must be a number', {});

package/lib/validator/types/ObjectType.d.ts

@@ -1,18 +1,45 @@
 import BasicType from "./BasicType";
-import IValidationRule from "../IValidationRule";
 import IValidationSubrule from "../IValidationSubrule";
 export default class ObjectType extends BasicType {
     constructor();
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex: any): this;
+    /**
+     * Setting the default value
+    */
+    default(def: object): this;
+    /**
+     * Rule object for defining properties
+     *
+     * Allows you to describe the fields of the required object
+     *
+     * @example
+     * ```ts
+     *  obj: Rule.object().fields({
+     *       bool: Rule.boolean().require().default(true).description('Boolean checkbox')
+     *  }).description('TEst ibject description'),
+     * ```
+    */
     fields(obj: {
         [key: string]: BasicType;
-    }): number;
-    static validate(obj: {
+    }): this;
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
         [key: string]: any;
-    }, key: string, rule: IValidationRule): boolean;
+    }, key: string): boolean;
     /**
      * Validate object fields
     */
-    protected static subValidate(obj: {
+    protected subValidate(obj: {
         [key: string]: any;
     }, key: string, sub: IValidationSubrule): void;
 }

package/lib/validator/types/ObjectType.js

@@ -10,23 +10,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const BasicType_1 = __importDefault(require("./BasicType"));
 const ErrorManager_1 = __importDefault(require("../../errors/ErrorManager"));
 const Validator_1 = __importDefault(require("../Validator"));
-const CoreError_1 = __importDefault(require("../../errors/CoreError"));
 class ObjectType extends BasicType_1.default {
     constructor() {
         super();
         this.rule.type = 'object';
     }
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
+    example(ex) {
+        this.rule.example = ex;
+        return this;
+    }
+    /**
+     * Setting the default value
+    */
+    default(def) {
+        this.rule.default = def;
+        return this;
+    }
+    /**
+     * Rule object for defining properties
+     *
+     * Allows you to describe the fields of the required object
+     *
+     * @example
+     * ```ts
+     *  obj: Rule.object().fields({
+     *       bool: Rule.boolean().require().default(true).description('Boolean checkbox')
+     *  }).description('TEst ibject description'),
+     * ```
+    */
     fields(obj) {
-        return this.rule.rules.push({ name: 'fields', args: obj });
+        this.rule.rules.push({ name: 'fields', args: obj });
+        return this;
     }
-    static validate(obj, key, rule) {
-        BasicType_1.default.validate(obj, key, rule);
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
+        this.basicValidate(obj, key);
         if (typeof obj[key] !== 'object')
             throw ErrorManager_1.default.make('VR_IS_NOT_OBJECT', {});
-        for (const subrule of rule.rules) {
+        for (const subrule of this.rule.rules) {
             switch (subrule.name) {
                 case 'fields':
-                    ObjectType.subValidate(obj, key, subrule);
+                    this.subValidate(obj, key, subrule);
                     break;
             }
         }
@@ -35,12 +69,12 @@ class ObjectType extends BasicType_1.default {
     /**
      * Validate object fields
     */
-    static subValidate(obj, key, sub) {
+    subValidate(obj, key, sub) {
         try {
             Validator_1.default.validate(sub.args, obj[key]);
         }
         catch (error) {
-            if (error instanceof CoreError_1.default) {
+            if (error instanceof Error) {
                 throw ErrorManager_1.default.make('VR_ERROR_OBJECT_FIELDS', { key }).add(error);
             }
         }

package/lib/validator/types/StringType.d.ts

@@ -1,19 +1,44 @@
 import BasicType from "./BasicType";
-import IValidationRule from "../IValidationRule";
 import IValidationSubrule from "../IValidationSubrule";
 export default class StringType extends BasicType {
     constructor();
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
     example(ex: string): this;
+    /**
+     * Setting the default value
+    */
     default(def: string): this;
+    /**
+     * Sets the maximum length of the string
+    */
     maxLength(max: number): this;
+    /**
+     * Sets the minimum length of the string
+    */
     minLength(min: number): this;
-    static validate(obj: {
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj: {
         [key: string]: any;
-    }, key: string, rule: IValidationRule): boolean;
-    protected static checkMaxLength(obj: {
+    }, key: string): boolean;
+    /**
+     * Checking the maximum string length
+    */
+    protected checkMaxLength(obj: {
         [key: string]: any;
     }, key: string, sub: IValidationSubrule): void;
-    protected static checkMinLength(obj: {
+    /**
+     * Checking the minimum string length
+    */
+    protected checkMinLength(obj: {
         [key: string]: any;
     }, key: string, sub: IValidationSubrule): void;
 }

package/lib/validator/types/StringType.js

@@ -14,44 +14,70 @@ class StringType extends BasicType_1.default {
         super();
         this.rule.type = 'string';
     }
+    /**
+     * Example of a valid value for this rule
+     *
+     * @param ex Example valid value
+    */
     example(ex) {
         this.rule.example = ex;
         return this;
     }
+    /**
+     * Setting the default value
+    */
     default(def) {
         this.rule.default = def;
         return this;
     }
+    /**
+     * Sets the maximum length of the string
+    */
     maxLength(max) {
         this.rule.rules.push({ name: 'maxLength', args: max });
         return this;
     }
+    /**
+     * Sets the minimum length of the string
+    */
     minLength(min) {
         this.rule.rules.push({ name: 'minLength', args: min });
         return this;
     }
-    static validate(obj, key, rule) {
-        BasicType_1.default.validate(obj, key, rule);
+    /**
+     * Method of validation of this type
+     *
+     * @param obj Validation object
+     * @param key Key for getting value from object
+    */
+    validate(obj, key) {
+        this.basicValidate(obj, key);
         if (typeof obj[key] !== 'string')
             throw ErrorManager_1.default.make('VR_IS_NOT_STRING', { key });
-        for (const subrule of rule.rules) {
+        for (const subrule of this.rule.rules) {
             switch (subrule.name) {
                 case 'maxLength':
-                    StringType.checkMaxLength(obj, key, subrule);
+                    this.checkMaxLength(obj, key, subrule);
                     break;
                 case 'minLength':
-                    StringType.checkMinLength(obj, key, subrule);
+                    this.checkMinLength(obj, key, subrule);
                     break;
             }
         }
         return true;
     }
-    static checkMaxLength(obj, key, sub) {
+    /**
+     * Checking the maximum string length
+    */
+    checkMaxLength(obj, key, sub) {
         const val = obj[key];
         if (val.length >= sub.args)
             throw ErrorManager_1.default.make('VR_STRING_MAX_LENGTH', { limit: sub.args, key });
     }
-    static checkMinLength(obj, key, sub) {
+    /**
+     * Checking the minimum string length
+    */
+    checkMinLength(obj, key, sub) {
         const val = obj[key];
         if (val.length <= sub.args)
             throw ErrorManager_1.default.make('VR_STRING_MIN_LENGTH', { limit: sub.args, key });

package/package.json

@@ -1,26 +1,27 @@
 {
   "name": "vrack2-core",
-  "version": "0.0.1",
-  "description": "VRack2 core utils",
+  "version": "1.0.0",
+  "description": "Фреймворк для создания событийно-ориентированных сервисов на JavaScript/TypeScript",
   "main": "./lib/index",
-  "scripts": {
-    "test": "node ./lib/test.js"
-  },
+  "scripts": {},
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.com/vrack/core-utils.git"
+    "url": "git+https://github.com/VRack2/vrack2-core.git"
   },
   "author": "Boris Bobylev",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "bugs": {
-    "url": "https://gitlab.com/vrack/core-utils/issues"
+    "url": "https://github.com/VRack2/vrack2-core/issues"
   },
-  "homepage": "https://gitlab.com/vrack/core-utils#readme",
+  "homepage": "https://github.com/VRack2/vrack2-core#readme",
   "devDependencies": {
     "@types/node": "^18.11.17",
     "@typescript-eslint/eslint-plugin": "^5.45.0",
     "@typescript-eslint/parser": "^5.45.0",
     "eslint": "^8.29.0",
     "typescript": "^4.9.3"
+  },
+  "dependencies": {
+    "vrack-db": "^3.0.1"
   }
 }

package/src/Bootstrap.ts

@@ -0,0 +1,122 @@
+/*
+ * Copyright © 2024 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import { ErrorManager, Rule } from '.';
+import BootClass from './boot/BootClass';
+import Container from './Container';
+import ImportManager from './ImportManager';
+
+
+/**
+ * Defines a list of bootstrap classes to load
+ *
+ * {
+ *   'ClassID': { 
+ *      path: 'importclass.path', 
+ *      options: {} 
+ *    }
+ * }
+*/
+export interface IBootListConfig {
+    [key: string]: {
+        /** VRack-style bootclass path */
+        path: string,
+        /** Options for this bootclass */
+        options: { [key: string]: any },
+    }
+}
+
+ErrorManager.register('Bootstrap', 'yNHeX5fwDH5P', 'BTSP_CLASS_ID_NOT_FOUND',
+    'Bootstrap class id not found', {
+    id: Rule.string().description('Class identify')
+})
+
+ErrorManager.register('Bootstrap', 'ack6kwHSBtcf', 'BTSP_INSTANCE_OF_INCORRECT',
+    'Bootstrap class id is not a class defined by check', {
+    id: Rule.string().description('Class identify')
+})
+
+ErrorManager.register('Bootstrap', 'DMloqbZG9J36', 'BTSP_MUST_BE_BOOTCLASS',
+    'The class must be inherited from BootClass', {
+    path: Rule.string().description('Class path')
+})
+
+/**
+ * Bootstrap is a class for running bootclasses, 
+ * which should work above Container and is required 
+ * for Container to work. 
+ * 
+ * For example DeviceManager class - it is 
+ * necessary for Container to work but it must be 
+ * replaceable and customizable. 
+ * 
+ * Bootstrap handles the loading of DeviceManager and 
+ * provides the ability to work with it from Container. 
+ * Bootclasses are a forced exception. 
+ * 
+ * This is the minimum code that is needed to do everything
+ * else in the style of VRack service.
+ * 
+*/
+export default class Bootstrap {
+
+    /**
+     * Loaded class list
+     * 
+     * ```ts
+     * { UniqueID: Classinstance }
+     * ```
+    */
+    protected loaded: { [key: string]: BootClass } = {}
+
+    /**
+     * List of downloadable classes and their settings
+     * 
+     * @see IBootListConfig
+    */
+    protected config: IBootListConfig
+
+    constructor(config: IBootListConfig){
+        this.config = config
+    }
+
+    /**
+     * Load bootclasses
+     * 
+     * Bootclass has some analogy to devices within VRack services.
+     * They also have options, process, processPromise methods similar to devices
+     * 
+     * @param Container Container for which loading is performed 
+    */
+    async loadBootList(Container: Container) {
+        for (const cn in this.config) {
+            const conf = this.config[cn]
+            const ExClass = await ImportManager.importClass(conf.path)
+            this.loaded[cn] = new ExClass(cn, ImportManager.importClassName(conf.path), Container, conf.options) 
+            if (!(this.loaded[cn] instanceof  BootClass)) {
+                throw ErrorManager.make('BTSP_INSTANCE_OF_INCORRECT', { path: conf.path }) 
+            }
+        }
+        for (const bc in this.loaded) this.loaded[bc].process()
+        for (const bc in this.loaded) await this.loaded[bc].processPromise()
+    }
+
+    /**
+     * Getting an initialized class
+     * 
+     * @example 
+     * ```ts
+     * this.Container.Bootstrap.getBootClass('DeviceMetrics', DeviceMetrics) as DeviceMetrics
+     * ```
+     * 
+     * @param id class identifier that was specified in the list
+     * @param cs Class to be compared with when receiving
+    */
+    getBootClass (id: string, cs: any ) {
+        if (!this.loaded[id]) throw ErrorManager.make('BTSP_CLASS_ID_NOT_FOUND', { id })
+        if (!(this.loaded[id] instanceof cs)) throw ErrorManager.make('BTSP_INSTANCE_OF_INCORRECT', { id })
+        return this.loaded[id] as typeof cs
+    }
+}