@syncbridge/common 0.6.0 → 0.6.2

package/classes/base-element.d.ts

@@ -14,7 +14,7 @@ export declare abstract class BaseElement<TEvents extends BaseElement.Events = B
     get status(): ServiceStatus;
     get statusMessage(): string;
     protected _init(): Promise<void>;
-    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _start(abortSignal?: AbortSignal): Promise<void>;
     protected _stop(): Promise<void>;
     protected onStatusChange(): void;
 }

package/classes/base-element.js

@@ -26,6 +26,7 @@ export class BaseElement extends Runnable {
     async _init() {
         for (const component of Object.values(this.components)) {
             component.on('status-change', (status, statusMessage) => {
+                component.on('component-status-change', (...args) => this.emitAsyncSafe('component-status-change', ...args));
                 /** Reset counters */
                 this._context.statusIndicators = this._context.statusIndicators || {};
                 Object.keys(ServiceStatus).forEach(key => {
@@ -42,7 +43,8 @@ export class BaseElement extends Runnable {
                     counter.componentNames.push(comp.name);
                 });
                 this.emitSafe('component-status-change', component, status, statusMessage);
-                if (this._context.status !== this._context.calculatedStatus)
+                if (this._context.status !== this._context.calculatedStatus ||
+                    this._context.statusMessage !== this._context.statusMessage)
                     this.onStatusChange();
             });
         }
@@ -60,8 +62,6 @@ export class BaseElement extends Runnable {
             .map(component => component.stop()));
     }
     onStatusChange() {
-        const oldStatus = this.status;
-        const oldStatusMessage = this.statusMessage;
         this._context.calculatedStatus = this._context.status;
         this._context.calculatedStatusMessage = this._context.statusMessage;
         if (!(this.status === ServiceStatus.stopped ||
@@ -72,13 +72,10 @@ export class BaseElement extends Runnable {
                 if (indicator?.count) {
                     this._context.calculatedStatus = _status;
                     this._context.calculatedStatusMessage = `${_status} components: ${indicator.componentNames}`;
-                    return;
+                    break;
                 }
             }
         }
-        if (this.status !== oldStatus || this.statusMessage !== oldStatusMessage) {
-            this.logger?.debug(this.status);
-            super.onStatusChange();
-        }
+        super.onStatusChange();
     }
 }

package/classes/runnable.d.ts

@@ -5,6 +5,7 @@ import { ServiceStatus } from '../models/index.js';
  */
 export declare abstract class Runnable<T extends Runnable.Events = Runnable.Events> extends AsyncEventEmitter<EventMap<T>> {
     protected _context: Runnable.Context;
+    private _startAbortController?;
     constructor(init?: Runnable.InitArgs);
     get status(): ServiceStatus;
     get statusMessage(): string;
@@ -34,7 +35,7 @@ export declare abstract class Runnable<T extends Runnable.Events = Runnable.Even
     /**
      *
      */
-    protected abstract _start(abortSignal: AbortSignal): Promise<void>;
+    protected abstract _start(abortSignal?: AbortSignal): Promise<void>;
     /**
      *
      */

package/classes/runnable.js

@@ -8,6 +8,7 @@ import { SbError } from './sb-error.js';
  */
 export class Runnable extends AsyncEventEmitter {
     _context;
+    _startAbortController;
     constructor(init) {
         super();
         this.setMaxListeners(1000);
@@ -67,6 +68,9 @@ export class Runnable extends AsyncEventEmitter {
         if (this.status === ServiceStatus.started)
             return;
         this.setStatus(ServiceStatus.starting);
+        const abortController = (this._startAbortController =
+            new AbortController());
+        abortSignal?.addEventListener('abort', () => abortController.abort());
         this._context.waitTimer = Promise.resolve()
             .then(async () => {
             await this.init();
@@ -74,8 +78,6 @@ export class Runnable extends AsyncEventEmitter {
                 let promiseSettled = false;
                 await new Promise((resolve, reject) => {
                     let startWaitTimer;
-                    const abortController = new AbortController();
-                    abortSignal?.addEventListener('abort', () => abortController.abort());
                     if (this._context.startMaxWaitMs) {
                         startWaitTimer = setTimeout(() => {
                             const err = new SbError('Start timeout', {
@@ -124,6 +126,7 @@ export class Runnable extends AsyncEventEmitter {
             });
         })
             .finally(() => {
+            this._startAbortController = undefined;
             this._context.waitTimer = undefined;
         });
         await this._context.waitTimer;
@@ -132,12 +135,13 @@ export class Runnable extends AsyncEventEmitter {
      *
      */
     async stop() {
-        if (this._context.waitTimer)
-            await this._context.waitTimer;
         if (this.status === ServiceStatus.stopped)
             return;
         this.setStatus(ServiceStatus.stopping);
         this.emit('stopping');
+        this._startAbortController?.abort();
+        if (this._context.waitTimer)
+            await this._context.waitTimer;
         this._context.waitTimer = Promise.resolve()
             .then(async () => {
             try {

package/classes/sb-error.d.ts

@@ -1,11 +1,17 @@
-export declare class SbError extends Error {
+import { ErrorIssue } from '@opra/common';
+export declare class SbError extends Error implements ErrorIssue {
     readonly cause?: Error;
+    severity: ErrorIssue['severity'];
     code?: string;
     [index: string]: any;
     constructor(message?: string | Error, options?: SbErrorOptions);
     toJSON(): any;
 }
-export interface SbErrorOptions {
+export interface SbErrorOptions extends Partial<ErrorIssue> {
     cause?: Error;
-    [key: string]: any;
+}
+/**
+ *
+ */
+export declare class SbValidationError extends SbError {
 }

package/classes/sb-error.js

@@ -1,5 +1,6 @@
 import { isPlainObject } from '@jsopen/objects';
 export class SbError extends Error {
+    severity = 'error';
     code;
     constructor(message, options) {
         super(typeof message === 'object' ? message.message || '' : message);
@@ -46,9 +47,13 @@ export class SbError extends Error {
             message: this.message,
         };
         for (const k of Object.keys(this)) {
-            if (k !== 'stack')
-                out[k] = this[k];
+            out[k] = this[k];
         }
         return out;
     }
 }
+/**
+ *
+ */
+export class SbValidationError extends SbError {
+}

package/classes/stack-executor.js

@@ -1,4 +1,5 @@
 import { ValidationError } from 'valgen';
+import { SbValidationError } from './sb-error.js';
 export class StackExecutor {
     stack = [];
     issues = [];
@@ -30,20 +31,23 @@ export class StackExecutor {
         const location = this.stack.join('/');
         if (e instanceof ValidationError) {
             e.issues.forEach(x => {
-                this.issues.push({
-                    ...x,
-                    severity: 'error',
-                    location: location + (x.location ? '/' + x.location : ''),
-                });
+                const issue = new SbValidationError(x.message, x);
+                issue.severity = x.severity ?? 'error';
+                issue.location = location + (x.location ? '/' + x.location : '');
+                issue.stack = x.stack;
+                this.issues.push(issue);
             });
         }
         else {
-            this.issues.push({
+            const issue = {
                 message: e.message,
-                ...e,
-                severity: 'error',
+                severity: e.severity || 'error',
                 location,
-            });
+                stack: e.stack,
+                ...e,
+            };
+            Object.setPrototypeOf(issue, Object.getPrototypeOf(e));
+            this.issues.push(issue);
         }
     }
 }

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.6.0';
+export const version = '0.6.2';
 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/index.d.ts

@@ -16,5 +16,5 @@ export * from './models-document.js';
 export * from './processor-factory.js';
 export * from './registry/extension-package.js';
 export * from './registry/extension-registry.js';
+export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
-export * from './utils/profile-utils.js';

package/index.js

@@ -16,5 +16,5 @@ export * from './models-document.js';
 export * from './processor-factory.js';
 export * from './registry/extension-package.js';
 export * from './registry/extension-registry.js';
+export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
-export * from './utils/profile-utils.js';

package/models-document.js

@@ -1,4 +1,5 @@
 import { ApiDocumentFactory } from '@opra/common';
+import { SbError } from './classes/sb-error.js';
 import * as models from './models/index.js';
 let doc;
 export async function initializeModelsDocument() {
@@ -11,6 +12,8 @@ export async function initializeModelsDocument() {
 }
 export function getModelsDocument() {
     if (!doc)
-        throw new Error('You must call initializeModelsDocument() first');
+        throw new SbError('You must call initializeModelsDocument() first', {
+            severity: 'fatal',
+        });
     return doc;
 }

package/package.json

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

package/processor-factory.js

@@ -1,4 +1,5 @@
 import equal from 'fast-deep-equal';
+import { SbError } from './classes/sb-error.js';
 import { StackExecutor } from './classes/stack-executor.js';
 import { initializeModelsDocument } from './models-document.js';
 import { ExtensionRegistry } from './registry/extension-registry.js';
@@ -94,9 +95,9 @@ export var ProcessorFactory;
                     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.');
+                        throw new SbError('Cannot change component class while processor running. You should stop it first.');
                     /** Validate sub components */
-                    if (childMetadata.components) {
+                    if (childMetadata.components && componentInstance) {
                         _validateComponents({
                             ...ctx,
                             owner: componentInstance,

package/registry/extension-package.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { updateErrorMessage } from '@jsopen/objects';
+import { SbError } from '../classes/sb-error.js';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
 import { isComponentBase, isProcessorBase } from '../utils/type-guartds.js';
 import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './helpers.js';
@@ -26,10 +27,10 @@ export class ExtensionPackage {
     static async fromDirectory(directory) {
         let filename = path.join(directory, 'package.json');
         if (!fs.existsSync(filename))
-            throw new TypeError(`Directory "${directory}" does not contain package.json`);
+            throw new SbError(`Directory "${directory}" does not contain package.json`);
         const pkgJson = JSON.parse(fs.readFileSync(filename, 'utf8'));
         if (!pkgJson.syncbridge)
-            throw new TypeError(`"${pkgJson.name}" is not a SyncBridge extension package`);
+            throw new SbError(`"${pkgJson.name}" is not a SyncBridge extension package`);
         const out = new ExtensionPackage();
         out.name = pkgJson.name;
         out.version = pkgJson.version;
@@ -100,7 +101,7 @@ export class ExtensionPackage {
         let entryPoint = (resolver || import.meta.resolve)(specifier);
         const pkgJson = locatePkgJson(path.dirname(entryPoint));
         if (!pkgJson) {
-            throw new TypeError(`Can't locate package.json file for "${specifier}"`);
+            throw new SbError(`Can't locate package.json file for "${specifier}"`);
         }
         if (path.isAbsolute(entryPoint) && process.platform === 'win32') {
             entryPoint = pathToFileURL(entryPoint).href;
@@ -178,11 +179,11 @@ export class ComponentExtension {
         const module = await import(this.pkg.entryPoint);
         const ctor = module[this.exportName];
         if (!ctor)
-            throw new TypeError(`Exported component "${this.exportName}" not found in package "${this.pkg.name}"`);
+            throw new SbError(`Exported component "${this.exportName}" not found in package "${this.pkg.name}"`);
         if (typeof ctor !== 'function')
-            throw new TypeError(`Exported component "${this.exportName}" is not a class`);
+            throw new SbError(`Exported component "${this.exportName}" is not a class`);
         if (!isComponentBase(ctor.prototype))
-            throw new TypeError(`Exported component "${this.exportName}" does not extends ComponentBase`);
+            throw new SbError(`Exported component "${this.exportName}" does not extends ComponentBase`);
         this._ctor = ctor;
         return this._ctor;
     }
@@ -216,11 +217,11 @@ export class ProcessorExtension {
         const module = await import(this.pkg.entryPoint);
         const ctor = module[this.exportName];
         if (!ctor)
-            throw new TypeError(`Exported processor "${this.exportName}" not found in package "${this.pkg.name}"`);
+            throw new SbError(`Exported processor "${this.exportName}" not found in package "${this.pkg.name}"`);
         if (typeof ctor !== 'function')
-            throw new TypeError(`Exported processor "${this.exportName}" is not a class`);
+            throw new SbError(`Exported processor "${this.exportName}" is not a class`);
         if (!isProcessorBase(ctor.prototype))
-            throw new TypeError(`Exported processor "${this.exportName}" does not extends ProcessorBase`);
+            throw new SbError(`Exported processor "${this.exportName}" does not extends ProcessorBase`);
         this._ctor = ctor;
         return this._ctor;
     }

package/registry/extension-registry.js

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { SbError } from '../classes/sb-error.js';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
 import { ComponentExtension, ExtensionPackage, ProcessorExtension, } from './extension-package.js';
 import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './helpers.js';
@@ -24,7 +25,7 @@ export var ExtensionRegistry;
         const cmp = findComponent(className, version);
         if (cmp)
             return cmp;
-        throw new Error(`Component "${className}" version "${version}" not found in registry`);
+        throw new SbError(`Component "${className}" version "${version}" not found in registry`);
     }
     ExtensionRegistry.getComponent = getComponent;
     /**
@@ -42,7 +43,7 @@ export var ExtensionRegistry;
     function getProcessor(className, version = '*') {
         const cmp = findProcessor(className, version);
         if (!cmp) {
-            throw new Error(`Processor "${className}" version "${version}" not found in registry`);
+            throw new SbError(`Processor "${className}" version "${version}" not found in registry`);
         }
         return cmp;
     }
@@ -75,7 +76,7 @@ export var ExtensionRegistry;
     async function registerComponent(ctor) {
         const _metadata = Reflect.getMetadata(COMPONENT_OPTIONS, ctor);
         if (!_metadata)
-            throw new TypeError(`Class "${ctor.name}" has no component metadata.`);
+            throw new SbError(`Class "${ctor.name}" has no component metadata.`);
         if (_metadata.abstract)
             return;
         const metadata = await normalizeComponentMetadata(_metadata);
@@ -100,7 +101,7 @@ export var ExtensionRegistry;
     async function registerProcessor(ctor) {
         const _metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, ctor);
         if (!_metadata)
-            throw new TypeError(`Class "${ctor.name}" has no processor metadata.`);
+            throw new SbError(`Class "${ctor.name}" has no processor metadata.`);
         if (_metadata.abstract)
             return;
         const metadata = await normalizeProcessorMetadata(_metadata);

package/utils/{profile-utils.js → decode-profile.js}

@@ -1,5 +1,5 @@
 import { isAny, isBase64, isBoolean, isDateString, isEmail, isHex, isNumber, isString, isTime, isURL, validator, vg, } from 'valgen';
-import { SbError } from '../classes/sb-error.js';
+import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
 import { Profile, VariableType, } from '../models/index.js';
 import { getModelsDocument } from '../models-document.js';
@@ -14,7 +14,11 @@ export function decodeProfile(materializedMetadata, rawProfile, options) {
             issues
                 .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                 .join('\n  ');
-        throw new SbError(msg, {
+        issues.forEach(issue => {
+            if (issue instanceof SbValidationError)
+                delete issue.stack;
+        });
+        throw new SbValidationError(msg, {
             workerId: rawProfile.id,
             issues,
         });
@@ -75,11 +79,7 @@ function _codecProcessElement(stackExecutor, codec, metadata, profile, options)
             for (const [k, defComponent] of Object.entries(metadata.components)) {
                 if (!profile.components[k]) {
                     if (defComponent.required) {
-                        stackExecutor.issues.push({
-                            message: `Component "${k}" is required`,
-                            severity: 'error',
-                            location: `/components/${k}`,
-                        });
+                        stackExecutor.issues.push(new SbValidationError(`Component "${k}" is required`));
                     }
                     continue;
                 }

package/utils/materialize-metadata.js

@@ -1,5 +1,5 @@
 import { clone, merge, omitUndefined } from '@jsopen/objects';
-import { SbError } from '../classes/sb-error.js';
+import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
 import { VariableType, } from '../models/index.js';
 import { ExtensionRegistry } from '../registry/extension-registry.js';
@@ -13,7 +13,11 @@ export function materializeMetadata(profile) {
             issues
                 .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                 .join('\n  ');
-        throw new SbError(msg, {
+        issues.forEach(issue => {
+            if (issue instanceof SbValidationError)
+                delete issue.stack;
+        });
+        throw new SbValidationError(msg, {
             workerId: profile.id,
             issues,
         });
@@ -67,12 +71,12 @@ function _materializeComponents(stackExecutor, metadata, profile) {
             const profileComponent = profile?.components?.[componentName];
             if (!profileComponent) {
                 if (metadataComponent.required)
-                    throw new Error(`Component "${componentName}" should be configured`);
+                    throw new SbValidationError(`Component "${componentName}" should be configured`);
                 return;
             }
             /** istanbul ignore next */
             if (!profileComponent.className)
-                throw new Error(`"className" property required`);
+                throw new SbValidationError(`"className" property required`);
             const reg = ExtensionRegistry.getComponent(profileComponent.className);
             materializedComponent.className = profileComponent.className;
             materializedComponent.variables = merge({}, [reg.metadata.variables || {}, metadataComponent.variables || {}], { deep: 'full' });
@@ -80,14 +84,14 @@ function _materializeComponents(stackExecutor, metadata, profile) {
             if (metadataComponent.className) {
                 if (materializedComponent.className &&
                     materializedComponent.className !== metadataComponent.className)
-                    throw new Error(`Selected component class "${profileComponent.className}" do not match with definition component class (${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 Error(`Selected component "${profileComponent.className}" do not implements some of required interfaces (${filtered.join(',')}).`);
+                    throw new SbValidationError(`Selected component "${profileComponent.className}" do not implements some of required interfaces (${filtered.join(',')}).`);
                 }
             }
             if (materializedComponent.variables) {