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(integrations): guard pull request transitions against task moves

Tin2dd66f66d854
diff --git a/apps/api/src/plugins/gitea/webhooks/pull-request-closed.ts b/apps/api/src/plugins/gitea/webhooks/pull-request-closed.ts
index 6bb4aedf0..04a2c52ce 100644
--- a/apps/api/src/plugins/gitea/webhooks/pull-request-closed.ts
+++ b/apps/api/src/plugins/gitea/webhooks/pull-request-closed.ts
@@ -1,3 +1,4 @@
+import { withIntegrationLink } from "../../github/services/with-integration-link";
import { and, eq } from "drizzle-orm";
import db from "../../../database";
import { externalLinkTable } from "../../../database/schema";
@@ -67,63 +68,80 @@ export async function handleGiteaPullRequestClosed(
continue;
}
- const task = await findTaskById(externalLink.taskId);
+ await withIntegrationLink(
+ externalLink,
+ integration,
+ async (database, afterCommit, lockedLink) => {
+ const task = await findTaskById(externalLink.taskId, database);
- if (!task) {
- continue;
- }
-
- const existingMetadata = externalLink.metadata
- ? JSON.parse(externalLink.metadata)
- : {};
+ if (!task) {
+ return;
+ }
- await updateExternalLink(externalLink.id, {
- metadata: {
- ...existingMetadata,
- state: "closed",
- merged: pull_request.merged,
- mergedAt: pull_request.merged_at,
- },
- });
+ const existingMetadata = lockedLink.metadata
+ ? JSON.parse(lockedLink.metadata)
+ : {};
- if (pull_request.merged) {
- const allTaskPRs = await db.query.externalLinkTable.findMany({
- where: and(
- eq(externalLinkTable.taskId, task.id),
- eq(externalLinkTable.resourceType, "pull_request"),
- ),
- });
+ await updateExternalLink(
+ externalLink.id,
+ {
+ metadata: {
+ ...existingMetadata,
+ state: "closed",
+ merged: pull_request.merged,
+ mergedAt: pull_request.merged_at,
+ },
+ },
+ database,
+ );
- const hasOpenPRs = allTaskPRs.some((pr) => {
- if (pr.id === externalLink.id) return false;
- const metadata = pr.metadata ? JSON.parse(pr.metadata) : {};
- return metadata.state === "open";
- });
+ if (pull_request.merged) {
+ const allTaskPRs = await database.query.externalLinkTable.findMany({
+ where: and(
+ eq(externalLinkTable.taskId, task.id),
+ eq(externalLinkTable.resourceType, "pull_request"),
+ ),
+ });
- if (!hasOpenPRs) {
- const targetStatus = await resolveTargetStatus(
- integration.projectId,
- "pr_merged",
- config.statusTransitions?.onPRMerge || "done",
- );
- const statusResult = await updateTaskStatus(task.id, targetStatus);
- if (
- statusResult.applied &&
- statusResult.before.status !== statusResult.after.status
- ) {
- await publishEvent("task.status_changed", {
- taskId: statusResult.after.id,
- projectId: statusResult.after.projectId,
- userId: null,
- oldStatus: statusResult.before.status,
- newStatus: statusResult.after.status,
- title: statusResult.after.title,
- assigneeId: statusResult.after.userId,
- type: "status_changed",
+ const hasOpenPRs = allTaskPRs.some((pr) => {
+ if (pr.id === externalLink.id) return false;
+ const metadata = pr.metadata ? JSON.parse(pr.metadata) : {};
+ return metadata.state === "open";
});
+
+ if (!hasOpenPRs) {
+ const targetStatus = await resolveTargetStatus(
+ integration.projectId,
+ "pr_merged",
+ config.statusTransitions?.onPRMerge || "done",
+ database,
+ );
+ const statusResult = await updateTaskStatus(
+ task.id,
+ targetStatus,
+ database,
+ );
+ if (
+ statusResult.applied &&
+ statusResult.before.status !== statusResult.after.status
+ ) {
+ afterCommit(() =>
+ publishEvent("task.status_changed", {
+ taskId: statusResult.after.id,
+ projectId: statusResult.after.projectId,
+ userId: null,
+ oldStatus: statusResult.before.status,
+ newStatus: statusResult.after.status,
+ title: statusResult.after.title,
+ assigneeId: statusResult.after.userId,
+ type: "status_changed",
+ }),
+ );
+ }
+ }
}
- }
- }
+ },
+ );
return;
}
diff --git a/apps/api/src/plugins/gitea/webhooks/pull-request-opened.ts b/apps/api/src/plugins/gitea/webhooks/pull-request-opened.ts
index 8cd4bf129..f07a5f066 100644
--- a/apps/api/src/plugins/gitea/webhooks/pull-request-opened.ts
+++ b/apps/api/src/plugins/gitea/webhooks/pull-request-opened.ts
@@ -1,3 +1,4 @@
+import { withIntegrationTask } from "../../github/services/integration-task-scope";
import { publishEvent } from "../../../events";
import {
createExternalLink,
@@ -92,44 +93,79 @@ export async function handleGiteaPullRequestOpened(
if (integrationId && integration.id !== integrationId) return;
const branchName = pull_request.head.ref;
- await createExternalLink({
- taskId: task.id,
- integrationId: integration.id,
- resourceType: "pull_request",
- externalId: pull_request.number.toString(),
- url: pull_request.html_url,
- title: pull_request.title,
- metadata: {
- state: pull_request.state,
- draft: pull_request.draft,
- merged: pull_request.merged,
- branch: branchName,
- author: pull_request.user?.login ?? pull_request.user?.username,
- },
- });
+ await withIntegrationTask(
+ task.id,
+ integration,
+ async (database, afterCommit) => {
+ const currentTask = await resolvePullRequestTask({
+ integrationId: integration.id,
+ projectId: integration.projectId,
+ projectSlug: integration.project.slug,
+ config,
+ repositoryUrl: repository.html_url,
+ pullRequest: pull_request,
+ database,
+ });
+ if (currentTask?.id !== task.id) return;
+ if (
+ await findExternalLink(
+ integration.id,
+ "pull_request",
+ pull_request.number.toString(),
+ database,
+ )
+ )
+ return;
+ await createExternalLink(
+ {
+ taskId: task.id,
+ integrationId: integration.id,
+ resourceType: "pull_request",
+ externalId: pull_request.number.toString(),
+ url: pull_request.html_url,
+ title: pull_request.title,
+ metadata: {
+ state: pull_request.state,
+ draft: pull_request.draft,
+ merged: pull_request.merged,
+ branch: branchName,
+ author: pull_request.user?.login ?? pull_request.user?.username,
+ },
+ },
+ database,
+ );
- const targetStatus = await resolveTargetStatus(
- integration.projectId,
- "pr_opened",
- config.statusTransitions?.onPROpen || "in-review",
- );
+ const targetStatus = await resolveTargetStatus(
+ integration.projectId,
+ "pr_opened",
+ config.statusTransitions?.onPROpen || "in-review",
+ database,
+ );
- if (task.status !== targetStatus) {
- const statusResult = await updateTaskStatus(task.id, targetStatus);
- if (
- statusResult.applied &&
- statusResult.before.status !== statusResult.after.status
- ) {
- await publishEvent("task.status_changed", {
- taskId: statusResult.after.id,
- projectId: statusResult.after.projectId,
- userId: null,
- oldStatus: statusResult.before.status,
- newStatus: statusResult.after.status,
- title: statusResult.after.title,
- assigneeId: statusResult.after.userId,
- type: "status_changed",
- });
- }
- }
+ if (currentTask.status !== targetStatus) {
+ const statusResult = await updateTaskStatus(
+ task.id,
+ targetStatus,
+ database,
+ );
+ if (
+ statusResult.applied &&
+ statusResult.before.status !== statusResult.after.status
+ ) {
+ afterCommit(() =>
+ publishEvent("task.status_changed", {
+ taskId: statusResult.after.id,
+ projectId: statusResult.after.projectId,
+ userId: null,
+ oldStatus: statusResult.before.status,
+ newStatus: statusResult.after.status,
+ title: statusResult.after.title,
+ assigneeId: statusResult.after.userId,
+ type: "status_changed",
+ }),
+ );
+ }
+ }
+ },
+ );
}
diff --git a/apps/api/src/plugins/github/services/task-service.ts b/apps/api/src/plugins/github/services/task-service.ts
index 49629b801..995042f71 100644
--- a/apps/api/src/plugins/github/services/task-service.ts
+++ b/apps/api/src/plugins/github/services/task-service.ts
@@ -19,8 +19,12 @@ export type UpdateTaskStatusResult =
const NON_COLUMN_STATUSES = new Set(["planned", "archived"]);
-export async function findTaskByNumber(projectId: string, taskNumber: number) {
- return db.query.taskTable.findFirst({
+export async function findTaskByNumber(
+ projectId: string,
+ taskNumber: number,
+ database: Pick<typeof db, "query"> = db,
+) {
+ return database.query.taskTable.findFirst({
where: and(
eq(taskTable.projectId, projectId),
eq(taskTable.number, taskNumber),
@@ -45,8 +49,11 @@ export async function findTaskByLink(
});
}
-export async function findTaskById(taskId: string) {
- return db.query.taskTable.findFirst({
+export async function findTaskById(
+ taskId: string,
+ database: Pick<typeof db, "query"> = db,
+) {
+ return database.query.taskTable.findFirst({
where: eq(taskTable.id, taskId),
});
}
@@ -97,13 +104,16 @@ export async function updateTaskStatus(
return { applied: true, before: task, after };
}
-export async function isTaskInFinalState(task: {
- projectId: string;
- status: string;
- columnId: string | null;
-}): Promise<boolean> {
+export async function isTaskInFinalState(
+ task: {
+ projectId: string;
+ status: string;
+ columnId: string | null;
+ },
+ database: Pick<typeof db, "query"> = db,
+): Promise<boolean> {
if (task.columnId) {
- const columnById = await db.query.columnTable.findFirst({
+ const columnById = await database.query.columnTable.findFirst({
where: and(
eq(columnTable.id, task.columnId),
eq(columnTable.projectId, task.projectId),
@@ -115,7 +125,7 @@ export async function isTaskInFinalState(task: {
}
}
- const columnByStatus = await db.query.columnTable.findFirst({
+ const columnByStatus = await database.query.columnTable.findFirst({
where: and(
eq(columnTable.projectId, task.projectId),
eq(columnTable.slug, task.status),
diff --git a/apps/api/src/plugins/github/services/with-integration-link.ts b/apps/api/src/plugins/github/services/with-integration-link.ts
new file mode 100644
index 000000000..bc65a3513
--- /dev/null
+++ b/apps/api/src/plugins/github/services/with-integration-link.ts
@@ -0,0 +1,36 @@
+import { and, eq } from "drizzle-orm";
+import { externalLinkTable } from "../../../database/schema";
+import {
+ withIntegrationTask,
+ type IntegrationDatabase,
+} from "./integration-task-scope";
+
+export function withIntegrationLink<T>(
+ link: { id: string; taskId: string },
+ integration: Parameters<typeof withIntegrationTask>[1],
+ apply: (
+ database: IntegrationDatabase,
+ afterCommit: (effect: () => Promise<void>) => void,
+ lockedLink: typeof externalLinkTable.$inferSelect,
+ ) => Promise<T>,
+) {
+ return withIntegrationTask(
+ link.taskId,
+ integration,
+ async (database, afterCommit) => {
+ const [lockedLink] = await database
+ .select()
+ .from(externalLinkTable)
+ .where(
+ and(
+ eq(externalLinkTable.id, link.id),
+ eq(externalLinkTable.taskId, link.taskId),
+ eq(externalLinkTable.integrationId, integration.id),
+ ),
+ )
+ .for("update");
+ if (!lockedLink) return;
+ return apply(database, afterCommit, lockedLink);
+ },
+ );
+}
diff --git a/apps/api/src/plugins/github/webhooks/pull-request-closed.ts b/apps/api/src/plugins/github/webhooks/pull-request-closed.ts
index 99affb901..97c974dc1 100644
--- a/apps/api/src/plugins/github/webhooks/pull-request-closed.ts
+++ b/apps/api/src/plugins/github/webhooks/pull-request-closed.ts
@@ -1,3 +1,4 @@
+import { withIntegrationLink } from "../services/with-integration-link";
import { and, eq } from "drizzle-orm";
import db from "../../../database";
import { externalLinkTable } from "../../../database/schema";
@@ -53,67 +54,84 @@ export async function handlePullRequestClosed(payload: PRClosedPayload) {
continue;
}
- const task = await findTaskById(externalLink.taskId);
+ await withIntegrationLink(
+ externalLink,
+ integration,
+ async (database, afterCommit, lockedLink) => {
+ const task = await findTaskById(externalLink.taskId, database);
- if (!task) {
- continue;
- }
-
- const existingMetadata = parseLinkMetadata(externalLink.metadata, {
- externalLinkId: externalLink.id,
- source: "pull_request_closed",
- });
-
- await updateExternalLink(externalLink.id, {
- metadata: {
- ...existingMetadata,
- state: "closed",
- merged: pull_request.merged,
- mergedAt: pull_request.merged_at,
- },
- });
-
- if (pull_request.merged) {
- const allTaskPRs = await db.query.externalLinkTable.findMany({
- where: and(
- eq(externalLinkTable.taskId, task.id),
- eq(externalLinkTable.resourceType, "pull_request"),
- ),
- });
+ if (!task) {
+ return;
+ }
- const hasOpenPRs = allTaskPRs.some((pr) => {
- if (pr.id === externalLink.id) return false;
- const metadata = parseLinkMetadata(pr.metadata, {
- externalLinkId: pr.id,
+ const existingMetadata = parseLinkMetadata(lockedLink.metadata, {
+ externalLinkId: externalLink.id,
source: "pull_request_closed",
});
- return metadata.state === "open";
- });
- if (!hasOpenPRs) {
- const targetStatus = await resolveTargetStatus(
- integration.projectId,
- "pr_merged",
- config.statusTransitions?.onPRMerge || "done",
+ await updateExternalLink(
+ externalLink.id,
+ {
+ metadata: {
+ ...existingMetadata,
+ state: "closed",
+ merged: pull_request.merged,
+ mergedAt: pull_request.merged_at,
+ },
+ },
+ database,
);
- const statusResult = await updateTaskStatus(task.id, targetStatus);
- if (
- statusResult.applied &&
- statusResult.before.status !== statusResult.after.status
- ) {
- await publishEvent("task.status_changed", {
- taskId: statusResult.after.id,
- projectId: statusResult.after.projectId,
- userId: null,
- oldStatus: statusResult.before.status,
- newStatus: statusResult.after.status,
- title: statusResult.after.title,
- assigneeId: statusResult.after.userId,
- type: "status_changed",
+
+ if (pull_request.merged) {
+ const allTaskPRs = await database.query.externalLinkTable.findMany({
+ where: and(
+ eq(externalLinkTable.taskId, task.id),
+ eq(externalLinkTable.resourceType, "pull_request"),
+ ),
+ });
+
+ const hasOpenPRs = allTaskPRs.some((pr) => {
+ if (pr.id === externalLink.id) return false;
+ const metadata = parseLinkMetadata(pr.metadata, {
+ externalLinkId: pr.id,
+ source: "pull_request_closed",
+ });
+ return metadata.state === "open";
});
+
+ if (!hasOpenPRs) {
+ const targetStatus = await resolveTargetStatus(
+ integration.projectId,
+ "pr_merged",
+ config.statusTransitions?.onPRMerge || "done",
+ database,
+ );
+ const statusResult = await updateTaskStatus(
+ task.id,
+ targetStatus,
+ database,
+ );
+ if (
+ statusResult.applied &&
+ statusResult.before.status !== statusResult.after.status
+ ) {
+ afterCommit(() =>
+ publishEvent("task.status_changed", {
+ taskId: statusResult.after.id,
+ projectId: statusResult.after.projectId,
+ userId: null,
+ oldStatus: statusResult.before.status,
+ newStatus: statusResult.after.status,
+ title: statusResult.after.title,
+ assigneeId: statusResult.after.userId,
+ type: "status_changed",
+ }),
+ );
+ }
+ }
}
- }
- }
+ },
+ );
return;
}
diff --git a/apps/api/src/plugins/github/webhooks/pull-request-opened.ts b/apps/api/src/plugins/github/webhooks/pull-request-opened.ts
index 71f2506b3..c6654140f 100644
--- a/apps/api/src/plugins/github/webhooks/pull-request-opened.ts
+++ b/apps/api/src/plugins/github/webhooks/pull-request-opened.ts
@@ -1,3 +1,4 @@
+import { withIntegrationTask } from "../services/integration-task-scope";
import { publishEvent } from "../../../events";
import type { GitHubConfig } from "../config";
import { createExternalLink, findExternalLink } from "../services/link-manager";
@@ -66,44 +67,79 @@ export async function handlePullRequestOpened(payload: PROpenedPayload) {
const { integration, config, task } = candidate;
const branchName = pull_request.head.ref;
- await createExternalLink({
- taskId: task.id,
- integrationId: integration.id,
- resourceType: "pull_request",
- externalId: pull_request.number.toString(),
- url: pull_request.html_url,
- title: pull_request.title,
- metadata: {
- state: pull_request.state,
- draft: pull_request.draft,
- merged: pull_request.merged,
- branch: branchName,
- author: pull_request.user?.login,
- },
- });
+ await withIntegrationTask(
+ task.id,
+ integration,
+ async (database, afterCommit) => {
+ const currentTask = await resolvePullRequestTask({
+ integrationId: integration.id,
+ projectId: integration.projectId,
+ projectSlug: integration.project.slug,
+ config,
+ repositoryUrl: `https://github.com/${repository.owner.login}/${repository.name}`,
+ pullRequest: pull_request,
+ database,
+ });
+ if (currentTask?.id !== task.id) return;
+ if (
+ await findExternalLink(
+ integration.id,
+ "pull_request",
+ pull_request.number.toString(),
+ database,
+ )
+ )
+ return;
+ await createExternalLink(
+ {
+ taskId: task.id,
+ integrationId: integration.id,
+ resourceType: "pull_request",
+ externalId: pull_request.number.toString(),
+ url: pull_request.html_url,
+ title: pull_request.title,
+ metadata: {
+ state: pull_request.state,
+ draft: pull_request.draft,
+ merged: pull_request.merged,
+ branch: branchName,
+ author: pull_request.user?.login,
+ },
+ },
+ database,
+ );
- const targetStatus = await resolveTargetStatus(
- integration.projectId,
- "pr_opened",
- config.statusTransitions?.onPROpen || "in-review",
- );
+ const targetStatus = await resolveTargetStatus(
+ integration.projectId,
+ "pr_opened",
+ config.statusTransitions?.onPROpen || "in-review",
+ database,
+ );
- if (task.status !== targetStatus) {
- const statusResult = await updateTaskStatus(task.id, targetStatus);
- if (
- statusResult.applied &&
- statusResult.before.status !== statusResult.after.status
- ) {
- await publishEvent("task.status_changed", {
- taskId: statusResult.after.id,
- projectId: statusResult.after.projectId,
- userId: null,
- oldStatus: statusResult.before.status,
- newStatus: statusResult.after.status,
- title: statusResult.after.title,
- assigneeId: statusResult.after.userId,
- type: "status_changed",
- });
- }
- }
+ if (currentTask.status !== targetStatus) {
+ const statusResult = await updateTaskStatus(
+ task.id,
+ targetStatus,
+ database,
+ );
+ if (
+ statusResult.applied &&
+ statusResult.before.status !== statusResult.after.status
+ ) {
+ afterCommit(() =>
+ publishEvent("task.status_changed", {
+ taskId: statusResult.after.id,
+ projectId: statusResult.after.projectId,
+ userId: null,
+ oldStatus: statusResult.before.status,
+ newStatus: statusResult.after.status,
+ title: statusResult.after.title,
+ assigneeId: statusResult.after.userId,
+ type: "status_changed",
+ }),
+ );
+ }
+ }
+ },
+ );
}
diff --git a/apps/api/src/plugins/gitlab/services/resolve-merge-request-task.ts b/apps/api/src/plugins/gitlab/services/resolve-merge-request-task.ts
index caae838ff..8caa59ea5 100644
--- a/apps/api/src/plugins/gitlab/services/resolve-merge-request-task.ts
+++ b/apps/api/src/plugins/gitlab/services/resolve-merge-request-task.ts
@@ -1,3 +1,4 @@
+import db from "../../../database";
import {
findTaskByLink,
findTaskByNumber,
@@ -10,7 +11,9 @@ export async function resolveMergeRequestTask({
projectSlug,
config,
mergeRequest,
+ database = db,
}: {
+ database?: Pick<typeof db, "query">;
projectId: string;
projectSlug: string;
config: GitlabConfig;
@@ -28,11 +31,15 @@ export async function resolveMergeRequestTask({
projectSlug,
);
const numberedTask = taskNumber
- ? await findTaskByNumber(projectId, taskNumber)
+ ? await findTaskByNumber(projectId, taskNumber, database)
: undefined;
return (
numberedTask ??
- findTaskByLink(projectId, [mergeRequest.title, mergeRequest.description])
+ findTaskByLink(
+ projectId,
+ [mergeRequest.title, mergeRequest.description],
+ database,
+ )
);
}
diff --git a/apps/api/src/plugins/gitlab/webhooks/merge-request-closed.ts b/apps/api/src/plugins/gitlab/webhooks/merge-request-closed.ts
index cd7499616..43804be54 100644
--- a/apps/api/src/plugins/gitlab/webhooks/merge-request-closed.ts
+++ b/apps/api/src/plugins/gitlab/webhooks/merge-request-closed.ts
@@ -1,3 +1,4 @@
+import { withIntegrationLink } from "../../github/services/with-integration-link";
import { and, eq } from "drizzle-orm";
import db from "../../../database";
import { externalLinkTable } from "../../../database/schema";
@@ -69,87 +70,105 @@ export async function handleGitlabMergeRequestClosed(
continue;
}
- const task = await findTaskById(externalLink.taskId);
-
- if (!task) {
- continue;
- }
-
- let existingMetadata: Record<string, unknown> = {};
- if (externalLink.metadata) {
- try {
- existingMetadata = JSON.parse(externalLink.metadata) as Record<
- string,
- unknown
- >;
- } catch (error) {
- console.warn("Failed to parse GitLab merge request metadata", {
- externalLinkId: externalLink.id,
- metadata: externalLink.metadata,
- error,
+ await withIntegrationLink(
+ externalLink,
+ integration,
+ async (database, afterCommit, lockedLink) => {
+ const task = await findTaskById(externalLink.taskId, database);
+
+ if (!task) {
+ return;
+ }
+
+ let existingMetadata: Record<string, unknown> = {};
+ if (lockedLink.metadata) {
+ try {
+ existingMetadata = JSON.parse(lockedLink.metadata) as Record<
+ string,
+ unknown
+ >;
+ } catch (error) {
+ console.warn("Failed to parse GitLab merge request metadata", {
+ externalLinkId: externalLink.id,
+ metadata: lockedLink.metadata,
+ error,
+ });
+ }
+ }
+
+ await updateExternalLink(
+ externalLink.id,
+ {
+ metadata: {
+ ...existingMetadata,
+ state: merged ? "merged" : "closed",
+ draft: false,
+ merged,
+ },
+ },
+ database,
+ );
+
+ if (!merged) {
+ return;
+ }
+
+ const allTaskMergeRequests =
+ await database.query.externalLinkTable.findMany({
+ where: and(
+ eq(externalLinkTable.taskId, task.id),
+ eq(externalLinkTable.resourceType, "pull_request"),
+ ),
+ });
+
+ const hasOpenMergeRequests = allTaskMergeRequests.some((link) => {
+ if (link.id === externalLink.id) return false;
+ try {
+ const metadata = link.metadata
+ ? (JSON.parse(link.metadata) as { state?: string })
+ : {};
+ return metadata.state === "opened";
+ } catch {
+ return false;
+ }
});
- }
- }
- await updateExternalLink(externalLink.id, {
- metadata: {
- ...existingMetadata,
- state: merged ? "merged" : "closed",
- draft: false,
- merged,
+ if (hasOpenMergeRequests) {
+ return;
+ }
+
+ const targetStatus = await resolveTargetStatus(
+ integration.projectId,
+ "pr_merged",
+ config.statusTransitions?.onPRMerge || "done",
+ database,
+ );
+
+ const statusResult = await updateTaskStatus(
+ task.id,
+ targetStatus,
+ database,
+ );
+ if (
+ statusResult.applied &&
+ statusResult.before.status !== statusResult.after.status
+ ) {
+ afterCommit(() =>
+ publishEvent("task.status_changed", {
+ taskId: statusResult.after.id,
+ projectId: statusResult.after.projectId,
+ userId: null,
+ oldStatus: statusResult.before.status,
+ newStatus: statusResult.after.status,
+ title: statusResult.after.title,
+ assigneeId: statusResult.after.userId,
+ type: "status_changed",
+ }),
+ );
+ }
},
- });
-
- if (!merged) {
- return;
- }
-
- const allTaskMergeRequests = await db.query.externalLinkTable.findMany({
- where: and(
- eq(externalLinkTable.taskId, task.id),
- eq(externalLinkTable.resourceType, "pull_request"),
- ),
- });
-
- const hasOpenMergeRequests = allTaskMergeRequests.some((link) => {
- if (link.id === externalLink.id) return false;
- try {
- const metadata = link.metadata
- ? (JSON.parse(link.metadata) as { state?: string })
- : {};
- return metadata.state === "opened";
- } catch {
- return false;
- }
- });
-
- if (hasOpenMergeRequests) {
- return;
- }
-
- const targetStatus = await resolveTargetStatus(
- integration.projectId,
- "pr_merged",
- config.statusTransitions?.onPRMerge || "done",
);
- const statusResult = await updateTaskStatus(task.id, targetStatus);
- if (
- statusResult.applied &&
- statusResult.before.status !== statusResult.after.status
- ) {
- await publishEvent("task.status_changed", {
- taskId: statusResult.after.id,
- projectId: statusResult.after.projectId,
- userId: null,
- oldStatus: statusResult.before.status,
- newStatus: statusResult.after.status,
- title: statusResult.after.title,
- assigneeId: statusResult.after.userId,
- type: "status_changed",
- });
- }
-
return;
}
}
diff --git a/apps/api/src/plugins/gitlab/webhooks/merge-request-opened.ts b/apps/api/src/plugins/gitlab/webhooks/merge-request-opened.ts
index 135d28b58..89b538eaa 100644
--- a/apps/api/src/plugins/gitlab/webhooks/merge-request-opened.ts
+++ b/apps/api/src/plugins/gitlab/webhooks/merge-request-opened.ts
@@ -1,3 +1,8 @@
+import { withIntegrationLink } from "../../github/services/with-integration-link";
+import {
+ withIntegrationTask,
+ type IntegrationDatabase,
+} from "../../github/services/integration-task-scope";
import { publishEvent } from "../../../events";
import {
createExternalLink,
@@ -98,69 +103,115 @@ export async function handleGitlabMergeRequestOpened(
continue;
}
- const metadata = {
- state: mergeRequest.state,
- draft: mergeRequest.draft === true,
- merged: false,
- branch: branchName,
- author: payload.user?.username ?? payload.user?.name,
- };
-
- if (existingLink) {
- await updateExternalLink(existingLink.id, {
- title: mergeRequest.title,
- url: mergeRequest.url,
- metadata,
- });
- } else {
- await createExternalLink({
- taskId: task.id,
- integrationId: integration.id,
- resourceType: "pull_request",
- externalId: mergeRequest.iid.toString(),
- url: mergeRequest.url,
- title: mergeRequest.title,
- metadata,
- });
- }
-
- if (!moveTask) {
- return;
- }
+ const apply = async (
+ database: IntegrationDatabase,
+ afterCommit: (effect: () => Promise<void>) => void,
+ lockedLink?: { metadata: string | null },
+ ) => {
+ const currentTask = await findTaskById(task.id, database);
+ if (!currentTask) return;
+ if (!existingLink) {
+ if (
+ await findExternalLink(
+ integration.id,
+ "pull_request",
+ mergeRequest.iid.toString(),
+ database,
+ )
+ )
+ return;
+ const resolved = await resolveMergeRequestTask({
+ projectId: integration.projectId,
+ projectSlug: integration.project!.slug,
+ config,
+ mergeRequest: { ...mergeRequest, source_branch: branchName },
+ database,
+ });
+ if (resolved?.id !== task.id) return;
+ }
+ const metadata = {
+ state: mergeRequest.state,
+ draft: mergeRequest.draft === true,
+ merged: false,
+ branch: branchName,
+ author: payload.user?.username ?? payload.user?.name,
+ };
+
+ if (existingLink) {
+ await updateExternalLink(
+ existingLink.id,
+ {
+ title: mergeRequest.title,
+ url: mergeRequest.url,
+ metadata,
+ },
+ database,
+ );
+ } else {
+ await createExternalLink(
+ {
+ taskId: task.id,
+ integrationId: integration.id,
+ resourceType: "pull_request",
+ externalId: mergeRequest.iid.toString(),
+ url: mergeRequest.url,
+ title: mergeRequest.title,
+ metadata,
+ },
+ database,
+ );
+ }
- // On reopen the link already exists, but the task still has to move.
- const targetStatus = await resolveTargetStatus(
- integration.projectId,
- "pr_opened",
- config.statusTransitions?.onPROpen || "in-review",
- );
+ if (!moveTask) {
+ return;
+ }
- const wasDraft =
- parseLinkMetadata<{ draft: boolean }>(existingLink?.metadata, {
- externalLinkId: existingLink?.id ?? "",
- source: "gitlab-merge-request-opened",
- }).draft === true;
- const canMove =
- !existingLink || wasDraft || !(await isTaskInFinalState(task));
-
- if (task.status !== targetStatus && canMove) {
- const statusResult = await updateTaskStatus(task.id, targetStatus);
- if (
- statusResult.applied &&
- statusResult.before.status !== statusResult.after.status
- ) {
- await publishEvent("task.status_changed", {
- taskId: statusResult.after.id,
- projectId: statusResult.after.projectId,
- userId: null,
- oldStatus: statusResult.before.status,
- newStatus: statusResult.after.status,
- title: statusResult.after.title,
- assigneeId: statusResult.after.userId,
- type: "status_changed",
- });
+ // On reopen the link already exists, but the task still has to move.
+ const targetStatus = await resolveTargetStatus(
+ integration.projectId,
+ "pr_opened",
+ config.statusTransitions?.onPROpen || "in-review",
+ database,
+ );
+
+ const wasDraft =
+ parseLinkMetadata<{ draft: boolean }>(lockedLink?.metadata, {
+ externalLinkId: existingLink?.id ?? "",
+ source: "gitlab-merge-request-opened",
+ }).draft === true;
+ const canMove =
+ !existingLink ||
+ wasDraft ||
+ !(await isTaskInFinalState(currentTask, database));
+
+ if (currentTask.status !== targetStatus && canMove) {
+ const statusResult = await updateTaskStatus(
+ task.id,
+ targetStatus,
+ database,
+ );
+ if (
+ statusResult.applied &&
+ statusResult.before.status !== statusResult.after.status
+ ) {
+ afterCommit(() =>
+ publishEvent("task.status_changed", {
+ taskId: statusResult.after.id,
+ projectId: statusResult.after.projectId,
+ userId: null,
+ oldStatus: statusResult.before.status,
+ newStatus: statusResult.after.status,
+ title: statusResult.after.title,
+ assigneeId: statusResult.after.userId,
+ type: "status_changed",
+ }),
+ );
+ }
}
- }
+ };
+ if (existingLink)
+ await withIntegrationLink(existingLink, integration, apply);
+ else await withIntegrationTask(task.id, integration, apply);
return;
}
diff --git a/tests/api-integration/integration-pr-task-ownership.test.ts b/tests/api-integration/integration-pr-task-ownership.test.ts
new file mode 100644
index 000000000..14be38458
--- /dev/null
+++ b/tests/api-integration/integration-pr-task-ownership.test.ts
@@ -0,0 +1,186 @@
+import { eq } from "drizzle-orm";
+import { beforeEach, expect, it, vi } from "vite-plus/test";
+import db, { getDatabase, schema } from "../../apps/api/src/database";
+import { handlePullRequestOpened } from "../../apps/api/src/plugins/github/webhooks/pull-request-opened";
+import { handlePullRequestClosed } from "../../apps/api/src/plugins/github/webhooks/pull-request-closed";
+import { handleGiteaPullRequestOpened } from "../../apps/api/src/plugins/gitea/webhooks/pull-request-opened";
+import { handleGiteaPullRequestClosed } from "../../apps/api/src/plugins/gitea/webhooks/pull-request-closed";
+import { handleGitlabMergeRequestOpened } from "../../apps/api/src/plugins/gitlab/webhooks/merge-request-opened";
+import { handleGitlabMergeRequestClosed } from "../../apps/api/src/plugins/gitlab/webhooks/merge-request-closed";
+import moveTask from "../../apps/api/src/task/controllers/move-task";
+import { resetTestDatabase } from "./helpers/database";
+import {
+ createProjectFixture,
+ createWorkspaceMember,
+} from "./helpers/fixtures";
+
+vi.mock("../../apps/api/src/events", () => ({
+ publishEvent: vi.fn(async () => undefined),
+}));
+beforeEach(resetTestDatabase);
+const cases = ["github", "gitea", "gitlab"].flatMap((provider) =>
+ ["opened", "merged"].flatMap((action) =>
+ ["ordinary", "moved", "returned"].map((race) => ({
+ provider,
+ action,
+ race,
+ })),
+ ),
+);
+it.each(cases)(
+ "$provider $action webhook respects task ownership ($race)",
+ async ({ provider, action, race }) => {
+ const { user, workspace } = await createWorkspaceMember();
+ const { project } = await createProjectFixture({
+ workspaceId: workspace.id,
+ slug: "KAN",
+ });
+ const { project: destination } = await createProjectFixture({
+ workspaceId: workspace.id,
+ });
+ await db
+ .update(schema.projectTable)
+ .set({ lastTaskNumber: 1 })
+ .where(eq(schema.projectTable.id, project.id));
+ const [task] = await db
+ .insert(schema.taskTable)
+ .values({
+ projectId: project.id,
+ number: 1,
+ title: "card",
+ status: "to-do",
+ position: 0,
+ })
+ .returning();
+ const [integration] = await db
+ .insert(schema.integrationTable)
+ .values({
+ projectId: project.id,
+ type: provider,
+ config: JSON.stringify({
+ baseUrl: "https://git.example",
+ accessToken: "test-only",
+ repositoryOwner: "owner",
+ repositoryName: "repo",
+ projectPath: "owner/repo",
+ installationId: 10,
+ repositoryId: 20,
+ verifiedGithubAccountId: "123",
+ verifiedByUserId: user.id,
+ branchPattern: "{slug}-{number}",
+ statusTransitions: { onPROpen: "in-progress", onPRMerge: "done" },
+ }),
+ })
+ .returning();
+ if (action === "merged")
+ await db.insert(schema.externalLinkTable).values({
+ taskId: task.id,
+ integrationId: integration.id,
+ resourceType: "pull_request",
+ externalId: "1",
+ url: "https://git.example/owner/repo/pull/1",
+ metadata: JSON.stringify({
+ state: provider === "gitlab" ? "opened" : "open",
+ }),
+ });
+ const request = {
+ action: action === "opened" ? "opened" : "closed",
+ installation: { id: 10 },
+ repository: {
+ id: 20,
+ owner: { login: "owner" },
+ name: "repo",
+ html_url: "https://git.example/owner/repo",
+ },
+ pull_request: {
+ number: 1,
+ title: "change",
+ body: null,
+ html_url: "https://git.example/owner/repo/pull/1",
+ state: action === "opened" ? "open" : "closed",
+ draft: false,
+ merged: action === "merged",
+ merged_at: action === "merged" ? new Date().toISOString() : null,
+ head: { ref: "KAN-1" },
+ user: { login: "author" },
+ },
+ };
+ const mergeRequest = {
+ project: {
+ id: 20,
+ name: "repo",
+ path_with_namespace: "owner/repo",
+ web_url: "https://git.example/owner/repo",
+ },
+ object_attributes: {
+ iid: 1,
+ title: "change",
+ description: null,
+ url: "https://git.example/owner/repo/-/merge_requests/1",
+ state: action === "opened" ? "opened" : "merged",
+ action: action === "opened" ? "open" : "merge",
+ source_branch: "KAN-1",
+ draft: false,
+ },
+ };
+ const transaction = getDatabase().transaction.bind(getDatabase());
+ const intercepted =
+ race === "ordinary"
+ ? undefined
+ : vi
+ .spyOn(getDatabase(), "transaction")
+ .mockImplementationOnce(async (apply, config) => {
+ await moveTask({
+ taskId: task.id,
+ destinationProjectId: destination.id,
+ userId: user.id,
+ });
+ if (race === "returned")
+ await moveTask({
+ taskId: task.id,
+ destinationProjectId: project.id,
+ userId: user.id,
+ });
+ return transaction(apply, config);
+ });
+ try {
+ if (provider === "github")
+ await (
+ action === "opened"
+ ? handlePullRequestOpened
+ : handlePullRequestClosed
+ )(request);
+ else if (provider === "gitea")
+ await (
+ action === "opened"
+ ? handleGiteaPullRequestOpened
+ : handleGiteaPullRequestClosed
+ )(request, integration.id);
+ else
+ await (
+ action === "opened"
+ ? handleGitlabMergeRequestOpened
+ : handleGitlabMergeRequestClosed
+ )(mergeRequest, integration.id);
+ const saved = await db.query.taskTable.findFirst({
+ where: eq(schema.taskTable.id, task.id),
+ });
+ expect(saved?.status).toBe(
+ race === "ordinary"
+ ? action === "opened"
+ ? "in-progress"
+ : "done"
+ : "to-do",
+ );
+ expect(saved?.projectId).toBe(
+ race === "moved" ? destination.id : project.id,
+ );
+ const links = await db.query.externalLinkTable.findMany({
+ where: eq(schema.externalLinkTable.taskId, task.id),
+ });
+ expect(links).toHaveLength(race === "ordinary" ? 1 : 0);
+ } finally {
+ intercepted?.mockRestore();
+ }
+ },
+);