@syncbridge/common 0.6.12 → 0.7.0

package/classes/base-element.d.ts

@@ -3,6 +3,9 @@ import { ServiceStatus } from '../models/index.js';
 import type { ComponentBase } from './component-base.js';
 import { Runnable } from './runnable.js';
 export declare abstract class BaseElement<TEvents extends BaseElement.Events = BaseElement.Events> extends Runnable<TEvents> {
+    static id: string;
+    static uri: string;
+    static packageName: string;
     static className: string;
     static interfaces: string[];
     protected _context: BaseElement.Context;

package/classes/base-element.js

@@ -1,6 +1,9 @@
 import { ServiceStatus } from '../models/index.js';
 import { Runnable } from './runnable.js';
 export class BaseElement extends Runnable {
+    static id;
+    static uri;
+    static packageName;
     static className;
     static interfaces;
     name;

package/constants.d.ts

@@ -1,7 +1,6 @@
 export declare const version = "1";
-export declare const OWN_ELEMENT_METADATA: unique symbol;
-export declare const COMPONENT_OPTIONS: unique symbol;
-export declare const PROCESSOR_OPTIONS: unique symbol;
+export declare const CLASS_METADATA: unique symbol;
+export declare const CLASS_TYPE: unique symbol;
 export declare const VARIABLE_CONTAINER: unique symbol;
 export declare const noOp: () => undefined;
 export declare const NODE_ENV: string;

package/constants.js

@@ -1,14 +1,6 @@
-export const version = '0.6.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');
-// export const USE_COMPONENT_OPTIONS_STORE = Symbol.for(
-//   'USE_COMPONENT_OPTIONS_STORE',
-// );
-// export const USE_VARIABLES_OPTIONS_STORE = Symbol.for(
-//   'USE_VARIABLE_OPTIONS_STORE',
-// );
-// export const USE_VARIABLES_PROPERTY = Symbol.for('USE_VARIABLE_PROPERTY');
+export const version = '0.7.0';
+export const CLASS_METADATA = Symbol.for('CLASS_METADATA');
+export const CLASS_TYPE = Symbol.for('CLASS_TYPE');
 export const VARIABLE_CONTAINER = Symbol.for('VARIABLE_CONTAINER');
 export const noOp = () => undefined;
 export const NODE_ENV = process.env.NODE_ENV === 'test'

package/decorators/component.decorator.d.ts

@@ -1,15 +1,13 @@
 import 'reflect-metadata';
-import { DeepPartial, PartialSome, StrictOmit, Type } from 'ts-gems';
+import { DeepPartial, StrictOmit, Type } from 'ts-gems';
 import { ComponentBase } from '../classes/component-base.js';
-import { ComponentMetadata, ElementComponentMetadata, VariableMetadataRecord } from '../models/index.js';
+import { ComponentMetadata } from '../models/index.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';
 export declare function Component<T extends ComponentBase>(options: Component.Options): (target: Type<T>) => void;
 export declare namespace Component {
-    interface Options extends PartialSome<StrictOmit<ComponentMetadata, 'components' | 'variables'>, 'className' | 'displayName' | 'tags' | 'interfaces' | 'author'> {
-        abstract?: boolean;
-        components?: Record<string, Partial<ElementComponentMetadata>>;
-        variables?: DeepPartial<VariableMetadataRecord>;
-    }
+    type Options = DeepPartial<StrictOmit<ComponentMetadata, 'components' | 'variables'>> & {
+        className?: string;
+    };
     function UseVariables<T extends ComponentBase>(variablesClass?: Type): (target: T, propertyKey: "values") => void;
     function UseComponent<T extends ComponentBase>(options: _UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
 }

package/decorators/component.decorator.js

@@ -1,19 +1,66 @@
 import 'reflect-metadata';
-import { COMPONENT_OPTIONS } from '../constants.js';
-import { finalizeElementMetadata } from './finalize-element-metadata.js';
+import path from 'node:path';
+import { omit } from '@jsopen/objects';
+import callerCallsite from 'caller-callsite';
+import { CLASS_METADATA, CLASS_TYPE } from '../constants.js';
+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)?$/;
 export function Component(options) {
+    const callerFile = callerCallsite()?.getFileName();
+    const pkgjson = callerFile && resolvePackageJson(path.dirname(callerFile));
+    if (!pkgjson)
+        throw new Error('Could not find package.json');
     return function (target) {
-        finalizeElementMetadata(target, options, COMPONENT_OPTIONS, NAME_PATTERN);
-        const metadata = Reflect.getMetadata(COMPONENT_OPTIONS, target);
-        metadata.interfaces = [
-            ...(metadata.interfaces || []),
-            ...(options.interfaces || [metadata.className]),
-        ];
-        target.className = metadata.className;
-        target.interfaces = [...metadata.interfaces];
+        const classType = Reflect.getMetadata(CLASS_TYPE, target);
+        if (classType && classType !== 'component')
+            throw new TypeError(`${target.name} already decorated as "${classType}"`);
+        /** Determine class name */
+        let className = options.className;
+        if (!className) {
+            const m = NAME_PATTERN.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];
+        }
+        /* c8 ignore next */
+        if (!className)
+            throw new TypeError('Class name is required');
+        /** Determine uri */
+        Reflect.defineMetadata(CLASS_TYPE, 'component', target);
+        const packageName = pkgjson.syncbridge?.name || pkgjson.name;
+        const uri = packageName + ':' + className;
+        const id = uri
+            .replace('@', '')
+            .replace(':', '__')
+            .replace(/\W/g, '_')
+            .toLowerCase();
+        const metadata = defineOwnMetadata(target, CLASS_METADATA, {
+            mergeBase: true,
+            overwrite: {
+                id,
+                uri,
+                displayName: className,
+                version: pkgjson.version,
+                author: parseNpmAuthor(pkgjson.author),
+                ...omit(options, ['uri']),
+            },
+        });
+        const base = Object.getPrototypeOf(target);
+        const baseMetadata = Reflect.getMetadata(CLASS_METADATA, base);
+        if (baseMetadata) {
+            metadata.interfaces = Array.from(new Set([...(baseMetadata?.interfaces || []), base.uri]));
+        }
+        target.id = id;
+        target.uri = uri;
+        target.packageName = packageName;
+        target.className = className;
+        target.interfaces = metadata.interfaces
+            ? [...metadata.interfaces]
+            : [];
     };
 }
 (function (Component) {

package/decorators/decorator-helpers.d.ts

@@ -1,2 +1,7 @@
 import 'reflect-metadata';
-export declare function defineMergeMetadata(target: any, metadataKey: any, metadata: any): any;
+import { AuthorMetadata } from '../models/index.js';
+export declare function defineOwnMetadata(target: any, metadataKey: string | symbol, options?: {
+    overwrite?: any;
+    mergeBase?: boolean;
+}): any;
+export declare function parseNpmAuthor(value: any): AuthorMetadata | undefined;

package/decorators/decorator-helpers.js

@@ -1,13 +1,48 @@
 import 'reflect-metadata';
 import { merge } from '@jsopen/objects';
-export function defineMergeMetadata(target, metadataKey, metadata) {
-    const oldMetadata = Reflect.getMetadata(metadataKey, target);
-    const finalMetadata = merge({}, [oldMetadata || {}, metadata], {
-        deep: 'full',
-        mergeArrays: true,
-        ignoreNulls: false,
-        ignoreUndefined: false,
-    });
-    Reflect.defineMetadata(metadataKey, finalMetadata, target);
-    return finalMetadata;
+import { AuthorMetadata } from '../models/index.js';
+export function defineOwnMetadata(target, metadataKey, options) {
+    let metadata = Reflect.getOwnMetadata(metadataKey, target);
+    const sources = [];
+    if (!metadata) {
+        metadata = {};
+        if (options?.mergeBase) {
+            const base = Object.getPrototypeOf(target);
+            const baseMetadata = Reflect.getMetadata(metadataKey, base);
+            if (baseMetadata)
+                sources.push(baseMetadata);
+        }
+    }
+    if (options?.overwrite)
+        sources.push(options?.overwrite);
+    if (sources.length)
+        merge(metadata, sources, {
+            deep: 'full',
+            mergeArrays: true,
+            ignoreNulls: false,
+            ignoreUndefined: false,
+        });
+    Reflect.defineMetadata(metadataKey, metadata, target);
+    return metadata;
+}
+const AUTHOR_PATTERN = /^\s*([^<(]+?)\s*(?:<([^>]+)>)?\s*(?:\(([^)]+)\))?\s*$/;
+export function parseNpmAuthor(value) {
+    if (!value)
+        return;
+    if (typeof value === 'string') {
+        const m = AUTHOR_PATTERN.exec(value);
+        if (m)
+            return new AuthorMetadata({
+                name: m[1],
+                email: m[2],
+                url: m[3],
+            });
+    }
+    else if (typeof value === 'object') {
+        return new AuthorMetadata({
+            name: value.name,
+            email: value.email,
+            url: value.url,
+        });
+    }
 }

package/decorators/processor-events.decorator.js

@@ -1,20 +1,26 @@
 import 'reflect-metadata';
-import { OWN_ELEMENT_METADATA } from '../constants.js';
-import { defineMergeMetadata } from './decorator-helpers.js';
+import { CLASS_METADATA } from '../constants.js';
+import { defineOwnMetadata } from './decorator-helpers.js';
 export function OnCreateProfile() {
     return function (target, propertyKey) {
-        defineMergeMetadata(target, OWN_ELEMENT_METADATA, {
-            staticEvents: {
-                onCreateProfile: propertyKey,
+        defineOwnMetadata(target, CLASS_METADATA, {
+            mergeBase: true,
+            overwrite: {
+                staticEvents: {
+                    onCreateProfile: propertyKey,
+                },
             },
         });
     };
 }
 export function OnUpdateProfile() {
     return function (target, propertyKey) {
-        defineMergeMetadata(target, OWN_ELEMENT_METADATA, {
-            staticEvents: {
-                onUpdateProfile: propertyKey,
+        defineOwnMetadata(target, CLASS_METADATA, {
+            mergeBase: true,
+            overwrite: {
+                staticEvents: {
+                    onUpdateProfile: propertyKey,
+                },
             },
         });
     };

package/decorators/processor.decorator.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
-import { DeepPartial, PartialSome, StrictOmit, Type } from 'ts-gems';
+import { DeepPartial, StrictOmit, Type } from 'ts-gems';
 import type { ProcessorBase } from '../classes/processor-base.js';
-import { ElementComponentMetadata, ProcessorMetadata, VariableMetadataRecord } from '../models/index.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 namespace Processor {
@@ -12,7 +12,7 @@ export declare namespace Processor {
     /**
      *
      */
-    function UseComponent<T extends ProcessorBase>(options: _UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
+    function UseComponent<T extends ProcessorBase>(options?: _UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
     /**
      *
      */
@@ -23,9 +23,7 @@ export declare namespace Processor {
     function OnUpdateProfile<T extends ProcessorBase>(): (target: Type<T>, propertyKey: string | symbol) => void;
 }
 export declare namespace Processor {
-    interface Options extends PartialSome<StrictOmit<ProcessorMetadata, 'components' | 'variables'>, 'className' | 'displayName' | 'tags' | 'author'> {
-        abstract?: boolean;
-        components?: Record<string, Partial<ElementComponentMetadata>>;
-        variables?: DeepPartial<VariableMetadataRecord>;
-    }
+    type Options = DeepPartial<StrictOmit<ProcessorMetadata, 'components' | 'variables'>> & {
+        className?: string;
+    };
 }

package/decorators/processor.decorator.js

@@ -1,13 +1,58 @@
 import 'reflect-metadata';
-import { PROCESSOR_OPTIONS } from '../constants.js';
-import { finalizeElementMetadata } from './finalize-element-metadata.js';
+import path from 'node:path';
+import { omit } from '@jsopen/objects';
+import callerCallsite from 'caller-callsite';
+import { CLASS_METADATA, CLASS_TYPE } from '../constants.js';
+import { resolvePackageJson } from '../utils/locate-package-json.js';
+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)?$/;
 export function Processor(options) {
+    const callerFile = callerCallsite()?.getFileName();
+    const pkgjson = callerFile && resolvePackageJson(path.dirname(callerFile));
+    if (!pkgjson)
+        throw new Error('Could not find package.json');
     return function (target) {
-        finalizeElementMetadata(target, options, PROCESSOR_OPTIONS, NAME_PATTERN);
+        const classType = Reflect.getMetadata(CLASS_TYPE, target);
+        if (classType && classType !== 'processor')
+            throw new TypeError(`${target.name} already decorated as "${classType}"`);
+        /** Determine class name */
+        let className = options.className;
+        if (!className) {
+            const m = NAME_PATTERN.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];
+        }
+        /* c8 ignore next */
+        if (!className)
+            throw new TypeError('Class name is required');
+        /** Determine uri */
+        Reflect.defineMetadata(CLASS_TYPE, 'processor', target);
+        const packageName = pkgjson.syncbridge?.name || pkgjson.name;
+        const uri = packageName + ':' + className;
+        const id = uri
+            .replace('@', '')
+            .replace(':', '__')
+            .replace(/\W/g, '_')
+            .toLowerCase();
+        defineOwnMetadata(target, CLASS_METADATA, {
+            mergeBase: true,
+            overwrite: {
+                id,
+                uri,
+                displayName: className,
+                version: pkgjson.version,
+                ...omit(options, ['uri']),
+            },
+        });
+        target.id = id;
+        target.uri = uri;
+        target.packageName = packageName;
+        target.className = className;
     };
 }
 (function (Processor) {

package/decorators/use-component.decorator.d.ts

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';
 import { ElementComponentMetadata } from '../models/index.js';
-export declare function UseComponent<T extends ProcessorBase | ComponentBase>(options: UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
+export declare function UseComponent<T extends ProcessorBase | ComponentBase>(options?: UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
 export declare namespace UseComponent {
     interface Options extends Partial<ElementComponentMetadata> {
     }

package/decorators/use-component.decorator.js

@@ -1,24 +1,22 @@
 import 'reflect-metadata';
-import { OWN_ELEMENT_METADATA } from '../constants.js';
-import { defineMergeMetadata } from './decorator-helpers.js';
-export function UseComponent(options) {
+import { CLASS_METADATA } from '../constants.js';
+import { defineOwnMetadata } from './decorator-helpers.js';
+export function UseComponent(options = {}) {
     return function (target, propertyKey) {
         /** c8 ignore next */
         if (typeof propertyKey !== 'string')
             throw new TypeError('Property key must be a string');
-        if (!options.className && !options.interfaces) {
+        if (!options.uri) {
             const designType = Reflect.getMetadata('design:type', target, propertyKey);
-            if (typeof designType === 'function' && designType.interfaces) {
-                options.interfaces = [...designType.interfaces];
+            if (typeof designType === 'function' && designType.uri) {
+                options.uri = designType.uri;
             }
         }
-        defineMergeMetadata(target.constructor, OWN_ELEMENT_METADATA, {
-            components: {
-                [propertyKey]: {
-                    ...options,
-                    propertyKey,
-                },
-            },
-        });
+        const metadata = defineOwnMetadata(target.constructor, CLASS_METADATA);
+        metadata.components = metadata.components || {};
+        metadata.components[propertyKey] = {
+            ...options,
+            propertyKey,
+        };
     };
 }

package/decorators/use-variables.decorator.js

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
-import { OWN_ELEMENT_METADATA, VARIABLE_CONTAINER } from '../constants.js';
-import { defineMergeMetadata } from './decorator-helpers.js';
+import { CLASS_METADATA, VARIABLE_CONTAINER } from '../constants.js';
+import { defineOwnMetadata } from './decorator-helpers.js';
 export function UseVariables(variablesClass) {
     return function (target, propertyKey) {
         /** c8 ignore next */
@@ -11,9 +11,8 @@ export function UseVariables(variablesClass) {
         if (!(typeof variablesClass === 'function')) {
             throw new TypeError('type of "variables" must be a class');
         }
-        const metadata = Reflect.getMetadata(VARIABLE_CONTAINER, variablesClass.prototype) || {};
-        defineMergeMetadata(target.constructor, OWN_ELEMENT_METADATA, {
-            variables: metadata,
-        });
+        const metadata = defineOwnMetadata(target.constructor, CLASS_METADATA);
+        metadata.variables =
+            Reflect.getMetadata(VARIABLE_CONTAINER, variablesClass.prototype) || {};
     };
 }

package/models/metadata/component-metadata.js

@@ -12,7 +12,7 @@ let ComponentMetadata = class ComponentMetadata extends ElementMetadata {
 __decorate([
     ApiField({
         label: 'Interfaces',
-        description: 'Interfaces which this component implemented',
+        description: 'List of component URIs which this component implemented',
         type: ArrayType('string'),
     }),
     __metadata("design:type", Array)

package/models/metadata/element-component-metadata.d.ts

@@ -10,9 +10,8 @@ export declare class ElementComponentMetadataRecord {
  */
 export declare class ElementComponentMetadata {
     propertyKey?: string;
-    className?: string;
+    uri: string;
     description?: string;
-    interfaces?: string[];
     required?: boolean;
     variables?: VariableMetadataRecord;
     components?: ElementComponentMetadataRecord;

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

@@ -21,11 +21,12 @@ let ElementComponentMetadata = class ElementComponentMetadata {
 };
 __decorate([
     ApiField({
-        label: 'Class Name',
-        description: 'Class name of the component',
+        label: 'Class URI',
+        description: 'URI of the class',
+        examples: ['@syncbridge/net:TcpClient', '@syncbridge/sqb:SqbClient'],
     }),
     __metadata("design:type", String)
-], ElementComponentMetadata.prototype, "className", void 0);
+], ElementComponentMetadata.prototype, "uri", void 0);
 __decorate([
     ApiField({
         label: 'Description',
@@ -33,16 +34,6 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], ElementComponentMetadata.prototype, "description", void 0);
-__decorate([
-    ApiField({
-        label: 'Interfaces',
-        description: 'Interfaces should be implemented by the component. This value is ignored if className is set',
-        type: 'string',
-        required: true,
-        examples: ['IoComponent'],
-    }),
-    __metadata("design:type", Array)
-], ElementComponentMetadata.prototype, "interfaces", void 0);
 __decorate([
     ApiField({
         label: 'Required',

package/models/metadata/element-metadata.d.ts

@@ -7,7 +7,8 @@ import { VariableMetadataRecord } from './variable-metadata.js';
 export declare class ElementMetadata {
     constructor(init?: Partial<ElementMetadata>);
     abstract?: boolean;
-    className: string;
+    id: string;
+    uri: string;
     displayName: string;
     iconUrl?: string;
     description?: string;

package/models/metadata/element-metadata.js

@@ -14,12 +14,20 @@ let ElementMetadata = class ElementMetadata {
 };
 __decorate([
     ApiField({
-        label: 'Class Name',
-        description: 'Uniquely identifies the element (camelCase, PascalCase)',
-        required: true,
+        label: 'Id',
+        description: 'Web friendly unique identifier',
+        examples: ['syncbridge_net__tcpclient', 'syncbridge_sqb__sqbclient'],
+    }),
+    __metadata("design:type", String)
+], ElementMetadata.prototype, "id", void 0);
+__decorate([
+    ApiField({
+        label: 'Class URI',
+        description: 'URI of the class',
+        examples: ['@syncbridge/net:TcpClient', '@syncbridge/sqb:SqbClient'],
     }),
     __metadata("design:type", String)
-], ElementMetadata.prototype, "className", void 0);
+], ElementMetadata.prototype, "uri", void 0);
 __decorate([
     ApiField({
         label: 'Name',

package/models/profile/profile-component.d.ts

@@ -16,7 +16,7 @@ export declare class ProfileComponentSettings {
  * ProfileComponent
  */
 export declare class ProfileComponent {
-    className: string;
+    uri: string;
     values?: Record<string, any>;
     components?: WorkerComponentRecord;
     settings?: ProfileComponentSettings;

package/models/profile/profile-component.js

@@ -42,11 +42,11 @@ let ProfileComponent = class ProfileComponent {
 };
 __decorate([
     ApiField({
-        description: 'Class name of the component',
-        examples: ['TcpClient', 'SerialClient'],
+        description: 'URI of the component',
+        examples: ['@syncbridge/net:TcpClient', '@syncbridge/serial:SerialClient'],
     }),
     __metadata("design:type", String)
-], ProfileComponent.prototype, "className", void 0);
+], ProfileComponent.prototype, "uri", void 0);
 __decorate([
     ApiField({
         label: 'Values',

package/models/profile/profile.d.ts

@@ -15,7 +15,7 @@ export declare class Profile {
     constructor(init?: Partial<Profile>);
     id: string;
     displayName: string;
-    processorClass: string;
+    processorUri: string;
     processorVersion?: string;
     group?: string;
     description?: string;

package/models/profile/profile.js

@@ -59,12 +59,12 @@ __decorate([
 ], Profile.prototype, "displayName", void 0);
 __decorate([
     ApiField({
-        label: 'Processor Class',
-        description: 'Class name of the processor',
+        label: 'Processor URI',
+        description: 'URI of the processor',
         required: true,
     }),
     __metadata("design:type", String)
-], Profile.prototype, "processorClass", void 0);
+], Profile.prototype, "processorUri", void 0);
 __decorate([
     ApiField({
         label: 'Processor Version',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.6.12",
+  "version": "0.7.0",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",
@@ -8,6 +8,7 @@
     "@jsopen/objects": "^2.2.0",
     "fast-deep-equal": "^3.1.3",
     "node-events-async": "^1.5.2",
+    "caller-callsite": "^6.0.0",
     "reflect-metadata": "^0.2.2",
     "semver": "^7.7.4",
     "ts-gems": "^3.11.5",

package/processor-factory.d.ts

@@ -9,7 +9,8 @@ export declare namespace ProcessorFactory {
         logger?: ILogger;
         dataDirectory?: string;
     }
-    function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<{
+    function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<T>;
+    function createProcessorSilent<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<{
         processor: T;
         issues: StackExecutor.Issue[];
     }>;