fix(codegen): prune stale generated files

Author: yyyyaaa

graphql/codegen/src/__tests__/codegen/write-generated-files.test.ts

@@ -0,0 +1,61 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { writeGeneratedFiles } from '../../core/output';
+
+describe('writeGeneratedFiles', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegen-write-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('removes stale TypeScript files when pruneStaleFiles is enabled', async () => {
+    const staleRoot = path.join(tempDir, 'stale.ts');
+    const staleNested = path.join(tempDir, 'nested', 'old.ts');
+    fs.mkdirSync(path.dirname(staleNested), { recursive: true });
+    fs.writeFileSync(staleRoot, 'export const stale = true;\n');
+    fs.writeFileSync(staleNested, 'export const old = true;\n');
+
+    const result = await writeGeneratedFiles(
+      [{ path: 'nested/new.ts', content: 'export const fresh = true;\n' }],
+      tempDir,
+      [],
+      {
+        showProgress: false,
+        formatFiles: false,
+        pruneStaleFiles: true,
+      },
+    );
+
+    expect(result.success).toBe(true);
+    expect(fs.existsSync(staleRoot)).toBe(false);
+    expect(fs.existsSync(staleNested)).toBe(false);
+    expect(fs.existsSync(path.join(tempDir, 'nested', 'new.ts'))).toBe(true);
+  });
+
+  it('keeps existing files when pruneStaleFiles is disabled', async () => {
+    const staleRoot = path.join(tempDir, 'stale.ts');
+    fs.writeFileSync(staleRoot, 'export const stale = true;\n');
+
+    const result = await writeGeneratedFiles(
+      [{ path: 'fresh.ts', content: 'export const fresh = true;\n' }],
+      tempDir,
+      [],
+      {
+        showProgress: false,
+        formatFiles: false,
+        pruneStaleFiles: false,
+      },
+    );
+
+    expect(result.success).toBe(true);
+    expect(fs.existsSync(staleRoot)).toBe(true);
+    expect(fs.existsSync(path.join(tempDir, 'fresh.ts'))).toBe(true);
+  });
+});

graphql/codegen/src/core/generate.ts

@@ -4,7 +4,7 @@
  * This is the primary entry point for programmatic usage.
  * The CLI is a thin wrapper around this function.
  */
-import path from 'path';
+import path from 'node:path';
 
 import type { GraphQLSDKConfigTarget } from '../types/config';
 import { getConfigOptions } from '../types/config';
@@ -79,12 +79,12 @@ export async function generate(
     endpoint: config.endpoint || undefined,
     schemaFile: config.schemaFile || undefined,
     db: config.db,
-    authorization: options.authorization || config.headers?.['Authorization'],
+    authorization: options.authorization || config.headers?.Authorization,
     headers: config.headers,
   });
 
   // Run pipeline
-  let pipelineResult;
+  let pipelineResult: Awaited<ReturnType<typeof runCodegenPipeline>>;
   try {
     console.log(`Fetching schema from ${source.describe()}...`);
     pipelineResult = await runCodegenPipeline({
@@ -115,6 +115,7 @@ export async function generate(
 
   const allFilesWritten: string[] = [];
   const bothEnabled = runReactQuery && runOrm;
+  const filesToWrite: Array<{ path: string; content: string }> = [];
 
   // Generate shared types when both are enabled
   if (bothEnabled) {
@@ -128,28 +129,11 @@ export async function generate(
       },
       config,
     });
-
-    if (!options.dryRun) {
-      const writeResult = await writeGeneratedFiles(
-        sharedResult.files,
-        outputRoot,
-        [],
-      );
-      if (!writeResult.success) {
-        return {
-          success: false,
-          message: `Failed to write shared types: ${writeResult.errors?.join(', ')}`,
-          output: outputRoot,
-          errors: writeResult.errors,
-        };
-      }
-      allFilesWritten.push(...(writeResult.filesWritten ?? []));
-    }
+    filesToWrite.push(...sharedResult.files);
   }
 
   // Generate React Query hooks
   if (runReactQuery) {
-    const hooksDir = path.join(outputRoot, 'hooks');
     console.log('Generating React Query hooks...');
     const { files } = generateReactQueryFiles({
       tables,
@@ -161,27 +145,16 @@ export async function generate(
       config,
       sharedTypesPath: bothEnabled ? '..' : undefined,
     });
-
-    if (!options.dryRun) {
-      const writeResult = await writeGeneratedFiles(files, hooksDir, [
-        'queries',
-        'mutations',
-      ]);
-      if (!writeResult.success) {
-        return {
-          success: false,
-          message: `Failed to write React Query hooks: ${writeResult.errors?.join(', ')}`,
-          output: outputRoot,
-          errors: writeResult.errors,
-        };
-      }
-      allFilesWritten.push(...(writeResult.filesWritten ?? []));
-    }
+    filesToWrite.push(
+      ...files.map((file) => ({
+        ...file,
+        path: path.posix.join('hooks', file.path),
+      })),
+    );
   }
 
   // Generate ORM client
   if (runOrm) {
-    const ormDir = path.join(outputRoot, 'orm');
     console.log('Generating ORM client...');
     const { files } = generateOrmFiles({
       tables,
@@ -193,38 +166,36 @@ export async function generate(
       config,
       sharedTypesPath: bothEnabled ? '..' : undefined,
     });
-
-    if (!options.dryRun) {
-      const writeResult = await writeGeneratedFiles(files, ormDir, [
-        'models',
-        'query',
-        'mutation',
-      ]);
-      if (!writeResult.success) {
-        return {
-          success: false,
-          message: `Failed to write ORM client: ${writeResult.errors?.join(', ')}`,
-          output: outputRoot,
-          errors: writeResult.errors,
-        };
-      }
-      allFilesWritten.push(...(writeResult.filesWritten ?? []));
-    }
+    filesToWrite.push(
+      ...files.map((file) => ({
+        ...file,
+        path: path.posix.join('orm', file.path),
+      })),
+    );
   }
 
   // Generate barrel file at output root
   // This re-exports from the appropriate subdirectories based on which generators are enabled
+  const barrelContent = generateRootBarrel({
+    hasTypes: bothEnabled,
+    hasHooks: runReactQuery,
+    hasOrm: runOrm,
+  });
+  filesToWrite.push({ path: 'index.ts', content: barrelContent });
+
   if (!options.dryRun) {
-    const barrelContent = generateRootBarrel({
-      hasTypes: bothEnabled,
-      hasHooks: runReactQuery,
-      hasOrm: runOrm,
+    const writeResult = await writeGeneratedFiles(filesToWrite, outputRoot, [], {
+      pruneStaleFiles: true,
     });
-    await writeGeneratedFiles(
-      [{ path: 'index.ts', content: barrelContent }],
-      outputRoot,
-      [],
-    );
+    if (!writeResult.success) {
+      return {
+        success: false,
+        message: `Failed to write generated files: ${writeResult.errors?.join(', ')}`,
+        output: outputRoot,
+        errors: writeResult.errors,
+      };
+    }
+    allFilesWritten.push(...(writeResult.filesWritten ?? []));
   }
 
   const generators = [runReactQuery && 'React Query', runOrm && 'ORM']

graphql/codegen/src/core/output/writer.ts

@@ -17,6 +17,7 @@ export type { GeneratedFile };
 export interface WriteResult {
   success: boolean;
   filesWritten?: string[];
+  filesRemoved?: string[];
   errors?: string[];
 }
 
@@ -28,6 +29,8 @@ export interface WriteOptions {
   showProgress?: boolean;
   /** Format files with oxfmt after writing (default: true) */
   formatFiles?: boolean;
+  /** Remove stale .ts files in outputDir that are not in current file list (default: false) */
+  pruneStaleFiles?: boolean;
 }
 
 type OxfmtFormatFn = (
@@ -85,9 +88,14 @@ export async function writeGeneratedFiles(
   subdirs: string[],
   options: WriteOptions = {},
 ): Promise<WriteResult> {
-  const { showProgress = true, formatFiles = true } = options;
+  const {
+    showProgress = true,
+    formatFiles = true,
+    pruneStaleFiles = false,
+  } = options;
   const errors: string[] = [];
   const written: string[] = [];
+  const removed: string[] = [];
   const total = files.length;
   const isTTY = process.stdout.isTTY;
 
@@ -117,6 +125,25 @@ export async function writeGeneratedFiles(
     return { success: false, errors };
   }
 
+  if (pruneStaleFiles) {
+    const expectedFiles = new Set(
+      files.map((file) => path.resolve(outputDir, file.path)),
+    );
+    const existingTsFiles = findTsFiles(outputDir);
+
+    for (const existingFile of existingTsFiles) {
+      const absolutePath = path.resolve(existingFile);
+      if (expectedFiles.has(absolutePath)) continue;
+      try {
+        fs.rmSync(absolutePath, { force: true });
+        removed.push(absolutePath);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        errors.push(`Failed to remove stale file ${absolutePath}: ${message}`);
+      }
+    }
+  }
+
   // Get oxfmt format function if formatting is enabled
   const formatFn = formatFiles ? await getOxfmtFormat() : null;
   if (formatFiles && !formatFn && showProgress) {
@@ -171,6 +198,7 @@ export async function writeGeneratedFiles(
   return {
     success: errors.length === 0,
     filesWritten: written,
+    filesRemoved: removed,
     errors: errors.length > 0 ? errors : undefined,
   };
 }