@adaas/a-concept 0.0.32 → 0.0.34

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

@@ -0,0 +1,130 @@
+import { A_Abstraction_Extend } from "@adaas/a-concept/decorators/A-Abstraction/A-Abstraction-Extend.decorator";
+import { A_Feature } from "../A-Feature/A-Feature.class";
+import { A_TYPES__A_AbstractionConstructor, A_TYPES__AbstractionState } from "./A-Abstraction.types";
+import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
+
+
+export class A_Abstraction {
+
+    public name: string;
+    protected features: A_Feature[] = [];
+    protected _current?: A_Feature;
+    protected _index: number = 0;
+
+    state: A_TYPES__AbstractionState = A_TYPES__AbstractionState.INITIALIZED;
+    error?: A_Error
+
+
+
+    /**
+     * Define a new A-Abstraction
+     */
+    static get Extend(): typeof A_Abstraction_Extend {
+        return A_Abstraction_Extend;
+    }
+
+
+
+    constructor(params: A_TYPES__Required<Partial<A_TYPES__A_AbstractionConstructor>, ['name', 'features']>) {
+        this.name = params.name;
+        this.features = params.features.map(def => new A_Feature(def));
+
+        this._current = this.features[0];
+    }
+
+
+    get feature(): A_Feature | undefined {
+        return this._current;
+    }
+
+    [Symbol.iterator](): Iterator<A_Feature, any> {
+        return {
+            // Custom next method
+            next: (): IteratorResult<A_Feature, any> => {
+                if (!this.isDone()) {
+
+                    this._current = this.features[this._index];
+
+                    return {
+                        value: this._current,
+                        done: false
+                    };
+                } else {
+
+                    this._current = undefined; // Reset current on end
+
+                    return {
+                        value: undefined,
+                        done: true
+                    };
+                }
+            }
+        };
+    }
+
+    /**
+     * This method moves the feature to the next stage
+     * 
+     * @param stage 
+     */
+    next(stage) {
+        const stageIndex = this.features.indexOf(stage);
+
+        this._index = stageIndex + 1;
+
+        if (this._index >= this.features.length) {
+            this.completed();
+        }
+    }
+
+    async completed(): Promise<void> {
+        this.state = A_TYPES__AbstractionState.COMPLETED;
+    }
+
+
+    /**
+     * This method marks the feature as failed and throws an error
+     * Uses to interrupt or end the feature processing
+     * 
+     * @param error 
+     */
+    async failed(
+        error: Error | A_Error | unknown
+    ): Promise<void> {
+        this.error = error as A_Error;
+        this.state = A_TYPES__AbstractionState.FAILED;
+    }
+
+
+    /**
+     * This method checks if the A-Feature is done
+     * 
+     * @returns 
+     */
+    isDone(): boolean {
+        return !this.feature
+            || this._index >= this.features.length
+            || this.state === A_TYPES__AbstractionState.COMPLETED
+            || this.state === A_TYPES__AbstractionState.FAILED;
+    }
+
+
+    async process() {
+        if (this.isDone()) 
+            return;
+        try {
+            this.state = A_TYPES__AbstractionState.PROCESSING;
+
+            for (const feature of this.features) {
+
+                await feature.process();
+            }
+
+            await this.completed();
+
+        } catch (error) {
+            await this.failed(error);
+        }
+
+    }
+}

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

@@ -0,0 +1,22 @@
+import { A_TYPES__Required } from "@adaas/a-utils";
+import { A_Container } from "../A-Container/A-Container.class";
+import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
+import { A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
+import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
+
+
+
+export type A_TYPES__A_AbstractionConstructor = {
+    name: string,
+    features: Array<A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps']>>
+} & A_TYPES__ScopeConstructor
+
+
+
+export enum A_TYPES__AbstractionState {
+    INITIALIZED = "INITIALIZED",
+    PROCESSING = "PROCESSING",
+
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+}

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

@@ -38,8 +38,6 @@ export class A_Channel<
     async call<_Resp extends any>(prop: A_TYPES__A_ChannelAggregateMethods<T>, params?: Partial<A_TYPES__A_ChannelCallParams>): Promise<_Resp> {
         // do HTTP Call or just inject class or whatever you want
 
-        console.log('Calling method', prop);
-
         return {} as _Resp;
     }
 }

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

@@ -1,3 +1,4 @@
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
 import { A_Component } from "../A-Component/A-Component.class"
 import { A_TYPES__ContainerCallParams } from "../A-Container/A-Container.types"
 import { A_Fragment } from "../A-Fragment/A-Fragment.class"
@@ -80,7 +81,7 @@ export type A_TYPES__A_ExecutableMethods<T> = {
 /**
  * Returns a string set of possible methods that could be called on a set of provided set of A-Components
  */
-export type A_TYPES__A_ChannelAggregateMethods<TClasses extends A_Component[]> = {
+export type A_TYPES__A_ChannelAggregateMethods<TClasses extends (A_Component | A_Container)[]> = {
     [K in keyof TClasses]: TClasses[K] extends infer Instance
     ? A_TYPES__A_ExecutableMethods<Instance>
     : never;

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,14 +1,8 @@
-import { A_TYPES__ConceptStage, A_TYPES__ConceptStageParams, 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_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;
@@ -28,7 +22,7 @@ import { A_Channel } from "../A-Channel/A-Channel.class";
  * 
  */
 export class A_Concept<
-    _Features extends A_Container<any>[] = any
+    _Imports extends A_Container[] = any
 > {
 
     // ==============================================================================
@@ -37,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);
     }
 
     /**
@@ -46,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);
     }
 
     /**
@@ -64,192 +58,196 @@ 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 Class  ======================================
+    // ==========================  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 || [],
             // containers: props.containers
             components: [
                 // A_Logger,
             ]
         });
 
-        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 this.sharedBase.Scope;
+    }
+
+
 
     // =======================================================================
     // ==========================  LIFECYCLE  ================================
     // =======================================================================
 
+
     /**
-     * Run the concept.
+     * Load the concept.
      */
-    async run(
-        params?: Partial<A_TYPES__ConceptStageParams>
+    async load(
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Load, params);
 
+        await abstraction.process();
     }
 
 
+
     /**
-     * Build the concept.
+     * Run the concept.
      */
-    async build(
-        params?: Partial<A_TYPES__ConceptStageParams>
+    async run(
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
+        await this.load(params);
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Run, params);
 
+        await abstraction.process();
     }
 
 
-    // /**
-    //  * Deploy the concept.
-    //  */
-    async deploy(
-        params?: Partial<A_TYPES__ConceptStageParams>
+    /**
+     * Start the concept.
+     * 
+     * @param params 
+     */
+    async start(
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
+        await this.load(params);
 
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Start, params);
+
+        await abstraction.process();
     }
 
 
-    // /**
-    //  * Publish the concept.
-    //  */
-    async publish(
-        params?: Partial<A_TYPES__ConceptStageParams>
+    /**
+     * Stop the concept.
+     * 
+     * @param params 
+     */
+    async stop(
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Stop, params);
 
+        await abstraction.process();
     }
 
 
     /**
-     * Call the specific method of the concept or included modules.
+     * Build the concept.
      */
-    async call<
-        K extends Record<_Features[number]['name'], _Features[number]['exports'][number]>
-    >(
-        container: K[keyof K],
-        params?: A_Fragment[]
+    async build(
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        // for (const feature of this.features) {
-        //     if (methodName in feature) {
-        //         (feature as any)[methodName](...args);
-        //     }
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Build, params);
 
-        // }
+        await abstraction.process();
     }
 
 
-    private async runStage(
-        method: A_TYPES__ConceptStage,
-        params: Partial<A_TYPES__ConceptStageParams>
+    /**
+     * Deploy the concept.
+     */
+    async deploy(
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Deploy, params);
 
-        const abstractions: {
-            container: A_Container<any>,
-            runners: 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();
-
-            abstractions.push({
-                container,
-                runners: [
-                    ...containerAbstractions.map(step => ({
-                        ...step,
-                        component: container,
-                    })),
-
-                    ...componentsAbstractions
-                ]
-            });
-        });
-
-
-
-
-        const scope = A_Context.allocate(this, {
-            components: params.components,
-            fragments: params.fragments,
-            parent: A_Context.scope(this)
-        });
-
+        await abstraction.process();
 
     }
 
 
-    private async execute(
-        params: Partial<A_TYPES__ConceptStageParams>
+    /**
+     * Publish the concept.
+     */
+    async publish(
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
-        const fragments = params.fragments || [];
-        const component = params.components || [];
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Publish, params);
 
+        await abstraction.process();
+    }
 
-        this.containers.map(container => {
-            const meta = A_Context.meta(container);
 
-            meta.get(A_TYPES__ContainerMetaKey.FEATURES)
+    // =======================================================================
+    // ==========================  CALL  =====================================
+    // =======================================================================
 
-        });
 
+    /**
+     * Call the specific method of the concept or included modules.
+     */
+    async call<
+        K extends Record<_Imports[number]['name'], string>
+    >(
+        container: K[keyof K],
+        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+    ) {
+        // const definition = this.meta.abstractionDefinition(A_TYPES__ConceptStage.Run, {
+        //     components: params?.components,
+        //     fragments: params?.fragments,
+        // });
+
+        // const feature = new A_Feature(definition);
 
+        // await feature.process();
     }
 
 }