vrack2-core 0.0.1

package/lib/errors/ErrorManager.js

@@ -0,0 +1,84 @@
+"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 CoreError_1 = __importDefault(require("./CoreError"));
+/**
+ * Класс является точкой входа для инициализации исключений
+ *
+ * Было принято решение вместо кучи мелких однотипных файлов сделать один класс
+ * со стандартным функционалом
+ */
+class ErrorManager {
+    constructor() {
+        this.registeredList = [];
+    }
+    /**
+     * Регистрирует тип ошибки компонента
+     *
+     * Перед тем как менеджер ошибок может создать ошибки, необходимо зарегистрировать ее тип.
+     *
+     * @param {string} name Название компонента
+     * @param {string} code Код ошибки
+     * @param {string} short Короткий код ошибки
+     * @param {string} description Описание ошибки
+     *
+    */
+    register(name, code, short, description, rules = {}) {
+        const reg1 = this.getRegistered(code);
+        const reg2 = this.getRegistered(short);
+        if (reg1 !== null || reg2 !== null)
+            throw this.make('EM_CODE_EXISTS', { code, short });
+        const nr = { name, code, short, description, rules };
+        this.registeredList.push(nr);
+    }
+    /**
+     * Создание ошибки
+     *
+     *
+     *
+     * @param {string} short
+    */
+    make(short, additional = {}) {
+        const reg = this.getRegistered(short);
+        if (reg === null)
+            throw this.make('EM_CODE_NOT_FOUND');
+        const ne = new CoreError_1.default(reg.name, reg.description, reg.code, reg.short);
+        ne.vAdd = Object.keys(additional);
+        return Object.assign(ne, additional);
+    }
+    /**
+     * Преобразует обычную ошибку в ошибку VRack
+     *
+     * @param {Error} error Ошибка для преобразования
+    */
+    convert(error) {
+        if (error.vError)
+            return error;
+        const ne = this.make('EM_ERROR_CONVERT');
+        ne.import(error);
+        return ne;
+    }
+    /**
+     * Возвращает тип ошибки или null
+     *
+     * @param {string} short Короткий код ошибки или код ошибки поиска
+    */
+    getRegistered(short) {
+        for (const registered of this.registeredList) {
+            if (registered.code === short || registered.short === short)
+                return registered;
+        }
+        return null;
+    }
+}
+const GlobalErrorManager = new ErrorManager();
+GlobalErrorManager.register('ErrorManager', 'NcZIb9QvQRcq', 'EM_CODE_EXISTS', 'This code already exists');
+GlobalErrorManager.register('ErrorManager', 'uLYv4mE1Yo50', 'EM_CODE_NOT_FOUND', 'No such error found');
+GlobalErrorManager.register('ErrorManager', 'RIl3BUrxWOzP', 'EM_ERROR_CONVERT', 'Converted error');
+exports.default = GlobalErrorManager;

package/lib/index.d.ts

@@ -0,0 +1,19 @@
+export { default as ErrorManager } from './errors/ErrorManager';
+export { default as CoreError } from './errors/CoreError';
+export { default as Rule } from './validator/Rule';
+export { default as Validator } from './validator/Validator';
+export { default as IValidationProblem } from './validator/IValidationProblem';
+export { default as IValidationRule } from './validator/IValidationRule';
+export { default as IValidationSubrule } from './validator/IValidationSubrule';
+export { default as ImportManager } from './ImportManager';
+export { default as DeviceManager } from './DeviceManager';
+export { default as Container } from './Container';
+export { default as MainProcess } from './MainProcess';
+export { default as Action } from './actions/Action';
+export { default as Device } from './service/Device';
+export { default as DeviceConnect } from './service/DeviceConnect';
+export { default as DevicePort } from './service/DevicePort';
+export { default as Port } from './ports/Port';
+export * from './service/Device';
+export * from './service/DeviceConnect';
+export * from './service/DevicePort';

package/lib/index.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Port = exports.DevicePort = exports.DeviceConnect = exports.Device = exports.Action = exports.MainProcess = exports.Container = exports.DeviceManager = exports.ImportManager = exports.Validator = exports.Rule = exports.CoreError = exports.ErrorManager = void 0;
+/* ---------------- VALIDATOR EXPORT ------------------- */
+var ErrorManager_1 = require("./errors/ErrorManager");
+Object.defineProperty(exports, "ErrorManager", { enumerable: true, get: function () { return __importDefault(ErrorManager_1).default; } });
+var CoreError_1 = require("./errors/CoreError");
+Object.defineProperty(exports, "CoreError", { enumerable: true, get: function () { return __importDefault(CoreError_1).default; } });
+var Rule_1 = require("./validator/Rule");
+Object.defineProperty(exports, "Rule", { enumerable: true, get: function () { return __importDefault(Rule_1).default; } });
+var Validator_1 = require("./validator/Validator");
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return __importDefault(Validator_1).default; } });
+/* ---------------- BASE OF VRACK ------------------- */
+var ImportManager_1 = require("./ImportManager");
+Object.defineProperty(exports, "ImportManager", { enumerable: true, get: function () { return __importDefault(ImportManager_1).default; } });
+var DeviceManager_1 = require("./DeviceManager");
+Object.defineProperty(exports, "DeviceManager", { enumerable: true, get: function () { return __importDefault(DeviceManager_1).default; } });
+var Container_1 = require("./Container");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return __importDefault(Container_1).default; } });
+var MainProcess_1 = require("./MainProcess");
+Object.defineProperty(exports, "MainProcess", { enumerable: true, get: function () { return __importDefault(MainProcess_1).default; } });
+var Action_1 = require("./actions/Action");
+Object.defineProperty(exports, "Action", { enumerable: true, get: function () { return __importDefault(Action_1).default; } });
+var Device_1 = require("./service/Device");
+Object.defineProperty(exports, "Device", { enumerable: true, get: function () { return __importDefault(Device_1).default; } });
+var DeviceConnect_1 = require("./service/DeviceConnect");
+Object.defineProperty(exports, "DeviceConnect", { enumerable: true, get: function () { return __importDefault(DeviceConnect_1).default; } });
+var DevicePort_1 = require("./service/DevicePort");
+Object.defineProperty(exports, "DevicePort", { enumerable: true, get: function () { return __importDefault(DevicePort_1).default; } });
+var Port_1 = require("./ports/Port");
+Object.defineProperty(exports, "Port", { enumerable: true, get: function () { return __importDefault(Port_1).default; } });
+__exportStar(require("./service/Device"), exports);
+__exportStar(require("./service/DeviceConnect"), exports);
+__exportStar(require("./service/DevicePort"), exports);

package/lib/ports/BasicPort.d.ts

@@ -0,0 +1,11 @@
+import BasicType from "../validator/types/BasicType";
+import ILocalPort from "./ILocalPort";
+import IPort from "./IPort";
+export default class BasicPort {
+    protected port: ILocalPort;
+    constructor();
+    dynamic(count: number): this;
+    requirement(req: BasicType): this;
+    description(des: string): this;
+    export(): IPort;
+}

package/lib/ports/BasicPort.js

@@ -0,0 +1,49 @@
+"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("../validator/types/BasicType"));
+class BasicPort {
+    constructor() {
+        this.port = {
+            type: 'unknown',
+            description: '',
+            required: false,
+            dynamic: false,
+            count: 0
+        };
+    }
+    dynamic(count) {
+        this.port.count = count;
+        this.port.dynamic = true;
+        return this;
+    }
+    requirement(req) {
+        this.port.requirement = req;
+        return this;
+    }
+    description(des) {
+        this.port.description = des;
+        return this;
+    }
+    export() {
+        const nPort = {
+            type: this.port.type,
+            description: this.port.description,
+            required: this.port.required,
+            dynamic: this.port.dynamic,
+            count: this.port.count
+        };
+        if (this.port.requirement instanceof BasicType_1.default)
+            nPort.requirement = this.port.requirement.export();
+        if (this.port.return instanceof BasicType_1.default)
+            nPort.return = this.port.return.export();
+        return nPort;
+    }
+}
+exports.default = BasicPort;

package/lib/ports/ILocalPort.d.ts

@@ -0,0 +1,10 @@
+import BasicType from "../validator/types/BasicType";
+export default interface ILocalPort {
+    type: string;
+    requirement?: BasicType;
+    return?: BasicType;
+    description: string;
+    required: boolean;
+    dynamic: boolean;
+    count: number;
+}

package/lib/ports/ILocalPort.js

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

package/lib/ports/IPort.d.ts

@@ -0,0 +1,10 @@
+import IValidationRule from "../validator/IValidationRule";
+export default interface IPort {
+    type: string;
+    requirement?: IValidationRule;
+    return?: IValidationRule;
+    description: string;
+    required: boolean;
+    dynamic: boolean;
+    count: number;
+}

package/lib/ports/IPort.js

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

package/lib/ports/Port.d.ts

@@ -0,0 +1,6 @@
+import ReturnPort from "./ReturnPort";
+import StandartPort from "./StandartPort";
+export default class Port {
+    static standart(): StandartPort;
+    static return(): ReturnPort;
+}

package/lib/ports/Port.js

@@ -0,0 +1,20 @@
+"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 ReturnPort_1 = __importDefault(require("./ReturnPort"));
+const StandartPort_1 = __importDefault(require("./StandartPort"));
+class Port {
+    static standart() {
+        return new StandartPort_1.default();
+    }
+    static return() {
+        return new ReturnPort_1.default();
+    }
+}
+exports.default = Port;

package/lib/ports/ReturnPort.d.ts

@@ -0,0 +1,6 @@
+import BasicType from "../validator/types/BasicType";
+import BasicPort from "./BasicPort";
+export default class ReturnPort extends BasicPort {
+    constructor();
+    return(req: BasicType): this;
+}

package/lib/ports/ReturnPort.js

@@ -0,0 +1,21 @@
+"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 BasicPort_1 = __importDefault(require("./BasicPort"));
+class ReturnPort extends BasicPort_1.default {
+    constructor() {
+        super();
+        this.port.type = 'return';
+    }
+    return(req) {
+        this.port.return = req;
+        return this;
+    }
+}
+exports.default = ReturnPort;

package/lib/ports/StandartPort.d.ts

@@ -0,0 +1,4 @@
+import BasicPort from "./BasicPort";
+export default class StandartPort extends BasicPort {
+    constructor();
+}

package/lib/ports/StandartPort.js

@@ -0,0 +1,17 @@
+"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 BasicPort_1 = __importDefault(require("./BasicPort"));
+class StandartPort extends BasicPort_1.default {
+    constructor() {
+        super();
+        this.port.type = 'standart';
+    }
+}
+exports.default = StandartPort;

package/lib/service/Device.d.ts

@@ -0,0 +1,175 @@
+import BasicType from "../validator/types/BasicType";
+import Container from '../Container';
+import BasicAction from "../actions/BasicAction";
+import BasicPort from "../ports/BasicPort";
+import DevicePort from "./DevicePort";
+/**
+ * Интерфейс списка исходящих портов устройства
+// */
+export declare enum EDeviceMessageTypes {
+    terminal = "terminal",
+    info = "info",
+    error = "error",
+    event = "event",
+    action = "action",
+    alert = "alert"
+}
+interface IDevicePorts {
+    input: {
+        [key: string]: DevicePort;
+    };
+    output: {
+        [key: string]: DevicePort;
+    };
+}
+export default class Device {
+    /** Идентификатор устройства */
+    id: string;
+    type: string;
+    ports: IDevicePorts;
+    /** Экземпляр класса виртуальной стойки */
+    Container: Container;
+    /** Входящие (назначаемые сверху) параметры устройства */
+    options: {
+        [key: string]: any;
+    };
+    constructor(id: string, type: string, Container: Container);
+    /**
+     * Short device description
+     *
+     * @return {string} Device description
+     * */
+    description(): string;
+    /**
+     * Shares данные устройства (обновляемые данные)
+     * используется с методом `this.render`
+     *
+     * @see render()
+     * */
+    shares: any;
+    /**
+     *
+    */
+    storage: any;
+    /** Список Action-методов устройства */
+    actions(): {
+        [key: string]: BasicAction;
+    };
+    /**
+     * Определение списка параметров устройства
+     *
+     * @returns {Array<Rule>}
+     * */
+    checkOptions(): {
+        [key: string]: BasicType;
+    };
+    /**
+     * Prepare options
+     *
+     * this method call before validating options
+    */
+    prepareOptions(): void;
+    inputs(): {
+        [key: string]: BasicPort;
+    };
+    outputs(): {
+        [key: string]: BasicPort;
+    };
+    /**
+     * Метод является входной точкой для начала инициализации устройства
+     *
+     * Устройство пройдет только следующие этапы создания устройства:
+     *
+     * - Создания класса
+     * - Назначение праметров устройства
+     *
+     * Необходимо использовать для назначения функций вызова динамических портов
+     * устройства.
+    */
+    preProcess(): void;
+    /**
+     * Метод является входной точкой для начала работы устройства
+     *
+     * Устройство пройдет следующие этапы создания устройства:
+     *
+     * - Создания класса
+     * - Назначение праметров устройства
+     * - Создание портов
+     * - Назначение функций вызова
+     * - Создание соединений между устройствами
+     * - Линковка Shares устройства
+     *
+     * Необходимо использовать для осуществления начала основной работы устройства
+     * например, инициализация подключений, создание таймеров и тп.
+    */
+    process(): void;
+    /**
+     * По аналогии с `process` но асинхронный, загрузчик будет ждать выполнения всех
+     * методов `processPromise` всех устройств.
+     *
+     * Используется, когда есть необходимость перед запуском стойки выполнить
+     * и дождаться выполнения асинхронного кода (инициализация некоторых файловых баз данных и тп)
+    */
+    processPromise(): Promise<void>;
+    stop(): void;
+    stopPromise(): Promise<void>;
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к постановке в очередь устройства на обновление данных `Shares`
+    */
+    render(): boolean;
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к сохранение в локальное файловое хранилище данных `Storage`
+    */
+    save(): boolean;
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке сообщению об ошибке
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Непосредственно объект ошибки, или объект который поможет разобратся в случившейся ситуации
+    */
+    error(data: string, trace: any): boolean;
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке информационного сообщения
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    notify(data: string, trace: any): boolean;
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке оповещения
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    alert(data: string, trace: any): boolean;
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке отладочной информации
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    terminal(data: string, trace: any): boolean;
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке сообщения о событии
+     *
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    protected event(type: string, data: string, trace: any): boolean;
+    /**
+     * Сообщает стойке, о том, что устройство не может дальше работать
+     * и произошла критическая ошибка
+     *
+     * Требует создание ошибки устройства DeviceError
+     *
+    */
+    terminate(error: Error, action: string): boolean;
+}
+export {};