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): preserve newer edits during crash recovery

Tined40a774b65f
diff --git a/apps/api/src/plugins/github/services/deferred-issue-edits.ts b/apps/api/src/plugins/github/services/deferred-issue-edits.ts
index ac9d2e0cc..b30435c22 100644
--- a/apps/api/src/plugins/github/services/deferred-issue-edits.ts
+++ b/apps/api/src/plugins/github/services/deferred-issue-edits.ts
@@ -1,6 +1,6 @@
-import { and, asc, eq, gt, like } from "drizzle-orm";
+import { and, asc, eq, gt, like, sql } from "drizzle-orm";
import db from "../../../database";
-import { externalLinkTable } from "../../../database/schema";
+import { externalLinkTable, taskTable } from "../../../database/schema";
import { publishEvent } from "../../../events";
import type { GiteaConfig } from "../../gitea/config";
import { createGiteaClient } from "../../gitea/utils/gitea-api";
@@ -10,13 +10,25 @@ import {
parseDeferredIssueEdit,
type IssueField,
} from "../utils/deferred-issue-edit";
-import { formatTaskDescriptionFromIssue } from "../utils/format";
+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, type SyncStamp } from "../utils/sync-echo";
+import {
+ inboundStamp,
+ uncertainOutboundIntent,
+ 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 {
+ linkedTaskScope,
+ type IntegrationDatabase,
+} from "./integration-task-scope";
import { withIntegrationLink } from "./with-integration-link";
type Integration = {
@@ -50,32 +62,75 @@ export async function deferIssueEdit(
tx,
);
},
- integration,
+ {
+ validate: (binding) =>
+ issueEditScope(binding) === issueEditScope(integration),
+ },
);
}
-async function readIssue(integration: Integration, externalId: string) {
- const number = Number(externalId);
+async function taskRevision(
+ taskId: string,
+ projectId: string,
+ fields: IssueField[],
+ database: IntegrationDatabase = db,
+) {
+ const [task] = await database
+ .select({
+ revision: sql<string>`md5(jsonb_build_array(${taskTable.updatedAt}, ${fields.includes("title") ? taskTable.title : sql`null`}, ${fields.includes("description") ? taskTable.description : sql`null`}, ${fields.includes("state") ? taskTable.status : sql`null`})::text)`,
+ })
+ .from(taskTable)
+ .where(linkedTaskScope(taskId, projectId));
+ return task?.revision;
+}
+
+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 config = JSON.parse(integration.config) as GiteaConfig;
- return createGiteaClient(config).getIssue(
- config.repositoryOwner,
- config.repositoryName,
- number,
- );
+ 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 config = JSON.parse(integration.config) as GitHubConfig;
- const octokit = await getVerifiedInstallationOctokit(config, true);
- return (
- await octokit.rest.issues.get({
- owner: config.repositoryOwner,
- repo: config.repositoryName,
- issue_number: number,
- request: { timeout: 10_000 },
- })
- ).data;
+ 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;
@@ -127,7 +182,14 @@ export async function replayDeferredIssueEdits() {
)
)
continue;
- const issue = await readIssue(integration, link.externalId);
+ const revision = await taskRevision(
+ link.taskId,
+ integration.projectId,
+ job.fields,
+ );
+ if (!revision) continue;
+ const provider = await issueAccess(integration, link);
+ const issue = await provider.read();
if (
typeof issue.title !== "string" ||
!["open", "closed"].includes(issue.state)
@@ -141,7 +203,8 @@ export async function replayDeferredIssueEdits() {
),
state: issue.state,
};
- await withIntegrationLink(
+ const repairs: Array<{ field: IssueField; value: string }> = [];
+ const applied = await withIntegrationLink(
link,
integration,
async (tx, afterCommit, locked) => {
@@ -158,9 +221,60 @@ export async function replayDeferredIssueEdits() {
)
)
return;
+ if (
+ (await taskRevision(
+ link.taskId,
+ integration.projectId,
+ job.fields,
+ tx,
+ )) !== revision
+ )
+ return;
+ const task = await tx.query.taskTable.findFirst({
+ where: linkedTaskScope(link.taskId, integration.projectId),
+ columns: { title: true, description: true, status: true },
+ });
+ if (!task) return;
+ for (const field of job.fields) {
+ const stamp = current.lastSync?.[field];
+ const uncertain = uncertainOutboundIntent(stamp, values[field]);
+ const local =
+ field === "state"
+ ? task.status === "done"
+ ? "closed"
+ : "open"
+ : field === "description"
+ ? task.description || ""
+ : task.title;
+ // A crashed older writer can leave the provider behind our completed
+ // local value. Its missing receipt does not make it a remote edit.
+ if (
+ uncertain &&
+ stamp?.source === "kaneo" &&
+ stamp.value === local &&
+ local !== values[field]
+ ) {
+ if (uncertain.intentId)
+ await updateExternalLink(
+ link.id,
+ {
+ outbound: {
+ field,
+ value: values[field],
+ intentId: uncertain.intentId,
+ pending: false,
+ uncertain: true,
+ },
+ },
+ tx,
+ );
+ repairs.push({ field, value: local });
+ }
+ }
// 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" &&
integration.type === "github" &&
@@ -198,7 +312,7 @@ export async function replayDeferredIssueEdits() {
{
metadata: current,
...(accepted.includes("title") ? { title: values.title } : {}),
- completeDeferredEdit: job.id,
+ ...(repairs.length ? {} : { completeDeferredEdit: job.id }),
},
tx,
);
@@ -209,9 +323,43 @@ export async function replayDeferredIssueEdits() {
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];
+ },
+ );
+ }
+ if (repairs.length)
+ await withIntegrationLink(
+ link,
+ integration,
+ async (tx) => {
+ await updateExternalLink(
+ link.id,
+ { completeDeferredEdit: job.id },
+ tx,
+ );
+ },
+ integration,
+ );
} catch (error) {
if (error instanceof PendingEcho) continue;
degraded = true;
diff --git a/apps/api/src/plugins/github/services/integration-task-scope.ts b/apps/api/src/plugins/github/services/integration-task-scope.ts
index 36e03f210..7ddeabcbd 100644
--- a/apps/api/src/plugins/github/services/integration-task-scope.ts
+++ b/apps/api/src/plugins/github/services/integration-task-scope.ts
@@ -25,7 +25,11 @@ export async function withIntegrationTask<T>(
database: IntegrationDatabase,
afterCommit: (effect: () => Promise<void>) => void,
) => Promise<T>,
- expectedBinding?: { config: string; type: string },
+ expectedBinding?: {
+ config?: string;
+ type?: string;
+ validate?: (binding: { config: string; type: string }) => boolean;
+ },
): Promise<T | undefined> {
const effects: Array<() => Promise<void>> = [];
const result = await db.transaction(async (tx) => {
@@ -49,18 +53,29 @@ export async function withIntegrationTask<T>(
if (!project) return undefined;
if (expectedBinding) {
const [binding] = await tx
- .select({ id: integrationTable.id })
+ .select({
+ config: integrationTable.config,
+ type: integrationTable.type,
+ })
.from(integrationTable)
.where(
and(
eq(integrationTable.id, integration.id),
- eq(integrationTable.config, expectedBinding.config),
- eq(integrationTable.type, expectedBinding.type),
+ expectedBinding.config === undefined
+ ? undefined
+ : eq(integrationTable.config, expectedBinding.config),
+ expectedBinding.type === undefined
+ ? undefined
+ : eq(integrationTable.type, expectedBinding.type),
eq(integrationTable.isActive, true),
),
)
.for("share");
- if (!binding) return undefined;
+ if (
+ !binding ||
+ (expectedBinding.validate && !expectedBinding.validate(binding))
+ )
+ return undefined;
}
if (taskId !== null) {
const [task] = await tx
diff --git a/apps/api/src/plugins/github/services/with-integration-link.ts b/apps/api/src/plugins/github/services/with-integration-link.ts
index 30a88a0c2..e2a97dd40 100644
--- a/apps/api/src/plugins/github/services/with-integration-link.ts
+++ b/apps/api/src/plugins/github/services/with-integration-link.ts
@@ -15,7 +15,7 @@ export function withIntegrationLink<T>(
afterCommit: (effect: () => Promise<void>) => void,
lockedLink: typeof externalLinkTable.$inferSelect,
) => Promise<T>,
- expectedBinding?: { config: string; type: string },
+ expectedBinding?: Parameters<typeof withIntegrationTask>[3],
) {
return withIntegrationTask(
link.taskId,
diff --git a/apps/api/src/plugins/github/utils/sync-echo.ts b/apps/api/src/plugins/github/utils/sync-echo.ts
index cbd57d416..444475d7d 100644
--- a/apps/api/src/plugins/github/utils/sync-echo.ts
+++ b/apps/api/src/plugins/github/utils/sync-echo.ts
@@ -78,9 +78,10 @@ export function outboundStamp(
export function boundOutboundHistory(entries: OutboundEntry[]) {
// Keep active intents until they settle; completed history stays bounded.
const recent = entries
- .filter(
- (entry) =>
- !entry.pending || Date.now() - Date.parse(entry.timestamp) < 300_000,
+ .map((entry) =>
+ entry.pending && Date.now() - Date.parse(entry.timestamp) >= 300_000
+ ? { ...entry, pending: false, uncertain: true }
+ : entry,
)
.sort((left, right) => left.timestamp.localeCompare(right.timestamp));
const completed = recent.filter((entry) => !entry.pending).slice(-32);
@@ -186,3 +187,16 @@ export function hasNewerObservedEdit(
(entry.observedUpdatedAt === updatedAt && !!entry.ambiguous)
);
}
+
+export function uncertainOutboundIntent(
+ stamp: SyncStamp | undefined,
+ value: string,
+) {
+ return stamp?.outbound?.find(
+ (entry) =>
+ !entry.cancelled &&
+ entry.hash === hash(value) &&
+ (entry.uncertain ||
+ (entry.pending && Date.now() - Date.parse(entry.timestamp) >= 300_000)),
+ );
+}
diff --git a/tests/api-integration/deferred-issue-edits.test.ts b/tests/api-integration/deferred-issue-edits.test.ts
index ed1a5fb8d..bb45eb496 100644
--- a/tests/api-integration/deferred-issue-edits.test.ts
+++ b/tests/api-integration/deferred-issue-edits.test.ts
@@ -17,7 +17,11 @@ import {
createProjectFixture,
createWorkspaceMember,
} from "./helpers/fixtures";
-const m = vi.hoisted(() => ({ integrations: [] as unknown[], read: vi.fn() }));
+const m = vi.hoisted(() => ({
+ integrations: [] as unknown[],
+ read: vi.fn(),
+ write: vi.fn(),
+}));
vi.mock("../../apps/api/src/events", () => ({
publishEvent: vi.fn(async () => undefined),
}));
@@ -32,15 +36,31 @@ vi.mock(
);
vi.mock("../../apps/api/src/plugins/github/utils/github-app", () => ({
getVerifiedInstallationOctokit: async () => ({
- rest: { issues: { get: async () => ({ data: await m.read() }) } },
+ rest: {
+ issues: {
+ get: async () => ({ data: await m.read() }),
+ update: async (params: Record<string, unknown>) => ({
+ data: await m.write(params),
+ }),
+ },
+ },
}),
}));
vi.mock("../../apps/api/src/plugins/gitea/utils/gitea-api", () => ({
- createGiteaClient: () => ({ getIssue: () => m.read() }),
+ createGiteaClient: () => ({
+ getIssue: () => m.read(),
+ updateIssue: (
+ _owner: string,
+ _repo: string,
+ _number: number,
+ params: Record<string, unknown>,
+ ) => m.write(params),
+ }),
}));
beforeEach(async () => {
await resetTestDatabase();
vi.clearAllMocks();
+ m.write.mockReset().mockResolvedValue({ updated_at: "2026-09-30T00:00:04Z" });
m.read.mockReset().mockResolvedValue({
title: "A",
body: "recovered body",
@@ -274,3 +294,96 @@ it("rechecks provider state after a newer inbound edit during HTTP", async () =>
expect((await current(task.id))?.description).toBe("newer edit");
expect((await metadata(link.id)).deferredIssueEdit).toBeUndefined();
});
+
+it("retains deferred edits across credential rotation on the same repository", async () => {
+ const { task, integration, link } = await seed("gitea");
+ await db
+ .update(schema.integrationTable)
+ .set({
+ config: JSON.stringify({
+ ...JSON.parse(integration.config),
+ accessToken: "rotated-test-secret",
+ }),
+ })
+ .where(eq(schema.integrationTable.id, integration.id));
+ await deferIssueEdit(link, integration, ["description"]);
+ expect((await metadata(link.id)).deferredIssueEdit.fields).toEqual([
+ "description",
+ ]);
+ await replayDeferredIssueEdits();
+ expect((await current(task.id))?.description).toBe("recovered body");
+ expect((await metadata(link.id)).deferredIssueEdit).toBeUndefined();
+});
+
+it("does not overwrite a local edit committed before its integration subscriber stamps it", async () => {
+ const { task, integration, link } = await seed();
+ await deferIssueEdit(link, integration, ["description"]);
+ m.read.mockImplementationOnce(async () => {
+ await db
+ .update(schema.taskTable)
+ .set({ description: "new local edit" })
+ .where(eq(schema.taskTable.id, task.id));
+ return { title: "A", body: "stale provider body", state: "closed" };
+ });
+ await replayDeferredIssueEdits();
+ expect((await current(task.id))?.description).toBe("new local edit");
+ expect((await metadata(link.id)).deferredIssueEdit).toBeDefined();
+ expect(publishEvent).not.toHaveBeenCalled();
+});
+it.each(
+ ["github", "gitea"].flatMap((provider) =>
+ ["title", "description", "state"].map((field) => ({ provider, field })),
+ ),
+)(
+ "repairs an expired older $provider $field writer without importing its stale value",
+ async ({ provider, field }) => {
+ const { task, integration, link } = await seed(provider);
+ const local =
+ field === "title" ? "B" : field === "description" ? "old body" : "open";
+ const stale =
+ field === "title"
+ ? "A"
+ : field === "description"
+ ? "recovered body"
+ : "closed";
+ const stamp = outboundStamp(
+ outboundStamp(undefined, stale, undefined, {
+ intentId: "orphan",
+ pending: true,
+ }),
+ local,
+ "2026-09-30T00:00:02Z",
+ { intentId: "newer-completed", pending: false },
+ );
+ const orphan = stamp.outbound?.find((entry) => entry.intentId === "orphan");
+ if (!orphan) throw new Error("Missing orphan fixture");
+ orphan.timestamp = new Date(Date.now() - 300_001).toISOString();
+ await db
+ .update(schema.externalLinkTable)
+ .set({ metadata: JSON.stringify({ lastSync: { [field]: stamp } }) })
+ .where(eq(schema.externalLinkTable.id, link.id));
+ await deferIssueEdit(link, integration, [
+ field as "title" | "description" | "state",
+ ]);
+ expect(
+ (await metadata(link.id)).lastSync[field].outbound.find(
+ (entry: { intentId: string }) => entry.intentId === "orphan",
+ ),
+ ).toMatchObject({ pending: false, uncertain: true });
+ await replayDeferredIssueEdits();
+ expect(await current(task.id)).toMatchObject({
+ title: "B",
+ description: "old body",
+ status: "to-do",
+ });
+ expect(m.write).toHaveBeenCalledWith(
+ expect.objectContaining(
+ field === "description"
+ ? { body: expect.stringContaining("old body") }
+ : { [field]: local },
+ ),
+ );
+ expect((await metadata(link.id)).deferredIssueEdit).toBeUndefined();
+ expect(publishEvent).not.toHaveBeenCalled();
+ },
+);