⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
import { randomUUID } from "node:crypto";
import { eq, sql } from "drizzle-orm";
import type { WSContext } from "hono/ws";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
import db, { schema } from "../../apps/api/src/database";
import { createApp } from "../../apps/api/src/index";
import createTaskRelation from "../../apps/api/src/task-relation/controllers/create-task-relation";
import { addConnection, removeConnection } from "../../apps/api/src/ws";
import { mockAuthenticatedSession } from "./helpers/auth";
import { resetTestDatabase } from "./helpers/database";
import {
createProjectFixture,
createWorkspaceMember,
} from "./helpers/fixtures";
async function addMember(workspaceId: string, userId: string, role = "member") {
await db.insert(schema.workspaceUserTable).values({
workspaceId,
userId,
role,
joinedAt: new Date(),
});
}
async function createTargetWorkspace() {
const [workspace] = await db
.insert(schema.workspaceTable)
.values({
id: `workspace-${randomUUID()}`,
createdAt: new Date(),
name: "Target Workspace",
slug: `workspace-${randomUUID()}`,
})
.returning();
return workspace;
}
// Activity rows are written by an event subscriber that the request doesn't
// await, so give the emitter a moment to drain before asserting.
async function waitForActivities(taskId: string, timeoutMs = 2000) {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
const rows = await db
.select()
.from(schema.activityTable)
.where(eq(schema.activityTable.taskId, taskId));
if (rows.length > 0) return rows;
await new Promise((resolve) => setTimeout(resolve, 25));
}
return [];
}
function moveRequest(workspaceId: string) {
return {
method: "PUT",
headers: { "content-type": "application/json" },
body: JSON.stringify({ workspaceId }),
};
}
describe("API integration: moving a project between workspaces", () => {
beforeEach(async () => {
await resetTestDatabase();
});
it("rejects a move into a workspace the caller doesn't belong to", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(404);
expect(await response.text()).toContain("Destination workspace not found");
const [unchanged] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(unchanged.workspaceId).toBe(owner.workspace.id);
});
it("rejects a move when the caller can't create projects in the target", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
// `viewer` grants only project:read in the target workspace.
await addMember(target.id, owner.user.id, "viewer");
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(403);
});
it("rejects a move when the caller can't manage target workspace settings", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
// Members can create projects, but cannot bring retained integrations into
// a workspace because they lack workspace:manage_settings.
await addMember(target.id, owner.user.id, "member");
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(403);
const [unchanged] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(unchanged.workspaceId).toBe(owner.workspace.id);
});
it("rejects a move when the target workspace already uses the project's key", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
slug: "kan",
});
// Different case on purpose: short-id lookup matches keys
// case-insensitively, so "KAN" and "kan" collide just the same.
await createProjectFixture({
workspaceId: target.id,
name: "Incumbent",
slug: "KAN",
});
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(409);
expect(await response.text()).toContain("Incumbent");
const [unchanged] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(unchanged.workspaceId).toBe(owner.workspace.id);
});
it("allows a move when only the source workspace uses that key", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
// A same-key project left behind in the source must not block the move —
// only the target workspace's keys matter.
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
slug: "kan",
});
await createProjectFixture({
workspaceId: owner.workspace.id,
name: "Sibling",
slug: "kan",
});
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(200);
const [moved] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(moved.workspaceId).toBe(target.id);
});
it("appends the moved project to the end of the target's ordering", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
// Position 0 in the source, which is already taken in the target: keeping
// it would leave two projects sharing a slot.
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const { project: firstInTarget } = await createProjectFixture({
workspaceId: target.id,
name: "First",
});
const { project: secondInTarget } = await createProjectFixture({
workspaceId: target.id,
name: "Second",
});
await db
.update(schema.projectTable)
.set({ position: 1 })
.where(eq(schema.projectTable.id, secondInTarget.id));
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(200);
const [moved] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(moved.position).toBe(2);
const positions = await db
.select({
id: schema.projectTable.id,
position: schema.projectTable.position,
})
.from(schema.projectTable)
.where(eq(schema.projectTable.workspaceId, target.id));
expect(
[...positions].sort((a, b) => a.position - b.position).map((p) => p.id),
).toEqual([firstInTarget.id, secondInTarget.id, project.id]);
expect(new Set(positions.map((p) => p.position)).size).toBe(3);
});
it("rejects a move out of a workspace where the caller can't delete projects", async () => {
const mover = await createWorkspaceMember({ role: "project-editor" });
const target = await createTargetWorkspace();
// Full rights in the target, so a 403 here can only come from the source.
await addMember(target.id, mover.user.id, "owner");
// A custom role is the only way to hold `update` without `delete`: every
// built-in role that grants one grants the other.
await db.insert(schema.workspaceRoleTable).values({
workspaceId: mover.workspace.id,
role: "project-editor",
permission: JSON.stringify({
project: ["create", "read", "update"],
}),
});
const { project } = await createProjectFixture({
workspaceId: mover.workspace.id,
});
mockAuthenticatedSession(mover.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(403);
const [unchanged] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(unchanged.workspaceId).toBe(mover.workspace.id);
});
it("rejects a move into the workspace the project is already in", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(owner.workspace.id),
);
expect(response.status).toBe(400);
});
it("moves the project and rewrites workspace-scoped side data", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
const { project, columns } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const [task] = await db
.insert(schema.taskTable)
.values({
projectId: project.id,
title: "Ship it",
columnId: columns.todo.id,
number: 1,
userId: owner.user.id,
})
.returning();
const [label] = await db
.insert(schema.labelTable)
.values({
name: "bug",
color: "#ff0000",
taskId: task.id,
workspaceId: owner.workspace.id,
})
.returning();
const [asset] = await db
.insert(schema.assetTable)
.values({
workspaceId: owner.workspace.id,
projectId: project.id,
taskId: task.id,
objectKey: `object-${randomUUID()}`,
filename: "screenshot.png",
mimeType: "image/png",
size: 1234,
})
.returning();
// A notification rule referencing the project through the composite
// (workspaceId, projectId) foreign key. Left in place, the workspace
// update would cascade into it and break the rule-side key.
const [rule] = await db
.insert(schema.userNotificationWorkspaceRuleTable)
.values({
userId: owner.user.id,
workspaceId: owner.workspace.id,
projectMode: "selected",
})
.returning();
await db.insert(schema.userNotificationWorkspaceProjectTable).values({
workspaceId: owner.workspace.id,
workspaceRuleId: rule.id,
projectId: project.id,
});
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(200);
const payload = (await response.json()) as {
workspaceId: string;
unassignedTaskCount: number;
};
expect(payload.workspaceId).toBe(target.id);
expect(payload.unassignedTaskCount).toBe(0);
const [movedProject] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(movedProject.workspaceId).toBe(target.id);
const [movedLabel] = await db
.select()
.from(schema.labelTable)
.where(eq(schema.labelTable.id, label.id));
expect(movedLabel.workspaceId).toBe(target.id);
const [movedAsset] = await db
.select()
.from(schema.assetTable)
.where(eq(schema.assetTable.id, asset.id));
expect(movedAsset.workspaceId).toBe(target.id);
const notificationProjects = await db
.select()
.from(schema.userNotificationWorkspaceProjectTable)
.where(
eq(schema.userNotificationWorkspaceProjectTable.projectId, project.id),
);
expect(notificationProjects).toHaveLength(0);
// The task and its column survive the move.
const [movedTask] = await db
.select()
.from(schema.taskTable)
.where(eq(schema.taskTable.id, task.id));
expect(movedTask.columnId).toBe(columns.todo.id);
const sourceListing = await app.request(
`/api/project?workspaceId=${owner.workspace.id}`,
);
expect(sourceListing.status).toBe(200);
const sourceProjects = (await sourceListing.json()) as { id: string }[];
expect(sourceProjects.map((item) => item.id)).not.toContain(project.id);
});
it("unassigns tasks whose assignee isn't a member of the target workspace", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const outsider = await createWorkspaceMember({ role: "member" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
// `outsider.user` is deliberately never added to the target workspace.
await addMember(owner.workspace.id, outsider.user.id, "member");
const { project, columns } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const [keptTask] = await db
.insert(schema.taskTable)
.values({
projectId: project.id,
title: "Stays assigned",
columnId: columns.todo.id,
number: 1,
userId: owner.user.id,
})
.returning();
const [droppedTask] = await db
.insert(schema.taskTable)
.values({
projectId: project.id,
title: "Loses its assignee",
columnId: columns.todo.id,
number: 2,
userId: outsider.user.id,
})
.returning();
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(200);
const payload = (await response.json()) as { unassignedTaskCount: number };
expect(payload.unassignedTaskCount).toBe(1);
const [kept] = await db
.select()
.from(schema.taskTable)
.where(eq(schema.taskTable.id, keptTask.id));
expect(kept.userId).toBe(owner.user.id);
const [dropped] = await db
.select()
.from(schema.taskTable)
.where(eq(schema.taskTable.id, droppedTask.id));
expect(dropped.userId).toBeNull();
// Losing an assignee has to land on the task's timeline, the same way a
// manual or bulk unassignment does — otherwise there's no record of which
// tasks a move touched.
const activities = await waitForActivities(droppedTask.id);
expect(activities).toHaveLength(1);
expect(activities[0].type).toBe("unassigned");
expect(activities[0].userId).toBe(owner.user.id);
const keptActivities = await db
.select()
.from(schema.activityTable)
.where(eq(schema.activityTable.taskId, keptTask.id));
expect(keptActivities).toHaveLength(0);
});
// The unassignment is predicated on the target's member set rather than a
// list of task ids, so an empty member set drops that term entirely — the
// remaining predicate still has to stay scoped to this project.
it("unassigns every task when no assignee is a member of the target", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const outsider = await createWorkspaceMember({ role: "member" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
await addMember(owner.workspace.id, outsider.user.id, "member");
const { project, columns } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const other = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const [movedTask] = await db
.insert(schema.taskTable)
.values({
projectId: project.id,
title: "Loses its assignee",
columnId: columns.todo.id,
number: 1,
userId: outsider.user.id,
})
.returning();
const [untouchedTask] = await db
.insert(schema.taskTable)
.values({
projectId: other.project.id,
title: "Belongs to another project",
columnId: other.columns.todo.id,
number: 1,
userId: outsider.user.id,
})
.returning();
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(200);
const payload = (await response.json()) as { unassignedTaskCount: number };
expect(payload.unassignedTaskCount).toBe(1);
const [moved] = await db
.select()
.from(schema.taskTable)
.where(eq(schema.taskTable.id, movedTask.id));
expect(moved.userId).toBeNull();
const [untouched] = await db
.select()
.from(schema.taskTable)
.where(eq(schema.taskTable.id, untouchedTask.id));
expect(untouched.userId).toBe(outsider.user.id);
});
});
describe("project move task relationships", () => {
beforeEach(resetTestDatabase);
it.each(["incoming", "outgoing", "internal"])(
"protects %s relationships",
async (direction) => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const { project: other } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const tasks = await db
.insert(schema.taskTable)
.values([
{ title: "Moving", projectId: project.id, number: 1 },
{
title: "Related",
projectId: direction === "internal" ? project.id : other.id,
number: 2,
},
])
.returning();
const [relation] = await db
.insert(schema.taskRelationTable)
.values({
sourceTaskId: tasks[direction === "incoming" ? 1 : 0].id,
targetTaskId: tasks[direction === "incoming" ? 0 : 1].id,
relationType: "blocks",
})
.returning();
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(direction === "internal" ? 200 : 409);
const [after] = await db
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(after.workspaceId).toBe(
direction === "internal" ? target.id : owner.workspace.id,
);
expect(
await db
.select()
.from(schema.taskRelationTable)
.where(eq(schema.taskRelationTable.id, relation.id)),
).toHaveLength(1);
},
);
});
describe("project move concurrency and realtime access", () => {
beforeEach(resetTestDatabase);
it("closes old project sockets even when there are no tasks to unassign", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
await addMember(target.id, owner.user.id, "owner");
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const socket = { send: vi.fn(), close: vi.fn() };
const conn = addConnection(
project.id,
socket as unknown as WSContext,
owner.user.id,
"window",
owner.workspace.id,
);
try {
mockAuthenticatedSession(owner.user);
const { app } = createApp();
const response = await app.request(
`/api/project/${project.id}/move`,
moveRequest(target.id),
);
expect(response.status).toBe(200);
expect(socket.close).toHaveBeenCalledWith(
1008,
"Project workspace changed",
);
expect(socket.send).toHaveBeenCalledWith(
JSON.stringify({ type: "PROJECT_MOVED", projectId: project.id }),
);
} finally {
removeConnection(project.id, conn);
}
});
it("relation creation waits for a moving project and rechecks the workspace", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const target = await createTargetWorkspace();
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const { project: other } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
const tasks = await db
.insert(schema.taskTable)
.values([
{ title: "Moving", projectId: project.id, number: 1 },
{ title: "Staying", projectId: other.id, number: 1 },
])
.returning();
let locked!: () => void;
let release!: () => void;
const ready = new Promise<void>((resolve) => {
locked = resolve;
});
const gate = new Promise<void>((resolve) => {
release = resolve;
});
const move = db.transaction(async (tx) => {
await tx
.select()
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id))
.for("update");
locked();
await gate;
await tx
.update(schema.projectTable)
.set({ workspaceId: target.id })
.where(eq(schema.projectTable.id, project.id));
});
await ready;
const relation = createTaskRelation({
sourceTaskId: tasks[0].id,
targetTaskId: tasks[1].id,
relationType: "blocks",
userId: owner.user.id,
workspaceId: owner.workspace.id,
}).then(
() => null,
(error: unknown) => error,
);
try {
await vi.waitFor(async () => {
const waiting = await db.execute(
sql`SELECT 1 FROM pg_stat_activity WHERE datname = current_database() AND wait_event_type = 'Lock' AND query LIKE '%for share%'`,
);
expect(waiting.rows.length).toBeGreaterThan(0);
});
} finally {
release();
}
await move;
expect(await relation).toMatchObject({ status: 404 });
expect(await db.select().from(schema.taskRelationTable)).toHaveLength(0);
});
});