@adaas/a-concept 0.0.64 → 0.1.1

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

@@ -0,0 +1,316 @@
+import { A_Container } from "../A-Container/A-Container.class";
+import { A_Abstraction } from "../A-Abstraction/A-Abstraction.class";
+import { A_Abstraction_Extend } from "@adaas/a-concept/global/A-Abstraction/A-Abstraction-Extend.decorator";
+import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_TYPES__ConceptAbstractions } from "./A-Concept.constants";
+import { A_TYPES__Concept_Init } from "./A-Concept.types";
+import { A_TYPES__AbstractionDecoratorConfig } from "../A-Abstraction/A-Abstraction.types";
+import { A_Feature } from "../A-Feature/A-Feature.class";
+
+
+
+export class A_Concept<
+    _Imports extends A_Container[] = A_Container[]
+> {
+
+    // ==============================================================================
+    // ====================  STATIC LIFECYCLE DECORATORS  ===========================
+    // ==============================================================================
+    /**
+     * Load the concept. This step runs before any other steps to ensure that all components are loaded.
+     */
+    static Load(
+        /**
+         * provide additional configuration for the abstraction extension to make it dependent on other factors
+         */
+        config?: Partial<A_TYPES__AbstractionDecoratorConfig>
+    ): ReturnType<typeof A_Abstraction_Extend> {
+        return A_Abstraction.Extend(A_TYPES__ConceptAbstractions.Load, config);
+    }
+
+    /**
+     * Publish the concept to ADAAS platform. (Or any other place defined in the concept)
+     *
+     * [!] To extend the logic just create a custom containers and override the default behavior.
+     */
+    static Publish(
+        /**
+        * provide additional configuration for the abstraction extension to make it dependent on other factors
+        */
+        config?: Partial<A_TYPES__AbstractionDecoratorConfig>
+    ): ReturnType<typeof A_Abstraction_Extend> {
+        return A_Abstraction.Extend(A_TYPES__ConceptAbstractions.Publish);
+    }
+
+    /**
+     * Deploy the concept to the environment.
+     */
+    static Deploy(
+        /**
+        * provide additional configuration for the abstraction extension to make it dependent on other factors
+        */
+        config?: Partial<A_TYPES__AbstractionDecoratorConfig>
+    ) {
+        return A_Abstraction.Extend(A_TYPES__ConceptAbstractions.Deploy, config);
+    }
+
+    /**
+     * Compiles the Concept in case there are some containers that require that. 
+     * 
+     * Can be used for static websites or any other concept that requires a build step.
+     * 
+     */
+    static Build(
+        /**
+        * provide additional configuration for the abstraction extension to make it dependent on other factors
+        */
+        config?: Partial<A_TYPES__AbstractionDecoratorConfig>
+    ) {
+        return A_Abstraction.Extend(A_TYPES__ConceptAbstractions.Build, config);
+    }
+
+    /**
+     *  Main execution of the concept.
+     */
+    static Run(
+        /**
+        * provide additional configuration for the abstraction extension to make it dependent on other factors
+        */
+        config?: Partial<A_TYPES__AbstractionDecoratorConfig>
+    ) {
+        return A_Abstraction.Extend(A_TYPES__ConceptAbstractions.Run, config);
+    }
+
+    /**
+     *  Start the concept. Uses for servers or any other background services.
+     */
+    static Start(
+        /**
+        * provide additional configuration for the abstraction extension to make it dependent on other factors
+        */
+        config?: Partial<A_TYPES__AbstractionDecoratorConfig>
+    ) {
+        return A_Abstraction.Extend(A_TYPES__ConceptAbstractions.Start, config);
+    }
+
+    /**
+     * Stop the concept. Uses for servers or any other background services.
+     */
+    static Stop(
+        /**
+        * provide additional configuration for the abstraction extension to make it dependent on other factors
+        */
+        config?: Partial<A_TYPES__AbstractionDecoratorConfig>
+    ) {
+        return A_Abstraction.Extend(A_TYPES__ConceptAbstractions.Stop, config);
+    }
+
+
+    /**
+     * Name of the concept
+     * 
+     * By default, the name of the Concept is 'a-concept'
+     */
+    private _name!: string;
+    /**
+     * A list of internally defined containers that the concept uses.
+     */
+    protected _containers!: A_Container[];
+
+
+
+    // ==============================================================================
+    // ==========================  MAIN Methods  ======================================
+    // ==============================================================================
+
+
+    /**
+     * A-Concept is a placeholder for the concept of the any program.
+     * 
+     * Concept - could be any Program regardless environment and it's goal.
+     * It could be mobile, web or simple html page.
+     * All depends on Containers and Components installed and provided in the Concept.
+     * 
+     * 
+     * [!] Concept operates ONLY with all Components and Containers provided to achieve the goal.
+     * 
+     * 
+     * @param props - Initialization properties for the Concept
+     */
+    constructor(
+        protected props: A_TYPES__Concept_Init<_Imports>
+    ) {
+        this._name = props.name || A_Context.root.name;
+
+        if (props.components && props.components.length)
+            props.components.forEach(component => this.scope.register(component))
+
+        if (props.fragments && props.fragments.length)
+            props.fragments.forEach(fragment => this.scope.register(fragment))
+
+        if (props.entities && props.entities.length)
+            props.entities.forEach(entity => this.scope.register(entity as any))
+
+
+        this._containers = props.containers || [];
+    }
+
+    /**
+     * Name of the concept
+     */
+    get name() {
+        return A_Context.root.name;
+    }
+    /**
+     * The primary Root scope of the concept.
+     */
+    get scope() {
+        return A_Context.root;
+    }
+
+    /**
+     * Register a class or value in the concept scope.
+     */
+    get register(): A_Scope['register'] {
+        return this.scope.register.bind(this.scope);
+    }
+
+    /**
+     * Resolve a class or value from the concept scope.
+     */
+    get resolve(): A_Scope['resolve'] {
+        return this.scope.resolve.bind(this.scope);
+    }
+
+
+    // =======================================================================
+    // ==========================  LIFECYCLE  ================================
+    // =======================================================================
+    /**
+     * Load the concept.
+     */
+    async load(
+        scope?: A_Scope,
+    ) {
+        const abstraction = new A_Abstraction({
+            name: A_TYPES__ConceptAbstractions.Load,
+            containers: this._containers,
+        });
+
+        await abstraction.process(scope);
+    }
+    /**
+     * Run the concept.
+     */
+    async run(
+        scope?: A_Scope,
+    ) {
+        const abstraction = new A_Abstraction({
+            name: A_TYPES__ConceptAbstractions.Run,
+            containers: this._containers,
+        });
+
+        await abstraction.process(scope);
+    }
+    /**
+     * Start the concept.
+     * 
+     * @param params 
+     */
+    async start(
+        scope?: A_Scope,
+    ) {
+        const abstraction = new A_Abstraction({
+            name: A_TYPES__ConceptAbstractions.Start,
+            containers: this._containers,
+        });
+
+        await abstraction.process(scope);
+    }
+    /**
+     * Stop the concept.
+     * 
+     * @param params 
+     */
+    async stop(
+        scope?: A_Scope,
+    ) {
+        const abstraction = new A_Abstraction({
+            name: A_TYPES__ConceptAbstractions.Stop,
+            containers: this._containers,
+        });
+
+        await abstraction.process(scope);
+    }
+    /**
+     * Build the concept.
+     */
+    async build(
+        scope?: A_Scope,
+    ) {
+        const abstraction = new A_Abstraction({
+            name: A_TYPES__ConceptAbstractions.Build,
+            containers: this._containers,
+        });
+
+        await abstraction.process(scope);
+    }
+    /**
+     * Deploy the concept.
+     */
+    async deploy(
+        scope?: A_Scope,
+    ) {
+        const abstraction = new A_Abstraction({
+            name: A_TYPES__ConceptAbstractions.Deploy,
+            containers: this._containers,
+        });
+
+        await abstraction.process(scope);
+
+    }
+    /**
+     * Publish the concept.
+     */
+    async publish(
+        scope?: A_Scope,
+    ) {
+        const abstraction = new A_Abstraction({
+            name: A_TYPES__ConceptAbstractions.Publish,
+            containers: this._containers,
+        });
+
+        await abstraction.process(scope);
+    }
+
+
+    // =======================================================================
+    // ==========================  CALL  =====================================
+    // =======================================================================
+
+
+    /**
+     * Call the specific method of the concept or included modules.
+     */
+    async call<
+        K extends Record<_Imports[number]['name'], string>
+    >(
+        /**
+         * Name of the method to call
+         */
+        method: K[keyof K],
+        /**
+         * Container in which the method is located
+         */
+        container: _Imports[number],
+    ) {
+        const feature = new A_Feature({ name: method, component: container });
+
+        return await feature.process();
+    }
+}
+
+
+
+

package/src/global/A-Concept/A-Concept.constants.ts

@@ -0,0 +1,36 @@
+export enum A_TYPES__ConceptAbstractions {
+    /**
+     * Run the concept.
+     */
+    Run = 'run',
+    /**
+     * Build the concept.
+     */
+    Build = 'build',
+    /**
+     * Publish the concept.
+     */
+    Publish = 'publish',
+    /**
+     * Deploy the concept.
+     */
+    Deploy = 'deploy',
+    /**
+     * Load the concept.
+     */
+    Load = 'load',
+    /**
+     * Start the concept.
+     */
+    Start = 'start',
+    /**
+     * Stop the concept.
+     */
+    Stop = 'stop',
+}
+
+
+
+export enum A_TYPES__ConceptMetaKey {
+    LIFECYCLE = 'a-component-extensions',
+}

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

@@ -0,0 +1,17 @@
+
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_Meta } from "../A-Meta/A-Meta.class";
+
+
+
+export class A_ConceptMeta extends A_Meta<any> {
+
+
+    constructor(
+        private containers: Array<A_Container>,
+    ) {
+        super();
+    }
+
+
+}

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

@@ -0,0 +1,100 @@
+import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/global/A-Inject/A-Inject.types";
+import { A_Container } from "../A-Container/A-Container.class";
+import { A_Concept } from "./A-Concept.class";
+import { A_TYPES__FeatureExtendDecoratorBehaviorConfig } from "../A-Feature/A-Feature.types";
+import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types";
+import { A_TYPES__Fragment_Constructor } from "../A-Fragment/A-Fragment.types";
+import { A_TYPES__Entity_Constructor } from "../A-Entity/A-Entity.types";
+
+
+// ============================================================================
+// --------------------------- Primary Types ----------------------------------
+// ============================================================================
+/**
+ * Concept constructor type
+ * Uses the generic type T to specify the type of the concept
+ */
+export type A_TYPES__Concept_Constructor<T = A_Concept> = new (...args: any[]) => T;
+/**
+ * Concept initialization type
+ * Uses the generic type T to specify the type of containers that the concept will use
+ */
+export type A_TYPES__Concept_Init<
+    T extends Array<A_Container>
+> = {
+    /**
+     * The name of the Concept
+     * If name is not provided, will be used from environment variable A_CONCEPT_NAME
+     * 
+     * By default, the name of the Concept is 'a-concept'
+     * 
+     */
+    name?: string,
+    /**
+     * A set of Context Fragments to register globally for the concept.
+     * These fragments will be available in the global context.
+     * 
+     */
+    fragments?: Array<InstanceType<A_TYPES__Fragment_Constructor>>,
+    /**
+     * A set of Containers that the concept depends on. 
+     * These containers will create a new Container for the concept.
+     */
+    containers?: T,
+    /**
+     * A set of Entities that the concept can use. 
+     * These components will be used in the concept.
+     */
+    entities?: Array<InstanceType<A_TYPES__Entity_Constructor> | A_TYPES__Entity_Constructor>
+    /**
+     * A set of Components available for all containers and fragments in the concept. 
+     * These components will be registered in the root scope of the concept.
+     * 
+     * [!] Note that these components will be available in all containers and fragments in the concept.
+     */
+    components?: Array<A_TYPES__Component_Constructor>
+}
+/**
+ * Concept serialized type
+ */
+export type A_TYPES__Concept_Serialized = {
+
+};
+
+
+// ============================================================================
+// --------------------------- Meta Types -------------------------------------
+// ============================================================================
+/**
+ * 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__FeatureExtendDecoratorBehaviorConfig
+
+
+
+/**
+ * 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__FeatureExtendDecoratorBehaviorConfig

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

@@ -1,120 +1,79 @@
-import { A_TYPES__ContainerConstructor } from "./A-Container.types";
-import { A_TYPES__Required } from "@adaas/a-utils";
 import { A_Context } from "../A-Context/A-Context.class";
+import { A_Feature } from "../A-Feature/A-Feature.class";
 import { A_Scope } from "../A-Scope/A-Scope.class";
-import { A_TYPES__FeatureCallParams, A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
+import { A_TYPES__Container_Init } from "./A-Container.types";
 
 
 
-/**
- * This class should combine Components to achieve the goal withing Concept
- * 
- * Container is a direct container that should be "run" to make Concept work. 
- * So because of that Container can be:
- * - HTTP Server
- * - BASH Script
- * - Database Connection
- * - Microservice
- * - etc.
- */
 export class A_Container {
-    protected readonly config!: Partial<A_TYPES__ContainerConstructor<any>>;
 
     /**
-     * Promise that will be resolved when the container is ready to be used.
+     * Configuration of the container that will be used to run it.
+     */
+    protected readonly config!: Partial<A_TYPES__Container_Init>;
+    /**
+     * Name of the container
      */
-    ready!: Promise<void>;
-
     get name() {
         return this.config.name || this.constructor.name;
     }
-
-    get Scope(): A_Scope {
+    /**
+     * Returns the scope where the container is registered
+     */
+    get scope(): A_Scope {
         return A_Context.scope(this);
     }
 
 
     /**
-     * Creates a new instance of A_Container
+     * This class should combine Components to achieve the goal withing Concept
      * 
-     * @param config 
+     * Container is a direct container that should be "run" to make Concept work. 
+     * So because of that Container can be:
+     * - HTTP Server
+     * - BASH Script
+     * - Database Connection
+     * - Microservice
+     * - etc.
+     * 
+     * @param config - Configuration of the container that will be used to run it.
      */
     constructor(
         /**
          * Configuration of the container that will be used to run it.
          */
-        config: Partial<A_TYPES__ContainerConstructor<any>>
+        config: Partial<A_TYPES__Container_Init>
     ) {
         this.config = config;
 
-        A_Context.allocate(this, {
-            name: this.name,
-            ...config
-        });
-    }
-
-
-    async call(
-        feature: string,
-        scope: A_Scope = this.Scope
-    ) {
-
-        if (scope && !scope.isInheritedFrom(this.Scope)) {
-            scope = scope.inherit(this.Scope);
-        }
-
-
-        const newFeature = A_Context.feature(this, feature, scope);
-
-        return await newFeature.process();
+        A_Context.allocate(this, this.config);
     }
 
 
     /**
-     * This method allows to get a feature Definition for the future reuse with custom Feature classes
+     * Calls the feature with the given name in the given scope
+     * 
+     * [!] Note: This method creates a new instance of the feature every time it is called
      * 
-     * @param feature 
+     * @param feature - the name of the feature to call
+     * @param scope  - the scope in which to call the feature
+     * @returns  - void
      */
-    feature(
+    async call(
+        /**
+         * Name of the feature to call
+         */
         feature: string,
-        scope: A_Scope = this.Scope
+        /**
+         * scope in which the feature will be executed
+         */
+        scope?: A_Scope
     ) {
+        const newFeature = new A_Feature({
+            name: feature,
+            component: this
+        });
 
-        if (scope && !scope.isInheritedFrom(this.Scope)) {
-            scope = scope.inherit(this.Scope);
-        }
-
-        return A_Context.featureDefinition(this, feature, scope);
-    }
-
-
-    // ==============================================================
-    // ======================= HOOKS ================================
-    // ==============================================================
-
-    /**
-     *  Before init hook to be used in inherited classes
-     * 
-     * @returns 
-     */
-    protected async onBeforeInit() {
-        return;
-    }
-
-    /**
-     * Main initialization method for the Container
-     */
-    protected async onInit() {
-        return;
-    }
-
-    /**
-     *  After init hook to be used in inherited classes
-     * 
-     * @returns 
-     */
-    protected async onAfterInit() {
-        return;
+        return await newFeature.process(scope);
     }
-
 }

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

@@ -0,0 +1,5 @@
+export enum A_TYPES__ContainerMetaKey {
+    FEATURES = 'a-container-features',
+    INJECTIONS = 'a-container-injections',
+    ABSTRACTIONS = 'a-container-abstractions',
+}

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

@@ -1,11 +1,9 @@
-import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
-import { A_TYPES__ConceptAbstractionMeta, A_TYPES__ConceptStage } from "../A-Concept/A_Concept.types";
+import { A_TYPES__ContainerMeta, } from "./A-Container.types";
+import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/global/A-Inject/A-Inject.types";
+import { A_TYPES__ConceptAbstraction, A_TYPES__ConceptAbstractionMeta } from "../A-Concept/A-Concept.types";
 import { A_Meta } from "../A-Meta/A-Meta.class";
-import {
-    A_TYPES__ContainerMeta,
-    A_TYPES__ContainerMetaKey
-} from "./A-Container.types";
-import { A_TYPES__A_DefineDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
+import { A_TYPES__ContainerMetaKey } from "./A-Container.constants";
+import { A_TYPES__FeatureDefineDecoratorMeta } from "../A-Feature/A-Feature.types";
 
 
 
@@ -34,7 +32,7 @@ export class A_ContainerMeta extends A_Meta<A_TYPES__ContainerMeta> {
      * 
      * @returns 
      */
-    features(): Array<A_TYPES__A_DefineDecorator_Meta> {
+    features(): Array<A_TYPES__FeatureDefineDecoratorMeta> {
 
         const features = this.get(A_TYPES__ContainerMetaKey.FEATURES);
 
@@ -50,15 +48,13 @@ export class A_ContainerMeta extends A_Meta<A_TYPES__ContainerMeta> {
      * @returns 
      */
     abstractions(
-        abstraction: A_TYPES__ConceptStage
+        abstraction: A_TYPES__ConceptAbstraction    
     ): 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