CLI: adding more validation to workflow

packages/runtime/src/util/validate-plan.ts

@@ -1,16 +1,20 @@
-import { ExecutionPlan, Step } from '@openfn/lexicon';
+import { ExecutionPlan, Job, Step, Trigger, WorkflowOptions } from '@openfn/lexicon';
 import { ValidationError } from '../errors';
+import createLogger from '@openfn/logger';
 
 type ModelNode = {
   up: Record<string, true>;
   down: Record<string, true>;
 };
 
+const logger = createLogger(undefined, { json: true });
+
 type Model = {
   [nodeId: string]: ModelNode;
 };
 
 export default (plan: ExecutionPlan) => {
+  assertWorkflowStructure(plan);
   assertStart(plan);
 
   const model = buildModel(plan);
@@ -20,6 +24,54 @@ export default (plan: ExecutionPlan) => {
   return true;
 };
 
+const assertWorkflowStructure = (plan: ExecutionPlan) => {
+  const { workflow, options } = plan;
+
+  if (!workflow || typeof workflow !== 'object') {
+    throw new ValidationError('Missing or invalid workflow key in execution plan.');
+  }
+
+  if (!Array.isArray(workflow.steps)) {
+    throw new ValidationError('The workflow.steps key must be an array.');
+  }
+
+  if (workflow.steps.length === 0) {
+    logger.warn('Warning: The workflow.steps array is empty.');
+  }
+
+  workflow.steps.forEach((step, index) => {
+    assertStepStructure(step, index);
+  });
+
+  if (options) {
+    assertOptionsStructure(options);
+  }
+};
+
+const assertStepStructure = (step: Job | Step | Trigger, index: number) => {
+  const allowedKeys = ['id', 'name', 'next', 'previous', 'adaptor', 'expression', 'state', 'configuration', 'linker'];
+
+  Object.keys(step).forEach((key) => {
+    if (!allowedKeys.includes(key)) {
+      throw new ValidationError(`Invalid key "${key}" in step ${step.id || index}.`);
+    }
+  });
+
+  if ('adaptor' in step && !('expression' in step)) {
+    throw new ValidationError(`Step ${index} with an adaptor must also have an expression.`);
+  }
+};
+
+const assertOptionsStructure = (options: WorkflowOptions) => {
+  const allowedKeys = ['timeout', 'stepTimeout', 'start', 'end', 'sanitize'];
+
+  Object.keys(options).forEach((key) => {
+    if (!allowedKeys.includes(key)) {
+      logger.warn(`Warning: Unrecognized option "${key}" in options object.`);
+    }
+  });
+};
+
 export const buildModel = ({ workflow }: ExecutionPlan) => {
   const model: Model = {};
 

packages/runtime/test/runtime.test.ts

@@ -528,7 +528,9 @@ test('stuff written to state before an error is preserved', async (t) => {
       steps: [
         {
           id: 'a',
-          data: { x: 0 },
+          state: {
+            data: { x: 0 }
+          },
           expression:
             'export default [(s) => { s.x = 1; throw new Error("test") }]',
         },

packages/runtime/test/util/validate-plan.test.ts

@@ -4,11 +4,11 @@ import type { ExecutionPlan, Job } from '@openfn/lexicon';
 import validate, { buildModel } from '../../src/util/validate-plan';
 
 const job = (id: string, next?: Record<string, boolean>) =>
-  ({
-    id,
-    next,
-    expression: '.',
-  } as Job);
+({
+  id,
+  next,
+  expression: '.',
+} as Job);
 
 test('builds a simple model', (t) => {
   const plan: ExecutionPlan = {
@@ -148,3 +148,44 @@ test('throws for invalid string start', (t) => {
     message: 'Could not find start job: z',
   });
 });
+
+test('throws for adaptor without an expression', (t) => {
+  const plan: ExecutionPlan = {
+    options: {
+      start: 'a',
+    },
+    workflow: {
+      steps: [
+        {
+          id: 'a',
+          adaptor: 'z'
+        }
+      ],
+    },
+  };
+
+  t.throws(() => validate(plan), {
+    message: 'Step 0 with an adaptor must also have an expression.',
+  });
+});
+
+test('throws for unknown key in a step', (t) => {
+  const plan: ExecutionPlan = {
+    options: {
+      start: 'a',
+    },
+    workflow: {
+      steps: [
+        {
+          id: 'a',
+          //@ts-ignore
+          key: 'z'
+        }
+      ],
+    },
+  };
+
+  t.throws(() => validate(plan), {
+    message: 'Invalid key "key" in step a.',
+  });
+});