@adaas/a-concept 0.1.23 → 0.1.25

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

@@ -28,16 +28,16 @@ export class A_StepsManager {
     private prepareSteps(
         entities: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>
     ): Array<A_TYPES__A_StageStep> {
-        return entities.map(step => {
-            return {
+        return entities
+            .map(step => ({
                 ...step,
 
                 behavior: step.behavior || 'sync',
-                before: step.before || [],
-                after: step.after || [],
+                before: step.before || '',
+                after: step.after || '',
+                override: step.override || '',
                 throwOnError: false
-            };
-        });
+            }));
     }
 
     private ID(step: A_TYPES__A_StageStep) {
@@ -47,36 +47,42 @@ export class A_StepsManager {
     private buildGraph() {
         if (this._isBuilt) return;
         this._isBuilt = true;
+
+        // Filter override
+        this.entities = this.entities
+            .filter((step, i, self) =>
+                !self.some(s => s.override ? new RegExp(s.override).test(this.ID(step)) : false)
+            );
+
         // Initialize graph nodes
         this.entities.forEach(entity => this.graph.set(this.ID(entity), new Set()));
 
         // Add directed edges based on 'before' and 'after'
         this.entities.forEach(entity => {
             const entityId = this.ID(entity);
-            const { before = [], after = [] } = entity;
 
             // Add edges for 'before' dependencies
             // If entity should execute before targets, then targets depend on entity
             // So we add edges: target -> entity (target depends on entity)
-            before.forEach(dep => {
-                const targets = this.matchEntities(entityId, dep);
+            if (entity.before) {
+                const targets = this.matchEntities(entityId, entity.before);
                 targets.forEach(target => {
                     if (!this.graph.has(target)) this.graph.set(target, new Set());
                     this.graph.get(target)!.add(entityId); // target depends on entity
                 });
-            });
+            }
 
             // Add edges for 'after' dependencies  
             // If entity should execute after sources, then entity depends on sources
             // So we add edges: entity -> source (entity depends on source)
-            after.forEach(dep => {
-                const sources = this.matchEntities(entityId, dep);
+            if (entity.after) {
+                const sources = this.matchEntities(entityId, entity.after);
 
                 sources.forEach(source => {
                     if (!this.graph.has(entityId)) this.graph.set(entityId, new Set());
                     this.graph.get(entityId)!.add(source); // entity depends on source
                 });
-            });
+            }
         });
     }
 

package/src/helpers/A_Common.helper.ts

@@ -201,4 +201,105 @@ export class A_CommonHelper {
         // For any other cases
         throw new Error('Unable to clone the object. Unsupported type.');
     }
+
+    /**
+     * Get a readable name for a component (string, class, function, React element, instance, etc.)
+     *
+     * Covers:
+     * - string tags ("div")
+     * - symbols (Symbol.for('xxx'))
+     * - functions and classes (with name or displayName)
+     * - React elements (object with `type`)
+     * - component instances (constructor.name)
+     * - objects with custom toString returning meaningful info
+     *
+     * Falls back to sensible defaults ("Unknown" / "Anonymous").
+     */
+    static getComponentName(component: any): string {
+        const UNKNOWN = 'Unknown';
+        const ANONYMOUS = 'Anonymous';
+
+        if (component === null || component === undefined) {
+            return UNKNOWN;
+        }
+
+        // Strings (HTML tags or explicit names)
+        if (typeof component === 'string') {
+            return component || UNKNOWN;
+        }
+
+        // Symbols
+        if (typeof component === 'symbol') {
+            try {
+                return component.toString();
+            } catch {
+                return UNKNOWN;
+            }
+        }
+
+        // Arrays - try to derive from first element
+        if (Array.isArray(component)) {
+            if (component.length === 0) return UNKNOWN;
+            return this.getComponentName(component[0]);
+        }
+
+        // Functions and classes
+        if (typeof component === 'function') {
+            const fnAny = component as any;
+            // Common React convention
+            if (fnAny.displayName) return String(fnAny.displayName);
+            if (fnAny.name) return String(fnAny.name);
+
+            // Try to extract a name from source if possible
+            try {
+                const src = Function.prototype.toString.call(component);
+                // class Foo { ... } or function foo() { ... } or foo => ...
+                const match = src.match(/^(?:class\s+([A-Za-z0-9_$]+)|function\s+([A-Za-z0-9_$]+)|([A-Za-z0-9_$]+)\s*=>)/);
+                if (match) {
+                    return match[1] || match[2] || match[3] || ANONYMOUS;
+                }
+            } catch {
+                // fallthrough
+            }
+            return ANONYMOUS;
+        }
+
+        // Objects (instances, React elements, plain objects)
+        if (typeof component === 'object') {
+            const objAny = component as any;
+
+            // React element: { type: ComponentOrString, props: ... }
+            if (objAny.type) {
+                return this.getComponentName(objAny.type);
+            }
+
+            // React forwardRef / memo wrappers often expose displayName
+            if (objAny.displayName) return String(objAny.displayName);
+            if (objAny.name) return String(objAny.name);
+
+            // Instance: use constructor name if available and not Object
+            if (objAny.constructor && objAny.constructor.name && objAny.constructor.name !== 'Object') {
+                return String(objAny.constructor.name);
+            }
+
+            // If object implements a meaningful toString, try it
+            try {
+                const s = objAny.toString();
+                if (typeof s === 'string' && s !== '[object Object]') {
+                    return s;
+                }
+            } catch {
+                // ignore
+            }
+
+            return ANONYMOUS;
+        }
+
+        // Fallback for other types
+        try {
+            return String(component);
+        } catch {
+            return UNKNOWN;
+        }
+    }
 }

package/src/helpers/A_TypeGuards.helper.ts

@@ -315,6 +315,14 @@ 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)
+            || A_TypeGuards.isEntityConstructor(param)
+            || A_CommonHelper.isInheritedFrom(param, A_Entity)
+
+    }
+
     /**
      * Allows to check if the provided param is of constructor type.
      * 

package/src/index.ts

@@ -0,0 +1,88 @@
+// =================================================================================================
+// ============================= Export Framework Components =======================================
+// =================================================================================================
+export * from './constants/env.constants';
+export * from './types/A_Common.types';
+
+// ---------------------- Major Components ----------------------
+export { A_Context } from './global/A-Context/A-Context.class';
+export * from './global/A-Context/A-Context.types';
+
+export { A_Concept } from './global/A-Concept/A-Concept.class';
+export { A_ConceptMeta } from './global/A-Concept/A-Concept.meta';
+export * from './global/A-Concept/A-Concept.types';
+
+export { A_Container } from './global/A-Container/A-Container.class';
+export { A_ContainerMeta } from './global/A-Container/A-Container.meta';
+export * from './global/A-Container/A-Container.class';
+
+export { A_Component } from './global/A-Component/A-Component.class';
+export { A_ComponentMeta } from './global/A-Component/A-Component.meta';
+export * from './global/A-Component/A-Component.types';
+
+export { A_Entity } from './global/A-Entity/A-Entity.class';
+export * from './global/A-Entity/A-Entity.types';
+
+
+// ---------------------- Common Components ----------------------
+export { A_Abstraction } from './global/A-Abstraction/A-Abstraction.class';
+export { A_AbstractionError } from './global/A-Abstraction/A-Abstraction.error';
+export * from './global/A-Abstraction/A-Abstraction.types';
+
+export { A_Caller } from './global/A-Caller/A_Caller.class';
+export { A_CallerError } from './global/A-Caller/A_Caller.error';
+export * from './global/A-Caller/A_Caller.types';
+
+export { A_Error } from './global/A-Error/A_Error.class';
+export * from './global/A-Error/A_Error.types';
+
+export { ASEID } from './global/ASEID/ASEID.class';
+export { ASEID_Error } from './global/ASEID/ASEID.error';
+export * from './global/ASEID/ASEID.types';
+
+export { A_Feature } from './global/A-Feature/A-Feature.class';
+export { A_FeatureError } from './global/A-Feature/A-Feature.error';
+export * from './global/A-Feature/A-Feature.types';
+
+export { A_Stage } from './global/A-Stage/A-Stage.class';
+export { A_StageError } from './global/A-Stage/A-Stage.error';
+export * from './global/A-Stage/A-Stage.types';
+
+export { A_Scope } from './global/A-Scope/A-Scope.class';
+export { A_ScopeError } from './global/A-Scope/A-Scope.error';
+export * from './global/A-Scope/A-Scope.types';
+
+export { A_Meta } from './global/A-Meta/A-Meta.class';
+export * from './global/A-Meta/A-Meta.types';
+
+export { A_Fragment } from './global/A-Fragment/A-Fragment.class';
+export * from './global/A-Fragment/A-Fragment.types';
+
+export { A_Dependency } from './global/A-Dependency/A-Dependency.class';
+export { A_DependencyError } from './global/A-Dependency/A-Dependency.error';
+export * from './global/A-Dependency/A-Dependency.types';
+
+
+// =================================================================================================
+// =============================== Export Decorators ===============================================
+// =================================================================================================
+export { A_Inject } from './global/A-Inject/A-Inject.decorator';
+export * from './global/A-Inject/A-Inject.types';
+export { A_Feature_Define } from './global/A-Feature/A-Feature-Define.decorator';
+export { A_Feature_Extend } from './global/A-Feature/A-Feature-Extend.decorator';
+export { A_Abstraction_Extend } from './global/A-Abstraction/A-Abstraction-Extend.decorator';
+export { A_Dependency_Require } from './global/A-Dependency/A-Dependency-Require.decorator';
+export { A_Dependency_Load } from './global/A-Dependency/A-Dependency-Load.decorator';
+export { A_Dependency_Default } from './global/A-Dependency/A-Dependency-Default.decorator';
+
+
+// =================================================================================================
+// =============================== Export Helpers ================================================
+// =================================================================================================
+export { A_CommonHelper } from './helpers/A_Common.helper';
+export { A_FormatterHelper } from './helpers/A_Formatter.helper';
+export { A_IdentityHelper, A_ID_TYPES__TimeId_Parts } from './helpers/A_Identity.helper';
+export { A_StepsManager } from './global/A-StepManager/A-StepManager.class';
+export { A_StepManagerError } from './global/A-StepManager/A-StepManager.error';
+export { A_TypeGuards } from './helpers/A_TypeGuards.helper';
+

package/tests/A-Component.test.ts

@@ -27,7 +27,7 @@ describe('A-Component tests', () => {
         A_Context.root.register(MyComponent);
         A_Context.root.register(DependentComponent);
 
-        const dependentComponent = A_Context.root.resolve(DependentComponent);
+        const dependentComponent = A_Context.root.resolve(DependentComponent)!;
 
         expect(dependentComponent.dependency).toBeInstanceOf(MyComponent);
     });

package/tests/A-Concept.test.ts

@@ -1,11 +1,16 @@
+import { A_Caller } from '@adaas/a-concept/global/A-Caller/A_Caller.class';
 import './test.setup';
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
 import { A_Concept } from "@adaas/a-concept/global/A-Concept/A-Concept.class";
 import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
 import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_TYPES__Entity_Init, A_TYPES__Entity_Serialized } from '@adaas/a-concept/global/A-Entity/A-Entity.types';
 import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
+import { A_Inject } from '@adaas/a-concept/global/A-Inject/A-Inject.decorator';
 import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Feature } from '@adaas/a-concept/global/A-Feature/A-Feature.class';
+import { A_TYPES__EntityFeatures } from '@adaas/a-concept/global/A-Entity/A-Entity.constants';
 
 
 jest.retryTimes(0);
@@ -93,19 +98,18 @@ describe('A-Concept tests', () => {
         const containerBScope = A_Context.scope(containerB)
 
         expect(containerAScope.resolveConstructor('MyEntityA')).toBe(MyEntityA);
-        expect(() => {
-            containerAScope.resolveConstructor('MyEntityB');
-        }).toThrow();
+        const undefinedMyEntityB = containerAScope.resolveConstructor('MyEntityB');
+        expect(undefinedMyEntityB).toBeUndefined();
 
         expect(containerBScope.resolveConstructor('MyEntityB')).toBe(MyEntityB);
-        expect(() => {
-            containerBScope.resolveConstructor('MyEntityA');
-        }).toThrow();
+        const undefinedMyEntityA = containerBScope.resolveConstructor('MyEntityA');
+
+        expect(undefinedMyEntityA).toBeUndefined();
 
         expect(concept.scope.resolve(MyContext)).toEqual(sharedContext);
         expect(concept.scope.resolve(MyContext)).toEqual(sharedContext);
     });
-     it('Should allow to register multiple containers', async () => {
+    it('Should allow to register multiple containers', async () => {
         A_Context.reset();
 
         class MyContainerA extends A_Container { }
@@ -123,9 +127,53 @@ describe('A-Concept tests', () => {
         });
 
         expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
-        expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);   
+        expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
+    })
+    it('Should have different entity behavior depending on the container', async () => {
+        A_Context.reset();
+        class MyEntityA extends A_Entity { testValue!: string; }
+
+        class ComponentA extends A_Component {
+            @A_Feature.Extend({ name: A_TYPES__EntityFeatures.LOAD })
+            async createEntityInstance(
+                @A_Inject(A_Caller) caller: MyEntityA
+            ) {
+                caller.testValue = 'ContainerA';
+            }
+        }
+
+        class ComponentB extends A_Component {
+            @A_Feature.Extend({ name: A_TYPES__EntityFeatures.LOAD })
+            async createEntityInstance(
+                @A_Inject(A_Caller) caller: MyEntityA
+            ) {
+                caller.testValue = 'ContainerB';
+            }
+        }
+
+        const containerA = new A_Container({ name: 'ContainerA', components: [ComponentA], entities: [MyEntityA] });
+        const containerB = new A_Container({ name: 'ContainerB', components: [ComponentB], entities: [MyEntityA] });
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                containerA,
+                containerB
+            ]
+        });
+
+        const entityFromContainerA = new MyEntityA();
+        const entityFromContainerB = new MyEntityA();
+
+        //  with registration
+        containerB.scope.register(entityFromContainerB)
+        await entityFromContainerB.load();
+
+        // without registration 
+        await entityFromContainerA.load(containerA.scope);
 
-     })
-     
+        expect(entityFromContainerA.testValue).toBe('ContainerA');
+        expect(entityFromContainerB.testValue).toBe('ContainerB');
+    })
 
 });

package/tests/A-Dependency.test.ts

@@ -0,0 +1,93 @@
+import { A_Component, A_Dependency, A_Entity, A_Error, A_Inject, A_Scope, A_ScopeError } from "../src";
+
+
+
+describe('A-Dependency tests', () => {
+
+    it('Should Allow to define a dependency', async () => {
+
+        class Test extends A_Component {
+            constructor(
+                @A_Dependency.Required()
+                @A_Inject(A_Component) component: A_Component,
+            ) {
+                super();
+                expect(component).toBeInstanceOf(A_Component);
+            }
+        }
+    });
+    it('Should Resolve a component with undefined dependency', async () => {
+        class DependencyRequiredComponent extends A_Component { }
+
+        class Test extends A_Component {
+            constructor(
+                @A_Inject(DependencyRequiredComponent) public component?: A_Component,
+            ) {
+                super();
+            }
+        }
+
+        const scope = new A_Scope({ components: [Test] });
+        const instance = scope.resolve(Test);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(Test);
+        expect(instance!.component).toBeUndefined();
+
+    });
+    it('Should throw an error if required dependency is not provided', async () => {
+        class DependencyRequiredComponent extends A_Component { }
+
+        class Test extends A_Component {
+            constructor(
+                @A_Dependency.Required()
+                @A_Inject(DependencyRequiredComponent) component: A_Component,
+            ) {
+                super();
+            }
+        }
+
+        const scope = new A_Scope({ components: [Test] });
+
+        try {
+            scope.resolve(Test);
+        } catch (error) {
+            expect(error).toBeInstanceOf(A_ScopeError);
+            expect((error as A_ScopeError).title).toBe(A_ScopeError.ResolutionError);
+        }
+
+        const dependency = scope.resolve(DependencyRequiredComponent);
+
+        expect(dependency).toBeUndefined();
+    });
+    it('Should resolve a component if it has default constructor for dependency', async () => {
+        class MyCustomEntity extends A_Entity<{ foo: string }> {
+            foo!: string;
+
+            fromNew(newEntity: { foo: string; }): void {
+                super.fromNew(newEntity);
+                this.foo = newEntity.foo;
+            }
+        }
+
+        class TestC extends A_Component {
+            constructor(
+                @A_Dependency.Default({ foo: 'bar' })
+                @A_Dependency.Required()
+                @A_Inject(MyCustomEntity) public component: MyCustomEntity,
+            ) {
+                super();
+            }
+        }
+
+        const scope = new A_Scope({ components: [TestC], entities: [MyCustomEntity] });
+
+        const instance = scope.resolve(TestC);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(TestC);
+        expect(instance!.component).toBeInstanceOf(MyCustomEntity);
+        expect(instance!.component.foo).toBe('bar');
+    });
+
+});

package/tests/A-Feature.test.ts

@@ -63,8 +63,8 @@ describe('A-Feature tests', () => {
                     component: MyExtendedComponent,
                     handler: 'testHandler',
                     behavior: 'sync',
-                    before: [],
-                    after: []
+                    before: '',
+                    after: ''
                 },
                 {
                     name: 'MyExtendedComponent.testHandler',
@@ -82,7 +82,7 @@ describe('A-Feature tests', () => {
         scope.register(MyComponent);
 
         // 4) create an instance of the component from the scope
-        const myComponent = scope.resolve(MyComponent);
+        const myComponent = scope.resolve(MyComponent)!;
         expect(myComponent).toBeInstanceOf(MyComponent);
         expect(myComponent.sum).toBe(0);
 
@@ -115,8 +115,8 @@ describe('A-Feature tests', () => {
                     component: 'MyExtendedComponent2',
                     handler: 'testHandler',
                     behavior: 'sync',
-                    before: [],
-                    after: []
+                    before: '',
+                    after: ''
                 }]
             })
             async testHandler() { }
@@ -129,7 +129,7 @@ describe('A-Feature tests', () => {
         scope.register(MyComponent2);
 
         // 4) create an instance of the component from the scope
-        const myComponent = scope.resolve(MyComponent2);
+        const myComponent = scope.resolve(MyComponent2)!;
         expect(myComponent).toBeInstanceOf(MyComponent2);
         expect(myComponent.sum).toBe(0);
 
@@ -179,7 +179,7 @@ describe('A-Feature tests', () => {
         const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
 
         // 3) create an instance of the component from the scope
-        const myComponent = scope.resolve(My_Component);
+        const myComponent = scope.resolve(My_Component)!;
         expect(myComponent).toBeInstanceOf(My_Component);
 
         // 4) call the feature caller to execute the feature
@@ -220,7 +220,7 @@ describe('A-Feature tests', () => {
         const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
 
         // 3) create an instance of the component from the scope
-        const myComponent = scope.resolve(My_Component);
+        const myComponent = scope.resolve(My_Component)!;
         expect(myComponent).toBeInstanceOf(My_Component);
 
         // 4) call the feature caller to execute the feature
@@ -271,7 +271,7 @@ describe('A-Feature tests', () => {
         const scope = new A_Scope({ name: 'TestScope', components: [My_Component] });
 
         // 3) create an instance of the component from the scope
-        const myComponent = scope.resolve(My_Component);
+        const myComponent = scope.resolve(My_Component)!;
         expect(myComponent).toBeInstanceOf(My_Component);
 
         // 4) call the feature caller to execute the feature
@@ -313,7 +313,7 @@ describe('A-Feature tests', () => {
         const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
 
         // 3) create an instance of the component from the scope
-        const myComponent = scope.resolve(My_Child_Component);
+        const myComponent = scope.resolve(My_Child_Component)!;
         expect(myComponent).toBeInstanceOf(My_Child_Component);
 
         await myComponent.feature1();
@@ -357,7 +357,7 @@ describe('A-Feature tests', () => {
         const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
 
         // 3) create an instance of the component from the scope
-        const myComponent = scope.resolve(My_Child_Component);
+        const myComponent = scope.resolve(My_Child_Component)!;
         expect(myComponent).toBeInstanceOf(My_Child_Component);
 
         await myComponent.feature1();

package/tests/A-Scope.test.ts

@@ -32,9 +32,10 @@ describe('A-Scope tests', () => {
         const resolved = scope.resolve(A_Component);
         expect(resolved).toBe(component);
     });
-    it('Should return an error when resolving a non-registered component', async () => {
+    it('Should return an undefined when resolving a non-registered component', async () => {
         const scope = new A_Scope({ name: 'TestScope' });
-        expect(() => scope.resolve(A_Component)).toThrowError();
+        const resolved = scope.resolve(A_Component);
+        expect(resolved).toBeUndefined();
     });
     it('Should allow to register and resolve a component with dependencies', async () => {
         class DependentComponent extends A_Component {
@@ -50,7 +51,7 @@ describe('A-Scope tests', () => {
         scope.register(component);
         scope.register(new DependentComponent(component));
 
-        const resolved = scope.resolve(DependentComponent);
+        const resolved = scope.resolve(DependentComponent)!;
         expect(resolved).toBeInstanceOf(DependentComponent);
         expect(resolved.dependency).toBe(component);
     });
@@ -188,11 +189,10 @@ describe('A-Scope tests', () => {
         expect(resolved2).toBe(MyEntity);
         expect(resolved3).toBe(MyEntity);
 
-        expect(() => {
-            const res = scope.resolveConstructor<MyEntity>('mya__entity');
+        const wrongConstructor = scope.resolveConstructor<MyEntity>('mya__entity');
+
+        expect(wrongConstructor).toBeUndefined();
 
-            console.log('RESOLVED:::: ', res)
-        }).toThrow();
 
         const instance = new resolved();
 
@@ -221,9 +221,9 @@ describe('A-Scope tests', () => {
         expect(resolved2).toBe(MyEntity);
         expect(resolved3).toBe(MyEntity);
 
-        expect(() => {
-            scope.resolveConstructor<MyEntity>('myS-entity');
-        }).toThrow();
+        const wrongConstructor = scope.resolveConstructor<MyEntity>('myS-entity');
+
+        expect(wrongConstructor).toBeUndefined();
 
 
         const instance = new resolved({ foo: 'bar' });