fix(parser): add format to deduplcation strategy

Author: mrlubos

.changeset/poor-stingrays-remember.md

@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+fix(parser): do not mark schemas as duplicate if they have different format

packages/openapi-ts-tests/test/__snapshots__/3.1.x/plugins/valibot/default/valibot.gen.ts

@@ -1089,7 +1089,10 @@ export const vApiVVersionODataControllerCountResponse = vModelFromZendesk;
 /**
  * foo in method
  */
-export const vGetApiVbyApiVersionSimpleOperationParameterFooParam = v.string();
+export const vGetApiVbyApiVersionSimpleOperationParameterFooParam = v.union([
+    v.string(),
+    v.pipe(v.string(), v.uuid())
+]);
 
 /**
  * Response is a simple number

packages/openapi-ts-tests/test/__snapshots__/3.1.x/plugins/zod/default/zod.gen.ts

@@ -1110,7 +1110,10 @@ export const zGetApiVbyApiVersionSimpleOperationData = z.object({
     body: z.never().optional(),
     headers: z.never().optional(),
     path: z.object({
-        foo_param: z.string()
+        foo_param: z.union([
+            z.string(),
+            z.string().uuid()
+        ])
     }),
     query: z.never().optional()
 });

packages/openapi-ts-tests/test/openapi-ts.config.ts

@@ -57,7 +57,7 @@ export default defineConfig(() => {
       //   'invalid',
       //   'servers-entry.yaml',
       // ),
-      path: path.resolve(__dirname, 'spec', '3.1.x', 'full.yaml'),
+      path: path.resolve(__dirname, 'spec', '3.1.x', 'validators.yaml'),
       // path: path.resolve(__dirname, 'spec', 'v3-transforms.json'),
       // path: 'http://localhost:4000/',
       // path: 'https://get.heyapi.dev/',
@@ -124,13 +124,13 @@ export default defineConfig(() => {
         // responseStyle: 'data',
         // throwOnError: true,
         // transformer: '@hey-api/transformers',
-        transformer: true,
-        validator: 'valibot',
+        // transformer: true,
+        validator: 'zod',
       },
       {
         // bigInt: true,
         dates: true,
-        name: '@hey-api/transformers',
+        // name: '@hey-api/transformers',
       },
       {
         enums: 'typescript+namespace',
@@ -152,14 +152,14 @@ export default defineConfig(() => {
         infiniteQueryKeyNameBuilder: '{{name}}IQK',
         infiniteQueryOptionsNameBuilder: '{{name}}InfiniteQuery',
         mutationOptionsNameBuilder: '{{name}}MutationOptions',
-        name: '@tanstack/react-query',
+        // name: '@tanstack/react-query',
         queryKeyNameBuilder: '{{name}}QK',
         queryOptionsNameBuilder: '{{name}}Query',
       },
       {
         // comments: false,
         // exportFromIndex: true,
-        name: 'valibot',
+        // name: 'valibot',
       },
       {
         // case: 'snake_case',

packages/openapi-ts/src/ir/__tests__/schema.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+
+import { deduplicateSchema } from '../schema';
+import type { IR } from '../types';
+
+describe('deduplicateSchema', () => {
+  const scenarios: ReadonlyArray<{
+    description: string;
+    detectFormat?: boolean;
+    result: IR.SchemaObject;
+    schema: IR.SchemaObject;
+  }> = [
+    {
+      description: 'keeps multiple strings if they have different formats',
+      result: {
+        items: [
+          {
+            format: 'uuid',
+            type: 'string',
+          },
+          {
+            type: 'string',
+          },
+        ],
+        logicalOperator: 'or',
+      },
+      schema: {
+        items: [
+          {
+            format: 'uuid',
+            type: 'string',
+          },
+          {
+            type: 'string',
+          },
+        ],
+        logicalOperator: 'or',
+      },
+    },
+    {
+      description:
+        'discards duplicate strings if they have different formats and `detectFormat` is `false`',
+      detectFormat: false,
+      result: {
+        format: 'uuid',
+        type: 'string',
+      },
+      schema: {
+        items: [
+          {
+            format: 'uuid',
+            type: 'string',
+          },
+          {
+            type: 'string',
+          },
+        ],
+        logicalOperator: 'or',
+      },
+    },
+  ];
+
+  it.each(scenarios)('$description', ({ detectFormat, result, schema }) => {
+    expect(deduplicateSchema({ detectFormat, schema })).toEqual(result);
+  });
+});

packages/openapi-ts/src/ir/parser.ts

@@ -7,8 +7,10 @@ import type { IR } from './types';
 export const parseIR = async ({ context }: { context: IR.Context }) => {
   await context.broadcast('before');
 
-  for (const server of context.ir.servers ?? []) {
-    await context.broadcast('server', { server });
+  if (context.ir.servers) {
+    for (const server of context.ir.servers) {
+      await context.broadcast('server', { server });
+    }
   }
 
   if (context.ir.components) {

packages/openapi-ts/src/ir/schema.ts

@@ -4,8 +4,10 @@ import type { IR } from './types';
  * Ensure we don't produce redundant types, e.g. string | string.
  */
 export const deduplicateSchema = <T extends IR.SchemaObject>({
+  detectFormat = true,
   schema,
 }: {
+  detectFormat?: boolean;
   schema: T;
 }): T => {
   if (!schema.items) {
@@ -35,7 +37,12 @@ export const deduplicateSchema = <T extends IR.SchemaObject>({
     ) {
       // const needs namespace to handle empty string values, otherwise
       // fallback would equal an actual value and we would skip an item
-      const typeId = `${item.$ref ?? ''}${item.type ?? ''}${item.const !== undefined ? `const-${item.const}` : ''}`;
+      const constant = item.const !== undefined ? `const-${item.const}` : '';
+      const format =
+        item.format !== undefined && detectFormat
+          ? `format-${item.format}`
+          : '';
+      const typeId = `${item.$ref ?? ''}${item.type ?? ''}${constant}${format}`;
       if (!typeIds.includes(typeId)) {
         typeIds.push(typeId);
         uniqueItems.push(item);
@@ -46,28 +53,29 @@ export const deduplicateSchema = <T extends IR.SchemaObject>({
     uniqueItems.push(item);
   }
 
-  schema.items = uniqueItems;
+  let result = { ...schema };
+  result.items = uniqueItems;
 
   if (
-    schema.items.length <= 1 &&
-    schema.type !== 'array' &&
-    schema.type !== 'enum' &&
-    schema.type !== 'tuple'
+    result.items.length <= 1 &&
+    result.type !== 'array' &&
+    result.type !== 'enum' &&
+    result.type !== 'tuple'
   ) {
     // bring the only item up to clean up the schema
-    const liftedSchema = schema.items[0];
-    delete schema.logicalOperator;
-    delete schema.items;
-    schema = {
-      ...schema,
+    const liftedSchema = result.items[0];
+    delete result.logicalOperator;
+    delete result.items;
+    result = {
+      ...result,
       ...liftedSchema,
     };
   }
 
   // exclude unknown if it's the only type left
-  if (schema.type === 'unknown') {
+  if (result.type === 'unknown') {
     return {} as T;
   }
 
-  return schema;
+  return result;
 };

packages/openapi-ts/src/plugins/@hey-api/typescript/plugin.ts

@@ -367,7 +367,7 @@ const arrayTypeToIdentifier = ({
     );
   }
 
-  schema = deduplicateSchema({ schema });
+  schema = deduplicateSchema({ detectFormat: false, schema });
 
   const itemTypes: Array<ts.TypeNode> = [];
 
@@ -859,6 +859,7 @@ const irParametersToIrSchema = ({
       const parameter = parameters[key]!;
 
       properties[parameter.name] = deduplicateSchema({
+        detectFormat: false,
         schema: parameter.schema,
       });
 
@@ -1233,7 +1234,7 @@ export const schemaToType = ({
       state,
     });
   } else if (schema.items) {
-    schema = deduplicateSchema({ schema });
+    schema = deduplicateSchema({ detectFormat: false, schema });
     if (schema.items) {
       const itemTypes: Array<ts.TypeNode> = [];