@syncbridge/common 0.6.14 → 0.7.1

package/utils/materialize-metadata.js

@@ -1,4 +1,4 @@
-import { clone, merge, omitUndefined } from '@jsopen/objects';
+import { clone, merge, omit, omitUndefined } from '@jsopen/objects';
 import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
 import { VariableType, } from '../models/index.js';
@@ -29,9 +29,9 @@ export function materializeMetadata(profile) {
  */
 export function materializeMetadataSilent(profile) {
     const stackExecutor = new StackExecutor();
-    const processorRec = ExtensionRegistry.getProcessor(profile.processorClass);
+    const processorRec = ExtensionRegistry.getProcessor(profile.processorUri);
     const metadata = omitUndefined(clone({
-        className: processorRec.metadata.className,
+        uri: processorRec.metadata.uri,
         displayName: processorRec.metadata.displayName,
         description: processorRec.metadata.description,
         iconUrl: processorRec.metadata.iconUrl,
@@ -41,10 +41,9 @@ export function materializeMetadataSilent(profile) {
         components: processorRec.metadata.components,
         ...processorRec.metadata,
     }, { deep: 'full' }));
-    delete metadata.components;
-    if (processorRec.metadata.components) {
+    if (metadata.components) {
         stackExecutor.execute('components', () => {
-            metadata.components = _materializeComponents(stackExecutor, processorRec.metadata, profile);
+            metadata.components = _materializeComponents(stackExecutor, metadata.components, profile);
         });
     }
     if (stackExecutor.issues?.length)
@@ -55,18 +54,10 @@ export function materializeMetadataSilent(profile) {
  *
  * @private
  */
-function _materializeComponents(stackExecutor, metadata, profile) {
+function _materializeComponents(stackExecutor, srcMetadata, profile) {
     const out = {};
-    for (const [componentName, metadataComponent,] of Object.entries(metadata.components)) {
+    for (const [componentName, metadataComponent,] of Object.entries(srcMetadata)) {
         stackExecutor.execute(componentName, () => {
-            const materializedComponent = {
-                interfaces: metadataComponent.interfaces
-                    ? [...metadataComponent.interfaces]
-                    : undefined,
-                required: metadataComponent.required,
-                ...metadataComponent,
-            };
-            out[componentName] = materializedComponent;
             /** Check if component defined in profile */
             const profileComponent = profile?.components?.[componentName];
             if (!profileComponent) {
@@ -75,34 +66,27 @@ function _materializeComponents(stackExecutor, metadata, profile) {
                 return;
             }
             /** istanbul ignore next */
-            if (!profileComponent.className)
-                throw new SbValidationError(`"className" property required`);
-            const reg = ExtensionRegistry.getComponent(profileComponent.className);
-            materializedComponent.className = profileComponent.className;
+            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}.`);
+            const materializedComponent = {
+                uri: profileComponent.uri,
+                ...omit(metadataComponent, ['uri', 'variables']),
+            };
+            out[componentName] = materializedComponent;
             materializedComponent.variables = merge({}, [reg.metadata.variables || {}, metadataComponent.variables || {}], { deep: 'full' });
             materializedComponent.variables = sortVariables(materializedComponent.variables);
-            if (metadataComponent.className) {
-                if (materializedComponent.className &&
-                    materializedComponent.className !== 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 SbValidationError(`Selected component "${profileComponent.className}" do not implements some of required interfaces (${filtered.join(',')}).`);
-                }
-            }
-            if (materializedComponent.variables) {
-                for (const [k, variable] of Object.entries(materializedComponent.variables)) {
-                    if (variable.ignored)
-                        delete materializedComponent.variables[k];
-                }
+            /** Remove ignored variables */
+            for (const [k, variable] of Object.entries(materializedComponent.variables)) {
+                if (variable.ignored)
+                    delete materializedComponent.variables[k];
             }
             if (reg.metadata.components) {
                 stackExecutor.execute('components', () => {
-                    materializedComponent.components = _materializeComponents(stackExecutor, reg.metadata, profileComponent);
+                    materializedComponent.components = _materializeComponents(stackExecutor, reg.metadata.components, profileComponent);
                 });
             }
         });
@@ -113,7 +97,7 @@ function sortVariables(variables) {
     if (!variables)
         return;
     const keys = Object.keys(variables);
-    const sorted = [...keys]
+    return [...keys]
         .sort((a, b) => {
         const va = variables[a];
         const vb = variables[b];
@@ -133,5 +117,4 @@ function sortVariables(variables) {
         a[k] = variables[k];
         return a;
     }, {});
-    return sorted;
 }

package/utils/normalize-metadata.js

@@ -23,7 +23,8 @@ export async function normalizeProcessorMetadata(metadata) {
 export async function normalizeProcessorMetadataSilent(metadata) {
     const decoder = await getProcMetadataTypeDecoder();
     let cloned = deepClone({
-        className: metadata.className,
+        id: metadata.id,
+        uri: metadata.uri,
         displayName: metadata.displayName,
         description: metadata.description,
         iconUrl: metadata.iconUrl,
@@ -67,7 +68,8 @@ export async function normalizeComponentMetadata(metadata) {
 export async function normalizeComponentMetadataSilent(metadata) {
     const decoder = await getCompMetadataTypeDecoder();
     let cloned = deepClone({
-        className: metadata.className,
+        id: metadata.id,
+        uri: metadata.uri,
         displayName: metadata.displayName,
         description: metadata.description,
         iconUrl: metadata.iconUrl,

package/decorators/finalize-element-metadata.d.ts

@@ -1,4 +0,0 @@
-import 'reflect-metadata';
-import { DeepPartial, Type } from 'ts-gems';
-import { ElementMetadata } from '../models/index.js';
-export declare function finalizeElementMetadata(target: Type, options: DeepPartial<ElementMetadata>, metadataKey: any, namePattern?: RegExp): void;

package/decorators/finalize-element-metadata.js

@@ -1,30 +0,0 @@
-import 'reflect-metadata';
-import { merge } from '@jsopen/objects';
-import { OWN_ELEMENT_METADATA } from '../constants.js';
-export function finalizeElementMetadata(target, options, metadataKey, namePattern) {
-    /** Determine class name */
-    let className = options.className;
-    if (!className && namePattern) {
-        const m = namePattern.exec(target.name);
-        if (!m)
-            throw new TypeError('Class name must be PascalCase and should contains only letters and numbers. Example: MyProcessor ');
-        if (m)
-            className = m[1];
-    }
-    if (!className)
-        throw new TypeError('Class name is required');
-    const base = Object.getPrototypeOf(target);
-    const baseMetadata = Reflect.getMetadata(metadataKey, base) || {};
-    const ownMetadata = Reflect.getMetadata(OWN_ELEMENT_METADATA, target);
-    const finalMetadata = merge({}, [baseMetadata, options, ownMetadata], {
-        deep: 'full',
-        mergeArrays: 'unique',
-        ignoreNulls: false,
-        ignoreUndefined: false,
-    });
-    finalMetadata.abstract = !!options.abstract;
-    finalMetadata.className = className;
-    finalMetadata.displayName = finalMetadata.displayName || className;
-    Reflect.defineMetadata(metadataKey, finalMetadata, target);
-    target.className = finalMetadata.className;
-}

package/registry/locate-package-json.d.ts

@@ -1,4 +0,0 @@
-/**
- *
- */
-export declare function locatePackageJson(directory: string): string | undefined;