feat(zod): revert #1907 to not use discriminatedUnion (#2118)

* #2085 revert changes from PR1907, except for cleanup performed in that PR

* #2085 formatter

---------

Co-authored-by: Tim Misset <[email protected]>

Author: timmisset

packages/zod/src/index.ts

@@ -351,7 +351,7 @@ export const generateZodValidationSchemaDefinition = (
     case 'object':
     default: {
       if (schema.allOf || schema.oneOf || schema.anyOf) {
-        let separator = schema.allOf
+        const separator = schema.allOf
           ? 'allOf'
           : schema.oneOf
             ? 'oneOf'
@@ -362,20 +362,10 @@ export const generateZodValidationSchemaDefinition = (
           | ReferenceObject
         )[];
 
-        if (
-          (schema.oneOf || schema.anyOf) &&
-          schema.discriminator &&
-          schema.discriminator.propertyName
-        ) {
-          // store the discriminator property name in the separator to be used when building the zod schema
-          // adding discriminator property name is already handled via the deference function
-          separator = `discriminator__${schema.discriminator.propertyName}`;
-        }
-
         functions.push([
           separator,
-          schemas.map((schema) => {
-            return generateZodValidationSchemaDefinition(
+          schemas.map((schema) =>
+            generateZodValidationSchemaDefinition(
               schema as SchemaObject,
               context,
               camel(name),
@@ -384,8 +374,8 @@ export const generateZodValidationSchemaDefinition = (
               {
                 required: true,
               },
-            );
-          }),
+            ),
+          ),
         ]);
         break;
       }
@@ -558,18 +548,7 @@ export const parseZodValidationSchemaDefinition = (
         '',
       );
     }
-    if (fn.startsWith('discriminator__')) {
-      const [, propertyName] = fn.split('discriminator__');
-      const typeSchemas = args.map(
-        ({ functions }: { functions: [string, any][]; consts: string[] }) => {
-          const schemaFunctions = functions.map(parseProperty).join('');
-          return schemaFunctions;
-        },
-      );
-      return `zod.discriminatedUnion('${propertyName}', [${typeSchemas.join(
-        ',',
-      )}])`;
-    } else if (fn === 'oneOf' || fn === 'anyOf') {
+    if (fn === 'oneOf' || fn === 'anyOf') {
       return args.reduce(
         (
           acc: string,

packages/zod/src/zod.test.ts

@@ -1160,240 +1160,6 @@ describe('generatePartOfSchemaGenerateZod', () => {
   });
 });
 
-const apiSchemaWithDiscriminator: GeneratorOptions = {
-  pathRoute: '/dogs',
-  context: {
-    specKey: 'dog',
-    specs: {
-      dog: {
-        openapi: '3.0.0',
-        info: {
-          version: '1.0.0',
-          title: 'Dogs',
-        },
-        paths: {
-          '/dogs': {
-            get: {
-              summary: 'List all dogs',
-              operationId: 'listDogs',
-              tags: ['dogs'],
-              responses: {
-                '200': {
-                  description: 'A paged array of dogs',
-                  content: {
-                    'application/json': {
-                      schema: {
-                        $ref: '#/components/schemas/Dogs',
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-        components: {
-          schemas: {
-            Dogs: {
-              type: 'array',
-              items: {
-                $ref: '#/components/schemas/Dog',
-              },
-            },
-            Dog: {
-              type: 'object',
-              oneOf: [
-                {
-                  $ref: '#/components/schemas/Labradoodle',
-                },
-                {
-                  $ref: '#/components/schemas/Dachshund',
-                },
-              ],
-              required: ['type'],
-              properties: {
-                barksPerMinute: {
-                  type: 'integer',
-                },
-              },
-              discriminator: {
-                propertyName: 'breed',
-                mapping: {
-                  Labradoodle: '#/components/schemas/Labradoodle',
-                  Dachshund: '#/components/schemas/Dachshund',
-                },
-              },
-            },
-            Labradoodle: {
-              type: 'object',
-              required: ['cuteness'],
-              properties: {
-                cuteness: {
-                  type: 'integer',
-                },
-                // in the real runner breed is added by getApiSchemas in import-open-api.ts, inferred from the discriminator
-                breed: {
-                  type: 'string',
-                  enum: ['Labradoodle'],
-                },
-              },
-            },
-            Dachshund: {
-              type: 'object',
-              required: ['length'],
-              properties: {
-                length: {
-                  type: 'integer',
-                },
-                // in the real runner breed is added by getApiSchemas in import-open-api.ts, inferred from the discriminator
-                breed: {
-                  type: 'string',
-                  enum: ['Labradoodle'],
-                },
-              },
-            },
-          },
-        },
-      },
-    },
-    output: {
-      override: {
-        zod: {
-          generateEachHttpStatus: false,
-        },
-      },
-    },
-  },
-} as const;
-
-describe('generateDiscriminatedUnionZod', () => {
-  it('generates a discriminatedUnion zod schema', async () => {
-    const result = await generateZod(
-      {
-        pathRoute: '/dogs',
-        verb: 'get',
-        operationName: 'test',
-        override: {
-          zod: {
-            strict: {
-              param: false,
-              body: false,
-              response: false,
-              query: false,
-              header: false,
-            },
-            generate: {
-              param: true,
-              body: true,
-              response: true,
-              query: true,
-              header: true,
-            },
-            coerce: {
-              param: false,
-              body: false,
-              response: false,
-              query: false,
-              header: false,
-            },
-          },
-        },
-      },
-      apiSchemaWithDiscriminator,
-      {},
-    );
-    expect(result.implementation).toBe(
-      `export const testResponseItem = zod.discriminatedUnion('breed', [zod.object({\n  "cuteness": zod.number(),\n  "breed": zod.enum(['Labradoodle']).optional()\n}),zod.object({\n  "length": zod.number(),\n  "breed": zod.enum(['Labradoodle']).optional()\n})])\nexport const testResponse = zod.array(testResponseItem)\n\n`,
-    );
-    expect(result.implementation).not.toContain('.or(zod.object');
-  });
-  it('generated discriminatedUnion zod schema strict setting', async () => {
-    const result = await generateZod(
-      {
-        pathRoute: '/dogs',
-        verb: 'get',
-        operationName: 'test',
-        override: {
-          zod: {
-            strict: {
-              param: true,
-              body: true,
-              response: true,
-              query: true,
-              header: true,
-            },
-            generate: {
-              param: true,
-              body: true,
-              response: true,
-              query: true,
-              header: true,
-            },
-            coerce: {
-              param: false,
-              body: false,
-              response: false,
-              query: false,
-              header: false,
-            },
-          },
-        },
-      },
-      apiSchemaWithDiscriminator,
-      {},
-    );
-    expect(result.implementation).toBe(
-      `export const testResponseItem = zod.discriminatedUnion('breed', [zod.object({\n  "cuteness": zod.number(),\n  "breed": zod.enum(['Labradoodle']).optional()\n}).strict(),zod.object({\n  "length": zod.number(),\n  "breed": zod.enum(['Labradoodle']).optional()\n}).strict()])\nexport const testResponse = zod.array(testResponseItem)\n\n`,
-    );
-  });
-  it('does not generate a discriminatedUnion zod schema when discriminator is absent', async () => {
-    const schemaWithoutDiscriminator = { ...apiSchemaWithDiscriminator };
-    const dogSchema = schemaWithoutDiscriminator.context.specs['dog']
-      .components!.schemas!['Dog'] as SchemaObject;
-    delete dogSchema.discriminator;
-    const result = await generateZod(
-      {
-        pathRoute: '/dogs',
-        verb: 'get',
-        operationName: 'test',
-        override: {
-          zod: {
-            strict: {
-              param: false,
-              body: false,
-              response: false,
-              query: false,
-              header: false,
-            },
-            generate: {
-              param: true,
-              body: true,
-              response: true,
-              query: true,
-              header: true,
-            },
-            coerce: {
-              param: false,
-              body: false,
-              response: false,
-              query: false,
-              header: false,
-            },
-          },
-        },
-      },
-      apiSchemaWithDiscriminator,
-      {},
-    );
-    expect(result.implementation).toBe(
-      `export const testResponseItem = zod.object({\n  "cuteness": zod.number(),\n  "breed": zod.enum(['Labradoodle']).optional()\n}).or(zod.object({\n  "length": zod.number(),\n  "breed": zod.enum(['Labradoodle']).optional()\n}))\nexport const testResponse = zod.array(testResponseItem)\n\n`,
-    );
-    expect(result.implementation).not.toContain(
-      "zod.discriminatedUnion('breed'",
-    );
-  });
-});
-
 describe('parsePrefixItemsArrayAsTupleZod', () => {
   it('generates correctly', async () => {
     const arrayWithPrefixItemsSchema: SchemaObject31 = {