@acorex/platform 1.0.0

package/esm2022/workflow/lib/workflow-registery.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXPWorkflowRegistryService {
+    constructor() {
+        this.functionsMap = new Map();
+        this.actionsMap = new Map();
+        this.workflowsMap = new Map();
+    }
+    registerWorkflow(name, workflow) {
+        this.workflowsMap.set(name, workflow);
+    }
+    getWorkflow(name) {
+        return this.workflowsMap.get(name);
+    }
+    registerAction(name, action) {
+        this.actionsMap.set(name, action);
+    }
+    getAction(name) {
+        return this.actionsMap.get(name);
+    }
+    registerFunction(name, func) {
+        this.functionsMap.set(name, func);
+    }
+    getFunction(name) {
+        return this.functionsMap.get(name);
+    }
+    getFunctionNames() {
+        return Array.from(this.functionsMap.keys());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/workflow/lib/workflow.module.mjs

@@ -0,0 +1,96 @@
+import { Inject, NgModule, Optional } from "@angular/core";
+import { AXPWorkflowRegistryService } from "./workflow-registery.service";
+import * as i0 from "@angular/core";
+export class AXPWorkflowModule {
+    static forRoot(config) {
+        return {
+            ngModule: AXPWorkflowModule,
+            providers: [
+                {
+                    provide: 'AXPWorkflowModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (config?.functions) {
+                            for (const [key, type] of Object.entries(config.functions)) {
+                                registry.registerFunction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.actions) {
+                            for (const [key, type] of Object.entries(config.actions)) {
+                                registry.registerAction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.workflows) {
+                            for (const [key, type] of Object.entries(config.workflows)) {
+                                registry.registerWorkflow(key, type);
+                            }
+                        }
+                    },
+                    deps: [AXPWorkflowRegistryService],
+                    multi: true
+                },
+                ...Object.values(config?.actions ?? {}),
+                ...Object.values(config?.functions ?? {}),
+            ]
+        };
+    }
+    static forChild(config) {
+        return {
+            ngModule: AXPWorkflowModule,
+            providers: [
+                {
+                    provide: 'AXPWorkflowModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (config?.functions) {
+                            for (const [key, type] of Object.entries(config.functions)) {
+                                registry.registerFunction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.actions) {
+                            for (const [key, type] of Object.entries(config.actions)) {
+                                registry.registerAction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.workflows) {
+                            for (const [key, type] of Object.entries(config.workflows)) {
+                                registry.registerWorkflow(key, type);
+                            }
+                        }
+                    },
+                    deps: [AXPWorkflowRegistryService],
+                    multi: true
+                },
+                ...Object.values(config?.actions ?? {}),
+                ...Object.values(config?.functions ?? {})
+            ]
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach(f => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPWorkflowModuleFactory']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.module.js","sourceRoot":"","sources":["../../../../../../libs/platform/workflow/src/lib/workflow.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, ModuleWithProviders, NgModule, Optional, Type } from \"@angular/core\";\nimport { AXPWorkflowRegistryService } from \"./workflow-registery.service\";\nimport { AXPWorkflow, AXPWorkflowAction, AXPWorkflowFunction } from \"./workflow.types\";\n\n\nexport interface AXPWorkflowModuleConfigs {\n    functions?: {\n        [name: string]: Type<AXPWorkflowFunction>\n    },\n    actions?: {\n        [name: string]: Type<AXPWorkflowAction>\n    },\n    workflows?: {\n        [name: string]: AXPWorkflow\n    }\n}\n\n@NgModule({\n    imports: [],\n    exports: [],\n    declarations: [],\n})\nexport class AXPWorkflowModule {\n\n    static forRoot(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule> {\n        return {\n            ngModule: AXPWorkflowModule,\n            providers: [\n                {\n                    provide: 'AXPWorkflowModuleFactory',\n                    useFactory: (registry: AXPWorkflowRegistryService) => () => {\n                        if (config?.functions) {\n                            for (const [key, type] of Object.entries(config.functions)) {\n                                registry.registerFunction(key, type);\n                            }\n                        }\n                        //\n                        if (config?.actions) {\n                            for (const [key, type] of Object.entries(config.actions)) {\n                                registry.registerAction(key, type);\n                            }\n                        }\n                        //\n                        if (config?.workflows) {\n                            for (const [key, type] of Object.entries(config.workflows)) {\n                                registry.registerWorkflow(key, type);\n                            }\n                        }\n                    },\n                    deps: [AXPWorkflowRegistryService],\n                    multi: true\n                },\n                ...Object.values(config?.actions ?? {}),\n                ...Object.values(config?.functions ?? {}),\n            ]\n        };\n    }\n\n    static forChild(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule> {\n        return {\n            ngModule: AXPWorkflowModule,\n            providers: [\n                {\n                    provide: 'AXPWorkflowModuleFactory',\n                    useFactory: (registry: AXPWorkflowRegistryService) => () => {\n                        if (config?.functions) {\n                            for (const [key, type] of Object.entries(config.functions)) {\n                                registry.registerFunction(key, type);\n                            }\n                        }\n                        //\n                        if (config?.actions) {\n                            for (const [key, type] of Object.entries(config.actions)) {\n                                registry.registerAction(key, type);\n                            }\n                        }\n                        //\n                        if (config?.workflows) {\n                            for (const [key, type] of Object.entries(config.workflows)) {\n                                registry.registerWorkflow(key, type);\n                            }\n                        }\n                    },\n                    deps: [AXPWorkflowRegistryService],\n                    multi: true\n                },\n                ...Object.values(config?.actions ?? {}),\n                ...Object.values(config?.functions ?? {})\n            ]\n        };\n    }\n\n    /**\n     * @ignore\n     */\n    constructor(@Optional() @Inject('AXPWorkflowModuleFactory') instances: any[]) {\n        instances?.forEach(f => {\n            f();\n        });\n    }\n}\n"]}

package/esm2022/workflow/lib/workflow.service.mjs

@@ -0,0 +1,141 @@
+import { Injectable, Injector, inject } from '@angular/core';
+import { AXPWorkflowError } from './errors.types';
+import { AXPWorkflowEventService } from './workflow-event-dispatcher.service';
+import { AXPWorkflowRegistryService } from './workflow-registery.service';
+import { AXPWorkflowContext, } from './workflow.types';
+import * as i0 from "@angular/core";
+import * as i1 from "./workflow-registery.service";
+export class AXPWorkflowService {
+    get events$() {
+        return this.eventService.events$;
+    }
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
+        this.eventService = inject(AXPWorkflowEventService);
+    }
+    async execute(workflow, initialContext = {}) {
+        // Instantiate or retrieve the workflow
+        const wk = typeof workflow === 'string' ? this.getWorkflowInstance(workflow) : workflow;
+        let currentStepId = wk.startStepId;
+        const context = new AXPWorkflowContext();
+        // Initialize context with initial variables
+        Object.entries(initialContext).forEach(e => context.setVariable(e[0], e[1]));
+        while (currentStepId) {
+            const currentStep = wk.steps[currentStepId];
+            if (!currentStep) {
+                throw new AXPWorkflowError(`Step '${currentStepId}' not found in the workflow steps.`);
+            }
+            // Instantiate or retrieve the action
+            const action = typeof currentStep.action === 'string' ? this.getActionInstance(currentStep.action) : currentStep.action;
+            if (currentStep.input) {
+                Object.assign(action, currentStep.input);
+            }
+            try {
+                await action.execute(context);
+            }
+            catch (error) {
+                throw new AXPWorkflowError('Workflow Error', error);
+            }
+            // Determine the next step based on the conditions
+            const nextStepInfo = await this.determineNextStep(currentStep, context);
+            if (nextStepInfo) {
+                currentStepId = nextStepInfo.nextStepId;
+            }
+            else {
+                break; // Exit the loop if no next step is determined
+            }
+        }
+    }
+    getActionInstance(actionName) {
+        const actionType = this.registryService.getAction(actionName);
+        if (!actionType) {
+            throw new AXPWorkflowError(`Action type '${actionName}' not found in the registry.`);
+        }
+        return this.injector.get(actionType);
+    }
+    getWorkflowInstance(workflowName) {
+        const workflowType = this.registryService.getWorkflow(workflowName);
+        if (!workflowType) {
+            throw new AXPWorkflowError(`Workflow type '${workflowName}' not found in the registry.`);
+        }
+        return workflowType;
+    }
+    async determineNextStep(currentStep, context) {
+        if (!currentStep.nextSteps) {
+            return null;
+        }
+        for (const nextStep of currentStep.nextSteps) {
+            if (await this.evaluateCondition(nextStep.conditions, context)) {
+                return nextStep;
+            }
+        }
+        return null;
+    }
+    async evaluateCondition(conditions, context) {
+        if (!conditions || conditions.length === 0) {
+            return true; // If no conditions, the step proceeds
+        }
+        // Map each condition to a promise using evaluateSingleCondition
+        const conditionPromises = conditions.map((condition) => this.evaluateSingleCondition(condition, context));
+        // Wait for all promises to resolve
+        const results = await Promise.all(conditionPromises);
+        // Check if every condition is true
+        return results.every((result) => result);
+    }
+    async evaluateSingleCondition(condition, context) {
+        switch (condition.type) {
+            case 'SINGLE':
+                return (!condition.expression ? true : await this.evaluateExpression(condition.expression, context));
+            case 'AND':
+                // Evaluate all conditions with 'AND' logic
+                const andConditions = condition.conditions ?? [];
+                const andResults = await Promise.all(andConditions.map((cond) => this.evaluateSingleCondition(cond, context)));
+                return andResults.every((result) => result);
+            case 'OR':
+                // Evaluate all conditions with 'OR' logic
+                const orConditions = condition.conditions ?? [];
+                const orResults = await Promise.all(orConditions.map((cond) => this.evaluateSingleCondition(cond, context)));
+                return orResults.some((result) => result);
+            default:
+                throw new AXPWorkflowError(`Unsupported condition type: ${condition.type}`);
+        }
+    }
+    async evaluateExpression(expression, context) {
+        try {
+            // Create a scope that includes context and registered functions
+            const scope = { context, ...this.createFunctionScope() };
+            // Evaluating the expression within the created scope
+            const sandbox = new Function('scope', `return (async function() { with (scope) { return ${expression}; } })();`);
+            const result = await sandbox(scope);
+            return result;
+        }
+        catch (error) {
+            console.error('Error evaluating expression:', error);
+            return false;
+        }
+    }
+    createFunctionScope() {
+        const scope = {};
+        this.registryService.getFunctionNames().forEach((name) => {
+            scope[name] = this.getFunctionInstance(name).execute;
+        });
+        return scope;
+    }
+    getFunctionInstance(functionName) {
+        const functionType = this.registryService.getFunction(functionName);
+        if (!functionType) {
+            throw new AXPWorkflowError(`Function type '${functionName}' not found in the registry.`);
+        }
+        return this.injector.get(functionType);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowService, deps: [{ token: i1.AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AXPWorkflowRegistryService }, { type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.service.js","sourceRoot":"","sources":["../../../../../../libs/platform/workflow/src/lib/workflow.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, inject } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { AXPWorkflowError } from './errors.types';\nimport { AXPWorkflowEventService } from './workflow-event-dispatcher.service';\nimport { AXPWorkflowRegistryService } from './workflow-registery.service';\nimport {\n  AXPWorkflow,\n  AXPWorkflowAction,\n  AXPWorkflowCondition,\n  AXPWorkflowContext,\n  AXPWorkflowEvent,\n  AXPWorkflowFunction,\n  AXPWorkflowNextStep,\n  AXPWorkflowStep,\n} from './workflow.types';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AXPWorkflowService {\n  private eventService = inject(AXPWorkflowEventService);\n\n  get events$(): Observable<AXPWorkflowEvent> {\n    return this.eventService.events$;\n  }\n\n  constructor(private registryService: AXPWorkflowRegistryService, private injector: Injector) { }\n\n  async execute(workflow: AXPWorkflow | string, initialContext: any = {}): Promise<void> {\n    // Instantiate or retrieve the workflow\n    const wk = typeof workflow === 'string' ? this.getWorkflowInstance(workflow) : workflow;\n\n    let currentStepId = wk.startStepId;\n    const context = new AXPWorkflowContext();\n    // Initialize context with initial variables\n    Object.entries(initialContext).forEach(e => context.setVariable(e[0], e[1]));\n\n    while (currentStepId) {\n      const currentStep = wk.steps[currentStepId];\n      if (!currentStep) {\n        throw new AXPWorkflowError(`Step '${currentStepId}' not found in the workflow steps.`);\n      }\n\n      // Instantiate or retrieve the action\n      const action =\n        typeof currentStep.action === 'string' ? this.getActionInstance(currentStep.action) : currentStep.action;\n      if (currentStep.input) {\n        Object.assign(action, currentStep.input);\n      }\n\n      try {\n        await action.execute(context);\n      } catch (error) {\n        throw new AXPWorkflowError('Workflow Error', error as Error);\n      }\n      // Determine the next step based on the conditions\n      const nextStepInfo = await this.determineNextStep(currentStep, context);\n      if (nextStepInfo) {\n        currentStepId = nextStepInfo.nextStepId;\n      } else {\n        break; // Exit the loop if no next step is determined\n      }\n    }\n  }\n\n  private getActionInstance(actionName: string): AXPWorkflowAction {\n    const actionType = this.registryService.getAction(actionName);\n    if (!actionType) {\n      throw new AXPWorkflowError(`Action type '${actionName}' not found in the registry.`);\n    }\n    return this.injector.get(actionType);\n  }\n\n  private getWorkflowInstance(workflowName: string): AXPWorkflow {\n    const workflowType = this.registryService.getWorkflow(workflowName);\n    if (!workflowType) {\n      throw new AXPWorkflowError(`Workflow type '${workflowName}' not found in the registry.`);\n    }\n    return workflowType;\n  }\n\n  private async determineNextStep(\n    currentStep: AXPWorkflowStep,\n    context: AXPWorkflowContext\n  ): Promise<AXPWorkflowNextStep | null> {\n    if (!currentStep.nextSteps) {\n      return null;\n    }\n    for (const nextStep of currentStep.nextSteps) {\n      if (await this.evaluateCondition(nextStep.conditions, context)) {\n        return nextStep;\n      }\n    }\n    return null;\n  }\n\n  private async evaluateCondition(conditions: AXPWorkflowCondition[], context: AXPWorkflowContext): Promise<boolean> {\n    if (!conditions || conditions.length === 0) {\n      return true; // If no conditions, the step proceeds\n    }\n\n    // Map each condition to a promise using evaluateSingleCondition\n    const conditionPromises = conditions.map((condition) => this.evaluateSingleCondition(condition, context));\n\n    // Wait for all promises to resolve\n    const results = await Promise.all(conditionPromises);\n\n    // Check if every condition is true\n    return results.every((result) => result);\n  }\n\n  private async evaluateSingleCondition(\n    condition: AXPWorkflowCondition,\n    context: AXPWorkflowContext\n  ): Promise<boolean> {\n    switch (condition.type) {\n      case 'SINGLE':\n        return (!condition.expression ? true : await this.evaluateExpression(condition.expression, context)) as boolean;\n      case 'AND':\n        // Evaluate all conditions with 'AND' logic\n        const andConditions = condition.conditions ?? [];\n        const andResults = await Promise.all(andConditions.map((cond) => this.evaluateSingleCondition(cond, context)));\n        return andResults.every((result) => result);\n\n      case 'OR':\n        // Evaluate all conditions with 'OR' logic\n        const orConditions = condition.conditions ?? [];\n        const orResults = await Promise.all(orConditions.map((cond) => this.evaluateSingleCondition(cond, context)));\n        return orResults.some((result) => result);\n\n      default:\n        throw new AXPWorkflowError(`Unsupported condition type: ${condition.type}`);\n    }\n  }\n\n  private async evaluateExpression(expression: string, context: AXPWorkflowContext): Promise<Boolean> {\n    try {\n      // Create a scope that includes context and registered functions\n      const scope = { context, ...this.createFunctionScope() };\n\n      // Evaluating the expression within the created scope\n      const sandbox = new Function('scope', `return (async function() { with (scope) { return ${expression}; } })();`);\n      const result = await sandbox(scope);\n      return result;\n    } catch (error) {\n      console.error('Error evaluating expression:', error);\n      return false;\n    }\n  }\n\n  private createFunctionScope(): any {\n    const scope: any = {};\n    this.registryService.getFunctionNames().forEach((name) => {\n      scope[name] = this.getFunctionInstance(name).execute;\n    });\n    return scope;\n  }\n\n  private getFunctionInstance(functionName: string): AXPWorkflowFunction {\n    const functionType = this.registryService.getFunction(functionName);\n    if (!functionType) {\n      throw new AXPWorkflowError(`Function type '${functionName}' not found in the registry.`);\n    }\n    return this.injector.get(functionType);\n  }\n}\n"]}

package/esm2022/workflow/lib/workflow.types.mjs

@@ -0,0 +1,52 @@
+import { Injectable, inject } from '@angular/core';
+import { filter } from 'rxjs';
+import { AXPWorkflowEventService } from './workflow-event-dispatcher.service';
+import * as i0 from "@angular/core";
+export class AXPWorkflowContext {
+    constructor() {
+        this.variables = new Map();
+        this.stepOutputs = new Map();
+        // You can add more helper methods as needed
+    }
+    setVariable(key, value) {
+        this.variables.set(key, value);
+    }
+    getVariable(key) {
+        return this.variables.get(key);
+    }
+    setOutput(stepId, output) {
+        this.stepOutputs.set(stepId, output);
+    }
+    getOutput(stepId) {
+        return this.stepOutputs.get(stepId);
+    }
+}
+export class AXPWorkflowAction {
+    constructor() {
+        this.eventService = inject(AXPWorkflowEventService);
+    }
+    dispatch(event) {
+        this.eventService.dispatch(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowAction, decorators: [{
+            type: Injectable
+        }] });
+export class AXPWorkflowFunction {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowFunction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
+            type: Injectable
+        }] });
+export function createWorkFlowEvent(type) {
+    const eventCreator = (payload) => ({ type, payload });
+    eventCreator.type = type;
+    return eventCreator;
+}
+export function ofType(...allowedTypes) {
+    return filter((event) => allowedTypes.some((type) => event.type === type.type));
+}
+//# sourceMappingURL=data:application/json;base64,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