@adaas/a-concept 0.0.5 → 0.0.7

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,9 @@ 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();
 
@@ -143,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
@@ -153,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) {
@@ -168,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;
             }
@@ -183,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;
             }
@@ -197,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;
             }
@@ -212,55 +215,66 @@ 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.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(
+        feature: A_Fragment
     ): 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_Fragment
     ): A_Scope | undefined {
 
         const instance = this.getInstance();
@@ -272,62 +286,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[]
-}

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

@@ -1,8 +1,17 @@
-import { A_Error, ASEID } from "@adaas/a-utils";
-
+import {
+    A_Error, A_TYPES__Required,
+    ASEID
+} from "@adaas/a-utils";
+import {
+    A_TYPES__Entity_JSON,
+    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_TYPES__Entity_JSON, A_TYPES__IEntity } from "./A-Entity.types";
-import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_Context } from "../A-Context/A-Context.class";
+
+
 
 /**
  * A_Entity is another abstraction that describes all major participants in the system business logic.
@@ -14,8 +23,8 @@ 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__EntityBaseMethods
 >
-    extends A_Fragment
     implements A_TYPES__IEntity {
 
     aseid!: ASEID;
@@ -34,7 +43,6 @@ export class A_Entity<
         newEntity: _ConstructorType
     )
     constructor(props: string | ASEID | _SerializedType | _ConstructorType) {
-        super();
 
         switch (true) {
             case (typeof props === 'string' && ASEID.isASEID(props)):
@@ -54,7 +62,6 @@ export class A_Entity<
             default:
                 throw new A_Error(A_CONSTANTS__DEFAULT_ERRORS.INCORRECT_A_ENTITY_CONSTRUCTOR);
         }
-
     }
 
     // ====================================================================
@@ -111,6 +118,55 @@ export class A_Entity<
     }
 
 
+    /**
+     * Call a feature of the component
+     * 
+     * @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: string,
+        /**
+         * 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;
+
+        const newFeature = A_Context.feature(this, feature, params);
+
+        return await newFeature.process();
+    }
+
+
+
+
     protected fromNewEntity(newEntity: _ConstructorType): void {
         return;
     }
@@ -121,6 +177,7 @@ export class A_Entity<
     }
 
 
+
     /**
      * Converts the entity to a JSON object 
      * 
@@ -138,4 +195,4 @@ export class A_Entity<
     toString(): string {
         return this.aseid.toString();
     }
-}
+}

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

@@ -0,0 +1,9 @@
+import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_TYPES__EntityMeta } from "./A-Entity.types";
+
+
+export class A_EntityMeta extends A_Meta<A_TYPES__EntityMeta> {
+
+
+
+}

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

@@ -1,4 +1,28 @@
 import { ASEID } from "@adaas/a-utils";
+import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+
+
+export type A_TYPES__EntityCallParams<T extends string> = {
+    name: T,
+    fragments: Array<A_Fragment>,
+    components: Array<{ new(...args: any[]): any }>
+}
+
+
+export type A_TYPES__EntityBaseMethods = [
+    A_TYPES__EntityBaseMethod.SAVE,
+    A_TYPES__EntityBaseMethod.UPDATE,
+    A_TYPES__EntityBaseMethod.DESTROY,
+    A_TYPES__EntityBaseMethod.LOAD
+]
+
+export enum A_TYPES__EntityBaseMethod {
+    SAVE = 'save',
+    UPDATE = 'update',
+    DESTROY = 'destroy',
+    LOAD = 'load'
+}
 
 export interface A_TYPES__IEntity {
     /**
@@ -15,3 +39,37 @@ export type A_TYPES__Entity_JSON = {
     aseid: string
 };
 
+
+
+
+
+export type A_TYPES__EntityMeta = {
+    [A_TYPES__EntityMetaKey.EXTENSIONS]: A_Meta<{
+
+        /**
+         * Where Key the regexp for what to apply the extension
+         * A set of container names or a wildcard, or a regexp
+         * 
+         *
+         * Where value is the extension instructions
+         */
+        [Key: string]: A_TYPES__EntityMeta_ExtensionItem[]
+
+    }>, case
+
+
+    [A_TYPES__EntityMetaKey.FEATURES]: any[],
+}
+
+export enum A_TYPES__EntityMetaKey {
+    EXTENSIONS = 'a-component-extensions',
+    FEATURES = 'a-component-features',
+}
+
+
+export type A_TYPES__EntityMeta_ExtensionItem = {
+    name: string,
+    handler: string,
+}
+
+