@adaas/a-concept 0.0.29 → 0.0.31

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

@@ -28,7 +28,6 @@ export class A_Entity<
     _SerializedType extends A_TYPES__Entity_JSON = A_TYPES__Entity_JSON,
     _FeatureNames extends Array<string | A_TYPES__EntityBaseMethod> = A_TYPES__EntityBaseMethods
 >
-    extends A_Fragment
     implements A_TYPES__IEntity {
 
     aseid!: ASEID;
@@ -57,8 +56,8 @@ export class A_Entity<
         newEntity: _ConstructorType
     )
     constructor(props: string | ASEID | _SerializedType | _ConstructorType) {
-        super();
 
+        
         switch (true) {
             case (typeof props === 'string' && ASEID.isASEID(props)):
                 this.aseid = new ASEID(props);
@@ -175,6 +174,9 @@ export class A_Entity<
             ? param2 || {}
             : param1;
 
+
+        console.log('WTF???? ', A_Context.scope(this))
+
         const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
 
         return await newFeature.process();
@@ -188,7 +190,7 @@ export class A_Entity<
 
     async load() {
         await this.call(A_TYPES__EntityBaseMethod.DESTROY, {
-            fragments: [
+            entities: [
                 this
             ]
         });
@@ -198,9 +200,9 @@ export class A_Entity<
 
     async destroy() {
         await this.call(A_TYPES__EntityBaseMethod.DESTROY, {
-            fragments: [
+            entities: [
                 this
-            ]
+            ],
         });
     }
 
@@ -208,7 +210,7 @@ export class A_Entity<
 
     async save() {
         await this.call(A_TYPES__EntityBaseMethod.SAVE, {
-            fragments: [
+            entities: [
                 this
             ]
         });

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

@@ -1,11 +1,15 @@
 import { ASEID } from "@adaas/a-utils";
 import { A_Meta } from "../A-Meta/A-Meta.class";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_TYPES__A_DefineDecorator_Meta, A_TYPES__A_ExtendDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
+import { A_Entity } from "./A-Entity.class";
+import { A_TYPES__ContainerMeta_FeatureItem } from "../A-Container/A-Container.types";
 
 
 export type A_TYPES__EntityCallParams<T extends string> = {
     name: T,
     fragments: Array<A_Fragment>,
+    entities: Array<A_Entity<any, any, any>>,
     components: Array<{ new(...args: any[]): any }>
 }
 
@@ -51,12 +55,19 @@ export type A_TYPES__EntityMeta = {
          *
          * Where value is the extension instructions
          */
-        [Key: string]: A_TYPES__EntityMeta_ExtensionItem[]
+        [Key: string]: A_TYPES__A_ExtendDecorator_Meta[]
 
     }>, case
 
 
-    [A_TYPES__EntityMetaKey.FEATURES]: any[],
+    [A_TYPES__EntityMetaKey.FEATURES]: A_Meta<{
+        /**
+         * Where Key is the name of the feature
+         * 
+         * Where value is the list of features
+         */
+        [Key: string]: A_TYPES__A_DefineDecorator_Meta
+    }>
 }
 
 export enum A_TYPES__EntityMetaKey {
@@ -65,9 +76,5 @@ export enum A_TYPES__EntityMetaKey {
 }
 
 
-export type A_TYPES__EntityMeta_ExtensionItem = {
-    name: string,
-    handler: string,
-}
 
 

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

@@ -1,9 +1,12 @@
 import { A_Feature_Define } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Define.decorator";
 import { A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Extend.decorator";
-import { A_TYPES__FeatureConstructor, A_TYPES__FeatureIteratorReturn, A_TYPES__FeatureState, A_TYPES__FeatureStep } from "./A-Feature.types";
-import { A_CommonHelper, A_Error, A_TYPES__Required } from "@adaas/a-utils";
+import { A_TYPES__FeatureConstructor, A_TYPES__FeatureState, } from "./A-Feature.types";
+import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
 import { A_Context } from "../A-Context/A-Context.class";
 import { A_TYPES__A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
+import { A_Stage } from "../A-Stage/A-Stage.class";
+import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
+import { StepsManager } from "@adaas/a-concept/helpers/StepsManager.class";
 
 
 
@@ -34,23 +37,27 @@ export class A_Feature {
     }
 
 
-
-
     // protected scope: A_Scope
-    protected steps: A_TYPES__FeatureStep[] = [];
-    protected _current?: A_TYPES__FeatureStep;
+    protected stages: Array<A_Stage> = [];
+    protected _current?: A_Stage;
     protected _index: number = 0;
+    protected SM: StepsManager;
 
     state: A_TYPES__FeatureState = A_TYPES__FeatureState.INITIALIZED;
 
     result?: any
     error?: A_Error
 
+
     constructor(
         params: A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps']>
     ) {
-        // this.scope = params.scope;
-        this.steps = params.steps;
+
+        this.SM = new StepsManager(params.steps);
+
+        this.stages = this.SM.toStages(this);
+
+        this._current = this.stages[0];
 
         A_Context.allocate(this, params);
     }
@@ -61,58 +68,69 @@ export class A_Feature {
      * 
      * @returns 
      */
-    [Symbol.iterator](): Iterator<A_TYPES__FeatureIteratorReturn, any> {
+    [Symbol.iterator](): Iterator<A_Stage, any> {
         return {
             // Custom next method
-            next: (): IteratorResult<A_TYPES__FeatureIteratorReturn, any> => {
-                if (this._index < this.steps.length) {
-                    if (
-                        (this.state as any) === A_TYPES__FeatureState.FAILED
-                        ||
-                        (this.state as any) === A_TYPES__FeatureState.COMPLETED
-                    ) {
-                        throw new Error('FEATURE_PROCESSING_INTERRUPTED');
-                    }
-
-                    this._current = this.steps[this._index];
-
-                    const { component, handler, args } = this._current;
+            next: (): IteratorResult<A_Stage, any> => {
+                if (!this.isDone()) {
 
-                    const instance = A_Context.scope(this).resolve(component);
+                    this._current = this.stages[this._index];
 
                     return {
-                        value: async () => {
-                            if (instance[handler]) {
-                                const callArgs = args.map(arg =>
-                                    // In case if the target is a feature step then pass the current feature
-                                    A_CommonHelper.isInheritedFrom(arg.target, A_Feature)
-                                        ? this
-                                        : A_Context.scope(this).resolve(arg.target)
-                                );
-
-                                await instance[handler](...callArgs);
-                            }
-
-                            this._index++;
-                        },
+                        value: this._current,
                         done: false
                     };
                 } else {
+
                     this._current = undefined; // Reset current on end
-                    return { value: undefined, done: true };
+
+                    return {
+                        value: undefined,
+                        done: true
+                    };
                 }
             }
         };
     }
 
-    // Access the current element
-    get current(): A_TYPES__FeatureStep | undefined {
+
+    /**
+     * Returns the current A-Feature Stage
+     * 
+     */
+    get stage(): A_Stage | undefined {
         return this._current;
     }
 
-    // Custom end strategy or stop condition (could be expanded if needed)
+
+
+    /**
+     * This method checks if the A-Feature is done
+     * 
+     * @returns 
+     */
     isDone(): boolean {
-        return this.current === null;
+        return !this.stage
+            || this._index >= this.stages.length
+            || this.state === A_TYPES__FeatureState.COMPLETED
+            || this.state === A_TYPES__FeatureState.FAILED;
+    }
+
+
+
+    /**
+     * This method moves the feature to the next stage
+     * 
+     * @param stage 
+     */
+    next(stage) {
+        const stageIndex = this.stages.indexOf(stage);
+
+        this._index = stageIndex + 1;
+
+        if (this._index >= this.stages.length) {
+            this.completed();
+        }
     }
 
 
@@ -120,14 +138,15 @@ export class A_Feature {
      * This method marks the feature as completed and returns the result
      * Uses to interrupt or end the feature processing
      * 
+     * The result of the feature is a Scope Fragments
+     * 
      * @param result 
      * @returns 
      */
-    async completed<T extends any>(
-        ...result: T[]
-    ): Promise<T> {
+    async completed<T extends any>(): Promise<T> {
+
+        this.result = A_Context.scope(this).toJSON();
 
-        this.result = result;
         this.state = A_TYPES__FeatureState.COMPLETED;
 
         return this.result;
@@ -146,25 +165,20 @@ export class A_Feature {
         this.error = error as A_Error;
         this.state = A_TYPES__FeatureState.FAILED;
 
+
         await this.errorHandler(error);
     }
 
 
-
+    /**
+     * This method processes the feature by executing all the stages
+     * 
+     */
     async process() {
-        try {
-            this.state = A_TYPES__FeatureState.PROCESSING;
+        this.state = A_TYPES__FeatureState.PROCESSING;
 
-            for (const step of this) {
-                await step();
-            }
-
-            await this.completed();
-
-        } catch (error) {
-            console.log('[!] Feature processing error:', error);
-
-            await this.failed(error);
+        for (const stage of this) {
+            await stage.process();
         }
     }
 
@@ -198,6 +212,4 @@ export class A_Feature {
                 throw error;
         }
     }
-
-
 }

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

@@ -1,13 +1,14 @@
+import { A_TYPES__A_InjectDecorator_Injectable, A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types"
 import { A_Component } from "../A-Component/A-Component.class"
-import { A_TYPES__ComponentMeta_InjectionParam, A_TYPES__ComponentMeta_InjectionParams } from "../A-Component/A-Component.types"
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
+import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types"
 
 
 export type A_TYPES__FeatureIteratorReturn<T extends any = any> = () => Promise<T>
 
 
 export type A_TYPES__FeatureConstructor = {
-    steps: A_TYPES__FeatureStep[]
+    steps: A_TYPES__A_StageStep[]
 } & A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig
 
 export enum A_TYPES__FeatureState {
@@ -19,24 +20,24 @@ export enum A_TYPES__FeatureState {
 }
 
 
-export type A_TYPES__FeatureStep = {
-    /**
-     * The component to be called
-     */
-    component: typeof A_Component,
-    /**
-     * The method to be called on the component
-     */
-    handler: string,
-    /**
-     * Original Feature Extension name
-     * 
-     * [!] could be string or regex
-     * 
-     */
-    name: string,
-    /**
-     * Arguments to be passed to the method
-     */
-    args: A_TYPES__ComponentMeta_InjectionParams
-}
+// export type A_TYPES__FeatureStep = {
+//     /**
+//      * The component to be called
+//      */
+//     component: typeof A_Component,
+//     /**
+//      * The method to be called on the component
+//      */
+//     handler: string,
+//     /**
+//      * Original Feature Extension name
+//      * 
+//      * [!] could be string or regex
+//      * 
+//      */
+//     name: string,
+//     /**
+//      * Arguments to be passed to the method
+//      */
+//     args: A_TYPES__A_InjectDecorator_Meta
+// }

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

@@ -115,4 +115,19 @@ export class A_Fragment {
         return;
     }
 
+
+
+
+
+    /**
+     * Returns the JSON representation of the Fragment
+     * 
+     * @returns 
+     */
+    toJSON() {
+        return {
+            name: this.name,
+        };
+    }
+
 }

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

@@ -1,14 +1,13 @@
-import { A_CommonHelper } from "@adaas/a-utils";
+import { A_CommonHelper, ASEID } from "@adaas/a-utils";
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "./A-Scope.types";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Context } from "../A-Context/A-Context.class";
 import {
-    A_TYPES__ComponentMeta_EntityInjectionInstructions,
-    A_TYPES__ComponentMeta_InjectionParam,
     A_TYPES__ComponentMetaKey
 } from "../A-Component/A-Component.types";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_Entity } from "../A-Entity/A-Entity.class";
+import { A_TYPES__A_InjectDecorator_EntityInjectionInstructions, A_TYPES__A_InjectDecorator_EntityInjectionQuery, A_TYPES__A_InjectDecorator_Injectable } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
 
 /**
  * 
@@ -72,6 +71,10 @@ export class A_Scope {
         // })
     }
 
+    private initEntities(_entities: Array<A_Entity>) {
+        _entities.forEach(this.register.bind(this));
+    }
+
 
     private initFragments(_fragments: Array<A_Fragment>) {
         _fragments.forEach(this.register.bind(this));
@@ -111,7 +114,7 @@ export class A_Scope {
         switch (true) {
 
             case A_CommonHelper.isInheritedFrom(entity, A_Component): {
-                const found = this.params.components.includes(entity);
+                const found = this.params.components.includes(entity as { new(...args: any[]): A_Component });
 
                 if (!found && !!this.parent)
                     return this.parent.has(entity as any);
@@ -149,20 +152,20 @@ export class A_Scope {
      * @param component 
      * @returns 
      */
-    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: T
     ): InstanceType<T>
     resolve<T extends { new(...args: any[]): A_Entity }>(
         entity: T,
-        instructions: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T>
-    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: Array<T>
     ): Array<InstanceType<T>>
     // base definition
-    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         param1: Array<T> | T,
-        param2?: string | Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        param2?: string | Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): Array<InstanceType<T>> | InstanceType<T> {
 
         switch (true) {
@@ -182,16 +185,18 @@ export class A_Scope {
 
 
 
+
+
     private resolveOnce<T extends { new(...args: any[]): A_Entity }>(
         entity: T,
-        instructions: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T> | undefined
-    private resolveOnce<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    private resolveOnce<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: T
     ): InstanceType<T>
-    private resolveOnce<T extends { new(...args: any[]): A_Entity } | A_TYPES__ComponentMeta_InjectionParam>(
+    private resolveOnce<T extends { new(...args: any[]): A_Entity } | A_TYPES__A_InjectDecorator_Injectable>(
         component: T,
-        instructions?: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T> {
         switch (true) {
             case A_CommonHelper.isInheritedFrom(component, A_Entity): {
@@ -218,9 +223,13 @@ export class A_Scope {
 
     private resolveEntity<T extends { new(...args: any[]): A_Entity }>(
         entity: T,
-        instructions?: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T> | undefined {
 
+        const query = instructions?.query || {};
+        const count = instructions?.pagination?.count || 1;
+
+
         switch (true) {
             case !instructions: {
 
@@ -233,25 +242,34 @@ export class A_Scope {
                         return found as InstanceType<T>;
 
                     case !found && !!this.parent:
-                        return this.parent.resolveFragment(entity);
+                        return this.parent.resolveEntity(entity, instructions);
 
                     default:
                         throw new Error(`Fragment ${entity.name} not found in the scope ${this.name}`);
                 }
             }
 
-            case !!instructions && !!instructions.aseid && this._entities.has(instructions.aseid): {
-                return this._entities.get(instructions.aseid) as InstanceType<T>;
-            }
+            case !!query.aseid
+                && typeof query.aseid === 'string'
+                && this._entities.has(query.aseid): {
+                    return this._entities.get(query.aseid) as InstanceType<T>;
+                }
 
-            case !!instructions && !!instructions.id && this._entities.has(instructions.id): {
-                // in this case we have to find the entity by the id
-                const entities = Array.from(this._entities.values());
+            case !!query.aseid
+                && query.aseid instanceof ASEID
+                && this._entities.has(query.aseid.toString()): {
+                    return this._entities.get(query.aseid.toString()) as InstanceType<T>;
+                }
 
-                const found = entities.find(e => e.id === instructions.id);
+            case !!query.id
+                && this._entities.has(query.id): {
+                    // in this case we have to find the entity by the id
+                    const entities = Array.from(this._entities.values());
 
-                return found as InstanceType<T>;
-            }
+                    const found = entities.find(e => e.id === query.id);
+
+                    return found as InstanceType<T>;
+                }
 
             default:
                 throw new Error(`Entity ${entity.constructor.name} not found in the scope ${this.name}`);
@@ -331,7 +349,7 @@ export class A_Scope {
 
                 const found = this.components.find(el => A_CommonHelper.isInheritedFrom(el, component));
 
-                return this.resolveComponent(found!);
+                return this.resolveComponent<T>(found as any);
             }
 
             // In case when the component is not available in the scope but the parent is available
@@ -398,4 +416,19 @@ export class A_Scope {
 
 
     }
+
+
+
+
+    toJSON(): Record<string, any> {
+        return this.fragments.reduce((acc, fragment) => {
+
+            const serialized = fragment.toJSON()
+
+            return {
+                ...acc,
+                [serialized.name]: serialized
+            }
+        }, {});
+    }
 }

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

@@ -1,3 +1,4 @@
+import { A_Component } from "../A-Component/A-Component.class"
 import { A_Fragment } from "../A-Fragment/A-Fragment.class"
 import { A_Scope } from "./A-Scope.class"
 
@@ -15,7 +16,7 @@ export type A_TYPES__ScopeConstructor = {
     /**
      * A set of Components available in the Scope
      */
-    components: Array<{ new(...args: any[]): any }>
+    components: Array<{ new(...args: any[]): A_Component }>
 
 
     /**