⚡ 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 { createHash, randomUUID } from "node:crypto";
import { beforeEach, describe, expect, it } from "vite-plus/test";
import db, { schema } from "../../apps/api/src/database";
import { createApp } from "../../apps/api/src/index";
import { mockAnonymousSession, mockAuthenticatedSession } from "./helpers/auth";
import { resetTestDatabase } from "./helpers/database";
import {
createProjectFixture,
createWorkspaceMember,
} from "./helpers/fixtures";
type RelationRow = typeof schema.taskRelationTable.$inferSelect;
let taskCounter = 0;
async function seedTask(
userId: string,
projectId: string,
title: string,
status = "to-do",
) {
taskCounter += 1;
const [task] = await db
.insert(schema.taskTable)
.values({
projectId,
userId,
title,
status,
priority: "medium",
number: taskCounter,
position: taskCounter,
})
.returning();
return task;
}
async function relate(
sourceTaskId: string,
targetTaskId: string,
relationType = "subtask",
) {
const [relation] = await db
.insert(schema.taskRelationTable)
.values({ sourceTaskId, targetTaskId, relationType })
.returning();
return relation;
}
async function fetchProjectRelations(projectId: string) {
const { app } = createApp();
return app.request(`/api/task-relation/project/${projectId}`);
}
describe("API integration: project task relations", () => {
beforeEach(async () => {
await resetTestDatabase();
taskCounter = 0;
});
it("returns the relations joining two tasks in the project", async () => {
const member = await createWorkspaceMember({ role: "owner" });
mockAuthenticatedSession(member.user);
const { project } = await createProjectFixture({
workspaceId: member.workspace.id,
});
const parent = await seedTask(member.user.id, project.id, "Parent");
const child = await seedTask(member.user.id, project.id, "Child");
const blocker = await seedTask(member.user.id, project.id, "Blocker");
const subtask = await relate(parent.id, child.id, "subtask");
const blocks = await relate(blocker.id, parent.id, "blocks");
const response = await fetchProjectRelations(project.id);
expect(response.status).toBe(200);
const payload = (await response.json()) as RelationRow[];
// Every type is returned; narrowing to subtasks is the caller's business.
expect(payload.map((relation) => relation.id).sort()).toEqual(
[subtask.id, blocks.id].sort(),
);
expect(
payload.find((relation) => relation.id === subtask.id),
).toMatchObject({
sourceTaskId: parent.id,
targetTaskId: child.id,
relationType: "subtask",
});
});
it("omits a relation whose other end is in a different project", async () => {
const member = await createWorkspaceMember({ role: "owner" });
mockAuthenticatedSession(member.user);
const { project } = await createProjectFixture({
workspaceId: member.workspace.id,
});
const other = await createProjectFixture({
workspaceId: member.workspace.id,
slug: "other-project",
});
const parent = await seedTask(member.user.id, project.id, "Parent");
const inside = await seedTask(member.user.id, project.id, "Inside");
const outside = await seedTask(member.user.id, other.project.id, "Outside");
const kept = await relate(parent.id, inside.id);
// Both directions: the endpoint requires each end to be in the project,
// so an outward and an inward edge exercise a different check each.
await relate(parent.id, outside.id);
await relate(outside.id, parent.id);
const response = await fetchProjectRelations(project.id);
const payload = (await response.json()) as RelationRow[];
expect(payload.map((relation) => relation.id)).toEqual([kept.id]);
});
it("returns an empty list for a project with no relations", async () => {
const member = await createWorkspaceMember({ role: "owner" });
mockAuthenticatedSession(member.user);
const { project } = await createProjectFixture({
workspaceId: member.workspace.id,
});
const response = await fetchProjectRelations(project.id);
expect(response.status).toBe(200);
await expect(response.json()).resolves.toEqual([]);
});
it("refuses a member whose role does not grant task:read", async () => {
const member = await createWorkspaceMember({ role: "viewer" });
const { project } = await createProjectFixture({
workspaceId: member.workspace.id,
});
await seedTask(member.user.id, project.id, "Parent");
// A workspace can redefine its roles, and the stored definition wins over
// the compiled-in one. This is the shape an API key restricted below
// task:read also takes.
await db.insert(schema.workspaceRoleTable).values({
workspaceId: member.workspace.id,
role: "viewer",
permission: JSON.stringify({ project: ["read"], workspace: ["read"] }),
});
mockAuthenticatedSession(member.user);
const response = await fetchProjectRelations(project.id);
expect(response.status).toBe(403);
});
it("allows a viewer, whose built-in role grants task:read", async () => {
const member = await createWorkspaceMember({ role: "viewer" });
mockAuthenticatedSession(member.user);
const { project } = await createProjectFixture({
workspaceId: member.workspace.id,
});
const parent = await seedTask(member.user.id, project.id, "Parent");
const child = await seedTask(member.user.id, project.id, "Child");
const relation = await relate(parent.id, child.id);
const response = await fetchProjectRelations(project.id);
expect(response.status).toBe(200);
const payload = (await response.json()) as RelationRow[];
expect(payload.map((row) => row.id)).toEqual([relation.id]);
});
it.each([false, true])(
"requires task:read on API keys (granted: %s)",
async (canReadTasks) => {
const member = await createWorkspaceMember({ role: "owner" });
const { project } = await createProjectFixture({
workspaceId: member.workspace.id,
});
const parent = await seedTask(member.user.id, project.id, "Parent");
const child = await seedTask(member.user.id, project.id, "Child");
const relation = await relate(parent.id, child.id);
mockAnonymousSession();
const key = `kaneo_test_${randomUUID()}`;
await db.insert(schema.apikeyTable).values({
referenceId: member.user.id,
userId: member.user.id,
key: createHash("sha256").update(key).digest("base64url"),
name: "project relations key",
createdAt: new Date(),
updatedAt: new Date(),
permissions: JSON.stringify({
project: ["read"],
...(canReadTasks ? { task: ["read"] } : {}),
}),
enabled: true,
});
const { app } = createApp();
const response = await app.request(
`/api/task-relation/project/${project.id}`,
{
headers: { Authorization: `Bearer ${key}` },
},
);
expect(response.status).toBe(canReadTasks ? 200 : 403);
if (canReadTasks) {
expect(await response.json()).toEqual([
expect.objectContaining({ id: relation.id }),
]);
}
},
);
it("refuses a caller outside the project's workspace", async () => {
const owner = await createWorkspaceMember({ role: "owner" });
const { project } = await createProjectFixture({
workspaceId: owner.workspace.id,
});
await seedTask(owner.user.id, project.id, "Parent");
const outsider = await createWorkspaceMember({ role: "owner" });
mockAuthenticatedSession(outsider.user);
const response = await fetchProjectRelations(project.id);
// Outside the workspace, the project is reported as not found.
expect(response.status).toBe(404);
});
});