fix: Avoid swap-file races when multiple plugin instances share a tadaOutputLocation

.changeset/hungry-pugs-tap.md

@@ -0,0 +1,5 @@
+---
+'@0no-co/graphqlsp': patch
+---
+
+Fix intermittent `ENOENT: no such file or directory, unlink '<output>.d.ts.tmp'` failures when multiple plugin instances write the same `tadaOutputLocation`, e.g. several TS projects in a monorepo extending a shared tsconfig. The typings swap-file now has a unique name per process and write, so concurrent regenerations no longer clobber each other's swap-files, and swap-file cleanup no longer masks the original write error

packages/graphqlsp/src/graphql/getSchema.ts

@@ -38,32 +38,34 @@ const touchFile = async (file: PathLike): Promise<void> => {
   } catch (_error) {}
 };
 
+let swapFileCounter = 0;
+
 /** Writes a file to a swapfile then moves it into place to prevent excess change events. */
 export const swapWrite = async (
   target: PathLike,
   contents: string
 ): Promise<void> => {
-  if (!(await statFile(target, stat => stat.isFile()))) {
-    // If the file doesn't exist, we can write directly, and not
-    // try-catch so the error falls through
-    await fs.writeFile(target, contents);
-  } else {
-    // If the file exists, we write to a swap-file, then rename (i.e. move)
-    // the file into place. No try-catch around `writeFile` for proper
-    // directory/permission errors
-    const tempTarget = target + '.tmp';
-    await fs.writeFile(tempTarget, contents);
-    try {
-      await fs.rename(tempTarget, target);
-    } catch (error) {
-      await fs.unlink(tempTarget);
-      throw error;
-    } finally {
-      // When we move the file into place, we also update its access and
-      // modification time manually, in case the rename doesn't trigger
-      // a change event
-      await touchFile(target);
-    }
+  // We write to a swap-file, then rename (i.e. move) the file into place.
+  // No try-catch around `writeFile` for proper directory/permission errors.
+  // The swap-file's name must be unique per process and call. Multiple
+  // plugin instances may target the same output file (e.g. several TS
+  // projects in a monorepo sharing one `tadaOutputLocation`), and a
+  // shared swap-file name would let one instance rename the file away
+  // while another still expects it, while direct writes to the target
+  // could interleave
+  const tempTarget = `${target}.${process.pid}.${swapFileCounter++}.tmp`;
+  await fs.writeFile(tempTarget, contents);
+  try {
+    await fs.rename(tempTarget, target);
+  } catch (error) {
+    // Clean-up is best-effort and must not mask the rename error
+    await fs.unlink(tempTarget).catch(() => {});
+    throw error;
+  } finally {
+    // When we move the file into place, we also update its access and
+    // modification time manually, in case the rename doesn't trigger
+    // a change event
+    await touchFile(target);
   }
 };
 

test/unit/swapWrite.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { swapWrite } from '../../packages/graphqlsp/src/graphql/getSchema';
+
+let dir: string;
+
+beforeEach(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'graphqlsp-swap-write-'));
+});
+
+afterEach(async () => {
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+describe('swapWrite', () => {
+  it('writes a new file directly', async () => {
+    const target = path.join(dir, 'introspection.d.ts');
+    await swapWrite(target, 'contents');
+    expect(await fs.readFile(target, 'utf8')).toBe('contents');
+  });
+
+  it('replaces an existing file', async () => {
+    const target = path.join(dir, 'introspection.d.ts');
+    await fs.writeFile(target, 'old');
+    await swapWrite(target, 'new');
+    expect(await fs.readFile(target, 'utf8')).toBe('new');
+  });
+
+  // Multiple plugin instances may share one `tadaOutputLocation`, e.g.
+  // several TS projects in a monorepo extending the same tsconfig. See:
+  // https://github.com/0no-co/gql.tada/issues/571
+  it.each([
+    { name: 'an existing target', createTarget: true },
+    { name: 'a missing target', createTarget: false },
+  ])('tolerates concurrent writes to $name', async ({ createTarget }) => {
+    const target = path.join(dir, 'introspection.d.ts');
+    if (createTarget) await fs.writeFile(target, 'initial');
+
+    const writers = Array.from({ length: 20 }, (_, index) =>
+      swapWrite(target, `contents-${index}`)
+    );
+    await expect(Promise.all(writers)).resolves.not.toThrow();
+
+    // The last rename wins, but the target must match one write in full
+    // and no swap-files may be left behind
+    const contents = await fs.readFile(target, 'utf8');
+    expect(contents).toMatch(/^contents-\d+$/);
+    const leftovers = (await fs.readdir(dir)).filter(file =>
+      file.endsWith('.tmp')
+    );
+    expect(leftovers).toEqual([]);
+  });
+});