@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/tests/workflow-trigger-schema.test.ts

@@ -0,0 +1,359 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { z } from "zod";
+import {
+  closeDb,
+  createWorkflow,
+  deleteWorkflow,
+  getWorkflow,
+  getWorkflowRun,
+  initDb,
+} from "../be/db";
+import type { Workflow, WorkflowDefinition } from "../types";
+import { startWorkflowExecution, TriggerSchemaError } from "../workflows/engine";
+import {
+  BaseExecutor,
+  type ExecutorDependencies,
+  type ExecutorResult,
+} from "../workflows/executors/base";
+import { ExecutorRegistry } from "../workflows/executors/registry";
+
+const TEST_DB_PATH = "./test-workflow-trigger-schema.sqlite";
+
+// ─── Test Executor ──────────────────────────────────────────
+
+class EchoExecutor extends BaseExecutor<typeof EchoExecutor.schema, typeof EchoExecutor.outSchema> {
+  static readonly schema = z.object({ message: z.string() });
+  static readonly outSchema = z.object({ echo: z.string() });
+
+  readonly type = "echo";
+  readonly mode = "instant" as const;
+  readonly configSchema = EchoExecutor.schema;
+  readonly outputSchema = EchoExecutor.outSchema;
+
+  protected async execute(
+    config: z.infer<typeof EchoExecutor.schema>,
+  ): Promise<ExecutorResult<z.infer<typeof EchoExecutor.outSchema>>> {
+    return { status: "success", output: { echo: config.message } };
+  }
+}
+
+// ─── Mock Dependencies ───────────────────────────────────────
+
+const mockDeps: ExecutorDependencies = {
+  db: {} as typeof import("../be/db"),
+  eventBus: { emit: () => {}, on: () => {}, off: () => {} },
+  interpolate: (t: string) => t,
+};
+
+function createTestRegistry(): ExecutorRegistry {
+  const registry = new ExecutorRegistry();
+  registry.register(new EchoExecutor(mockDeps));
+  return registry;
+}
+
+let workflowCounter = 0;
+const createdWorkflowIds: string[] = [];
+
+function makeWorkflow(
+  def: WorkflowDefinition,
+  overrides?: { triggerSchema?: Record<string, unknown> },
+): Workflow {
+  workflowCounter++;
+  const workflow = createWorkflow({
+    name: `test-trigger-schema-${workflowCounter}-${Date.now()}`,
+    definition: def,
+    triggerSchema: overrides?.triggerSchema,
+  });
+  createdWorkflowIds.push(workflow.id);
+  return workflow;
+}
+
+// ─── Tests ───────────────────────────────────────────────────
+
+describe("Workflow triggerSchema (Phase 4)", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    for (const id of createdWorkflowIds) {
+      try {
+        deleteWorkflow(id);
+      } catch {
+        // Already deleted
+      }
+    }
+    closeDb();
+    try {
+      await unlink(TEST_DB_PATH);
+      await unlink(`${TEST_DB_PATH}-wal`);
+      await unlink(`${TEST_DB_PATH}-shm`);
+    } catch {
+      // Files may not exist
+    }
+  });
+
+  // ─── Valid Trigger Payload ──────────────────────────────────
+
+  test("valid trigger payload against schema — execution starts", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [
+        {
+          id: "step1",
+          type: "echo",
+          config: { message: "{{trigger.message}}" },
+        },
+      ],
+    };
+
+    const workflow = makeWorkflow(def, {
+      triggerSchema: {
+        type: "object",
+        properties: { message: { type: "string" } },
+        required: ["message"],
+      },
+    });
+
+    const runId = await startWorkflowExecution(workflow, { message: "hello world" }, registry);
+    const run = getWorkflowRun(runId);
+    expect(run!.status).toBe("completed");
+  });
+
+  // ─── Invalid Trigger Payload ────────────────────────────────
+
+  test("invalid trigger payload — execution rejected with descriptive error", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [
+        {
+          id: "step1",
+          type: "echo",
+          config: { message: "{{trigger.message}}" },
+        },
+      ],
+    };
+
+    const workflow = makeWorkflow(def, {
+      triggerSchema: {
+        type: "object",
+        properties: { message: { type: "string" } },
+        required: ["message"],
+      },
+    });
+
+    try {
+      await startWorkflowExecution(workflow, { wrong: "field" }, registry);
+      throw new Error("Should have thrown TriggerSchemaError");
+    } catch (err) {
+      expect(err).toBeInstanceOf(TriggerSchemaError);
+      const tsErr = err as TriggerSchemaError;
+      expect(tsErr.validationErrors.length).toBeGreaterThan(0);
+      expect(tsErr.message).toContain("message");
+    }
+  });
+
+  // ─── No triggerSchema — Any Payload Accepted ────────────────
+
+  test("no triggerSchema defined — any payload accepted (backward compat)", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [
+        {
+          id: "step1",
+          type: "echo",
+          config: { message: "hi" },
+        },
+      ],
+    };
+
+    // No triggerSchema
+    const workflow = makeWorkflow(def);
+
+    const runId = await startWorkflowExecution(
+      workflow,
+      { anything: "goes", nested: { deep: true } },
+      registry,
+    );
+    const run = getWorkflowRun(runId);
+    expect(run!.status).toBe("completed");
+  });
+
+  // ─── Required Fields ────────────────────────────────────────
+
+  test("schema with required fields — missing field triggers error", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [
+        {
+          id: "step1",
+          type: "echo",
+          config: { message: "hi" },
+        },
+      ],
+    };
+
+    const workflow = makeWorkflow(def, {
+      triggerSchema: {
+        type: "object",
+        required: ["repo", "branch"],
+      },
+    });
+
+    try {
+      await startWorkflowExecution(workflow, { repo: "myrepo" }, registry);
+      throw new Error("Should have thrown TriggerSchemaError");
+    } catch (err) {
+      expect(err).toBeInstanceOf(TriggerSchemaError);
+      const tsErr = err as TriggerSchemaError;
+      // Should mention the missing "branch" field
+      expect(tsErr.validationErrors.some((e) => e.includes("branch"))).toBe(true);
+      // Should NOT mention "repo" (it's present)
+      expect(tsErr.validationErrors.some((e) => e.includes("repo"))).toBe(false);
+    }
+  });
+
+  // ─── Field-Level Error Details ──────────────────────────────
+
+  test("trigger validation error includes field-level details", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [
+        {
+          id: "step1",
+          type: "echo",
+          config: { message: "hi" },
+        },
+      ],
+    };
+
+    const workflow = makeWorkflow(def, {
+      triggerSchema: {
+        type: "object",
+        properties: {
+          count: { type: "number" },
+          name: { type: "string" },
+        },
+        required: ["count", "name"],
+      },
+    });
+
+    try {
+      // Pass wrong types for both fields
+      await startWorkflowExecution(workflow, { count: "not-a-number", name: 42 }, registry);
+      throw new Error("Should have thrown TriggerSchemaError");
+    } catch (err) {
+      expect(err).toBeInstanceOf(TriggerSchemaError);
+      const tsErr = err as TriggerSchemaError;
+      // Should have field-level details for both fields
+      expect(tsErr.validationErrors.some((e) => e.includes("count"))).toBe(true);
+      expect(tsErr.validationErrors.some((e) => e.includes("name"))).toBe(true);
+    }
+  });
+
+  // ─── TriggerSchemaError Properties ──────────────────────────
+
+  test("TriggerSchemaError has correct name and validationErrors array", () => {
+    const errors = ['root: missing required property "foo"', 'bar: expected type "number"'];
+    const err = new TriggerSchemaError(errors);
+    expect(err.name).toBe("TriggerSchemaError");
+    expect(err.validationErrors).toEqual(errors);
+    expect(err.message).toContain("foo");
+    expect(err.message).toContain("bar");
+    expect(err).toBeInstanceOf(Error);
+  });
+
+  // ─── triggerSchema Persisted in DB ──────────────────────────
+
+  test("triggerSchema is persisted and retrieved from DB", () => {
+    const def: WorkflowDefinition = {
+      nodes: [{ id: "s1", type: "echo", config: { message: "hi" } }],
+    };
+
+    const schema = {
+      type: "object",
+      properties: { repo: { type: "string" } },
+      required: ["repo"],
+    };
+
+    const workflow = makeWorkflow(def, { triggerSchema: schema });
+    const loaded = getWorkflow(workflow.id);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.triggerSchema).toEqual(schema);
+  });
+
+  test("workflow without triggerSchema has undefined triggerSchema", () => {
+    const def: WorkflowDefinition = {
+      nodes: [{ id: "s1", type: "echo", config: { message: "hi" } }],
+    };
+
+    const workflow = makeWorkflow(def);
+    const loaded = getWorkflow(workflow.id);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.triggerSchema).toBeUndefined();
+  });
+
+  // ─── Wrong Root Type ────────────────────────────────────────
+
+  test("trigger data of wrong root type — rejected", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [{ id: "s1", type: "echo", config: { message: "hi" } }],
+    };
+
+    const workflow = makeWorkflow(def, {
+      triggerSchema: { type: "object" },
+    });
+
+    try {
+      // Pass a string instead of an object
+      await startWorkflowExecution(workflow, "just a string", registry);
+      throw new Error("Should have thrown TriggerSchemaError");
+    } catch (err) {
+      expect(err).toBeInstanceOf(TriggerSchemaError);
+      const tsErr = err as TriggerSchemaError;
+      expect(tsErr.validationErrors[0]).toContain("object");
+    }
+  });
+
+  // ─── Null Trigger Data ──────────────────────────────────────
+
+  test("null trigger data against object schema — rejected", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [{ id: "s1", type: "echo", config: { message: "hi" } }],
+    };
+
+    const workflow = makeWorkflow(def, {
+      triggerSchema: { type: "object" },
+    });
+
+    try {
+      await startWorkflowExecution(workflow, null, registry);
+      throw new Error("Should have thrown TriggerSchemaError");
+    } catch (err) {
+      expect(err).toBeInstanceOf(TriggerSchemaError);
+    }
+  });
+
+  // ─── Empty Schema — Accepts Anything ────────────────────────
+
+  test("empty triggerSchema ({}) — accepts any payload", async () => {
+    const registry = createTestRegistry();
+    const def: WorkflowDefinition = {
+      nodes: [{ id: "s1", type: "echo", config: { message: "hi" } }],
+    };
+
+    const workflow = makeWorkflow(def, { triggerSchema: {} });
+
+    const runId = await startWorkflowExecution(workflow, { anything: "goes" }, registry);
+    const run = getWorkflowRun(runId);
+    expect(run!.status).toBe("completed");
+  });
+});

package/src/tests/workflow-triggers-v2.test.ts

@@ -0,0 +1,264 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import crypto from "node:crypto";
+import { unlink } from "node:fs/promises";
+import { z } from "zod";
+import { closeDb, createWorkflow, getWorkflowRun, initDb, updateWorkflow } from "../be/db";
+import type { Workflow } from "../types";
+import { startWorkflowExecution } from "../workflows/engine";
+import { BaseExecutor, type ExecutorResult } from "../workflows/executors/base";
+import { ExecutorRegistry } from "../workflows/executors/registry";
+import { handleWebhookTrigger, verifyHmacSignature, WebhookError } from "../workflows/triggers";
+
+const TEST_DB_PATH = "./test-workflow-triggers-v2.sqlite";
+
+// ─── Test Executor ──────────────────────────────────────────
+
+class NoopExecutor extends BaseExecutor<typeof NoopExecutor.schema, typeof NoopExecutor.outSchema> {
+  static readonly schema = z.object({
+    channel: z.string().optional(),
+    template: z.string().optional(),
+  });
+  static readonly outSchema = z.object({ sent: z.boolean() });
+
+  readonly type = "notify";
+  readonly mode = "instant" as const;
+  readonly configSchema = NoopExecutor.schema;
+  readonly outputSchema = NoopExecutor.outSchema;
+
+  protected async execute(): Promise<ExecutorResult<z.infer<typeof NoopExecutor.outSchema>>> {
+    return { status: "success", output: { sent: true } };
+  }
+}
+
+// ─── Setup ──────────────────────────────────────────────────
+
+let registry: ExecutorRegistry;
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+  registry = new ExecutorRegistry();
+  registry.register(new NoopExecutor());
+});
+
+afterAll(async () => {
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function makeWorkflow(overrides?: Partial<Parameters<typeof createWorkflow>[0]>): Workflow {
+  return createWorkflow({
+    name: `test-wf-${crypto.randomUUID().slice(0, 8)}`,
+    definition: {
+      nodes: [
+        {
+          id: "n1",
+          type: "notify",
+          config: { channel: "swarm", template: "test" },
+        },
+      ],
+    },
+    ...overrides,
+  });
+}
+
+// ─── HMAC Verification ──────────────────────────────────────
+
+describe("verifyHmacSignature", () => {
+  const secret = "test-secret-123";
+  const body = '{"event":"test"}';
+
+  test("valid sha256=<hex> signature passes", () => {
+    const hmac = crypto.createHmac("sha256", secret);
+    hmac.update(body);
+    const sig = `sha256=${hmac.digest("hex")}`;
+
+    expect(verifyHmacSignature(secret, body, sig)).toBe(true);
+  });
+
+  test("valid raw hex signature passes", () => {
+    const hmac = crypto.createHmac("sha256", secret);
+    hmac.update(body);
+    const sig = hmac.digest("hex");
+
+    expect(verifyHmacSignature(secret, body, sig)).toBe(true);
+  });
+
+  test("invalid signature fails", () => {
+    expect(verifyHmacSignature(secret, body, "sha256=invalid")).toBe(false);
+  });
+
+  test("wrong secret fails", () => {
+    const hmac = crypto.createHmac("sha256", "wrong-secret");
+    hmac.update(body);
+    const sig = `sha256=${hmac.digest("hex")}`;
+
+    expect(verifyHmacSignature(secret, body, sig)).toBe(false);
+  });
+
+  test("empty signature fails", () => {
+    expect(verifyHmacSignature(secret, body, "")).toBe(false);
+  });
+});
+
+// ─── Webhook Trigger ────────────────────────────────────────
+
+describe("handleWebhookTrigger", () => {
+  test("valid HMAC starts workflow", async () => {
+    const secret = "my-webhook-secret";
+    const workflow = makeWorkflow({
+      triggers: [{ type: "webhook", hmacSecret: secret }],
+    });
+
+    const body = '{"event":"deploy"}';
+    const hmac = crypto.createHmac("sha256", secret);
+    hmac.update(body);
+    const sig = `sha256=${hmac.digest("hex")}`;
+
+    const result = await handleWebhookTrigger(workflow.id, body, sig, sig, registry);
+
+    expect(result.runId).toBeDefined();
+    expect(typeof result.runId).toBe("string");
+
+    // Verify the run was created
+    const run = getWorkflowRun(result.runId);
+    expect(run).not.toBeNull();
+    expect(run!.workflowId).toBe(workflow.id);
+  });
+
+  test("invalid HMAC rejects with 401", async () => {
+    const workflow = makeWorkflow({
+      triggers: [{ type: "webhook", hmacSecret: "secret-123" }],
+    });
+
+    try {
+      await handleWebhookTrigger(
+        workflow.id,
+        '{"test":true}',
+        "sha256=invalid",
+        "sha256=invalid",
+        registry,
+      );
+      expect(true).toBe(false); // Should not reach here
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(401);
+    }
+  });
+
+  test("missing signature rejects with 401 when hmacSecret is set", async () => {
+    const workflow = makeWorkflow({
+      triggers: [{ type: "webhook", hmacSecret: "secret-xyz" }],
+    });
+
+    try {
+      await handleWebhookTrigger(workflow.id, '{"test":true}', undefined, undefined, registry);
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(401);
+    }
+  });
+
+  test("no hmacSecret configured accepts any request", async () => {
+    const workflow = makeWorkflow({
+      triggers: [{ type: "webhook" }],
+    });
+
+    const result = await handleWebhookTrigger(
+      workflow.id,
+      '{"data":"hello"}',
+      undefined,
+      undefined,
+      registry,
+    );
+
+    expect(result.runId).toBeDefined();
+    const run = getWorkflowRun(result.runId);
+    expect(run).not.toBeNull();
+  });
+
+  test("workflow not found returns 404", async () => {
+    try {
+      await handleWebhookTrigger(
+        "00000000-0000-0000-0000-000000000000",
+        "{}",
+        undefined,
+        undefined,
+        registry,
+      );
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(404);
+    }
+  });
+
+  test("disabled workflow returns 400", async () => {
+    const workflow = makeWorkflow({
+      triggers: [{ type: "webhook" }],
+    });
+    // Disable the workflow
+    updateWorkflow(workflow.id, { enabled: false });
+
+    try {
+      await handleWebhookTrigger(workflow.id, "{}", undefined, undefined, registry);
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(400);
+    }
+  });
+});
+
+// ─── Manual Trigger ─────────────────────────────────────────
+
+describe("manual trigger (startWorkflowExecution)", () => {
+  test("always available — workflow starts without triggers", async () => {
+    const workflow = makeWorkflow();
+
+    const runId = await startWorkflowExecution(workflow, { manual: true }, registry);
+
+    expect(runId).toBeDefined();
+    const run = getWorkflowRun(runId);
+    expect(run).not.toBeNull();
+    // Should complete (single notify node)
+    expect(run!.status).toBe("completed");
+  });
+});
+
+// ─── Cooldown ───────────────────────────────────────────────
+
+describe("cooldown", () => {
+  test("trigger within cooldown window produces skipped run", async () => {
+    const workflow = makeWorkflow({
+      cooldown: { hours: 1 },
+    });
+
+    // First trigger — should complete normally
+    const runId1 = await startWorkflowExecution(workflow, {}, registry);
+    const run1 = getWorkflowRun(runId1);
+    expect(run1!.status).toBe("completed");
+
+    // Second trigger — should be skipped (within 1-hour cooldown)
+    const runId2 = await startWorkflowExecution(workflow, {}, registry);
+    const run2 = getWorkflowRun(runId2);
+    expect(run2!.status).toBe("skipped");
+    expect(run2!.error).toBe("cooldown");
+  });
+
+  test("no cooldown configured — always runs", async () => {
+    const workflow = makeWorkflow();
+
+    const runId1 = await startWorkflowExecution(workflow, {}, registry);
+    const run1 = getWorkflowRun(runId1);
+    expect(run1!.status).toBe("completed");
+
+    const runId2 = await startWorkflowExecution(workflow, {}, registry);
+    const run2 = getWorkflowRun(runId2);
+    expect(run2!.status).toBe("completed");
+  });
+});