@adaas/a-concept 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "A-Concept is a framework of the new generation that is tailored to use AI, enabling developers to create AI-powered applications with ease. It provides a structured approach to building, managing, and deploying AI-driven solutions.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

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

@@ -29,7 +29,7 @@ export class A_Component {
      * @param scope  - the scope in which to call the feature
      * @returns  - void
      */
-    async call(
+    call(
         /**
          * Name of the feature to call
          */
@@ -38,13 +38,13 @@ export class A_Component {
          * Scope in which the feature will be executed
          */
         scope?: A_Scope
-    ) {
+    ): Promise<any> | void {
         const newFeature = new A_Feature({
             name: feature,
             component: this
         });
 
-        return await newFeature.process(scope);
+        return newFeature.process(scope);
     }
 }
 

package/src/global/A-Dependency/A-Dependency-All.decorator.ts

@@ -16,12 +16,7 @@ import { A_TYPES__EntityMetaKey } from "../A-Entity/A-Entity.constants";
 /**
  * Should indicate which All is required
  */
-export function A_Dependency_All<T extends A_Entity>(
-    /**
-     * Constructor Parameters that will be used to create the default instance
-     */
-    entity: A_TYPES__Entity_Constructor<T>
-): A_TYPES__A_Dependency_AllDecoratorReturn {
+export function A_Dependency_All(): A_TYPES__A_Dependency_AllDecoratorReturn {
 
     return function (
         target: A_TYPES__InjectableTargets,

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

@@ -175,6 +175,7 @@ export class A_Dependency<
             ...strategy,
             pagination: {
                 ...this._defaultPagination,
+                ...(this._resolutionStrategy || {}).pagination,
                 ...(strategy.pagination || {})
             },
         };

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

@@ -355,13 +355,13 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * This method processes the feature by executing all the stages
      * 
      */
-    async process(
+    process(
         /**
          * Optional scope to be used to resolve the steps dependencies
          * If not provided, the scope of the caller component will be used
          */
         scope?: A_Scope,
-    ) {
+    ): Promise<void> | void {
         try {
             // It seems like this is a bad idea to enforce scope inheritance here
             // ---------------------------------------------------------------
@@ -373,20 +373,63 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
 
             this._state = A_TYPES__FeatureState.PROCESSING;
 
-            for (const stage of this) {
-                await stage.process(scope);
-            }
+            // Convert iterator to array to get all stages
+            const stages = Array.from(this);
+            
+            return this.processStagesSequentially(stages, scope, 0);
 
-            return await this.completed();
         } catch (error) {
-            return await this.failed(new A_FeatureError({
+            this.failed(new A_FeatureError({
                 title: A_FeatureError.FeatureProcessingError,
                 description: `An error occurred while processing the A-Feature: ${this.name}. Failed at stage: ${this.stage?.name || 'N/A'}.`,
                 stage: this.stage,
                 originalError: error
             }));
         }
+    }
+
+    /**
+     * Process stages one by one, ensuring each stage completes before starting the next
+     */
+    private processStagesSequentially(
+        stages: A_Stage[], 
+        scope: A_Scope | undefined, 
+        index: number
+    ): Promise<void> | void {
+        try {
+            // If we've processed all stages, complete the feature
+            if (index >= stages.length) {
+                this.completed();
+                return;
+            }
 
+            const stage = stages[index];
+            const result = stage.process(scope);
+
+            if (A_TypeGuards.isPromiseInstance(result)) {
+                // Async stage - return promise that processes remaining stages
+                return result.then(() => {
+                    return this.processStagesSequentially(stages, scope, index + 1);
+                }).catch(error => {
+                    this.failed(new A_FeatureError({
+                        title: A_FeatureError.FeatureProcessingError,
+                        description: `An error occurred while processing the A-Feature: ${this.name}. Failed at stage: ${stage.name}.`,
+                        stage: stage,
+                        originalError: error
+                    }));
+                });
+            } else {
+                // Sync stage - continue to next stage immediately
+                return this.processStagesSequentially(stages, scope, index + 1);
+            }
+        } catch (error) {
+            this.failed(new A_FeatureError({
+                title: A_FeatureError.FeatureProcessingError,
+                description: `An error occurred while processing the A-Feature: ${this.name}. Failed at stage: ${this.stage?.name || 'N/A'}.`,
+                stage: this.stage,
+                originalError: error
+            }));
+        }
     }
     /**
      * This method moves the feature to the next stage
@@ -409,7 +452,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * @param result 
      * @returns 
      */
-    async completed(): Promise<void> {
+    completed(): void {
         if (this.isProcessed) return;
 
 
@@ -423,7 +466,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * 
      * @param error 
      */
-    async failed(error: A_FeatureError) {
+    failed(error: A_FeatureError) {
         if (this.isProcessed) return;
 
         this._state = A_TYPES__FeatureState.FAILED;

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

@@ -766,20 +766,36 @@ export class A_Scope<
 
 
         // 5) apply pagination
+
         const count = dependency.pagination.count;
         const from = dependency.pagination.from;  // from start or from end
 
 
+
         const startSliceIndex = from === 'end'
-            ? Math.max(result.length - count, 0)
+            ? (count === -1 ? 0 : Math.max(result.length - count, 0))
             : 0;
+
+        //  end slice should handle -1 for all items
         const endSliceIndex = from === 'end'
             ? result.length
-            : Math.min(count, result.length);
+            : (count === -1 ? result.length : Math.min(count, result.length));
 
         const slice = result.slice(startSliceIndex, endSliceIndex);
 
-        return slice.length === 1 ? slice[0] : slice.length ? slice : undefined;
+        /**
+         * Default behavior is to return single instance if count is 1
+         * 
+         * If Directive All (-1) is provided or count > 1, an array is returned
+         * 
+         * If no instances found, undefined is returned
+         */
+        return slice.length === 1
+            && count !== -1
+            ? slice[0]
+            : slice.length
+                ? slice
+                : undefined;
     }
 
 
@@ -940,17 +956,20 @@ export class A_Scope<
         param1: A_TYPES__Ctor<A_TYPES__A_DependencyInjectable> | string
     ): Array<T> {
 
-        const results: Array<T> = [];
+        const results: Set<T> = new Set();
 
         // 1) Resolve all in the current scope
         const currentResults = this.resolveFlatAll<T>(param1 as any);
-        results.push(...currentResults);
+        currentResults.forEach(result => results.add(result));
 
         // 2) resolve all in the imported scopes
         this._imports.forEach(importedScope => {
+
             if (importedScope.has(param1 as any)) {
                 const importedResults = importedScope.resolveFlatAll<T>(param1 as any);
-                results.push(...importedResults);
+
+
+                importedResults.forEach(result => results.add(result));
             }
         });
 
@@ -958,8 +977,9 @@ export class A_Scope<
         let parentScope = this._parent;
 
         while (parentScope && parentScope.has(param1 as any)) {
-            const parentResults = parentScope.resolveFlatAll<T>(param1 as any);
-            results.push(...parentResults);
+
+            const parentResults = parentScope.resolveAll<T>(param1 as any);
+            parentResults.forEach(result => results.add(result));
 
             // Move to the next parent scope
             parentScope = parentScope._parent;
@@ -967,7 +987,7 @@ export class A_Scope<
 
 
 
-        return results;
+        return Array.from(results);
     }
 
 
@@ -1128,7 +1148,6 @@ export class A_Scope<
             param1 as A_Dependency<T> :
             new A_Dependency<T>(param1)
 
-
         return this.resolveDependency<T>(dependency);
     }
 

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

@@ -35,11 +35,6 @@ export class A_Stage {
      */
     private _status: A_TYPES__A_Stage_Status = A_TYPES__A_Stage_Status.INITIALIZED;
 
-    /**
-     * Promise that will be resolved when the stage is Processed
-     */
-    private _processed: Promise<void> | undefined;
-
 
     /**
      * A_Stage is a callable A_Function within A_Feature that should be run with specific parameters.
@@ -106,7 +101,7 @@ export class A_Stage {
      * @param step 
      * @returns 
      */
-    protected async getStepArgs(
+    protected getStepArgs(
         scope: A_Scope,
         step: A_TYPES__A_StageStep
     ) {
@@ -114,24 +109,22 @@ export class A_Stage {
             (step.dependency.target as A_TYPES__Container_Constructor | A_TYPES__Component_Constructor)
             || scope.resolveConstructor(step.dependency.name);
 
-        return Promise
-            .all(A_Context
-                .meta(resolverConstructor)
-                .injections(step.handler)
-                .map(async dependency => {
-                    switch (true) {
-                        case A_TypeGuards.isCallerConstructor(dependency.target):
-                            return this._feature.caller.component;
+        return A_Context
+            .meta(resolverConstructor)
+            .injections(step.handler)
+            .map(dependency => {
+                switch (true) {
+                    case A_TypeGuards.isCallerConstructor(dependency.target):
+                        return this._feature.caller.component;
 
-                        case A_TypeGuards.isFeatureConstructor(dependency.target):
-                            return this._feature;
+                    case A_TypeGuards.isFeatureConstructor(dependency.target):
+                        return this._feature;
 
-                        default: {
-                            return scope.resolve(dependency);
-                        }
+                    default: {
+                        return scope.resolve(dependency);
                     }
-                })
-            )
+                }
+            })
     }
 
 
@@ -174,17 +167,23 @@ export class A_Stage {
      * @param step 
      * @returns 
      */
-    protected async callStepHandler(
+    protected callStepHandler(
         step: A_TYPES__A_StageStep,
         scope: A_Scope
-    ) {
+    ): {
+        handler: Function,
+        params: any[]
+    } {
         // 1) Resolve component
-        const component = await this.getStepComponent(scope, step);
+        const component = this.getStepComponent(scope, step);
         // 2) Resolve arguments
-        const callArgs = await this.getStepArgs(scope, step);
+        const callArgs = this.getStepArgs(scope, step);
 
         // 3) Call handler
-        return await component[step.handler](...callArgs);
+        return {
+            handler: component[step.handler].bind(component),
+            params: callArgs
+        }
     }
 
 
@@ -198,48 +197,51 @@ export class A_Stage {
      * 
      * @param scope - Scope to be used to resolve the steps dependencies
      */
-    async process(
+     process(
         /**
          * Scope to be used to resolve the steps dependencies
          */
         scope?: A_Scope,
-    ): Promise<void> {
+    ): Promise<void> | void {
 
         const targetScope = A_TypeGuards.isScopeInstance(scope)
             ? scope
             : this._feature.scope;
 
-        if (!this._processed)
-            this._processed = new Promise<void>(
-                async (resolve, reject) => {
-                    try {
-                        this._status = A_TYPES__A_Stage_Status.PROCESSING;
-
-                        if (this._definition.behavior === 'sync') {
-                            // in case we have to wait for the result
-                            await this.callStepHandler(this._definition, targetScope);
-                        } else {
-                            // in case we don't have to wait for the result
-                            this.callStepHandler(this._definition, targetScope);
-                        }
+        if (!this.isProcessed) {
+            this._status = A_TYPES__A_Stage_Status.PROCESSING;
+
+            const { handler, params } = this.callStepHandler(this._definition, targetScope);
 
-                        this.completed();
+            const result = handler(...params);
 
-                        return resolve();
-                    } catch (error) {
-                        const wrappedError = new A_Error(error as any);
+            if (A_TypeGuards.isPromiseInstance(result)) {
 
-                        this.failed(wrappedError);
+                return new Promise<void>(
+                    async (resolve, reject) => {
+                        try {
+                            await result;
+
+                            this.completed();
 
-                        if (this._definition.throwOnError) {
                             return resolve();
-                        } else {
-                            return reject(wrappedError);
+                        } catch (error) {
+                            const wrappedError = new A_Error(error as any);
+
+                            this.failed(wrappedError);
+
+                            if (this._definition.throwOnError) {
+                                return resolve();
+                            } else {
+                                return reject(wrappedError);
+                            }
                         }
-                    }
-                });
+                    });
+            } else {
+                this.completed();
+            }
+        }
 
-        return this._processed;
     }
 
 

package/src/helpers/A_TypeGuards.helper.ts

@@ -367,4 +367,9 @@ export class A_TypeGuards {
     static isErrorSerializedType<T extends A_TYPES__Error_Serialized>(param: any): param is T {
         return !!param && A_TypeGuards.isObject(param) && !(param instanceof Error) && "aseid" in param && ASEID.isASEID(param.aseid);
     }
+
+
+    static isPromiseInstance<T>(value: any): value is Promise<T> {
+        return value instanceof Promise;
+    }
 }

package/tests/A-Abstraction.test.ts

@@ -334,8 +334,6 @@ describe('A-Abstraction Tests', () => {
 
         await concept.load();
 
-        console.log(executionOrder);
-
         expect(executionOrder).toEqual(['stepTwo']);
     });
 });

package/tests/A-Dependency.test.ts

@@ -49,7 +49,7 @@ describe('A-Dependency tests', () => {
         }
 
         class testEntity extends A_Entity {
-            
+
             @A_Feature.Extend({
                 name: 'test'
             })
@@ -357,5 +357,97 @@ describe('A-Dependency tests', () => {
         // });
 
     });
+    it('Should support directive All for query', async () => {
+
+        const executionChain: number[] = [];
+
+        class MyEntity_A extends A_Entity<{ name: string }> {
+            name!: string;
+
+            fromNew(newEntity: { name: string; }): void {
+                super.fromNew(newEntity);
+                this.name = newEntity.name;
+            }
+        }
+
+        class MyComponent extends A_Component {
+
+
+            @A_Feature.Extend()
+            async allEntities(
+                @A_Dependency.All()
+                @A_Inject(MyEntity_A) entities: MyEntity_A[],
+                @A_Inject(A_Scope) scope: A_Scope,
+            ) {
+                executionChain.push(entities.length);
+            }
+
+            @A_Feature.Extend()
+            async allFlatEntities(
+                @A_Dependency.Flat()
+                //  That's important because current scope is feature scope, and plat applies for current scope only
+                @A_Dependency.All()
+                @A_Dependency.Parent(-1)
+                @A_Inject(MyEntity_A) entities: MyEntity_A[],
+                @A_Inject(A_Scope) scope: A_Scope,
+
+            ) {
+                executionChain.push(entities.length);
+            }
+
+            @A_Feature.Extend()
+            async withImportedEntities(
+                @A_Dependency.All()
+                @A_Inject(MyEntity_A) entities: MyEntity_A[],
+            ) {
+                executionChain.push(entities.length);
+            }
+        }
+
+        const parentScope = new A_Scope({
+            name: 'Parent Scope',
+            entities: [
+                new MyEntity_A({ name: 'Entity 1' }),
+                new MyEntity_A({ name: 'Entity 2' }),
+                new MyEntity_A({ name: 'Entity 3' }),
+            ]
+        });
+
+        const childScope = new A_Scope({
+            name: 'Child Scope',
+            components: [MyComponent],
+            entities: [
+                new MyEntity_A({ name: 'Entity 4' }),
+                new MyEntity_A({ name: 'Entity 5' }),
+            ]
+        }, { parent: parentScope });
+
+
+        const importScope = new A_Scope({
+            name: 'Import Scope',
+            entities: [
+                new MyEntity_A({ name: 'Entity 6' }),
+            ]
+        });
+
+
+
+        const componentInstance = childScope.resolve(MyComponent);
+
+        await componentInstance?.call('allEntities');
+        await componentInstance?.call('allFlatEntities');
+        await componentInstance?.call('withImportedEntities');
+
+        expect(executionChain).toEqual([5, 2, 5]);
+
+        childScope.import(importScope);
+
+        await componentInstance?.call('withImportedEntities');
+
+
+        expect(executionChain).toEqual([5, 2, 5, 6]);
+
+
+    });
 
 });

package/tests/A-Feature.test.ts

@@ -644,7 +644,7 @@ describe('A-Feature tests', () => {
         await baseEntity.test();
 
         expect(executionResults).toEqual(['testMethod']);
-        
+
         await myEntity.test();
 
         expect(executionResults).toEqual(['testMethod', 'testMethod']);
@@ -783,4 +783,89 @@ describe('A-Feature tests', () => {
         ]);
 
     })
+    it('Should execute Sync operations properly', async () => {
+
+        const resultChain: string[] = [];
+
+
+        class ChildComponent_A extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            test1() {
+                resultChain.push('ChildComponent_A.test');
+            }
+        }
+
+        class ChildComponent_B extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            test2() {
+                resultChain.push('ChildComponent_B.test');
+            }
+        }
+
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A, ChildComponent_B] });
+
+        testScope.resolve(ChildComponent_A)!.call('testFeature');
+
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'ChildComponent_B.test'
+        ]);
+
+    })
+
+    it('Should execute Async operations properly', async () => {
+
+        const resultChain: string[] = [];
+
+
+        class ChildComponent_A extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async test1() {
+                resultChain.push('ChildComponent_A.test');
+
+                await new Promise<void>(async (resolve) => {
+                    setTimeout(() => {
+                        resolve();
+                    }, 3000);
+                });
+            }
+        }
+
+        class ChildComponent_B extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async test2() {
+                resultChain.push('ChildComponent_B.test');
+            }
+        }
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A, ChildComponent_B] });
+
+        await Promise.all([
+            new Promise<void>(async (resolve) => {
+                setTimeout(() => {
+                    resultChain.push('feature3');
+
+                    resolve();
+                }, 2000);
+            }),
+            testScope.resolve(ChildComponent_A)!.call('testFeature')
+        ]);
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'feature3',
+            'ChildComponent_B.test'
+        ]);
+
+    })
 });