@adaas/a-concept 0.0.3 → 0.0.4

package/src/decorators/A-Feature/A-Feature-Extend.decorator.ts

@@ -0,0 +1,57 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import {
+    A_TYPES__A_ExtendDecoratorConfig,
+    A_TYPES__A_ExtendDecoratorDescriptor,
+} from "./A-Feature.decorator.types";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.types";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+
+
+
+
+/**
+ * A-Extend decorator
+ * 
+ * This decorator allows to define a custom Extend stage for the Container.
+ * These stages are executed in a container-specific order and can be extended by components that are injected into the container.
+ * This approach allows to create a flexible and extendable architecture for the application.
+ * 
+ * The main difference between the A-Extend and A-Extend decorators is that A-Extend methods can be inherited and overridden by child classes.
+ * 
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Feature_Extend(
+    config: Partial<A_TYPES__A_ExtendDecoratorConfig> = {}
+) {
+    return function (
+        target: A_Component,
+        propertyKey: string,
+        descriptor: A_TYPES__A_ExtendDecoratorDescriptor
+    ) {
+
+        // Get the existed metadata or create a new one
+        const existedMeta = A_Context
+            .meta(target)
+            .get(A_TYPES__ComponentMetaKey.EXTENSIONS)
+            || new Map();
+
+        // Set the metadata of the method to define a custom Feature with name
+        existedMeta.set(propertyKey, {
+            name: config.name || propertyKey,
+            handler: propertyKey,
+            container: config.container
+                ? typeof config.container === 'string'
+                    ? config.container
+                    : config.container.name
+                : '*',
+        });
+
+        //  Update the metadata of the container with the new Feature definition
+        A_Context
+            .meta(target)
+            .set(A_TYPES__ComponentMetaKey.EXTENSIONS, existedMeta);
+
+    };
+}

package/src/decorators/A-Feature/A-Feature.decorator.types.ts

@@ -0,0 +1,56 @@
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class"
+
+
+export type A_TYPES__A_FeatureDecoratorDescriptor =
+
+    TypedPropertyDescriptor<() => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => Promise<any>>
+    |
+    TypedPropertyDescriptor<() => Promise<any>>
+
+
+export type A_TYPES__A_FeatureDecoratorConfig = {
+    name: string,
+}
+
+
+
+export type A_TYPES__A_ExtendDecoratorDescriptor =
+
+    TypedPropertyDescriptor<() => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => Promise<any>>
+    |
+    TypedPropertyDescriptor<() => Promise<any>>
+
+
+export type A_TYPES__A_ExtendDecoratorConfig = {
+    /**
+     * Name of the container Lifecycle method to be extended.
+     * 
+     * [!] If not provided will be used the name of the method.
+     */
+    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.
+     */
+    container: string | typeof A_Container<any>
+}
+
+
+

package/src/decorators/A-Inject/A-Inject.decorator.ts

@@ -1,6 +1,15 @@
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
-import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_TYPES__A_InjectDecoratorReturn, A_TYPES__A_InjectDecoratorStorageInstruction } from "./A-Inject.decorator.types";
+import { A_STORAGE__A_Inject_Instructions } from "@adaas/a-concept/storage/A_Inject.storage";
+import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.types";
+
+
+
+
 
 /**
  * A-Inject decorator
@@ -13,63 +22,66 @@ import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.cla
  * @param params 
  * @returns 
  */
+export function A_Inject(
+    scope: typeof A_Scope
+): A_TYPES__A_InjectDecoratorReturn
+
+export function A_Inject(
+    component: typeof A_Component
+): A_TYPES__A_InjectDecoratorReturn
+export function A_Inject(
+    component: { new(...args: any[]): any }
+): A_TYPES__A_InjectDecoratorReturn
+
+//  Allows to inject just one container
+export function A_Inject(
+    container: typeof A_Container
+): A_TYPES__A_InjectDecoratorReturn
+
+// Allows to inject just one Context Fragment
+export function A_Inject(
+    fragment: typeof A_Fragment
+): A_TYPES__A_InjectDecoratorReturn
+
+// Allows to inject multiple Fragments 
 export function A_Inject<
-    T extends { new(...args: any[]): A_Component }
->(
-    component: T
-)
-export function A_Inject<
-    T extends { new(...args: any[]): A_Namespace }
->(
-    namespace: T
-)
-export function A_Inject<
-    E extends { new(...args: any[]): A_Namespace },
-    T extends Array<E>
+    T extends Array<typeof A_Fragment>
 >(
-    namespaces: T
-)
+    fragments: T
+): A_TYPES__A_InjectDecoratorReturn
+
+// ====================== BASE FUNCTION ======================
 export function A_Inject<
-    E extends { new(...args: any[]): A_Namespace },
-    K extends { new(...args: any[]): A_Component },
-    T extends Array<E>
+    T extends Array<typeof A_Fragment>
 >(
-    param1: T | E | K
-) {
-    switch (true) {
-        case param1 instanceof A_Component:
-            return function (
-                target: T,
-                propertyKey: string | symbol,
-                parameterIndex: number
-            ) {
-                //  It should be just register the parameter in method that will be resolved in the method
-            }
-        case param1 instanceof A_Namespace:
-            return function (
-                target: T,
-                propertyKey: string | symbol,
-                parameterIndex: number
-            ) {
-                //  It should be just register the parameter in method that will be resolved in the method
-            }
-    }
+    param1: T | typeof A_Fragment | typeof A_Component | typeof A_Container | typeof A_Fragment,
+): A_TYPES__A_InjectDecoratorReturn {
+    return function (
+        target: A_Component,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) {
 
-    // const namespaces: Array<typeof A_Namespace> = [
-    //     ...(Array.isArray(param1) ? param1 : [param1])
-    // ];
+        const method = methodName ? methodName : 'constructor';
 
-    // const resolvedNamespaces: Array<A_Namespace> = []
 
-    // for (const namespace of namespaces) {
-    //     resolvedNamespaces.push(A_Context.resolve(namespace));
-    // }
+        const existedMeta = A_Context
+            .meta(target)
+            .get(A_TYPES__ComponentMetaKey.INJECTIONS)
+            || new Map();
 
-    // return function (
-    //     target: T | E,
-    //     propertyKey: string | symbol,
-    //     parameterIndex: number
-    // ) {
-    //     //  It should be just register the parameter in method that will be resolved in the method
-    // }
+        const paramsArray = existedMeta.get(method) || [];
+
+        paramsArray[parameterIndex] = param1;
+
+        existedMeta.set(method, paramsArray);
+
+
+        A_Context
+            .meta(target)
+            .set(
+                A_TYPES__ComponentMetaKey.INJECTIONS,
+                existedMeta
+            )
+    }
 }

package/src/decorators/A-Inject/A-Inject.decorator.types.ts

@@ -1,10 +1,37 @@
+
 export type A_TYPES__A_InjectDecoratorDescriptor = TypedPropertyDescriptor<(
     ...args: any[]
 ) => Promise<void>>
 
 
+export type A_TYPES__A_InjectDecoratorReturn<T = any> = (
+    target: T,
+    propertyKey: string | symbol | undefined,
+    parameterIndex: number
+) => void
+
+
+// export type A_TYPES__A_InjectDecoratorStorageInstruction = {
+//     index: number,
+//     type: typeof A_Namespace
+//     | typeof A_Component
+//     | typeof A_Container
+//     | typeof A_ContextFragment
+//     | Array<typeof A_Namespace>
+//     | Array<typeof A_Component>
+//     | Array<typeof A_Container>
+//     | Array<typeof A_ContextFragment>
+//     | { new(...args: any[]): any }
+// }  
 
-export type A_TYPES__A_InjectDecoratorStorageInstruction = {
-    handler: string,
-    // config: A_TYPES__A_InjectDecoratorConfig
-}
+export type A_TYPES__A_InjectDecoratorStorageInstruction = Array<
+    // typeof A_Namespace
+    // | typeof A_Component
+    // | typeof A_Container
+    // | typeof A_ContextFragment
+    // | Array<typeof A_Namespace>
+    // | Array<typeof A_Component>
+    // | Array<typeof A_Container>
+    // | Array<typeof A_ContextFragment>
+    | { new(...args: any[]): any }
+> 

package/src/decorators/A-Stage/A-Stage.decorator.ts

@@ -0,0 +1,57 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import {
+    A_TYPES__A_StageDecoratorConfig,
+    A_TYPES__A_StageDecoratorDescriptor,
+} from "./A-Stage.decorator.types";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.types";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.types";
+import { A_TYPES__ConceptStage } from "@adaas/a-concept/global/A-Concept/A_Concept.types";
+
+
+
+
+/**
+ * A_Stage Decorator uses to extend basic A-Concept Stage methods inside Containers.
+ * 
+ * Using this decorator you can define extend a logic and sequence of the Container Stage methods execution.  
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Stage(
+    method: A_TYPES__ConceptStage
+) {
+
+
+    return function A_Stage(
+        config: Partial<A_TYPES__A_StageDecoratorConfig> = {}
+    ) {
+        return function (
+            target: A_Container<any>,
+            propertyKey: string,
+            descriptor: A_TYPES__A_StageDecoratorDescriptor
+        ) {
+
+            // Get the existed metadata or create a new one
+            const existedMeta = A_Context
+                .meta(target)
+                .get(A_TYPES__ContainerMetaKey.STAGES)
+                || new Map();
+
+            // Set the metadata of the method to define a custom Stage with name
+            existedMeta
+                .set(propertyKey, {
+                    name: method,
+                    handler: propertyKey,
+                });
+
+            //  Update the metadata of the container with the new Stage definition
+            A_Context
+                .meta(target)
+                .set(A_TYPES__ContainerMetaKey.STAGES, existedMeta);
+
+        };
+    }
+}

package/src/decorators/A-Stage/A-Stage.decorator.types.ts

@@ -0,0 +1,23 @@
+import { A_Concept } from "@adaas/a-concept/global/A-Concept/A_Concept.class"
+import { A_TYPES__ConceptStage } from "@adaas/a-concept/global/A-Concept/A_Concept.types"
+
+export type A_TYPES__A_StageDecoratorDescriptor =
+
+    TypedPropertyDescriptor<() => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => Promise<any>>
+    |
+    TypedPropertyDescriptor<() => Promise<any>>
+
+
+export type A_TYPES__A_StageDecoratorConfig = {
+}
+
+
+

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

@@ -0,0 +1,48 @@
+
+
+/**
+ * A_Channel is an abstraction over any Communication Type from event emitters to message queues, HTTP requests, etc.
+ * 
+ * A_Channel uses to connect Containers between each other. When
+ * When One container needs to communicate with another container, it uses A_Channel.
+ * 
+ */
+export class A_Channel<T> {
+    private proxyInstance: T | null = null;
+    private realInstance: T | null = null;
+
+    constructor(
+        private realClass: { new(...args: any[]): T },
+        private args: any[]
+    ) {
+
+    }
+
+    protected async loadInstance(): Promise<T> {
+        if (!this.realInstance)
+            this.realInstance = new this.realClass(...this.args);
+
+        return this.realInstance;
+    }
+
+
+    public async resolve(): Promise<T> {
+        if (!this.proxyInstance) {
+            const realInstance = await this.loadInstance();
+
+            this.proxyInstance = new Proxy({}, {
+                get: (target, prop) => {
+                    const value = (realInstance as any)[prop];
+
+                    // If the property is a method, return a bound function
+                    if (typeof value === 'function') {
+                        return value.bind(realInstance);
+                    }
+                    return value;
+                }
+            }) as T;
+        }
+
+        return this.proxyInstance;
+    }
+}

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

@@ -0,0 +1,60 @@
+
+
+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',
+
+    /**
+     * 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-Component/A-Component.class.ts

@@ -1,33 +1,5 @@
-import { A_Namespace } from "../A-Namespace/A_Namespace.class";
-
-
-
 /**
  * This element only contains the specific code
  * 
  */
-export class A_Component<T extends A_Namespace = A_Namespace> {
-
-    constructor(
-        /**
-         * Primary context that impacts the component behavior
-         */
-        protected namespace: A_Namespace
-    ) {
-
-    }
-
-
-
-
-    // constructor(
-    //     private auth: A_AUTH_Context,
-    //     private arc: A_ARC_Context,
-    //     private products: A_PRODUCTS_Context,
-    //     private express: A_EXPRESS_Context,
-    // ) { 
-
-    // }
-
-
-}
+export class A_Component { }

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

@@ -0,0 +1,9 @@
+import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_TYPES__ComponentMeta } from "./A-Component.types";
+
+
+export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
+
+
+
+}

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

@@ -0,0 +1,40 @@
+
+
+export type A_TYPES__ComponentMeta = {
+    [A_TYPES__ComponentMetaKey.EXTENSIONS]: Map<string, A_TYPES__ComponentMeta_ExtensionItem>,
+    [A_TYPES__ComponentMetaKey.FEATURES]: any[],
+    [A_TYPES__ComponentMetaKey.INJECTIONS]: Map<
+        // Where key is method name
+        Symbol | string,
+        // And value is Injection instructions
+        A_TYPES__ComponentMeta_InjectionParams
+    >
+
+}
+
+export enum A_TYPES__ComponentMetaKey {
+    EXTENSIONS = 'a-component-extensions',
+    FEATURES = 'a-component-features',
+    INJECTIONS = 'a-component-injections',
+}
+
+
+export type A_TYPES__ComponentMeta_ExtensionItem = {
+    name: string,
+    container: string,
+    handler: string,
+}
+
+
+export type A_TYPES__ComponentMeta_InjectionParams = Array<
+    // typeof A_Namespace
+    // | typeof A_Component
+    // | typeof A_Container
+    // | typeof A_ContextFragment
+    // | Array<typeof A_Namespace>
+    // | Array<typeof A_Component>
+    // | Array<typeof A_Container>
+    // | Array<typeof A_ContextFragment>
+    | { new(...args: any[]): any }
+>
+