@adaas/a-concept 0.0.2 → 0.0.4

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

@@ -1,7 +1,15 @@
-import { A_CONCEPT_LifecycleDeclarationsStorage } from "src/storage/A_Concept.storage";
-import { A_TYPES__A_CONCEPT_RootRunParams, A_TYPES__IConceptConstructor } from "./A_Concept.types";
+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_Errors } from "src/containers/A-Errors/A-Errors.namespace";
+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_Stage } from "@adaas/a-concept/decorators/A-Stage/A-Stage.decorator";
+
+
+
+
+// export type RunParams<T> = T extends A_Container<any, infer Params> ? Params : never;
 
 
 
@@ -17,56 +25,95 @@ import { A_Errors } from "src/containers/A-Errors/A-Errors.namespace";
  * 
  * 
  */
-export class A_Concept {
-
+export class A_Concept<
+    _Features extends A_Container<any>[] = any
+> {
 
+    // ==============================================================================
+    // ====================  STATIC LIFECYCLE DECORATORS  ===========================
+    // ==============================================================================
     /**
-     * Context is a root namespace for the concept.
+     * Load the concept. This step runs before any other steps to ensure that all components are loaded.
      */
-    Context!: typeof A_Context;
+    static get Load() {
+        return A_Stage(A_TYPES__ConceptStage.Load);
+    }
 
     /**
-     * Context provider is a singleton that provides the context for ALL concepts.
+     * Publish the concept to ADAAS platform. (Or any other place defined in the concept)
+     *
+     * [!] To extend the logic just create a custom containers and override the default behavior.
      */
+    static get Publish() {
+        return A_Stage(A_TYPES__ConceptStage.Publish);
+    }
 
-    protected props!: A_TYPES__IConceptConstructor;
-
-    constructor(
-        props: A_TYPES__IConceptConstructor
-    ) {
-        this.props = props;
-
-        this.Context = A_Context;
+    /**
+     * Deploy the concept to the environment.
+     */
+    static get Deploy() {
+        return A_Stage(A_TYPES__ConceptStage.Deploy);
     }
 
+    /**
+     * Compiles the Concept in case there are some containers that require that. 
+     * 
+     * Can be used for static websites or any other concept that requires a build step.
+     * 
+     */
+    static get Build() {
+        return A_Stage(A_TYPES__ConceptStage.Build);
+    }
 
-    get namespace() {
-        return this.Context.root
+    /**
+     *  Main execution of the concept.
+     */
+    static get Run() {
+        return A_Stage(A_TYPES__ConceptStage.Run);
     }
 
+    /**
+     *  Start the concept. Uses for servers or any other background services.
+     */
+    static get Start() {
+        return A_Stage(A_TYPES__ConceptStage.Start);
+    }
 
     /**
-     * Returns true if the class has inherited from the given class.
-     * 
-     * @param cl 
-     * @returns 
+     * Stop the concept. Uses for servers or any other background services.
      */
-    private hasInherited(cl: { new(...args: any[]) }): boolean {
-        return this.constructor === cl
-            ? false
-            : true
+    static get Stop() {
+        return A_Stage(A_TYPES__ConceptStage.Stop);
     }
 
 
 
+    // ==============================================================================
+    // ==========================  MAIN Class  ======================================
+    // ==============================================================================
 
-    protected async init() {
-        // await this.Context.init();
+    protected containers: A_Container<any>[] = [];
 
-        // await this.DM.init();
+    constructor(
+        protected props: A_TYPES__IConceptConstructor<_Features>
+    ) {
+        A_Context.allocate(this, {
+            name: props.name,
+            fragments: props.fragments || [],
+            // containers: props.containers
+            components: [
+                A_Logger,
+            ]
+        });
+
+        this.containers = props.containers || [];
     }
 
 
+    get namespace() {
+        return A_Context.scope(this).name;
+    }
+
 
     // =======================================================================
     // ==========================  LIFECYCLE  ================================
@@ -76,35 +123,18 @@ export class A_Concept {
      * Run the concept.
      */
     async run(
-        params: A_TYPES__A_CONCEPT_RootRunParams = {}
+        params?: Partial<A_TYPES__ConceptStageParams>
     ) {
 
-        //  to prevent modification of the method parameters use the A_Context directly without decorators 
-        const [
-            Errors
-        ] = this.Context.resolve([A_Errors]);
-
-        if (this.hasInherited(A_Concept))
-            Errors.throw('[root.run] method can not be overridden in the inherited classes');
-
-
-        // const allRunDeclarations = A_CONCEPT_LifecycleDeclarationsStorage
-        //     .get(A_CONCEPT_STORAGE__DECORATORS_RUN_DECLARATIONS);
     }
 
 
     /**
      * Build the concept.
      */
-    async build() {
-        //  to prevent modification of the method parameters use the A_Context directly without decorators 
-        const [
-            Errors
-        ] = this.Context.resolve([A_Errors]);
-
-
-        if (this.hasInherited(A_Concept))
-            Errors.throw('[root.build] method can not be overridden in the inherited classes');
+    async build(
+        params?: Partial<A_TYPES__ConceptStageParams>
+    ) {
 
     }
 
@@ -112,32 +142,96 @@ export class A_Concept {
     // /**
     //  * Deploy the concept.
     //  */
-    // async deploy() {
-    //     if (this.hasInherited(A_Concept))
-    //         this.Context.Errors.throw('[root.deploy] method can not be overridden in the inherited classes');
-    // }
+    async deploy(
+        params?: Partial<A_TYPES__ConceptStageParams>
+    ) {
+
+    }
 
 
     // /**
     //  * Publish the concept.
     //  */
-    // async publish() {
-    //     if (this.hasInherited(A_Concept))
-    //         this.Context.Errors.throw('[root.publish] method can not be overridden in the inherited classes');
-    // }
+    async publish(
+        params?: Partial<A_TYPES__ConceptStageParams>
+    ) {
+
+    }
 
 
     /**
      * Call the specific method of the concept or included modules.
      */
-    async call() {
-        //  to prevent modification of the method parameters use the A_Context directly without decorators 
-        const [
-            Errors
-        ] = this.Context.resolve([A_Errors]);
+    async call<
+        K extends Record<_Features[number]['name'], _Features[number]['exports'][number]>
+    >(
+        container: K[keyof K],
+        params?: A_Fragment[]
+    ) {
+        // for (const feature of this.features) {
+        //     if (methodName in feature) {
+        //         (feature as any)[methodName](...args);
+        //     }
 
-        // if (this.hasInherited(A_Concept))
-        //     this.Context.Errors.throw('[root.call] method can not be overridden in the inherited classes');
+        // }
     }
 
-}
+
+    private async runStage(
+        method: A_TYPES__ConceptStage,
+        params: Partial<A_TYPES__ConceptStageParams>
+    ) {
+
+        const stages: any[] = [];
+
+        this.containers.map(container => {
+            const meta = A_Context.meta(container);
+
+            const containerStages = meta.get(A_TYPES__ContainerMetaKey.STAGES)
+
+
+            if (containerStages) {
+                for (const [name, stage] of containerStages) {
+                    if (stage.name === method) {
+                        stages.push({
+                            name,
+                            container,
+                        });
+                    }
+                }
+
+            }
+        });
+
+        const scope = A_Context.allocate(this, {
+            components: params.components,
+            fragments: params.fragments,
+            parent: A_Context.scope(this)
+        });
+
+        for (const stage of stages) {
+            await stage.container[stage.name](params);
+        }
+
+    }
+
+
+    private async execute(
+        params: Partial<A_TYPES__ConceptStageParams>
+    ) {
+        const fragments = params.fragments || [];
+        const component = params.components || [];
+
+
+        this.containers.map(container => {
+            const meta = A_Context.meta(container);
+
+            meta.get(A_TYPES__ContainerMetaKey.FEATURES)
+
+        });
+
+
+    }
+
+}
+

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

@@ -0,0 +1,9 @@
+import { A_Meta } from "../A-Meta/A-Meta.class";
+// import { A_TYPES__ComponentMeta } from "./A-Component.types";
+
+
+export class A_ConceptMeta extends A_Meta<any> {
+
+
+
+}

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

@@ -1,32 +1,60 @@
-import { A_Concept } from "./A_Concept.class";
-import { A_Namespace } from "../A-Namespace/A_Namespace.class";
 import { A_Container } from "../A-Container/A-Container.class";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 
 
-export interface A_TYPES__IConceptConstructor {
+export enum A_TYPES__ConceptStage {
+    Run = 'run',
+    Build = 'build',
+    Publish = 'publish',
+    Deploy = 'deploy',
+    Load = 'load',
+    Start = 'start',
+    Stop = 'stop',
+}
+
+
+// export type A_TYPES__ConceptMeta = {
+//     [A_TYPES__ConceptMetaKey.EXTENSIONS]: Map<string, A_TYPES__ConceptMeta_ExtensionItem>,
+//     [A_TYPES__ConceptMetaKey.FEATURES]: any[],
+//     // [A_TYPES__ConceptMetaKey.INJECTIONS]: Map<
+//     //     // Where key is method name
+//     //     Symbol | string,
+//     //     // And value is Injection instructions
+//     //     A_TYPES__ConceptMeta_InjectionParams
+//     // >
+
+// }
+
+export enum A_TYPES__ConceptMetaKey {
+    LIFECYCLE = 'a-component-extensions',
+}
+
+
+export interface A_TYPES__IConceptConstructor<
+    T extends Array<A_Container<any>>
+> {
     name: string,
-    description?: string,
 
     /**
-     * A set of Namespaces that the concept depends on. 
-     * These namespaces will create a new Context for the concept.
+     * A set of Context Fragments to register globally for the concept.
+     * These fragments will be available in the global context.
      * 
      */
-    context?: Array<A_Namespace>,
+    fragments?: Array<A_Fragment>,
 
 
     /**
      * A set of Containers that the concept depends on. 
      * These containers will create a new Container for the concept.
      */
-    containers?: Array<{ new(...args: any[]): A_Container }>,
+    containers?: T,
 
 
     /**
      * A set of external Concepts that can be used in the current Concept. 
      * To provide additional functionality or extend the current Concept.
      */
-    import?: Array<A_Concept>
+    // import?: Array<A_Concept>
 }
 
 
@@ -38,7 +66,14 @@ export interface A_TYPES__IConceptConstructor {
 // =======================================================================
 // =======================================================================
 
-export type A_TYPES__A_CONCEPT_RootRunParams = {
+export type A_TYPES__ConceptStageParams = {
+    fragments: Array<A_Fragment>,
+    components: Array<{ new(...args: any[]): any }>
+}
 
 
+export type A_TYPES__ConceptCallParams<T extends string> = {
+    name: T,
+    fragments: Array<A_Fragment>,
+    components: Array<{ new(...args: any[]): any }>
 }

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

@@ -1,39 +1,194 @@
-import { A_Namespace } from "../A-Namespace/A_Namespace.class";
+import { A_TYPES__ContainerCallParams, A_TYPES__ContainerConstructor } from "./A-Container.types";
+import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_TYPES__Required } from "@adaas/a-utils";
+import { A_Feature } from "../A-Feature/A-Feature.class";
+import { A_CONTAINER_Storage, A_CONTAINER_STORAGE__Definition__Lifecycle } from "@adaas/a-concept/storage/A_Container.storage";
+import { A_COMPONENT_Storage } from "@adaas/a-concept/storage/A_Component.storage";
+import { A_TYPES__FeatureStep } from "../A-Feature/A-Feature.types";
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 
 
 
 /**
- * This class should combine Components to achieve the goal withing Context 
- * Container could be interpreted as any Structure Entity, or Abstract Entity
- * For example:
- * - Controller (all Controllers with base logic)
- * - Service (all Services with base logic)
- * - Module (all Modules with base logic)
+ * This class should combine Components to achieve the goal withing Concept
+ * 
+ * Container is a direct container that should be "run" to make Concept work. 
+ * So because of that Container can be:
+ * - HTTP Server
+ * - BASH Script
+ * - Database Connection
+ * - Microservice
  * - etc.
  */
-export class A_Container<T extends A_Namespace = A_Namespace> {
+export class A_Container<
+    _FeatureNames extends Array<string>
+> {
+    // scope!: A_Scope
 
-    protected readonly namespace!: T;
+    protected readonly config!: Partial<A_TYPES__ContainerConstructor<_FeatureNames>>;
+
+    /**
+     * Promise that will be resolved when the container is ready to be used.
+     */
+    ready!: Promise<void>;
+
+    get exports(): _FeatureNames {
+        return this.config.exports || [] as any;
+    }
+
+    get name() {
+        return this.config.name || this.constructor.name;
+    }
 
 
     constructor(
-        namespace?: T
+        /**
+         * Configuration of the container that will be used to run it.
+         */
+        config: Partial<A_TYPES__ContainerConstructor<_FeatureNames>>
     ) {
-        if (namespace) {
-            this.namespace = namespace;
+        this.config = config;
+
+        const components = config.components || [];
+        const fragments = config.fragments || [];
+
+        A_Context.allocate(this, {
+            components,
+            fragments
+        });
+
+        /**
+         * Run Async Initialization
+         */
+        this.init();
+    }
+
+
+    protected hasInherited(cl: { new(...args: any[]) }): boolean {
+        return this.constructor === cl
+            ? false
+            : true
+    }
+
+
+    /**
+     * Initializes the Namespace or can be used to reinitialize the Namespace
+     */
+    private async init() {
+        if (!this.ready)
+            this.ready = new Promise(async (resolve, reject) => {
+                try {
+                    await this.onBeforeInit();
+
+                    await this.onInit();
+
+                    await this.onAfterInit();
+
+
+                    return resolve();
+                } catch (error) {
+                    return reject(error);
+                }
+            });
+        else
+            await this.ready;
+    }
+
+
+
+
+
+    /**
+     * This method allows to call the lifecycle method of the container as well as any other Feature defined for it
+     * 
+     * @param lifecycleMethod 
+     * @param args 
+     */
+    call(
+        /**
+         * A-Feature method name to be called
+         */
+        feature: _FeatureNames[number],
+    ): A_Feature
+    call(
+        /**
+         * A-Feature name to be called
+         */
+        params: A_TYPES__Required<Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>>, ['name']>,
+    ): A_Feature
+
+    call(
+        /**
+        * A-Feature method name to be called
+        */
+        feature: _FeatureNames[number],
+        /**
+         * Parameters to provide additional data to the feature
+         */
+        params: Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>>,
+    ): A_Feature
+
+    call(
+        param1: _FeatureNames[number] | A_TYPES__Required<Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>>, ['name']>,
+        param2?: Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>>
+    ): A_Feature {
+
+        let feature: string;
+        let params: Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>>;
+
+        if (typeof param1 === 'string') {
+            feature = param1;
+            params = param2 || {};
+        } else {
+            feature = param1.name;
+            params = param1;
         }
+
+        const meta = A_Context.meta(this);
+
+        const steps = meta.feature(this, feature);
+
+        const newFeature = new A_Feature({
+            name: `${this.constructor.name}.${feature}`,
+            fragments: param2?.fragments || [],
+            components: param2?.components || [],
+            steps,
+            parent: A_Context.scope(this)
+        });
+
+        return newFeature;
     }
 
 
-    // bind(
-    //     Context: T,
-    //     /**
-    //      * Context provider from parent Concept
-    //      * It's possible to use the same ContextProvider for all Containers
-    //      */
-    //     ContextProvider: A_ContextProvider
-    // ) {
-    //     this.Context = Context;
-    // }
+
+    // ==============================================================
+    // ======================= HOOKS ================================
+    // ==============================================================
+
+    /**
+     *  Before init hook to be used in inherited classes
+     * 
+     * @returns 
+     */
+    protected async onBeforeInit() {
+        return;
+    }
+
+    /**
+     * Main initialization method for the Container
+     */
+    protected async onInit() {
+        return;
+    }
+
+    /**
+     *  After init hook to be used in inherited classes
+     * 
+     * @returns 
+     */
+    protected async onAfterInit() {
+        return;
+    }
 
 }

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

@@ -0,0 +1,80 @@
+import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_TYPES__FeatureStep } from "../A-Feature/A-Feature.types";
+import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_Container } from "./A-Container.class";
+import {
+    A_TYPES__ContainerMeta,
+    A_TYPES__ContainerMetaKey
+} from "./A-Container.types";
+
+
+
+export class A_ContainerMeta extends A_Meta<A_TYPES__ContainerMeta> {
+
+
+    feature<T extends string>(
+        container: A_Container<any>,
+        name: T,
+        // params:
+    ) {
+        const scope = A_Context.scope(container);
+
+        // First lets validate that there'are registered method with the same name
+        const featureMeta = this.get(A_TYPES__ContainerMetaKey.FEATURES);
+
+        if (!featureMeta) {
+            throw new Error(`Container ${container.constructor.name} has no metadata defined`);
+        }
+
+        const instruction = featureMeta.get(name);
+
+        if (!instruction)
+            throw new Error(`Method ${name} is not defined in ${this.constructor.name}`);
+
+        // const scope = new A_Scope({
+        //     name: `${this.constructor.name}.${feature}`,
+        //     fragments: param2?.fragments || [],
+        //     components: param2?.components || []
+        // }, {
+        //     parent: this.scope
+        // });
+
+
+        // Now we need to resolve the method from all registered components 
+        return scope
+            .components
+            .reduce((
+                acc, component
+            ) => {
+                const componentMeta = A_Context.meta(component);
+
+                const extensions = componentMeta.get(A_TYPES__ComponentMetaKey.EXTENSIONS) || [];
+                const injections = componentMeta.get(A_TYPES__ComponentMetaKey.INJECTIONS);
+
+                const out: A_TYPES__FeatureStep[] = [];
+
+                extensions.forEach((extension, handler) => {
+                    if (
+                        extension.name === name
+                        &&
+                        (extension.container === container.constructor.name || extension.container === '*')
+                    ) {
+                        const args = injections?.get(handler) || [];
+
+                        out.push({
+                            component,
+                            handler,
+                            args
+                        });
+                    }
+                });
+
+                return [
+                    ...acc,
+                    ...out
+                ];
+
+            }, [] as A_TYPES__FeatureStep[])
+    }
+}