fork of hey-api/openapi-ts because I need some additional things
refactor: allow path in top-level detect function
+1378
-1068
+5
.changeset/fluffy-words-dress.md
+5
.changeset/fluffy-words-dress.md
+5
.changeset/smart-comics-talk.md
+5
.changeset/smart-comics-talk.md
+1
-1
dev/openapi-python.config.ts
+1
-1
dev/openapi-python.config.ts
+1
-1
dev/openapi-ts.config.ts
+1
-1
dev/openapi-ts.config.ts
+13
packages/openapi-python/src/plugins/pydantic/v2/plugin.ts
+13
packages/openapi-python/src/plugins/pydantic/v2/plugin.ts
···
13
13
optional,
14
14
plugin,
15
15
schema,
16
+
schemaExtractor,
16
17
state,
17
18
}: IrSchemaToAstOptions & {
18
19
optional?: boolean;
19
20
schema: IR.SchemaObject;
20
21
}): Ast {
22
+
if (schemaExtractor && !schema.$ref) {
23
+
const extracted = schemaExtractor({
24
+
meta: {
25
+
resource: 'definition',
26
+
resourceId: pathToJsonPointer(fromRef(state.path)),
27
+
},
28
+
path: fromRef(state.path),
29
+
schema,
30
+
});
31
+
if (extracted !== schema) schema = extracted;
32
+
}
33
+
21
34
if (schema.$ref) {
22
35
const query: SymbolMeta = {
23
36
category: 'schema',
+16
-5
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/plugin.ts
+16
-5
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/plugin.ts
···
1
1
import type { Symbol } from '@hey-api/codegen-core';
2
-
import { refs } from '@hey-api/codegen-core';
3
-
import type { IR } from '@hey-api/shared';
4
-
import type { SchemaWithType } from '@hey-api/shared';
5
-
import { applyNaming } from '@hey-api/shared';
6
-
import { deduplicateSchema } from '@hey-api/shared';
2
+
import { fromRef, refs } from '@hey-api/codegen-core';
3
+
import type { IR, SchemaWithType } from '@hey-api/shared';
4
+
import { applyNaming, deduplicateSchema, pathToJsonPointer } from '@hey-api/shared';
7
5
8
6
import type { MaybeTsDsl, TypeTsDsl } from '../../../../ts-dsl';
9
7
import { $ } from '../../../../ts-dsl';
···
18
16
export function irSchemaToAst({
19
17
plugin,
20
18
schema,
19
+
schemaExtractor,
21
20
state,
22
21
}: IrSchemaToAstOptions & {
23
22
schema: IR.SchemaObject;
24
23
}): MaybeTsDsl<TypeTsDsl> {
24
+
if (schemaExtractor && !schema.$ref) {
25
+
const extracted = schemaExtractor({
26
+
meta: {
27
+
resource: 'definition',
28
+
resourceId: pathToJsonPointer(fromRef(state.path)),
29
+
},
30
+
path: fromRef(state.path),
31
+
schema,
32
+
});
33
+
if (extracted !== schema) schema = extracted;
34
+
}
35
+
25
36
if (schema.symbolRef) {
26
37
const baseType = $.type(schema.symbolRef);
27
38
if (schema.omit && schema.omit.length > 0) {
+13
packages/openapi-ts/src/plugins/arktype/v2/plugin.ts
+13
packages/openapi-ts/src/plugins/arktype/v2/plugin.ts
···
13
13
// optional,
14
14
plugin,
15
15
schema,
16
+
schemaExtractor,
16
17
state,
17
18
}: IrSchemaToAstOptions & {
18
19
/**
···
23
24
optional?: boolean;
24
25
schema: IR.SchemaObject;
25
26
}): Ast {
27
+
if (schemaExtractor && !schema.$ref) {
28
+
const extracted = schemaExtractor({
29
+
meta: {
30
+
resource: 'definition',
31
+
resourceId: pathToJsonPointer(fromRef(state.path)),
32
+
},
33
+
path: fromRef(state.path),
34
+
schema,
35
+
});
36
+
if (extracted !== schema) schema = extracted;
37
+
}
38
+
26
39
let ast: Partial<Ast> = {};
27
40
28
41
// const z = plugin.referenceSymbol({
+22
-26
packages/openapi-ts/src/plugins/valibot/resolvers/types.ts
+22
-26
packages/openapi-ts/src/plugins/valibot/resolvers/types.ts
···
5
5
import type { GetIntegerLimit } from '../../../plugins/shared/utils/formats';
6
6
import type { $, DollarTsDsl } from '../../../ts-dsl';
7
7
import type { Pipe, PipeResult, Pipes, PipesUtils } from '../shared/pipes';
8
-
import type { Ast, PluginState } from '../shared/types';
9
-
import type { ValibotPlugin } from '../types';
8
+
import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types';
10
9
11
10
export type Resolvers = Plugin.Resolvers<{
12
11
/**
···
70
69
71
70
type ValidatorResolver = (ctx: ValidatorResolverContext) => PipeResult | null | undefined;
72
71
73
-
interface BaseContext extends DollarTsDsl {
74
-
/**
75
-
* Functions for working with pipes.
76
-
*/
77
-
pipes: PipesUtils & {
72
+
type BaseContext = DollarTsDsl &
73
+
Pick<IrSchemaToAstOptions, 'plugin' | 'schemaExtractor'> & {
74
+
/**
75
+
* Functions for working with pipes.
76
+
*/
77
+
pipes: PipesUtils & {
78
+
/**
79
+
* The current pipe.
80
+
*
81
+
* In Valibot, this represents a list of call expressions ("pipes")
82
+
* being assembled to form a schema definition.
83
+
*
84
+
* Each pipe can be extended, modified, or replaced to customize
85
+
* the resulting schema.
86
+
*/
87
+
current: Pipes;
88
+
};
78
89
/**
79
-
* The current pipe.
80
-
*
81
-
* In Valibot, this represents a list of call expressions ("pipes")
82
-
* being assembled to form a schema definition.
83
-
*
84
-
* Each pipe can be extended, modified, or replaced to customize
85
-
* the resulting schema.
90
+
* Provides access to commonly used symbols within the plugin.
86
91
*/
87
-
current: Pipes;
88
-
};
89
-
/**
90
-
* The plugin instance.
91
-
*/
92
-
plugin: ValibotPlugin['Instance'];
93
-
/**
94
-
* Provides access to commonly used symbols within the plugin.
95
-
*/
96
-
symbols: {
97
-
v: Symbol;
92
+
symbols: {
93
+
v: Symbol;
94
+
};
98
95
};
99
-
}
100
96
101
97
export interface EnumResolverContext extends BaseContext {
102
98
/**
+52
-76
packages/openapi-ts/src/plugins/valibot/v1/plugin.ts
+52
-76
packages/openapi-ts/src/plugins/valibot/v1/plugin.ts
···
1
1
import type { SymbolMeta } from '@hey-api/codegen-core';
2
-
import { fromRef, ref, refs } from '@hey-api/codegen-core';
3
-
import type { IR, SchemaExtractor, SchemaWithType } from '@hey-api/shared';
4
-
import {
5
-
applyNaming,
6
-
deduplicateSchema,
7
-
inlineSchema,
8
-
pathToJsonPointer,
9
-
refToName,
10
-
} from '@hey-api/shared';
2
+
import { fromRef, ref } from '@hey-api/codegen-core';
3
+
import type { IR, SchemaWithType } from '@hey-api/shared';
4
+
import { deduplicateSchema, pathToJsonPointer } from '@hey-api/shared';
11
5
12
6
import { maybeBigInt } from '../../../plugins/shared/utils/coerce';
13
7
import { $ } from '../../../ts-dsl';
14
-
import { exportAst } from '../shared/export';
15
8
import { irOperationToAst } from '../shared/operation';
16
9
import { pipesToNode } from '../shared/pipes';
17
-
import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types';
10
+
import type { Ast, IrSchemaToAstOptions } from '../shared/types';
18
11
import { irWebhookToAst } from '../shared/webhook';
19
12
import type { ValibotPlugin } from '../types';
20
13
import { identifiers } from './constants';
14
+
import { createProcessor } from './processor';
21
15
import { irSchemaWithTypeToAst } from './toAst';
22
16
23
17
export function irSchemaToAst({
24
18
optional,
25
19
plugin,
26
20
schema,
27
-
schemaExtractor = inlineSchema,
21
+
schemaExtractor,
28
22
state,
29
23
}: IrSchemaToAstOptions & {
30
24
/**
···
34
28
*/
35
29
optional?: boolean;
36
30
schema: IR.SchemaObject;
37
-
schemaExtractor?: SchemaExtractor;
38
31
}): Ast {
39
-
if (!schema.$ref) {
40
-
const resolved = schemaExtractor({ path: fromRef(state.path), schema });
41
-
if (resolved !== schema) {
42
-
schema = resolved;
43
-
}
32
+
if (schemaExtractor && !schema.$ref) {
33
+
const extracted = schemaExtractor({
34
+
meta: {
35
+
resource: 'definition',
36
+
resourceId: pathToJsonPointer(fromRef(state.path)),
37
+
},
38
+
naming: plugin.config.definitions,
39
+
path: fromRef(state.path),
40
+
plugin,
41
+
schema,
42
+
});
43
+
if (extracted !== schema) schema = extracted;
44
44
}
45
45
46
46
const ast: Ast = {
···
71
71
const typeAst = irSchemaWithTypeToAst({
72
72
plugin,
73
73
schema: schema as SchemaWithType,
74
+
schemaExtractor,
74
75
state,
75
76
});
76
77
ast.typeName = typeAst.anyType;
···
121
122
schema: {
122
123
type: 'unknown',
123
124
},
125
+
schemaExtractor,
124
126
state,
125
127
});
126
128
ast.typeName = typeAst.anyType;
···
152
154
return ast as Ast;
153
155
}
154
156
155
-
function handleComponent({
156
-
plugin,
157
-
schema,
158
-
state,
159
-
}: IrSchemaToAstOptions & {
160
-
schema: IR.SchemaObject;
161
-
}): void {
162
-
const $ref = pathToJsonPointer(fromRef(state.path));
163
-
const ast = irSchemaToAst({ plugin, schema, state });
164
-
const baseName = refToName($ref);
165
-
const symbol = plugin.symbol(applyNaming(baseName, plugin.config.definitions), {
166
-
meta: {
167
-
category: 'schema',
168
-
path: fromRef(state.path),
169
-
resource: 'definition',
170
-
resourceId: $ref,
171
-
tags: fromRef(state.tags),
172
-
tool: 'valibot',
173
-
},
174
-
});
175
-
exportAst({
176
-
ast,
177
-
plugin,
178
-
schema,
179
-
state,
180
-
symbol,
181
-
});
182
-
}
183
-
184
157
export const handlerV1: ValibotPlugin['Handler'] = ({ plugin }) => {
185
158
plugin.symbol('v', {
186
159
external: 'valibot',
···
191
164
},
192
165
});
193
166
167
+
const processor = createProcessor(plugin);
168
+
194
169
plugin.forEach('operation', 'parameter', 'requestBody', 'schema', 'webhook', (event) => {
195
-
const state = refs<PluginState>({
196
-
hasLazyExpression: false,
197
-
path: event._path,
198
-
tags: event.tags,
199
-
});
200
170
switch (event.type) {
201
171
case 'operation':
202
172
irOperationToAst({
203
-
getAst: (schema, path) => {
204
-
const state = refs<PluginState>({
205
-
hasLazyExpression: false,
206
-
path,
207
-
tags: event.tags,
208
-
});
209
-
return irSchemaToAst({ plugin, schema, state });
210
-
},
211
173
operation: event.operation,
174
+
path: event._path,
212
175
plugin,
213
-
state,
176
+
processor,
177
+
tags: event.tags,
214
178
});
215
179
break;
216
180
case 'parameter':
217
-
handleComponent({
181
+
processor.process({
182
+
meta: {
183
+
resource: 'definition',
184
+
resourceId: pathToJsonPointer(event._path),
185
+
},
186
+
naming: plugin.config.definitions,
187
+
path: event._path,
218
188
plugin,
219
189
schema: event.parameter.schema,
220
-
state,
190
+
tags: event.tags,
221
191
});
222
192
break;
223
193
case 'requestBody':
224
-
handleComponent({
194
+
processor.process({
195
+
meta: {
196
+
resource: 'definition',
197
+
resourceId: pathToJsonPointer(event._path),
198
+
},
199
+
naming: plugin.config.definitions,
200
+
path: event._path,
225
201
plugin,
226
202
schema: event.requestBody.schema,
227
-
state,
203
+
tags: event.tags,
228
204
});
229
205
break;
230
206
case 'schema':
231
-
handleComponent({
207
+
processor.process({
208
+
meta: {
209
+
resource: 'definition',
210
+
resourceId: pathToJsonPointer(event._path),
211
+
},
212
+
naming: plugin.config.definitions,
213
+
path: event._path,
232
214
plugin,
233
215
schema: event.schema,
234
-
state,
216
+
tags: event.tags,
235
217
});
236
218
break;
237
219
case 'webhook':
238
220
irWebhookToAst({
239
-
getAst: (schema, path) => {
240
-
const state = refs<PluginState>({
241
-
hasLazyExpression: false,
242
-
path,
243
-
tags: event.tags,
244
-
});
245
-
return irSchemaToAst({ plugin, schema, state });
246
-
},
247
221
operation: event.operation,
222
+
path: event._path,
248
223
plugin,
249
-
state,
224
+
processor,
225
+
tags: event.tags,
250
226
});
251
227
break;
252
228
}
+58
packages/openapi-ts/src/plugins/valibot/v1/processor.ts
+58
packages/openapi-ts/src/plugins/valibot/v1/processor.ts
···
1
+
import { refs } from '@hey-api/codegen-core';
2
+
import type { IR } from '@hey-api/shared';
3
+
import { createSchemaProcessor, pathToJsonPointer } from '@hey-api/shared';
4
+
5
+
import { exportAst } from '../shared/export';
6
+
import type { ProcessorContext, ProcessorResult } from '../shared/processor';
7
+
import type { PluginState } from '../shared/types';
8
+
import type { ValibotPlugin } from '../types';
9
+
import { irSchemaToAst } from './plugin';
10
+
11
+
export function createProcessor(plugin: ValibotPlugin['Instance']): ProcessorResult {
12
+
const processor = createSchemaProcessor();
13
+
14
+
const hooks = [plugin.config['~hooks']?.schemas, plugin.context.config.parser.hooks.schemas];
15
+
16
+
function extractor(ctx: ProcessorContext): IR.SchemaObject {
17
+
if (processor.hasEmitted(ctx.path)) {
18
+
return ctx.schema;
19
+
}
20
+
21
+
for (const hook of hooks) {
22
+
const result = hook?.shouldExtract?.(ctx);
23
+
if (result) {
24
+
process({
25
+
namingAnchor: processor.context.anchor,
26
+
tags: processor.context.tags,
27
+
...ctx,
28
+
});
29
+
return { $ref: pathToJsonPointer(ctx.path) };
30
+
}
31
+
}
32
+
33
+
return ctx.schema;
34
+
}
35
+
36
+
function process(ctx: ProcessorContext): void {
37
+
if (!processor.markEmitted(ctx.path)) return;
38
+
39
+
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
40
+
const state = refs<PluginState>({
41
+
hasLazyExpression: false,
42
+
path: ctx.path,
43
+
tags: ctx.tags,
44
+
});
45
+
46
+
const ast = irSchemaToAst({
47
+
plugin,
48
+
schema: ctx.schema,
49
+
schemaExtractor: extractor,
50
+
state,
51
+
});
52
+
53
+
exportAst({ ...ctx, ast, plugin, state });
54
+
});
55
+
}
56
+
57
+
return { process };
58
+
}
+14
-15
packages/openapi-ts/src/plugins/valibot/v1/toAst/array.ts
+14
-15
packages/openapi-ts/src/plugins/valibot/v1/toAst/array.ts
···
9
9
import { irSchemaToAst } from '../plugin';
10
10
import { unknownToAst } from './unknown';
11
11
12
-
export const arrayToAst = ({
13
-
plugin,
14
-
schema,
15
-
state,
16
-
}: IrSchemaToAstOptions & {
17
-
schema: SchemaWithType<'array'>;
18
-
}): Omit<Ast, 'typeName'> => {
12
+
export function arrayToAst(
13
+
options: IrSchemaToAstOptions & {
14
+
schema: SchemaWithType<'array'>;
15
+
},
16
+
): Omit<Ast, 'typeName'> {
17
+
const { plugin } = options;
18
+
let { schema } = options;
19
+
19
20
const result: Omit<Ast, 'typeName'> = {
20
21
pipes: [],
21
22
};
···
26
27
if (!schema.items) {
27
28
const expression = functionName.call(
28
29
unknownToAst({
29
-
plugin,
30
+
...options,
30
31
schema: {
31
32
type: 'unknown',
32
33
},
33
-
state,
34
34
}),
35
35
);
36
36
result.pipes.push(expression);
···
40
40
// at least one item is guaranteed
41
41
const itemExpressions = schema.items!.map((item, index) => {
42
42
const itemAst = irSchemaToAst({
43
-
plugin,
43
+
...options,
44
44
schema: item,
45
45
state: {
46
-
...state,
47
-
path: ref([...fromRef(state.path), 'items', index]),
46
+
...options.state,
47
+
path: ref([...fromRef(options.state.path), 'items', index]),
48
48
},
49
49
});
50
50
if (itemAst.hasLazyExpression) {
···
69
69
70
70
const expression = functionName.call(
71
71
unknownToAst({
72
-
plugin,
72
+
...options,
73
73
schema: {
74
74
type: 'unknown',
75
75
},
76
-
state,
77
76
}),
78
77
);
79
78
result.pipes.push(expression);
···
100
99
}
101
100
102
101
return result as Omit<Ast, 'typeName'>;
103
-
};
102
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/enum.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/enum.ts
···
65
65
return ctx.pipes.current;
66
66
}
67
67
68
-
export const enumToAst = ({
68
+
export function enumToAst({
69
69
plugin,
70
70
schema,
71
71
state,
72
72
}: IrSchemaToAstOptions & {
73
73
schema: SchemaWithType<'enum'>;
74
-
}): Pipe => {
74
+
}): Pipe {
75
75
const v = plugin.external('valibot.v');
76
76
77
77
const { enumMembers } = itemsNode({
···
118
118
const resolver = plugin.config['~resolvers']?.enum;
119
119
const node = resolver?.(ctx) ?? enumResolver(ctx);
120
120
return ctx.pipes.toNode(node, plugin);
121
-
};
121
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/never.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/never.ts
···
4
4
import type { IrSchemaToAstOptions } from '../../shared/types';
5
5
import { identifiers } from '../constants';
6
6
7
-
export const neverToAst = ({
7
+
export function neverToAst({
8
8
plugin,
9
9
}: IrSchemaToAstOptions & {
10
10
schema: SchemaWithType<'never'>;
11
-
}) => {
11
+
}) {
12
12
const v = plugin.external('valibot.v');
13
13
const expression = $(v).attr(identifiers.schemas.never).call();
14
14
return expression;
15
-
};
15
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/null.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/null.ts
···
4
4
import type { IrSchemaToAstOptions } from '../../shared/types';
5
5
import { identifiers } from '../constants';
6
6
7
-
export const nullToAst = ({
7
+
export function nullToAst({
8
8
plugin,
9
9
}: IrSchemaToAstOptions & {
10
10
schema: SchemaWithType<'null'>;
11
-
}) => {
11
+
}) {
12
12
const v = plugin.external('valibot.v');
13
13
const expression = $(v).attr(identifiers.schemas.null).call();
14
14
return expression;
15
-
};
15
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/number.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/number.ts
···
105
105
return ctx.pipes.current;
106
106
}
107
107
108
-
export const numberToNode = ({
108
+
export function numberToNode({
109
109
plugin,
110
110
schema,
111
111
}: IrSchemaToAstOptions & {
112
112
schema: SchemaWithType<'integer' | 'number'>;
113
-
}): Pipe => {
113
+
}): Pipe {
114
114
const ctx: NumberResolverContext = {
115
115
$,
116
116
nodes: {
···
137
137
const resolver = plugin.config['~resolvers']?.number;
138
138
const node = resolver?.(ctx) ?? numberResolver(ctx);
139
139
return ctx.pipes.toNode(node, plugin);
140
-
};
140
+
}
+11
-13
packages/openapi-ts/src/plugins/valibot/v1/toAst/object.ts
+11
-13
packages/openapi-ts/src/plugins/valibot/v1/toAst/object.ts
···
16
16
if (schema.additionalProperties.type === 'never') return null;
17
17
18
18
const additionalAst = irSchemaToAst({
19
-
plugin,
19
+
...ctx,
20
20
schema: schema.additionalProperties,
21
21
state: {
22
22
...ctx.utils.state,
···
64
64
const property = schema.properties[name]!;
65
65
66
66
const propertyAst = irSchemaToAst({
67
+
...ctx,
67
68
optional: !schema.required?.includes(name),
68
-
plugin,
69
69
schema: property,
70
70
state: {
71
71
...ctx.utils.state,
···
79
79
return shape;
80
80
}
81
81
82
-
export const objectToAst = ({
83
-
plugin,
84
-
schema,
85
-
state,
86
-
}: IrSchemaToAstOptions & {
87
-
schema: SchemaWithType<'object'>;
88
-
}): Omit<Ast, 'typeName'> => {
82
+
export function objectToAst(
83
+
options: IrSchemaToAstOptions & {
84
+
schema: SchemaWithType<'object'>;
85
+
},
86
+
): Omit<Ast, 'typeName'> {
87
+
const { plugin } = options;
89
88
const ctx: ObjectResolverContext = {
89
+
...options,
90
90
$,
91
91
nodes: {
92
92
additionalProperties: additionalPropertiesNode,
···
97
97
...pipes,
98
98
current: [],
99
99
},
100
-
plugin,
101
-
schema,
102
100
symbols: {
103
101
v: plugin.external('valibot.v'),
104
102
},
105
103
utils: {
106
104
ast: {},
107
-
state,
105
+
state: options.state,
108
106
},
109
107
};
110
108
const resolver = plugin.config['~resolvers']?.object;
111
109
const node = resolver?.(ctx) ?? objectResolver(ctx);
112
110
ctx.utils.ast.pipes = [ctx.pipes.toNode(node, plugin)];
113
111
return ctx.utils.ast as Omit<Ast, 'typeName'>;
114
-
};
112
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/string.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/string.ts
···
98
98
return ctx.pipes.current;
99
99
}
100
100
101
-
export const stringToNode = ({
101
+
export function stringToNode({
102
102
plugin,
103
103
schema,
104
104
}: IrSchemaToAstOptions & {
105
105
schema: SchemaWithType<'string'>;
106
-
}): Pipe => {
106
+
}): Pipe {
107
107
const ctx: StringResolverContext = {
108
108
$,
109
109
nodes: {
···
128
128
const resolver = plugin.config['~resolvers']?.string;
129
129
const node = resolver?.(ctx) ?? stringResolver(ctx);
130
130
return ctx.pipes.toNode(node, plugin);
131
-
};
131
+
}
+12
-13
packages/openapi-ts/src/plugins/valibot/v1/toAst/tuple.ts
+12
-13
packages/openapi-ts/src/plugins/valibot/v1/toAst/tuple.ts
···
8
8
import { irSchemaToAst } from '../plugin';
9
9
import { unknownToAst } from './unknown';
10
10
11
-
export const tupleToAst = ({
12
-
plugin,
13
-
schema,
14
-
state,
15
-
}: IrSchemaToAstOptions & {
16
-
schema: SchemaWithType<'tuple'>;
17
-
}): Omit<Ast, 'typeName'> => {
11
+
export function tupleToAst(
12
+
options: IrSchemaToAstOptions & {
13
+
schema: SchemaWithType<'tuple'>;
14
+
},
15
+
): Omit<Ast, 'typeName'> {
16
+
const { plugin, schema } = options;
17
+
18
18
const result: Partial<Omit<Ast, 'typeName'>> = {};
19
19
20
20
const v = plugin.external('valibot.v');
···
34
34
if (schema.items) {
35
35
const tupleElements = schema.items.map((item, index) => {
36
36
const schemaPipes = irSchemaToAst({
37
-
plugin,
37
+
...options,
38
38
schema: item,
39
39
state: {
40
-
...state,
41
-
path: ref([...fromRef(state.path), 'items', index]),
40
+
...options.state,
41
+
path: ref([...fromRef(options.state.path), 'items', index]),
42
42
},
43
43
});
44
44
if (schemaPipes.hasLazyExpression) {
···
57
57
return {
58
58
pipes: [
59
59
unknownToAst({
60
-
plugin,
60
+
...options,
61
61
schema: {
62
62
type: 'unknown',
63
63
},
64
-
state,
65
64
}),
66
65
],
67
66
};
68
-
};
67
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/undefined.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/undefined.ts
···
4
4
import type { IrSchemaToAstOptions } from '../../shared/types';
5
5
import { identifiers } from '../constants';
6
6
7
-
export const undefinedToAst = ({
7
+
export function undefinedToAst({
8
8
plugin,
9
9
}: IrSchemaToAstOptions & {
10
10
schema: SchemaWithType<'undefined'>;
11
-
}) => {
11
+
}) {
12
12
const v = plugin.external('valibot.v');
13
13
const expression = $(v).attr(identifiers.schemas.undefined).call();
14
14
return expression;
15
-
};
15
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/unknown.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/unknown.ts
···
4
4
import type { IrSchemaToAstOptions } from '../../shared/types';
5
5
import { identifiers } from '../constants';
6
6
7
-
export const unknownToAst = ({
7
+
export function unknownToAst({
8
8
plugin,
9
9
}: IrSchemaToAstOptions & {
10
10
schema: SchemaWithType<'unknown'>;
11
-
}) => {
11
+
}) {
12
12
const v = plugin.external('valibot.v');
13
13
const expression = $(v).attr(identifiers.schemas.unknown).call();
14
14
return expression;
15
-
};
15
+
}
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/void.ts
+3
-3
packages/openapi-ts/src/plugins/valibot/v1/toAst/void.ts
···
4
4
import type { IrSchemaToAstOptions } from '../../shared/types';
5
5
import { identifiers } from '../constants';
6
6
7
-
export const voidToAst = ({
7
+
export function voidToAst({
8
8
plugin,
9
9
}: IrSchemaToAstOptions & {
10
10
schema: SchemaWithType<'void'>;
11
-
}) => {
11
+
}) {
12
12
const v = plugin.external('valibot.v');
13
13
const expression = $(v).attr(identifiers.schemas.void).call();
14
14
return expression;
15
-
};
15
+
}
+51
-75
packages/openapi-ts/src/plugins/zod/mini/plugin.ts
+51
-75
packages/openapi-ts/src/plugins/zod/mini/plugin.ts
···
1
1
import type { SymbolMeta } from '@hey-api/codegen-core';
2
-
import { fromRef, ref, refs } from '@hey-api/codegen-core';
2
+
import { fromRef, ref } from '@hey-api/codegen-core';
3
3
import type { IR, SchemaWithType } from '@hey-api/shared';
4
-
import { applyNaming, deduplicateSchema, pathToJsonPointer, refToName } from '@hey-api/shared';
4
+
import { deduplicateSchema, pathToJsonPointer } from '@hey-api/shared';
5
5
6
6
import { maybeBigInt } from '../../../plugins/shared/utils/coerce';
7
7
import { $ } from '../../../ts-dsl';
8
8
import { identifiers } from '../constants';
9
-
import { exportAst } from '../shared/export';
10
9
import { getZodModule } from '../shared/module';
11
10
import { irOperationToAst } from '../shared/operation';
12
-
import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types';
11
+
import type { Ast, IrSchemaToAstOptions } from '../shared/types';
13
12
import { irWebhookToAst } from '../shared/webhook';
14
13
import type { ZodPlugin } from '../types';
14
+
import { createProcessor } from './processor';
15
15
import { irSchemaWithTypeToAst } from './toAst';
16
16
17
17
export function irSchemaToAst({
18
18
optional,
19
19
plugin,
20
20
schema,
21
+
schemaExtractor,
21
22
state,
22
23
}: IrSchemaToAstOptions & {
23
24
/**
···
28
29
optional?: boolean;
29
30
schema: IR.SchemaObject;
30
31
}): Ast {
32
+
if (schemaExtractor && !schema.$ref) {
33
+
const extracted = schemaExtractor({
34
+
meta: {
35
+
resource: 'definition',
36
+
resourceId: pathToJsonPointer(fromRef(state.path)),
37
+
},
38
+
naming: plugin.config.definitions,
39
+
path: fromRef(state.path),
40
+
plugin,
41
+
schema,
42
+
});
43
+
if (extracted !== schema) schema = extracted;
44
+
}
45
+
31
46
let ast: Partial<Ast> = {};
32
47
33
48
const z = plugin.external('zod.z');
···
155
170
return ast as Ast;
156
171
}
157
172
158
-
function handleComponent({
159
-
plugin,
160
-
schema,
161
-
state,
162
-
}: IrSchemaToAstOptions & {
163
-
schema: IR.SchemaObject;
164
-
}): void {
165
-
const $ref = pathToJsonPointer(fromRef(state.path));
166
-
const ast = irSchemaToAst({ plugin, schema, state });
167
-
const baseName = refToName($ref);
168
-
const symbol = plugin.symbol(applyNaming(baseName, plugin.config.definitions), {
169
-
meta: {
170
-
category: 'schema',
171
-
path: fromRef(state.path),
172
-
resource: 'definition',
173
-
resourceId: $ref,
174
-
tags: fromRef(state.tags),
175
-
tool: 'zod',
176
-
},
177
-
});
178
-
const typeInferSymbol = plugin.config.definitions.types.infer.enabled
179
-
? plugin.symbol(applyNaming(baseName, plugin.config.definitions.types.infer), {
180
-
meta: {
181
-
category: 'type',
182
-
path: fromRef(state.path),
183
-
resource: 'definition',
184
-
resourceId: $ref,
185
-
tags: fromRef(state.tags),
186
-
tool: 'zod',
187
-
variant: 'infer',
188
-
},
189
-
})
190
-
: undefined;
191
-
exportAst({
192
-
ast,
193
-
plugin,
194
-
schema,
195
-
symbol,
196
-
typeInferSymbol,
197
-
});
198
-
}
199
-
200
173
export const handlerMini: ZodPlugin['Handler'] = ({ plugin }) => {
201
174
plugin.symbol('z', {
202
175
external: getZodModule({ plugin }),
···
207
180
},
208
181
});
209
182
183
+
const processor = createProcessor(plugin);
184
+
210
185
plugin.forEach('operation', 'parameter', 'requestBody', 'schema', 'webhook', (event) => {
211
-
const state = refs<PluginState>({
212
-
hasLazyExpression: false,
213
-
path: event._path,
214
-
tags: event.tags,
215
-
});
216
186
switch (event.type) {
217
187
case 'operation':
218
188
irOperationToAst({
219
-
getAst: (schema, path) => {
220
-
const state = refs<PluginState>({
221
-
hasLazyExpression: false,
222
-
path,
223
-
tags: event.tags,
224
-
});
225
-
return irSchemaToAst({ plugin, schema, state });
226
-
},
227
189
operation: event.operation,
190
+
path: event._path,
228
191
plugin,
229
-
state,
192
+
processor,
193
+
tags: event.tags,
230
194
});
231
195
break;
232
196
case 'parameter':
233
-
handleComponent({
197
+
processor.process({
198
+
meta: {
199
+
resource: 'definition',
200
+
resourceId: pathToJsonPointer(event._path),
201
+
},
202
+
naming: plugin.config.definitions,
203
+
path: event._path,
234
204
plugin,
235
205
schema: event.parameter.schema,
236
-
state,
206
+
tags: event.tags,
237
207
});
238
208
break;
239
209
case 'requestBody':
240
-
handleComponent({
210
+
processor.process({
211
+
meta: {
212
+
resource: 'definition',
213
+
resourceId: pathToJsonPointer(event._path),
214
+
},
215
+
naming: plugin.config.definitions,
216
+
path: event._path,
241
217
plugin,
242
218
schema: event.requestBody.schema,
243
-
state,
219
+
tags: event.tags,
244
220
});
245
221
break;
246
222
case 'schema':
247
-
handleComponent({
223
+
processor.process({
224
+
meta: {
225
+
resource: 'definition',
226
+
resourceId: pathToJsonPointer(event._path),
227
+
},
228
+
naming: plugin.config.definitions,
229
+
path: event._path,
248
230
plugin,
249
231
schema: event.schema,
250
-
state,
232
+
tags: event.tags,
251
233
});
252
234
break;
253
235
case 'webhook':
254
236
irWebhookToAst({
255
-
getAst: (schema, path) => {
256
-
const state = refs<PluginState>({
257
-
hasLazyExpression: false,
258
-
path,
259
-
tags: event.tags,
260
-
});
261
-
return irSchemaToAst({ plugin, schema, state });
262
-
},
263
237
operation: event.operation,
238
+
path: event._path,
264
239
plugin,
265
-
state,
240
+
processor,
241
+
tags: event.tags,
266
242
});
267
243
break;
268
244
}
+58
packages/openapi-ts/src/plugins/zod/mini/processor.ts
+58
packages/openapi-ts/src/plugins/zod/mini/processor.ts
···
1
+
import { refs } from '@hey-api/codegen-core';
2
+
import type { IR } from '@hey-api/shared';
3
+
import { createSchemaProcessor, pathToJsonPointer } from '@hey-api/shared';
4
+
5
+
import { exportAst } from '../shared/export';
6
+
import type { ProcessorContext, ProcessorResult } from '../shared/processor';
7
+
import type { PluginState } from '../shared/types';
8
+
import type { ZodPlugin } from '../types';
9
+
import { irSchemaToAst } from './plugin';
10
+
11
+
export function createProcessor(plugin: ZodPlugin['Instance']): ProcessorResult {
12
+
const processor = createSchemaProcessor();
13
+
14
+
const hooks = [plugin.config['~hooks']?.schemas, plugin.context.config.parser.hooks.schemas];
15
+
16
+
function extractor(ctx: ProcessorContext): IR.SchemaObject {
17
+
if (processor.hasEmitted(ctx.path)) {
18
+
return ctx.schema;
19
+
}
20
+
21
+
for (const hook of hooks) {
22
+
const result = hook?.shouldExtract?.(ctx);
23
+
if (result) {
24
+
process({
25
+
namingAnchor: processor.context.anchor,
26
+
tags: processor.context.tags,
27
+
...ctx,
28
+
});
29
+
return { $ref: pathToJsonPointer(ctx.path) };
30
+
}
31
+
}
32
+
33
+
return ctx.schema;
34
+
}
35
+
36
+
function process(ctx: ProcessorContext): void {
37
+
if (!processor.markEmitted(ctx.path)) return;
38
+
39
+
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
40
+
const state = refs<PluginState>({
41
+
hasLazyExpression: false,
42
+
path: ctx.path,
43
+
tags: ctx.tags,
44
+
});
45
+
46
+
const ast = irSchemaToAst({
47
+
plugin,
48
+
schema: ctx.schema,
49
+
schemaExtractor: extractor,
50
+
state,
51
+
});
52
+
53
+
exportAst({ ...ctx, ast, plugin, state });
54
+
});
55
+
}
56
+
57
+
return { process };
58
+
}
+5
-32
packages/openapi-ts/src/plugins/zod/types.ts
+5
-32
packages/openapi-ts/src/plugins/zod/types.ts
···
9
9
10
10
import type { IApi } from './api';
11
11
import type { Resolvers } from './resolvers';
12
+
import type { TypeOptions } from './shared/types';
12
13
13
14
export type UserConfig = Plugin.Name<'zod'> &
14
15
Plugin.Hooks &
···
422
423
offset: boolean;
423
424
};
424
425
/** Configuration for reusable schema definitions. */
425
-
definitions: NamingOptions &
426
-
FeatureToggle & {
427
-
/** Configuration for TypeScript type generation from Zod schemas. */
428
-
types: {
429
-
/** Configuration for `infer` types. */
430
-
infer: NamingOptions & FeatureToggle;
431
-
};
432
-
};
426
+
definitions: NamingOptions & FeatureToggle & TypeOptions;
433
427
/** Enable Zod metadata support? */
434
428
metadata: boolean;
435
429
/** Configuration for request-specific Zod schemas. */
436
-
requests: NamingOptions &
437
-
FeatureToggle & {
438
-
/** Configuration for TypeScript type generation from Zod schemas. */
439
-
types: {
440
-
/** Configuration for `infer` types. */
441
-
infer: NamingOptions & FeatureToggle;
442
-
};
443
-
};
430
+
requests: NamingOptions & FeatureToggle & TypeOptions;
444
431
/** Configuration for response-specific Zod schemas. */
445
-
responses: NamingOptions &
446
-
FeatureToggle & {
447
-
/** Configuration for TypeScript type generation from Zod schemas. */
448
-
types: {
449
-
/** Configuration for `infer` types. */
450
-
infer: NamingOptions & FeatureToggle;
451
-
};
452
-
};
432
+
responses: NamingOptions & FeatureToggle & TypeOptions;
453
433
/** Configuration for TypeScript type generation from Zod schemas. */
454
434
types: {
455
435
/** Configuration for `infer` types. */
···
459
439
};
460
440
};
461
441
/** Configuration for webhook-specific Zod schemas. */
462
-
webhooks: NamingOptions &
463
-
FeatureToggle & {
464
-
/** Configuration for TypeScript type generation from Zod schemas. */
465
-
types: {
466
-
/** Configuration for `infer` types. */
467
-
infer: NamingOptions & FeatureToggle;
468
-
};
469
-
};
442
+
webhooks: NamingOptions & FeatureToggle & TypeOptions;
470
443
};
471
444
472
445
export type ZodPlugin = DefinePlugin<UserConfig, Config, IApi>;
+51
-75
packages/openapi-ts/src/plugins/zod/v3/plugin.ts
+51
-75
packages/openapi-ts/src/plugins/zod/v3/plugin.ts
···
1
1
import type { SymbolMeta } from '@hey-api/codegen-core';
2
-
import { fromRef, ref, refs } from '@hey-api/codegen-core';
2
+
import { fromRef, ref } from '@hey-api/codegen-core';
3
3
import type { IR, SchemaWithType } from '@hey-api/shared';
4
-
import { applyNaming, deduplicateSchema, pathToJsonPointer, refToName } from '@hey-api/shared';
4
+
import { deduplicateSchema, pathToJsonPointer } from '@hey-api/shared';
5
5
6
6
import { maybeBigInt } from '../../../plugins/shared/utils/coerce';
7
7
import { $ } from '../../../ts-dsl';
8
8
import { identifiers } from '../constants';
9
-
import { exportAst } from '../shared/export';
10
9
import { getZodModule } from '../shared/module';
11
10
import { irOperationToAst } from '../shared/operation';
12
-
import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types';
11
+
import type { Ast, IrSchemaToAstOptions } from '../shared/types';
13
12
import { irWebhookToAst } from '../shared/webhook';
14
13
import type { ZodPlugin } from '../types';
14
+
import { createProcessor } from './processor';
15
15
import { irSchemaWithTypeToAst } from './toAst';
16
16
17
17
export function irSchemaToAst({
18
18
optional,
19
19
plugin,
20
20
schema,
21
+
schemaExtractor,
21
22
state,
22
23
}: IrSchemaToAstOptions & {
23
24
/**
···
28
29
optional?: boolean;
29
30
schema: IR.SchemaObject;
30
31
}): Ast {
32
+
if (schemaExtractor && !schema.$ref) {
33
+
const extracted = schemaExtractor({
34
+
meta: {
35
+
resource: 'definition',
36
+
resourceId: pathToJsonPointer(fromRef(state.path)),
37
+
},
38
+
naming: plugin.config.definitions,
39
+
path: fromRef(state.path),
40
+
plugin,
41
+
schema,
42
+
});
43
+
if (extracted !== schema) schema = extracted;
44
+
}
45
+
31
46
let ast: Partial<Ast> = {};
32
47
33
48
const z = plugin.external('zod.z');
···
153
168
return ast as Ast;
154
169
}
155
170
156
-
function handleComponent({
157
-
plugin,
158
-
schema,
159
-
state,
160
-
}: IrSchemaToAstOptions & {
161
-
schema: IR.SchemaObject;
162
-
}): void {
163
-
const $ref = pathToJsonPointer(fromRef(state.path));
164
-
const ast = irSchemaToAst({ plugin, schema, state });
165
-
const baseName = refToName($ref);
166
-
const symbol = plugin.symbol(applyNaming(baseName, plugin.config.definitions), {
167
-
meta: {
168
-
category: 'schema',
169
-
path: fromRef(state.path),
170
-
resource: 'definition',
171
-
resourceId: $ref,
172
-
tags: fromRef(state.tags),
173
-
tool: 'zod',
174
-
},
175
-
});
176
-
const typeInferSymbol = plugin.config.definitions.types.infer.enabled
177
-
? plugin.symbol(applyNaming(baseName, plugin.config.definitions.types.infer), {
178
-
meta: {
179
-
category: 'type',
180
-
path: fromRef(state.path),
181
-
resource: 'definition',
182
-
resourceId: $ref,
183
-
tags: fromRef(state.tags),
184
-
tool: 'zod',
185
-
variant: 'infer',
186
-
},
187
-
})
188
-
: undefined;
189
-
exportAst({
190
-
ast,
191
-
plugin,
192
-
schema,
193
-
symbol,
194
-
typeInferSymbol,
195
-
});
196
-
}
197
-
198
171
export const handlerV3: ZodPlugin['Handler'] = ({ plugin }) => {
199
172
plugin.symbol('z', {
200
173
external: getZodModule({ plugin }),
···
204
177
},
205
178
});
206
179
180
+
const processor = createProcessor(plugin);
181
+
207
182
plugin.forEach('operation', 'parameter', 'requestBody', 'schema', 'webhook', (event) => {
208
-
const state = refs<PluginState>({
209
-
hasLazyExpression: false,
210
-
path: event._path,
211
-
tags: event.tags,
212
-
});
213
183
switch (event.type) {
214
184
case 'operation':
215
185
irOperationToAst({
216
-
getAst: (schema, path) => {
217
-
const state = refs<PluginState>({
218
-
hasLazyExpression: false,
219
-
path,
220
-
tags: event.tags,
221
-
});
222
-
return irSchemaToAst({ plugin, schema, state });
223
-
},
224
186
operation: event.operation,
187
+
path: event._path,
225
188
plugin,
226
-
state,
189
+
processor,
190
+
tags: event.tags,
227
191
});
228
192
break;
229
193
case 'parameter':
230
-
handleComponent({
194
+
processor.process({
195
+
meta: {
196
+
resource: 'definition',
197
+
resourceId: pathToJsonPointer(event._path),
198
+
},
199
+
naming: plugin.config.definitions,
200
+
path: event._path,
231
201
plugin,
232
202
schema: event.parameter.schema,
233
-
state,
203
+
tags: event.tags,
234
204
});
235
205
break;
236
206
case 'requestBody':
237
-
handleComponent({
207
+
processor.process({
208
+
meta: {
209
+
resource: 'definition',
210
+
resourceId: pathToJsonPointer(event._path),
211
+
},
212
+
naming: plugin.config.definitions,
213
+
path: event._path,
238
214
plugin,
239
215
schema: event.requestBody.schema,
240
-
state,
216
+
tags: event.tags,
241
217
});
242
218
break;
243
219
case 'schema':
244
-
handleComponent({
220
+
processor.process({
221
+
meta: {
222
+
resource: 'definition',
223
+
resourceId: pathToJsonPointer(event._path),
224
+
},
225
+
naming: plugin.config.definitions,
226
+
path: event._path,
245
227
plugin,
246
228
schema: event.schema,
247
-
state,
229
+
tags: event.tags,
248
230
});
249
231
break;
250
232
case 'webhook':
251
233
irWebhookToAst({
252
-
getAst: (schema, path) => {
253
-
const state = refs<PluginState>({
254
-
hasLazyExpression: false,
255
-
path,
256
-
tags: event.tags,
257
-
});
258
-
return irSchemaToAst({ plugin, schema, state });
259
-
},
260
234
operation: event.operation,
235
+
path: event._path,
261
236
plugin,
262
-
state,
237
+
processor,
238
+
tags: event.tags,
263
239
});
264
240
break;
265
241
}
+58
packages/openapi-ts/src/plugins/zod/v3/processor.ts
+58
packages/openapi-ts/src/plugins/zod/v3/processor.ts
···
1
+
import { refs } from '@hey-api/codegen-core';
2
+
import type { IR } from '@hey-api/shared';
3
+
import { createSchemaProcessor, pathToJsonPointer } from '@hey-api/shared';
4
+
5
+
import { exportAst } from '../shared/export';
6
+
import type { ProcessorContext, ProcessorResult } from '../shared/processor';
7
+
import type { PluginState } from '../shared/types';
8
+
import type { ZodPlugin } from '../types';
9
+
import { irSchemaToAst } from './plugin';
10
+
11
+
export function createProcessor(plugin: ZodPlugin['Instance']): ProcessorResult {
12
+
const processor = createSchemaProcessor();
13
+
14
+
const hooks = [plugin.config['~hooks']?.schemas, plugin.context.config.parser.hooks.schemas];
15
+
16
+
function extractor(ctx: ProcessorContext): IR.SchemaObject {
17
+
if (processor.hasEmitted(ctx.path)) {
18
+
return ctx.schema;
19
+
}
20
+
21
+
for (const hook of hooks) {
22
+
const result = hook?.shouldExtract?.(ctx);
23
+
if (result) {
24
+
process({
25
+
namingAnchor: processor.context.anchor,
26
+
tags: processor.context.tags,
27
+
...ctx,
28
+
});
29
+
return { $ref: pathToJsonPointer(ctx.path) };
30
+
}
31
+
}
32
+
33
+
return ctx.schema;
34
+
}
35
+
36
+
function process(ctx: ProcessorContext): void {
37
+
if (!processor.markEmitted(ctx.path)) return;
38
+
39
+
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
40
+
const state = refs<PluginState>({
41
+
hasLazyExpression: false,
42
+
path: ctx.path,
43
+
tags: ctx.tags,
44
+
});
45
+
46
+
const ast = irSchemaToAst({
47
+
plugin,
48
+
schema: ctx.schema,
49
+
schemaExtractor: extractor,
50
+
state,
51
+
});
52
+
53
+
exportAst({ ...ctx, ast, plugin, state });
54
+
});
55
+
}
56
+
57
+
return { process };
58
+
}
+51
-75
packages/openapi-ts/src/plugins/zod/v4/plugin.ts
+51
-75
packages/openapi-ts/src/plugins/zod/v4/plugin.ts
···
1
1
import type { SymbolMeta } from '@hey-api/codegen-core';
2
-
import { fromRef, ref, refs } from '@hey-api/codegen-core';
2
+
import { fromRef, ref } from '@hey-api/codegen-core';
3
3
import type { IR, SchemaWithType } from '@hey-api/shared';
4
-
import { applyNaming, deduplicateSchema, pathToJsonPointer, refToName } from '@hey-api/shared';
4
+
import { deduplicateSchema, pathToJsonPointer } from '@hey-api/shared';
5
5
6
6
import { maybeBigInt } from '../../../plugins/shared/utils/coerce';
7
7
import { $ } from '../../../ts-dsl';
8
8
import { identifiers } from '../constants';
9
-
import { exportAst } from '../shared/export';
10
9
import { getZodModule } from '../shared/module';
11
10
import { irOperationToAst } from '../shared/operation';
12
-
import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types';
11
+
import type { Ast, IrSchemaToAstOptions } from '../shared/types';
13
12
import { irWebhookToAst } from '../shared/webhook';
14
13
import type { ZodPlugin } from '../types';
14
+
import { createProcessor } from './processor';
15
15
import { irSchemaWithTypeToAst } from './toAst';
16
16
17
17
export function irSchemaToAst({
18
18
optional,
19
19
plugin,
20
20
schema,
21
+
schemaExtractor,
21
22
state,
22
23
}: IrSchemaToAstOptions & {
23
24
/**
···
28
29
optional?: boolean;
29
30
schema: IR.SchemaObject;
30
31
}): Ast {
32
+
if (schemaExtractor && !schema.$ref) {
33
+
const extracted = schemaExtractor({
34
+
meta: {
35
+
resource: 'definition',
36
+
resourceId: pathToJsonPointer(fromRef(state.path)),
37
+
},
38
+
naming: plugin.config.definitions,
39
+
path: fromRef(state.path),
40
+
plugin,
41
+
schema,
42
+
});
43
+
if (extracted !== schema) schema = extracted;
44
+
}
45
+
31
46
let ast: Partial<Ast> = {};
32
47
33
48
const z = plugin.external('zod.z');
···
157
172
return ast as Ast;
158
173
}
159
174
160
-
function handleComponent({
161
-
plugin,
162
-
schema,
163
-
state,
164
-
}: IrSchemaToAstOptions & {
165
-
schema: IR.SchemaObject;
166
-
}): void {
167
-
const $ref = pathToJsonPointer(fromRef(state.path));
168
-
const ast = irSchemaToAst({ plugin, schema, state });
169
-
const baseName = refToName($ref);
170
-
const symbol = plugin.symbol(applyNaming(baseName, plugin.config.definitions), {
171
-
meta: {
172
-
category: 'schema',
173
-
path: fromRef(state.path),
174
-
resource: 'definition',
175
-
resourceId: $ref,
176
-
tags: fromRef(state.tags),
177
-
tool: 'zod',
178
-
},
179
-
});
180
-
const typeInferSymbol = plugin.config.definitions.types.infer.enabled
181
-
? plugin.symbol(applyNaming(baseName, plugin.config.definitions.types.infer), {
182
-
meta: {
183
-
category: 'type',
184
-
path: fromRef(state.path),
185
-
resource: 'definition',
186
-
resourceId: $ref,
187
-
tags: fromRef(state.tags),
188
-
tool: 'zod',
189
-
variant: 'infer',
190
-
},
191
-
})
192
-
: undefined;
193
-
exportAst({
194
-
ast,
195
-
plugin,
196
-
schema,
197
-
symbol,
198
-
typeInferSymbol,
199
-
});
200
-
}
201
-
202
175
export const handlerV4: ZodPlugin['Handler'] = ({ plugin }) => {
203
176
plugin.symbol('z', {
204
177
external: getZodModule({ plugin }),
···
209
182
},
210
183
});
211
184
185
+
const processor = createProcessor(plugin);
186
+
212
187
plugin.forEach('operation', 'parameter', 'requestBody', 'schema', 'webhook', (event) => {
213
-
const state = refs<PluginState>({
214
-
hasLazyExpression: false,
215
-
path: event._path,
216
-
tags: event.tags,
217
-
});
218
188
switch (event.type) {
219
189
case 'operation':
220
190
irOperationToAst({
221
-
getAst: (schema, path) => {
222
-
const state = refs<PluginState>({
223
-
hasLazyExpression: false,
224
-
path,
225
-
tags: event.tags,
226
-
});
227
-
return irSchemaToAst({ plugin, schema, state });
228
-
},
229
191
operation: event.operation,
192
+
path: event._path,
230
193
plugin,
231
-
state,
194
+
processor,
195
+
tags: event.tags,
232
196
});
233
197
break;
234
198
case 'parameter':
235
-
handleComponent({
199
+
processor.process({
200
+
meta: {
201
+
resource: 'definition',
202
+
resourceId: pathToJsonPointer(event._path),
203
+
},
204
+
naming: plugin.config.definitions,
205
+
path: event._path,
236
206
plugin,
237
207
schema: event.parameter.schema,
238
-
state,
208
+
tags: event.tags,
239
209
});
240
210
break;
241
211
case 'requestBody':
242
-
handleComponent({
212
+
processor.process({
213
+
meta: {
214
+
resource: 'definition',
215
+
resourceId: pathToJsonPointer(event._path),
216
+
},
217
+
naming: plugin.config.definitions,
218
+
path: event._path,
243
219
plugin,
244
220
schema: event.requestBody.schema,
245
-
state,
221
+
tags: event.tags,
246
222
});
247
223
break;
248
224
case 'schema':
249
-
handleComponent({
225
+
processor.process({
226
+
meta: {
227
+
resource: 'definition',
228
+
resourceId: pathToJsonPointer(event._path),
229
+
},
230
+
naming: plugin.config.definitions,
231
+
path: event._path,
250
232
plugin,
251
233
schema: event.schema,
252
-
state,
234
+
tags: event.tags,
253
235
});
254
236
break;
255
237
case 'webhook':
256
238
irWebhookToAst({
257
-
getAst: (schema, path) => {
258
-
const state = refs<PluginState>({
259
-
hasLazyExpression: false,
260
-
path,
261
-
tags: event.tags,
262
-
});
263
-
return irSchemaToAst({ plugin, schema, state });
264
-
},
265
239
operation: event.operation,
240
+
path: event._path,
266
241
plugin,
267
-
state,
242
+
processor,
243
+
tags: event.tags,
268
244
});
269
245
break;
270
246
}
+58
packages/openapi-ts/src/plugins/zod/v4/processor.ts
+58
packages/openapi-ts/src/plugins/zod/v4/processor.ts
···
1
+
import { refs } from '@hey-api/codegen-core';
2
+
import type { IR } from '@hey-api/shared';
3
+
import { createSchemaProcessor, pathToJsonPointer } from '@hey-api/shared';
4
+
5
+
import { exportAst } from '../shared/export';
6
+
import type { ProcessorContext, ProcessorResult } from '../shared/processor';
7
+
import type { PluginState } from '../shared/types';
8
+
import type { ZodPlugin } from '../types';
9
+
import { irSchemaToAst } from './plugin';
10
+
11
+
export function createProcessor(plugin: ZodPlugin['Instance']): ProcessorResult {
12
+
const processor = createSchemaProcessor();
13
+
14
+
const hooks = [plugin.config['~hooks']?.schemas, plugin.context.config.parser.hooks.schemas];
15
+
16
+
function extractor(ctx: ProcessorContext): IR.SchemaObject {
17
+
if (processor.hasEmitted(ctx.path)) {
18
+
return ctx.schema;
19
+
}
20
+
21
+
for (const hook of hooks) {
22
+
const result = hook?.shouldExtract?.(ctx);
23
+
if (result) {
24
+
process({
25
+
namingAnchor: processor.context.anchor,
26
+
tags: processor.context.tags,
27
+
...ctx,
28
+
});
29
+
return { $ref: pathToJsonPointer(ctx.path) };
30
+
}
31
+
}
32
+
33
+
return ctx.schema;
34
+
}
35
+
36
+
function process(ctx: ProcessorContext): void {
37
+
if (!processor.markEmitted(ctx.path)) return;
38
+
39
+
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
40
+
const state = refs<PluginState>({
41
+
hasLazyExpression: false,
42
+
path: ctx.path,
43
+
tags: ctx.tags,
44
+
});
45
+
46
+
const ast = irSchemaToAst({
47
+
plugin,
48
+
schema: ctx.schema,
49
+
schemaExtractor: extractor,
50
+
state,
51
+
});
52
+
53
+
exportAst({ ...ctx, ast, plugin, state });
54
+
});
55
+
}
56
+
57
+
return { process };
58
+
}
+7
-1
turbo.json
+7
-1
turbo.json
···
3
3
"tasks": {
4
4
"build": {
5
5
"dependsOn": ["^build"],
6
-
"inputs": ["src/**", "package.json", "tsdown.config.ts", "tsconfig.json"],
6
+
"inputs": [
7
+
"src/**",
8
+
"!src/**/*.test.ts",
9
+
"package.json",
10
+
"tsconfig.json",
11
+
"tsdown.config.ts"
12
+
],
7
13
"outputs": [
8
14
".next/**",
9
15
"!.next/cache/**",