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.

6.7 KB
Raw Blame
import { issueEditScope } from "../../github/utils/deferred-issue-edit";
import { deferIssueEdit } from "../../github/services/deferred-issue-edits";
import { inboundStamp } from "../../github/utils/sync-echo";
import { publishEvent } from "../../../events";
import { withIntegrationLink } from "../../github/services/with-integration-link";
import type { GiteaConfig } from "../config";
import { createGiteaClient } from "../utils/gitea-api";
import {
  inboundEcho,
  withEchoConfirmation,
} from "../../github/utils/inbound-echo";
import { linkedTaskScope } from "../../github/services/integration-task-scope";
import { taskTable } from "../../../database/schema";
import {
  findExternalLink,
  updateExternalLink,
} from "../../github/services/link-manager";
import { formatTaskDescriptionFromIssue } from "../../github/utils/format";
import {
  findAllIntegrationsByGiteaRepo,
  repoOwnerLogin,
} from "../services/integration-lookup";
import { baseUrlFromRepositoryHtmlUrl } from "../utils/webhook-repo";

type IssueEditedPayload = {
  action: string;
  issue: {
    number: number;
    title: string;
    body: string | null;
    updated_at?: string;
    html_url: string;
  };
  changes?: {
    title?: { from: string };
    body?: { from: string };
  };
  repository: {
    owner: { login?: string; username?: string };
    name: string;
    html_url: string;
  };
};

export async function handleGiteaIssueEdited(
  payload: IssueEditedPayload,
  integrationId?: string,
) {
  const { issue, repository, changes } = payload;

  if (!changes?.title && !changes?.body) {
    return;
  }

  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 externalLink = await findExternalLink(
      integration.id,
      "issue",
      issue.number.toString(),
    );

    if (!externalLink) {
      continue;
    }

    const readCurrent = async () => {
      const config = JSON.parse(integration.config) as GiteaConfig;
      return await createGiteaClient(config).getIssue(
        config.repositoryOwner,
        config.repositoryName,
        issue.number,
      );
    };
    await withEchoConfirmation(
      readCurrent,
      (current, confirmation) =>
        withIntegrationLink(
          externalLink,
          integration,
          async (db, afterCommit, externalLink) => {
            const task = await db.query.taskTable.findFirst({
              where: linkedTaskScope(
                externalLink.taskId,
                integration.projectId,
              ),
            });

            if (!task) {
              return;
            }
            const metadata = externalLink.metadata
              ? JSON.parse(externalLink.metadata)
              : {};

            const updateData: Record<string, unknown> = {};
            const updatedMetadata = { ...metadata };

            if (!updatedMetadata.lastSync) {
              updatedMetadata.lastSync = {};
            }

            if (changes.title) {
              const lastTitleSync = metadata.lastSync?.title;

              let shouldUpdateTitle = true;

              if (lastTitleSync) {
                if (
                  inboundEcho(
                    lastTitleSync,
                    issue.title,
                    issue.updated_at,
                    current?.title,
                    {
                      linkId: externalLink.id,
                      field: "title",
                      localValue: task.title,
                      confirmation,
                    },
                  )
                ) {
                  shouldUpdateTitle = false;
                }
              }

              if (shouldUpdateTitle) {
                updateData.title = issue.title;
                updatedMetadata.lastSync.title = inboundStamp(
                  metadata.lastSync?.title,
                  issue.title,
                  "gitea",
                  issue.updated_at,
                );
              }
            }

            if (changes.body) {
              const lastDescSync = metadata.lastSync?.description;
              const formattedDescription = formatTaskDescriptionFromIssue(
                issue.body,
                externalLink.taskId,
              );

              let shouldUpdateDescription = true;

              if (lastDescSync) {
                if (
                  inboundEcho(
                    lastDescSync,
                    formattedDescription,
                    issue.updated_at,
                    current
                      ? formatTaskDescriptionFromIssue(
                          current.body ?? null,
                          task.id,
                        )
                      : undefined,
                    {
                      linkId: externalLink.id,
                      field: "description",
                      localValue: task.description || "",
                      confirmation,
                    },
                  )
                ) {
                  shouldUpdateDescription = false;
                }
              }

              if (shouldUpdateDescription) {
                updateData.description = formattedDescription;
                updatedMetadata.lastSync.description = inboundStamp(
                  metadata.lastSync?.description,
                  formattedDescription,
                  "gitea",
                  issue.updated_at,
                );
              }
            }

            if (Object.keys(updateData).length > 0) {
              await db
                .update(taskTable)
                .set(updateData)
                .where(linkedTaskScope(task.id, integration.projectId));

              await updateExternalLink(
                externalLink.id,
                {
                  title: issue.title,
                  metadata: updatedMetadata,
                },
                db,
              );
              afterCommit(() =>
                publishEvent("task.updated", {
                  projectId: integration.projectId,
                  taskId: externalLink.taskId,
                  ...(typeof updateData.title === "string"
                    ? { titleChanged: true }
                    : {}),
                }),
              );
            }

            return;
          },
          {
            validate: (binding) =>
              issueEditScope(binding) === issueEditScope(integration),
          },
        ),
      () =>
        deferIssueEdit(externalLink, integration, [
          ...(changes.title ? ["title" as const] : []),
          ...(changes.body ? ["description" as const] : []),
        ]),
    );
  }
}