@justworkflowit/cdk-constructs 0.0.187 → 0.0.189

package/dist/__tests__/workflowEngine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/workflowEngine.test.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const engine_1 = require("@justworkflowit/engine");
+describe('Workflow Engine Integration Tests', () => {
+    const simpleIntegration = 'simpleIntegration';
+    const outputAPropertyKey = 'outputPropertyA';
+    const outputA = {
+        [outputAPropertyKey]: 'anOutputPropertyValue',
+    };
+    const stepExecutorA = {
+        type: simpleIntegration,
+        execute: (_args) => Promise.resolve({
+            status: 'success',
+            payload: outputA,
+        }),
+    };
+    const stepExecutorB = {
+        type: 'noopIntegration',
+        execute: (_args) => Promise.resolve({
+            status: 'success',
+            payload: {},
+        }),
+    };
+    const stepExecutors = [stepExecutorA, stepExecutorB];
+    const step1Name = 'firstStep';
+    const step2Name = 'secondStep';
+    const step1InputName = `${step1Name}Input`;
+    const step1OutputName = `${step1Name}Output`;
+    const step2InputName = `${step2Name}Input`;
+    const step2OutputName = `${step2Name}Output`;
+    const validWorkflowDefinition = {
+        workflowName: 'validWorkflowDefinition',
+        steps: [
+            {
+                name: step1Name,
+                retries: 2,
+                timeoutSeconds: 1000,
+                transitionToStep: step2Name,
+                integrationDetails: {
+                    type: simpleIntegration,
+                    inputDefinition: {
+                        $ref: `#/definitions/${step1InputName}`,
+                    },
+                    outputDefinition: {
+                        $ref: `#/definitions/${step1OutputName}`,
+                    },
+                    inputTransformer: {
+                        fieldset: [
+                            {
+                                to: 'inputPropertyA',
+                                withTemplate: 'a brand new field',
+                            },
+                        ],
+                    },
+                },
+            },
+            {
+                name: step2Name,
+                retries: 2,
+                timeoutSeconds: 1000,
+                transitionToStep: null,
+                integrationDetails: {
+                    type: simpleIntegration,
+                    inputDefinition: {
+                        $ref: `#/definitions/${step2InputName}`,
+                    },
+                    outputDefinition: {
+                        $ref: `#/definitions/${step2OutputName}`,
+                    },
+                    inputTransformer: {
+                        fieldset: [
+                            {
+                                from: `${step1Name}Output.${outputAPropertyKey}`,
+                                to: 'inputPropertyB',
+                            },
+                        ],
+                    },
+                },
+            },
+        ],
+        definitions: {
+            [step1InputName]: {
+                type: 'object',
+                properties: {
+                    inputPropertyA: {
+                        type: 'string',
+                    },
+                },
+                required: ['inputPropertyA'],
+                additionalProperties: false,
+            },
+            [step1OutputName]: {
+                type: 'object',
+                properties: {
+                    outputPropertyA: {
+                        type: 'string',
+                    },
+                },
+                required: ['outputPropertyA'],
+                additionalProperties: false,
+            },
+            [step2InputName]: {
+                type: 'object',
+                properties: {
+                    inputPropertyB: {
+                        type: 'string',
+                    },
+                },
+                required: ['inputPropertyB'],
+                additionalProperties: false,
+            },
+            [step2OutputName]: {
+                type: 'object',
+                properties: {
+                    outputPropertyB: {
+                        type: 'string',
+                    },
+                },
+                required: ['outputPropertyB'],
+                additionalProperties: false,
+            },
+        },
+    };
+    test('should initialize engine with valid workflow definition', () => {
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(validWorkflowDefinition),
+                stepExecutors,
+            });
+        }).not.toThrow();
+    });
+    test('should execute a valid workflow', async () => {
+        const engine = new engine_1.JustWorkflowItEngine({
+            workflowDefinition: JSON.stringify(validWorkflowDefinition),
+            stepExecutors,
+        });
+        const initialState = {
+            nextStepName: step1Name,
+            executionData: {},
+            executionHistory: [],
+        };
+        const runner = new engine_1.SampleEngineRunner(engine, initialState);
+        await runner.runUntilTerminalStep();
+        const finalState = runner.getCurrentWorkflowState();
+        expect(finalState).toBeDefined();
+        expect(finalState.nextStepName).toBeNull();
+        expect(finalState.executionHistory.length).toBeGreaterThan(0);
+    });
+    test('should validate workflow definition structure', () => {
+        const engine = new engine_1.JustWorkflowItEngine({
+            workflowDefinition: JSON.stringify(validWorkflowDefinition),
+            stepExecutors,
+        });
+        expect(engine).toBeInstanceOf(engine_1.JustWorkflowItEngine);
+    });
+    test('should handle workflow with multiple steps', async () => {
+        const engine = new engine_1.JustWorkflowItEngine({
+            workflowDefinition: JSON.stringify(validWorkflowDefinition),
+            stepExecutors,
+        });
+        const initialState = {
+            nextStepName: step1Name,
+            executionData: {},
+            executionHistory: [],
+        };
+        const runner = new engine_1.SampleEngineRunner(engine, initialState);
+        await runner.runUntilTerminalStep();
+        const finalState = runner.getCurrentWorkflowState();
+        // Verify that the workflow executed both steps
+        expect(finalState.executionHistory.length).toBe(2);
+        expect(finalState.executionHistory[0].stepName).toBe(step1Name);
+        expect(finalState.executionHistory[1].stepName).toBe(step2Name);
+    });
+    test('should validate step definitions exist', () => {
+        const workflowWithMissingDefinition = {
+            ...validWorkflowDefinition,
+            definitions: {},
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithMissingDefinition),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should execute step and transition to next step', async () => {
+        const engine = new engine_1.JustWorkflowItEngine({
+            workflowDefinition: JSON.stringify(validWorkflowDefinition),
+            stepExecutors,
+        });
+        const initialState = {
+            nextStepName: step1Name,
+            executionData: {},
+            executionHistory: [],
+        };
+        const stateAfterStep1 = await engine.executeNextStep(initialState);
+        expect(stateAfterStep1.nextStepName).toBe(step2Name);
+        expect(stateAfterStep1.executionHistory.length).toBe(1);
+        expect(stateAfterStep1.executionHistory[0].stepName).toBe(step1Name);
+        expect(stateAfterStep1.executionHistory[0]?.output?.status).toBe('success');
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@justworkflowit/cdk-constructs",
   "description": "",
-  "version": "0.0.187",
+  "version": "0.0.189",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
@@ -10,7 +10,8 @@
   "scripts": {
     "build": "tsc && node esbuild-lambdas.js",
     "lint": "eslint . --ext .ts",
-    "lint:fix": "eslint --fix . --ext .ts"
+    "lint:fix": "eslint --fix . --ext .ts",
+    "test": "jest"
   },
   "files": [
     "dist",
@@ -23,10 +24,13 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.842.0",
     "@justworkflowit/api-client": "*",
+    "@justworkflowit/engine": "^0.0.72",
     "aws-cdk-lib": "^2.0.0",
     "constructs": "^10.0.0"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.5",
     "cdk-cli": "^1.1.0",
     "eslint": "^9.29.0",
     "eslint-config-prettier": "^9.1.0",
@@ -35,7 +39,9 @@
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-testing-library": "^7.1.1",
     "eslint-plugin-unused-imports": "^4.1.4",
+    "jest": "^29.7.0",
     "prettier": "^3.6.2",
+    "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.24.1"