@adaas/a-concept 0.1.50 → 0.1.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

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

@@ -10,6 +10,7 @@ import { ASEID } from "../ASEID/ASEID.class";
 import { A_IdentityHelper } from "@adaas/a-concept/helpers/A_Identity.helper";
 import { A_EntityError } from "./A-Entity.error";
 import { A_Feature } from "../A-Feature/A-Feature.class";
+import { A_TYPES__ASEID_Constructor } from "../ASEID/ASEID.types";
 
 
 /**
@@ -239,6 +240,23 @@ export class A_Entity<
         throw new A_EntityError(A_EntityError.ValidationError, 'Unable to determine A-Entity constructor initialization method. Please check the provided parameters.');
     }
 
+    /**
+     * Generates a new ASEID for the entity. 
+     * It uses class definitions for concept, scope, and entity,
+     * and allows overriding any of these values.
+     * 
+     * @param override 
+     * @returns 
+     */
+    protected generateASEID(override?: Partial<A_TYPES__ASEID_Constructor>): ASEID {
+        return new ASEID({
+            concept: override?.concept || (this.constructor as typeof A_Entity).concept,
+            scope: override?.scope || (this.constructor as typeof A_Entity).scope,
+            entity: override?.entity || (this.constructor as typeof A_Entity).entity,
+            id: override?.id || A_IdentityHelper.generateTimeId()
+        });
+    }
+
 
     /**
      * Call a feature of the component with the provided scope
@@ -318,12 +336,8 @@ export class A_Entity<
      * @returns 
      */
     fromUndefined(): void {
-        this.aseid = new ASEID({
-            concept: (this.constructor as typeof A_Entity).concept,
-            scope: (this.constructor as typeof A_Entity).scope,
-            entity: (this.constructor as typeof A_Entity).entity,
-            id: A_IdentityHelper.generateTimeId()
-        });
+        this.aseid = this.generateASEID();
+        
         return;
     }
 
@@ -336,12 +350,7 @@ export class A_Entity<
      * @returns 
      */
     fromNew(newEntity: _ConstructorType): void {
-        this.aseid = new ASEID({
-            concept: (this.constructor as typeof A_Entity).concept,
-            scope: (this.constructor as typeof A_Entity).scope,
-            entity: (this.constructor as typeof A_Entity).entity,
-            id: A_IdentityHelper.generateTimeId()
-        });
+        this.aseid =  this.generateASEID();
 
         return;
     }

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

@@ -641,6 +641,117 @@ export class A_Scope<
 
 
 
+
+    /**
+     * This method should resolve all instances of the components, or entities within the scope, by provided parent class
+     * So in case of providing a base class it should return all instances that extends this base class
+     * 
+     * @param component 
+     */
+    resolveAll<T extends A_Component>(
+        /**
+         * Provide a component constructor to resolve its instance from the scope
+         */
+        component: A_TYPES__Component_Constructor<T>
+    ): Array<T>
+    resolveAll<T extends A_Fragment>(
+        /**
+         * Provide a fragment constructor to resolve its instance from the scope
+         */
+        fragment: A_TYPES__Fragment_Constructor<T>
+    ): Array<T>
+    resolveAll<T extends A_Entity>(
+        /**
+         * Provide an entity constructor to resolve its instance or an array of instances from the scope
+         */
+        entity: A_TYPES__Entity_Constructor<T>
+    ): Array<T>
+    resolveAll<T extends A_TYPES__ScopeResolvableComponents>(
+        constructorName: string
+    ): Array<T>
+    resolveAll<T extends A_TYPES__ScopeResolvableComponents>(
+        /**
+         * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+         */
+        param1: A_TYPES__InjectableConstructors
+    ): Array<T> {
+        const results: Array<T> = [];
+
+        switch (true) {
+            // 1) if a parameter is a component constructor
+            case A_TypeGuards.isComponentConstructor(param1): {
+                // 1) Check components
+                this.allowedComponents.forEach(ctor => {
+                    if (A_CommonHelper.isInheritedFrom(ctor, param1)) {
+                        const instance = this.resolve<T>(ctor);
+                        if (instance) results.push(instance as T);
+                    }
+                });
+                break;
+            }
+            // 2) if a parameter is a fragment constructor
+            case A_TypeGuards.isFragmentConstructor(param1): {
+                // 2) Check fragments
+                this.allowedFragments.forEach(ctor => {
+                    if (A_CommonHelper.isInheritedFrom(ctor, param1)) {
+                        const instance = this.resolve(ctor);
+                        if (instance) results.push(instance as T);
+                    }
+                });
+                break;
+            }
+
+            case A_TypeGuards.isEntityConstructor(param1): {
+                // 3) Check entities
+                this.allowedEntities.forEach(ctor => {
+                    if (A_CommonHelper.isInheritedFrom(ctor, param1)) {
+                        const instance = this.resolve<T>(ctor);
+                        if (instance) results.push(instance as T);
+                    }
+                });
+                break;
+            }
+
+            case A_TypeGuards.isString(param1): {
+                // 4) Check by name
+                const ctor = this.resolveConstructor(param1);
+                if (!A_TypeGuards.isComponentConstructor(ctor)
+                    && !A_TypeGuards.isEntityConstructor(ctor)
+                    && !A_TypeGuards.isFragmentConstructor(ctor)
+                )
+                    throw new A_ScopeError(
+                        A_ScopeError.ResolutionError,
+                        `Unable to resolve all instances for name: ${param1} in scope ${this.name} as no matching component, entity or fragment constructor found`);
+
+
+                if (ctor) {
+                    const instances = this.resolveAll<T>(ctor as any);
+                    if (instances)
+                        results.push(...instances);
+                }
+                break;
+            }
+
+            default:
+                throw new A_ScopeError(
+                    A_ScopeError.ResolutionError,
+                    `Invalid parameter provided to resolveAll method: ${param1} in scope ${this.name}`);
+        }
+
+
+        const parentScope = this._parent;
+        
+        while (parentScope && parentScope.has(param1 as any)) {
+            const parentResults = parentScope.resolveAll<T>(param1 as any);
+            results.push(...parentResults);
+            break;
+        }
+        
+
+        return results;
+    }
+
+
     /**
      * This method allows to resolve/inject a component, fragment or entity from the scope
      * Depending on the provided parameters it can resolve:
@@ -762,6 +873,8 @@ export class A_Scope<
 
 
 
+
+
     // ==================================================================================================
     // --------------------------------------------------------------------------------------------------
     // -------------------------------------INTERNAL RESOLVERS-------------------------------------------

package/tests/A-Scope.test.ts

@@ -375,5 +375,63 @@ describe('A-Scope tests', () => {
 
         expect(container.scope.issuer()).toBe(container);
     });
+    it('Should be able to resolve all Component of particular type from scope', async () => {
+
+        class BaseComponent extends A_Component { }
+        class ComponentA extends BaseComponent { }
+        class ComponentB extends BaseComponent { }
+        class ComponentC extends A_Component { }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+        scope.register(ComponentA);
+        scope.register(ComponentB);
+        scope.register(ComponentC);
+
+        const resolvedComponents = scope.resolveAll<BaseComponent>(BaseComponent);
+
+        expect(resolvedComponents.length).toBe(2);
+        //  some of  resolvedComponents should be instances of ComponentA and ComponentB
+        expect(resolvedComponents.some(c => c instanceof ComponentA)).toBe(true)
+        expect(resolvedComponents.some(c => c instanceof ComponentB)).toBe(true)
+        //  should not contain class instance of ComponentC
+        expect(resolvedComponents.some(c => c instanceof ComponentC)).toBe(false)
+
+    });
+
+    it('Should be able to resolve all Component of particular type from all parent scopes as well with priority from current scope', async () => {
+
+        class BaseComponent extends A_Component { }
+        class ComponentA extends BaseComponent { }
+        class ComponentB extends BaseComponent { }
+        class ComponentC extends BaseComponent { }
+        class ComponentD extends A_Component { }
+
+        const parentScope = new A_Scope({ name: 'ParentScope' });
+        const childScope = new A_Scope({ name: 'ChildScope' });
+
+        childScope.inherit(parentScope);
+
+        parentScope.register(ComponentA);
+        parentScope.register(ComponentB);
+        childScope.register(ComponentC);
+        childScope.register(ComponentD);
+
+
+        const resolvedComponents = childScope.resolveAll<BaseComponent>(BaseComponent);
+
+        expect(resolvedComponents.length).toBe(3);
+
+        //  should not contain class instance of ComponentD
+        expect(resolvedComponents).not.toContain(ComponentD);
+
+        //  some of  resolvedComponents should be instances of ComponentA, ComponentB and ComponentC
+        expect(resolvedComponents.some(c => c instanceof ComponentA)).toBe(true)
+        expect(resolvedComponents.some(c => c instanceof ComponentB)).toBe(true)
+        expect(resolvedComponents.some(c => c instanceof ComponentC)).toBe(true)
+
+        //  the first element should be instance of ComponentC as it is registered in child scope
+        expect(resolvedComponents[0] instanceof ComponentC).toBe(true);
+    });
 
 });