@adaas/a-utils 0.1.24 → 0.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "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",
@@ -80,7 +80,7 @@
     "build": "tsup --config tsup.config.ts"
   },
   "dependencies": {
-    "@adaas/a-concept": "^0.1.46"
+    "@adaas/a-concept": "^0.1.47"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",

package/src/index.ts

@@ -71,6 +71,13 @@ export { A_ExecutionContext } from './lib/A-Execution/A-Execution.context';
 export { A_OperationContext } from './lib/A-Operation/A-Operation.context';
 export * from './lib/A-Operation/A-Operation.types';
 
+// ============================================================================
+// A-Service Container
+// ============================================================================ 
+export { A_Service } from './lib/A-Service/A-Service.container';
+// export * from './lib/A-Service/A-Service.types';
+export * from './lib/A-Service/A-Service.constants';
+
 // ============================================================================
 // A-Polyfill Components
 // ============================================================================

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

@@ -0,0 +1,17 @@
+export enum A_ServiceFeatures {
+
+    onBeforeLoad = '_A_Service_onBeforeLoad',
+    onLoad = '_A_Service_onLoad',
+    onAfterLoad = '_A_Service_onAfterLoad',
+
+    onBeforeStart = '_A_Service_onBeforeStart',
+    onStart = '_A_Service_onStart',
+    onAfterStart = '_A_Service_onAfterStart',
+
+    onBeforeStop = '_A_Service_onBeforeStop',
+    onStop = '_A_Service_onStop',
+    onAfterStop = '_A_Service_onAfterStop',
+
+
+    onError = '_A_Service_onError',
+}

package/src/lib/A-Service/A-Service.container.ts

@@ -0,0 +1,162 @@
+import { A_Concept, A_Container, A_Error, A_Feature, A_Inject } from "@adaas/a-concept";
+import { A_ServiceFeatures } from "./A-Service.constants";
+import { A_Polyfill } from "../A-Polyfill/A-Polyfill.component";
+import { A_Config } from "../A-Config/A-Config.context";
+import { A_Logger } from "../A-Logger/A-Logger.component";
+import { A_Service_Error } from "./A-Service.error";
+
+
+
+
+/**
+ * A-Service is a container that can run different types of services, such as HTTP servers, workers, etc.
+ * Depending on the provided config and configuration, it will load the necessary components and start the service.
+ * 
+ */
+export class A_Service extends A_Container {
+
+
+    @A_Concept.Start()
+    /**
+     * Start the server
+     */
+    async start() {
+        try {
+            await this.call(A_ServiceFeatures.onBeforeStart);
+
+            await this.call(A_ServiceFeatures.onStart);
+
+            await this.call(A_ServiceFeatures.onAfterStart);
+
+        } catch (error) {
+
+            let wrappedError;
+
+            switch (true) {
+                case error instanceof A_Service_Error:
+                    wrappedError = error;
+                    break;
+
+                case error instanceof A_Error && error.originalError instanceof A_Service_Error:
+                    wrappedError = error.originalError;
+                    break;
+
+                default:
+                    wrappedError = new A_Service_Error({
+                        title: A_Service_Error.ServiceStartError,
+                        description: 'An error occurred while processing the request.',
+                        originalError: error
+                    })
+                    break;
+            }
+
+            this.scope.register(wrappedError);
+
+            await this.call(A_ServiceFeatures.onError);
+        }
+
+    }
+
+    @A_Concept.Stop()
+    /**
+     * Stop the server
+     */
+    async stop() {
+        try {
+            await this.call(A_ServiceFeatures.onBeforeStop);
+
+            await this.call(A_ServiceFeatures.onStop);
+
+            await this.call(A_ServiceFeatures.onAfterStop);
+
+        } catch (error) {
+
+            let wrappedError;
+
+            switch (true) {
+                case error instanceof A_Service_Error:
+                    wrappedError = error;
+                    break;
+
+                case error instanceof A_Error && error.originalError instanceof A_Service_Error:
+                    wrappedError = error.originalError;
+                    break;
+
+                default:
+                    wrappedError = new A_Service_Error({
+                        title: A_Service_Error.ServiceStopError,
+                        description: 'An error occurred while processing the request.',
+                        originalError: error
+                    })
+                    break;
+            }
+
+            this.scope.register(wrappedError);
+
+            await this.call(A_ServiceFeatures.onError);
+        }
+    }
+
+    // ======================================================================================
+    // ============================= A-Service Lifecycle =================================
+    // ======================================================================================
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onBeforeLoad](
+        @A_Inject(A_Polyfill) polyfill: A_Polyfill,
+    ): Promise<void> {
+        // Initialize Polyfill
+        if (!polyfill) {
+            this.scope.register(A_Polyfill);
+            polyfill = this.scope.resolve(A_Polyfill)!
+        }
+    }
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onLoad](...args: any[]) { }
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onAfterLoad](...args: any[]) { }
+
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onBeforeStart](...args: any[]) { }
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onStart](...args: any[]) { }
+
+    @A_Feature.Extend()
+    protected async  [A_ServiceFeatures.onAfterStart](...args: any[]) { }
+
+
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onBeforeStop](...args: any[]) { }
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onStop](...args: any[]) { }
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onAfterStop](...args: any[]) { }
+
+
+
+    @A_Feature.Extend({
+        before: /.*/
+    })
+    protected async [A_ServiceFeatures.onError](
+        @A_Inject(A_Error) error: A_Error,
+        @A_Inject(A_Logger) logger?: A_Logger,
+        ...args: any[]) {
+        logger?.error(error);
+    }
+
+}
+
+
+
+
+
+
+
+

package/src/lib/A-Service/A-Service.error.ts

@@ -0,0 +1,11 @@
+import { A_Error } from "@adaas/a-concept";
+
+
+
+export class A_Service_Error extends A_Error {
+
+    static readonly ServiceStartError = 'Service start error';
+
+    static readonly ServiceStopError = 'Service stop error';
+
+}

package/src/lib/A-Service/A-Service.types.ts

@@ -0,0 +1,32 @@
+import { A_Component, A_Fragment } from "@adaas/a-concept";
+
+
+export type A_SERVER_TYPES__ServerFeatures = [
+    A_SERVER_TYPES__ServerFeature.beforeStart,
+    A_SERVER_TYPES__ServerFeature.afterStart,
+    A_SERVER_TYPES__ServerFeature.beforeStop,
+    A_SERVER_TYPES__ServerFeature.afterStop,
+    A_SERVER_TYPES__ServerFeature.onRequest
+]
+
+export enum A_SERVER_TYPES__ServerFeature {
+    beforeStart = 'beforeStart',
+    afterStart = 'afterStart',
+    beforeStop = 'beforeStop',
+    afterStop = 'afterStop',
+    beforeRequest = 'beforeRequest',
+    onRequest = 'onRequest',
+    afterRequest = 'afterRequest',
+}
+
+
+export type A_ServiceConstructor = {
+    name: string,
+    version: string,
+    controllers: Array<A_Component>,
+    entities: Array<A_Fragment>,
+    extensions: Array<A_Component>
+}
+
+
+

package/tests/A-Command.test.ts

@@ -612,6 +612,71 @@ describe('A-Command tests', () => {
             expect([A_Command_Status.COMPLETED, A_Command_Status.FAILED])
                 .toContain(command.status);
         });
+
+        it('Should stop command execution in case of error', async () => {
+
+            class FailingProcessor extends A_Component {
+
+                @A_Feature.Extend({
+                    name: A_CommandFeatures.onExecute
+                })
+                async step1(
+                    @A_Inject(A_Caller) command: ErrorTestCommand
+                ) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+
+                    testExecutionLog.push('Step 1 executed');
+                }
+
+                @A_Feature.Extend({
+                    name: A_CommandFeatures.onExecute
+                })
+                async step2(
+                    @A_Inject(A_Caller) command: ErrorTestCommand
+                ) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    testExecutionLog.push('Step 2 executed');
+                    throw new Error('Simulated error in step 2');
+                }
+
+                @A_Feature.Extend({
+                    name: A_CommandFeatures.onExecute
+                })
+                async step3(
+                    @A_Inject(A_Caller) command: ErrorTestCommand
+                ) {
+                    testExecutionLog.push('Step 3 executed');
+                }
+            }
+
+            const container = new A_Container({
+                name: 'Error Stop Test Container',
+                components: [
+                    FailingProcessor,
+                    A_StateMachine
+                ],
+                entities: [ErrorTestCommand]
+            });
+
+            const concept = new A_Concept({
+                containers: [container]
+            });
+
+            await concept.load();
+
+            const command = new ErrorTestCommand({ shouldFail: true });
+            container.scope.register(command);
+
+            await command.execute();
+
+            expect(command.status).toBe(A_Command_Status.FAILED);
+            expect(command.error).toBeDefined();
+            expect(command.isProcessed).toBe(true);
+            expect(testExecutionLog).toEqual([
+                'Step 1 executed',
+                'Step 2 executed'
+            ]); // Step 3 should not be executed
+        });
     });
 
     // =============================================================================