@syncbridge/common 0.9.6 → 0.10.0

package/classes/console-logger.d.ts

@@ -0,0 +1,13 @@
+import { ILogger } from '../interfaces/index.js';
+export declare class ConsoleLogger implements ILogger {
+    level: string;
+    critical(...args: any[]): ILogger;
+    debug(...args: any[]): ILogger;
+    error(...args: any[]): ILogger;
+    fatal(...args: any[]): ILogger;
+    info(...args: any[]): ILogger;
+    trace(...args: any[]): ILogger;
+    warn(...args: any[]): ILogger;
+    child(): ILogger;
+    close(): void | Promise<void>;
+}

package/classes/console-logger.js

@@ -0,0 +1,37 @@
+export class ConsoleLogger {
+    level = 'info';
+    critical(...args) {
+        console.warn(...args);
+        return this;
+    }
+    debug(...args) {
+        console.debug(...args);
+        return this;
+    }
+    error(...args) {
+        console.error(...args);
+        return this;
+    }
+    fatal(...args) {
+        console.error(...args);
+        return this;
+    }
+    info(...args) {
+        console.info(...args);
+        return this;
+    }
+    trace(...args) {
+        console.trace(...args);
+        return this;
+    }
+    warn(...args) {
+        console.warn(...args);
+        return this;
+    }
+    child() {
+        return this;
+    }
+    close() {
+        return undefined;
+    }
+}

package/classes/runnable.js

@@ -52,7 +52,7 @@ export class Runnable extends AsyncEventEmitter {
         await this._init().catch(e => {
             const err = e instanceof SbError ? e : new SbError(e);
             err.code = 'INIT_FAILED';
-            err.message = `Initialization failed doe to: ${err.message}`;
+            err.message = `Initialization failed: ${err.message}`;
             this.setStatus(ServiceStatus.invalid, err.message);
             this.onError(err);
             throw err;

package/classes/stack-executor.d.ts

@@ -1,11 +1,13 @@
 import { ErrorIssue } from '@opra/common';
+type NotPromise<T> = T extends Promise<any> ? never : T;
 export declare class StackExecutor {
     stack: string[];
     issues: StackExecutor.Issue[];
     executeAsync(stack: string, fn: () => Promise<any>): Promise<void>;
-    execute(stack: string, fn: () => any): void;
+    execute<T>(stack: string, fn: () => NotPromise<T>): void;
     handleError(e: any): void;
 }
 export declare namespace StackExecutor {
     type Issue = ErrorIssue;
 }
+export {};

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.9.6';
+export const version = '0.10.0';
 export const CLASS_METADATA = Symbol.for('CLASS_METADATA');
 export const CLASS_TYPE = Symbol.for('CLASS_TYPE');
 export const VARIABLE_CONTAINER = Symbol.for('VARIABLE_CONTAINER');

package/decorators/use-component.decorator.d.ts

@@ -1,9 +1,11 @@
 import 'reflect-metadata';
+import { StrictOmit } from 'ts-gems';
 import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';
 import { ElementComponentMetadata } from '../models/index.js';
 export declare function UseComponent<T extends ProcessorBase | ComponentBase>(options?: UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
 export declare namespace UseComponent {
-    interface Options extends Partial<ElementComponentMetadata> {
+    interface Options extends Partial<StrictOmit<ElementComponentMetadata, 'classUri' | 'interfaceUri'>> {
+        uri?: string;
     }
 }

package/decorators/use-component.decorator.js

@@ -1,4 +1,5 @@
 import 'reflect-metadata';
+import { omit } from '@jsopen/objects';
 import { CLASS_METADATA } from '../constants.js';
 import { defineOwnMetadata } from './decorator-helpers.js';
 export function UseComponent(options = {}) {
@@ -6,16 +7,18 @@ export function UseComponent(options = {}) {
         /** c8 ignore next */
         if (typeof propertyKey !== 'string')
             throw new TypeError('Property key must be a string');
-        if (!options.uri) {
+        let uri = options.uri;
+        if (!uri) {
             const designType = Reflect.getMetadata('design:type', target, propertyKey);
             if (typeof designType === 'function' && designType.uri) {
-                options.uri = designType.uri;
+                uri = designType.uri;
             }
         }
         const metadata = defineOwnMetadata(target.constructor, CLASS_METADATA);
         metadata.components = metadata.components || {};
         metadata.components[propertyKey] = {
-            ...options,
+            interfaceUri: uri,
+            ...omit(options, ['classUri', 'interfaceUri']),
             propertyKey,
         };
     };

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './classes/base-element.js';
 export * from './classes/component-base.js';
+export * from './classes/console-logger.js';
 export * from './classes/frame-stream.js';
 export * from './classes/processor-base.js';
 export * from './classes/runnable.js';

package/index.js

@@ -1,5 +1,6 @@
 export * from './classes/base-element.js';
 export * from './classes/component-base.js';
+export * from './classes/console-logger.js';
 export * from './classes/frame-stream.js';
 export * from './classes/processor-base.js';
 export * from './classes/runnable.js';

package/models/metadata/element-component-metadata.d.ts

@@ -10,8 +10,8 @@ export declare class ElementComponentMetadataRecord {
  */
 export declare class ElementComponentMetadata {
     propertyKey?: string;
-    abstract?: boolean;
-    uri: string;
+    interfaceUri: string;
+    classUri?: string;
     description?: string;
     required?: boolean;
     variables?: VariableMetadataRecord;

package/models/metadata/element-component-metadata.js

@@ -21,20 +21,21 @@ let ElementComponentMetadata = class ElementComponentMetadata {
 };
 __decorate([
     ApiField({
-        label: 'Abstract',
-        description: 'Determines if the component uri is set in profile or it not. If set true an explicit uri is required.',
-        examples: ['@syncbridge/net:TcpClient', '@syncbridge/sqb:SqbClient'],
+        label: 'Class URI',
+        description: 'The interface URI that the assigned class should implement.',
+        examples: ['@syncbridge/builtin:IoClient'],
+        required: true,
     }),
-    __metadata("design:type", Boolean)
-], ElementComponentMetadata.prototype, "abstract", void 0);
+    __metadata("design:type", String)
+], ElementComponentMetadata.prototype, "interfaceUri", void 0);
 __decorate([
     ApiField({
-        label: 'Class URI',
-        description: 'URI of the class',
+        label: 'Interface URI',
+        description: 'The required in URI for the class to be assigned.',
         examples: ['@syncbridge/net:TcpClient', '@syncbridge/sqb:SqbClient'],
     }),
     __metadata("design:type", String)
-], ElementComponentMetadata.prototype, "uri", void 0);
+], ElementComponentMetadata.prototype, "classUri", void 0);
 __decorate([
     ApiField({
         label: 'Description',

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

@@ -2,7 +2,7 @@ import { LogOptions } from './log-options.js';
 /**
  * WorkerComponentRecord
  */
-export declare class WorkerComponentRecord {
+export declare class ProfileComponentRecord {
     [key: string]: ProfileComponent;
 }
 /**
@@ -18,7 +18,7 @@ export declare class ProfileComponentSettings {
 export declare class ProfileComponent {
     uri: string;
     values?: Record<string, any>;
-    components?: WorkerComponentRecord;
+    components?: ProfileComponentRecord;
     settings?: ProfileComponentSettings;
     disabled?: boolean;
 }

package/models/profile/profile-component.js

@@ -4,15 +4,15 @@ import { LogOptions } from './log-options.js';
 /**
  * WorkerComponentRecord
  */
-let WorkerComponentRecord = class WorkerComponentRecord {
+let ProfileComponentRecord = class ProfileComponentRecord {
 };
-WorkerComponentRecord = __decorate([
+ProfileComponentRecord = __decorate([
     ComplexType({
         description: 'Container for profile components',
         additionalFields: () => ProfileComponent,
     })
-], WorkerComponentRecord);
-export { WorkerComponentRecord };
+], ProfileComponentRecord);
+export { ProfileComponentRecord };
 /**
  * ProfileComponentSettings
  */
@@ -60,7 +60,7 @@ __decorate([
         label: 'Components',
         description: 'Sub components',
     }),
-    __metadata("design:type", WorkerComponentRecord)
+    __metadata("design:type", ProfileComponentRecord)
 ], ProfileComponent.prototype, "components", void 0);
 __decorate([
     ApiField({

package/models/profile/profile.d.ts

@@ -1,5 +1,5 @@
 import { ProfileLogOptions } from './log-options.js';
-import { WorkerComponentRecord } from './profile-component.js';
+import { ProfileComponentRecord } from './profile-component.js';
 /**
  * ProfileSettings
  */
@@ -21,6 +21,6 @@ export declare class Profile {
     description?: string;
     iconUrl?: string;
     values?: Record<string, any>;
-    components?: WorkerComponentRecord;
+    components?: ProfileComponentRecord;
     settings?: ProfileSettings;
 }

package/models/profile/profile.js

@@ -1,7 +1,7 @@
 import { __decorate, __metadata } from "tslib";
 import { ApiField, ComplexType } from '@opra/common';
 import { ProfileLogOptions } from './log-options.js';
-import { WorkerComponentRecord } from './profile-component.js';
+import { ProfileComponentRecord } from './profile-component.js';
 /**
  * ProfileSettings
  */
@@ -106,7 +106,7 @@ __decorate([
         label: 'Components',
         description: 'Components of the processor',
     }),
-    __metadata("design:type", WorkerComponentRecord)
+    __metadata("design:type", ProfileComponentRecord)
 ], Profile.prototype, "components", void 0);
 __decorate([
     ApiField({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.9.6",
+  "version": "0.10.0",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",

package/processor-factory.js

@@ -82,48 +82,49 @@ export var ProcessorFactory;
     ProcessorFactory.updateProcessor = updateProcessor;
     async function _configureProcessor(ctx) {
         const { processor, profile } = ctx;
+        const newMetadata = materializeMetadata(profile);
         const cmpCtx = {
             ...ctx,
             owner: processor,
             curPath: '',
-            newMetadata: materializeMetadata(profile),
-            newProfile: profile,
-            oldMetadata: processor[ProcessorFactory.METADATA_KEY],
-            oldProfile: processor[ProcessorFactory.PROFILE_KEY],
+            newMetadataComponents: newMetadata.components,
+            newProfileComponents: profile.components,
+            oldMetadataComponents: processor[ProcessorFactory.METADATA_KEY]?.components,
+            oldProfileComponents: processor[ProcessorFactory.PROFILE_KEY]?.components,
         };
         _validateComponents(cmpCtx);
         await _configureComponents(cmpCtx);
-        processor[ProcessorFactory.METADATA_KEY] = cmpCtx.newMetadata;
+        processor[ProcessorFactory.METADATA_KEY] = newMetadata;
         processor[ProcessorFactory.PROFILE_KEY] = profile;
     }
     function _validateComponents(ctx) {
-        const { newMetadata, newProfile, oldMetadata, oldProfile, curPath, owner, stackExecutor, processor, } = ctx;
-        if (!newMetadata.components)
+        const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, processor, } = ctx;
+        if (!newMetadataComponents)
             return;
         // Stack: components
         stackExecutor.execute('components', () => {
-            for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
+            for (const [key, newChildMetadata] of Object.entries(newMetadataComponents)) {
                 // Stack: components/componentName
                 stackExecutor.execute(key, () => {
-                    const oldChildMetadata = oldMetadata?.components?.[key];
-                    const oldChildProfile = oldProfile?.components?.[key];
-                    const childProfile = newProfile.components[key];
+                    const oldChildMetadata = oldMetadataComponents?.[key];
+                    const oldChildProfile = oldProfileComponents?.[key];
+                    const newChildProfile = newProfileComponents[key];
                     const componentPath = curPath ? curPath + '/' + key : key;
                     const componentInstance = owner.components?.[key];
                     if (processor.stopped &&
-                        oldMetadata?.uri &&
-                        oldMetadata?.uri !== newMetadata.uri)
+                        oldChildProfile?.uri &&
+                        oldChildProfile?.uri !== newChildProfile.uri)
                         throw new SbError('Cannot change component class while processor running. You should stop it first.');
                     /** Validate sub-components */
-                    if (childMetadata.components && componentInstance) {
+                    if (newChildMetadata.components && componentInstance) {
                         _validateComponents({
                             ...ctx,
                             owner: componentInstance,
                             curPath: componentPath,
-                            newMetadata: childMetadata,
-                            newProfile: childProfile,
-                            oldMetadata: oldChildMetadata,
-                            oldProfile: oldChildProfile,
+                            newMetadataComponents: newChildMetadata.components,
+                            newProfileComponents: newChildProfile.components,
+                            oldMetadataComponents: oldChildMetadata?.components,
+                            oldProfileComponents: oldChildProfile?.components,
                         });
                     }
                 });
@@ -131,91 +132,90 @@ export var ProcessorFactory;
         });
     }
     async function _configureComponents(ctx) {
-        const { newMetadata, newProfile, stackExecutor } = ctx;
-        if (!newMetadata.components)
+        const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, processor, } = ctx;
+        if (!newMetadataComponents)
             return;
+        owner.components = owner.components || {};
         // Stack: components
         await stackExecutor.executeAsync('components', async () => {
-            for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
+            for (const [key, newChildMetadata] of Object.entries(newMetadataComponents)) {
                 // Stack: components/componentName
                 await stackExecutor.executeAsync(key, async () => {
-                    if (!newProfile.components?.[key]?.disabled)
-                        await _configureComponent(ctx, key, childMetadata);
-                });
-            }
-        });
-    }
-    async function _configureComponent(ctx, key, childMetadata) {
-        const { newProfile, oldMetadata, oldProfile, curPath, owner, processor } = ctx;
-        const childProfile = newProfile.components[key];
-        if (!childProfile?.uri)
-            return;
-        const oldChildMetadata = oldMetadata?.components?.[key];
-        const oldChildProfile = oldProfile?.components?.[key];
-        const componentPath = curPath ? curPath + '/' + key : key;
-        let componentInstance = owner.components?.[key];
-        /** Create the component only if the owner stopped */ // todo implement hotplug components
-        if (owner.stopped) {
-            const compReg = ExtensionRegistry.getComponent(childMetadata.uri);
-            /** Create the component instance */
-            const compClass = await compReg.getClass();
-            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 {
-            componentInstance.values = {};
-            const patchValues = (target, valPath, newValues, newVariables, oldValues, oldVariables) => {
-                if (oldValues)
-                    Object.assign(target, oldValues);
-                const updatedValues = ctx.valueUpdates.get(componentInstance) || [];
-                ctx.valueUpdates.set(componentInstance, updatedValues);
-                if (newVariables) {
-                    for (const [varKey, varMeta] of Object.entries(newVariables)) {
-                        const keyPath = valPath ? valPath + '.' + varKey : varKey;
-                        /** Update only hotplug variables */
-                        if (varMeta?.hotPlug !== true)
-                            continue;
-                        if (varMeta.type === 'nested') {
-                            target[varKey] = {};
-                            patchValues(target[varKey], keyPath, newValues[varKey], newVariables[varKey]?.variables || {}, oldValues?.[varKey], oldVariables?.[varKey]?.variables);
-                            continue;
+                    if (newProfileComponents?.[key]?.disabled)
+                        return;
+                    // Stack: components/componentName
+                    await stackExecutor.executeAsync(key, async () => {
+                        const oldChildMetadata = oldMetadataComponents?.[key];
+                        const oldChildProfile = oldProfileComponents?.[key];
+                        const newChildProfile = newProfileComponents[key];
+                        const componentPath = curPath ? curPath + '/' + key : key;
+                        let componentInstance = owner.components[key];
+                        /** Create the component only if the owner stopped */ // todo implement hotplug components
+                        if (owner.stopped) {
+                            const compReg = ExtensionRegistry.getComponent(newChildMetadata.classUri);
+                            /** Create the component instance */
+                            const compClass = await compReg.getClass();
+                            componentInstance = new compClass({
+                                processor: processor,
+                                parent: owner,
+                                name: key,
+                                path: componentPath,
+                                values: newChildProfile.values || {},
+                            });
+                            owner.components[key] = componentInstance;
+                            if (newChildMetadata.propertyKey)
+                                owner[newChildMetadata.propertyKey] = componentInstance;
                         }
-                        if (!equal(target[varKey], newValues[varKey])) {
-                            updatedValues.push(keyPath);
-                            target[varKey] = newValues[varKey];
+                        else {
+                            componentInstance.values = {};
+                            const patchValues = (target, valPath, newValues, newVariables, oldValues, oldVariables) => {
+                                if (oldValues)
+                                    Object.assign(target, oldValues);
+                                const updatedValues = ctx.valueUpdates.get(componentInstance) || [];
+                                ctx.valueUpdates.set(componentInstance, updatedValues);
+                                if (newVariables) {
+                                    for (const [varKey, varMeta] of Object.entries(newVariables)) {
+                                        const keyPath = valPath ? valPath + '.' + varKey : varKey;
+                                        /** Update only hotplug variables */
+                                        if (varMeta?.hotPlug !== true)
+                                            continue;
+                                        if (varMeta.type === 'nested') {
+                                            target[varKey] = {};
+                                            patchValues(target[varKey], keyPath, newValues[varKey], newVariables[varKey]?.variables || {}, oldValues?.[varKey], oldVariables?.[varKey]?.variables);
+                                            continue;
+                                        }
+                                        if (!equal(target[varKey], newValues[varKey])) {
+                                            updatedValues.push(keyPath);
+                                            target[varKey] = newValues[varKey];
+                                        }
+                                    }
+                                }
+                            };
+                            patchValues(componentInstance.values, '', newChildProfile.values || {}, newChildMetadata.variables || {}, oldChildProfile?.values, oldChildMetadata?.variables);
                         }
-                    }
-                }
-            };
-            patchValues(componentInstance.values, '', childProfile.values || {}, childMetadata.variables || {}, oldChildProfile?.values, oldChildMetadata?.variables);
-        }
-        /** Create the child logger */
-        componentInstance.logger = owner.logger?.child({
-            component: componentPath,
+                        /** Create the child logger */
+                        componentInstance.logger = owner.logger?.child({
+                            component: componentPath,
+                        });
+                        if (newChildProfile.settings?.logs?.level) {
+                            componentInstance.logger.level =
+                                newChildProfile.settings?.logs?.level;
+                        }
+                        /** Initialize sub components */
+                        if (newChildMetadata.components) {
+                            await _configureComponents({
+                                ...ctx,
+                                owner: componentInstance,
+                                curPath: componentPath,
+                                newMetadataComponents: newChildMetadata.components,
+                                newProfileComponents: newChildProfile.components,
+                                oldMetadataComponents: oldChildMetadata?.components,
+                                oldProfileComponents: oldChildProfile?.components,
+                            });
+                        }
+                    });
+                });
+            }
         });
-        if (childProfile.settings?.logs?.level) {
-            componentInstance.logger.level = childProfile.settings?.logs?.level;
-        }
-        /** Initialize sub components */
-        if (childMetadata.components) {
-            await _configureComponents({
-                ...ctx,
-                owner: componentInstance,
-                curPath: componentPath,
-                newMetadata: childMetadata,
-                newProfile: childProfile,
-                oldMetadata: oldChildMetadata,
-                oldProfile: oldChildProfile,
-            });
-        }
     }
 })(ProcessorFactory || (ProcessorFactory = {}));

package/utils/materialize-metadata.js

@@ -68,8 +68,7 @@ function _materializeComponents(stackExecutor, srcMetadata, profile, returnUndef
                     return;
                 }
                 materializedComponent = {
-                    abstract: true,
-                    uri: metadataComponent.uri,
+                    interfaceUri: metadataComponent.interfaceUri,
                     description: metadataComponent.description,
                     required: metadataComponent.required,
                 };
@@ -80,12 +79,15 @@ function _materializeComponents(stackExecutor, srcMetadata, profile, returnUndef
                 if (!profileComponent.uri)
                     throw new SbValidationError(`"uri" property required`);
                 const reg = ExtensionRegistry.getComponent(profileComponent.uri);
-                if (!(profileComponent.uri === metadataComponent.uri ||
-                    reg.metadata.interfaces?.includes(metadataComponent.uri)))
-                    throw new SbValidationError(`Selected component "${profileComponent.uri}" do not implement ${metadataComponent.uri}.`);
+                if (!(profileComponent.uri === metadataComponent.interfaceUri ||
+                    reg.metadata.interfaces?.includes(metadataComponent.interfaceUri)))
+                    throw new SbValidationError(`Selected component "${profileComponent.uri}" do not implement ${metadataComponent.interfaceUri}.`);
+                if (profileComponent.disabled && metadataComponent.required) {
+                    throw new SbValidationError(`Component "${componentName}" is disabled but it is required.`);
+                }
                 materializedComponent = {
-                    uri: profileComponent.uri,
-                    ...omit(metadataComponent, ['uri', 'variables']),
+                    classUri: profileComponent.uri,
+                    ...omit(metadataComponent, ['classUri', 'variables']),
                 };
                 materializedComponent.variables = merge({}, [reg.metadata.variables || {}, metadataComponent.variables || {}], { deep: 'full' });
                 materializedComponent.variables = sortVariables(materializedComponent.variables);