vrack2-core 0.0.1

package/lib/ImportManager.d.ts

@@ -0,0 +1,15 @@
+export default class ImportManager {
+    /**
+     * Dynamic import method
+     *
+     * @param {string} path Full or relative path to file
+    */
+    static importPath(raPath: string): Promise<any>;
+    static importClass(cs: string): Promise<any>;
+    static importJSON(filePath: string): Promise<any>;
+    static tryJsonParse(jsonRaw: string): any;
+    static camelize(text: string): string;
+    protected static getSub(imp: any, get: string): any;
+    static systemPath(): string;
+    protected static tryImport(p: string): Promise<any>;
+}

package/lib/ImportManager.js

@@ -0,0 +1,145 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const ErrorManager_1 = __importDefault(require("./errors/ErrorManager"));
+const Rule_1 = __importDefault(require("./validator/Rule"));
+ErrorManager_1.default.register('ImportManager', 'kwRobwFPzc5g', 'IM_FILE_NOT_FOUND', 'Import file not found', {
+    filePath: Rule_1.default.string().description('Path to file')
+});
+ErrorManager_1.default.register('ImportManager', 'dMJfR6rmC7o6', 'IM_JSON_INCORRECT', 'Import file json incorrect', {
+    jsonRaw: Rule_1.default.string().description('Raw json data'),
+    parsingError: Rule_1.default.string().description('Json parse error string')
+});
+ErrorManager_1.default.register('ImportManager', 'u3dsX3vZpKrz', 'IM_CLASS_PATH_ERROR', 'Error import class - No acts', {
+    path: Rule_1.default.string().description('Class path string')
+});
+ErrorManager_1.default.register('ImportManager', 'PscFAcmXr11U', 'IM_CLASS_VENDOR_ERROR', 'Error import class - vendor not found', {
+    path: Rule_1.default.string().description('Class path string')
+});
+ErrorManager_1.default.register('ImportManager', 'm9MJNeKv3xYW', 'IM_CLASS_ACT_ERROR', 'Error import class - class act = undefined', {
+    path: Rule_1.default.string().description('Class path string')
+});
+class ImportManager {
+    /**
+     * Dynamic import method
+     *
+     * @param {string} path Full or relative path to file
+    */
+    static importPath(raPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // IF we have absolute path
+            if (path_1.default.isAbsolute(raPath)) {
+                const ti = yield ImportManager.tryImport(raPath);
+                if (ti !== false)
+                    return ti;
+            }
+            const mbfp = path_1.default.join(ImportManager.systemPath(), raPath);
+            if ((0, fs_1.existsSync)(mbfp)) {
+                const ti = yield ImportManager.tryImport(raPath);
+                if (ti !== false)
+                    return ti;
+            }
+            const ti = yield Promise.resolve(`${raPath}`).then(s => __importStar(require(s)));
+            return ti;
+        });
+    }
+    static importClass(cs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const acts = cs.split('.');
+            const vendor = acts.shift();
+            if (typeof vendor !== 'string')
+                throw ErrorManager_1.default.make('IM_CLASS_PATH_ERROR', { path: cs });
+            let ret = yield ImportManager.tryImport(vendor);
+            if (ret === false)
+                throw ErrorManager_1.default.make('IM_CLASS_VENDOR_ERROR', { path: cs });
+            for (const act of acts) {
+                ret = ret[act];
+                if (ret === undefined)
+                    throw ErrorManager_1.default.make('IM_CLASS_ACT_ERROR', { path: cs });
+            }
+            return ret;
+        });
+    }
+    static importJSON(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!path_1.default.isAbsolute(filePath)) {
+                filePath = path_1.default.join(ImportManager.systemPath(), filePath);
+            }
+            if ((0, fs_1.existsSync)(filePath)) {
+                const jdata = (0, fs_1.readFileSync)(filePath).toString('utf-8');
+                return ImportManager.tryJsonParse(jdata);
+            }
+            throw ErrorManager_1.default.make('IM_FILE_NOT_FOUND', { filePath });
+        });
+    }
+    static tryJsonParse(jsonRaw) {
+        try {
+            return JSON.parse(jsonRaw);
+        }
+        catch (e) {
+            throw ErrorManager_1.default.make('IM_JSON_INCORRECT', {
+                jsonRaw, parsingError: (e instanceof Error) ? e.toString() : 'Unknown base json parse error'
+            });
+        }
+    }
+    static camelize(text) {
+        return text.replace(/^([A-Z])|[.]+(\w)/g, function (match, p1, p2, offset) {
+            if (p2)
+                return p2.toUpperCase();
+            return p1.toLowerCase();
+        });
+    }
+    static getSub(imp, get) {
+        return imp[get];
+    }
+    static systemPath() {
+        return process.cwd();
+    }
+    static tryImport(p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield Promise.resolve(`${p}`).then(s => __importStar(require(s)));
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+}
+exports.default = ImportManager;

package/lib/MainProcess.d.ts

@@ -0,0 +1,9 @@
+import Container from "./Container";
+import DeviceManager from "./DeviceManager";
+import IServiceStructure from "./IServiceStructure";
+export default class MainProcess {
+    Container: Container;
+    DeviceManager: DeviceManager;
+    constructor(ContainerClass: typeof Container, DeviceManagerClass: typeof DeviceManager, service: IServiceStructure);
+    run(): Promise<void>;
+}

package/lib/MainProcess.js

@@ -0,0 +1,28 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ImportManager_1 = __importDefault(require("./ImportManager"));
+class MainProcess {
+    constructor(ContainerClass, DeviceManagerClass, service) {
+        this.DeviceManager = new DeviceManagerClass(ImportManager_1.default.systemPath(), './devices');
+        this.DeviceManager.updateList();
+        this.Container = new ContainerClass(service, this.DeviceManager);
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.Container.run();
+        });
+    }
+}
+exports.default = MainProcess;

package/lib/Utility.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Преобразует строку типа `aaa.bbb.ccc` в строку типа `aaaBbbCcc`
+ * Обратите внимание на то, что первый символ первого актета не преобразуется,
+ * если есть такая необходимость, можно добавить точку в самое начало строки `.aaa.bbb.ccc`
+ * результат выполнения будет `AaaBbbCcc`
+*/
+declare function camelize(text: string): string;
+/**
+ * Проверяет, является ли JSON строка валидным JSON
+ * Обычно используется, когда неважно в чем конретно проблема в JSON
+ * и нужно просто узнать валидный он или нет
+ *
+*/
+declare function validJSON(text: string): any;
+/**
+ * Преобразует строку в локальный путь VRack, на данный момент
+ * это просто приведение строки в lowerCase
+ *
+*/
+declare function toPath(text: string): string;
+export { camelize, validJSON, toPath };

package/lib/Utility.js

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPath = exports.validJSON = exports.camelize = void 0;
+/**
+ * Преобразует строку типа `aaa.bbb.ccc` в строку типа `aaaBbbCcc`
+ * Обратите внимание на то, что первый символ первого актета не преобразуется,
+ * если есть такая необходимость, можно добавить точку в самое начало строки `.aaa.bbb.ccc`
+ * результат выполнения будет `AaaBbbCcc`
+*/
+function camelize(text) {
+    return text.replace(/^([A-Z])|[.]+(\w)/g, function (match, p1, p2, offset) {
+        if (p2)
+            return p2.toUpperCase();
+        return p1.toLowerCase();
+    });
+}
+exports.camelize = camelize;
+/**
+ * Проверяет, является ли JSON строка валидным JSON
+ * Обычно используется, когда неважно в чем конретно проблема в JSON
+ * и нужно просто узнать валидный он или нет
+ *
+*/
+function validJSON(text) {
+    try {
+        const cfg = JSON.parse(text);
+        if (!(cfg && typeof cfg === 'object'))
+            return false;
+        return cfg;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.validJSON = validJSON;
+/**
+ * Преобразует строку в локальный путь VRack, на данный момент
+ * это просто приведение строки в lowerCase
+ *
+*/
+function toPath(text) {
+    return text.toLowerCase();
+}
+exports.toPath = toPath;

package/lib/actions/Action.d.ts

@@ -0,0 +1,4 @@
+import GlobalAction from "./GlobalAction";
+export default class Action {
+    static global(): GlobalAction;
+}

package/lib/actions/Action.js

@@ -0,0 +1,16 @@
+"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 GlobalAction_1 = __importDefault(require("./GlobalAction"));
+class Action {
+    static global() {
+        return new GlobalAction_1.default();
+    }
+}
+exports.default = Action;

package/lib/actions/BasicAction.d.ts

@@ -0,0 +1,15 @@
+import BasicType from "../validator/types/BasicType";
+import IAction from "./IAction";
+import ILocalAction from "./ILocalAction";
+export default class BasicAction {
+    protected action: ILocalAction;
+    constructor();
+    requirements(req: {
+        [key: string]: BasicType;
+    }): this;
+    returns(ret: {
+        [key: string]: BasicType;
+    }): this;
+    description(des: string): this;
+    export(): IAction;
+}

package/lib/actions/BasicAction.js

@@ -0,0 +1,44 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+class BasicAction {
+    constructor() {
+        this.action = {
+            type: 'unknown',
+            requirements: {},
+            returns: {},
+            description: ''
+        };
+    }
+    requirements(req) {
+        this.action.requirements = req;
+        return this;
+    }
+    returns(ret) {
+        this.action.returns = ret;
+        return this;
+    }
+    description(des) {
+        this.action.description = des;
+        return this;
+    }
+    export() {
+        const nAction = {
+            type: this.action.type,
+            requirements: {},
+            returns: {},
+            description: this.action.description,
+        };
+        for (const key in this.action.requirements) {
+            nAction.requirements[key] = this.action.requirements[key].export();
+        }
+        for (const key in this.action.returns) {
+            nAction.returns[key] = this.action.returns[key].export();
+        }
+        return nAction;
+    }
+}
+exports.default = BasicAction;

package/lib/actions/GlobalAction.d.ts

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

package/lib/actions/GlobalAction.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 BasicAction_1 = __importDefault(require("./BasicAction"));
+class GlobalAction extends BasicAction_1.default {
+    constructor() {
+        super();
+        this.action.type = 'global';
+    }
+}
+exports.default = GlobalAction;

package/lib/actions/IAction.d.ts

@@ -0,0 +1,11 @@
+import IValidationRule from "../validator/IValidationRule";
+export default interface IAction {
+    type: string;
+    requirements: {
+        [key: string]: IValidationRule;
+    };
+    returns: {
+        [key: string]: IValidationRule;
+    };
+    description: string;
+}

package/lib/actions/IAction.js

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

package/lib/actions/ILocalAction.d.ts

@@ -0,0 +1,11 @@
+import BasicType from "../validator/types/BasicType";
+export default interface ILocalAction {
+    type: string;
+    requirements: {
+        [key: string]: BasicType;
+    };
+    returns: {
+        [key: string]: BasicType;
+    };
+    description: string;
+}

package/lib/actions/ILocalAction.js

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

package/lib/errors/CoreError.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Базовый класс для реализаиции ошибок с возможностью
+ * импортирования и экспортирования классов ошибок для
+ * клиент-серверных операций.
+ *
+ * В VRack очень много передается по сети в виде JSON.  Поскольку
+ * в чистом виде ошибки не преобрзауются в JSON, были сделаны методы
+ * для экспортирования и импортирования с сохранения основных важных свойств.
+ *
+ * Если импортируемая ошибка имеет свойства которых нет в базовом классе, буду добавлены.
+ * Для получения неизвестных свойств можно воспользоватся функцией (для typescript) getUnknownProperty
+ *
+ * Для работы с ошибками VRack рекомендуется использовать ErrorManager
+ *
+*/
+declare class CoreError extends Error {
+    /** Флаг того что ошибка пренадлежит VRack */
+    vError: boolean;
+    /** Код ошибки VRack */
+    vCode: string;
+    /** Кородкий код VRack */
+    vShort: string;
+    /** Список дополнительных параметров */
+    vAdd: Array<string>;
+    /**  */
+    vAddErrors: Array<CoreError>;
+    constructor(name: string, message: string, code: string, short: string);
+    /**
+     * Импортирует ошибку пришедшую по сети в виде JSON объекта
+     * На всякий случай использует objectify для приходящего объекта
+     *
+     * @returns {CoreError} this после модификации
+    */
+    import(error: any): this;
+    /**
+     * Возвращает объект для передачи его по сети с предварительным
+     * преобразованием в JSON
+    */
+    export(): any;
+    add(err: CoreError): this;
+    /**
+     * Для Typescript используется для получения неизвестного
+     * свойства экземпляра после импорта пришедшей ошибки
+    */
+    getUnknownProperty(field: string): any | undefined;
+    /**
+     *  Возвращает объект для передачи его по сети
+     *
+     * @param {any} error Ошибка для преобразования в объект
+     * */
+    static objectify(error: any): any;
+}
+export default CoreError;

package/lib/errors/CoreError.js

@@ -0,0 +1,81 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Базовый класс для реализаиции ошибок с возможностью
+ * импортирования и экспортирования классов ошибок для
+ * клиент-серверных операций.
+ *
+ * В VRack очень много передается по сети в виде JSON.  Поскольку
+ * в чистом виде ошибки не преобрзауются в JSON, были сделаны методы
+ * для экспортирования и импортирования с сохранения основных важных свойств.
+ *
+ * Если импортируемая ошибка имеет свойства которых нет в базовом классе, буду добавлены.
+ * Для получения неизвестных свойств можно воспользоватся функцией (для typescript) getUnknownProperty
+ *
+ * Для работы с ошибками VRack рекомендуется использовать ErrorManager
+ *
+*/
+class CoreError extends Error {
+    constructor(name, message, code, short) {
+        super(message);
+        /** Флаг того что ошибка пренадлежит VRack */
+        this.vError = true;
+        /** Код ошибки VRack */
+        this.vCode = "";
+        /** Кородкий код VRack */
+        this.vShort = "";
+        /** Список дополнительных параметров */
+        this.vAdd = [];
+        /**  */
+        this.vAddErrors = [];
+        this.name = name;
+        this.vCode = code;
+        this.vShort = short;
+    }
+    /**
+     * Импортирует ошибку пришедшую по сети в виде JSON объекта
+     * На всякий случай использует objectify для приходящего объекта
+     *
+     * @returns {CoreError} this после модификации
+    */
+    import(error) {
+        const objectifyError = CoreError.objectify(error);
+        Object.assign(this, objectifyError);
+        return this;
+    }
+    /**
+     * Возвращает объект для передачи его по сети с предварительным
+     * преобразованием в JSON
+    */
+    export() {
+        return CoreError.objectify(this);
+    }
+    add(err) {
+        this.vAddErrors.push(CoreError.objectify(err));
+        return this;
+    }
+    /**
+     * Для Typescript используется для получения неизвестного
+     * свойства экземпляра после импорта пришедшей ошибки
+    */
+    getUnknownProperty(field) {
+        const dynamicKey = field;
+        return this[dynamicKey];
+    }
+    /**
+     *  Возвращает объект для передачи его по сети
+     *
+     * @param {any} error Ошибка для преобразования в объект
+     * */
+    static objectify(error) {
+        const result = {};
+        for (const key of Object.getOwnPropertyNames(error))
+            result[key] = error[key];
+        return result;
+    }
+}
+exports.default = CoreError;

package/lib/errors/ErrorManager.d.ts

@@ -0,0 +1,47 @@
+import BasicType from "../validator/types/BasicType";
+import CoreError from "./CoreError";
+/**
+ * Класс является точкой входа для инициализации исключений
+ *
+ * Было принято решение вместо кучи мелких однотипных файлов сделать один класс
+ * со стандартным функционалом
+ */
+declare class ErrorManager {
+    private registeredList;
+    /**
+     * Регистрирует тип ошибки компонента
+     *
+     * Перед тем как менеджер ошибок может создать ошибки, необходимо зарегистрировать ее тип.
+     *
+     * @param {string} name Название компонента
+     * @param {string} code Код ошибки
+     * @param {string} short Короткий код ошибки
+     * @param {string} description Описание ошибки
+     *
+    */
+    register(name: string, code: string, short: string, description: string, rules?: {
+        [key: string]: BasicType;
+    }): void;
+    /**
+     * Создание ошибки
+     *
+     *
+     *
+     * @param {string} short
+    */
+    make(short: string, additional?: {}): CoreError;
+    /**
+     * Преобразует обычную ошибку в ошибку VRack
+     *
+     * @param {Error} error Ошибка для преобразования
+    */
+    convert(error: any): any;
+    /**
+     * Возвращает тип ошибки или null
+     *
+     * @param {string} short Короткий код ошибки или код ошибки поиска
+    */
+    private getRegistered;
+}
+declare const GlobalErrorManager: ErrorManager;
+export default GlobalErrorManager;