@griffin-app/griffin-plan-executor 0.1.13 → 0.1.15

package/dist/executor.test.js

@@ -1,18 +1,18 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { executePlanV1 } from "./executor.js";
+import { executeMonitorV1 } from "./executor.js";
 import { StubAdapter } from "./adapters/stub.js";
 import { START, END } from "./types.js";
 import { LocalEventEmitter } from "./events";
 import { SecretProviderRegistry } from "./secrets/registry.js";
 import { EnvSecretProvider } from "./secrets/providers/env.js";
-describe("executePlanV1", () => {
+describe("executeMonitorV1", () => {
     let stubClient;
     let options;
     let organizationId = "test-org";
     beforeEach(() => {
         stubClient = new StubAdapter();
         const secretRegistry = new SecretProviderRegistry();
-        secretRegistry.register(new EnvSecretProvider());
+        secretRegistry.setProvider(new EnvSecretProvider());
         options = {
             mode: "local",
             httpClient: stubClient,
@@ -22,8 +22,8 @@ describe("executePlanV1", () => {
     });
     describe("Single HttpRequest Execution", () => {
         it("should execute a simple GET request successfully", async () => {
-            const plan = {
-                id: "test-plan-1",
+            const monitor = {
+                id: "test-monitor-1",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Simple GET Test",
@@ -58,7 +58,7 @@ describe("executePlanV1", () => {
                     data: { users: [{ id: 1, name: "Alice" }] },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             expect(result.errors).toHaveLength(0);
             expect(result.results).toHaveLength(1);
@@ -70,8 +70,8 @@ describe("executePlanV1", () => {
             expect(result.results[0].duration_ms).toBeGreaterThanOrEqual(0);
         });
         it("should execute a POST request with body and headers", async () => {
-            const plan = {
-                id: "test-plan-2",
+            const monitor = {
+                id: "test-monitor-2",
                 name: "POST Test",
                 version: "1.0",
                 environment: "default",
@@ -111,7 +111,7 @@ describe("executePlanV1", () => {
                     data: { id: 2, name: "Bob", email: "bob@example.com" },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             expect(result.results[0].response).toEqual({
                 id: 2,
@@ -120,8 +120,8 @@ describe("executePlanV1", () => {
             });
         });
         it("should handle JSON string responses by parsing them", async () => {
-            const plan = {
-                id: "test-plan-3",
+            const monitor = {
+                id: "test-monitor-3",
                 name: "JSON String Response Test",
                 version: "1.0",
                 environment: "default",
@@ -156,13 +156,13 @@ describe("executePlanV1", () => {
                     data: '{"message":"hello"}',
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            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 plan = {
-                id: "test-plan-4",
+            const monitor = {
+                id: "test-monitor-4",
                 name: "BaseUrl Override Test",
                 version: "1.0",
                 environment: "default",
@@ -197,14 +197,14 @@ describe("executePlanV1", () => {
                     data: { users: [] },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
         });
     });
     describe("Multiple HTTP Methods", () => {
         it("should handle PUT requests", async () => {
-            const plan = {
-                id: "test-plan-5",
+            const monitor = {
+                id: "test-monitor-5",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "PUT Test",
@@ -240,7 +240,7 @@ describe("executePlanV1", () => {
                     data: { id: 1, name: "Updated Name" },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             expect(result.results[0].response).toEqual({
                 id: 1,
@@ -248,8 +248,8 @@ describe("executePlanV1", () => {
             });
         });
         it("should handle DELETE requests", async () => {
-            const plan = {
-                id: "test-plan-6",
+            const monitor = {
+                id: "test-monitor-6",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "DELETE Test",
@@ -284,13 +284,13 @@ describe("executePlanV1", () => {
                     data: null,
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            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 plan = {
-                id: "test-plan-7",
+            const monitor = {
+                id: "test-monitor-7",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "PATCH Test",
@@ -326,14 +326,14 @@ describe("executePlanV1", () => {
                     data: { id: 1, email: "newemail@example.com" },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
         });
     });
     describe("Sequential Execution", () => {
         it("should execute two endpoints in sequence", async () => {
-            const plan = {
-                id: "test-plan-8",
+            const monitor = {
+                id: "test-monitor-8",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Sequential Test",
@@ -389,7 +389,7 @@ describe("executePlanV1", () => {
                     data: { step: 2 },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             expect(result.results).toHaveLength(2);
             expect(result.results[0].nodeId).toBe("first");
@@ -398,8 +398,8 @@ describe("executePlanV1", () => {
             expect(result.results[1].response).toEqual({ step: 2 });
         });
         it("should execute a linear chain of multiple endpoints", async () => {
-            const plan = {
-                id: "test-plan-9",
+            const monitor = {
+                id: "test-monitor-9",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Multi-Step Linear Test",
@@ -479,7 +479,7 @@ describe("executePlanV1", () => {
                 match: /\/step4$/,
                 response: { status: 200, statusText: "OK", data: { step: 4 } },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            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 });
@@ -490,8 +490,8 @@ describe("executePlanV1", () => {
     });
     describe("Wait Node", () => {
         it("should execute a wait node successfully", async () => {
-            const plan = {
-                id: "test-plan-10",
+            const monitor = {
+                id: "test-monitor-10",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Wait Test",
@@ -516,7 +516,7 @@ describe("executePlanV1", () => {
                 ],
             };
             const startTime = Date.now();
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             const endTime = Date.now();
             expect(result.success).toBe(true);
             expect(result.results).toHaveLength(1);
@@ -526,8 +526,8 @@ describe("executePlanV1", () => {
             expect(endTime - startTime).toBeGreaterThanOrEqual(100);
         });
         it("should execute endpoints with waits in between", async () => {
-            const plan = {
-                id: "test-plan-11",
+            const monitor = {
+                id: "test-monitor-11",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "HttpRequest-Wait-HttpRequest Test",
@@ -584,7 +584,7 @@ describe("executePlanV1", () => {
                 match: /\/second$/,
                 response: { status: 200, statusText: "OK", data: { step: 2 } },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             expect(result.results).toHaveLength(3);
             expect(result.results[1].nodeId).toBe("wait");
@@ -593,8 +593,8 @@ describe("executePlanV1", () => {
     });
     describe("Assertion Node", () => {
         it("should execute an assertion node (currently no-op)", async () => {
-            const plan = {
-                id: "test-plan-12",
+            const monitor = {
+                id: "test-monitor-12",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Assertion Test",
@@ -638,7 +638,7 @@ describe("executePlanV1", () => {
                     data: { value: 42 },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             expect(result.results).toHaveLength(2);
             expect(result.results[1].nodeId).toBe("assert");
@@ -647,8 +647,8 @@ describe("executePlanV1", () => {
     });
     describe("Error Handling", () => {
         it("should handle failed HTTP requests gracefully", async () => {
-            const plan = {
-                id: "test-plan-13",
+            const monitor = {
+                id: "test-monitor-13",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Failed Request Test",
@@ -676,7 +676,7 @@ describe("executePlanV1", () => {
                 ],
             };
             // Don't add a stub - this will cause the request to fail
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(false);
             expect(result.errors).toHaveLength(1);
             expect(result.errors[0]).toContain("failing-request");
@@ -685,8 +685,8 @@ describe("executePlanV1", () => {
             expect(result.results[0].error).toBeDefined();
         });
         it("should handle disconnected nodes gracefully", async () => {
-            const plan = {
-                id: "test-plan-14",
+            const monitor = {
+                id: "test-monitor-14",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Disconnected Nodes Test",
@@ -724,14 +724,14 @@ describe("executePlanV1", () => {
                     data: {},
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            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 plan = {
-                id: "test-plan-15",
+            const monitor = {
+                id: "test-monitor-15",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Continue After Failure Test",
@@ -775,7 +775,7 @@ describe("executePlanV1", () => {
                 response: { status: 200, statusText: "OK", data: { ok: true } },
             });
             // No stub for /fail - it will fail
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(false);
             expect(result.results).toHaveLength(2);
             expect(result.results[0].success).toBe(true);
@@ -784,8 +784,8 @@ describe("executePlanV1", () => {
     });
     describe("Response Storage", () => {
         it("should store successful responses for downstream nodes", async () => {
-            const plan = {
-                id: "test-plan-16",
+            const monitor = {
+                id: "test-monitor-16",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Response Storage Test",
@@ -841,14 +841,14 @@ describe("executePlanV1", () => {
                     data: { name: "John Doe", age: 30 },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            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 plan = {
-                id: "test-plan-17",
+            const monitor = {
+                id: "test-monitor-17",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Failed Response Not Stored Test",
@@ -876,15 +876,15 @@ describe("executePlanV1", () => {
                 ],
             };
             // No stub configured - will fail
-            const result = await executePlanV1(plan, organizationId, options);
+            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 plan = {
-                id: "test-plan-18",
+            const monitor = {
+                id: "test-monitor-18",
                 name: "Timing Test",
                 version: "1.0",
                 environment: "default",
@@ -919,13 +919,13 @@ describe("executePlanV1", () => {
                     data: { test: true },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.totalDuration_ms).toBeGreaterThanOrEqual(0);
             expect(result.totalDuration_ms).toBeGreaterThanOrEqual(result.results[0].duration_ms);
         });
         it("should track individual node durations", async () => {
-            const plan = {
-                id: "test-plan-19",
+            const monitor = {
+                id: "test-monitor-19",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Node Duration Test",
@@ -982,7 +982,7 @@ describe("executePlanV1", () => {
                 match: /\/2$/,
                 response: { status: 200, statusText: "OK", data: {} },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             result.results.forEach((nodeResult) => {
                 expect(nodeResult.duration_ms).toBeGreaterThanOrEqual(0);
@@ -991,12 +991,12 @@ describe("executePlanV1", () => {
         });
     });
     describe("Edge Cases", () => {
-        it("should handle empty plan (no nodes)", async () => {
-            const plan = {
-                id: "test-plan-20",
+        it("should handle empty monitor (no nodes)", async () => {
+            const monitor = {
+                id: "test-monitor-20",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
-                name: "Empty Plan Test",
+                name: "Empty Monitor Test",
                 version: "1.0",
                 environment: "default",
                 nodes: [],
@@ -1007,15 +1007,15 @@ describe("executePlanV1", () => {
                     },
                 ],
             };
-            const result = await executePlanV1(plan, organizationId, options);
-            // Empty plan with just START->END should succeed with no results
+            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 plan = {
-                id: "test-plan-21",
+            const monitor = {
+                id: "test-monitor-21",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Single Node Test",
@@ -1050,13 +1050,13 @@ describe("executePlanV1", () => {
                     data: { alone: true },
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            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 plan = {
-                id: "test-plan-22",
+            const monitor = {
+                id: "test-monitor-22",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
                 name: "Complex Data Test",
@@ -1103,7 +1103,7 @@ describe("executePlanV1", () => {
                     data: complexData,
                 },
             });
-            const result = await executePlanV1(plan, organizationId, options);
+            const result = await executeMonitorV1(monitor, organizationId, options);
             expect(result.success).toBe(true);
             expect(result.results[0].response).toEqual(complexData);
         });
@@ -1116,12 +1116,12 @@ describe("executePlanV1", () => {
             events = [];
             emitter.subscribe((event) => events.push(event));
         });
-        it("should emit PLAN_START and PLAN_END events", async () => {
-            const plan = {
+        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 Plan",
+                name: "Event Test Monitor",
                 version: "1.0",
                 environment: "default",
                 nodes: [
@@ -1149,33 +1149,33 @@ describe("executePlanV1", () => {
                 match: "https://api.example.com/test",
                 response: { status: 200, statusText: "OK", data: { ok: true } },
             });
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });
-            const planStartEvents = events.filter((e) => e.type === "PLAN_START");
-            const planEndEvents = events.filter((e) => e.type === "PLAN_END");
+            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: "PLAN_START",
-                planId: "event-test-1",
-                planName: "Event Test Plan",
-                planVersion: "1.0",
+                type: "MONITOR_START",
+                monitorId: "event-test-1",
+                monitorName: "Event Test Monitor",
+                monitorVersion: "1.0",
                 nodeCount: 1,
                 edgeCount: 2,
             });
             const planEnd = planEndEvents[0];
             expect(planEnd).toMatchObject({
-                type: "PLAN_END",
+                type: "MONITOR_END",
                 success: true,
                 nodeResultCount: 1,
                 errorCount: 0,
             });
         });
         it("should emit NODE_START and NODE_END events for each node", async () => {
-            const plan = {
+            const monitor = {
                 id: "event-test-2",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
@@ -1233,7 +1233,7 @@ describe("executePlanV1", () => {
                 match: /\/second$/,
                 response: { status: 200, statusText: "OK", data: { step: 2 } },
             });
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });
@@ -1256,7 +1256,7 @@ describe("executePlanV1", () => {
             });
         });
         it("should emit HTTP_REQUEST and HTTP_RESPONSE events for endpoint nodes", async () => {
-            const plan = {
+            const monitor = {
                 id: "event-test-3",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
@@ -1290,7 +1290,7 @@ describe("executePlanV1", () => {
                 match: "https://api.example.com/create",
                 response: { status: 201, statusText: "Created", data: { id: 123 } },
             });
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });
@@ -1322,7 +1322,7 @@ describe("executePlanV1", () => {
             expect(httpResponse.duration_ms).toBeGreaterThanOrEqual(0);
         });
         it("should emit WAIT_START event for wait nodes", async () => {
-            const plan = {
+            const monitor = {
                 id: "event-test-4",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
@@ -1347,7 +1347,7 @@ describe("executePlanV1", () => {
                     },
                 ],
             };
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });
@@ -1360,7 +1360,7 @@ describe("executePlanV1", () => {
             });
         });
         it("should emit ERROR event on HTTP request failure", async () => {
-            const plan = {
+            const monitor = {
                 id: "event-test-5",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
@@ -1389,7 +1389,7 @@ describe("executePlanV1", () => {
                 ],
             };
             // No stub - request will fail
-            const result = await executePlanV1(plan, organizationId, {
+            const result = await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });
@@ -1398,7 +1398,7 @@ describe("executePlanV1", () => {
             expect(result.errors.length).toBeGreaterThan(0);
         });
         it("should maintain monotonic sequence numbers", async () => {
-            const plan = {
+            const monitor = {
                 id: "event-test-6",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
@@ -1430,7 +1430,7 @@ describe("executePlanV1", () => {
                 match: "https://api.example.com/test",
                 response: { status: 200, statusText: "OK", data: {} },
             });
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });
@@ -1447,7 +1447,7 @@ describe("executePlanV1", () => {
         });
         it("should use provided executionId if given", async () => {
             const customExecutionId = "custom-exec-id-123";
-            const plan = {
+            const monitor = {
                 id: "event-test-7",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
@@ -1479,7 +1479,7 @@ describe("executePlanV1", () => {
                 match: "https://api.example.com/test",
                 response: { status: 200, statusText: "OK", data: {} },
             });
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
                 executionId: customExecutionId,
@@ -1490,7 +1490,7 @@ describe("executePlanV1", () => {
             });
         });
         it("should emit events in correct order", async () => {
-            const plan = {
+            const monitor = {
                 id: "event-test-8",
                 project: "test-project",
                 frequency: { every: 1, unit: "MINUTE" },
@@ -1522,21 +1522,21 @@ describe("executePlanV1", () => {
                 match: "https://api.example.com/test",
                 response: { status: 200, statusText: "OK", data: {} },
             });
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });
             const eventTypes = events.map((e) => e.type);
-            // Expected order: PLAN_START, NODE_START, HTTP_REQUEST, HTTP_RESPONSE, NODE_END, PLAN_END
-            expect(eventTypes[0]).toBe("PLAN_START");
+            // 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("PLAN_END");
+            expect(eventTypes[5]).toBe("MONITOR_END");
         });
         it("should handle failed HTTP requests correctly", async () => {
-            const plan = {
+            const monitor = {
                 id: "event-test-9",
                 name: "Failed Request Event Test",
                 version: "1.0",
@@ -1565,7 +1565,7 @@ describe("executePlanV1", () => {
                 ],
             };
             // No stub - request will fail
-            await executePlanV1(plan, organizationId, {
+            await executeMonitorV1(monitor, organizationId, {
                 ...options,
                 eventEmitter: emitter,
             });