@syncbridge/common 0.11.0 → 0.12.1

package/classes/stack-executor.d.ts

@@ -3,8 +3,8 @@ 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<T>(stack: string, fn: () => NotPromise<T>): void;
+    executeAsync(stack: string, fn: () => Promise<any>): Promise<boolean>;
+    execute<T>(stack: string, fn: () => NotPromise<T>): boolean;
     handleError(e: any): void;
 }
 export declare namespace StackExecutor {

package/classes/stack-executor.js

@@ -14,6 +14,7 @@ export class StackExecutor {
         finally {
             this.stack.pop();
         }
+        return !this.issues.find(i => !(i.severity === 'warning' || i.severity === 'info'));
     }
     execute(stack, fn) {
         this.stack.push(stack);
@@ -26,6 +27,7 @@ export class StackExecutor {
         finally {
             this.stack.pop();
         }
+        return !this.issues.find(i => !(i.severity === 'warning' || i.severity === 'info'));
     }
     handleError(e) {
         const location = this.stack.join('/');

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.11.0';
+export const version = '0.12.1';
 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/component.decorator.js

@@ -9,7 +9,7 @@ import { resolvePackageJson } from '../utils/locate-package-json.js';
 import { defineOwnMetadata, parseNpmAuthor } from './decorator-helpers.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';
 import { UseVariables as _UseVariables } from './use-variables.decorator.js';
-const NAME_PATTERN = /^(.*?)(Component)?$/;
+const NAME_PATTERN = /^([A-Z][A-Za-z0-9_]*?)(Component)?$/;
 export function Component(options) {
     const callerFile = callerCallsite()?.getFileName();
     const pkgjson = callerFile && resolvePackageJson(path.dirname(callerFile));

package/decorators/define-variable.decorator.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import type { DeepPartial, StrictOmit, Type } from 'ts-gems';
 import { VariableMetadata, VariableMetadataRecord } from '../models/index.js';
-export declare function DefineVariable(options: DefineVariable.Options): (target: Object, propertyKey: string | symbol) => void;
+export declare function DefineVariable(options?: DefineVariable.Options): (target: Object, propertyKey: string | symbol) => void;
 type TEnumValue = (string | number)[] | Record<string, string | number>;
 type TVariable = DeepPartial<VariableMetadataRecord> | Type;
 export declare namespace DefineVariable {

package/decorators/define-variable.decorator.js

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { deepClone, merge, omitUndefined } from '@jsopen/objects';
 import { VARIABLE_CONTAINER } from '../constants.js';
 import { VariableMetadata, VariableMetadataRecord, VariableType, } from '../models/index.js';
-export function DefineVariable(options) {
+export function DefineVariable(options = {}) {
     return function (target, propertyKey) {
         /** c8 ignore next */
         if (typeof propertyKey !== 'string')
@@ -36,6 +36,8 @@ export function DefineVariable(options) {
                 metadata.type = VariableType.Boolean;
             else if (designType === Number)
                 metadata.type = VariableType.Number;
+            else if (designType === BigInt)
+                metadata.type = VariableType.BigInt;
             else if (typeof designType === 'function' &&
                 Reflect.hasMetadata(VARIABLE_CONTAINER, designType.prototype)) {
                 metadata.type = VariableType.Nested;

package/decorators/processor.decorator.d.ts

@@ -3,7 +3,7 @@ import type { DeepPartial, StrictOmit, Type } from 'ts-gems';
 import type { ProcessorBase } from '../classes/processor-base.js';
 import { ProcessorMetadata } from '../models/index.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';
-export declare function Processor<T extends ProcessorBase>(options: Processor.Options): (target: Type<T>) => void;
+export declare function Processor<T extends ProcessorBase>(options?: Processor.Options): (target: Type<T>) => void;
 export declare namespace Processor {
     /**
      *

package/decorators/processor.decorator.js

@@ -9,7 +9,7 @@ import { defineOwnMetadata } from './decorator-helpers.js';
 import { OnCreateProfile as _OnCreateProfile, OnUpdateProfile as _OnUpdateProfile, } from './processor-events.decorator.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';
 import { UseVariables as _UseVariables } from './use-variables.decorator.js';
-const NAME_PATTERN = /^(.*?)(Processor)?$/;
+const NAME_PATTERN = /^([A-Z][A-Za-z0-9_]*)(Processor)?$/;
 export function Processor(options) {
     const callerFile = callerCallsite()?.getFileName();
     const pkgjson = callerFile && resolvePackageJson(path.dirname(callerFile));
@@ -20,7 +20,7 @@ export function Processor(options) {
         if (classType && classType !== 'processor')
             throw new TypeError(`${target.name} already decorated as "${classType}"`);
         /** Determine class name */
-        let className = options.className;
+        let className = options?.className;
         if (!className) {
             const m = NAME_PATTERN.exec(target.name);
             if (!m)
@@ -39,7 +39,7 @@ export function Processor(options) {
             uri,
             displayName: className,
             version: pkgjson.version,
-            abstract: !!options.abstract,
+            abstract: !!options?.abstract,
             ...omit(options, ['uri', 'components', 'variables', 'version']),
         });
         target.uri = uri;

package/index.d.ts

@@ -20,5 +20,5 @@ export * from './registry/extension-registry.js';
 export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
 export * from './utils/normalize-metadata.js';
-export * from './utils/type-guartds.js';
+export * from './utils/type-guards.js';
 export * from './utils/uri-to-id.js';

package/index.js

@@ -20,5 +20,5 @@ export * from './registry/extension-registry.js';
 export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
 export * from './utils/normalize-metadata.js';
-export * from './utils/type-guartds.js';
+export * from './utils/type-guards.js';
 export * from './utils/uri-to-id.js';

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

@@ -55,7 +55,6 @@ __decorate([
     ApiField({
         label: 'Required',
         description: 'Determine if the component is required or not',
-        default: true,
     }),
     __metadata("design:type", Boolean)
 ], ElementComponentMetadata.prototype, "required", void 0);

package/package.json

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

package/processor-factory.d.ts

@@ -11,10 +11,16 @@ export declare namespace ProcessorFactory {
     }
     function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<T>;
     function createProcessorSilent<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<{
+        result: true;
         processor: T;
         issues: StackExecutor.Issue[];
+    } | {
+        result: false;
+        issues: StackExecutor.Issue[];
     }>;
-    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<{
+    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<void>;
+    function updateProcessorSilent(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<{
+        result: boolean;
         issues: StackExecutor.Issue[];
     }>;
 }

package/processor-factory.js

@@ -1,59 +1,91 @@
+import { clone } from '@jsopen/objects';
 import equal from 'fast-deep-equal';
 import { ComponentBase } from './classes/component-base.js';
 import { ProcessorBase } from './classes/processor-base.js';
 import { SbError, SbValidationError } from './classes/sb-error.js';
 import { StackExecutor } from './classes/stack-executor.js';
-import { ElementComponentMetadataRecord, Profile, ProfileComponentRecord, VariableMetadataRecord, } from './models/index.js';
+import { ElementComponentMetadataRecord, ProcessorMetadata, Profile, ProfileComponentRecord, VariableMetadataRecord, } from './models/index.js';
 import { initializeModelsDocument } from './models-document.js';
 import { ExtensionRegistry } from './registry/extension-registry.js';
-import { materializeMetadata } from './utils/materialize-metadata.js';
+import { decodeProfile } from './utils/decode-profile.js';
+import { materializeMetadataSilent } from './utils/materialize-metadata.js';
 export var ProcessorFactory;
 (function (ProcessorFactory) {
     ProcessorFactory.METADATA_KEY = Symbol('METADATA');
     ProcessorFactory.PROFILE_KEY = Symbol('PROFILE');
     async function createProcessor(profile, options) {
-        const { processor: out, issues } = await createProcessorSilent(profile, options);
-        if (issues?.length) {
+        const r1 = await createProcessorSilent(profile, options);
+        if (!r1.result) {
             const msg = 'Error while creating processor.\n  ' +
-                issues
+                r1.issues
                     .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                     .join('\n  ');
-            issues.forEach(issue => {
+            r1.issues.forEach(issue => {
                 if (issue instanceof SbValidationError)
                     delete issue.stack;
             });
             throw new SbValidationError(msg, {
-                issues,
+                issues: r1.issues,
             });
         }
-        return out;
+        return r1.processor;
     }
     ProcessorFactory.createProcessor = createProcessor;
     async function createProcessorSilent(profile, options) {
-        await initializeModelsDocument();
-        const reg = ExtensionRegistry.getProcessor(profile.processorUri, profile.processorVersion);
-        const processorClass = await reg.getClass();
-        const processor = new processorClass({
-            name: profile.displayName,
-            logger: options?.logger,
-            values: profile.values || {},
-            dataDirectory: options?.dataDirectory,
-        });
         const ctx = {
             stackExecutor: new StackExecutor(),
-            processor,
+            processor: undefined,
             profile,
             options,
-            valueUpdates: new Map(),
-        };
-        await _configureProcessor(ctx);
-        return {
-            processor: processor,
-            issues: ctx.stackExecutor.issues,
         };
+        try {
+            await initializeModelsDocument();
+            if (!(await _configureProcessor(ctx))) {
+                return {
+                    result: false,
+                    issues: ctx.stackExecutor.issues,
+                };
+            }
+            return {
+                result: true,
+                processor: ctx.processor,
+                issues: ctx.stackExecutor.issues,
+            };
+        }
+        catch (error) {
+            return {
+                result: false,
+                issues: [
+                    ...ctx.stackExecutor.issues,
+                    {
+                        message: error.message,
+                        type: 'error',
+                        severity: 'error',
+                        stack: error.stack,
+                    },
+                ],
+            };
+        }
     }
     ProcessorFactory.createProcessorSilent = createProcessorSilent;
     async function updateProcessor(processor, profile, options) {
+        const r1 = await updateProcessorSilent(processor, profile, options);
+        if (!r1.result) {
+            const msg = 'Error while updating processor.\n  ' +
+                r1.issues
+                    .map(issue => `- ${issue.message}. Location: /${issue.location}`)
+                    .join('\n  ');
+            r1.issues.forEach(issue => {
+                if (issue instanceof SbValidationError)
+                    delete issue.stack;
+            });
+            throw new SbValidationError(msg, {
+                issues: r1.issues,
+            });
+        }
+    }
+    ProcessorFactory.updateProcessor = updateProcessor;
+    async function updateProcessorSilent(processor, profile, options) {
         if (options?.logger)
             processor.logger = options.logger;
         if (options?.dataDirectory)
@@ -65,47 +97,82 @@ export var ProcessorFactory;
             options,
             valueUpdates: new Map(),
         };
-        await _configureProcessor(ctx);
+        if (!(await _configureProcessor(ctx))) {
+            return {
+                result: false,
+                issues: ctx.stackExecutor.issues,
+            };
+        }
         const signalUpdates = async (obj) => {
             if (obj.components) {
                 for (const component of Object.values(obj.components)) {
                     await signalUpdates(component);
                 }
             }
-            const properties = ctx.valueUpdates.get(obj);
+            const properties = ctx.valueUpdates?.get(obj);
             if (properties?.length) {
                 await obj.emitAsyncSafe('values-updated', properties);
             }
         };
         await signalUpdates(processor);
         return {
+            result: true,
             issues: ctx.stackExecutor.issues,
         };
     }
-    ProcessorFactory.updateProcessor = updateProcessor;
+    ProcessorFactory.updateProcessorSilent = updateProcessorSilent;
     async function _configureProcessor(ctx) {
-        const { processor, profile } = ctx;
-        const newMetadata = materializeMetadata(profile);
+        const r1 = materializeMetadataSilent(ctx.profile);
+        if (!r1.result) {
+            ctx.stackExecutor.issues.push(...r1.issues);
+            return false;
+        }
+        /* Decode profile */
+        const profile = decodeProfile(r1.metadata, ctx.profile);
+        ctx.profile = profile;
+        const oldMetadata = ctx.processor?.[ProcessorFactory.METADATA_KEY];
+        const oldProfile = ctx.processor?.[ProcessorFactory.PROFILE_KEY];
+        if (!ctx.processor) {
+            /* Create new processor instance */
+            const reg = ExtensionRegistry.getProcessor(profile.processorUri, profile.processorVersion);
+            const processorClass = await reg.getClass();
+            /* Create processor instance */
+            ctx.processor = new processorClass({
+                name: profile.displayName,
+                logger: ctx.options?.logger,
+                values: profile.values ? clone(profile.values) : {},
+                dataDirectory: ctx.options?.dataDirectory,
+            });
+        }
+        else {
+            /* Update values */
+            if (!ctx.stackExecutor.execute('values', () => {
+                _patchValues(ctx, ctx.processor, ctx.processor.values, '', profile.values, r1.metadata.variables || {}, oldProfile?.values, oldMetadata.variables);
+            })) {
+                return false;
+            }
+        }
         const cmpCtx = {
             ...ctx,
-            owner: processor,
+            owner: ctx.processor,
             curPath: '',
-            newMetadataComponents: newMetadata.components,
+            newMetadataComponents: r1.metadata.components,
             newProfileComponents: profile.components,
-            oldMetadataComponents: processor[ProcessorFactory.METADATA_KEY]?.components,
-            oldProfileComponents: processor[ProcessorFactory.PROFILE_KEY]?.components,
+            oldMetadataComponents: oldMetadata?.components,
+            oldProfileComponents: oldProfile?.components,
         };
-        _validateComponents(cmpCtx);
-        await _configureComponents(cmpCtx);
-        processor[ProcessorFactory.METADATA_KEY] = newMetadata;
-        processor[ProcessorFactory.PROFILE_KEY] = profile;
+        if (!(_validateComponents(cmpCtx) && (await _configureComponents(cmpCtx)))) {
+            return false;
+        }
+        ctx.processor[ProcessorFactory.METADATA_KEY] = r1.metadata;
+        ctx.processor[ProcessorFactory.PROFILE_KEY] = profile;
+        return true;
     }
     function _validateComponents(ctx) {
-        const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, processor, } = ctx;
+        const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, } = ctx;
         if (!newMetadataComponents)
-            return;
-        // Stack: components
-        stackExecutor.execute('components', () => {
+            return true;
+        return stackExecutor.execute('components', () => {
             for (const [key, newChildMetadata] of Object.entries(newMetadataComponents)) {
                 // Stack: components/componentName
                 stackExecutor.execute(key, () => {
@@ -114,10 +181,9 @@ export var ProcessorFactory;
                     const newChildProfile = newProfileComponents[key];
                     const componentPath = curPath ? curPath + '/' + key : key;
                     const componentInstance = owner.components?.[key];
-                    if (processor.stopped &&
-                        oldChildProfile?.uri &&
+                    if (oldChildProfile?.uri &&
                         oldChildProfile?.uri !== newChildProfile.uri)
-                        throw new SbError('Cannot change component class while processor running. You should stop it first.');
+                        throw new SbError(`You should not change uri of the component (${componentPath})`);
                     /** Validate sub-components */
                     if (newChildMetadata.components && componentInstance) {
                         _validateComponents({
@@ -137,10 +203,10 @@ export var ProcessorFactory;
     async function _configureComponents(ctx) {
         const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, processor, } = ctx;
         if (!newMetadataComponents)
-            return;
+            return true;
         owner.components = owner.components || {};
         // Stack: components
-        await stackExecutor.executeAsync('components', async () => {
+        return await stackExecutor.executeAsync('components', async () => {
             for (const [key, newChildMetadata] of Object.entries(newMetadataComponents)) {
                 // Stack: components/componentName
                 await stackExecutor.executeAsync(key, async () => {
@@ -153,17 +219,18 @@ export var ProcessorFactory;
                         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) {
+                        /** Create the component */
+                        if (!componentInstance) {
                             const compReg = ExtensionRegistry.getComponent(newChildMetadata.classUri);
                             /** Create the component instance */
                             const compClass = await compReg.getClass();
+                            const values = { ...newChildProfile.values };
                             componentInstance = new compClass({
                                 processor: processor,
                                 parent: owner,
                                 name: key,
                                 path: componentPath,
-                                values: newChildProfile.values || {},
+                                values,
                             });
                             owner.components[key] = componentInstance;
                             if (newChildMetadata.propertyKey)
@@ -171,30 +238,7 @@ export var ProcessorFactory;
                         }
                         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(ctx, componentInstance, componentInstance.values, '', newChildProfile.values || {}, newChildMetadata.variables || {}, oldChildProfile?.values, oldChildMetadata?.variables);
                         }
                         /** Create the child logger */
                         componentInstance.logger = owner.logger?.child({
@@ -204,7 +248,7 @@ export var ProcessorFactory;
                             componentInstance.logger.level =
                                 newChildProfile.settings?.logs?.level;
                         }
-                        /** Initialize sub components */
+                        /** Initialize sub-components */
                         if (newChildMetadata.components) {
                             await _configureComponents({
                                 ...ctx,
@@ -221,4 +265,27 @@ export var ProcessorFactory;
             }
         });
     }
+    function _patchValues(ctx, instance, target, valPath, newValues, newVariables, oldValues, oldVariables) {
+        if (oldValues)
+            Object.assign(target, oldValues);
+        const updatedValues = ctx.valueUpdates?.get(instance) || [];
+        ctx.valueUpdates?.set(instance, 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(ctx, instance, 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];
+                }
+            }
+        }
+    }
 })(ProcessorFactory || (ProcessorFactory = {}));

package/registry/extension-package.js

@@ -4,7 +4,7 @@ import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';
 import { SbError } from '../classes/sb-error.js';
 import { ComponentMetadata, ElementMetadata, ProcessorMetadata, } from '../models/index.js';
-import { isComponentBase, isProcessorBase } from '../utils/type-guartds.js';
+import { isComponentBase, isProcessorBase } from '../utils/type-guards.js';
 /**
  *
  */

package/utils/materialize-metadata.d.ts

@@ -8,6 +8,10 @@ export declare function materializeMetadata(profile: Profile, returnUndefinedCom
  *
  */
 export declare function materializeMetadataSilent(profile: Profile, returnUndefinedComponentsAsAbstract?: boolean): {
+    result: true;
     metadata: ProcessorMetadata;
-    issues?: StackExecutor.Issue[];
+    issues: StackExecutor.Issue[];
+} | {
+    result: false;
+    issues: StackExecutor.Issue[];
 };

package/utils/materialize-metadata.js

@@ -7,22 +7,22 @@ import { ExtensionRegistry } from '../registry/extension-registry.js';
  * Materializes metadata from profile.
  */
 export function materializeMetadata(profile, returnUndefinedComponentsAsAbstract) {
-    const { metadata, issues } = materializeMetadataSilent(profile, returnUndefinedComponentsAsAbstract);
-    if (issues?.length) {
+    const r = materializeMetadataSilent(profile, returnUndefinedComponentsAsAbstract);
+    if (!r.result) {
         const msg = 'Worker profile validation error.\n  ' +
-            issues
+            r.issues
                 .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                 .join('\n  ');
-        issues.forEach(issue => {
+        r.issues.forEach(issue => {
             if (issue instanceof SbValidationError)
                 delete issue.stack;
         });
         throw new SbValidationError(msg, {
             workerId: profile.id,
-            issues,
+            issues: r.issues,
         });
     }
-    return metadata;
+    return r.metadata;
 }
 /**
  *
@@ -48,8 +48,8 @@ export function materializeMetadataSilent(profile, returnUndefinedComponentsAsAb
         });
     }
     if (stackExecutor.issues?.length)
-        return { metadata, issues: stackExecutor.issues };
-    return { metadata };
+        return { result: false, issues: stackExecutor.issues };
+    return { result: true, metadata, issues: stackExecutor.issues };
 }
 /**
  *

package/utils/normalize-metadata.js

@@ -39,7 +39,8 @@ export async function normalizeProcessorMetadataSilent(metadata) {
     cloned.variables = normalizeVariables(cloned.variables);
     cloned.components = normalizeComponents(cloned.components);
     const { value, errors } = decoder.silent(cloned);
-    merge(value, metadata, { keepExisting: true, deep: 'full' });
+    if (value)
+        merge(value, metadata, { keepExisting: true, deep: 'full' });
     return {
         metadata: value || cloned,
         issues: errors?.map(x => ({
@@ -84,7 +85,8 @@ export async function normalizeComponentMetadataSilent(metadata) {
     cloned.variables = normalizeVariables(cloned.variables);
     cloned.components = normalizeComponents(cloned.components);
     const { value, errors } = decoder.silent(cloned);
-    merge(value, metadata, { keepExisting: true, deep: 'full' });
+    if (value)
+        merge(value, metadata, { keepExisting: true, deep: 'full' });
     return {
         metadata: value || cloned,
         issues: errors?.map(x => ({