@adaas/a-concept 0.0.29 → 0.0.30

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

@@ -1,3 +1,6 @@
+import { A_Component } from "../A-Component/A-Component.class";
+import { A_Container } from "../A-Container/A-Container.class";
+import { A_TYPES__A_ChannelAggregated, A_TYPES__A_ChannelAggregateMethods, A_TYPES__A_ChannelCallParams, A_TYPES__A_ChannelConstructor } from "./A-Channel.types";
 
 
 /**
@@ -7,42 +10,36 @@
  * When One container needs to communicate with another container, it uses A_Channel.
  * 
  */
-export class A_Channel<T> {
-    private proxyInstance: T | null = null;
-    private realInstance: T | null = null;
+export class A_Channel<
+    T extends Array<A_Component | A_Container> = any[],
+    _Constructor extends A_TYPES__A_ChannelConstructor = A_TYPES__A_ChannelConstructor
+> {
 
-    constructor(
-        private realClass: { new(...args: any[]): T },
-        private args: any[]
-    ) {
+    id: string;
 
-    }
+    protected channel: A_TYPES__A_ChannelAggregated<T>;
 
-    protected async loadInstance(): Promise<T> {
-        if (!this.realInstance)
-            this.realInstance = new this.realClass(...this.args);
 
-        return this.realInstance;
-    }
+    constructor(params: A_TYPES__A_ChannelConstructor) {
+        this.id = params.id;
 
+        this.channel = new Proxy(
+            {} as A_TYPES__A_ChannelAggregated<T>,
+            {
+                get: (target, prop) => {
+                    return async (...args: any[]) => {
+                        this.call(prop as A_TYPES__A_ChannelAggregateMethods<T>);
+                    };
+                }
+            });
+    }
 
-    public async resolve(): Promise<T> {
-        if (!this.proxyInstance) {
-            const realInstance = await this.loadInstance();
 
-            this.proxyInstance = new Proxy({}, {
-                get: (target, prop) => {
-                    const value = (realInstance as any)[prop];
+    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
 
-                    // If the property is a method, return a bound function
-                    if (typeof value === 'function') {
-                        return value.bind(realInstance);
-                    }
-                    return value;
-                }
-            }) as T;
-        }
+        console.log('Calling method', prop);
 
-        return this.proxyInstance;
+        return {} as _Resp;
     }
 }

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

@@ -1,3 +1,6 @@
+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"
 
 
 export type A_TYPES__A_DependencyReferenceConstructor = {
@@ -58,3 +61,53 @@ export type A_TYPES__A_DependencyReferenceConstructorConfig = {
         timeout: number
     }
 }
+
+
+export type A_TYPES__A_ChannelCallParams = {
+    fragments: Array<A_Fragment>,
+    components: Array<typeof A_Component>
+}
+
+
+/**
+ * Returns a string set of possible methods that could be called on a provided A-Component
+ */
+export type A_TYPES__A_ExecutableMethods<T> = {
+    [K in keyof T]: T[K] extends (...arg: Partial<A_TYPES__A_ChannelCallParams>[]) => Promise<any> ? K : never
+}[keyof 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[]> = {
+    [K in keyof TClasses]: TClasses[K] extends infer Instance
+    ? A_TYPES__A_ExecutableMethods<Instance>
+    : never;
+}[number];
+
+
+/**
+ * Describes a type of proxy object and consists of all callable methods from a set opf provided components 
+ */
+export type A_TYPES__A_ChannelAggregated<TClasses extends any[]> = {
+    [Method in A_TYPES__A_ChannelAggregateMethods<TClasses>]: {
+        [Class in keyof TClasses]: TClasses[Class] extends infer Instance
+        ? Method extends keyof Instance
+        // Just put it here for possible cases with detailed params
+        // ? Instance[Method]
+        ? (params: Partial<A_TYPES__A_ChannelCallParams>) => Promise<any>
+        : never
+        : never;
+    }[number]; // Select the method signature from any matching class
+};
+
+
+
+
+/**
+ * A set of parameters are required to construct a new A-Channel
+ */
+export type A_TYPES__A_ChannelConstructor = {
+    id: string,
+}

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

@@ -1,8 +1,10 @@
 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";
+import { A_TYPES__ComponentCallParams, A_TYPES__ComponentConstructor } from "./A-Component.types";
 import { A_Scope } from "../A-Scope/A-Scope.class";
 
+
+
 /**
  * This element only contains the specific code
  * 
@@ -10,6 +12,9 @@ import { A_Scope } from "../A-Scope/A-Scope.class";
 export class A_Component<
     _FeatureNames extends Array<string> = any,
 > {
+    constructor(
+        params?: Partial<A_TYPES__ComponentConstructor<_FeatureNames>>
+    ) { }
 
 
     /**
@@ -62,4 +67,7 @@ export class A_Component<
 
         return await newFeature.process();
     }
-}
+}
+
+
+

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

@@ -1,3 +1,4 @@
+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";
 
@@ -35,7 +36,10 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
                         // component: constructor,
                         name: extension.name,
                         handler: extension.handler,
-                        args
+                        args,
+                        behavior: extension.behavior,
+                        before: extension.before || [],
+                        after: extension.after || []
                     });
 
                 });
@@ -45,4 +49,41 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
         return steps;
     }
 
+
+    /**
+     * Returns a set of instructions to run proper methods in Component during A-Concept Stage
+     * 
+     * @param stage 
+     * @returns 
+     */
+    abstractions(
+        abstraction: A_TYPES__ConceptStage
+    ): A_TYPES__ConceptAbstractionMeta[] {
+        const steps: A_TYPES__ConceptAbstractionMeta[] = [];
+
+        const abstractions = this.get(A_TYPES__ComponentMetaKey.ABSTRACTIONS);
+        const injections = this.get(A_TYPES__ComponentMetaKey.INJECTIONS);
+
+        // const constructor = A_Context.component(this);
+
+
+        abstractions
+            // returns all extensions that match the feature
+            ?.find(`CONCEPT_ABSTRACTION::${abstraction}`)
+            .forEach(([handler, extensions]) => {
+                extensions.forEach(extension => {
+                    const args = injections?.get(extension.handler) || [];
+
+                    steps.push({
+                        ...extension,
+                        // component: constructor,
+                        args,
+                    });
+
+                });
+            });
+
+
+        return steps;
+    }
 }

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

@@ -1,10 +1,12 @@
-import { A_Entity } from "../A-Entity/A-Entity.class"
-import { A_Feature } from "../A-Feature/A-Feature.class"
+import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types"
 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"
+import { A_TYPES__A_ExtendDecorator_BehaviorConfig, A_TYPES__A_ExtendDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types"
+import { A_TYPES__ConceptAbstraction, A_TYPES__ConceptAbstractionMeta } from "../A-Concept/A_Concept.types"
 
+export type A_TYPES__ComponentConstructor<_Exports extends Array<String>> = {
+    exports: _Exports,
+}
 
 export type A_TYPES__ComponentCallParams<T extends string> = {
     name: T,
@@ -23,7 +25,7 @@ export type A_TYPES__ComponentMeta = {
          *
          * Where value is the extension instructions
          */
-        [Key: string]: A_TYPES__ComponentMeta_ExtensionItem[]
+        [Key: string]: A_TYPES__A_ExtendDecorator_Meta[]
     }>,
 
 
@@ -36,7 +38,16 @@ export type A_TYPES__ComponentMeta = {
          * 
          * Where value is the list of injections
          */
-        [Key: string]: A_TYPES__ComponentMeta_InjectionParams
+        [Key: string]: A_TYPES__A_InjectDecorator_Meta
+    }>
+
+    [A_TYPES__ComponentMetaKey.ABSTRACTIONS]: A_Meta<{
+        /**
+         * Where Key is the name of the stage
+         * 
+         * Where value is the list of injections
+         */
+        [Key: string]: A_TYPES__ConceptAbstraction[]
     }>
 }
 
@@ -44,7 +55,7 @@ export enum A_TYPES__ComponentMetaKey {
     EXTENSIONS = 'a-component-extensions',
     FEATURES = 'a-component-features',
     INJECTIONS = 'a-component-injections',
-    STAGES = 'a-component-stages',
+    ABSTRACTIONS = 'a-component-abstractions',
 }
 
 export type A_TYPES__ComponentMetaExtension = {
@@ -59,39 +70,8 @@ export type A_TYPES__ComponentMetaExtension = {
     /**
      * The arguments that will be passed to the handler
      */
-    args: A_TYPES__ComponentMeta_InjectionParams
-}
-
-
-export type A_TYPES__ComponentMeta_ExtensionItem = {
-    name: string,
-    handler: string,
-}
-
-export type A_TYPES__ComponentMeta_InjectionParams = Array<{
-    target: A_TYPES__ComponentMeta_InjectionParam
-} | {
-    target: { new(...args: any[]): A_Entity },
-    instructions: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
-}>;
-
-
-export type A_TYPES__ComponentMeta_EntityInjectionInstructions = {
-    aseid: string,
-    id: string,
-}
+    args: A_TYPES__A_InjectDecorator_Meta
 
+} & A_TYPES__A_ExtendDecorator_BehaviorConfig
 
-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

@@ -4,7 +4,9 @@ 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";
+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";
 
 
 
@@ -35,8 +37,8 @@ export class A_Concept<
     /**
      * Load the concept. This step runs before any other steps to ensure that all components are loaded.
      */
-    static get Load() {
-        return A_Stage(A_TYPES__ConceptStage.Load);
+    static Load() {
+        return A_Abstraction(A_TYPES__ConceptStage.Load);
     }
 
     /**
@@ -44,15 +46,15 @@ export class A_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);
+    static Publish() {
+        return A_Abstraction(A_TYPES__ConceptStage.Publish);
     }
 
     /**
      * Deploy the concept to the environment.
      */
-    static get Deploy() {
-        return A_Stage(A_TYPES__ConceptStage.Deploy);
+    static Deploy() {
+        return A_Abstraction(A_TYPES__ConceptStage.Deploy);
     }
 
     /**
@@ -61,29 +63,29 @@ export class A_Concept<
      * 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);
+    static Build() {
+        return A_Abstraction(A_TYPES__ConceptStage.Build);
     }
 
     /**
      *  Main execution of the concept.
      */
-    static get Run() {
-        return A_Stage(A_TYPES__ConceptStage.Run);
+    static Run() {
+        return A_Abstraction(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);
+    static Start() {
+        return A_Abstraction(A_TYPES__ConceptStage.Start);
     }
 
     /**
      * Stop the concept. Uses for servers or any other background services.
      */
-    static get Stop() {
-        return A_Stage(A_TYPES__ConceptStage.Stop);
+    static Stop() {
+        return A_Abstraction(A_TYPES__ConceptStage.Stop);
     }
 
 
@@ -182,26 +184,46 @@ export class A_Concept<
         params: Partial<A_TYPES__ConceptStageParams>
     ) {
 
-        const stages: any[] = [];
+        const abstractions: {
+            container: A_Container<any>,
+            runners: Array<A_TYPES__A_StageStep>
+        }[] = [];
+
 
         this.containers.map(container => {
             const meta = A_Context.meta(container);
 
-            const containerStages = meta.get(A_TYPES__ContainerMetaKey.STAGES)
+            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
+                ]
+            });
+        });
 
 
-            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,
@@ -209,9 +231,6 @@ export class A_Concept<
             parent: A_Context.scope(this)
         });
 
-        for (const stage of stages) {
-            await stage.container[stage.name](params);
-        }
 
     }
 
@@ -235,3 +254,5 @@ export class A_Concept<
 
 }
 
+
+

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

@@ -1,5 +1,9 @@
+import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
 import { A_Container } from "../A-Container/A-Container.class";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_Entity } from "../A-Entity/A-Entity.class";
+import { A_Component } from "../A-Component/A-Component.class";
+import { A_TYPES__A_ExtendDecorator_BehaviorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 
 
 export enum A_TYPES__ConceptStage {
@@ -58,6 +62,42 @@ export interface A_TYPES__IConceptConstructor<
 }
 
 
+/**
+ * Uses as a transfer object to pass configurations to Feature constructor
+ */
+export type A_TYPES__ConceptAbstractionMeta = {
+    /**
+     * The name of original Extension Definition
+     */
+    name: string,
+    /**
+     * The name of the handler that will be used to apply the extension
+     */
+    handler: string,
+    /**
+     * The arguments that will be passed to the handler
+     */
+    args: A_TYPES__A_InjectDecorator_Meta
+} & A_TYPES__A_ExtendDecorator_BehaviorConfig
+
+
+
+/**
+ * Uses to define the extension that will be applied to the Concept
+ */
+export type A_TYPES__ConceptAbstraction = {
+    /**
+     * The name of original Extension Definition
+     */
+    name: string,
+    /**
+     * The name of the handler that will be used to apply the extension
+     */
+    handler: string,
+} & A_TYPES__A_ExtendDecorator_BehaviorConfig
+
+
+
 
 
 // =======================================================================
@@ -68,12 +108,17 @@ export interface A_TYPES__IConceptConstructor<
 
 export type A_TYPES__ConceptStageParams = {
     fragments: Array<A_Fragment>,
-    components: Array<{ new(...args: any[]): any }>
+    components: Array<{ new(...args: any[]): A_Component }>,
+    entities: Array<{ new(...args: any[]): A_Entity }>
 }
 
 
 export type A_TYPES__ConceptCallParams<T extends string> = {
     name: T,
     fragments: Array<A_Fragment>,
-    components: Array<{ new(...args: any[]): any }>
-}
+    components: Array<{ new(...args: any[]): A_Component }>,
+    entities: Array<{ new(...args: any[]): A_Entity<any, any, any> }>
+}
+
+
+

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

@@ -18,7 +18,7 @@ import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
  * - etc.
  */
 export class A_Container<
-    _FeatureNames extends Array<string>
+    _FeatureNames extends Array<string> = any
 > {
     // scope!: A_Scope
 
@@ -55,46 +55,10 @@ export class A_Container<
 
         A_Context.allocate(this, config);
 
-        /**
-         * 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
@@ -138,7 +102,7 @@ export class A_Container<
             ? param2 || {}
             : param1;
 
-        const newFeature = A_Context.feature(this.Scope, this, feature, params);
+        const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
 
         return await newFeature.process();
     }

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

@@ -1,8 +1,5 @@
-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_TYPES__ConceptAbstractionMeta, A_TYPES__ConceptStage } from "../A-Concept/A_Concept.types";
 import { A_Meta } from "../A-Meta/A-Meta.class";
-import { A_Container } from "./A-Container.class";
 import {
     A_TYPES__ContainerMeta,
     A_TYPES__ContainerMetaKey
@@ -13,4 +10,44 @@ import {
 export class A_ContainerMeta extends A_Meta<A_TYPES__ContainerMeta> {
 
 
+    /**
+     * Returns a set of instructions to run proper methods in Container during A-Concept Stage
+     * 
+     * @param stage 
+     * @returns 
+     */
+    abstractions(
+        abstraction: A_TYPES__ConceptStage
+    ): A_TYPES__ConceptAbstractionMeta[] {
+        const steps: A_TYPES__ConceptAbstractionMeta[] = [];
+
+        const abstractions = this.get(A_TYPES__ContainerMetaKey.ABSTRACTIONS);
+        const injections = this.get(A_TYPES__ContainerMetaKey.INJECTIONS);
+
+        // const constructor = A_Context.component(this);
+
+
+        abstractions
+            // returns all extensions that match the feature
+            ?.find(`CONCEPT_ABSTRACTION::${abstraction}`)
+            .forEach(([handler, extensions]) => {
+                extensions.forEach(extension => {
+                    const args = injections?.get(extension.handler) || [];
+
+                    steps.push({
+                        name: extension.name,
+                        handler: extension.handler,
+                        args,
+                        before: extension.before,
+                        behavior: extension.behavior,
+                        after: extension.after
+                    });
+
+                });
+            });
+
+
+        return steps;
+    }
+
 }