@adaas/a-concept 0.0.28 → 0.0.30

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

@@ -1,14 +1,13 @@
-import { A_CommonHelper } from "@adaas/a-utils";
+import { A_CommonHelper, ASEID } from "@adaas/a-utils";
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "./A-Scope.types";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Context } from "../A-Context/A-Context.class";
 import {
-    A_TYPES__ComponentMeta_EntityInjectionInstructions,
-    A_TYPES__ComponentMeta_InjectionParam,
     A_TYPES__ComponentMetaKey
 } from "../A-Component/A-Component.types";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_Entity } from "../A-Entity/A-Entity.class";
+import { A_TYPES__A_InjectDecorator_EntityInjectionInstructions, A_TYPES__A_InjectDecorator_EntityInjectionQuery, A_TYPES__A_InjectDecorator_Injectable } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
 
 /**
  * 
@@ -72,6 +71,10 @@ export class A_Scope {
         // })
     }
 
+    private initEntities(_entities: Array<A_Entity>) {
+        _entities.forEach(this.register.bind(this));
+    }
+
 
     private initFragments(_fragments: Array<A_Fragment>) {
         _fragments.forEach(this.register.bind(this));
@@ -111,7 +114,7 @@ export class A_Scope {
         switch (true) {
 
             case A_CommonHelper.isInheritedFrom(entity, A_Component): {
-                const found = this.params.components.includes(entity);
+                const found = this.params.components.includes(entity as { new(...args: any[]): A_Component });
 
                 if (!found && !!this.parent)
                     return this.parent.has(entity as any);
@@ -149,20 +152,20 @@ export class A_Scope {
      * @param component 
      * @returns 
      */
-    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: T
     ): InstanceType<T>
     resolve<T extends { new(...args: any[]): A_Entity }>(
         entity: T,
-        instructions: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T>
-    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: Array<T>
     ): Array<InstanceType<T>>
     // base definition
-    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         param1: Array<T> | T,
-        param2?: string | Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        param2?: string | Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): Array<InstanceType<T>> | InstanceType<T> {
 
         switch (true) {
@@ -182,16 +185,18 @@ export class A_Scope {
 
 
 
+
+
     private resolveOnce<T extends { new(...args: any[]): A_Entity }>(
         entity: T,
-        instructions: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T> | undefined
-    private resolveOnce<T extends A_TYPES__ComponentMeta_InjectionParam>(
+    private resolveOnce<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: T
     ): InstanceType<T>
-    private resolveOnce<T extends { new(...args: any[]): A_Entity } | A_TYPES__ComponentMeta_InjectionParam>(
+    private resolveOnce<T extends { new(...args: any[]): A_Entity } | A_TYPES__A_InjectDecorator_Injectable>(
         component: T,
-        instructions?: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T> {
         switch (true) {
             case A_CommonHelper.isInheritedFrom(component, A_Entity): {
@@ -218,9 +223,13 @@ export class A_Scope {
 
     private resolveEntity<T extends { new(...args: any[]): A_Entity }>(
         entity: T,
-        instructions?: Partial<A_TYPES__ComponentMeta_EntityInjectionInstructions>
+        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): InstanceType<T> | undefined {
 
+        const query = instructions?.query || {};
+        const count = instructions?.pagination?.count || 1;
+
+
         switch (true) {
             case !instructions: {
 
@@ -233,25 +242,34 @@ export class A_Scope {
                         return found as InstanceType<T>;
 
                     case !found && !!this.parent:
-                        return this.parent.resolveFragment(entity);
+                        return this.parent.resolveEntity(entity, instructions);
 
                     default:
                         throw new Error(`Fragment ${entity.name} not found in the scope ${this.name}`);
                 }
             }
 
-            case !!instructions && !!instructions.aseid && this._entities.has(instructions.aseid): {
-                return this._entities.get(instructions.aseid) as InstanceType<T>;
-            }
+            case !!query.aseid
+                && typeof query.aseid === 'string'
+                && this._entities.has(query.aseid): {
+                    return this._entities.get(query.aseid) as InstanceType<T>;
+                }
 
-            case !!instructions && !!instructions.id && this._entities.has(instructions.id): {
-                // in this case we have to find the entity by the id
-                const entities = Array.from(this._entities.values());
+            case !!query.aseid
+                && query.aseid instanceof ASEID
+                && this._entities.has(query.aseid.toString()): {
+                    return this._entities.get(query.aseid.toString()) as InstanceType<T>;
+                }
 
-                const found = entities.find(e => e.id === instructions.id);
+            case !!query.id
+                && this._entities.has(query.id): {
+                    // in this case we have to find the entity by the id
+                    const entities = Array.from(this._entities.values());
 
-                return found as InstanceType<T>;
-            }
+                    const found = entities.find(e => e.id === query.id);
+
+                    return found as InstanceType<T>;
+                }
 
             default:
                 throw new Error(`Entity ${entity.constructor.name} not found in the scope ${this.name}`);
@@ -331,7 +349,7 @@ export class A_Scope {
 
                 const found = this.components.find(el => A_CommonHelper.isInheritedFrom(el, component));
 
-                return this.resolveComponent(found!);
+                return this.resolveComponent<T>(found as any);
             }
 
             // In case when the component is not available in the scope but the parent is available
@@ -398,4 +416,19 @@ export class A_Scope {
 
 
     }
+
+
+
+
+    toJSON(): Record<string, any> {
+        return this.fragments.reduce((acc, fragment) => {
+
+            const serialized = fragment.toJSON()
+
+            return {
+                ...acc,
+                [serialized.name]: serialized
+            }
+        }, {});
+    }
 }

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

@@ -1,3 +1,4 @@
+import { A_Component } from "../A-Component/A-Component.class"
 import { A_Fragment } from "../A-Fragment/A-Fragment.class"
 import { A_Scope } from "./A-Scope.class"
 
@@ -15,7 +16,7 @@ export type A_TYPES__ScopeConstructor = {
     /**
      * A set of Components available in the Scope
      */
-    components: Array<{ new(...args: any[]): any }>
+    components: Array<{ new(...args: any[]): A_Component }>
 
 
     /**

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

@@ -0,0 +1,225 @@
+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) {
+        return step.args.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,106 @@
+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,
+
+    /**
+     * Arguments to be passed to the method
+     */
+    args: A_TYPES__A_InjectDecorator_Meta
+
+} & 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;
+    }
+}