vrack2-core 0.0.1

package/src/IServiceStructure.ts

@@ -0,0 +1,6 @@
+import  IStructureDevice  from "./IStructureDevice"
+
+export default interface IServiceStructure {
+    devices: Array<IStructureDevice>
+    connections: Array<string>
+}

package/src/IStructureDevice.ts

@@ -0,0 +1,5 @@
+export default interface IStructureDevice {
+    id: string;
+    type: string;
+    options: { [key: string]: any; };
+}

package/src/ImportManager.ts

@@ -0,0 +1,112 @@
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import ErrorManager from "./errors/ErrorManager";
+import Rule from "./validator/Rule";
+
+ErrorManager.register('ImportManager', 'kwRobwFPzc5g', 'IM_FILE_NOT_FOUND',
+    'Import file not found', {
+    filePath: Rule.string().description('Path to file')
+})
+
+ErrorManager.register('ImportManager', 'dMJfR6rmC7o6', 'IM_JSON_INCORRECT',
+    'Import file json incorrect', {
+    jsonRaw: Rule.string().description('Raw json data'),
+    parsingError: Rule.string().description('Json parse error string')
+})
+
+ErrorManager.register('ImportManager', 'u3dsX3vZpKrz', 'IM_CLASS_PATH_ERROR',
+    'Error import class - No acts', {
+    path: Rule.string().description('Class path string')
+})
+
+ErrorManager.register('ImportManager', 'PscFAcmXr11U', 'IM_CLASS_VENDOR_ERROR',
+    'Error import class - vendor not found', {
+    path: Rule.string().description('Class path string')
+})
+
+ErrorManager.register('ImportManager', 'm9MJNeKv3xYW', 'IM_CLASS_ACT_ERROR',
+    'Error import class - class act = undefined', {
+    path: Rule.string().description('Class path string')
+})
+
+
+export default class ImportManager {
+    /**
+     * Dynamic import method
+     * 
+     * @param {string} path Full or relative path to file
+    */
+    static async importPath(raPath: string) {
+
+        // IF we have absolute path
+        if (path.isAbsolute(raPath)){
+            const ti = await ImportManager.tryImport(raPath)
+            if (ti !== false) return ti
+        }
+        const mbfp = path.join(ImportManager.systemPath(), raPath)
+        if (existsSync(mbfp)){
+            const ti = await ImportManager.tryImport(raPath)
+            if (ti !== false) return ti
+        }
+        const ti = await import(raPath)
+        return ti
+    }
+
+    static async importClass(cs:string) {
+        const acts = cs.split('.')
+        const vendor = acts.shift()
+        if (typeof vendor !== 'string') throw ErrorManager.make('IM_CLASS_PATH_ERROR', { path: cs })
+        let ret = await ImportManager.tryImport(vendor)
+        if (ret === false) throw ErrorManager.make('IM_CLASS_VENDOR_ERROR', { path: cs })
+        for (const act of acts) {
+            ret = ret[act]
+            if (ret === undefined) throw ErrorManager.make('IM_CLASS_ACT_ERROR', { path: cs })
+        }
+        return ret
+    }
+
+    static async importJSON(filePath: string){
+        if (!path.isAbsolute(filePath)){
+            filePath =  path.join(ImportManager.systemPath(), filePath)
+        }
+        if (existsSync(filePath)){
+            const jdata = readFileSync(filePath).toString('utf-8')
+            return ImportManager.tryJsonParse(jdata)
+        }
+        throw ErrorManager.make('IM_FILE_NOT_FOUND', { filePath })
+    }
+
+    static tryJsonParse(jsonRaw: string) : any{
+        try {
+            return JSON.parse(jsonRaw)
+        } catch (e) {
+            throw ErrorManager.make('IM_JSON_INCORRECT', {
+                jsonRaw, parsingError: (e instanceof Error)?e.toString() : 'Unknown base json parse error'
+            })
+        }
+    }
+    
+    static camelize(text: string) {
+        return text.replace(/^([A-Z])|[.]+(\w)/g, function (match, p1, p2, offset) {
+            if (p2) return p2.toUpperCase()
+            return p1.toLowerCase()
+        })
+    }
+    
+
+    protected static getSub(imp: any, get: string){
+        return imp[get]
+    }
+
+    static systemPath(){
+        return process.cwd()
+    }
+
+    protected static async tryImport(p: string){
+        try {
+            return await import(p)
+        } catch (error){
+            return false
+        }
+    }
+}

package/src/MainProcess.ts

@@ -0,0 +1,18 @@
+import Container from "./Container";
+import DeviceManager from "./DeviceManager";
+import IServiceStructure from "./IServiceStructure";
+import ImportManager from "./ImportManager";
+
+
+export default class MainProcess  {
+    Container: Container
+    DeviceManager : DeviceManager
+    constructor(ContainerClass: typeof Container, DeviceManagerClass: typeof DeviceManager, service: IServiceStructure){
+        this.DeviceManager = new DeviceManagerClass(ImportManager.systemPath(), './devices')
+        this.DeviceManager.updateList()
+        this.Container = new ContainerClass(service, this.DeviceManager)
+    }
+    async run (){
+        await this.Container.run()
+    }
+}

package/src/Utility.ts

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

package/src/actions/Action.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import GlobalAction from "./GlobalAction";
+
+export default class Action {
+    static global() {
+        return new GlobalAction()
+    }
+}

package/src/actions/BasicAction.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicType from "../validator/types/BasicType";
+import IAction from "./IAction";
+import ILocalAction from "./ILocalAction"
+
+
+export default class BasicAction {
+    protected action: ILocalAction
+
+    constructor() {
+        this.action = {
+            type: 'unknown',
+            requirements: {},
+            returns: {},
+            description: ''
+        }
+    }
+
+    requirements(req: { [key: string]: BasicType; }){
+        this.action.requirements = req
+        return this
+    }
+
+    returns (ret: { [key: string]: BasicType; }){
+        this.action.returns = ret
+        return this
+    }
+
+    description(des: string){
+        this.action.description = des
+        return this
+    }
+
+    export(): IAction{
+        const nAction: IAction = {
+            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
+    }
+}

package/src/actions/GlobalAction.ts

@@ -0,0 +1,14 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicAction from "./BasicAction";
+
+export default class GlobalAction extends BasicAction {
+
+    constructor() {
+        super()
+        this.action.type = 'global'
+    }
+}

package/src/actions/IAction.ts

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

package/src/actions/ILocalAction.ts

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

package/src/errors/CoreError.ts

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

package/src/errors/ErrorManager.ts

@@ -0,0 +1,93 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicType from "../validator/types/BasicType"
+import CoreError from "./CoreError"
+
+interface RegisteredError {
+    name: string,
+    code: string,
+    short: string,
+    description: string,
+    rules: {[key:string]: BasicType}
+}
+
+
+/**
+ * Класс является точкой входа для инициализации исключений
+ * 
+ * Было принято решение вместо кучи мелких однотипных файлов сделать один класс
+ * со стандартным функционалом
+ */
+class ErrorManager {
+
+    private registeredList: Array<RegisteredError> = []
+
+    /**
+     * Регистрирует тип ошибки компонента
+     * 
+     * Перед тем как менеджер ошибок может создать ошибки, необходимо зарегистрировать ее тип.
+     * 
+     * @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} = {}) {
+        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: string, additional = {}) {
+        const reg = this.getRegistered(short)
+        if (reg === null) throw this.make('EM_CODE_NOT_FOUND')
+        const ne = new CoreError(reg.name, reg.description,reg.code, reg.short)
+        ne.vAdd = Object.keys(additional)
+        return Object.assign(ne, additional)
+    }
+
+    /**
+     * Преобразует обычную ошибку в ошибку VRack
+     * 
+     * @param {Error} error Ошибка для преобразования
+    */
+    convert(error: any){
+        if (error.vError) return error
+        const ne = this.make('EM_ERROR_CONVERT')
+        ne.import(error)
+        return ne
+    }
+
+    /**
+     * Возвращает тип ошибки или null
+     * 
+     * @param {string} short Короткий код ошибки или код ошибки поиска
+    */
+    private getRegistered(short: string) : RegisteredError | null {
+        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')
+export default GlobalErrorManager

package/src/index.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+
+/* ---------------- VALIDATOR EXPORT ------------------- */
+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'
+
+/* ---------------- BASE OF VRACK ------------------- */
+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/src/ports/BasicPort.ts

@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicType from "../validator/types/BasicType";
+import ILocalPort from "./ILocalPort";
+import IPort from "./IPort";
+
+export default class BasicPort {
+    protected port: ILocalPort
+
+    constructor() {
+        this.port = {
+            type: 'unknown',
+            description: '',
+            required: false,
+            dynamic: false,
+            count: 0
+        }
+    }
+
+    dynamic(count: number){
+        this.port.count = count
+        this.port.dynamic = true
+        return this
+    }
+
+    requirement(req:  BasicType ){
+        this.port.requirement = req
+        return this
+    }
+
+    description(des: string){
+        this.port.description = des
+        return this
+    }
+
+    export(): IPort{
+        const nPort: IPort = {
+            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) nPort.requirement = this.port.requirement.export() 
+        if (this.port.return instanceof BasicType) nPort.return = this.port.return.export() 
+
+        return nPort
+    }
+}

package/src/ports/ILocalPort.ts

@@ -0,0 +1,12 @@
+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/src/ports/IPort.ts

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

package/src/ports/Port.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import ReturnPort from "./ReturnPort";
+import StandartPort from "./StandartPort";
+
+export default class Port {
+    static standart() {
+        return new StandartPort()
+    }
+
+    static return() {
+        return new ReturnPort()
+    }
+}

package/src/ports/ReturnPort.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicType from "../validator/types/BasicType"
+import BasicPort from "./BasicPort"
+
+export default class ReturnPort extends BasicPort {
+    constructor() {
+        super()
+        this.port.type = 'return'
+    }
+
+    return(req:  BasicType ){
+        this.port.return = req
+        return this
+    }
+}

package/src/ports/StandartPort.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import BasicPort from "./BasicPort"
+
+export default class StandartPort extends BasicPort {
+    constructor() {
+        super()
+        this.port.type = 'standart'
+    }
+}