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.

7.9 KB
Raw Blame
import { issueEditScope } from "../utils/deferred-issue-edit";
import { deferIssueEdit } from "../services/deferred-issue-edits";
import { inboundStamp } from "../../github/utils/sync-echo";
import { publishEvent } from "../../../events";
import { withIntegrationLink } from "../services/with-integration-link";
import type { GitHubConfig } from "../config";
import { getVerifiedInstallationOctokit } from "../utils/github-app";
import { inboundEcho, withEchoConfirmation } from "../utils/inbound-echo";
import { linkedTaskScope } from "../services/integration-task-scope";
import { taskTable } from "../../../database/schema";
import { findExternalLink, updateExternalLink } from "../services/link-manager";
import { findAllIntegrationsByRepo } from "../services/task-service";
import { formatTaskDescriptionFromIssue } from "../utils/format";
import { parseLinkMetadata } from "../utils/parse-link-metadata";

// What this handler reads back out of the row. Every field is optional,
// because the row may predate any of them.
type SyncStamp = import("../utils/sync-echo").SyncStamp;

type IssueEditedMetadata = {
  lastSync?: {
    title?: SyncStamp;
    description?: SyncStamp;
  };
};

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;
    };
  };
  installation?: { id: number };
  repository: {
    id: number;
    owner: { login: string };
    name: string;
    full_name: string;
  };
};

export async function handleIssueEdited(payload: IssueEditedPayload) {
  const { issue, changes } = payload;

  if (!changes?.title && !changes?.body) {
    console.log(
      `Issue #${issue.number} edited but no title/body changes detected`,
    );
    return;
  }

  const integrations = await findAllIntegrationsByRepo(payload);

  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 GitHubConfig;
      const octokit = await getVerifiedInstallationOctokit(config);
      return (
        await octokit.rest.issues.get({
          owner: config.repositoryOwner,
          repo: config.repositoryName,
          issue_number: issue.number,
        })
      ).data;
    };
    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) {
              console.error(`Task ${externalLink.taskId} not found`);
              return;
            }
            const metadata = parseLinkMetadata<IssueEditedMetadata>(
              externalLink.metadata,
              {
                externalLinkId: externalLink.id,
                source: "issue_edited",
              },
            );

            const updateData: Record<string, unknown> = {};
            const updatedMetadata: IssueEditedMetadata = { ...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,
                    },
                  )
                ) {
                  console.log(
                    "Skipping title update - already synced from Kaneo",
                  );
                  shouldUpdateTitle = false;
                }
              }

              if (shouldUpdateTitle) {
                updateData.title = issue.title;
                updatedMetadata.lastSync.title = inboundStamp(
                  metadata.lastSync?.title,
                  issue.title,
                  "github",
                  issue.updated_at,
                );
                console.log(
                  `Updating task title from GitHub: "${changes.title.from}" → "${issue.title}"`,
                );
              }
            }

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

              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,
                    },
                  )
                ) {
                  console.log(
                    "Skipping description update - already synced from Kaneo",
                  );
                  shouldUpdateDescription = false;
                }
              }

              if (shouldUpdateDescription) {
                updateData.description = formattedDescription;
                updatedMetadata.lastSync.description = inboundStamp(
                  metadata.lastSync?.description,
                  formattedDescription,
                  "github",
                  issue.updated_at,
                );
                console.log("Updating task description from GitHub");
              }
            }

            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 }
                    : {}),
                }),
              );

              console.log(
                `Synced ${Object.keys(updateData).join(", ")} from GitHub issue #${issue.number} to task ${task.id}`,
              );
            } else {
              console.log(
                `No updates needed for task ${task.id} from issue #${issue.number}`,
              );
            }

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