+5

.changeset/curly-geckos-play.md

··· 1 1 + --- 2 2 + '@hey-api/codegen-core': patch 3 3 + --- 4 4 + 5 5 + **types**: document default values for `importKind` and `kind`

+7

.changeset/fruity-camels-type.md

··· 1 1 + --- 2 2 + '@hey-api/openapi-ts': minor 3 3 + --- 4 4 + 5 5 + **plugin(valibot)**: **BREAKING:** standardize `~resolvers` API 6 6 + 7 7 + The [Resolvers API](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) has been simplified and expanded to provide a more consistent behavior across plugins. You can view a few common examples on the [Resolvers](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) page.

+7

.changeset/upset-weeks-dream.md

··· 1 1 + --- 2 2 + '@hey-api/openapi-ts': minor 3 3 + --- 4 4 + 5 5 + **plugin(zod)**: **BREAKING:** standardize `~resolvers` API 6 6 + 7 7 + The [Resolvers API](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) has been simplified and expanded to provide a more consistent behavior across plugins. You can view a few common examples on the [Resolvers](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) page.

+86 -41

dev/openapi-ts.config.ts

··· 431 431 }, 432 432 }, 433 433 '~resolvers': { 434 434 - object: { 435 435 - // base({ $, additional, pipes, shape }) { 436 436 - // if (additional === undefined) { 437 437 - // return pipes.push($('v').attr('looseObject').call(shape)); 438 438 - // } 439 439 - // return; 440 440 - // }, 441 441 - }, 442 442 - string: { 443 443 - formats: { 444 444 - // date: ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()), 445 445 - // 'date-time': ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()), 446 446 - }, 434 434 + // number(ctx) { 435 435 + // const { $, plugin, symbols } = ctx; 436 436 + // const { v } = symbols; 437 437 + // // ctx.nodes.base = () => { 438 438 + // // // implement custom base number resolver 439 439 + // // } 440 440 + // const big = plugin.symbolOnce('Big', { 441 441 + // external: 'big.js', 442 442 + // importKind: 'default', 443 443 + // }); 444 444 + // return $(v).attr('instance').call(big); 445 445 + // }, 446 446 + object(ctx) { 447 447 + const { $, symbols } = ctx; 448 448 + const { v } = symbols; 449 449 + const additional = ctx.nodes.additionalProperties(ctx); 450 450 + if (additional === undefined) { 451 451 + const shape = ctx.nodes.shape(ctx); 452 452 + ctx.nodes.base = () => $(v).attr('looseObject').call(shape); 453 453 + } 447 454 }, 448 448 - // validator({ $, plugin, schema, v }) { 455 455 + // string(ctx) { 456 456 + // const { $, schema, symbols } = ctx; 457 457 + // const { v } = symbols; 458 458 + // if (schema.format === 'date' || schema.format === 'date-time') { 459 459 + // ctx.nodes.format = () => $(v).attr('isoDateTime').call(); 460 460 + // } 461 461 + // }, 462 462 + // validator(ctx) { 463 463 + // const { $, plugin, symbols } = ctx; 464 464 + // const { schema, v } = symbols; 449 465 // const vShadow = plugin.symbol('v'); 450 466 // const test = plugin.symbol('test'); 451 467 // const e = plugin.symbol('err'); ··· 467 483 { 468 484 // case: 'snake_case', 469 485 // comments: false, 470 470 - compatibilityVersion: 3, 486 486 + compatibilityVersion: 'mini', 471 487 dates: { 472 488 // local: true, 473 489 // offset: true, ··· 516 532 }, 517 533 }, 518 534 '~resolvers': { 519 519 - object: { 520 520 - // base({ $, additional, shape }) { 521 521 - // if (!additional) { 522 522 - // // return $('z').attr('object').call(shape).attr('passthrough').call() 523 523 - // return $('z').attr('object').call(shape).attr('strict').call(); 524 524 - // } 525 525 - // return; 526 526 - // }, 527 527 - }, 528 528 - string: { 529 529 - formats: { 530 530 - // date: ({ $ }) => $('z').attr('date').call(), 531 531 - // 'date-time': ({ $ }) => $('z').attr('date').call(), 532 532 - // int64: ({ $ }) => $('z').attr('string').call().attr('refine').call( 533 533 - // $.func().param('val').do( 534 534 - // $.try( 535 535 - // $('z').attr('int64').call().attr('parse').call($('BigInt').call('val')), 536 536 - // $.return($.literal(true)) 537 537 - // ).catch( 538 538 - // $.return($.literal(false)) 539 539 - // ), 540 540 - // ), 541 541 - // $.object().prop('message', $.literal('Must be a valid int64 string')) 542 542 - // ), 543 543 - }, 544 544 - }, 535 535 + // number(ctx) { 536 536 + // const { $, plugin, symbols } = ctx; 537 537 + // const { z } = symbols; 538 538 + // // ctx.nodes.base = () => { 539 539 + // // // implement custom base number resolver 540 540 + // // } 541 541 + // const big = plugin.symbolOnce('Big', { 542 542 + // external: 'big.js', 543 543 + // importKind: 'default', 544 544 + // }); 545 545 + // return $(z).attr('instanceof').call(big); 546 546 + // }, 547 547 + // object(ctx) { 548 548 + // const { $, symbols } = ctx; 549 549 + // const { z } = symbols; 550 550 + // const additional = ctx.nodes.additionalProperties(ctx); 551 551 + // if (additional === undefined) { 552 552 + // const shape = ctx.nodes.shape(ctx); 553 553 + // // return $('z').attr('object').call(shape).attr('passthrough').call() 554 554 + // ctx.nodes.base = () => 555 555 + // $(z).attr('object').call(shape).attr('strict').call(); 556 556 + // } 557 557 + // }, 558 558 + // string(ctx) { 559 559 + // const { $, schema, symbols } = ctx; 560 560 + // const { z } = symbols; 561 561 + // if (schema.format === 'date' || schema.format === 'date-time') { 562 562 + // ctx.nodes.format = () => $(z).attr('date').call(); 563 563 + // } 564 564 + // if (schema.format === 'int64') { 565 565 + // ctx.nodes.format = () => 566 566 + // $(z) 567 567 + // .attr('string') 568 568 + // .call() 569 569 + // .attr('refine') 570 570 + // .call( 571 571 + // $.func() 572 572 + // .param('val') 573 573 + // .do( 574 574 + // $.try( 575 575 + // $(z) 576 576 + // .attr('int64') 577 577 + // .call() 578 578 + // .attr('parse') 579 579 + // .call($('BigInt').call('val')), 580 580 + // $.return($.literal(true)), 581 581 + // ).catch($.return($.literal(false))), 582 582 + // ), 583 583 + // $.object().prop( 584 584 + // 'message', 585 585 + // $.literal('Must be a valid int64 string'), 586 586 + // ), 587 587 + // ); 588 588 + // } 589 589 + // }, 545 590 // validator({ $, schema }) { 546 591 // return [ 547 592 // $.const('parsed').assign(

+10

docs/.vitepress/config/en.ts

··· 259 259 collapsed: true, 260 260 items: [ 261 261 { 262 262 + link: '/openapi-ts/plugins/concepts/resolvers', 263 263 + text: 'Resolvers', 264 264 + }, 265 265 + ], 266 266 + text: 'Concepts', 267 267 + }, 268 268 + { 269 269 + collapsed: true, 270 270 + items: [ 271 271 + { 262 272 link: '/openapi-ts/plugins/custom', 263 273 text: 'Plugin', 264 274 },

+2 -2

docs/openapi-ts/clients.md

··· 1 1 --- 2 2 title: Clients 3 3 - description: REST clients for Hey API. Compatible with all our features. 3 3 + description: HTTP clients for Hey API. Compatible with all our features. 4 4 --- 5 5 6 6 <script setup lang="ts"> 7 7 import { embedProject } from '../embed' 8 8 </script> 9 9 10 10 - # REST Clients 10 10 + # HTTP Clients 11 11 12 12 We all send HTTP requests in a slightly different way. Hey API doesn't force you to use any specific technology. What we do, however, is support your choice with great clients. All seamlessly integrated with our other features. 13 13

+6

docs/openapi-ts/migrating.md

··· 7 7 8 8 While we try to avoid breaking changes, sometimes it's unavoidable in order to offer you the latest features. This page lists changes that require updates to your code. If you run into a problem with migration, please [open an issue](https://github.com/hey-api/openapi-ts/issues). 9 9 10 10 + ## v0.90.0 11 11 + 12 12 + ### Resolvers API 13 13 + 14 14 + The [Resolvers API](/openapi-ts/plugins/concepts/resolvers) has been simplified and expanded to provide a more consistent behavior across plugins. You can view a few common examples on the [Resolvers](/openapi-ts/plugins/concepts/resolvers) page. 15 15 + 10 16 ## v0.89.0 11 17 12 18 ### Prefer named exports

+181

docs/openapi-ts/plugins/concepts/resolvers.md

··· 1 1 + --- 2 2 + title: Resolvers 3 3 + description: Understand the concepts behind plugins. 4 4 + --- 5 5 + 6 6 + # Resolvers 7 7 + 8 8 + Sometimes the default plugin behavior isn't what you need or expect. Resolvers let you patch plugins in a safe and performant way, without forking or reimplementing core logic. 9 9 + 10 10 + Currently available for [Valibot](/openapi-ts/plugins/valibot) and [Zod](/openapi-ts/plugins/zod). 11 11 + 12 12 + ## Examples 13 13 + 14 14 + This page demonstrates resolvers through a few common scenarios. 15 15 + 16 16 + 1. [Handle arbitrary schema formats](#example-1) 17 17 + 2. [Validate high precision numbers](#example-2) 18 18 + 3. [Replace default base](#example-3) 19 19 + 20 20 + ## Terminology 21 21 + 22 22 + Before we look at examples, let's go through the resolvers API to help you understand how they work. Plugins that support resolvers expose them through the `~resolvers` option. Each resolver is a function that receives context and returns an implemented node (or patches existing ones). 23 23 + 24 24 + The resolver context will usually contain: 25 25 + 26 26 + - `$` - The node builder interface. Use it to build your custom logic. 27 27 + - `nodes` - Parts of the plugin logic. You can use these to avoid reimplementing the functionality, or replace them with custom implementation. 28 28 + - `plugin` - The plugin instance. You'll most likely use it to register new symbols. 29 29 + - `symbols` - Frequently used symbols. These are effectively shorthands for commonly used `plugin.referenceSymbol()` calls. 30 30 + 31 31 + Other fields may include the current schema or relevant utilities. 32 32 + 33 33 + ## Example 1 34 34 + 35 35 + ### Handle arbitrary schema formats 36 36 + 37 37 + By default, the Valibot plugin may produce the following schemas for `date` and `date-time` strings. 38 38 + 39 39 + ```js 40 40 + export const vDates = v.object({ 41 41 + created: v.pipe(v.string(), v.isoDate()), 42 42 + modified: v.pipe(v.string(), v.isoTimestamp()), 43 43 + }); 44 44 + ``` 45 45 + 46 46 + We can override this behavior by patching the `nodes.format` function only for strings with `date` or `date-time` formats. 47 47 + 48 48 + ```js 49 49 + { 50 50 + name: 'valibot', 51 51 + '~resolvers': { 52 52 + string(ctx) { 53 53 + const { $, schema, symbols } = ctx; 54 54 + const { v } = symbols; 55 55 + if (schema.format === 'date' || schema.format === 'date-time') { 56 56 + ctx.nodes.format = () => $(v).attr('isoDateTime').call(); 57 57 + } 58 58 + } 59 59 + } 60 60 + } 61 61 + ``` 62 62 + 63 63 + This applies custom logic with surgical precision, without affecting the rest of the default behavior. 64 64 + 65 65 + ::: code-group 66 66 + 67 67 + ```js [after] 68 68 + export const vDates = v.object({ 69 69 + created: v.pipe(v.string(), v.isoDateTime()), 70 70 + modified: v.pipe(v.string(), v.isoDateTime()), 71 71 + }); 72 72 + ``` 73 73 + 74 74 + ```js [before] 75 75 + export const vDates = v.object({ 76 76 + created: v.pipe(v.string(), v.isoDate()), 77 77 + modified: v.pipe(v.string(), v.isoTimestamp()), 78 78 + }); 79 79 + ``` 80 80 + 81 81 + ::: 82 82 + 83 83 + ## Example 2 84 84 + 85 85 + ### Validate high precision numbers 86 86 + 87 87 + Let's say you're dealing with very large or unsafe numbers. 88 88 + 89 89 + ```js 90 90 + export const vAmount = v.number(); 91 91 + ``` 92 92 + 93 93 + In this case, you'll want to use a third-party library to validate your values. We can use big.js to validate all numbers by replacing the whole resolver. 94 94 + 95 95 + ```js 96 96 + { 97 97 + name: 'valibot', 98 98 + '~resolvers': { 99 99 + number(ctx) { 100 100 + const { $, plugin, symbols } = ctx; 101 101 + const { v } = symbols; 102 102 + const big = plugin.symbolOnce('Big', { 103 103 + external: 'big.js', 104 104 + importKind: 'default', 105 105 + }); 106 106 + return $(v).attr('instance').call(big); 107 107 + } 108 108 + } 109 109 + } 110 110 + ``` 111 111 + 112 112 + We're calling `plugin.symbolOnce()` to ensure we always use the same symbol reference. 113 113 + 114 114 + ::: code-group 115 115 + 116 116 + ```js [after] 117 117 + import Big from 'big.js'; 118 118 + 119 119 + export const vAmount = v.instance(Big); 120 120 + ``` 121 121 + 122 122 + ```js [before] 123 123 + export const vAmount = v.number(); 124 124 + ``` 125 125 + 126 126 + ::: 127 127 + 128 128 + ## Example 3 129 129 + 130 130 + ### Replace default base 131 131 + 132 132 + You might want to replace the default base schema, e.g. `v.object()`. 133 133 + 134 134 + ```js 135 135 + export const vUser = v.object({ 136 136 + age: v.number(), 137 137 + }); 138 138 + ``` 139 139 + 140 140 + Let's say we want to interpret any schema without explicitly defined additional properties as a loose object. 141 141 + 142 142 + ```js 143 143 + { 144 144 + name: 'valibot', 145 145 + '~resolvers': { 146 146 + object(ctx) { 147 147 + const { $, symbols } = ctx; 148 148 + const { v } = symbols; 149 149 + const additional = ctx.nodes.additionalProperties(ctx); 150 150 + if (additional === undefined) { 151 151 + const shape = ctx.nodes.shape(ctx); 152 152 + ctx.nodes.base = () => $(v).attr('looseObject').call(shape); 153 153 + } 154 154 + } 155 155 + } 156 156 + } 157 157 + ``` 158 158 + 159 159 + Above we demonstrate patching a node based on the result of another node. 160 160 + 161 161 + ::: code-group 162 162 + 163 163 + ```js [after] 164 164 + export const vUser = v.looseObject({ 165 165 + age: v.number(), 166 166 + }); 167 167 + ``` 168 168 + 169 169 + ```js [before] 170 170 + export const vUser = v.object({ 171 171 + age: v.number(), 172 172 + }); 173 173 + ``` 174 174 + 175 175 + ::: 176 176 + 177 177 + ## Feedback 178 178 + 179 179 + We welcome feedback on the Resolvers API. [Open a GitHub issue](https://github.com/hey-api/openapi-ts/issues) to request support for additional plugins. 180 180 + 181 181 + <!--@include: ../../../partials/sponsors.md-->

+4

docs/openapi-ts/plugins/valibot.md

··· 207 207 208 208 ::: 209 209 210 210 + ## Resolvers 211 211 + 212 212 + You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers). 213 213 + 210 214 ## API 211 215 212 216 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/valibot/types.d.ts) interface.

+4

docs/openapi-ts/plugins/zod.md

··· 299 299 300 300 You can customize the naming and casing pattern for schema-specific `types` using the `.name` and `.case` options. 301 301 302 302 + ## Resolvers 303 303 + 304 304 + You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers). 305 305 + 302 306 ## API 303 307 304 308 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/zod/types.d.ts) interface.

+4

docs/openapi-ts/plugins/zod/mini.md

··· 312 312 313 313 You can customize the naming and casing pattern for schema-specific `types` using the `.name` and `.case` options. 314 314 315 315 + ## Resolvers 316 316 + 317 317 + You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers). 318 318 + 315 319 ## API 316 320 317 321 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/zod/types.d.ts) interface.

+4

docs/openapi-ts/plugins/zod/v3.md

··· 310 310 311 311 You can customize the naming and casing pattern for schema-specific `types` using the `.name` and `.case` options. 312 312 313 313 + ## Resolvers 314 314 + 315 315 + You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers). 316 316 + 313 317 ## API 314 318 315 319 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/zod/types.d.ts) interface.

+4

packages/codegen-core/src/symbols/types.d.ts

··· 44 44 getFilePath?: Symbol['getFilePath']; 45 45 /** 46 46 * Kind of import if this symbol represents an import. 47 47 + * 48 48 + * @default 'named' 47 49 */ 48 50 importKind?: BindingKind; 49 51 /** 50 52 * Kind of symbol. 53 53 + * 54 54 + * @default 'var' 51 55 */ 52 56 kind?: SymbolKind; 53 57 /**

+6 -6

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

··· 630 630 }); 631 631 632 632 export const vPageable = v.object({ 633 633 - page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(0)), 0), 634 634 - size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(1))), 633 633 + page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647')), 0), 634 634 + size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'))), 635 635 sort: v.optional(v.array(v.string())) 636 636 }); 637 637 ··· 962 962 }), v.strictObject({ 963 963 bar: vNonAsciiStringæøåÆøÅöôêÊ字符串 964 964 })]), v.object({ 965 965 - baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]), 966 966 - qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0)) 965 965 + baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]), 966 966 + qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255')) 967 967 })]); 968 968 969 969 export const vModelWithOneOfAndProperties = v.intersect([v.union([vSimpleParameter, vNonAsciiStringæøåÆøÅöôêÊ字符串]), v.object({ 970 970 - baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]), 971 971 - qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0)) 970 970 + baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]), 971 971 + qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255')) 972 972 })]); 973 973 974 974 /**

+6 -6

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

··· 630 630 }); 631 631 632 632 export const vPageable = v.object({ 633 633 - page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(0)), 0), 634 634 - size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(1))), 633 633 + page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647')), 0), 634 634 + size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'))), 635 635 sort: v.optional(v.array(v.string())) 636 636 }); 637 637 ··· 972 972 }), v.strictObject({ 973 973 bar: vNonAsciiStringæøåÆøÅöôêÊ字符串 974 974 })]), v.object({ 975 975 - baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]), 976 976 - qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0)) 975 975 + baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]), 976 976 + qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255')) 977 977 })]); 978 978 979 979 export const vModelWithOneOfAndProperties = v.intersect([v.union([vSimpleParameter, vNonAsciiStringæøåÆøÅöôêÊ字符串]), v.object({ 980 980 - baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]), 981 981 - qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0)) 980 980 + baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]), 981 981 + qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255')) 982 982 })]); 983 983 984 984 /**

+1 -1

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/validators-bigint-min-max/valibot.gen.ts

··· 7 7 v.number(), 8 8 v.string(), 9 9 v.bigint() 10 10 - ]), v.transform(x => BigInt(x)), v.minValue(BigInt('-9223372036854775808'), 'Invalid value: Expected int64 to be >= -9223372036854775808'), v.maxValue(BigInt('9223372036854775807'), 'Invalid value: Expected int64 to be <= 9223372036854775807'), v.minValue(BigInt(0)), v.maxValue(BigInt(100)))) 10 10 + ]), v.transform(x => BigInt(x)), v.minValue(BigInt(0)), v.maxValue(BigInt(100)))) 11 11 });

+6 -6

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/mini/default/zod.gen.ts

··· 710 710 }); 711 711 712 712 export const zPageable = z.object({ 713 713 - page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0), 714 714 - size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))), 713 713 + page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0), 714 714 + size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 715 715 sort: z.optional(z.array(z.string())) 716 716 }); 717 717 ··· 1127 1127 }) 1128 1128 ]), z.object({ 1129 1129 baz: z.union([ 1130 1130 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1130 1130 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1131 1131 z.null() 1132 1132 ]), 1133 1133 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1133 1133 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1134 1134 })); 1135 1135 1136 1136 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1138 1138 zNonAsciiStringæøåÆøÅöôêÊ字符串 1139 1139 ]), z.object({ 1140 1140 baz: z.union([ 1141 1141 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1141 1141 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1142 1142 z.null() 1143 1143 ]), 1144 1144 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1144 1144 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1145 1145 })); 1146 1146 1147 1147 /**

+6 -6

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/v3/default/zod.gen.ts

··· 708 708 }); 709 709 710 710 export const zPageable = z.object({ 711 711 - page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0), 712 712 - size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(), 711 711 + page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0), 712 712 + size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(), 713 713 sort: z.array(z.string()).optional() 714 714 }); 715 715 ··· 1125 1125 }) 1126 1126 ]), z.object({ 1127 1127 baz: z.union([ 1128 1128 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1128 1128 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1129 1129 z.null() 1130 1130 ]), 1131 1131 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1131 1131 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1132 1132 })); 1133 1133 1134 1134 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1136 1136 zNonAsciiStringæøåÆøÅöôêÊ字符串 1137 1137 ]), z.object({ 1138 1138 baz: z.union([ 1139 1139 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1139 1139 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1140 1140 z.null() 1141 1141 ]), 1142 1142 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1142 1142 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1143 1143 })); 1144 1144 1145 1145 /**

+6 -6

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/v4/default/zod.gen.ts

··· 710 710 }); 711 711 712 712 export const zPageable = z.object({ 713 713 - page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0), 714 714 - size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)), 713 713 + page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0), 714 714 + size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })), 715 715 sort: z.optional(z.array(z.string())) 716 716 }); 717 717 ··· 1127 1127 }) 1128 1128 ]), z.object({ 1129 1129 baz: z.union([ 1130 1130 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1130 1130 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1131 1131 z.null() 1132 1132 ]), 1133 1133 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1133 1133 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1134 1134 })); 1135 1135 1136 1136 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1138 1138 zNonAsciiStringæøåÆøÅöôêÊ字符串 1139 1139 ]), z.object({ 1140 1140 baz: z.union([ 1141 1141 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1141 1141 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1142 1142 z.null() 1143 1143 ]), 1144 1144 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1144 1144 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1145 1145 })); 1146 1146 1147 1147 /**

+6 -6

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/mini/default/zod.gen.ts

··· 707 707 }); 708 708 709 709 export const zPageable = z.object({ 710 710 - page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0), 711 711 - size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))), 710 710 + page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0), 711 711 + size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 712 712 sort: z.optional(z.array(z.string())) 713 713 }); 714 714 ··· 1133 1133 }) 1134 1134 ]), z.object({ 1135 1135 baz: z.union([ 1136 1136 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1136 1136 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1137 1137 z.null() 1138 1138 ]), 1139 1139 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1139 1139 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1140 1140 })); 1141 1141 1142 1142 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1144 1144 zNonAsciiStringæøåÆøÅöôêÊ字符串 1145 1145 ]), z.object({ 1146 1146 baz: z.union([ 1147 1147 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1147 1147 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1148 1148 z.null() 1149 1149 ]), 1150 1150 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1150 1150 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1151 1151 })); 1152 1152 1153 1153 /**

+1 -1

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/mini/validators-bigint-min-max/zod.gen.ts

··· 3 3 import * as z from 'zod/v4-mini'; 4 4 5 5 export const zFoo = z.object({ 6 6 - foo: z.optional(z.coerce.bigint().check(z.minimum(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }), z.maximum(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }), z.gte(BigInt(0)), z.lte(BigInt(100)))) 6 6 + foo: z.optional(z.coerce.bigint().check(z.gte(BigInt(0)), z.lte(BigInt(100)))) 7 7 });

+6 -6

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

··· 705 705 }); 706 706 707 707 export const zPageable = z.object({ 708 708 - page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0), 709 709 - size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(), 708 708 + page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0), 709 709 + size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(), 710 710 sort: z.array(z.string()).optional() 711 711 }); 712 712 ··· 1131 1131 }) 1132 1132 ]), z.object({ 1133 1133 baz: z.union([ 1134 1134 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1134 1134 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1135 1135 z.null() 1136 1136 ]), 1137 1137 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1137 1137 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1138 1138 })); 1139 1139 1140 1140 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1142 1142 zNonAsciiStringæøåÆøÅöôêÊ字符串 1143 1143 ]), z.object({ 1144 1144 baz: z.union([ 1145 1145 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1145 1145 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1146 1146 z.null() 1147 1147 ]), 1148 1148 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1148 1148 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1149 1149 })); 1150 1150 1151 1151 /**

+1 -1

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v3/validators-bigint-min-max/zod.gen.ts

··· 3 3 import { z } from 'zod'; 4 4 5 5 export const zFoo = z.object({ 6 6 - foo: z.coerce.bigint().min(BigInt('-9223372036854775808'), { message: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { message: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)).optional() 6 6 + foo: z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)).optional() 7 7 });

+6 -6

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v4/default/zod.gen.ts

··· 707 707 }); 708 708 709 709 export const zPageable = z.object({ 710 710 - page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0), 711 711 - size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)), 710 710 + page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0), 711 711 + size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })), 712 712 sort: z.optional(z.array(z.string())) 713 713 }); 714 714 ··· 1133 1133 }) 1134 1134 ]), z.object({ 1135 1135 baz: z.union([ 1136 1136 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1136 1136 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1137 1137 z.null() 1138 1138 ]), 1139 1139 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1139 1139 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1140 1140 })); 1141 1141 1142 1142 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1144 1144 zNonAsciiStringæøåÆøÅöôêÊ字符串 1145 1145 ]), z.object({ 1146 1146 baz: z.union([ 1147 1147 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1147 1147 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1148 1148 z.null() 1149 1149 ]), 1150 1150 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1150 1150 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1151 1151 })); 1152 1152 1153 1153 /**

+1 -1

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v4/validators-bigint-min-max/zod.gen.ts

··· 3 3 import { z } from 'zod/v4'; 4 4 5 5 export const zFoo = z.object({ 6 6 - foo: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100))) 6 6 + foo: z.optional(z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100))) 7 7 });

+6 -6

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/mini/default/zod.gen.ts

··· 710 710 }); 711 711 712 712 export const zPageable = z.object({ 713 713 - page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0), 714 714 - size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))), 713 713 + page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0), 714 714 + size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 715 715 sort: z.optional(z.array(z.string())) 716 716 }); 717 717 ··· 1127 1127 }) 1128 1128 ]), z.object({ 1129 1129 baz: z.union([ 1130 1130 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1130 1130 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1131 1131 z.null() 1132 1132 ]), 1133 1133 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1133 1133 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1134 1134 })); 1135 1135 1136 1136 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1138 1138 zNonAsciiStringæøåÆøÅöôêÊ字符串 1139 1139 ]), z.object({ 1140 1140 baz: z.union([ 1141 1141 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1141 1141 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1142 1142 z.null() 1143 1143 ]), 1144 1144 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1144 1144 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1145 1145 })); 1146 1146 1147 1147 /**

+6 -6

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/v3/default/zod.gen.ts

··· 708 708 }); 709 709 710 710 export const zPageable = z.object({ 711 711 - page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0), 712 712 - size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(), 711 711 + page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0), 712 712 + size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(), 713 713 sort: z.array(z.string()).optional() 714 714 }); 715 715 ··· 1125 1125 }) 1126 1126 ]), z.object({ 1127 1127 baz: z.union([ 1128 1128 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1128 1128 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1129 1129 z.null() 1130 1130 ]), 1131 1131 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1131 1131 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1132 1132 })); 1133 1133 1134 1134 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1136 1136 zNonAsciiStringæøåÆøÅöôêÊ字符串 1137 1137 ]), z.object({ 1138 1138 baz: z.union([ 1139 1139 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1139 1139 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1140 1140 z.null() 1141 1141 ]), 1142 1142 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1142 1142 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1143 1143 })); 1144 1144 1145 1145 /**

+6 -6

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/v4/default/zod.gen.ts

··· 710 710 }); 711 711 712 712 export const zPageable = z.object({ 713 713 - page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0), 714 714 - size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)), 713 713 + page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0), 714 714 + size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })), 715 715 sort: z.optional(z.array(z.string())) 716 716 }); 717 717 ··· 1127 1127 }) 1128 1128 ]), z.object({ 1129 1129 baz: z.union([ 1130 1130 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1130 1130 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1131 1131 z.null() 1132 1132 ]), 1133 1133 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1133 1133 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1134 1134 })); 1135 1135 1136 1136 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1138 1138 zNonAsciiStringæøåÆøÅöôêÊ字符串 1139 1139 ]), z.object({ 1140 1140 baz: z.union([ 1141 1141 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1141 1141 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1142 1142 z.null() 1143 1143 ]), 1144 1144 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1144 1144 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1145 1145 })); 1146 1146 1147 1147 /**

+6 -6

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/mini/default/zod.gen.ts

··· 707 707 }); 708 708 709 709 export const zPageable = z.object({ 710 710 - page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0), 711 711 - size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))), 710 710 + page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0), 711 711 + size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 712 712 sort: z.optional(z.array(z.string())) 713 713 }); 714 714 ··· 1133 1133 }) 1134 1134 ]), z.object({ 1135 1135 baz: z.union([ 1136 1136 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1136 1136 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1137 1137 z.null() 1138 1138 ]), 1139 1139 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1139 1139 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1140 1140 })); 1141 1141 1142 1142 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1144 1144 zNonAsciiStringæøåÆøÅöôêÊ字符串 1145 1145 ]), z.object({ 1146 1146 baz: z.union([ 1147 1147 - z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)), 1147 1147 + z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })), 1148 1148 z.null() 1149 1149 ]), 1150 1150 - qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0)) 1150 1150 + qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' })) 1151 1151 })); 1152 1152 1153 1153 /**

+1 -1

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/mini/validators-bigint-min-max/zod.gen.ts

··· 3 3 import * as z from 'zod/mini'; 4 4 5 5 export const zFoo = z.object({ 6 6 - foo: z.optional(z.coerce.bigint().check(z.minimum(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }), z.maximum(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }), z.gte(BigInt(0)), z.lte(BigInt(100)))) 6 6 + foo: z.optional(z.coerce.bigint().check(z.gte(BigInt(0)), z.lte(BigInt(100)))) 7 7 });

+6 -6

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v3/default/zod.gen.ts

··· 705 705 }); 706 706 707 707 export const zPageable = z.object({ 708 708 - page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0), 709 709 - size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(), 708 708 + page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0), 709 709 + size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(), 710 710 sort: z.array(z.string()).optional() 711 711 }); 712 712 ··· 1131 1131 }) 1132 1132 ]), z.object({ 1133 1133 baz: z.union([ 1134 1134 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1134 1134 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1135 1135 z.null() 1136 1136 ]), 1137 1137 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1137 1137 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1138 1138 })); 1139 1139 1140 1140 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1142 1142 zNonAsciiStringæøåÆøÅöôêÊ字符串 1143 1143 ]), z.object({ 1144 1144 baz: z.union([ 1145 1145 - z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1145 1145 + z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }), 1146 1146 z.null() 1147 1147 ]), 1148 1148 - qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1148 1148 + qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }) 1149 1149 })); 1150 1150 1151 1151 /**

+1 -1

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v3/validators-bigint-min-max/zod.gen.ts

··· 3 3 import { z } from 'zod/v3'; 4 4 5 5 export const zFoo = z.object({ 6 6 - foo: z.coerce.bigint().min(BigInt('-9223372036854775808'), { message: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { message: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)).optional() 6 6 + foo: z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)).optional() 7 7 });

+6 -6

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

··· 707 707 }); 708 708 709 709 export const zPageable = z.object({ 710 710 - page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0), 711 711 - size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)), 710 710 + page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0), 711 711 + size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })), 712 712 sort: z.optional(z.array(z.string())) 713 713 }); 714 714 ··· 1133 1133 }) 1134 1134 ]), z.object({ 1135 1135 baz: z.union([ 1136 1136 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1136 1136 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1137 1137 z.null() 1138 1138 ]), 1139 1139 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1139 1139 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1140 1140 })); 1141 1141 1142 1142 export const zModelWithOneOfAndProperties = z.intersection(z.union([ ··· 1144 1144 zNonAsciiStringæøåÆøÅöôêÊ字符串 1145 1145 ]), z.object({ 1146 1146 baz: z.union([ 1147 1147 - z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0), 1147 1147 + z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), 1148 1148 z.null() 1149 1149 ]), 1150 1150 - qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0) 1150 1150 + qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }) 1151 1151 })); 1152 1152 1153 1153 /**

+1 -1

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v4/validators-bigint-min-max/zod.gen.ts

··· 3 3 import { z } from 'zod'; 4 4 5 5 export const zFoo = z.object({ 6 6 - foo: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100))) 6 6 + foo: z.optional(z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100))) 7 7 });

-8

packages/openapi-ts/src/plugins/arktype/v2/toAst/object.ts

··· 93 93 result.hasLazyExpression = true; 94 94 } 95 95 96 96 - // Return with typeName for circular references 97 97 - if (result.hasLazyExpression) { 98 98 - return { 99 99 - ...result, 100 100 - typeName: 'TODO', 101 101 - } as Ast; 102 102 - } 103 103 - 104 96 return result as Omit<Ast, 'typeName'>; 105 97 } 106 98

+8 -5

packages/openapi-ts/src/plugins/shared/utils/coerce.ts

··· 1 1 import { $ } from '~/ts-dsl'; 2 2 3 3 - export const shouldCoerceToBigInt = (format: string | undefined): boolean => 3 3 + export type MaybeBigInt = ( 4 4 + value: unknown, 5 5 + format: string | undefined, 6 6 + ) => ReturnType<typeof $.fromValue>; 7 7 + export type ShouldCoerceToBigInt = (format: string | undefined) => boolean; 8 8 + 9 9 + export const shouldCoerceToBigInt: ShouldCoerceToBigInt = (format) => 4 10 format === 'int64' || format === 'uint64'; 5 11 6 6 - export const maybeBigInt = ( 7 7 - value: unknown, 8 8 - format: string | undefined, 9 9 - ): ReturnType<typeof $.fromValue> => { 12 12 + export const maybeBigInt: MaybeBigInt = (value, format) => { 10 13 if (!shouldCoerceToBigInt(format)) { 11 14 return $.fromValue(value); 12 15 }

+6 -4

packages/openapi-ts/src/plugins/shared/utils/formats.ts

··· 7 7 minValue: Range; 8 8 } 9 9 10 10 + export type GetIntegerLimit = ( 11 11 + format: string | undefined, 12 12 + ) => IntegerLimit | undefined; 13 13 + 10 14 const rangeErrors = (format: string, range: [Range, Range]) => ({ 11 15 maxError: `Invalid value: Expected ${format} to be <= ${range[1]}`, 12 16 minError: `Invalid value: Expected ${format} to be >= ${range[0]}`, ··· 23 27 uint8: [0, 255], 24 28 }; 25 29 26 26 - export function getIntegerLimit( 27 27 - format: string | undefined, 28 28 - ): IntegerLimit | undefined { 30 30 + export const getIntegerLimit: GetIntegerLimit = (format) => { 29 31 if (!format) return; 30 32 const range = integerRange[format]; 31 33 if (!range) return; 32 34 const errors = rangeErrors(format, range); 33 35 return { maxValue: range[1], minValue: range[0], ...errors }; 34 34 - } 36 36 + };

+28

packages/openapi-ts/src/plugins/shared/utils/instance.ts

··· 106 106 this.package = props.context.package; 107 107 } 108 108 109 109 + external( 110 110 + resource: Required<SymbolMeta>['resource'], 111 111 + meta?: Omit<SymbolMeta, 'category' | 'resource'>, 112 112 + ): Symbol { 113 113 + return this.gen.symbols.reference({ 114 114 + ...meta, 115 115 + category: 'external', 116 116 + resource, 117 117 + }); 118 118 + } 119 119 + 109 120 /** 110 121 * Iterates over various input elements as specified by the event types, in 111 122 * a specific order: servers, schemas, parameters, request bodies, then ··· 376 387 hook({ plugin: this, symbol: symbolOut }); 377 388 } 378 389 return symbolOut; 390 390 + } 391 391 + 392 392 + /** 393 393 + * Registers a symbol only if it does not already exist based on the provided 394 394 + * metadata. This prevents duplicate symbols from being created in the project. 395 395 + */ 396 396 + symbolOnce(name: SymbolIn['name'], symbol?: Omit<SymbolIn, 'name'>): Symbol { 397 397 + const meta = { 398 398 + ...symbol?.meta, 399 399 + }; 400 400 + if (symbol?.external) { 401 401 + meta.category = 'external'; 402 402 + meta.resource = symbol.external; 403 403 + } 404 404 + const existing = this.querySymbol(meta); 405 405 + if (existing) return existing; 406 406 + return this.symbol(name, { ...symbol, meta }); 379 407 } 380 408 381 409 private buildEventHooks(): EventHooks {

+2 -2

packages/openapi-ts/src/plugins/valibot/shared/export.ts

··· 5 5 import { $ } from '~/ts-dsl'; 6 6 7 7 import { identifiers } from '../v1/constants'; 8 8 - import { pipesToAst } from './pipesToAst'; 8 8 + import { pipesToNode } from './pipes'; 9 9 import type { Ast, IrSchemaToAstOptions } from './types'; 10 10 11 11 export const exportAst = ({ ··· 32 32 .$if(state.hasLazyExpression['~ref'], (c) => 33 33 c.type($.type(v).attr(ast.typeName || identifiers.types.GenericSchema)), 34 34 ) 35 35 - .assign(pipesToAst(ast.pipes, plugin)); 35 35 + .assign(pipesToNode(ast.pipes, plugin)); 36 36 plugin.node(statement); 37 37 };

+52

packages/openapi-ts/src/plugins/valibot/shared/pipes.ts

··· 1 1 + import { $ } from '~/ts-dsl'; 2 2 + 3 3 + import type { ValibotPlugin } from '../types'; 4 4 + import { identifiers } from '../v1/constants'; 5 5 + 6 6 + export type Pipe = ReturnType<typeof $.call | typeof $.expr>; 7 7 + export type Pipes = Array<Pipe>; 8 8 + export type PipeResult = Pipes | Pipe; 9 9 + 10 10 + type PushPipes = (target: Pipes, pipes: PipeResult) => Pipes; 11 11 + type PipesToNode = ( 12 12 + pipes: PipeResult, 13 13 + plugin: ValibotPlugin['Instance'], 14 14 + ) => Pipe; 15 15 + 16 16 + export const pipesToNode: PipesToNode = (pipes, plugin) => { 17 17 + if (!(pipes instanceof Array)) return pipes; 18 18 + if (pipes.length === 1) return pipes[0]!; 19 19 + 20 20 + const v = plugin.external('valibot.v'); 21 21 + return $(v) 22 22 + .attr(identifiers.methods.pipe) 23 23 + .call(...pipes); 24 24 + }; 25 25 + 26 26 + export const pushPipes: PushPipes = (target, pipes) => { 27 27 + if (pipes instanceof Array) { 28 28 + target.push(...pipes); 29 29 + } else { 30 30 + target.push(pipes); 31 31 + } 32 32 + return target; 33 33 + }; 34 34 + 35 35 + export interface PipesUtils { 36 36 + /** 37 37 + * Push pipes into target array. 38 38 + */ 39 39 + push: PushPipes; 40 40 + /** 41 41 + * Convert pipes to a single node. 42 42 + */ 43 43 + toNode: PipesToNode; 44 44 + } 45 45 + 46 46 + /** 47 47 + * Functions for working with pipes. 48 48 + */ 49 49 + export const pipes: PipesUtils = { 50 50 + push: pushPipes, 51 51 + toNode: pipesToNode, 52 52 + };

-21

packages/openapi-ts/src/plugins/valibot/shared/pipesToAst.ts

··· 1 1 - import { $ } from '~/ts-dsl'; 2 2 - 3 3 - import type { ValibotPlugin } from '../types'; 4 4 - import { identifiers } from '../v1/constants'; 5 5 - 6 6 - export const pipesToAst = ( 7 7 - pipes: ReadonlyArray<ReturnType<typeof $.call | typeof $.expr>>, 8 8 - plugin: ValibotPlugin['Instance'], 9 9 - ): ReturnType<typeof $.call | typeof $.expr> => { 10 10 - if (pipes.length === 1) { 11 11 - return pipes[0]!; 12 12 - } 13 13 - 14 14 - const v = plugin.referenceSymbol({ 15 15 - category: 'external', 16 16 - resource: 'valibot.v', 17 17 - }); 18 18 - return $(v) 19 19 - .attr(identifiers.methods.pipe) 20 20 - .call(...pipes); 21 21 - };

+2 -2

packages/openapi-ts/src/plugins/valibot/shared/types.d.ts

··· 2 2 import type ts from 'typescript'; 3 3 4 4 import type { IR } from '~/ir/types'; 5 5 - import type { $ } from '~/ts-dsl'; 6 5 7 6 import type { ValibotPlugin } from '../types'; 7 7 + import type { Pipes } from './pipes'; 8 8 9 9 export type Ast = { 10 10 hasLazyExpression?: boolean; 11 11 - pipes: Array<ReturnType<typeof $.call | typeof $.expr>>; 11 11 + pipes: Pipes; 12 12 typeName?: string | ts.Identifier; 13 13 }; 14 14

+120 -93

packages/openapi-ts/src/plugins/valibot/types.d.ts

··· 1 1 - import type { Symbol } from '@hey-api/codegen-core'; 2 2 - import type ts from 'typescript'; 1 1 + import type { Refs, Symbol } from '@hey-api/codegen-core'; 3 2 4 3 import type { IR } from '~/ir/types'; 5 5 - import type { DefinePlugin, Plugin } from '~/plugins'; 6 6 - import type { $, DollarTsDsl, TsDsl } from '~/ts-dsl'; 4 4 + import type { DefinePlugin, Plugin, SchemaWithType } from '~/plugins'; 5 5 + import type { 6 6 + MaybeBigInt, 7 7 + ShouldCoerceToBigInt, 8 8 + } from '~/plugins/shared/utils/coerce'; 9 9 + import type { GetIntegerLimit } from '~/plugins/shared/utils/formats'; 10 10 + import type { $, DollarTsDsl } from '~/ts-dsl'; 7 11 import type { StringCase, StringName } from '~/types/case'; 8 8 - import type { MaybeArray } from '~/types/utils'; 9 12 10 13 import type { IApi } from './api'; 14 14 + import type { Pipe, PipeResult, PipesUtils } from './shared/pipes'; 15 15 + import type { Ast, PluginState } from './shared/types'; 11 16 12 17 export type UserConfig = Plugin.Name<'valibot'> & 13 18 Plugin.Hooks & ··· 321 326 }; 322 327 }; 323 328 324 324 - type SharedResolverArgs = DollarTsDsl & { 329 329 + interface BaseResolverContext extends DollarTsDsl { 325 330 /** 326 326 - * The current builder state being processed by this resolver. 327 327 - * 328 328 - * In Valibot, this represents the current list of call expressions ("pipes") 329 329 - * being assembled to form a schema definition. 330 330 - * 331 331 - * Each pipe can be extended, modified, or replaced to customize how the 332 332 - * resulting schema is constructed. Returning `undefined` from a resolver will 333 333 - * use the default generation behavior. 331 331 + * Functions for working with pipes. 334 332 */ 335 335 - pipes: Array<ReturnType<typeof $.call>>; 333 333 + pipes: PipesUtils & { 334 334 + /** 335 335 + * The current pipe. 336 336 + * 337 337 + * In Valibot, this represents a list of call expressions ("pipes") 338 338 + * being assembled to form a schema definition. 339 339 + * 340 340 + * Each pipe can be extended, modified, or replaced to customize 341 341 + * the resulting schema. 342 342 + */ 343 343 + current: Pipes; 344 344 + }; 345 345 + /** 346 346 + * The plugin instance. 347 347 + */ 336 348 plugin: ValibotPlugin['Instance']; 337 337 - }; 349 349 + /** 350 350 + * Provides access to commonly used symbols within the plugin. 351 351 + */ 352 352 + symbols: { 353 353 + v: Symbol; 354 354 + }; 355 355 + } 338 356 339 339 - export type FormatResolverArgs = SharedResolverArgs & { 340 340 - schema: IR.SchemaObject; 341 341 - }; 357 357 + export interface NumberResolverContext extends BaseResolverContext { 358 358 + /** 359 359 + * Nodes used to build different parts of the number schema. 360 360 + */ 361 361 + nodes: { 362 362 + base: (ctx: NumberResolverContext) => PipeResult; 363 363 + const: (ctx: NumberResolverContext) => PipeResult | undefined; 364 364 + max: (ctx: NumberResolverContext) => PipeResult | undefined; 365 365 + min: (ctx: NumberResolverContext) => PipeResult | undefined; 366 366 + }; 367 367 + schema: SchemaWithType<'integer' | 'number'>; 368 368 + /** 369 369 + * Utility functions for number schema processing. 370 370 + */ 371 371 + utils: { 372 372 + getIntegerLimit: GetIntegerLimit; 373 373 + maybeBigInt: MaybeBigInt; 374 374 + shouldCoerceToBigInt: ShouldCoerceToBigInt; 375 375 + }; 376 376 + } 342 377 343 343 - export type ObjectBaseResolverArgs = SharedResolverArgs & { 344 344 - /** Null = never */ 345 345 - additional?: ReturnType<typeof $.call | typeof $.expr> | null; 346 346 - schema: IR.SchemaObject; 347 347 - shape: ReturnType<typeof $.object>; 348 348 - }; 378 378 + export interface ObjectResolverContext extends BaseResolverContext { 379 379 + /** 380 380 + * Nodes used to build different parts of the object schema. 381 381 + */ 382 382 + nodes: { 383 383 + /** 384 384 + * If `additionalProperties` is `false` or `{ type: 'never' }`, returns `null` 385 385 + * to indicate no additional properties are allowed. 386 386 + */ 387 387 + additionalProperties: ( 388 388 + ctx: ObjectResolverContext, 389 389 + ) => Pipe | null | undefined; 390 390 + base: (ctx: ObjectResolverContext) => PipeResult; 391 391 + shape: (ctx: ObjectResolverContext) => ReturnType<typeof $.object>; 392 392 + }; 393 393 + schema: SchemaWithType<'object'>; 394 394 + /** 395 395 + * Utility functions for object schema processing. 396 396 + */ 397 397 + utils: { 398 398 + ast: Partial<Omit<Ast, 'typeName'>>; 399 399 + state: Refs<PluginState>; 400 400 + }; 401 401 + } 349 402 350 350 - export type ValidatorResolverArgs = SharedResolverArgs & { 403 403 + export interface StringResolverContext extends BaseResolverContext { 404 404 + /** 405 405 + * Nodes used to build different parts of the string schema. 406 406 + */ 407 407 + nodes: { 408 408 + base: (ctx: StringResolverContext) => PipeResult; 409 409 + const: (ctx: StringResolverContext) => PipeResult | undefined; 410 410 + format: (ctx: StringResolverContext) => PipeResult | undefined; 411 411 + length: (ctx: StringResolverContext) => PipeResult | undefined; 412 412 + maxLength: (ctx: StringResolverContext) => PipeResult | undefined; 413 413 + minLength: (ctx: StringResolverContext) => PipeResult | undefined; 414 414 + pattern: (ctx: StringResolverContext) => PipeResult | undefined; 415 415 + }; 416 416 + schema: SchemaWithType<'string'>; 417 417 + } 418 418 + 419 419 + export interface ValidatorResolverContext extends BaseResolverContext { 351 420 operation: IR.Operation; 352 352 - schema: Symbol; 353 353 - v: Symbol; 354 354 - }; 421 421 + /** 422 422 + * Provides access to commonly used symbols within the plugin. 423 423 + */ 424 424 + symbols: BaseResolverContext['symbols'] & { 425 425 + schema: Symbol; 426 426 + }; 427 427 + } 355 428 356 429 type ValidatorResolver = ( 357 357 - args: ValidatorResolverArgs, 358 358 - ) => MaybeArray<TsDsl<ts.Statement>> | null | undefined; 430 430 + ctx: ValidatorResolverContext, 431 431 + ) => PipeResult | null | undefined; 359 432 360 433 type Resolvers = Plugin.Resolvers<{ 361 434 /** 362 362 - * Resolvers for number schemas. 435 435 + * Resolver for number schemas. 363 436 * 364 364 - * Allows customization of how number types are rendered, including 365 365 - * per-format handling. 437 437 + * Allows customization of how number types are rendered. 438 438 + * 439 439 + * Returning `undefined` will execute the default resolver logic. 366 440 */ 367 367 - number?: { 368 368 - /** 369 369 - * Resolvers for number formats (e.g., `float`, `double`, `int32`). 370 370 - * 371 371 - * Each key represents a specific format name with a custom 372 372 - * resolver function that controls how that format is rendered. 373 373 - * 374 374 - * Example path: `~resolvers.number.formats.float` 375 375 - * 376 376 - * Returning `undefined` from a resolver will apply the default 377 377 - * generation behavior for that format. 378 378 - */ 379 379 - formats?: Record< 380 380 - string, 381 381 - (args: FormatResolverArgs) => boolean | number | undefined 382 382 - >; 383 383 - }; 441 441 + number?: (ctx: NumberResolverContext) => PipeResult | undefined; 384 442 /** 385 385 - * Resolvers for object schemas. 443 443 + * Resolver for object schemas. 386 444 * 387 445 * Allows customization of how object types are rendered. 388 446 * 389 389 - * Example path: `~resolvers.object.base` 390 390 - * 391 391 - * Returning `undefined` from a resolver will apply the default 392 392 - * generation behavior for the object schema. 447 447 + * Returning `undefined` will execute the default resolver logic. 393 448 */ 394 394 - object?: { 395 395 - /** 396 396 - * Controls how object schemas are constructed. 397 397 - * 398 398 - * Called with the fully assembled shape (properties) and any additional 399 399 - * property schema, allowing the resolver to choose the correct Valibot 400 400 - * base constructor and modify the schema chain if needed. 401 401 - * 402 402 - * Returning `undefined` will execute the default resolver logic. 403 403 - */ 404 404 - base?: ( 405 405 - args: ObjectBaseResolverArgs, 406 406 - ) => ReturnType<typeof $.call> | undefined; 407 407 - }; 449 449 + object?: (ctx: ObjectResolverContext) => PipeResult | undefined; 408 450 /** 409 409 - * Resolvers for string schemas. 451 451 + * Resolver for string schemas. 410 452 * 411 411 - * Allows customization of how string types are rendered, including 412 412 - * per-format handling. 453 453 + * Allows customization of how string types are rendered. 454 454 + * 455 455 + * Returning `undefined` will execute the default resolver logic. 413 456 */ 414 414 - string?: { 415 415 - /** 416 416 - * Resolvers for string formats (e.g., `uuid`, `email`, `date-time`). 417 417 - * 418 418 - * Each key represents a specific format name with a custom 419 419 - * resolver function that controls how that format is rendered. 420 420 - * 421 421 - * Example path: `~resolvers.string.formats.uuid` 422 422 - * 423 423 - * Returning `undefined` from a resolver will apply the default 424 424 - * generation behavior for that format. 425 425 - */ 426 426 - formats?: Record< 427 427 - string, 428 428 - (args: FormatResolverArgs) => boolean | number | undefined 429 429 - >; 430 430 - }; 457 457 + string?: (ctx: StringResolverContext) => PipeResult | undefined; 431 458 /** 432 459 * Resolvers for request and response validators. 433 460 * ··· 435 462 * 436 463 * Example path: `~resolvers.validator.request` or `~resolvers.validator.response` 437 464 * 438 438 - * Returning `undefined` from a resolver will apply the default generation logic. 465 465 + * Returning `undefined` will execute the default resolver logic. 439 466 */ 440 467 validator?: 441 468 | ValidatorResolver ··· 443 470 /** 444 471 * Controls how the request validator function body is generated. 445 472 * 446 446 - * Returning `undefined` will fall back to the default `.await().return()` logic. 473 473 + * Returning `undefined` will execute the default resolver logic. 447 474 */ 448 475 request?: ValidatorResolver; 449 476 /** 450 477 * Controls how the response validator function body is generated. 451 478 * 452 452 - * Returning `undefined` will fall back to the default `.await().return()` logic. 479 479 + * Returning `undefined` will execute the default resolver logic. 453 480 */ 454 481 response?: ValidatorResolver; 455 482 };

+34 -26

packages/openapi-ts/src/plugins/valibot/v1/api.ts

··· 1 1 import { $ } from '~/ts-dsl'; 2 2 3 3 + import { pipes } from '../shared/pipes'; 3 4 import type { ValidatorArgs } from '../shared/types'; 4 4 - import type { ValidatorResolverArgs } from '../types'; 5 5 + import type { ValidatorResolverContext } from '../types'; 5 6 import { identifiers } from './constants'; 6 7 7 7 - const defaultValidatorResolver = ({ 8 8 - schema, 9 9 - v, 10 10 - }: ValidatorResolverArgs): ReturnType<typeof $.return> => 11 11 - $(v).attr(identifiers.async.parseAsync).call(schema, 'data').await().return(); 8 8 + const validatorResolver = ( 9 9 + ctx: ValidatorResolverContext, 10 10 + ): ReturnType<typeof $.return> => { 11 11 + const { schema, v } = ctx.symbols; 12 12 + return $(v) 13 13 + .attr(identifiers.async.parseAsync) 14 14 + .call(schema, 'data') 15 15 + .await() 16 16 + .return(); 17 17 + }; 12 18 13 19 export const createRequestValidatorV1 = ({ 14 20 operation, ··· 23 29 }); 24 30 if (!symbol) return; 25 31 26 26 - const v = plugin.referenceSymbol({ 27 27 - category: 'external', 28 28 - resource: 'valibot.v', 29 29 - }); 30 30 - const args: ValidatorResolverArgs = { 32 32 + const ctx: ValidatorResolverContext = { 31 33 $, 32 34 operation, 33 33 - pipes: [], 35 35 + pipes: { 36 36 + ...pipes, 37 37 + current: [], 38 38 + }, 34 39 plugin, 35 35 - schema: symbol, 36 36 - v, 40 40 + symbols: { 41 41 + schema: symbol, 42 42 + v: plugin.external('valibot.v'), 43 43 + }, 37 44 }; 38 45 const validator = plugin.config['~resolvers']?.validator; 39 46 const resolver = 40 47 typeof validator === 'function' ? validator : validator?.request; 41 41 - const candidates = [resolver, defaultValidatorResolver]; 48 48 + const candidates = [resolver, validatorResolver]; 42 49 for (const candidate of candidates) { 43 43 - const statements = candidate?.(args); 50 50 + const statements = candidate?.(ctx); 44 51 if (statements === null) return; 45 52 if (statements !== undefined) { 46 53 return $.func() ··· 65 72 }); 66 73 if (!symbol) return; 67 74 68 68 - const v = plugin.referenceSymbol({ 69 69 - category: 'external', 70 70 - resource: 'valibot.v', 71 71 - }); 72 72 - const args: ValidatorResolverArgs = { 75 75 + const ctx: ValidatorResolverContext = { 73 76 $, 74 77 operation, 75 75 - pipes: [], 78 78 + pipes: { 79 79 + ...pipes, 80 80 + current: [], 81 81 + }, 76 82 plugin, 77 77 - schema: symbol, 78 78 - v, 83 83 + symbols: { 84 84 + schema: symbol, 85 85 + v: plugin.external('valibot.v'), 86 86 + }, 79 87 }; 80 88 const validator = plugin.config['~resolvers']?.validator; 81 89 const resolver = 82 90 typeof validator === 'function' ? validator : validator?.response; 83 83 - const candidates = [resolver, defaultValidatorResolver]; 91 91 + const candidates = [resolver, validatorResolver]; 84 92 for (const candidate of candidates) { 85 85 - const statements = candidate?.(args); 93 93 + const statements = candidate?.(ctx); 86 94 if (statements === null) return; 87 95 if (statements !== undefined) { 88 96 return $.func()

+4 -4

packages/openapi-ts/src/plugins/valibot/v1/plugin.ts

··· 11 11 12 12 import { exportAst } from '../shared/export'; 13 13 import { irOperationToAst } from '../shared/operation'; 14 14 - import { pipesToAst } from '../shared/pipesToAst'; 14 14 + import { pipesToNode } from '../shared/pipes'; 15 15 import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types'; 16 16 import { irWebhookToAst } from '../shared/webhook'; 17 17 import type { ValibotPlugin } from '../types'; ··· 87 87 path: ref([...fromRef(state.path), 'items', index]), 88 88 }, 89 89 }); 90 90 - return pipesToAst(itemAst.pipes, plugin); 90 90 + return pipesToNode(itemAst.pipes, plugin); 91 91 }); 92 92 93 93 if (schema.logicalOperator === 'and') { ··· 129 129 $(v) 130 130 .attr(identifiers.schemas.optional) 131 131 .call( 132 132 - pipesToAst(ast.pipes, plugin), 132 132 + pipesToNode(ast.pipes, plugin), 133 133 schema.type === 'integer' || schema.type === 'number' 134 134 ? maybeBigInt(schema.default, schema.format) 135 135 : $.fromValue(schema.default), ··· 139 139 ast.pipes = [ 140 140 $(v) 141 141 .attr(identifiers.schemas.optional) 142 142 - .call(pipesToAst(ast.pipes, plugin)), 142 142 + .call(pipesToNode(ast.pipes, plugin)), 143 143 ]; 144 144 } 145 145 }

+2 -2

packages/openapi-ts/src/plugins/valibot/v1/toAst/array.ts

··· 4 4 import type { SchemaWithType } from '~/plugins'; 5 5 import { $ } from '~/ts-dsl'; 6 6 7 7 - import { pipesToAst } from '../../shared/pipesToAst'; 7 7 + import { pipesToNode } from '../../shared/pipes'; 8 8 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 9 9 import { identifiers } from '../constants'; 10 10 import { irSchemaToAst } from '../plugin'; ··· 54 54 if (itemAst.hasLazyExpression) { 55 55 result.hasLazyExpression = true; 56 56 } 57 57 - return pipesToAst(itemAst.pipes, plugin); 57 57 + return pipesToNode(itemAst.pipes, plugin); 58 58 }); 59 59 60 60 if (itemExpressions.length === 1) {

+3 -3

packages/openapi-ts/src/plugins/valibot/v1/toAst/boolean.ts

··· 1 1 import type { SchemaWithType } from '~/plugins'; 2 2 import { $ } from '~/ts-dsl'; 3 3 4 4 - import { pipesToAst } from '../../shared/pipesToAst'; 4 4 + import { pipesToNode } from '../../shared/pipes'; 5 5 import type { IrSchemaToAstOptions } from '../../shared/types'; 6 6 import { identifiers } from '../constants'; 7 7 ··· 22 22 pipes.push( 23 23 $(v).attr(identifiers.schemas.literal).call($.literal(schema.const)), 24 24 ); 25 25 - return pipesToAst(pipes, plugin); 25 25 + return pipesToNode(pipes, plugin); 26 26 } 27 27 28 28 pipes.push($(v).attr(identifiers.schemas.boolean).call()); 29 29 - return pipesToAst(pipes, plugin); 29 29 + return pipesToNode(pipes, plugin); 30 30 };

+9 -9

packages/openapi-ts/src/plugins/valibot/v1/toAst/index.ts

··· 2 2 import { shouldCoerceToBigInt } from '~/plugins/shared/utils/coerce'; 3 3 import type { $ } from '~/ts-dsl'; 4 4 5 5 - import { pipesToAst } from '../../shared/pipesToAst'; 5 5 + import { pipesToNode } from '../../shared/pipes'; 6 6 import type { IrSchemaToAstOptions } from '../../shared/types'; 7 7 import { arrayToAst } from './array'; 8 8 import { booleanToAst } from './boolean'; 9 9 import { enumToAst } from './enum'; 10 10 import { neverToAst } from './never'; 11 11 import { nullToAst } from './null'; 12 12 - import { numberToAst } from './number'; 12 12 + import { numberToNode } from './number'; 13 13 import { objectToAst } from './object'; 14 14 - import { stringToAst } from './string'; 14 14 + import { stringToNode } from './string'; 15 15 import { tupleToAst } from './tuple'; 16 16 import { undefinedToAst } from './undefined'; 17 17 import { unknownToAst } from './unknown'; ··· 29 29 switch (schema.type) { 30 30 case 'array': 31 31 return { 32 32 - expression: pipesToAst( 32 32 + expression: pipesToNode( 33 33 arrayToAst({ 34 34 ...args, 35 35 schema: schema as SchemaWithType<'array'>, ··· 54 54 case 'integer': 55 55 case 'number': 56 56 return { 57 57 - expression: numberToAst({ 57 57 + expression: numberToNode({ 58 58 ...args, 59 59 schema: schema as SchemaWithType<'integer' | 'number'>, 60 60 }), ··· 75 75 }; 76 76 case 'object': 77 77 return { 78 78 - expression: pipesToAst( 78 78 + expression: pipesToNode( 79 79 objectToAst({ 80 80 ...args, 81 81 schema: schema as SchemaWithType<'object'>, ··· 86 86 case 'string': 87 87 return { 88 88 expression: shouldCoerceToBigInt(schema.format) 89 89 - ? numberToAst({ 89 89 + ? numberToNode({ 90 90 ...args, 91 91 schema: { ...schema, type: 'number' }, 92 92 }) 93 93 - : stringToAst({ 93 93 + : stringToNode({ 94 94 ...args, 95 95 schema: schema as SchemaWithType<'string'>, 96 96 }), 97 97 }; 98 98 case 'tuple': 99 99 return { 100 100 - expression: pipesToAst( 100 100 + expression: pipesToNode( 101 101 tupleToAst({ 102 102 ...args, 103 103 schema: schema as SchemaWithType<'tuple'>,

+117 -69

packages/openapi-ts/src/plugins/valibot/v1/toAst/number.ts

··· 6 6 import { getIntegerLimit } from '~/plugins/shared/utils/formats'; 7 7 import { $ } from '~/ts-dsl'; 8 8 9 9 - import { pipesToAst } from '../../shared/pipesToAst'; 9 9 + import type { Pipe, PipeResult, Pipes } from '../../shared/pipes'; 10 10 + import { pipes } from '../../shared/pipes'; 10 11 import type { IrSchemaToAstOptions } from '../../shared/types'; 12 12 + import type { NumberResolverContext } from '../../types'; 11 13 import { identifiers } from '../constants'; 12 14 13 13 - export const numberToAst = ({ 14 14 - plugin, 15 15 - schema, 16 16 - }: IrSchemaToAstOptions & { 17 17 - schema: SchemaWithType<'integer' | 'number'>; 18 18 - }) => { 19 19 - const v = plugin.referenceSymbol({ 20 20 - category: 'external', 21 21 - resource: 'valibot.v', 22 22 - }); 23 23 - 24 24 - if (schema.const !== undefined) { 25 25 - return $(v) 26 26 - .attr(identifiers.schemas.literal) 27 27 - .call(maybeBigInt(schema.const, schema.format)); 28 28 - } 29 29 - 30 30 - const pipes: Array<ReturnType<typeof $.call>> = []; 31 31 - 32 32 - if (shouldCoerceToBigInt(schema.format)) { 33 33 - pipes.push( 15 15 + function baseNode(ctx: NumberResolverContext): PipeResult { 16 16 + const { schema, symbols } = ctx; 17 17 + const { v } = symbols; 18 18 + if (ctx.utils.shouldCoerceToBigInt(schema.format)) { 19 19 + return [ 34 20 $(v) 35 21 .attr(identifiers.schemas.union) 36 22 .call( ··· 43 29 $(v) 44 30 .attr(identifiers.actions.transform) 45 31 .call($.func().param('x').do($('BigInt').call('x').return())), 46 46 - ); 47 47 - } else { 48 48 - pipes.push($(v).attr(identifiers.schemas.number).call()); 49 49 - if (schema.type === 'integer') { 50 50 - pipes.push($(v).attr(identifiers.actions.integer).call()); 51 51 - } 32 32 + ]; 33 33 + } 34 34 + const pipes: Pipes = []; 35 35 + pipes.push($(v).attr(identifiers.schemas.number).call()); 36 36 + if (schema.type === 'integer') { 37 37 + pipes.push($(v).attr(identifiers.actions.integer).call()); 52 38 } 39 39 + return pipes; 40 40 + } 53 41 54 54 - const integerLimit = getIntegerLimit(schema.format); 55 55 - if (integerLimit) { 56 56 - pipes.push( 57 57 - $(v) 58 58 - .attr(identifiers.actions.minValue) 59 59 - .call( 60 60 - maybeBigInt(integerLimit.minValue, schema.format), 61 61 - $.literal(integerLimit.minError), 62 62 - ), 63 63 - $(v) 64 64 - .attr(identifiers.actions.maxValue) 65 65 - .call( 66 66 - maybeBigInt(integerLimit.maxValue, schema.format), 67 67 - $.literal(integerLimit.maxError), 68 68 - ), 69 69 - ); 42 42 + function constNode(ctx: NumberResolverContext): PipeResult | undefined { 43 43 + const { schema, symbols } = ctx; 44 44 + const { v } = symbols; 45 45 + if (schema.const === undefined) return; 46 46 + return $(v) 47 47 + .attr(identifiers.schemas.literal) 48 48 + .call(ctx.utils.maybeBigInt(schema.const, schema.format)); 49 49 + } 50 50 + 51 51 + function maxNode(ctx: NumberResolverContext): PipeResult | undefined { 52 52 + const { schema, symbols } = ctx; 53 53 + const { v } = symbols; 54 54 + if (schema.exclusiveMaximum !== undefined) { 55 55 + return $(v) 56 56 + .attr(identifiers.actions.ltValue) 57 57 + .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format)); 70 58 } 59 59 + if (schema.maximum !== undefined) { 60 60 + return $(v) 61 61 + .attr(identifiers.actions.maxValue) 62 62 + .call(ctx.utils.maybeBigInt(schema.maximum, schema.format)); 63 63 + } 64 64 + const limit = ctx.utils.getIntegerLimit(schema.format); 65 65 + if (limit) { 66 66 + return $(v) 67 67 + .attr(identifiers.actions.maxValue) 68 68 + .call( 69 69 + ctx.utils.maybeBigInt(limit.maxValue, schema.format), 70 70 + $.literal(limit.maxError), 71 71 + ); 72 72 + } 73 73 + return; 74 74 + } 71 75 76 76 + function minNode(ctx: NumberResolverContext): PipeResult | undefined { 77 77 + const { schema, symbols } = ctx; 78 78 + const { v } = symbols; 72 79 if (schema.exclusiveMinimum !== undefined) { 73 73 - pipes.push( 74 74 - $(v) 75 75 - .attr(identifiers.actions.gtValue) 76 76 - .call(maybeBigInt(schema.exclusiveMinimum, schema.format)), 77 77 - ); 78 78 - } else if (schema.minimum !== undefined) { 79 79 - pipes.push( 80 80 - $(v) 81 81 - .attr(identifiers.actions.minValue) 82 82 - .call(maybeBigInt(schema.minimum, schema.format)), 83 83 - ); 80 80 + return $(v) 81 81 + .attr(identifiers.actions.gtValue) 82 82 + .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format)); 83 83 + } 84 84 + if (schema.minimum !== undefined) { 85 85 + return $(v) 86 86 + .attr(identifiers.actions.minValue) 87 87 + .call(ctx.utils.maybeBigInt(schema.minimum, schema.format)); 88 88 + } 89 89 + const limit = ctx.utils.getIntegerLimit(schema.format); 90 90 + if (limit) { 91 91 + return $(v) 92 92 + .attr(identifiers.actions.minValue) 93 93 + .call( 94 94 + ctx.utils.maybeBigInt(limit.minValue, schema.format), 95 95 + $.literal(limit.minError), 96 96 + ); 84 97 } 98 98 + return; 99 99 + } 100 100 + 101 101 + function numberResolver(ctx: NumberResolverContext): Pipes { 102 102 + const constNode = ctx.nodes.const(ctx); 103 103 + if (constNode) return ctx.pipes.push(ctx.pipes.current, constNode); 85 104 86 86 - if (schema.exclusiveMaximum !== undefined) { 87 87 - pipes.push( 88 88 - $(v) 89 89 - .attr(identifiers.actions.ltValue) 90 90 - .call(maybeBigInt(schema.exclusiveMaximum, schema.format)), 91 91 - ); 92 92 - } else if (schema.maximum !== undefined) { 93 93 - pipes.push( 94 94 - $(v) 95 95 - .attr(identifiers.actions.maxValue) 96 96 - .call(maybeBigInt(schema.maximum, schema.format)), 97 97 - ); 98 98 - } 105 105 + const baseNode = ctx.nodes.base(ctx); 106 106 + if (baseNode) ctx.pipes.push(ctx.pipes.current, baseNode); 107 107 + 108 108 + const minNode = ctx.nodes.min(ctx); 109 109 + if (minNode) ctx.pipes.push(ctx.pipes.current, minNode); 110 110 + 111 111 + const maxNode = ctx.nodes.max(ctx); 112 112 + if (maxNode) ctx.pipes.push(ctx.pipes.current, maxNode); 113 113 + 114 114 + return ctx.pipes.current; 115 115 + } 99 116 100 100 - return pipesToAst(pipes, plugin); 117 117 + export const numberToNode = ({ 118 118 + plugin, 119 119 + schema, 120 120 + }: IrSchemaToAstOptions & { 121 121 + schema: SchemaWithType<'integer' | 'number'>; 122 122 + }): Pipe => { 123 123 + const ctx: NumberResolverContext = { 124 124 + $, 125 125 + nodes: { 126 126 + base: baseNode, 127 127 + const: constNode, 128 128 + max: maxNode, 129 129 + min: minNode, 130 130 + }, 131 131 + pipes: { 132 132 + ...pipes, 133 133 + current: [], 134 134 + }, 135 135 + plugin, 136 136 + schema, 137 137 + symbols: { 138 138 + v: plugin.external('valibot.v'), 139 139 + }, 140 140 + utils: { 141 141 + getIntegerLimit, 142 142 + maybeBigInt, 143 143 + shouldCoerceToBigInt, 144 144 + }, 145 145 + }; 146 146 + const resolver = plugin.config['~resolvers']?.number; 147 147 + const node = resolver?.(ctx) ?? numberResolver(ctx); 148 148 + return ctx.pipes.toNode(node, plugin); 101 149 };

+76 -69

packages/openapi-ts/src/plugins/valibot/v1/toAst/object.ts

··· 3 3 import type { SchemaWithType } from '~/plugins'; 4 4 import { $ } from '~/ts-dsl'; 5 5 6 6 - import { pipesToAst } from '../../shared/pipesToAst'; 6 6 + import type { Pipe, PipeResult } from '../../shared/pipes'; 7 7 + import { pipes } from '../../shared/pipes'; 7 8 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 8 8 - import type { ObjectBaseResolverArgs } from '../../types'; 9 9 + import type { ObjectResolverContext } from '../../types'; 9 10 import { identifiers } from '../constants'; 10 11 import { irSchemaToAst } from '../plugin'; 11 12 12 12 - function defaultObjectBaseResolver({ 13 13 - additional, 14 14 - pipes, 15 15 - plugin, 16 16 - shape, 17 17 - }: ObjectBaseResolverArgs): number { 18 18 - const v = plugin.referenceSymbol({ 19 19 - category: 'external', 20 20 - resource: 'valibot.v', 13 13 + function additionalPropertiesNode( 14 14 + ctx: ObjectResolverContext, 15 15 + ): Pipe | null | undefined { 16 16 + const { plugin, schema } = ctx; 17 17 + 18 18 + if (!schema.additionalProperties || !schema.additionalProperties.type) return; 19 19 + if (schema.additionalProperties.type === 'never') return null; 20 20 + 21 21 + const additionalAst = irSchemaToAst({ 22 22 + plugin, 23 23 + schema: schema.additionalProperties, 24 24 + state: { 25 25 + ...ctx.utils.state, 26 26 + path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']), 27 27 + }, 21 28 }); 29 29 + if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true; 30 30 + return pipes.toNode(additionalAst.pipes, plugin); 31 31 + } 22 32 23 23 - // Handle `additionalProperties: { type: 'never' }` → v.strictObject() 33 33 + function baseNode(ctx: ObjectResolverContext): PipeResult { 34 34 + const { nodes, symbols } = ctx; 35 35 + const { v } = symbols; 36 36 + 37 37 + const additional = nodes.additionalProperties(ctx); 38 38 + const shape = nodes.shape(ctx); 39 39 + 24 40 if (additional === null) { 25 25 - return pipes.push($(v).attr(identifiers.schemas.strictObject).call(shape)); 41 41 + return $(v).attr(identifiers.schemas.strictObject).call(shape); 26 42 } 27 43 28 28 - // Handle additionalProperties as schema → v.record() or v.objectWithRest() 29 44 if (additional) { 30 45 if (shape.isEmpty) { 31 31 - return pipes.push( 32 32 - $(v) 33 33 - .attr(identifiers.schemas.record) 34 34 - .call($(v).attr(identifiers.schemas.string).call(), additional), 35 35 - ); 46 46 + return $(v) 47 47 + .attr(identifiers.schemas.record) 48 48 + .call($(v).attr(identifiers.schemas.string).call(), additional); 36 49 } 37 50 38 38 - // If there are named properties, use v.objectWithRest() to validate both 39 39 - return pipes.push( 40 40 - $(v).attr(identifiers.schemas.objectWithRest).call(shape, additional), 41 41 - ); 51 51 + return $(v) 52 52 + .attr(identifiers.schemas.objectWithRest) 53 53 + .call(shape, additional); 42 54 } 43 55 44 44 - // Default case → v.object() 45 45 - return pipes.push($(v).attr(identifiers.schemas.object).call(shape)); 56 56 + return $(v).attr(identifiers.schemas.object).call(shape); 46 57 } 47 58 48 48 - export const objectToAst = ({ 49 49 - plugin, 50 50 - schema, 51 51 - state, 52 52 - }: IrSchemaToAstOptions & { 53 53 - schema: SchemaWithType<'object'>; 54 54 - }): Omit<Ast, 'typeName'> => { 55 55 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 56 56 - const pipes: Array<ReturnType<typeof $.call>> = []; 57 57 - 59 59 + function objectResolver(ctx: ObjectResolverContext): PipeResult { 58 60 // TODO: parser - handle constants 61 61 + return ctx.nodes.base(ctx); 62 62 + } 59 63 64 64 + function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> { 65 65 + const { plugin, schema } = ctx; 60 66 const shape = $.object().pretty(); 61 61 - const required = schema.required ?? []; 62 67 63 68 for (const name in schema.properties) { 64 69 const property = schema.properties[name]!; 65 65 - const isRequired = required.includes(name); 66 70 67 71 const propertyAst = irSchemaToAst({ 68 68 - optional: !isRequired, 72 72 + optional: !schema.required?.includes(name), 69 73 plugin, 70 74 schema: property, 71 75 state: { 72 72 - ...state, 73 73 - path: ref([...fromRef(state.path), 'properties', name]), 76 76 + ...ctx.utils.state, 77 77 + path: ref([...fromRef(ctx.utils.state.path), 'properties', name]), 74 78 }, 75 79 }); 76 76 - if (propertyAst.hasLazyExpression) result.hasLazyExpression = true; 77 77 - 78 78 - shape.prop(name, pipesToAst(propertyAst.pipes, plugin)); 80 80 + if (propertyAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true; 81 81 + shape.prop(name, pipes.toNode(propertyAst.pipes, plugin)); 79 82 } 80 83 81 81 - let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined; 82 82 - if (schema.additionalProperties && schema.additionalProperties.type) { 83 83 - if (schema.additionalProperties.type === 'never') { 84 84 - additional = null; 85 85 - } else { 86 86 - const additionalAst = irSchemaToAst({ 87 87 - plugin, 88 88 - schema: schema.additionalProperties, 89 89 - state: { 90 90 - ...state, 91 91 - path: ref([...fromRef(state.path), 'additionalProperties']), 92 92 - }, 93 93 - }); 94 94 - if (additionalAst.hasLazyExpression) result.hasLazyExpression = true; 95 95 - additional = pipesToAst(additionalAst.pipes, plugin); 96 96 - } 97 97 - } 84 84 + return shape; 85 85 + } 98 86 99 99 - const args: ObjectBaseResolverArgs = { 87 87 + export const objectToAst = ({ 88 88 + plugin, 89 89 + schema, 90 90 + state, 91 91 + }: IrSchemaToAstOptions & { 92 92 + schema: SchemaWithType<'object'>; 93 93 + }): Omit<Ast, 'typeName'> => { 94 94 + const ctx: ObjectResolverContext = { 100 95 $, 101 101 - additional, 102 102 - pipes, 96 96 + nodes: { 97 97 + additionalProperties: additionalPropertiesNode, 98 98 + base: baseNode, 99 99 + shape: shapeNode, 100 100 + }, 101 101 + pipes: { 102 102 + ...pipes, 103 103 + current: [], 104 104 + }, 103 105 plugin, 104 106 schema, 105 105 - shape, 107 107 + symbols: { 108 108 + v: plugin.external('valibot.v'), 109 109 + }, 110 110 + utils: { 111 111 + ast: {}, 112 112 + state, 113 113 + }, 106 114 }; 107 107 - const resolver = plugin.config['~resolvers']?.object?.base; 108 108 - if (!resolver?.(args)) defaultObjectBaseResolver(args); 109 109 - 110 110 - result.pipes = [pipesToAst(pipes, plugin)]; 111 111 - return result as Omit<Ast, 'typeName'>; 115 115 + const resolver = plugin.config['~resolvers']?.object; 116 116 + const node = resolver?.(ctx) ?? objectResolver(ctx); 117 117 + ctx.utils.ast.pipes = [ctx.pipes.toNode(node, plugin)]; 118 118 + return ctx.utils.ast as Omit<Ast, 'typeName'>; 112 119 };

+109 -65

packages/openapi-ts/src/plugins/valibot/v1/toAst/string.ts

··· 1 1 import type { SchemaWithType } from '~/plugins'; 2 2 import { $ } from '~/ts-dsl'; 3 3 4 4 - import { pipesToAst } from '../../shared/pipesToAst'; 4 4 + import type { Pipe, PipeResult, Pipes } from '../../shared/pipes'; 5 5 + import { pipes } from '../../shared/pipes'; 5 6 import type { IrSchemaToAstOptions } from '../../shared/types'; 6 6 - import type { FormatResolverArgs } from '../../types'; 7 7 + import type { StringResolverContext } from '../../types'; 7 8 import { identifiers } from '../constants'; 8 9 9 9 - const defaultFormatResolver = ({ 10 10 - pipes, 11 11 - plugin, 12 12 - schema, 13 13 - }: FormatResolverArgs): boolean | number => { 14 14 - const v = plugin.referenceSymbol({ 15 15 - category: 'external', 16 16 - resource: 'valibot.v', 17 17 - }); 10 10 + function baseNode(ctx: StringResolverContext): PipeResult { 11 11 + const { v } = ctx.symbols; 12 12 + return $(v).attr(identifiers.schemas.string).call(); 13 13 + } 18 14 15 15 + function constNode(ctx: StringResolverContext): PipeResult | undefined { 16 16 + const { schema, symbols } = ctx; 17 17 + const { v } = symbols; 18 18 + if (typeof schema.const !== 'string') return; 19 19 + return $(v).attr(identifiers.schemas.literal).call($.literal(schema.const)); 20 20 + } 21 21 + 22 22 + function formatNode(ctx: StringResolverContext): PipeResult | undefined { 23 23 + const { schema, symbols } = ctx; 24 24 + const { v } = symbols; 19 25 switch (schema.format) { 20 26 case 'date': 21 21 - return pipes.push($(v).attr(identifiers.actions.isoDate).call()); 27 27 + return $(v).attr(identifiers.actions.isoDate).call(); 22 28 case 'date-time': 23 23 - return pipes.push($(v).attr(identifiers.actions.isoTimestamp).call()); 29 29 + return $(v).attr(identifiers.actions.isoTimestamp).call(); 24 30 case 'email': 25 25 - return pipes.push($(v).attr(identifiers.actions.email).call()); 31 31 + return $(v).attr(identifiers.actions.email).call(); 26 32 case 'ipv4': 27 33 case 'ipv6': 28 28 - return pipes.push($(v).attr(identifiers.actions.ip).call()); 34 34 + return $(v).attr(identifiers.actions.ip).call(); 29 35 case 'time': 30 30 - return pipes.push($(v).attr(identifiers.actions.isoTimeSecond).call()); 36 36 + return $(v).attr(identifiers.actions.isoTimeSecond).call(); 31 37 case 'uri': 32 32 - return pipes.push($(v).attr(identifiers.actions.url).call()); 38 38 + return $(v).attr(identifiers.actions.url).call(); 33 39 case 'uuid': 34 34 - return pipes.push($(v).attr(identifiers.actions.uuid).call()); 40 40 + return $(v).attr(identifiers.actions.uuid).call(); 35 41 } 36 42 37 37 - return true; 38 38 - }; 43 43 + return; 44 44 + } 39 45 40 40 - export const stringToAst = ({ 41 41 - plugin, 42 42 - schema, 43 43 - }: IrSchemaToAstOptions & { 44 44 - schema: SchemaWithType<'string'>; 45 45 - }): ReturnType<typeof $.call | typeof $.expr> => { 46 46 - const v = plugin.referenceSymbol({ 47 47 - category: 'external', 48 48 - resource: 'valibot.v', 49 49 - }); 46 46 + function lengthNode(ctx: StringResolverContext): PipeResult | undefined { 47 47 + const { schema, symbols } = ctx; 48 48 + const { v } = symbols; 49 49 + if (schema.minLength === undefined || schema.minLength !== schema.maxLength) 50 50 + return; 51 51 + return $(v) 52 52 + .attr(identifiers.actions.length) 53 53 + .call($.literal(schema.minLength)); 54 54 + } 50 55 51 51 - if (typeof schema.const === 'string') { 52 52 - return $(v).attr(identifiers.schemas.literal).call($.literal(schema.const)); 53 53 - } 56 56 + function maxLengthNode(ctx: StringResolverContext): PipeResult | undefined { 57 57 + const { schema, symbols } = ctx; 58 58 + const { v } = symbols; 59 59 + if (schema.maxLength === undefined) return; 60 60 + return $(v) 61 61 + .attr(identifiers.actions.maxLength) 62 62 + .call($.literal(schema.maxLength)); 63 63 + } 54 64 55 55 - const pipes: Array<ReturnType<typeof $.call>> = []; 56 56 - pipes.push($(v).attr(identifiers.schemas.string).call()); 65 65 + function minLengthNode(ctx: StringResolverContext): PipeResult | undefined { 66 66 + const { schema, symbols } = ctx; 67 67 + const { v } = symbols; 68 68 + if (schema.minLength === undefined) return; 69 69 + return $(v) 70 70 + .attr(identifiers.actions.minLength) 71 71 + .call($.literal(schema.minLength)); 72 72 + } 57 73 58 58 - if (schema.format) { 59 59 - const args: FormatResolverArgs = { $, pipes, plugin, schema }; 60 60 - const resolver = 61 61 - plugin.config['~resolvers']?.string?.formats?.[schema.format]; 62 62 - if (!resolver?.(args)) defaultFormatResolver(args); 63 63 - } 74 74 + function patternNode(ctx: StringResolverContext): PipeResult | undefined { 75 75 + const { schema, symbols } = ctx; 76 76 + const { v } = symbols; 77 77 + if (!schema.pattern) return; 78 78 + return $(v).attr(identifiers.actions.regex).call($.regexp(schema.pattern)); 79 79 + } 64 80 65 65 - if (schema.minLength === schema.maxLength && schema.minLength !== undefined) { 66 66 - pipes.push( 67 67 - $(v).attr(identifiers.actions.length).call($.literal(schema.minLength)), 68 68 - ); 81 81 + function stringResolver(ctx: StringResolverContext): Pipes { 82 82 + const constNode = ctx.nodes.const(ctx); 83 83 + if (constNode) return ctx.pipes.push(ctx.pipes.current, constNode); 84 84 + 85 85 + const baseNode = ctx.nodes.base(ctx); 86 86 + if (baseNode) ctx.pipes.push(ctx.pipes.current, baseNode); 87 87 + 88 88 + const formatNode = ctx.nodes.format(ctx); 89 89 + if (formatNode) ctx.pipes.push(ctx.pipes.current, formatNode); 90 90 + 91 91 + const lengthNode = ctx.nodes.length(ctx); 92 92 + if (lengthNode) { 93 93 + ctx.pipes.push(ctx.pipes.current, lengthNode); 69 94 } else { 70 70 - if (schema.minLength !== undefined) { 71 71 - pipes.push( 72 72 - $(v) 73 73 - .attr(identifiers.actions.minLength) 74 74 - .call($.literal(schema.minLength)), 75 75 - ); 76 76 - } 95 95 + const minLengthNode = ctx.nodes.minLength(ctx); 96 96 + if (minLengthNode) ctx.pipes.push(ctx.pipes.current, minLengthNode); 77 97 78 78 - if (schema.maxLength !== undefined) { 79 79 - pipes.push( 80 80 - $(v) 81 81 - .attr(identifiers.actions.maxLength) 82 82 - .call($.literal(schema.maxLength)), 83 83 - ); 84 84 - } 98 98 + const maxLengthNode = ctx.nodes.maxLength(ctx); 99 99 + if (maxLengthNode) ctx.pipes.push(ctx.pipes.current, maxLengthNode); 85 100 } 86 101 87 87 - if (schema.pattern) { 88 88 - pipes.push( 89 89 - $(v).attr(identifiers.actions.regex).call($.regexp(schema.pattern)), 90 90 - ); 91 91 - } 102 102 + const patternNode = ctx.nodes.pattern(ctx); 103 103 + if (patternNode) ctx.pipes.push(ctx.pipes.current, patternNode); 92 104 93 93 - return pipesToAst(pipes, plugin); 105 105 + return ctx.pipes.current; 106 106 + } 107 107 + 108 108 + export const stringToNode = ({ 109 109 + plugin, 110 110 + schema, 111 111 + }: IrSchemaToAstOptions & { 112 112 + schema: SchemaWithType<'string'>; 113 113 + }): Pipe => { 114 114 + const ctx: StringResolverContext = { 115 115 + $, 116 116 + nodes: { 117 117 + base: baseNode, 118 118 + const: constNode, 119 119 + format: formatNode, 120 120 + length: lengthNode, 121 121 + maxLength: maxLengthNode, 122 122 + minLength: minLengthNode, 123 123 + pattern: patternNode, 124 124 + }, 125 125 + pipes: { 126 126 + ...pipes, 127 127 + current: [], 128 128 + }, 129 129 + plugin, 130 130 + schema, 131 131 + symbols: { 132 132 + v: plugin.external('valibot.v'), 133 133 + }, 134 134 + }; 135 135 + const resolver = plugin.config['~resolvers']?.string; 136 136 + const node = resolver?.(ctx) ?? stringResolver(ctx); 137 137 + return ctx.pipes.toNode(node, plugin); 94 138 };

+2 -2

packages/openapi-ts/src/plugins/valibot/v1/toAst/tuple.ts

··· 3 3 import type { SchemaWithType } from '~/plugins'; 4 4 import { $ } from '~/ts-dsl'; 5 5 6 6 - import { pipesToAst } from '../../shared/pipesToAst'; 6 6 + import { pipesToNode } from '../../shared/pipes'; 7 7 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 8 8 import { identifiers } from '../constants'; 9 9 import { irSchemaToAst } from '../plugin'; ··· 48 48 if (schemaPipes.hasLazyExpression) { 49 49 result.hasLazyExpression = true; 50 50 } 51 51 - return pipesToAst(schemaPipes.pipes, plugin); 51 51 + return pipesToNode(schemaPipes.pipes, plugin); 52 52 }); 53 53 result.pipes = [ 54 54 $(v)

+29 -15

packages/openapi-ts/src/plugins/zod/mini/api.ts

··· 2 2 3 3 import { identifiers } from '../constants'; 4 4 import type { ValidatorArgs } from '../shared/types'; 5 5 - import type { ValidatorResolverArgs } from '../types'; 5 5 + import type { ValidatorResolverContext } from '../types'; 6 6 7 7 - const defaultValidatorResolver = ({ 8 8 - schema, 9 9 - }: ValidatorResolverArgs): ReturnType<typeof $.return> => 10 10 - $(schema).attr(identifiers.parseAsync).call('data').await().return(); 7 7 + const validatorResolver = ( 8 8 + ctx: ValidatorResolverContext, 9 9 + ): ReturnType<typeof $.return> => { 10 10 + const { schema } = ctx.symbols; 11 11 + return $(schema).attr(identifiers.parseAsync).call('data').await().return(); 12 12 + }; 11 13 12 14 export const createRequestValidatorMini = ({ 13 15 operation, ··· 22 24 }); 23 25 if (!symbol) return; 24 26 25 25 - const args: ValidatorResolverArgs = { 27 27 + const z = plugin.external('zod.z'); 28 28 + const ctx: ValidatorResolverContext = { 26 29 $, 27 27 - chain: undefined, 30 30 + chain: { 31 31 + current: $(z), 32 32 + }, 28 33 operation, 29 34 plugin, 30 30 - schema: symbol, 35 35 + symbols: { 36 36 + schema: symbol, 37 37 + z, 38 38 + }, 31 39 }; 32 40 const validator = plugin.config['~resolvers']?.validator; 33 41 const resolver = 34 42 typeof validator === 'function' ? validator : validator?.request; 35 35 - const candidates = [resolver, defaultValidatorResolver]; 43 43 + const candidates = [resolver, validatorResolver]; 36 44 for (const candidate of candidates) { 37 37 - const statements = candidate?.(args); 45 45 + const statements = candidate?.(ctx); 38 46 if (statements === null) return; 39 47 if (statements !== undefined) { 40 48 return $.func() ··· 59 67 }); 60 68 if (!symbol) return; 61 69 62 62 - const args: ValidatorResolverArgs = { 70 70 + const z = plugin.external('zod.z'); 71 71 + const ctx: ValidatorResolverContext = { 63 72 $, 64 64 - chain: undefined, 73 73 + chain: { 74 74 + current: $(z), 75 75 + }, 65 76 operation, 66 77 plugin, 67 67 - schema: symbol, 78 78 + symbols: { 79 79 + schema: symbol, 80 80 + z, 81 81 + }, 68 82 }; 69 83 const validator = plugin.config['~resolvers']?.validator; 70 84 const resolver = 71 85 typeof validator === 'function' ? validator : validator?.response; 72 72 - const candidates = [resolver, defaultValidatorResolver]; 86 86 + const candidates = [resolver, validatorResolver]; 73 87 for (const candidate of candidates) { 74 74 - const statements = candidate?.(args); 88 88 + const statements = candidate?.(ctx); 75 89 if (statements === null) return; 76 90 if (statements !== undefined) { 77 91 return $.func()

+1 -1

packages/openapi-ts/src/plugins/zod/mini/toAst/array.ts

··· 112 112 } 113 113 } 114 114 115 115 - if (checks.length) { 115 115 + if (checks.length > 0) { 116 116 result.expression = result.expression 117 117 .attr(identifiers.check) 118 118 .call(...checks);

+5 -5

packages/openapi-ts/src/plugins/zod/mini/toAst/index.ts

··· 7 7 import { enumToAst } from './enum'; 8 8 import { neverToAst } from './never'; 9 9 import { nullToAst } from './null'; 10 10 - import { numberToAst } from './number'; 10 10 + import { numberToNode } from './number'; 11 11 import { objectToAst } from './object'; 12 12 - import { stringToAst } from './string'; 12 12 + import { stringToNode } from './string'; 13 13 import { tupleToAst } from './tuple'; 14 14 import { undefinedToAst } from './undefined'; 15 15 import { unknownToAst } from './unknown'; ··· 39 39 }); 40 40 case 'integer': 41 41 case 'number': 42 42 - return numberToAst({ 42 42 + return numberToNode({ 43 43 ...args, 44 44 schema: schema as SchemaWithType<'integer' | 'number'>, 45 45 }); ··· 60 60 }); 61 61 case 'string': 62 62 return shouldCoerceToBigInt(schema.format) 63 63 - ? numberToAst({ 63 63 + ? numberToNode({ 64 64 ...args, 65 65 schema: { ...schema, type: 'number' }, 66 66 }) 67 67 - : stringToAst({ 67 67 + : stringToNode({ 68 68 ...args, 69 69 schema: schema as SchemaWithType<'string'>, 70 70 });

+123 -72

packages/openapi-ts/src/plugins/zod/mini/toAst/number.ts

··· 7 7 import { $ } from '~/ts-dsl'; 8 8 9 9 import { identifiers } from '../../constants'; 10 10 + import type { Chain } from '../../shared/chain'; 10 11 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 12 12 + import type { NumberResolverContext } from '../../types'; 11 13 12 12 - export const numberToAst = ({ 13 13 - plugin, 14 14 - schema, 15 15 - }: IrSchemaToAstOptions & { 16 16 - schema: SchemaWithType<'integer' | 'number'>; 17 17 - }): Omit<Ast, 'typeName'> => { 18 18 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 19 19 - 20 20 - const z = plugin.referenceSymbol({ 21 21 - category: 'external', 22 22 - resource: 'zod.z', 23 23 - }); 24 24 - 25 25 - if (schema.const !== undefined) { 26 26 - result.expression = $(z) 27 27 - .attr(identifiers.literal) 28 28 - .call(maybeBigInt(schema.const, schema.format)); 29 29 - return result as Omit<Ast, 'typeName'>; 14 14 + function baseNode(ctx: NumberResolverContext): Chain { 15 15 + const { schema, symbols } = ctx; 16 16 + const { z } = symbols; 17 17 + if (ctx.utils.shouldCoerceToBigInt(schema.format)) { 18 18 + return $(z).attr(identifiers.coerce).attr(identifiers.bigint).call(); 30 19 } 31 31 - 32 32 - if (shouldCoerceToBigInt(schema.format)) { 33 33 - result.expression = $(z) 34 34 - .attr(identifiers.coerce) 35 35 - .attr(identifiers.bigint) 36 36 - .call(); 37 37 - } else { 38 38 - result.expression = $(z).attr(identifiers.number).call(); 39 39 - if (schema.type === 'integer') { 40 40 - result.expression = $(z).attr(identifiers.int).call(); 41 41 - } 20 20 + let chain = $(z).attr(identifiers.number).call(); 21 21 + if (schema.type === 'integer') { 22 22 + chain = $(z).attr(identifiers.int).call(); 42 23 } 24 24 + return chain; 25 25 + } 43 26 44 44 - const checks: Array<ReturnType<typeof $.call>> = []; 27 27 + function constNode(ctx: NumberResolverContext): Chain | undefined { 28 28 + const { schema, symbols } = ctx; 29 29 + const { z } = symbols; 30 30 + if (schema.const === undefined) return; 31 31 + return $(z) 32 32 + .attr(identifiers.literal) 33 33 + .call(ctx.utils.maybeBigInt(schema.const, schema.format)); 34 34 + } 45 35 46 46 - const integerLimit = getIntegerLimit(schema.format); 47 47 - if (integerLimit) { 48 48 - checks.push( 49 49 - $(z) 50 50 - .attr(identifiers.minimum) 51 51 - .call( 52 52 - maybeBigInt(integerLimit.minValue, schema.format), 53 53 - $.object().prop('error', $.literal(integerLimit.minError)), 54 54 - ), 55 55 - $(z) 56 56 - .attr(identifiers.maximum) 57 57 - .call( 58 58 - maybeBigInt(integerLimit.maxValue, schema.format), 59 59 - $.object().prop('error', $.literal(integerLimit.maxError)), 60 60 - ), 61 61 - ); 36 36 + function maxNode(ctx: NumberResolverContext): Chain | undefined { 37 37 + const { schema, symbols } = ctx; 38 38 + const { z } = symbols; 39 39 + if (schema.exclusiveMaximum !== undefined) { 40 40 + return $(z) 41 41 + .attr(identifiers.lt) 42 42 + .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format)); 43 43 + } 44 44 + if (schema.maximum !== undefined) { 45 45 + return $(z) 46 46 + .attr(identifiers.lte) 47 47 + .call(ctx.utils.maybeBigInt(schema.maximum, schema.format)); 48 48 + } 49 49 + const limit = ctx.utils.getIntegerLimit(schema.format); 50 50 + if (limit) { 51 51 + return $(z) 52 52 + .attr(identifiers.maximum) 53 53 + .call( 54 54 + ctx.utils.maybeBigInt(limit.maxValue, schema.format), 55 55 + $.object().prop('error', $.literal(limit.maxError)), 56 56 + ); 62 57 } 58 58 + return; 59 59 + } 63 60 61 61 + function minNode(ctx: NumberResolverContext): Chain | undefined { 62 62 + const { schema, symbols } = ctx; 63 63 + const { z } = symbols; 64 64 if (schema.exclusiveMinimum !== undefined) { 65 65 - checks.push( 66 66 - $(z) 67 67 - .attr(identifiers.gt) 68 68 - .call(maybeBigInt(schema.exclusiveMinimum, schema.format)), 69 69 - ); 70 70 - } else if (schema.minimum !== undefined) { 71 71 - checks.push( 72 72 - $(z) 73 73 - .attr(identifiers.gte) 74 74 - .call(maybeBigInt(schema.minimum, schema.format)), 75 75 - ); 65 65 + return $(z) 66 66 + .attr(identifiers.gt) 67 67 + .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format)); 68 68 + } 69 69 + if (schema.minimum !== undefined) { 70 70 + return $(z) 71 71 + .attr(identifiers.gte) 72 72 + .call(ctx.utils.maybeBigInt(schema.minimum, schema.format)); 73 73 + } 74 74 + const limit = ctx.utils.getIntegerLimit(schema.format); 75 75 + if (limit) { 76 76 + return $(z) 77 77 + .attr(identifiers.minimum) 78 78 + .call( 79 79 + ctx.utils.maybeBigInt(limit.minValue, schema.format), 80 80 + $.object().prop('error', $.literal(limit.minError)), 81 81 + ); 76 82 } 83 83 + return; 84 84 + } 77 85 78 78 - if (schema.exclusiveMaximum !== undefined) { 79 79 - checks.push( 80 80 - $(z) 81 81 - .attr(identifiers.lt) 82 82 - .call(maybeBigInt(schema.exclusiveMaximum, schema.format)), 83 83 - ); 84 84 - } else if (schema.maximum !== undefined) { 85 85 - checks.push( 86 86 - $(z) 87 87 - .attr(identifiers.lte) 88 88 - .call(maybeBigInt(schema.maximum, schema.format)), 89 89 - ); 86 86 + function numberResolver(ctx: NumberResolverContext): Chain { 87 87 + const constNode = ctx.nodes.const(ctx); 88 88 + if (constNode) { 89 89 + ctx.chain.current = constNode; 90 90 + return ctx.chain.current; 90 91 } 91 92 92 92 - if (checks.length) { 93 93 - result.expression = result.expression 93 93 + const baseNode = ctx.nodes.base(ctx); 94 94 + if (baseNode) ctx.chain.current = baseNode; 95 95 + 96 96 + const checks: Array<Chain> = []; 97 97 + 98 98 + const minNode = ctx.nodes.min(ctx); 99 99 + if (minNode) checks.push(minNode); 100 100 + 101 101 + const maxNode = ctx.nodes.max(ctx); 102 102 + if (maxNode) checks.push(maxNode); 103 103 + 104 104 + if (checks.length > 0) { 105 105 + ctx.chain.current = ctx.chain.current 94 106 .attr(identifiers.check) 95 107 .call(...checks); 96 108 } 97 109 98 98 - return result as Omit<Ast, 'typeName'>; 110 110 + return ctx.chain.current; 111 111 + } 112 112 + 113 113 + export const numberToNode = ({ 114 114 + plugin, 115 115 + schema, 116 116 + state, 117 117 + }: IrSchemaToAstOptions & { 118 118 + schema: SchemaWithType<'integer' | 'number'>; 119 119 + }): Omit<Ast, 'typeName'> => { 120 120 + const ast: Partial<Omit<Ast, 'typeName'>> = {}; 121 121 + const z = plugin.external('zod.z'); 122 122 + const ctx: NumberResolverContext = { 123 123 + $, 124 124 + chain: { 125 125 + current: $(z), 126 126 + }, 127 127 + nodes: { 128 128 + base: baseNode, 129 129 + const: constNode, 130 130 + max: maxNode, 131 131 + min: minNode, 132 132 + }, 133 133 + plugin, 134 134 + schema, 135 135 + symbols: { 136 136 + z, 137 137 + }, 138 138 + utils: { 139 139 + ast, 140 140 + getIntegerLimit, 141 141 + maybeBigInt, 142 142 + shouldCoerceToBigInt, 143 143 + state, 144 144 + }, 145 145 + }; 146 146 + const resolver = plugin.config['~resolvers']?.number; 147 147 + const node = resolver?.(ctx) ?? numberResolver(ctx); 148 148 + ast.expression = node; 149 149 + return ast as Omit<Ast, 'typeName'>; 99 150 };

+70 -52

packages/openapi-ts/src/plugins/zod/mini/toAst/object.ts

··· 4 4 import { $ } from '~/ts-dsl'; 5 5 6 6 import { identifiers } from '../../constants'; 7 7 + import type { Chain } from '../../shared/chain'; 7 8 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 8 8 - import type { ObjectBaseResolverArgs } from '../../types'; 9 9 + import type { ObjectResolverContext } from '../../types'; 9 10 import { irSchemaToAst } from '../plugin'; 10 11 11 11 - function defaultObjectBaseResolver({ 12 12 - additional, 13 13 - plugin, 14 14 - shape, 15 15 - }: ObjectBaseResolverArgs): ReturnType<typeof $.call> { 16 16 - const z = plugin.referenceSymbol({ 17 17 - category: 'external', 18 18 - resource: 'zod.z', 12 12 + function additionalPropertiesNode( 13 13 + ctx: ObjectResolverContext, 14 14 + ): Chain | null | undefined { 15 15 + const { plugin, schema } = ctx; 16 16 + 17 17 + if ( 18 18 + !schema.additionalProperties || 19 19 + (schema.properties && Object.keys(schema.properties).length > 0) 20 20 + ) 21 21 + return; 22 22 + 23 23 + const additionalAst = irSchemaToAst({ 24 24 + plugin, 25 25 + schema: schema.additionalProperties, 26 26 + state: { 27 27 + ...ctx.utils.state, 28 28 + path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']), 29 29 + }, 19 30 }); 31 31 + if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true; 32 32 + return additionalAst.expression; 33 33 + } 34 34 + 35 35 + function baseNode(ctx: ObjectResolverContext): Chain { 36 36 + const { nodes, symbols } = ctx; 37 37 + const { z } = symbols; 38 38 + 39 39 + const additional = nodes.additionalProperties(ctx); 40 40 + const shape = nodes.shape(ctx); 20 41 21 42 if (additional) { 22 43 return $(z) ··· 27 48 return $(z).attr(identifiers.object).call(shape); 28 49 } 29 50 30 30 - export const objectToAst = ({ 31 31 - plugin, 32 32 - schema, 33 33 - state, 34 34 - }: IrSchemaToAstOptions & { 35 35 - schema: SchemaWithType<'object'>; 36 36 - }): Omit<Ast, 'typeName'> => { 37 37 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 38 38 - 51 51 + function objectResolver(ctx: ObjectResolverContext): Chain { 39 52 // TODO: parser - handle constants 53 53 + return ctx.nodes.base(ctx); 54 54 + } 40 55 56 56 + function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> { 57 57 + const { plugin, schema } = ctx; 41 58 const shape = $.object().pretty(); 42 42 - const required = schema.required ?? []; 43 59 44 60 for (const name in schema.properties) { 45 61 const property = schema.properties[name]!; 46 46 - const isRequired = required.includes(name); 47 62 48 63 const propertyAst = irSchemaToAst({ 49 49 - optional: !isRequired, 64 64 + optional: !schema.required?.includes(name), 50 65 plugin, 51 66 schema: property, 52 67 state: { 53 53 - ...state, 54 54 - path: ref([...fromRef(state.path), 'properties', name]), 68 68 + ...ctx.utils.state, 69 69 + path: ref([...fromRef(ctx.utils.state.path), 'properties', name]), 55 70 }, 56 71 }); 57 72 if (propertyAst.hasLazyExpression) { 58 58 - result.hasLazyExpression = true; 59 59 - } 60 60 - 61 61 - if (propertyAst.hasLazyExpression) { 73 73 + ctx.utils.ast.hasLazyExpression = true; 62 74 shape.getter(name, propertyAst.expression.return()); 63 75 } else { 64 76 shape.prop(name, propertyAst.expression); 65 77 } 66 78 } 67 79 68 68 - let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined; 69 69 - if ( 70 70 - schema.additionalProperties && 71 71 - (!schema.properties || !Object.keys(schema.properties).length) 72 72 - ) { 73 73 - const additionalAst = irSchemaToAst({ 74 74 - plugin, 75 75 - schema: schema.additionalProperties, 76 76 - state: { 77 77 - ...state, 78 78 - path: ref([...fromRef(state.path), 'additionalProperties']), 79 79 - }, 80 80 - }); 81 81 - if (additionalAst.hasLazyExpression) result.hasLazyExpression = true; 82 82 - additional = additionalAst.expression; 83 83 - } 80 80 + return shape; 81 81 + } 84 82 85 85 - const args: ObjectBaseResolverArgs = { 83 83 + export const objectToAst = ({ 84 84 + plugin, 85 85 + schema, 86 86 + state, 87 87 + }: IrSchemaToAstOptions & { 88 88 + schema: SchemaWithType<'object'>; 89 89 + }): Omit<Ast, 'typeName'> => { 90 90 + const ast: Partial<Omit<Ast, 'typeName'>> = {}; 91 91 + const z = plugin.external('zod.z'); 92 92 + const ctx: ObjectResolverContext = { 86 93 $, 87 87 - additional, 88 88 - chain: undefined, 94 94 + chain: { 95 95 + current: $(z), 96 96 + }, 97 97 + nodes: { 98 98 + additionalProperties: additionalPropertiesNode, 99 99 + base: baseNode, 100 100 + shape: shapeNode, 101 101 + }, 89 102 plugin, 90 103 schema, 91 91 - shape, 104 104 + symbols: { 105 105 + z, 106 106 + }, 107 107 + utils: { 108 108 + ast, 109 109 + state, 110 110 + }, 92 111 }; 93 93 - const resolver = plugin.config['~resolvers']?.object?.base; 94 94 - const chain = resolver?.(args) ?? defaultObjectBaseResolver(args); 95 95 - result.expression = chain; 96 96 - 97 97 - return result as Omit<Ast, 'typeName'>; 112 112 + const resolver = plugin.config['~resolvers']?.object; 113 113 + const node = resolver?.(ctx) ?? objectResolver(ctx); 114 114 + ast.expression = node; 115 115 + return ast as Omit<Ast, 'typeName'>; 98 116 };

+105 -58

packages/openapi-ts/src/plugins/zod/mini/toAst/string.ts

··· 2 2 import { $ } from '~/ts-dsl'; 3 3 4 4 import { identifiers } from '../../constants'; 5 5 + import type { Chain } from '../../shared/chain'; 5 6 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 6 6 - import type { FormatResolverArgs } from '../../types'; 7 7 + import type { StringResolverContext } from '../../types'; 8 8 + 9 9 + function baseNode(ctx: StringResolverContext): Chain { 10 10 + const { z } = ctx.symbols; 11 11 + return $(z).attr(identifiers.string).call(); 12 12 + } 13 13 + 14 14 + function constNode(ctx: StringResolverContext): Chain | undefined { 15 15 + const { schema, symbols } = ctx; 16 16 + const { z } = symbols; 17 17 + if (typeof schema.const !== 'string') return; 18 18 + return $(z).attr(identifiers.literal).call($.literal(schema.const)); 19 19 + } 7 20 8 8 - const defaultFormatResolver = ({ 9 9 - chain, 10 10 - plugin, 11 11 - schema, 12 12 - }: FormatResolverArgs): ReturnType<typeof $.call> => { 13 13 - const z = plugin.referenceSymbol({ 14 14 - category: 'external', 15 15 - resource: 'zod.z', 16 16 - }); 21 21 + function formatNode(ctx: StringResolverContext): Chain | undefined { 22 22 + const { plugin, schema, symbols } = ctx; 23 23 + const { z } = symbols; 17 24 18 25 switch (schema.format) { 19 26 case 'date': ··· 43 50 return $(z).attr(identifiers.url).call(); 44 51 case 'uuid': 45 52 return $(z).attr(identifiers.uuid).call(); 46 46 - default: 47 47 - return chain; 48 53 } 49 49 - }; 50 54 51 51 - export const stringToAst = ({ 52 52 - plugin, 53 53 - schema, 54 54 - }: IrSchemaToAstOptions & { 55 55 - schema: SchemaWithType<'string'>; 56 56 - }): Omit<Ast, 'typeName'> => { 57 57 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 58 58 - let chain: ReturnType<typeof $.call>; 55 55 + return; 56 56 + } 59 57 60 60 - const z = plugin.referenceSymbol({ 61 61 - category: 'external', 62 62 - resource: 'zod.z', 63 63 - }); 58 58 + function lengthNode(ctx: StringResolverContext): Chain | undefined { 59 59 + const { schema, symbols } = ctx; 60 60 + const { z } = symbols; 61 61 + if (schema.minLength === undefined || schema.minLength !== schema.maxLength) 62 62 + return; 63 63 + return $(z).attr(identifiers.length).call($.literal(schema.minLength)); 64 64 + } 65 65 + 66 66 + function maxLengthNode(ctx: StringResolverContext): Chain | undefined { 67 67 + const { schema, symbols } = ctx; 68 68 + const { z } = symbols; 69 69 + if (schema.maxLength === undefined) return; 70 70 + return $(z).attr(identifiers.maxLength).call($.literal(schema.maxLength)); 71 71 + } 72 72 + 73 73 + function minLengthNode(ctx: StringResolverContext): Chain | undefined { 74 74 + const { schema, symbols } = ctx; 75 75 + const { z } = symbols; 76 76 + if (schema.minLength === undefined) return; 77 77 + return $(z).attr(identifiers.minLength).call($.literal(schema.minLength)); 78 78 + } 64 79 65 65 - if (typeof schema.const === 'string') { 66 66 - chain = $(z).attr(identifiers.literal).call($.literal(schema.const)); 67 67 - result.expression = chain; 68 68 - return result as Omit<Ast, 'typeName'>; 80 80 + function patternNode(ctx: StringResolverContext): Chain | undefined { 81 81 + const { schema, symbols } = ctx; 82 82 + const { z } = symbols; 83 83 + if (!schema.pattern) return; 84 84 + return $(z).attr(identifiers.regex).call($.regexp(schema.pattern)); 85 85 + } 86 86 + 87 87 + function stringResolver(ctx: StringResolverContext): Chain { 88 88 + const constNode = ctx.nodes.const(ctx); 89 89 + if (constNode) { 90 90 + ctx.chain.current = constNode; 91 91 + return ctx.chain.current; 69 92 } 70 93 71 71 - chain = $(z).attr(identifiers.string).call(); 94 94 + const baseNode = ctx.nodes.base(ctx); 95 95 + if (baseNode) ctx.chain.current = baseNode; 72 96 73 73 - if (schema.format) { 74 74 - const args: FormatResolverArgs = { $, chain, plugin, schema }; 75 75 - const resolver = 76 76 - plugin.config['~resolvers']?.string?.formats?.[schema.format]; 77 77 - chain = resolver?.(args) ?? defaultFormatResolver(args); 78 78 - } 97 97 + const formatNode = ctx.nodes.format(ctx); 98 98 + if (formatNode) ctx.chain.current = formatNode; 79 99 80 80 - const checks: Array<ReturnType<typeof $.call>> = []; 100 100 + const checks: Array<Chain> = []; 81 101 82 82 - if (schema.minLength === schema.maxLength && schema.minLength !== undefined) { 83 83 - checks.push( 84 84 - $(z).attr(identifiers.length).call($.literal(schema.minLength)), 85 85 - ); 102 102 + const lengthNode = ctx.nodes.length(ctx); 103 103 + if (lengthNode) { 104 104 + checks.push(lengthNode); 86 105 } else { 87 87 - if (schema.minLength !== undefined) { 88 88 - checks.push( 89 89 - $(z).attr(identifiers.minLength).call($.literal(schema.minLength)), 90 90 - ); 91 91 - } 106 106 + const minLengthNode = ctx.nodes.minLength(ctx); 107 107 + if (minLengthNode) checks.push(minLengthNode); 92 108 93 93 - if (schema.maxLength !== undefined) { 94 94 - checks.push( 95 95 - $(z).attr(identifiers.maxLength).call($.literal(schema.maxLength)), 96 96 - ); 97 97 - } 109 109 + const maxLengthNode = ctx.nodes.maxLength(ctx); 110 110 + if (maxLengthNode) checks.push(maxLengthNode); 98 111 } 99 112 100 100 - if (schema.pattern) { 101 101 - checks.push($(z).attr(identifiers.regex).call($.regexp(schema.pattern))); 113 113 + const patternNode = ctx.nodes.pattern(ctx); 114 114 + if (patternNode) checks.push(patternNode); 115 115 + 116 116 + if (checks.length > 0) { 117 117 + ctx.chain.current = ctx.chain.current 118 118 + .attr(identifiers.check) 119 119 + .call(...checks); 102 120 } 103 121 104 104 - if (checks.length) { 105 105 - chain = chain.attr(identifiers.check).call(...checks); 106 106 - } 122 122 + return ctx.chain.current; 123 123 + } 107 124 108 108 - result.expression = chain; 109 109 - return result as Omit<Ast, 'typeName'>; 125 125 + export const stringToNode = ({ 126 126 + plugin, 127 127 + schema, 128 128 + }: IrSchemaToAstOptions & { 129 129 + schema: SchemaWithType<'string'>; 130 130 + }): Omit<Ast, 'typeName'> => { 131 131 + const z = plugin.external('zod.z'); 132 132 + const ctx: StringResolverContext = { 133 133 + $, 134 134 + chain: { 135 135 + current: $(z), 136 136 + }, 137 137 + nodes: { 138 138 + base: baseNode, 139 139 + const: constNode, 140 140 + format: formatNode, 141 141 + length: lengthNode, 142 142 + maxLength: maxLengthNode, 143 143 + minLength: minLengthNode, 144 144 + pattern: patternNode, 145 145 + }, 146 146 + plugin, 147 147 + schema, 148 148 + symbols: { 149 149 + z, 150 150 + }, 151 151 + }; 152 152 + const resolver = plugin.config['~resolvers']?.string; 153 153 + const node = resolver?.(ctx) ?? stringResolver(ctx); 154 154 + return { 155 155 + expression: node, 156 156 + }; 110 157 };

+3

packages/openapi-ts/src/plugins/zod/shared/chain.ts

··· 1 1 + import type { $ } from '~/ts-dsl'; 2 2 + 3 3 + export type Chain = ReturnType<typeof $.call | typeof $.expr>;

+120 -87

packages/openapi-ts/src/plugins/zod/types.d.ts

··· 1 1 - import type { Symbol } from '@hey-api/codegen-core'; 1 1 + import type { Refs, Symbol } from '@hey-api/codegen-core'; 2 2 import type ts from 'typescript'; 3 3 4 4 import type { IR } from '~/ir/types'; 5 5 - import type { DefinePlugin, Plugin } from '~/plugins'; 5 5 + import type { DefinePlugin, Plugin, SchemaWithType } from '~/plugins'; 6 6 + import type { 7 7 + MaybeBigInt, 8 8 + ShouldCoerceToBigInt, 9 9 + } from '~/plugins/shared/utils/coerce'; 10 10 + import type { GetIntegerLimit } from '~/plugins/shared/utils/formats'; 6 11 import type { $, DollarTsDsl, TsDsl } from '~/ts-dsl'; 7 12 import type { StringCase, StringName } from '~/types/case'; 8 13 import type { MaybeArray } from '~/types/utils'; 9 14 10 15 import type { IApi } from './api'; 16 16 + import type { Chain } from './shared/chain'; 17 17 + import type { Ast, PluginState } from './shared/types'; 11 18 12 19 export type UserConfig = Plugin.Name<'zod'> & 13 20 Plugin.Hooks & ··· 747 754 }; 748 755 }; 749 756 750 750 - type SharedResolverArgs = DollarTsDsl & { 757 757 + interface BaseResolverContext extends DollarTsDsl { 758 758 + /** 759 759 + * Functions for working with chains. 760 760 + */ 761 761 + chain: { 762 762 + /** 763 763 + * The current chain. 764 764 + * 765 765 + * In Zod, this represents a chain of call expressions ("chains") 766 766 + * being assembled to form a schema definition. 767 767 + * 768 768 + * Each chain can be extended, modified, or replaced to customize 769 769 + * the resulting schema. 770 770 + */ 771 771 + current: Chain; 772 772 + }; 751 773 /** 752 752 - * The current fluent builder chain under construction for this resolver. 753 753 - * 754 754 - * Represents the in-progress call sequence (e.g., a Zod or DSL chain) 755 755 - * that defines the current schema or expression being generated. 756 756 - * 757 757 - * This chain can be extended, transformed, or replaced entirely to customize 758 758 - * the resulting output of the resolver. 774 774 + * The plugin instance. 759 775 */ 760 760 - chain?: ReturnType<typeof $.call>; 761 776 plugin: ZodPlugin['Instance']; 762 762 - }; 777 777 + /** 778 778 + * Provides access to commonly used symbols within the plugin. 779 779 + */ 780 780 + symbols: { 781 781 + z: Symbol; 782 782 + }; 783 783 + } 763 784 764 764 - export type FormatResolverArgs = Required<SharedResolverArgs> & { 765 765 - schema: IR.SchemaObject; 766 766 - }; 785 785 + export interface NumberResolverContext extends BaseResolverContext { 786 786 + /** 787 787 + * Nodes used to build different parts of the number schema. 788 788 + */ 789 789 + nodes: { 790 790 + base: (ctx: NumberResolverContext) => Chain; 791 791 + const: (ctx: NumberResolverContext) => Chain | undefined; 792 792 + max: (ctx: NumberResolverContext) => Chain | undefined; 793 793 + min: (ctx: NumberResolverContext) => Chain | undefined; 794 794 + }; 795 795 + schema: SchemaWithType<'integer' | 'number'>; 796 796 + /** 797 797 + * Utility functions for number schema processing. 798 798 + */ 799 799 + utils: { 800 800 + ast: Partial<Omit<Ast, 'typeName'>>; 801 801 + getIntegerLimit: GetIntegerLimit; 802 802 + maybeBigInt: MaybeBigInt; 803 803 + shouldCoerceToBigInt: ShouldCoerceToBigInt; 804 804 + state: Refs<PluginState>; 805 805 + }; 806 806 + } 767 807 768 768 - export type ObjectBaseResolverArgs = SharedResolverArgs & { 769 769 - /** Null = never */ 770 770 - additional?: ReturnType<typeof $.call | typeof $.expr> | null; 771 771 - schema: IR.SchemaObject; 772 772 - shape: ReturnType<typeof $.object>; 773 773 - }; 808 808 + export interface ObjectResolverContext extends BaseResolverContext { 809 809 + /** 810 810 + * Nodes used to build different parts of the object schema. 811 811 + */ 812 812 + nodes: { 813 813 + /** 814 814 + * If `additionalProperties` is `false` or `{ type: 'never' }`, returns `null` 815 815 + * to indicate no additional properties are allowed. 816 816 + */ 817 817 + additionalProperties: ( 818 818 + ctx: ObjectResolverContext, 819 819 + ) => Chain | null | undefined; 820 820 + base: (ctx: ObjectResolverContext) => Chain; 821 821 + shape: (ctx: ObjectResolverContext) => ReturnType<typeof $.object>; 822 822 + }; 823 823 + schema: SchemaWithType<'object'>; 824 824 + /** 825 825 + * Utility functions for object schema processing. 826 826 + */ 827 827 + utils: { 828 828 + ast: Partial<Omit<Ast, 'typeName'>>; 829 829 + state: Refs<PluginState>; 830 830 + }; 831 831 + } 774 832 775 775 - export type ValidatorResolverArgs = SharedResolverArgs & { 833 833 + export interface StringResolverContext extends BaseResolverContext { 834 834 + /** 835 835 + * Nodes used to build different parts of the string schema. 836 836 + */ 837 837 + nodes: { 838 838 + base: (ctx: StringResolverContext) => Chain; 839 839 + const: (ctx: StringResolverContext) => Chain | undefined; 840 840 + format: (ctx: StringResolverContext) => Chain | undefined; 841 841 + length: (ctx: StringResolverContext) => Chain | undefined; 842 842 + maxLength: (ctx: StringResolverContext) => Chain | undefined; 843 843 + minLength: (ctx: StringResolverContext) => Chain | undefined; 844 844 + pattern: (ctx: StringResolverContext) => Chain | undefined; 845 845 + }; 846 846 + schema: SchemaWithType<'string'>; 847 847 + } 848 848 + 849 849 + export interface ValidatorResolverContext extends BaseResolverContext { 776 850 operation: IR.Operation; 777 777 - schema: Symbol; 778 778 - }; 851 851 + /** 852 852 + * Provides access to commonly used symbols within the plugin. 853 853 + */ 854 854 + symbols: BaseResolverContext['symbols'] & { 855 855 + schema: Symbol; 856 856 + }; 857 857 + } 779 858 780 859 type ValidatorResolver = ( 781 781 - args: ValidatorResolverArgs, 860 860 + ctx: ValidatorResolverContext, 782 861 ) => MaybeArray<TsDsl<ts.Statement>> | null | undefined; 783 862 784 863 type Resolvers = Plugin.Resolvers<{ 785 864 /** 786 786 - * Resolvers for number schemas. 865 865 + * Resolver for number schemas. 787 866 * 788 788 - * Allows customization of how number types are rendered, including 789 789 - * per-format handling. 867 867 + * Allows customization of how number types are rendered. 868 868 + * 869 869 + * Returning `undefined` will execute the default resolver logic. 790 870 */ 791 791 - number?: { 792 792 - /** 793 793 - * Resolvers for number formats (e.g., `float`, `double`, `int32`). 794 794 - * 795 795 - * Each key represents a specific format name with a custom 796 796 - * resolver function that controls how that format is rendered. 797 797 - * 798 798 - * Example path: `~resolvers.number.formats.float` 799 799 - * 800 800 - * Returning `undefined` from a resolver will apply the default 801 801 - * generation behavior for that format. 802 802 - */ 803 803 - formats?: Record< 804 804 - string, 805 805 - (args: FormatResolverArgs) => boolean | number | undefined 806 806 - >; 807 807 - }; 871 871 + number?: (ctx: NumberResolverContext) => Chain | undefined; 808 872 /** 809 809 - * Resolvers for object schemas. 873 873 + * Resolver for object schemas. 810 874 * 811 875 * Allows customization of how object types are rendered. 812 876 * 813 813 - * Example path: `~resolvers.object.base` 814 814 - * 815 815 - * Returning `undefined` from a resolver will apply the default 816 816 - * generation behavior for the object schema. 877 877 + * Returning `undefined` will execute the default resolver logic. 817 878 */ 818 818 - object?: { 819 819 - /** 820 820 - * Controls how object schemas are constructed. 821 821 - * 822 822 - * Called with the fully assembled shape (properties) and any additional 823 823 - * property schema, allowing the resolver to choose the correct Zod 824 824 - * base constructor and modify the schema chain if needed. 825 825 - * 826 826 - * Returning `undefined` will execute the default resolver logic. 827 827 - */ 828 828 - base?: ( 829 829 - args: ObjectBaseResolverArgs, 830 830 - ) => ReturnType<typeof $.call> | undefined; 831 831 - }; 879 879 + object?: (ctx: ObjectResolverContext) => Chain | undefined; 832 880 /** 833 833 - * Resolvers for string schemas. 881 881 + * Resolver for string schemas. 834 882 * 835 835 - * Allows customization of how string types are rendered, including 836 836 - * per-format handling. 883 883 + * Allows customization of how string types are rendered. 884 884 + * 885 885 + * Returning `undefined` will execute the default resolver logic. 837 886 */ 838 838 - string?: { 839 839 - /** 840 840 - * Resolvers for string formats (e.g., `uuid`, `email`, `date-time`). 841 841 - * 842 842 - * Each key represents a specific format name with a custom 843 843 - * resolver function that controls how that format is rendered. 844 844 - * 845 845 - * Example path: `~resolvers.string.formats.uuid` 846 846 - * 847 847 - * Returning `undefined` from a resolver will apply the default 848 848 - * generation logic for that format. 849 849 - */ 850 850 - formats?: Record< 851 851 - string, 852 852 - (args: FormatResolverArgs) => ReturnType<typeof $.call> | undefined 853 853 - >; 854 854 - }; 887 887 + string?: (ctx: StringResolverContext) => Chain | undefined; 855 888 /** 856 889 * Resolvers for request and response validators. 857 890 * ··· 859 892 * 860 893 * Example path: `~resolvers.validator.request` or `~resolvers.validator.response` 861 894 * 862 862 - * Returning `undefined` from a resolver will apply the default generation logic. 895 895 + * Returning `undefined` will execute the default resolver logic. 863 896 */ 864 897 validator?: 865 898 | ValidatorResolver ··· 867 900 /** 868 901 * Controls how the request validator function body is generated. 869 902 * 870 870 - * Returning `undefined` will fall back to the default `.await().return()` logic. 903 903 + * Returning `undefined` will execute the default resolver logic. 871 904 */ 872 905 request?: ValidatorResolver; 873 906 /** 874 907 * Controls how the response validator function body is generated. 875 908 * 876 876 - * Returning `undefined` will fall back to the default `.await().return()` logic. 909 909 + * Returning `undefined` will execute the default resolver logic. 877 910 */ 878 911 response?: ValidatorResolver; 879 912 };

+29 -15

packages/openapi-ts/src/plugins/zod/v3/api.ts

··· 2 2 3 3 import { identifiers } from '../constants'; 4 4 import type { ValidatorArgs } from '../shared/types'; 5 5 - import type { ValidatorResolverArgs } from '../types'; 5 5 + import type { ValidatorResolverContext } from '../types'; 6 6 7 7 - const defaultValidatorResolver = ({ 8 8 - schema, 9 9 - }: ValidatorResolverArgs): ReturnType<typeof $.return> => 10 10 - $(schema).attr(identifiers.parseAsync).call('data').await().return(); 7 7 + const validatorResolver = ( 8 8 + ctx: ValidatorResolverContext, 9 9 + ): ReturnType<typeof $.return> => { 10 10 + const { schema } = ctx.symbols; 11 11 + return $(schema).attr(identifiers.parseAsync).call('data').await().return(); 12 12 + }; 11 13 12 14 export const createRequestValidatorV3 = ({ 13 15 operation, ··· 22 24 }); 23 25 if (!symbol) return; 24 26 25 25 - const args: ValidatorResolverArgs = { 27 27 + const z = plugin.external('zod.z'); 28 28 + const ctx: ValidatorResolverContext = { 26 29 $, 27 27 - chain: undefined, 30 30 + chain: { 31 31 + current: $(z), 32 32 + }, 28 33 operation, 29 34 plugin, 30 30 - schema: symbol, 35 35 + symbols: { 36 36 + schema: symbol, 37 37 + z, 38 38 + }, 31 39 }; 32 40 const validator = plugin.config['~resolvers']?.validator; 33 41 const resolver = 34 42 typeof validator === 'function' ? validator : validator?.request; 35 35 - const candidates = [resolver, defaultValidatorResolver]; 43 43 + const candidates = [resolver, validatorResolver]; 36 44 for (const candidate of candidates) { 37 37 - const statements = candidate?.(args); 45 45 + const statements = candidate?.(ctx); 38 46 if (statements === null) return; 39 47 if (statements !== undefined) { 40 48 return $.func() ··· 59 67 }); 60 68 if (!symbol) return; 61 69 62 62 - const args: ValidatorResolverArgs = { 70 70 + const z = plugin.external('zod.z'); 71 71 + const ctx: ValidatorResolverContext = { 63 72 $, 64 64 - chain: undefined, 73 73 + chain: { 74 74 + current: $(z), 75 75 + }, 65 76 operation, 66 77 plugin, 67 67 - schema: symbol, 78 78 + symbols: { 79 79 + schema: symbol, 80 80 + z, 81 81 + }, 68 82 }; 69 83 const validator = plugin.config['~resolvers']?.validator; 70 84 const resolver = 71 85 typeof validator === 'function' ? validator : validator?.response; 72 72 - const candidates = [resolver, defaultValidatorResolver]; 86 86 + const candidates = [resolver, validatorResolver]; 73 87 for (const candidate of candidates) { 74 74 - const statements = candidate?.(args); 88 88 + const statements = candidate?.(ctx); 75 89 if (statements === null) return; 76 90 if (statements !== undefined) { 77 91 return $.func()

+5 -5

packages/openapi-ts/src/plugins/zod/v3/toAst/index.ts

··· 7 7 import { enumToAst } from './enum'; 8 8 import { neverToAst } from './never'; 9 9 import { nullToAst } from './null'; 10 10 - import { numberToAst } from './number'; 10 10 + import { numberToNode } from './number'; 11 11 import { objectToAst } from './object'; 12 12 - import { stringToAst } from './string'; 12 12 + import { stringToNode } from './string'; 13 13 import { tupleToAst } from './tuple'; 14 14 import { undefinedToAst } from './undefined'; 15 15 import { unknownToAst } from './unknown'; ··· 46 46 case 'integer': 47 47 case 'number': 48 48 return { 49 49 - expression: numberToAst({ 49 49 + expression: numberToNode({ 50 50 ...args, 51 51 schema: schema as SchemaWithType<'integer' | 'number'>, 52 52 }), ··· 73 73 case 'string': 74 74 return { 75 75 expression: shouldCoerceToBigInt(schema.format) 76 76 - ? numberToAst({ 76 76 + ? numberToNode({ 77 77 ...args, 78 78 schema: { ...schema, type: 'number' }, 79 79 }) 80 80 - : stringToAst({ 80 80 + : stringToNode({ 81 81 ...args, 82 82 schema: schema as SchemaWithType<'string'>, 83 83 }),

+112 -53

packages/openapi-ts/src/plugins/zod/v3/toAst/number.ts

··· 7 7 import { $ } from '~/ts-dsl'; 8 8 9 9 import { identifiers } from '../../constants'; 10 10 - import type { IrSchemaToAstOptions } from '../../shared/types'; 10 10 + import type { Chain } from '../../shared/chain'; 11 11 + import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 12 12 + import type { NumberResolverContext } from '../../types'; 11 13 12 12 - export const numberToAst = ({ 13 13 - plugin, 14 14 - schema, 15 15 - }: IrSchemaToAstOptions & { 16 16 - schema: SchemaWithType<'integer' | 'number'>; 17 17 - }) => { 18 18 - const z = plugin.referenceSymbol({ 19 19 - category: 'external', 20 20 - resource: 'zod.z', 21 21 - }); 22 22 - 23 23 - if (schema.const !== undefined) { 24 24 - const expression = $(z) 25 25 - .attr(identifiers.literal) 26 26 - .call(maybeBigInt(schema.const, schema.format)); 27 27 - return expression; 14 14 + function baseNode(ctx: NumberResolverContext): Chain { 15 15 + const { schema, symbols } = ctx; 16 16 + const { z } = symbols; 17 17 + if (ctx.utils.shouldCoerceToBigInt(schema.format)) { 18 18 + return $(z).attr(identifiers.coerce).attr(identifiers.bigint).call(); 28 19 } 20 20 + let chain = $(z).attr(identifiers.number).call(); 21 21 + if (schema.type === 'integer') { 22 22 + chain = chain.attr(identifiers.int).call(); 23 23 + } 24 24 + return chain; 25 25 + } 29 26 30 30 - let numberExpression: ReturnType<typeof $.call>; 27 27 + function constNode(ctx: NumberResolverContext): Chain | undefined { 28 28 + const { schema, symbols } = ctx; 29 29 + const { z } = symbols; 30 30 + if (schema.const === undefined) return; 31 31 + return $(z) 32 32 + .attr(identifiers.literal) 33 33 + .call(ctx.utils.maybeBigInt(schema.const, schema.format)); 34 34 + } 31 35 32 32 - if (shouldCoerceToBigInt(schema.format)) { 33 33 - numberExpression = $(z) 34 34 - .attr(identifiers.coerce) 35 35 - .attr(identifiers.bigint) 36 36 - .call(); 37 37 - } else { 38 38 - numberExpression = $(z).attr(identifiers.number).call(); 39 39 - if (schema.type === 'integer') { 40 40 - numberExpression = numberExpression.attr(identifiers.int).call(); 41 41 - } 36 36 + function maxNode(ctx: NumberResolverContext): Chain | undefined { 37 37 + const { chain, schema } = ctx; 38 38 + if (schema.exclusiveMaximum !== undefined) { 39 39 + return chain.current 40 40 + .attr(identifiers.lt) 41 41 + .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format)); 42 42 + } 43 43 + if (schema.maximum !== undefined) { 44 44 + return chain.current 45 45 + .attr(identifiers.lte) 46 46 + .call(ctx.utils.maybeBigInt(schema.maximum, schema.format)); 42 47 } 43 43 - 44 44 - const integerLimit = getIntegerLimit(schema.format); 45 45 - if (integerLimit) { 46 46 - numberExpression = numberExpression 47 47 - .attr(identifiers.min) 48 48 - .call( 49 49 - maybeBigInt(integerLimit.minValue, schema.format), 50 50 - $.object().prop('message', $.literal(integerLimit.minError)), 51 51 - ) 48 48 + const limit = ctx.utils.getIntegerLimit(schema.format); 49 49 + if (limit) { 50 50 + return chain.current 52 51 .attr(identifiers.max) 53 52 .call( 54 54 - maybeBigInt(integerLimit.maxValue, schema.format), 55 55 - $.object().prop('message', $.literal(integerLimit.maxError)), 53 53 + ctx.utils.maybeBigInt(limit.maxValue, schema.format), 54 54 + $.object().prop('message', $.literal(limit.maxError)), 56 55 ); 57 56 } 57 57 + return; 58 58 + } 58 59 60 60 + function minNode(ctx: NumberResolverContext): Chain | undefined { 61 61 + const { chain, schema } = ctx; 59 62 if (schema.exclusiveMinimum !== undefined) { 60 60 - numberExpression = numberExpression 63 63 + return chain.current 61 64 .attr(identifiers.gt) 62 62 - .call(maybeBigInt(schema.exclusiveMinimum, schema.format)); 63 63 - } else if (schema.minimum !== undefined) { 64 64 - numberExpression = numberExpression 65 65 + .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format)); 66 66 + } 67 67 + if (schema.minimum !== undefined) { 68 68 + return chain.current 65 69 .attr(identifiers.gte) 66 66 - .call(maybeBigInt(schema.minimum, schema.format)); 70 70 + .call(ctx.utils.maybeBigInt(schema.minimum, schema.format)); 71 71 + } 72 72 + const limit = ctx.utils.getIntegerLimit(schema.format); 73 73 + if (limit) { 74 74 + return chain.current 75 75 + .attr(identifiers.min) 76 76 + .call( 77 77 + ctx.utils.maybeBigInt(limit.minValue, schema.format), 78 78 + $.object().prop('message', $.literal(limit.minError)), 79 79 + ); 67 80 } 81 81 + return; 82 82 + } 68 83 69 69 - if (schema.exclusiveMaximum !== undefined) { 70 70 - numberExpression = numberExpression 71 71 - .attr(identifiers.lt) 72 72 - .call(maybeBigInt(schema.exclusiveMaximum, schema.format)); 73 73 - } else if (schema.maximum !== undefined) { 74 74 - numberExpression = numberExpression 75 75 - .attr(identifiers.lte) 76 76 - .call(maybeBigInt(schema.maximum, schema.format)); 84 84 + function numberResolver(ctx: NumberResolverContext): Chain { 85 85 + const constNode = ctx.nodes.const(ctx); 86 86 + if (constNode) { 87 87 + ctx.chain.current = constNode; 88 88 + return ctx.chain.current; 77 89 } 78 90 79 79 - return numberExpression; 91 91 + const baseNode = ctx.nodes.base(ctx); 92 92 + if (baseNode) ctx.chain.current = baseNode; 93 93 + 94 94 + const minNode = ctx.nodes.min(ctx); 95 95 + if (minNode) ctx.chain.current = minNode; 96 96 + 97 97 + const maxNode = ctx.nodes.max(ctx); 98 98 + if (maxNode) ctx.chain.current = maxNode; 99 99 + 100 100 + return ctx.chain.current; 101 101 + } 102 102 + 103 103 + export const numberToNode = ({ 104 104 + plugin, 105 105 + schema, 106 106 + state, 107 107 + }: IrSchemaToAstOptions & { 108 108 + schema: SchemaWithType<'integer' | 'number'>; 109 109 + }): Chain => { 110 110 + const ast: Partial<Omit<Ast, 'typeName'>> = {}; 111 111 + const z = plugin.external('zod.z'); 112 112 + const ctx: NumberResolverContext = { 113 113 + $, 114 114 + chain: { 115 115 + current: $(z), 116 116 + }, 117 117 + nodes: { 118 118 + base: baseNode, 119 119 + const: constNode, 120 120 + max: maxNode, 121 121 + min: minNode, 122 122 + }, 123 123 + plugin, 124 124 + schema, 125 125 + symbols: { 126 126 + z, 127 127 + }, 128 128 + utils: { 129 129 + ast, 130 130 + getIntegerLimit, 131 131 + maybeBigInt, 132 132 + shouldCoerceToBigInt, 133 133 + state, 134 134 + }, 135 135 + }; 136 136 + const resolver = plugin.config['~resolvers']?.number; 137 137 + const node = resolver?.(ctx) ?? numberResolver(ctx); 138 138 + return node; 80 139 };

+76 -57

packages/openapi-ts/src/plugins/zod/v3/toAst/object.ts

··· 4 4 import { $ } from '~/ts-dsl'; 5 5 6 6 import { identifiers } from '../../constants'; 7 7 + import type { Chain } from '../../shared/chain'; 7 8 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 8 8 - import type { ObjectBaseResolverArgs } from '../../types'; 9 9 + import type { ObjectResolverContext } from '../../types'; 9 10 import { irSchemaToAst } from '../plugin'; 10 11 11 11 - function defaultObjectBaseResolver({ 12 12 - additional, 13 13 - plugin, 14 14 - shape, 15 15 - }: ObjectBaseResolverArgs): ReturnType<typeof $.call> { 16 16 - const z = plugin.referenceSymbol({ 17 17 - category: 'external', 18 18 - resource: 'zod.z', 12 12 + function additionalPropertiesNode( 13 13 + ctx: ObjectResolverContext, 14 14 + ): Chain | null | undefined { 15 15 + const { plugin, schema } = ctx; 16 16 + 17 17 + if ( 18 18 + !schema.additionalProperties || 19 19 + (schema.properties && Object.keys(schema.properties).length > 0) 20 20 + ) 21 21 + return; 22 22 + 23 23 + const additionalAst = irSchemaToAst({ 24 24 + plugin, 25 25 + schema: schema.additionalProperties, 26 26 + state: { 27 27 + ...ctx.utils.state, 28 28 + path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']), 29 29 + }, 19 30 }); 31 31 + if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true; 32 32 + return additionalAst.expression; 33 33 + } 34 34 + 35 35 + function baseNode(ctx: ObjectResolverContext): Chain { 36 36 + const { nodes, symbols } = ctx; 37 37 + const { z } = symbols; 38 38 + 39 39 + const additional = nodes.additionalProperties(ctx); 40 40 + const shape = nodes.shape(ctx); 20 41 21 42 if (additional) { 22 43 return $(z).attr(identifiers.record).call(additional); ··· 25 46 return $(z).attr(identifiers.object).call(shape); 26 47 } 27 48 28 28 - export const objectToAst = ({ 29 29 - plugin, 30 30 - schema, 31 31 - state, 32 32 - }: IrSchemaToAstOptions & { 33 33 - schema: SchemaWithType<'object'>; 34 34 - }): Omit<Ast, 'typeName'> & { 35 35 - anyType?: string; 36 36 - } => { 37 37 - let hasLazyExpression = false; 38 38 - 49 49 + function objectResolver(ctx: ObjectResolverContext): Chain { 39 50 // TODO: parser - handle constants 51 51 + return ctx.nodes.base(ctx); 52 52 + } 40 53 54 54 + function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> { 55 55 + const { plugin, schema } = ctx; 41 56 const shape = $.object().pretty(); 42 42 - const required = schema.required ?? []; 43 57 44 58 for (const name in schema.properties) { 45 59 const property = schema.properties[name]!; 46 46 - const isRequired = required.includes(name); 47 60 48 48 - const propertyExpression = irSchemaToAst({ 49 49 - optional: !isRequired, 61 61 + const propertyAst = irSchemaToAst({ 62 62 + optional: !schema.required?.includes(name), 50 63 plugin, 51 64 schema: property, 52 65 state: { 53 53 - ...state, 54 54 - path: ref([...fromRef(state.path), 'properties', name]), 66 66 + ...ctx.utils.state, 67 67 + path: ref([...fromRef(ctx.utils.state.path), 'properties', name]), 55 68 }, 56 69 }); 57 57 - 58 58 - if (propertyExpression.hasLazyExpression) hasLazyExpression = true; 59 59 - 60 60 - shape.prop(name, propertyExpression.expression); 70 70 + if (propertyAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true; 71 71 + shape.prop(name, propertyAst.expression); 61 72 } 62 73 63 63 - let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined; 64 64 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 65 65 - if ( 66 66 - schema.additionalProperties && 67 67 - (!schema.properties || !Object.keys(schema.properties).length) 68 68 - ) { 69 69 - const additionalAst = irSchemaToAst({ 70 70 - plugin, 71 71 - schema: schema.additionalProperties, 72 72 - state: { 73 73 - ...state, 74 74 - path: ref([...fromRef(state.path), 'additionalProperties']), 75 75 - }, 76 76 - }); 77 77 - hasLazyExpression = additionalAst.hasLazyExpression || hasLazyExpression; 78 78 - additional = additionalAst.expression; 79 79 - } 74 74 + return shape; 75 75 + } 80 76 81 81 - const args: ObjectBaseResolverArgs = { 77 77 + export const objectToAst = ({ 78 78 + plugin, 79 79 + schema, 80 80 + state, 81 81 + }: IrSchemaToAstOptions & { 82 82 + schema: SchemaWithType<'object'>; 83 83 + }): Omit<Ast, 'typeName'> & { 84 84 + anyType?: string; 85 85 + } => { 86 86 + const ast: Partial<Omit<Ast, 'typeName'>> = {}; 87 87 + const z = plugin.external('zod.z'); 88 88 + const ctx: ObjectResolverContext = { 82 89 $, 83 83 - additional, 84 84 - chain: undefined, 90 90 + chain: { 91 91 + current: $(z), 92 92 + }, 93 93 + nodes: { 94 94 + additionalProperties: additionalPropertiesNode, 95 95 + base: baseNode, 96 96 + shape: shapeNode, 97 97 + }, 85 98 plugin, 86 99 schema, 87 87 - shape, 100 100 + symbols: { 101 101 + z, 102 102 + }, 103 103 + utils: { 104 104 + ast, 105 105 + state, 106 106 + }, 88 107 }; 89 89 - const resolver = plugin.config['~resolvers']?.object?.base; 90 90 - const chain = resolver?.(args) ?? defaultObjectBaseResolver(args); 91 91 - result.expression = chain; 92 92 - 108 108 + const resolver = plugin.config['~resolvers']?.object; 109 109 + const node = resolver?.(ctx) ?? objectResolver(ctx); 110 110 + ast.expression = node; 93 111 return { 112 112 + ...ast, 94 113 anyType: 'AnyZodObject', 95 95 - expression: result.expression!, 96 96 - hasLazyExpression, 114 114 + } as Omit<Ast, 'typeName'> & { 115 115 + anyType: string; 97 116 }; 98 117 };

+103 -49

packages/openapi-ts/src/plugins/zod/v3/toAst/string.ts

··· 2 2 import { $ } from '~/ts-dsl'; 3 3 4 4 import { identifiers } from '../../constants'; 5 5 + import type { Chain } from '../../shared/chain'; 5 6 import type { IrSchemaToAstOptions } from '../../shared/types'; 6 6 - import type { FormatResolverArgs } from '../../types'; 7 7 + import type { StringResolverContext } from '../../types'; 7 8 8 8 - const defaultFormatResolver = ({ 9 9 - chain, 10 10 - plugin, 11 11 - schema, 12 12 - }: FormatResolverArgs): ReturnType<typeof $.call> => { 9 9 + function baseNode(ctx: StringResolverContext): Chain { 10 10 + const { z } = ctx.symbols; 11 11 + return $(z).attr(identifiers.string).call(); 12 12 + } 13 13 + 14 14 + function constNode(ctx: StringResolverContext): Chain | undefined { 15 15 + const { schema, symbols } = ctx; 16 16 + const { z } = symbols; 17 17 + if (typeof schema.const !== 'string') return; 18 18 + return $(z).attr(identifiers.literal).call($.literal(schema.const)); 19 19 + } 20 20 + 21 21 + function formatNode(ctx: StringResolverContext): Chain | undefined { 22 22 + const { chain, plugin, schema } = ctx; 23 23 + 13 24 switch (schema.format) { 14 25 case 'date': 15 15 - return chain.attr(identifiers.date).call(); 26 26 + return chain.current.attr(identifiers.date).call(); 16 27 case 'date-time': { 17 28 const obj = $.object() 18 29 .$if(plugin.config.dates.offset, (o) => ··· 21 32 .$if(plugin.config.dates.local, (o) => 22 33 o.prop('local', $.literal(true)), 23 34 ); 24 24 - return chain 35 35 + return chain.current 25 36 .attr(identifiers.datetime) 26 37 .call(obj.hasProps() ? obj : undefined); 27 38 } 28 39 case 'email': 29 29 - return chain.attr(identifiers.email).call(); 40 40 + return chain.current.attr(identifiers.email).call(); 30 41 case 'ipv4': 31 42 case 'ipv6': 32 32 - return chain.attr(identifiers.ip).call(); 43 43 + return chain.current.attr(identifiers.ip).call(); 33 44 case 'time': 34 34 - return chain.attr(identifiers.time).call(); 45 45 + return chain.current.attr(identifiers.time).call(); 35 46 case 'uri': 36 36 - return chain.attr(identifiers.url).call(); 47 47 + return chain.current.attr(identifiers.url).call(); 37 48 case 'uuid': 38 38 - return chain.attr(identifiers.uuid).call(); 39 39 - default: 40 40 - return chain; 49 49 + return chain.current.attr(identifiers.uuid).call(); 41 50 } 42 42 - }; 43 51 44 44 - export const stringToAst = ({ 45 45 - plugin, 46 46 - schema, 47 47 - }: IrSchemaToAstOptions & { 48 48 - schema: SchemaWithType<'string'>; 49 49 - }): ReturnType<typeof $.call> => { 50 50 - let chain: ReturnType<typeof $.call>; 52 52 + return; 53 53 + } 51 54 52 52 - const z = plugin.referenceSymbol({ 53 53 - category: 'external', 54 54 - resource: 'zod.z', 55 55 - }); 55 55 + function lengthNode(ctx: StringResolverContext): Chain | undefined { 56 56 + const { chain, schema } = ctx; 57 57 + if (schema.minLength === undefined || schema.minLength !== schema.maxLength) 58 58 + return; 59 59 + return chain.current 60 60 + .attr(identifiers.length) 61 61 + .call($.literal(schema.minLength)); 62 62 + } 56 63 57 57 - if (typeof schema.const === 'string') { 58 58 - chain = $(z).attr(identifiers.literal).call($.literal(schema.const)); 59 59 - return chain; 60 60 - } 64 64 + function maxLengthNode(ctx: StringResolverContext): Chain | undefined { 65 65 + const { chain, schema } = ctx; 66 66 + if (schema.maxLength === undefined) return; 67 67 + return chain.current.attr(identifiers.max).call($.literal(schema.maxLength)); 68 68 + } 61 69 62 62 - chain = $(z).attr(identifiers.string).call(); 70 70 + function minLengthNode(ctx: StringResolverContext): Chain | undefined { 71 71 + const { chain, schema } = ctx; 72 72 + if (schema.minLength === undefined) return; 73 73 + return chain.current.attr(identifiers.min).call($.literal(schema.minLength)); 74 74 + } 63 75 64 64 - if (schema.format) { 65 65 - const args: FormatResolverArgs = { $, chain, plugin, schema }; 66 66 - const resolver = 67 67 - plugin.config['~resolvers']?.string?.formats?.[schema.format]; 68 68 - chain = resolver?.(args) ?? defaultFormatResolver(args); 76 76 + function patternNode(ctx: StringResolverContext): Chain | undefined { 77 77 + const { chain, schema } = ctx; 78 78 + if (!schema.pattern) return; 79 79 + return chain.current.attr(identifiers.regex).call($.regexp(schema.pattern)); 80 80 + } 81 81 + 82 82 + function stringResolver(ctx: StringResolverContext): Chain { 83 83 + const constNode = ctx.nodes.const(ctx); 84 84 + if (constNode) { 85 85 + ctx.chain.current = constNode; 86 86 + return ctx.chain.current; 69 87 } 70 88 71 71 - if (schema.minLength === schema.maxLength && schema.minLength !== undefined) { 72 72 - chain = chain.attr(identifiers.length).call($.literal(schema.minLength)); 89 89 + const baseNode = ctx.nodes.base(ctx); 90 90 + if (baseNode) ctx.chain.current = baseNode; 91 91 + 92 92 + const formatNode = ctx.nodes.format(ctx); 93 93 + if (formatNode) ctx.chain.current = formatNode; 94 94 + 95 95 + const lengthNode = ctx.nodes.length(ctx); 96 96 + if (lengthNode) { 97 97 + ctx.chain.current = lengthNode; 73 98 } else { 74 74 - if (schema.minLength !== undefined) { 75 75 - chain = chain.attr(identifiers.min).call($.literal(schema.minLength)); 76 76 - } 99 99 + const minLengthNode = ctx.nodes.minLength(ctx); 100 100 + if (minLengthNode) ctx.chain.current = minLengthNode; 77 101 78 78 - if (schema.maxLength !== undefined) { 79 79 - chain = chain.attr(identifiers.max).call($.literal(schema.maxLength)); 80 80 - } 102 102 + const maxLengthNode = ctx.nodes.maxLength(ctx); 103 103 + if (maxLengthNode) ctx.chain.current = maxLengthNode; 81 104 } 82 105 83 83 - if (schema.pattern) { 84 84 - chain = chain.attr(identifiers.regex).call($.regexp(schema.pattern)); 85 85 - } 106 106 + const patternNode = ctx.nodes.pattern(ctx); 107 107 + if (patternNode) ctx.chain.current = patternNode; 86 108 87 87 - return chain; 109 109 + return ctx.chain.current; 110 110 + } 111 111 + 112 112 + export const stringToNode = ({ 113 113 + plugin, 114 114 + schema, 115 115 + }: IrSchemaToAstOptions & { 116 116 + schema: SchemaWithType<'string'>; 117 117 + }): Chain => { 118 118 + const z = plugin.external('zod.z'); 119 119 + const ctx: StringResolverContext = { 120 120 + $, 121 121 + chain: { 122 122 + current: $(z), 123 123 + }, 124 124 + nodes: { 125 125 + base: baseNode, 126 126 + const: constNode, 127 127 + format: formatNode, 128 128 + length: lengthNode, 129 129 + maxLength: maxLengthNode, 130 130 + minLength: minLengthNode, 131 131 + pattern: patternNode, 132 132 + }, 133 133 + plugin, 134 134 + schema, 135 135 + symbols: { 136 136 + z, 137 137 + }, 138 138 + }; 139 139 + const resolver = plugin.config['~resolvers']?.string; 140 140 + const node = resolver?.(ctx) ?? stringResolver(ctx); 141 141 + return node; 88 142 };

+29 -15

packages/openapi-ts/src/plugins/zod/v4/api.ts

··· 2 2 3 3 import { identifiers } from '../constants'; 4 4 import type { ValidatorArgs } from '../shared/types'; 5 5 - import type { ValidatorResolverArgs } from '../types'; 5 5 + import type { ValidatorResolverContext } from '../types'; 6 6 7 7 - const defaultValidatorResolver = ({ 8 8 - schema, 9 9 - }: ValidatorResolverArgs): ReturnType<typeof $.return> => 10 10 - $(schema).attr(identifiers.parseAsync).call('data').await().return(); 7 7 + const validatorResolver = ( 8 8 + ctx: ValidatorResolverContext, 9 9 + ): ReturnType<typeof $.return> => { 10 10 + const { schema } = ctx.symbols; 11 11 + return $(schema).attr(identifiers.parseAsync).call('data').await().return(); 12 12 + }; 11 13 12 14 export const createRequestValidatorV4 = ({ 13 15 operation, ··· 22 24 }); 23 25 if (!symbol) return; 24 26 25 25 - const args: ValidatorResolverArgs = { 27 27 + const z = plugin.external('zod.z'); 28 28 + const ctx: ValidatorResolverContext = { 26 29 $, 27 27 - chain: undefined, 30 30 + chain: { 31 31 + current: $(z), 32 32 + }, 28 33 operation, 29 34 plugin, 30 30 - schema: symbol, 35 35 + symbols: { 36 36 + schema: symbol, 37 37 + z, 38 38 + }, 31 39 }; 32 40 const validator = plugin.config['~resolvers']?.validator; 33 41 const resolver = 34 42 typeof validator === 'function' ? validator : validator?.request; 35 35 - const candidates = [resolver, defaultValidatorResolver]; 43 43 + const candidates = [resolver, validatorResolver]; 36 44 for (const candidate of candidates) { 37 37 - const statements = candidate?.(args); 45 45 + const statements = candidate?.(ctx); 38 46 if (statements === null) return; 39 47 if (statements !== undefined) { 40 48 return $.func() ··· 59 67 }); 60 68 if (!symbol) return; 61 69 62 62 - const args: ValidatorResolverArgs = { 70 70 + const z = plugin.external('zod.z'); 71 71 + const ctx: ValidatorResolverContext = { 63 72 $, 64 64 - chain: undefined, 73 73 + chain: { 74 74 + current: $(z), 75 75 + }, 65 76 operation, 66 77 plugin, 67 67 - schema: symbol, 78 78 + symbols: { 79 79 + schema: symbol, 80 80 + z, 81 81 + }, 68 82 }; 69 83 const validator = plugin.config['~resolvers']?.validator; 70 84 const resolver = 71 85 typeof validator === 'function' ? validator : validator?.response; 72 72 - const candidates = [resolver, defaultValidatorResolver]; 86 86 + const candidates = [resolver, validatorResolver]; 73 87 for (const candidate of candidates) { 74 74 - const statements = candidate?.(args); 88 88 + const statements = candidate?.(ctx); 75 89 if (statements === null) return; 76 90 if (statements !== undefined) { 77 91 return $.func()

+5 -5

packages/openapi-ts/src/plugins/zod/v4/toAst/index.ts

··· 7 7 import { enumToAst } from './enum'; 8 8 import { neverToAst } from './never'; 9 9 import { nullToAst } from './null'; 10 10 - import { numberToAst } from './number'; 10 10 + import { numberToNode } from './number'; 11 11 import { objectToAst } from './object'; 12 12 - import { stringToAst } from './string'; 12 12 + import { stringToNode } from './string'; 13 13 import { tupleToAst } from './tuple'; 14 14 import { undefinedToAst } from './undefined'; 15 15 import { unknownToAst } from './unknown'; ··· 39 39 }); 40 40 case 'integer': 41 41 case 'number': 42 42 - return numberToAst({ 42 42 + return numberToNode({ 43 43 ...args, 44 44 schema: schema as SchemaWithType<'integer' | 'number'>, 45 45 }); ··· 60 60 }); 61 61 case 'string': 62 62 return shouldCoerceToBigInt(schema.format) 63 63 - ? numberToAst({ 63 63 + ? numberToNode({ 64 64 ...args, 65 65 schema: { ...schema, type: 'number' }, 66 66 }) 67 67 - : stringToAst({ 67 67 + : stringToNode({ 68 68 ...args, 69 69 schema: schema as SchemaWithType<'string'>, 70 70 });

+112 -52

packages/openapi-ts/src/plugins/zod/v4/toAst/number.ts

··· 7 7 import { $ } from '~/ts-dsl'; 8 8 9 9 import { identifiers } from '../../constants'; 10 10 + import type { Chain } from '../../shared/chain'; 10 11 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 12 12 + import type { NumberResolverContext } from '../../types'; 11 13 12 12 - export const numberToAst = ({ 13 13 - plugin, 14 14 - schema, 15 15 - }: IrSchemaToAstOptions & { 16 16 - schema: SchemaWithType<'integer' | 'number'>; 17 17 - }): Omit<Ast, 'typeName'> => { 18 18 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 14 14 + function baseNode(ctx: NumberResolverContext): Chain { 15 15 + const { schema, symbols } = ctx; 16 16 + const { z } = symbols; 17 17 + if (ctx.utils.shouldCoerceToBigInt(schema.format)) { 18 18 + return $(z).attr(identifiers.coerce).attr(identifiers.bigint).call(); 19 19 + } 20 20 + let chain = $(z).attr(identifiers.number).call(); 21 21 + if (schema.type === 'integer') { 22 22 + chain = $(z).attr(identifiers.int).call(); 23 23 + } 24 24 + return chain; 25 25 + } 19 26 20 20 - const z = plugin.referenceSymbol({ 21 21 - category: 'external', 22 22 - resource: 'zod.z', 23 23 - }); 27 27 + function constNode(ctx: NumberResolverContext): Chain | undefined { 28 28 + const { schema, symbols } = ctx; 29 29 + const { z } = symbols; 30 30 + if (schema.const === undefined) return; 31 31 + return $(z) 32 32 + .attr(identifiers.literal) 33 33 + .call(ctx.utils.maybeBigInt(schema.const, schema.format)); 34 34 + } 24 35 25 25 - if (schema.const !== undefined) { 26 26 - result.expression = $(z) 27 27 - .attr(identifiers.literal) 28 28 - .call(maybeBigInt(schema.const, schema.format)); 29 29 - return result as Omit<Ast, 'typeName'>; 36 36 + function maxNode(ctx: NumberResolverContext): Chain | undefined { 37 37 + const { chain, schema } = ctx; 38 38 + if (schema.exclusiveMaximum !== undefined) { 39 39 + return chain.current 40 40 + .attr(identifiers.lt) 41 41 + .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format)); 30 42 } 31 31 - 32 32 - if (shouldCoerceToBigInt(schema.format)) { 33 33 - result.expression = $(z) 34 34 - .attr(identifiers.coerce) 35 35 - .attr(identifiers.bigint) 36 36 - .call(); 37 37 - } else { 38 38 - result.expression = $(z).attr(identifiers.number).call(); 39 39 - if (schema.type === 'integer') { 40 40 - result.expression = $(z).attr(identifiers.int).call(); 41 41 - } 43 43 + if (schema.maximum !== undefined) { 44 44 + return chain.current 45 45 + .attr(identifiers.lte) 46 46 + .call(ctx.utils.maybeBigInt(schema.maximum, schema.format)); 42 47 } 43 43 - 44 44 - const integerLimit = getIntegerLimit(schema.format); 45 45 - if (integerLimit) { 46 46 - result.expression = result.expression 47 47 - .attr(identifiers.min) 48 48 - .call( 49 49 - maybeBigInt(integerLimit.minValue, schema.format), 50 50 - $.object().prop('error', $.literal(integerLimit.minError)), 51 51 - ) 48 48 + const limit = ctx.utils.getIntegerLimit(schema.format); 49 49 + if (limit) { 50 50 + return chain.current 52 51 .attr(identifiers.max) 53 52 .call( 54 54 - maybeBigInt(integerLimit.maxValue, schema.format), 55 55 - $.object().prop('error', $.literal(integerLimit.maxError)), 53 53 + ctx.utils.maybeBigInt(limit.maxValue, schema.format), 54 54 + $.object().prop('error', $.literal(limit.maxError)), 56 55 ); 57 56 } 57 57 + return; 58 58 + } 58 59 60 60 + function minNode(ctx: NumberResolverContext): Chain | undefined { 61 61 + const { chain, schema } = ctx; 59 62 if (schema.exclusiveMinimum !== undefined) { 60 60 - result.expression = result.expression 63 63 + return chain.current 61 64 .attr(identifiers.gt) 62 62 - .call(maybeBigInt(schema.exclusiveMinimum, schema.format)); 63 63 - } else if (schema.minimum !== undefined) { 64 64 - result.expression = result.expression 65 65 + .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format)); 66 66 + } 67 67 + if (schema.minimum !== undefined) { 68 68 + return chain.current 65 69 .attr(identifiers.gte) 66 66 - .call(maybeBigInt(schema.minimum, schema.format)); 70 70 + .call(ctx.utils.maybeBigInt(schema.minimum, schema.format)); 71 71 + } 72 72 + const limit = ctx.utils.getIntegerLimit(schema.format); 73 73 + if (limit) { 74 74 + return chain.current 75 75 + .attr(identifiers.min) 76 76 + .call( 77 77 + ctx.utils.maybeBigInt(limit.minValue, schema.format), 78 78 + $.object().prop('error', $.literal(limit.minError)), 79 79 + ); 67 80 } 81 81 + return; 82 82 + } 68 83 69 69 - if (schema.exclusiveMaximum !== undefined) { 70 70 - result.expression = result.expression 71 71 - .attr(identifiers.lt) 72 72 - .call(maybeBigInt(schema.exclusiveMaximum, schema.format)); 73 73 - } else if (schema.maximum !== undefined) { 74 74 - result.expression = result.expression 75 75 - .attr(identifiers.lte) 76 76 - .call(maybeBigInt(schema.maximum, schema.format)); 84 84 + function numberResolver(ctx: NumberResolverContext): Chain { 85 85 + const constNode = ctx.nodes.const(ctx); 86 86 + if (constNode) { 87 87 + ctx.chain.current = constNode; 88 88 + return ctx.chain.current; 77 89 } 78 90 79 79 - return result as Omit<Ast, 'typeName'>; 91 91 + const baseNode = ctx.nodes.base(ctx); 92 92 + if (baseNode) ctx.chain.current = baseNode; 93 93 + 94 94 + const minNode = ctx.nodes.min(ctx); 95 95 + if (minNode) ctx.chain.current = minNode; 96 96 + 97 97 + const maxNode = ctx.nodes.max(ctx); 98 98 + if (maxNode) ctx.chain.current = maxNode; 99 99 + 100 100 + return ctx.chain.current; 101 101 + } 102 102 + 103 103 + export const numberToNode = ({ 104 104 + plugin, 105 105 + schema, 106 106 + state, 107 107 + }: IrSchemaToAstOptions & { 108 108 + schema: SchemaWithType<'integer' | 'number'>; 109 109 + }): Omit<Ast, 'typeName'> => { 110 110 + const ast: Partial<Omit<Ast, 'typeName'>> = {}; 111 111 + const z = plugin.external('zod.z'); 112 112 + const ctx: NumberResolverContext = { 113 113 + $, 114 114 + chain: { 115 115 + current: $(z), 116 116 + }, 117 117 + nodes: { 118 118 + base: baseNode, 119 119 + const: constNode, 120 120 + max: maxNode, 121 121 + min: minNode, 122 122 + }, 123 123 + plugin, 124 124 + schema, 125 125 + symbols: { 126 126 + z, 127 127 + }, 128 128 + utils: { 129 129 + ast, 130 130 + getIntegerLimit, 131 131 + maybeBigInt, 132 132 + shouldCoerceToBigInt, 133 133 + state, 134 134 + }, 135 135 + }; 136 136 + const resolver = plugin.config['~resolvers']?.number; 137 137 + const node = resolver?.(ctx) ?? numberResolver(ctx); 138 138 + ast.expression = node; 139 139 + return ast as Omit<Ast, 'typeName'>; 80 140 };

+70 -60

packages/openapi-ts/src/plugins/zod/v4/toAst/object.ts

··· 4 4 import { $ } from '~/ts-dsl'; 5 5 6 6 import { identifiers } from '../../constants'; 7 7 + import type { Chain } from '../../shared/chain'; 7 8 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 8 8 - import type { ObjectBaseResolverArgs } from '../../types'; 9 9 + import type { ObjectResolverContext } from '../../types'; 9 10 import { irSchemaToAst } from '../plugin'; 10 11 11 11 - function defaultObjectBaseResolver({ 12 12 - additional, 13 13 - plugin, 14 14 - shape, 15 15 - }: ObjectBaseResolverArgs): ReturnType<typeof $.call> { 16 16 - const z = plugin.referenceSymbol({ 17 17 - category: 'external', 18 18 - resource: 'zod.z', 12 12 + function additionalPropertiesNode( 13 13 + ctx: ObjectResolverContext, 14 14 + ): Chain | null | undefined { 15 15 + const { plugin, schema } = ctx; 16 16 + 17 17 + if ( 18 18 + !schema.additionalProperties || 19 19 + (schema.properties && Object.keys(schema.properties).length > 0) 20 20 + ) 21 21 + return; 22 22 + 23 23 + const additionalAst = irSchemaToAst({ 24 24 + plugin, 25 25 + schema: schema.additionalProperties, 26 26 + state: { 27 27 + ...ctx.utils.state, 28 28 + path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']), 29 29 + }, 19 30 }); 31 31 + if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true; 32 32 + return additionalAst.expression; 33 33 + } 34 34 + 35 35 + function baseNode(ctx: ObjectResolverContext): Chain { 36 36 + const { nodes, symbols } = ctx; 37 37 + const { z } = symbols; 38 38 + 39 39 + const additional = nodes.additionalProperties(ctx); 40 40 + const shape = nodes.shape(ctx); 20 41 21 42 if (additional) { 22 43 return $(z) ··· 27 48 return $(z).attr(identifiers.object).call(shape); 28 49 } 29 50 30 30 - export const objectToAst = ({ 31 31 - plugin, 32 32 - schema, 33 33 - state, 34 34 - }: IrSchemaToAstOptions & { 35 35 - schema: SchemaWithType<'object'>; 36 36 - }): Omit<Ast, 'typeName'> => { 37 37 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 38 38 - 51 51 + function objectResolver(ctx: ObjectResolverContext): Chain { 39 52 // TODO: parser - handle constants 53 53 + return ctx.nodes.base(ctx); 54 54 + } 40 55 56 56 + function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> { 57 57 + const { plugin, schema } = ctx; 41 58 const shape = $.object().pretty(); 42 42 - const required = schema.required ?? []; 43 59 44 60 for (const name in schema.properties) { 45 61 const property = schema.properties[name]!; 46 46 - const isRequired = required.includes(name); 47 62 48 63 const propertyAst = irSchemaToAst({ 49 49 - optional: !isRequired, 64 64 + optional: !schema.required?.includes(name), 50 65 plugin, 51 66 schema: property, 52 67 state: { 53 53 - ...state, 54 54 - path: ref([...fromRef(state.path), 'properties', name]), 68 68 + ...ctx.utils.state, 69 69 + path: ref([...fromRef(ctx.utils.state.path), 'properties', name]), 55 70 }, 56 71 }); 57 72 if (propertyAst.hasLazyExpression) { 58 58 - result.hasLazyExpression = true; 59 59 - } 60 60 - 61 61 - if (propertyAst.hasLazyExpression) { 73 73 + ctx.utils.ast.hasLazyExpression = true; 62 74 shape.getter(name, propertyAst.expression.return()); 63 75 } else { 64 76 shape.prop(name, propertyAst.expression); 65 77 } 66 78 } 67 79 68 68 - let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined; 69 69 - if ( 70 70 - schema.additionalProperties && 71 71 - (!schema.properties || !Object.keys(schema.properties).length) 72 72 - ) { 73 73 - const additionalAst = irSchemaToAst({ 74 74 - plugin, 75 75 - schema: schema.additionalProperties, 76 76 - state: { 77 77 - ...state, 78 78 - path: ref([...fromRef(state.path), 'additionalProperties']), 79 79 - }, 80 80 - }); 81 81 - if (additionalAst.hasLazyExpression) result.hasLazyExpression = true; 82 82 - additional = additionalAst.expression; 83 83 - } 80 80 + return shape; 81 81 + } 84 82 85 85 - const args: ObjectBaseResolverArgs = { 83 83 + export const objectToAst = ({ 84 84 + plugin, 85 85 + schema, 86 86 + state, 87 87 + }: IrSchemaToAstOptions & { 88 88 + schema: SchemaWithType<'object'>; 89 89 + }): Omit<Ast, 'typeName'> => { 90 90 + const ast: Partial<Omit<Ast, 'typeName'>> = {}; 91 91 + const z = plugin.external('zod.z'); 92 92 + const ctx: ObjectResolverContext = { 86 93 $, 87 87 - additional, 88 88 - chain: undefined, 94 94 + chain: { 95 95 + current: $(z), 96 96 + }, 97 97 + nodes: { 98 98 + additionalProperties: additionalPropertiesNode, 99 99 + base: baseNode, 100 100 + shape: shapeNode, 101 101 + }, 89 102 plugin, 90 103 schema, 91 91 - shape, 104 104 + symbols: { 105 105 + z, 106 106 + }, 107 107 + utils: { 108 108 + ast, 109 109 + state, 110 110 + }, 92 111 }; 93 93 - const resolver = plugin.config['~resolvers']?.object?.base; 94 94 - const chain = resolver?.(args) ?? defaultObjectBaseResolver(args); 95 95 - result.expression = chain; 96 96 - 97 97 - // Return with typeName for circular references 98 98 - if (result.hasLazyExpression) { 99 99 - return { 100 100 - ...result, 101 101 - typeName: 'ZodType', 102 102 - } as Ast; 103 103 - } 104 104 - 105 105 - return result as Omit<Ast, 'typeName'>; 112 112 + const resolver = plugin.config['~resolvers']?.object; 113 113 + const node = resolver?.(ctx) ?? objectResolver(ctx); 114 114 + ast.expression = node; 115 115 + return ast as Omit<Ast, 'typeName'>; 106 116 };

+98 -49

packages/openapi-ts/src/plugins/zod/v4/toAst/string.ts

··· 2 2 import { $ } from '~/ts-dsl'; 3 3 4 4 import { identifiers } from '../../constants'; 5 5 + import type { Chain } from '../../shared/chain'; 5 6 import type { Ast, IrSchemaToAstOptions } from '../../shared/types'; 6 6 - import type { FormatResolverArgs } from '../../types'; 7 7 + import type { StringResolverContext } from '../../types'; 8 8 + 9 9 + function baseNode(ctx: StringResolverContext): Chain { 10 10 + const { z } = ctx.symbols; 11 11 + return $(z).attr(identifiers.string).call(); 12 12 + } 13 13 + 14 14 + function constNode(ctx: StringResolverContext): Chain | undefined { 15 15 + const { schema, symbols } = ctx; 16 16 + const { z } = symbols; 17 17 + if (typeof schema.const !== 'string') return; 18 18 + return $(z).attr(identifiers.literal).call($.literal(schema.const)); 19 19 + } 7 20 8 8 - const defaultFormatResolver = ({ 9 9 - chain, 10 10 - plugin, 11 11 - schema, 12 12 - }: FormatResolverArgs): ReturnType<typeof $.call> => { 13 13 - const z = plugin.referenceSymbol({ 14 14 - category: 'external', 15 15 - resource: 'zod.z', 16 16 - }); 21 21 + function formatNode(ctx: StringResolverContext): Chain | undefined { 22 22 + const { plugin, schema, symbols } = ctx; 23 23 + const { z } = symbols; 17 24 18 25 switch (schema.format) { 19 26 case 'date': ··· 43 50 return $(z).attr(identifiers.url).call(); 44 51 case 'uuid': 45 52 return $(z).attr(identifiers.uuid).call(); 46 46 - default: 47 47 - return chain; 48 53 } 49 49 - }; 50 54 51 51 - export const stringToAst = ({ 52 52 - plugin, 53 53 - schema, 54 54 - }: IrSchemaToAstOptions & { 55 55 - schema: SchemaWithType<'string'>; 56 56 - }): Omit<Ast, 'typeName'> => { 57 57 - const result: Partial<Omit<Ast, 'typeName'>> = {}; 58 58 - let chain: ReturnType<typeof $.call>; 55 55 + return; 56 56 + } 57 57 + 58 58 + function lengthNode(ctx: StringResolverContext): Chain | undefined { 59 59 + const { chain, schema } = ctx; 60 60 + if (schema.minLength === undefined || schema.minLength !== schema.maxLength) 61 61 + return; 62 62 + return chain.current 63 63 + .attr(identifiers.length) 64 64 + .call($.literal(schema.minLength)); 65 65 + } 66 66 + 67 67 + function maxLengthNode(ctx: StringResolverContext): Chain | undefined { 68 68 + const { chain, schema } = ctx; 69 69 + if (schema.maxLength === undefined) return; 70 70 + return chain.current.attr(identifiers.max).call($.literal(schema.maxLength)); 71 71 + } 72 72 + 73 73 + function minLengthNode(ctx: StringResolverContext): Chain | undefined { 74 74 + const { chain, schema } = ctx; 75 75 + if (schema.minLength === undefined) return; 76 76 + return chain.current.attr(identifiers.min).call($.literal(schema.minLength)); 77 77 + } 59 78 60 60 - const z = plugin.referenceSymbol({ 61 61 - category: 'external', 62 62 - resource: 'zod.z', 63 63 - }); 79 79 + function patternNode(ctx: StringResolverContext): Chain | undefined { 80 80 + const { chain, schema } = ctx; 81 81 + if (!schema.pattern) return; 82 82 + return chain.current.attr(identifiers.regex).call($.regexp(schema.pattern)); 83 83 + } 64 84 65 65 - if (typeof schema.const === 'string') { 66 66 - chain = $(z).attr(identifiers.literal).call($.literal(schema.const)); 67 67 - result.expression = chain; 68 68 - return result as Omit<Ast, 'typeName'>; 85 85 + function stringResolver(ctx: StringResolverContext): Chain { 86 86 + const constNode = ctx.nodes.const(ctx); 87 87 + if (constNode) { 88 88 + ctx.chain.current = constNode; 89 89 + return ctx.chain.current; 69 90 } 70 91 71 71 - chain = $(z).attr(identifiers.string).call(); 92 92 + const baseNode = ctx.nodes.base(ctx); 93 93 + if (baseNode) ctx.chain.current = baseNode; 72 94 73 73 - if (schema.format) { 74 74 - const args: FormatResolverArgs = { $, chain, plugin, schema }; 75 75 - const resolver = 76 76 - plugin.config['~resolvers']?.string?.formats?.[schema.format]; 77 77 - chain = resolver?.(args) ?? defaultFormatResolver(args); 78 78 - } 95 95 + const formatNode = ctx.nodes.format(ctx); 96 96 + if (formatNode) ctx.chain.current = formatNode; 79 97 80 80 - if (schema.minLength === schema.maxLength && schema.minLength !== undefined) { 81 81 - chain = chain.attr(identifiers.length).call($.literal(schema.minLength)); 98 98 + const lengthNode = ctx.nodes.length(ctx); 99 99 + if (lengthNode) { 100 100 + ctx.chain.current = lengthNode; 82 101 } else { 83 83 - if (schema.minLength !== undefined) { 84 84 - chain = chain.attr(identifiers.min).call($.literal(schema.minLength)); 85 85 - } 102 102 + const minLengthNode = ctx.nodes.minLength(ctx); 103 103 + if (minLengthNode) ctx.chain.current = minLengthNode; 86 104 87 87 - if (schema.maxLength !== undefined) { 88 88 - chain = chain.attr(identifiers.max).call($.literal(schema.maxLength)); 89 89 - } 105 105 + const maxLengthNode = ctx.nodes.maxLength(ctx); 106 106 + if (maxLengthNode) ctx.chain.current = maxLengthNode; 90 107 } 91 108 92 92 - if (schema.pattern) { 93 93 - chain = chain.attr(identifiers.regex).call($.regexp(schema.pattern)); 94 94 - } 109 109 + const patternNode = ctx.nodes.pattern(ctx); 110 110 + if (patternNode) ctx.chain.current = patternNode; 111 111 + 112 112 + return ctx.chain.current; 113 113 + } 95 114 96 96 - result.expression = chain; 97 97 - return result as Omit<Ast, 'typeName'>; 115 115 + export const stringToNode = ({ 116 116 + plugin, 117 117 + schema, 118 118 + }: IrSchemaToAstOptions & { 119 119 + schema: SchemaWithType<'string'>; 120 120 + }): Omit<Ast, 'typeName'> => { 121 121 + const z = plugin.external('zod.z'); 122 122 + const ctx: StringResolverContext = { 123 123 + $, 124 124 + chain: { 125 125 + current: $(z), 126 126 + }, 127 127 + nodes: { 128 128 + base: baseNode, 129 129 + const: constNode, 130 130 + format: formatNode, 131 131 + length: lengthNode, 132 132 + maxLength: maxLengthNode, 133 133 + minLength: minLengthNode, 134 134 + pattern: patternNode, 135 135 + }, 136 136 + plugin, 137 137 + schema, 138 138 + symbols: { 139 139 + z, 140 140 + }, 141 141 + }; 142 142 + const resolver = plugin.config['~resolvers']?.string; 143 143 + const node = resolver?.(ctx) ?? stringResolver(ctx); 144 144 + return { 145 145 + expression: node, 146 146 + }; 98 147 };