vrack2-core 0.0.1

package/lib/service/Device.js

@@ -0,0 +1,191 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDeviceMessageTypes = void 0;
+/**
+ * Интерфейс списка исходящих портов устройства
+// */
+// export interface IDeviceOutputList {
+//     [index: string]: OutputPort;
+// }
+// /**
+//  * Интерфейс списка входящих портов устройства
+// */
+// export interface IDeviceInputList {
+//     [index: string]: InputPort;
+// }
+var EDeviceMessageTypes;
+(function (EDeviceMessageTypes) {
+    EDeviceMessageTypes["terminal"] = "terminal";
+    EDeviceMessageTypes["info"] = "info";
+    EDeviceMessageTypes["error"] = "error";
+    EDeviceMessageTypes["event"] = "event";
+    EDeviceMessageTypes["action"] = "action";
+    EDeviceMessageTypes["alert"] = "alert";
+})(EDeviceMessageTypes = exports.EDeviceMessageTypes || (exports.EDeviceMessageTypes = {}));
+class Device {
+    constructor(id, type, Container) {
+        /** Входящие (назначаемые сверху) параметры устройства */
+        this.options = {};
+        /**
+         * Shares данные устройства (обновляемые данные)
+         * используется с методом `this.render`
+         *
+         * @see render()
+         * */
+        this.shares = {};
+        /**
+         *
+        */
+        this.storage = {};
+        this.id = id;
+        this.type = type;
+        this.Container = Container;
+        this.ports = {
+            input: {},
+            output: {}
+        };
+    }
+    /**
+     * Short device description
+     *
+     * @return {string} Device description
+     * */
+    description() {
+        return '';
+    }
+    /** Список Action-методов устройства */
+    actions() { return {}; }
+    /**
+     * Определение списка параметров устройства
+     *
+     * @returns {Array<Rule>}
+     * */
+    checkOptions() { return {}; }
+    /**
+     * Prepare options
+     *
+     * this method call before validating options
+    */
+    prepareOptions() { return; }
+    inputs() { return {}; }
+    outputs() { return {}; }
+    /**
+     * Метод является входной точкой для начала инициализации устройства
+     *
+     * Устройство пройдет только следующие этапы создания устройства:
+     *
+     * - Создания класса
+     * - Назначение праметров устройства
+     *
+     * Необходимо использовать для назначения функций вызова динамических портов
+     * устройства.
+    */
+    preProcess() { return; }
+    /**
+     * Метод является входной точкой для начала работы устройства
+     *
+     * Устройство пройдет следующие этапы создания устройства:
+     *
+     * - Создания класса
+     * - Назначение праметров устройства
+     * - Создание портов
+     * - Назначение функций вызова
+     * - Создание соединений между устройствами
+     * - Линковка Shares устройства
+     *
+     * Необходимо использовать для осуществления начала основной работы устройства
+     * например, инициализация подключений, создание таймеров и тп.
+    */
+    process() { return; }
+    /**
+     * По аналогии с `process` но асинхронный, загрузчик будет ждать выполнения всех
+     * методов `processPromise` всех устройств.
+     *
+     * Используется, когда есть необходимость перед запуском стойки выполнить
+     * и дождаться выполнения асинхронного кода (инициализация некоторых файловых баз данных и тп)
+    */
+    processPromise() {
+        return __awaiter(this, void 0, void 0, function* () { return; });
+    }
+    stop() { return; }
+    stopPromise() {
+        return __awaiter(this, void 0, void 0, function* () { return; });
+    }
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к постановке в очередь устройства на обновление данных `Shares`
+    */
+    render() { return this.event('device.render', 'shares', this.shares); }
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к сохранение в локальное файловое хранилище данных `Storage`
+    */
+    save() { return this.event('device.save', 'storage', this.storage); }
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке сообщению об ошибке
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Непосредственно объект ошибки, или объект который поможет разобратся в случившейся ситуации
+    */
+    error(data, trace) { return this.event('device.error', data, trace); }
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке информационного сообщения
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    notify(data, trace) { return this.event('device.notify', data, trace); }
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке оповещения
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    alert(data, trace) { return this.event('device.alert', data, trace); }
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке отладочной информации
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    terminal(data, trace) { return this.event('device.terminal', data, trace); }
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке сообщения о событии
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    event(type, data, trace) {
+        const nEvent = { id: this.id, data, trace };
+        return this.Container.emit(type, nEvent);
+    }
+    /**
+     * Сообщает стойке, о том, что устройство не может дальше работать
+     * и произошла критическая ошибка
+     *
+     * Требует создание ошибки устройства DeviceError
+     *
+    */
+    terminate(error, action) {
+        return this.event('device.terminate', action, error);
+    }
+}
+exports.default = Device;

package/lib/service/DeviceConnect.d.ts

@@ -0,0 +1,21 @@
+import DevicePort from "./DevicePort";
+/**
+ * Класс для соедиения портов устройств
+ *
+*/
+export default class {
+    outputLink: DevicePort;
+    inputLink: DevicePort;
+    /**
+     * Инициализация соединения, требует 2 порта которые привязаны
+     * к устройствам
+     *
+    */
+    constructor(output: DevicePort, input: DevicePort);
+    /**
+     * Вызов входящего порта при вызове соединения
+     *
+     * @param {any} data Данные
+    */
+    push(data: any): any;
+}

package/lib/service/DeviceConnect.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Класс для соедиения портов устройств
+ *
+*/
+class default_1 {
+    /**
+     * Инициализация соединения, требует 2 порта которые привязаны
+     * к устройствам
+     *
+    */
+    constructor(output, input) {
+        this.outputLink = output;
+        this.inputLink = input;
+        this.outputLink.addConnection(this);
+        this.inputLink.addConnection(this);
+    }
+    /**
+     * Вызов входящего порта при вызове соединения
+     *
+     * @param {any} data Данные
+    */
+    push(data) {
+        return this.inputLink.push(data);
+    }
+}
+exports.default = default_1;

package/lib/service/DevicePort.d.ts

@@ -0,0 +1,24 @@
+import IPort from "../ports/IPort";
+import DeviceConnect from "./DeviceConnect";
+/**
+ * Класс для реализации порта устройства
+ * Порт может быть как входящий так и исходящий
+*/
+export default class DevicePort {
+    connected: boolean;
+    connections: Array<DeviceConnect>;
+    id: string;
+    type: string;
+    required: boolean;
+    constructor(id: string, port: IPort);
+    /**
+     * Добавление связи в порт
+    */
+    addConnection(connection: DeviceConnect): void;
+    /**
+     * Вызов входящего порта при вызове соединения
+     *
+     * @param {any} data Данные
+    */
+    push(data: any): any;
+}

package/lib/service/DevicePort.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Класс для реализации порта устройства
+ * Порт может быть как входящий так и исходящий
+*/
+class DevicePort {
+    constructor(id, port) {
+        this.connected = false;
+        this.connections = [];
+        this.id = id;
+        this.type = port.type;
+        this.required = port.required;
+    }
+    /**
+     * Добавление связи в порт
+    */
+    addConnection(connection) {
+        this.connected = true;
+        this.connections.push(connection);
+    }
+    /**
+     * Вызов входящего порта при вызове соединения
+     *
+     * @param {any} data Данные
+    */
+    push(data) {
+        if (this.connected) {
+            if (this.connections.length === 1)
+                return this.connections[0].push(data);
+            for (const conn of this.connections) {
+                conn.push(data);
+            }
+        }
+    }
+}
+exports.default = DevicePort;

package/lib/service/IDeviceEvent.d.ts

@@ -0,0 +1,5 @@
+export default interface IDeviceEvent {
+    id: string;
+    data: string;
+    trace: any;
+}

package/lib/service/IDeviceEvent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/test.d.ts

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

package/lib/test.js

@@ -0,0 +1,58 @@
+"use strict";
+// import Action from "./rack/Action";
+// import Port from "./rack/Port";
+// import Rule from "./validator/Rule";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Rule_1 = __importDefault(require("./validator/Rule"));
+const Validator_1 = __importDefault(require("./validator/Validator"));
+Rule_1.default.array().require();
+// class Device {
+//     options (){
+//         return {
+//             test: Rule.string().default('Default string').description('Test string'),
+//             list: Rule.Array().objects({
+//                 name: Rule.string(),
+//                 value: Rule.number()
+//             })
+//         }
+//     }
+//     outputs(){
+//         return {
+//             'test.output%d': Port.standart().dynamic(5),
+//         }
+//     }
+//     inputs(){
+//         return {
+//             'test.output%d': Port.return().dynamic(5),
+//         }
+//     }
+//     actions(){
+//         return {
+//             'test.action': Action.global().rules({
+//                 test: Rule.string().default('Default string').description('Test string'),
+//             }).description('Test action for call global')
+//         }
+//     }
+//     init(){
+//     }
+//     process(){
+//     }
+//     async processPromise(){
+//     }
+// }
+const rules = {
+    obj: Rule_1.default.object().require().description('Test validation object'),
+    str: Rule_1.default.string().require().minLength(5),
+    arr: Rule_1.default.array().require(),
+    num: Rule_1.default.number().require().integer().description('integer test')
+};
+const data = {
+    obj: {},
+    str: 'qwe4',
+    arr: [],
+    num: 1.23
+};
+Validator_1.default.validate(rules, data);

package/lib/validator/IValidationProblem.d.ts

@@ -0,0 +1,8 @@
+import IValidationRule from "./IValidationRule";
+export default interface IValidationProblem {
+    type: string;
+    code: string;
+    description: string;
+    rule: IValidationRule;
+    arg: any;
+}

package/lib/validator/IValidationProblem.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/validator/IValidationRule.d.ts

@@ -0,0 +1,9 @@
+import IValidationSubrule from "./IValidationSubrule";
+export default interface IValidationRule {
+    type: string;
+    require: boolean;
+    default: any;
+    rules: Array<IValidationSubrule>;
+    example: any;
+    description: string;
+}

package/lib/validator/IValidationRule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/validator/IValidationSubrule.d.ts

@@ -0,0 +1,4 @@
+export default interface IValidationSubrule {
+    name: string;
+    args: any;
+}

package/lib/validator/IValidationSubrule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/validator/Rule.d.ts

@@ -0,0 +1,12 @@
+import ArrayType from "./types/ArrayType";
+import NumberType from "./types/NumberType";
+import ObjectType from "./types/ObjectType";
+import StringType from "./types/StringType";
+/**
+*/
+export default class Rule {
+    static number(): NumberType;
+    static string(): StringType;
+    static object(): ObjectType;
+    static array(): ArrayType;
+}

package/lib/validator/Rule.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ArrayType_1 = __importDefault(require("./types/ArrayType"));
+const NumberType_1 = __importDefault(require("./types/NumberType"));
+const ObjectType_1 = __importDefault(require("./types/ObjectType"));
+const StringType_1 = __importDefault(require("./types/StringType"));
+/**
+*/
+class Rule {
+    static number() {
+        return new NumberType_1.default();
+    }
+    static string() {
+        return new StringType_1.default();
+    }
+    static object() {
+        return new ObjectType_1.default();
+    }
+    static array() {
+        return new ArrayType_1.default();
+    }
+}
+exports.default = Rule;

package/lib/validator/Validator.d.ts

@@ -0,0 +1,14 @@
+import BasicType from "./types/BasicType";
+import CoreError from "../errors/CoreError";
+import IValidationProblem from './IValidationProblem';
+import IValidationRule from "./IValidationRule";
+export default class Validator {
+    static validate(rules: {
+        [key: string]: BasicType;
+    }, data: {
+        [key: string]: any;
+    }): boolean;
+    private static makeError;
+    protected static makeProblem(err: CoreError, key: string, rule: IValidationRule): IValidationProblem;
+    private static getClass;
+}

package/lib/validator/Validator.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ErrorManager_1 = __importDefault(require("../errors/ErrorManager"));
+const ArrayType_1 = __importDefault(require("./types/ArrayType"));
+const NumberType_1 = __importDefault(require("./types/NumberType"));
+const ObjectType_1 = __importDefault(require("./types/ObjectType"));
+const StringType_1 = __importDefault(require("./types/StringType"));
+const CoreError_1 = __importDefault(require("../errors/CoreError"));
+ErrorManager_1.default.register('Validator', 'VXLeMLVnIXGf', 'VR_TYPE_NOT_EXISTS', 'Type not exists', {});
+ErrorManager_1.default.register('Validator', 'X1UP4P2HRHWd', 'VR_NOT_PASS', 'Validation error - data not pass', {});
+class Validator {
+    static validate(rules, data) {
+        const problems = [];
+        for (const key of Object.keys(rules)) {
+            const rule = rules[key];
+            const ruleRaw = rule.export();
+            const cs = Validator.getClass(ruleRaw.type);
+            try {
+                cs.validate(data, key, ruleRaw);
+            }
+            catch (err) {
+                if (err instanceof CoreError_1.default)
+                    problems.push(Validator.makeProblem(err, key, ruleRaw));
+            }
+        }
+        if (problems.length)
+            Validator.makeError(problems);
+        return true;
+    }
+    static makeError(eList) {
+        throw ErrorManager_1.default.make('VR_NOT_PASS', {
+            problems: eList
+        });
+    }
+    static makeProblem(err, key, rule) {
+        return {
+            type: err.vShort, code: err.vCode, description: err.message, rule, arg: err.vAdd
+        };
+    }
+    static getClass(cn) {
+        switch (cn) {
+            case 'string': return StringType_1.default;
+            case 'number': return NumberType_1.default;
+            case 'object': return ObjectType_1.default;
+            case 'array': return ArrayType_1.default;
+        }
+        throw ErrorManager_1.default.make('VR_TYPE_NOT_EXISTS', { type: cn });
+    }
+}
+exports.default = Validator;

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

@@ -0,0 +1,14 @@
+import IValidationRule from "../IValidationRule";
+import BasicType from "./BasicType";
+import IValidationSubrule from "../IValidationSubrule";
+export default class ArrayType extends BasicType {
+    constructor();
+    default(def: Array<any>): this;
+    content(t: BasicType): this;
+    static validate(obj: {
+        [key: string]: any;
+    }, key: string, rule: IValidationRule): boolean;
+    protected static checkContent(obj: {
+        [key: string]: any;
+    }, key: string, sub: IValidationSubrule): void;
+}

package/lib/validator/types/ArrayType.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 ArrayType extends BasicType_1.default {
+    constructor() {
+        super();
+        this.rule.type = 'array';
+    }
+    default(def) {
+        this.rule.default = def;
+        return this;
+    }
+    content(t) {
+        this.rule.rules.push({ name: 'contain', args: t });
+        return this;
+    }
+    static validate(obj, key, rule) {
+        BasicType_1.default.validate(obj, key, rule);
+        if (!Array.isArray(obj[key]))
+            throw ErrorManager_1.default.make('VR_IS_NOT_ARRAY', {});
+        for (const subrule of rule.rules) {
+            switch (subrule.name) {
+                case 'fields':
+                    ArrayType.checkContent(obj, key, subrule);
+                    break;
+            }
+        }
+        return true;
+    }
+    static checkContent(obj, key, sub) {
+        const sw = { value: undefined };
+        const tr = { value: sub.args };
+        for (const index of obj[key]) {
+            sw.value = obj[key][index];
+            try {
+                Validator_1.default.validate(tr, sw);
+            }
+            catch (error) {
+                if (error instanceof CoreError_1.default) {
+                    throw ErrorManager_1.default.make('VR_ARRAY_CONTENT_ERROR', { index }).add(error);
+                }
+            }
+        }
+    }
+}
+exports.default = ArrayType;
+ErrorManager_1.default.register('Validator', '3U9s3ZsTH6FA', 'VR_IS_NOT_ARRAY', 'Value must be a array', {});
+ErrorManager_1.default.register('Validator', 'Eg9cIXlxi1yP', 'VR_ARRAY_CONTENT_ERROR', 'Validation error inside the array data', {});

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

@@ -0,0 +1,18 @@
+import IValidationRule from "../IValidationRule";
+export default class BasicType {
+    protected rule: IValidationRule;
+    constructor();
+    require(): this;
+    example(ex: any): this;
+    description(desc: string): this;
+    export(): IValidationRule;
+    static validate(obj: {
+        [key: string]: any;
+    }, key: string, rule: IValidationRule): boolean;
+    protected static checkDefault(obj: {
+        [key: string]: any;
+    }, key: string, rule: IValidationRule): void;
+    protected static checkRequire(obj: {
+        [key: string]: any;
+    }, key: string, rule: IValidationRule): void;
+}