blokctl 0.7.0 → 1.0.0

package/dist/commands/generate/validators/WorkflowValidator.js

@@ -29,15 +29,21 @@ export function validateWorkflow(jsonString) {
             warnings: [],
         };
     }
-    validateTopLevel(workflow, errors, warnings);
+    const v2 = isV2Workflow(workflow.steps);
+    validateTopLevel(workflow, v2, errors, warnings);
     if (workflow.trigger && typeof workflow.trigger === "object") {
         validateTrigger(workflow.trigger, errors, warnings);
     }
     const stepNames = new Set();
     if (Array.isArray(workflow.steps)) {
-        validateSteps(workflow.steps, stepNames, errors, warnings);
+        if (v2) {
+            validateV2Steps(workflow.steps, stepNames, errors, warnings);
+        }
+        else {
+            validateSteps(workflow.steps, stepNames, errors, warnings);
+        }
     }
-    if (workflow.nodes && typeof workflow.nodes === "object") {
+    if (!v2 && workflow.nodes && typeof workflow.nodes === "object") {
         validateNodes(workflow.nodes, stepNames, errors, warnings);
     }
     return {
@@ -46,7 +52,17 @@ export function validateWorkflow(jsonString) {
         warnings,
     };
 }
-function validateTopLevel(workflow, errors, warnings) {
+function isV2Workflow(steps) {
+    if (!Array.isArray(steps))
+        return false;
+    return steps.some((s) => {
+        if (!s || typeof s !== "object")
+            return false;
+        const step = s;
+        return step.use !== undefined || step.branch !== undefined || (step.id !== undefined && step.name === undefined);
+    });
+}
+function validateTopLevel(workflow, v2, errors, warnings) {
     if (!workflow.name || typeof workflow.name !== "string") {
         errors.push('Missing or invalid "name" field (must be a non-empty string)');
     }
@@ -71,7 +87,7 @@ function validateTopLevel(workflow, errors, warnings) {
     else if (workflow.steps.length === 0) {
         errors.push('"steps" array must not be empty');
     }
-    if (!workflow.nodes || typeof workflow.nodes !== "object") {
+    if (!v2 && (!workflow.nodes || typeof workflow.nodes !== "object")) {
         errors.push('Missing or invalid "nodes" field (must be an object)');
     }
 }
@@ -205,6 +221,65 @@ function validateSteps(steps, stepNames, errors, warnings) {
         stepNames.add(step.name);
     }
 }
+function validateV2Steps(steps, ids, errors, warnings) {
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        if (!step || typeof step !== "object") {
+            errors.push(`Step at index ${i} must be an object`);
+            continue;
+        }
+        if (!step.id || typeof step.id !== "string") {
+            errors.push(`Step at index ${i} is missing required "id" field`);
+            continue;
+        }
+        if (ids.has(step.id)) {
+            errors.push(`Duplicate step id "${step.id}" — step ids are flat per workflow (including branch arms)`);
+        }
+        ids.add(step.id);
+        if (step.branch !== undefined) {
+            const branch = step.branch;
+            if (!branch || typeof branch !== "object") {
+                errors.push(`Step "${step.id}" has an invalid "branch" (must be an object)`);
+                continue;
+            }
+            if (!branch.when || typeof branch.when !== "string") {
+                errors.push(`Branch step "${step.id}" is missing a "when" condition string`);
+            }
+            else if (branch.when.startsWith("js/") || branch.when.startsWith("$.")) {
+                errors.push(`Branch step "${step.id}" "when" must be a raw \`ctx.*\` expression (e.g. "ctx.state.x > 10") — never "js/..." or "$...", which throw at runtime`);
+            }
+            if (!Array.isArray(branch.then) || branch.then.length === 0) {
+                errors.push(`Branch step "${step.id}" must have a non-empty "then" array`);
+            }
+            else {
+                validateV2Steps(branch.then, ids, errors, warnings);
+            }
+            if (branch.else !== undefined) {
+                if (!Array.isArray(branch.else)) {
+                    errors.push(`Branch step "${step.id}" "else" must be an array when present`);
+                }
+                else {
+                    validateV2Steps(branch.else, ids, errors, warnings);
+                }
+            }
+            continue;
+        }
+        if ((!step.use || typeof step.use !== "string") && typeof step.subworkflow !== "string") {
+            errors.push(`Step "${step.id}" is missing required "use" field (the node to run)`);
+        }
+        if (step.type !== undefined) {
+            if (typeof step.type !== "string") {
+                errors.push(`Step "${step.id}" "type" must be a string`);
+            }
+            else if (!VALID_STEP_TYPES.includes(step.type) && !step.type.startsWith("runtime.")) {
+                warnings.push(`Step "${step.id}" has unusual type "${step.type}". Common types: ${VALID_STEP_TYPES.join(", ")}`);
+            }
+        }
+        if (step.as !== undefined && step.spread !== undefined) {
+            errors.push(`Step "${step.id}" sets both "as" and "spread" — they are mutually exclusive`);
+        }
+    }
+}
 function validateNodes(nodes, stepNames, errors, warnings) {
     const allReferencedStepNames = new Set(stepNames);
     for (const [nodeName, nodeConfig] of Object.entries(nodes)) {

package/dist/commands/generate/validators/WorkflowValidator.test.js

@@ -644,4 +644,70 @@ describe("WorkflowValidator", () => {
             expect(result.valid).toBe(true);
         });
     });
+    describe("v2 workflows (inline inputs, no nodes map)", () => {
+        const base = {
+            name: "V2 Flow",
+            description: "A v2 workflow",
+            version: "1.0.0",
+            trigger: { http: { method: "GET", path: "/v2" } },
+        };
+        it("accepts a v2 workflow with id/use/inputs and no nodes map", () => {
+            const result = validateWorkflow(JSON.stringify({
+                ...base,
+                steps: [
+                    { id: "fetch", use: "@blokjs/api-call", inputs: { url: "https://x" } },
+                    { id: "respond", use: "@blokjs/respond", inputs: { body: "$.state.fetch" }, ephemeral: true },
+                ],
+            }));
+            expect(result.valid).toBe(true);
+        });
+        it("accepts a v2 branch step and validates its arm ids", () => {
+            const result = validateWorkflow(JSON.stringify({
+                ...base,
+                steps: [
+                    {
+                        id: "route",
+                        branch: {
+                            when: "ctx.req.method === 'POST'",
+                            then: [{ id: "create", use: "@blokjs/api-call", inputs: {} }],
+                            else: [{ id: "read", use: "@blokjs/api-call", inputs: {} }],
+                        },
+                    },
+                ],
+            }));
+            expect(result.valid).toBe(true);
+        });
+        it("errors on a v2 step missing use", () => {
+            const result = validateWorkflow(JSON.stringify({ ...base, steps: [{ id: "x", inputs: {} }] }));
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes('missing required "use"'))).toBe(true);
+        });
+        it("errors on a duplicate id across a branch arm", () => {
+            const result = validateWorkflow(JSON.stringify({
+                ...base,
+                steps: [
+                    { id: "dup", use: "@blokjs/api-call", inputs: {} },
+                    {
+                        id: "b",
+                        branch: { when: "ctx.state.dup.ok", then: [{ id: "dup", use: "@blokjs/respond", inputs: {} }] },
+                    },
+                ],
+            }));
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("Duplicate step id"))).toBe(true);
+        });
+        it("errors on a branch when prefixed with js/ or $.", () => {
+            const result = validateWorkflow(JSON.stringify({
+                ...base,
+                steps: [{ id: "b", branch: { when: "js/ctx.state.x", then: [{ id: "t", use: "n", inputs: {} }] } }],
+            }));
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("raw"))).toBe(true);
+        });
+        it("errors when a v2 step sets both as and spread", () => {
+            const result = validateWorkflow(JSON.stringify({ ...base, steps: [{ id: "x", use: "n", as: "y", spread: true, inputs: {} }] }));
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.includes("mutually exclusive"))).toBe(true);
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blokctl",
-	"version": "0.7.0",
+	"version": "1.0.0",
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"description": "cli for blok",
@@ -30,7 +30,7 @@
 	"keywords": ["blokctl", "cli", "blok", "blok"],
 	"dependencies": {
 		"@ai-sdk/openai": "^1.3.22",
-		"@blokjs/runner": "^0.7.0",
+		"@blokjs/runner": "^1.0.0",
 		"@clack/prompts": "^1.0.0",
 		"ai": "^4.3.16",
 		"better-sqlite3": "^12.6.2",