@adaas/a-utils 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "A-Utils is a set of utilities that are used across the ADAAS ecosystem. This package is designed to be a collection of utilities that are used across the ADAAS ecosystem.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

package/src/index.ts

@@ -96,10 +96,14 @@ export { A_Route } from './lib/A-Route/A-Route.entity';
 export { A_Signal } from './lib/A-Signal/entities/A-Signal.entity';
 export { A_SignalVector } from './lib/A-Signal/entities/A-SignalVector.entity';
 export { A_SignalBus } from './lib/A-Signal/components/A-SignalBus.component';
+export { A_SignalBusError } from './lib/A-Signal/components/A-SignalBus.error';
+
+export * from './lib/A-Signal/components/A-SignalBus.constants';
+// export * from './lib/A-Signal/components/A-SignalBus.types';
 export { A_SignalConfig } from './lib/A-Signal/context/A-SignalConfig.context';
 export { A_SignalState } from './lib/A-Signal/context/A-SignalState.context';
 export * from './lib/A-Signal/A-Signal.types';
-export * from './lib/A-Signal/A-Signal.constants';  
+// export * from './lib/A-Signal/A-Signal.constants';  
 
 // ============================================================================
 // A-Schedule Components

package/src/lib/A-Signal/A-Signal.constants.ts

@@ -1,10 +0,0 @@
-
-export enum A_SignalFeatures {
-    Next = '_A_SignalFeatures_Next',
-}
-
-
-
-export enum A_SignalVectorFeatures {
-    Next = '_A_SignalVectorFeatures_Next',
-}

package/src/lib/A-Signal/components/A-SignalBus.component.ts

@@ -1,11 +1,12 @@
-import { A_Caller, A_Component, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
-import { A_SignalFeatures } from "../A-Signal.constants";
+import { A_Caller, A_Component, A_Context, A_Dependency, A_Error, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
 import { A_SignalState } from "../context/A-SignalState.context";
 import { A_SignalConfig } from "../context/A-SignalConfig.context";
 import { A_Config } from "../../A-Config/A-Config.context";
 import { A_Logger } from "../../A-Logger/A-Logger.component";
 import { A_Signal } from "../entities/A-Signal.entity";
 import { A_Frame } from "@adaas/a-frame";
+import { A_SignalBusFeatures } from "./A-SignalBus.constants";
+import { A_SignalBusError } from "./A-SignalBus.error";
 
 
 
@@ -27,44 +28,82 @@ import { A_Frame } from "@adaas/a-frame";
 export class A_SignalBus extends A_Component {
 
 
-    /**
-     * This methods extends A-Signal Emit feature to handle signal emission within the bus.
-     * 
-     * It updates the signal state and emits the updated signal vector.
-     * 
-     * @param signal 
-     * @param globalConfig 
-     * @param logger 
-     * @param state 
-     * @param config 
-     * @returns 
-     */
+    @A_Frame.Method({
+        description: 'Emit multiple signals through the signal bus.'
+    })
+    async next(...signals: A_Signal[]) {
+        const scope = new A_Scope({
+            name: `A_SignalBus-Next-Scope`,
+            entities: signals
+        })
+            .inherit(A_Context.scope(this));
+
+        try {
+            await this.call(A_SignalBusFeatures.onBeforeNext, scope);
+            await this.call(A_SignalBusFeatures.onNext, scope);
+
+            scope.destroy();
+
+        } catch (error) {
+
+            let wrappedError;
+
+            switch (true) {
+                case error instanceof A_SignalBusError:
+                    wrappedError = error;
+                    break;
+
+                case error instanceof A_Error && error.originalError instanceof A_SignalBusError:
+                    wrappedError = error.originalError;
+                    break;
+
+                default:
+                    wrappedError = new A_SignalBusError({
+                        title: A_SignalBusError.SignalProcessingError,
+                        description: `An error occurred while processing the signal.`,
+                        originalError: error
+                    })
+                    break;
+            }
+
+            scope.register(wrappedError);
+
+            await this.call(A_SignalBusFeatures.onError);
+
+            scope.destroy();
+        }
+    }
+
+
+    @A_Feature.Extend({
+        before: /.*/
+    })
+    protected async [A_SignalBusFeatures.onError](
+        @A_Inject(A_Error) error: A_Error,
+        @A_Inject(A_Logger) logger?: A_Logger,
+        ...args: any[]
+    ) {
+        logger?.error(error);
+    }
+
     @A_Feature.Extend({
-        scope: [A_Signal]
+        scope: [A_SignalBus],
+        before: /.*/
     })
-    async [A_SignalFeatures.Next](
-        @A_Inject(A_Caller) signal: A_Signal,
+    async [A_SignalBusFeatures.onBeforeNext](
         @A_Inject(A_Scope) scope: A_Scope,
 
         @A_Inject(A_Config) globalConfig?: A_Config<['A_SIGNAL_VECTOR_STRUCTURE']>,
-        @A_Inject(A_Logger) logger?: A_Logger,
         @A_Inject(A_SignalState) state?: A_SignalState,
+
+        @A_Inject(A_Logger) logger?: A_Logger,
         @A_Inject(A_SignalConfig) config?: A_SignalConfig,
     ) {
-
-        /*
-        1) create a signal when it occurs via new A_Signal('somedata')
-        2) emit a signal when needed via signal.emit(scope)
-        3) the bus should listen for all emitted signals within the scope
-        4) when a signal is emitted, the bus should store a signal in some place (probably it's memory)
-        */
-
         /**
          * We need a context where component is registered, to prevent any duplicate registrations
          */
         const componentContext = A_Context.scope(this);
 
-
         if (!config) {
             config = new A_SignalConfig({
                 stringStructure: globalConfig?.get('A_SIGNAL_VECTOR_STRUCTURE') || undefined
@@ -80,22 +119,61 @@ export class A_SignalBus extends A_Component {
             state = new A_SignalState(config.structure);
             componentContext.register(state);
         }
+    }
+
+    /**
+     * This methods extends A-Signal Emit feature to handle signal emission within the bus.
+     * 
+     * It updates the signal state and emits the updated signal vector.
+     * 
+     * @param signal 
+     * @param globalConfig 
+     * @param logger 
+     * @param state 
+     * @param config 
+     * @returns 
+     */
+    @A_Feature.Extend({
+        scope: [A_SignalBus],
+        before: /.*/
+    })
+    async [A_SignalBusFeatures.onNext](
+        // @A_Dependency.All()
+        // @A_Inject(A_Signal) signal: A_Signal[],
+        @A_Inject(A_Scope) scope: A_Scope,
+
+        @A_Dependency.Required()
+        @A_Inject(A_SignalState) state: A_SignalState,
+
+        @A_Inject(A_Config) globalConfig?: A_Config<['A_SIGNAL_VECTOR_STRUCTURE']>,
+        @A_Inject(A_Logger) logger?: A_Logger,
+        @A_Inject(A_SignalConfig) config?: A_SignalConfig,
+    ) {
+        /*
+        1) create a signal when it occurs via new A_Signal('somedata')
+        2) emit a signal when needed via bus.next(signal)
+        3) the bus should listen for all emitted signals within the scope
+        4) when a signal is emitted, the bus should store a signal in some place (probably it's memory)
+        */
+        const signals = scope.resolveFlatAll<A_Signal>(A_Signal);
 
+        for (const signal of signals) {
 
-        if (!state.has(signal))
-            return;
+            if (!state.has(signal))
+                return;
 
+            //  ------------------------------------------------------------------
+            //  And finally if all checks are passed, we can update the state
+            //  ------------------------------------------------------------------
 
-        //  ------------------------------------------------------------------
-        //  And finally if all checks are passed, we can update the state
-        //  ------------------------------------------------------------------
+            logger?.debug(`A_SignalBus: Updating state for signal '${signal.constructor.name}' with data:`, signal.data);
 
-        logger?.debug(`A_SignalBus: Updating state for signal '${signal.constructor.name}' with data:`, signal.data);
+            state.set(signal);
 
-        state.set(signal);
+            const vector = state.toVector();
 
-        const vector = state.toVector();
+            scope.register(vector);
 
-        await vector.next(scope);
+        }
     }
 }

package/src/lib/A-Signal/components/A-SignalBus.constants.ts

@@ -0,0 +1,7 @@
+
+export enum A_SignalBusFeatures {
+    onBeforeNext = '_A_SignalBusFeatures_onBeforeNext',
+    onNext = '_A_SignalBusFeatures_onNext',
+
+    onError = '_A_SignalBusFeatures_onError',
+}

package/src/lib/A-Signal/components/A-SignalBus.error.ts

@@ -0,0 +1,9 @@
+import { A_Error } from "@adaas/a-concept";
+
+
+
+export class A_SignalBusError extends A_Error {
+
+
+    static readonly SignalProcessingError = 'Signal processing error';
+}

package/src/lib/A-Signal/entities/A-Signal.entity.ts

@@ -1,6 +1,5 @@
 import { A_Entity, A_Scope } from "@adaas/a-concept";
 import { A_Signal_Init, A_Signal_Serialized } from "../A-Signal.types";
-import { A_SignalFeatures } from "../A-Signal.constants";
 import { A_Frame } from "@adaas/a-frame";
 
 /**
@@ -52,17 +51,6 @@ export class A_Signal<
         this.data = newEntity.data;
     }
 
-    /**
-     * Emits this signal within the provided scope.
-     * 
-     * Scope is mandatory since signal itself should not be registered in the scope, 
-     * but should use particular scope context to use proper set of components
-     * 
-     * @param scope 
-     */
-    async next(scope: A_Scope) {
-        await this.call(A_SignalFeatures.Next, scope);
-    }
 
 
     toJSON(): A_Signal_Serialized<_TSignalDataType> {

package/src/lib/A-Signal/entities/A-SignalVector.entity.ts

@@ -1,7 +1,6 @@
 import { A_Entity, A_Scope, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
 import { A_SignalVector_Serialized, A_SignalVector_Init } from "../A-Signal.types";
 import { A_Signal } from "./A-Signal.entity";
-import { A_SignalVectorFeatures } from "../A-Signal.constants";
 import { A_Frame } from "@adaas/a-frame";
 
 
@@ -94,15 +93,6 @@ export class A_SignalVector<
     }
 
 
-    /**
-     * Emits the signal vector to the specified scope.
-     * 
-     * @param scope
-     */
-    async next(scope: A_Scope): Promise<void> {
-        return await this.call(A_SignalVectorFeatures.Next, scope);
-    }
-
     
     /**
      * Checks if the vector contains a signal of the specified type.

package/tests/A-Signal.test.ts

@@ -1,6 +1,6 @@
-import { A_Caller, A_Component, A_Concept, A_Container, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
-import { A_SignalVectorFeatures } from "@adaas/a-utils/lib/A-Signal/A-Signal.constants";
+import { A_Component, A_Concept, A_Container, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
 import { A_SignalBus } from "@adaas/a-utils/lib/A-Signal/components/A-SignalBus.component";
+import { A_SignalBusFeatures } from "@adaas/a-utils/lib/A-Signal/components/A-SignalBus.constants";
 import { A_SignalConfig } from "@adaas/a-utils/lib/A-Signal/context/A-SignalConfig.context";
 import { A_Signal } from "@adaas/a-utils/lib/A-Signal/entities/A-Signal.entity";
 import { A_SignalVector } from "@adaas/a-utils/lib/A-Signal/entities/A-SignalVector.entity";
@@ -71,23 +71,19 @@ describe('A-Signal tests', () => {
         class UserIntentionListener extends A_Component {
             @A_Concept.Start()
             async start(
-                @A_Inject(A_Scope) scope: A_Scope,
                 @A_Inject(A_SignalBus) bus: A_SignalBus
             ) {
-
-
-                const signal = new A_Signal({
+                await bus.next(new A_Signal({
                     data: {
                         buttonId: 'submit-order'
                     }
-                })
-                await signal.next(scope)
+                }))
             }
 
 
             @A_Feature.Extend()
-            async [A_SignalVectorFeatures.Next](
-                @A_Inject(A_Caller) vector: A_SignalVector
+            async [A_SignalBusFeatures.onNext](
+                @A_Inject(A_SignalVector) vector: A_SignalVector
             ) {
                 result = vector;
             }
@@ -145,13 +141,13 @@ describe('A-Signal tests', () => {
                     }
                 })
 
-                await signal.next(scope)
+                await bus.next(signal)
             }
 
 
             @A_Feature.Extend()
-            async [A_SignalVectorFeatures.Next](
-                @A_Inject(A_Caller) vector: A_SignalVector
+            async [A_SignalBusFeatures.onNext](
+                @A_Inject(A_SignalVector) vector: A_SignalVector
             ) {
                 result = vector;
             }