Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

fix(import): preserve exact names and column references during imports

Tin223e8a60b7cc
diff --git a/apps/api/src/task/controllers/import-tasks.ts b/apps/api/src/task/controllers/import-tasks.ts
index 5e381d392..2d4fed23e 100644
--- a/apps/api/src/task/controllers/import-tasks.ts
+++ b/apps/api/src/task/controllers/import-tasks.ts
@@ -1,4 +1,4 @@
-import { asc, eq } from "drizzle-orm";
+import { and, asc, eq } from "drizzle-orm";
import { HTTPException } from "hono/http-exception";
import db from "../../database";
import { columnTable, projectTable, taskTable } from "../../database/schema";
@@ -87,10 +87,20 @@ async function importTasks(
);
const warnings = [statusWarning, priorityWarning].filter(Boolean);
- const column = columns.find((candidate) => candidate.slug === status);
-
const createdTask = await db.transaction(async (tx) => {
const taskNumber = await claimTaskNumber(projectId, tx);
+ // Recheck the snapshot's column and retain it until the insert commits.
+ const [column] = await tx
+ .select({ id: columnTable.id })
+ .from(columnTable)
+ .where(
+ and(
+ eq(columnTable.projectId, projectId),
+ eq(columnTable.slug, status),
+ ),
+ )
+ .limit(1)
+ .for("key share");
const position = await nextTaskPosition(
tx,
projectId,
diff --git a/apps/api/src/task/resolve-import-task-status.test.ts b/apps/api/src/task/resolve-import-task-status.test.ts
index 3fb693361..4fc160e3b 100644
--- a/apps/api/src/task/resolve-import-task-status.test.ts
+++ b/apps/api/src/task/resolve-import-task-status.test.ts
@@ -32,6 +32,45 @@ describe("resolveImportTaskStatus", () => {
]),
).toEqual({ status: "to-do" });
});
+ it.each(["to-do", "planned", "archived"])(
+ "prefers the canonical status %s over an exact display name",
+ (status) =>
+ expect(
+ resolveImportTaskStatus(status, [
+ ...columns,
+ { slug: "other", name: status },
+ ]),
+ ).toEqual({ status }),
+ );
+ it.each([
+ ["QA+", "qa-plus"],
+ ["QA-", "qa-minus"],
+ ])("resolves the exact name %s despite colliding aliases", (name, slug) => {
+ expect(
+ resolveImportTaskStatus(name, [
+ { slug: "qa-plus", name: "QA+" },
+ { slug: "qa-minus", name: "QA-" },
+ ]),
+ ).toEqual({ status: slug });
+ });
+ it("rejects duplicate exact display names", () => {
+ expect(
+ resolveImportTaskStatus("QA+", [
+ { slug: "qa-plus", name: "QA+" },
+ { slug: "other", name: "QA+" },
+ ]),
+ ).toHaveProperty("error");
+ });
+ it.each(["qa", " QA+ "])(
+ "rejects the ambiguous normalized alias %s",
+ (status) =>
+ expect(
+ resolveImportTaskStatus(status, [
+ { slug: "qa-plus", name: "QA+" },
+ { slug: "qa-minus", name: "QA-" },
+ ]),
+ ).toHaveProperty("error"),
+ );
it("rejects ambiguous display names", () => {
expect(
resolveImportTaskStatus("ready-to-start", [
diff --git a/apps/api/src/task/resolve-import-task-status.ts b/apps/api/src/task/resolve-import-task-status.ts
index b8581620d..48e2a4cc5 100644
--- a/apps/api/src/task/resolve-import-task-status.ts
+++ b/apps/api/src/task/resolve-import-task-status.ts
@@ -12,10 +12,13 @@ export function resolveImportTaskStatus(
// Persisted slugs and virtual statuses take precedence over display names.
if (validStatuses.includes(status)) return { status };
- const alias = toSlug(status);
- const matches = alias
- ? columns.filter((column) => toSlug(column.name) === alias)
- : [];
+ let matches = columns.filter((column) => column.name === status);
+ if (matches.length === 0) {
+ const alias = toSlug(status);
+ matches = alias
+ ? columns.filter((column) => toSlug(column.name) === alias)
+ : [];
+ }
const [match] = matches;
if (matches.length === 1 && match) return { status: match.slug };
if (matches.length > 1) {
diff --git a/tests/api-integration/task-import-column-race.test.ts b/tests/api-integration/task-import-column-race.test.ts
new file mode 100644
index 000000000..ccf086e1a
--- /dev/null
+++ b/tests/api-integration/task-import-column-race.test.ts
@@ -0,0 +1,120 @@
+import { eq, sql } from "drizzle-orm";
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import db, { getDatabasePool, schema } from "../../apps/api/src/database";
+import deleteColumn from "../../apps/api/src/column/controllers/delete-column";
+import importTasks from "../../apps/api/src/task/controllers/import-tasks";
+import { resetTestDatabase } from "./helpers/database";
+import {
+ createProjectFixture,
+ createWorkspaceMember,
+} from "./helpers/fixtures";
+
+const hooks = vi.hoisted(() => ({ beforePosition: vi.fn(), publish: vi.fn() }));
+vi.mock("../../apps/api/src/events", async (original) => ({
+ ...(await original<object>()),
+ publishEvent: hooks.publish,
+}));
+vi.mock(
+ "../../apps/api/src/task/controllers/next-task-position",
+ async (original) => {
+ const actual =
+ await original<
+ typeof import("../../apps/api/src/task/controllers/next-task-position")
+ >();
+ return {
+ ...actual,
+ nextTaskPosition: async (
+ ...args: Parameters<typeof actual.nextTaskPosition>
+ ) => {
+ await hooks.beforePosition();
+ return actual.nextTaskPosition(...args);
+ },
+ };
+ },
+);
+
+beforeEach(async () => {
+ hooks.beforePosition.mockReset();
+ hooks.publish.mockReset();
+ await resetTestDatabase();
+});
+
+async function fixture() {
+ const { user, workspace } = await createWorkspaceMember({ role: "owner" });
+ return {
+ user,
+ ...(await createProjectFixture({ workspaceId: workspace.id })),
+ };
+}
+
+describe("task import column deletion", () => {
+ it("does not reuse a column ID deleted after the import snapshot", async () => {
+ const { user, project, columns } = await fixture();
+ hooks.publish.mockImplementationOnce(async () => {
+ await deleteColumn(columns.done.id);
+ });
+ const result = await importTasks(
+ project.id,
+ [
+ { title: "First", status: "to-do" },
+ { title: "Second", status: "done" },
+ ],
+ user.id,
+ );
+ expect(result.results.successful).toBe(2);
+ expect(result.results.failed).toBe(0);
+ expect(result.results.tasks[1]?.task).toMatchObject({
+ status: "done",
+ columnId: null,
+ });
+ });
+
+ it("keeps a resolved column valid until its task transaction commits", async () => {
+ const { user, project, columns } = await fixture();
+ const client = await getDatabasePool().connect();
+ const {
+ rows: [{ pid }],
+ } = await client.query<{ pid: number }>("SELECT pg_backend_pid() AS pid");
+ let deletion: Promise<unknown> | undefined;
+ try {
+ hooks.beforePosition.mockImplementationOnce(async () => {
+ deletion = client.query('DELETE FROM "column" WHERE id = $1', [
+ columns.done.id,
+ ]);
+ // This independent connection must wait for the import's column lock.
+ await vi.waitFor(
+ async () => {
+ const activity = await db.execute<{
+ wait_event_type: string | null;
+ }>(sql`
+ SELECT wait_event_type FROM pg_stat_activity WHERE pid = ${pid}
+ `);
+ expect(activity.rows[0]?.wait_event_type).toBe("Lock");
+ },
+ { timeout: 2000, interval: 10 },
+ );
+ });
+ const result = await importTasks(
+ project.id,
+ [{ title: "Concurrent", status: "done" }],
+ user.id,
+ );
+ expect(result.results.successful).toBe(1);
+ expect(result.results.failed).toBe(0);
+ await deletion;
+ const stored = await db
+ .select()
+ .from(schema.taskTable)
+ .where(eq(schema.taskTable.projectId, project.id));
+ expect(stored).toHaveLength(1);
+ expect(stored[0]).toMatchObject({
+ title: "Concurrent",
+ status: "done",
+ columnId: null,
+ });
+ } finally {
+ await deletion?.catch(() => {});
+ client.release();
+ }
+ });
+});