@adaas/a-concept 0.0.63 → 0.1.1

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

@@ -1,57 +1,91 @@
-import { A_Abstraction_Extend } from "@adaas/a-concept/decorators/A-Abstraction/A-Abstraction-Extend.decorator";
+import { A_Abstraction_Extend } from "@adaas/a-concept/global/A-Abstraction/A-Abstraction-Extend.decorator";
 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_TYPES__Abstraction_Init } from "./A-Abstraction.types";
 import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
+
 export class A_Abstraction {
 
-    public name: string;
-    protected features: A_Feature[] = [];
+    /**
+     * The name of the Abstraction e.g. 'deploy', 'start', 'test', etc.
+     */
+    protected _name: string;
+    /**
+     * List of features that are part of this Abstraction
+     */
+    protected _features: A_Feature[] = [];
+    /**
+     * The Feature currently being processed
+     */
     protected _current?: A_Feature;
+    /**
+     * Actual Index of the current Feature being processed
+     */
     protected _index: number = 0;
 
-    state: A_TYPES__AbstractionState = A_TYPES__AbstractionState.INITIALIZED;
-    error?: A_Error
-
-
-    readonly Scope!: A_Scope;
 
     /**
-     * Define a new A-Abstraction
+     * Allows to extends A-Abstraction with additional methods
      */
     static get Extend(): typeof A_Abstraction_Extend {
         return A_Abstraction_Extend;
     }
 
-
+    /**
+     * A-Abstraction is an object that is common for any application. 
+     * By providing components and creating abstraction extensions it's possible to create a unique behavior of the whole solution.
+     * 
+     * Every application has basic abstractions like 'start', 'stop', 'deploy', 'test', etc. 
+     * They can be easily extended with additional logic from both containers and components.
+     * 
+     * 
+     * @param params 
+     */
     constructor(
         /**
          * Parameters to define the A-Abstraction
          */
-        params: A_TYPES__A_AbstractionConstructor
+        params: A_TYPES__Abstraction_Init
     ) {
-        this.name = params.name;
-        
-        this.features = params.features.map(def => new A_Feature(def));
+        this._name = params.name;
 
-        this._current = this.features[0];
-    }
+        this._features = params.containers.map(container => {
+            return new A_Feature({ name: this._name, component: container, })
+        });
 
+        this._current = this._features[0];
+    }
 
+    /**
+     * Returns the name of the Abstraction
+     */
+    get name(): string { return this._name; }
+    /**
+     * Returns the current Feature being processed
+     */
     get feature(): A_Feature | undefined {
         return this._current;
     }
+    /**
+     * This method checks if the A-Feature is done
+     * 
+     * @returns 
+     */
+    get isDone(): boolean {
+        return !this.feature
+            || this._index >= this._features.length
+
+    }
 
 
     [Symbol.iterator](): Iterator<A_Feature, any> {
         return {
             // Custom next method
             next: (): IteratorResult<A_Feature, any> => {
-                if (!this.isDone()) {
+                if (!this.isDone) {
 
-                    this._current = this.features[this._index];
+                    this._current = this._features[this._index];
 
                     return {
                         value: this._current,
@@ -71,68 +105,40 @@ export class A_Abstraction {
     }
 
     /**
-     * This method moves the feature to the next stage
+     * This method moves the Abstraction processing to the next Feature in the list
      * 
      * @param stage 
      */
     next(stage) {
-        const stageIndex = this.features.indexOf(stage);
-
-        this._index = stageIndex + 1;
-
-        if (this._index >= this.features.length) {
-            this.completed();
+        if (this._index >= this._features.length) {
+            return;
         }
-    }
-
-    async completed(): Promise<void> {
-        this.state = A_TYPES__AbstractionState.COMPLETED;
-    }
 
+        const stageIndex = this._features.indexOf(stage);
 
-    /**
-     * This method marks the feature as failed and throws an error
-     * Uses to interrupt or end the feature processing
-     * 
-     * @param error 
-     */
-    async failed(
-        error: Error | A_Error | unknown
-    ): Promise<void> {
-        this.error = error as A_Error;
-        this.state = A_TYPES__AbstractionState.FAILED;
+        this._index = stageIndex + 1;
     }
 
 
+
     /**
-     * This method checks if the A-Feature is done
+     * Allows to process all stages of the Abstraction
      * 
      * @returns 
      */
-    isDone(): boolean {
-        return !this.feature
-            || this._index >= this.features.length
-            || this.state === A_TYPES__AbstractionState.COMPLETED
-            || this.state === A_TYPES__AbstractionState.FAILED;
-    }
-
-
-    async process() {
-        if (this.isDone())
+    async process(
+        /**
+         * Allows to override the scope in which the Abstraction will be processed
+         * 
+         */
+        scope?: A_Scope
+    ) {
+        if (this.isDone)
             return;
-        try {
-            this.state = A_TYPES__AbstractionState.PROCESSING;
-
-            for (const feature of this.features) {
 
-                await feature.process();
-            }
-
-            await this.completed();
+        for (const feature of this._features) {
 
-        } catch (error) {
-            await this.failed(error);
+            await feature.process(scope);
         }
-
     }
 }

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

@@ -0,0 +1,9 @@
+import { A_Error } from "../A-Error/A_Error.class";
+
+export class A_AbstractionError extends A_Error {
+    /**
+     * This error code indicates that there was an issue extending the abstraction execution
+     */
+    static readonly AbstractionExtensionError = 'Unable to extend abstraction execution';
+
+}

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

@@ -1,9 +1,23 @@
-import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
+import { A_Component } from "../A-Component/A-Component.class";
+import { A_Container } from "../A-Container/A-Container.class";
+import { A_Feature } from "../A-Feature/A-Feature.class";
+import { A_TYPES__FeatureExtendDecoratorConfig } from "../A-Feature/A-Feature.types";
 import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_Abstraction } from "./A-Abstraction.class";
 
 
-
-export type A_TYPES__A_AbstractionConstructor = {
+// ============================================================================
+// --------------------------- Primary Types ----------------------------------
+// ============================================================================
+/**
+ * Abstraction constructor type
+ * Uses the generic type T to specify the type of the abstraction
+ */
+export type A_TYPES__Abstraction_Constructor<T = A_Abstraction> = new (...args: any[]) => T;
+/**
+ * Abstraction initialization type
+ */
+export type A_TYPES__Abstraction_Init = {
     /**
      * Name of the A-Abstraction
      */
@@ -11,19 +25,44 @@ export type A_TYPES__A_AbstractionConstructor = {
     /**
      * Features that compose the A-Abstraction
      */
-    features: Array<A_TYPES__FeatureConstructor>
+    containers: Array<A_Container>
+};
+/**
+ * Abstraction serialized type
+ */
+export type A_TYPES__Abstraction_Serialized = {
     /**
-     * Scope in which the A-Abstraction will be executed
+     * The ASEID of the abstraction
      */
-    scope: A_Scope
-}
+    aseid: string
+};
+
+
+
+/**
+ * Components that can extend Abstractions
+ */
+export type A_TYPES__AbstractionAvailableComponents = A_Component
+    | A_Container
+
+
+// ===========================================================================
+// --------------------------- Decorator Types -------------------------------
+// ===========================================================================
 
+export type A_TYPES__AbstractionDecoratorDescriptor =
 
+    TypedPropertyDescriptor<() => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => Promise<any>>
+    |
+    TypedPropertyDescriptor<() => Promise<any>>
 
-export enum A_TYPES__AbstractionState {
-    INITIALIZED = "INITIALIZED",
-    PROCESSING = "PROCESSING",
 
-    COMPLETED = "COMPLETED",
-    FAILED = "FAILED",
-}
+export type A_TYPES__AbstractionDecoratorConfig = A_TYPES__FeatureExtendDecoratorConfig

package/src/global/A-Caller/A_Caller.class.ts

@@ -0,0 +1,61 @@
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_TYPES__FeatureAvailableComponents } from "../A-Feature/A-Feature.types";
+import { A_CallerError } from "./A_Caller.error";
+
+
+
+/**
+ * This is a common class that uses to return an entity that initiates a feature call
+ * 
+ * It can be used then in @A_Inject(A_Caller) to get the entity that initiated the feature call
+ * 
+ * [!] the class itself may be retrieved, but may require additional processing inside the feature
+ * 
+ */
+export class A_Caller<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> {
+
+    /**
+     * The component that initiated the feature call
+     */
+    protected _component: T;
+
+
+    /**
+     * A_Caller allows to get the component that initiated the feature call
+     * 
+     * It can be used then in @A_Inject(A_Caller) to get the entity that initiated the feature call
+     * 
+     * [!] If Scope is not provided, a new empty scope will be created and inherited from the global scope
+     * 
+     * @param component 
+     * @param scope 
+     */
+    constructor(
+        component: T
+    ) {
+        this.validateParams(component);
+
+        this._component = component;
+    }
+
+    get component(): T {
+        return this._component;
+    }
+
+
+    /**
+     * Validates the provided parameters and Ensures that the component is of an allowed type
+     * 
+     * @param component 
+     */
+    protected validateParams(
+        component: T
+    ) {
+        if (!A_TypeGuards.isAllowedForFeatureCall(component)) {
+            throw new A_CallerError(
+                A_CallerError.CallerInitializationError,
+                `Invalid A-Caller component provided of type: ${typeof component} with value: ${JSON.stringify(component).slice(0, 100)}...`
+            );
+        }
+    }
+}

package/src/global/A-Caller/A_Caller.error.ts

@@ -0,0 +1,10 @@
+import { A_Error } from "../A-Error/A_Error.class";
+
+
+export class A_CallerError extends A_Error {
+
+    /**
+     * This error code indicates that there was an issue initializing the A-Caller
+     */
+    static readonly CallerInitializationError = 'Unable to initialize A-Caller';
+}

package/src/global/A-Caller/A_Caller.types.ts

@@ -0,0 +1,25 @@
+import { A_Component } from "../A-Component/A-Component.class";
+import { A_Container } from "../A-Container/A-Container.class";
+import { A_Entity } from "../A-Entity/A-Entity.class";
+import { A_Caller } from "./A_Caller.class";
+
+
+export type A_TYPES__CallerComponent = A_Container | A_Component | A_Entity;
+
+
+// ============================================================================
+// --------------------------- Primary Types ----------------------------------
+// ============================================================================
+/**
+ * Caller constructor type
+ * Uses the generic type T to specify the type of the caller component
+ */
+export type A_TYPES__Caller_Constructor<T = A_Caller> = new (...args: any[]) => T;
+/**
+ * Caller initialization type
+ */
+export type A_TYPES__Caller_Init = {};
+/**
+ * Caller serialized type
+ */
+export type A_TYPES__Caller_Serialized = {};

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

@@ -1,20 +1,34 @@
 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_Feature } from "../A-Feature/A-Feature.class";
 import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 
 /**
- * This element only contains the specific code
+ * A-Component is a primary "extendable" object in the system
+ * A unique combination of Components creates completely new functionality
  * 
+ * The most important thing is that A-Component is STATELESS, it means that it doesn't store any state in itself
+ * 
+ * 
+ * [!] Every A-Component is a singleton, so if you need to create multiple instances of the same logic - use A-Container
+ * [!] So one scope can have only one instance of the same A-Component
+ * [!] Every A-Component can be extended by features and extensions
+ * [!] ONLY A-Component can have A-Feature extensions
+ *
  */
 export class A_Component {
-    constructor() {
-    }
-
 
 
+    /**
+     * 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 - the name of the feature to call
+     * @param scope  - the scope in which to call the feature
+     * @returns  - void
+     */
     async call(
         /**
          * Name of the feature to call
@@ -23,17 +37,14 @@ export class A_Component {
         /**
          * Scope in which the feature will be executed
          */
-        scope: A_Scope = A_Context.scope(this)
+        scope?: A_Scope
     ) {
+        const newFeature = new A_Feature({
+            name: feature,
+            component: this
+        });
 
-        if (scope && !scope.isInheritedFrom(A_Context.scope(this))) {
-            scope = scope.inherit(A_Context.scope(this));
-        }
-
-
-        const newFeature = A_Context.feature(this, feature, scope);
-
-        return await newFeature.process();
+        return await newFeature.process(scope);
     }
 }
 

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

@@ -0,0 +1,9 @@
+
+
+
+export enum A_TYPES__ComponentMetaKey {
+    EXTENSIONS = 'a-component-extensions',
+    FEATURES = 'a-component-features',
+    INJECTIONS = 'a-component-injections',
+    ABSTRACTIONS = 'a-component-abstractions',
+}

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

@@ -1,14 +1,13 @@
-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__A_InjectDecorator_Meta } from "@adaas/a-concept/global/A-Inject/A-Inject.types";
+import { A_TYPES__ConceptAbstractionMeta } 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";
-import { A_TYPES__A_DefineDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
+import { A_TYPES__ComponentMeta, A_TYPES__ComponentMetaExtension } from "./A-Component.types";
+import { A_TYPES__ComponentMetaKey } from "./A-Component.constants";
+import { A_TYPES__FeatureDefineDecoratorMeta } from "../A-Feature/A-Feature.types";
 
 
 export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
 
-
-
     /**
      * Allows to get all the injections for a given handler
      * 
@@ -25,8 +24,6 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
         return args;
     }
 
-
-
     /**
      * Allows to get all the extensions for a given feature
      * 
@@ -39,7 +36,6 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
         const steps: A_TYPES__ComponentMetaExtension[] = [];
 
         const extensions = this.get(A_TYPES__ComponentMetaKey.EXTENSIONS);
-        const injections = this.get(A_TYPES__ComponentMetaKey.INJECTIONS);
 
         extensions
             // returns all extensions that match the feature
@@ -62,14 +58,12 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
         return steps;
     }
 
-
-
     /**
      * Returns all features defined in the Component
      * 
      * @returns 
      */
-    features(): Array<A_TYPES__A_DefineDecorator_Meta> {
+    features(): Array<A_TYPES__FeatureDefineDecoratorMeta> {
 
         const features = this.get(A_TYPES__ComponentMetaKey.FEATURES);
 
@@ -78,7 +72,6 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
             .map(([, feature]) => feature) || [];
     }
 
-
     /**
      * Returns a set of instructions to run proper methods in Component during A-Concept Stage
      * 
@@ -93,9 +86,6 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
         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(abstraction)

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

@@ -1,24 +1,50 @@
-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_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/global/A-Inject/A-Inject.types"
 import { A_Meta } from "../A-Meta/A-Meta.class"
-import { A_TYPES__A_DefineDecorator_Meta, 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"
-import { A_TYPES__ContainerMeta_FeatureItem } from "../A-Container/A-Container.types"
+import { A_TYPES__ConceptAbstraction } from "../A-Concept/A-Concept.types"
+import { A_Component } from "./A-Component.class"
+import { A_TYPES__ComponentMetaKey } from "./A-Component.constants"
+import { A_TYPES__FeatureDefineDecoratorMeta, A_TYPES__FeatureExtendDecoratorBehaviorConfig, A_TYPES__FeatureExtendDecoratorMeta } from "../A-Feature/A-Feature.types"
+
+
 
-export type A_TYPES__ComponentConstructor<_Exports extends Array<String> = any> = {
-    exports: _Exports,
-}
 
-export type A_TYPES__ComponentCallParams<T extends string> = {
-    name: T,
-    fragments: Array<A_Fragment>,
-    components: Array<{ new(...args: any[]): any }>
-}
 
 
+// ============================================================================
+// --------------------------- Primary Types ----------------------------------
+// ============================================================================
+/**
+ * Component constructor type
+ * Uses the generic type T to specify the type of the component
+ */
+export type A_TYPES__Component_Constructor<T = A_Component> = new (...args: any[]) => T;
+/**
+ * Component initialization type
+ */
+export type A_TYPES__Component_Init = any;
+/**
+ * Component serialized type
+ */
+export type A_TYPES__Component_Serialized = {
+    /**
+     * The ASEID of the component
+     */
+    aseid: string
+};
+
+
+
+// ============================================================================
+// --------------------------- Meta Types -------------------------------------
+// ============================================================================
+/**
+ * Component meta type
+ */
 export type A_TYPES__ComponentMeta = {
+    /**
+     * Extensions applied to the component per handler
+     */
     [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
@@ -26,20 +52,22 @@ export type A_TYPES__ComponentMeta = {
          *
          * Where value is the extension instructions
          */
-        [Key: string]: A_TYPES__A_ExtendDecorator_Meta[]
+        [Key: string]: A_TYPES__FeatureExtendDecoratorMeta[]
     }>,
-
-
+    /**
+     * Features defined on the component per handler
+     */
     [A_TYPES__ComponentMetaKey.FEATURES]: A_Meta<{
         /**
          * Where Key is the name of the feature
          * 
          * Where value is the list of features
          */
-        [Key: string]: A_TYPES__A_DefineDecorator_Meta
+        [Key: string]: A_TYPES__FeatureDefineDecoratorMeta
     }>
-
-
+    /**
+     * Injections defined on the component per handler
+     */
     [A_TYPES__ComponentMetaKey.INJECTIONS]: A_Meta<{
         /**
          * Where Key is the name of the injection
@@ -48,7 +76,9 @@ export type A_TYPES__ComponentMeta = {
          */
         [Key: string]: A_TYPES__A_InjectDecorator_Meta
     }>
-
+    /**
+     *  Abstractions extended by the component per handler
+     */
     [A_TYPES__ComponentMetaKey.ABSTRACTIONS]: A_Meta<{
         /**
          * Where Key is the name of the stage
@@ -59,12 +89,7 @@ export type A_TYPES__ComponentMeta = {
     }>
 }
 
-export enum A_TYPES__ComponentMetaKey {
-    EXTENSIONS = 'a-component-extensions',
-    FEATURES = 'a-component-features',
-    INJECTIONS = 'a-component-injections',
-    ABSTRACTIONS = 'a-component-abstractions',
-}
+
 
 export type A_TYPES__ComponentMetaExtension = {
     /**
@@ -75,6 +100,6 @@ export type A_TYPES__ComponentMetaExtension = {
      * The name of the handler that will be used to apply the extension
      */
     handler: string,
-} & A_TYPES__A_ExtendDecorator_BehaviorConfig
+} & A_TYPES__FeatureExtendDecoratorBehaviorConfig