feat: added option to coerce specific types in plugin-zod

.changeset/stupid-jeans-rush.md

@@ -0,0 +1,5 @@
+---
+"@kubb/plugin-zod": minor
+---
+
+Added coercion for specific types only

docs/plugins/plugin-zod/index.md

@@ -185,7 +185,7 @@ Use of z.coerce.string() instead of z.string().
 
 |           |           |
 |----------:|:----------|
-|     Type: | `boolean` |
+|     Type: | `boolean \| { dates?: boolean, strings?: boolean, numbers?: boolean}` |
 | Required: | `false`   |
 |  Default: | `false'`  |
 
@@ -201,6 +201,11 @@ z.string()
 z.date()
 z.number()
 ```
+```typescript [{numbers: true, strings: false, dates: false}]
+z.string()
+z.date()
+z.coerce.number()
+```
 :::
 
 ### operations

packages/plugin-zod/src/generators/__snapshots__/coercion.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pet = z.object({ "id": z.coerce.number().int(), "name": z.coerce.string(), "date": z.coerce.date().optional(), "tag": z.coerce.string().min(5).max(100).optional() });

packages/plugin-zod/src/generators/__snapshots__/coercionDates.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pet = z.object({ "id": z.number().int(), "name": z.string(), "date": z.coerce.date().optional(), "tag": z.string().min(5).max(100).optional() });

packages/plugin-zod/src/generators/__snapshots__/coercionNumbers.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pet = z.object({ "id": z.coerce.number().int(), "name": z.string(), "date": z.date().optional(), "tag": z.string().min(5).max(100).optional() });

packages/plugin-zod/src/generators/__snapshots__/coercionStrings.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pet = z.object({ "id": z.number().int(), "name": z.coerce.string(), "date": z.date().optional(), "tag": z.coerce.string().min(5).max(100).optional() });

packages/plugin-zod/src/generators/zodGenerator.test.tsx

@@ -195,6 +195,38 @@ describe('zodGenerator schema', async () => {
       input: '../../mocks/discriminator.yaml',
       options: {},
     },
+    {
+      name: 'coercion',
+      path: 'Pet',
+      input: '../../mocks/petStore.yaml',
+      options: {
+        coercion: true,
+      },
+    },
+    {
+      name: 'coercion-strings',
+      path: 'Pet',
+      input: '../../mocks/petStore.yaml',
+      options: {
+        coercion: { strings: true },
+      },
+    },
+    {
+      name: 'coercion-numbers',
+      path: 'Pet',
+      input: '../../mocks/petStore.yaml',
+      options: {
+        coercion: { numbers: true },
+      },
+    },
+    {
+      name: 'coercion-dates',
+      path: 'Pet',
+      input: '../../mocks/petStore.yaml',
+      options: {
+        coercion: { dates: true },
+      },
+    },
   ] as const satisfies Array<{
     input: string
     name: string

packages/plugin-zod/src/parser/index.ts

@@ -150,14 +150,25 @@ export function sort(items?: Schema[]): Schema[] {
   return transformers.orderBy(items, [(v) => order.indexOf(v.keyword)], ['asc'])
 }
 
+const shouldCoerce = (coercion: ParserOptions['coercion'] | undefined, type: 'dates' | 'strings' | 'numbers'): boolean => {
+  if (coercion === undefined) {
+    return false
+  }
+  if (typeof coercion === 'boolean') {
+    return coercion
+  }
+
+  return !!coercion[type]
+}
+
 type ParserOptions = {
   name: string
   typeName?: string
   description?: string
 
   keysToOmit?: string[]
   mapper?: Record<string, string>
-  coercion?: boolean
+  coercion?: boolean | { dates?: boolean; strings?: boolean; numbers?: boolean }
 }
 
 export function parse(parent: Schema | undefined, current: Schema, options: ParserOptions): string | undefined {
@@ -325,15 +336,15 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
   }
 
   if (isKeyword(current, schemaKeywords.string)) {
-    return zodKeywordMapper.string(options.coercion)
+    return zodKeywordMapper.string(shouldCoerce(options.coercion, 'strings'))
   }
 
   if (isKeyword(current, schemaKeywords.number)) {
-    return zodKeywordMapper.number(options.coercion)
+    return zodKeywordMapper.number(shouldCoerce(options.coercion, 'numbers'))
   }
 
   if (isKeyword(current, schemaKeywords.integer)) {
-    return zodKeywordMapper.integer(options.coercion)
+    return zodKeywordMapper.integer(shouldCoerce(options.coercion, 'numbers'))
   }
 
   if (isKeyword(current, schemaKeywords.min)) {
@@ -348,11 +359,11 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
   }
 
   if (isKeyword(current, schemaKeywords.date)) {
-    return zodKeywordMapper.date(current.args.type, options.coercion)
+    return zodKeywordMapper.date(current.args.type, shouldCoerce(options.coercion, 'dates'))
   }
 
   if (isKeyword(current, schemaKeywords.time)) {
-    return zodKeywordMapper.time(current.args.type, options.coercion)
+    return zodKeywordMapper.time(current.args.type, shouldCoerce(options.coercion, 'dates'))
   }
 
   if (current.keyword in zodKeywordMapper && 'args' in current) {

packages/plugin-zod/src/types.ts

@@ -53,8 +53,15 @@ export type Options = {
   inferred?: boolean
   /**
    * Use of z.coerce.string() instead of z.string()
+   * can also be an object to enable coercion for dates, strings, and numbers
    */
-  coercion?: boolean
+  coercion?:
+    | boolean
+    | {
+        dates?: boolean
+        strings?: boolean
+        numbers?: boolean
+      }
   operations?: boolean
   mapper?: Record<string, string>
   transformers?: {
@@ -93,7 +100,7 @@ type ResolvedOptions = {
   mapper: NonNullable<Options['mapper']>
   importPath: NonNullable<Options['importPath']>
   coercion: NonNullable<Options['coercion']>
-  operations: NonNullable<Options['coercion']>
+  operations: NonNullable<Options['operations']>
 }
 
 export type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>