@syncbridge/common 0.4.0

package/classes/runnable.js

@@ -0,0 +1,228 @@
+import { clearTimeout } from 'node:timers';
+import { AsyncEventEmitter } from 'node-events-async';
+import { NODE_ENV, noOp } from '../constants.js';
+import { ServiceStatus } from '../models/index.js';
+import { SbError } from './sb-error.js';
+/**
+ *
+ */
+export class Runnable extends AsyncEventEmitter {
+    _context;
+    constructor(init) {
+        super();
+        this.setMaxListeners(1000);
+        this._context = {
+            initialized: false,
+            status: ServiceStatus.stopped,
+            statusMessage: 'Stopped',
+            startMaxWaitMs: init?.startMaxWaitMs ?? (NODE_ENV === 'dev' ? 60000 * 5 : 30000),
+            stopMaxWaitMs: init?.stopMaxWaitMs ?? (NODE_ENV === 'dev' ? 60000 * 5 : 30000),
+        };
+    }
+    get status() {
+        return this._context.status;
+    }
+    get statusMessage() {
+        return this._context.statusMessage;
+    }
+    get startTime() {
+        return this._context.startTime;
+    }
+    /**
+     *
+     */
+    get stopped() {
+        return (this.status === ServiceStatus.stopped ||
+            this.status === ServiceStatus.invalid);
+    }
+    startNoWait() {
+        this.start().catch(noOp);
+    }
+    stopNoWait() {
+        this.stop().catch(noOp);
+    }
+    /**
+     *
+     */
+    async init() {
+        if (this._context.initialized)
+            return;
+        this._context.initialized = true;
+        await this._init().catch(e => {
+            const err = e instanceof SbError ? e : new SbError(e);
+            err.code = 'INIT_FAILED';
+            err.message = `Initialization failed doe to: ${err.message}`;
+            this.setStatus(ServiceStatus.invalid, err.message);
+            this.onError(err);
+            throw err;
+        });
+        this.onInitialize();
+    }
+    /**
+     *
+     */
+    async start(abortSignal) {
+        if (this._context.waitTimer)
+            await this._context.waitTimer;
+        if (this.status === ServiceStatus.started)
+            return;
+        this.setStatus(ServiceStatus.starting);
+        this._context.waitTimer = Promise.resolve()
+            .then(async () => {
+            await this.init();
+            try {
+                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', {
+                                code: 'START_TIMEOUT',
+                            });
+                            abortController.abort(err);
+                            reject(err);
+                        }, this._context.startMaxWaitMs).unref();
+                    }
+                    const onStopping = () => {
+                        clearTimeout(startWaitTimer);
+                        abortController.abort();
+                        reject();
+                    };
+                    this.once('stopping', onStopping);
+                    Promise.resolve()
+                        .then(async () => {
+                        await this._start(abortController.signal);
+                        if (promiseSettled)
+                            return;
+                        if (this._context.status === ServiceStatus.starting)
+                            this.setStatus(ServiceStatus.started);
+                        resolve();
+                    })
+                        .catch(e => {
+                        reject(e);
+                    })
+                        .finally(() => {
+                        this.removeListener('stopping', onStopping);
+                        clearTimeout(startWaitTimer);
+                    });
+                }).finally(() => (promiseSettled = true));
+            }
+            catch (e) {
+                const err = e instanceof SbError ? e : new SbError(e);
+                err.code = err.code || 'START_FAILED';
+                this.onError(err);
+                throw err;
+            }
+        })
+            .catch(async (e) => {
+            const err = e instanceof SbError ? e : new SbError(e);
+            this._context.waitTimer = undefined;
+            await this.stop().then(() => {
+                throw err;
+            });
+        })
+            .finally(() => {
+            this._context.waitTimer = undefined;
+        });
+        await this._context.waitTimer;
+    }
+    /**
+     *
+     */
+    async stop() {
+        if (this._context.waitTimer)
+            await this._context.waitTimer;
+        if (this.status === ServiceStatus.stopped)
+            return;
+        this.setStatus(ServiceStatus.stopping);
+        this.emit('stopping');
+        this._context.waitTimer = Promise.resolve()
+            .then(async () => {
+            try {
+                let promiseSettled = false;
+                await new Promise((resolve, reject) => {
+                    let stopWaitTimer;
+                    if (this._context.stopMaxWaitMs) {
+                        stopWaitTimer = setTimeout(() => {
+                            const err = new SbError('Stop timeout', {
+                                code: 'STOP_TIMEOUT',
+                            });
+                            reject(err);
+                        }, this._context.stopMaxWaitMs).unref();
+                    }
+                    Promise.resolve()
+                        .then(async () => {
+                        await this._stop();
+                        if (promiseSettled)
+                            return;
+                        if (this._context.status === ServiceStatus.stopping)
+                            this.setStatus(ServiceStatus.stopped);
+                        resolve();
+                    })
+                        .catch(e => reject(e))
+                        .finally(() => {
+                        clearTimeout(stopWaitTimer);
+                    });
+                }).finally(() => (promiseSettled = true));
+            }
+            catch (e) {
+                const err = e instanceof SbError ? e : new SbError(e);
+                err.code = err.code || 'STOP_FAILED';
+                this.onError(err);
+                this._context.waitTimer = undefined;
+                await this._terminate().then(() => {
+                    this.setStatus(ServiceStatus.stopped, err.message);
+                    throw e;
+                });
+            }
+        })
+            .finally(() => {
+            this._context.waitTimer = undefined;
+        });
+        await this._context.waitTimer;
+    }
+    /**
+     *
+     */
+    _init() {
+        return Promise.resolve();
+    }
+    /**
+     *
+     */
+    _terminate() {
+        return Promise.resolve();
+    }
+    /**
+     *
+     */
+    onError(err) {
+        this.emitSafe('error', err);
+    }
+    /**
+     *
+     */
+    onInitialize() {
+        this.emitSafe('initialize');
+    }
+    /**
+     *
+     */
+    onStatusChange() {
+        this.emitSafe('status-change', this.status, this.statusMessage);
+    }
+    /**
+     *
+     */
+    setStatus(status, statusMessage) {
+        if (this._context.status !== status) {
+            this._context.status = status;
+            this._context.statusMessage = statusMessage || '';
+            if (status === ServiceStatus.started)
+                this._context.startTime = new Date();
+            this.onStatusChange();
+        }
+    }
+}

package/classes/sb-error.d.ts

@@ -0,0 +1,11 @@
+export declare class SbError extends Error {
+    readonly cause?: Error;
+    code?: string;
+    [index: string]: any;
+    constructor(message?: string | Error, options?: SbErrorOptions);
+    toJSON(): any;
+}
+export interface SbErrorOptions {
+    cause?: Error;
+    [key: string]: any;
+}

package/classes/sb-error.js

@@ -0,0 +1,54 @@
+import { isPlainObject } from '@jsopen/objects';
+export class SbError extends Error {
+    code;
+    constructor(message, options) {
+        super(typeof message === 'object' ? message.message || '' : message);
+        if (message && typeof message === 'object') {
+            if (message instanceof Error) {
+                this.stack = message.stack;
+                Object.defineProperty(this, 'cause', {
+                    value: message,
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+            for (const k of Object.keys(message)) {
+                if (message[k] !== undefined) {
+                    Object.defineProperty(this, k, {
+                        value: message[k],
+                        writable: true,
+                        configurable: true,
+                        enumerable: !message[k] ||
+                            typeof message[k] !== 'object' ||
+                            isPlainObject(message[k]),
+                    });
+                }
+            }
+        }
+        if (options) {
+            for (const k of Object.keys(options)) {
+                if (options[k] !== undefined) {
+                    Object.defineProperty(this, k, {
+                        value: options[k],
+                        writable: true,
+                        configurable: true,
+                        enumerable: !options[k] ||
+                            typeof options[k] !== 'object' ||
+                            isPlainObject(options[k]),
+                    });
+                }
+            }
+        }
+    }
+    toJSON() {
+        const out = {
+            message: this.message,
+        };
+        for (const k of Object.keys(this)) {
+            if (k !== 'stack')
+                out[k] = this[k];
+        }
+        return out;
+    }
+}

package/classes/stack-executor.d.ts

@@ -0,0 +1,10 @@
+import { ErrorIssue } from '@opra/common';
+export declare class StackExecutor {
+    stack: string[];
+    issues: StackExecutor.Issue[];
+    execute(stack: string, fn: () => any): void;
+    handleError(e: any): void;
+}
+export declare namespace StackExecutor {
+    type Issue = ErrorIssue;
+}

package/classes/stack-executor.js

@@ -0,0 +1,37 @@
+import { ValidationError } from 'valgen';
+export class StackExecutor {
+    stack = [];
+    issues = [];
+    execute(stack, fn) {
+        this.stack.push(stack);
+        try {
+            fn();
+        }
+        catch (e) {
+            this.handleError(e);
+        }
+        finally {
+            this.stack.pop();
+        }
+    }
+    handleError(e) {
+        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 : ''),
+                });
+            });
+        }
+        else {
+            this.issues.push({
+                message: e.message,
+                ...e,
+                severity: 'error',
+                location,
+            });
+        }
+    }
+}

package/constants.d.ts

@@ -0,0 +1,6 @@
+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 VARIABLE_CONTAINER: unique symbol;
+export declare const noOp: () => undefined;
+export declare const NODE_ENV: string;

package/constants.js

@@ -0,0 +1,17 @@
+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 VARIABLE_CONTAINER = Symbol.for('VARIABLE_CONTAINER');
+export const noOp = () => undefined;
+export const NODE_ENV = process.env.NODE_ENV === 'test'
+    ? 'test'
+    : (process.env.NODE_ENV || '').startsWith('dev')
+        ? 'dev'
+        : 'prod';

package/decorators/component.decorator.d.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+import { DeepPartial, PartialSome, StrictOmit, Type } from 'ts-gems';
+import { ComponentBase } from '../classes/component-base.js';
+import { ComponentMetadata, ElementComponentMetadata, VariableMetadataRecord } 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>;
+    }
+    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

@@ -0,0 +1,28 @@
+import 'reflect-metadata';
+import { COMPONENT_OPTIONS } from '../constants.js';
+import { finalizeElementMetadata } from './finalize-element-metadata.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) {
+    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];
+    };
+}
+(function (Component) {
+    function UseVariables(variablesClass) {
+        return _UseVariables(variablesClass);
+    }
+    Component.UseVariables = UseVariables;
+    function UseComponent(options) {
+        return _UseComponent(options);
+    }
+    Component.UseComponent = UseComponent;
+})(Component || (Component = {}));

package/decorators/decorator-helpers.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+export declare function defineMergeMetadata(target: any, metadataKey: any, metadata: any): any;

package/decorators/decorator-helpers.js

@@ -0,0 +1,13 @@
+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;
+}

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

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+import { 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;
+type TEnumValue = (string | number)[] | Record<string, string | number>;
+type TVariable = DeepPartial<VariableMetadataRecord> | Type;
+export declare namespace DefineVariable {
+    interface Options extends Partial<StrictOmit<VariableMetadata, 'variables' | 'enumValues' | 'choice'>> {
+        variables?: TVariable | Promise<TVariable>;
+        enumValues?: TEnumValue | Promise<TEnumValue>;
+        choice?: string[] | Promise<string[]>;
+    }
+}
+export {};

package/decorators/define-variable.decorator.js

@@ -0,0 +1,57 @@
+import 'reflect-metadata';
+import { deepClone, merge, omitUndefined } from '@jsopen/objects';
+import { VARIABLE_CONTAINER } from '../constants.js';
+import { VariableType, } from '../models/index.js';
+export function DefineVariable(options) {
+    return function (target, propertyKey) {
+        /** c8 ignore next */
+        if (typeof propertyKey !== 'string')
+            throw new TypeError('Property key must be a string');
+        const designType = Reflect.getMetadata('design:type', target, propertyKey);
+        if (designType === Array)
+            options.isArray = true;
+        if (typeof options.variables === 'function') {
+            options.type = VariableType.Nested;
+            options.variables = Reflect.getMetadata(VARIABLE_CONTAINER, options.variables.prototype);
+        }
+        if (options.enumValues && !options.type) {
+            options.type = VariableType.Enum;
+        }
+        if (options.type !== VariableType.Enum)
+            delete options.enumValues;
+        if (!options.type) {
+            if (designType === String)
+                options.type = VariableType.String;
+            else if (designType === Boolean)
+                options.type = VariableType.Boolean;
+            else if (designType === Number)
+                options.type = VariableType.Number;
+            else if (typeof designType === 'function' &&
+                Reflect.hasMetadata(VARIABLE_CONTAINER, designType.prototype)) {
+                options.type = VariableType.Nested;
+                options.variables = Reflect.getMetadata(VARIABLE_CONTAINER, designType.prototype);
+            }
+        }
+        if (options.isArray && !options.type)
+            throw new TypeError('Array variables must have type defined. ' +
+                (target.constructor.name +
+                    '.' +
+                    propertyKey +
+                    ' is an array variable'));
+        const base = Object.getPrototypeOf(target);
+        const baseMetadata = Reflect.hasMetadata(VARIABLE_CONTAINER, base)
+            ? deepClone(Reflect.getMetadata(VARIABLE_CONTAINER, base))
+            : {};
+        let metadata = merge(baseMetadata, options, {
+            deep: 'full',
+            ignoreNulls: false,
+            ignoreUndefined: false,
+        });
+        metadata = omitUndefined(metadata, 'full');
+        const metadataRecord = Reflect.hasOwnMetadata(VARIABLE_CONTAINER, target)
+            ? Reflect.getMetadata(VARIABLE_CONTAINER, target)
+            : {};
+        metadataRecord[propertyKey] = metadata;
+        Reflect.defineMetadata(VARIABLE_CONTAINER, metadataRecord, target);
+    };
+}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,30 @@
+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/decorators/processor-events.decorator.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+import { Type } from 'ts-gems';
+import type { ProcessorBase } from '../classes/processor-base.js';
+export declare function OnCreateProfile<T extends Type<ProcessorBase>>(): (target: T, propertyKey: string | symbol) => void;
+export declare function OnUpdateProfile<T extends Type<ProcessorBase>>(): (target: T, propertyKey: string | symbol) => void;

package/decorators/processor-events.decorator.js

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+import { OWN_ELEMENT_METADATA } from '../constants.js';
+import { defineMergeMetadata } from './decorator-helpers.js';
+export function OnCreateProfile() {
+    return function (target, propertyKey) {
+        defineMergeMetadata(target, OWN_ELEMENT_METADATA, {
+            staticEvents: {
+                onCreateProfile: propertyKey,
+            },
+        });
+    };
+}
+export function OnUpdateProfile() {
+    return function (target, propertyKey) {
+        defineMergeMetadata(target, OWN_ELEMENT_METADATA, {
+            staticEvents: {
+                onUpdateProfile: propertyKey,
+            },
+        });
+    };
+}

package/decorators/processor.decorator.d.ts

@@ -0,0 +1,31 @@
+import 'reflect-metadata';
+import { DeepPartial, PartialSome, StrictOmit, Type } from 'ts-gems';
+import type { ProcessorBase } from '../classes/processor-base.js';
+import { ElementComponentMetadata, ProcessorMetadata, VariableMetadataRecord } 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 {
+    /**
+     *
+     */
+    function UseVariables<T extends ProcessorBase>(variablesClass?: Type): (target: T, propertyKey: "values") => void;
+    /**
+     *
+     */
+    function UseComponent<T extends ProcessorBase>(options: _UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
+    /**
+     *
+     */
+    function OnCreateProfile<T extends ProcessorBase>(): (target: Type<T>, propertyKey: string | symbol) => void;
+    /**
+     *
+     */
+    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>;
+    }
+}

package/decorators/processor.decorator.js

@@ -0,0 +1,42 @@
+import 'reflect-metadata';
+import { PROCESSOR_OPTIONS } from '../constants.js';
+import { finalizeElementMetadata } from './finalize-element-metadata.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) {
+    return function (target) {
+        finalizeElementMetadata(target, options, PROCESSOR_OPTIONS, NAME_PATTERN);
+    };
+}
+(function (Processor) {
+    /**
+     *
+     */
+    function UseVariables(variablesClass) {
+        return _UseVariables(variablesClass);
+    }
+    Processor.UseVariables = UseVariables;
+    /**
+     *
+     */
+    function UseComponent(options) {
+        return _UseComponent(options);
+    }
+    Processor.UseComponent = UseComponent;
+    /**
+     *
+     */
+    function OnCreateProfile() {
+        return _OnCreateProfile();
+    }
+    Processor.OnCreateProfile = OnCreateProfile;
+    /**
+     *
+     */
+    function OnUpdateProfile() {
+        return _OnUpdateProfile();
+    }
+    Processor.OnUpdateProfile = OnUpdateProfile;
+})(Processor || (Processor = {}));

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

@@ -0,0 +1,9 @@
+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 namespace UseComponent {
+    interface Options extends Partial<ElementComponentMetadata> {
+    }
+}