fix: resolve name collisions

Ticket: DX-2854

This commit resolves name collisions by appending a collision number to
the component name

Author: starfy84

packages/openapi-generator/src/cli.ts

@@ -157,13 +157,35 @@ const app = command({
         ...Object.values(route.response),
       ];
     });
+    const componentLocations: Record<string, string> = {};
+    const componentCollisionCounters: Record<string, number> = {};
+
+    // Helper to generate unique component names (name, name1, name2, ...)
+    const getUniqueComponentName = (name: string): string => {
+      if (components[name] === undefined) {
+        return name;
+      }
+      const counter = (componentCollisionCounters[name] ?? 0) + 1;
+      componentCollisionCounters[name] = counter;
+      return `${name}${counter}`;
+    };
+
     let schema: Schema | undefined;
     while (((schema = queue.pop()), schema !== undefined)) {
       const refs = getRefs(schema, project.getTypes());
       for (const ref of refs) {
-        if (components[ref.name] !== undefined) {
+        if (
+          components[ref.name] !== undefined &&
+          componentLocations[ref.name] === ref.location
+        ) {
           continue;
         }
+
+        const componentName =
+          components[ref.name] !== undefined
+            ? getUniqueComponentName(ref.name)
+            : ref.name;
+
         const sourceFile = project.get(ref.location);
         if (sourceFile === undefined) {
           logError(`Could not find '${ref.name}' from '${ref.location}'`);
@@ -217,7 +239,8 @@ const app = command({
           codecE.right.comment = comment;
         }
 
-        components[ref.name] = codecE.right;
+        components[componentName] = codecE.right;
+        componentLocations[componentName] = ref.location;
         queue.push(codecE.right);
       }
     }

packages/openapi-generator/src/project.ts

@@ -16,26 +16,39 @@ export class Project {
   private processedFiles: Record<string, SourceFile>;
   private pendingFiles: Set<string>;
   private types: Record<string, string>;
+  private typeCollisionCounters: Record<string, number>;
   private visitedPackages: Set<string>;
 
   constructor(files: Record<string, SourceFile> = {}, knownImports = KNOWN_IMPORTS) {
     this.processedFiles = files;
     this.pendingFiles = new Set();
     this.knownImports = knownImports;
     this.types = {};
+    this.typeCollisionCounters = {};
     this.visitedPackages = new Set();
   }
 
   add(path: string, sourceFile: SourceFile): void {
     this.processedFiles[path] = sourceFile;
     this.pendingFiles.delete(path);
 
-    // Update types mapping
+    // Update types mapping with collision handling
     for (const exp of sourceFile.symbols.exports) {
-      this.types[exp.exportedName] = path;
+      const name = this.getUniqueTypeName(exp.exportedName);
+      this.types[name] = path;
     }
   }
 
+  private getUniqueTypeName(name: string): string {
+    if (this.types[name] === undefined) {
+      return name;
+    }
+
+    const counter = (this.typeCollisionCounters[name] ?? 0) + 1;
+    this.typeCollisionCounters[name] = counter;
+    return `${name}${counter}`;
+  }
+
   get(path: string): SourceFile | undefined {
     return this.processedFiles[path];
   }
@@ -62,11 +75,6 @@ export class Project {
           continue;
         }
 
-        // map types to their file path
-        for (const exp of sourceFile.symbols.exports) {
-          this.types[exp.exportedName] = path;
-        }
-
         this.add(path, sourceFile);
 
         // Process imports

packages/openapi-generator/test/externalModule.test.ts

@@ -199,3 +199,43 @@ testCase(
   {},
   {},
 );
+
+test('handles name collisions with numbered suffixes (name, name1, name2, ...)', async () => {
+  const project = new Project({}, KNOWN_IMPORTS);
+  const entryPointPath = p.resolve('test/sample-types/nameCollision.ts');
+  await project.parseEntryPoint(entryPointPath);
+
+  const types = project.getTypes();
+
+  const pkgAPath = p.resolve('test/sample-types/node_modules/@test/pkg-a/src/index.ts');
+  const pkgBPath = p.resolve('test/sample-types/node_modules/@test/pkg-b/src/index.ts');
+
+  const sharedTypePath = types['SharedType'];
+  assert.ok(
+    sharedTypePath === pkgAPath || sharedTypePath === pkgBPath,
+    'SharedType should map to whichever package was processed first',
+  );
+
+  const sharedType1Path = types['SharedType1'];
+  assert.ok(
+    sharedType1Path === pkgAPath || sharedType1Path === pkgBPath,
+    'SharedType1 should map to the other package',
+  );
+
+  // They should be different
+  assert.notEqual(
+    sharedTypePath,
+    sharedType1Path,
+    'SharedType and SharedType1 should map to different packages',
+  );
+
+  // SharedTypeCodec should be mapped normally
+  assert.equal(types['SharedTypeCodec'], pkgBPath);
+
+  // Verify both files were parsed correctly
+  const pkgAFile = project.get(pkgAPath);
+  const pkgBFile = project.get(pkgBPath);
+
+  assert.notEqual(pkgAFile, undefined, 'pkg-a file should be parsed');
+  assert.notEqual(pkgBFile, undefined, 'pkg-b file should be parsed');
+});

packages/openapi-generator/test/sample-types/nameCollision.ts

@@ -0,0 +1,10 @@
+import * as t from 'io-ts';
+import { SharedType } from '@test/pkg-a';
+import { SharedTypeCodec } from '@test/pkg-b';
+
+// This file uses SharedType from pkg-a
+// and SharedTypeCodec from pkg-b (which internally has its own SharedType)
+export const MyCodec = t.type({
+  state: SharedType,
+  otherState: SharedTypeCodec,
+});