@adaas/a-concept 0.0.64 → 0.1.1

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

@@ -1,69 +1,307 @@
-import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
 import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types"
 import { A_Fragment } from "../A-Fragment/A-Fragment.class"
 import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class"
-import { A_Scope } from "../A-Scope/A-Scope.class"
 import { A_Container } from "../A-Container/A-Container.class"
 import { A_Component } from "../A-Component/A-Component.class"
+import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types"
+import { A_TYPES__Container_Constructor } from "../A-Container/A-Container.types"
+import { A_TYPES__Entity_Constructor } from "../A-Entity/A-Entity.types"
+import { A_Feature } from "./A-Feature.class"
+import { A_TYPES__Required } from "@adaas/a-concept/types/A_Common.types"
+import { A_Scope } from "../A-Scope/A-Scope.class"
 
 
-export type A_TYPES__FeatureIteratorReturn<T extends any = any> = () => Promise<T>
+// ============================================================================
+// --------------------------- Primary Types ----------------------------------
+// ============================================================================
+/**
+ * Feature constructor type
+ * Uses the generic type T to specify the type of the feature
+ */
+export type A_TYPES__Feature_Constructor<T = A_Feature> = new (...args: any[]) => T;
+/**
+ * Feature initialization type
+ */
+export type A_TYPES__Feature_Init<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> = A_TYPES__Feature_InitWithComponent<T> | A_TYPES__Feature_InitWithTemplate
+/**
+ * Feature initialization type using component
+ */
+export type A_TYPES__Feature_InitWithComponent<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> = {
+    /**
+     * Feature Name
+     */
+    name: string,
+    /**
+     * The component from where the feature is calling. It's important for proper scoping. 
+     * Based on the component would be retrieved connected components, entities and containers.
+     * 
+     * [!] Could be Container, Entity, Component or Command
+     */
+    component: T,
+}
+/**
+ * Feature initialization type using template
+ */
+export type A_TYPES__Feature_InitWithTemplate = {
+    /**
+     * Feature Name
+     */
+    name: string,
+    /**
+     * The scope from where to retrieve dependent components, entities and containers. 
+     * 
+     * [!] Important for proper scoping. 
+     */
+    scope: A_Scope
+    /**
+     * Optional Feature template to be used instead of building it from decorators
+     */
+    template: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>
+}
+
+/**
+ * Feature serialized type
+ */
+export type A_TYPES__Feature_Serialized = {}
 
 
-export type A_TYPES__FeatureCallParams = {
-    fragments: Array<A_Fragment>,
-    entities: Array<A_Entity<any, any>>,
-    components: Array<{ new(...args: any[]): any }>
+/**
+ * Feature lifecycle states
+ */
+export enum A_TYPES__FeatureState {
+    /**
+     * The feature has been initialized
+     */
+    INITIALIZED = "INITIALIZED",
+    /**
+     * The feature is currently being processed
+     */
+    PROCESSING = "PROCESSING",
+    /**
+     * The feature has been completed
+     */
+    COMPLETED = "COMPLETED",
+    /**
+     * The feature has been interrupted
+     */
+    INTERRUPTED = "INTERRUPTED",
 }
 
+// ===========================================================================-
+// --------------------------- Available Types -------------------------------
+// ===========================================================================
+
+/**
+ * A list of component where features can be Defined
+ * 
+ * [!] On this component Feature Definition is Available
+ */
+export type A_TYPES__FeatureAvailableComponents = InstanceType<A_TYPES__FeatureAvailableConstructors>
+/**
+ * A list of constructors where features can be Defined
+ * 
+ * [!] On this component Feature Definition is Available
+ */
+export type A_TYPES__FeatureAvailableConstructors = A_TYPES__Component_Constructor
+    | A_TYPES__Entity_Constructor
+    | A_TYPES__Container_Constructor
+
 
 
-export type A_TYPES__FeatureConstructor = {
+// ===========================================================================
+// --------------------------- Decorator Types -------------------------------
+// ===========================================================================
+// ---------------------------------------------------------------------------
+// --------------------Feature Define Decorator Types-------------------------
+// ---------------------------------------------------------------------------
+/**
+ * Indicates a type of Feature Define decorator
+ */
+export type A_TYPES__FeatureDefineDecoratorDescriptor =
+    TypedPropertyDescriptor<() => any>
+    | TypedPropertyDescriptor<(...args: any[]) => any>
+    | TypedPropertyDescriptor<(...args: any[]) => Promise<any>>
+    | TypedPropertyDescriptor<() => Promise<any>>
+/**
+ * Describes additional configuration properties to be used in Feature Define decorator
+ */
+export type A_TYPES__FeatureDefineDecoratorConfig = {
     /**
-     * Name of the A-Feature
+     * Feature name
+     * 
+     * [!] By default uses the method name
      */
     name: string,
     /**
-     * Steps that compose the A-Feature
+     * Indicates a default behavior of the feature. If true the feature will be automatically attached to the execution.
+     * 
+     * [!] Before feature execution the method itself will be called to prepare the feature template
+     * [!] Default is false
      */
-    steps: A_TYPES__A_StageStep[],
+    invoke: boolean,
     /**
-     * Scope in which the A-Feature will be executed
+     * Allows to add a default behavior or number of steps that will be part of the feature
      */
-    scope: A_Scope
+    template: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>
+}
+/**
+ * Describes a single template item used in Feature Define decorator
+ */
+export type A_TYPES__FeatureDefineDecoratorTemplateItem = A_TYPES__Required<Partial<A_TYPES__A_StageStep>, ['name', 'handler', 'component']>
+/**
+ * Describes a target where Feature Define decorator can be applied
+ * 
+ * [!] The feature can be defined on Container, Entity, Component or Command
+ */
+export type A_TYPES__FeatureDefineDecoratorTarget = A_Container
+    | A_Entity
+    | A_Component
+/**
+ * A type of Meta information stored by Feature Define decorator
+ * This information then uses by A-Context to build a proper feature template
+ */
+export type A_TYPES__FeatureDefineDecoratorMeta = {
+    /**
+     * Feature name
+     * mainly it's a unique combination of the class name and method name
+     */
+    name: string,
+    /**
+     * Actual method name in the class
+     */
+    handler: string,
+    /**
+     * Indicates a default behavior of the feature. If true the feature will be automatically attached to the execution.
+     * 
+     * [!] Before feature execution the method itself will be called to prepare the feature template
+     * [!] Default is false
+     */
+    invoke: boolean,
+    /**
+     * Allows to add a default behavior or number of steps that will be part of the feature
+     */
+    template: Array<A_TYPES__A_StageStep>
+}
+// ---------------------------------------------------------------------------
+// --------------------Feature Extend Decorator Types-------------------------
+// ---------------------------------------------------------------------------
+/**
+ * Descriptor type for A_Extend decorator
+ */
+export type A_TYPES__FeatureExtendDecoratorDescriptor =
+    TypedPropertyDescriptor<() => any>
+    | TypedPropertyDescriptor<(...args: any[]) => any>
+    | TypedPropertyDescriptor<(...args: any[]) => Promise<any>>
+    | TypedPropertyDescriptor<() => Promise<any>>
+/**
+ * Target type for A_Extend decorator
+ * 
+ * [!] Can be applied only on A-Components
+ */
+export type A_TYPES__FeatureExtendDecoratorTarget = A_Component
+/**
+ * Meta type for A_Extend decorator
+ */
+export type A_TYPES__FeatureExtendDecoratorMeta = {
+    /**
+     * Original Feature Extension name
+     * 
+     * [!] could be string or regex
+     */
+    name: string,
+    /**
+     * Actual method name in the class
+     */
+    handler: string
+} & A_TYPES__FeatureExtendDecoratorBehaviorConfig
+/**
+ * Configuration type for A_Extend decorator
+ */
+export type A_TYPES__FeatureExtendDecoratorConfig = {
     /**
+     * Name of the container Lifecycle method to be extended.
      * 
+     * [!] If not provided will be used the name of the method.
+     * [!!] If name contains "." dot it will be considered as a path to the method.
      */
-    caller: A_Component | A_Entity | A_Container
+    name: string,
+    /**
+     * Container class or container name uses to identify the proper container in case when the name is not unique.
+     * 
+     * [!] If not provided will be applied to all containers with the same name.
+     * [!!] By default uses OR to join all provided items. If you need more complex Logic, please use Regexp instead
+     * 
+     * [!!!] In case if you need to exclude some containers, entities or components, please use "exclude" property
+     * 
+     * Example:
+     * 
+     * ```ts
+     *  @A_Feature.Extend({
+     *      name: 'load',
+     *      scope: {
+     *          include: [A_Container1, A_Entity1],
+     *          exclude: [A_Component1]
+     *      }
+     *  })
+     * ```
+     */
+    scope: Array<A_TYPES__FeatureExtendDecoratorScopeItem> | Partial<A_TYPES__FeatureExtendDecoratorScopeConfig>,
+} & A_TYPES__FeatureExtendDecoratorBehaviorConfig
+/**
+ * Scope item that can be used in A_Extend decorator configuration
+ */
+export type A_TYPES__FeatureExtendDecoratorScopeConfig = {
+    /**
+     * A list of components, entities or containers to include in the scope of the extension
+     */
+    include?: Array<A_TYPES__FeatureExtendDecoratorScopeItem>,
+    /**
+     * A list of components, entities or containers to exclude from the scope of the extension
+     */
+    exclude?: Array<A_TYPES__FeatureExtendDecoratorScopeItem>
 }
+/**
+ * A single item that can be used in scope configuration
+ */
+export type A_TYPES__FeatureExtendDecoratorScopeItem = { new(...args: any[]): A_Container }
+    | { new(...args: any[]): A_Entity }
+    | { new(...args: any[]): A_Component }
+/**
+ * Behavior configuration for A_Extend decorator
+ */
+export type A_TYPES__FeatureExtendDecoratorBehaviorConfig = {
+    /**
+     * The behavior of the method. 
+     * In case its async it will be executed independently from the main thread.
+     * 
+     * [!] However, in case of sync, it will be executed in the main thread.in the order of the declaration.
+     * 
+     */
+    behavior: 'async' | 'sync'
 
-export enum A_TYPES__FeatureState {
-    INITIALIZED = "INITIALIZED",
-    PROCESSING = "PROCESSING",
 
-    COMPLETED = "COMPLETED",
-    FAILED = "FAILED",
+    /**
+     * Allows to define the order of the execution of the method.
+     * 
+     * [!] In case the method has circular dependencies it will Throw an error.
+     * 
+     */
+    before: string[]
+
+    /**
+     * Allows to define the order of the execution of the method.
+     * 
+     * [!] In case the method has circular dependencies it will Throw an error.
+     * 
+     */
+    after: string[]
 }
 
 
-// export type A_TYPES__FeatureStep = {
-//     /**
-//      * The component to be called
-//      */
-//     component: typeof A_Component,
-//     /**
-//      * The method to be called on the component
-//      */
-//     handler: string,
-//     /**
-//      * Original Feature Extension name
-//      * 
-//      * [!] could be string or regex
-//      * 
-//      */
-//     name: string,
-//     /**
-//      * Arguments to be passed to the method
-//      */
-//     args: A_TYPES__A_InjectDecorator_Meta
-// }
+
+
+
+
+
+
+

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

@@ -1,132 +1,61 @@
-import { A_Context } from "../A-Context/A-Context.class";
-import { A_TYPES__FragmentConstructor } from "./A-Fragment.types";
+import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_TYPES__Fragment_Init } from "./A-Fragment.types";
 
 
-/**
- * A-Fragment = Context Fragments is a set of arguments that can be used to define a Context for the pipeline. 
- * In other words it is a dynamic context that will be created on pipeline start and destroyed on pipeline end.
- * During the execution of the pipeline, the Context Fragments can be used to pass the data between the pipeline steps. 
- * 
- * Or to store the data that is required for the pipeline execution
- * 
- */
-export class A_Fragment {
-
-    name: string;
-
 
+export class A_Fragment<
+    _MemoryItems extends Record<string, any> = any
+> {
     /**
-     * Indicates that Context Fragment is ready to use
+     * Fragment Name
      */
-    ready!: Promise<void>;
-
-
-    constructor(params: Partial<A_TYPES__FragmentConstructor> = {}) {
-
-        this.name = params.name || this.constructor.name;
-
-        /**
-         * Register the Namespace in the global Namespace provider
-         */
-        this.name = params.name || this.constructor.name;
-
-        /**
-         * Run Async Initialization
-         */
-        this.init();
-    }
-
-
-
-
-    private hasInherited(cl: { new(...args: any[]) }): boolean {
-        return this.constructor === cl
-            ? false
-            : true
-    }
-
+    name: string;
     /**
-     * Initializes the Namespace or can be used to reinitialize the Namespace
+     * Memory storage for the Fragment instance
      */
-    private async init() {
-        if (!this.ready)
-            this.ready = new Promise(async (resolve, reject) => {
-                try {
-                    await this.onBeforeInit();
+    protected _meta: A_Meta<_MemoryItems> = new A_Meta<_MemoryItems>();
 
-                    await this.onInit();
-
-                    await this.onAfterInit();
-
-                    return resolve();
-                } catch (error) {
-                    return reject(error);
-                }
-            });
-        else
-            await this.ready;
-    }
-
-
-
-
-
-
-
-    // ==============================================================
-    // ======================= HOOKS ================================
-    // ==============================================================
 
     /**
-     *  Before init hook to be used in inherited classes
+     * A-Fragment is a singleton, a piece of execution Context that can be shared between the Components/Entities/Commands
+     * For every A_Scope can be defined only One A_Fragment of the same type. 
+     * This class is useful for the design purpose and maintainance of the application
      * 
-     * @returns 
-     */
-    protected async onBeforeInit() {
-        return;
-    }
-
-    /**
-     * Main initialization method for the SDK
+     * 
+     * [!] Every A_Fragment is a Memory Class that can store data in memory between the steps of the pipeline.
+     * [!] So if it necessary to store some information in the Execution Context - use memory of the Fragment
      */
-    protected async onInit() {
-        // global logger configuration
-        if (A_Context.environment === 'server' && !this.hasInherited(A_Fragment)) {
-            // eslint-disable-next-line no-use-before-define
-            // process.on('uncaughtException', (error) => {
-            //     // log only in case of A_AUTH_Error
-            //     if (error instanceof A_Error)
-            //         this.Logger.error(error);
-            // });
-            // // eslint-disable-next-line no-use-before-define
-            // process.on('unhandledRejection', (error) => {
-            //     if (error instanceof A_Error)
-            //         this.Logger.error(error);
-            // });
-        }
+    constructor(params: Partial<A_TYPES__Fragment_Init> = {}) {
+        /**
+         * Register the Namespace in the global Namespace provider
+         */
+        this.name = params.name || this.constructor.name;
     }
 
     /**
-     *  After init hook to be used in inherited classes
+     * Returns the Meta object that allows to store data in the Fragment memory
      * 
-     * @returns 
+     * @returns
      */
-    protected async onAfterInit() {
-        return;
+    get memory(): A_Meta<_MemoryItems> {
+        return this._meta;
     }
 
 
 
 
-
     /**
      * Returns the JSON representation of the Fragment
      * 
      * @returns 
      */
-    toJSON(): Record<string, any> {
+    toJSON(): _MemoryItems & { name: string } {
         return {
             name: this.name,
+            ...this.memory.toArray().reduce((acc, [key, value]) => {
+                acc[key] = value;
+                return acc;
+            }, {} as _MemoryItems)
         };
     }
 

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

@@ -1,6 +1,28 @@
+// ============================================================================
+// --------------------------- Primary Types ----------------------------------
+// ============================================================================
 
+import { A_Fragment } from "./A-Fragment.class";
 
-
-export type A_TYPES__FragmentConstructor = {
+/**
+ * Fragment constructor type
+ * Uses the generic type T to specify the type of the fragment
+ */
+export type A_TYPES__Fragment_Constructor<T = A_Fragment> = new (...args: any[]) => T;
+/**
+ * Fragment initialization type
+ */
+export type A_TYPES__Fragment_Init = {
     name: string
-}
+};
+/**
+ * Fragment serialized type
+ */
+export type A_TYPES__Fragment_Serialized = {
+    /**
+     * The ASEID of the fragment
+     */
+    aseid: string
+};
+
+