@adaas/a-concept 0.0.3 → 0.0.5

package/src/global/A-Dependency/A-DependencyReference.types.ts

@@ -1,61 +1,61 @@
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class"
+// import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class"
 
 
-export type A_TYPES__A_DependencyReferenceConstructor = {
-    /**
-     * The name of the dependency 
-     */
-    name: string
-    /**
-     * The version of the module 
-     * By default it is 1.0.0
-     */
-    version: string
-    /**
-     * The dependencies of the module 
-     * Could be:
-     * - other Modules
-     * - other Contexts
-     * 
-     */
-    dependencies: Array<typeof A_Namespace>
-    /**
-     * The source of the dependency 
-     * Could be:
-     * - a string representing the path to the module
-     * - a module class  (in case when config should be provided via the module constructor)
-     * - a module class constructor
-     * - a context class (in case when config should be provided via the context constructor)
-     * - a context class constructor
-     * 
-     */
-    // source: A_Module | A_Context | typeof A_Module | typeof A_Context | string
-    source: A_Namespace
-}
+// export type A_TYPES__A_DependencyReferenceConstructor = {
+//     /**
+//      * The name of the dependency 
+//      */
+//     name: string
+//     /**
+//      * The version of the module 
+//      * By default it is 1.0.0
+//      */
+//     version: string
+//     /**
+//      * The dependencies of the module 
+//      * Could be:
+//      * - other Modules
+//      * - other Contexts
+//      * 
+//      */
+//     dependencies: Array<typeof A_Namespace>
+//     /**
+//      * The source of the dependency 
+//      * Could be:
+//      * - a string representing the path to the module
+//      * - a module class  (in case when config should be provided via the module constructor)
+//      * - a module class constructor
+//      * - a context class (in case when config should be provided via the context constructor)
+//      * - a context class constructor
+//      * 
+//      */
+//     // source: A_Module | A_Context | typeof A_Module | typeof A_Context | string
+//     source: A_Namespace
+// }
 
 
-export type A_TYPES__A_DependencyReferenceConstructorConfig = {
-    /**
-     * Sync  - blocks A-Express Application initialization until module is ready 
-     * Async - allows to initialize module after A-Express Application initialization
-     */
-    behavior: 'async' | 'sync',
+// export type A_TYPES__A_DependencyReferenceConstructorConfig = {
+//     /**
+//      * Sync  - blocks A-Express Application initialization until module is ready 
+//      * Async - allows to initialize module after A-Express Application initialization
+//      */
+//     behavior: 'async' | 'sync',
 
-    /**
-     * Allows to define a scheme of retries
-     */
-    retries: {
-        /**
-         * The number of retries
-         * Default is 3
-         */
-        n: number,
-        /**
-         * The timeout between retries
-         * Multiplied by the number of retries 
-         * So after each retry the timeout is increased e.g. 1000ms * 1, 1000ms * 2, 1000ms * 3
-         * Default is 1000
-         */
-        timeout: number
-    }
-}
+//     /**
+//      * Allows to define a scheme of retries
+//      */
+//     retries: {
+//         /**
+//          * The number of retries
+//          * Default is 3
+//          */
+//         n: number,
+//         /**
+//          * The timeout between retries
+//          * Multiplied by the number of retries 
+//          * So after each retry the timeout is increased e.g. 1000ms * 1, 1000ms * 2, 1000ms * 3
+//          * Default is 1000
+//          */
+//         timeout: number
+//     }
+// }

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

@@ -0,0 +1,141 @@
+import { A_Error, ASEID } from "@adaas/a-utils";
+
+import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
+import { A_TYPES__Entity_JSON, A_TYPES__IEntity } from "./A-Entity.types";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+
+/**
+ * A_Entity is another abstraction that describes all major participants in the system business logic.
+ * Each Entity should have a clear definition and a clear set of responsibilities. 
+ * However, entity may hide some of its responsibilities behind the interface to prevent overload. 
+ * 
+ * Each entity should be connected to the ContextFragment (Scope) and should be able to communicate with other entities.
+ */
+export class A_Entity<
+    _ConstructorType = any,
+    _SerializedType extends A_TYPES__Entity_JSON = A_TYPES__Entity_JSON,
+>
+    extends A_Fragment
+    implements A_TYPES__IEntity {
+
+    aseid!: ASEID;
+
+
+    constructor(
+        aseid: string
+    )
+    constructor(
+        aseid: ASEID
+    )
+    constructor(
+        serialized: _SerializedType
+    )
+    constructor(
+        newEntity: _ConstructorType
+    )
+    constructor(props: string | ASEID | _SerializedType | _ConstructorType) {
+        super();
+
+        switch (true) {
+            case (typeof props === 'string' && ASEID.isASEID(props)):
+                this.aseid = new ASEID(props);
+                break;
+            case (props instanceof ASEID):
+                this.aseid = props;
+                break;
+            case (typeof props === 'object' && (props as any).aseid):
+                this.fromSerialized(props as _SerializedType);
+                break;
+
+            case (typeof props === 'object'):
+                this.fromNewEntity(props as _ConstructorType);
+                break
+
+            default:
+                throw new A_Error(A_CONSTANTS__DEFAULT_ERRORS.INCORRECT_A_ENTITY_CONSTRUCTOR);
+        }
+
+    }
+
+    // ====================================================================
+    // ================== DUPLICATED ASEID Getters ========================
+    // ====================================================================
+
+    /**
+     * Extracts the ID from the ASEID
+     * ID is the unique identifier of the entity
+     */
+    get id(): string | number {
+        return this.aseid.id;
+    }
+
+    /**
+     * Extracts the namespace from the ASEID
+     * namespace is an application specific identifier from where the entity is coming from
+     */
+    get namespace(): string {
+        return this.aseid.namespace
+    }
+
+    /**
+     * Extracts the scope from the ASEID
+     * scope is the scope of the entity from Application Namespace
+     */
+    get scope(): string {
+        return this.aseid.scope;
+    }
+
+    /**
+     * Extracts the entity from the ASEID
+     * entity is the name of the entity from Application Namespace
+     */
+    get entity(): string {
+        return this.aseid.entity;
+    }
+
+    /**
+     * Extracts the version from the ASEID
+     * version is the version of the entity
+     */
+
+    get version(): string | undefined {
+        return this.aseid.version;
+    }
+
+    /**
+     * Extracts the shard from the ASEID
+     * shard is the shard of the entity
+     */
+    get shard(): string | undefined {
+        return this.aseid.shard;
+    }
+
+
+    protected fromNewEntity(newEntity: _ConstructorType): void {
+        return;
+    }
+
+    protected fromSerialized(serialized: _SerializedType): void {
+        this.aseid = new ASEID((serialized).aseid);
+        return;
+    }
+
+
+    /**
+     * Converts the entity to a JSON object 
+     * 
+     * 
+     * @returns 
+     */
+    toJSON(): _SerializedType {
+        return {
+            aseid: this.aseid.toString()
+        } as _SerializedType;
+    }
+
+
+
+    toString(): string {
+        return this.aseid.toString();
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ASEID } from "@adaas/a-utils";
+
+export interface A_TYPES__IEntity {
+    /**
+     * The ASEID of the entity
+     */
+    aseid: ASEID
+};
+
+
+export type A_TYPES__Entity_JSON = {
+    /**
+     * The ASEID of the entity
+     */
+    aseid: string
+};
+

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,96 @@
+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];
+    }
+
+
+    // Delete a key-value pair by key
+    delete(key: keyof _StorageItems): boolean {
+        return this.meta.delete(key);
+    }
+
+    // Search for keys by regex
+    findByRegex(regex: RegExp): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+        const results: Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> = [];
+        for (const [key, value] of this.meta.entries()) {
+            if (regex.test(String(key))) {
+                results.push([key, value]);
+            }
+        }
+        return results;
+    }
+
+    // Check if a key exists
+    has(key: keyof _StorageItems): boolean {
+        return this.meta.has(key);
+    }
+
+    // Get all entries in the map
+    entries(): IterableIterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+        return this.meta.entries();
+    }
+
+
+    // Clear all entries
+    clear(): void {
+        this.meta.clear();
+    }
+
+
+
+}
+
+