@adaas/a-concept 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.3.3",
+  "version": "0.3.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",
   "author": {

package/src/lib/A-Abstraction/A-Abstraction-Extend.decorator.ts

@@ -65,7 +65,7 @@ export function A_Abstraction_Extend(
         }
 
         let metaKey;
-        const meta: A_ContainerMeta | A_ComponentMeta = A_Context.meta(target);
+        const meta: A_Meta = A_Context.meta(target);
 
         switch (true) {
             case A_TypeGuards.isContainerConstructor(target) || A_TypeGuards.isContainerInstance(target):

package/src/lib/A-Component/A-Component.meta.ts

@@ -50,7 +50,7 @@ export class A_ComponentMeta<T extends A_TYPES__ComponentMeta = A_TYPES__Compone
                         before: extension.before || '',
                         after: extension.after || '',
                         throwOnError: extension.throwOnError || true,
-                        override: ''
+                        override: extension.override || '',
                     });
 
                 });

package/src/lib/A-Container/A-Container.meta.ts

@@ -13,7 +13,7 @@ import { A_TYPES__FeatureDefineDecoratorMeta } from "@adaas/a-concept/a-feature"
 
 
 
-export class A_ContainerMeta extends A_Meta<A_TYPES__ContainerMeta> {
+export class A_ContainerMeta<T extends A_TYPES__ContainerMeta = A_TYPES__ContainerMeta> extends A_Meta<T> {
 
 
 

package/src/lib/A-Context/A-Context.class.ts

@@ -8,6 +8,7 @@ import {
 } from "@adaas/a-concept/a-scope";
 import {
     A_Meta,
+    A_TYPES__Meta_Constructor,
     A_TYPES__MetaLinkedComponentConstructors,
     A_TYPES__MetaLinkedComponents
 } from "@adaas/a-concept/a-meta";
@@ -376,7 +377,7 @@ export class A_Context {
          */
         component: A_TYPES__Component_Constructor,
     ): T
-    static meta<T extends A_ComponentMeta, S extends A_Component>(
+    static meta<T extends A_ComponentMeta<any>, S extends A_Component>(
         /**
          * Get meta for the specific component instance.
          */
@@ -442,7 +443,7 @@ export class A_Context {
         ) throw new A_ContextError(A_ContextError.InvalidMetaParameterError, `Invalid parameter provided to get meta. Component of type ${componentName} is not allowed for meta storage. Only A_Container, A_Component and A_Entity are allowed.`);
 
         let property: A_TYPES__MetaLinkedComponentConstructors;
-        let metaType: typeof A_Meta<T> | typeof A_ContainerMeta | typeof A_ComponentMeta | typeof A_EntityMeta
+        let metaType: A_TYPES__Meta_Constructor<A_Meta<any>>
 
         switch (true) {
             // 1) If param1 is instance of A_Container
@@ -833,6 +834,17 @@ export class A_Context {
                                 steps.delete(`${A_CommonHelper.getComponentName(inherited)}.${declaration.handler}`);
                             }
 
+                            // Check if the declaration has an override regexp and remove matching steps
+                            // Match against both the full step key (Component.handler) and the handler alone
+                            if (declaration.override) {
+                                const overrideRegexp = new RegExp(declaration.override);
+                                for (const [stepKey, step] of steps) {
+                                    if (overrideRegexp.test(stepKey) || overrideRegexp.test(step.handler)) {
+                                        steps.delete(stepKey);
+                                    }
+                                }
+                            }
+
                             steps.set(`${A_CommonHelper.getComponentName(cmp)}.${declaration.handler}`, {
                                 dependency: new A_Dependency(cmp),
                                 ...declaration

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

@@ -5,14 +5,15 @@ import {
     A_TYPES__IEntity,
 } from "./A-Entity.types";
 import { A_Scope } from "@adaas/a-concept/a-scope";
-import { A_FormatterHelper} from "@adaas/a-concept/helpers/A_Formatter.helper";
-import { A_IdentityHelper} from "@adaas/a-concept/helpers/A_Identity.helper";
+import { A_FormatterHelper } from "@adaas/a-concept/helpers/A_Formatter.helper";
+import { A_IdentityHelper } from "@adaas/a-concept/helpers/A_Identity.helper";
 import {
     ASEID,
     A_TYPES__ASEID_Constructor
 } from "@adaas/a-concept/aseid";
 import { A_EntityError } from "./A-Entity.error";
 import { A_Feature } from "@adaas/a-concept/a-feature";
+import { A_TYPES__EntityFeatures } from "./A-Entity.constants";
 
 
 /**
@@ -289,24 +290,24 @@ export class A_Entity<
     /**
      * The default method that can be called and extended to load entity data.
      */
-    async load(
+    load(
         scope?: A_Scope,
-    ) {
-        return this.call('load', scope);
+    ): Promise<void> | void {
+        return this.call(A_TYPES__EntityFeatures.LOAD, scope);
     }
 
     /**
      * The default method that can be called and extended to destroy entity data.
      */
-    async destroy(scope?: A_Scope) {
-        return this.call('destroy', scope);
+    destroy(scope?: A_Scope): Promise<void> | void {
+        return this.call(A_TYPES__EntityFeatures.DESTROY, scope);
     }
 
     /**
      * The default method that can be called and extended to save entity data.
      */
-    async save(scope?: A_Scope) {
-        return this.call('save', scope);
+    save(scope?: A_Scope): Promise<void> | void {
+        return this.call(A_TYPES__EntityFeatures.SAVE, scope);
     }
 
 

package/src/lib/A-Entity/A-Entity.constants.ts

@@ -5,8 +5,8 @@ export enum A_TYPES__EntityMetaKey {
     INJECTIONS = 'a-component-injections',
 }
 
-export enum A_TYPES__EntityFeatures {
-    SAVE = 'save',
-    DESTROY = 'destroy',
-    LOAD = 'load'
-}
+export const A_TYPES__EntityFeatures = {
+    SAVE: '_A_Entity__Save',
+    DESTROY: '_A_Entity__Destroy',
+    LOAD: '_A_Entity__Load'
+} as const;

package/src/lib/A-Entity/A-Entity.meta.ts

@@ -5,7 +5,7 @@ import { A_TYPES__FeatureDefineDecoratorMeta } from "@adaas/a-concept/a-feature"
 import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/a-inject";
 
 
-export class A_EntityMeta extends A_Meta<A_TYPES__EntityMeta> {
+export class A_EntityMeta<T extends A_TYPES__EntityMeta = A_TYPES__EntityMeta> extends A_Meta<T> {
 
     /**
      * Returns all features defined in the Container

package/src/lib/A-Entity/A-Entity.types.ts

@@ -1,7 +1,7 @@
 import { A_Meta } from "@adaas/a-concept/a-meta";
 import { A_Entity } from "./A-Entity.class";
 import { ASEID } from "@adaas/a-concept/aseid";
-import { A_TYPES__EntityMetaKey } from "./A-Entity.constants";
+import { A_TYPES__EntityFeatures, A_TYPES__EntityMetaKey } from "./A-Entity.constants";
 import { A_TYPES__FeatureDefineDecoratorMeta, A_TYPES__FeatureExtendDecoratorMeta } from "@adaas/a-concept/a-feature";
 import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/a-inject";
 import { A_TYPES__Ctor } from "@adaas/a-concept/types";
@@ -88,3 +88,4 @@ export type A_TYPES__EntityMeta = {
 
 
 
+export type A_TYPES__EntityFeatureNames =  typeof A_TYPES__EntityFeatures[keyof typeof A_TYPES__EntityFeatures];

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

@@ -843,7 +843,7 @@ export class A_Scope<
         /**
          * Provide the component constructor or its name to retrieve its constructor
          */
-        component:  A_TYPES__Ctor<T>
+        component: A_TYPES__Ctor<T>
     ): A_TYPES__Component_Constructor<T> | undefined
     resolveConstructor<T extends A_Entity>(
         /**
@@ -888,7 +888,7 @@ export class A_Scope<
                     .find((e) => A_CommonHelper.isInheritedFrom(e, name)) as A_TYPES__Error_Constructor<T> | undefined;
         }
 
-        if(!A_TypeGuards.isString(name))
+        if (!A_TypeGuards.isString(name))
             throw new A_ScopeError(
                 A_ScopeError.ResolutionError,
                 `Invalid constructor name provided: ${name}`
@@ -1865,7 +1865,12 @@ export class A_Scope<
          */
         entity: A_Entity
     ): void
-
+    deregister<T extends A_TYPES__A_DependencyInjectable>(
+        /**
+         * Provide an entity instance to register it in the scope
+         */
+        component: T
+    ): void
     deregister(
         param1: unknown
     ): void {

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

@@ -16,6 +16,11 @@ export class A_StepsManager {
     public tempMark: Set<string>;
     public sortedEntities: string[];
 
+    /**
+     * Maps each step instance to a unique ID.
+     * Duplicate steps (same dependency.name + handler) get indexed suffixes (e.g., #1, #2).
+     */
+    private _uniqueIdMap: Map<A_TYPES__A_StageStep, string> = new Map();
 
     private _isBuilt: boolean = false;
 
@@ -27,6 +32,7 @@ export class A_StepsManager {
         this.tempMark = new Set();
         this.sortedEntities = [];
 
+        this.assignUniqueIds();
     }
 
     private prepareSteps(
@@ -44,20 +50,68 @@ export class A_StepsManager {
             }));
     }
 
-    private ID(step: A_TYPES__A_StageStep) {
+    /**
+     * Returns the base (non-unique) ID for a step: `dependency.name.handler`
+     */
+    private baseID(step: A_TYPES__A_StageStep) {
         return `${step.dependency.name}.${step.handler}`;
     }
 
+    /**
+     * Returns the unique ID assigned to a specific step instance.
+     * Falls back to baseID if not yet assigned.
+     */
+    private ID(step: A_TYPES__A_StageStep) {
+        return this._uniqueIdMap.get(step) || this.baseID(step);
+    }
+
+    /**
+     * Assigns unique IDs to all steps. 
+     * Duplicate base IDs get an index suffix (#0, #1, ...).
+     * Steps with unique base IDs keep their original ID (no suffix).
+     */
+    private assignUniqueIds() {
+        // Count occurrences of each base ID
+        const counts = new Map<string, number>();
+        for (const step of this.entities) {
+            const base = this.baseID(step);
+            counts.set(base, (counts.get(base) || 0) + 1);
+        }
+
+        // Assign unique IDs with index suffix only for duplicates
+        const indexTracker = new Map<string, number>();
+        for (const step of this.entities) {
+            const base = this.baseID(step);
+            if (counts.get(base)! > 1) {
+                const idx = indexTracker.get(base) || 0;
+                this._uniqueIdMap.set(step, `${base}#${idx}`);
+                indexTracker.set(base, idx + 1);
+            } else {
+                this._uniqueIdMap.set(step, base);
+            }
+        }
+    }
+
     private buildGraph() {
         if (this._isBuilt) return;
         this._isBuilt = true;
 
-        // Filter override
+        // Filter override — match against both the full base ID and handler name
+        // so both formats work (e.g., `^.*\.step(4|5)$` and `^test1$`)
+        // A step's own override pattern should not cause it to filter itself out
         this.entities = this.entities
             .filter((step, i, self) =>
-                !self.some(s => s.override ? new RegExp(s.override).test(this.ID(step)) : false)
+                !self.some((s, j) => {
+                    if (i === j || !s.override) return false;
+                    const re = new RegExp(s.override);
+                    return re.test(this.baseID(step)) || re.test(step.handler);
+                })
             );
 
+        // Re-assign unique IDs after filtering
+        this._uniqueIdMap.clear();
+        this.assignUniqueIds();
+
         // Initialize graph nodes
         this.entities.forEach(entity => this.graph.set(this.ID(entity), new Set()));
 
@@ -90,12 +144,12 @@ export class A_StepsManager {
         });
     }
 
-    // Match entities by name or regex
+    // Match entities by name or regex — matches against the base ID for pattern compatibility
     private matchEntities(entityId: string, pattern: string): string[] {
         const regex = new RegExp(pattern);
 
         return this.entities
-            .filter(entity => regex.test(this.ID(entity)) && this.ID(entity) !== entityId)
+            .filter(entity => regex.test(this.baseID(entity)) && this.ID(entity) !== entityId)
             .map(entity => this.ID(entity));
     }
 

package/tests/A-Feature.test.ts

@@ -1038,4 +1038,80 @@ describe('A-Feature tests', () => {
             'ChildComponent_A.test'
         ]);
     })
+    it('Should keep override definition', async () => {
+
+        const resultChain: string[] = [];
+
+        class ChildComponent_A extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async test1() {
+                resultChain.push('ChildComponent_A.test1');
+            }
+
+            @A_Feature.Extend({
+                name: 'testFeature',
+                override: ['test1']
+            })
+            async test2() {
+                resultChain.push('ChildComponent_A.test2');
+            }
+        }
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A] });
+
+        const featureDefinition = A_Context.featureTemplate('testFeature', testScope.resolve(ChildComponent_A)!, testScope);
+
+
+        expect(featureDefinition).toBeDefined();
+        expect(featureDefinition.length).toBe(1);
+        expect(featureDefinition[0].handler).toBe('test2');
+
+        await testScope.resolve(ChildComponent_A)!.call('testFeature');
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test2'
+        ]);
+    })
+
+    it('Should allow to run feature with the same steps', async () => {
+
+        const resultChain: string[] = [];
+
+        class ComponentA extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async feature1() {
+                resultChain.push('ComponentA.feature1');
+            }
+        }
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ComponentA] });
+
+        const feature = new A_Feature({
+            name: 'testFeature',
+            scope: testScope,
+            template: [
+                {
+                    name: 'ComponentA.feature1',
+                    dependency: new A_Dependency('ComponentA'),
+                    handler: 'feature1',
+                },
+                {
+                    name: 'ComponentA.feature1',
+                    dependency: new A_Dependency('ComponentA'),
+                    handler: 'feature1',
+                },
+            ]
+        });
+
+        await feature.process();
+
+        expect(resultChain).toEqual([
+            'ComponentA.feature1',
+            'ComponentA.feature1'
+        ]);
+    })
 });