fork of hey-api/openapi-ts because I need some additional things
refactor: typescript plugin
+1029
-845
+4
-4
dev/typescript/presets.ts
+4
-4
dev/typescript/presets.ts
···
10
10
zod({ metadata: true }),
11
11
tanstackReactQuery({ queryKeys: { tags: true } }),
12
12
],
13
-
minimal: () => [
14
-
/** Just types, nothing else */
15
-
typescript(),
16
-
],
17
13
sdk: () => [
18
14
/** SDK with types */
19
15
typescript(),
···
30
26
typescript(),
31
27
sdk(),
32
28
tanstackReactQuery({ queryKeys: { tags: true } }),
29
+
],
30
+
types: () => [
31
+
/** Just types, nothing else */
32
+
typescript(),
33
33
],
34
34
validated: () => [
35
35
/** SDK + Zod validation */
+10
-3
packages/openapi-python/src/plugins/pydantic/v2/processor.ts
+10
-3
packages/openapi-python/src/plugins/pydantic/v2/processor.ts
···
42
42
return ctx.schema;
43
43
}
44
44
45
-
function process(ctx: ProcessorContext): void {
45
+
function process(ctx: ProcessorContext): PydanticFinal | void {
46
46
if (!processor.markEmitted(ctx.path)) return;
47
47
48
-
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
48
+
const shouldExport = ctx.export !== false;
49
+
50
+
return processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
49
51
const visitor = createVisitor({ schemaExtractor: extractor });
50
52
const walk = createSchemaWalker(visitor);
51
53
···
59
61
plugin,
60
62
}) as PydanticFinal;
61
63
62
-
exportAst({ ...ctx, final, plugin });
64
+
if (shouldExport) {
65
+
exportAst({ ...ctx, final, plugin });
66
+
return;
67
+
}
68
+
69
+
return final;
63
70
});
64
71
}
65
72
+31
-5
packages/openapi-ts/src/plugins/@hey-api/typescript/api.ts
+31
-5
packages/openapi-ts/src/plugins/@hey-api/typescript/api.ts
···
1
-
import type { MaybeTsDsl, TypeTsDsl } from '../../../ts-dsl';
2
-
import { irSchemaToAstV1 } from './v1/api';
1
+
import type { IR } from '@hey-api/shared';
2
+
3
+
import { $ } from '../../../ts-dsl';
4
+
import type { TypeScriptResult } from './shared/types';
5
+
import type { HeyApiTypeScriptPlugin } from './types';
6
+
import { createProcessor } from './v1/processor';
3
7
4
8
export type IApi = {
5
-
schemaToType: (args: Parameters<typeof irSchemaToAstV1>[0]) => MaybeTsDsl<TypeTsDsl>;
9
+
schemaToType: (
10
+
plugin: HeyApiTypeScriptPlugin['Instance'],
11
+
schema: IR.SchemaObject,
12
+
) => TypeScriptResult['type'];
6
13
};
7
14
8
15
export class Api implements IApi {
9
-
schemaToType(args: Parameters<typeof irSchemaToAstV1>[0]): MaybeTsDsl<TypeTsDsl> {
10
-
return irSchemaToAstV1(args);
16
+
schemaToType(
17
+
plugin: HeyApiTypeScriptPlugin['Instance'],
18
+
schema: IR.SchemaObject,
19
+
): TypeScriptResult['type'] {
20
+
const processor = createProcessor(plugin);
21
+
const result = processor.process({
22
+
export: false,
23
+
meta: {
24
+
resource: 'definition',
25
+
resourceId: '',
26
+
},
27
+
naming: plugin.config.definitions,
28
+
path: [],
29
+
plugin,
30
+
schema,
31
+
});
32
+
33
+
if (!result) {
34
+
return $.type(plugin.config.topType);
35
+
}
36
+
return result.type;
11
37
}
12
38
}
-1
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/api.ts
-1
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/api.ts
···
1
-
export { irSchemaToAst as irSchemaToAstV1 } from './plugin';
+33
-116
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/plugin.ts
+33
-116
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/plugin.ts
···
1
1
import type { Symbol } from '@hey-api/codegen-core';
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';
2
+
import type { IR } from '@hey-api/shared';
3
+
import { applyNaming, pathToJsonPointer } from '@hey-api/shared';
5
4
6
-
import type { MaybeTsDsl, TypeTsDsl } from '../../../../ts-dsl';
7
5
import { $ } from '../../../../ts-dsl';
8
6
import { createClientOptions } from '../shared/clientOptions';
9
-
import { exportType } from '../shared/export';
10
7
import { operationToType } from '../shared/operation';
11
-
import type { IrSchemaToAstOptions, PluginState } from '../shared/types';
12
8
import { webhookToType } from '../shared/webhook';
13
9
import type { HeyApiTypeScriptPlugin } from '../types';
14
-
import { irSchemaWithTypeToAst } from './toAst';
15
-
16
-
export function irSchemaToAst({
17
-
plugin,
18
-
schema,
19
-
schemaExtractor,
20
-
state,
21
-
}: IrSchemaToAstOptions & {
22
-
schema: IR.SchemaObject;
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
-
36
-
if (schema.symbolRef) {
37
-
const baseType = $.type(schema.symbolRef);
38
-
if (schema.omit && schema.omit.length > 0) {
39
-
// Render as Omit<Type, 'prop1' | 'prop2'>
40
-
const omittedKeys =
41
-
schema.omit.length === 1
42
-
? $.type.literal(schema.omit[0]!)
43
-
: $.type.or(...schema.omit.map((key) => $.type.literal(key)));
44
-
return $.type('Omit').generics(baseType, omittedKeys);
45
-
}
46
-
return baseType;
47
-
}
48
-
49
-
if (schema.$ref) {
50
-
const symbol = plugin.referenceSymbol({
51
-
category: 'type',
52
-
resource: 'definition',
53
-
resourceId: schema.$ref,
54
-
});
55
-
const baseType = $.type(symbol);
56
-
if (schema.omit && schema.omit.length > 0) {
57
-
// Render as Omit<Type, 'prop1' | 'prop2'>
58
-
const omittedKeys =
59
-
schema.omit.length === 1
60
-
? $.type.literal(schema.omit[0]!)
61
-
: $.type.or(...schema.omit.map((key) => $.type.literal(key)));
62
-
return $.type('Omit').generics(baseType, omittedKeys);
63
-
}
64
-
return baseType;
65
-
}
66
-
67
-
if (schema.type) {
68
-
return irSchemaWithTypeToAst({
69
-
plugin,
70
-
schema: schema as SchemaWithType,
71
-
state,
72
-
});
73
-
}
74
-
75
-
if (schema.items) {
76
-
schema = deduplicateSchema({ detectFormat: false, schema });
77
-
if (schema.items) {
78
-
const itemTypes = schema.items.map((item) => irSchemaToAst({ plugin, schema: item, state }));
79
-
return schema.logicalOperator === 'and' ? $.type.and(...itemTypes) : $.type.or(...itemTypes);
80
-
}
81
-
82
-
return irSchemaToAst({ plugin, schema, state });
83
-
}
84
-
85
-
// catch-all fallback for failed schemas
86
-
return irSchemaWithTypeToAst({
87
-
plugin,
88
-
schema: {
89
-
type: 'unknown',
90
-
},
91
-
state,
92
-
});
93
-
}
94
-
95
-
function handleComponent({
96
-
plugin,
97
-
schema,
98
-
state,
99
-
}: IrSchemaToAstOptions & {
100
-
schema: IR.SchemaObject;
101
-
}) {
102
-
const type = irSchemaToAst({ plugin, schema, state });
103
-
exportType({
104
-
plugin,
105
-
schema,
106
-
state,
107
-
type,
108
-
});
109
-
}
10
+
import { createProcessor } from './processor';
110
11
111
12
export const handlerV1: HeyApiTypeScriptPlugin['Handler'] = ({ plugin }) => {
112
-
// reserve node for ClientOptions
113
13
const nodeClientIndex = plugin.node(null);
114
-
// reserve node for Webhooks
115
14
const nodeWebhooksIndex = plugin.node(null);
116
15
117
16
const servers: Array<IR.ServerObject> = [];
118
17
const webhooks: Array<Symbol> = [];
119
18
19
+
const processor = createProcessor(plugin);
20
+
120
21
plugin.forEach(
121
22
'operation',
122
23
'parameter',
···
125
26
'server',
126
27
'webhook',
127
28
(event) => {
128
-
const state = refs<PluginState>({
129
-
path: event._path,
130
-
tags: event.tags,
131
-
});
132
29
switch (event.type) {
133
30
case 'operation':
134
31
operationToType({
135
32
operation: event.operation,
33
+
path: event._path,
136
34
plugin,
137
-
state,
35
+
tags: event.tags,
138
36
});
139
37
break;
140
38
case 'parameter':
141
-
handleComponent({
39
+
processor.process({
40
+
meta: {
41
+
resource: 'definition',
42
+
resourceId: pathToJsonPointer(event._path),
43
+
},
44
+
naming: plugin.config.definitions,
45
+
path: event._path,
142
46
plugin,
143
47
schema: event.parameter.schema,
144
-
state,
48
+
tags: event.tags,
145
49
});
146
50
break;
147
51
case 'requestBody':
148
-
handleComponent({
52
+
processor.process({
53
+
meta: {
54
+
resource: 'definition',
55
+
resourceId: pathToJsonPointer(event._path),
56
+
},
57
+
naming: plugin.config.definitions,
58
+
path: event._path,
149
59
plugin,
150
60
schema: event.requestBody.schema,
151
-
state,
61
+
tags: event.tags,
152
62
});
153
63
break;
154
64
case 'schema':
155
-
handleComponent({
65
+
processor.process({
66
+
meta: {
67
+
resource: 'definition',
68
+
resourceId: pathToJsonPointer(event._path),
69
+
},
70
+
naming: plugin.config.definitions,
71
+
path: event._path,
156
72
plugin,
157
73
schema: event.schema,
158
-
state,
74
+
tags: event.tags,
159
75
});
160
76
break;
161
77
case 'server':
···
165
81
webhooks.push(
166
82
webhookToType({
167
83
operation: event.operation,
84
+
path: event._path,
168
85
plugin,
169
-
state,
86
+
tags: event.tags,
170
87
}),
171
88
);
172
89
break;
+68
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/processor.ts
+68
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/processor.ts
···
1
+
import { ref } from '@hey-api/codegen-core';
2
+
import type { Hooks, IR } from '@hey-api/shared';
3
+
import { createSchemaProcessor, createSchemaWalker, pathToJsonPointer } from '@hey-api/shared';
4
+
5
+
import { exportAst } from '../shared/export';
6
+
import type { ProcessorContext, ProcessorResult } from '../shared/processor';
7
+
import type { TypeScriptFinal } from '../shared/types';
8
+
import type { HeyApiTypeScriptPlugin } from '../types';
9
+
import { createVisitor } from './walker';
10
+
11
+
export function createProcessor(plugin: HeyApiTypeScriptPlugin['Instance']): ProcessorResult {
12
+
const processor = createSchemaProcessor();
13
+
14
+
const extractorHooks: ReadonlyArray<NonNullable<Hooks['schemas']>['shouldExtract']> = [
15
+
plugin.config['~hooks']?.schemas?.shouldExtract,
16
+
plugin.context.config.parser.hooks.schemas?.shouldExtract,
17
+
];
18
+
19
+
function extractor(ctx: ProcessorContext): IR.SchemaObject {
20
+
if (processor.hasEmitted(ctx.path)) {
21
+
return ctx.schema;
22
+
}
23
+
24
+
for (const hook of extractorHooks) {
25
+
const result = hook?.(ctx);
26
+
if (result) {
27
+
process({
28
+
namingAnchor: processor.context.anchor,
29
+
tags: processor.context.tags,
30
+
...ctx,
31
+
});
32
+
return { $ref: pathToJsonPointer(ctx.path) };
33
+
}
34
+
}
35
+
36
+
return ctx.schema;
37
+
}
38
+
39
+
function process(ctx: ProcessorContext): TypeScriptFinal | void {
40
+
if (!processor.markEmitted(ctx.path)) return;
41
+
42
+
const shouldExport = ctx.export !== false;
43
+
44
+
return processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
45
+
const visitor = createVisitor({ schemaExtractor: extractor });
46
+
const walk = createSchemaWalker(visitor);
47
+
48
+
const result = walk(ctx.schema, {
49
+
path: ref(ctx.path),
50
+
plugin,
51
+
});
52
+
53
+
const final = visitor.applyModifiers(result, {
54
+
path: ref(ctx.path),
55
+
plugin,
56
+
}) as TypeScriptFinal;
57
+
58
+
if (shouldExport) {
59
+
exportAst({ ...ctx, final, plugin });
60
+
return;
61
+
}
62
+
63
+
return final;
64
+
});
65
+
}
66
+
67
+
return { process };
68
+
}
+23
-28
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/array.ts
+23
-28
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/array.ts
···
1
-
import { fromRef, ref } from '@hey-api/codegen-core';
1
+
import { ref } from '@hey-api/codegen-core';
2
2
import type { SchemaWithType } from '@hey-api/shared';
3
+
import type { Walker } from '@hey-api/shared';
3
4
import { deduplicateSchema } from '@hey-api/shared';
4
5
5
-
import type { MaybeTsDsl, TypeTsDsl } from '../../../../../ts-dsl';
6
6
import { $ } from '../../../../../ts-dsl';
7
-
import type { IrSchemaToAstOptions } from '../../shared/types';
8
-
import { irSchemaToAst } from '../plugin';
7
+
import type { HeyApiTypeScriptPlugin } from '../../shared/types';
8
+
import type { TypeScriptResult } from '../../shared/types';
9
9
10
10
export function arrayToAst({
11
11
plugin,
12
12
schema,
13
-
state,
14
-
}: IrSchemaToAstOptions & {
13
+
walk,
14
+
}: {
15
+
plugin: HeyApiTypeScriptPlugin['Instance'];
15
16
schema: SchemaWithType<'array'>;
16
-
}): TypeTsDsl {
17
+
walk: Walker<TypeScriptResult, HeyApiTypeScriptPlugin['Instance']>;
18
+
}): TypeScriptResult['type'] {
17
19
if (!schema.items) {
18
20
return $.type('Array').generic($.type(plugin.config.topType));
19
21
}
20
22
21
-
schema = deduplicateSchema({ detectFormat: true, schema });
22
-
23
-
const itemTypes: Array<MaybeTsDsl<TypeTsDsl>> = [];
24
-
25
-
if (schema.items) {
26
-
schema.items.forEach((item, index) => {
27
-
const type = irSchemaToAst({
28
-
plugin,
29
-
schema: item,
30
-
state: {
31
-
...state,
32
-
path: ref([...fromRef(state.path), 'items', index]),
33
-
},
34
-
});
35
-
itemTypes.push(type);
36
-
});
23
+
const dedupedSchema = deduplicateSchema({ detectFormat: true, schema });
24
+
if (!dedupedSchema.items) {
25
+
return $.type('Array').generic($.type(plugin.config.topType));
37
26
}
38
27
39
-
if (itemTypes.length === 1) {
40
-
return $.type('Array').generic(itemTypes[0]!);
28
+
const itemResults: Array<TypeScriptResult> = dedupedSchema.items.map((item) =>
29
+
walk(item, {
30
+
path: ref([]),
31
+
plugin,
32
+
}),
33
+
);
34
+
if (itemResults.length === 1) {
35
+
return $.type('Array').generic(itemResults[0]!.type);
41
36
}
42
37
43
-
return schema.logicalOperator === 'and'
44
-
? $.type('Array').generic($.type.and(...itemTypes))
45
-
: $.type('Array').generic($.type.or(...itemTypes));
38
+
return dedupedSchema.logicalOperator === 'and'
39
+
? $.type('Array').generic($.type.and(...itemResults.map((r) => r.type)))
40
+
: $.type('Array').generic($.type.or(...itemResults.map((r) => r.type)));
46
41
}
+5
-5
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/boolean.ts
+5
-5
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/boolean.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
4
3
import { $ } from '../../../../../ts-dsl';
5
-
import type { IrSchemaToAstOptions } from '../../shared/types';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
6
5
7
6
export function booleanToAst({
8
7
schema,
9
-
}: IrSchemaToAstOptions & {
8
+
}: {
9
+
plugin: HeyApiTypeScriptPlugin['Instance'];
10
10
schema: SchemaWithType<'boolean'>;
11
-
}): TypeTsDsl {
11
+
}): TypeScriptResult['type'] {
12
12
if (schema.const !== undefined) {
13
-
return $.type.literal(schema.const as boolean);
13
+
return $.type.fromValue(schema.const);
14
14
}
15
15
16
16
return $.type('boolean');
+58
-15
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/enum.ts
+58
-15
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/enum.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { MaybeTsDsl, TypeTsDsl } from '../../../../../ts-dsl';
4
-
import type { IrSchemaToAstOptions } from '../../shared/types';
5
-
import { irSchemaToAst } from '../plugin';
3
+
import { $ } from '../../../../../ts-dsl';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
5
+
import type { TypeScriptEnumData } from '../../shared/types';
6
+
7
+
function buildEnumData(
8
+
plugin: HeyApiTypeScriptPlugin['Instance'],
9
+
schema: SchemaWithType<'enum'>,
10
+
): TypeScriptEnumData | undefined {
11
+
if (!plugin.config.enums.enabled) {
12
+
return undefined;
13
+
}
14
+
15
+
const items = schema.items ?? [];
16
+
const mode = plugin.config.enums.mode;
17
+
18
+
return {
19
+
items: items.map((item, index) => {
20
+
let key: string;
21
+
if (item.title) {
22
+
key = item.title;
23
+
} else if (typeof item.const === 'number' || typeof item.const === 'string') {
24
+
key = `${item.const}`;
25
+
} else if (typeof item.const === 'boolean') {
26
+
key = item.const ? 'true' : 'false';
27
+
} else if (item.const === null) {
28
+
key = 'null';
29
+
} else {
30
+
key = `${index}`;
31
+
}
32
+
return { key, schema: item };
33
+
}),
34
+
mode,
35
+
};
36
+
}
6
37
7
38
export function enumToAst({
8
39
plugin,
9
40
schema,
10
-
state,
11
-
}: IrSchemaToAstOptions & {
41
+
}: {
42
+
plugin: HeyApiTypeScriptPlugin['Instance'];
12
43
schema: SchemaWithType<'enum'>;
13
-
}): MaybeTsDsl<TypeTsDsl> {
14
-
const type = irSchemaToAst({
15
-
plugin,
16
-
schema: {
17
-
...schema,
18
-
type: undefined,
19
-
},
20
-
state,
21
-
});
22
-
return type;
44
+
}): {
45
+
enumData?: TypeScriptEnumData;
46
+
type: TypeScriptResult['type'];
47
+
} {
48
+
const items = schema.items ?? [];
49
+
const enumData = buildEnumData(plugin, schema);
50
+
51
+
let type: TypeScriptResult['type'];
52
+
53
+
if (items.length === 0) {
54
+
type = $.type('never');
55
+
} else {
56
+
const literalTypes = items
57
+
.filter((item) => item.const !== undefined)
58
+
.map((item) => $.type.fromValue(item.const));
59
+
type = literalTypes.length > 0 ? $.type.or(...literalTypes) : $.type('string');
60
+
}
61
+
62
+
return {
63
+
enumData,
64
+
type,
65
+
};
23
66
}
-97
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/index.ts
-97
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/index.ts
···
1
-
import type { SchemaWithType } from '@hey-api/shared';
2
-
3
-
import type { MaybeTsDsl, TypeTsDsl } from '../../../../../ts-dsl';
4
-
import type { IrSchemaToAstOptions } from '../../shared/types';
5
-
import { arrayToAst } from './array';
6
-
import { booleanToAst } from './boolean';
7
-
import { enumToAst } from './enum';
8
-
import { neverToAst } from './never';
9
-
import { nullToAst } from './null';
10
-
import { numberToAst } from './number';
11
-
import { objectToAst } from './object';
12
-
import { stringToAst } from './string';
13
-
import { tupleToAst } from './tuple';
14
-
import { undefinedToAst } from './undefined';
15
-
import { unknownToAst } from './unknown';
16
-
import { voidToAst } from './void';
17
-
18
-
export function irSchemaWithTypeToAst({
19
-
schema,
20
-
...args
21
-
}: IrSchemaToAstOptions & {
22
-
schema: SchemaWithType;
23
-
}): MaybeTsDsl<TypeTsDsl> {
24
-
const transformersPlugin = args.plugin.getPlugin('@hey-api/transformers');
25
-
if (transformersPlugin?.config.typeTransformers) {
26
-
for (const typeTransformer of transformersPlugin.config.typeTransformers) {
27
-
const typeNode = typeTransformer({ schema });
28
-
if (typeNode) {
29
-
return typeNode;
30
-
}
31
-
}
32
-
}
33
-
34
-
switch (schema.type) {
35
-
case 'array':
36
-
return arrayToAst({
37
-
...args,
38
-
schema: schema as SchemaWithType<'array'>,
39
-
});
40
-
case 'boolean':
41
-
return booleanToAst({
42
-
...args,
43
-
schema: schema as SchemaWithType<'boolean'>,
44
-
});
45
-
case 'enum':
46
-
return enumToAst({
47
-
...args,
48
-
schema: schema as SchemaWithType<'enum'>,
49
-
});
50
-
case 'integer':
51
-
case 'number':
52
-
return numberToAst({
53
-
...args,
54
-
schema: schema as SchemaWithType<'integer' | 'number'>,
55
-
});
56
-
case 'never':
57
-
return neverToAst({
58
-
...args,
59
-
schema: schema as SchemaWithType<'never'>,
60
-
});
61
-
case 'null':
62
-
return nullToAst({
63
-
...args,
64
-
schema: schema as SchemaWithType<'null'>,
65
-
});
66
-
case 'object':
67
-
return objectToAst({
68
-
...args,
69
-
schema: schema as SchemaWithType<'object'>,
70
-
});
71
-
case 'string':
72
-
return stringToAst({
73
-
...args,
74
-
schema: schema as SchemaWithType<'string'>,
75
-
});
76
-
case 'tuple':
77
-
return tupleToAst({
78
-
...args,
79
-
schema: schema as SchemaWithType<'tuple'>,
80
-
});
81
-
case 'undefined':
82
-
return undefinedToAst({
83
-
...args,
84
-
schema: schema as SchemaWithType<'undefined'>,
85
-
});
86
-
case 'unknown':
87
-
return unknownToAst({
88
-
...args,
89
-
schema: schema as SchemaWithType<'unknown'>,
90
-
});
91
-
case 'void':
92
-
return voidToAst({
93
-
...args,
94
-
schema: schema as SchemaWithType<'void'>,
95
-
});
96
-
}
97
-
}
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/never.ts
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/never.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
4
3
import { $ } from '../../../../../ts-dsl';
5
-
import type { IrSchemaToAstOptions } from '../../shared/types';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
6
5
7
-
export const neverToAst = (
8
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars
9
-
_args: IrSchemaToAstOptions & {
10
-
schema: SchemaWithType<'never'>;
11
-
},
12
-
): TypeTsDsl => {
13
-
const node = $.type('never');
14
-
return node;
15
-
};
6
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
7
+
export function neverToAst(args: {
8
+
plugin: HeyApiTypeScriptPlugin['Instance'];
9
+
schema: SchemaWithType<'never'>;
10
+
}): TypeScriptResult['type'] {
11
+
return $.type('never');
12
+
}
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/null.ts
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/null.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
4
3
import { $ } from '../../../../../ts-dsl';
5
-
import type { IrSchemaToAstOptions } from '../../shared/types';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
6
5
7
-
export const nullToAst = (
8
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars
9
-
_args: IrSchemaToAstOptions & {
10
-
schema: SchemaWithType<'null'>;
11
-
},
12
-
): TypeTsDsl => {
13
-
const node = $.type.literal(null);
14
-
return node;
15
-
};
6
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
7
+
export function nullToAst(args: {
8
+
plugin: HeyApiTypeScriptPlugin['Instance'];
9
+
schema: SchemaWithType<'null'>;
10
+
}): TypeScriptResult['type'] {
11
+
return $.type.literal(null);
12
+
}
+7
-7
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/number.ts
+7
-7
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/number.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
4
3
import { $ } from '../../../../../ts-dsl';
5
-
import type { IrSchemaToAstOptions } from '../../shared/types';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
6
5
7
-
export const numberToAst = ({
6
+
export function numberToAst({
8
7
plugin,
9
8
schema,
10
-
}: IrSchemaToAstOptions & {
9
+
}: {
10
+
plugin: HeyApiTypeScriptPlugin['Instance'];
11
11
schema: SchemaWithType<'integer' | 'number'>;
12
-
}): TypeTsDsl => {
12
+
}): TypeScriptResult['type'] {
13
13
if (schema.const !== undefined) {
14
-
return $.type.literal(schema.const as number);
14
+
return $.type.fromValue(schema.const);
15
15
}
16
16
17
17
if (schema.type === 'integer' && schema.format === 'int64') {
···
22
22
}
23
23
24
24
return $.type('number');
25
-
};
25
+
}
+28
-56
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/object.ts
+28
-56
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/object.ts
···
1
-
import { fromRef, ref } from '@hey-api/codegen-core';
2
-
import type { IR } from '@hey-api/shared';
3
-
import type { SchemaWithType } from '@hey-api/shared';
1
+
import { ref } from '@hey-api/codegen-core';
2
+
import type { IR, SchemaWithType, Walker } from '@hey-api/shared';
3
+
import { deduplicateSchema } from '@hey-api/shared';
4
4
5
5
import { createSchemaComment } from '../../../../../plugins/shared/utils/schema';
6
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
7
6
import { $ } from '../../../../../ts-dsl';
8
-
import type { IrSchemaToAstOptions } from '../../shared/types';
9
-
import { irSchemaToAst } from '../plugin';
7
+
import type { HeyApiTypeScriptPlugin } from '../../shared/types';
8
+
import type { TypeScriptResult } from '../../shared/types';
10
9
11
10
export function objectToAst({
12
11
plugin,
13
12
schema,
14
-
state,
15
-
}: IrSchemaToAstOptions & {
13
+
walk,
14
+
}: {
15
+
plugin: HeyApiTypeScriptPlugin['Instance'];
16
16
schema: SchemaWithType<'object'>;
17
-
}): TypeTsDsl {
18
-
// TODO: parser - handle constants
17
+
walk: Walker<TypeScriptResult, HeyApiTypeScriptPlugin['Instance']>;
18
+
}): TypeScriptResult['type'] {
19
19
const shape = $.type.object();
20
20
const required = schema.required ?? [];
21
21
let indexSchemas: Array<IR.SchemaObject> = [];
···
23
23
24
24
for (const name in schema.properties) {
25
25
const property = schema.properties[name]!;
26
-
const propertyType = irSchemaToAst({
27
-
plugin,
28
-
schema: property,
29
-
state: {
30
-
...state,
31
-
path: ref([...fromRef(state.path), 'properties', name]),
32
-
},
33
-
});
26
+
const propertyResult = walk(property, { path: ref([]), plugin });
34
27
const isRequired = required.includes(name);
35
28
shape.prop(name, (p) =>
36
29
p
37
30
.$if(plugin.config.comments && createSchemaComment(property), (p, v) => p.doc(v))
38
31
.readonly(property.accessScope === 'read')
39
32
.required(isRequired)
40
-
.type(propertyType),
33
+
.type(propertyResult.type),
41
34
);
42
35
indexSchemas.push(property);
43
36
···
46
39
}
47
40
}
48
41
49
-
// include pattern value schemas into the index union
50
42
if (schema.patternProperties) {
51
43
for (const pattern in schema.patternProperties) {
52
44
const ir = schema.patternProperties[pattern]!;
···
67
59
const addProps = addPropsObj;
68
60
if (addProps && addProps.type !== 'never') {
69
61
if (addProps.type === 'unknown') {
70
-
// When additionalProperties is unknown (e.g. `{}` or `true`), it already subsumes all
71
-
// named property types, so we only need the additionalProperties schema itself (plus any
72
-
// patternProperties) in the index signature. Including named property types would produce
73
-
// a redundant, noisy union like `unknown | string | null | ...`.
74
62
const patternSchemas: Array<IR.SchemaObject> = schema.patternProperties
75
63
? Object.values(schema.patternProperties)
76
64
: [];
77
65
indexSchemas = [addProps, ...patternSchemas];
78
66
} else {
79
-
// For typed additionalProperties (e.g. `{ type: 'string' }`), named property types must
80
-
// be included so that TypeScript's index signature constraint is satisfied.
81
67
indexSchemas.unshift(addProps);
82
68
}
83
69
} else if (!hasPatterns && !indexSchemas.length && addProps && addProps.type === 'never') {
84
-
// keep "never" only when there are NO patterns and NO explicit properties
85
70
indexSchemas = [addProps];
86
71
}
87
72
88
-
// `unknown` already subsumes `undefined`, so no need to add it explicitly
89
73
if (hasOptionalProperties && addProps?.type !== 'unknown') {
90
74
indexSchemas.push({ type: 'undefined' });
91
75
}
92
76
93
-
const type =
94
-
indexSchemas.length === 1
95
-
? irSchemaToAst({
96
-
plugin,
97
-
schema: indexSchemas[0]!,
98
-
state,
99
-
})
100
-
: irSchemaToAst({
101
-
plugin,
102
-
schema: { items: indexSchemas, logicalOperator: 'or' },
103
-
state,
104
-
});
77
+
if (indexSchemas.length > 0) {
78
+
const unionSchema: IR.SchemaObject =
79
+
indexSchemas.length === 1
80
+
? indexSchemas[0]!
81
+
: deduplicateSchema({ schema: { items: indexSchemas, logicalOperator: 'or' } });
105
82
106
-
if (schema.propertyNames?.$ref) {
107
-
return $.type
108
-
.mapped('key')
109
-
.key(
110
-
irSchemaToAst({
111
-
plugin,
112
-
schema: {
113
-
$ref: schema.propertyNames.$ref,
114
-
},
115
-
state,
116
-
}),
117
-
)
118
-
.optional()
119
-
.type(type);
83
+
const indexType = walk(unionSchema, { path: ref([]), plugin }).type;
84
+
85
+
if (schema.propertyNames?.$ref) {
86
+
const propertyNamesResult = walk(
87
+
{ $ref: schema.propertyNames.$ref },
88
+
{ path: ref([]), plugin },
89
+
);
90
+
return $.type.mapped('key').key(propertyNamesResult.type).optional().type(indexType);
91
+
}
92
+
93
+
shape.idxSig('key', (i) => i.key('string').type(indexType));
120
94
}
121
-
122
-
shape.idxSig('key', (i) => i.key('string').type(type));
123
95
}
124
96
125
97
return shape;
+19
-20
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/string.ts
+19
-20
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/string.ts
···
2
2
import type { SchemaWithType } from '@hey-api/shared';
3
3
import { toCase } from '@hey-api/shared';
4
4
5
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
6
5
import { $ } from '../../../../../ts-dsl';
7
-
import type { IrSchemaToAstOptions } from '../../shared/types';
6
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
8
7
9
-
export const stringToAst = ({
8
+
export function stringToAst({
10
9
plugin,
11
10
schema,
12
-
}: IrSchemaToAstOptions & {
11
+
}: {
12
+
plugin: HeyApiTypeScriptPlugin['Instance'];
13
13
schema: SchemaWithType<'string'>;
14
-
}): TypeTsDsl => {
14
+
}): TypeScriptResult['type'] {
15
15
if (schema.const !== undefined) {
16
-
return $.type.literal(schema.const as string);
16
+
return $.type.fromValue(schema.const);
17
17
}
18
18
19
19
if (schema.format) {
···
31
31
if (schema.format === 'typeid' && typeof schema.example === 'string') {
32
32
const parts = String(schema.example).split('_');
33
33
parts.pop(); // remove the ID part
34
-
const type = parts.join('_');
34
+
const typeidBase = parts.join('_');
35
35
36
-
const query: SymbolMeta = {
36
+
const typeidQuery: SymbolMeta = {
37
37
category: 'type',
38
38
resource: 'type-id',
39
-
resourceId: type,
39
+
resourceId: typeidBase,
40
40
tool: 'typescript',
41
41
};
42
-
if (!plugin.getSymbol(query)) {
43
-
const queryTypeId: SymbolMeta = {
42
+
if (!plugin.getSymbol(typeidQuery)) {
43
+
const containerQuery: SymbolMeta = {
44
44
category: 'type',
45
45
resource: 'type-id',
46
46
tool: 'typescript',
47
47
variant: 'container',
48
48
};
49
49
50
-
if (!plugin.getSymbol(queryTypeId)) {
50
+
if (!plugin.getSymbol(containerQuery)) {
51
51
const symbolTypeId = plugin.symbol('TypeID', {
52
-
meta: queryTypeId,
52
+
meta: containerQuery,
53
53
});
54
54
const nodeTypeId = $.type
55
55
.alias(symbolTypeId)
···
59
59
plugin.node(nodeTypeId);
60
60
}
61
61
62
-
const symbolTypeId = plugin.referenceSymbol(queryTypeId);
63
-
const symbolTypeName = plugin.symbol(toCase(`${type}_id`, plugin.config.case), {
64
-
meta: query,
62
+
const refSymbol = plugin.referenceSymbol(containerQuery);
63
+
const symbolTypeName = plugin.symbol(toCase(`${typeidBase}_id`, plugin.config.case), {
64
+
meta: typeidQuery,
65
65
});
66
66
const node = $.type
67
67
.alias(symbolTypeName)
68
68
.export()
69
-
.type($.type(symbolTypeId).generic($.type.literal(type)));
69
+
.type($.type(refSymbol).generic($.type.literal(typeidBase)));
70
70
plugin.node(node);
71
71
}
72
-
const symbol = plugin.referenceSymbol(query);
73
-
return $.type(symbol);
72
+
return $.type(plugin.referenceSymbol(typeidQuery));
74
73
}
75
74
}
76
75
77
76
return $.type('string');
78
-
};
77
+
}
+13
-18
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/tuple.ts
+13
-18
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/tuple.ts
···
1
-
import { fromRef, ref } from '@hey-api/codegen-core';
1
+
import { ref } from '@hey-api/codegen-core';
2
2
import type { SchemaWithType } from '@hey-api/shared';
3
+
import type { Walker } from '@hey-api/shared';
3
4
4
-
import type { MaybeTsDsl, TypeTsDsl } from '../../../../../ts-dsl';
5
5
import { $ } from '../../../../../ts-dsl';
6
-
import type { IrSchemaToAstOptions } from '../../shared/types';
7
-
import { irSchemaToAst } from '../plugin';
6
+
import type { HeyApiTypeScriptPlugin } from '../../shared/types';
7
+
import type { TypeScriptResult } from '../../shared/types';
8
8
9
9
export function tupleToAst({
10
10
plugin,
11
11
schema,
12
-
state,
13
-
}: IrSchemaToAstOptions & {
12
+
walk,
13
+
}: {
14
+
plugin: HeyApiTypeScriptPlugin['Instance'];
14
15
schema: SchemaWithType<'tuple'>;
15
-
}): MaybeTsDsl<TypeTsDsl> {
16
-
let itemTypes: Array<MaybeTsDsl<TypeTsDsl>> = [];
16
+
walk: Walker<TypeScriptResult, HeyApiTypeScriptPlugin['Instance']>;
17
+
}): TypeScriptResult['type'] {
18
+
let itemTypes: Array<TypeScriptResult['type']> = [];
17
19
18
20
if (schema.const && Array.isArray(schema.const)) {
19
21
itemTypes = schema.const.map((value) => $.type.fromValue(value));
20
22
} else if (schema.items) {
21
-
schema.items.forEach((item, index) => {
22
-
const type = irSchemaToAst({
23
-
plugin,
24
-
schema: item,
25
-
state: {
26
-
...state,
27
-
path: ref([...fromRef(state.path), 'items', index]),
28
-
},
29
-
});
30
-
itemTypes.push(type);
23
+
schema.items.forEach((item) => {
24
+
const result = walk(item, { path: ref([]), plugin });
25
+
itemTypes.push(result.type);
31
26
});
32
27
}
33
28
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/undefined.ts
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/undefined.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
4
3
import { $ } from '../../../../../ts-dsl';
5
-
import type { IrSchemaToAstOptions } from '../../shared/types';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
6
5
7
-
export const undefinedToAst = (
8
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars
9
-
_args: IrSchemaToAstOptions & {
10
-
schema: SchemaWithType<'undefined'>;
11
-
},
12
-
): TypeTsDsl => {
13
-
const node = $.type('undefined');
14
-
return node;
15
-
};
6
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
7
+
export function undefinedToAst(args: {
8
+
plugin: HeyApiTypeScriptPlugin['Instance'];
9
+
schema: SchemaWithType<'undefined'>;
10
+
}): TypeScriptResult['type'] {
11
+
return $.type('undefined');
12
+
}
+5
-6
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/unknown.ts
+5
-6
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/unknown.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
4
3
import { $ } from '../../../../../ts-dsl';
5
-
import type { IrSchemaToAstOptions } from '../../shared/types';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
6
5
7
6
export function unknownToAst({
8
7
plugin,
9
-
}: IrSchemaToAstOptions & {
8
+
}: {
9
+
plugin: HeyApiTypeScriptPlugin['Instance'];
10
10
schema: SchemaWithType<'unknown'>;
11
-
}): TypeTsDsl {
12
-
const node = $.type(plugin.config.topType);
13
-
return node;
11
+
}): TypeScriptResult['type'] {
12
+
return $.type(plugin.config.topType);
14
13
}
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/void.ts
+8
-11
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/void.ts
···
1
1
import type { SchemaWithType } from '@hey-api/shared';
2
2
3
-
import type { TypeTsDsl } from '../../../../../ts-dsl';
4
3
import { $ } from '../../../../../ts-dsl';
5
-
import type { IrSchemaToAstOptions } from '../../shared/types';
4
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../../shared/types';
6
5
7
-
export const voidToAst = (
8
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars
9
-
_args: IrSchemaToAstOptions & {
10
-
schema: SchemaWithType<'void'>;
11
-
},
12
-
): TypeTsDsl => {
13
-
const node = $.type('void');
14
-
return node;
15
-
};
6
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
7
+
export function voidToAst(args: {
8
+
plugin: HeyApiTypeScriptPlugin['Instance'];
9
+
schema: SchemaWithType<'void'>;
10
+
}): TypeScriptResult['type'] {
11
+
return $.type('void');
12
+
}
+214
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/walker.ts
+214
packages/openapi-ts/src/plugins/@hey-api/typescript/v1/walker.ts
···
1
+
import { fromRef } from '@hey-api/codegen-core';
2
+
import type { SchemaExtractor, SchemaVisitor } from '@hey-api/shared';
3
+
import { pathToJsonPointer } from '@hey-api/shared';
4
+
5
+
import { $ } from '../../../../ts-dsl';
6
+
import { defaultMeta, inheritMeta } from '../shared/meta';
7
+
import type { ProcessorContext } from '../shared/processor';
8
+
import type { HeyApiTypeScriptPlugin, TypeScriptResult } from '../shared/types';
9
+
import { arrayToAst } from './toAst/array';
10
+
import { booleanToAst } from './toAst/boolean';
11
+
import { enumToAst } from './toAst/enum';
12
+
import { neverToAst } from './toAst/never';
13
+
import { nullToAst } from './toAst/null';
14
+
import { numberToAst } from './toAst/number';
15
+
import { objectToAst } from './toAst/object';
16
+
import { stringToAst } from './toAst/string';
17
+
import { tupleToAst } from './toAst/tuple';
18
+
import { undefinedToAst } from './toAst/undefined';
19
+
import { unknownToAst } from './toAst/unknown';
20
+
import { voidToAst } from './toAst/void';
21
+
22
+
export interface VisitorConfig {
23
+
/** Optional schema extractor function. */
24
+
schemaExtractor?: SchemaExtractor<ProcessorContext>;
25
+
}
26
+
27
+
export function createVisitor(
28
+
config: VisitorConfig,
29
+
): SchemaVisitor<TypeScriptResult, HeyApiTypeScriptPlugin['Instance']> {
30
+
const { schemaExtractor } = config;
31
+
32
+
return {
33
+
applyModifiers(result) {
34
+
return {
35
+
enumData: result.enumData,
36
+
type: result.type,
37
+
};
38
+
},
39
+
array(schema, ctx, walk) {
40
+
const type = arrayToAst({
41
+
plugin: ctx.plugin,
42
+
schema,
43
+
walk,
44
+
});
45
+
return {
46
+
meta: defaultMeta(schema),
47
+
type,
48
+
};
49
+
},
50
+
boolean(schema, ctx) {
51
+
const type = booleanToAst({ plugin: ctx.plugin, schema });
52
+
return {
53
+
meta: defaultMeta(schema),
54
+
type,
55
+
};
56
+
},
57
+
enum(schema, ctx) {
58
+
const { enumData, type } = enumToAst({ plugin: ctx.plugin, schema });
59
+
return {
60
+
enumData,
61
+
meta: defaultMeta(schema),
62
+
type,
63
+
};
64
+
},
65
+
integer(schema, ctx) {
66
+
const type = numberToAst({ plugin: ctx.plugin, schema });
67
+
return {
68
+
meta: defaultMeta(schema),
69
+
type,
70
+
};
71
+
},
72
+
intercept(schema, ctx, walk) {
73
+
if (schemaExtractor && !schema.$ref) {
74
+
const extracted = schemaExtractor({
75
+
meta: {
76
+
resource: 'definition',
77
+
resourceId: pathToJsonPointer(fromRef(ctx.path)),
78
+
},
79
+
naming: ctx.plugin.config.definitions,
80
+
path: fromRef(ctx.path),
81
+
plugin: ctx.plugin,
82
+
schema,
83
+
});
84
+
85
+
if (extracted !== schema) {
86
+
return walk(extracted, ctx);
87
+
}
88
+
}
89
+
90
+
const transformersPlugin = ctx.plugin.getPlugin('@hey-api/transformers');
91
+
if (transformersPlugin?.config.typeTransformers) {
92
+
for (const typeTransformer of transformersPlugin.config.typeTransformers) {
93
+
const typeNode = typeTransformer({ schema });
94
+
if (typeNode) {
95
+
return { meta: defaultMeta(schema), type: typeNode };
96
+
}
97
+
}
98
+
}
99
+
},
100
+
intersection(items, schemas, parentSchema) {
101
+
const type = items.length === 1 ? items[0]!.type : $.type.and(...items.map((r) => r.type));
102
+
103
+
return {
104
+
meta: inheritMeta(parentSchema, items),
105
+
type,
106
+
};
107
+
},
108
+
never(schema, ctx) {
109
+
const type = neverToAst({ plugin: ctx.plugin, schema });
110
+
return {
111
+
meta: defaultMeta(schema),
112
+
type,
113
+
};
114
+
},
115
+
null(schema, ctx) {
116
+
const type = nullToAst({ plugin: ctx.plugin, schema });
117
+
return {
118
+
meta: defaultMeta(schema),
119
+
type,
120
+
};
121
+
},
122
+
number(schema, ctx) {
123
+
const type = numberToAst({ plugin: ctx.plugin, schema });
124
+
return {
125
+
meta: defaultMeta(schema),
126
+
type,
127
+
};
128
+
},
129
+
object(schema, ctx, walk) {
130
+
const type = objectToAst({
131
+
plugin: ctx.plugin,
132
+
schema,
133
+
walk,
134
+
});
135
+
return {
136
+
meta: defaultMeta(schema),
137
+
type,
138
+
};
139
+
},
140
+
postProcess(result) {
141
+
return result;
142
+
},
143
+
reference($ref, schema, ctx) {
144
+
const symbol = ctx.plugin.referenceSymbol({
145
+
category: 'type',
146
+
resource: 'definition',
147
+
resourceId: $ref,
148
+
});
149
+
150
+
if (schema.omit && schema.omit.length > 0) {
151
+
const omittedKeys =
152
+
schema.omit.length === 1
153
+
? $.type.literal(schema.omit[0]!)
154
+
: $.type.or(...schema.omit.map((key) => $.type.literal(key)));
155
+
return {
156
+
meta: defaultMeta(schema),
157
+
type: $.type('Omit').generics($.type(symbol), omittedKeys),
158
+
};
159
+
}
160
+
161
+
return {
162
+
meta: defaultMeta(schema),
163
+
type: $.type(symbol),
164
+
};
165
+
},
166
+
string(schema, ctx) {
167
+
const type = stringToAst({ plugin: ctx.plugin, schema });
168
+
return {
169
+
meta: defaultMeta(schema),
170
+
type,
171
+
};
172
+
},
173
+
tuple(schema, ctx, walk) {
174
+
const type = tupleToAst({
175
+
plugin: ctx.plugin,
176
+
schema,
177
+
walk,
178
+
});
179
+
return {
180
+
meta: defaultMeta(schema),
181
+
type,
182
+
};
183
+
},
184
+
undefined(schema, ctx) {
185
+
const type = undefinedToAst({ plugin: ctx.plugin, schema });
186
+
return {
187
+
meta: defaultMeta(schema),
188
+
type,
189
+
};
190
+
},
191
+
union(items, schemas, parentSchema) {
192
+
const type = items.length === 1 ? items[0]!.type : $.type.or(...items.map((r) => r.type));
193
+
194
+
return {
195
+
meta: inheritMeta(parentSchema, items),
196
+
type,
197
+
};
198
+
},
199
+
unknown(schema, ctx) {
200
+
const type = unknownToAst({ plugin: ctx.plugin, schema });
201
+
return {
202
+
meta: defaultMeta(schema),
203
+
type,
204
+
};
205
+
},
206
+
void(schema, ctx) {
207
+
const type = voidToAst({ plugin: ctx.plugin, schema });
208
+
return {
209
+
meta: defaultMeta(schema),
210
+
type,
211
+
};
212
+
},
213
+
};
214
+
}
+1
-8
packages/openapi-ts/src/plugins/@tanstack/query-core/v5/infiniteQueryOptions.ts
+1
-8
packages/openapi-ts/src/plugins/@tanstack/query-core/v5/infiniteQueryOptions.ts
···
1
-
import { ref } from '@hey-api/codegen-core';
2
1
import type { IR } from '@hey-api/shared';
3
2
import { applyNaming, operationPagination } from '@hey-api/shared';
4
3
···
156
155
),
157
156
);
158
157
const pluginTypeScript = plugin.getPluginOrThrow('@hey-api/typescript');
159
-
const type = pluginTypeScript.api.schemaToType({
160
-
plugin: pluginTypeScript,
161
-
schema: pagination.schema,
162
-
state: {
163
-
path: ref([]),
164
-
},
165
-
});
158
+
const type = pluginTypeScript.api.schemaToType(pluginTypeScript, pagination.schema);
166
159
167
160
const symbolInfiniteQueryKey = plugin.symbol(
168
161
applyNaming(operation.id, plugin.config.infiniteQueryKeys),
+10
-3
packages/openapi-ts/src/plugins/valibot/v1/processor.ts
+10
-3
packages/openapi-ts/src/plugins/valibot/v1/processor.ts
···
36
36
return ctx.schema;
37
37
}
38
38
39
-
function process(ctx: ProcessorContext): void {
39
+
function process(ctx: ProcessorContext): ValibotFinal | void {
40
40
if (!processor.markEmitted(ctx.path)) return;
41
41
42
-
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
42
+
const shouldExport = ctx.export !== false;
43
+
44
+
return processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
43
45
const visitor = createVisitor({ schemaExtractor: extractor });
44
46
const walk = createSchemaWalker(visitor);
45
47
···
53
55
plugin,
54
56
}) as ValibotFinal;
55
57
56
-
exportAst({ ...ctx, final, plugin });
58
+
if (shouldExport) {
59
+
exportAst({ ...ctx, final, plugin });
60
+
return;
61
+
}
62
+
63
+
return final;
57
64
});
58
65
}
59
66
+1
-1
packages/openapi-ts/src/plugins/zod/mini/processor.ts
+1
-1
packages/openapi-ts/src/plugins/zod/mini/processor.ts
···
36
36
function process(ctx: ProcessorContext): void {
37
37
if (!processor.markEmitted(ctx.path)) return;
38
38
39
-
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
39
+
return processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
40
40
const state = refs<PluginState>({
41
41
hasLazyExpression: false,
42
42
path: ctx.path,
+1
-1
packages/openapi-ts/src/plugins/zod/v3/processor.ts
+1
-1
packages/openapi-ts/src/plugins/zod/v3/processor.ts
···
36
36
function process(ctx: ProcessorContext): void {
37
37
if (!processor.markEmitted(ctx.path)) return;
38
38
39
-
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
39
+
return processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
40
40
const state = refs<PluginState>({
41
41
hasLazyExpression: false,
42
42
path: ctx.path,
+1
-1
packages/openapi-ts/src/plugins/zod/v4/processor.ts
+1
-1
packages/openapi-ts/src/plugins/zod/v4/processor.ts
···
36
36
function process(ctx: ProcessorContext): void {
37
37
if (!processor.markEmitted(ctx.path)) return;
38
38
39
-
processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
39
+
return processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
40
40
const state = refs<PluginState>({
41
41
hasLazyExpression: false,
42
42
path: ctx.path,
+6
-1
packages/openapi-ts/src/ts-dsl/type/fromValue.ts
+6
-1
packages/openapi-ts/src/ts-dsl/type/fromValue.ts
···
15
15
return new TypeLiteralTsDsl(input);
16
16
}
17
17
18
-
if (typeof input === 'number' || typeof input === 'boolean' || typeof input === 'string') {
18
+
if (
19
+
typeof input === 'number' ||
20
+
typeof input === 'boolean' ||
21
+
typeof input === 'string' ||
22
+
typeof input === 'bigint'
23
+
) {
19
24
return new TypeLiteralTsDsl(input);
20
25
}
21
26
+3
-3
packages/openapi-ts/src/ts-dsl/type/literal.ts
+3
-3
packages/openapi-ts/src/ts-dsl/type/literal.ts
···
2
2
import ts from 'typescript';
3
3
4
4
import { TsDsl } from '../base';
5
-
import { LiteralTsDsl } from '../expr/literal';
5
+
import { LiteralTsDsl, type LiteralValue } from '../expr/literal';
6
6
7
7
const Mixed = TsDsl<ts.LiteralTypeNode>;
8
8
···
10
10
readonly '~dsl' = 'TypeLiteralTsDsl';
11
11
override scope: NodeScope = 'type';
12
12
13
-
protected value: string | number | boolean | null;
13
+
protected value: LiteralValue;
14
14
15
-
constructor(value: string | number | boolean | null) {
15
+
constructor(value: LiteralValue) {
16
16
super();
17
17
this.value = value;
18
18
}