vrack2-core 0.0.1

package/src/service/Device.ts

@@ -0,0 +1,225 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+
+// import DeviceError from "../errors/DeviceError";
+// import Rule from "../validator/ValidatorRule";
+import BasicType from "../validator/types/BasicType";
+import Container from '../Container';
+import BasicAction from "../actions/BasicAction";
+import BasicPort from "../ports/BasicPort";
+import DevicePort from "./DevicePort";
+import  IDeviceEvent  from "./IDeviceEvent";
+
+
+/**
+ * Интерфейс списка исходящих портов устройства
+// */
+// export interface IDeviceOutputList {
+//     [index: string]: OutputPort;
+// }
+
+// /**
+//  * Интерфейс списка входящих портов устройства
+// */
+// export interface IDeviceInputList {
+//     [index: string]: InputPort;
+// }
+
+export 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){
+        this.id = id
+        this.type = type
+        this.Container = Container
+        this.ports = {
+            input: {},
+            output: {}
+        }
+    }
+
+    /** 
+     * Short device description
+     * 
+     * @return {string} Device description
+     * */
+    description(): string{
+        return ''
+    }
+
+    /** 
+     * Shares данные устройства (обновляемые данные) 
+     * используется с методом `this.render`
+     * 
+     * @see render()
+     * */
+    shares: any = {};
+
+    /**
+     * 
+    */
+    storage: any = {}
+
+    /** Список Action-методов устройства */
+    actions() : { [key: string] : BasicAction} { return {} }
+
+    /** 
+     * Определение списка параметров устройства 
+     * 
+     * @returns {Array<Rule>}
+     * */
+    checkOptions(): {[key:string]: BasicType} { return {} }
+
+    /**
+     * Prepare options 
+     * 
+     * this method call before validating options
+    */
+    prepareOptions() { return }
+
+
+    inputs () : {[key:string]: BasicPort} { return {} }
+    outputs () : {[key:string]: BasicPort} { return {} }
+
+    /**
+     * Метод является входной точкой для начала инициализации устройства
+     * 
+     * Устройство пройдет только следующие этапы создания устройства:
+     * 
+     * - Создания класса
+     * - Назначение праметров устройства
+     * 
+     * Необходимо использовать для назначения функций вызова динамических портов
+     * устройства.
+    */
+    preProcess() { return }
+
+    /**
+     * Метод является входной точкой для начала работы устройства
+     * 
+     * Устройство пройдет следующие этапы создания устройства:
+     * 
+     * - Создания класса
+     * - Назначение праметров устройства
+     * - Создание портов 
+     * - Назначение функций вызова
+     * - Создание соединений между устройствами
+     * - Линковка Shares устройства
+     * 
+     * Необходимо использовать для осуществления начала основной работы устройства
+     * например, инициализация подключений, создание таймеров и тп.
+    */
+    process() { return }
+
+    /**
+     * По аналогии с `process` но асинхронный, загрузчик будет ждать выполнения всех 
+     * методов `processPromise` всех устройств.
+     * 
+     * Используется, когда есть необходимость перед запуском стойки выполнить
+     * и дождаться выполнения асинхронного кода (инициализация некоторых файловых баз данных и тп)
+    */
+    async processPromise() { return }
+
+    stop() { return }
+
+    async stopPromise() { 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: string, trace: any) { return this.event('device.error', data, trace) }
+
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке информационного сообщения
+     * 
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    notify(data: string, trace: any) { return this.event('device.notify', data, trace) }
+
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке оповещения
+     * 
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    alert(data: string, trace: any) { return this.event('device.alert', data, trace) }
+
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке отладочной информации
+     * 
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    terminal(data: string, trace: any) { return this.event('device.terminal', data, trace) }
+
+    /**
+     * Метод заменяется загрузчиком стойки, после чего, вызов этого метода приводит
+     * к отправке сообщения о событии
+     * 
+     * @param {string} data Сообщение об ошибке
+     * @param {any} trace Дополнительная информация
+    */
+    protected event(type:string, data: string, trace: any) { 
+        const nEvent: IDeviceEvent = {id: this.id, data, trace}
+        return this.Container.emit(type, nEvent) 
+    }
+
+    /**
+     * Сообщает стойке, о том, что устройство не может дальше работать
+     * и произошла критическая ошибка
+     * 
+     * Требует создание ошибки устройства DeviceError
+     * 
+    */
+    terminate(error: Error, action: string) {
+        return this.event('device.terminate', action, error)
+    }
+}

package/src/service/DeviceConnect.ts

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

package/src/service/DevicePort.ts

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

package/src/service/IDeviceEvent.ts

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

package/src/test.ts

@@ -0,0 +1,82 @@
+// import Action from "./rack/Action";
+// import Port from "./rack/Port";
+// import Rule from "./validator/Rule";
+
+import Rule from "./validator/Rule";
+import Validator from "./validator/Validator";
+
+Rule.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.object().require().description('Test validation object'),
+    str: Rule.string().require().minLength(5),
+    arr: Rule.array().require(),
+    num: Rule.number().require().integer().description('integer test')
+}
+
+
+const data = {
+    obj: {},
+    str: 'qwe4',
+    arr: [],
+    num: 1.23
+}
+
+
+Validator.validate(rules,data)
+
+

package/src/validator/IValidationProblem.ts

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

package/src/validator/IValidationRule.ts

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

package/src/validator/IValidationSubrule.ts

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

package/src/validator/Rule.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+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() {
+        return new NumberType()
+    }
+
+    static string(){
+        return new StringType()
+    }
+
+    static object(){
+        return new ObjectType()
+    }
+
+    static array (){
+        return new ArrayType()
+    }
+}

package/src/validator/Validator.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import ErrorManager from "../errors/ErrorManager";
+
+import ArrayType from "./types/ArrayType";
+import BasicType from "./types/BasicType";
+import NumberType from "./types/NumberType";
+import ObjectType from "./types/ObjectType";
+import StringType from "./types/StringType";
+
+import CoreError from "../errors/CoreError";
+import IValidationProblem from './IValidationProblem';
+import IValidationRule from "./IValidationRule";
+
+ErrorManager.register(
+    'Validator', 'VXLeMLVnIXGf', 'VR_TYPE_NOT_EXISTS',
+    'Type not exists', {
+})
+
+ErrorManager.register(
+    'Validator', 'X1UP4P2HRHWd', 'VR_NOT_PASS',
+    'Validation error - data not pass', {
+})
+
+export default class Validator {
+
+    static validate(rules: {[key:string]: BasicType},data: {[key:string]: any}) : boolean {
+        const problems: Array<IValidationProblem> = []
+        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) problems.push(Validator.makeProblem(err, key, ruleRaw))
+            }
+        }
+        if (problems.length) Validator.makeError(problems)
+        return true;
+    }
+
+    private static makeError(eList: Array<IValidationProblem>){
+        throw ErrorManager.make('VR_NOT_PASS', {
+            problems: eList
+        })
+    }
+
+    protected static makeProblem(err: CoreError, key: string, rule: IValidationRule) : IValidationProblem {
+        return {
+            type: err.vShort, code: err.vCode, description: err.message, rule, arg: err.vAdd
+        }
+    }
+
+    private static getClass(cn : string){
+        switch (cn){
+            case 'string': return StringType
+            case 'number': return NumberType
+            case 'object': return ObjectType
+            case 'array': return ArrayType
+        }
+        throw ErrorManager.make('VR_TYPE_NOT_EXISTS', { type: cn })
+    }
+}

package/src/validator/types/ArrayType.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import IValidationRule from "../IValidationRule";
+import BasicType from "./BasicType";
+import ErrorManager from "../../errors/ErrorManager"
+import IValidationSubrule from "../IValidationSubrule";
+import Validator from "../Validator";
+import CoreError from "../../errors/CoreError";
+
+export default class ArrayType extends BasicType {
+    constructor() {
+        super()
+        this.rule.type = 'array'
+    }
+
+    default(def: Array<any>) {
+        this.rule.default = def
+        return this
+    }
+
+    content(t: BasicType) {
+        this.rule.rules.push({ name: 'contain', args: t })
+        return this
+    }
+
+    static validate(obj: { [key: string]: any; }, key: string, rule: IValidationRule): boolean {
+        BasicType.validate(obj, key, rule)
+        if (!Array.isArray(obj[key])) throw ErrorManager.make('VR_IS_NOT_ARRAY', {})
+        for (const subrule of rule.rules) {
+            switch (subrule.name) {
+                case 'fields':
+                    ArrayType.checkContent(obj, key, subrule)
+                    break
+            }
+        }
+        return true
+    }
+
+    protected static checkContent(obj: { [key: string]: any }, key: string, sub: IValidationSubrule) {
+        const sw = { value: undefined }
+        const tr = { value: sub.args }
+        for (const index of obj[key]) {
+            sw.value = obj[key][index]
+            try {
+                Validator.validate(tr, sw)
+            } catch (error) {
+                if (error instanceof CoreError) {
+                    throw ErrorManager.make('VR_ARRAY_CONTENT_ERROR', { index }).add(error)
+                }
+            }
+        }
+    }
+
+}
+
+ErrorManager.register(
+    'Validator', '3U9s3ZsTH6FA', 'VR_IS_NOT_ARRAY',
+    'Value must be a array', {
+})
+
+ErrorManager.register(
+    'Validator', 'Eg9cIXlxi1yP', 'VR_ARRAY_CONTENT_ERROR',
+    'Validation error inside the array data', {
+})

package/src/validator/types/BasicType.ts

@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+
+import ErrorManager from "../../errors/ErrorManager"
+import IValidationRule from "../IValidationRule"
+
+export default class BasicType {
+    protected rule: IValidationRule
+
+    constructor() {
+        this.rule = {
+            type: '',
+            require: false,
+            default: undefined,
+            rules: [],
+            example: undefined,
+            description: ''
+        }
+    }
+
+    require(){
+        this.rule.require = true
+        return this
+    }
+
+    example(ex: any){
+        this.rule.example = ex
+        return this
+    }
+
+    description(desc: string){
+        this.rule.description = desc
+        return this
+    }
+
+    export() {
+        return this.rule
+    }
+
+    static validate(obj: {[key:string]: any}, key: string, rule: IValidationRule) :boolean {
+        BasicType.checkDefault(obj, key, rule)
+        BasicType.checkRequire(obj, key, rule)
+        return true;
+    }
+
+    protected static checkDefault(obj: {[key:string]: any}, key: string, rule: IValidationRule) {
+        if (rule.default === undefined) return 
+        if (obj[key] === undefined) obj[key] = rule.default
+    }
+
+    protected static checkRequire(obj: {[key:string]: any}, key: string, rule: IValidationRule) {
+        if (obj[key] === undefined) throw ErrorManager.make('VR_ERROR_REQUAERED', { key })
+    }
+}
+
+ErrorManager.register(
+    'Validator', 'Jwg5Mr1NqaSj', 'VR_ERROR_REQUAERED',
+    'A value is required', {
+})