fix(tests): eliminate empty image-occurrence-set race in integration seeding

Address intermittent CI failures caused by concurrent creation of the shared empty image occurrence set.

Root cause:
- integration helpers seeded ImageOccurrenceSet via upsert on the same occurrencesHash from concurrent test flows
- under contention, Prisma intermittently surfaced P2002 unique-constraint errors, producing flaky API integration failures

Changes:
- add getOrCreateEmptyImageOccurrenceSet() in api-endpoints.integration.shared.ts
- replace direct imageOccurrenceSet upsert in ensurePostVersionForSeed() with the new helper
- add explicit unique-constraint handling (code P2002) and race recovery by reloading the raced row
- keep helper promise-cached per process for the shared empty occurrence-set row to reduce duplicate concurrent create attempts
- harden production-side createOrFindByUniqueConstraint in post.ts with bounded retry after unique-constraint races before rethrowing

Validation:
- pnpm typecheck passed
- pnpm lint:ci passed
- pnpm run test:integration:api passed
- stress check: pnpm run test:integration:api passed 5 consecutive times

Author: hugbubby

src/typescript/api/src/lib/trpc/routes/post.ts

@@ -93,6 +93,8 @@ const WIKIPEDIA_HOST_REGEX = /^([a-z0-9-]+)(?:\.m)?\.wikipedia\.org$/i;
 const WIKIPEDIA_ARTICLE_PATH_PREFIX = "/wiki/";
 const WIKIPEDIA_INDEX_PATH_REGEX = /^\/w\/index\.php(?:[/?#]|$)/i;
 const WIKIPEDIA_PAGE_ID_REGEX = /^\d+$/;
+const UNIQUE_CONSTRAINT_RACE_RETRY_ATTEMPTS = 30;
+const UNIQUE_CONSTRAINT_RACE_RETRY_DELAY_MS = 20;
 
 function unreachableInvestigationStatus(status: never): never {
   throw new TRPCError({
@@ -706,13 +708,17 @@ async function createOrFindByUniqueConstraint<T>(input: {
     if (!isUniqueConstraintError(error)) {
       throw error;
     }
-
-    const raced = await input.findExisting();
-    if (raced === null) {
-      throw error;
+    // In concurrent transactions, the winning insert can briefly be invisible
+    // to this transaction right after a unique-constraint conflict.
+    for (let attempt = 0; attempt < UNIQUE_CONSTRAINT_RACE_RETRY_ATTEMPTS; attempt += 1) {
+      const raced = await input.findExisting();
+      if (raced !== null) {
+        input.assertEquivalent(raced);
+        return raced;
+      }
+      await new Promise((resolve) => setTimeout(resolve, UNIQUE_CONSTRAINT_RACE_RETRY_DELAY_MS));
     }
-    input.assertEquivalent(raced);
-    return raced;
+    throw error;
   }
 }
 

src/typescript/api/test/integration/api-endpoints.integration.shared.ts

@@ -415,11 +415,54 @@ function sha256(input: string): string {
 }
 
 const EMPTY_IMAGE_OCCURRENCES_HASH = sha256(JSON.stringify([]));
+let emptyImageOccurrenceSetPromise: Promise<{ id: string }> | null = null;
 
 function versionHashFromContentHash(contentHash: string): string {
   return sha256(`${contentHash}\n${EMPTY_IMAGE_OCCURRENCES_HASH}`);
 }
 
+function isPrismaUniqueConstraintError(error: unknown): boolean {
+  return isNonNullObject(error) && error["code"] === "P2002";
+}
+
+async function getOrCreateEmptyImageOccurrenceSet(): Promise<{ id: string }> {
+  emptyImageOccurrenceSetPromise ??= (async () => {
+    const existing = await prisma.imageOccurrenceSet.findUnique({
+      where: { occurrencesHash: EMPTY_IMAGE_OCCURRENCES_HASH },
+      select: { id: true },
+    });
+    if (existing !== null) {
+      return existing;
+    }
+
+    try {
+      return await prisma.imageOccurrenceSet.create({
+        data: { occurrencesHash: EMPTY_IMAGE_OCCURRENCES_HASH },
+        select: { id: true },
+      });
+    } catch (error) {
+      if (!isPrismaUniqueConstraintError(error)) {
+        throw error;
+      }
+      const raced = await prisma.imageOccurrenceSet.findUnique({
+        where: { occurrencesHash: EMPTY_IMAGE_OCCURRENCES_HASH },
+        select: { id: true },
+      });
+      if (raced !== null) {
+        return raced;
+      }
+      throw error;
+    }
+  })();
+
+  try {
+    return await emptyImageOccurrenceSetPromise;
+  } catch (error) {
+    emptyImageOccurrenceSetPromise = null;
+    throw error;
+  }
+}
+
 async function ensurePostVersionForSeed(input: {
   postId: string;
   contentHash: string;
@@ -444,12 +487,7 @@ async function ensurePostVersionForSeed(input: {
       },
       select: { id: true },
     }),
-    prisma.imageOccurrenceSet.upsert({
-      where: { occurrencesHash: EMPTY_IMAGE_OCCURRENCES_HASH },
-      create: { occurrencesHash: EMPTY_IMAGE_OCCURRENCES_HASH },
-      update: {},
-      select: { id: true },
-    }),
+    getOrCreateEmptyImageOccurrenceSet(),
   ]);
 
   const now = new Date();