⚡ 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 { and, eq, ne, sql } from "drizzle-orm";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
import db, { schema } from "../../apps/api/src/database";
import { subscribeToEvent } from "../../apps/api/src/events";
import { createApp } from "../../apps/api/src/index";
import { createNextOccurrence } from "../../apps/api/src/task/recurrence/create-next-occurrence";
import { mockAuthenticatedSession } from "./helpers/auth";
import { resetTestDatabase } from "./helpers/database";
import {
createProjectFixture,
createWorkspaceMember,
} from "./helpers/fixtures";
import { createRestrictedWorkspace } from "./helpers/project-access/create-restricted-workspace";
const weekly = { frequency: "weekly", interval: 1, timeZone: "UTC" } as const;
async function seedProject() {
const member = await createWorkspaceMember();
const { project, columns } = await createProjectFixture({
workspaceId: member.workspace.id,
});
mockAuthenticatedSession(member.user);
return { member, project, columns, app: createApp().app };
}
async function seedTask(
projectId: string,
columnId: string,
overrides: Partial<typeof schema.taskTable.$inferInsert> = {},
) {
const [project] = await db
.update(schema.projectTable)
.set({ lastTaskNumber: 1 })
.where(eq(schema.projectTable.id, projectId))
.returning();
const [task] = await db
.insert(schema.taskTable)
.values({
projectId,
columnId,
title: "Send the weekly report",
status: "to-do",
priority: "high",
number: project?.lastTaskNumber ?? 1,
position: 1,
startDate: new Date("2026-03-09T00:00:00.000Z"),
dueDate: new Date("2026-03-10T00:00:00.000Z"),
recurrence: weekly,
...overrides,
})
.returning();
if (!task) throw new Error("Failed to seed task");
return task;
}
function request(
app: Awaited<ReturnType<typeof seedProject>>["app"],
method: string,
path: string,
body: unknown,
) {
return app.request(path, {
method,
headers: { "content-type": "application/json" },
body: JSON.stringify(body),
});
}
function otherTasks(projectId: string, taskId: string) {
return db.query.taskTable.findMany({
where: and(
eq(schema.taskTable.projectId, projectId),
ne(schema.taskTable.id, taskId),
),
});
}
async function waitForNextOccurrence(projectId: string, taskId: string) {
return vi.waitFor(async () => {
const [next] = await otherTasks(projectId, taskId);
if (!next) throw new Error("No next occurrence yet");
return next;
});
}
describe("API integration: recurring tasks", () => {
beforeEach(async () => {
await resetTestDatabase();
});
it("sets and clears a task's recurrence rule", async () => {
const { project, columns, app } = await seedProject();
const task = await seedTask(project.id, columns.todo.id, {
recurrence: null,
});
const set = await request(app, "PUT", `/api/task/recurrence/${task.id}`, {
recurrence: {
frequency: "monthly",
interval: 3,
timeZone: "Europe/Madrid",
},
});
expect(set.status).toBe(200);
await expect(set.json()).resolves.toMatchObject({
recurrence: {
frequency: "monthly",
interval: 3,
timeZone: "Europe/Madrid",
},
});
const cleared = await request(
app,
"PUT",
`/api/task/recurrence/${task.id}`,
{ recurrence: null },
);
expect(cleared.status).toBe(200);
const stored = await db.query.taskTable.findFirst({
where: eq(schema.taskTable.id, task.id),
});
expect(stored?.recurrence).toBeNull();
});
it("rejects a member without task update permission", async () => {
const viewer = await createWorkspaceMember({ role: "viewer" });
const { project, columns } = await createProjectFixture({
workspaceId: viewer.workspace.id,
});
mockAuthenticatedSession(viewer.user);
const task = await seedTask(project.id, columns.todo.id, {
recurrence: null,
});
const response = await request(
createApp().app,
"PUT",
`/api/task/recurrence/${task.id}`,
{ recurrence: weekly },
);
expect(response.status).toBe(403);
const stored = await db.query.taskTable.findFirst({
where: eq(schema.taskTable.id, task.id),
});
expect(stored?.recurrence).toBeNull();
});
it("creates a task that already repeats", async () => {
const { project, app } = await seedProject();
const recurrence = { ...weekly, weekdays: [1, 4] };
const created = await request(app, "POST", `/api/task/${project.id}`, {
title: "Water the plants",
description: "",
priority: "no-priority",
status: "to-do",
dueDate: "2026-03-10T00:00:00.000Z",
recurrence,
});
expect(created.status).toBe(200);
const task = await created.json();
expect(task).toMatchObject({ recurrence });
const stored = await db.query.taskTable.findFirst({
where: eq(schema.taskTable.id, task.id),
});
expect(stored?.recurrence).toEqual(recurrence);
const invalid = await request(app, "POST", `/api/task/${project.id}`, {
title: "Water the plants",
description: "",
priority: "no-priority",
status: "to-do",
recurrence: { ...weekly, frequency: "daily", weekdays: [1] },
});
expect(invalid.status).toBe(400);
});
it("rejects invalid recurrence rules", async () => {
const { project, columns, app } = await seedProject();
const task = await seedTask(project.id, columns.todo.id);
for (const recurrence of [
{ ...weekly, interval: 0 },
{ ...weekly, interval: 1.5 },
{ ...weekly, frequency: "hourly" },
{ ...weekly, timeZone: "Mars/Olympus" },
{ ...weekly, weekdays: [] },
{ ...weekly, weekdays: [1, 1] },
{ ...weekly, weekdays: [7] },
{ ...weekly, frequency: "daily", weekdays: [1] },
]) {
const response = await request(
app,
"PUT",
`/api/task/recurrence/${task.id}`,
{ recurrence },
);
expect(response.status).toBe(400);
}
});
it("creates the next occurrence when the task is completed", async () => {
const { member, project, columns, app } = await seedProject();
const task = await seedTask(project.id, columns.inReview.id, {
status: "in-review",
userId: member.user.id,
});
await db.insert(schema.labelTable).values({
name: "reports",
color: "#22c55e",
workspaceId: member.workspace.id,
taskId: task.id,
});
const [field] = await db
.insert(schema.customFieldDefinitionTable)
.values({ projectId: project.id, name: "Audience", type: "text" })
.returning();
if (!field) throw new Error("Failed to seed custom field");
await db
.insert(schema.customFieldValueTable)
.values({ taskId: task.id, fieldId: field.id, value: "Board" });
const response = await request(app, "PUT", `/api/task/status/${task.id}`, {
status: "done",
});
expect(response.status).toBe(200);
const next = await waitForNextOccurrence(project.id, task.id);
expect(next).toMatchObject({
title: task.title,
status: "to-do",
columnId: columns.todo.id,
priority: "high",
userId: member.user.id,
number: 2,
startDate: new Date("2026-03-16T00:00:00.000Z"),
dueDate: new Date("2026-03-17T00:00:00.000Z"),
recurrence: weekly,
});
const completed = await db.query.taskTable.findFirst({
where: eq(schema.taskTable.id, task.id),
});
expect(completed).toMatchObject({ status: "done", recurrence: null });
const labels = await db.query.labelTable.findMany({
where: eq(schema.labelTable.taskId, next.id),
});
expect(labels.map((label) => label.name)).toEqual(["reports"]);
const values = await db.query.customFieldValueTable.findMany({
where: eq(schema.customFieldValueTable.taskId, next.id),
});
expect(values.map((value) => value.value)).toEqual(["Board"]);
});
it("creates the next occurrence when a task is dragged or bulk-completed", async () => {
const { project, columns, app } = await seedProject();
const dragged = await seedTask(project.id, columns.todo.id);
const reorder = await request(app, "POST", "/api/task/reorder", {
projectId: project.id,
tasks: [{ id: dragged.id, position: 0, status: "done" }],
});
expect(reorder.status).toBe(200);
const afterDrag = await waitForNextOccurrence(project.id, dragged.id);
const bulk = await request(app, "PATCH", "/api/task/bulk", {
taskIds: [afterDrag.id],
operation: "updateStatus",
value: "done",
});
expect(bulk.status).toBe(200);
await vi.waitFor(async () => {
const tasks = await db.query.taskTable.findMany({
where: eq(schema.taskTable.projectId, project.id),
});
expect(tasks).toHaveLength(3);
});
const open = await db.query.taskTable.findMany({
where: and(
eq(schema.taskTable.projectId, project.id),
eq(schema.taskTable.status, "to-do"),
),
});
expect(open).toHaveLength(1);
expect(open[0]?.dueDate).toEqual(new Date("2026-03-24T00:00:00.000Z"));
});
it("creates one next occurrence per completion", async () => {
const { project, columns } = await seedProject();
const task = await seedTask(project.id, columns.done.id, {
status: "done",
});
const results = await Promise.all([
createNextOccurrence(task.id, null),
createNextOccurrence(task.id, null),
]);
expect(results.filter(Boolean)).toHaveLength(1);
expect(await otherTasks(project.id, task.id)).toHaveLength(1);
// The losing claim rolls back, so it does not use up a task number.
const [counter] = await db
.select({ lastTaskNumber: schema.projectTable.lastTaskNumber })
.from(schema.projectTable)
.where(eq(schema.projectTable.id, project.id));
expect(counter?.lastTaskNumber).toBe(2);
// Reopening and completing the old task again does not repeat it twice.
await db
.update(schema.taskTable)
.set({ status: "to-do", columnId: columns.todo.id })
.where(eq(schema.taskTable.id, task.id));
await db
.update(schema.taskTable)
.set({ status: "done", columnId: columns.done.id })
.where(eq(schema.taskTable.id, task.id));
await expect(createNextOccurrence(task.id, null)).resolves.toBeNull();
expect(await otherTasks(project.id, task.id)).toHaveLength(1);
});
it("dates the next occurrence from the rule it claims", async () => {
const { project, columns } = await seedProject();
const task = await seedTask(project.id, columns.done.id, {
status: "done",
});
const daily = { ...weekly, frequency: "daily" } as const;
// An edit holds the row while the occurrence reads the old rule and waits
// for the lock.
let commitEdit = () => {};
const editCommitted = new Promise<void>((resolve) => {
commitEdit = resolve;
});
let editLocked = () => {};
const locked = new Promise<void>((resolve) => {
editLocked = resolve;
});
const edit = db.transaction(async (tx) => {
await tx
.update(schema.taskTable)
.set({ recurrence: daily })
.where(eq(schema.taskTable.id, task.id));
editLocked();
await editCommitted;
});
await locked;
const occurrence = createNextOccurrence(task.id, null);
await vi.waitFor(async () => {
const { rows } = await db.execute(
sql`select 1 from pg_stat_activity where wait_event_type = 'Lock'`,
);
if (!rows.length) throw new Error("The claim is not waiting yet");
});
commitEdit();
await edit;
await expect(occurrence).resolves.toMatchObject({
startDate: new Date("2026-03-10T00:00:00.000Z"),
dueDate: new Date("2026-03-11T00:00:00.000Z"),
recurrence: daily,
});
});
it("only lets a completed task edit the rule it still holds", async () => {
const { project, columns, app } = await seedProject();
const task = await seedTask(project.id, columns.done.id, {
status: "done",
});
const monthly = { ...weekly, frequency: "monthly" } as const;
const setRule = (recurrence: unknown) =>
request(app, "PUT", `/api/task/recurrence/${task.id}`, { recurrence });
// The rule has not moved yet, so the next task will take the edit.
expect((await setRule(monthly)).status).toBe(200);
// Another request claims the rule while this edit waits for the row.
let commitClaim = () => {};
const claimCommitted = new Promise<void>((resolve) => {
commitClaim = resolve;
});
let claimLocked = () => {};
const locked = new Promise<void>((resolve) => {
claimLocked = resolve;
});
const claim = db.transaction(async (tx) => {
await tx
.update(schema.taskTable)
.set({ recurrence: null })
.where(eq(schema.taskTable.id, task.id));
claimLocked();
await claimCommitted;
});
await locked;
const edit = setRule(weekly);
await vi.waitFor(async () => {
const { rows } = await db.execute(
sql`select 1 from pg_stat_activity where wait_event_type = 'Lock'`,
);
if (!rows.length) throw new Error("The edit is not waiting yet");
});
commitClaim();
await claim;
expect((await edit).status).toBe(409);
expect((await setRule(null)).status).toBe(200);
const stored = await db.query.taskTable.findFirst({
where: eq(schema.taskTable.id, task.id),
});
expect(stored?.recurrence).toBeNull();
});
it("does not create a task in a final column that repeats", async () => {
const { project, app } = await seedProject();
const created = await request(app, "POST", `/api/task/${project.id}`, {
title: "Water the plants",
description: "",
priority: "no-priority",
status: "done",
recurrence: weekly,
});
expect(created.status).toBe(400);
expect(
await db.query.taskTable.findMany({
where: eq(schema.taskTable.projectId, project.id),
}),
).toHaveLength(0);
});
it("keeps repeating when a required field has no value", async () => {
const { project, columns } = await seedProject();
const task = await seedTask(project.id, columns.done.id, {
status: "done",
});
// Added after the task, without a default to fill it.
await db.insert(schema.customFieldDefinitionTable).values({
projectId: project.id,
name: "Audience",
type: "text",
required: true,
});
const next = await createNextOccurrence(task.id, null);
expect(next).toMatchObject({
status: "to-do",
dueDate: new Date("2026-03-17T00:00:00.000Z"),
recurrence: weekly,
});
});
it("tells clients that the completed task no longer repeats", async () => {
const { project, columns } = await seedProject();
const task = await seedTask(project.id, columns.done.id, {
status: "done",
});
const updated: string[] = [];
await subscribeToEvent<{ taskId: string }>("task.updated", async (data) => {
updated.push(data.taskId);
});
const next = await createNextOccurrence(task.id, null);
expect(next).not.toBeNull();
expect(updated).toContain(task.id);
});
it("leaves the next occurrence unassigned when the assignee has left", async () => {
const { project, columns } = await seedProject();
const departed = await createWorkspaceMember();
const task = await seedTask(project.id, columns.done.id, {
status: "done",
userId: departed.user.id,
});
const next = await createNextOccurrence(task.id, null);
expect(next).toMatchObject({ userId: null, recurrence: weekly });
});
it("ignores tasks that are not completed or do not repeat", async () => {
const { project, columns } = await seedProject();
const open = await seedTask(project.id, columns.inProgress.id, {
status: "in-progress",
});
await expect(createNextOccurrence(open.id, null)).resolves.toBeNull();
const plain = await seedTask(project.id, columns.done.id, {
status: "done",
recurrence: null,
number: 2,
});
await expect(createNextOccurrence(plain.id, null)).resolves.toBeNull();
expect(
await db.query.taskTable.findMany({
where: eq(schema.taskTable.projectId, project.id),
}),
).toHaveLength(2);
});
it("repeats from the completion date when the task has no due date", async () => {
const { project, columns } = await seedProject();
const task = await seedTask(project.id, columns.done.id, {
status: "done",
dueDate: null,
});
const before = Date.now();
const next = await createNextOccurrence(task.id, null);
expect(next?.startDate).toBeNull();
const due = next?.dueDate?.getTime() ?? 0;
expect(due).toBeGreaterThanOrEqual(before + 7 * 24 * 60 * 60 * 1000);
expect(due).toBeLessThanOrEqual(Date.now() + 7 * 24 * 60 * 60 * 1000);
});
it("repeats on the selected weekdays", async () => {
const { project, columns, app } = await seedProject();
// Due Tuesday 2026-03-10, repeating on Tuesdays and Thursdays.
const task = await seedTask(project.id, columns.todo.id);
const rule = { ...weekly, weekdays: [2, 4] };
const set = await request(app, "PUT", `/api/task/recurrence/${task.id}`, {
recurrence: rule,
});
expect(set.status).toBe(200);
await request(app, "PUT", `/api/task/status/${task.id}`, {
status: "done",
});
const next = await waitForNextOccurrence(project.id, task.id);
expect(next).toMatchObject({
startDate: new Date("2026-03-11T00:00:00.000Z"),
dueDate: new Date("2026-03-12T00:00:00.000Z"),
recurrence: rule,
});
});
it("keeps a parent link the completing member cannot see", async () => {
const { restricted, alpha, alphaTask, betaTask } =
await createRestrictedWorkspace();
if (!alphaTask || !betaTask) throw new Error("Failed to seed tasks");
const done = await db.query.columnTable.findFirst({
where: and(
eq(schema.columnTable.projectId, alpha.id),
eq(schema.columnTable.isFinal, true),
),
});
if (!done) throw new Error("Missing final column");
await db.insert(schema.taskRelationTable).values({
sourceTaskId: betaTask.id,
targetTaskId: alphaTask.id,
relationType: "subtask",
});
await db
.update(schema.taskTable)
.set({ status: done.slug, columnId: done.id, recurrence: weekly })
.where(eq(schema.taskTable.id, alphaTask.id));
const next = await createNextOccurrence(alphaTask.id, restricted.id);
expect(next).not.toBeNull();
const links = await db.query.taskRelationTable.findMany({
where: eq(schema.taskRelationTable.targetTaskId, next?.id ?? ""),
});
expect(links).toMatchObject([
{ sourceTaskId: betaTask.id, relationType: "subtask" },
]);
});
});