@vertesia/workflow 1.1.1-dev.20260505.163000Z → 1.3.0-dev.20260620.061059Z

package/src/dsl/validation.test.ts

@@ -1,257 +1,276 @@
-import { describe, expect, test } from "vitest";
-import { validateWorkflow } from "./validation.ts";
+import type { DSLWorkflowSpec } from '@vertesia/common';
+import { describe, expect, test } from 'vitest';
+import { validateWorkflow } from './validation.js';
 
 describe('workflow validation', () => {
-
-    test('empty object is not a valid workflow', () => {
-        const workflow: any = {
-        }
-        const errors = validateWorkflow(workflow);
+    test('should reject an empty object as a workflow', () => {
+        const workflow = {};
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(2);
-    })
+    });
 
-    test('activities is required', () => {
-        const workflow: any = {
-            name: "test",
-        }
-        const errors = validateWorkflow(workflow);
+    test('should require activities', () => {
+        const workflow = {
+            name: 'test',
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-    test('activities should be an array', () => {
-        const workflow: any = {
-            name: "test",
-            activities: {}
-        }
-        const errors = validateWorkflow(workflow);
+    test('should require activities to be an array', () => {
+        const workflow = {
+            name: 'test',
+            activities: {},
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-    test('activities array should have at least one item', () => {
-        const workflow: any = {
-            name: "test",
-            activities: []
-        }
-        const errors = validateWorkflow(workflow);
+    test('should require activities array to have at least one item', () => {
+        const workflow = {
+            name: 'test',
+            activities: [],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-    test('activity should have a name', () => {
-        const workflow: any = {
-            name: "test",
-            activities: [{}]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should require activity to have a name', () => {
+        const workflow = {
+            name: 'test',
+            activities: [{}],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-    test('allow empty activity', () => {
-        const workflow: any = {
-            name: "test",
-            activities: [{ name: "test" }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should allow empty activity', () => {
+        const workflow = {
+            name: 'test',
+            activities: [{ name: 'test' }],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(0);
-    })
+    });
 
-    test('import undeclared var', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true },
-            activities: [{
-                name: "test",
-                import: ["foo", "bar"]
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should reject imported undeclared vars', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true },
+            activities: [
+                {
+                    name: 'test',
+                    import: ['foo', 'bar'],
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-
-    test('import declared vars', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": true },
-            activities: [{
-                name: "test",
-                import: ["foo", "bar"]
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should allow importing declared vars', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: true },
+            activities: [
+                {
+                    name: 'test',
+                    import: ['foo', 'bar'],
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(0);
-    })
+    });
 
-    test('import unknown imported var through expressions', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true },
-            activities: [{
-                name: "test",
-                import: [{ "foo": "foo", "barLen": "bar.length" }]
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should reject unknown imported vars through expressions', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true },
+            activities: [
+                {
+                    name: 'test',
+                    import: [{ foo: 'foo', barLen: 'bar.length' }],
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-    test('import declared vars through expressions', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": "true" },
-            activities: [{
-                name: "test",
-                import: [{ "foo": "foo", "barLen": "bar.length" }]
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should allow declared vars through expressions', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: 'true' },
+            activities: [
+                {
+                    name: 'test',
+                    import: [{ foo: 'foo', barLen: 'bar.length' }],
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(0);
-    })
+    });
 
-    test('detect self references', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "object_type": "thetype" },
-            activities: [{
-                name: "test",
-                import: ["object_type"],
-                params: {
-                    "object_type": "${object_type}"
-                }
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should detect self references', () => {
+        const workflow = {
+            name: 'test',
+            vars: { object_type: 'thetype' },
+            activities: [
+                {
+                    name: 'test',
+                    import: ['object_type'],
+                    params: {
+                        object_type: '${object_type}',
+                    },
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-        expect(errors[0].includes("Self referencing parameter")).toBe(true);
-    })
+        expect(errors[0].includes('Self referencing parameter')).toBe(true);
+    });
 
-    test('reference known vars in fetch', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": "true" },
-            activities: [{
-                name: "test",
-                import: [{ "foo": "foo", "barLen": "bar.length" }],
-                fetch: {
-                    doc: {
-                        query: {
-                            foo: "${foo}",
-                            barLen: "${barLen}"
-                        }
-                    }
-                }
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should allow known vars in fetch', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: 'true' },
+            activities: [
+                {
+                    name: 'test',
+                    import: [{ foo: 'foo', barLen: 'bar.length' }],
+                    fetch: {
+                        doc: {
+                            query: {
+                                foo: '${foo}',
+                                barLen: '${barLen}',
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         console.log('##############errors', errors);
 
         expect(errors.length).toBe(0);
-    })
+    });
 
-    test('reference unknown vars in fetch', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": "true" },
-            activities: [{
-                name: "test",
-                import: [],
-                fetch: {
-                    doc: {
-                        query: {
-                            foo: "${foo}",
-                            barLen: "${barLen}"
-                        }
-                    }
-                }
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should reject unknown vars in fetch', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: 'true' },
+            activities: [
+                {
+                    name: 'test',
+                    import: [],
+                    fetch: {
+                        doc: {
+                            query: {
+                                foo: '${foo}',
+                                barLen: '${barLen}',
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(2);
-    })
+    });
 
-    test('reference one unknown and one known var in fetch', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": "true" },
-            activities: [{
-                name: "test",
-                import: ["foo"],
-                fetch: {
-                    doc: {
-                        query: {
-                            foo: "${foo}",
-                            barLen: "${barLen}"
-                        }
-                    }
-                }
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should reject one unknown var in fetch while allowing known vars', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: 'true' },
+            activities: [
+                {
+                    name: 'test',
+                    import: ['foo'],
+                    fetch: {
+                        doc: {
+                            query: {
+                                foo: '${foo}',
+                                barLen: '${barLen}',
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-    test('reference 2 unknown vars in params', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": "true" },
-            activities: [{
-                name: "test",
-                import: ["foo"],
-                params: {
-                    barLength: "${barLen}",
-                    doc: "${doc.text}"
-                }
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should reject two unknown vars in params', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: 'true' },
+            activities: [
+                {
+                    name: 'test',
+                    import: ['foo'],
+                    params: {
+                        barLength: '${barLen}',
+                        doc: '${doc.text}',
+                    },
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(2);
-    })
+    });
 
-    test('reference 1 unknown vars in params', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": "true" },
-            activities: [{
-                name: "test",
-                import: ["foo", { "barLen": "bar.length" }],
-                params: {
-                    barLength: "${barLen}",
-                    doc: "${doc.text}"
-                }
-            }]
-        }
-        const errors = validateWorkflow(workflow);
+    test('should reject one unknown var in params', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: 'true' },
+            activities: [
+                {
+                    name: 'test',
+                    import: ['foo', { barLen: 'bar.length' }],
+                    params: {
+                        barLength: '${barLen}',
+                        doc: '${doc.text}',
+                    },
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(1);
-    })
+    });
 
-    test('reference known vars in params', () => {
-        const workflow: any = {
-            name: "test",
-            vars: { "foo": true, "bar": "true" },
+    test('should allow known vars in params', () => {
+        const workflow = {
+            name: 'test',
+            vars: { foo: true, bar: 'true' },
             activities: [
                 {
-                    name: "test0",
-                    output: "previousResult"
-                }, {
-                    name: "test",
-                    import: ["foo", { "barLen": "bar.length" }, "previousResult"],
+                    name: 'test0',
+                    output: 'previousResult',
+                },
+                {
+                    name: 'test',
+                    import: ['foo', { barLen: 'bar.length' }, 'previousResult'],
                     fetch: {
                         doc: {
                             query: {
-                                foo: "${foo}",
-                                barLen: "${barLen}"
-                            }
-                        }
+                                foo: '${foo}',
+                                barLen: '${barLen}',
+                            },
+                        },
                     },
                     params: {
-                        fooParam: "${foo}",
-                        barLenParam: "${barLen}",
-                        doc: "${doc.text}",
-                        prev: "${previousResult}"
-                    }
-                }]
-        }
-        const errors = validateWorkflow(workflow);
+                        fooParam: '${foo}',
+                        barLenParam: '${barLen}',
+                        doc: '${doc.text}',
+                        prev: '${previousResult}',
+                    },
+                },
+            ],
+        };
+        const errors = validateWorkflow(workflow as unknown as DSLWorkflowSpec);
         expect(errors.length).toBe(0);
-    })
-
-})
+    });
+});

package/src/dsl/validation.ts

@@ -1,11 +1,11 @@
-import { DSLActivitySpec, DSLWorkflowSpec, DSLWorkflowStep } from "@vertesia/common";
-import { Vars, splitPath } from "./vars.js";
+import type { DSLActivitySpec, DSLWorkflowSpec, DSLWorkflowStep } from '@vertesia/common';
+import { splitPath, Vars } from './vars.js';
 
 export function validateWorkflow(workflow: DSLWorkflowSpec, vars: string[] = []) {
     const errors: string[] = [];
     const workflowVars = new Set(vars);
-    workflowVars.add("objectId");
-    workflowVars.add("objectIds");
+    workflowVars.add('objectId');
+    workflowVars.add('objectIds');
     if (workflow.vars) {
         for (const v of Object.keys(workflow.vars)) {
             workflowVars.add(v);
@@ -22,7 +22,7 @@ export function validateWorkflow(workflow: DSLWorkflowSpec, vars: string[] = [])
         errors.push("The workflow requires one of 'steps' or 'activities' properties. Neither is present.");
         return errors;
     }
-    const stepsPropName = workflow.steps ? "steps" : "activities";
+    const stepsPropName = workflow.steps ? 'steps' : 'activities';
     const steps = workflow.steps || workflow.activities;
     if (!steps || !Array.isArray(steps)) {
         errors.push(`Workflow '${stepsPropName}' property is required`);
@@ -33,10 +33,11 @@ export function validateWorkflow(workflow: DSLWorkflowSpec, vars: string[] = [])
         return errors;
     }
     if (!steps.length) {
-        errors.push("Workflow should have at least one step or activity");
+        errors.push('Workflow should have at least one step or activity');
     }
 
-    const activities: DSLActivitySpec[] = stepsPropName === "steps" ? (steps as DSLWorkflowStep[]).filter(s => s.type === "activity") : steps;
+    const activities: DSLActivitySpec[] =
+        stepsPropName === 'steps' ? (steps as DSLWorkflowStep[]).filter((s) => s.type === 'activity') : steps;
     for (const activity of activities) {
         const activityErrors = validateActivity(activity, workflowVars);
         if (activityErrors.length > 0) {
@@ -55,7 +56,7 @@ export function validateWorkflow(workflow: DSLWorkflowSpec, vars: string[] = [])
 export function validateActivity(activity: DSLActivitySpec, workflowVars: Set<string>): string[] {
     const errors: string[] = [];
     if (!activity.name) {
-        errors.push("Activity name is required");
+        errors.push('Activity name is required');
     }
     const importedVars = activity.import;
     const localVars: Record<string, boolean> = {};
@@ -99,18 +100,22 @@ export function validateActivity(activity: DSLActivitySpec, workflowVars: Set<st
     return errors;
 }
 
-
-function validateExpressions(target: Record<string, any>, localVars: Record<string, boolean>, errors: string[], checkSelfReference = false) {
+function validateExpressions(
+    target: Record<string, unknown>,
+    localVars: Record<string, boolean>,
+    errors: string[],
+    checkSelfReference = false,
+) {
     const vars = new Vars(localVars);
     const refs = vars.getUnknownReferences(target);
     for (const ref of refs) {
-        errors.push(`Unknown variable "${ref.name}" in expression "${ref.expression}"`)
+        errors.push(`Unknown variable "${ref.name}" in expression "${ref.expression}"`);
     }
     if (checkSelfReference) {
         // check for self references like `"object_type": "${object_type}"`.
         for (const key of Object.keys(target)) {
             const value = target[key];
-            if (typeof value === 'string' && value.includes("${" + key + "}")) {
+            if (typeof value === 'string' && value.includes(`\${${key}}`)) {
                 errors.push(`Self referencing parameter "${key}" in expression "${value}"`);
             }
         }