@justworkflowit/cdk-constructs 0.0.189 → 0.0.191

package/dist/__tests__/workflowEngine.test.js

@@ -199,4 +199,244 @@ describe('Workflow Engine Integration Tests', () => {
         expect(stateAfterStep1.executionHistory[0].stepName).toBe(step1Name);
         expect(stateAfterStep1.executionHistory[0]?.output?.status).toBe('success');
     });
+    test('should reject invalid workflow definition with malformed JSON', () => {
+        const invalidJson = '{ "workflowName": "invalid", "steps": [';
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: invalidJson,
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with missing required fields', () => {
+        const workflowMissingSteps = {
+            workflowName: 'missingSteps',
+            // steps field is missing
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowMissingSteps),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with invalid step structure', () => {
+        const workflowWithInvalidStep = {
+            workflowName: 'invalidStep',
+            steps: [
+                {
+                    // Missing required 'name' field
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: simpleIntegration,
+                    },
+                },
+            ],
+            definitions: {},
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithInvalidStep),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with non-existent step executor type', () => {
+        const workflowWithBadExecutorType = {
+            workflowName: 'badExecutorType',
+            steps: [
+                {
+                    name: 'testStep',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: 'nonExistentExecutorType',
+                        inputDefinition: {
+                            $ref: '#/definitions/testInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/testOutput',
+                        },
+                    },
+                },
+            ],
+            definitions: {
+                testInput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+                testOutput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithBadExecutorType),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with invalid reference in input transformer', () => {
+        const workflowWithInvalidTransformer = {
+            workflowName: 'invalidTransformer',
+            steps: [
+                {
+                    name: 'testStep',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: simpleIntegration,
+                        inputDefinition: {
+                            $ref: '#/definitions/testInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/testOutput',
+                        },
+                        inputTransformer: {
+                            fieldset: [
+                                {
+                                    from: 'nonExistentStep.someProperty',
+                                    to: 'outputProperty',
+                                },
+                            ],
+                        },
+                    },
+                },
+            ],
+            definitions: {
+                testInput: {
+                    type: 'object',
+                    properties: {
+                        outputProperty: {
+                            type: 'string',
+                        },
+                    },
+                    required: ['outputProperty'],
+                    additionalProperties: false,
+                },
+                testOutput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithInvalidTransformer),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow with array index reference that may not exist', () => {
+        const emptyArrayExecutor = {
+            type: 'emptyArrayExecutor',
+            execute: (_args) => Promise.resolve({
+                status: 'success',
+                payload: { items: [] },
+            }),
+        };
+        const secondStepExecutor = {
+            type: 'secondStepExecutor',
+            execute: (_args) => Promise.resolve({
+                status: 'success',
+                payload: {},
+            }),
+        };
+        const workflowWithArrayReference = {
+            workflowName: 'arrayReferenceWorkflow',
+            steps: [
+                {
+                    name: 'getItems',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: 'processItem',
+                    integrationDetails: {
+                        type: 'emptyArrayExecutor',
+                        inputDefinition: {
+                            $ref: '#/definitions/getItemsInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/getItemsOutput',
+                        },
+                    },
+                },
+                {
+                    name: 'processItem',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: 'secondStepExecutor',
+                        inputDefinition: {
+                            $ref: '#/definitions/processItemInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/processItemOutput',
+                        },
+                        inputTransformer: {
+                            fieldset: [
+                                {
+                                    // This references an array element that may not exist
+                                    from: 'getItemsOutput.items[0].id',
+                                    to: 'itemId',
+                                },
+                            ],
+                        },
+                    },
+                },
+            ],
+            definitions: {
+                getItemsInput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+                getItemsOutput: {
+                    type: 'object',
+                    properties: {
+                        items: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string' },
+                                },
+                            },
+                        },
+                    },
+                    required: ['items'],
+                    additionalProperties: false,
+                },
+                processItemInput: {
+                    type: 'object',
+                    properties: {
+                        itemId: { type: 'string' },
+                    },
+                    required: ['itemId'],
+                    additionalProperties: false,
+                },
+                processItemOutput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        };
+        // Engine performs static type analysis and catches this at definition time
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithArrayReference),
+                stepExecutors: [emptyArrayExecutor, secondStepExecutor],
+            });
+        }).toThrow(/Missing expected field.*items\[0\]/);
+    });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@justworkflowit/cdk-constructs",
   "description": "",
-  "version": "0.0.189",
+  "version": "0.0.191",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {