@syncbridge/common 0.4.0

package/models/metadata/variable-metadata.js

@@ -0,0 +1,138 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+import { VariableFormat } from '../enums/variable-format.enum.js';
+import { VariableType } from '../enums/variable-type.enum.js';
+/**
+ *
+ */
+let VariableMetadataRecord = class VariableMetadataRecord {
+};
+VariableMetadataRecord = __decorate([
+    ComplexType({
+        description: 'User defined variables',
+        additionalFields: () => VariableMetadata,
+    })
+], VariableMetadataRecord);
+export { VariableMetadataRecord };
+/**
+ *
+ */
+let VariableMetadata = class VariableMetadata {
+    ignored;
+    hotPlug;
+};
+__decorate([
+    ApiField({
+        description: 'Determine if the variable can be changed while worker running',
+    }),
+    __metadata("design:type", Boolean)
+], VariableMetadata.prototype, "hotPlug", void 0);
+__decorate([
+    ApiField({
+        description: 'Label of the variable',
+    }),
+    __metadata("design:type", String)
+], VariableMetadata.prototype, "label", void 0);
+__decorate([
+    ApiField({
+        description: 'Processor description',
+    }),
+    __metadata("design:type", String)
+], VariableMetadata.prototype, "description", void 0);
+__decorate([
+    ApiField({
+        description: 'Examples of the variable value.',
+        type: 'string',
+        isArray: true,
+    }),
+    __metadata("design:type", Array)
+], VariableMetadata.prototype, "examples", void 0);
+__decorate([
+    ApiField({
+        description: 'Choices of the variable',
+        type: 'string',
+        isArray: true,
+    }),
+    __metadata("design:type", Array)
+], VariableMetadata.prototype, "choice", void 0);
+__decorate([
+    ApiField({
+        description: 'Data type of the variable',
+        type: VariableType,
+    }),
+    __metadata("design:type", String)
+], VariableMetadata.prototype, "type", void 0);
+__decorate([
+    ApiField({
+        description: 'Nested variables. Available if type is object',
+    }),
+    __metadata("design:type", VariableMetadataRecord)
+], VariableMetadata.prototype, "variables", void 0);
+__decorate([
+    ApiField({
+        description: 'Format of the variable. Available if type is string',
+        type: VariableFormat,
+    }),
+    __metadata("design:type", String)
+], VariableMetadata.prototype, "format", void 0);
+__decorate([
+    ApiField({
+        description: 'List of values. Available if type is enum',
+        type: 'string',
+    }),
+    __metadata("design:type", Array)
+], VariableMetadata.prototype, "enumValues", void 0);
+__decorate([
+    ApiField({
+        description: 'Determine if the variable is an array or not',
+    }),
+    __metadata("design:type", Boolean)
+], VariableMetadata.prototype, "isArray", void 0);
+__decorate([
+    ApiField({
+        description: 'Minimum number of items in the array. Available if isArray is true',
+    }),
+    __metadata("design:type", Number)
+], VariableMetadata.prototype, "minOccurs", void 0);
+__decorate([
+    ApiField({
+        description: 'Maximum number of items in the array. Available if isArray is true',
+    }),
+    __metadata("design:type", Number)
+], VariableMetadata.prototype, "maxOccurs", void 0);
+__decorate([
+    ApiField({
+        description: 'Determine if the variable is required or not',
+    }),
+    __metadata("design:type", Boolean)
+], VariableMetadata.prototype, "required", void 0);
+__decorate([
+    ApiField({
+        description: 'Default value of the variable',
+    }),
+    __metadata("design:type", Object)
+], VariableMetadata.prototype, "default", void 0);
+__decorate([
+    ApiField({
+        description: 'Regex pattern for the variable value. Available if type is string',
+    }),
+    __metadata("design:type", String)
+], VariableMetadata.prototype, "pattern", void 0);
+__decorate([
+    ApiField({
+        description: 'Minimum value for the variable',
+    }),
+    __metadata("design:type", Object)
+], VariableMetadata.prototype, "minValue", void 0);
+__decorate([
+    ApiField({
+        description: 'Maximum value for the variable',
+    }),
+    __metadata("design:type", Object)
+], VariableMetadata.prototype, "maxValue", void 0);
+VariableMetadata = __decorate([
+    ComplexType({
+        description: 'User defined variable definition',
+    })
+], VariableMetadata);
+export { VariableMetadata };

package/models/profile/log-options.d.ts

@@ -0,0 +1,16 @@
+import { LogLevel } from '../enums/log-level.js';
+/**
+ * LogOptions
+ */
+export declare class LogOptions {
+    constructor(init?: Partial<LogOptions>);
+    level?: LogLevel;
+    errorStack?: boolean;
+}
+/**
+ * ProfileSettings
+ */
+export declare class ProfileLogOptions extends LogOptions {
+    constructor(init?: Partial<ProfileLogOptions>);
+    terminal?: boolean;
+}

package/models/profile/log-options.js

@@ -0,0 +1,56 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+import { LogLevel } from '../enums/log-level.js';
+/**
+ * LogOptions
+ */
+let LogOptions = class LogOptions {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+    level;
+    errorStack;
+};
+__decorate([
+    ApiField({
+        label: 'Level',
+        description: 'Determines the log level',
+        default: LogLevel.info,
+    }),
+    __metadata("design:type", String)
+], LogOptions.prototype, "level", void 0);
+__decorate([
+    ApiField({
+        label: 'Error Stack',
+        description: 'Determines if error stack will be logged or not',
+    }),
+    __metadata("design:type", Boolean)
+], LogOptions.prototype, "errorStack", void 0);
+LogOptions = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], LogOptions);
+export { LogOptions };
+/**
+ * ProfileSettings
+ */
+let ProfileLogOptions = class ProfileLogOptions extends LogOptions {
+    constructor(init) {
+        super(init);
+    }
+    terminal;
+};
+__decorate([
+    ApiField({
+        label: 'Terminal',
+        description: 'Determines if logs will be piped to application terminal',
+        default: true,
+    }),
+    __metadata("design:type", Boolean)
+], ProfileLogOptions.prototype, "terminal", void 0);
+ProfileLogOptions = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], ProfileLogOptions);
+export { ProfileLogOptions };

package/models/profile/profile-component.d.ts

@@ -0,0 +1,23 @@
+import { LogOptions } from './log-options.js';
+/**
+ * WorkerComponentRecord
+ */
+export declare class WorkerComponentRecord {
+    [key: string]: ProfileComponent;
+}
+/**
+ * ProfileComponentSettings
+ */
+export declare class ProfileComponentSettings {
+    constructor(init?: Partial<ProfileComponentSettings>);
+    logs?: LogOptions;
+}
+/**
+ * ProfileComponent
+ */
+export declare class ProfileComponent {
+    className: string;
+    values?: Record<string, any>;
+    components?: WorkerComponentRecord;
+    settings?: ProfileComponentSettings;
+}

package/models/profile/profile-component.js

@@ -0,0 +1,77 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+import { LogOptions } from './log-options.js';
+/**
+ * WorkerComponentRecord
+ */
+let WorkerComponentRecord = class WorkerComponentRecord {
+};
+WorkerComponentRecord = __decorate([
+    ComplexType({
+        description: 'Container for profile components',
+        additionalFields: () => ProfileComponent,
+    })
+], WorkerComponentRecord);
+export { WorkerComponentRecord };
+/**
+ * ProfileComponentSettings
+ */
+let ProfileComponentSettings = class ProfileComponentSettings {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+    logs;
+};
+__decorate([
+    ApiField({
+        label: 'Logs',
+        description: 'Log settings of the component',
+    }),
+    __metadata("design:type", LogOptions)
+], ProfileComponentSettings.prototype, "logs", void 0);
+ProfileComponentSettings = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], ProfileComponentSettings);
+export { ProfileComponentSettings };
+/**
+ * ProfileComponent
+ */
+let ProfileComponent = class ProfileComponent {
+};
+__decorate([
+    ApiField({
+        description: 'Class name of the component',
+        examples: ['TcpClient', 'SerialClient'],
+    }),
+    __metadata("design:type", String)
+], ProfileComponent.prototype, "className", void 0);
+__decorate([
+    ApiField({
+        label: 'Values',
+        description: 'Values of user defined variables',
+        type: 'object',
+    }),
+    __metadata("design:type", Object)
+], ProfileComponent.prototype, "values", void 0);
+__decorate([
+    ApiField({
+        label: 'Components',
+        description: 'Sub components',
+    }),
+    __metadata("design:type", WorkerComponentRecord)
+], ProfileComponent.prototype, "components", void 0);
+__decorate([
+    ApiField({
+        label: 'Settings',
+        description: 'Settings of the component',
+    }),
+    __metadata("design:type", ProfileComponentSettings)
+], ProfileComponent.prototype, "settings", void 0);
+ProfileComponent = __decorate([
+    ComplexType({
+        description: 'User defined variable definition',
+    })
+], ProfileComponent);
+export { ProfileComponent };

package/models/profile/profile.d.ts

@@ -0,0 +1,25 @@
+import { ProfileLogOptions } from './log-options.js';
+import { WorkerComponentRecord } from './profile-component.js';
+/**
+ * ProfileSettings
+ */
+export declare class ProfileSettings {
+    constructor(init?: Partial<ProfileSettings>);
+    autostart?: boolean;
+    logs?: ProfileLogOptions;
+}
+/**
+ * Profile
+ */
+export declare class Profile {
+    constructor(init?: Partial<Profile>);
+    id: string;
+    displayName: string;
+    processorClass: string;
+    group?: string;
+    description?: string;
+    iconUrl?: string;
+    values?: Record<string, any>;
+    components?: WorkerComponentRecord;
+    settings?: ProfileSettings;
+}

package/models/profile/profile.js

@@ -0,0 +1,115 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiField, ComplexType } from '@opra/common';
+import { ProfileLogOptions } from './log-options.js';
+import { WorkerComponentRecord } from './profile-component.js';
+/**
+ * ProfileSettings
+ */
+let ProfileSettings = class ProfileSettings {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+    autostart;
+    logs;
+};
+__decorate([
+    ApiField({
+        label: 'Auto Start',
+        description: 'Determines if the processor will be auto started or not',
+    }),
+    __metadata("design:type", Boolean)
+], ProfileSettings.prototype, "autostart", void 0);
+__decorate([
+    ApiField({
+        label: 'Logs',
+        description: 'Log settings of the processor',
+    }),
+    __metadata("design:type", ProfileLogOptions)
+], ProfileSettings.prototype, "logs", void 0);
+ProfileSettings = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], ProfileSettings);
+export { ProfileSettings };
+/**
+ * Profile
+ */
+let Profile = class Profile {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+};
+__decorate([
+    ApiField({
+        label: 'Identity',
+        description: 'Uniquely identifies the profile',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], Profile.prototype, "id", void 0);
+__decorate([
+    ApiField({
+        label: 'Display Name',
+        description: 'Human friendly name of the profile to be displayed in the UI',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], Profile.prototype, "displayName", void 0);
+__decorate([
+    ApiField({
+        label: 'Processor Class',
+        description: 'Class name of the processor',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], Profile.prototype, "processorClass", void 0);
+__decorate([
+    ApiField({
+        label: 'Group',
+        description: 'Group of the profile. Profiles are grouped by this value',
+    }),
+    __metadata("design:type", String)
+], Profile.prototype, "group", void 0);
+__decorate([
+    ApiField({
+        label: 'Description',
+        description: 'Long description',
+    }),
+    __metadata("design:type", String)
+], Profile.prototype, "description", void 0);
+__decorate([
+    ApiField({
+        label: 'Icon',
+        description: 'Icon url',
+    }),
+    __metadata("design:type", String)
+], Profile.prototype, "iconUrl", void 0);
+__decorate([
+    ApiField({
+        label: 'Values',
+        description: 'Values of user defined variables',
+        type: 'object',
+    }),
+    __metadata("design:type", Object)
+], Profile.prototype, "values", void 0);
+__decorate([
+    ApiField({
+        label: 'Components',
+        description: 'Components of the processor',
+    }),
+    __metadata("design:type", WorkerComponentRecord)
+], Profile.prototype, "components", void 0);
+__decorate([
+    ApiField({
+        label: 'Settings',
+        description: 'Settings of the processor',
+    }),
+    __metadata("design:type", ProfileSettings)
+], Profile.prototype, "settings", void 0);
+Profile = __decorate([
+    ComplexType(),
+    __metadata("design:paramtypes", [Object])
+], Profile);
+export { Profile };

package/models-document.d.ts

@@ -0,0 +1,3 @@
+import { ApiDocument } from '@opra/common';
+export declare function initializeModelsDocument(): Promise<void>;
+export declare function getModelsDocument(): ApiDocument;

package/models-document.js

@@ -0,0 +1,15 @@
+import { ApiDocumentFactory } from '@opra/common';
+import * as models from './models/index.js';
+let doc;
+export async function initializeModelsDocument() {
+    doc =
+        doc ||
+            (await ApiDocumentFactory.createDocument({
+                types: [...Object.values(models)],
+            }));
+}
+export function getModelsDocument() {
+    if (!doc)
+        throw new Error('You must call initializeModelsDocument() first');
+    return doc;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@syncbridge/common",
+  "version": "0.4.0",
+  "description": "SyncBridge Common utilities",
+  "author": "Panates Inc",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@jsopen/objects": "^2.0.2",
+    "node-events-async": "^1.5.0",
+    "reflect-metadata": "^0.2.2",
+    "ts-gems": "^3.11.3",
+    "valgen": "^5.19.4"
+  },
+  "peerDependencies": {
+    "@opra/common": ">=1.17.1 <2"
+  },
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=20.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/processor-factory.d.ts

@@ -0,0 +1,13 @@
+import { ProcessorBase } from './classes/processor-base.js';
+import { ILogger } from './interfaces/index.js';
+import { Profile } from './models/index.js';
+export declare namespace ProcessorFactory {
+    const METADATA_KEY: unique symbol;
+    const PROFILE_KEY: unique symbol;
+    interface ProcessorOptions {
+        logger: ILogger;
+        dataDirectory?: string;
+    }
+    function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<T>;
+    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<void>;
+}

package/processor-factory.js

@@ -0,0 +1,106 @@
+import { StackExecutor } from './classes/stack-executor.js';
+import { initializeModelsDocument } from './models-document.js';
+import { ExtensionRegistry } from './registry.js';
+import { materializeMetadata } from './utils/metadata-utils.js';
+export var ProcessorFactory;
+(function (ProcessorFactory) {
+    ProcessorFactory.METADATA_KEY = Symbol('METADATA');
+    ProcessorFactory.PROFILE_KEY = Symbol('PROFILE');
+    async function createProcessor(profile, options) {
+        await initializeModelsDocument();
+        const reg = ExtensionRegistry.getProcessor(profile.processorClass);
+        const processor = new reg.ctor({
+            name: profile.displayName,
+            logger: options?.logger,
+            values: profile.values || {},
+            dataDirectory: options?.dataDirectory,
+        });
+        await _configureProcessor(processor, profile);
+        return processor;
+    }
+    ProcessorFactory.createProcessor = createProcessor;
+    async function updateProcessor(processor, profile, options) {
+        if (options?.logger)
+            processor.logger = options.logger;
+        if (options?.dataDirectory)
+            processor.dataDirectory = options.dataDirectory;
+        return _configureProcessor(processor, profile);
+    }
+    ProcessorFactory.updateProcessor = updateProcessor;
+    async function _configureProcessor(processor, profile) {
+        const processorMetadata = materializeMetadata(profile);
+        const stackExecutor = new StackExecutor();
+        function configureComponents(owner, curPath, newMetadata, newProfile, oldMetadata, oldProfile) {
+            if (!newMetadata.components)
+                return;
+            // Stack: components
+            stackExecutor.execute('components', () => {
+                for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
+                    // Stack: components/componentName
+                    stackExecutor.execute(key, () => {
+                        const oldChildMetadata = oldMetadata?.components?.[key];
+                        const oldChildProfile = oldProfile?.components?.[key];
+                        const childProfile = newProfile.components[key];
+                        const componentPath = curPath ? curPath + '/' + key : key;
+                        let componentInstance = owner.components?.[key];
+                        /** Create component only if processor is stopped */
+                        if (processor.stopped) {
+                            const compReg = ExtensionRegistry.getComponent(childMetadata.className);
+                            /** Create the component instance */
+                            const compClass = compReg.ctor;
+                            componentInstance = new compClass({
+                                processor: processor,
+                                parent: owner,
+                                name: key,
+                                path: componentPath,
+                                values: childProfile.values || {},
+                            });
+                            owner.components = owner.components || {};
+                            owner.components[key] = componentInstance;
+                            if (childMetadata.propertyKey)
+                                owner[childMetadata.propertyKey] = componentInstance;
+                        }
+                        else if (oldMetadata?.className &&
+                            oldMetadata?.className !== newMetadata.className) {
+                            throw new Error('Can not change component class while processor running. You should stop it first.');
+                        }
+                        else {
+                            // todo update only hot-plug values
+                            componentInstance.values = childProfile.values || {};
+                        }
+                        /** Create the child logger */
+                        componentInstance.logger = owner.logger?.child({
+                            component: componentPath,
+                        });
+                        if (childProfile.settings?.logs?.level) {
+                            componentInstance.logger.level =
+                                childProfile.settings?.logs?.level;
+                        }
+                        /** Initialize sub components */
+                        if (childMetadata.components) {
+                            configureComponents(componentInstance, componentPath, childMetadata, childProfile, oldChildMetadata, oldChildProfile);
+                        }
+                    });
+                }
+            });
+        }
+        configureComponents(processor, '', processorMetadata, profile, processor[ProcessorFactory.METADATA_KEY], processor[ProcessorFactory.PROFILE_KEY]);
+        processor[ProcessorFactory.METADATA_KEY] = processorMetadata;
+        processor[ProcessorFactory.PROFILE_KEY] = profile;
+        // processor.on('error', err => this.logger.error(err));
+        // processor.on('status-change', args => {
+        //   this.messageHandler.emit('status-change', args);
+        // });
+        // processor.on(
+        //   'component-status-change',
+        //   (component, status, statusMessage) => {
+        //     this.messageHandler.emit('component-status-change', {
+        //       componentName: component.name,
+        //       path: component.path,
+        //       status,
+        //       statusMessage,
+        //     });
+        //   },
+        // );
+    }
+})(ProcessorFactory || (ProcessorFactory = {}));

package/registry.d.ts

@@ -0,0 +1,32 @@
+import { Type } from 'ts-gems';
+import type { ComponentBase } from './classes/component-base.js';
+import type { ProcessorBase } from './classes/processor-base.js';
+import type { ComponentMetadata, ProcessorMetadata } from './models/index.js';
+export declare namespace ExtensionRegistry {
+    const packages: Map<string, ExtensionPackageRecord>;
+    const components: Map<string, ComponentRecord>;
+    const processors: Map<string, ProcessorRecord>;
+    function setResolver(resolver: (name: string) => string): void;
+    function getProcessor(className: string): ExtensionRegistry.ProcessorRecord;
+    function getComponent(className: string): ExtensionRegistry.ComponentRecord;
+    function registerPackage(...specifiers: string[]): Promise<void>;
+    function registerComponent(ctor: Type, packageName: string): Promise<void>;
+    function registerProcessor(ctor: Type, packageName: string): Promise<void>;
+}
+export declare namespace ExtensionRegistry {
+    interface ExtensionPackageRecord {
+        name: string;
+        description?: string;
+        version: string;
+    }
+    interface ComponentRecord {
+        package: string;
+        ctor: Type<ComponentBase>;
+        metadata: ComponentMetadata;
+    }
+    interface ProcessorRecord {
+        package: string;
+        ctor: Type<ProcessorBase>;
+        metadata: ProcessorMetadata;
+    }
+}