feat(fetch): make output.schemas.type exclusive and remove override.fetch.useSchemaResponse (orval-labs#2667)

* feat: make `output.schemas.type` exclusive and remove `override.fetch.useR Schema Response`

* chore: update fetch test

* feat: simplified fetch client import

* chore: remove old test

* fix: faild test

Author: soartec-lab

packages/core/src/types.ts

@@ -202,12 +202,12 @@ export type SchemaGenerationType = 'typescript' | 'zod';
 
 export type SchemaOptions = {
   path: string;
-  type: SchemaGenerationType | SchemaGenerationType[];
+  type: SchemaGenerationType;
 };
 
 export type NormalizedSchemaOptions = {
   path: string;
-  type: SchemaGenerationType[];
+  type: SchemaGenerationType;
 };
 
 export type OutputOptions = {
@@ -629,15 +629,13 @@ export type NormalizedFetchOptions = {
   includeHttpResponseReturnType: boolean;
   forceSuccessResponse: boolean;
   jsonReviver?: Mutator;
-  useZodSchemaResponse: boolean;
   runtimeValidation: boolean;
 };
 
 export type FetchOptions = {
   includeHttpResponseReturnType?: boolean;
   forceSuccessResponse?: boolean;
   jsonReviver?: Mutator;
-  useZodSchemaResponse?: boolean;
   runtimeValidation?: boolean;
 };
 

packages/fetch/src/index.ts

@@ -45,14 +45,6 @@ const FETCH_DEPENDENCIES: GeneratorDependency[] = [
 
 export const getFetchDependencies = () => FETCH_DEPENDENCIES;
 
-const PRIMITIVE_TYPES = new Set([
-  'string',
-  'number',
-  'boolean',
-  'void',
-  'unknown',
-]);
-
 export const generateRequestFunction = (
   {
     queryParams,
@@ -169,7 +161,14 @@ ${
   );
 
   const responseType = response.definition.success;
-  const isPrimitiveType = PRIMITIVE_TYPES.has(responseType);
+
+  const isPrimitiveType = [
+    'string',
+    'number',
+    'boolean',
+    'void',
+    'unknown',
+  ].includes(responseType);
   const hasSchema = response.imports.some((imp) => imp.name === responseType);
 
   const isValidateResponse =
@@ -204,12 +203,7 @@ ${
     )
     .map((r) => {
       const name = `${responseTypeName}${pascal(r.key)}${'suffix' in r ? r.suffix : ''}`;
-
-      const hasValidZodSchema = r.value && !PRIMITIVE_TYPES.has(r.value);
-      const dataType =
-        override.fetch.useZodSchemaResponse && hasValidZodSchema
-          ? `zod.infer<typeof ${r.value}>`
-          : r.value || 'unknown';
+      const dataType = r.value || 'unknown';
 
       return {
         name,
@@ -413,57 +407,24 @@ export const fetchResponseTypeName = (
 export const generateClient: ClientBuilder = (
   verbOptions,
   options,
-  outputClient,
+  _outputClient,
   output,
 ) => {
   const imports = generateVerbImports(verbOptions);
   const functionImplementation = generateRequestFunction(verbOptions, options);
 
-  const isZodSchemaImportsRequired =
-    verbOptions.override.fetch.useZodSchemaResponse ||
-    verbOptions.override.fetch.runtimeValidation;
-
-  const responseImports = isZodSchemaImportsRequired
-    ? [
-        ...verbOptions.response.types.success,
-        ...verbOptions.response.types.errors,
-      ].flatMap((response) =>
-        response.imports.map((imp) => ({
-          name: imp.name,
-          schemaName: imp.name,
-          isZodSchema: true,
-          values: true,
-        })),
-      )
-    : [];
-
-  const requestImports = isZodSchemaImportsRequired
-    ? [
-        ...verbOptions.body.imports,
-        ...(verbOptions.queryParams
-          ? [{ name: `${pascal(verbOptions.operationName)}QueryParams` }]
-          : []),
-        ...(verbOptions.headers
-          ? [{ name: `${pascal(verbOptions.operationName)}Header` }]
-          : []),
-      ].map((imp) => ({
-        name: imp.name,
-        schemaName: imp.name,
-        isZodSchema: true,
-        values: true,
-      }))
-    : [];
-
-  const zodSchemaImports = [...responseImports, ...requestImports];
+  const isZodSchema =
+    isObject(output?.schemas) && output.schemas.type === 'zod';
 
-  const zodSchemaNames = new Set(zodSchemaImports.map((imp) => imp.name));
-  const filteredImports = imports.filter(
-    (imp) => !zodSchemaNames.has(imp.name),
-  );
+  const generateImports = imports.map((imp) => ({
+    ...imp,
+    isZodSchema: isZodSchema,
+    values: isZodSchema ? true : imp.values,
+  }));
 
   return {
     implementation: `${functionImplementation}\n`,
-    imports: [...filteredImports, ...zodSchemaImports],
+    imports: generateImports,
   };
 };
 

packages/orval/src/client.ts

@@ -246,7 +246,12 @@ export const generateOperations = (
         outputClient,
         output,
       );
-      const client = await generatorClient(verbOption, options, outputClient);
+      const client = await generatorClient(
+        verbOption,
+        options,
+        outputClient,
+        output,
+      );
 
       if (!client.implementation) {
         return acc;

packages/orval/src/utils/options.ts

@@ -96,13 +96,9 @@ function normalizeSchemasOption(
     return normalizePath(schemas, workspace);
   }
 
-  const types: SchemaGenerationType[] = Array.isArray(schemas.type)
-    ? schemas.type
-    : [schemas.type];
-
   return {
     path: normalizePath(schemas.path, workspace),
-    type: types,
+    type: schemas.type,
   };
 }
 
@@ -370,8 +366,6 @@ export async function normalizeOptions(
             true,
           forceSuccessResponse:
             outputOptions.override?.fetch?.forceSuccessResponse ?? false,
-          useZodSchemaResponse:
-            outputOptions.override?.fetch?.useZodSchemaResponse ?? false,
           runtimeValidation:
             outputOptions.override?.fetch?.runtimeValidation ?? false,
           ...outputOptions.override?.fetch,

packages/orval/src/write-specs.ts

@@ -65,49 +65,45 @@ export async function writeSpecs(
         indexFiles: output.indexFiles,
       });
     } else {
-      const types: SchemaGenerationType[] = Array.isArray(output.schemas.type)
-        ? output.schemas.type
-        : [output.schemas.type];
+      const schemaType = output.schemas.type;
 
-      for (const schemaType of types) {
-        if (schemaType === 'typescript') {
-          const fileExtension = output.fileExtension || '.ts';
+      if (schemaType === 'typescript') {
+        const fileExtension = output.fileExtension || '.ts';
 
-          await writeSchemas({
-            schemaPath: output.schemas.path,
-            schemas,
-            target,
-            namingConvention: output.namingConvention,
-            fileExtension,
-            header,
-            indexFiles: output.indexFiles,
-          });
-        } else if (schemaType === 'zod') {
-          const fileExtension = '.zod.ts';
+        await writeSchemas({
+          schemaPath: output.schemas.path,
+          schemas,
+          target,
+          namingConvention: output.namingConvention,
+          fileExtension,
+          header,
+          indexFiles: output.indexFiles,
+        });
+      } else if (schemaType === 'zod') {
+        const fileExtension = '.zod.ts';
+
+        await writeZodSchemas(
+          builder,
+          output.schemas.path,
+          fileExtension,
+          header,
+          output,
+        );
 
-          await writeZodSchemas(
-            builder,
+        if (builder.verbOptions) {
+          await writeZodSchemasFromVerbs(
+            builder.verbOptions,
             output.schemas.path,
             fileExtension,
             header,
             output,
-          );
-
-          if (builder.verbOptions) {
-            await writeZodSchemasFromVerbs(
-              builder.verbOptions,
-              output.schemas.path,
-              fileExtension,
-              header,
+            {
+              spec: builder.spec,
+              target: builder.target,
+              workspace,
               output,
-              {
-                spec: builder.spec,
-                target: builder.target,
-                workspace,
-                output,
-              },
-            );
-          }
+            },
+          );
         }
       }
     }

tests/configs/default.config.ts

@@ -530,17 +530,4 @@ export default defineConfig({
       target: '../specifications/petstore.yaml',
     },
   },
-  'schemas-zod-and-typescript': {
-    output: {
-      target: '../generated/default/schemas-zod-and-typescript/endpoints.ts',
-      schemas: {
-        path: '../generated/default/schemas-zod-and-typescript/model',
-        type: ['typescript', 'zod'],
-      },
-      client: 'fetch',
-    },
-    input: {
-      target: '../specifications/petstore.yaml',
-    },
-  },
 });

tests/configs/fetch.config.ts

@@ -299,12 +299,11 @@ export default defineConfig({
       target: '../generated/fetch/zod-schema-response-single/endpoints.ts',
       schemas: {
         path: '../generated/fetch/zod-schema-response-single/model',
-        type: ['typescript', 'zod'],
+        type: 'zod',
       },
       client: 'fetch',
       override: {
         fetch: {
-          useZodSchemaResponse: true,
           runtimeValidation: true,
         },
       },
@@ -318,14 +317,13 @@ export default defineConfig({
       target: '../generated/fetch/zod-schema-response-split/endpoints.ts',
       schemas: {
         path: '../generated/fetch/zod-schema-response-split/model',
-        type: ['typescript', 'zod'],
+        type: 'zod',
       },
       mode: 'split',
       indexFiles: false,
       client: 'fetch',
       override: {
         fetch: {
-          useZodSchemaResponse: true,
           runtimeValidation: true,
         },
       },
@@ -339,13 +337,12 @@ export default defineConfig({
       target: '../generated/fetch/zod-schema-response-tags/endpoints.ts',
       schemas: {
         path: '../generated/fetch/zod-schema-response-tags/model',
-        type: ['typescript', 'zod'],
+        type: 'zod',
       },
       mode: 'tags',
       client: 'fetch',
       override: {
         fetch: {
-          useZodSchemaResponse: true,
           runtimeValidation: true,
         },
       },
@@ -359,13 +356,12 @@ export default defineConfig({
       target: '../generated/fetch/zod-schema-response-tags-split/endpoints.ts',
       schemas: {
         path: '../generated/fetch/zod-schema-response-tags-split/model',
-        type: ['typescript', 'zod'],
+        type: 'zod',
       },
       mode: 'tags-split',
       client: 'fetch',
       override: {
         fetch: {
-          useZodSchemaResponse: true,
           runtimeValidation: true,
         },
       },