@adaas/a-concept 0.0.4 → 0.0.6

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

@@ -1,7 +1,7 @@
 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_Container } from "../A-Container/A-Container.class";
-import { A_Logger } from "@adaas/a-concept/base/A-Logger/A-Logger.component";
+// 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";
@@ -102,7 +102,7 @@ export class A_Concept<
             fragments: props.fragments || [],
             // containers: props.containers
             components: [
-                A_Logger,
+                // A_Logger,
             ]
         });
 

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

@@ -1,12 +1,8 @@
 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";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 
@@ -41,6 +37,10 @@ export class A_Container<
         return this.config.name || this.constructor.name;
     }
 
+    get Scope(): A_Scope {
+        return A_Context.scope(this);
+    }
+
 
     constructor(
         /**
@@ -53,10 +53,7 @@ export class A_Container<
         const components = config.components || [];
         const fragments = config.fragments || [];
 
-        A_Context.allocate(this, {
-            components,
-            fragments
-        });
+        A_Context.allocate(this, config);
 
         /**
          * Run Async Initialization
@@ -105,20 +102,20 @@ export class A_Container<
      * @param lifecycleMethod 
      * @param args 
      */
-    call(
+    async call(
         /**
          * A-Feature method name to be called
          */
         feature: _FeatureNames[number],
-    ): A_Feature
-    call(
+    ): Promise<any>
+    async call(
         /**
          * A-Feature name to be called
          */
         params: A_TYPES__Required<Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>>, ['name']>,
-    ): A_Feature
+    ): Promise<any>
 
-    call(
+    async call(
         /**
         * A-Feature method name to be called
         */
@@ -127,37 +124,23 @@ export class A_Container<
          * Parameters to provide additional data to the feature
          */
         params: Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>>,
-    ): A_Feature
+    ): Promise<any>
 
-    call(
+    async 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);
+    ): Promise<any> {
 
-        const steps = meta.feature(this, feature);
+        const feature: string = typeof param1 === 'string'
+            ? param1
+            : param1.name;
+        const params: Partial<A_TYPES__ContainerCallParams<_FeatureNames[number]>> = typeof param1 === 'string'
+            ? param2 || {}
+            : param1;
 
-        const newFeature = new A_Feature({
-            name: `${this.constructor.name}.${feature}`,
-            fragments: param2?.fragments || [],
-            components: param2?.components || [],
-            steps,
-            parent: A_Context.scope(this)
-        });
+        const newFeature = A_Context.feature(this, feature, params);
 
-        return newFeature;
+        return await newFeature.process();
     }
 
 

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

@@ -13,68 +13,4 @@ import {
 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[])
-    }
 }

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

@@ -1,4 +1,4 @@
-import { A_CommonHelper, A_Polyfills, A_TYPES__Dictionary } from "@adaas/a-utils";
+import { A_CommonHelper, A_Polyfills } from "@adaas/a-utils";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Feature } from "../A-Feature/A-Feature.class";
@@ -9,6 +9,10 @@ import { A_Meta } from "../A-Meta/A-Meta.class";
 import { A_ComponentMeta } from "../A-Component/A-Component.meta";
 import { A_ContainerMeta } from "../A-Container/A-Container.meta";
 import { A_Concept } from "../A-Concept/A_Concept.class";
+import { A_TYPES__EntityBaseMethod } from "../A-Entity/A-Entity.types";
+import { A_Entity } from "../A-Entity/A-Entity.class";
+import { A_EntityMeta } from "../A-Entity/A-Entity.meta";
+import { A_TYPES__FeatureStep } from "../A-Feature/A-Feature.types";
 
 
 /**
@@ -38,6 +42,21 @@ export class A_Context {
     protected concepts: WeakMap<A_Concept<any>, A_Scope> = new WeakMap();
 
 
+    /**
+     * Uses to store the scope of every element in the program. 
+     */
+    protected registry: WeakMap<
+        A_Concept<any> |
+        A_Container<any> |
+        A_Feature |
+        A_Component |
+        A_Fragment |
+        A_Entity,
+        A_Scope
+    > = new WeakMap();
+
+
+
 
     /**
      * A set of allocated scopes per every element in the program.
@@ -46,7 +65,11 @@ export class A_Context {
 
     protected conceptsMeta: Map<typeof A_Concept.constructor, A_Meta<any>> = new Map();
     protected containersMeta: Map<typeof A_Container.constructor, A_ContainerMeta> = new Map();
-    protected componentsMeta: Map<typeof A_Container.constructor, A_ComponentMeta> = new Map();
+    protected componentsMeta: Map<typeof A_Component, A_ComponentMeta> = new Map();
+    protected entitiesMeta: Map<typeof A_Entity.constructor, A_EntityMeta> = new Map();
+
+    // uses to allow to store custom meta data
+    protected customMeta: Map<typeof A_Container.constructor, A_Meta<any>> = new Map();
 
 
     /**
@@ -141,6 +164,9 @@ export class A_Context {
     static meta(
         container: A_Container<any>,
     ): A_ContainerMeta
+    static meta(
+        entity: A_Entity,
+    ): A_ContainerMeta
     static meta(
         component: typeof A_Component,
     ): A_ComponentMeta
@@ -151,14 +177,13 @@ export class A_Context {
         component: { new(...args: any[]): any },
     ): A_Meta<T>
     static meta<T extends Record<string, any>>(
-        param1: typeof A_Container | A_Container<any> | { new(...args: any[]): any } | A_Component | typeof A_Component,
+        param1: typeof A_Container | A_Container<any> | { new(...args: any[]): any } | A_Component | typeof A_Component | typeof A_Entity | A_Entity
     ): A_ContainerMeta | A_ComponentMeta | A_Meta<T> {
         const instance = this.getInstance();
 
         let metaStorage: WeakMap<typeof A_Container.constructor, A_Meta<any>>;
         let property: Function;
-
-        let meta: A_Meta<any>;
+        let metaType: typeof A_Meta<T> | typeof A_ContainerMeta | typeof A_ComponentMeta | typeof A_EntityMeta
 
 
         switch (true) {
@@ -166,14 +191,7 @@ export class A_Context {
 
                 metaStorage = instance.containersMeta;
                 property = param1.constructor;
-
-
-                if (!metaStorage.has(property)) {
-                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ContainerMeta();
-                    metaStorage.set(property, new A_ContainerMeta().from(inheritMeta));
-                }
-
-                meta = metaStorage.get(property)!;
+                metaType = A_ContainerMeta;
 
                 break;
             }
@@ -181,13 +199,7 @@ export class A_Context {
             case A_CommonHelper.isInheritedFrom(param1, A_Container): {
                 metaStorage = instance.containersMeta;
                 property = param1 as typeof A_Container<any>;
-
-                if (!metaStorage.has(property)) {
-                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ContainerMeta();
-                    metaStorage.set(property, new A_ContainerMeta().from(inheritMeta));
-                }
-
-                meta = metaStorage.get(property)!;
+                metaType = A_ContainerMeta;
 
                 break;
             }
@@ -195,14 +207,7 @@ export class A_Context {
             case param1 instanceof A_Component: {
                 metaStorage = instance.componentsMeta;
                 property = param1.constructor;
-
-
-                if (!metaStorage.has(property)) {
-                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ComponentMeta();
-                    metaStorage.set(property, new A_ComponentMeta().from(inheritMeta));
-                }
-
-                meta = metaStorage.get(property)!;
+                metaType = A_ComponentMeta;
 
                 break;
             }
@@ -210,55 +215,63 @@ export class A_Context {
             case A_CommonHelper.isInheritedFrom(param1, A_Component): {
                 metaStorage = instance.componentsMeta;
                 property = param1 as typeof A_Component;
+                metaType = A_ComponentMeta;
 
+                break;
+            }
 
-                if (!metaStorage.has(property)) {
-                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ComponentMeta();
-                    metaStorage.set(property, new A_ComponentMeta().from(inheritMeta));
-                }
+            case param1 instanceof A_Entity: {
+                metaStorage = instance.entitiesMeta;
+                property = param1.constructor;
+                metaType = A_ComponentMeta;
 
-                meta = metaStorage.get(property)!;
+                break;
+            }
 
+            case A_CommonHelper.isInheritedFrom(param1, A_Entity): {
+                metaStorage = instance.entitiesMeta;
+                property = param1 as typeof A_Entity;
+                metaType = A_EntityMeta;
                 break;
             }
 
+
             default: {
-                metaStorage = instance.componentsMeta;
+                metaStorage = instance.customMeta;
                 property = typeof (param1 as any) === 'function' ? param1 : param1.constructor;
-
-                if (!metaStorage.has(property)) {
-                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_Meta();
-                    metaStorage.set(property, new A_Meta().from(inheritMeta));
-                }
-
-                meta = metaStorage.get(property)!;
+                metaType = A_Meta;
 
                 break;
             }
         }
 
-        // const inheritMeta: T = metaStorage.get(Object.getPrototypeOf(property))  || new A_Meta() as T;
-        // // we just know that the type of parent meta is the same as the type of the current meta
-        // const meta = metaStorage.get(property);
+        if (!metaStorage.has(property)) {
+            const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new metaType();
+            metaStorage.set(property, new metaType().from(inheritMeta as any));
+        }
 
-        return meta!;
+        return metaStorage.get(property)!;
     }
 
 
 
-
-
+    static scope(
+        entity: A_Entity
+    ): A_Scope
+    static scope(
+        component: A_Component
+    ): A_Scope
     static scope(
         concept: A_Concept
     ): A_Scope
     static scope(
-        component: A_Container<any>
+        container: A_Container<any>
     ): A_Scope
     static scope(
-        component: A_Feature
+        feature: A_Feature
     ): A_Scope
     static scope(
-        param1: A_Feature | A_Container<any> | A_Concept
+        param1: A_Feature | A_Container<any> | A_Concept | A_Component<any> | A_Entity
     ): A_Scope | undefined {
 
         const instance = this.getInstance();
@@ -270,62 +283,209 @@ export class A_Context {
             case param1 instanceof A_Feature:
                 return instance.features.get(param1);
 
-
             case param1 instanceof A_Concept:
                 return instance.concepts.get(param1);
 
+            case param1 instanceof A_Entity:
+                return instance.registry.get(param1);
+
+            case param1 instanceof A_Component:
+                return instance.registry.get(param1);
+
+            case param1 instanceof A_Fragment:
+                return instance.registry.get(param1);
+
             default:
                 throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
         }
     }
 
 
+    /**
+     * This method returns a component by its meta.
+     * 
+     * @param meta 
+     * @returns 
+     */
+    static component(
+        meta: A_ComponentMeta
+    ): typeof A_Component {
+        const instance = this.getInstance();
+
+        let component: typeof A_Component | undefined;
+
+        instance.componentsMeta.forEach((meta, constructor) => {
+            if (meta === meta) {
+                component = constructor;
+            }
+        });
+
+        if (!component) {
+            throw new Error(`[!] A-Concept Context: Component not found.`);
+        }
+        return component;
+    }
+
+
+
+    /**
+     * This method returns a step-by-step instructions of feature implementation depending on the feature name and the class.
+     * 
+     * @param scope 
+     * @returns 
+     */
+    static feature<T extends Array<string>>(
+        entity: A_Entity<any, any, T>,
+        feature: A_TYPES__EntityBaseMethod | string | T[number] | RegExp,
+        params?: Partial<A_TYPES__ScopeConstructor>
+    ): A_Feature
+    static feature<T extends Array<string>>(
+        container: A_Container<T>,
+        feature: T[number],
+        params?: Partial<A_TYPES__ScopeConstructor>
+    ): A_Feature
+    static feature(
+        component: A_Component,
+        feature: string,
+        params?: Partial<A_TYPES__ScopeConstructor>
+    ): A_Feature
+    static feature<T extends Array<string>>(
+        param1: A_Component<T> | A_Container<T> | A_Entity<any, any, T>,
+        param2: string | T[number],
+        param3?: Partial<A_TYPES__ScopeConstructor>
+    ): A_Feature {
+
+
+        const instance = this.getInstance();
+
+        const component = param1;
+        const feature: string = param2;
+        const config = param3 || {};
+        // TODO:  have no idea why it's not working because of that "any"
+        const scope = this.scope(component as any);
+        const steps: A_TYPES__FeatureStep[] = [];
+
+        // Now we need to resolve the method from all registered components 
+
+        // We need to get all components that has extensions for the feature in component
+        instance.componentsMeta
+            .forEach((meta, constructor) => {
+                try {
+                    // Just try to make sure that component not only Indexed but also presented in scope
+                    scope.resolve(constructor);
+
+                    // Get all extensions for the feature
+                    meta
+                        .extensions(feature)
+                        .forEach(({ handler, args }) => {
+                            steps.push({
+                                component: constructor,
+                                handler,
+                                args
+                            });
+                        });
+
+                } catch (error) {
+                    // do nothing
+                }
+            });
+
+        const newFeature = new A_Feature({
+            name: `${component.constructor.name}.${feature}`,
+            fragments: config.fragments,
+            components: config.components,
+            steps,
+            parent: component instanceof A_Container ? this.scope(component) : undefined
+        });
+
+        return newFeature;
+    }
+
+
 
     /**
      * Register a Namespace in the provider.
      * @param Namespace 
      */
-    static register(Namespace: A_Fragment): string
     static register(
-        Namespace: A_Fragment,
-        namespace?: string
-    ): string
+        scope: A_Scope,
+        container: A_Container<any>
+    )
+    static register(
+        scope: A_Scope,
+        entity: A_Entity
+    )
+    static register(
+        scope: A_Scope,
+        component: A_Component
+    )
+    static register(
+        scope: A_Scope,
+        fragment: A_Fragment
+    )
     static register(
-        param1: A_Fragment,
-        param2?: A_Fragment | string,
-    ): string {
+        scope: A_Scope,
+        param1: A_Fragment | A_Container<any> | A_Entity | A_Component,
+    ) {
 
         const instance = this.getInstance();
 
-        let fragment: A_Fragment;
-        let name: string;
+        switch (true) {
+            case param1 instanceof A_Component:
+                instance.registry.set(param1, scope);
+                break;
+
+            case param1 instanceof A_Container:
+                instance.registry.set(param1, scope);
+                break;
+
+            case param1 instanceof A_Entity:
+                instance.registry.set(param1, scope);
+                break;
+
+            case param1 instanceof A_Fragment:
+                instance.registry.set(param1, scope);
+                break;
+
+            default:
+                instance.registry.set(param1, scope);
 
-        if (typeof param2 === 'string') {
-            name = param2;
-            fragment = param1;
-        } else {
-            fragment = param1 as A_Fragment;
-            name = fragment.name;
         }
 
-        /**
-         * If the namespace is not provided, then use the root namespace.
-         * If the root namespace is not provided, then use the default namespace.
-         */
-        if (!name)
-            name = this.root
-                || process.env.ADAAS_NAMESPACE
-                || process.env.A_NAMESPACE
-                || process.env.ADAAS_APP_NAMESPACE
-                || 'a-concept'
+
+        // if (param1 instanceof A_Fragment) {
+
+        //     const instance = this.getInstance();
+
+        //     let fragment: A_Fragment;
+        //     let name: string;
+
+        //     if (typeof param2 === 'string') {
+        //         name = param2;
+        //         fragment = param1;
+        //     } else {
+        //         fragment = param1 as A_Fragment;
+        //         name = fragment.name;
+        //     }
+
+        //     /**
+        //      * If the namespace is not provided, then use the root namespace.
+        //      * If the root namespace is not provided, then use the default namespace.
+        //      */
+        //     if (!name)
+        //         name = this.root
+        //             || process.env.ADAAS_NAMESPACE
+        //             || process.env.A_NAMESPACE
+        //             || process.env.ADAAS_APP_NAMESPACE
+        //             || 'a-concept'
 
 
+        //     if (!this.root)
+        //         instance._root = name;
 
-        if (!this.root)
-            instance._root = name;
+        //     // instance.namedFragments.set(namespace, Namespace);
 
-        // instance.namedFragments.set(namespace, Namespace);
+        //     return name;
 
-        return name;
     }
 }

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

@@ -1,15 +0,0 @@
-import { A_Scope } from "../A-Scope/A-Scope.class"
-
-
-
-export type A_TYPES__ContextExecutionPipeline = {
-    scope: A_Scope
-    steps: A_TYPES__ContextExecutionPipelineStep[]
-}
-
-
-export type A_TYPES__ContextExecutionPipelineStep = {
-    component: { new(...args: any[]): any },
-    handler: string,
-    args: any[]
-}