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.

18.7 KB
Raw Blame
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" },
    ]);
  });
});