@syncbridge/common 0.5.11 → 0.5.12

package/classes/base-element.d.ts

@@ -28,6 +28,7 @@ export declare namespace BaseElement {
             status: ServiceStatus,
             statusMessage: string
         ];
+        'values-updated': [string[]];
     }
     interface InitArgs extends Runnable.InitArgs {
         logger?: ILogger;

package/classes/base-element.js

@@ -48,7 +48,9 @@ export class BaseElement extends Runnable {
         await Promise.all(Object.values(this.components).map(component => component.init()));
     }
     async _start(abortSignal) {
-        await Promise.all(Object.values(this.components).map(component => component.start(abortSignal)));
+        if (this.status === ServiceStatus.starting ||
+            this.status === ServiceStatus.started)
+            await Promise.all(Object.values(this.components).map(component => component.start(abortSignal)));
     }
     async _stop() {
         await Promise.all(Object.values(this.components)

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.5.11';
+export const version = '0.5.12';
 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/models/enums/log-level.d.ts

@@ -5,6 +5,7 @@ export declare enum LogLevel {
     error = "error",
     warn = "warn",
     info = "info",
+    verbose = "verbose",
     trace = "trace",
     debug = "debug"
 }

package/models/enums/log-level.js

@@ -7,6 +7,7 @@ export var LogLevel;
     LogLevel["error"] = "error";
     LogLevel["warn"] = "warn";
     LogLevel["info"] = "info";
+    LogLevel["verbose"] = "verbose";
     LogLevel["trace"] = "trace";
     LogLevel["debug"] = "debug";
 })(LogLevel || (LogLevel = {}));

package/package.json

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

package/processor-factory.d.ts

@@ -6,12 +6,14 @@ export declare namespace ProcessorFactory {
     const METADATA_KEY: unique symbol;
     const PROFILE_KEY: unique symbol;
     interface ProcessorOptions {
-        logger: ILogger;
+        logger?: ILogger;
         dataDirectory?: string;
     }
     function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<{
         processor: T;
         issues: StackExecutor.Issue[];
     }>;
-    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<StackExecutor.Issue[]>;
+    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<{
+        issues: StackExecutor.Issue[];
+    }>;
 }

package/processor-factory.js

@@ -16,10 +16,17 @@ export var ProcessorFactory;
             values: profile.values || {},
             dataDirectory: options?.dataDirectory,
         });
-        const issues = await _configureProcessor(processor, profile);
+        const ctx = {
+            stackExecutor: new StackExecutor(),
+            processor,
+            profile,
+            options,
+            valueUpdates: new Map(),
+        };
+        await _configureProcessor(ctx);
         return {
             processor: processor,
-            issues,
+            issues: ctx.stackExecutor.issues,
         };
     }
     ProcessorFactory.createProcessor = createProcessor;
@@ -28,69 +35,160 @@ export var ProcessorFactory;
             processor.logger = options.logger;
         if (options?.dataDirectory)
             processor.dataDirectory = options.dataDirectory;
-        return _configureProcessor(processor, profile);
+        const ctx = {
+            stackExecutor: new StackExecutor(),
+            processor,
+            profile,
+            options,
+            valueUpdates: new Map(),
+        };
+        await _configureProcessor(ctx);
+        const signalUpdates = async (obj) => {
+            if (obj.components) {
+                for (const component of Object.values(obj.components)) {
+                    await signalUpdates(component);
+                }
+            }
+            if (ctx.valueUpdates.has(obj)) {
+                await obj.emitAsyncSafe('values-updated', ctx.valueUpdates.get(obj));
+            }
+        };
+        signalUpdates(processor);
+        return {
+            issues: ctx.stackExecutor.issues,
+        };
     }
     ProcessorFactory.updateProcessor = updateProcessor;
-    async function _configureProcessor(processor, profile) {
-        const processorMetadata = materializeMetadata(profile);
-        const stackExecutor = new StackExecutor();
-        async function configureComponents(owner, curPath, newMetadata, newProfile, oldMetadata, oldProfile) {
-            if (!newMetadata.components)
-                return;
-            // Stack: components
-            await stackExecutor.executeAsync('components', async () => {
-                for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
-                    // Stack: components/componentName
-                    await stackExecutor.executeAsync(key, async () => {
-                        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 = 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 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,
+    async function _configureProcessor(ctx) {
+        const { processor, profile } = ctx;
+        const cmpCtx = {
+            ...ctx,
+            owner: processor,
+            curPath: '',
+            newMetadata: materializeMetadata(profile),
+            newProfile: profile,
+            oldMetadata: processor[ProcessorFactory.METADATA_KEY],
+            oldProfile: processor[ProcessorFactory.PROFILE_KEY],
+        };
+        _validateComponents(cmpCtx);
+        await _configureComponents(cmpCtx);
+        processor[ProcessorFactory.METADATA_KEY] = cmpCtx.newMetadata;
+        processor[ProcessorFactory.PROFILE_KEY] = profile;
+    }
+    function _validateComponents(ctx) {
+        const { newMetadata, newProfile, oldMetadata, oldProfile, curPath, owner, stackExecutor, processor, } = ctx;
+        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;
+                    const componentInstance = owner.components?.[key];
+                    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);
+                    /** Validate sub components */
+                    if (childMetadata.components) {
+                        _validateComponents({
+                            ...ctx,
+                            owner: componentInstance,
+                            curPath: componentPath,
+                            newMetadata: childMetadata,
+                            newProfile: childProfile,
+                            oldMetadata: oldChildMetadata,
+                            oldProfile: oldChildProfile,
                         });
-                        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);
-                        }
-                    });
+                    }
+                });
+            }
+        });
+    }
+    async function _configureComponents(ctx) {
+        const { newMetadata, stackExecutor } = ctx;
+        if (!newMetadata.components)
+            return;
+        // Stack: components
+        await stackExecutor.executeAsync('components', async () => {
+            for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
+                // Stack: components/componentName
+                await stackExecutor.executeAsync(key, async () => {
+                    await _configureComponent(ctx, key, childMetadata);
+                });
+            }
+        });
+    }
+    async function _configureComponent(ctx, key, childMetadata) {
+        const { newMetadata, 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) {
+            const compReg = ExtensionRegistry.getComponent(childMetadata.className);
+            /** 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, 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;
+                    }
+                    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);
+        }
+        /** 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) {
+            await _configureComponents({
+                ...ctx,
+                owner: componentInstance,
+                curPath: componentPath,
+                newMetadata: childMetadata,
+                newProfile: childProfile,
+                oldMetadata: oldChildMetadata,
+                oldProfile: oldChildProfile,
             });
         }
-        await configureComponents(processor, '', processorMetadata, profile, processor[ProcessorFactory.METADATA_KEY], processor[ProcessorFactory.PROFILE_KEY]);
-        processor[ProcessorFactory.METADATA_KEY] = processorMetadata;
-        processor[ProcessorFactory.PROFILE_KEY] = profile;
-        return stackExecutor.issues;
     }
 })(ProcessorFactory || (ProcessorFactory = {}));