@adaas/a-concept 0.2.4 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "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-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-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/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]);
+
+
+    });
 
 });