@justworkflowit/cdk-constructs 0.0.192 → 0.0.194

package/dist/__tests__/constructs/justWorkflowItConstructs.test.d.ts

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

package/dist/__tests__/constructs/justWorkflowItConstructs.test.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const justWorkflowItConstructs_1 = require("../../constructs/justWorkflowItConstructs");
+describe('JustWorkflowItConstructs', () => {
+    const validWorkflowDefinition = JSON.stringify({
+        workflowName: 'validWorkflow',
+        steps: [
+            {
+                name: 'step1',
+                retries: 2,
+                timeoutSeconds: 1000,
+                transitionToStep: null,
+                integrationDetails: {
+                    type: 'testIntegration',
+                    inputDefinition: {
+                        $ref: '#/definitions/step1Input',
+                    },
+                    outputDefinition: {
+                        $ref: '#/definitions/step1Output',
+                    },
+                },
+            },
+        ],
+        definitions: {
+            step1Input: {
+                type: 'object',
+                properties: {
+                    inputProperty: {
+                        type: 'string',
+                    },
+                },
+                required: ['inputProperty'],
+                additionalProperties: false,
+            },
+            step1Output: {
+                type: 'object',
+                properties: {
+                    outputProperty: {
+                        type: 'string',
+                    },
+                },
+                required: ['outputProperty'],
+                additionalProperties: false,
+            },
+        },
+    });
+    test('should create construct with valid workflow definition', () => {
+        const app = new aws_cdk_lib_1.App();
+        const stack = new aws_cdk_lib_1.Stack(app, 'TestStack');
+        expect(() => {
+            new justWorkflowItConstructs_1.JustWorkflowItConstructs(stack, {
+                disambiguator: 'test',
+                organizationId: 'org123',
+                workflowDefinitions: [validWorkflowDefinition],
+            });
+        }).not.toThrow();
+    });
+    test('should reject construct with invalid workflow definition at synth time', () => {
+        const app = new aws_cdk_lib_1.App();
+        const stack = new aws_cdk_lib_1.Stack(app, 'TestStack');
+        const invalidWorkflowDefinition = JSON.stringify({
+            workflowName: 'invalidWorkflow',
+            steps: [
+                {
+                    // Missing required 'name' field
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: 'testIntegration',
+                    },
+                },
+            ],
+            definitions: {},
+        });
+        expect(() => {
+            new justWorkflowItConstructs_1.JustWorkflowItConstructs(stack, {
+                disambiguator: 'test',
+                organizationId: 'org123',
+                workflowDefinitions: [invalidWorkflowDefinition],
+            });
+        }).toThrow(/Invalid workflow definition at index 0/);
+    });
+    test('should reject construct with malformed JSON workflow definition', () => {
+        const app = new aws_cdk_lib_1.App();
+        const stack = new aws_cdk_lib_1.Stack(app, 'TestStack');
+        const malformedJson = '{ "workflowName": "invalid", "steps": [';
+        expect(() => {
+            new justWorkflowItConstructs_1.JustWorkflowItConstructs(stack, {
+                disambiguator: 'test',
+                organizationId: 'org123',
+                workflowDefinitions: [malformedJson],
+            });
+        }).toThrow(/Invalid workflow definition at index 0/);
+    });
+    test('should validate multiple workflow definitions and report correct index on failure', () => {
+        const app = new aws_cdk_lib_1.App();
+        const stack = new aws_cdk_lib_1.Stack(app, 'TestStack');
+        const invalidAtIndex1 = JSON.stringify({
+            workflowName: 'invalid',
+            // Missing steps
+        });
+        expect(() => {
+            new justWorkflowItConstructs_1.JustWorkflowItConstructs(stack, {
+                disambiguator: 'test',
+                organizationId: 'org123',
+                workflowDefinitions: [
+                    validWorkflowDefinition,
+                    invalidAtIndex1,
+                    validWorkflowDefinition,
+                ],
+            });
+        }).toThrow(/Invalid workflow definition at index 1/);
+    });
+    test('should reject workflow with array index that may not exist', () => {
+        const app = new aws_cdk_lib_1.App();
+        const stack = new aws_cdk_lib_1.Stack(app, 'TestStack');
+        const workflowWithArrayRef = JSON.stringify({
+            workflowName: 'arrayRefWorkflow',
+            steps: [
+                {
+                    name: 'getItems',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: 'processItem',
+                    integrationDetails: {
+                        type: 'getItemsIntegration',
+                        inputDefinition: {
+                            $ref: '#/definitions/getItemsInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/getItemsOutput',
+                        },
+                    },
+                },
+                {
+                    name: 'processItem',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: 'processItemIntegration',
+                        inputDefinition: {
+                            $ref: '#/definitions/processItemInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/processItemOutput',
+                        },
+                        inputTransformer: {
+                            fieldset: [
+                                {
+                                    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,
+                },
+            },
+        });
+        expect(() => {
+            new justWorkflowItConstructs_1.JustWorkflowItConstructs(stack, {
+                disambiguator: 'test',
+                organizationId: 'org123',
+                workflowDefinitions: [workflowWithArrayRef],
+            });
+        }).toThrow(/Invalid workflow definition at index 0.*items\[0\]/);
+    });
+});

package/dist/constructs/justWorkflowItConstructs.js

@@ -45,9 +45,38 @@ const aws_s3_1 = require("aws-cdk-lib/aws-s3");
 const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
 const path = __importStar(require("path"));
 const uuid_1 = require("uuid");
+const engine_1 = require("@justworkflowit/engine");
 class JustWorkflowItConstructs extends constructs_1.Construct {
     constructor(scope, props) {
         super(scope, `${JustWorkflowItConstructs.CONSTRUCT_ID_PREFIX}${props.disambiguator}`);
+        // Validate all workflow definitions at CDK synth time
+        props.workflowDefinitions.forEach((definition, index) => {
+            try {
+                // Parse the workflow to extract integration types
+                const parsedWorkflow = JSON.parse(definition);
+                const integrationTypes = new Set();
+                if (parsedWorkflow.steps && Array.isArray(parsedWorkflow.steps)) {
+                    parsedWorkflow.steps.forEach((step) => {
+                        if (step?.integrationDetails?.type) {
+                            integrationTypes.add(step.integrationDetails.type);
+                        }
+                    });
+                }
+                // Create dummy step executors for validation purposes
+                const dummyExecutors = Array.from(integrationTypes).map((type) => ({
+                    type,
+                    execute: async () => ({ status: 'success', payload: {} }),
+                }));
+                // This will throw if the workflow definition is invalid
+                new engine_1.JustWorkflowItEngine({
+                    workflowDefinition: definition,
+                    stepExecutors: dummyExecutors,
+                });
+            }
+            catch (error) {
+                throw new Error(`Invalid workflow definition at index ${index}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
         const secretName = '/justworkflowit/api/authToken';
         const secret = new aws_secretsmanager_1.Secret(this, 'JustWorkflowItAuthTokenSecret', {
             secretName,
@@ -72,7 +101,7 @@ class JustWorkflowItConstructs extends constructs_1.Construct {
         });
         const integrationLambda = new aws_lambda_nodejs_1.NodejsFunction(this, 'JustWorkflowItDefinitionDeployerLambda', {
             functionName: `JustWorkflowItDefinitionDeployer-${props.disambiguator}`,
-            entry: path.join(__dirname, '../lambda/definitionDeployerLambda.js'),
+            entry: path.join(__dirname, '../lambda/definitionDeployerLambda.ts'),
             handler: 'handler',
             runtime: aws_lambda_1.Runtime.NODEJS_20_X,
             timeout: aws_cdk_lib_1.Duration.minutes(5),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@justworkflowit/cdk-constructs",
   "description": "",
-  "version": "0.0.192",
+  "version": "0.0.194",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
@@ -24,11 +24,11 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.842.0",
     "@justworkflowit/api-client": "*",
+    "@justworkflowit/engine": "^0.0.74",
     "aws-cdk-lib": "^2.0.0",
     "constructs": "^10.0.0"
   },
   "devDependencies": {
-    "@justworkflowit/engine": "^0.0.72",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.5",
     "cdk-cli": "^1.1.0",
@@ -47,6 +47,8 @@
     "typescript-eslint": "^8.24.1"
   },
   "peerDependencies": {
+    "@justworkflowit/api-client": "*",
+    "@justworkflowit/engine": "^0.0.74",
     "aws-cdk-lib": "^2.0.0",
     "constructs": "^10.0.0"
   }