convex-effect-workflows 0.1.0

package/src/component/dashboard.scaling.test.ts

@@ -0,0 +1,268 @@
+/// <reference types="vite/client" />
+
+import { describe, expect, test } from "vitest";
+import { api } from "./_generated/api.js";
+import { initConvexTest } from "./setup.test.js";
+
+async function createTerminalExecution(
+  t: ReturnType<typeof initConvexTest>,
+  args: {
+    executionId: string;
+    tenantId: string;
+    workflowName?: string;
+    status: "completed" | "failed";
+    startedAt?: number;
+  },
+) {
+  await t.mutation(api.executions.createExecution, {
+    workflowName: args.workflowName ?? "scalingWorkflow",
+    executionId: args.executionId,
+    tenantId: args.tenantId,
+    payload: { id: args.executionId },
+  });
+
+  if (args.status === "completed") {
+    await t.mutation(api.executions.completeExecution, {
+      executionId: args.executionId,
+      generation: 0,
+      kind: "success",
+      result: { ok: true },
+    });
+  } else {
+    await t.mutation(api.executions.completeExecution, {
+      executionId: args.executionId,
+      generation: 0,
+      kind: "failure",
+      error: "failed",
+    });
+  }
+
+  if (args.startedAt !== undefined) {
+    await t.mutation(api.executions.internalPatchExecution, {
+      executionId: args.executionId,
+      startedAt: args.startedAt,
+    });
+  }
+}
+
+describe("dashboard query scaling", () => {
+  test("listExecutions applies tenant+status+time filters with stable cursoring", async () => {
+    const t = initConvexTest();
+
+    const windowStart = 1_800_000_000_000;
+    const inWindowTime = windowStart + 100;
+
+    await createTerminalExecution(t, {
+      executionId: "old-000",
+      tenantId: "tenant-a",
+      status: "completed",
+      startedAt: windowStart - 10_000,
+    });
+
+    await createTerminalExecution(t, {
+      executionId: "new-999",
+      tenantId: "tenant-a",
+      status: "completed",
+      startedAt: windowStart + 10_000,
+    });
+
+    await createTerminalExecution(t, {
+      executionId: "noise-tenant",
+      tenantId: "tenant-b",
+      status: "completed",
+      startedAt: inWindowTime,
+    });
+
+    await createTerminalExecution(t, {
+      executionId: "noise-status",
+      tenantId: "tenant-a",
+      status: "failed",
+      startedAt: inWindowTime,
+    });
+
+    const expected = ["match-001", "match-002", "match-003", "match-004"];
+    for (const executionId of expected) {
+      await createTerminalExecution(t, {
+        executionId,
+        tenantId: "tenant-a",
+        status: "completed",
+        startedAt: inWindowTime,
+      });
+    }
+
+    const firstPage = await t.query(api.dashboard.listExecutions, {
+      tenantId: "tenant-a",
+      status: "completed",
+      startedAfter: windowStart,
+      startedBefore: windowStart + 1_000,
+      order: "asc",
+      limit: 2,
+    });
+
+    expect(firstPage.page).toHaveLength(2);
+    expect(firstPage.page.map((row: any) => row.executionId)).toEqual(expected.slice(0, 2));
+    expect(firstPage.isDone).toBe(false);
+    expect(firstPage.cursor).toBeTruthy();
+
+    const secondPage = await t.query(api.dashboard.listExecutions, {
+      tenantId: "tenant-a",
+      status: "completed",
+      startedAfter: windowStart,
+      startedBefore: windowStart + 1_000,
+      order: "asc",
+      limit: 2,
+      cursorStartedAt: firstPage.cursor!.startedAt,
+      cursorExecutionId: firstPage.cursor!.executionId,
+    });
+
+    expect(secondPage.page).toHaveLength(2);
+    expect(secondPage.page.map((row: any) => row.executionId)).toEqual(expected.slice(2));
+    expect(secondPage.isDone).toBe(true);
+  });
+
+  test("listExecutions handles large filtered pages with cursor continuation", async () => {
+    const t = initConvexTest();
+
+    const time = 1_900_000_000_000;
+
+    for (let i = 0; i < 120; i++) {
+      await createTerminalExecution(t, {
+        executionId: `match-${String(i).padStart(3, "0")}`,
+        tenantId: "tenant-a",
+        status: "completed",
+        startedAt: time,
+      });
+    }
+
+    for (let i = 0; i < 20; i++) {
+      await createTerminalExecution(t, {
+        executionId: `noise-failed-${String(i).padStart(3, "0")}`,
+        tenantId: "tenant-a",
+        status: "failed",
+        startedAt: time,
+      });
+      await createTerminalExecution(t, {
+        executionId: `noise-tenant-${String(i).padStart(3, "0")}`,
+        tenantId: "tenant-b",
+        status: "completed",
+        startedAt: time,
+      });
+    }
+
+    const firstPage = await t.query(api.dashboard.listExecutions, {
+      tenantId: "tenant-a",
+      status: "completed",
+      startedAfter: time - 1,
+      startedBefore: time + 1,
+      order: "asc",
+      limit: 100,
+    });
+
+    expect(firstPage.page).toHaveLength(100);
+    expect(firstPage.isDone).toBe(false);
+    expect(firstPage.cursor).toBeTruthy();
+    expect(firstPage.page.every((row: any) => row.executionId.startsWith("match-"))).toBe(true);
+
+    const secondPage = await t.query(api.dashboard.listExecutions, {
+      tenantId: "tenant-a",
+      status: "completed",
+      startedAfter: time - 1,
+      startedBefore: time + 1,
+      order: "asc",
+      limit: 100,
+      cursorStartedAt: firstPage.cursor!.startedAt,
+      cursorExecutionId: firstPage.cursor!.executionId,
+    });
+
+    expect(secondPage.page).toHaveLength(20);
+    expect(secondPage.isDone).toBe(true);
+    expect(secondPage.page.every((row: any) => row.executionId.startsWith("match-"))).toBe(true);
+  });
+
+  test("listExecutionLogs paginates large equal-timestamp sets with stable tie-breakers", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "logWorkflow",
+      executionId: "exec-logs-scale",
+      payload: { ok: true },
+    });
+
+    const timestamp = 2_000_000_000_000;
+
+    for (let i = 0; i < 120; i++) {
+      await t.mutation(api.logs.createLog, {
+        executionId: "exec-logs-scale",
+        traceId: "trace-scale",
+        spanId: "span-hot",
+        stepNumber: 0,
+        level: "info",
+        source: "activity",
+        message: `match-${String(i).padStart(3, "0")}`,
+        timestamp,
+      });
+    }
+
+    for (let i = 0; i < 25; i++) {
+      await t.mutation(api.logs.createLog, {
+        executionId: "exec-logs-scale",
+        traceId: "trace-scale",
+        spanId: "span-hot",
+        stepNumber: 0,
+        level: "error",
+        source: "activity",
+        message: `noise-level-${i}`,
+        timestamp,
+      });
+      await t.mutation(api.logs.createLog, {
+        executionId: "exec-logs-scale",
+        traceId: "trace-scale",
+        spanId: "span-other",
+        stepNumber: 0,
+        level: "info",
+        source: "activity",
+        message: `noise-span-${i}`,
+        timestamp,
+      });
+    }
+
+    const firstPage = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs-scale",
+      level: "info",
+      source: "activity",
+      spanId: "span-hot",
+      order: "asc",
+      limit: 100,
+    });
+
+    expect(firstPage.page).toHaveLength(100);
+    expect(firstPage.isDone).toBe(false);
+    expect(firstPage.cursor).toBeTruthy();
+    expect(
+      firstPage.page.every((row: any) => row.message.startsWith("match-")),
+    ).toBe(true);
+
+    const firstIds = new Set(firstPage.page.map((row: any) => row._id));
+
+    const secondPage = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs-scale",
+      level: "info",
+      source: "activity",
+      spanId: "span-hot",
+      order: "asc",
+      limit: 100,
+      afterTimestamp: firstPage.cursor!.timestamp,
+      afterLogId: firstPage.cursor!.logId,
+    });
+
+    expect(secondPage.page).toHaveLength(20);
+    expect(secondPage.isDone).toBe(true);
+    expect(
+      secondPage.page.every((row: any) => row.message.startsWith("match-")),
+    ).toBe(true);
+
+    for (const row of secondPage.page) {
+      expect(firstIds.has(row._id)).toBe(false);
+    }
+  });
+});