@adaas/a-concept 0.0.29 → 0.0.31

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

@@ -0,0 +1,234 @@
+import { A_CommonHelper, A_Error } from "@adaas/a-utils";
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_Feature } from "../A-Feature/A-Feature.class";
+import { A_TYPES__A_Stage_JSON, A_TYPES__A_Stage_Status, A_TYPES__A_StageStep } from "./A-Stage.types";
+import { A_Container } from "../A-Container/A-Container.class";
+
+
+
+/**
+ * A_Stage is a set of A_Functions within A_Feature that should be run in a specific order.
+ * Each stage may contain one or more functions. 
+ * [!] That always run in parallel (in NodeJS asynchronously), independently of each other.
+ * 
+ * A-Stage is a common object that uses to simplify logic and re-use of A-Feature internals for better composition. 
+ */
+export class A_Stage {
+
+
+
+    constructor(
+        private feature: A_Feature,
+        private steps: A_TYPES__A_StageStep[] = []
+    ) {
+
+    }
+
+    status: A_TYPES__A_Stage_Status = A_TYPES__A_Stage_Status.INITIALIZED;
+    /**
+     * Promise that will be resolved when the stage is Processed
+     */
+    processed: Promise<void> | undefined;
+
+
+    get before(): string[] {
+        return this.steps.reduce((acc, step) => ([
+            ...acc,
+            ...step.before
+        ]), [] as string[]);
+    }
+
+    get after(): string[] {
+        return this.steps.reduce((acc, step) => ([
+            ...acc,
+            ...step.after
+        ]), [] as string[]);
+    }
+
+
+    /**
+     * Resolves the arguments of the step
+     * 
+     * @param step 
+     * @returns 
+     */
+    protected async getStepArgs(step: A_TYPES__A_StageStep) {
+
+        const target = step.component instanceof A_Container ?
+            step.component.constructor : step.component;
+
+        return A_Context
+            .meta(target)
+            .injections(
+                step.handler
+            )
+            .map(async arg =>
+                // In case if the target is a feature step then pass the current feature
+                A_CommonHelper.isInheritedFrom(arg.target, A_Feature)
+                    ? this
+                    : A_Context.scope(this.feature).resolve(arg.target)
+            );
+    }
+
+
+    /**
+     * Adds a step to the stage
+     * 
+     * @param step 
+     * @returns 
+     */
+    add(
+        step: A_TYPES__A_StageStep
+    ): this {
+        this.steps.push(step);
+
+        return this;
+    }
+
+
+    /**
+     * Resolves the component of the step
+     * 
+     * @param step 
+     * @returns 
+     */
+    protected getStepInstance(step: A_TYPES__A_StageStep) {
+        const { component, handler } = step;
+
+        // TODO: probably would be better to do it another way. let's think about it
+        const instance = component instanceof A_Container
+            ? component
+            : A_Context.scope(this.feature).resolve(component);
+
+        if (!instance)
+            throw new Error(`Unable to resolve component ${component.name}`);
+
+        if (!instance[handler])
+            throw new Error(`Handler ${handler} not found in ${instance.constructor.name}`);
+
+        return instance;
+    }
+
+
+
+    /**
+     * Calls the handler of the step
+     * 
+     * @param step 
+     * @returns 
+     */
+    protected async getStepHandler(step: A_TYPES__A_StageStep) {
+
+        const instance = this.getStepInstance(step);
+        const callArgs = await this.getStepArgs(step);
+
+        return instance[step.handler](...callArgs);
+
+    }
+
+
+    /**
+     * Runs async all the steps of the stage
+     * 
+     * @returns 
+     */
+    async process(): Promise<void> {
+        if (!this.processed)
+            this.processed = new Promise<void>(
+                async (resolve, reject) => {
+                    try {
+                        this.status = A_TYPES__A_Stage_Status.PROCESSING;
+
+                        const syncSteps = this.steps.filter(step => step.behavior === 'sync');
+                        const asyncSteps = this.steps.filter(step => step.behavior === 'async');
+
+                        // Run sync steps
+
+                        await Promise
+                            .all([
+
+                                // Run async steps that are independent of each other
+                                ...asyncSteps.map(step => this.getStepHandler(step)),
+
+                                // Run sync steps that are dependent on each other
+                                new Promise<void>(
+                                    async (r, j) => {
+                                        try {
+                                            for (const step of syncSteps) {
+                                                await this.getStepHandler(step);
+                                            }
+
+                                            return r();
+                                        } catch (error) {
+                                            return j(error);
+                                        }
+                                    }
+                                )
+                            ]);
+
+                        this.completed();
+
+                        return resolve();
+
+                    } catch (error) {
+                        this.failed(error);
+
+                        return reject(error);
+                    }
+                });
+
+
+        return this.processed;
+    }
+
+
+    /**
+     * Skips the stage
+     * 
+     */
+    skip() {
+        this.status = A_TYPES__A_Stage_Status.SKIPPED;
+
+        this.feature.next(this);
+    }
+
+
+
+
+    // ==========================================
+    // ============ Status methods =============
+    // ==========================================
+
+    protected completed() {
+        this.status = A_TYPES__A_Stage_Status.COMPLETED;
+
+        this.feature.next(this);
+    }
+
+    protected failed(
+        error: Error | A_Error | unknown
+    ) {
+        this.status = A_TYPES__A_Stage_Status.FAILED;
+
+        this.feature.failed(error);
+    }
+
+
+
+    // ==========================================
+    // ============ Serialization ===============
+    // ==========================================
+
+
+    /**
+     * Serializes the stage to JSON
+     * 
+     */
+    toJSON(): A_TYPES__A_Stage_JSON {
+
+        return {
+            name: 'A_Stage',
+            status: this.status,
+        }
+    }
+}   

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

@@ -0,0 +1,101 @@
+import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types"
+import { A_Component } from "../A-Component/A-Component.class"
+import { A_Container } from "../A-Container/A-Container.class"
+import { A_TYPES__A_ExtendDecorator_BehaviorConfig, A_TYPES__A_ExtendDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types"
+
+
+
+export enum A_TYPES__A_Stage_Status {
+    /**
+     * The stage is currently being processed
+     */
+    PROCESSING = 'PROCESSING',
+    /**
+     * The stage has been completed
+     */
+    COMPLETED = 'COMPLETED',
+    /**
+     * The stage has failed
+     */
+    FAILED = 'FAILED',
+    /**
+     * The stage has been skipped
+     */
+    SKIPPED = 'SKIPPED',
+    /**
+     * The stage has been paused
+     */
+    // PAUSED = 'PAUSED',
+    /**
+     * The stage has been stopped
+     */
+    // STOPPED = 'STOPPED',
+    /**
+     * The stage has been started
+     */
+    // STARTED = 'STARTED',
+    /**
+     * The stage has been initialized
+     */
+    INITIALIZED = 'INITIALIZED',
+    /**
+     * The stage has been reset
+     */
+    // RESET = 'RESET',
+    /**
+     * The stage has been resumed
+     */
+    // RESUMED = 'RESUMED',
+    /**
+     * The stage has been suspended
+     */
+    // SUSPENDED = 'SUSPENDED',
+    /**
+     * The stage has been terminated
+     */
+    // TERMINATED = 'TERMINATED',
+    /**
+     * The stage has been aborted
+     */
+    ABORTED = 'ABORTED'
+}
+
+
+export type A_TYPES__A_StageStep = {
+
+    /**
+     * The component to be called
+     */
+    component: typeof A_Component | typeof A_Container | A_Container<any>
+
+    /**
+     * The method to be called on the component
+     */
+    handler: string,
+
+    /**
+     * Original Feature Extension name
+     * 
+     * [!] could be string or regex
+     * 
+     */
+    name: string,
+
+} & A_TYPES__A_ExtendDecorator_BehaviorConfig
+
+
+
+export type A_TYPES__A_Stage_JSON = {
+
+    /**
+     * The name of the stage
+     */
+    name: string,
+
+    /**
+     *  The status of the stage
+     * 
+     */
+    status: A_TYPES__A_Stage_Status,
+
+}

package/src/helpers/StepsManager.class.ts

@@ -0,0 +1,104 @@
+import { A_Feature } from "../global/A-Feature/A-Feature.class";
+import { A_Stage } from "../global/A-Stage/A-Stage.class";
+import { A_TYPES__A_StageStep } from "../global/A-Stage/A-Stage.types";
+
+export class StepsManager {
+
+    public entities: A_TYPES__A_StageStep[];
+    public graph: Map<string, Set<string>>;
+    public visited: Set<string>;
+    public tempMark: Set<string>;
+    public sortedEntities: string[];
+
+
+    constructor(entities: A_TYPES__A_StageStep[]) {
+        this.entities = entities;
+        this.graph = new Map();
+        this.visited = new Set();
+        this.tempMark = new Set();
+        this.sortedEntities = [];
+    }
+
+    private buildGraph() {
+        // Initialize graph nodes
+        this.entities.forEach(entity => this.graph.set(entity.name, new Set()));
+
+        // Add directed edges based on 'before' and 'after'
+        this.entities.forEach(entity => {
+            const { name, before = [], after = [] } = entity;
+
+            // Add edges for 'before' dependencies
+            before.forEach(dep => {
+                const targets = this.matchEntities(dep);
+                targets.forEach(target => {
+                    if (!this.graph.has(target)) this.graph.set(target, new Set());
+                    this.graph.get(target)!.add(name); // target -> name (target should be before name)
+                });
+            });
+
+            // Add edges for 'after' dependencies
+            after.forEach(dep => {
+                const sources = this.matchEntities(dep);
+                sources.forEach(source => {
+                    if (!this.graph.has(name)) this.graph.set(name, new Set());
+                    this.graph.get(name)!.add(source); // name -> source (name should be before source)
+                });
+            });
+        });
+    }
+
+    // Match entities by name or regex
+    private matchEntities(pattern) {
+        const regex = new RegExp(`^${pattern}$`);
+        return this.entities
+            .filter(entity => regex.test(entity.name))
+            .map(entity => entity.name);
+    }
+
+    // Topological sort with cycle detection
+    private visit(node) {
+        if (this.tempMark.has(node)) throw new Error("Circular dependency detected");
+
+        if (!this.visited.has(node)) {
+            this.tempMark.add(node);
+            (this.graph.get(node) || []).forEach(neighbor => this.visit(neighbor));
+            this.tempMark.delete(node);
+            this.visited.add(node);
+            this.sortedEntities.push(node);
+        }
+    }
+
+    // Sort the entities based on dependencies
+    toStages(feature: A_Feature): Array<A_Stage> {
+        this.buildGraph();
+
+        // Start topological sort
+        this.entities.forEach(entity => {
+            if (!this.visited.has(entity.name)) this.visit(entity.name);
+        });
+
+        const stages: A_Stage[] = [];
+
+        // Map sorted names back to entity objects
+        this.sortedEntities
+            .map(name => {
+
+                const step = this.entities.find(entity => entity.name === name)!;
+
+                let stage = stages.find(stage => {
+                    return stage.after.every(after => step.after.includes(after))
+                        && step.before.every(before => stage.after.includes(before));
+                });
+
+
+                if (!stage) {
+                    stage = new A_Stage(feature);
+                    stages.push(stage);
+                }
+
+                stage.add(step);
+            });
+
+        return stages;
+    }
+}

package/tests/channel.ts

@@ -0,0 +1,213 @@
+// import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+// 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_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+// import { EventEmitter } from "stream";
+
+
+// class ComponentA extends A_Component<[
+//     'method1',
+//     'method2'
+// ]> {
+
+//     @A_Feature.Define({
+//         name: 'method1',
+//         channels: []
+//     } as any)
+//     async method1() {
+
+//     }
+
+//     @A_Feature.Define({
+//         name: 'method2',
+//         channels: []
+//     } as any)
+//     async method2() {
+
+//     }
+// }
+
+
+// class ComponentB extends A_Component<[
+//     'ComponentB_method3',
+//     'ComponentB_method4'
+// ]> {
+
+//     @A_Feature.Define({
+//         name: 'ComponentB_method3',
+//         channels: []
+//     } as any)
+//     async ComponentB_method3(param1: {
+//         key: string
+//     }) {
+
+//     }
+
+//     @A_Feature.Define({
+//         name: 'ComponentB_method4',
+//         channels: []
+//     } as any)
+//     async ComponentB_method4(foo: number) {
+
+//     }
+// }
+
+
+
+// type MethodsWithSpecificArg<T, ArgType> = {
+//     [K in keyof T]: T[K] extends (arg: ArgType, ...args: any[]) => Promise<any> ? K : never
+// }[keyof T];
+
+// // Example argument type
+// type SpecificArgType = { key: string };
+
+// type AggregateMethods<TClasses extends A_Component[]> = {
+//     [K in keyof TClasses]: TClasses[K] extends infer Instance
+//     ? MethodsWithSpecificArg<Instance, SpecificArgType>
+//     : never;
+// }[number];
+
+
+// type MethodObject2<TClasses extends any[]> = {
+//     [Method in AggregateMethods<TClasses>]: {
+//         [Class in keyof TClasses]: TClasses[Class] extends infer Instance
+//         ? Method extends keyof Instance
+//         ? Instance[Method]
+//         : never
+//         : never;
+//     }[number]; // Select the method signature from any matching class
+// };
+
+
+
+// // decorator to create a channel 
+// function A_Connect() {
+//     return function (target: any, prop: string) {
+//         console.log('A_Connect', target, prop);
+//     }
+// }
+
+
+
+// class Channel<T extends A_Component[]> {
+
+//     channel: MethodObject2<T>;
+
+//     constructor() {
+//         this.channel = new Proxy(
+//             {} as MethodObject2<T>,
+//             {
+//                 get: (target, prop) => {
+//                     return async (...args: any[]) => {
+//                         this.call(prop as AggregateMethods<T>);
+//                     };
+//                 }
+//             });
+//     }
+
+
+//     async call(prop: AggregateMethods<T>) {
+//         // do HTTP Call or just inject class or whatever you want
+
+//         console.log('Calling method', prop);
+//     }
+
+// }
+
+
+
+
+// class HTTP<T extends A_Component[]> extends Channel<T> {
+
+//     async call(prop: AggregateMethods<T>): Promise<void> {
+
+//         console.log('HTTP Call', prop);
+//     }
+// }
+
+// class ConceptDirect<T extends A_Component[]> extends Channel<T> {
+
+//     // protected originalInstance: T;
+
+//     async call(prop: AggregateMethods<T>): Promise<void> {
+//         console.log('Direct Call', prop);
+//     }
+
+// }
+
+
+
+// class ConceptEE extends Channel<any> {
+
+//     private emitter: EventEmitter = new EventEmitter();
+
+//     constructor() {
+//         super();
+//     }
+
+//     async call(prop: string): Promise<void> {
+//         console.log('EE Call', prop);
+//     }
+
+//     on = this.emitter.on.bind(this.emitter);
+
+//     emit = this.emitter.emit.bind(this.emitter);
+
+// }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// class FooContainer extends A_Container<[
+//     'doSomething',
+//     'doAnotherThing'
+// ]> {
+
+
+//     @A_Feature.Define({
+//         name: 'doSomething',
+//         channels: [ConceptDirect, HTTP]
+//     } as any)
+//     async doSomething(
+//         @A_Inject(HTTP) http: HTTP<[ComponentA, ComponentB]>,
+//     ) {
+
+//         // @A_Connect(http, 'ComponentB_method3')
+
+//         const foo = await http.channel.ComponentB_method3({
+//             key: 'value'
+//         });
+//     }
+
+
+
+
+//     @A_Feature.Define({
+//         name: 'doAnotherThing',
+//         channels: [HTTP]
+//     } as any)
+//     async onRequest() {
+//         await this.call('doSomething');
+//     }
+// }
+
+
+
+