@adaas/a-concept 0.0.33 → 0.0.35

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

@@ -1,7 +1,6 @@
-import { A_TYPES__Required } from "@adaas/a-utils";
 import { A_Context } from "../A-Context/A-Context.class";
-import { A_TYPES__ComponentCallParams, A_TYPES__ComponentConstructor } from "./A-Component.types";
-import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_TYPES__ComponentConstructor } from "./A-Component.types";
+import { A_TYPES__FeatureCallParams } from "../A-Feature/A-Feature.types";
 
 
 
@@ -9,64 +8,25 @@ import { A_Scope } from "../A-Scope/A-Scope.class";
  * This element only contains the specific code
  * 
  */
-export class A_Component<
-    _FeatureNames extends Array<string> = any,
-> {
+export class A_Component {
     constructor(
-        params?: Partial<A_TYPES__ComponentConstructor<_FeatureNames>>
-    ) { }
+        params?: Partial<A_TYPES__ComponentConstructor<any>>
+    ) { 
+        console.log('A-Component instance created', this);
 
+    }
 
-    /**
-     * Call a feature of the component
-     * 
-     * @param lifecycleMethod 
-     * @param args 
-     */
-    async call(
-        scope: A_Scope,
-        /**
-         * A-Feature method name to be called
-         */
-        feature: _FeatureNames[number],
-    ): Promise<any>
-    async call(
-        scope: A_Scope,
-        /**
-         * A-Feature name to be called
-         */
-        params: A_TYPES__Required<Partial<A_TYPES__ComponentCallParams<_FeatureNames[number]>>, ['name']>,
-    ): Promise<any>
 
     async call(
-        scope: A_Scope,
-        /**
-        * A-Feature method name to be called
-        */
         feature: string,
-        /**
-         * Parameters to provide additional data to the feature
-         */
-        params: Partial<A_TYPES__ComponentCallParams<_FeatureNames[number]>>,
-    ): Promise<any>
-
-    async call(
-        scope: A_Scope,
-        param1: _FeatureNames[number] | A_TYPES__Required<Partial<A_TYPES__ComponentCallParams<_FeatureNames[number]>>, ['name']>,
-        param2?: Partial<A_TYPES__ComponentCallParams<_FeatureNames[number]>>
-    ): Promise<any> {
-
-        const feature: string = typeof param1 === 'string'
-            ? param1
-            : param1.name;
-        const params: Partial<A_TYPES__ComponentCallParams<_FeatureNames[number]>> = typeof param1 === 'string'
-            ? param2 || {}
-            : param1;
-
-        const newFeature = A_Context.feature(scope, this, feature, params);
+        params: Partial<A_TYPES__FeatureCallParams> = {}
+    ) {
+        const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
 
         return await newFeature.process();
     }
+
+
 }
 
 

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

@@ -2,6 +2,7 @@ import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-I
 import { A_TYPES__ConceptAbstractionMeta, A_TYPES__ConceptStage } from "../A-Concept/A_Concept.types";
 import { A_Meta } from "../A-Meta/A-Meta.class";
 import { A_TYPES__ComponentMeta, A_TYPES__ComponentMetaExtension, A_TYPES__ComponentMetaKey } from "./A-Component.types";
+import { A_TYPES__A_DefineDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 
 
 export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
@@ -62,6 +63,22 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
     }
 
 
+
+    /**
+     * Returns all features defined in the Component
+     * 
+     * @returns 
+     */
+    features(): Array<A_TYPES__A_DefineDecorator_Meta> {
+
+        const features = this.get(A_TYPES__ComponentMetaKey.FEATURES);
+
+        return features?.toArray()
+            // returns all extensions that match the feature
+            .map(([, feature]) => feature) || [];
+    }
+
+
     /**
      * Returns a set of instructions to run proper methods in Component during A-Concept Stage
      * 
@@ -69,7 +86,7 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
      * @returns 
      */
     abstractions(
-        abstraction: A_TYPES__ConceptStage
+        abstraction: any
     ): A_TYPES__ConceptAbstractionMeta[] {
         const steps: A_TYPES__ConceptAbstractionMeta[] = [];
 
@@ -81,7 +98,7 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
 
         abstractions
             // returns all extensions that match the feature
-            ?.find(`CONCEPT_ABSTRACTION::${abstraction}`)
+            ?.find(abstraction)
             .forEach(([handler, extensions]) => {
                 extensions.forEach(extension => {
                     const args = injections?.get(extension.handler) || [];

package/src/global/A-Concept/A_Concept.class.ts

@@ -1,18 +1,8 @@
-import { A_TYPES__ConceptStage, A_TYPES__ConceptAbstractionCallParams, A_TYPES__IConceptConstructor } from "./A_Concept.types";
-import { A_Context } from "../A-Context/A-Context.class";
+import { A_TYPES__ConceptStage, A_TYPES__ConceptAbstractionCallParams, A_TYPES__IConceptConstructor, A_TYPES__ConceptAbstractionMeta } from "./A_Concept.types";
 import { A_Container } from "../A-Container/A-Container.class";
-// import { A_Logger } from "@adaas/a-concept/base/A-Logger/A-Logger.component";
-import { A_Fragment } from "../A-Fragment/A-Fragment.class";
-import { A_TYPES__ContainerMetaKey } from "../A-Container/A-Container.types";
-import { A_Abstraction } from "@adaas/a-concept/decorators/A-Abstraction/A-Abstraction.decorator";
-import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
-import { A_Channel } from "../A-Channel/A-Channel.class";
-import { A_Feature } from "../A-Feature/A-Feature.class";
-import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
-import { A_TYPES__Required } from "@adaas/a-utils";
-import { A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
-
-
+import { A_Abstraction } from "../A-Abstraction/A-Abstraction.class";
+import { A_ConceptMeta } from "./A_Concept.meta";
+import { A_Abstraction_Extend } from "@adaas/a-concept/decorators/A-Abstraction/A-Abstraction-Extend.decorator";
 
 
 // export type RunParams<T> = T extends A_Container<any, infer Params> ? Params : never;
@@ -32,7 +22,7 @@ import { A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
  * 
  */
 export class A_Concept<
-    _Features extends A_Container<any>[] = any
+    _Imports extends A_Container[] = any
 > {
 
     // ==============================================================================
@@ -41,8 +31,8 @@ export class A_Concept<
     /**
      * Load the concept. This step runs before any other steps to ensure that all components are loaded.
      */
-    static Load() {
-        return A_Abstraction(A_TYPES__ConceptStage.Load);
+    static Load(): ReturnType<typeof A_Abstraction_Extend> {
+        return A_Abstraction.Extend(A_TYPES__ConceptStage.Load);
     }
 
     /**
@@ -50,15 +40,15 @@ export class A_Concept<
      *
      * [!] To extend the logic just create a custom containers and override the default behavior.
      */
-    static Publish() {
-        return A_Abstraction(A_TYPES__ConceptStage.Publish);
+    static Publish(): ReturnType<typeof A_Abstraction_Extend> {
+        return A_Abstraction.Extend(A_TYPES__ConceptStage.Publish);
     }
 
     /**
      * Deploy the concept to the environment.
      */
     static Deploy() {
-        return A_Abstraction(A_TYPES__ConceptStage.Deploy);
+        return A_Abstraction.Extend(A_TYPES__ConceptStage.Deploy);
     }
 
     /**
@@ -68,43 +58,46 @@ export class A_Concept<
      * 
      */
     static Build() {
-        return A_Abstraction(A_TYPES__ConceptStage.Build);
+        return A_Abstraction.Extend(A_TYPES__ConceptStage.Build);
     }
 
     /**
      *  Main execution of the concept.
      */
     static Run() {
-        return A_Abstraction(A_TYPES__ConceptStage.Run);
+        return A_Abstraction.Extend(A_TYPES__ConceptStage.Run);
     }
 
     /**
      *  Start the concept. Uses for servers or any other background services.
      */
     static Start() {
-        return A_Abstraction(A_TYPES__ConceptStage.Start);
+        return A_Abstraction.Extend(A_TYPES__ConceptStage.Start);
     }
 
     /**
      * Stop the concept. Uses for servers or any other background services.
      */
     static Stop() {
-        return A_Abstraction(A_TYPES__ConceptStage.Stop);
+        return A_Abstraction.Extend(A_TYPES__ConceptStage.Stop);
     }
 
 
+    private sharedBase!: A_Container;
+    private meta!: A_ConceptMeta
+
+
 
     // ==============================================================================
     // ==========================  MAIN Methods  ======================================
     // ==============================================================================
 
-    protected containers: A_Container<any>[] = [];
+    protected containers!: A_Container[];
 
     constructor(
-        protected props: A_TYPES__IConceptConstructor<_Features>
+        protected props: A_TYPES__IConceptConstructor<_Imports>
     ) {
-
-        A_Context.allocate(this, {
+        this.sharedBase = new A_Container({
             name: props.name,
             fragments: props.fragments || [],
             entities: props.entities || [],
@@ -114,19 +107,26 @@ export class A_Concept<
             ]
         });
 
-        this.containers = props.containers || [];
+        this.containers = (props.containers || []).map(container => {
+            container.Scope.parent(this.Scope);
+
+            return container;
+        });
+
+        this.meta = new A_ConceptMeta(this.containers, this.sharedBase);
     }
 
 
     get namespace() {
-        return A_Context.scope(this).name;
+        return this.sharedBase.name;
     }
 
     get Scope() {
-        return A_Context.scope(this);
+        return this.sharedBase.Scope;
     }
 
 
+
     // =======================================================================
     // ==========================  LIFECYCLE  ================================
     // =======================================================================
@@ -138,9 +138,7 @@ export class A_Concept<
     async load(
         params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Load, params);
-
-        const abstraction = new A_Feature(definition);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Load, params);
 
         await abstraction.process();
     }
@@ -155,9 +153,7 @@ export class A_Concept<
     ) {
         await this.load(params);
 
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Run, params);
-
-        const abstraction = new A_Feature(definition);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Run, params);
 
         await abstraction.process();
     }
@@ -173,9 +169,7 @@ export class A_Concept<
     ) {
         await this.load(params);
 
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Start, params);
-
-        const abstraction = new A_Feature(definition);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Start, params);
 
         await abstraction.process();
     }
@@ -189,9 +183,7 @@ export class A_Concept<
     async stop(
         params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Stop, params);
-
-        const abstraction = new A_Feature(definition);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Stop, params);
 
         await abstraction.process();
     }
@@ -203,9 +195,7 @@ export class A_Concept<
     async build(
         params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Build, params);
-
-        const abstraction = new A_Feature(definition);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Build, params);
 
         await abstraction.process();
     }
@@ -217,9 +207,7 @@ export class A_Concept<
     async deploy(
         params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Deploy, params);
-
-        const abstraction = new A_Feature(definition);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Deploy, params);
 
         await abstraction.process();
 
@@ -232,9 +220,7 @@ export class A_Concept<
     async publish(
         params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Publish, params);
-
-        const abstraction = new A_Feature(definition);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Publish, params);
 
         await abstraction.process();
     }
@@ -249,86 +235,19 @@ export class A_Concept<
      * Call the specific method of the concept or included modules.
      */
     async call<
-        K extends Record<_Features[number]['name'], _Features[number]['exports'][number]>
+        K extends Record<_Imports[number]['name'], string>
     >(
         container: K[keyof K],
         params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        const definition = this.abstractionDefinition(A_TYPES__ConceptStage.Run, {
-            components: params?.components,
-            fragments: params?.fragments,
-        });
-
-        const feature = new A_Feature(definition);
-
-        await feature.process();
-    }
-
-
-    abstractionDefinition(
-        method: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
-
-        const abstractionSteps: Array<A_TYPES__A_StageStep> = [];
-
-        this.containers.map(container => {
-            const meta = A_Context.meta(container);
-
-            const containerAbstractions: Array<A_TYPES__A_StageStep> = meta
-                .abstractions(method)
-                .map(step => ({
-                    component: container,
-                    ...step
-                }));
-
-            const containerScope = A_Context.scope(container);
-
-            const componentsAbstractions = containerScope
-                .components
-                .map(component => A_Context.meta(component).abstractions(method).map(step => ({
-                    component,
-                    ...step
-                })))
-                .flat();
-
-            abstractionSteps.push(
-                ...containerAbstractions.map(step => ({
-                    ...step,
-                    component: container,
-                })),
-
-                ...componentsAbstractions
-            );
-        });
-
-
-        return {
-            ...params,
-            name: `${this.namespace}.${method}`,
-            steps: abstractionSteps,
-            parent: this.Scope,
-            components: params?.components || [],
-            fragments: params?.fragments || [],
-        };
-    }
-
-
-    private async execute(
-        params: Partial<A_TYPES__ConceptAbstractionCallParams>
-    ) {
-        const fragments = params.fragments || [];
-        const component = params.components || [];
-
-
-        this.containers.map(container => {
-            const meta = A_Context.meta(container);
-
-            meta.get(A_TYPES__ContainerMetaKey.FEATURES)
-
-        });
+        // const definition = this.meta.abstractionDefinition(A_TYPES__ConceptStage.Run, {
+        //     components: params?.components,
+        //     fragments: params?.fragments,
+        // });
 
+        // const feature = new A_Feature(definition);
 
+        // await feature.process();
     }
 
 }

package/src/global/A-Concept/A_Concept.meta.ts

@@ -1,9 +1,77 @@
+
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
 import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_TYPES__Required } from "@adaas/a-utils";
+import { A_TYPES__ConceptAbstractionCallParams, A_TYPES__ConceptStage } from "./A_Concept.types";
+import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
+import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_TYPES__A_FeatureDecoratorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
+import { A_TYPES__A_AbstractionConstructor } from "../A-Abstraction/A-Abstraction.types";
+import { A_Abstraction } from "../A-Abstraction/A-Abstraction.class";
 // import { A_TYPES__ComponentMeta } from "./A-Component.types";
 
 
 export class A_ConceptMeta extends A_Meta<any> {
 
 
+    constructor(
+        private containers: Array<A_Container>,
+        private base: A_Container
+    ) {
+        super();
+    }
+
+    abstractionDefinition(
+        method: A_TYPES__ConceptStage,
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+    ): A_TYPES__Required<Partial<A_TYPES__A_AbstractionConstructor>, ['features']> {
+
+        const featureDefinitions = this.containers.map(container =>
+            A_Context.abstractionDefinition(container.Scope, container, method, params)
+        );
+
+
+        const definition = {
+            ...params,
+            name: `${this.base.name}.${method}`,
+            features: featureDefinitions,
+            parent: this.base.Scope,
+            components: params?.components || [],
+            fragments: params?.fragments || [],
+        };
+
+        return definition;
+    }
+
+
+
+    abstraction(
+        method: A_TYPES__ConceptStage,
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+    ): A_Abstraction {
+
+
+        const featureDefinitions = this.containers.map(container => {
+            const definition = A_Context.abstractionDefinition(container.Scope, container, method, params);
+
+            return {
+                ...definition,
+                steps: definition.steps.map(step => ({ ...step, component: step.component ? step.component : container }))
+            }
+        });
+
+
+        const definition = {
+            ...params,
+            name: `${this.base.name}.${method}`,
+            features: featureDefinitions,
+            parent: this.base.Scope,
+            components: params?.components || [],
+            fragments: params?.fragments || [],
+        };
+
+        return new A_Abstraction(definition);
+    }
 
 }

package/src/global/A-Concept/A_Concept.types.ts

@@ -35,7 +35,7 @@ export enum A_TYPES__ConceptMetaKey {
 
 
 export interface A_TYPES__IConceptConstructor<
-    T extends Array<A_Container<any>>
+    T extends Array<A_Container>
 > {
     name: string,
 
@@ -124,7 +124,7 @@ export type A_TYPES__ConceptCallParams<T extends string> = {
     name: T,
     fragments: Array<A_Fragment>,
     components: Array<{ new(...args: any[]): A_Component }>,
-    entities: Array<{ new(...args: any[]): A_Entity<any, any, any> }>
+    entities: Array<{ new(...args: any[]): A_Entity }>
 }