@syncbridge/common 0.12.1 → 0.12.3

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.12.1';
+export const version = '0.12.3';
 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/models/profile/log-options.js

@@ -16,7 +16,6 @@ __decorate([
     ApiField({
         label: 'Level',
         description: 'Determines the log level',
-        default: LogLevel.info,
     }),
     __metadata("design:type", String)
 ], LogOptions.prototype, "level", void 0);
@@ -45,7 +44,6 @@ __decorate([
     ApiField({
         label: 'Pipe To Main',
         description: 'Determines if logs will be piped to application terminal',
-        default: true,
     }),
     __metadata("design:type", Boolean)
 ], ProfileLogOptions.prototype, "pipeToMain", void 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",
@@ -12,7 +12,7 @@
     "reflect-metadata": "^0.2.2",
     "semver": "^7.8.0",
     "ts-gems": "^3.12.0",
-    "valgen": "^6.1.0"
+    "valgen": "^6.2.0"
   },
   "peerDependencies": {
     "@opra/common": ">=1.17.1 <2"

package/processor-factory.js

@@ -7,8 +7,7 @@ import { StackExecutor } from './classes/stack-executor.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 { decodeProfile } from './utils/decode-profile.js';
-import { materializeMetadataSilent } from './utils/materialize-metadata.js';
+import { decodeProfileSilent } from './utils/decode-profile.js';
 export var ProcessorFactory;
 (function (ProcessorFactory) {
     ProcessorFactory.METADATA_KEY = Symbol('METADATA');
@@ -122,32 +121,31 @@ export var ProcessorFactory;
     }
     ProcessorFactory.updateProcessorSilent = updateProcessorSilent;
     async function _configureProcessor(ctx) {
-        const r1 = materializeMetadataSilent(ctx.profile);
+        /* Decode profile */
+        const r1 = decodeProfileSilent(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;
+        ctx.profile = r1.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 reg = ExtensionRegistry.getProcessor(r1.profile.processorUri, r1.profile.processorVersion);
             const processorClass = await reg.getClass();
             /* Create processor instance */
             ctx.processor = new processorClass({
-                name: profile.displayName,
+                name: r1.profile.displayName,
                 logger: ctx.options?.logger,
-                values: profile.values ? clone(profile.values) : {},
+                values: r1.profile.values ? clone(r1.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);
+                _patchValues(ctx, ctx.processor, ctx.processor.values, '', r1.profile.values, r1.metadata.variables || {}, oldProfile?.values, oldMetadata.variables);
             })) {
                 return false;
             }
@@ -157,7 +155,7 @@ export var ProcessorFactory;
             owner: ctx.processor,
             curPath: '',
             newMetadataComponents: r1.metadata.components,
-            newProfileComponents: profile.components,
+            newProfileComponents: r1.profile.components,
             oldMetadataComponents: oldMetadata?.components,
             oldProfileComponents: oldProfile?.components,
         };
@@ -165,7 +163,7 @@ export var ProcessorFactory;
             return false;
         }
         ctx.processor[ProcessorFactory.METADATA_KEY] = r1.metadata;
-        ctx.processor[ProcessorFactory.PROFILE_KEY] = profile;
+        ctx.processor[ProcessorFactory.PROFILE_KEY] = r1.profile;
         return true;
     }
     function _validateComponents(ctx) {

package/utils/decode-profile.d.ts

@@ -7,19 +7,28 @@ export interface CodecOptions {
 /**
  * Decodes profile
  */
-export declare function decodeProfile(materializedMetadata: ProcessorMetadata, rawProfile: Profile, options?: CodecOptions): Profile;
-export declare function decodeProfileSilent(materializedMetadata: ProcessorMetadata, rawProfile: Profile, options?: CodecOptions): {
+export declare function decodeProfile(profile: Profile, options?: CodecOptions): Profile;
+export declare function decodeProfileSilent(profile: Profile, options?: CodecOptions): {
+    result: true;
     profile: Profile;
+    metadata: ProcessorMetadata;
     issues?: StackExecutor.Issue[];
+} | {
+    result: false;
+    issues: StackExecutor.Issue[];
 };
 /**
  * Encodes profile
  */
-export declare function encodeProfile(materializedMetadata: ProcessorMetadata, rawProfile: Profile, options?: CodecOptions): Profile;
+export declare function encodeProfile(rawProfile: Profile, options?: CodecOptions): Profile;
 /**
  * Encodes profile
  */
-export declare function encodeProfileSilent(metadata: ProcessorMetadata, rawProfile: Profile, options?: CodecOptions): {
+export declare function encodeProfileSilent(profile: Profile, options?: CodecOptions): {
+    result: true;
     profile: Profile;
     issues?: StackExecutor.Issue[];
+} | {
+    result: false;
+    issues: StackExecutor.Issue[];
 };

package/utils/decode-profile.js

@@ -4,82 +4,102 @@ import { StackExecutor } from '../classes/stack-executor.js';
 import { ElementComponentMetadata, ProcessorMetadata, Profile, ProfileComponent, VariableMetadataRecord, VariableType, } from '../models/index.js';
 import { getModelsDocument } from '../models-document.js';
 import { secretDecryptor, secretEncryptor } from './encrypt-helpers.js';
+import { materializeMetadataSilent } from './materialize-metadata.js';
 /**
  * Decodes profile
  */
-export function decodeProfile(materializedMetadata, rawProfile, options) {
-    const { profile: out, issues } = decodeProfileSilent(materializedMetadata, rawProfile, options);
-    if (issues?.length) {
+export function decodeProfile(profile, options) {
+    const r1 = decodeProfileSilent(profile, options);
+    if (!r1.result) {
         const msg = 'Worker profile decoding error.\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, {
-            workerId: rawProfile.id,
-            issues,
+            workerId: profile.id,
+            issues: r1.issues,
         });
     }
-    return out;
+    return r1.profile;
 }
-export function decodeProfileSilent(materializedMetadata, rawProfile, options) {
+export function decodeProfileSilent(profile, options) {
     const modelsDocument = getModelsDocument();
+    const r1 = materializeMetadataSilent(profile);
+    if (!r1.result) {
+        return { result: false, issues: r1.issues };
+    }
     const t = modelsDocument.node.getComplexType(Profile);
     const fn = t.generateCodec('decode');
-    const out = fn(rawProfile);
+    const out = fn(profile);
     const stackExecutor = new StackExecutor();
-    _codecProcessElement(stackExecutor, 'decode', materializedMetadata, out, options);
-    return { profile: out, issues: stackExecutor.issues };
+    _codecProcessElement(stackExecutor, 'decode', r1.metadata, out, options);
+    if (stackExecutor.issues.find(i => !(i.severity === 'warning' || i.severity === 'info'))) {
+        return { result: false, issues: stackExecutor.issues };
+    }
+    return {
+        result: true,
+        profile: out,
+        metadata: r1.metadata,
+        issues: stackExecutor.issues,
+    };
 }
 /**
  * Encodes profile
  */
-export function encodeProfile(materializedMetadata, rawProfile, options) {
-    const { profile: out, issues } = encodeProfileSilent(materializedMetadata, rawProfile, options);
-    if (issues?.length) {
+export function encodeProfile(rawProfile, options) {
+    const r1 = encodeProfileSilent(rawProfile, options);
+    if (!r1.result) {
         const msg = 'Worker profile encoding error.\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, {
             workerId: rawProfile.id,
-            issues,
+            issues: r1.issues,
         });
     }
-    return out;
+    return r1.profile;
 }
 /**
  * Encodes profile
  */
-export function encodeProfileSilent(metadata, rawProfile, options) {
+export function encodeProfileSilent(profile, options) {
     const modelsDocument = getModelsDocument();
+    const r1 = materializeMetadataSilent(profile);
+    if (!r1.result) {
+        return { result: false, issues: r1.issues };
+    }
     const t = modelsDocument.node.getComplexType(Profile);
     const fn = t.generateCodec('encode', { coerce: true });
     const out = fn({
-        id: rawProfile.id,
-        processorUri: rawProfile.processorUri,
-        displayName: rawProfile.displayName,
-        group: rawProfile.group,
-        description: rawProfile.description,
-        iconUrl: rawProfile.iconUrl,
+        id: profile.id,
+        processorUri: profile.processorUri,
+        displayName: profile.displayName,
+        group: profile.group,
+        description: profile.description,
+        iconUrl: profile.iconUrl,
         settings: {
-            autostart: rawProfile.settings?.autostart ?? false,
-            logs: rawProfile.settings?.logs ?? {},
-            ...rawProfile.settings,
+            autostart: profile.settings?.autostart ?? false,
+            logs: profile.settings?.logs ?? {},
+            ...profile.settings,
         },
-        values: rawProfile.values,
-        ...rawProfile,
+        values: profile.values,
+        ...profile,
     });
     const stackExecutor = new StackExecutor();
-    _codecProcessElement(stackExecutor, 'encode', metadata, out, options);
-    return { profile: out, issues: stackExecutor.issues };
+    _codecProcessElement(stackExecutor, 'encode', r1.metadata, out, options);
+    if (stackExecutor.issues.find(i => !(i.severity === 'warning' || i.severity === 'info'))) {
+        return { result: false, issues: stackExecutor.issues };
+    }
+    return { result: true, profile: out, issues: stackExecutor.issues };
 }
 /**
  *
@@ -130,6 +150,11 @@ function _decodeVariables(stackExecutor, codec, metadata, profile, options) {
                 if (defVariable == null)
                     return;
                 const fns = [];
+                if (defVariable.ignored) {
+                    if (defVariable.default === undefined)
+                        return;
+                    fns.push(vg.fixed(defVariable.default));
+                }
                 switch (defVariable.type) {
                     case VariableType.String: {
                         switch (defVariable.format) {

package/utils/materialize-metadata.d.ts

@@ -3,11 +3,17 @@ import { ProcessorMetadata, Profile } from '../models/index.js';
 /**
  * Materializes metadata from profile.
  */
-export declare function materializeMetadata(profile: Profile, returnUndefinedComponentsAsAbstract?: boolean): ProcessorMetadata;
+export declare function materializeMetadata(profile: Profile, options?: {
+    returnUndefinedComponentsAsAbstract?: boolean;
+    removeIgnoredVariables?: boolean;
+}): ProcessorMetadata;
 /**
  *
  */
-export declare function materializeMetadataSilent(profile: Profile, returnUndefinedComponentsAsAbstract?: boolean): {
+export declare function materializeMetadataSilent(profile: Profile, options?: {
+    returnUndefinedComponentsAsAbstract?: boolean;
+    removeIgnoredVariables?: boolean;
+}): {
     result: true;
     metadata: ProcessorMetadata;
     issues: StackExecutor.Issue[];

package/utils/materialize-metadata.js

@@ -6,8 +6,8 @@ import { ExtensionRegistry } from '../registry/extension-registry.js';
 /**
  * Materializes metadata from profile.
  */
-export function materializeMetadata(profile, returnUndefinedComponentsAsAbstract) {
-    const r = materializeMetadataSilent(profile, returnUndefinedComponentsAsAbstract);
+export function materializeMetadata(profile, options) {
+    const r = materializeMetadataSilent(profile, options);
     if (!r.result) {
         const msg = 'Worker profile validation error.\n  ' +
             r.issues
@@ -27,7 +27,7 @@ export function materializeMetadata(profile, returnUndefinedComponentsAsAbstract
 /**
  *
  */
-export function materializeMetadataSilent(profile, returnUndefinedComponentsAsAbstract) {
+export function materializeMetadataSilent(profile, options) {
     const stackExecutor = new StackExecutor();
     const processorRec = ExtensionRegistry.getProcessor(profile.processorUri);
     const metadata = omitUndefined(clone({
@@ -42,9 +42,15 @@ export function materializeMetadataSilent(profile, returnUndefinedComponentsAsAb
         components: processorRec.metadata.components,
         ...processorRec.metadata,
     }, { deep: 'full' }));
+    /* Remove ignored variables */
+    for (const [k, variable] of Object.entries(metadata.variables)) {
+        if (variable.ignored && options?.removeIgnoredVariables)
+            delete metadata.variables[k];
+    }
+    /* Materialize components */
     if (metadata.components) {
         stackExecutor.execute('components', () => {
-            metadata.components = _materializeComponents(stackExecutor, metadata.components, profile, returnUndefinedComponentsAsAbstract);
+            metadata.components = _materializeComponents(stackExecutor, metadata.components, profile, options);
         });
     }
     if (stackExecutor.issues?.length)
@@ -55,7 +61,7 @@ export function materializeMetadataSilent(profile, returnUndefinedComponentsAsAb
  *
  * @private
  */
-function _materializeComponents(stackExecutor, srcMetadata, profile, returnUndefinedComponentsAsAbstract) {
+function _materializeComponents(stackExecutor, srcMetadata, profile, options) {
     const out = {};
     for (const [componentName, metadataComponent,] of Object.entries(srcMetadata)) {
         stackExecutor.execute(componentName, () => {
@@ -63,7 +69,7 @@ function _materializeComponents(stackExecutor, srcMetadata, profile, returnUndef
             let materializedComponent;
             const profileComponent = profile?.components?.[componentName];
             if (!profileComponent) {
-                if (!returnUndefinedComponentsAsAbstract) {
+                if (!options?.returnUndefinedComponentsAsAbstract) {
                     if (metadataComponent.required)
                         throw new SbValidationError(`Component "${componentName}" should be configured`);
                     return;
@@ -96,12 +102,12 @@ function _materializeComponents(stackExecutor, srcMetadata, profile, returnUndef
                 out[componentName] = materializedComponent;
                 /** Remove ignored variables */
                 for (const [k, variable] of Object.entries(materializedComponent.variables)) {
-                    if (variable.ignored)
+                    if (variable.ignored && options?.removeIgnoredVariables)
                         delete materializedComponent.variables[k];
                 }
                 if (reg.metadata.components) {
                     stackExecutor.execute('components', () => {
-                        materializedComponent.components = _materializeComponents(stackExecutor, reg.metadata.components, profileComponent, returnUndefinedComponentsAsAbstract);
+                        materializedComponent.components = _materializeComponents(stackExecutor, reg.metadata.components, profileComponent, options);
                     });
                 }
             }