@adaas/a-concept 0.0.28 → 0.0.30

package/examples/fe-be/components/BE-Controller.component.ts

@@ -0,0 +1,20 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+
+
+
+export class BEController extends A_Component {
+
+
+
+    @A_Feature.Define({
+        name: 'getOrdersCount',
+        // channel
+    })
+    getOrdersCount() {
+
+        return 0;
+    }
+
+
+}

package/examples/fe-be/components/FE.component.ts

@@ -0,0 +1,13 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Concept } from "@adaas/a-concept/global/A-Concept/A_Concept.class";
+
+
+
+export class FEComponent extends A_Component {
+
+
+    @A_Concept.Load()
+    async renderHomePage() {
+
+    }
+}

package/examples/fe-be/containers/ServerApp.container.ts

@@ -0,0 +1,8 @@
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+
+
+export class ServerApp extends A_Container {
+
+
+
+}

package/examples/fe-be/containers/WebApp.container.ts

@@ -0,0 +1,13 @@
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+
+
+
+export class WebApp extends A_Container {
+
+
+
+
+
+
+
+}

package/examples/multi-container/channels/Direct.channel.ts

@@ -0,0 +1,39 @@
+import { A_Channel } from "@adaas/a-concept/global/A-Channel/A-Channel.class";
+import { A_TYPES__A_ChannelAggregateMethods, A_TYPES__A_ChannelCallParams } from "@adaas/a-concept/global/A-Channel/A-Channel.types";
+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";
+
+
+export class DirectChannel<
+    T extends A_Container<any>,
+> extends A_Channel<[T]> {
+
+    protected instance: T
+
+    constructor(
+        public container: T
+    ) {
+        super({
+            id: `direct-channel--${container.name}`
+        });
+
+        this.instance = container;
+    }
+
+
+    async call<_Resp extends unknown>(
+        prop: A_TYPES__A_ChannelAggregateMethods<[T]>,
+        params?: Partial<A_TYPES__A_ChannelCallParams>
+    ): Promise<_Resp> {
+
+        if (!this.instance[prop]) {
+            throw new Error(`Method ${prop} not found in ${this.instance.name}`);
+        }
+
+        return await (this.instance[prop] as any)(params) as Promise<_Resp>;
+    }
+
+}
+
+
+

package/examples/multi-container/containers/Command.container.ts

@@ -0,0 +1,41 @@
+import { A_Connect } from "@adaas/a-concept/decorators/A-Connect/A-Connect.decorator";
+import { A_Channel } from "@adaas/a-concept/global/A-Channel/A-Channel.class";
+import { A_TYPES__A_ChannelCallParams } from "@adaas/a-concept/global/A-Channel/A-Channel.types";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { ScheduleContainer } from "./Schedule.container";
+
+
+
+export class CommandContainer extends A_Container<[
+    'execute',
+]> {
+
+    constructor() {
+        super({});
+    }
+
+
+
+    @A_Feature.Define({
+        name: 'execute',
+        // channels: []
+    })
+    async execute(
+        arg: Partial<A_TYPES__A_ChannelCallParams>
+    ) {
+        console.log('CommandContainer -> command()');
+    }
+
+
+
+
+    async doSomething(
+        @A_Connect(A_Channel, '') schedule: A_Channel<[ScheduleContainer]>
+    ) {
+
+        schedule.call('schedule', {});
+
+    }
+
+}

package/examples/multi-container/containers/Schedule.container.ts

@@ -0,0 +1,57 @@
+import { A_Connect } from "@adaas/a-concept/decorators/A-Connect/A-Connect.decorator";
+import { A_Feature_Define } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Define.decorator";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Channel } from "@adaas/a-concept/global/A-Channel/A-Channel.class";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { CommandContainer } from "./Command.container";
+import { A_TYPES__A_ExecutableMethods } from "@adaas/a-concept/global/A-Channel/A-Channel.types";
+
+
+export class ScheduleContainer extends A_Container<[
+    'schedule',
+    'start',
+    'stop',
+    'pause',
+]> {
+
+    private tasks = [];
+
+
+    constructor() {
+        super({});
+    }
+
+
+
+    @A_Feature_Define({
+        name: 'schedule',
+        // channels: []
+    })
+    async schedule(
+        // @A_Inject('task') task: any
+    ) {
+        console.log('ScheduleContainer -> schedule()');
+    }
+
+
+
+    @A_Feature_Define({
+        name: 'start',
+        // channels: []
+    })
+    async start() {
+        console.log('ScheduleContainer -> start()');
+    }
+
+
+
+    async onExecution(
+        @A_Connect(A_Channel, '') commands: A_Channel<[CommandContainer]>
+    ) {
+        const result = await commands.call('execute', {
+            fragments: []
+        });
+
+    }
+
+}

package/examples/simple/components/A.component.ts

@@ -16,7 +16,8 @@ export class ComponentA extends A_Component {
     @A_Feature.Extend()
     async method_A(
         @A_Inject(ContextFragmentA) fragmentA: ContextFragmentA,
-        @A_Inject(A_Logger) logger: A_Logger
+        @A_Inject(A_Logger) logger: A_Logger,
+
     ) {
         logger.log('red', 'Component A ->  method_A()');
         fragmentA.decrement();

package/examples/simple/containers/Main.container.ts

@@ -7,6 +7,7 @@ import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorato
 import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_Logger } from "@adaas/a-concept/base/A-Logger/A-Logger.component";
 import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { EntityA } from "../entities/EntityA.entity";
 
 
 
@@ -49,6 +50,13 @@ export class MainContainer extends A_Container<
     ) {
         console.log('Method B', A_Context.root);
 
+        const entity = new EntityA('test@test:test:0000000001');
+
+        this.Scope.register(entity);
+
+        await entity.doSomething();
+
+
         const logger = this.Scope.resolve(A_Logger);
 
         // or  you can manually call the feature
@@ -57,10 +65,10 @@ export class MainContainer extends A_Container<
             fragments: [new ContextFragmentA(), new ContextFragmentB()]
         });
 
-        for (const step of feature) {
-            logger.log('Manual Loop Execution Step', feature.current);
+        for (const stage of feature) {
+            logger.log('Manual Loop Execution Step', feature.stage);
 
-            await step();
+            await stage.process();
         }
     }
 }

package/examples/simple/entities/EntityA.entity.ts

@@ -0,0 +1,16 @@
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_TYPES__EntityBaseMethods } from "@adaas/a-concept/global/A-Entity/A-Entity.types";
+
+
+
+export class EntityA extends A_Entity<any, any, [
+    ...A_TYPES__EntityBaseMethods,
+    'doSomething'
+]> {
+
+
+
+    async doSomething() {
+        await this.call('doSomething');
+    }
+}

package/examples/simple-http-server/contexts/http-request.context.ts

@@ -33,13 +33,13 @@ export class HTTPRequest extends A_Fragment {
     }
 
 
-    async toJSON<T extends any>(): Promise<T> {
-        if (!this._body) {
-            this._body = await this.parseBody();
-        }
+    // async toJSON<T extends any>(): Promise<T> {
+    //     if (!this._body) {
+    //         this._body = await this.parseBody();
+    //     }
 
-        return this._body;
-    }
+    //     return this._body;
+    // }
 
     private parseBody(): Promise<any> {
         return new Promise((resolve, reject) => {

package/index.ts

@@ -1,7 +1,7 @@
-
 // =================================================================================================
 // ============================= Export Framework Components =======================================
 // =================================================================================================
+
 // ---------------------- Major Components ----------------------
 export { A_Context } from './src/global/A-Context/A-Context.class';
 // export * from './src/global/A-Context/A-Context.types';
@@ -23,9 +23,15 @@ export * from './src/global/A-Entity/A-Entity.types';
 
 
 // ---------------------- Common Components ----------------------
+export { A_Channel } from './src/global/A-Channel/A-Channel.class';
+export * from './src/global/A-Channel/A-Channel.types';
+
 export { A_Feature } from './src/global/A-Feature/A-Feature.class';
 export * from './src/global/A-Feature/A-Feature.types';
 
+export { A_Stage } from './src/global/A-Stage/A-Stage.class';
+export * from './src/global/A-Stage/A-Stage.types';
+
 export { A_Scope } from './src/global/A-Scope/A-Scope.class';
 export * from './src/global/A-Scope/A-Scope.types';
 
@@ -47,8 +53,11 @@ export { A_Feature_Define } from './src/decorators/A-Feature/A-Feature-Define.de
 export { A_Feature_Extend } from './src/decorators/A-Feature/A-Feature-Extend.decorator';
 export * from './src/decorators/A-Feature/A-Feature.decorator.types';
 
-export { A_Stage } from './src/decorators/A-Stage/A-Stage.decorator';
-export * from './src/decorators/A-Stage/A-Stage.decorator.types';
+export { A_Abstraction } from './src/decorators/A-Abstraction/A-Abstraction.decorator';
+export * from './src/decorators/A-Abstraction/A-Abstraction.decorator.types';
+
+export { A_Connect } from './src/decorators/A-Connect/A-Connect.decorator';
+export * from './src/decorators/A-Connect/A-Connect.decorator.types';
 
 
 // =================================================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/base/A-Config/components/ConfigReader.component.ts

@@ -55,23 +55,24 @@ export class ConfigReader extends A_Component {
 
     /**
      * Finds the root directory of the project by locating the folder containing package.json
+     * 
      * @param {string} startPath - The initial directory to start searching from (default is __dirname)
      * @returns {string|null} - The path to the root directory or null if package.json is not found
      */
     protected async getProjectRoot(startPath = __dirname) {
-        let currentPath = startPath;
+        // let currentPath = startPath;
 
-        const fs = await A_Polyfills.fs();
+        // const fs = await A_Polyfills.fs();
 
-        while (!fs.existsSync(`${currentPath}/package.json`)) {
-            const parentPath = currentPath.substring(0, currentPath.lastIndexOf('/'));
-            if (parentPath === currentPath || parentPath === '') {
-                // Reached the root of the filesystem without finding package.json
-                return null;
-            }
-            currentPath = parentPath;
-        }
+        // while (!fs.existsSync(`${currentPath}/package.json`)) {
+        //     const parentPath = currentPath.substring(0, currentPath.lastIndexOf('/'));
+        //     if (parentPath === currentPath || parentPath === '') {
+        //         // Reached the root of the filesystem without finding package.json
+        //         return null;
+        //     }
+        //     currentPath = parentPath;
+        // }
 
-        return currentPath;
+        return process.cwd();
     }
 }

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

@@ -0,0 +1,82 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import {
+    A_TYPES__A_AbstractionDecoratorDescriptor,
+} from "./A-Abstraction.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__ConceptAbstraction, A_TYPES__ConceptStage } from "@adaas/a-concept/global/A-Concept/A_Concept.types";
+import { A_ContainerMeta } from "@adaas/a-concept/global/A-Container/A-Container.meta";
+import { A_ComponentMeta } from "@adaas/a-concept/global/A-Component/A-Component.meta";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
+import { A_TYPES__A_ExtendDecoratorConfig } from "../A-Feature/A-Feature.decorator.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_Abstraction(
+    method: A_TYPES__ConceptStage,
+    config: Partial<A_TYPES__A_ExtendDecoratorConfig> = {}
+) {
+    return function (
+        target: A_Container<any> | A_Component,
+        propertyKey: string,
+        descriptor: A_TYPES__A_AbstractionDecoratorDescriptor
+    ) {
+
+        const meta: A_ContainerMeta | A_ComponentMeta = A_Context.meta(target as any);
+
+        let metaKey;
+
+        const StageKey = `CONCEPT_ABSTRACTION::${method}`;
+
+        switch (true) {
+            case target instanceof A_Container:
+                metaKey = A_TYPES__ContainerMetaKey.ABSTRACTIONS
+                break;
+            case target instanceof A_Component:
+                metaKey = A_TYPES__ComponentMetaKey.ABSTRACTIONS
+                break;
+            default:
+                throw new Error(`Concept Stage cannot be defined on the ${target} level`);
+        }
+
+        // Get the existed metadata or create a new one
+        const existedMeta: A_Meta<{
+            [Key: string]: A_TYPES__ConceptAbstraction[];
+        }> = meta.get(metaKey) || new A_Meta();
+
+        // Set the metadata of the method to define a custom Stage with name
+        const existedMetaValue = existedMeta.get(StageKey) || [];
+
+
+        // Add the new method to the metadata
+        existedMetaValue.push({
+            name: method,
+            handler: propertyKey,
+            before: config.before || [],
+            after: config.after || [],
+            behavior: config.behavior || 'sync'
+        });
+
+        // Set the metadata of the method to define a custom Feature with name
+        existedMeta.set(StageKey, existedMetaValue);
+
+
+        //  Update the metadata of the container with the new Stage definition
+        A_Context
+            .meta(target as any)
+            .set(
+                metaKey,
+                existedMeta
+            );
+
+    };
+}

package/src/decorators/{A-Stage/A-Stage.decorator.types.ts → A-Abstraction/A-Abstraction.decorator.types.ts}

@@ -1,7 +1,5 @@
-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 =
+export type A_TYPES__A_AbstractionDecoratorDescriptor =
 
     TypedPropertyDescriptor<() => any>
     |

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

@@ -0,0 +1,71 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+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_ContainerMeta } from "@adaas/a-concept/global/A-Container/A-Container.meta";
+import { A_ComponentMeta } from "@adaas/a-concept/global/A-Component/A-Component.meta";
+import { A_Channel } from "@adaas/a-concept/global/A-Channel/A-Channel.class";
+
+
+/**
+ * A_Connect decorators allows to establish a connection between the Containers.
+ * 
+ * Depending on the A-Channel implementation the connection could be established in different ways like:
+ * - Direct connection (Async Module import)
+ * - Remote connection (HTTP, WebSockets)
+ * - Local connection (Shared Memory, IPC)
+ * - Event-based connection (EventEmitter, PubSub)
+ * 
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Connect(
+    channel: typeof A_Channel,
+    /**
+     * Connection name
+     */
+    id: string
+)
+export function A_Connect(
+    channel: typeof A_Channel,
+    config?: any | string
+) {
+    return function (
+        target: A_Container<any> | A_Component,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) {
+
+        const meta: A_ContainerMeta | A_ComponentMeta = A_Context.meta(target as any);
+
+        let metaKey;
+
+
+        // // Get the existed metadata or create a new one
+        // const existedMeta: A_Meta<{
+        //     [Key: string]: A_TYPES__ContainerMeta_StageExtension[];
+        // }> = meta.get(metaKey) || new A_Meta();
+
+        // // Set the metadata of the method to define a custom Stage with name
+        // const existedMetaValue = existedMeta.get(StageKey) || [];
+
+        // // Add the new method to the metadata
+        // existedMetaValue.push({
+        //     name: method,
+        //     handler: propertyKey,
+        // });
+
+        // // Set the metadata of the method to define a custom Feature with name
+        // existedMeta.set(StageKey, existedMetaValue);
+
+
+        // //  Update the metadata of the container with the new Stage definition
+        // A_Context
+        //     .meta(target as any)
+        //     .set(
+        //         metaKey,
+        //         existedMeta
+        //     );
+
+    };
+}

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

@@ -0,0 +1,6 @@
+
+export type A_TYPES__A_ConnectDecoratorConfig = {
+}
+
+
+

package/src/decorators/A-Entity/A-Entity-List.decorator.ts

@@ -0,0 +1,12 @@
+
+
+export function A_EntityListDecorator(...args: any[]): any {
+
+    return function (
+        target: any,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+
+    }
+}

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

@@ -0,0 +1,18 @@
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class"
+import { ASEID } from "@adaas/a-utils"
+
+
+
+export type A_TYPES__EntityListDecoratorQuery = {
+    aseid: string | ASEID,
+    id: string,
+    type: { new(...args: any[]): A_Entity<any, any, any> },
+    entity: string
+}
+
+
+
+export type A_TYPES__EntityListDecoratorPagination = {
+    limit: number,
+    offset: number
+}

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

@@ -57,6 +57,9 @@ export function A_Feature_Extend(
     ) {
 
         let targetRegexp: RegExp;
+        let behavior: 'sync' | 'async' = 'sync';
+        let before: string[] = [];
+        let after: string[] = [];
 
 
         // Check if the config is a RegExp
@@ -70,6 +73,10 @@ export function A_Feature_Extend(
                     .join('|')})`
                 : '.*'
                 }\\.${param1.name || propertyKey}$`);
+
+            behavior = param1.behavior || behavior;
+            before = param1.before || before;
+            after = param1.after || after;
         }
         else {
             targetRegexp = new RegExp(`^.*\\.${propertyKey}$`);
@@ -88,6 +95,9 @@ export function A_Feature_Extend(
         existedMetaValue.push({
             name: targetRegexp.source,
             handler: propertyKey,
+            behavior,
+            before,
+            after
         });
 
         // Set the metadata of the method to define a custom Feature with name

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

@@ -64,9 +64,45 @@ export type A_TYPES__A_ExtendDecoratorConfig = {
         | { new(...args: any[]): A_Entity }
         | { new(...args: any[]): A_Component }
     >
+} & A_TYPES__A_ExtendDecorator_BehaviorConfig
+
+
+export type A_TYPES__A_ExtendDecorator_BehaviorConfig = {
+    /**
+     * 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'
+
+
+    /**
+     * 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__A_ExtendDecorator_Meta = {
+    name: string,
+    handler: string
+} & A_TYPES__A_ExtendDecorator_BehaviorConfig
+
+
+