@syncbridge/common 0.5.12 → 0.6.1

package/classes/base-element.js

@@ -12,8 +12,10 @@ export class BaseElement extends Runnable {
         this.logger = init.logger;
         this.name = init.name;
         this.values = init.values;
-        if (this.logger)
-            this.on('error', err => this.logger?.error(err));
+        this.on('error', err => this.logger?.error(err));
+        this.on('values-updated', (properties) => {
+            this.logger?.info(`Configuration changed. Updated properties: ${properties.join(',')}`);
+        });
     }
     get status() {
         return this._context.calculatedStatus || this._context.status;

package/classes/sb-error.d.ts

@@ -1,11 +1,16 @@
-export declare class SbError extends Error {
+import { ErrorIssue } from '@opra/common';
+export declare class SbError extends Error implements ErrorIssue {
     readonly cause?: Error;
+    severity: ErrorIssue['severity'];
     code?: string;
     [index: string]: any;
     constructor(message?: string | Error, options?: SbErrorOptions);
-    toJSON(): any;
 }
-export interface SbErrorOptions {
+export interface SbErrorOptions extends Partial<ErrorIssue> {
     cause?: Error;
-    [key: string]: any;
+}
+/**
+ *
+ */
+export declare class SbValidationError extends SbError {
 }

package/classes/sb-error.js

@@ -1,5 +1,6 @@
 import { isPlainObject } from '@jsopen/objects';
 export class SbError extends Error {
+    severity = 'error';
     code;
     constructor(message, options) {
         super(typeof message === 'object' ? message.message || '' : message);
@@ -41,14 +42,9 @@ export class SbError extends Error {
             }
         }
     }
-    toJSON() {
-        const out = {
-            message: this.message,
-        };
-        for (const k of Object.keys(this)) {
-            if (k !== 'stack')
-                out[k] = this[k];
-        }
-        return out;
-    }
+}
+/**
+ *
+ */
+export class SbValidationError extends SbError {
 }

package/classes/stack-executor.js

@@ -1,4 +1,5 @@
 import { ValidationError } from 'valgen';
+import { SbValidationError } from './sb-error.js';
 export class StackExecutor {
     stack = [];
     issues = [];
@@ -30,20 +31,16 @@ export class StackExecutor {
         const location = this.stack.join('/');
         if (e instanceof ValidationError) {
             e.issues.forEach(x => {
-                this.issues.push({
-                    ...x,
-                    severity: 'error',
-                    location: location + (x.location ? '/' + x.location : ''),
-                });
+                const issue = new SbValidationError(x.message, x);
+                x.severity = x.severity ?? 'error';
+                x.location = location + (x.location ? '/' + x.location : '');
+                this.issues.push(issue);
             });
         }
         else {
-            this.issues.push({
-                message: e.message,
-                ...e,
-                severity: 'error',
-                location,
-            });
+            e.severity = e.severity ?? 'error';
+            e.location = location;
+            this.issues.push(e);
         }
     }
 }

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.5.12';
+export const version = '0.6.1';
 export const OWN_ELEMENT_METADATA = Symbol.for('OWN_ELEMENT_METADATA');
 export const COMPONENT_OPTIONS = Symbol.for('COMPONENT_OPTIONS');
 export const PROCESSOR_OPTIONS = Symbol.for('PROCESSOR_OPTIONS');

package/index.d.ts

@@ -16,5 +16,5 @@ export * from './models-document.js';
 export * from './processor-factory.js';
 export * from './registry/extension-package.js';
 export * from './registry/extension-registry.js';
-export * from './utils/metadata-utils.js';
-export * from './utils/profile-utils.js';
+export * from './utils/decode-profile.js';
+export * from './utils/materialize-metadata.js';

package/index.js

@@ -16,5 +16,5 @@ export * from './models-document.js';
 export * from './processor-factory.js';
 export * from './registry/extension-package.js';
 export * from './registry/extension-registry.js';
-export * from './utils/metadata-utils.js';
-export * from './utils/profile-utils.js';
+export * from './utils/decode-profile.js';
+export * from './utils/materialize-metadata.js';

package/models-document.js

@@ -1,4 +1,5 @@
 import { ApiDocumentFactory } from '@opra/common';
+import { SbError } from './classes/sb-error.js';
 import * as models from './models/index.js';
 let doc;
 export async function initializeModelsDocument() {
@@ -11,6 +12,8 @@ export async function initializeModelsDocument() {
 }
 export function getModelsDocument() {
     if (!doc)
-        throw new Error('You must call initializeModelsDocument() first');
+        throw new SbError('You must call initializeModelsDocument() first', {
+            severity: 'fatal',
+        });
     return doc;
 }

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.5.12",
+  "version": "0.6.1",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",
   "dependencies": {
     "@jsopen/objects": "^2.1.1",
+    "fast-deep-equal": "^3.1.3",
     "node-events-async": "^1.5.0",
     "reflect-metadata": "^0.2.2",
     "semver": "^7.7.4",
     "ts-gems": "^3.11.3",
-    "valgen": "^5.19.4"
+    "valgen": "^5.19.5"
   },
   "peerDependencies": {
     "@opra/common": ">=1.17.1 <2"

package/processor-factory.js

@@ -1,7 +1,9 @@
+import equal from 'fast-deep-equal';
+import { SbError } from './classes/sb-error.js';
 import { StackExecutor } from './classes/stack-executor.js';
 import { initializeModelsDocument } from './models-document.js';
 import { ExtensionRegistry } from './registry/extension-registry.js';
-import { materializeMetadata } from './utils/metadata-utils.js';
+import { materializeMetadata } from './utils/materialize-metadata.js';
 export var ProcessorFactory;
 (function (ProcessorFactory) {
     ProcessorFactory.METADATA_KEY = Symbol('METADATA');
@@ -49,11 +51,12 @@ export var ProcessorFactory;
                     await signalUpdates(component);
                 }
             }
-            if (ctx.valueUpdates.has(obj)) {
-                await obj.emitAsyncSafe('values-updated', ctx.valueUpdates.get(obj));
+            const properties = ctx.valueUpdates.get(obj);
+            if (properties?.length) {
+                await obj.emitAsyncSafe('values-updated', properties);
             }
         };
-        signalUpdates(processor);
+        await signalUpdates(processor);
         return {
             issues: ctx.stackExecutor.issues,
         };
@@ -92,8 +95,7 @@ export var ProcessorFactory;
                     if (processor.stopped &&
                         oldMetadata?.className &&
                         oldMetadata?.className !== newMetadata.className)
-                        throw new Error('Can not change component class while processor running. You should stop it first.');
-                    ExtensionRegistry.getComponent(childMetadata.className);
+                        throw new SbError('Cannot change component class while processor running. You should stop it first.');
                     /** Validate sub components */
                     if (childMetadata.components) {
                         _validateComponents({
@@ -125,14 +127,14 @@ export var ProcessorFactory;
         });
     }
     async function _configureComponent(ctx, key, childMetadata) {
-        const { newMetadata, newProfile, oldMetadata, oldProfile, curPath, owner, processor, } = ctx;
+        const { newProfile, oldMetadata, oldProfile, curPath, owner, processor } = ctx;
         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 the component only if the processor stopped */
-        if (processor.stopped) {
+        /** Create the component only if the owner stopped */ // todo implement hotplug components
+        if (owner.stopped) {
             const compReg = ExtensionRegistry.getComponent(childMetadata.className);
             /** Create the component instance */
             const compClass = await compReg.getClass();
@@ -150,26 +152,30 @@ export var ProcessorFactory;
         }
         else {
             componentInstance.values = {};
-            const patchValues = (target, valPath, newValues, newVariables, oldVariables, oldValues) => {
-                Object.assign(target, newValues);
-                const updatedValues = [];
-                for (const [varKey, varMeta] of Object.entries(newMetadata)) {
-                    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 || {}, oldVariables?.[varKey]?.variables, oldValues?.[varKey]);
-                        continue;
+            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];
+                        }
                     }
-                    updatedValues.push(keyPath);
-                    target[varKey] = newValues[varKey];
                 }
-                if (updatedValues.length)
-                    ctx.valueUpdates.set(componentInstance, updatedValues);
             };
-            patchValues(componentInstance.values, '', childProfile.values || {}, childMetadata.variables || {}, oldChildMetadata?.variables, oldProfile?.values);
+            patchValues(componentInstance.values, '', childProfile.values || {}, childMetadata.variables || {}, oldChildProfile?.values, oldChildMetadata?.variables);
         }
         /** Create the child logger */
         componentInstance.logger = owner.logger?.child({

package/registry/extension-package.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { updateErrorMessage } from '@jsopen/objects';
+import { SbError } from '../classes/sb-error.js';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
 import { isComponentBase, isProcessorBase } from '../utils/type-guartds.js';
 import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './helpers.js';
@@ -26,10 +27,10 @@ export class ExtensionPackage {
     static async fromDirectory(directory) {
         let filename = path.join(directory, 'package.json');
         if (!fs.existsSync(filename))
-            throw new TypeError(`Directory "${directory}" does not contain package.json`);
+            throw new SbError(`Directory "${directory}" does not contain package.json`);
         const pkgJson = JSON.parse(fs.readFileSync(filename, 'utf8'));
         if (!pkgJson.syncbridge)
-            throw new TypeError(`"${pkgJson.name}" is not a SyncBridge extension package`);
+            throw new SbError(`"${pkgJson.name}" is not a SyncBridge extension package`);
         const out = new ExtensionPackage();
         out.name = pkgJson.name;
         out.version = pkgJson.version;
@@ -100,7 +101,7 @@ export class ExtensionPackage {
         let entryPoint = (resolver || import.meta.resolve)(specifier);
         const pkgJson = locatePkgJson(path.dirname(entryPoint));
         if (!pkgJson) {
-            throw new TypeError(`Can't locate package.json file for "${specifier}"`);
+            throw new SbError(`Can't locate package.json file for "${specifier}"`);
         }
         if (path.isAbsolute(entryPoint) && process.platform === 'win32') {
             entryPoint = pathToFileURL(entryPoint).href;
@@ -178,11 +179,11 @@ export class ComponentExtension {
         const module = await import(this.pkg.entryPoint);
         const ctor = module[this.exportName];
         if (!ctor)
-            throw new TypeError(`Exported component "${this.exportName}" not found in package "${this.pkg.name}"`);
+            throw new SbError(`Exported component "${this.exportName}" not found in package "${this.pkg.name}"`);
         if (typeof ctor !== 'function')
-            throw new TypeError(`Exported component "${this.exportName}" is not a class`);
+            throw new SbError(`Exported component "${this.exportName}" is not a class`);
         if (!isComponentBase(ctor.prototype))
-            throw new TypeError(`Exported component "${this.exportName}" does not extends ComponentBase`);
+            throw new SbError(`Exported component "${this.exportName}" does not extends ComponentBase`);
         this._ctor = ctor;
         return this._ctor;
     }
@@ -216,11 +217,11 @@ export class ProcessorExtension {
         const module = await import(this.pkg.entryPoint);
         const ctor = module[this.exportName];
         if (!ctor)
-            throw new TypeError(`Exported processor "${this.exportName}" not found in package "${this.pkg.name}"`);
+            throw new SbError(`Exported processor "${this.exportName}" not found in package "${this.pkg.name}"`);
         if (typeof ctor !== 'function')
-            throw new TypeError(`Exported processor "${this.exportName}" is not a class`);
+            throw new SbError(`Exported processor "${this.exportName}" is not a class`);
         if (!isProcessorBase(ctor.prototype))
-            throw new TypeError(`Exported processor "${this.exportName}" does not extends ProcessorBase`);
+            throw new SbError(`Exported processor "${this.exportName}" does not extends ProcessorBase`);
         this._ctor = ctor;
         return this._ctor;
     }

package/registry/extension-registry.js

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { SbError } from '../classes/sb-error.js';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
 import { ComponentExtension, ExtensionPackage, ProcessorExtension, } from './extension-package.js';
 import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './helpers.js';
@@ -24,7 +25,7 @@ export var ExtensionRegistry;
         const cmp = findComponent(className, version);
         if (cmp)
             return cmp;
-        throw new Error(`Component "${className}" version "${version}" not found in registry`);
+        throw new SbError(`Component "${className}" version "${version}" not found in registry`);
     }
     ExtensionRegistry.getComponent = getComponent;
     /**
@@ -42,7 +43,7 @@ export var ExtensionRegistry;
     function getProcessor(className, version = '*') {
         const cmp = findProcessor(className, version);
         if (!cmp) {
-            throw new Error(`Processor "${className}" version "${version}" not found in registry`);
+            throw new SbError(`Processor "${className}" version "${version}" not found in registry`);
         }
         return cmp;
     }
@@ -75,7 +76,7 @@ export var ExtensionRegistry;
     async function registerComponent(ctor) {
         const _metadata = Reflect.getMetadata(COMPONENT_OPTIONS, ctor);
         if (!_metadata)
-            throw new TypeError(`Class "${ctor.name}" has no component metadata.`);
+            throw new SbError(`Class "${ctor.name}" has no component metadata.`);
         if (_metadata.abstract)
             return;
         const metadata = await normalizeComponentMetadata(_metadata);
@@ -100,7 +101,7 @@ export var ExtensionRegistry;
     async function registerProcessor(ctor) {
         const _metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, ctor);
         if (!_metadata)
-            throw new TypeError(`Class "${ctor.name}" has no processor metadata.`);
+            throw new SbError(`Class "${ctor.name}" has no processor metadata.`);
         if (_metadata.abstract)
             return;
         const metadata = await normalizeProcessorMetadata(_metadata);

package/utils/{profile-utils.js → decode-profile.js}

@@ -1,5 +1,5 @@
 import { isAny, isBase64, isBoolean, isDateString, isEmail, isHex, isNumber, isString, isTime, isURL, validator, vg, } from 'valgen';
-import { SbError } from '../classes/sb-error.js';
+import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
 import { Profile, VariableType, } from '../models/index.js';
 import { getModelsDocument } from '../models-document.js';
@@ -14,7 +14,7 @@ export function decodeProfile(materializedMetadata, rawProfile, options) {
             issues
                 .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                 .join('\n  ');
-        throw new SbError(msg, {
+        throw new SbValidationError(msg, {
             workerId: rawProfile.id,
             issues,
         });
@@ -75,11 +75,7 @@ function _codecProcessElement(stackExecutor, codec, metadata, profile, options)
             for (const [k, defComponent] of Object.entries(metadata.components)) {
                 if (!profile.components[k]) {
                     if (defComponent.required) {
-                        stackExecutor.issues.push({
-                            message: `Component "${k}" is required`,
-                            severity: 'error',
-                            location: `/components/${k}`,
-                        });
+                        stackExecutor.issues.push(new SbValidationError(`Component "${k}" is required`));
                     }
                     continue;
                 }

package/utils/{metadata-utils.js → materialize-metadata.js}

@@ -1,5 +1,5 @@
 import { clone, merge, omitUndefined } from '@jsopen/objects';
-import { SbError } from '../classes/sb-error.js';
+import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
 import { VariableType, } from '../models/index.js';
 import { ExtensionRegistry } from '../registry/extension-registry.js';
@@ -13,7 +13,7 @@ export function materializeMetadata(profile) {
             issues
                 .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                 .join('\n  ');
-        throw new SbError(msg, {
+        throw new SbValidationError(msg, {
             workerId: profile.id,
             issues,
         });
@@ -67,12 +67,12 @@ function _materializeComponents(stackExecutor, metadata, profile) {
             const profileComponent = profile?.components?.[componentName];
             if (!profileComponent) {
                 if (metadataComponent.required)
-                    throw new Error(`Component "${componentName}" should be configured`);
+                    throw new SbValidationError(`Component "${componentName}" should be configured`);
                 return;
             }
             /** istanbul ignore next */
             if (!profileComponent.className)
-                throw new Error(`"className" property required`);
+                throw new SbValidationError(`"className" property required`);
             const reg = ExtensionRegistry.getComponent(profileComponent.className);
             materializedComponent.className = profileComponent.className;
             materializedComponent.variables = merge({}, [reg.metadata.variables || {}, metadataComponent.variables || {}], { deep: 'full' });
@@ -80,14 +80,14 @@ function _materializeComponents(stackExecutor, metadata, profile) {
             if (metadataComponent.className) {
                 if (materializedComponent.className &&
                     materializedComponent.className !== metadataComponent.className)
-                    throw new Error(`Selected component class "${profileComponent.className}" do not match with definition component class (${metadataComponent.className}).`);
+                    throw new SbValidationError(`Selected component class "${profileComponent.className}" do not match with definition component class (${metadataComponent.className}).`);
             }
             else {
                 const requiredInterfaces = metadataComponent.interfaces || [];
                 const implementations = reg.metadata.interfaces || [];
                 const filtered = requiredInterfaces.filter(x => !implementations.includes(x));
                 if (filtered.length) {
-                    throw new Error(`Selected component "${profileComponent.className}" do not implements some of required interfaces (${filtered.join(',')}).`);
+                    throw new SbValidationError(`Selected component "${profileComponent.className}" do not implements some of required interfaces (${filtered.join(',')}).`);
                 }
             }
             if (materializedComponent.variables) {