@adaas/a-concept 0.0.5 → 0.0.7

package/src/decorators/A-Feature/A-Feature-Extend.decorator.ts

@@ -5,6 +5,9 @@ import {
 } from "./A-Feature.decorator.types";
 import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.types";
 import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
 
 
 
@@ -31,27 +34,29 @@ export function A_Feature_Extend(
         descriptor: A_TYPES__A_ExtendDecoratorDescriptor
     ) {
 
+        const extensionName = config.name || propertyKey
+
         // Get the existed metadata or create a new one
         const existedMeta = A_Context
             .meta(target)
             .get(A_TYPES__ComponentMetaKey.EXTENSIONS)
-            || new Map();
+            || new A_Meta();
 
-        // Set the metadata of the method to define a custom Feature with name
-        existedMeta.set(propertyKey, {
-            name: config.name || propertyKey,
+
+        const existedMetaValue = existedMeta.get(extensionName) || [];
+
+        // Add the new method to the metadata
+        existedMetaValue.push({
+            name: extensionName,
             handler: propertyKey,
-            container: config.container
-                ? typeof config.container === 'string'
-                    ? config.container
-                    : config.container.name
-                : '*',
         });
 
+        // Set the metadata of the method to define a custom Feature with name
+        existedMeta.set(extensionName, existedMetaValue);
+
         //  Update the metadata of the container with the new Feature definition
         A_Context
             .meta(target)
             .set(A_TYPES__ComponentMetaKey.EXTENSIONS, existedMeta);
-
     };
 }

package/src/decorators/A-Inject/A-Inject.decorator.ts

@@ -1,10 +1,11 @@
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
-import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
-import { A_TYPES__A_InjectDecoratorReturn, A_TYPES__A_InjectDecoratorStorageInstruction } from "./A-Inject.decorator.types";
+import { A_TYPES__A_InjectDecoratorReturn } from "./A-Inject.decorator.types";
 import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
 import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.types";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
 
 
 
@@ -33,9 +34,9 @@ export function A_Inject(
 ): A_TYPES__A_InjectDecoratorReturn
 
 //  Allows to inject just one container
-export function A_Inject(
-    container: typeof A_Container
-): A_TYPES__A_InjectDecoratorReturn
+// export function A_Inject(
+//     container: typeof A_Container
+// ): A_TYPES__A_InjectDecoratorReturn
 
 // Allows to inject just one Context Fragment
 export function A_Inject(
@@ -50,10 +51,9 @@ export function A_Inject<
 ): A_TYPES__A_InjectDecoratorReturn
 
 // ====================== BASE FUNCTION ======================
-export function A_Inject<
-    T extends Array<typeof A_Fragment>
->(
-    param1: T | typeof A_Fragment | typeof A_Component | typeof A_Container | typeof A_Fragment,
+export function A_Inject(
+    param1: typeof A_Fragment | typeof A_Component | typeof A_Scope | typeof A_Feature,
+
 ): A_TYPES__A_InjectDecoratorReturn {
     return function (
         target: A_Component,
@@ -61,13 +61,15 @@ export function A_Inject<
         parameterIndex: number
     ) {
 
-        const method = methodName ? methodName : 'constructor';
+        const method = methodName ? String(methodName) : 'constructor';
 
+        console.log('target: ', target);
 
         const existedMeta = A_Context
             .meta(target)
             .get(A_TYPES__ComponentMetaKey.INJECTIONS)
-            || new Map();
+            || new A_Meta();
+
 
         const paramsArray = existedMeta.get(method) || [];
 

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

@@ -1,5 +1,60 @@
+import { A_TYPES__Required } from "@adaas/a-utils";
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_TYPES__ComponentCallParams } from "./A-Component.types";
+
 /**
  * This element only contains the specific code
  * 
  */
-export class A_Component { }
+export class A_Component<
+    _FeatureNames extends Array<string> = any,
+> {
+
+
+    /**
+     * 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__ComponentCallParams<_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__ComponentCallParams<_FeatureNames[number]>>,
+    ): Promise<any>
+
+    async call(
+        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(this, feature, params);
+
+        return await newFeature.process();
+    }
+}

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

@@ -1,9 +1,48 @@
 import { A_Meta } from "../A-Meta/A-Meta.class";
-import { A_TYPES__ComponentMeta } from "./A-Component.types";
+import { A_TYPES__ComponentMeta, A_TYPES__ComponentMetaExtension, A_TYPES__ComponentMetaKey } from "./A-Component.types";
 
 
 export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
 
 
 
+
+    /**
+     * Allows to get all the extensions for a given feature
+     * 
+     * @param feature 
+     * @returns 
+     */
+    extensions(
+        feature: string
+    ): A_TYPES__ComponentMetaExtension[] {
+        const steps: A_TYPES__ComponentMetaExtension[] = [];
+
+        const extensions = this.get(A_TYPES__ComponentMetaKey.EXTENSIONS);
+        const injections = this.get(A_TYPES__ComponentMetaKey.INJECTIONS);
+
+        // const constructor = A_Context.component(this);
+
+
+        extensions
+            // returns all extensions that match the feature
+            ?.find(feature)
+            .forEach(([handler, extensions]) => {
+                extensions.forEach(extension => {
+
+                    const args = injections?.get(extension.handler) || [];
+
+                    steps.push({
+                        // component: constructor,
+                        handler: extension.handler,
+                        args
+                    });
+
+                });
+            });
+
+
+        return steps;
+    }
+
 }

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

@@ -1,15 +1,42 @@
+import { A_Feature } from "../A-Feature/A-Feature.class"
+import { A_Fragment } from "../A-Fragment/A-Fragment.class"
+import { A_Meta } from "../A-Meta/A-Meta.class"
+import { A_Scope } from "../A-Scope/A-Scope.class"
+import { A_Component } from "./A-Component.class"
+
+
+export type A_TYPES__ComponentCallParams<T extends string> = {
+    name: T,
+    fragments: Array<A_Fragment>,
+    components: Array<{ new(...args: any[]): any }>
+}
 
 
 export type A_TYPES__ComponentMeta = {
-    [A_TYPES__ComponentMetaKey.EXTENSIONS]: Map<string, A_TYPES__ComponentMeta_ExtensionItem>,
+    [A_TYPES__ComponentMetaKey.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__ComponentMeta_ExtensionItem[]
+    }>,
+
+
     [A_TYPES__ComponentMetaKey.FEATURES]: any[],
-    [A_TYPES__ComponentMetaKey.INJECTIONS]: Map<
-        // Where key is method name
-        Symbol | string,
-        // And value is Injection instructions
-        A_TYPES__ComponentMeta_InjectionParams
-    >
 
+
+    [A_TYPES__ComponentMetaKey.INJECTIONS]: A_Meta<{
+        /**
+         * Where Key is the name of the injection
+         * 
+         * Where value is the list of injections
+         */
+        [Key: string]: Array<A_TYPES__ComponentMeta_InjectionParam>
+    }>
 }
 
 export enum A_TYPES__ComponentMetaKey {
@@ -18,23 +45,28 @@ export enum A_TYPES__ComponentMetaKey {
     INJECTIONS = 'a-component-injections',
 }
 
+export type A_TYPES__ComponentMetaExtension = {
+    handler: string,
+    args: A_TYPES__ComponentMeta_InjectionParam[]
+}
+
 
 export type A_TYPES__ComponentMeta_ExtensionItem = {
     name: string,
-    container: string,
     handler: string,
 }
 
 
-export type A_TYPES__ComponentMeta_InjectionParams = Array<
-    // typeof A_Namespace
-    // | typeof A_Component
-    // | typeof A_Container
-    // | typeof A_ContextFragment
-    // | Array<typeof A_Namespace>
-    // | Array<typeof A_Component>
-    // | Array<typeof A_Container>
-    // | Array<typeof A_ContextFragment>
-    | { new(...args: any[]): any }
->
+
+export type A_TYPES__ComponentMeta_InjectionParam =
+    { new(...args: any[]): A_Fragment }
+    | { new(...args: any[]): A_Component }
+    // | { new(...args: any[]): any }
+    | { new(...args: any[]): A_Scope }
+    | { new(...args: any[]): A_Feature };
+// typeof A_Fragment
+// | typeof A_Component
+// // | { new(...args: any[]): any }
+// | typeof A_Scope
+// | typeof A_Feature;
 

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

@@ -2,6 +2,7 @@ import { A_TYPES__ContainerCallParams, A_TYPES__ContainerConstructor } from "./A
 import { A_TYPES__Required } from "@adaas/a-utils";
 import { A_Feature } from "../A-Feature/A-Feature.class";
 import { A_Context } from "../A-Context/A-Context.class";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 
@@ -36,6 +37,10 @@ export class A_Container<
         return this.config.name || this.constructor.name;
     }
 
+    get Scope(): A_Scope {
+        return A_Context.scope(this);
+    }
+
 
     constructor(
         /**
@@ -48,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
@@ -100,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
         */
@@ -122,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[])
-    }
 }