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.

15.2 KB
Raw Blame
import { integrationInActiveWorkspace } from "../../../workspace/archive/active-workspace-sql";
import { canSyncTask } from "../../sync/eligibility";
import { and, asc, gt, sql } from "drizzle-orm";
import db from "../../../database";
import { externalLinkTable } from "../../../database/schema";
import { publishEvent } from "../../../events";
import { withJobLease } from "../../../scheduler/leader-lock";
import type { GiteaConfig } from "../../gitea/config";
import { createGiteaClient } from "../../gitea/utils/gitea-api";
import type { GitHubConfig } from "../config";
import {
  issueEditScope,
  parseDeferredIssueEdit,
  type IssueField,
} from "../utils/deferred-issue-edit";
import {
  formatIssueBody,
  formatTaskDescriptionFromIssue,
} from "../utils/format";
import { getVerifiedInstallationOctokit } from "../utils/github-app";
import { inboundEcho, PendingEcho } from "../utils/inbound-echo";
import { parseLinkMetadata } from "../utils/parse-link-metadata";
import {
  inboundStamp,
  inboundOccurredAfterIntent,
  uncertainOutboundIntents,
  type SyncStamp,
} from "../utils/sync-echo";
import { writeInboundTaskField } from "./apply-observed-task-value";
import { updateExternalLink } from "./link-manager";
import { syncLatestTaskValue } from "./sync-latest-task-value";
import { isTaskInFinalState } from "./task-service";
import { isStateSyncPaused } from "../../sync/state-sync-paused";
import {
  linkedTaskScope,
  integrationTaskRevision,
} from "./integration-task-scope";
import { withIntegrationLink } from "./with-integration-link";

type Integration = {
  id: string;
  projectId: string;
  type: string;
  config: string;
};
type Metadata = Record<string, unknown> & {
  lastSync?: Record<string, SyncStamp>;
};
const metadataFor = (link: { id: string; metadata: string | null }) =>
  parseLinkMetadata<Metadata>(link.metadata, {
    externalLinkId: link.id,
    source: "deferred_issue_edit",
  });

export { deferIssueEdit } from "./defer-issue-edit";

async function issueAccess(
  integration: Integration,
  link: { externalId: string; taskId: string },
) {
  const number = Number(link.externalId);
  if (!Number.isSafeInteger(number) || number <= 0)
    throw new Error("Invalid issue number");
  const config = JSON.parse(integration.config);
  const { repositoryOwner: owner, repositoryName: repo } = config;
  const payload = (field: IssueField, value: string) =>
    field === "description"
      ? { body: formatIssueBody(value, link.taskId) }
      : { [field]: value };
  if (integration.type === "gitea") {
    const client = createGiteaClient(config as GiteaConfig);
    return {
      read: () => client.getIssue(owner, repo, number),
      write: async (field: IssueField, value: string) =>
        (await client.updateIssue(owner, repo, number, payload(field, value)))
          ?.updated_at,
    };
  }
  const octokit = await getVerifiedInstallationOctokit(
    config as GitHubConfig,
    true,
  );
  return {
    read: async () =>
      (
        await octokit.rest.issues.get({
          owner,
          repo,
          issue_number: number,
          request: { timeout: 10_000 },
        })
      ).data,
    write: async (field: IssueField, value: string) =>
      (
        await octokit.rest.issues.update({
          owner,
          repo,
          issue_number: number,
          ...payload(field, value),
          request: { timeout: 10_000 },
        })
      )?.data?.updated_at,
  };
}

let running = false;
let cursor: string | undefined;
export async function replayDeferredIssueEdits() {
  return withJobLease(
    "deferred-issue-edits",
    replayClaimedIssueEdits,
    () => ({}),
  );
}

async function replayClaimedIssueEdits() {
  if (running) return {};
  running = true;
  let degraded = false;
  const deadline = Date.now() + 45_000;
  try {
    const links = await db.query.externalLinkTable.findMany({
      where: and(
        sql`${externalLinkTable.resourceType} = 'issue' AND ${externalLinkTable.metadata} LIKE '%"deferredIssueEdit":%'`,
        integrationInActiveWorkspace(externalLinkTable.integrationId),
        cursor ? gt(externalLinkTable.id, cursor) : undefined,
      ),
      with: { integration: true },
      orderBy: asc(externalLinkTable.id),
      limit: 20,
    });
    if (!links.length) cursor = undefined;
    let processed = 0;
    for (const link of links) {
      if (Date.now() >= deadline) break;
      cursor = link.id;
      processed++;
      try {
        const metadata = metadataFor(link);
        const job = parseDeferredIssueEdit(metadata.deferredIssueEdit);
        if (!job) continue;
        const integration = link.integration;
        if (
          !integration?.isActive ||
          !["github", "gitea"].includes(integration.type) ||
          issueEditScope(integration) !== job.scope
        ) {
          await updateExternalLink(link.id, { completeDeferredEdit: job.id });
          continue;
        }
        if (
          !(await canSyncTask(
            link.taskId,
            integration.id,
            undefined,
            integration.config,
          ))
        )
          continue;
        const fields = [
          ...new Set([...job.fields, ...(job.repairFields ?? [])]),
        ];
        // An orphaned writer expires after five minutes; until then let it settle.
        if (
          fields.some((field) =>
            metadata.lastSync?.[field]?.outbound?.some(
              (entry) =>
                entry.pending &&
                !entry.cancelled &&
                Date.now() - Date.parse(entry.timestamp) < 300_000,
            ),
          )
        )
          continue;
        const revision = await integrationTaskRevision(
          link.taskId,
          integration.projectId,
        );
        if (!revision) continue;
        const provider = await issueAccess(integration, link);
        let issue: Awaited<ReturnType<typeof provider.read>>;
        try {
          issue = await provider.read();
        } catch (error) {
          if (
            typeof error !== "object" ||
            error === null ||
            !("status" in error) ||
            error.status !== 404
          )
            throw error;
          // Only retire this read's job; credentials, binding, or queued fields
          // may have changed while the provider request was in flight.
          await withIntegrationLink(
            link,
            integration,
            async (tx) => {
              await updateExternalLink(
                link.id,
                { completeDeferredEdit: job.id },
                tx,
              );
            },
            integration,
          );
          continue;
        }
        if (
          typeof issue.title !== "string" ||
          !["open", "closed"].includes(issue.state)
        )
          throw new Error("Invalid issue response");
        const values = {
          title: issue.title,
          description: formatTaskDescriptionFromIssue(
            issue.body ?? null,
            link.taskId,
          ),
          state: issue.state,
        };
        const repairs: Array<{
          field: IssueField;
          value: string;
          intentIds: string[];
        }> = [];
        const applied = await withIntegrationLink(
          link,
          integration,
          async (tx, afterCommit, locked) => {
            const current = metadataFor(locked);
            if (
              parseDeferredIssueEdit(current.deferredIssueEdit)?.id !== job.id
            )
              return;
            if (
              fields.some(
                (field) =>
                  JSON.stringify(current.lastSync?.[field]) !==
                  JSON.stringify(metadata.lastSync?.[field]),
              )
            )
              return;
            if (
              (await integrationTaskRevision(
                link.taskId,
                integration.projectId,
                tx,
              )) !== revision
            )
              return;
            const task = await tx.query.taskTable.findFirst({
              where: linkedTaskScope(link.taskId, integration.projectId),
              columns: {
                title: true,
                description: true,
                status: true,
                columnId: true,
                projectId: true,
              },
            });
            if (!task) return;
            const taskIsClosed = fields.includes("state")
              ? await isTaskInFinalState(task, tx)
              : false;
            // Skip state for archived tasks and settle what still waits on it.
            const statePaused =
              fields.includes("state") && isStateSyncPaused(task.status);
            if (statePaused) current.state = values.state;
            for (const field of fields) {
              if (field === "state" && statePaused) continue;
              const stamp = current.lastSync?.[field];
              const uncertain = uncertainOutboundIntents(stamp, values[field]);
              const intentIds = uncertain.flatMap((entry) =>
                entry.intentId ? [entry.intentId] : [],
              );
              const local =
                field === "state"
                  ? taskIsClosed
                    ? "closed"
                    : "open"
                  : field === "description"
                    ? task.description || ""
                    : task.title;
              if (
                job.repairFields?.includes(field) &&
                !job.fields.includes(field)
              ) {
                repairs.push({
                  field,
                  value: local,
                  intentIds,
                });
                continue;
              }
              // A crashed older writer can leave the provider behind our completed
              // local value. Its missing receipt does not make it a remote edit.
              if (
                local !== values[field] &&
                uncertain.some(
                  (entry) =>
                    !(
                      stamp?.source !== "kaneo" &&
                      stamp?.inboundValue === local &&
                      inboundOccurredAfterIntent(stamp, entry)
                    ),
                )
              ) {
                repairs.push({
                  field,
                  value: local,
                  intentIds,
                });
              }
            }
            // Classify every field before writing any: PendingEcho commits only its observation.
            const accepted = job.fields.filter(
              (field) =>
                !repairs.some((repair) => repair.field === field) &&
                !(field === "state" && statePaused) &&
                !(
                  field === "state" &&
                  integration.type === "github" &&
                  current.createdFrom === "kaneo"
                ) &&
                !inboundEcho(
                  current.lastSync?.[field],
                  values[field],
                  issue.updated_at,
                  values[field],
                  {
                    linkId: link.id,
                    field,
                    localValue:
                      field === "state"
                        ? taskIsClosed
                          ? "closed"
                          : "open"
                        : field === "description"
                          ? task.description || ""
                          : task.title,
                  },
                ),
            );
            for (const field of accepted) {
              await writeInboundTaskField(
                tx,
                afterCommit,
                link,
                integration,
                field,
                values[field],
              );
              current.lastSync = {
                ...current.lastSync,
                [field]: inboundStamp(
                  current.lastSync?.[field],
                  values[field],
                  integration.type,
                  issue.updated_at,
                ),
              };
              if (field === "state") current.state = values.state;
            }
            await updateExternalLink(
              link.id,
              {
                metadata: current,
                ...(accepted.includes("title") ? { title: values.title } : {}),
                ...(statePaused
                  ? { retireUncertainOutbound: "state" as const }
                  : {}),
                ...(repairs.length ? {} : { completeDeferredEdit: job.id }),
              },
              tx,
            );
            if (accepted.length)
              afterCommit(() =>
                publishEvent("task.updated", {
                  taskId: link.taskId,
                  projectId: integration.projectId,
                }),
              );
            return true;
          },
          integration,
        );
        if (applied !== true) continue;
        for (const repair of repairs) {
          await syncLatestTaskValue(
            link.taskId,
            integration.projectId,
            link,
            repair.field,
            repair.value,
            (value) => provider.write(repair.field, value),
            async () => {
              const current = await provider.read();
              return repair.field === "description"
                ? formatTaskDescriptionFromIssue(
                    current.body ?? null,
                    link.taskId,
                  )
                : current[repair.field];
            },
            integration,
            true,
          );
          // A later field can fail; persist this field's successful repair first.
          if (repair.intentIds.length)
            await withIntegrationLink(
              link,
              integration,
              async (tx) => {
                await updateExternalLink(
                  link.id,
                  {
                    retireOutboundIntents: {
                      field: repair.field,
                      intentIds: repair.intentIds,
                    },
                  },
                  tx,
                );
              },
              integration,
            );
        }
        if (repairs.length)
          await withIntegrationLink(
            link,
            integration,
            async (tx, _afterCommit, locked) => {
              // Writes settled after the receipt need their own later correction.
              const current = metadataFor(locked);
              const remaining = fields.filter(
                (field) =>
                  uncertainOutboundIntents(current.lastSync?.[field]).length,
              );
              await updateExternalLink(
                link.id,
                remaining.length
                  ? {
                      deferredEdit: {
                        fields: [],
                        repairFields: remaining,
                        scope: job.scope,
                      },
                    }
                  : { completeDeferredEdit: job.id },
                tx,
              );
            },
            integration,
          );
      } catch (error) {
        if (error instanceof PendingEcho) continue;
        degraded = true;
        console.error("Deferred issue edit failed", {
          externalLinkId: link.id,
        });
      }
    }
    if (processed === links.length && links.length < 20) cursor = undefined;
    return { degraded };
  } finally {
    running = false;
  }
}