refactor(threads): dedup maintenance threads by stable key via index

2026-07-11 14:00:16 -04:00
parent c3f73ac656
commit 0e894f8e67
2 changed files with 157 additions and 7 deletions
@@ -0,0 +1,146 @@
+import { convexTest } from 'convex-test';
+import { describe, expect, test } from 'vitest';
+
+import type { Id } from '../../convex/_generated/dataModel.js';
+import { internal } from '../../convex/_generated/api.js';
+import schema from '../../convex/schema';
+
+const modules = import.meta.glob('../../convex/**/*.*s');
+
+const seedSpoon = async (t: ReturnType<typeof convexTest>) =>
+  await t.mutation(async (ctx) => {
+    const now = Date.now();
+    const ownerId = await ctx.db.insert('users', {
+      email: 'maintenance-thread@example.com',
+      name: 'Maintenance Thread Owner',
+    });
+    const spoonId = await ctx.db.insert('spoons', {
+      ownerId,
+      name: 'Maintenance Thread Spoon',
+      provider: 'github',
+      upstreamOwner: 'upstream',
+      upstreamRepo: 'editor',
+      upstreamDefaultBranch: 'main',
+      upstreamUrl: 'https://github.com/upstream/editor',
+      forkOwner: 'team',
+      forkRepo: 'editor-spoon',
+      forkUrl: 'https://github.com/team/editor-spoon',
+      visibility: 'private',
+      maintenanceMode: 'watch',
+      syncCadence: 'daily',
+      productionRefStrategy: 'default_branch',
+      status: 'active',
+      createdAt: now,
+      updatedAt: now,
+    });
+    return { ownerId, spoonId };
+  });
+
+const baseArgs = (
+  ownerId: Id<'users'>,
+  spoonId: Id<'spoons'>,
+  dedupKey: string,
+) => ({
+  spoonId,
+  ownerId,
+  source: 'upstream_update' as const,
+  title: 'Upstream maintenance review',
+  summary: 'Upstream advanced; review recommended.',
+  upstreamTo: 'headsha',
+  dedupKey,
+  jobType: 'maintenance_review' as const,
+});
+
+const countSpoonThreads = async (
+  t: ReturnType<typeof convexTest>,
+  spoonId: Id<'spoons'>,
+) =>
+  await t.run(async (ctx) => {
+    const threads = await ctx.db.query('threads').collect();
+    return threads.filter((thread) => thread.spoonId === spoonId).length;
+  });
+
+describe('createMaintenanceThread dedup by key', () => {
+  test('reuses an open thread when called twice with the same dedupKey', async () => {
+    const t = convexTest(schema, modules);
+    const { ownerId, spoonId } = await seedSpoon(t);
+
+    const first = await t.mutation(
+      internal.threads.createMaintenanceThread,
+      baseArgs(ownerId, spoonId, 'base:head'),
+    );
+    const second = await t.mutation(
+      internal.threads.createMaintenanceThread,
+      baseArgs(ownerId, spoonId, 'base:head'),
+    );
+
+    expect(second).toBe(first);
+    expect(await countSpoonThreads(t, spoonId)).toBe(1);
+  });
+
+  test('creates a new thread for a different dedupKey', async () => {
+    const t = convexTest(schema, modules);
+    const { ownerId, spoonId } = await seedSpoon(t);
+
+    const first = await t.mutation(
+      internal.threads.createMaintenanceThread,
+      baseArgs(ownerId, spoonId, 'base:head1'),
+    );
+    const second = await t.mutation(
+      internal.threads.createMaintenanceThread,
+      baseArgs(ownerId, spoonId, 'base:head2'),
+    );
+
+    expect(second).not.toBe(first);
+    expect(await countSpoonThreads(t, spoonId)).toBe(2);
+  });
+
+  test('creates a new thread when the prior thread for the key is terminal', async () => {
+    const t = convexTest(schema, modules);
+    const { ownerId, spoonId } = await seedSpoon(t);
+
+    const first = await t.mutation(
+      internal.threads.createMaintenanceThread,
+      baseArgs(ownerId, spoonId, 'base:head'),
+    );
+
+    await t.run(async (ctx) => {
+      await ctx.db.patch(first, { status: 'resolved' });
+    });
+
+    const second = await t.mutation(
+      internal.threads.createMaintenanceThread,
+      baseArgs(ownerId, spoonId, 'base:head'),
+    );
+
+    expect(second).not.toBe(first);
+    expect(await countSpoonThreads(t, spoonId)).toBe(2);
+  });
+
+  test('findOpenMaintenanceThread returns the open thread by key and null when terminal', async () => {
+    const t = convexTest(schema, modules);
+    const { ownerId, spoonId } = await seedSpoon(t);
+
+    const threadId = await t.mutation(
+      internal.threads.createMaintenanceThread,
+      baseArgs(ownerId, spoonId, 'base:head'),
+    );
+
+    const found = await t.query(internal.threads.findOpenMaintenanceThread, {
+      spoonId,
+      ownerId,
+      dedupKey: 'base:head',
+    });
+    expect(found?._id).toBe(threadId);
+
+    await t.run(async (ctx) => {
+      await ctx.db.patch(threadId, { status: 'failed' });
+    });
+
+    const afterTerminal = await t.query(
+      internal.threads.findOpenMaintenanceThread,
+      { spoonId, ownerId, dedupKey: 'base:head' },
+    );
+    expect(afterTerminal).toBeNull();
+  });
+});