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(tasks): preserve mutation scope and batch bulk effects

Tin8f2edce3fcd3
diff --cc apps/api/src/task/controllers/bulk-update-tasks.ts
index 45bb38688,3f827b30c..7d7701b7e
--- a/apps/api/src/task/controllers/bulk-update-tasks.ts
+++ b/apps/api/src/task/controllers/bulk-update-tasks.ts
@@@ -6,6 -6,7 +6,8 @@@ import
labelTable,
projectTable,
taskTable,
+ userTable,
++ taskReminderSentTable,
workspaceUserTable,
} from "../../database/schema";
import { publishEvent } from "../../events";
@@@ -13,10 -14,6 +15,7 @@@ import { removeLabelFromGitea } from ".
import { removeLabelFromGitHub } from "../../plugins/github/utils/sync-label-to-github";
import { removeLabelFromGitlab } from "../../plugins/gitlab/utils/sync-label-to-gitlab";
import { assertAssignableUser } from "../../utils/assert-assignable-user";
- import {
- publishTaskMutation,
- recordTaskMutation,
- } from "./task-mutation-effects";
++import { publishTaskMutation } from "./task-mutation-effects";
import { getSubtaskParentProjects } from "../get-subtask-parent-projects";
import {
assertValidPriority,
@@@ -155,11 -168,21 +170,22 @@@ async function bulkUpdateTasks(
projects: parentProjects,
});
for (const updatedTask of updatedTasks) {
- const before = tasks.find((task) => task.id === updatedTask.id)!;
+ const before = beforeById.get(updatedTask.id)!;
- await publishEvent("task.status_changed", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId,
- oldStatus: before.status,
- newStatus: updatedTask.status,
- title: updatedTask.title,
- assigneeId: updatedTask.userId,
- type: "status_changed",
+ await publishTaskMutation(before, updatedTask, userId, {
++ fields: ["status"],
++ skipRelationRefresh: true,
++
skipSubtaskParentRefresh: true,
});
++ if (before.status === updatedTask.status)
++ await publishEvent("task.updated", {
++ taskId: updatedTask.id,
++ projectId: updatedTask.projectId,
++ userId,
++ });
}
+ for (const projectId of projectIds)
+ await publishEvent("task-relation.refresh", { projectId, userId });
break;
}
@@@ -176,16 -199,17 +202,17 @@@
updatedCount = result.rowCount ?? foundIds.length;
- for (const task of tasks) {
- await publishEvent("task.priority_changed", {
- taskId: task.id,
- projectId: task.projectId,
+ for (const task of tasks)
+ await publishTaskMutation(
+ task,
+ {
+ ...task,
+ description: null,
+ priority: value,
+ },
userId,
- oldPriority: task.priority,
- newPriority: value,
- title: task.title,
- type: "priority_changed",
- });
- }
++ { fields: ["priority"] },
+ );
break;
}
@@@ -196,21 -220,38 +223,28 @@@
await assertAssignableUser(assigneeId, workspaceId);
}
- const newAssigneeName = assigneeId
- ? (
- await db
- .select({ name: userTable.name })
- .from(userTable)
- .where(eq(userTable.id, assigneeId))
- .limit(1)
- )[0]?.name
++ const assignee = assigneeId
++ ? await db.query.userTable.findFirst({
++ columns: { name: true },
++ where: eq(userTable.id, assigneeId),
++ })
+ : undefined;
-
const result = await db
.update(taskTable)
.set({ userId: assigneeId })
.where(inArray(taskTable.id, foundIds));
-
updatedCount = result.rowCount ?? foundIds.length;
-
- for (const task of tasks) {
- const eventType = assigneeId
- ? "task.assignee_changed"
- : "task.unassigned";
- await publishEvent(eventType, {
- taskId: task.id,
- projectId: task.projectId,
+ for (const task of tasks)
+ await publishTaskMutation(
+ task,
+ {
+ ...task,
+ description: null,
+ userId: assigneeId,
+ },
userId,
- oldAssignee: task.userId,
- newAssignee: newAssigneeName,
- newAssigneeId: assigneeId,
- title: task.title,
- type: assigneeId ? "assignee_changed" : "unassigned",
- });
- }
++ { fields: ["userId"], assigneeName: assignee?.name ?? null },
+ );
break;
}
@@@ -360,26 -401,24 +394,41 @@@
}
}
- const updatedTasks = await db.transaction(async (tx) => {
- const changed = await tx
- const result = await db
- .update(taskTable)
- .set({ dueDate: parsedDate })
- .where(inArray(taskTable.id, foundIds));
-
- updatedCount = result.rowCount ?? foundIds.length;
-
- for (const task of tasks) {
- await publishEvent("task.due_date_changed", {
- taskId: task.id,
- projectId: task.projectId,
++ const { updatedTasks, beforeById } = await db.transaction(async (tx) => {
++ const before = await tx
++ .select({ id: taskTable.id, dueDate: taskTable.dueDate })
++ .from(taskTable)
++ .where(inArray(taskTable.id, foundIds))
++ .orderBy(asc(taskTable.id))
++ .for("update");
++ const beforeById = new Map(before.map((task) => [task.id, task]));
++ const changedIds = before
++ .filter((task) => task.dueDate?.getTime() !== parsedDate?.getTime())
++ .map((task) => task.id);
++ if (changedIds.length)
++ await tx
++ .delete(taskReminderSentTable)
++ .where(inArray(taskReminderSentTable.taskId, changedIds));
++ const updatedTasks = await tx
+ .update(taskTable)
+ .set({ dueDate: parsedDate })
+ .where(inArray(taskTable.id, foundIds))
+ .returning({
- ...getTableColumns(taskTable),
- description: sql<null>`null`,
++ id: taskTable.id,
++ projectId: taskTable.projectId,
++ title: taskTable.title,
++ dueDate: taskTable.dueDate,
+ });
- for (const task of tasks)
- await recordTaskMutation(tx, task, { dueDate: parsedDate }, userId);
- return changed;
++ return { updatedTasks, beforeById };
+ });
+ updatedCount = updatedTasks.length;
+ for (const updatedTask of updatedTasks)
+ await publishTaskMutation(
- tasks.find((task) => task.id === updatedTask.id)!,
++ beforeById.get(updatedTask.id)!,
+ updatedTask,
userId,
- oldDueDate: task.dueDate,
- newDueDate: parsedDate,
- title: task.title,
- type: "due_date_changed",
- });
- }
++ { fields: ["dueDate"] },
+ );
break;
}
diff --cc apps/api/src/task/controllers/task-mutation-effects.ts
index e8da5d963,000000000..46c7d5d98
mode 100644,000000..100644
--- a/apps/api/src/task/controllers/task-mutation-effects.ts
+++ b/apps/api/src/task/controllers/task-mutation-effects.ts
@@@ -1,160 -1,0 +1,178 @@@
+import { eq } from "drizzle-orm";
+import db from "../../database";
+import {
+ activityTable,
+ taskReminderSentTable,
+ taskTable,
+ userTable,
+} from "../../database/schema";
+import { publishEvent } from "../../events";
+import createNotification from "../../notification/controllers/create-notification";
+import { deleteOrphanedAssets } from "../../storage/cleanup-assets";
+import { parseMentionIds } from "../../utils/parse-mentions";
+
+type Task = typeof taskTable.$inferSelect;
+type Transaction = Parameters<Parameters<typeof db.transaction>[0]>[0];
+type Changes = Partial<
+ Pick<
+ Task,
+ "title" | "status" | "priority" | "description" | "userId" | "dueDate"
+ >
+>;
+export type TaskBefore = Pick<
+ Task,
+ "id" | "projectId" | "title" | "status" | "priority" | "userId" | "dueDate"
+> & { description?: string | null };
+
+export async function recordTaskMutation(
+ tx: Transaction,
+ before: TaskBefore,
+ changes: Changes,
+ userId?: string,
+) {
+ if (changes.title !== undefined && before.title !== changes.title) {
+ await tx.insert(activityTable).values({
+ taskId: before.id,
+ type: "title_changed",
+ userId: userId ?? null,
+ content: null,
+ eventData: { oldTitle: before.title, newTitle: changes.title },
+ });
+ }
+ if (
+ changes.dueDate !== undefined &&
+ before.dueDate?.getTime() !== changes.dueDate?.getTime()
+ ) {
+ await tx
+ .delete(taskReminderSentTable)
+ .where(eq(taskReminderSentTable.taskId, before.id));
+ }
+}
+
+export async function publishTaskMutation(
- before: TaskBefore,
- after: TaskBefore & { description: string | null },
++ before: Partial<TaskBefore>,
++ after: Pick<TaskBefore, "id" | "projectId" | "title"> & Partial<TaskBefore>,
+ userId?: string,
- options?: { skipSubtaskParentRefresh?: boolean },
++ options: {
++ skipSubtaskParentRefresh?: boolean;
++ skipRelationRefresh?: boolean;
++ fields?: Array<keyof Changes>;
++ assigneeName?: string | null;
++ } = {},
+) {
++ const changed = (field: keyof Changes) =>
++ (!options.fields || options.fields.includes(field)) &&
++ before[field] !== after[field];
+ const common = {
+ taskId: after.id,
+ projectId: after.projectId,
+ userId,
+ title: after.title,
+ };
- if (before.status !== after.status) {
++ if (changed("status")) {
+ await publishEvent("task.status_changed", {
+ ...common,
+ oldStatus: before.status,
+ newStatus: after.status,
+ assigneeId: after.userId,
+ type: "status_changed",
- ...options,
- });
- await publishEvent("task-relation.refresh", {
- projectId: after.projectId,
- userId,
++ ...(options.skipSubtaskParentRefresh
++ ? { skipSubtaskParentRefresh: true }
++ : {}),
+ });
++ if (!options.skipRelationRefresh)
++ await publishEvent("task-relation.refresh", {
++ projectId: after.projectId,
++ userId,
++ });
+ }
- if (before.title !== after.title)
++ if (changed("title"))
+ await publishEvent("task.title_changed", {
+ ...common,
+ oldTitle: before.title,
+ newTitle: after.title,
+ type: "title_changed",
+ });
- if (before.priority !== after.priority)
++ if (changed("priority"))
+ await publishEvent("task.priority_changed", {
+ ...common,
+ oldPriority: before.priority,
+ newPriority: after.priority,
+ type: "priority_changed",
+ });
- if (before.userId !== after.userId) {
- const assignee = after.userId
- ? (
- await db
- .select({ name: userTable.name })
- .from(userTable)
- .where(eq(userTable.id, after.userId))
- .limit(1)
- )[0]
- : undefined;
++ if (changed("userId")) {
++ const assignee =
++ options.assigneeName !== undefined
++ ? { name: options.assigneeName ?? undefined }
++ : after.userId
++ ? (
++ await db
++ .select({ name: userTable.name })
++ .from(userTable)
++ .where(eq(userTable.id, after.userId))
++ .limit(1)
++ )[0]
++ : undefined;
+ await publishEvent(
+ after.userId ? "task.assignee_changed" : "task.unassigned",
+ {
+ ...common,
+ oldAssignee: before.userId,
+ newAssignee: assignee?.name,
+ newAssigneeId: after.userId,
+ type: after.userId ? "assignee_changed" : "unassigned",
+ },
+ );
+ }
- if (before.dueDate?.getTime() !== after.dueDate?.getTime())
++ if (
++ (!options.fields || options.fields.includes("dueDate")) &&
++ before.dueDate?.getTime() !== after.dueDate?.getTime()
++ )
+ await publishEvent("task.due_date_changed", {
+ ...common,
+ oldDueDate: before.dueDate,
+ newDueDate: after.dueDate,
+ type: "due_date_changed",
+ });
+ if (
++ (!options.fields || options.fields.includes("description")) &&
+ before.description !== undefined &&
+ before.description !== after.description
+ ) {
+ await publishEvent("task.description_changed", {
+ ...common,
+ oldDescription: before.description,
+ newDescription: after.description,
+ type: "description_changed",
+ });
+ deleteOrphanedAssets(before.description, after.description, {
+ taskId: after.id,
+ }).catch(() => {});
+ const oldMentions = new Set(parseMentionIds(before.description));
+ const newlyMentioned = parseMentionIds(after.description).filter(
+ (id) => id !== userId && !oldMentions.has(id),
+ );
+ if (newlyMentioned.length) {
+ const editor = userId
+ ? (
+ await db
+ .select({ name: userTable.name })
+ .from(userTable)
+ .where(eq(userTable.id, userId))
+ .limit(1)
+ )[0]
+ : undefined;
+ for (const mentionedId of newlyMentioned)
+ await createNotification({
+ userId: mentionedId,
+ type: "task_mention",
+ eventData: {
+ taskTitle: after.title,
+ mentionerName: editor?.name ?? null,
+ },
+ resourceId: after.id,
+ resourceType: "task",
+ });
+ }
+ }
+}
diff --cc apps/api/src/task/controllers/update-task-assignee.ts
index d16a0b773,11de30d59..3d2d9f20a
--- a/apps/api/src/task/controllers/update-task-assignee.ts
+++ b/apps/api/src/task/controllers/update-task-assignee.ts
@@@ -51,7 -51,38 +51,9 @@@ async function updateTaskAssignee(
});
}
- await publishTaskMutation(existingTask, updatedTask, currentUserId);
- const newAssigneeName = nextAssigneeId
- ? (
- await db
- .select({ name: userTable.name })
- .from(userTable)
- .where(eq(userTable.id, nextAssigneeId))
- .limit(1)
- )[0]?.name
- : undefined;
-
- if (!nextAssigneeId) {
- await publishEvent("task.unassigned", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId: currentUserId,
- title: updatedTask.title,
- type: "unassigned",
- });
-
- return updatedTask;
- }
-
- await publishEvent("task.assignee_changed", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId: currentUserId,
- oldAssignee: existingTask.userId,
- newAssignee: newAssigneeName,
- newAssigneeId: nextAssigneeId,
- title: updatedTask.title,
- type: "assignee_changed",
++ await publishTaskMutation(existingTask, updatedTask, currentUserId, {
++ fields: ["userId"],
+ });
return updatedTask;
}
diff --cc apps/api/src/task/controllers/update-task-description.ts
index be62c6f11,6a232a9de..810f72047
--- a/apps/api/src/task/controllers/update-task-description.ts
+++ b/apps/api/src/task/controllers/update-task-description.ts
@@@ -35,8 -38,47 +35,10 @@@ async function updateTaskDescription(
});
}
- await publishTaskMutation(existingTask, updatedTask, currentUserId);
- await publishEvent("task.description_changed", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId: currentUserId,
- oldDescription: existingTask.description,
- newDescription: description,
- type: "description_changed",
++ await publishTaskMutation(existingTask, updatedTask, currentUserId, {
++ fields: ["description"],
+ });
- deleteOrphanedAssets(existingTask.description, description, {
- taskId: id,
- }).catch(() => {});
-
- // Notify members newly @mentioned by this edit (skip ones already mentioned
- // in the previous description, and the editor themselves).
- const alreadyMentioned = new Set(parseMentionIds(existingTask.description));
- const newlyMentioned = parseMentionIds(description).filter(
- (mentionedId) =>
- mentionedId !== currentUserId && !alreadyMentioned.has(mentionedId),
- );
-
- if (newlyMentioned.length > 0) {
- const [editor] = await db
- .select({ name: userTable.name })
- .from(userTable)
- .where(eq(userTable.id, currentUserId));
-
- for (const mentionedId of newlyMentioned) {
- await createNotification({
- userId: mentionedId,
- type: "task_mention",
- eventData: {
- taskTitle: updatedTask.title,
- mentionerName: editor?.name ?? null,
- },
- resourceId: updatedTask.id,
- resourceType: "task",
- });
- }
- }
-
return updatedTask;
}
diff --cc apps/api/src/task/controllers/update-task-due-date.ts
index 9cbec0907,de50436ac..a32147516
--- a/apps/api/src/task/controllers/update-task-due-date.ts
+++ b/apps/api/src/task/controllers/update-task-due-date.ts
@@@ -51,7 -40,15 +51,9 @@@ async function updateTaskDueDate(
});
}
- await publishTaskMutation(existingTask, updatedTask, currentUserId);
- await publishEvent("task.due_date_changed", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId: currentUserId,
- oldDueDate: existingTask.dueDate,
- newDueDate: dueDate,
- title: updatedTask.title,
- type: "due_date_changed",
++ await publishTaskMutation(existingTask, updatedTask, currentUserId, {
++ fields: ["dueDate"],
+ });
return updatedTask;
}
diff --cc apps/api/src/task/controllers/update-task-priority.ts
index 2250465e8,ce63fd728..942e55775
--- a/apps/api/src/task/controllers/update-task-priority.ts
+++ b/apps/api/src/task/controllers/update-task-priority.ts
@@@ -35,7 -35,15 +35,9 @@@ async function updateTaskPriority(
});
}
- await publishTaskMutation(existingTask, updatedTask, currentUserId);
- await publishEvent("task.priority_changed", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId: currentUserId,
- oldPriority: existingTask.priority,
- newPriority: priority,
- title: updatedTask.title,
- type: "priority_changed",
++ await publishTaskMutation(existingTask, updatedTask, currentUserId, {
++ fields: ["priority"],
+ });
return updatedTask;
}
diff --cc apps/api/src/task/controllers/update-task-status.ts
index a2cf07e4c,328e1866e..633835b07
--- a/apps/api/src/task/controllers/update-task-status.ts
+++ b/apps/api/src/task/controllers/update-task-status.ts
@@@ -45,7 -45,21 +45,9 @@@ async function updateTaskStatus(
});
}
- await publishTaskMutation(existingTask, updatedTask, currentUserId);
- await publishEvent("task.status_changed", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId: currentUserId,
- oldStatus: existingTask.status,
- newStatus: status,
- title: updatedTask.title,
- assigneeId: updatedTask.userId,
- type: "status_changed",
- });
-
- await publishEvent("task-relation.refresh", {
- projectId: updatedTask.projectId,
- userId: currentUserId,
++ await publishTaskMutation(existingTask, updatedTask, currentUserId, {
++ fields: ["status"],
+ });
return updatedTask;
}
diff --cc apps/api/src/task/controllers/update-task-title.ts
index f42835300,e2e935633..5c1c43d4c
--- a/apps/api/src/task/controllers/update-task-title.ts
+++ b/apps/api/src/task/controllers/update-task-title.ts
@@@ -57,7 -52,14 +57,9 @@@ async function updateTaskTitle(
return task;
});
- await publishTaskMutation(existingTask, updatedTask, currentUserId);
- await publishEvent("task.title_changed", {
- taskId: updatedTask.id,
- projectId: updatedTask.projectId,
- userId: currentUserId,
- oldTitle: existingTask.title,
- newTitle: title,
- type: "title_changed",
++ await publishTaskMutation(existingTask, updatedTask, currentUserId, {
++ fields: ["title"],
+ });
return updatedTask;
}
diff --cc tests/api-integration/task-mutation-parity.test.ts
index b226517e0,000000000..df144e3dc
mode 100644,000000..100644
--- a/tests/api-integration/task-mutation-parity.test.ts
+++ b/tests/api-integration/task-mutation-parity.test.ts
@@@ -1,96 -1,0 +1,199 @@@
++import updateTaskPriority from "../../apps/api/src/task/controllers/update-task-priority";
+import { eq } from "drizzle-orm";
+import { beforeEach, expect, it, vi } from "vite-plus/test";
- import db, { schema } from "../../apps/api/src/database";
++import db, { getDatabase, schema } from "../../apps/api/src/database";
+import updateTask from "../../apps/api/src/task/controllers/update-task";
+import bulkUpdateTasks from "../../apps/api/src/task/controllers/bulk-update-tasks";
+import { resetTestDatabase } from "./helpers/database";
+import {
+ createProjectFixture,
+ createWorkspaceMember,
+} from "./helpers/fixtures";
+const publish = vi.hoisted(() => vi.fn(async () => undefined));
+vi.mock("../../apps/api/src/events", () => ({ publishEvent: publish }));
+beforeEach(async () => {
+ await resetTestDatabase();
+ vi.clearAllMocks();
+});
+it("full updates store title history, assignment events and reset reminders together", async () => {
+ const { user, workspace } = await createWorkspaceMember();
+ const { project } = await createProjectFixture({ workspaceId: workspace.id });
+ const due = new Date("2030-01-01");
+ const [task] = await db
+ .insert(schema.taskTable)
+ .values({
+ projectId: project.id,
+ title: "old",
+ status: "to-do",
+ priority: "low",
+ dueDate: due,
+ position: 0,
+ })
+ .returning();
+ await db
+ .insert(schema.taskReminderSentTable)
+ .values({ taskId: task.id, reminderType: "due_today" });
+ await updateTask(
+ task.id,
+ "new",
+ "to-do",
+ undefined,
+ new Date("2030-02-01"),
+ project.id,
+ undefined,
+ "low",
+ 0,
+ user.id,
+ user.id,
+ );
+ expect(await db.query.activityTable.findMany()).toEqual([
+ expect.objectContaining({
+ type: "title_changed",
+ eventData: { oldTitle: "old", newTitle: "new" },
+ }),
+ ]);
+ expect(await db.query.taskReminderSentTable.findMany()).toHaveLength(0);
+ expect(publish).toHaveBeenCalledWith(
+ "task.assignee_changed",
+ expect.objectContaining({ newAssigneeId: user.id }),
+ );
+});
+it("bulk due date updates clear claims and preserve claims for unchanged dates", async () => {
+ const { user, workspace } = await createWorkspaceMember();
+ const { project } = await createProjectFixture({ workspaceId: workspace.id });
+ const [task] = await db
+ .insert(schema.taskTable)
+ .values({
+ projectId: project.id,
+ title: "task",
+ status: "to-do",
+ dueDate: new Date("2030-01-01"),
+ })
+ .returning();
+ await db
+ .insert(schema.taskReminderSentTable)
+ .values({ taskId: task.id, reminderType: "due_today" });
+ await bulkUpdateTasks({
+ taskIds: [task.id],
+ operation: "updateDueDate",
+ value: "2030-01-01",
+ userId: user.id,
+ });
+ expect(await db.query.taskReminderSentTable.findMany()).toHaveLength(1);
+ await bulkUpdateTasks({
+ taskIds: [task.id],
+ operation: "updateDueDate",
+ value: null,
+ userId: user.id,
+ });
+ expect(await db.query.taskReminderSentTable.findMany()).toHaveLength(0);
+ expect(
+ (
+ await db.query.taskTable.findFirst({
+ where: eq(schema.taskTable.id, task.id),
+ })
+ )?.dueDate,
+ ).toBeNull();
+});
++
++it("a single-field write does not attribute another concurrent field change to its actor", async () => {
++ const { user, workspace } = await createWorkspaceMember();
++ const { project } = await createProjectFixture({ workspaceId: workspace.id });
++ const [task] = await db
++ .insert(schema.taskTable)
++ .values({ projectId: project.id, title: "old", priority: "low" })
++ .returning();
++ const findFirst = getDatabase().query.taskTable.findFirst.bind(
++ getDatabase().query.taskTable,
++ );
++ vi.spyOn(getDatabase().query.taskTable, "findFirst").mockImplementationOnce(
++ async (query) => {
++ const before = await findFirst(query);
++ await db
++ .update(schema.taskTable)
++ .set({ title: "concurrent title" })
++ .where(eq(schema.taskTable.id, task.id));
++ return before;
++ },
++ );
++ await updateTaskPriority({
++ id: task.id,
++ priority: "high",
++ currentUserId: user.id,
++ });
++ expect(publish.mock.calls.map(([type]) => type)).toEqual([
++ "task.priority_changed",
++ ]);
++});
++it("bulk due dates use locked current dates before clearing reminder claims", async () => {
++ const { user, workspace } = await createWorkspaceMember();
++ const { project } = await createProjectFixture({ workspaceId: workspace.id });
++ const [task] = await db
++ .insert(schema.taskTable)
++ .values({
++ projectId: project.id,
++ title: "date race",
++ dueDate: new Date("2030-01-01"),
++ })
++ .returning();
++ const transaction = db.transaction.bind(db);
++ vi.spyOn(getDatabase(), "transaction").mockImplementationOnce(
++ async (apply, config) => {
++ await db
++ .update(schema.taskTable)
++ .set({ dueDate: new Date("2030-02-01") })
++ .where(eq(schema.taskTable.id, task.id));
++ await db
++ .insert(schema.taskReminderSentTable)
++ .values({ taskId: task.id, reminderType: "due_today" });
++ return transaction(apply, config);
++ },
++ );
++ await bulkUpdateTasks({
++ taskIds: [task.id],
++ operation: "updateDueDate",
++ value: "2030-01-01",
++ userId: user.id,
++ });
++ expect(await db.query.taskReminderSentTable.findMany()).toHaveLength(0);
++ expect(publish).toHaveBeenCalledWith(
++ "task.due_date_changed",
++ expect.objectContaining({
++ oldDueDate: new Date("2030-02-01"),
++ newDueDate: new Date("2030-01-01"),
++ }),
++ );
++});
++it("bulk assignment resolves the assignee once and bulk status refreshes each project once", async () => {
++ const { user, workspace } = await createWorkspaceMember();
++ const { project } = await createProjectFixture({ workspaceId: workspace.id });
++ const tasks = await db
++ .insert(schema.taskTable)
++ .values(
++ Array.from({ length: 3 }, (_, i) => ({
++ projectId: project.id,
++ title: `bulk-${i}`,
++ number: i + 1,
++ status: "to-do",
++ })),
++ )
++ .returning();
++ const nameLookup = vi.spyOn(getDatabase().query.userTable, "findFirst");
++ await bulkUpdateTasks({
++ taskIds: tasks.map((task) => task.id),
++ operation: "updateAssignee",
++ value: user.id,
++ userId: user.id,
++ });
++ expect(nameLookup).toHaveBeenCalledTimes(1);
++ publish.mockClear();
++ await bulkUpdateTasks({
++ taskIds: tasks.map((task) => task.id),
++ operation: "updateStatus",
++ value: "in-progress",
++ userId: user.id,
++ });
++ expect(
++ publish.mock.calls.filter(([type]) => type === "task-relation.refresh"),
++ ).toHaveLength(1);
++});