@adaas/a-utils 0.1.18 → 0.1.20

package/src/lib/A-Channel/A-Channel.component.ts

@@ -1,9 +1,8 @@
 import { A_Component, A_Context, A_Error, A_Feature, A_IdentityHelper, A_Inject, A_Scope, A_TYPES__InjectableConstructors, A_TYPES__InjectableTargets } from "@adaas/a-concept";
 import { A_ChannelError } from "./A-Channel.error";
 import { A_ChannelFeatures } from "./A-Channel.constants";
+import { A_OperationContext } from "../A-Operation/A-Operation.context";
 import { A_ChannelRequest } from "./A-ChannelRequest.context";
-import { A_Logger } from "../A-Logger/A-Logger.component";
-import { A_Config } from "../A-Config/A-Config.context";
 
 /**
  * A-Channel - A powerful, extensible communication channel component
@@ -406,7 +405,6 @@ export class A_Channel extends A_Component {
 
         try {
             // Set up dependency injection scope
-            requestScope.inherit(A_Context.scope(this));
             requestScope.register(context);
 
             // Execute request lifecycle
@@ -415,6 +413,7 @@ export class A_Channel extends A_Component {
             await this.call(A_ChannelFeatures.onAfterRequest, requestScope);
 
             this._processing = false;
+
             return context;
 
         } catch (error) {
@@ -423,11 +422,14 @@ export class A_Channel extends A_Component {
             // Create channel-specific error
             const channelError = new A_ChannelError(error);
             context.fail(channelError);
+            requestScope.register(channelError);
 
             // Call error handling hook
             await this.call(A_ChannelFeatures.onError, requestScope);
 
-            return context;
+            requestScope.destroy();
+
+            throw channelError;
         }
     }
 
@@ -488,7 +490,7 @@ export class A_Channel extends A_Component {
         });
 
         // Create request context for the message
-        const context = new A_ChannelRequest<_ParamsType>(message);
+        const context = new A_OperationContext('send', message);
 
         try {
             // Set up dependency injection scope
@@ -505,11 +507,14 @@ export class A_Channel extends A_Component {
 
             // Create channel-specific error
             const channelError = new A_ChannelError(error);
+            requestScope.register(channelError);
             context.fail(channelError);
 
             // Call error handling hook
             await this.call(A_ChannelFeatures.onError, requestScope);
 
+            requestScope.destroy();
+
             // Note: We don't re-throw the error for fire-and-forget operations
             // The error is handled by the onError hook
         }
@@ -523,14 +528,14 @@ export class A_Channel extends A_Component {
      * For fire-and-forget pattern: Use send()
      * For consumer patterns: Implement custom consumer logic using request() in a loop
      */
-    async consume<T extends Record<string, any> = Record<string, any>>(): Promise<A_ChannelRequest<any, T>> {
+    async consume<T extends Record<string, any> = Record<string, any>>(): Promise<A_OperationContext<any, T>> {
         await this.initialize;
 
         this._processing = true;
 
         const requestScope = new A_Scope({ name: `a-channel@scope:consume:${A_IdentityHelper.generateTimeId()}` });
 
-        const context = new A_ChannelRequest<any, T>();
+        const context = new A_OperationContext('consume', {} as T);
 
         try {
             requestScope.inherit(A_Context.scope(this));
@@ -541,7 +546,7 @@ export class A_Channel extends A_Component {
 
             this._processing = false;
 
-            return context
+            return context as A_OperationContext<any, T>;
 
         } catch (error) {
 
@@ -553,73 +558,8 @@ export class A_Channel extends A_Component {
 
             await this.call(A_ChannelFeatures.onError, requestScope);
 
-            return context;
+            return context as A_OperationContext<any, T>;
         }
     }
 
-}
-
-
-
-
-class HttpChannel extends A_Channel {
-
-    protected baseUrl!: string
-}
-
-
-class SSOChannel extends HttpChannel {
-    constructor() {
-        super();
-
-        this.baseUrl = 'https://sso.example.com';
-    }
-}
-
-
-class PrstChannel extends HttpChannel {
-
-    constructor() {
-        super();
-
-        this.baseUrl = 'https://prst.example.com';
-    }
-}
-
-
-class PollyspotChannel extends HttpChannel {
-
-    constructor() {
-        super();
-
-        this.baseUrl = 'https://pollyspot.example.com';
-    }
-}
-
-
-class GlobalErrorhandler extends A_Component {
-
-    @A_Feature.Extend({
-        name: A_ChannelFeatures.onError,
-        scope: [PollyspotChannel]
-    })
-    async handleError(
-        @A_Inject(A_ChannelRequest) context: A_ChannelRequest<any, any>,
-        @A_Inject(A_Logger) logger: A_Logger,
-        @A_Inject(A_Config) config: A_Config
-    ) {
-        // Handle the error
-    }
-
-    @A_Feature.Extend({
-        name: A_ChannelFeatures.onError,
-    })
-    async anotherError(
-        @A_Inject(A_ChannelRequest) context: A_ChannelRequest<any, any>,
-        @A_Inject(A_Logger) logger: A_Logger,
-        @A_Inject(A_Config) config: A_Config
-    ) {
-        // Handle the error
-
-    }
 }

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

@@ -1,5 +1,5 @@
 import { A_Error, A_TypeGuards } from "@adaas/a-concept";
-import { A_ChannelRequest } from "./A-ChannelRequest.context";
+import { A_OperationContext } from "../A-Operation/A-Operation.context";
 
 
 export class A_ChannelError extends A_Error {
@@ -15,7 +15,7 @@ export class A_ChannelError extends A_Error {
     // ==================== Properties ==========================
     // ==========================================================
 
-    protected _context?: A_ChannelRequest
+    protected _context?: A_OperationContext
 
 
     /**
@@ -27,21 +27,21 @@ export class A_ChannelError extends A_Error {
      */
     constructor(
         originalError: string | A_Error | Error | any,
-        context?: A_ChannelRequest | string
+        context?: A_OperationContext | string
     ) {
         if (A_TypeGuards.isString(context))
             super(originalError, context);
         else
             super(originalError);
 
-        if (context instanceof A_ChannelRequest)
+        if (context instanceof A_OperationContext)
             this._context = context
     }
 
     /***
      * Returns Context of the error
      */
-    get context(): A_ChannelRequest | undefined {
+    get context(): A_OperationContext | undefined {
         return this._context
     }
 

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

@@ -1,11 +1,3 @@
+import { A_ChannelRequestStatuses } from "./A-Channel.constants";
+import { A_OperationContext } from "../A-Operation/A-Operation.context";
 
-
-export type A_ChannelRequestContext_Serialized<
-    _ParamsType extends Record<string, any> = Record<string, any>,
-    _ResultType extends Record<string, any> = Record<string, any>,
-> = {
-    params: _ParamsType;
-    result?: _ResultType;
-    status: string;
-    errors?: string[];
-};

package/src/lib/A-Channel/A-ChannelRequest.context.ts

@@ -1,91 +1,42 @@
-import { A_Error, A_Fragment } from "@adaas/a-concept";
+import { A_OperationContext } from "../A-Operation/A-Operation.context";
 import { A_ChannelRequestStatuses } from "./A-Channel.constants";
-import { A_ChannelRequestContext_Serialized } from "./A-Channel.types";
-
 
 export class A_ChannelRequest<
     _ParamsType extends Record<string, any> = Record<string, any>,
     _ResultType extends Record<string, any> = Record<string, any>,
-> extends A_Fragment {
-
-
-    protected _params: _ParamsType;
-    protected _result?: _ResultType;
-    protected _errors: Set<Error> = new Set();
-
-    protected _status: A_ChannelRequestStatuses = A_ChannelRequestStatuses.PENDING;
-
+> extends A_OperationContext<
+    'request',
+    _ParamsType,
+    {
+        data?: _ResultType;
+        status?: A_ChannelRequestStatuses;
+    }
+> {
 
     constructor(
-        params: Partial<_ParamsType> = {}
+        params?: _ParamsType,
     ) {
-        super();
-        this._params = params as _ParamsType;
+        super('request', params);
     }
 
-    /**
-     * Returns the status of the request
-     */
-    get status(): A_ChannelRequestStatuses {
-        return this._status;
-    }
 
-    /**
-     * Returns the parameters of the request
-     */
-    get failed(): boolean {
-        return this._errors.size > 0;
-    }
-    /**
-     * Returns the Params of the Request
-     */
-    get params() {
-        return this._params;
-    }
-    /**
-     * Returns the Result of the Request
-     */
-    get data() {
-        return this._result;
+    get status(): A_ChannelRequestStatuses | undefined {
+        return this.result?.status;
     }
 
-    get errors(): Set<Error> | undefined {
-        return this._errors.size > 0 ? this._errors : undefined;
+    get data(): _ResultType | undefined {
+        return this.result?.data;
     }
 
-    // ==========================================================
-    // ==================== Mutations ===========================
-    // ==========================================================
-    /**
-     * Adds an error to the context
-     * 
-     * @param error 
-     */
-    fail(error: A_Error) {
-        this._status = A_ChannelRequestStatuses.FAILED;
-        this._errors.add(error);
-    }
-    /**
-     * Sets the result of the request
-     * 
-     * @param result 
-     */
-    succeed(result: _ResultType) {
-        this._status = A_ChannelRequestStatuses.SUCCESS;
-        this._result = result;
-    }
 
-    /**
-     * Serializes the context to a JSON object
-     * 
-     * @returns 
-     */
-    toJSON(): A_ChannelRequestContext_Serialized<_ParamsType, _ResultType> {
-        return {
-            params: this._params,
-            result: this._result,
-            status: this._status,
-            errors: this.errors ? Array.from(this._errors).map(err => err.toString()) : undefined,
-        }
+    succeed(result: _ResultType): void {
+        const existed = this.result;
+
+        super.succeed({
+            ...existed,
+            data: result,
+            status: A_ChannelRequestStatuses.SUCCESS,
+        });
     }
-}
+
+}    

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

@@ -1,71 +1,126 @@
 /**
- * A-Command Statuses
+ * A-Command Status Enumeration
+ * 
+ * Defines all possible states a command can be in during its lifecycle.
+ * Commands progress through these states in a specific order:
+ * CREATED → INITIALIZED → COMPILED → EXECUTING → COMPLETED/FAILED
  */
-export enum A_CONSTANTS__A_Command_Status {
+export enum A_Command_Status {
     /**
-     * Command has been created but not yet initialized
+     * Initial state when command is instantiated but not yet ready for execution
      */
     CREATED = 'CREATED',
-    /** 
-     * Command is initializing
-     */
-    INITIALIZATION = 'INITIALIZATION',
+    
     /**
-     * Command has been initialized
+     * Command has been initialized with execution scope and dependencies
      */
     INITIALIZED = 'INITIALIZED',
+    
     /**
-     * Command is compiling
-     */
-    COMPILATION = 'COMPILATION',
-    /**
-     * Command is compiled
+     * Command has been compiled and is ready for execution
      */
     COMPILED = 'COMPILED',
+    
     /**
-     * Command is executing
+     * Command is currently being executed
      */
-    IN_PROGRESS = 'IN_PROGRESS',
+    EXECUTING = 'EXECUTING',
+    
     /**
      * Command has completed successfully
      */
     COMPLETED = 'COMPLETED',
+    
     /**
-     * Command has failed
+     * Command execution has failed with errors
      */
     FAILED = 'FAILED',
 }
 
+
+/**
+ * A-Command State Transitions
+ * 
+ * Defines valid state transitions for command lifecycle management.
+ * These transitions are used by the StateMachine to enforce proper command flow.
+ */
+export enum A_CommandTransitions {
+    /** Transition from CREATED to INITIALIZED state */
+    CREATED_TO_INITIALIZED = 'created_initialized',
+    
+    /** Transition from INITIALIZED to EXECUTING state */
+    INITIALIZED_TO_EXECUTING = 'initialized_executing',
+    
+    /** Transition from EXECUTING to COMPLETED state (success path) */
+    EXECUTING_TO_COMPLETED = 'executing_completed',
+    
+    /** Transition from EXECUTING to FAILED state (error path) */
+    EXECUTING_TO_FAILED = 'executing_failed',
+}
+
 /**
  * A-Command Lifecycle Features
+ * 
+ * Defines feature extension points that components can implement to customize
+ * command behavior at different stages of the lifecycle.
+ * 
+ * Components can use @A_Feature.Extend() decorator with these feature names
+ * to inject custom logic into command execution.
  */
 export enum A_CommandFeatures {
     /**
-     * Allows to extend initialization logic and behavior
+     * Triggered during command initialization phase
+     * Use to set up execution environment, validate parameters, or prepare resources
      */
     onInit = 'onInit',
+    
     /**
-     * Allows to extend compilation logic and behavior
+     * Triggered before command execution starts
+     * Use for pre-execution validation, logging, or setup tasks
      */
-    onCompile = 'onCompile',
+    onBeforeExecute = 'onBeforeExecute',
+    
     /**
-     * Allows to extend execution logic and behavior
+     * Main command execution logic
+     * Core business logic should be implemented here
      */
     onExecute = 'onExecute',
+    
     /**
-     * Allows to extend completion logic and behavior
+     * Triggered after command execution completes (success or failure)
+     * Use for cleanup, logging, or post-processing tasks
+     */
+    onAfterExecute = 'onAfterExecute',
+    
+    /**
+     * Triggered when command completes successfully
+     * Use for success-specific operations like notifications or result processing
      */
     onComplete = 'onComplete',
+    
     /**
-     * 
+     * Triggered when command execution fails
+     * Use for error handling, cleanup, or failure notifications
      */
     onFail = 'onFail',
+    
+    /**
+     * Triggered when an error occurs during execution
+     * Use for error logging, transformation, or recovery attempts
+     */
+    onError = 'onError',
 }
 
 
 
 
-export type A_CONSTANTS__A_Command_Event = keyof typeof A_CommandFeatures;
+/**
+ * Type alias for command lifecycle event names
+ * Represents all available events that can be listened to on a command instance
+ */
+export type A_Command_Event = keyof typeof A_CommandFeatures;
+
+