@adaas/a-concept 0.1.61 → 0.2.1

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

@@ -13,5 +13,7 @@ export class A_ScopeError extends A_Error {
 
     static readonly CircularInheritanceError = 'A-Scope Circular Inheritance Error';
 
+    static readonly CircularImportError = 'A-Scope Circular Import Error';
+
     static readonly DeregistrationError = 'A-Scope Deregistration Error';
 }

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

@@ -11,6 +11,7 @@ import { A_TYPES__Error_Constructor } from "../A-Error/A_Error.types"
 import { A_Scope } from "./A-Scope.class"
 import { A_TYPES__Container_Constructor } from "../A-Container/A-Container.types"
 import { A_TYPES__Feature_Constructor } from "../A-Feature/A-Feature.types"
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types"
 
 
 // ============================================================================
@@ -20,7 +21,7 @@ import { A_TYPES__Feature_Constructor } from "../A-Feature/A-Feature.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;
+export type A_TYPES__Scope_Constructor<T = A_Scope> = A_TYPES__Ctor<T>;
 /**
  * Scope initialization type
  */
@@ -74,17 +75,13 @@ export type A_TYPES__Scope_Serialized = {}
 
 
 /**
- * 
+ * A list of constructors that can have a scope associated with them
  */
 export type A_TYPES__ScopeLinkedConstructors = A_TYPES__Container_Constructor | A_TYPES__Feature_Constructor;
 /**
  * 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_Error | A_Scope;
 /**
  * A list of components that are dependent on a scope and do not have their own scope
  */
@@ -93,5 +90,4 @@ export type A_TYPES_ScopeDependentComponents = A_Component | A_Entity | A_Fragme
  * 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
-
+export type A_TYPES_ScopeIndependentComponents = A_Error | A_Scope | A_Caller

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

@@ -9,10 +9,10 @@ import { A_Scope } from "../A-Scope/A-Scope.class";
 import { A_StageError } from "./A-Stage.error";
 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_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+import { A_TYPES__A_DependencyInjectable } from "../A-Dependency/A-Dependency.types";
 
 
 
@@ -110,85 +110,24 @@ export class A_Stage {
         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;
-        }
-
+        let resolverConstructor: A_TYPES__Container_Constructor | A_TYPES__Component_Constructor =
+            (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 arg => {
+                .map(async dependency => {
                     switch (true) {
-                        case A_TypeGuards.isCallerConstructor(arg.target):
+                        case A_TypeGuards.isCallerConstructor(dependency.target):
                             return this._feature.caller.component;
 
-                        case A_TypeGuards.isFeatureConstructor(arg.target):
+                        case A_TypeGuards.isFeatureConstructor(dependency.target):
                             return this._feature;
 
                         default: {
-                            const { target, require, create, defaultArgs, parent, flat } = arg;
-
-
-                            let dependency;
-                            let targetScope = scope;
-
-
-                            switch (true) {
-                                // 1) Flat resolution
-                                case flat: {
-                                    dependency = targetScope.resolveFlat(target);
-                                    break;
-                                }
-                                // 2) Parent resolution
-                                case parent && typeof parent.layerOffset === 'number': {
-                                    const targetParent = targetScope.parentOffset(parent.layerOffset);
-                                    if (!targetParent) {
-                                        throw new A_StageError(
-                                            A_StageError.ArgumentsResolutionError,
-                                            `Unable to resolve parent scope at layer offset ${parent.layerOffset} for argument ${A_CommonHelper.getComponentName(arg.target)} for stage ${this.name} in scope ${scope.name}`
-                                        );
-                                    }
-                                    dependency = targetParent.resolve(target);
-                                    targetScope = targetParent;
-
-                                    break;
-                                }
-                                // 3) Normal resolution
-                                default: {
-                                    dependency = targetScope.resolve(target);
-                                    break;
-                                }
-                            }
-
-                            if (create && !dependency && A_TypeGuards.isAllowedForDependencyDefaultCreation(target)) {
-                                const newDependency = new target(...defaultArgs);
-
-                                targetScope.register(newDependency);
-                                return newDependency;
-                            }
-
-                            if (require && !dependency) {
-                                throw new A_StageError(
-                                    A_StageError.ArgumentsResolutionError,
-                                    `Unable to resolve required argument ${A_CommonHelper.getComponentName(arg.target)} for stage ${this.name} in scope ${scope.name}`
-                                );
-                            }
-
-                            return dependency;
+                            return scope.resolve(dependency);
                         }
                     }
                 })
@@ -206,29 +145,23 @@ export class A_Stage {
         scope: A_Scope,
         step: A_TYPES__A_StageStep
     ) {
-        const { component, handler } = step;
-
-        let instance: A_TYPES__ScopeResolvableComponents | undefined
+        const { dependency, handler } = step;
 
-        switch (true) {
-            case A_TypeGuards.isContainerInstance(component):
-                instance = component;
-                break;
+        let instance: A_TYPES__A_DependencyInjectable | undefined =
+            (scope.resolve(dependency) || this.feature.scope.resolve(dependency)) as A_TYPES__A_DependencyInjectable
 
-            case A_TypeGuards.isString(component):
-                instance = scope.resolve(component) || this.feature.scope.resolve(component);
-                break;
-
-            default:
-                instance = scope.resolve(component) || this.feature.scope.resolve(component);
-                break;
-        }
 
         if (!instance)
-            throw new A_StageError(A_StageError.CompileError, `Unable to resolve component ${typeof component === 'string' ? component : component.name} from scope ${scope.name}`);
+            throw new A_StageError(
+                A_StageError.CompileError,
+                `Unable to resolve component ${dependency.name} from scope ${scope.name}`
+            );
 
         if (!instance[handler])
-            throw new A_StageError(A_StageError.CompileError, `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;
     }

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

@@ -1,5 +1,7 @@
 import { A_Container } from "../A-Container/A-Container.class"
 import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types"
+import { A_Dependency } from "../A-Dependency/A-Dependency.class"
+import { A_Component } from "../A-Component/A-Component.class"
 
 
 
@@ -49,7 +51,7 @@ export type A_TYPES__A_StageStep = {
     /**
      * The component to be called
      */
-    component: A_TYPES__Component_Constructor | A_Container | string
+    dependency: A_Dependency,
     /**
      * The method to be called on the component
      */

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

@@ -41,7 +41,7 @@ export class A_StepsManager {
     }
 
     private ID(step: A_TYPES__A_StageStep) {
-        return `${typeof step.component === 'string' ? step.component : step.component.name}.${step.handler}`;
+        return `${step.dependency.name}.${step.handler}`;
     }
 
     private buildGraph() {

package/src/global/ASEID/ASEID.class.ts

@@ -31,6 +31,26 @@ export class ASEID {
     }
 
 
+    static compare(aseid1: ASEID | string | undefined, aseid2: ASEID | string | undefined): boolean {
+
+        if (!aseid1 || !aseid2) {
+            return false;
+        }
+
+        if (A_TypeGuards.isString(aseid1) && this.isASEID(aseid1) === false) {
+            throw new ASEID_Error(ASEID_Error.ASEIDValidationError, `Invalid ASEID format provided: ${aseid1}`);
+        }
+
+        if (A_TypeGuards.isString(aseid2) && this.isASEID(aseid2) === false) {
+            throw new ASEID_Error(ASEID_Error.ASEIDValidationError, `Invalid ASEID format provided: ${aseid2}`);
+        }
+
+        const aseidObj1 = aseid1 instanceof ASEID ? aseid1 : new ASEID(aseid1);
+        const aseidObj2 = aseid2 instanceof ASEID ? aseid2 : new ASEID(aseid2);
+
+        return aseidObj1.toString() === aseidObj2.toString();
+    }
+
 
     // ====================================================================
     // ==================== Hidden ASEID Information ======================

package/src/helpers/A_Common.helper.ts

@@ -312,6 +312,10 @@ export class A_CommonHelper {
             if (fnAny.displayName) return String(fnAny.displayName);
             if (fnAny.name) return String(fnAny.name);
 
+            if(fnAny.constructor && fnAny.constructor.name) {
+                return String(fnAny.constructor.name);
+            }
+
             // Try to extract a name from source if possible
             try {
                 const src = Function.prototype.toString.call(component);

package/src/helpers/A_TypeGuards.helper.ts

@@ -29,6 +29,8 @@ import { A_TYPES__AbstractionAvailableComponents } from "../global/A-Abstraction
 import { A_TYPES__Scope_Constructor, A_TYPES__ScopeLinkedComponents, A_TYPES__ScopeLinkedConstructors } from "../global/A-Scope/A-Scope.types";
 import { A_TYPES__InjectableTargets } from "../global/A-Inject/A-Inject.types";
 import { ASEID } from "../global/ASEID/ASEID.class";
+import { A_Dependency } from "../global/A-Dependency/A-Dependency.class";
+import { A_TYPES__A_DependencyInjectable } from "../global/A-Dependency/A-Dependency.types";
 
 
 
@@ -175,9 +177,27 @@ export class A_TypeGuards {
     static isCallerConstructor(ctor: any): ctor is A_TYPES__Caller_Constructor {
         return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Caller);
     }
+    /**
+     * Type guard to check if the constructor is of type A_Dependency
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isDependencyConstructor<T extends A_TYPES__A_DependencyInjectable>(ctor: any): ctor is A_Dependency<T> {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Dependency);
+    }
     // ----------------------------------------------------------------------------
     // Instance type guards
     // ----------------------------------------------------------------------------
+    /**
+     * Type guard to check if the instance is of type A_Dependency
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isDependencyInstance<T extends A_TYPES__A_DependencyInjectable>(instance: any): instance is A_Dependency<T> {
+        return instance instanceof A_Dependency;
+    }
     /**
      * Type guard to check if the instance is of type A_Container
      * 
@@ -275,6 +295,11 @@ export class A_TypeGuards {
     // ==========================================================================
     // ========================= SPECIAL Type Guards =============================
     // ===========================================================================
+    static hasASEID(value: any): value is A_Entity | A_Error {
+        return value && typeof value === 'object' && 'aseid' && (A_TypeGuards.isEntityInstance(value) || A_TypeGuards.isErrorInstance(value));
+    }
+
+
     static isConstructorAllowedForScopeAllocation(target: any): target is A_TYPES__ScopeLinkedConstructors {
         return A_TypeGuards.isContainerConstructor(target)
             || A_TypeGuards.isFeatureConstructor(target);
@@ -320,9 +345,9 @@ export class A_TypeGuards {
             || A_TypeGuards.isComponentInstance(param);
     }
 
-    static isAllowedForDependencyDefaultCreation(param: any): param is A_TYPES__Entity_Constructor | A_TYPES__Component_Constructor {
-        return A_TypeGuards.isComponentConstructor(param)
-            || A_CommonHelper.isInheritedFrom(param, A_Component)
+    static isAllowedForDependencyDefaultCreation(param: any): param is A_TYPES__Entity_Constructor | A_TYPES__Fragment_Constructor {
+        return A_TypeGuards.isFragmentConstructor(param)
+            || A_CommonHelper.isInheritedFrom(param, A_Fragment)
             || A_TypeGuards.isEntityConstructor(param)
             || A_CommonHelper.isInheritedFrom(param, A_Entity)
 

package/src/types/A_Common.types.ts

@@ -1,6 +1,10 @@
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 type Decrement = [never, 0, 1, 2, 3, 4, 5];
 
+
+export type A_TYPES__Ctor<T> = new (...args: any[]) => T;
+
+
 export type A_TYPES__DeepPartial<T, D extends number = 5> = {
     [P in keyof Required<T>]?:
     [D] extends [never] ? any :

package/tests/A-Abstraction.test.ts

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

package/tests/A-Dependency.test.ts

@@ -191,14 +191,13 @@ describe('A-Dependency tests', () => {
                 @A_Inject(MyEntity_A) public myEntityA: MyEntity_A,
             ) {
                 super();
-
             }
         }
 
-        const parentScope = new A_Scope({ entities: [new MyEntity_A({ name: 'Parent Entity' })] });
-        const childScope = new A_Scope({ components: [ChildComponent] }, { parent: parentScope });
+        const parentScope = new A_Scope({ name: 'Parent Scope', entities: [new MyEntity_A({ name: 'Parent Entity' })] });
+        const childScope = new A_Scope({ name: 'Child Scope', components: [ChildComponent] }, { parent: parentScope });
 
-        const instance = childScope.resolve(ChildComponent);
+        const instance = childScope.resolveDependency(new A_Dependency<ChildComponent>(ChildComponent)) as ChildComponent;
 
         expect(instance).toBeDefined();
         expect(instance).toBeInstanceOf(ChildComponent);
@@ -268,7 +267,7 @@ describe('A-Dependency tests', () => {
             name: 'Grandparent Scope',
             entities: [new MyEntity_A({ name: 'Grandparent Entity' })]
         });
-        
+
         const parentScope = new A_Scope({
             name: 'Parent Scope',
             entities: [new MyEntity_A({ name: 'Parent Entity' })]
@@ -288,4 +287,49 @@ describe('A-Dependency tests', () => {
         expect(instance!.myEntityA.name).toBe('Grandparent Entity');
     });
 
+    it('Should support proper types declaration', async () => {
+
+        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 {
+            constructor(
+                @A_Dependency.Parent(-2)
+                @A_Inject(MyEntity_A) public myEntityA: MyEntity_A,
+            ) {
+                super();
+
+            }
+        }
+
+
+        const dependency = new A_Dependency(MyEntity_A, {
+            query: {
+                name: 'Test Entity'
+            },
+            pagination: {
+                count: 5,
+                from: 'start'
+            }
+        });
+
+
+        // const dependency2 = new A_Dependency(MyComponent, {
+        //     query: {
+        //         name: 'Test Entity'
+        //     },
+        //     pagination: {
+        //         count: 5,
+        //         from: 'start'
+        //     }
+        // });
+
+    });
+
 });

package/tests/A-Feature.test.ts

@@ -5,7 +5,7 @@ import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 import { A_Caller } from '@adaas/a-concept/global/A-Caller/A_Caller.class';
 import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
 import { A_TYPES__ComponentMetaKey } from '@adaas/a-concept/global/A-Component/A-Component.constants';
-import { A_Entity, A_Error, A_TYPES__FeatureState } from "../src";
+import { A_Dependency, A_Entity, A_Error, A_TYPES__FeatureState } from "../src";
 
 jest.retryTimes(0);
 
@@ -27,7 +27,7 @@ describe('A-Feature tests', () => {
         const template = [
             {
                 name: 'A_Component.testHandler',
-                component: A_Component,
+                dependency: new A_Dependency(A_Component),
                 handler: 'testHandler',
             }
         ]
@@ -59,7 +59,7 @@ describe('A-Feature tests', () => {
                 invoke: true,
                 template: [{
                     name: 'MyExtendedComponent.testHandler',
-                    component: MyExtendedComponent,
+                    dependency: new A_Dependency(MyExtendedComponent),
                     handler: 'testHandler',
                     behavior: 'sync',
                     before: '',
@@ -67,7 +67,7 @@ describe('A-Feature tests', () => {
                 },
                 {
                     name: 'MyExtendedComponent.testHandler',
-                    component: MyExtendedComponent,
+                    dependency: new A_Dependency(MyExtendedComponent),
                     handler: 'testHandler'
                 }]
             })
@@ -113,7 +113,7 @@ describe('A-Feature tests', () => {
                 invoke: true,
                 template: [{
                     name: 'MyExtendedComponent.testHandler',
-                    component: MyExtendedComponent,
+                    dependency: new A_Dependency(MyExtendedComponent),
                     handler: 'testHandler',
                     behavior: 'sync',
                     before: '',
@@ -121,7 +121,7 @@ describe('A-Feature tests', () => {
                 },
                 {
                     name: 'MyExtendedComponent.testHandler',
-                    component: MyExtendedComponent,
+                    dependency: new A_Dependency(MyExtendedComponent),
                     handler: 'testHandler'
                 }]
             })
@@ -172,7 +172,7 @@ describe('A-Feature tests', () => {
                 invoke: true,
                 template: [{
                     name: 'MyExtendedComponent2.testHandler',
-                    component: 'MyExtendedComponent2',
+                    dependency: new A_Dependency('MyExtendedComponent2'),
                     handler: 'testHandler',
                     behavior: 'sync',
                     before: '',
@@ -345,8 +345,7 @@ describe('A-Feature tests', () => {
     it('Should inherit feature definitions & extensions', async () => {
         const executionOrder: string[] = [];
 
-        // 1) create a base component with some feature
-        class My_Component extends A_Component {
+        class Parent_Component extends A_Component {
 
             @A_Feature.Define({ invoke: false })
             async feature1() {
@@ -363,6 +362,27 @@ describe('A-Feature tests', () => {
             ) {
                 executionOrder.push('stepTwo');
             }
+
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension2(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepFour');
+            }
+        }
+
+        // 1) create a base component with some feature
+        class My_Component extends Parent_Component {
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepThree');
+            }
         }
 
 
@@ -374,11 +394,18 @@ describe('A-Feature tests', () => {
 
         // 3) create an instance of the component from the scope
         const myComponent = scope.resolve(My_Child_Component)!;
+
+
+        const featureDefinition = A_Context.featureTemplate('feature1', myComponent, scope)
+
+        expect(featureDefinition).toBeDefined();
+        expect(featureDefinition.length).toBe(2);
+
         expect(myComponent).toBeInstanceOf(My_Child_Component);
 
         await myComponent.feature1();
 
-        expect(executionOrder).toEqual(['stepOne', 'stepTwo']);
+        expect(executionOrder).toEqual(['stepOne', 'stepThree', 'stepFour']);
     });
 
     it('Should allow override feature extension', async () => {
@@ -491,7 +518,7 @@ describe('A-Feature tests', () => {
             template: [
                 {
                     name: 'A_Component.testHandler',
-                    component: 'A_Component',
+                    dependency: new A_Dependency('A_Component'),
                     handler: 'testHandler',
                 }
             ]
@@ -548,17 +575,17 @@ describe('A-Feature tests', () => {
             template: [
                 {
                     name: 'ComponentA.feature1',
-                    component: 'ComponentA',
+                    dependency: new A_Dependency('ComponentA'),
                     handler: 'feature1',
                 },
                 {
                     name: 'ComponentA.feature2',
-                    component: 'ComponentA',
+                    dependency: new A_Dependency('ComponentA'),
                     handler: 'feature2',
                 },
                 {
                     name: 'ComponentA.feature3',
-                    component: 'ComponentA',
+                    dependency: new A_Dependency('ComponentA'),
                     handler: 'feature3',
                 },
             ]
@@ -589,7 +616,6 @@ describe('A-Feature tests', () => {
             async test() {
                 await this.call('myFeature');
             }
-
         }
 
         class MyComponent extends A_Component {
@@ -603,9 +629,7 @@ describe('A-Feature tests', () => {
             }
         }
 
-        class My_Entity extends BaseEntity {
-
-        }
+        class My_Entity extends BaseEntity { }
 
         const scope = new A_Scope({ name: 'TestScope', components: [MyComponent] });
 
@@ -620,7 +644,7 @@ describe('A-Feature tests', () => {
         await baseEntity.test();
 
         expect(executionResults).toEqual(['testMethod']);
-
+        
         await myEntity.test();
 
         expect(executionResults).toEqual(['testMethod', 'testMethod']);
@@ -691,6 +715,7 @@ describe('A-Feature tests', () => {
 
 
         class ChildComponent_A extends BaseComponent {
+
             @A_Feature.Extend({
                 name: 'testFeature',
                 scope: [ChildComponent_A]