Skip to content

The open-source app everyone uses to manage agents at work

fix(server): accept parentIssueId alias in GET /issues (#4032)

scokeepa2ebc236b089d
diff --git a/server/src/__tests__/helpers/route-test-harness.ts b/server/src/__tests__/helpers/route-test-harness.ts
new file mode 100644
index 0000000000..6b704caf6a
--- /dev/null
+++ b/server/src/__tests__/helpers/route-test-harness.ts
@@ -0,0 +1,141 @@
+import { randomUUID } from "node:crypto";
+import express, { type Router } from "express";
+import { isNotNull } from "drizzle-orm";
+import {
+ companies,
+ companyMemberships,
+ createDb,
+ issues,
+ principalPermissionGrants,
+} from "@paperclipai/db";
+import { afterAll, afterEach, beforeAll, describe } from "vitest";
+import { errorHandler } from "../../middleware/index.js";
+import { ensureHumanRoleDefaultGrants } from "../../services/principal-access-compatibility.js";
+import {
+ getEmbeddedPostgresTestSupport,
+ startEmbeddedPostgresTestDatabase,
+} from "./embedded-postgres.js";
+
+type Db = ReturnType<typeof createDb>;
+
+const embeddedPostgresSupport = await getEmbeddedPostgresTestSupport();
+
+/** `describe` on hosts that can run embedded Postgres, `describe.skip` elsewhere. */
+export const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip;
+
+export type EmbeddedPostgresContext = { readonly db: Db };
+
+/**
+ * Registers the embedded Postgres lifecycle for the enclosing `describe`. Read
+ * `.db` from inside a test; it is unavailable until `beforeAll` has run.
+ */
+export function useEmbeddedPostgres(
+ prefix: string,
+ opts: { resetEach?: (db: Db) => Promise<void> } = {},
+): EmbeddedPostgresContext {
+ let db: Db | null = null;
+ let tempDb: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>> | null = null;
+
+ beforeAll(async () => {
+ tempDb = await startEmbeddedPostgresTestDatabase(prefix);
+ db = createDb(tempDb.connectionString);
+ }, 20_000);
+
+ if (opts.resetEach) {
+ const resetEach = opts.resetEach;
+ afterEach(async () => {
+ if (db) await resetEach(db);
+ });
+ }
+
+ afterAll(async () => {
+ await tempDb?.cleanup();
+ tempDb = null;
+ db = null;
+ });
+
+ return {
+ get db() {
+ if (!db) throw new Error("embedded Postgres is not started yet — read .db inside a test");
+ return db;
+ },
+ };
+}
+
+export type BoardActor = {
+ type: "board";
+ source: string;
+ userId: string;
+ companyIds: string[];
+ memberships: { companyId: string; membershipRole: string; status: string }[];
+ isInstanceAdmin: boolean;
+};
+
+export type SeededCompany = { companyId: string; userId: string; actor: BoardActor };
+
+/** Creates a company whose board user holds company-scoped read and write grants. */
+export async function seedCompanyWithBoardAccess(db: Db, name: string): Promise<SeededCompany> {
+ const companyId = randomUUID();
+ const userId = `user-${randomUUID()}`;
+ await db.insert(companies).values({
+ id: companyId,
+ name: `${name} ${companyId}`,
+ issuePrefix: `T${companyId.replaceAll("-", "").slice(0, 6).toUpperCase()}`,
+ requireBoardApprovalForNewAgents: false,
+ });
+ await db.insert(companyMemberships).values({
+ companyId,
+ principalType: "user",
+ principalId: userId,
+ status: "active",
+ membershipRole: "owner",
+ updatedAt: new Date(),
+ });
+ await ensureHumanRoleDefaultGrants(db, {
+ companyId,
+ principalId: userId,
+ membershipRole: "owner",
+ grantedByUserId: null,
+ });
+ return {
+ companyId,
+ userId,
+ actor: {
+ type: "board",
+ source: "session",
+ userId,
+ companyIds: [companyId],
+ memberships: [{ companyId, membershipRole: "owner", status: "active" }],
+ isInstanceAdmin: false,
+ },
+ };
+}
+
+type RouterFactory = (db: Db, storage: never) => Router;
+
+/** Mounts route modules under `/api` behind a fixed actor, with the real error handler. */
+export function routeApp(db: Db, actor: BoardActor, ...routerFactories: RouterFactory[]) {
+ const app = express();
+ app.use(express.json());
+ app.use((req, _res, next) => {
+ (req as any).actor = actor;
+ next();
+ });
+ for (const factory of routerFactories) {
+ app.use("/api", factory(db, {} as never));
+ }
+ app.use(errorHandler);
+ return app;
+}
+
+/**
+ * Clears the company and issue fixtures seeded by `seedCompanyWithBoardAccess`.
+ * Suites that seed other tables need their own reset.
+ */
+export async function resetCompanyIssueFixtures(db: Db) {
+ await db.delete(issues).where(isNotNull(issues.parentId));
+ await db.delete(issues);
+ await db.delete(principalPermissionGrants);
+ await db.delete(companyMemberships);
+ await db.delete(companies);
+}
diff --git a/server/src/__tests__/issues-list-query-parsing.test.ts b/server/src/__tests__/issues-list-query-parsing.test.ts
index f601aa8fc2..91024b93d0 100644
--- a/server/src/__tests__/issues-list-query-parsing.test.ts
+++ b/server/src/__tests__/issues-list-query-parsing.test.ts
@@ -1,74 +1,59 @@
-import express from "express";
+import { randomUUID } from "node:crypto";
import request from "supertest";
-import { describe, expect, it } from "vitest";
-import { parseStatusFilter } from "../services/issues.ts";
+import { expect, it } from "vitest";
+import { issues } from "@paperclipai/db";
+import { issueRoutes } from "../routes/issues.js";
+import {
+ describeEmbeddedPostgres,
+ resetCompanyIssueFixtures,
+ routeApp,
+ seedCompanyWithBoardAccess,
+ useEmbeddedPostgres,
+} from "./helpers/route-test-harness.js";
/**
- * Regression test for https://github.com/paperclipai/paperclip/issues/4628
- *
- * Stands up a minimal Express app whose handler mirrors the parsing path
- * `server/src/routes/issues.ts:957-958` uses to forward `req.query.status`
- * into `issueService.list({ status })`. Verifies the four shapes Express's
- * default `qs` parser can produce all normalize correctly and none crash:
- *
- * 1. Single value — `?status=todo`
- * 2. Comma-separated — `?status=todo,in_progress` (legacy)
- * 3. Repeated key (array) — `?status=todo&status=in_progress` (the bug)
- * 4. Mixed array + CSV — `?status=todo,in_progress&status=done`
- *
- * Pre-fix, case 3 returned HTTP 500 with `TypeError: filters.status.split is
- * not a function`. We don't spin embedded-postgres here; the helper itself is
- * unit-tested in `parse-status-filter.test.ts`, and the route→helper contract
- * is what regresses if anyone reverts the fix.
+ * Regression coverage for https://github.com/paperclipai/paperclip/issues/4628.
+ * Express's `qs` parser hands the list route either a string or an array for
+ * `?status=`, and the route normalizes both shapes.
*/
-function buildApp() {
- const app = express();
- app.use(express.json());
- app.get("/api/companies/:companyId/issues", (req, res) => {
- // Mirror the cast at routes/issues.ts:958 exactly. Pre-fix this said
- // `as string | undefined` and the cast was a lie when qs returned an array.
- const statusInput = req.query.status as string | string[] | undefined;
- const statuses = parseStatusFilter(statusInput);
- res.status(200).json({ statuses });
+describeEmbeddedPostgres("issue list status query parsing", () => {
+ const ctx = useEmbeddedPostgres("paperclip-issues-list-query-parsing-", {
+ resetEach: resetCompanyIssueFixtures,
});
- return app;
-}
-describe("issue list status query parsing", () => {
- it("accepts a single ?status=todo and returns one normalized status", async () => {
- const res = await request(buildApp()).get("/api/companies/c1/issues?status=todo");
- expect(res.status).toBe(200);
- expect(res.body).toEqual({ statuses: ["todo"] });
+ async function listStatuses(query: string) {
+ const company = await seedCompanyWithBoardAccess(ctx.db, "Status parsing");
+ const companyId = company.companyId;
+ await ctx.db.insert(issues).values([
+ { id: randomUUID(), companyId, title: "Todo", status: "todo", priority: "medium" },
+ { id: randomUUID(), companyId, title: "In progress", status: "in_progress", priority: "medium" },
+ { id: randomUUID(), companyId, title: "Done", status: "done", priority: "medium" },
+ ]);
+ const res = await request(routeApp(ctx.db, company.actor, issueRoutes))
+ .get(`/api/companies/${companyId}/issues${query}`)
+ .expect(200);
+ return (res.body as { status: string }[]).map((issue) => issue.status).sort();
+ }
+
+ it("accepts a single ?status=todo", async () => {
+ expect(await listStatuses("?status=todo")).toEqual(["todo"]);
});
- it("accepts comma-separated ?status=todo,in_progress (preserves legacy CSV)", async () => {
- const res = await request(buildApp()).get(
- "/api/companies/c1/issues?status=todo,in_progress",
- );
- expect(res.status).toBe(200);
- expect(res.body).toEqual({ statuses: ["todo", "in_progress"] });
+ it("accepts comma-separated ?status=todo,in_progress", async () => {
+ expect(await listStatuses("?status=todo,in_progress")).toEqual(["in_progress", "todo"]);
});
- it("accepts repeated ?status=todo&status=in_progress without crashing (the bug fix)", async () => {
- const res = await request(buildApp()).get(
- "/api/companies/c1/issues?status=todo&status=in_progress",
- );
- expect(res.status).toBe(200);
- expect(res.body).toEqual({ statuses: ["todo", "in_progress"] });
+ it("accepts repeated ?status=todo&status=in_progress", async () => {
+ expect(await listStatuses("?status=todo&status=in_progress")).toEqual(["in_progress", "todo"]);
});
- it("accepts mixed array + CSV ?status=todo,in_progress&status=done", async () => {
- const res = await request(buildApp()).get(
- "/api/companies/c1/issues?status=todo,in_progress&status=done",
- );
- expect(res.status).toBe(200);
- expect(res.body).toEqual({ statuses: ["todo", "in_progress", "done"] });
+ it("accepts mixed array and CSV ?status=todo,in_progress&status=done", async () => {
+ expect(await listStatuses("?status=todo,in_progress&status=done"))
+ .toEqual(["done", "in_progress", "todo"]);
});
- it("accepts no ?status param and returns an empty status filter", async () => {
- const res = await request(buildApp()).get("/api/companies/c1/issues");
- expect(res.status).toBe(200);
- expect(res.body).toEqual({ statuses: [] });
+ it("returns every status when ?status is absent", async () => {
+ expect(await listStatuses("")).toEqual(["done", "in_progress", "todo"]);
});
});
diff --git a/server/src/__tests__/issues-parent-id-alias.test.ts b/server/src/__tests__/issues-parent-id-alias.test.ts
new file mode 100644
index 0000000000..5d1be26202
--- /dev/null
+++ b/server/src/__tests__/issues-parent-id-alias.test.ts
@@ -0,0 +1,116 @@
+import { randomUUID } from "node:crypto";
+import request from "supertest";
+import { expect, it } from "vitest";
+import { issues } from "@paperclipai/db";
+import { issueRoutes } from "../routes/issues.js";
+import {
+ describeEmbeddedPostgres,
+ resetCompanyIssueFixtures,
+ routeApp,
+ seedCompanyWithBoardAccess,
+ useEmbeddedPostgres,
+} from "./helpers/route-test-harness.js";
+
+describeEmbeddedPostgres("issue list parentIssueId query alias", () => {
+ const ctx = useEmbeddedPostgres("paperclip-issues-parent-id-alias-", {
+ resetEach: resetCompanyIssueFixtures,
+ });
+
+ async function seed() {
+ const company = await seedCompanyWithBoardAccess(ctx.db, "Parent alias");
+ const companyId = company.companyId;
+ const parentId = randomUUID();
+ const otherParentId = randomUUID();
+ const childId = randomUUID();
+ const blockedChildId = randomUUID();
+
+ await ctx.db.insert(issues).values([
+ { id: parentId, companyId, title: "Parent", status: "todo", priority: "medium" },
+ { id: otherParentId, companyId, title: "Other parent", status: "todo", priority: "medium" },
+ ]);
+ await ctx.db.insert(issues).values([
+ { id: childId, companyId, title: "Child", status: "todo", priority: "medium", parentId },
+ { id: blockedChildId, companyId, title: "Blocked child", status: "blocked", priority: "medium", parentId },
+ {
+ id: randomUUID(),
+ companyId,
+ title: "Other child",
+ status: "todo",
+ priority: "medium",
+ parentId: otherParentId,
+ },
+ {
+ id: randomUUID(),
+ companyId,
+ title: "Blocked other child",
+ status: "blocked",
+ priority: "medium",
+ parentId: otherParentId,
+ },
+ ]);
+
+ return { ...company, parentId, otherParentId, childId, blockedChildId };
+ }
+
+ type Seeded = Awaited<ReturnType<typeof seed>>;
+
+ function appFor(seeded: Seeded) {
+ return routeApp(ctx.db, seeded.actor, issueRoutes);
+ }
+
+ async function listIds(seeded: Seeded, query: Record<string, string>) {
+ const res = await request(appFor(seeded))
+ .get(`/api/companies/${seeded.companyId}/issues`)
+ .query(query)
+ .expect(200);
+ return (res.body as { id: string }[]).map((issue) => issue.id).sort();
+ }
+
+ async function blockedCount(seeded: Seeded, query: Record<string, string>) {
+ const res = await request(appFor(seeded))
+ .get(`/api/companies/${seeded.companyId}/issues/count`)
+ .query({ attention: "blocked", ...query })
+ .expect(200);
+ return res.body as { count: number };
+ }
+
+ function childrenOfParent(seeded: Seeded) {
+ return [seeded.childId, seeded.blockedChildId].sort();
+ }
+
+ it("filters children by ?parentId=", async () => {
+ const seeded = await seed();
+ expect(await listIds(seeded, { parentId: seeded.parentId })).toEqual(childrenOfParent(seeded));
+ });
+
+ it("filters children by ?parentIssueId=", async () => {
+ const seeded = await seed();
+ expect(await listIds(seeded, { parentIssueId: seeded.parentId })).toEqual(childrenOfParent(seeded));
+ });
+
+ it("prefers ?parentId= when both spellings are present", async () => {
+ const seeded = await seed();
+ const ids = await listIds(seeded, {
+ parentId: seeded.parentId,
+ parentIssueId: seeded.otherParentId,
+ });
+ expect(ids).toEqual(childrenOfParent(seeded));
+ });
+
+ it("returns the whole company list when neither spelling is present", async () => {
+ const seeded = await seed();
+ expect(await listIds(seeded, {})).toHaveLength(6);
+ });
+
+ it("filters the blocked count by ?parentIssueId=", async () => {
+ const seeded = await seed();
+ expect(await blockedCount(seeded, { parentIssueId: seeded.parentId })).toEqual({ count: 1 });
+ });
+
+ it("returns the same blocked count for both spellings", async () => {
+ const seeded = await seed();
+ const byShortForm = await blockedCount(seeded, { parentId: seeded.parentId });
+ const byAlias = await blockedCount(seeded, { parentIssueId: seeded.parentId });
+ expect(byAlias).toEqual(byShortForm);
+ });
+});
diff --git a/server/src/routes/issues.ts b/server/src/routes/issues.ts
index 8477bbdd1a..811efef137 100644
--- a/server/src/routes/issues.ts
+++ b/server/src/routes/issues.ts
@@ -5210,7 +5210,7 @@ export function issueRoutes(
projectId: req.query.projectId as string | undefined,
workspaceId: req.query.workspaceId as string | undefined,
executionWorkspaceId: req.query.executionWorkspaceId as string | undefined,
- parentId: req.query.parentId as string | undefined,
+ parentId: (req.query.parentId ?? req.query.parentIssueId) as string | undefined,
descendantOf: req.query.descendantOf as string | undefined,
labelId: req.query.labelId as string | undefined,
originKind: req.query.originKind as string | undefined,
@@ -5402,7 +5402,7 @@ export function issueRoutes(
projectId: req.query.projectId as string | undefined,
workspaceId: req.query.workspaceId as string | undefined,
executionWorkspaceId: req.query.executionWorkspaceId as string | undefined,
- parentId: req.query.parentId as string | undefined,
+ parentId: (req.query.parentId ?? req.query.parentIssueId) as string | undefined,
descendantOf: req.query.descendantOf as string | undefined,
labelId: req.query.labelId as string | undefined,
originKind: req.query.originKind as string | undefined,