blokctl 0.2.0

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

@@ -0,0 +1,301 @@
+const VALID_TRIGGER_TYPES = [
+    "http",
+    "grpc",
+    "manual",
+    "cron",
+    "queue",
+    "pubsub",
+    "worker",
+    "webhook",
+    "sse",
+    "websocket",
+];
+const VALID_STEP_TYPES = ["module", "local", "runtime.python3", "runtime.go", "runtime.java"];
+const VALID_HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "ANY", "*"];
+const VALID_QUEUE_PROVIDERS = ["kafka", "rabbitmq", "sqs", "redis", "beanstalk"];
+const VALID_PUBSUB_PROVIDERS = ["gcp", "aws", "azure"];
+const VALID_WEBHOOK_SOURCES = ["github", "stripe", "shopify", "custom"];
+export function validateWorkflow(jsonString) {
+    const errors = [];
+    const warnings = [];
+    let workflow;
+    try {
+        workflow = JSON.parse(jsonString);
+    }
+    catch (e) {
+        return {
+            valid: false,
+            errors: [`Invalid JSON: ${e.message}`],
+            warnings: [],
+        };
+    }
+    validateTopLevel(workflow, 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 (workflow.nodes && typeof workflow.nodes === "object") {
+        validateNodes(workflow.nodes, stepNames, errors, warnings);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+function validateTopLevel(workflow, errors, warnings) {
+    if (!workflow.name || typeof workflow.name !== "string") {
+        errors.push('Missing or invalid "name" field (must be a non-empty string)');
+    }
+    if (workflow.description === undefined) {
+        warnings.push('Missing "description" field - recommended for documentation');
+    }
+    else if (typeof workflow.description !== "string") {
+        errors.push('"description" must be a string');
+    }
+    if (!workflow.version || typeof workflow.version !== "string") {
+        errors.push('Missing or invalid "version" field (must be a string like "1.0.0")');
+    }
+    else if (!/^\d+\.\d+\.\d+/.test(workflow.version)) {
+        warnings.push('"version" should follow semver format (e.g., "1.0.0")');
+    }
+    if (!workflow.trigger || typeof workflow.trigger !== "object") {
+        errors.push('Missing or invalid "trigger" field (must be an object)');
+    }
+    if (!workflow.steps || !Array.isArray(workflow.steps)) {
+        errors.push('Missing or invalid "steps" field (must be an array)');
+    }
+    else if (workflow.steps.length === 0) {
+        errors.push('"steps" array must not be empty');
+    }
+    if (!workflow.nodes || typeof workflow.nodes !== "object") {
+        errors.push('Missing or invalid "nodes" field (must be an object)');
+    }
+}
+function validateTrigger(trigger, errors, warnings) {
+    const triggerKeys = Object.keys(trigger);
+    if (triggerKeys.length === 0) {
+        errors.push("Trigger must have exactly one trigger type");
+        return;
+    }
+    if (triggerKeys.length > 1) {
+        errors.push(`Trigger must have exactly one trigger type, found ${triggerKeys.length}: ${triggerKeys.join(", ")}`);
+        return;
+    }
+    const triggerType = triggerKeys[0];
+    if (!VALID_TRIGGER_TYPES.includes(triggerType)) {
+        errors.push(`Invalid trigger type "${triggerType}". Valid types: ${VALID_TRIGGER_TYPES.join(", ")}`);
+        return;
+    }
+    const config = trigger[triggerType];
+    if (!config || typeof config !== "object") {
+        errors.push(`Trigger "${triggerType}" must have a configuration object`);
+        return;
+    }
+    switch (triggerType) {
+        case "http":
+            validateHttpTrigger(config, errors, warnings);
+            break;
+        case "queue":
+            validateQueueTrigger(config, errors, warnings);
+            break;
+        case "pubsub":
+            validatePubSubTrigger(config, errors, warnings);
+            break;
+        case "cron":
+            validateCronTrigger(config, errors, warnings);
+            break;
+        case "webhook":
+            validateWebhookTrigger(config, errors, warnings);
+            break;
+    }
+}
+function validateHttpTrigger(config, errors, warnings) {
+    if (config.method && typeof config.method === "string") {
+        if (!VALID_HTTP_METHODS.includes(config.method.toUpperCase())) {
+            errors.push(`Invalid HTTP method "${config.method}". Valid methods: ${VALID_HTTP_METHODS.join(", ")}`);
+        }
+    }
+    if (config.path !== undefined && typeof config.path !== "string") {
+        errors.push('HTTP trigger "path" must be a string');
+    }
+    if (config.accept !== undefined && typeof config.accept !== "string") {
+        warnings.push('HTTP trigger "accept" should be a string');
+    }
+}
+function validateQueueTrigger(config, errors, warnings) {
+    if (!config.provider || typeof config.provider !== "string") {
+        errors.push('Queue trigger requires "provider" field');
+    }
+    else if (!VALID_QUEUE_PROVIDERS.includes(config.provider)) {
+        errors.push(`Invalid queue provider "${config.provider}". Valid providers: ${VALID_QUEUE_PROVIDERS.join(", ")}`);
+    }
+    if (!config.topic || typeof config.topic !== "string") {
+        errors.push('Queue trigger requires "topic" field');
+    }
+}
+function validatePubSubTrigger(config, errors, warnings) {
+    if (!config.provider || typeof config.provider !== "string") {
+        errors.push('Pub/Sub trigger requires "provider" field');
+    }
+    else if (!VALID_PUBSUB_PROVIDERS.includes(config.provider)) {
+        errors.push(`Invalid pub/sub provider "${config.provider}". Valid providers: ${VALID_PUBSUB_PROVIDERS.join(", ")}`);
+    }
+    if (!config.topic || typeof config.topic !== "string") {
+        errors.push('Pub/Sub trigger requires "topic" field');
+    }
+    if (!config.subscription || typeof config.subscription !== "string") {
+        errors.push('Pub/Sub trigger requires "subscription" field');
+    }
+}
+function validateCronTrigger(config, errors, warnings) {
+    if (!config.schedule || typeof config.schedule !== "string") {
+        errors.push('Cron trigger requires "schedule" field (cron expression)');
+    }
+    else {
+        const parts = config.schedule.trim().split(/\s+/);
+        if (parts.length < 5 || parts.length > 6) {
+            errors.push(`Invalid cron expression "${config.schedule}". Must have 5 or 6 space-separated fields`);
+        }
+    }
+    if (config.timezone !== undefined && typeof config.timezone !== "string") {
+        errors.push('Cron trigger "timezone" must be a string');
+    }
+}
+function validateWebhookTrigger(config, errors, warnings) {
+    if (!config.source || typeof config.source !== "string") {
+        errors.push('Webhook trigger requires "source" field');
+    }
+    else if (!VALID_WEBHOOK_SOURCES.includes(config.source)) {
+        warnings.push(`Unknown webhook source "${config.source}". Known sources: ${VALID_WEBHOOK_SOURCES.join(", ")}`);
+    }
+    if (!config.events || !Array.isArray(config.events)) {
+        errors.push('Webhook trigger requires "events" array');
+    }
+    else if (config.events.length === 0) {
+        errors.push('Webhook trigger "events" array must not be empty');
+    }
+}
+function validateSteps(steps, stepNames, 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.name || typeof step.name !== "string") {
+            errors.push(`Step at index ${i} is missing required "name" field`);
+            continue;
+        }
+        if (!step.node || typeof step.node !== "string") {
+            errors.push(`Step "${step.name}" is missing required "node" field`);
+        }
+        if (!step.type || typeof step.type !== "string") {
+            errors.push(`Step "${step.name}" is missing required "type" field`);
+        }
+        else if (!VALID_STEP_TYPES.includes(step.type)) {
+            warnings.push(`Step "${step.name}" has unusual type "${step.type}". Common types: ${VALID_STEP_TYPES.join(", ")}`);
+        }
+        if (stepNames.has(step.name)) {
+            errors.push(`Duplicate step name "${step.name}"`);
+        }
+        stepNames.add(step.name);
+    }
+}
+function validateNodes(nodes, stepNames, errors, warnings) {
+    const allReferencedStepNames = new Set(stepNames);
+    for (const [nodeName, nodeConfig] of Object.entries(nodes)) {
+        if (!nodeConfig || typeof nodeConfig !== "object") {
+            errors.push(`Node "${nodeName}" must be an object`);
+            continue;
+        }
+        const config = nodeConfig;
+        if (config.conditions && Array.isArray(config.conditions)) {
+            collectConditionalStepNames(config.conditions, allReferencedStepNames);
+        }
+    }
+    for (const stepName of allReferencedStepNames) {
+        if (!nodes[stepName]) {
+            errors.push(`Step "${stepName}" is referenced but has no matching entry in "nodes"`);
+        }
+    }
+    for (const [nodeName, nodeConfig] of Object.entries(nodes)) {
+        if (!nodeConfig || typeof nodeConfig !== "object")
+            continue;
+        const config = nodeConfig;
+        if (config.conditions && Array.isArray(config.conditions)) {
+            validateConditions(nodeName, config.conditions, errors, warnings);
+        }
+        else if (config.inputs === undefined) {
+            warnings.push(`Node "${nodeName}" has neither "inputs" nor "conditions" - may need configuration`);
+        }
+    }
+}
+function collectConditionalStepNames(conditions, stepNames) {
+    for (const condition of conditions) {
+        if (!condition || typeof condition !== "object")
+            continue;
+        const cond = condition;
+        if (cond.steps && Array.isArray(cond.steps)) {
+            for (const step of cond.steps) {
+                if (step.name && typeof step.name === "string") {
+                    stepNames.add(step.name);
+                }
+            }
+        }
+    }
+}
+function validateConditions(nodeName, conditions, errors, warnings) {
+    let hasElse = false;
+    const conditionStepNames = new Set();
+    for (let i = 0; i < conditions.length; i++) {
+        const cond = conditions[i];
+        if (!cond || typeof cond !== "object") {
+            errors.push(`Condition ${i} in node "${nodeName}" must be an object`);
+            continue;
+        }
+        if (!cond.type || !["if", "else"].includes(cond.type)) {
+            errors.push(`Condition ${i} in node "${nodeName}" must have type "if" or "else"`);
+            continue;
+        }
+        if (cond.type === "if") {
+            if (!cond.condition || typeof cond.condition !== "string") {
+                errors.push(`Condition ${i} in node "${nodeName}" (type "if") must have a "condition" string`);
+            }
+            else {
+                const condStr = cond.condition;
+                if (!condStr.includes("ctx.")) {
+                    warnings.push(`Condition ${i} in node "${nodeName}" doesn't reference ctx.* - may be invalid`);
+                }
+            }
+        }
+        if (cond.type === "else") {
+            hasElse = true;
+            if (i !== conditions.length - 1) {
+                errors.push(`"else" condition in node "${nodeName}" must be the last condition`);
+            }
+        }
+        if (!cond.steps || !Array.isArray(cond.steps) || cond.steps.length === 0) {
+            errors.push(`Condition ${i} in node "${nodeName}" must have at least one step`);
+        }
+        else {
+            for (const step of cond.steps) {
+                if (step.name && typeof step.name === "string") {
+                    if (conditionStepNames.has(step.name)) {
+                        warnings.push(`Duplicate step name "${step.name}" in conditional branches of node "${nodeName}"`);
+                    }
+                    conditionStepNames.add(step.name);
+                }
+                if (!step.name || !step.node || !step.type) {
+                    errors.push(`Step in condition ${i} of node "${nodeName}" must have name, node, and type fields`);
+                }
+            }
+        }
+    }
+    if (!hasElse) {
+        warnings.push(`Conditional node "${nodeName}" has no "else" branch - consider adding a fallback`);
+    }
+}

package/dist/commands/generate/validators/WorkflowValidator.test.d.ts

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