@adaas/a-concept 0.0.39 → 0.0.40

package/examples/simple-http-server/containers/http-server.container.ts

@@ -5,6 +5,7 @@ import { A_Concept } from "@adaas/a-concept/global/A-Concept/A_Concept.class";
 import { A_Config } from "@adaas/a-concept/base/A-Config/A-Config.context";
 import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
 import { HTTPRequest } from "../contexts/http-request.context";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 
 
 
@@ -42,11 +43,12 @@ export class HttpServer extends A_Container {
         req: IncomingMessage,
         res: ServerResponse
     ) {
-        return await this.call('onRequest', {
+        return await this.call('onRequest', new A_Scope({
+            name: `http-request::${Date.now()}`,
             fragments: [
                 new HTTPRequest(req, res)
             ]
-        });
+        }));
     }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

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

@@ -2,6 +2,7 @@ import { A_Abstraction_Extend } from "@adaas/a-concept/decorators/A-Abstraction/
 import { A_Feature } from "../A-Feature/A-Feature.class";
 import { A_TYPES__A_AbstractionConstructor, A_TYPES__AbstractionState } from "./A-Abstraction.types";
 import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 export class A_Abstraction {
@@ -15,6 +16,7 @@ export class A_Abstraction {
     error?: A_Error
 
 
+    readonly Scope!: A_Scope;
 
     /**
      * Define a new A-Abstraction
@@ -24,9 +26,14 @@ export class A_Abstraction {
     }
 
 
-
-    constructor(params: A_TYPES__Required<Partial<A_TYPES__A_AbstractionConstructor>, ['name', 'features']>) {
+    constructor(
+        /**
+         * Parameters to define the A-Abstraction
+         */
+        params: A_TYPES__A_AbstractionConstructor
+    ) {
         this.name = params.name;
+        
         this.features = params.features.map(def => new A_Feature(def));
 
         this._current = this.features[0];
@@ -37,6 +44,7 @@ export class A_Abstraction {
         return this._current;
     }
 
+
     [Symbol.iterator](): Iterator<A_Feature, any> {
         return {
             // Custom next method
@@ -110,7 +118,7 @@ export class A_Abstraction {
 
 
     async process() {
-        if (this.isDone()) 
+        if (this.isDone())
             return;
         try {
             this.state = A_TYPES__AbstractionState.PROCESSING;

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

@@ -1,15 +1,22 @@
-import { A_TYPES__Required } from "@adaas/a-utils";
-import { A_Container } from "../A-Container/A-Container.class";
 import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
-import { A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
-import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 
 export type A_TYPES__A_AbstractionConstructor = {
+    /**
+     * Name of the A-Abstraction
+     */
     name: string,
-    features: Array<A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps']>>
-} & A_TYPES__ScopeConstructor
+    /**
+     * Features that compose the A-Abstraction
+     */
+    features: Array<A_TYPES__FeatureConstructor>
+    /**
+     * Scope in which the A-Abstraction will be executed
+     */
+    scope: A_Scope
+}
 
 
 

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

@@ -1,6 +1,7 @@
 import { A_Context } from "../A-Context/A-Context.class";
 import { A_TYPES__ComponentConstructor } from "./A-Component.types";
 import { A_TYPES__FeatureCallParams } from "../A-Feature/A-Feature.types";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 
@@ -9,24 +10,28 @@ import { A_TYPES__FeatureCallParams } from "../A-Feature/A-Feature.types";
  * 
  */
 export class A_Component {
-    constructor(
-        params?: Partial<A_TYPES__ComponentConstructor<any>>
-    ) { 
+    constructor() {
         console.log('A-Component instance created', this);
 
     }
 
 
     async call(
+        /**
+         * Name of the feature to call
+         */
         feature: string,
-        params: Partial<A_TYPES__FeatureCallParams> = {}
+        /**
+         * Scope in which the feature will be executed
+         */
+        scope?: A_Scope,
     ) {
-        const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
+        scope = scope ? scope.inherit(A_Context.scope(this)) : A_Context.scope(this);
+
+        const newFeature = A_Context.feature(this, feature, scope);
 
         return await newFeature.process();
     }
-
-
 }
 
 

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

@@ -3,6 +3,7 @@ import { A_Container } from "../A-Container/A-Container.class";
 import { A_Abstraction } from "../A-Abstraction/A-Abstraction.class";
 import { A_ConceptMeta } from "./A_Concept.meta";
 import { A_Abstraction_Extend } from "@adaas/a-concept/decorators/A-Abstraction/A-Abstraction-Extend.decorator";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 // export type RunParams<T> = T extends A_Container<any, infer Params> ? Params : never;
@@ -98,18 +99,16 @@ export class A_Concept<
         protected props: A_TYPES__IConceptConstructor<_Imports>
     ) {
         this.sharedBase = new A_Container({
-            name: props.name,
+            name: `${props.name}::base`,
             fragments: props.fragments || [],
             entities: props.entities || [],
-            // containers: props.containers
             components: [
                 // A_Logger,
-            ]
+            ],
         });
 
         this.containers = (props.containers || []).map(container => {
             container.Scope.parent(this.Scope);
-
             return container;
         });
 
@@ -136,9 +135,11 @@ export class A_Concept<
      * Load the concept.
      */
     async load(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Load, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Load, scope);
 
         await abstraction.process();
     }
@@ -149,11 +150,11 @@ export class A_Concept<
      * Run the concept.
      */
     async run(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        await this.load(params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
 
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Run, params);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Run, scope);
 
         await abstraction.process();
     }
@@ -165,11 +166,11 @@ export class A_Concept<
      * @param params 
      */
     async start(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        await this.load(params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
 
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Start, params);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Start, scope);
 
         await abstraction.process();
     }
@@ -181,9 +182,11 @@ export class A_Concept<
      * @param params 
      */
     async stop(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Stop, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Stop, scope);
 
         await abstraction.process();
     }
@@ -193,9 +196,11 @@ export class A_Concept<
      * Build the concept.
      */
     async build(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Build, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Build, scope);
 
         await abstraction.process();
     }
@@ -205,9 +210,11 @@ export class A_Concept<
      * Deploy the concept.
      */
     async deploy(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Deploy, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Deploy, scope);
 
         await abstraction.process();
 
@@ -218,9 +225,11 @@ export class A_Concept<
      * Publish the concept.
      */
     async publish(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Publish, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Publish, scope);
 
         await abstraction.process();
     }
@@ -238,7 +247,6 @@ export class A_Concept<
         K extends Record<_Imports[number]['name'], string>
     >(
         container: K[keyof K],
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
         // const definition = this.meta.abstractionDefinition(A_TYPES__ConceptStage.Run, {
         //     components: params?.components,

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

@@ -9,6 +9,7 @@ import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_TYPES__A_FeatureDecoratorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_TYPES__A_AbstractionConstructor } from "../A-Abstraction/A-Abstraction.types";
 import { A_Abstraction } from "../A-Abstraction/A-Abstraction.class";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 // import { A_TYPES__ComponentMeta } from "./A-Component.types";
 
 
@@ -24,21 +25,17 @@ export class A_ConceptMeta extends A_Meta<any> {
 
     abstractionDefinition(
         method: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
-    ): A_TYPES__Required<Partial<A_TYPES__A_AbstractionConstructor>, ['features']> {
+        scope: A_Scope
+    ): A_TYPES__A_AbstractionConstructor {
 
         const featureDefinitions = this.containers.map(container =>
-            A_Context.abstractionDefinition(container.Scope, container, method, params)
+            A_Context.abstractionDefinition(container, method, scope)
         );
 
-
         const definition = {
-            ...params,
             name: `${this.base.name}.${method}`,
             features: featureDefinitions,
-            parent: this.base.Scope,
-            components: params?.components || [],
-            fragments: params?.fragments || [],
+            scope
         };
 
         return definition;
@@ -48,12 +45,11 @@ export class A_ConceptMeta extends A_Meta<any> {
 
     abstraction(
         method: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope: A_Scope
     ): A_Abstraction {
 
-
         const featureDefinitions = this.containers.map(container => {
-            const definition = A_Context.abstractionDefinition(container.Scope, container, method, params);
+            const definition = A_Context.abstractionDefinition(container, method, container.Scope);
 
             return {
                 ...definition,
@@ -63,12 +59,9 @@ export class A_ConceptMeta extends A_Meta<any> {
 
 
         const definition = {
-            ...params,
             name: `${this.base.name}.${method}`,
             features: featureDefinitions,
-            parent: this.base.Scope,
-            components: params?.components || [],
-            fragments: params?.fragments || [],
+            scope
         };
 
         return new A_Abstraction(definition);

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

@@ -44,20 +44,20 @@ export class A_Container {
     ) {
         this.config = config;
 
-        const components = config.components || [];
-        const fragments = config.fragments || [];
-
-        A_Context.allocate(this, config);
-
-
+        A_Context.allocate(this, {
+            name: this.name,
+            ...config
+        });
     }
 
 
     async call(
         feature: string,
-        params: Partial<A_TYPES__FeatureCallParams> = {}
+        scope?: A_Scope,
     ) {
-        const newFeature = A_Context.feature(this.Scope, this, feature, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const newFeature = A_Context.feature(this, feature, scope);
 
         return await newFeature.process();
     }
@@ -70,10 +70,12 @@ export class A_Container {
      */
     feature(
         feature: string,
-        params: Partial<A_TYPES__FeatureCallParams> = {}
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
+        scope?: A_Scope,
+    ): A_TYPES__FeatureConstructor {
+
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
 
-        return A_Context.featureDefinition(this.Scope, this, feature, params);
+        return A_Context.featureDefinition(this, feature, scope);
     }
 
 

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

@@ -118,22 +118,34 @@ export class A_Context {
         component: any,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
+    static allocate(
+        component: any,
+        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
+    ): A_Scope
     static allocate(
         feature: A_Feature,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
+    static allocate(
+        feature: A_Feature,
+        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
+    ): A_Scope
     static allocate(
         container: A_Container,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
+    static allocate(
+        container: A_Container,
+        importing: A_Scope
+    ): A_Scope
     static allocate(
         param1: A_Container | A_Feature | A_Component | any,
-        param2: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
+        param2: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
     ): A_Scope {
 
         const instance = this.getInstance();
 
-        const newScope = new A_Scope(param2, param2);
+        const newScope = param2 instanceof A_Scope ? param2 : new A_Scope(param2, param2);
 
         switch (true) {
             case param1 instanceof A_Container:
@@ -345,33 +357,14 @@ export class A_Context {
      * @returns 
      */
     static featureDefinition(
-        scope: A_Scope,
-        entity: A_Entity,
-        feature: A_TYPES__EntityBaseMethod | string | RegExp,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition(
-        scope: A_Scope,
-        container: A_Container,
-        feature: string,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition(
-        scope: A_Scope,
-        component: A_Component,
-        feature: string,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition(
-        scope: A_Scope,
-        param1: A_Component | A_Container | A_Entity,
-        param2: string,
-        param3?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
+        component: A_Component | A_Container | A_Entity,
+        feature: string | RegExp,
+        scope: A_Scope
+    ): A_TYPES__FeatureConstructor {
         const instance = this.getInstance();
 
-        const component = param1;
-        const config = param3 || {};
+        const name = `${component.constructor.name}.${feature}`;
+
 
         /**
          * Important NOTE::: Component Scope and Parent Scope are different things.
@@ -433,10 +426,10 @@ export class A_Context {
             throw new Error(`[!] A-Concept Context: Features not found. for Component ${component.constructor.name}`);
 
 
-        const featureDefinition = allFeatures.get(param2);
+        const featureDefinition = allFeatures.get(feature);
 
         if (!featureDefinition)
-            throw new Error(`[!] A-Concept Context: Feature ${param2} not found. for Component ${component.constructor.name}`);
+            throw new Error(`[!] A-Concept Context: Feature ${feature} not found. for Component ${component.constructor.name}`);
 
 
         const steps: A_TYPES__A_StageStep[] = [
@@ -449,7 +442,6 @@ export class A_Context {
         //     scope: scope.name
         // }).toString();
 
-        const feature = `${component.constructor.name}.${param2}`;
 
         // Now we need to resolve the method from all registered components 
 
@@ -460,7 +452,7 @@ export class A_Context {
                 if (scope.has(constructor))
                     // Get all extensions for the feature
                     meta
-                        .extensions(feature)
+                        .extensions(name)
                         .forEach((declaration) => {
                             steps.push({
                                 component: constructor,
@@ -470,14 +462,8 @@ export class A_Context {
             });
 
 
-        return {
-            name: feature,
-            fragments: config.fragments || [],
-            components: config.components || [],
-            entities: config.entities || [],
-            steps,
-            parent: scope
-        };
+
+        return { name, steps, scope };
     }
 
     /**
@@ -487,33 +473,13 @@ export class A_Context {
      * @returns 
      */
     static abstractionDefinition(
-        scope: A_Scope,
-        entity: A_Entity,
-        feature: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static abstractionDefinition(
-        scope: A_Scope,
-        container: A_Container,
-        feature: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static abstractionDefinition(
-        scope: A_Scope,
-        component: A_Component,
-        feature: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static abstractionDefinition(
-        scope: A_Scope,
-        param1: A_Component | A_Container | A_Entity,
-        param2: A_TYPES__ConceptStage,
-        param3?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
+        component: A_Component | A_Container | A_Entity,
+        abstraction: A_TYPES__ConceptStage,
+        scope: A_Scope
+    ): A_TYPES__FeatureConstructor {
         const instance = this.getInstance();
 
-        const component = param1;
-        const config = param3 || {};
+        const name = `${component.constructor.name}.${abstraction}`;
 
         let metaKey;
 
@@ -534,14 +500,13 @@ export class A_Context {
 
         const featureDefinition = this.meta(component)
             .get(metaKey)
-            .get(param2) || []
+            .get(abstraction) || []
 
 
         const steps: A_TYPES__A_StageStep[] = [
             ...featureDefinition
         ];
 
-        const feature = `${component.constructor.name}.${param2}`;
 
         // We need to get all components that has extensions for the feature in component
         instance.componentsMeta
@@ -550,7 +515,7 @@ export class A_Context {
                 if (scope.has(constructor))
                     // Get all extensions for the feature
                     meta
-                        .abstractions(feature)
+                        .abstractions(name)
                         .forEach((declaration) => {
                             steps.push({
                                 component: constructor,
@@ -560,14 +525,7 @@ export class A_Context {
             });
 
 
-        return {
-            name: feature,
-            fragments: config.fragments || [],
-            components: config.components || [],
-            entities: config.entities || [],
-            steps,
-            parent: scope
-        };
+        return { name, steps, scope };
     }
 
     /**
@@ -577,31 +535,26 @@ export class A_Context {
      * @returns 
      */
     static feature<T extends Array<string>>(
-        scope: A_Scope,
         entity: A_Entity<any, any>,
         feature: A_TYPES__EntityBaseMethod | string | T[number] | RegExp,
-        params?: Partial<A_TYPES__ScopeConstructor>
+        scope: A_Scope
     ): A_Feature
     static feature<T extends Array<string>>(
-        scope: A_Scope,
         container: A_Container,
         feature: T[number],
-        params?: Partial<A_TYPES__ScopeConstructor>
+        scope: A_Scope
     ): A_Feature
     static feature(
-        scope: A_Scope,
         component: A_Component,
         feature: string,
-        params?: Partial<A_TYPES__ScopeConstructor>
+        scope: A_Scope
     ): A_Feature
     static feature<T extends Array<string>>(
-        scope: A_Scope,
         param1: A_Component | A_Container | A_Entity<any, any>,
         param2: string | T[number],
-        param3?: Partial<A_TYPES__ScopeConstructor>
+        param3: A_Scope
     ): A_Feature {
-
-        const featureConstructor = this.featureDefinition(scope, param1, param2, param3);
+        const featureConstructor = this.featureDefinition(param1, param2, param3);
 
         const newFeature = new A_Feature(featureConstructor);
 

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

@@ -10,6 +10,7 @@ import {
 import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
 import { A_Context } from "../A-Context/A-Context.class";
 import { A_TYPES__FeatureCallParams } from "../A-Feature/A-Feature.types";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 
@@ -135,14 +136,14 @@ export class A_Entity<
      * @param lifecycleMethod 
      * @param args 
      */
-     async call(
+    async call(
         feature: string,
-        params: Partial<A_TYPES__FeatureCallParams> = {}
+        scope?: A_Scope,
     ) {
-        params.entities = params.entities || [this];
 
+        scope = scope ? scope.inherit(A_Context.scope(this)) : A_Context.scope(this);
 
-        const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
+        const newFeature = A_Context.feature(this, feature, scope);
 
         return await newFeature.process();
     }