@onlineapps/cookbook-core 2.1.7 → 2.1.9

package/src/parser/cookbookValidator.js

@@ -35,11 +35,11 @@ const loadSchemaFile = (filename) => {
   if (fs.existsSync(schemaPath)) {
     return JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
   }
-  // Fallback to default schema
-  return JSON.parse(fs.readFileSync(path.join(__dirname, '../../schemas/cookbook.schema.json'), 'utf-8'));
+  // Fallback to default v2 schema
+  return JSON.parse(fs.readFileSync(path.join(__dirname, '../../schemas/cookbook.v2.schema.json'), 'utf-8'));
 };
 
-const cookbookSchema = loadSchemaFile('cookbook.schema.json');
+const cookbookSchema = loadSchemaFile('cookbook.v2.schema.json');
 const strictSchema = loadSchemaFile('cookbook.strict.schema.json');
 const relaxedSchema = loadSchemaFile('cookbook.relaxed.schema.json');
 

package/src/parser/cookbookValidatorV2.js

@@ -29,19 +29,18 @@ class CookbookValidationError extends Error {
 }
 
 /**
- * Load schema file with version detection
+ * Load V2 schema - V1 IS BANNED, only one schema exists
  */
 function loadSchema(version = '2.0') {
-  const schemaMap = {
-    '1.0': 'cookbook.schema.json',       // Legacy v1.0 schema
-    '2.0': 'cookbook.v2.schema.json'     // New v2.0 schema with snake_case
-  };
+  // V1 is BANNED - reject immediately
+  if (version.startsWith('1.')) {
+    throw new CookbookValidationError('V1 FORMAT BANNED! Use version 2.x.x');
+  }
 
-  const filename = schemaMap[version.split('.')[0] + '.0'] || schemaMap['2.0'];
-  const schemaPath = path.join(__dirname, '../../schemas', filename);
+  const schemaPath = path.join(__dirname, '../../schemas/cookbook.v2.schema.json');
 
   if (!fs.existsSync(schemaPath)) {
-    throw new CookbookValidationError(`Schema file not found: ${filename}`);
+    throw new CookbookValidationError('Schema file not found: cookbook.v2.schema.json');
   }
 
   return JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
@@ -249,53 +248,48 @@ function validateSemantics(cookbook, version) {
       stepIds.add(stepId);
     }
 
-    // Check nested steps
-    if (step.steps) {
-      step.steps.forEach((nested, idx) =>
-        checkStep(nested, `${path}.steps[${idx}]`)
+    // Check nested steps - V2: all nested steps are objects keyed by step_id
+    if (step.steps && typeof step.steps === 'object') {
+      Object.entries(step.steps).forEach(([nestedKey, nested]) =>
+        checkStep(nested, `${path}.steps.${nestedKey}`)
       );
     }
-    if (step.body) {
-      step.body.forEach((nested, idx) =>
-        checkStep(nested, `${path}.body[${idx}]`)
+    if (step.body && typeof step.body === 'object') {
+      Object.entries(step.body).forEach(([nestedKey, nested]) =>
+        checkStep(nested, `${path}.body.${nestedKey}`)
       );
     }
-    if (step.branches) {
-      step.branches.forEach((branch, idx) => {
-        if (branch.steps) {
-          branch.steps.forEach((nested, jdx) =>
-            checkStep(nested, `${path}.branches[${idx}].steps[${jdx}]`)
-          );
-        }
+    if (step.branches && typeof step.branches === 'object') {
+      Object.entries(step.branches).forEach(([branchKey, branch]) => {
+        checkStep(branch, `${path}.branches.${branchKey}`);
       });
     }
     if (step.cases) {
       Object.keys(step.cases).forEach(caseKey => {
         const caseVal = step.cases[caseKey];
-        if (caseVal.steps) {
-          caseVal.steps.forEach((nested, idx) =>
-            checkStep(nested, `${path}.cases.${caseKey}.steps[${idx}]`)
-          );
-        }
+        checkStep(caseVal, `${path}.cases.${caseKey}`);
       });
     }
   }
 
-  // Check all steps
+  // Check all steps - V2: steps is an OBJECT keyed by step_id, NOT an array
   if (cookbook.steps) {
-    cookbook.steps.forEach((step, idx) =>
-      checkStep(step, `steps[${idx}]`)
+    if (Array.isArray(cookbook.steps)) {
+      throw new CookbookValidationError('V1 FORMAT BANNED! steps must be an object keyed by step_id, not an array');
+    }
+    Object.entries(cookbook.steps).forEach(([stepKey, step]) =>
+      checkStep(step, `steps.${stepKey}`)
     );
   }
 
   // Check dependencies exist
   if (version === '2.0' && cookbook.steps) {
-    cookbook.steps.forEach((step, idx) => {
+    Object.entries(cookbook.steps).forEach(([stepKey, step]) => {
       if (step.depends_on) {
         step.depends_on.forEach(dep => {
           if (!stepIds.has(dep)) {
             throw new CookbookValidationError(
-              `Step ${idx} depends on non-existent step_id '${dep}'`
+              `Step '${stepKey}' depends on non-existent step_id '${dep}'`
             );
           }
         });

package/src/schema.js

@@ -22,15 +22,15 @@ function loadSchema(mode = 'default') {
       schemaFile = 'cookbook.relaxed.schema.json';
       break;
     default:
-      schemaFile = 'cookbook.schema.json';
+      schemaFile = 'cookbook.v2.schema.json';
   }
 
   const schemaPath = path.join(__dirname, '../schemas', schemaFile);
 
   // Check if file exists
   if (!fs.existsSync(schemaPath)) {
-    // Fall back to default schema
-    const defaultPath = path.join(__dirname, '../schemas/cookbook.schema.json');
+    // Fall back to default v2 schema
+    const defaultPath = path.join(__dirname, '../schemas/cookbook.v2.schema.json');
     return JSON.parse(fs.readFileSync(defaultPath, 'utf-8'));
   }
 

package/schemas/cookbook.schema.json

@@ -1,482 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "required": ["steps", "version"],
-  "additionalProperties": true,
-  "properties": {
-    "name": {
-      "type": "string",
-      "minLength": 1
-    },
-    "version": {
-      "type": "string",
-      "pattern": "^\\d+\\.\\d+\\.\\d+$",
-      "description": "Semantic version of the cookbook schema"
-    },
-    "description": {
-      "type": "string"
-    },
-    "api_input": {
-      "type": "object"
-    },
-    "global_error_handler": {
-      "$ref": "#/definitions/ErrorHandler",
-      "description": "Default error handling for all steps"
-    },
-    "global_retry": {
-      "$ref": "#/definitions/Retry",
-      "description": "Default retry policy for all steps"
-    },
-    "global_timeout": {
-      "type": "integer",
-      "minimum": 1,
-      "description": "Maximum execution time for entire workflow in milliseconds"
-    },
-    "metadata": {
-      "type": "object",
-      "properties": {
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "priority": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 10
-        },
-        "deprecated": {
-          "type": "boolean"
-        },
-        "deprecationMessage": {
-          "type": "string"
-        },
-        "author": {
-          "type": "string"
-        },
-        "created": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "modified": {
-          "type": "string",
-          "format": "date-time"
-        }
-      },
-      "additionalProperties": true
-    },
-    "steps": {
-      "type": "array",
-      "minItems": 1,
-      "items": {
-        "$ref": "#/definitions/Step"
-      }
-    }
-  },
-  "definitions": {
-    "Step": {
-      "type": "object",
-      "required": ["id", "type"],
-      "oneOf": [
-        { "$ref": "#/definitions/TaskStep" },
-        { "$ref": "#/definitions/ForeachStep" },
-        { "$ref": "#/definitions/ForkJoinStep" },
-        { "$ref": "#/definitions/SwitchStep" },
-        { "$ref": "#/definitions/SubWorkflowStep" },
-        { "$ref": "#/definitions/WaitStep" },
-        { "$ref": "#/definitions/DispatchStep" }
-      ]
-    },
-    "TaskStep": {
-      "type": "object",
-      "required": ["id", "type", "service"],
-      "additionalProperties": true,
-      "properties": {
-        "id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "type": {
-          "type": "string",
-          "const": "task"
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
-        "service": {
-          "type": "string",
-          "minLength": 1
-        },
-        "action": {
-          "type": "string",
-          "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
-        },
-        "endpoint": {
-          "type": "string",
-          "minLength": 1
-        },
-        "operation": {
-          "type": "string",
-          "minLength": 1,
-          "description": "Operation identifier for the service to execute"
-        },
-        "input": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional input mapping - supports all JSON types"
-        },
-        "output": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional output mapping - supports all JSON types"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "retry": {
-          "$ref": "#/definitions/Retry"
-        },
-        "timeoutMs": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression that must evaluate to true for step to execute"
-        }
-      },
-      "condition": {
-        "type": "string",
-        "description": "JSONPath expression for conditional execution"
-      },
-      "timeoutMs": {
-        "type": "integer",
-        "minimum": 1,
-        "description": "Timeout for entire foreach loop"
-      },
-      "on_error": {
-        "$ref": "#/definitions/ErrorHandler"
-      }
-    },
-    "ForeachStep": {
-      "type": "object",
-      "required": ["id", "type", "iterator", "body"],
-      "additionalProperties": true,
-      "properties": {
-        "id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "type": {
-          "type": "string",
-          "const": "foreach"
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
-        "iterator": {
-          "type": "string",
-          "minLength": 1
-        },
-        "body": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "$ref": "#/definitions/Step"
-          }
-        },
-        "output": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional output collection mapping"
-        }
-      }
-    },
-    "ForkJoinStep": {
-      "type": "object",
-      "required": ["id", "type", "branches", "join"],
-      "additionalProperties": true,
-      "properties": {
-        "id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "type": {
-          "type": "string",
-          "const": "fork_join"
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
-        "branches": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "$ref": "#/definitions/Step"
-          }
-        },
-        "join": {
-          "type": "object",
-          "required": ["strategy"],
-          "additionalProperties": false,
-          "properties": {
-            "strategy": {
-              "type": "string",
-              "enum": ["merge", "first", "last", "all", "custom"],
-              "description": "How to combine branch results"
-            },
-            "output": {
-              "type": "object",
-              "additionalProperties": true,
-              "description": "Optional output mapping for joined results"
-            }
-          }
-        }
-      },
-      "condition": {
-        "type": "string",
-        "description": "JSONPath expression for conditional execution"
-      },
-      "timeoutMs": {
-        "type": "integer",
-        "minimum": 1,
-        "description": "Timeout for all branches"
-      },
-      "on_error": {
-        "$ref": "#/definitions/ErrorHandler"
-      }
-    },
-    "SwitchStep": {
-      "type": "object",
-      "required": ["id", "type", "expression", "cases", "default"],
-      "additionalProperties": true,
-      "properties": {
-        "id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "type": {
-          "type": "string",
-          "const": "switch"
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
-        "expression": {
-          "type": "string",
-          "minLength": 1
-        },
-        "cases": {
-          "type": "object",
-          "minProperties": 1,
-          "additionalProperties": {
-            "$ref": "#/definitions/Step"
-          }
-        },
-        "default": {
-          "$ref": "#/definitions/Step"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        }
-      }
-    },
-    "SubWorkflowStep": {
-      "type": "object",
-      "required": ["id", "type", "steps"],
-      "additionalProperties": true,
-      "properties": {
-        "id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "type": {
-          "type": "string",
-          "const": "sub_workflow"
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
-        "input": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional input for sub-workflow - supports all JSON types"
-        },
-        "steps": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "$ref": "#/definitions/Step"
-          }
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
-        },
-        "timeoutMs": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Timeout for entire sub-workflow"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        }
-      }
-    },
-    "WaitStep": {
-      "type": "object",
-      "required": ["id", "type", "durationMs"],
-      "additionalProperties": true,
-      "properties": {
-        "id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "type": {
-          "type": "string",
-          "const": "wait"
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
-        "durationMs": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
-        }
-      }
-    },
-    "DispatchStep": {
-      "type": "object",
-      "required": ["id", "type", "method", "target"],
-      "additionalProperties": true,
-      "properties": {
-        "id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "type": {
-          "type": "string",
-          "const": "dispatch"
-        },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
-        "method": {
-          "type": "string",
-          "enum": ["webhook", "http", "grpc", "kafka", "sqs", "custom"],
-          "description": "Dispatch method to use"
-        },
-        "target": {
-          "type": "string",
-          "format": "uri"
-        },
-        "input": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional dispatch payload - supports all JSON types"
-        },
-        "retry": {
-          "$ref": "#/definitions/Retry"
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
-        },
-        "timeoutMs": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Timeout for dispatch operation"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        }
-      }
-    },
-    "Retry": {
-      "type": "object",
-      "required": ["maxAttempts", "delayMs"],
-      "additionalProperties": false,
-      "properties": {
-        "maxAttempts": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "delayMs": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "backoffMultiplier": {
-          "type": "number",
-          "minimum": 1.0,
-          "maximum": 5.0,
-          "description": "Exponential backoff multiplier"
-        }
-      }
-    },
-    "ErrorHandler": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "strategy": {
-          "type": "string",
-          "enum": ["retry", "fail", "continue", "compensate", "fallback"],
-          "description": "How to handle errors"
-        },
-        "retries": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 10,
-          "description": "Number of retries before applying strategy"
-        },
-        "retryDelayMs": {
-          "type": "integer",
-          "minimum": 0,
-          "description": "Delay between retries"
-        },
-        "fallbackStep": {
-          "type": "string",
-          "description": "Step ID to execute as fallback"
-        },
-        "compensationStep": {
-          "type": "string",
-          "description": "Step ID to execute for compensation/rollback"
-        },
-        "errorOutput": {
-          "type": "string",
-          "description": "JSONPath to store error details"
-        }
-      },
-      "required": ["strategy"]
-    }
-  }
-}