@powerhousedao/switchboard 6.2.3-dev.9 → 6.2.3

package/test/workflow/resolvers.test.ts

@@ -0,0 +1,296 @@
+// What the workflow subgraph does with the caller behind a request: every
+// workflow-scoped field hands it to the runtime, and secret writes are admins'.
+import type {
+  Context,
+  IAuthorizationService,
+} from "@powerhousedao/reactor-api";
+import {
+  WORKFLOW_SYNCING_MESSAGE,
+  WorkflowSyncingError,
+  type WorkflowRuntimeService,
+} from "@powerhousedao/reactor-workflow";
+import { parse, type FieldNode, type OperationDefinitionNode } from "graphql";
+import { describe, expect, it, vi } from "vitest";
+import { getResolvers } from "../../src/workflow/resolvers.js";
+
+const CTX = {
+  headers: {},
+  db: {},
+  user: { address: "0xadmin" },
+} as unknown as Context;
+
+type Resolver = (
+  parent: unknown,
+  args: unknown,
+  ctx: Context,
+  info?: unknown,
+) => Promise<unknown>;
+
+// The resolve info for the first runtime field of a real query document.
+function runsInfo(query: string) {
+  const operation = parse(query).definitions[0] as OperationDefinitionNode;
+  const root = operation.selectionSet.selections[0] as FieldNode;
+  return { fieldNodes: [root.selectionSet!.selections[0] as FieldNode] };
+}
+
+const emptyPage = (): Promise<unknown> =>
+  Promise.resolve({ records: [], hasNextPage: false, cursor: null });
+
+function fakeRuntime() {
+  return {
+    webhookEndpoint: vi.fn(() => Promise.resolve(null)),
+    triggerStates: vi.fn(() => Promise.resolve([])),
+    runs: vi.fn(() => Promise.resolve([])),
+    runsPage: vi.fn(emptyPage),
+    run: vi.fn(() => Promise.resolve(null)),
+    fire: vi.fn(() => Promise.resolve({})),
+    rerun: vi.fn(() => Promise.resolve({})),
+    testStep: vi.fn(() => Promise.resolve({})),
+    stepOutputTree: vi.fn(() => Promise.resolve({})),
+    blockResolutions: vi.fn(() => Promise.resolve([])),
+    testTrigger: vi.fn(() => Promise.resolve(null)),
+    cancelTriggerTestFor: vi.fn(() => Promise.resolve(true)),
+    secrets: vi.fn(() =>
+      Promise.resolve({
+        create: vi.fn(() => Promise.resolve({ ref: "secret://v1:00" })),
+        rotate: vi.fn(() => Promise.resolve({ ref: "secret://v1:00" })),
+        delete: vi.fn(() => Promise.resolve()),
+      }),
+    ),
+  };
+}
+
+function build(isAdmin: boolean) {
+  const runtime = fakeRuntime();
+  const authorizationService = {
+    isSupremeAdmin: vi.fn(() => isAdmin),
+  } as unknown as IAuthorizationService;
+  const resolvers = getResolvers(
+    runtime as unknown as WorkflowRuntimeService,
+    authorizationService,
+  ) as Record<string, Record<string, Resolver>>;
+  return {
+    runtime,
+    queries: resolvers.WorkflowRuntimeQueries,
+    mutations: resolvers.WorkflowRuntimeMutations,
+  };
+}
+
+describe("the workflow resolvers and the caller", () => {
+  it("hands the caller to every workflow-scoped field", async () => {
+    const { runtime, queries, mutations } = build(true);
+
+    await queries.webhookEndpoint({}, { workflowId: "wf-1" }, CTX);
+    await queries.triggerStates({}, {}, CTX);
+    await queries.runs({}, { driveId: "drive-1" }, CTX);
+    await queries.run({}, { id: "run-1" }, CTX);
+    await mutations.fire({}, { workflowId: "wf-1", payload: { a: 1 } }, CTX);
+    await mutations.rerun({}, { runId: "run-1" }, CTX);
+    await mutations.testStep({}, { workflowId: "wf-1", stepId: "s1" }, CTX);
+    await queries.stepOutputTree({}, { workflowId: "wf-1", stepId: "s1" }, CTX);
+    await queries.blockResolutions({}, { workflowId: "wf-1" }, CTX);
+    await mutations.testTrigger(
+      {},
+      { workflowId: "wf-1", payload: { a: 1 }, timeoutSeconds: 30 },
+      CTX,
+    );
+    await mutations.cancelTriggerTest({}, { workflowId: "wf-1" }, CTX);
+
+    expect(runtime.webhookEndpoint).toHaveBeenCalledWith("wf-1", CTX, {});
+    expect(runtime.triggerStates).toHaveBeenCalledWith(CTX);
+    expect(runtime.runs).toHaveBeenCalledWith(
+      { driveId: "drive-1", withStepData: true },
+      CTX,
+    );
+    expect(runtime.run).toHaveBeenCalledWith("run-1", CTX);
+    expect(runtime.fire).toHaveBeenCalledWith(
+      "wf-1",
+      { a: 1 },
+      "manual",
+      undefined,
+      CTX,
+    );
+    expect(runtime.rerun).toHaveBeenCalledWith("run-1", CTX);
+    expect(runtime.testStep).toHaveBeenCalledWith("wf-1", "s1", CTX, {});
+    expect(runtime.stepOutputTree).toHaveBeenCalledWith("wf-1", "s1", CTX);
+    expect(runtime.blockResolutions).toHaveBeenCalledWith("wf-1", CTX);
+    expect(runtime.testTrigger).toHaveBeenCalledWith("wf-1", CTX, {
+      payload: { a: 1 },
+      timeoutMs: 30_000,
+    });
+    expect(runtime.cancelTriggerTestFor).toHaveBeenCalledWith("wf-1", CTX);
+  });
+
+  it("passes the caller's drive, and tags a still-syncing workflow", async () => {
+    const { runtime, queries, mutations } = build(true);
+    const drive = { driveId: "drive-1" };
+
+    await queries.webhookEndpoint({}, { workflowId: "wf-1", ...drive }, CTX);
+    await mutations.testTrigger({}, { workflowId: "wf-1", ...drive }, CTX);
+    runtime.testStep.mockRejectedValueOnce(new WorkflowSyncingError());
+    const syncing = mutations.testStep(
+      {},
+      { workflowId: "wf-1", stepId: "s1", ...drive },
+      CTX,
+    );
+
+    expect(runtime.webhookEndpoint).toHaveBeenCalledWith("wf-1", CTX, drive);
+    expect(runtime.testTrigger).toHaveBeenCalledWith("wf-1", CTX, drive);
+    await expect(syncing).rejects.toMatchObject({
+      message: WORKFLOW_SYNCING_MESSAGE,
+      extensions: { code: "WORKFLOW_SYNCING", retryable: true },
+    });
+    expect(runtime.testStep).toHaveBeenCalledWith("wf-1", "s1", CTX, drive);
+  });
+
+  it("refuses secret writes to a caller who does not administer the reactor", async () => {
+    const { runtime, mutations } = build(false);
+
+    await expect(
+      mutations.createSecret({}, { value: "s3cret" }, CTX),
+    ).rejects.toThrow("Admin access required");
+    await expect(
+      mutations.rotateSecret({}, { ref: "secret://v1:00", value: "s" }, CTX),
+    ).rejects.toThrow("Admin access required");
+    await expect(
+      mutations.deleteSecret({}, { ref: "secret://v1:00" }, CTX),
+    ).rejects.toThrow("Admin access required");
+    // Refused before the store is ever opened.
+    expect(runtime.secrets).not.toHaveBeenCalled();
+  });
+
+  it("lets an administrator write secrets", async () => {
+    const { runtime, mutations } = build(true);
+
+    await mutations.createSecret({}, { value: "s3cret", label: "slack" }, CTX);
+
+    expect(runtime.secrets).toHaveBeenCalledTimes(1);
+  });
+
+  it("serves the piece version a run's steps ran", async () => {
+    const { runtime, queries } = build(true);
+    runtime.run.mockResolvedValueOnce({
+      row: { id: "run-1", warnings: 1, trigger_payload: null },
+      steps: [
+        {
+          step_id: "s1",
+          input: null,
+          output: null,
+          piece_version: "2.1.0",
+          piece_source: "registry",
+          version_match: "fallback",
+          version_note:
+            "Pinned 3.0.0 is not available; runs 2.1.0 from registry",
+        },
+      ],
+    } as never);
+
+    const run = (await queries.run({}, { id: "run-1" }, CTX)) as {
+      warnings: number;
+      steps: Record<string, unknown>[];
+    };
+
+    expect(run.warnings).toBe(1);
+    expect(run.steps[0]).toMatchObject({
+      pieceVersion: "2.1.0",
+      pieceSource: "registry",
+      versionMatch: "fallback",
+      versionNote: "Pinned 3.0.0 is not available; runs 2.1.0 from registry",
+    });
+  });
+});
+
+describe("the runs listing and step data", () => {
+  it("reads step blobs only when the query selects them", async () => {
+    const { runtime, queries } = build(false);
+    const withData = (query: string) =>
+      queries.runs({}, {}, CTX, runsInfo(query)).then(
+        () =>
+          (runtime.runs.mock.calls.at(-1) as unknown[])[0] as {
+            withStepData: boolean;
+          },
+      );
+
+    expect(
+      (await withData("{ workflowRuntime { runs { id status } } }"))
+        .withStepData,
+    ).toBe(false);
+    expect(
+      (
+        await withData(
+          "{ workflowRuntime { runs { id steps { stepId status } } } }",
+        )
+      ).withStepData,
+    ).toBe(false);
+    expect(
+      (
+        await withData(
+          "{ workflowRuntime { runs { id steps { stepId output } } } }",
+        )
+      ).withStepData,
+    ).toBe(true);
+    // A fragment can select anything, so it reads as asking for the blobs.
+    expect(
+      (
+        await withData(
+          "{ workflowRuntime { runs { id steps { ...S } } } } fragment S on WorkflowStepRunRecord { input }",
+        )
+      ).withStepData,
+    ).toBe(true);
+  });
+});
+
+describe("the runs page", () => {
+  it("passes paging through and serves the page", async () => {
+    const { runtime, queries } = build(false);
+    runtime.runsPage.mockResolvedValueOnce({
+      records: [],
+      hasNextPage: true,
+      cursor: "next",
+    });
+
+    const page = await queries.runsPage(
+      {},
+      {
+        driveId: "drive-1",
+        excludeTriggerKinds: ["test"],
+        paging: { limit: 10, cursor: "prev" },
+      },
+      CTX,
+      runsInfo(
+        "{ workflowRuntime { runsPage { items { id steps { status } } cursor } } }",
+      ),
+    );
+
+    expect(runtime.runsPage).toHaveBeenCalledWith(
+      {
+        driveId: "drive-1",
+        excludeTriggerKinds: ["test"],
+        limit: 10,
+        cursor: "prev",
+        withStepData: false,
+      },
+      CTX,
+    );
+    expect(page).toEqual({
+      items: [],
+      hasNextPage: true,
+      hasPreviousPage: true,
+      cursor: "next",
+    });
+  });
+
+  it("reports a cursor it did not issue as bad input", async () => {
+    const { runtime, queries } = build(false);
+    const invalid = new Error("Invalid runs cursor");
+    invalid.name = "InvalidRunCursorError";
+    runtime.runsPage.mockRejectedValueOnce(invalid);
+
+    const error = (await queries
+      .runsPage({}, { paging: { cursor: "junk" } }, CTX)
+      .catch((thrown: unknown) => thrown)) as {
+      extensions?: { code?: string };
+    };
+    expect(error.extensions?.code).toBe("BAD_USER_INPUT");
+  });
+});

package/test/workflow/webhook-dedupe.test.ts

@@ -0,0 +1,295 @@
+// Redelivery and the sender's verification round, over a real socket: both
+// are decided by the reactor from one config field, before the trigger runs.
+import { afterEach, describe, expect, it } from "vitest";
+import { startWebhookHost, waitForRuns, type WebhookHost } from "./harness.js";
+
+let host: WebhookHost | undefined;
+
+afterEach(async () => {
+  // Even on failure: a thrown expectation would leave the port open.
+  await host?.stop();
+  host = undefined;
+});
+
+const JSON_HEADERS = { "content-type": "application/json" };
+
+// Gives a run that should NOT exist time to appear: asserting the instant a
+// response lands wins the race whether the trigger fired or not.
+async function settle(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+interface PolicyShape {
+  dedupe?: { field: unknown; ttlSeconds?: number };
+  challengeField?: unknown;
+}
+
+describe("the core webhook trigger redelivery", () => {
+  it("dedupes on a bare field name found in the query string", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      dedupeField: "eventId",
+      dedupeTtlSeconds: 60,
+    });
+    const send = () => host!.deliver(token, { query: { eventId: "evt-1" } });
+
+    expect((await send()).status).toBe(202);
+    await waitForRuns(host, 1);
+    // A redelivery is answered as a success so the provider stops retrying;
+    // 4xx here would make a well-behaved sender retry forever.
+    expect((await send()).status).toBe(200);
+    await settle();
+    expect(host.fired).toHaveLength(1);
+  });
+
+  it("dedupes on a bare field name found as a top-level body field", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      dedupeField: "id",
+      dedupeTtlSeconds: 60,
+    });
+    const send = () =>
+      host!.deliver(token, {
+        headers: JSON_HEADERS,
+        body: '{"id":"evt_1","kind":"created"}',
+      });
+
+    expect((await send()).status).toBe(202);
+    await waitForRuns(host, 1);
+    expect((await send()).status).toBe(200);
+    await settle();
+    expect(host.fired).toHaveLength(1);
+  });
+
+  it("dedupes on a `header:`-sourced field", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      dedupeField: "header:x-delivery-id",
+      dedupeTtlSeconds: 60,
+    });
+    const send = () =>
+      host!.deliver(token, {
+        headers: { ...JSON_HEADERS, "x-delivery-id": "abc-123" },
+        body: '{"a":1}',
+      });
+
+    expect((await send()).status).toBe(202);
+    await waitForRuns(host, 1);
+    expect((await send()).status).toBe(200);
+    await settle();
+    expect(host.fired).toHaveLength(1);
+  });
+
+  it("dedupes on a `body:` path nested inside the payload", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      dedupeField: "body:data.object.id",
+      dedupeTtlSeconds: 60,
+    });
+    const send = () =>
+      host!.deliver(token, {
+        headers: JSON_HEADERS,
+        body: '{"data":{"object":{"id":"in_1"}}}',
+      });
+
+    expect((await send()).status).toBe(202);
+    await waitForRuns(host, 1);
+    expect((await send()).status).toBe(200);
+    await settle();
+    expect(host.fired).toHaveLength(1);
+  });
+
+  it("keys only on the named field, not on the URL or the body", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      dedupeField: "header:x-delivery-id",
+      dedupeTtlSeconds: 60,
+    });
+
+    const first = await host.deliver(token, {
+      headers: { ...JSON_HEADERS, "x-delivery-id": "abc-123" },
+      query: { attempt: "1" },
+      body: '{"attempt":1}',
+    });
+    expect(first.status).toBe(202);
+    await waitForRuns(host, 1);
+
+    // A retry is rarely byte-identical, so anything keyed on the URL or the
+    // whole request would treat this as a new event and run twice.
+    const retry = await host.deliver(token, {
+      headers: { ...JSON_HEADERS, "x-delivery-id": "abc-123" },
+      query: { attempt: "2" },
+      body: '{"attempt":2}',
+    });
+    expect(retry.status).toBe(200);
+    await settle();
+    expect(host.fired).toHaveLength(1);
+  });
+
+  it("starts a second run when the named field carries a different value", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      dedupeField: "header:x-delivery-id",
+      dedupeTtlSeconds: 60,
+    });
+    const send = (id: string) =>
+      host!.deliver(token, {
+        headers: { ...JSON_HEADERS, "x-delivery-id": id },
+        body: '{"a":1}',
+      });
+
+    expect((await send("abc-123")).status).toBe(202);
+    expect((await send("def-456")).status).toBe(202);
+    await waitForRuns(host, 2);
+    expect(host.fired).toHaveLength(2);
+  });
+
+  it("runs every delivery when no dedupe field is configured", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({ methods: "POST" });
+    const send = () =>
+      host!.deliver(token, { headers: JSON_HEADERS, body: '{"a":1}' });
+
+    expect((await send()).status).toBe(202);
+    expect((await send()).status).toBe(202);
+    // Without an id there is no key, and collapsing unrelated deliveries under
+    // a shared "no key" bucket would silently drop real events.
+    await waitForRuns(host, 2);
+    expect(host.fired).toHaveLength(2);
+  });
+
+  it("runs both deliveries when the configured field is absent from the request", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      dedupeField: "header:x-delivery-id",
+      dedupeTtlSeconds: 60,
+    });
+    const send = (body: string) =>
+      host!.deliver(token, { headers: JSON_HEADERS, body });
+
+    expect((await send('{"a":1}')).status).toBe(202);
+    expect((await send('{"a":2}')).status).toBe(202);
+    // A missing field is not a key either: two senders that both omit it are
+    // not the same delivery, and treating them as one loses the second event.
+    await waitForRuns(host, 2);
+    expect(host.fired).toHaveLength(2);
+  });
+
+  it("drops everything after the first when the named field repeats across events", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      // A subscription id is the same on every delivery for that subscription,
+      // so naming it here is a configuration mistake with no error to see.
+      dedupeField: "subscriptionId",
+      dedupeTtlSeconds: 60,
+    });
+    const send = (eventId: string) =>
+      host!.deliver(token, {
+        headers: JSON_HEADERS,
+        body: `{"subscriptionId":"sub_1","eventId":"${eventId}"}`,
+      });
+
+    expect((await send("evt_1")).status).toBe(202);
+    await waitForRuns(host, 1);
+    // Two different events, second silently discarded: the field has to
+    // identify the delivery, not the thing it is about.
+    expect((await send("evt_2")).status).toBe(200);
+    await settle();
+    expect(host.fired).toHaveLength(1);
+  });
+});
+
+describe("the core webhook trigger endpoint verification", () => {
+  it("echoes a bare challenge field from the query string without running", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      challengeField: "hub.challenge",
+    });
+
+    const response = await host.deliver(token, {
+      query: { "hub.challenge": "nonce-42" },
+    });
+    expect(response.status).toBe(200);
+    // Verbatim: providers compare the body byte for byte, so a JSON wrapper or
+    // a trailing newline fails the subscription with nothing to read.
+    expect(await response.text()).toBe("nonce-42");
+    await settle();
+    expect(host.fired).toHaveLength(0);
+  });
+
+  it("echoes a `header:`-sourced challenge field without running", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      challengeField: "header:x-hook-challenge",
+    });
+
+    const response = await host.deliver(token, {
+      headers: { ...JSON_HEADERS, "x-hook-challenge": "nonce-99" },
+      body: '{"type":"url_verification"}',
+    });
+    expect(response.status).toBe(200);
+    expect(await response.text()).toBe("nonce-99");
+    await settle();
+    expect(host.fired).toHaveLength(0);
+  });
+
+  it("runs as usual when the challenge field is absent", async () => {
+    host = await startWebhookHost();
+    const { token } = await host.arm({
+      methods: "POST",
+      challengeField: "hub.challenge",
+    });
+
+    // The challenge round happens once; every delivery after it is a real
+    // event, so a configured challenge field must not swallow the endpoint.
+    const response = await host.deliver(token, {
+      headers: JSON_HEADERS,
+      body: '{"id":"evt_1"}',
+    });
+    expect(response.status).toBe(202);
+    const [run] = await waitForRuns(host, 1);
+    expect(run.kind).toBe("webhook");
+  });
+});
+
+describe("the core webhook trigger field policy", () => {
+  it("hands the reactor a source-tagged field for a prefixed config", async () => {
+    host = await startWebhookHost();
+    await host.arm({
+      methods: "POST",
+      dedupeField: "header:X-Delivery-ID",
+      challengeField: "body:challenge.value",
+      dedupeTtlSeconds: 60,
+    });
+
+    const policy = (await host.policyFor()) as PolicyShape;
+    // Lowercased for the reactor's header record; the prefix must survive
+    // parsing or the reactor reads the query string and finds no id.
+    expect(policy.dedupe?.field).toEqual({ header: "x-delivery-id" });
+    expect(policy.dedupe?.ttlSeconds).toBe(60);
+    expect(policy.challengeField).toEqual({ body: "challenge.value" });
+  });
+
+  it("leaves a bare field name bare, so the reactor tries query then body", async () => {
+    host = await startWebhookHost();
+    await host.arm({
+      methods: "POST",
+      dedupeField: "eventId",
+      challengeField: "hub.challenge",
+    });
+
+    const policy = (await host.policyFor()) as PolicyShape;
+    expect(policy.dedupe?.field).toBe("eventId");
+    expect(policy.challengeField).toBe("hub.challenge");
+  });
+});