@adaas/a-concept 0.0.64 → 0.1.2

package/src/global/A-Scope/A-Scope.error.ts

@@ -0,0 +1,13 @@
+import { A_Error } from "../A-Error/A_Error.class";
+
+export class A_ScopeError extends A_Error {
+
+
+    static readonly InitializationError = 'A-Scope Initialization Error';
+
+    static readonly ConstructorError = 'Unable to construct A-Scope instance';
+
+
+    static readonly CircularInheritanceError = 'A-Scope Circular Inheritance Error';
+
+}

package/src/global/A-Scope/A-Scope.types.ts

@@ -1,27 +1,31 @@
-import { A_Command } from "../A-Command/A-Command.class"
 import { A_Component } from "../A-Component/A-Component.class"
+import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types"
+import { A_Container } from "../A-Container/A-Container.class"
 import { A_Entity } from "../A-Entity/A-Entity.class"
+import { A_TYPES__Entity_Constructor } from "../A-Entity/A-Entity.types"
+import { A_Feature } from "../A-Feature/A-Feature.class"
 import { A_Fragment } from "../A-Fragment/A-Fragment.class"
+import { A_Caller } from "../A-Caller/A_Caller.class"
+import { A_Error } from "../A-Error/A_Error.class"
+import { A_TYPES__Error_Constructor } from "../A-Error/A_Error.types"
 import { A_Scope } from "./A-Scope.class"
 
 
-export type A_TYPES__AllowedComponentsConstructor<T = A_Component> = new (...args: any[]) => T;
-export type A_TYPES__AllowedEntitiesConstructor<T = A_Entity> = new (...args: any[]) => T;
-export type A_TYPES__AllowedFragmentsConstructor<T = A_Fragment> = new (...args: any[]) => T;
-export type A_TYPES__AllowedCommandsConstructor<T = A_Command> = new (...args: any[]) => T;
-export type A_TYPES__AllowedScopesConstructor<T = A_Scope> = new (...args: any[]) => T;
-export type A_TYPES__AllowedConstructors<T extends A_Component | A_Fragment | A_Entity | A_Command | A_Scope = any> =
-    | A_TYPES__AllowedComponentsConstructor<T>
-    | A_TYPES__AllowedFragmentsConstructor<T>
-    | A_TYPES__AllowedEntitiesConstructor<T>
-    | A_TYPES__AllowedCommandsConstructor<T>
-    | A_TYPES__AllowedScopesConstructor<T>;
-
-
-export type A_TYPES__ScopeConstructor<
-    _ComponentType extends A_TYPES__AllowedComponentsConstructor[] = A_TYPES__AllowedComponentsConstructor[],
-    _CommandType extends A_TYPES__AllowedCommandsConstructor[] = A_TYPES__AllowedCommandsConstructor[],
-    _EntityType extends A_Entity[] = A_Entity[],
+// ============================================================================
+// --------------------------- Primary Types ----------------------------------
+// ============================================================================
+/**
+ * Scope constructor type
+ * Uses the generic type T to specify the type of the Scope
+ */
+export type A_TYPES__Scope_Constructor<T = A_Scope> = new (...args: any[]) => T;
+/**
+ * Scope initialization type
+ */
+export type A_TYPES__Scope_Init<
+    _ComponentType extends A_TYPES__Component_Constructor[] = A_TYPES__Component_Constructor[],
+    _ErrorType extends A_TYPES__Error_Constructor[] = A_TYPES__Error_Constructor[],
+    _EntityType extends A_TYPES__Entity_Constructor[] = A_TYPES__Entity_Constructor[],
     _FragmentType extends A_Fragment[] = A_Fragment[],
 > = {
     /**
@@ -37,20 +41,50 @@ export type A_TYPES__ScopeConstructor<
      */
     components: [..._ComponentType],
     /**
-     * A set of Entities available in the Scope
-     *  
+     * A set of Errors available in the Scope
      */
-    entities: [..._EntityType];
+    errors: [..._ErrorType],
     /**
-     * A set of Commands available in the Scope
+     * A set of Entities available in the Scope
+     *  
      */
-    commands: [..._CommandType],
-}
-
-
+    entities: [
+        ..._EntityType,
+        ...InstanceType<_EntityType[number]>[]
+    ];
+};
+/**
+ * Scope configuration type
+ */
 export type A_TYPES__ScopeConfig = {
     /**
      * Allows to define a parent to take dependencies from in case of the current scope does not have the required component
      */
     parent: A_Scope
-}
+}
+/**
+ * Scope serialized type
+ */
+export type A_TYPES__Scope_Serialized = {}
+
+
+
+
+/**
+ * A list of components that can have a scope associated with them
+ */
+export type A_TYPES__ScopeLinkedComponents = A_Container | A_Feature;
+/**
+ * A list of components that can be resolved by a scope
+ */
+export type A_TYPES__ScopeResolvableComponents = A_Component | A_Fragment | A_Entity | A_Fragment
+/**
+ * A list of components that are dependent on a scope and do not have their own scope
+ */
+export type A_TYPES_ScopeDependentComponents = A_Component | A_Entity | A_Fragment
+/**
+ * A list of components that are independent of a scope. They don't need a scope to be resolved
+ * Those components haven't scope dependent features.
+ */
+export type A_TYPES_ScopeIndependentComponents = A_Error | A_Scope | A_Caller
+

package/src/global/A-Stage/A-Stage.class.ts

@@ -1,51 +1,56 @@
-import { A_CommonHelper, A_Error } from "@adaas/a-utils";
+import {
+    A_TYPES__A_Stage_JSON, A_TYPES__A_Stage_Status,
+    A_TYPES__A_StageStep, A_TYPES__A_StageStepProcessingExtraParams
+} from "./A-Stage.types";
 import { A_Context } from "../A-Context/A-Context.class";
 import { A_Feature } from "../A-Feature/A-Feature.class";
-import { A_TYPES__A_Stage_JSON, A_TYPES__A_Stage_Status, A_TYPES__A_StageStep, A_TYPES__A_StageStepProcessingExtraParams } from "./A-Stage.types";
-import { A_Container } from "../A-Container/A-Container.class";
 import { A_Scope } from "../A-Scope/A-Scope.class";
 import { A_StageError } from "./A-Stage.error";
-import { A_FeatureCaller } from "../A-Feature/A-FeatureCaller.class";
-import { A_Entity } from "../A-Entity/A-Entity.class";
+import { A_Error } from "../A-Error/A_Error.class";
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_TYPES__ScopeResolvableComponents } from "../A-Scope/A-Scope.types";
+import { A_TYPES__Container_Constructor } from "../A-Container/A-Container.types";
+import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types";
+import { A_TYPES__InjectableConstructors } from "@adaas/a-concept/global/A-Inject/A-Inject.types";
 
 
-/**
- * A_Stage is a set of A_Functions within A_Feature that should be run in a specific order.
- * Each stage may contain one or more functions. 
- * [!] That always run in parallel (in NodeJS asynchronously), independently of each other.
- * 
- * A-Stage is a common object that uses to simplify logic and re-use of A-Feature internals for better composition. 
- */
-export class A_Stage {
 
-    readonly name: string = 'A_Stage';
+export class A_Stage {
 
-    private readonly feature!: A_Feature;
+    private readonly _feature!: A_Feature;
     private readonly _steps!: A_TYPES__A_StageStep[];
+    private _error?: Error | A_Error | any;
+
 
+    /**
+     * A_Stage is a set of A_Functions within A_Feature that should be run in a specific order.
+     * Each stage may contain one or more functions. 
+     * [!] That always run in parallel (in NodeJS asynchronously), independently of each other.
+     * 
+     * A-Stage is a common object that uses to simplify logic and re-use of A-Feature internals for better composition. 
+     */
     constructor(
         feature: A_Feature,
-        _steps: A_TYPES__A_StageStep[] = []
+        steps: A_TYPES__A_StageStep[] = []
     ) {
-        this.feature = feature;
-        this._steps = _steps;
-        this.name = `${this.feature.name}::a-stage:[sync:${this
-            .syncSteps
-            .map(s => typeof s.component === 'string' ? s.component : s.component.name + '.' + s.handler)
-            .join(' -> ')}][async:${this
-                .asyncSteps
-                .map(s => typeof s.component === 'string' ? s.component : s.component.name + '.' + s.handler)
-                .join(' -> ')}]`;
-
+        this._feature = feature;
+        this._steps = steps;
     }
 
     status: A_TYPES__A_Stage_Status = A_TYPES__A_Stage_Status.INITIALIZED;
+
     /**
      * Promise that will be resolved when the stage is Processed
      */
     processed: Promise<void> | undefined;
 
 
+
+
+    get name(): string {
+        return this.toString();
+    }
+
     get before(): string[] {
         return this._steps.reduce((acc, step) => ([
             ...acc,
@@ -64,7 +69,6 @@ export class A_Stage {
         return this._steps;
     }
 
-
     get asyncSteps(): A_TYPES__A_StageStep[] {
         return this._steps.filter(step => step.behavior === 'async');
     }
@@ -81,29 +85,47 @@ export class A_Stage {
      * @returns 
      */
     protected async getStepArgs(
-        step: A_TYPES__A_StageStep,
-        scope: A_Scope
+        scope: A_Scope,
+        step: A_TYPES__A_StageStep
     ) {
+        let resolverConstructor: A_TYPES__Container_Constructor | A_TYPES__Component_Constructor;
+
+        switch (true) {
+            case A_TypeGuards.isContainerInstance(step.component):
+                resolverConstructor = step.component.constructor as A_TYPES__Container_Constructor;
+                break;
+
+            case A_TypeGuards.isString(step.component):
+                resolverConstructor = scope.resolveConstructor(step.component);
+                break;
+
+            default:
+                resolverConstructor = step.component;
+                break;
+        }
+
 
         return Promise
             .all(A_Context
-                .meta(
-                    // TODO: fix types
-                    (step.component instanceof A_Container
-                        ? step.component.constructor
-                        : step.component) as any
-
-                )
+                .meta(resolverConstructor)
                 .injections(step.handler)
                 .map(async arg => {
-                    if (A_CommonHelper.isInheritedFrom(arg.target, A_FeatureCaller))
-                        return this.feature.Caller.resolve();
+                    switch (true) {
+                        case A_TypeGuards.isCallerConstructor(arg.target):
+                            return this._feature.caller.component;
 
+                        case A_TypeGuards.isScopeConstructor(arg.target):
+                            return scope;
 
-                    if (A_CommonHelper.isInheritedFrom(arg.target, A_Feature))
-                        return this.feature;
+                        case A_TypeGuards.isFeatureConstructor(arg.target):
+                            return this._feature;
 
-                    return scope.resolve((arg as any).target, (arg as any).instructions)
+                        case A_TypeGuards.isEntityConstructor(arg.target) && 'instructions' in arg:
+                            return scope.resolve(arg.target, arg.instructions)
+
+                        default:
+                            return scope.resolve(arg.target)
+                    }
                 })
             )
     }
@@ -130,21 +152,33 @@ export class A_Stage {
      * @param step 
      * @returns 
      */
-    protected getStepInstance(step: A_TYPES__A_StageStep) {
+    protected getStepInstance(
+        scope: A_Scope,
+        step: A_TYPES__A_StageStep
+    ) {
         const { component, handler } = step;
 
+        let instance: A_TYPES__ScopeResolvableComponents | undefined
 
-        // TODO: probably would be better to do it another way. let's think about it
-        const instance = component instanceof A_Container
-            ? component
-            // TODO: fix types
-            : this.feature.Scope.resolve(component as any);
+        switch (true) {
+            case A_TypeGuards.isContainerInstance(component):
+                instance = component;
+                break;
+
+            case A_TypeGuards.isString(component):
+                instance = scope.resolve(component);
+                break;
+
+            default:
+                instance = scope.resolve(component);
+                break;
+        }
 
         if (!instance)
-            throw new Error(`Unable to resolve component ${typeof component === 'string' ? component : component.name} from scope ${this.feature.Scope.name}`);
+            throw new A_StageError(A_StageError.CompileError, `Unable to resolve component ${typeof component === 'string' ? component : component.name} from scope ${scope.name}`);
 
         if (!instance[handler])
-            throw new Error(`Handler ${handler} not found in ${instance.constructor.name}`);
+            throw new A_StageError(A_StageError.CompileError, `Handler ${handler} not found in ${instance.constructor.name}`);
 
         return instance;
     }
@@ -161,30 +195,54 @@ export class A_Stage {
         step: A_TYPES__A_StageStep,
         scope: A_Scope
     ) {
-        const instance = await this.getStepInstance(step);
-        const callArgs = await this.getStepArgs(step, scope);
+        const instance = await this.getStepInstance(scope, step);
+        const callArgs = await this.getStepArgs(scope, step);
 
         return await instance[step.handler](...callArgs);
     }
 
 
+    skip() {
+        this.status = A_TYPES__A_Stage_Status.SKIPPED;
+    }
+
+
     /**
-     * Runs async all the _steps of the stage
+     * This method processes the stage by executing all the steps
      * 
-     * @returns 
+     * @param scope - Scope to be used to resolve the steps dependencies
      */
     async process(
         /**
          * Scope to be used to resolve the steps dependencies
          */
-        scope: A_Scope = new A_Scope({}, {}),
+        scope?: A_Scope,
+    ): Promise<void>
+    async process(
+        /**
+         * Extra parameters to control the steps processing
+         */
         params?: Partial<A_TYPES__A_StageStepProcessingExtraParams>
+    ): Promise<void>
+    async process(
+        /**
+         * Scope to be used to resolve the steps dependencies
+         */
+        param1?: A_Scope | Partial<A_TYPES__A_StageStepProcessingExtraParams>,
+        /**
+         * Extra parameters to control the steps processing
+         */
+        param2?: Partial<A_TYPES__A_StageStepProcessingExtraParams>
     ): Promise<void> {
 
-        scope = scope.inherit(this.feature.Scope);
+        const scope = A_TypeGuards.isScopeInstance(param1)
+            ? param1
+            : A_Context.scope(this._feature);
 
+        const params = A_TypeGuards.isScopeInstance(param1)
+            ? param2
+            : param1;
 
-        // console.log(' -> Init stage processing:', this.name);
 
         if (!this.processed)
             this.processed = new Promise<void>(
@@ -229,9 +287,7 @@ export class A_Stage {
 
                         this.completed();
 
-                        // console.log(' -> Finished stage processing:', this.name);
                         return resolve();
-
                     } catch (error) {
                         this.failed(error);
 
@@ -244,35 +300,20 @@ export class A_Stage {
     }
 
 
-    /**
-     * Skips the stage
-     * 
-     */
-    skip() {
-        this.status = A_TYPES__A_Stage_Status.SKIPPED;
-
-        this.feature.next(this);
-    }
-
-
-
-
     // ==========================================
     // ============ Status methods =============
     // ==========================================
 
     protected completed() {
         this.status = A_TYPES__A_Stage_Status.COMPLETED;
-
-        this.feature.next(this);
     }
 
     protected failed(
-        error: Error | A_Error | unknown
+        error: Error | A_Error | any
     ) {
-        this.status = A_TYPES__A_Stage_Status.FAILED;
+        this._error = error;
 
-        this.feature.failed(new A_StageError(error));
+        this.status = A_TYPES__A_Stage_Status.FAILED;
     }
 
 
@@ -280,17 +321,38 @@ export class A_Stage {
     // ==========================================
     // ============ Serialization ===============
     // ==========================================
-
-
     /**
      * Serializes the stage to JSON
      * 
      */
     toJSON(): A_TYPES__A_Stage_JSON {
-
         return {
-            name: 'A_Stage',
+            name: this.name,
             status: this.status,
         }
     }
+
+    /**
+     * Returns a string representation of the stage
+     * 
+     * @returns 
+     */
+    toString() {
+        return [
+            this._feature.name,
+            '::a-stage:',
+            '[sync:',
+            this
+                .syncSteps
+                .map(s => typeof s.component === 'string' ? s.component : s.component.name + '.' + s.handler)
+                .join(' -> '),
+            ']',
+            '[async:',
+            this
+                .asyncSteps
+                .map(s => typeof s.component === 'string' ? s.component : s.component.name + '.' + s.handler)
+                .join(' -> '),
+            ']'
+        ].join('');
+    }
 }   

package/src/global/A-Stage/A-Stage.error.ts

@@ -1,9 +1,11 @@
-import { A_Error } from "@adaas/a-utils";
+import { A_Error } from "../A-Error/A_Error.class";
 
 
 export class A_StageError extends A_Error {
 
 
-    
+    static get CompileError(): string {
+        return 'Unable to compile A-Stage';
+    }
 
 }

package/src/global/A-Stage/A-Stage.types.ts

@@ -1,8 +1,6 @@
-import { A_Component } from "../A-Component/A-Component.class"
 import { A_Container } from "../A-Container/A-Container.class"
-import { A_TYPES__A_ExtendDecorator_BehaviorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types"
-import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
-import { A_Scope } from "../A-Scope/A-Scope.class"
+import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types"
+import { A_TYPES__FeatureExtendDecoratorBehaviorConfig } from "../A-Feature/A-Feature.types"
 
 
 
@@ -39,22 +37,6 @@ export enum A_TYPES__A_Stage_Status {
      * The stage has been initialized
      */
     INITIALIZED = 'INITIALIZED',
-    /**
-     * The stage has been reset
-     */
-    // RESET = 'RESET',
-    /**
-     * The stage has been resumed
-     */
-    // RESUMED = 'RESUMED',
-    /**
-     * The stage has been suspended
-     */
-    // SUSPENDED = 'SUSPENDED',
-    /**
-     * The stage has been terminated
-     */
-    // TERMINATED = 'TERMINATED',
     /**
      * The stage has been aborted
      */
@@ -63,17 +45,14 @@ export enum A_TYPES__A_Stage_Status {
 
 
 export type A_TYPES__A_StageStep = {
-
     /**
      * The component to be called
      */
-    component: typeof A_Component | A_Container | string
-
+    component: A_TYPES__Component_Constructor | A_Container | string
     /**
      * The method to be called on the component
      */
     handler: string,
-
     /**
      * Original Feature Extension name
      * 
@@ -82,7 +61,7 @@ export type A_TYPES__A_StageStep = {
      */
     name: string,
 
-} & A_TYPES__A_ExtendDecorator_BehaviorConfig
+} & A_TYPES__FeatureExtendDecoratorBehaviorConfig