⚡ 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 { withIntegrationLink } from "../../github/services/with-integration-link";
import { and, eq } from "drizzle-orm";
import db from "../../../database";
import { externalLinkTable } from "../../../database/schema";
import { publishEvent } from "../../../events";
import { updateExternalLink } from "../../github/services/link-manager";
import {
findTaskById,
updateTaskStatus,
} from "../../github/services/task-service";
import type { GiteaConfig } from "../config";
import {
findAllIntegrationsByGiteaRepo,
repoOwnerLogin,
} from "../services/integration-lookup";
import { resolveTargetStatus } from "../utils/resolve-column";
import { baseUrlFromRepositoryHtmlUrl } from "../utils/webhook-repo";
type PRClosedPayload = {
action: string;
pull_request: {
number: number;
title: string;
html_url: string;
state: string;
merged: boolean;
merged_at: string | null;
head: {
ref: string;
};
};
repository: {
owner: { login?: string; username?: string };
name: string;
html_url: string;
};
};
export async function handleGiteaPullRequestClosed(
payload: PRClosedPayload,
integrationId?: string,
) {
const { pull_request, repository } = payload;
const baseUrl = baseUrlFromRepositoryHtmlUrl(repository.html_url);
if (!baseUrl) return;
const owner = repoOwnerLogin(repository);
const integrations = await findAllIntegrationsByGiteaRepo(
baseUrl,
owner,
repository.name,
integrationId,
);
for (const integration of integrations) {
const config = JSON.parse(integration.config) as GiteaConfig;
const externalLink = await db.query.externalLinkTable.findFirst({
where: and(
eq(externalLinkTable.integrationId, integration.id),
eq(externalLinkTable.resourceType, "pull_request"),
eq(externalLinkTable.externalId, pull_request.number.toString()),
),
});
if (!externalLink) {
continue;
}
await withIntegrationLink(
externalLink,
integration,
async (database, afterCommit, lockedLink) => {
const task = await findTaskById(externalLink.taskId, database);
if (!task) {
return;
}
const existingMetadata = lockedLink.metadata
? JSON.parse(lockedLink.metadata)
: {};
await updateExternalLink(
externalLink.id,
{
metadata: {
...existingMetadata,
state: "closed",
merged: pull_request.merged,
mergedAt: pull_request.merged_at,
},
},
database,
);
afterCommit(() =>
publishEvent("task.updated", {
projectId: integration.projectId,
taskId: task.id,
}),
);
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 = 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;
}
}