@adaas/a-concept 0.0.2 → 0.0.4

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

@@ -0,0 +1,156 @@
+import { A_Feature_Define } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Define.decorator";
+import { A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Extend.decorator";
+import { A_TYPES__FeatureConstructor, A_TYPES__FeatureState, A_TYPES__FeatureStep } from "./A-Feature.types";
+import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
+import { A_Context } from "../A-Context/A-Context.class";
+
+
+
+/**
+ * A_Feature is representing a feature that can be executed across multiple components
+ * This class stores the steps of the feature and executes them in order of appearance
+ * 
+ * Using A_Feature.Define and A_Feature.Extend decorators to define and extend the feature methods 
+ * across the different, distributed components
+ * 
+ */
+export class A_Feature {
+
+
+    /**
+     * Define a new A-Feature
+     */
+    static get Define() {
+        return A_Feature_Define;
+    }
+
+
+    /**
+     * Extend an existing A-Feature
+     */
+    static get Extend() {
+        return A_Feature_Extend;
+    }
+
+
+
+
+    // protected scope: A_Scope
+    protected steps: A_TYPES__FeatureStep[] = []
+
+    state: A_TYPES__FeatureState = A_TYPES__FeatureState.INITIALIZED;
+
+    result?: any
+    error?: A_Error
+
+    constructor(
+        params: A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps']>
+    ) {
+        // this.scope = params.scope;
+        this.steps = params.steps;
+
+        A_Context.allocate(this, params);
+
+    }
+
+
+    /**
+     * This method marks the feature as completed and returns the result
+     * Uses to interrupt or end the feature processing
+     * 
+     * @param result 
+     * @returns 
+     */
+    async completed<T extends any>(
+        ...result: T[]
+    ): Promise<T> {
+
+        this.result = result;
+        this.state = A_TYPES__FeatureState.COMPLETED;
+
+        return this.result;
+    }
+
+
+    /**
+     * 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
+    ) {
+        this.error = error as A_Error;
+        this.state = A_TYPES__FeatureState.FAILED;
+
+        await this.errorHandler(error);
+    }
+
+
+
+    async process() {
+        try {
+            this.state = A_TYPES__FeatureState.PROCESSING;
+
+            for (const { component, handler, args } of this.steps) {
+
+                if (
+                    (this.state as any) === A_TYPES__FeatureState.FAILED
+                    ||
+                    (this.state as any) === A_TYPES__FeatureState.COMPLETED
+                ) {
+                    throw new Error('FEATURE_PROCESSING_INTERRUPTED');
+                }
+
+                const instance = A_Context.scope(this).resolve(component);
+
+                if (instance[handler]) {
+                    const callArgs = A_Context.scope(this).resolve(args);
+                    await instance[handler](...callArgs);
+                }
+            }
+
+            await this.completed();
+
+        } catch (error) {
+            console.log('Feature processing error:', error);
+
+            await this.failed(error);
+        }
+    }
+
+
+    protected async errorHandler(error: Error | A_Error | unknown) {
+        switch (true) {
+            case error instanceof A_Error:
+                throw error;
+
+
+            case error instanceof Error
+                && error.message === 'FEATURE_PROCESSING_INTERRUPTED'
+                && this.state === A_TYPES__FeatureState.FAILED:
+                throw new A_Error({
+                    message: 'FEATURE_PROCESSING_INTERRUPTED',
+                    code: 'FEATURE_PROCESSING_INTERRUPTED',
+                    data: {
+                        feature: this
+                    }
+                });
+
+
+            case error instanceof Error
+                && error.message === 'FEATURE_PROCESSING_INTERRUPTED'
+                && this.state === A_TYPES__FeatureState.COMPLETED:
+
+                // Do nothing
+                break;
+
+            default:
+                throw error;
+        }
+    }
+
+
+}

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

@@ -0,0 +1,20 @@
+import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
+
+export type A_TYPES__FeatureConstructor = {
+    steps: A_TYPES__FeatureStep[]
+} & A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig
+
+export enum A_TYPES__FeatureState {
+    INITIALIZED = "INITIALIZED",
+    PROCESSING = "PROCESSING",
+
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+}
+
+
+export type A_TYPES__FeatureStep = {
+    component: { new(...args: any[]): any },
+    handler: string,
+    args: any[]
+}

package/src/global/{A-Namespace/A_Namespace.class.ts → A-Fragment/A-Fragment.class.ts}

@@ -1,48 +1,37 @@
-import { A_Polyfills } from '@adaas/a-utils';
-import {
-    A_TYPES__NamespaceConstructor,
-    A_TYPES__INamespace,
-} from './A_Namespace.types';
-import { A_Context } from '../A-Context/A-Context.class';
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_TYPES__FragmentConstructor } from "./A-Fragment.types";
 
 
 /**
- * A_Namespace is a base class for all Namespaces in the A
+ * 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. 
  * 
- * Namespace is a shared object within some environment, service or Application. 
- * It is used to share some data, configuration, dependencies, etc. between different parts of the application.
+ * Or to store the data that is required for the pipeline execution
  * 
- * Namespace allow to :
- * - share some data between different parts of the application, 
- * - share some configuration between different parts of the application,
- * - share some dependencies between different parts of the application,
- * - extend the capabilities of the application by adding new features or modifying existing ones into base classes
- *
  */
-export class A_Namespace<
-    _ConstructorConfigType extends A_TYPES__NamespaceConstructor = any
-> implements A_TYPES__INamespace {
+export class A_Fragment {
+
+    name: string;
 
-    /**
-     * Namespace namespace
-     */
-    name!: string;
 
     /**
-     * Ready Promise to ensure the SDK is ready to use
+     * Indicates that Context Fragment is ready to use
      */
     ready!: Promise<void>;
 
-    constructor(
-        protected config?: _ConstructorConfigType
-    ) {
+
+    constructor(params: Partial<A_TYPES__FragmentConstructor> = {}) {
+
+        this.name = params.name || this.constructor.name;
+
         /**
          * Register the Namespace in the global Namespace provider
          */
         this.name = A_Context
             .register(
                 this,
-                config?.name
+                this.name
             );
 
         /**
@@ -53,6 +42,7 @@ export class A_Namespace<
 
 
 
+
     private hasInherited(cl: { new(...args: any[]) }): boolean {
         return this.constructor === cl
             ? false
@@ -62,7 +52,7 @@ export class A_Namespace<
     /**
      * Initializes the Namespace or can be used to reinitialize the Namespace
      */
-    protected async init() {
+    private async init() {
         if (!this.ready)
             this.ready = new Promise(async (resolve, reject) => {
                 try {
@@ -83,6 +73,10 @@ export class A_Namespace<
 
 
 
+
+
+
+
     // ==============================================================
     // ======================= HOOKS ================================
     // ==============================================================
@@ -100,9 +94,8 @@ export class A_Namespace<
      * Main initialization method for the SDK
      */
     protected async onInit() {
-
         // global logger configuration
-        if (A_Context.environment === 'server' && !this.hasInherited(A_Namespace)) {
+        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
@@ -125,4 +118,5 @@ export class A_Namespace<
     protected async onAfterInit() {
         return;
     }
+
 }

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

@@ -0,0 +1,6 @@
+
+
+
+export type A_TYPES__FragmentConstructor = {
+    name: string
+}

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

@@ -0,0 +1,60 @@
+import { A_TYPES__Dictionary } from "@adaas/a-utils";
+import { A_Component } from "../A-Component/A-Component.class";
+import { A_Container } from "../A-Container/A-Container.class";
+
+
+
+/**
+ * A Meta is an entity that stores all the metadata for the specific entity like container, component, feature, etc. 
+ * 
+ * [!] Meta can be different depending on the type of input data
+ */
+export class A_Meta<
+    _StorageItems extends Record<string, any>
+// _StorageItems extends Record<string, Map<string | Symbol, any> | Array<any> | A_TYPES__Dictionary<any>>
+> {
+
+    protected meta: Map<keyof _StorageItems, _StorageItems[keyof _StorageItems]> = new Map();
+
+
+    from(
+        meta: A_Meta<_StorageItems>
+    ): A_Meta<_StorageItems> {
+        this.meta = new Map(meta.meta);
+
+        return this;
+    }
+
+
+    // ===================================================================================================
+    // ================================ META OPERATIONS ==================================================
+    // ===================================================================================================
+
+    // Method to set values in the map
+    set<K extends keyof _StorageItems>(key: K, value: _StorageItems[K]) {
+
+        const inheritedValue = this.meta.get(key)
+            || Array.isArray(value)
+            ? []
+            : (value as any) instanceof Map
+                ? new Map()
+                : {};
+        const targetValue = this.meta.get(key)
+            || Array.isArray(value)
+            ? [
+                ...inheritedValue as any
+            ] : (value as any) instanceof Map
+                ? new Map(inheritedValue as any)
+                : { ...inheritedValue };
+
+        this.meta.set(key, value);
+
+    }
+
+    // Method to get values from the map
+    get<K extends keyof _StorageItems>(key: K): _StorageItems[K] | undefined {
+        return this.meta.get(key) as _StorageItems[K];
+    }
+}
+
+

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

@@ -0,0 +1,208 @@
+import { A_CommonHelper } from "@adaas/a-utils";
+import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "./A-Scope.types";
+import { A_STORAGE__A_Inject_Instructions } from "@adaas/a-concept/storage/A_Inject.storage";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+
+/**
+ * 
+ * 
+ * A_Scope refers to the visibility and accessibility of :
+ * - variables, 
+ * - Components, 
+ * - Context Fragments 
+ * - and objects in different parts of your code. 
+ * Scope determines where a particular piece of data (like a variable or function) 
+ * can be accessed, modified, or referenced, and it plays a crucial role in avoiding naming collisions and ensuring data integrity. 
+ * 
+ * 
+ */
+export class A_Scope {
+
+    name: string = '';
+
+    private _components: WeakMap<{ new(...args: any[]): any }, any> = new WeakMap();
+    private _fragments: WeakMap<typeof A_Fragment.constructor, any> = new WeakMap();
+
+    private parent?: A_Scope;
+
+    protected params!: A_TYPES__ScopeConstructor
+
+
+    constructor(
+        params: Partial<A_TYPES__ScopeConstructor>,
+        config: Partial<A_TYPES__ScopeConfig> = {}
+    ) {
+        this.name = params.name || this.constructor.name;
+
+        // TODO: move to defaults
+        const defaultParams: A_TYPES__ScopeConstructor = {
+            name: '',
+            components: [],
+            fragments: [],
+            import: [],
+            export: [],
+        };
+
+
+        this.params = A_CommonHelper.deepCloneAndMerge<A_TYPES__ScopeConstructor>(params, defaultParams);
+
+        this.initComponents(params.components || []);
+        this.initFragments(params.fragments || []);
+
+        if (config.parent) {
+            this.parent = config.parent;
+        }
+    }
+
+
+    private initComponents(_components: Array<{ new(...args: any[]): any }>) {
+        // _components.forEach(component => {
+        //     this._components.set(component, new component());
+        // })
+    }
+
+
+    private initFragments(_fragments: Array<A_Fragment>) {
+        _fragments.forEach(this.register.bind(this));
+    }
+
+
+    get components() {
+        return this.params.components || [];
+    }
+
+
+
+    /**
+     * This method is used to check if the component is available in the scope
+     * 
+     * @param component 
+     * @returns 
+     */
+    has(
+        component: { new(...args: any[]): any }
+    ): boolean
+    has(
+        fragment: A_Fragment
+    ): boolean
+    has(
+        entity: { new(...args: any[]): any } | A_Fragment
+    ): boolean {
+
+        switch (true) {
+            case entity instanceof A_Fragment
+                && this._fragments.has(entity.constructor): {
+                    return true;
+                }
+
+            case entity instanceof A_Fragment
+                && !this._fragments.has(entity.constructor)
+                && !!this.parent: {
+                    return this.parent.has(entity);
+                }
+
+            case !(entity instanceof A_Fragment)
+                && this._components.has(entity): {
+                    return true;
+                }
+
+            case !(entity instanceof A_Fragment)
+                && !this._components.has(entity)
+                && !!this.parent: {
+                    return this.parent.has(entity);
+                }
+
+            default: {
+                return false;
+            }
+        }
+    }
+
+
+    /**
+     * This method is used to get the component by class
+     * 
+     * @param component 
+     * @returns 
+     */
+    resolve<T extends { new(...args: any[]): any }>(component: T): InstanceType<T>
+    resolve<T extends { new(...args: any[]): any }>(component: Array<T>): Array<InstanceType<T>>
+    // base definition
+    resolve<T extends { new(...args: any[]): any }>(
+        param1: Array<T> | T,
+        param2?: string
+    ): Array<InstanceType<T>> | InstanceType<T> {
+
+        switch (true) {
+            case Array.isArray(param1): {
+                return param1.map(c => this.resolveOnce(c));
+            }
+
+            case typeof param1 === 'function': {
+                return this.resolveOnce(param1);
+            }
+
+            default: {
+                throw new Error('Invalid arguments provided');
+            }
+        }
+    }
+
+
+
+
+    private resolveOnce<T extends { new(...args: any[]): any }>(component: T): InstanceType<T> {
+        switch (true) {
+            case A_CommonHelper.isInheritedFrom(component, A_Fragment): {
+                return this.resolveFragment(component);
+            }
+
+            case this.components.includes(component) && this._components.has(component): {
+
+                return this._components.get(component);
+            }
+            case this.components.includes(component) && !this._components.has(component): {
+
+                const argsMeta = A_STORAGE__A_Inject_Instructions.get(component);
+
+                let resolvedArgs: Array<any> = [];
+
+                if (argsMeta)
+                    resolvedArgs = (argsMeta.get('constructor') || [])
+                        .map(arg => this.resolve(arg));
+
+                this._components.set(component, new component());
+
+                return this._components.get(component);
+            }
+
+            case !this.components.includes(component) && !!this.parent: {
+
+                return this.parent.resolve(component);
+            }
+            default:
+                throw new Error(`Component ${component.name} not found in the scope`);
+        }
+    }
+
+
+
+    private resolveFragment<T extends { new(...args: any[]): any }>(fragment: T): InstanceType<T> {
+
+        if (this._fragments.has(fragment)) {
+            return this._fragments.get(fragment);
+        }
+
+        if (this.parent) {
+            return this.parent.resolveFragment(fragment);
+        }
+
+        throw new Error(`Fragment ${fragment.name} not found in the scope ${this.name}`);
+    }
+
+
+
+    register(fragment: A_Fragment): void {
+        this._fragments.set(fragment.constructor, fragment);
+    }
+}

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

@@ -0,0 +1,37 @@
+import { A_Fragment } from "../A-Fragment/A-Fragment.class"
+import { A_Scope } from "./A-Scope.class"
+
+
+export type A_TYPES__ScopeConstructor = {
+
+    /**
+     * Scope Name
+     */
+    name: string,
+    /**
+     * A list of Context Fragments available in the Scope
+     */
+    fragments: Array<A_Fragment>
+    /**
+     * A set of Components available in the Scope
+     */
+    components: Array<{ new(...args: any[]): any }>
+
+
+    /**
+     * A list of Features/Lifecycle Hooks available in the Scope
+     */
+    import: Array<string>,
+    /**
+     * A list of Features/Lifecycle Hooks available to be exported from the Scope
+     */
+    export: Array<string>
+}
+
+
+export type A_TYPES__ScopeConfig = {
+    /**
+     * Allows to define a parent to take dependencies from in case of the current scope does not have the required component
+     */
+    parent: A_Scope
+}

package/src/storage/A_Component.storage.ts

@@ -0,0 +1,28 @@
+// =================================================================================================
+// ========== Component Storage ====================================================================
+// =================================================================================================
+
+import { A_Component } from "../global/A-Component/A-Component.class";
+
+
+// -------------------------------------------------------------------------------
+// ----- A Concept -> Component Declaration -> Symbol Declaration Keys --------------- 
+// -------------------------------------------------------------------------------
+export const A_COMPONENT_STORAGE__Definition__Extensions = Symbol('a-container-extensions');
+export const A_COMPONENT_STORAGE__Definition__Feature = Symbol('a-container-feature');
+
+
+
+/**
+ * 
+ * This storage is used to store the containers metadata, definitions and configurations
+ */
+export const A_COMPONENT_Storage: Map<
+    typeof A_Component | { new(...args: any[]): any },
+    Map<
+        Symbol | string,
+        any
+    >
+> = new Map();
+
+

package/src/storage/A_Concept.storage.ts

@@ -2,6 +2,9 @@
 
 // --------------------------------------------------------------
 // ----- A Concept -> Module Declaration -> Main Config ---------
+
+import { A_Container } from "../global/A-Container/A-Container.class";
+
 // --------------------------------------------------------------
 export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Config = Symbol('a-concept-modules-declaration');
 
@@ -42,4 +45,5 @@ export const A_CONCEPT_LifecycleDeclarationsStorage: Map<Symbol, any> = new Map(
  * The simplest way to store the decorators
  * If any extra API is needed, it can be added here or replaced with a new class
  */
-export const A_CONCEPT_Storage = new WeakMap();
+export const A_CONCEPT_Storage = new WeakMap();
+

package/src/storage/A_Container.storage.ts

@@ -0,0 +1,21 @@
+// =================================================================================================
+// ========== Container Storage ====================================================================
+// =================================================================================================
+
+import { A_Container } from "../global/A-Container/A-Container.class";
+
+// -------------------------------------------------------------------------------
+// ----- A Concept -> Container Declaration -> Symbol Declaration Keys --------------- 
+// -------------------------------------------------------------------------------
+export const A_CONTAINER_STORAGE__Definition__Lifecycle = Symbol('a-container-lifecycle');
+export const A_CONTAINER_STORAGE__Definition__Feature = Symbol('a-container-feature');
+
+
+
+/**
+ * This storage is used to store the containers metadata, definitions and configurations
+ * 
+ */
+export const A_CONTAINER_Storage: WeakMap<typeof A_Container.constructor, Map<Symbol | string, any>> = new WeakMap();
+
+