@griffin-app/griffin-executor 0.1.0

package/dist/executor.test.js

@@ -0,0 +1,1584 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { executeMonitorV1 } from "./executor.js";
+import { StubAdapter } from "./adapters/stub.js";
+import { START, END } from "./types.js";
+import { LocalEventEmitter } from "./events";
+import { EnvSecretProvider } from "./secrets/providers/env.js";
+describe("executeMonitorV1", () => {
+    let stubClient;
+    let options;
+    let organizationId = "test-org";
+    beforeEach(() => {
+        stubClient = new StubAdapter();
+        options = {
+            mode: "local",
+            httpClient: stubClient,
+            timeout: 5000,
+            secretProvider: new EnvSecretProvider(),
+        };
+    });
+    describe("Single HttpRequest Execution", () => {
+        it("should execute a simple GET request successfully", async () => {
+            const monitor = {
+                id: "test-monitor-1",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Simple GET Test",
+                environment: "default",
+                version: "1.0",
+                nodes: [
+                    {
+                        id: "get-users",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/users",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "get-users",
+                    },
+                    {
+                        from: "get-users",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/users",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { users: [{ id: 1, name: "Alice" }] },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.errors).toHaveLength(0);
+            expect(result.results).toHaveLength(1);
+            expect(result.results[0].nodeId).toBe("get-users");
+            expect(result.results[0].success).toBe(true);
+            expect(result.results[0].response).toEqual({
+                users: [{ id: 1, name: "Alice" }],
+            });
+            expect(result.results[0].duration_ms).toBeGreaterThanOrEqual(0);
+        });
+        it("should execute a POST request with body and headers", async () => {
+            const monitor = {
+                id: "test-monitor-2",
+                name: "POST Test",
+                version: "1.0",
+                environment: "default",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                nodes: [
+                    {
+                        id: "create-user",
+                        type: "HTTP_REQUEST",
+                        method: "POST",
+                        base: "https://api.example.com",
+                        path: "/users",
+                        headers: {
+                            "Content-Type": { $literal: "application/json" },
+                            Authorization: { $literal: "Bearer token123" },
+                        },
+                        body: { name: "Bob", email: "bob@example.com" },
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "create-user",
+                    },
+                    {
+                        from: "create-user",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: (req) => req.url === "https://api.example.com/users" && req.method === "POST",
+                response: {
+                    status: 201,
+                    statusText: "Created",
+                    data: { id: 2, name: "Bob", email: "bob@example.com" },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results[0].response).toEqual({
+                id: 2,
+                name: "Bob",
+                email: "bob@example.com",
+            });
+        });
+        it("should handle JSON string responses by parsing them", async () => {
+            const monitor = {
+                id: "test-monitor-3",
+                name: "JSON String Response Test",
+                version: "1.0",
+                environment: "default",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                nodes: [
+                    {
+                        id: "get-data",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/data",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "get-data",
+                    },
+                    {
+                        from: "get-data",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/data",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: '{"message":"hello"}',
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results[0].response).toEqual({ message: "hello" });
+        });
+        it("should override endpoint_host with baseUrl option", async () => {
+            const monitor = {
+                id: "test-monitor-4",
+                name: "BaseUrl Override Test",
+                version: "1.0",
+                environment: "default",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                nodes: [
+                    {
+                        id: "get-users",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        base: "https://api.example.com",
+                        path: "/users",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "get-users",
+                    },
+                    {
+                        from: "get-users",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/users",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { users: [] },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe("Multiple HTTP Methods", () => {
+        it("should handle PUT requests", async () => {
+            const monitor = {
+                id: "test-monitor-5",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "PUT Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "update-user",
+                        type: "HTTP_REQUEST",
+                        method: "PUT",
+                        path: "/users/1",
+                        base: "https://api.example.com",
+                        body: { name: "Updated Name" },
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "update-user",
+                    },
+                    {
+                        from: "update-user",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/users/1",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { id: 1, name: "Updated Name" },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results[0].response).toEqual({
+                id: 1,
+                name: "Updated Name",
+            });
+        });
+        it("should handle DELETE requests", async () => {
+            const monitor = {
+                id: "test-monitor-6",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "DELETE Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "delete-user",
+                        type: "HTTP_REQUEST",
+                        method: "DELETE",
+                        path: "/users/1",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "delete-user",
+                    },
+                    {
+                        from: "delete-user",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/users/1",
+                response: {
+                    status: 204,
+                    statusText: "No Content",
+                    data: null,
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results[0].response).toBeNull();
+        });
+        it("should handle PATCH requests", async () => {
+            const monitor = {
+                id: "test-monitor-7",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "PATCH Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "patch-user",
+                        type: "HTTP_REQUEST",
+                        method: "PATCH",
+                        path: "/users/1",
+                        base: "https://api.example.com",
+                        body: { email: "newemail@example.com" },
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "patch-user",
+                    },
+                    {
+                        from: "patch-user",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/users/1",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { id: 1, email: "newemail@example.com" },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe("Sequential Execution", () => {
+        it("should execute two endpoints in sequence", async () => {
+            const monitor = {
+                id: "test-monitor-8",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Sequential Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "first",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/first",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "second",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/second",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "first",
+                    },
+                    {
+                        from: "first",
+                        to: "second",
+                    },
+                    {
+                        from: "second",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient
+                .addStub({
+                match: "https://api.example.com/first",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { step: 1 },
+                },
+            })
+                .addStub({
+                match: "https://api.example.com/second",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { step: 2 },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(2);
+            expect(result.results[0].nodeId).toBe("first");
+            expect(result.results[1].nodeId).toBe("second");
+            expect(result.results[0].response).toEqual({ step: 1 });
+            expect(result.results[1].response).toEqual({ step: 2 });
+        });
+        it("should execute a linear chain of multiple endpoints", async () => {
+            const monitor = {
+                id: "test-monitor-9",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Multi-Step Linear Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "step1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/step1",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "step2",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/step2",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "step3",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/step3",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "step4",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/step4",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "step1",
+                    },
+                    {
+                        from: "step1",
+                        to: "step2",
+                    },
+                    {
+                        from: "step2",
+                        to: "step3",
+                    },
+                    {
+                        from: "step3",
+                        to: "step4",
+                    },
+                    {
+                        from: "step4",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient
+                .addStub({
+                match: /\/step1$/,
+                response: { status: 200, statusText: "OK", data: { step: 1 } },
+            })
+                .addStub({
+                match: /\/step2$/,
+                response: { status: 200, statusText: "OK", data: { step: 2 } },
+            })
+                .addStub({
+                match: /\/step3$/,
+                response: { status: 200, statusText: "OK", data: { step: 3 } },
+            })
+                .addStub({
+                match: /\/step4$/,
+                response: { status: 200, statusText: "OK", data: { step: 4 } },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(4);
+            expect(result.results[0].response).toEqual({ step: 1 });
+            expect(result.results[1].response).toEqual({ step: 2 });
+            expect(result.results[2].response).toEqual({ step: 3 });
+            expect(result.results[3].response).toEqual({ step: 4 });
+        });
+    });
+    describe("Wait Node", () => {
+        it.skip("should execute a wait node successfully", async () => {
+            const monitor = {
+                id: "test-monitor-10",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Wait Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "wait-node",
+                        type: "WAIT",
+                        duration_ms: 100,
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "wait-node",
+                    },
+                    {
+                        from: "wait-node",
+                        to: END,
+                    },
+                ],
+            };
+            const startTime = Date.now();
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            const endTime = Date.now();
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(1);
+            expect(result.results[0].nodeId).toBe("wait-node");
+            expect(result.results[0].success).toBe(true);
+            expect(result.results[0].duration_ms).toBeGreaterThanOrEqual(100);
+            expect(endTime - startTime).toBeGreaterThanOrEqual(100);
+        });
+        it("should execute endpoints with waits in between", async () => {
+            const monitor = {
+                id: "test-monitor-11",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "HttpRequest-Wait-HttpRequest Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "first-request",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/first",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "wait",
+                        type: "WAIT",
+                        duration_ms: 50,
+                    },
+                    {
+                        id: "second-request",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/second",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "first-request",
+                    },
+                    {
+                        from: "first-request",
+                        to: "wait",
+                    },
+                    {
+                        from: "wait",
+                        to: "second-request",
+                    },
+                    {
+                        from: "second-request",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient
+                .addStub({
+                match: /\/first$/,
+                response: { status: 200, statusText: "OK", data: { step: 1 } },
+            })
+                .addStub({
+                match: /\/second$/,
+                response: { status: 200, statusText: "OK", data: { step: 2 } },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(3);
+            expect(result.results[1].nodeId).toBe("wait");
+            expect(result.results[1].duration_ms).toBeGreaterThanOrEqual(50);
+        });
+    });
+    describe("Assertion Node", () => {
+        it("should execute an assertion node (currently no-op)", async () => {
+            const monitor = {
+                id: "test-monitor-12",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Assertion Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "get-data",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/data",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "assert",
+                        type: "ASSERTION",
+                        assertions: [],
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "get-data",
+                    },
+                    {
+                        from: "get-data",
+                        to: "assert",
+                    },
+                    {
+                        from: "assert",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/data",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { value: 42 },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(2);
+            expect(result.results[1].nodeId).toBe("assert");
+            expect(result.results[1].success).toBe(true);
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle failed HTTP requests gracefully", async () => {
+            const monitor = {
+                id: "test-monitor-13",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Failed Request Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "failing-request",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/fail",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "failing-request",
+                    },
+                    {
+                        from: "failing-request",
+                        to: END,
+                    },
+                ],
+            };
+            // Don't add a stub - this will cause the request to fail
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(false);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("failing-request");
+            expect(result.errors[0]).toContain("No stub matched request");
+            expect(result.results[0].success).toBe(false);
+            expect(result.results[0].error).toBeDefined();
+        });
+        it("should handle disconnected nodes gracefully", async () => {
+            const monitor = {
+                id: "test-monitor-14",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Disconnected Nodes Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "node1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/path",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "node2",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/path",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    { from: START, to: END }, // Direct path that skips nodes
+                    { from: "node1", to: "node2" }, // Circular - disconnected from main flow
+                    { from: "node2", to: "node1" },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/path",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: {},
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            // Graph can execute but disconnected nodes are not executed
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(0); // No nodes executed
+        });
+        it("should continue execution after a failed node", async () => {
+            const monitor = {
+                id: "test-monitor-15",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Continue After Failure Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "success-node",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/success",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "fail-node",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/fail",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "success-node",
+                    },
+                    {
+                        from: "success-node",
+                        to: "fail-node",
+                    },
+                    {
+                        from: "fail-node",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: /\/success$/,
+                response: { status: 200, statusText: "OK", data: { ok: true } },
+            });
+            // No stub for /fail - it will fail
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(false);
+            expect(result.results).toHaveLength(2);
+            expect(result.results[0].success).toBe(true);
+            expect(result.results[1].success).toBe(false);
+        });
+    });
+    describe("Response Storage", () => {
+        it("should store successful responses for downstream nodes", async () => {
+            const monitor = {
+                id: "test-monitor-16",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Response Storage Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "get-user-id",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/user",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "get-profile",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/profile",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "get-user-id",
+                    },
+                    {
+                        from: "get-user-id",
+                        to: "get-profile",
+                    },
+                    {
+                        from: "get-profile",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient
+                .addStub({
+                match: /\/user$/,
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { userId: 123 },
+                },
+            })
+                .addStub({
+                match: /\/profile$/,
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { name: "John Doe", age: 30 },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results[0].response).toEqual({ userId: 123 });
+            expect(result.results[1].response).toEqual({ name: "John Doe", age: 30 });
+        });
+        it("should not store failed responses", async () => {
+            const monitor = {
+                id: "test-monitor-17",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Failed Response Not Stored Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "failing-endpoint",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/fail",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "failing-endpoint",
+                    },
+                    {
+                        from: "failing-endpoint",
+                        to: END,
+                    },
+                ],
+            };
+            // No stub configured - will fail
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(false);
+            expect(result.results[0].response).toBeUndefined();
+        });
+    });
+    describe("Timing and Performance", () => {
+        it("should track total execution duration", async () => {
+            const monitor = {
+                id: "test-monitor-18",
+                name: "Timing Test",
+                version: "1.0",
+                environment: "default",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                nodes: [
+                    {
+                        id: "endpoint",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/data",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "endpoint",
+                    },
+                    {
+                        from: "endpoint",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/data",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { test: true },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.totalDuration_ms).toBeGreaterThanOrEqual(0);
+            expect(result.totalDuration_ms).toBeGreaterThanOrEqual(result.results[0].duration_ms);
+        });
+        it.skip("should track individual node durations", async () => {
+            const monitor = {
+                id: "test-monitor-19",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Node Duration Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "node1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/1",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "wait",
+                        type: "WAIT",
+                        duration_ms: 50,
+                    },
+                    {
+                        id: "node2",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/2",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "node1",
+                    },
+                    {
+                        from: "node1",
+                        to: "wait",
+                    },
+                    {
+                        from: "wait",
+                        to: "node2",
+                    },
+                    {
+                        from: "node2",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient
+                .addStub({
+                match: /\/1$/,
+                response: { status: 200, statusText: "OK", data: {} },
+            })
+                .addStub({
+                match: /\/2$/,
+                response: { status: 200, statusText: "OK", data: {} },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            result.results.forEach((nodeResult) => {
+                expect(nodeResult.duration_ms).toBeGreaterThanOrEqual(0);
+            });
+            expect(result.results[1].duration_ms).toBeGreaterThanOrEqual(50);
+        });
+    });
+    describe("Edge Cases", () => {
+        it("should handle empty monitor (no nodes)", async () => {
+            const monitor = {
+                id: "test-monitor-20",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Empty Monitor Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [],
+                edges: [
+                    {
+                        from: START,
+                        to: END,
+                    },
+                ],
+            };
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            // Empty monitor with just START->END should succeed with no results
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it("should handle single node with no edges", async () => {
+            const monitor = {
+                id: "test-monitor-21",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Single Node Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "only-node",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/single",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "only-node",
+                    },
+                    {
+                        from: "only-node",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/single",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: { alone: true },
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results).toHaveLength(1);
+        });
+        it("should handle complex response data types", async () => {
+            const monitor = {
+                id: "test-monitor-22",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Complex Data Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "complex",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/complex",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "complex",
+                    },
+                    {
+                        from: "complex",
+                        to: END,
+                    },
+                ],
+            };
+            const complexData = {
+                string: "test",
+                number: 42,
+                boolean: true,
+                null: null,
+                array: [1, 2, 3],
+                nested: {
+                    deep: {
+                        value: "nested",
+                    },
+                },
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/complex",
+                response: {
+                    status: 200,
+                    statusText: "OK",
+                    data: complexData,
+                },
+            });
+            const result = await executeMonitorV1(monitor, organizationId, options);
+            expect(result.success).toBe(true);
+            expect(result.results[0].response).toEqual(complexData);
+        });
+    });
+    describe("Event Emission", () => {
+        let emitter;
+        let events;
+        beforeEach(() => {
+            emitter = new LocalEventEmitter();
+            events = [];
+            emitter.subscribe((event) => events.push(event));
+        });
+        it("should emit MONITOR_START and MONITOR_END events", async () => {
+            const monitor = {
+                id: "event-test-1",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Event Test Monitor",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "node-1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/test",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "node-1",
+                    },
+                    {
+                        from: "node-1",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/test",
+                response: { status: 200, statusText: "OK", data: { ok: true } },
+            });
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            const planStartEvents = events.filter((e) => e.type === "MONITOR_START");
+            const planEndEvents = events.filter((e) => e.type === "MONITOR_END");
+            expect(planStartEvents).toHaveLength(1);
+            expect(planEndEvents).toHaveLength(1);
+            const planStart = planStartEvents[0];
+            expect(planStart).toMatchObject({
+                type: "MONITOR_START",
+                monitor_id: "event-test-1",
+                monitor_name: "Event Test Monitor",
+                monitor_version: "1.0",
+                node_count: 1,
+                edge_count: 2,
+            });
+            const planEnd = planEndEvents[0];
+            expect(planEnd).toMatchObject({
+                type: "MONITOR_END",
+                success: true,
+                node_result_count: 1,
+                error_count: 0,
+            });
+        });
+        it("should emit NODE_START and NODE_END events for each node", async () => {
+            const monitor = {
+                id: "event-test-2",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Multi-Node Event Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "endpoint-1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/first",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                    {
+                        id: "wait-1",
+                        type: "WAIT",
+                        duration_ms: 10,
+                    },
+                    {
+                        id: "endpoint-2",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/second",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "endpoint-1",
+                    },
+                    {
+                        from: "endpoint-1",
+                        to: "wait-1",
+                    },
+                    {
+                        from: "wait-1",
+                        to: "endpoint-2",
+                    },
+                    {
+                        from: "endpoint-2",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient
+                .addStub({
+                match: /\/first$/,
+                response: { status: 200, statusText: "OK", data: { step: 1 } },
+            })
+                .addStub({
+                match: /\/second$/,
+                response: { status: 200, statusText: "OK", data: { step: 2 } },
+            });
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            const nodeStartEvents = events.filter((e) => e.type === "NODE_START");
+            const nodeEndEvents = events.filter((e) => e.type === "NODE_END");
+            expect(nodeStartEvents).toHaveLength(3);
+            expect(nodeEndEvents).toHaveLength(3);
+            // Check node types
+            expect(nodeStartEvents[0]).toMatchObject({
+                node_id: "endpoint-1",
+                node_type: "HTTP_REQUEST",
+            });
+            expect(nodeStartEvents[1]).toMatchObject({
+                node_id: "wait-1",
+                node_type: "WAIT",
+            });
+            expect(nodeStartEvents[2]).toMatchObject({
+                node_id: "endpoint-2",
+                node_type: "HTTP_REQUEST",
+            });
+        });
+        it("should emit HTTP_REQUEST and HTTP_RESPONSE events for endpoint nodes", async () => {
+            const monitor = {
+                id: "event-test-3",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "HTTP Event Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "http-node",
+                        type: "HTTP_REQUEST",
+                        method: "POST",
+                        path: "/create",
+                        base: "https://api.example.com",
+                        headers: { "Content-Type": { $literal: "application/json" } },
+                        body: { name: "test" },
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "http-node",
+                    },
+                    {
+                        from: "http-node",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/create",
+                response: { status: 201, statusText: "Created", data: { id: 123 } },
+            });
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            const httpRequestEvents = events.filter((e) => e.type === "HTTP_REQUEST");
+            const httpResponseEvents = events.filter((e) => e.type === "HTTP_RESPONSE");
+            expect(httpRequestEvents).toHaveLength(1);
+            expect(httpResponseEvents).toHaveLength(1);
+            const httpRequest = httpRequestEvents[0];
+            expect(httpRequest).toMatchObject({
+                type: "HTTP_REQUEST",
+                node_id: "http-node",
+                attempt: 1,
+                method: "POST",
+                url: "https://api.example.com/create",
+                has_body: true,
+            });
+            expect(httpRequest.headers).toEqual({
+                "Content-Type": "application/json",
+            });
+            const httpResponse = httpResponseEvents[0];
+            expect(httpResponse).toMatchObject({
+                type: "HTTP_RESPONSE",
+                node_id: "http-node",
+                attempt: 1,
+                status: 201,
+                status_text: "Created",
+                has_body: true,
+            });
+            expect(httpResponse.duration_ms).toBeGreaterThanOrEqual(0);
+        });
+        it("should emit WAIT_START event for wait nodes", async () => {
+            const monitor = {
+                id: "event-test-4",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Wait Event Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "wait-node",
+                        type: "WAIT",
+                        duration_ms: 50,
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "wait-node",
+                    },
+                    {
+                        from: "wait-node",
+                        to: END,
+                    },
+                ],
+            };
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            const waitStartEvents = events.filter((e) => e.type === "WAIT_START");
+            expect(waitStartEvents).toHaveLength(1);
+            expect(waitStartEvents[0]).toMatchObject({
+                type: "WAIT_START",
+                node_id: "wait-node",
+                duration_ms: 50,
+            });
+        });
+        it("should emit ERROR event on HTTP request failure", async () => {
+            const monitor = {
+                id: "event-test-5",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Error Event Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "failing-node",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/fail",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "failing-node",
+                    },
+                    {
+                        from: "failing-node",
+                        to: END,
+                    },
+                ],
+            };
+            // No stub - request will fail
+            const result = await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            result.errors;
+            // Should emit error for the failed HTTP request
+            expect(result.errors.length).toBeGreaterThan(0);
+        });
+        it("should maintain monotonic sequence numbers", async () => {
+            const monitor = {
+                id: "event-test-6",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Sequence Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "node-1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/test",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "node-1",
+                    },
+                    {
+                        from: "node-1",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/test",
+                response: { status: 200, statusText: "OK", data: {} },
+            });
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            // Check that all events have the same executionId
+            const executionIds = [...new Set(events.map((e) => e.execution_id))];
+            expect(executionIds).toHaveLength(1);
+            // Check that sequence numbers are monotonically increasing
+            const seqs = events.map((e) => e.seq);
+            for (let i = 0; i < seqs.length - 1; i++) {
+                expect(seqs[i + 1]).toBe(seqs[i] + 1);
+            }
+            // First event should be seq 0
+            expect(seqs[0]).toBe(0);
+        });
+        it("should use provided executionId if given", async () => {
+            const customExecutionId = "custom-exec-id-123";
+            const monitor = {
+                id: "event-test-7",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Custom Execution ID Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "node-1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/test",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "node-1",
+                    },
+                    {
+                        from: "node-1",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/test",
+                response: { status: 200, statusText: "OK", data: {} },
+            });
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+                executionId: customExecutionId,
+            });
+            // All events should have the custom executionId
+            events.forEach((event) => {
+                expect(event.execution_id).toBe(customExecutionId);
+            });
+        });
+        it("should emit events in correct order", async () => {
+            const monitor = {
+                id: "event-test-8",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                name: "Event Order Test",
+                version: "1.0",
+                environment: "default",
+                nodes: [
+                    {
+                        id: "node-1",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/test",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "node-1",
+                    },
+                    {
+                        from: "node-1",
+                        to: END,
+                    },
+                ],
+            };
+            stubClient.addStub({
+                match: "https://api.example.com/test",
+                response: { status: 200, statusText: "OK", data: {} },
+            });
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            const eventTypes = events.map((e) => e.type);
+            // Expected order: MONITOR_START, NODE_START, HTTP_REQUEST, HTTP_RESPONSE, NODE_END, MONITOR_END
+            expect(eventTypes[0]).toBe("MONITOR_START");
+            expect(eventTypes[1]).toBe("NODE_START");
+            expect(eventTypes[2]).toBe("HTTP_REQUEST");
+            expect(eventTypes[3]).toBe("HTTP_RESPONSE");
+            expect(eventTypes[4]).toBe("NODE_END");
+            expect(eventTypes[5]).toBe("MONITOR_END");
+        });
+        it("should handle failed HTTP requests correctly", async () => {
+            const monitor = {
+                id: "event-test-9",
+                name: "Failed Request Event Test",
+                version: "1.0",
+                environment: "default",
+                project: "test-project",
+                frequency: { every: 1, unit: "MINUTE" },
+                nodes: [
+                    {
+                        id: "failing-node",
+                        type: "HTTP_REQUEST",
+                        method: "GET",
+                        path: "/fail",
+                        base: "https://api.example.com",
+                        response_format: "JSON",
+                    },
+                ],
+                edges: [
+                    {
+                        from: START,
+                        to: "failing-node",
+                    },
+                    {
+                        from: "failing-node",
+                        to: END,
+                    },
+                ],
+            };
+            // No stub - request will fail
+            await executeMonitorV1(monitor, organizationId, {
+                ...options,
+                eventEmitter: emitter,
+            });
+            const httpResponseEvents = events.filter((e) => e.type === "HTTP_RESPONSE");
+            const nodeEndEvents = events.filter((e) => e.type === "NODE_END");
+            expect(httpResponseEvents).toHaveLength(1);
+            expect(httpResponseEvents[0]).toMatchObject({
+                status: 0,
+                status_text: "Error",
+                has_body: false,
+            });
+            expect(nodeEndEvents[0]).toMatchObject({
+                success: false,
+            });
+            expect(nodeEndEvents[0].error).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=executor.test.js.map