@adaas/a-concept 0.0.33 → 0.0.35

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

@@ -1,18 +1,15 @@
 import {
     A_CommonHelper,
-    A_Error, A_TYPES__Required,
+    A_Error,
     ASEID
 } from "@adaas/a-utils";
 import {
     A_TYPES__Entity_JSON,
-    A_TYPES__EntityBaseMethod,
-    A_TYPES__EntityBaseMethods,
-    A_TYPES__EntityCallParams,
     A_TYPES__IEntity
 } from "./A-Entity.types";
 import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
 import { A_Context } from "../A-Context/A-Context.class";
-import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_TYPES__FeatureCallParams } from "../A-Feature/A-Feature.types";
 
 
 
@@ -25,8 +22,7 @@ import { A_Fragment } from "../A-Fragment/A-Fragment.class";
  */
 export class A_Entity<
     _ConstructorType = any,
-    _SerializedType extends A_TYPES__Entity_JSON = A_TYPES__Entity_JSON,
-    _FeatureNames extends Array<string | A_TYPES__EntityBaseMethod> = A_TYPES__EntityBaseMethods
+    _SerializedType extends A_TYPES__Entity_JSON = A_TYPES__Entity_JSON
 >
     implements A_TYPES__IEntity {
 
@@ -57,7 +53,7 @@ export class A_Entity<
     )
     constructor(props: string | ASEID | _SerializedType | _ConstructorType) {
 
-        
+
         switch (true) {
             case (typeof props === 'string' && ASEID.isASEID(props)):
                 this.aseid = new ASEID(props);
@@ -139,43 +135,12 @@ export class A_Entity<
      * @param lifecycleMethod 
      * @param args 
      */
-    async call(
-        /**
-         * A-Feature method name to be called
-         */
-        feature: _FeatureNames[number],
-    ): Promise<any>
-    async call(
-        /**
-         * A-Feature name to be called
-         */
-        params: A_TYPES__Required<Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>, ['name']>,
-    ): Promise<any>
-    async call(
-        /**
-        * A-Feature method name to be called
-        */
-        feature: _FeatureNames[number],
-        /**
-         * Parameters to provide additional data to the feature
-         */
-        params: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>,
-    ): Promise<any>
-
-    async call(
-        param1: _FeatureNames[number] | A_TYPES__Required<Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>, ['name']>,
-        param2?: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>
-    ): Promise<any> {
-
-        const feature: string = typeof param1 === 'string'
-            ? param1
-            : param1.name;
-        const params: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>> = typeof param1 === 'string'
-            ? param2 || {}
-            : param1;
-
-
-        console.log('WTF???? ', A_Context.scope(this))
+     async call(
+        feature: string,
+        params: Partial<A_TYPES__FeatureCallParams> = {}
+    ) {
+        params.entities = params.entities || [this];
+
 
         const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
 
@@ -188,33 +153,21 @@ export class A_Entity<
     // ====================================================================
 
 
-    async load() {
-        await this.call(A_TYPES__EntityBaseMethod.DESTROY, {
-            entities: [
-                this
-            ]
-        });
-    }
-
-
-
-    async destroy() {
-        await this.call(A_TYPES__EntityBaseMethod.DESTROY, {
-            entities: [
-                this
-            ],
-        });
-    }
 
+    /**
+     * The default method that can be called and extended to load entity data.
+     */
+    async load() { }
 
+    /**
+     * The default method that can be called and extended to destroy entity data.
+     */
+    async destroy() { }
 
-    async save() {
-        await this.call(A_TYPES__EntityBaseMethod.SAVE, {
-            entities: [
-                this
-            ]
-        });
-    }
+    /**
+     * The default method that can be called and extended to save entity data.
+     */
+    async save() { }
 
 
 

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

@@ -1,9 +1,10 @@
+import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
 import { A_Meta } from "../A-Meta/A-Meta.class";
-import { A_TYPES__EntityMeta } from "./A-Entity.types";
+import { A_TYPES__EntityMeta, A_TYPES__EntityMetaKey } from "./A-Entity.types";
 
 
 export class A_EntityMeta extends A_Meta<A_TYPES__EntityMeta> {
 
-
+  
 
 }

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

@@ -9,7 +9,7 @@ import { A_TYPES__ContainerMeta_FeatureItem } from "../A-Container/A-Container.t
 export type A_TYPES__EntityCallParams<T extends string> = {
     name: T,
     fragments: Array<A_Fragment>,
-    entities: Array<A_Entity<any, any, any>>,
+    entities: Array<A_Entity<any, any>>,
     components: Array<{ new(...args: any[]): any }>
 }
 
@@ -73,6 +73,7 @@ export type A_TYPES__EntityMeta = {
 export enum A_TYPES__EntityMetaKey {
     EXTENSIONS = 'a-component-extensions',
     FEATURES = 'a-component-features',
+    ABSTRACTIONS = 'a-component-abstractions',
 }
 
 

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

@@ -1,15 +1,12 @@
+import { A_Context } from "../A-Context/A-Context.class";
 import { A_Feature_Define } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Define.decorator";
 import { A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Extend.decorator";
 import { A_TYPES__FeatureConstructor, A_TYPES__FeatureState, } from "./A-Feature.types";
 import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
-import { A_Context } from "../A-Context/A-Context.class";
 import { A_TYPES__A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_Stage } from "../A-Stage/A-Stage.class";
-import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
 import { StepsManager } from "@adaas/a-concept/helpers/StepsManager.class";
 
-
-
 /**
  * A_Feature is representing a feature that can be executed across multiple components
  * This class stores the steps of the feature and executes them in order of appearance
@@ -48,10 +45,12 @@ export class A_Feature {
     result?: any
     error?: A_Error
 
+    readonly name: string;
 
     constructor(
         params: A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps']>
     ) {
+        this.name = params.name || this.constructor.name;
 
         this.SM = new StepsManager(params.steps);
 
@@ -175,11 +174,23 @@ export class A_Feature {
      * 
      */
     async process() {
-        this.state = A_TYPES__FeatureState.PROCESSING;
+        if (this.isDone()) {
+            return this.result;
+        }
+
+        try {
+            this.state = A_TYPES__FeatureState.PROCESSING;
+
+            for (const stage of this.stages) {
+                await stage.process();
+            }
+
+            await this.completed();
 
-        for (const stage of this) {
-            await stage.process();
+        } catch (error) {
+            await this.failed(error);
         }
+      
     }
 
 

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

@@ -1,12 +1,20 @@
-import { A_TYPES__A_InjectDecorator_Injectable, A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types"
-import { A_Component } from "../A-Component/A-Component.class"
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
 import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types"
+import { A_Fragment } from "../A-Fragment/A-Fragment.class"
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class"
 
 
 export type A_TYPES__FeatureIteratorReturn<T extends any = any> = () => Promise<T>
 
 
+export type A_TYPES__FeatureCallParams = {
+    fragments: Array<A_Fragment>,
+    entities: Array<A_Entity<any, any>>,
+    components: Array<{ new(...args: any[]): any }>
+}
+
+
+
 export type A_TYPES__FeatureConstructor = {
     steps: A_TYPES__A_StageStep[]
 } & A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig

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

@@ -124,7 +124,7 @@ export class A_Fragment {
      * 
      * @returns 
      */
-    toJSON() {
+    toJSON(): Record<string, any> {
         return {
             name: this.name,
         };

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

@@ -1,11 +1,3 @@
-// 
-// 
-// 
-// 
-// 
-// 
-
-
 /**
  * A Meta is an entity that stores all the metadata for the specific entity like container, component, feature, etc. 
  * 
@@ -185,4 +177,9 @@ export class A_Meta<
     clear(): void {
         this.meta.clear();
     }
+
+
+    toArray(): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+        return Array.from(this.meta.entries());
+    }
 }

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

@@ -7,7 +7,11 @@ import {
 } from "../A-Component/A-Component.types";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_Entity } from "../A-Entity/A-Entity.class";
-import { A_TYPES__A_InjectDecorator_EntityInjectionInstructions, A_TYPES__A_InjectDecorator_EntityInjectionQuery, A_TYPES__A_InjectDecorator_Injectable } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
+import {
+    A_TYPES__A_InjectDecorator_EntityInjectionInstructions,
+    A_TYPES__A_InjectDecorator_Injectable
+} from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
+
 
 /**
  * 
@@ -24,13 +28,13 @@ import { A_TYPES__A_InjectDecorator_EntityInjectionInstructions, A_TYPES__A_Inje
  */
 export class A_Scope {
 
-    name: string = '';
+    readonly name: string = '';
 
     private _components: WeakMap<typeof A_Component.constructor, any> = new WeakMap();
     private _fragments: WeakMap<typeof A_Fragment.constructor, any> = new WeakMap();
     private _entities: Map<string, A_Entity> = new Map();
 
-    private parent?: A_Scope;
+    private _parent?: A_Scope;
 
     protected params!: A_TYPES__ScopeConstructor
 
@@ -47,8 +51,8 @@ export class A_Scope {
             components: [],
             fragments: [],
             entities: [],
-            import: [],
-            export: [],
+            // import: [],
+            // export: [],
         };
 
 
@@ -62,7 +66,7 @@ export class A_Scope {
         this.initEntities(params.entities || []);
 
         if (config.parent) {
-            this.parent = config.parent;
+            this._parent = config.parent;
         }
     }
 
@@ -92,6 +96,19 @@ export class A_Scope {
     }
 
 
+    parent(setValue: A_Scope): void
+    parent(): A_Scope
+    parent(
+        setValue?: A_Scope
+    ): A_Scope | undefined {
+        if (setValue) {
+            this._parent = setValue;
+            return;
+        }
+
+        return this._parent;
+    }
+
 
     /**
      * This method is used to check if the component is available in the scope
@@ -118,8 +135,8 @@ export class A_Scope {
             case A_CommonHelper.isInheritedFrom(entity, A_Component): {
                 const found = this.params.components.includes(entity as { new(...args: any[]): A_Component });
 
-                if (!found && !!this.parent)
-                    return this.parent.has(entity as any);
+                if (!found && !!this._parent)
+                    return this._parent.has(entity as any);
 
                 return found;
             }
@@ -135,8 +152,8 @@ export class A_Scope {
             case A_CommonHelper.isInheritedFrom(entity, A_Fragment): {
                 const found = this._fragments.has(entity);
 
-                if (!found && !!this.parent)
-                    return this.parent.has(entity as any);
+                if (!found && !!this._parent)
+                    return this._parent.has(entity as any);
 
                 return found;
             }
@@ -200,6 +217,8 @@ export class A_Scope {
         component: T,
         instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T> {
+
+
         switch (true) {
             case A_CommonHelper.isInheritedFrom(component, A_Entity): {
                 return this.resolveEntity(component as typeof A_Entity, instructions) as InstanceType<T>;
@@ -243,8 +262,8 @@ export class A_Scope {
                     case !!found:
                         return found as InstanceType<T>;
 
-                    case !found && !!this.parent:
-                        return this.parent.resolveEntity(entity, instructions);
+                    case !found && !!this._parent:
+                        return this._parent.resolveEntity(entity, instructions);
 
                     default:
                         throw new Error(`Fragment ${entity.name} not found in the scope ${this.name}`);
@@ -292,8 +311,8 @@ export class A_Scope {
             case fragmentInstancePresented && !this._fragments.has(fragment):
                 return this.fragments.find(fr => fr instanceof fragment) as InstanceType<T>;
 
-            case !fragmentInstancePresented && !!this.parent:
-                return this.parent.resolveFragment(fragment);
+            case !fragmentInstancePresented && !!this._parent:
+                return this._parent.resolveFragment(fragment);
 
             default:
                 throw new Error(`Fragment ${fragment.name} not found in the scope ${this.name}`);
@@ -310,11 +329,9 @@ export class A_Scope {
         new(...args: any[]): T
     }): T {
 
-        //  The idea here that in case when Scope has no exact component we have to resolve it from the parent
-        //  BUT: if it's not presented in parent  we have to check for inheritance
+        //  The idea here that in case when Scope has no exact component we have to resolve it from the _parent
+        //  BUT: if it's not presented in _parent  we have to check for inheritance
         //  That means that we should ensure that there's no components that are children of the required component
-
-
         switch (true) {
             // In case when the component is available and exists in the scope
             case this.components.includes(component) && this._components.has(component): {
@@ -354,9 +371,9 @@ export class A_Scope {
                 return this.resolveComponent<T>(found as any);
             }
 
-            // In case when the component is not available in the scope but the parent is available
-            case !this.components.includes(component) && !!this.parent: {
-                return this.parent.resolveComponent(component);
+            // In case when the component is not available in the scope but the _parent is available
+            case !this.components.includes(component) && !!this._parent: {
+                return this._parent.resolveComponent(component);
             }
 
             default:

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

@@ -28,11 +28,11 @@ export type A_TYPES__ScopeConstructor = {
     /**
      * A list of Features/Lifecycle Hooks available in the Scope
      */
-    import: Array<string>,
+    // import: Array<string>,
     /**
      * A list of Features/Lifecycle Hooks available to be exported from the Scope
      */
-    export: Array<string>
+    // export: Array<string>
 }
 
 

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

@@ -5,7 +5,6 @@ import { A_TYPES__A_Stage_JSON, A_TYPES__A_Stage_Status, A_TYPES__A_StageStep }
 import { A_Container } from "../A-Container/A-Container.class";
 
 
-
 /**
  * A_Stage is a set of A_Functions within A_Feature that should be run in a specific order.
  * Each stage may contain one or more functions. 
@@ -53,21 +52,20 @@ export class A_Stage {
      * @returns 
      */
     protected async getStepArgs(step: A_TYPES__A_StageStep) {
-
-        const target = step.component instanceof A_Container ?
-            step.component.constructor : step.component;
-
-        return A_Context
-            .meta(target)
-            .injections(
-                step.handler
-            )
-            .map(async arg =>
-                // In case if the target is a feature step then pass the current feature
-                A_CommonHelper.isInheritedFrom(arg.target, A_Feature)
-                    ? this
-                    : A_Context.scope(this.feature).resolve(arg.target)
-            );
+        return Promise
+            .all(A_Context
+                .meta(
+                    step.component instanceof A_Container
+                        ? step.component.constructor
+                        : step.component
+                )
+                .injections(step.handler)
+                .map(async arg =>
+                    // In case if the target is a feature step then pass the current feature
+                    A_CommonHelper.isInheritedFrom(arg.target, A_Feature)
+                        ? this.feature
+                        : A_Context.scope(this.feature).resolve(arg.target)
+                ));
     }
 
 
@@ -95,6 +93,7 @@ export class A_Stage {
     protected getStepInstance(step: A_TYPES__A_StageStep) {
         const { component, handler } = step;
 
+
         // TODO: probably would be better to do it another way. let's think about it
         const instance = component instanceof A_Container
             ? component
@@ -117,11 +116,12 @@ export class A_Stage {
      * @param step 
      * @returns 
      */
-    protected async getStepHandler(step: A_TYPES__A_StageStep) {
+    protected async callStepHandler(step: A_TYPES__A_StageStep) {
 
-        const instance = this.getStepInstance(step);
+        const instance = await this.getStepInstance(step);
         const callArgs = await this.getStepArgs(step);
 
+
         return instance[step.handler](...callArgs);
 
     }
@@ -148,14 +148,14 @@ export class A_Stage {
                             .all([
 
                                 // Run async steps that are independent of each other
-                                ...asyncSteps.map(step => this.getStepHandler(step)),
+                                ...asyncSteps.map(step => this.callStepHandler(step)),
 
                                 // Run sync steps that are dependent on each other
                                 new Promise<void>(
                                     async (r, j) => {
                                         try {
                                             for (const step of syncSteps) {
-                                                await this.getStepHandler(step);
+                                                await this.callStepHandler(step);
                                             }
 
                                             return r();

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

@@ -1,7 +1,6 @@
-import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types"
 import { A_Component } from "../A-Component/A-Component.class"
 import { A_Container } from "../A-Container/A-Container.class"
-import { A_TYPES__A_ExtendDecorator_BehaviorConfig, A_TYPES__A_ExtendDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types"
+import { A_TYPES__A_ExtendDecorator_BehaviorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types"
 
 
 
@@ -66,7 +65,7 @@ export type A_TYPES__A_StageStep = {
     /**
      * The component to be called
      */
-    component: typeof A_Component<any> | typeof A_Container<any> | A_Container<any>
+    component: typeof A_Component |  A_Container 
 
     /**
      * The method to be called on the component

package/src/helpers/StepsManager.class.ts

@@ -17,11 +17,16 @@ export class StepsManager {
         this.visited = new Set();
         this.tempMark = new Set();
         this.sortedEntities = [];
+
+    }
+
+    private ID(step: A_TYPES__A_StageStep) {
+        return `${step.component.name}.${step.handler}`;
     }
 
     private buildGraph() {
         // Initialize graph nodes
-        this.entities.forEach(entity => this.graph.set(entity.name, new Set()));
+        this.entities.forEach(entity => this.graph.set(this.ID(entity), new Set()));
 
         // Add directed edges based on 'before' and 'after'
         this.entities.forEach(entity => {
@@ -51,8 +56,8 @@ export class StepsManager {
     private matchEntities(pattern) {
         const regex = new RegExp(`^${pattern}$`);
         return this.entities
-            .filter(entity => regex.test(entity.name))
-            .map(entity => entity.name);
+            .filter(entity => regex.test(this.ID(entity)))
+            .map(entity => this.ID(entity));
     }
 
     // Topological sort with cycle detection
@@ -74,16 +79,15 @@ export class StepsManager {
 
         // Start topological sort
         this.entities.forEach(entity => {
-            if (!this.visited.has(entity.name)) this.visit(entity.name);
+            if (!this.visited.has(this.ID(entity))) this.visit(this.ID(entity));
         });
 
         const stages: A_Stage[] = [];
 
         // Map sorted names back to entity objects
         this.sortedEntities
-            .map(name => {
-
-                const step = this.entities.find(entity => entity.name === name)!;
+            .map(id => {
+                const step = this.entities.find(entity => this.ID(entity) === id)!;
 
                 let stage = stages.find(stage => {
                     return stage.after.every(after => step.after.includes(after))

package/trace-require.js

@@ -0,0 +1,46 @@
+const Module = require("module");
+const path = require("path");
+
+// Colors (ANSI escape codes)
+const colors = {
+  reset: "\x1b[0m",
+  gray: "\x1b[90m",
+  green: "\x1b[32m",
+  cyan: "\x1b[36m",
+  yellow: "\x1b[33m",
+};
+
+// Indent helper
+function indent(level) {
+  return "  ".repeat(level);
+}
+
+const originalLoad = Module._load;
+let stack = [];
+
+Module._load = function (request, parent, isMain) {
+  const resolved = Module._resolveFilename(request, parent);
+  const parentFile = parent && parent.filename ? parent.filename : "<root>";
+  const depth = stack.length;
+
+  let color = colors.gray;
+  let label = resolved;
+
+  if (resolved.includes("/src/")) {
+    color = colors.green; // project source
+    label = path.relative(process.cwd(), resolved);
+  } else if (resolved.includes("node_modules")) {
+    color = colors.cyan; // external deps
+    label = path.relative(process.cwd(), resolved);
+  } else {
+    color = colors.yellow; // stdlib / others
+  }
+
+  console.log(indent(depth) + color + label + colors.reset);
+
+  stack.push(resolved);
+  const result = originalLoad.apply(this, arguments);
+  stack.pop();
+
+  return result;
+};