+2 -1

packages/openapi-ts/package.json

reviewed

··· 116 116 "rxjs": "7.8.1", 117 117 "ts-node": "10.9.2", 118 118 "tslib": "2.6.3", 119 119 - "typescript": "5.5.3" 119 119 + "typescript": "5.5.3", 120 120 + "zod": "3.23.8" 120 121 } 121 122 }

+2 -155

packages/openapi-ts/src/compiler/index.ts

reviewed

··· 1 1 - import { type PathLike, rmSync, writeFileSync } from 'node:fs'; 2 2 - import path from 'node:path'; 3 3 - 4 4 - import type ts from 'typescript'; 5 5 - 6 6 - import { ensureDirSync } from '../generate/utils'; 7 1 import * as classes from './classes'; 8 2 import * as convert from './convert'; 9 3 import * as module from './module'; ··· 18 12 export type { Comments } from './utils'; 19 13 export type { ClassElement, Node, TypeNode } from 'typescript'; 20 14 21 21 - const splitNameAndExtension = (fileName: string) => { 22 22 - const match = fileName.match(/\.[0-9a-z]+$/i); 23 23 - const extension = match ? match[0].slice(1) : ''; 24 24 - const name = fileName.slice( 25 25 - 0, 26 26 - fileName.length - (extension ? extension.length + 1 : 0), 27 27 - ); 28 28 - return { extension, name }; 29 29 - }; 30 30 - 31 31 - export class TypeScriptFile { 32 32 - private _headers: Array<string> = []; 33 33 - private _imports = new Map< 34 34 - string, 35 35 - Map<string, utils.ImportExportItemObject> 36 36 - >(); 37 37 - private _items: Array<ts.Node | string> = []; 38 38 - private _name: string; 39 39 - private _path: PathLike; 40 40 - 41 41 - public constructor({ 42 42 - dir, 43 43 - name, 44 44 - header = true, 45 45 - }: { 46 46 - dir: string; 47 47 - header?: boolean; 48 48 - name: string; 49 49 - }) { 50 50 - this._name = this._setName(name); 51 51 - this._path = path.resolve(dir, this.getName()); 52 52 - 53 53 - if (header) { 54 54 - this._headers = [ 55 55 - ...this._headers, 56 56 - '// This file is auto-generated by @hey-api/openapi-ts', 57 57 - ]; 58 58 - } 59 59 - } 60 60 - 61 61 - public add(...nodes: Array<ts.Node | string>) { 62 62 - this._items = [...this._items, ...nodes]; 63 63 - } 64 64 - 65 65 - /** 66 66 - * Adds an import to the provided module. Handles duplication, returns added import. 67 67 - */ 68 68 - public import({ 69 69 - module, 70 70 - ...importedItem 71 71 - }: utils.ImportExportItemObject & { 72 72 - module: string; 73 73 - }): utils.ImportExportItemObject { 74 74 - let moduleMap = this._imports.get(module); 75 75 - 76 76 - if (!moduleMap) { 77 77 - moduleMap = new Map<string, utils.ImportExportItemObject>(); 78 78 - this._imports.set(module, moduleMap); 79 79 - } 80 80 - 81 81 - const match = moduleMap.get(importedItem.name); 82 82 - if (match) { 83 83 - return match; 84 84 - } 85 85 - 86 86 - moduleMap.set(importedItem.name, importedItem); 87 87 - return importedItem; 88 88 - } 89 89 - 90 90 - public getName(withExtension = true) { 91 91 - if (withExtension) { 92 92 - return this._name; 93 93 - } 94 94 - 95 95 - const { name } = splitNameAndExtension(this._name); 96 96 - return name; 97 97 - } 98 98 - 99 99 - public isEmpty() { 100 100 - return !this._items.length; 101 101 - } 102 102 - 103 103 - public remove(options?: Parameters<typeof rmSync>[1]) { 104 104 - rmSync(this._path, options); 105 105 - } 106 106 - 107 107 - /** 108 108 - * Removes last node form the stack. Works as undo. 109 109 - */ 110 110 - public removeNode() { 111 111 - this._items = this._items.slice(0, this._items.length - 1); 112 112 - } 113 113 - 114 114 - private _setName(fileName: string) { 115 115 - if (fileName.includes('index')) { 116 116 - return fileName; 117 117 - } 118 118 - 119 119 - const { extension, name } = splitNameAndExtension(fileName); 120 120 - return [name, 'gen', extension].filter(Boolean).join('.'); 121 121 - } 122 122 - 123 123 - public toString(separator: string = '\n') { 124 124 - let output: string[] = []; 125 125 - if (this._headers.length) { 126 126 - output = [...output, this._headers.join('\n')]; 127 127 - } 128 128 - let importsStringArray: string[] = []; 129 129 - for (const [_module, moduleMap] of this._imports.entries()) { 130 130 - const imports = Array.from(moduleMap.values()); 131 131 - const node = compiler.namedImportDeclarations({ 132 132 - imports, 133 133 - module: _module, 134 134 - }); 135 135 - importsStringArray = [ 136 136 - ...importsStringArray, 137 137 - utils.tsNodeToString({ node }), 138 138 - ]; 139 139 - } 140 140 - if (importsStringArray.length) { 141 141 - output = [...output, importsStringArray.join('\n')]; 142 142 - } 143 143 - output = [ 144 144 - ...output, 145 145 - ...this._items.map((node) => 146 146 - typeof node === 'string' 147 147 - ? node 148 148 - : utils.tsNodeToString({ node, unescape: true }), 149 149 - ), 150 150 - ]; 151 151 - return output.join(separator); 152 152 - } 153 153 - 154 154 - public write(separator = '\n') { 155 155 - if (this.isEmpty()) { 156 156 - this.remove({ force: true }); 157 157 - return; 158 158 - } 159 159 - 160 160 - let dir = this._path; 161 161 - if (typeof this._path === 'string') { 162 162 - const parts = this._path.split(path.sep); 163 163 - dir = parts.slice(0, parts.length - 1).join(path.sep); 164 164 - } 165 165 - ensureDirSync(dir); 166 166 - writeFileSync(this._path, this.toString(separator)); 167 167 - } 168 168 - } 169 169 - 170 15 export const compiler = { 171 16 anonymousFunction: types.createAnonymousFunction, 172 17 arrayLiteralExpression: types.createArrayLiteralExpression, ··· 187 32 indexedAccessTypeNode: types.createIndexedAccessTypeNode, 188 33 isTsNode: utils.isTsNode, 189 34 keywordTypeNode: types.createKeywordTypeNode, 35 35 + literalTypeNode: types.createLiteralTypeNode, 190 36 methodDeclaration: classes.createMethodDeclaration, 191 37 namedImportDeclarations: module.createNamedImportDeclarations, 192 38 namespaceDeclaration: types.createNamespaceDeclaration, 193 39 nodeToString: utils.tsNodeToString, 40 40 + null: types.createNull, 194 41 objectExpression: types.createObjectType, 195 42 ots: utils.ots, 196 43 propertyAccessExpression: types.createPropertyAccessExpression,

+86 -27

packages/openapi-ts/src/compiler/typedef.ts

reviewed

··· 1 1 import ts from 'typescript'; 2 2 3 3 - import { createTypeNode, createTypeReferenceNode } from './types'; 4 4 - import { addLeadingComments, type Comments, tsNodeToString } from './utils'; 3 3 + import { validTypescriptIdentifierRegExp } from '../utils/regexp'; 4 4 + import { 5 5 + createKeywordTypeNode, 6 6 + createStringLiteral, 7 7 + createTypeNode, 8 8 + createTypeReferenceNode, 9 9 + } from './types'; 10 10 + import { 11 11 + addLeadingComments, 12 12 + type Comments, 13 13 + createIdentifier, 14 14 + tsNodeToString, 15 15 + } from './utils'; 5 16 6 17 const nullNode = createTypeReferenceNode({ typeName: 'null' }); 7 18 ··· 38 49 * @returns ts.TypeLiteralNode | ts.TypeUnionNode 39 50 */ 40 51 export const createTypeInterfaceNode = ({ 52 52 + indexProperty, 41 53 isNullable, 42 54 properties, 55 55 + useLegacyResolution, 43 56 }: { 57 57 + /** 58 58 + * Adds an index signature if defined. 59 59 + * @example 60 60 + * ```ts 61 61 + * type IndexProperty = { 62 62 + * [key: string]: string 63 63 + * } 64 64 + * ``` 65 65 + */ 66 66 + indexProperty?: Property; 44 67 isNullable?: boolean; 45 68 properties: Property[]; 69 69 + useLegacyResolution: boolean; 46 70 }) => { 47 47 - const node = ts.factory.createTypeLiteralNode( 48 48 - properties.map((property) => { 49 49 - const modifiers: readonly ts.Modifier[] | undefined = property.isReadOnly 50 50 - ? [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)] 51 51 - : undefined; 71 71 + const propertyTypes: Array<ts.TypeNode> = []; 52 72 53 53 - const questionToken: ts.QuestionToken | undefined = 54 54 - property.isRequired !== false 55 55 - ? undefined 56 56 - : ts.factory.createToken(ts.SyntaxKind.QuestionToken); 73 73 + const members: Array<ts.TypeElement> = properties.map((property) => { 74 74 + const modifiers: readonly ts.Modifier[] | undefined = property.isReadOnly 75 75 + ? [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)] 76 76 + : undefined; 77 77 + 78 78 + const questionToken: ts.QuestionToken | undefined = 79 79 + property.isRequired !== false 80 80 + ? undefined 81 81 + : ts.factory.createToken(ts.SyntaxKind.QuestionToken); 82 82 + 83 83 + const type: ts.TypeNode | undefined = createTypeNode(property.type); 84 84 + propertyTypes.push(type); 85 85 + 86 86 + const signature = ts.factory.createPropertySignature( 87 87 + modifiers, 88 88 + useLegacyResolution || 89 89 + property.name.match(validTypescriptIdentifierRegExp) 90 90 + ? property.name 91 91 + : createStringLiteral({ text: property.name }), 92 92 + questionToken, 93 93 + type, 94 94 + ); 57 95 58 58 - const type: ts.TypeNode | undefined = createTypeNode(property.type); 96 96 + addLeadingComments({ 97 97 + comments: property.comment, 98 98 + node: signature, 99 99 + }); 59 100 60 60 - const signature = ts.factory.createPropertySignature( 61 61 - modifiers, 62 62 - property.name, 63 63 - questionToken, 64 64 - type, 65 65 - ); 101 101 + return signature; 102 102 + }); 66 103 67 67 - addLeadingComments({ 68 68 - comments: property.comment, 69 69 - node: signature, 70 70 - }); 104 104 + if (indexProperty) { 105 105 + const modifiers: readonly ts.Modifier[] | undefined = 106 106 + indexProperty.isReadOnly 107 107 + ? [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)] 108 108 + : undefined; 109 109 + const indexSignature = ts.factory.createIndexSignature( 110 110 + modifiers, 111 111 + [ 112 112 + ts.factory.createParameterDeclaration( 113 113 + undefined, 114 114 + undefined, 115 115 + createIdentifier({ text: indexProperty.name }), 116 116 + undefined, 117 117 + createKeywordTypeNode({ 118 118 + keyword: 'string', 119 119 + }), 120 120 + undefined, 121 121 + ), 122 122 + ], 123 123 + createTypeNode(indexProperty.type), 124 124 + ); 125 125 + members.push(indexSignature); 126 126 + } 71 127 72 72 - return signature; 73 73 - }), 74 74 - ); 128 128 + const node = ts.factory.createTypeLiteralNode(members); 75 129 return maybeNullable({ isNullable, node }); 76 130 }; 77 131 ··· 140 194 keys: (any | ts.TypeNode)[], 141 195 values: (any | ts.TypeNode)[], 142 196 isNullable: boolean = false, 197 197 + useLegacyResolution: boolean = true, 143 198 ) => { 144 199 const keyNode = createTypeUnionNode({ 145 200 types: keys, ··· 157 212 type: valueNode, 158 213 }, 159 214 ], 215 215 + useLegacyResolution, 160 216 }); 161 217 return maybeNullable({ isNullable, node }); 162 218 }; ··· 168 224 * @returns ts.TypeReferenceNode | ts.UnionTypeNode 169 225 */ 170 226 export const createTypeArrayNode = ( 171 171 - types: (any | ts.TypeNode)[], 227 227 + types: (any | ts.TypeNode)[] | ts.TypeNode | string, 172 228 isNullable: boolean = false, 173 229 ) => { 174 230 const node = createTypeReferenceNode({ 175 175 - typeArguments: [createTypeUnionNode({ types })], 231 231 + typeArguments: [ 232 232 + // @ts-ignore 233 233 + Array.isArray(types) ? createTypeUnionNode({ types }) : types, 234 234 + ], 176 235 typeName: 'Array', 177 236 }); 178 237 return maybeNullable({ isNullable, node });

+78 -31

packages/openapi-ts/src/compiler/types.ts

reviewed

··· 1 1 import ts from 'typescript'; 2 2 3 3 + import { escapeName } from '../utils/escape'; 3 4 import { validTypescriptIdentifierRegExp } from '../utils/regexp'; 4 5 import { 5 6 addLeadingComments, ··· 110 111 return node; 111 112 }; 112 113 114 114 + export const createNull = (): ts.NullLiteral => ts.factory.createNull(); 115 115 + 113 116 /** 114 117 * Convert an unknown value to an expression. 115 118 * @param identifiers - list of keys that are treated as identifiers. ··· 132 135 value: T; 133 136 }): ts.Expression | undefined => { 134 137 if (value === null) { 135 135 - return ts.factory.createNull(); 138 138 + return createNull(); 136 139 } 137 140 138 141 if (Array.isArray(value)) { ··· 252 255 export const createKeywordTypeNode = ({ 253 256 keyword, 254 257 }: { 255 255 - keyword: 'any' | 'boolean' | 'string'; 258 258 + keyword: 'any' | 'boolean' | 'number' | 'string' | 'undefined' | 'unknown'; 256 259 }) => { 257 260 let kind: ts.KeywordTypeSyntaxKind = ts.SyntaxKind.AnyKeyword; 258 261 switch (keyword) { 259 262 case 'boolean': 260 263 kind = ts.SyntaxKind.BooleanKeyword; 261 264 break; 265 265 + case 'number': 266 266 + kind = ts.SyntaxKind.NumberKeyword; 267 267 + break; 262 268 case 'string': 263 269 kind = ts.SyntaxKind.StringKeyword; 264 270 break; 271 271 + case 'undefined': 272 272 + kind = ts.SyntaxKind.UndefinedKeyword; 273 273 + break; 274 274 + case 'unknown': 275 275 + kind = ts.SyntaxKind.UnknownKeyword; 276 276 + break; 265 277 } 266 278 return ts.factory.createKeywordTypeNode(kind); 267 279 }; ··· 287 299 : undefined, 288 300 ), 289 301 ); 302 302 + 303 303 + export const createLiteralTypeNode = ({ 304 304 + literal, 305 305 + }: { 306 306 + literal: ts.LiteralTypeNode['literal']; 307 307 + }) => { 308 308 + const node = ts.factory.createLiteralTypeNode(literal); 309 309 + return node; 310 310 + }; 290 311 291 312 /** 292 313 * Create arrow function type expression. ··· 559 580 }) 560 581 .filter(isType<ObjectAssignment>); 561 582 562 562 - const expression = ts.factory.createObjectLiteralExpression( 583 583 + const node = ts.factory.createObjectLiteralExpression( 563 584 properties as any[], 564 585 multiLine, 565 586 ); 566 587 567 588 addLeadingComments({ 568 589 comments, 569 569 - node: expression, 590 590 + node, 570 591 }); 571 592 572 572 - return expression; 593 593 + return node; 573 594 }; 574 595 575 596 /** 576 597 * Create enum declaration. Example `export enum T = { X, Y };` 577 577 - * @param comments - comments to add to each property of enum. 598 598 + * @param comments - comments to add to each property. 578 599 * @param leadingComment - leading comment to add to enum. 579 600 * @param name - the name of the enum. 580 601 * @param obj - the object representing the enum. 581 581 - * @returns 602 602 + * @returns ts.EnumDeclaration 582 603 */ 583 583 - export const createEnumDeclaration = <T extends object>({ 584 584 - comments, 585 585 - leadingComment, 604 604 + export const createEnumDeclaration = < 605 605 + T extends Record<string, any> | Array<ObjectValue>, 606 606 + >({ 607 607 + comments: enumMemberComments = {}, 608 608 + leadingComment: comments, 586 609 name, 587 610 obj, 588 611 }: { ··· 591 614 name: string; 592 615 obj: T; 593 616 }): ts.EnumDeclaration => { 594 594 - const declaration = ts.factory.createEnumDeclaration( 595 595 - [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], 596 596 - createIdentifier({ text: name }), 597 597 - Object.entries(obj).map(([key, value]) => { 598 598 - const initializer = toExpression({ unescape: true, value }); 599 599 - const assignment = ts.factory.createEnumMember(key, initializer); 600 600 - const comment = comments?.[key]; 617 617 + const members: Array<ts.EnumMember> = Array.isArray(obj) 618 618 + ? obj.map((value) => { 619 619 + const enumMember = ts.factory.createEnumMember( 620 620 + escapeName(value.key), 621 621 + toExpression({ 622 622 + value: value.value, 623 623 + }), 624 624 + ); 625 625 + 626 626 + addLeadingComments({ 627 627 + comments: value.comments, 628 628 + node: enumMember, 629 629 + }); 630 630 + 631 631 + return enumMember; 632 632 + }) 633 633 + : Object.entries(obj).map(([key, value]) => { 634 634 + const initializer = toExpression({ unescape: true, value }); 635 635 + const enumMember = ts.factory.createEnumMember(key, initializer); 636 636 + 637 637 + addLeadingComments({ 638 638 + comments: enumMemberComments[key], 639 639 + node: enumMember, 640 640 + }); 601 641 602 602 - addLeadingComments({ 603 603 - comments: comment, 604 604 - node: assignment, 642 642 + return enumMember; 605 643 }); 606 644 607 607 - return assignment; 608 608 - }), 645 645 + const node = ts.factory.createEnumDeclaration( 646 646 + [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], 647 647 + createIdentifier({ text: name }), 648 648 + members, 609 649 ); 610 650 611 651 addLeadingComments({ 612 612 - comments: leadingComment, 613 613 - node: declaration, 652 652 + comments, 653 653 + node, 614 654 }); 615 655 616 616 - return declaration; 656 656 + return node; 617 657 }; 618 658 619 659 /** ··· 622 662 * @param nodes - the nodes in the namespace. 623 663 * @returns 624 664 */ 625 625 - export const createNamespaceDeclaration = < 626 626 - T extends Array<ts.EnumDeclaration>, 627 627 - >({ 665 665 + export const createNamespaceDeclaration = ({ 628 666 name, 629 667 statements, 630 668 }: { 631 669 name: string; 632 632 - statements: T; 670 670 + statements: Array<ts.Statement>; 633 671 }) => 634 672 ts.factory.createModuleDeclaration( 635 673 [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ··· 649 687 return node; 650 688 }; 651 689 652 652 - export const createStringLiteral = ({ text }: { text: string }) => { 653 653 - const node = ts.factory.createStringLiteral(text); 690 690 + export const createStringLiteral = ({ 691 691 + isSingleQuote, 692 692 + text, 693 693 + }: { 694 694 + isSingleQuote?: boolean; 695 695 + text: string; 696 696 + }) => { 697 697 + if (isSingleQuote === undefined) { 698 698 + isSingleQuote = !text.includes("'"); 699 699 + } 700 700 + const node = ts.factory.createStringLiteral(text, isSingleQuote); 654 701 return node; 655 702 }; 656 703

+5 -14

packages/openapi-ts/src/compiler/utils.ts

reviewed

··· 2 2 3 3 import { getConfig } from '../utils/config'; 4 4 import { unescapeName } from '../utils/escape'; 5 5 + import { createStringLiteral } from './types'; 5 6 6 7 export interface ImportExportItemObject { 7 8 alias?: string; ··· 9 10 name: string; 10 11 } 11 12 12 12 - export const CONFIG = { 13 13 - newLine: ts.NewLineKind.LineFeed, 14 14 - scriptKind: ts.ScriptKind.TS, 15 15 - scriptTarget: ts.ScriptTarget.ES2015, 16 16 - useSingleQuotes: true, 17 17 - }; 18 18 - 19 19 - const printer = ts.createPrinter({ newLine: CONFIG.newLine }); 13 13 + const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }); 20 14 21 15 export const createSourceFile = (sourceText: string) => 22 16 ts.createSourceFile( 23 17 '', 24 18 sourceText, 25 25 - CONFIG.scriptTarget, 19 19 + ts.ScriptTarget.ES2015, 26 20 undefined, 27 27 - CONFIG.scriptKind, 21 21 + ts.ScriptKind.TS, 28 22 ); 29 23 30 24 const blankSourceFile = createSourceFile(''); ··· 145 139 if (text.startsWith('`')) { 146 140 return createIdentifier({ text }); 147 141 } 148 148 - return ts.factory.createStringLiteral( 149 149 - text, 150 150 - text.includes("'") ? false : CONFIG.useSingleQuotes, 151 151 - ); 142 142 + return createStringLiteral({ text }); 152 143 }, 153 144 }; 154 145

+1 -1

packages/openapi-ts/src/generate/__tests__/index.spec.ts

reviewed

··· 3 3 4 4 import { describe, expect, it, vi } from 'vitest'; 5 5 6 6 - import { TypeScriptFile } from '../../compiler'; 7 6 import { setConfig } from '../../utils/config'; 7 7 + import { TypeScriptFile } from '../files'; 8 8 import { generateIndexFile } from '../indexFile'; 9 9 10 10 vi.mock('node:fs');

+8 -2

packages/openapi-ts/src/generate/__tests__/output.spec.ts

reviewed

··· 2 2 3 3 import { describe, expect, it, vi } from 'vitest'; 4 4 5 5 + import type { Client } from '../../types/client'; 5 6 import { setConfig } from '../../utils/config'; 6 7 import { generateOutput } from '../output'; 7 8 import { mockTemplates, openApi } from './mocks'; ··· 33 34 useOptions: false, 34 35 }); 35 36 36 36 - const client: Parameters<typeof generateOutput>[1] = { 37 37 + const client: Client = { 37 38 models: [], 38 39 server: 'http://localhost:8080', 39 40 services: [], ··· 41 42 version: 'v1', 42 43 }; 43 44 44 44 - await generateOutput(openApi, client, mockTemplates); 45 45 + await generateOutput({ 46 46 + client, 47 47 + context: undefined, 48 48 + openApi, 49 49 + templates: mockTemplates, 50 50 + }); 45 51 46 52 expect(rmSync).toHaveBeenCalled(); 47 53 expect(mkdirSync).toHaveBeenCalled();

+21 -5

packages/openapi-ts/src/generate/__tests__/services.spec.ts

reviewed

··· 3 3 4 4 import { describe, expect, it, vi } from 'vitest'; 5 5 6 6 - import { TypeScriptFile } from '../../compiler'; 7 6 import type { Operation } from '../../types/client'; 8 7 import type { Files } from '../../types/utils'; 9 8 import { setConfig } from '../../utils/config'; 9 9 + import { TypeScriptFile } from '../files'; 10 10 import { generateServices } from '../services'; 11 11 12 12 vi.mock('node:fs'); ··· 80 80 name: 'types.ts', 81 81 }); 82 82 83 83 - await generateServices({ client, files }); 83 83 + await generateServices({ 84 84 + client, 85 85 + context: undefined, 86 86 + files, 87 87 + }); 84 88 85 89 files.services.write(); 86 90 ··· 162 166 name: 'types.ts', 163 167 }); 164 168 165 165 - await generateServices({ client, files }); 169 169 + await generateServices({ 170 170 + client, 171 171 + context: undefined, 172 172 + files, 173 173 + }); 166 174 167 175 files.services.write(); 168 176 ··· 206 214 name: 'types.ts', 207 215 }); 208 216 209 209 - await generateServices({ client, files }); 217 217 + await generateServices({ 218 218 + client, 219 219 + context: undefined, 220 220 + files, 221 221 + }); 210 222 211 223 files.services.write(); 212 224 ··· 252 264 name: 'types.ts', 253 265 }); 254 266 255 255 - await generateServices({ client, files }); 267 267 + await generateServices({ 268 268 + client, 269 269 + context: undefined, 270 270 + files, 271 271 + }); 256 272 257 273 files.services.write(); 258 274

+2 -1

packages/openapi-ts/src/generate/__tests__/types.spec.ts

reviewed

··· 3 3 4 4 import { describe, expect, it, vi } from 'vitest'; 5 5 6 6 - import { TypeScriptFile } from '../../compiler'; 7 6 import { setConfig } from '../../utils/config'; 7 7 + import { TypeScriptFile } from '../files'; 8 8 import { generateTypes } from '../types'; 9 9 10 10 vi.mock('node:fs'); ··· 75 75 76 76 await generateTypes({ 77 77 client, 78 78 + context: undefined, 78 79 files, 79 80 }); 80 81

+176

packages/openapi-ts/src/generate/files/index.ts

reviewed

··· 1 1 + import { type PathLike, rmSync, writeFileSync } from 'node:fs'; 2 2 + import path from 'node:path'; 3 3 + 4 4 + import type ts from 'typescript'; 5 5 + 6 6 + import { compiler } from '../../compiler'; 7 7 + import { 8 8 + type ImportExportItemObject, 9 9 + tsNodeToString, 10 10 + } from '../../compiler/utils'; 11 11 + import { ensureValidTypeScriptJavaScriptIdentifier } from '../../openApi'; 12 12 + import { reservedWordsRegExp } from '../../utils/regexp'; 13 13 + import { ensureDirSync } from '../utils'; 14 14 + import { ensureUniqueIdentifier, splitNameAndExtension } from './name'; 15 15 + import type { Namespaces } from './types'; 16 16 + 17 17 + export class TypeScriptFile { 18 18 + private _headers: Array<string> = []; 19 19 + private _imports = new Map<string, Map<string, ImportExportItemObject>>(); 20 20 + private _items: Array<ts.Node | string> = []; 21 21 + private _name: string; 22 22 + private _path: PathLike; 23 23 + 24 24 + public namespaces: Namespaces = { 25 25 + type: {}, 26 26 + value: {}, 27 27 + }; 28 28 + 29 29 + public constructor({ 30 30 + dir, 31 31 + header = true, 32 32 + name, 33 33 + }: { 34 34 + dir: string; 35 35 + header?: boolean; 36 36 + name: string; 37 37 + }) { 38 38 + this._name = this._setName(name); 39 39 + this._path = path.resolve(dir, this.getName()); 40 40 + 41 41 + if (header) { 42 42 + this._headers.push( 43 43 + '// This file is auto-generated by @hey-api/openapi-ts', 44 44 + ); 45 45 + } 46 46 + } 47 47 + 48 48 + public add(...nodes: Array<ts.Node | string>) { 49 49 + this._items = this._items.concat(nodes); 50 50 + } 51 51 + 52 52 + public identifier({ 53 53 + namespace, 54 54 + ...args 55 55 + }: Omit<Parameters<typeof ensureUniqueIdentifier>[0], 'namespace'> & { 56 56 + namespace: keyof Namespaces; 57 57 + }) { 58 58 + let validNameTransformer: ((name: string) => string) | undefined; 59 59 + switch (namespace) { 60 60 + // TODO: parser - add case transformers 61 61 + case 'type': 62 62 + case 'value': 63 63 + validNameTransformer = (name) => 64 64 + ensureValidTypeScriptJavaScriptIdentifier(name).replace( 65 65 + reservedWordsRegExp, 66 66 + '_$1', 67 67 + ); 68 68 + break; 69 69 + } 70 70 + return ensureUniqueIdentifier({ 71 71 + namespace: this.namespaces[namespace], 72 72 + validNameTransformer, 73 73 + ...args, 74 74 + }); 75 75 + } 76 76 + 77 77 + /** 78 78 + * Adds an import to the provided module. Handles duplication, returns added import. 79 79 + */ 80 80 + public import({ 81 81 + module, 82 82 + ...importedItem 83 83 + }: ImportExportItemObject & { 84 84 + module: string; 85 85 + }): ImportExportItemObject { 86 86 + let moduleMap = this._imports.get(module); 87 87 + 88 88 + if (!moduleMap) { 89 89 + moduleMap = new Map<string, ImportExportItemObject>(); 90 90 + this._imports.set(module, moduleMap); 91 91 + } 92 92 + 93 93 + const match = moduleMap.get(importedItem.name); 94 94 + if (match) { 95 95 + return match; 96 96 + } 97 97 + 98 98 + moduleMap.set(importedItem.name, importedItem); 99 99 + return importedItem; 100 100 + } 101 101 + 102 102 + public getName(withExtension = true) { 103 103 + if (withExtension) { 104 104 + return this._name; 105 105 + } 106 106 + 107 107 + const { name } = splitNameAndExtension(this._name); 108 108 + return name; 109 109 + } 110 110 + 111 111 + public isEmpty() { 112 112 + return !this._items.length; 113 113 + } 114 114 + 115 115 + public remove(options?: Parameters<typeof rmSync>[1]) { 116 116 + rmSync(this._path, options); 117 117 + } 118 118 + 119 119 + /** 120 120 + * Removes last node form the stack. Works as undo. 121 121 + */ 122 122 + public removeNode() { 123 123 + this._items = this._items.slice(0, this._items.length - 1); 124 124 + } 125 125 + 126 126 + private _setName(fileName: string) { 127 127 + if (fileName.includes('index')) { 128 128 + return fileName; 129 129 + } 130 130 + 131 131 + const { extension, name } = splitNameAndExtension(fileName); 132 132 + return [name, 'gen', extension].filter(Boolean).join('.'); 133 133 + } 134 134 + 135 135 + public toString(separator: string = '\n') { 136 136 + let output: string[] = []; 137 137 + if (this._headers.length) { 138 138 + output.push(this._headers.join('\n')); 139 139 + } 140 140 + const importsStringArray: string[] = []; 141 141 + for (const [_module, moduleMap] of this._imports.entries()) { 142 142 + const imports = Array.from(moduleMap.values()); 143 143 + const node = compiler.namedImportDeclarations({ 144 144 + imports, 145 145 + module: _module, 146 146 + }); 147 147 + importsStringArray.push(tsNodeToString({ node })); 148 148 + } 149 149 + if (importsStringArray.length) { 150 150 + output.push(importsStringArray.join('\n')); 151 151 + } 152 152 + output = output.concat( 153 153 + this._items.map((node) => 154 154 + typeof node === 'string' 155 155 + ? node 156 156 + : tsNodeToString({ node, unescape: true }), 157 157 + ), 158 158 + ); 159 159 + return output.join(separator); 160 160 + } 161 161 + 162 162 + public write(separator = '\n') { 163 163 + if (this.isEmpty()) { 164 164 + this.remove({ force: true }); 165 165 + return; 166 166 + } 167 167 + 168 168 + let dir = this._path; 169 169 + if (typeof this._path === 'string') { 170 170 + const parts = this._path.split(path.sep); 171 171 + dir = parts.slice(0, parts.length - 1).join(path.sep); 172 172 + } 173 173 + ensureDirSync(dir); 174 174 + writeFileSync(this._path, this.toString(separator)); 175 175 + } 176 176 + }

+84

packages/openapi-ts/src/generate/files/name.ts

reviewed

··· 1 1 + import type { EnsureUniqueIdentifierResult, Namespace } from './types'; 2 2 + 3 3 + export const ensureUniqueIdentifier = ({ 4 4 + $ref, 5 5 + count = 1, 6 6 + create = false, 7 7 + namespace, 8 8 + validNameTransformer, 9 9 + }: { 10 10 + $ref: string; 11 11 + count?: number; 12 12 + create?: boolean; 13 13 + namespace: Namespace; 14 14 + validNameTransformer?: (value: string) => string; 15 15 + }): EnsureUniqueIdentifierResult => { 16 16 + const parts = $ref.split('/'); 17 17 + let name = parts[parts.length - 1] || ''; 18 18 + 19 19 + if (!name) { 20 20 + return { 21 21 + created: false, 22 22 + name: '', 23 23 + }; 24 24 + } 25 25 + 26 26 + const refValue = namespace[$ref]; 27 27 + if (refValue) { 28 28 + return { 29 29 + created: false, 30 30 + name: refValue.name, 31 31 + }; 32 32 + } 33 33 + 34 34 + if (count > 1) { 35 35 + name = `${name}${count}`; 36 36 + } 37 37 + 38 38 + let nameValue = namespace[name]; 39 39 + if (nameValue) { 40 40 + if (nameValue.$ref === $ref) { 41 41 + return { 42 42 + created: false, 43 43 + name: nameValue.name, 44 44 + }; 45 45 + } 46 46 + 47 47 + return ensureUniqueIdentifier({ 48 48 + $ref, 49 49 + count: count + 1, 50 50 + create, 51 51 + namespace, 52 52 + validNameTransformer, 53 53 + }); 54 54 + } 55 55 + 56 56 + if (!create) { 57 57 + return { 58 58 + created: false, 59 59 + name: '', 60 60 + }; 61 61 + } 62 62 + 63 63 + nameValue = { 64 64 + $ref, 65 65 + name: validNameTransformer ? validNameTransformer(name) : name, 66 66 + }; 67 67 + namespace[name] = nameValue; 68 68 + namespace[nameValue.$ref] = nameValue; 69 69 + 70 70 + return { 71 71 + created: true, 72 72 + name: nameValue.name, 73 73 + }; 74 74 + }; 75 75 + 76 76 + export const splitNameAndExtension = (fileName: string) => { 77 77 + const match = fileName.match(/\.[0-9a-z]+$/i); 78 78 + const extension = match ? match[0].slice(1) : ''; 79 79 + const name = fileName.slice( 80 80 + 0, 81 81 + fileName.length - (extension ? extension.length + 1 : 0), 82 82 + ); 83 83 + return { extension, name }; 84 84 + };

+33

packages/openapi-ts/src/generate/files/types.ts

reviewed

··· 1 1 + import type { ModelMeta } from '../../openApi'; 2 2 + 3 3 + export type Namespace = Record<string, ModelMeta>; 4 4 + 5 5 + export interface Namespaces { 6 6 + /** 7 7 + * Type namespace. Types, interfaces, and type aliases exist here. 8 8 + * @example 9 9 + * ```ts 10 10 + * export type Foo = string; 11 11 + * ``` 12 12 + */ 13 13 + type: Namespace; 14 14 + /** 15 15 + * Value namespace. Variables, functions, classes, and constants exist here. 16 16 + * @example 17 17 + * ```js 18 18 + * export const foo = ''; 19 19 + * ``` 20 20 + */ 21 21 + value: Namespace; 22 22 + } 23 23 + 24 24 + export interface EnsureUniqueIdentifierResult { 25 25 + /** 26 26 + * Did this function add a new property to the file's `identifiers` map? 27 27 + */ 28 28 + created: boolean; 29 29 + /** 30 30 + * Unique name for the resource. 31 31 + */ 32 32 + name: string; 33 33 + }

+2 -1

packages/openapi-ts/src/generate/indexFile.ts

reviewed

··· 1 1 - import { compiler, TypeScriptFile } from '../compiler'; 1 1 + import { compiler } from '../compiler'; 2 2 import type { Files } from '../types/utils'; 3 3 import { getConfig } from '../utils/config'; 4 4 + import { TypeScriptFile } from './files'; 4 5 5 6 export const generateIndexFile = async ({ 6 7 files,

+78 -37

packages/openapi-ts/src/generate/output.ts

reviewed

··· 1 1 import path from 'node:path'; 2 2 3 3 + import type { IRContext } from '../ir/context'; 3 4 import type { OpenApi } from '../openApi'; 4 5 import type { Client } from '../types/client'; 5 6 import type { Files } from '../types/utils'; ··· 21 22 * @param client Client containing models, schemas, and services 22 23 * @param templates Templates wrapper with all loaded Handlebars templates 23 24 */ 24 24 - export const generateOutput = async ( 25 25 - openApi: OpenApi, 26 26 - client: Client, 27 27 - templates: Templates, 28 28 - ): Promise<void> => { 25 25 + export const generateOutput = async ({ 26 26 + client, 27 27 + context, 28 28 + openApi, 29 29 + templates, 30 30 + }: { 31 31 + client: Client | undefined; 32 32 + context: IRContext | undefined; 33 33 + openApi: OpenApi; 34 34 + templates: Templates; 35 35 + }): Promise<void> => { 29 36 const config = getConfig(); 30 37 31 31 - if (config.services.include && config.services.asClass) { 32 32 - const regexp = new RegExp(config.services.include); 33 33 - client.services = client.services.filter((service) => 34 34 - regexp.test(service.name), 35 35 - ); 36 36 - } 38 38 + // TODO: parser - handle IR 39 39 + if (client) { 40 40 + if (config.services.include && config.services.asClass) { 41 41 + const regexp = new RegExp(config.services.include); 42 42 + client.services = client.services.filter((service) => 43 43 + regexp.test(service.name), 44 44 + ); 45 45 + } 37 46 38 38 - if (config.types.include) { 39 39 - const regexp = new RegExp(config.types.include); 40 40 - client.models = client.models.filter((model) => regexp.test(model.name)); 47 47 + if (config.types.include) { 48 48 + const regexp = new RegExp(config.types.include); 49 49 + client.models = client.models.filter((model) => regexp.test(model.name)); 50 50 + } 41 51 } 42 52 43 53 const outputPath = path.resolve(config.output.path); ··· 47 57 await generateClient(outputPath, config.client.name); 48 58 49 59 // types.gen.ts 50 50 - await generateTypes({ client, files }); 60 60 + await generateTypes({ 61 61 + client, 62 62 + context, 63 63 + files, 64 64 + }); 51 65 52 66 // schemas.gen.ts 53 67 await generateSchemas({ files, openApi }); 54 68 55 69 // transformers 56 56 - if ( 57 57 - config.services.export && 58 58 - client.services.length && 59 59 - config.types.dates === 'types+transform' 60 60 - ) { 61 61 - await generateResponseTransformers({ 62 62 - client, 63 63 - onNode: (node) => { 64 64 - files.types?.add(node); 65 65 - }, 66 66 - onRemoveNode: () => { 67 67 - files.types?.removeNode(); 68 68 - }, 69 69 - }); 70 70 + // TODO: parser - handle IR 71 71 + if (client) { 72 72 + if ( 73 73 + config.services.export && 74 74 + client.services.length && 75 75 + config.types.dates === 'types+transform' 76 76 + ) { 77 77 + await generateResponseTransformers({ 78 78 + client, 79 79 + onNode: (node) => { 80 80 + files.types?.add(node); 81 81 + }, 82 82 + onRemoveNode: () => { 83 83 + files.types?.removeNode(); 84 84 + }, 85 85 + }); 86 86 + } 70 87 } 71 88 72 89 // services.gen.ts 73 73 - await generateServices({ client, files }); 90 90 + await generateServices({ 91 91 + client, 92 92 + context, 93 93 + files, 94 94 + }); 74 95 75 96 // deprecated files 76 76 - await generateClientClass(openApi, outputPath, client, templates); 77 77 - await generateCore( 78 78 - path.resolve(config.output.path, 'core'), 79 79 - client, 80 80 - templates, 81 81 - ); 97 97 + if (client) { 98 98 + await generateClientClass(openApi, outputPath, client, templates); 99 99 + await generateCore( 100 100 + path.resolve(config.output.path, 'core'), 101 101 + client, 102 102 + templates, 103 103 + ); 104 104 + } 82 105 83 106 // index.ts. Any files generated after this won't be included in exports 84 107 // from the index file. 85 108 await generateIndexFile({ files }); 86 109 87 110 // plugins 88 88 - await generatePlugins({ client, files }); 111 111 + await generatePlugins({ 112 112 + client, 113 113 + context, 114 114 + files, 115 115 + }); 89 116 90 117 Object.entries(files).forEach(([name, file]) => { 91 118 if (config.dryRun) { ··· 98 125 file.write('\n\n'); 99 126 } 100 127 }); 128 128 + 129 129 + if (context) { 130 130 + Object.entries(context.files).forEach(([name, file]) => { 131 131 + if (config.dryRun) { 132 132 + return; 133 133 + } 134 134 + 135 135 + if (name === 'index') { 136 136 + file.write(); 137 137 + } else { 138 138 + file.write('\n\n'); 139 139 + } 140 140 + }); 141 141 + } 101 142 };

+19 -7

packages/openapi-ts/src/generate/plugins.ts

reviewed

··· 1 1 import path from 'node:path'; 2 2 3 3 - import { TypeScriptFile } from '../compiler'; 3 3 + import type { IRContext } from '../ir/context'; 4 4 import type { Client } from '../types/client'; 5 5 import type { Files } from '../types/utils'; 6 6 import { getConfig, isLegacyClient } from '../utils/config'; 7 7 + import { TypeScriptFile } from './files'; 7 8 8 9 export const generatePlugins = async ({ 9 10 client, 10 11 files, 12 12 + context, 11 13 }: { 12 12 - client: Client; 14 14 + client: Client | undefined; 15 15 + context: IRContext | undefined; 13 16 files: Files; 14 17 }) => { 15 18 const config = getConfig(); ··· 29 32 dir: outputDir, 30 33 name: `${outputParts[outputParts.length - 1]}.ts`, 31 34 }); 32 32 - plugin.handler({ 33 33 - client, 34 34 - files, 35 35 - plugin: plugin as never, 36 36 - }); 35 35 + 36 36 + if (context) { 37 37 + plugin.handler_experimental({ 38 38 + context, 39 39 + files, 40 40 + plugin: plugin as never, 41 41 + }); 42 42 + } else if (client) { 43 43 + plugin.handler({ 44 44 + client, 45 45 + files, 46 46 + plugin: plugin as never, 47 47 + }); 48 48 + } 37 49 } 38 50 };

+2 -1

packages/openapi-ts/src/generate/schemas.ts

reviewed

··· 1 1 - import { compiler, TypeScriptFile } from '../compiler'; 1 1 + import { compiler } from '../compiler'; 2 2 import type { OpenApi, OpenApiV2Schema, OpenApiV3Schema } from '../openApi'; 3 3 import { ensureValidTypeScriptJavaScriptIdentifier } from '../openApi'; 4 4 import type { Files } from '../types/utils'; 5 5 import { getConfig } from '../utils/config'; 6 6 + import { TypeScriptFile } from './files'; 6 7 7 8 const ensureValidSchemaOutput = ( 8 9 schema: unknown,

+193 -40

packages/openapi-ts/src/generate/services.ts

reviewed

··· 4 4 FunctionParameter, 5 5 Node, 6 6 } from '../compiler'; 7 7 - import { compiler, TypeScriptFile } from '../compiler'; 7 7 + import { compiler } from '../compiler'; 8 8 import type { FunctionTypeParameter, ObjectValue } from '../compiler/types'; 9 9 + import type { IRContext } from '../ir/context'; 10 10 + import type { 11 11 + IROperationObject, 12 12 + IRPathItemObject, 13 13 + IRPathsObject, 14 14 + } from '../ir/ir'; 9 15 import { isOperationParameterRequired } from '../openApi'; 10 16 import type { 11 17 Client, ··· 14 20 OperationParameter, 15 21 Service, 16 22 } from '../types/client'; 23 23 + import type { Config } from '../types/config'; 17 24 import type { Files } from '../types/utils'; 18 25 import { camelCase } from '../utils/camelCase'; 19 26 import { getConfig, isLegacyClient } from '../utils/config'; ··· 23 30 import { setUniqueTypeName } from '../utils/type'; 24 31 import { unique } from '../utils/unique'; 25 32 import { clientModulePath, clientOptionsTypeName } from './client'; 33 33 + import { TypeScriptFile } from './files'; 34 34 + import { irRef } from './types'; 26 35 27 36 type OnNode = (node: Node) => void; 28 37 type OnImport = (name: string) => void; ··· 58 67 export const modelResponseTransformerTypeName = (name: string) => 59 68 `${name}ModelResponseTransformer`; 60 69 70 70 + interface OperationIRRef { 71 71 + /** 72 72 + * Operation ID 73 73 + */ 74 74 + id: string; 75 75 + } 76 76 + 77 77 + const operationIrRef = ({ 78 78 + id, 79 79 + type, 80 80 + }: OperationIRRef & { 81 81 + type: 'data' | 'error' | 'response'; 82 82 + }): string => { 83 83 + let affix = ''; 84 84 + switch (type) { 85 85 + case 'data': 86 86 + affix = 'Data'; 87 87 + break; 88 88 + case 'error': 89 89 + affix = 'Error'; 90 90 + break; 91 91 + case 'response': 92 92 + affix = 'Response'; 93 93 + break; 94 94 + } 95 95 + return `${irRef}${camelCase({ 96 96 + input: id, 97 97 + pascalCase: true, 98 98 + })}${affix}`; 99 99 + }; 100 100 + 101 101 + export const operationDataRef = ({ id }: OperationIRRef): string => 102 102 + operationIrRef({ id, type: 'data' }); 103 103 + 61 104 export const operationDataTypeName = (name: string) => 62 105 `${camelCase({ 63 106 input: name, 64 107 pascalCase: true, 65 108 })}Data`; 66 109 110 110 + export const operationErrorRef = ({ id }: OperationIRRef): string => 111 111 + operationIrRef({ id, type: 'error' }); 112 112 + 67 113 export const operationErrorTypeName = (name: string) => 68 114 `${camelCase({ 69 115 input: name, ··· 73 119 // operation response type ends with "Response", it's enough to append "Transformer" 74 120 export const operationResponseTransformerTypeName = (name: string) => 75 121 `${name}Transformer`; 122 122 + 123 123 + export const operationResponseRef = ({ id }: OperationIRRef): string => 124 124 + operationIrRef({ id, type: 'response' }); 76 125 77 126 export const operationResponseTypeName = (name: string) => 78 127 `${camelCase({ ··· 463 512 }); 464 513 }; 465 514 466 466 - export const toOperationName = ( 467 467 - operation: Operation, 468 468 - handleIllegal: boolean, 469 469 - ) => { 470 470 - const config = getConfig(); 471 471 - 515 515 + export const toOperationName = ({ 516 516 + config, 517 517 + id, 518 518 + operation, 519 519 + handleIllegal, 520 520 + }: { 521 521 + config: Config; 522 522 + handleIllegal?: boolean; 523 523 + id: string; 524 524 + operation: IROperationObject | Operation; 525 525 + }) => { 472 526 if (config.services.methodNameBuilder) { 473 527 return config.services.methodNameBuilder(operation); 474 528 } 475 529 476 476 - if (handleIllegal && operation.name.match(reservedWordsRegExp)) { 477 477 - return `${operation.name}_`; 530 530 + if (handleIllegal && id.match(reservedWordsRegExp)) { 531 531 + return `${id}_`; 478 532 } 479 533 480 480 - return operation.name; 534 534 + return id; 481 535 }; 482 536 483 537 const toOperationStatements = ( ··· 651 705 comment: toOperationComment(operation), 652 706 exportConst: true, 653 707 expression, 654 654 - name: toOperationName(operation, true), 708 708 + name: toOperationName({ 709 709 + config, 710 710 + handleIllegal: true, 711 711 + id: operation.name, 712 712 + operation, 713 713 + }), 655 714 }); 656 715 onNode(statement); 657 716 } ··· 664 723 comment: toOperationComment(operation), 665 724 isStatic: 666 725 config.name === undefined && config.client.name !== 'legacy/angular', 667 667 - name: toOperationName(operation, false), 726 726 + name: toOperationName({ 727 727 + config, 728 728 + id: operation.name, 729 729 + operation, 730 730 + }), 668 731 parameters: toOperationParamType(client, operation), 669 732 returnType: !isLegacy 670 733 ? undefined ··· 723 786 ? { args: [{ providedIn: 'root' }], name: 'Injectable' } 724 787 : undefined, 725 788 members, 726 726 - name: transformServiceName(service.name), 789 789 + name: transformServiceName({ 790 790 + config, 791 791 + name: service.name, 792 792 + }), 727 793 }); 728 794 onNode(statement); 729 795 }; 730 796 731 731 - const checkPrerequisites = ({ files }: { files: Files }) => { 732 732 - const config = getConfig(); 797 797 + const checkPrerequisites = ({ 798 798 + context, 799 799 + files, 800 800 + }: { 801 801 + context: IRContext | undefined; 802 802 + files: Files; 803 803 + }) => { 804 804 + if (!context) { 805 805 + const config = getConfig(); 806 806 + 807 807 + if (!config.client.name) { 808 808 + throw new Error( 809 809 + '🚫 client needs to be set to generate services - which HTTP client do you want to use?', 810 810 + ); 811 811 + } 812 812 + 813 813 + if (!files.types) { 814 814 + throw new Error( 815 815 + '🚫 types need to be exported to generate services - enable type generation', 816 816 + ); 817 817 + } 818 818 + 819 819 + return; 820 820 + } 733 821 734 734 - if (!config.client.name) { 822 822 + if (!context.config.client.name) { 735 823 throw new Error( 736 824 '🚫 client needs to be set to generate services - which HTTP client do you want to use?', 737 825 ); 738 826 } 739 827 740 740 - if (!files.types) { 828 828 + if (!context.file({ id: 'types' })) { 741 829 throw new Error( 742 830 '🚫 types need to be exported to generate services - enable type generation', 743 831 ); ··· 746 834 747 835 export const generateServices = async ({ 748 836 client, 837 837 + context, 749 838 files, 750 839 }: { 751 751 - client: Client; 840 840 + client: Client | undefined; 841 841 + context: IRContext | undefined; 752 842 files: Files; 753 843 }): Promise<void> => { 754 844 const config = getConfig(); ··· 757 847 return; 758 848 } 759 849 760 760 - checkPrerequisites({ files }); 850 850 + checkPrerequisites({ context, files }); 761 851 762 852 const isLegacy = isLegacyClient(config); 763 853 ··· 854 944 files.services.add(statement); 855 945 } 856 946 857 857 - for (const service of client.services) { 858 858 - processService({ 859 859 - client, 860 860 - onClientImport: (imported) => { 861 861 - files.services.import({ 862 862 - module: clientModulePath({ sourceOutput: servicesOutput }), 863 863 - name: imported, 864 864 - }); 865 865 - }, 866 866 - onImport: (imported) => { 867 867 - files.services.import({ 868 868 - // this detection could be done safer, but it shouldn't cause any issues 869 869 - asType: !imported.endsWith('Transformer'), 870 870 - module: `./${files.types.getName(false)}`, 871 871 - name: imported, 947 947 + if (client) { 948 948 + for (const service of client.services) { 949 949 + processService({ 950 950 + client, 951 951 + onClientImport: (imported) => { 952 952 + files.services.import({ 953 953 + module: clientModulePath({ sourceOutput: servicesOutput }), 954 954 + name: imported, 955 955 + }); 956 956 + }, 957 957 + onImport: (imported) => { 958 958 + files.services.import({ 959 959 + // this detection could be done safer, but it shouldn't cause any issues 960 960 + asType: !imported.endsWith('Transformer'), 961 961 + module: `./${files.types.getName(false)}`, 962 962 + name: imported, 963 963 + }); 964 964 + }, 965 965 + onNode: (node) => { 966 966 + files.services.add(node); 967 967 + }, 968 968 + service, 969 969 + }); 970 970 + } 971 971 + return; 972 972 + } 973 973 + 974 974 + if (!context) { 975 975 + return; 976 976 + } 977 977 + 978 978 + // TODO: parser - generate services 979 979 + for (const path in context.ir.paths) { 980 980 + const pathItem = context.ir.paths[path as keyof IRPathsObject]; 981 981 + // console.warn(pathItem) 982 982 + 983 983 + for (const method in pathItem) { 984 984 + const operation = pathItem[method as keyof IRPathItemObject]!; 985 985 + 986 986 + if (operation.parameters) { 987 987 + const identifier = context.file({ id: 'types' })!.identifier({ 988 988 + $ref: operationDataRef({ id: operation.id }), 989 989 + namespace: 'type', 872 990 }); 873 873 - }, 874 874 - onNode: (node) => { 875 875 - files.services.add(node); 876 876 - }, 877 877 - service, 878 878 - }); 991 991 + if (identifier.name) { 992 992 + files.services.import({ 993 993 + // this detection could be done safer, but it shouldn't cause any issues 994 994 + asType: !identifier.name.endsWith('Transformer'), 995 995 + module: `./${context.file({ id: 'types' })!.getName(false)}`, 996 996 + name: identifier.name, 997 997 + }); 998 998 + } 999 999 + } 1000 1000 + 1001 1001 + // if (!isLegacy) { 1002 1002 + // generateImport({ 1003 1003 + // client, 1004 1004 + // meta: { 1005 1005 + // // TODO: this should be exact ref to operation for consistency, 1006 1006 + // // but name should work too as operation ID is unique 1007 1007 + // $ref: operation.name, 1008 1008 + // name: operation.name, 1009 1009 + // }, 1010 1010 + // nameTransformer: operationErrorTypeName, 1011 1011 + // onImport, 1012 1012 + // }); 1013 1013 + // } 1014 1014 + 1015 1015 + // const successResponses = operation.responses.filter((response) => 1016 1016 + // response.responseTypes.includes('success'), 1017 1017 + // ); 1018 1018 + // if (successResponses.length) { 1019 1019 + // generateImport({ 1020 1020 + // client, 1021 1021 + // meta: { 1022 1022 + // // TODO: this should be exact ref to operation for consistency, 1023 1023 + // // but name should work too as operation ID is unique 1024 1024 + // $ref: operation.name, 1025 1025 + // name: operation.name, 1026 1026 + // }, 1027 1027 + // nameTransformer: operationResponseTypeName, 1028 1028 + // onImport, 1029 1029 + // }); 1030 1030 + // } 1031 1031 + } 879 1032 } 880 1033 };

+1139 -21

packages/openapi-ts/src/generate/types.ts

reviewed

··· 1 1 import type { EnumDeclaration } from 'typescript'; 2 2 + import type ts from 'typescript'; 2 3 4 4 + import type { Property } from '../compiler'; 5 5 + import { type Comments, compiler, type Node } from '../compiler'; 6 6 + import type { IRContext } from '../ir/context'; 7 7 + import type { 8 8 + IROperationObject, 9 9 + IRParameterObject, 10 10 + IRPathsObject, 11 11 + IRResponseObject, 12 12 + IRSchemaObject, 13 13 + } from '../ir/ir'; 14 14 + import { addItemsToSchema } from '../ir/utils'; 3 15 import { 4 4 - type Comments, 5 5 - compiler, 6 6 - type Node, 7 7 - TypeScriptFile, 8 8 - } from '../compiler'; 9 9 - import { isOperationParameterRequired } from '../openApi'; 10 10 - import type { Method, Model, OperationParameter } from '../types/client'; 11 11 - import type { Client } from '../types/client'; 16 16 + ensureValidTypeScriptJavaScriptIdentifier, 17 17 + isOperationParameterRequired, 18 18 + } from '../openApi'; 19 19 + import type { 20 20 + Client, 21 21 + Method, 22 22 + Model, 23 23 + OperationParameter, 24 24 + } from '../types/client'; 12 25 import type { Files } from '../types/utils'; 13 26 import { getConfig, isLegacyClient } from '../utils/config'; 14 27 import { enumEntry, enumUnionType } from '../utils/enum'; 15 28 import { escapeComment } from '../utils/escape'; 29 29 + import { isRefOpenApiComponent } from '../utils/ref'; 16 30 import { sortByName, sorterByName } from '../utils/sort'; 17 31 import { 18 32 setUniqueTypeName, 19 33 type SetUniqueTypeNameResult, 20 34 toType, 21 35 } from '../utils/type'; 36 36 + import { TypeScriptFile } from './files'; 22 37 import { 38 38 + operationDataRef, 23 39 operationDataTypeName, 40 40 + operationErrorRef, 24 41 operationErrorTypeName, 42 42 + operationResponseRef, 25 43 operationResponseTypeName, 26 44 } from './services'; 27 45 ··· 32 50 onRemoveNode?: VoidFunction; 33 51 } 34 52 53 53 + interface SchemaWithType<T extends Required<IRSchemaObject>['type']> 54 54 + extends Omit<IRSchemaObject, 'type'> { 55 55 + type: Extract<Required<IRSchemaObject>['type'], T>; 56 56 + } 57 57 + 35 58 const treeName = '$OpenApiTs'; 59 59 + 60 60 + export const irRef = '#/ir/'; 61 61 + const typesId = 'types'; 36 62 37 63 export const emptyModel: Model = { 38 64 $refs: [], ··· 600 626 } 601 627 }; 602 628 629 629 + const parseSchemaJsDoc = ({ schema }: { schema: IRSchemaObject }) => { 630 630 + const comments = [ 631 631 + schema.description && escapeComment(schema.description), 632 632 + schema.deprecated && '@deprecated', 633 633 + ]; 634 634 + return comments; 635 635 + }; 636 636 + 637 637 + const addJavaScriptEnum = ({ 638 638 + $ref, 639 639 + context, 640 640 + schema, 641 641 + }: { 642 642 + $ref: string; 643 643 + context: IRContext; 644 644 + schema: SchemaWithType<'enum'>; 645 645 + }) => { 646 646 + const identifier = context.file({ id: typesId })!.identifier({ 647 647 + $ref, 648 648 + create: true, 649 649 + namespace: 'value', 650 650 + }); 651 651 + 652 652 + // TODO: parser - this is the old parser behavior where we would NOT 653 653 + // print nested enum identifiers if they already exist. This is a 654 654 + // blocker for referencing these identifiers within the file as 655 655 + // we cannot guarantee just because they have a duplicate identifier, 656 656 + // they have a duplicate value. 657 657 + if (!identifier.created) { 658 658 + return; 659 659 + } 660 660 + 661 661 + const enumObject = schemaToEnumObject({ schema }); 662 662 + 663 663 + const expression = compiler.objectExpression({ 664 664 + multiLine: true, 665 665 + obj: enumObject.obj, 666 666 + }); 667 667 + const node = compiler.constVariable({ 668 668 + assertion: 'const', 669 669 + comment: parseSchemaJsDoc({ schema }), 670 670 + exportConst: true, 671 671 + expression, 672 672 + name: identifier.name, 673 673 + }); 674 674 + return node; 675 675 + }; 676 676 + 677 677 + const schemaToEnumObject = ({ schema }: { schema: IRSchemaObject }) => { 678 678 + const typeofItems: Array< 679 679 + | 'string' 680 680 + | 'number' 681 681 + | 'bigint' 682 682 + | 'boolean' 683 683 + | 'symbol' 684 684 + | 'undefined' 685 685 + | 'object' 686 686 + | 'function' 687 687 + > = []; 688 688 + 689 689 + const obj = (schema.items ?? []).map((item) => { 690 690 + const typeOfItemConst = typeof item.const; 691 691 + 692 692 + if (!typeofItems.includes(typeOfItemConst)) { 693 693 + typeofItems.push(typeOfItemConst); 694 694 + } 695 695 + 696 696 + let key; 697 697 + if (item.title) { 698 698 + key = item.title; 699 699 + } else if (typeOfItemConst === 'number') { 700 700 + key = `_${item.const}`; 701 701 + } else if (typeOfItemConst === 'boolean') { 702 702 + const valid = typeOfItemConst ? 'true' : 'false'; 703 703 + key = valid.toLocaleUpperCase(); 704 704 + } else { 705 705 + let valid = ensureValidTypeScriptJavaScriptIdentifier( 706 706 + item.const as string, 707 707 + ); 708 708 + if (!valid) { 709 709 + // TODO: parser - abstract empty string handling 710 710 + valid = 'empty_string'; 711 711 + } 712 712 + key = valid.toLocaleUpperCase(); 713 713 + } 714 714 + return { 715 715 + comments: parseSchemaJsDoc({ schema: item }), 716 716 + key, 717 717 + value: item.const, 718 718 + }; 719 719 + }); 720 720 + 721 721 + return { 722 722 + obj, 723 723 + typeofItems, 724 724 + }; 725 725 + }; 726 726 + 727 727 + const addTypeEnum = ({ 728 728 + $ref, 729 729 + context, 730 730 + schema, 731 731 + }: { 732 732 + $ref: string; 733 733 + context: IRContext; 734 734 + schema: SchemaWithType<'enum'>; 735 735 + }) => { 736 736 + const identifier = context.file({ id: typesId })!.identifier({ 737 737 + $ref, 738 738 + create: true, 739 739 + namespace: 'type', 740 740 + }); 741 741 + 742 742 + // TODO: parser - this is the old parser behavior where we would NOT 743 743 + // print nested enum identifiers if they already exist. This is a 744 744 + // blocker for referencing these identifiers within the file as 745 745 + // we cannot guarantee just because they have a duplicate identifier, 746 746 + // they have a duplicate value. 747 747 + if ( 748 748 + !identifier.created && 749 749 + context.config.types.enums !== 'typescript+namespace' 750 750 + ) { 751 751 + return; 752 752 + } 753 753 + 754 754 + const node = compiler.typeAliasDeclaration({ 755 755 + comment: parseSchemaJsDoc({ schema }), 756 756 + exportType: true, 757 757 + name: identifier.name, 758 758 + type: schemaToType({ 759 759 + context, 760 760 + schema: { 761 761 + ...schema, 762 762 + type: undefined, 763 763 + }, 764 764 + }), 765 765 + }); 766 766 + return node; 767 767 + }; 768 768 + 769 769 + const addTypeScriptEnum = ({ 770 770 + $ref, 771 771 + context, 772 772 + schema, 773 773 + }: { 774 774 + $ref: string; 775 775 + context: IRContext; 776 776 + schema: SchemaWithType<'enum'>; 777 777 + }) => { 778 778 + const identifier = context.file({ id: typesId })!.identifier({ 779 779 + $ref, 780 780 + create: true, 781 781 + namespace: 'value', 782 782 + }); 783 783 + 784 784 + // TODO: parser - this is the old parser behavior where we would NOT 785 785 + // print nested enum identifiers if they already exist. This is a 786 786 + // blocker for referencing these identifiers within the file as 787 787 + // we cannot guarantee just because they have a duplicate identifier, 788 788 + // they have a duplicate value. 789 789 + if ( 790 790 + !identifier.created && 791 791 + context.config.types.enums !== 'typescript+namespace' 792 792 + ) { 793 793 + return; 794 794 + } 795 795 + 796 796 + const enumObject = schemaToEnumObject({ schema }); 797 797 + 798 798 + // TypeScript enums support only string and number values so we need to fallback to types 799 799 + if ( 800 800 + enumObject.typeofItems.filter( 801 801 + (type) => type !== 'number' && type !== 'string', 802 802 + ).length 803 803 + ) { 804 804 + const node = addTypeEnum({ 805 805 + $ref, 806 806 + context, 807 807 + schema, 808 808 + }); 809 809 + return node; 810 810 + } 811 811 + 812 812 + const node = compiler.enumDeclaration({ 813 813 + leadingComment: parseSchemaJsDoc({ schema }), 814 814 + name: identifier.name, 815 815 + obj: enumObject.obj, 816 816 + }); 817 817 + return node; 818 818 + }; 819 819 + 820 820 + const arrayTypeToIdentifier = ({ 821 821 + context, 822 822 + namespace, 823 823 + schema, 824 824 + }: { 825 825 + context: IRContext; 826 826 + namespace: Array<ts.Statement>; 827 827 + schema: SchemaWithType<'array'>; 828 828 + }) => { 829 829 + if (!schema.items) { 830 830 + return compiler.typeArrayNode( 831 831 + compiler.keywordTypeNode({ 832 832 + keyword: 'unknown', 833 833 + }), 834 834 + ); 835 835 + } 836 836 + 837 837 + return compiler.typeArrayNode( 838 838 + schemaToType({ 839 839 + context, 840 840 + namespace, 841 841 + schema: { 842 842 + ...schema, 843 843 + type: undefined, 844 844 + }, 845 845 + }), 846 846 + ); 847 847 + }; 848 848 + 849 849 + const booleanTypeToIdentifier = ({ 850 850 + schema, 851 851 + }: { 852 852 + context: IRContext; 853 853 + namespace: Array<ts.Statement>; 854 854 + schema: SchemaWithType<'boolean'>; 855 855 + }) => { 856 856 + if (schema.const !== undefined) { 857 857 + return compiler.literalTypeNode({ 858 858 + literal: compiler.ots.boolean(schema.const as boolean), 859 859 + }); 860 860 + } 861 861 + 862 862 + return compiler.keywordTypeNode({ 863 863 + keyword: 'boolean', 864 864 + }); 865 865 + }; 866 866 + 867 867 + const enumTypeToIdentifier = ({ 868 868 + $ref, 869 869 + context, 870 870 + namespace, 871 871 + schema, 872 872 + }: { 873 873 + $ref?: string; 874 874 + context: IRContext; 875 875 + namespace: Array<ts.Statement>; 876 876 + schema: SchemaWithType<'enum'>; 877 877 + }): ts.TypeNode => { 878 878 + // TODO: parser - add option to inline enums 879 879 + if ($ref) { 880 880 + const isRefComponent = isRefOpenApiComponent($ref); 881 881 + 882 882 + // when enums are disabled (default), emit only reusable components 883 883 + // as types, otherwise the output would be broken if we skipped all enums 884 884 + if (!context.config.types.enums && isRefComponent) { 885 885 + const typeNode = addTypeEnum({ 886 886 + $ref, 887 887 + context, 888 888 + schema, 889 889 + }); 890 890 + if (typeNode) { 891 891 + context.file({ id: typesId })!.add(typeNode); 892 892 + } 893 893 + } 894 894 + 895 895 + if (context.config.types.enums === 'javascript') { 896 896 + const typeNode = addTypeEnum({ 897 897 + $ref, 898 898 + context, 899 899 + schema, 900 900 + }); 901 901 + if (typeNode) { 902 902 + context.file({ id: typesId })!.add(typeNode); 903 903 + } 904 904 + 905 905 + const objectNode = addJavaScriptEnum({ 906 906 + $ref, 907 907 + context, 908 908 + schema, 909 909 + }); 910 910 + if (objectNode) { 911 911 + context.file({ id: typesId })!.add(objectNode); 912 912 + } 913 913 + } 914 914 + 915 915 + if (context.config.types.enums === 'typescript') { 916 916 + const enumNode = addTypeScriptEnum({ 917 917 + $ref, 918 918 + context, 919 919 + schema, 920 920 + }); 921 921 + if (enumNode) { 922 922 + context.file({ id: typesId })!.add(enumNode); 923 923 + } 924 924 + } 925 925 + 926 926 + if (context.config.types.enums === 'typescript+namespace') { 927 927 + const enumNode = addTypeScriptEnum({ 928 928 + $ref, 929 929 + context, 930 930 + schema, 931 931 + }); 932 932 + if (enumNode) { 933 933 + if (isRefComponent) { 934 934 + context.file({ id: typesId })!.add(enumNode); 935 935 + } else { 936 936 + // emit enum inside TypeScript namespace 937 937 + namespace.push(enumNode); 938 938 + } 939 939 + } 940 940 + } 941 941 + } 942 942 + 943 943 + const type = schemaToType({ 944 944 + context, 945 945 + schema: { 946 946 + ...schema, 947 947 + type: undefined, 948 948 + }, 949 949 + }); 950 950 + return type; 951 951 + }; 952 952 + 953 953 + const numberTypeToIdentifier = ({ 954 954 + schema, 955 955 + }: { 956 956 + context: IRContext; 957 957 + namespace: Array<ts.Statement>; 958 958 + schema: SchemaWithType<'number'>; 959 959 + }) => { 960 960 + if (schema.const !== undefined) { 961 961 + return compiler.literalTypeNode({ 962 962 + literal: compiler.ots.number(schema.const as number), 963 963 + }); 964 964 + } 965 965 + 966 966 + return compiler.keywordTypeNode({ 967 967 + keyword: 'number', 968 968 + }); 969 969 + }; 970 970 + 971 971 + const objectTypeToIdentifier = ({ 972 972 + context, 973 973 + namespace, 974 974 + schema, 975 975 + }: { 976 976 + context: IRContext; 977 977 + namespace: Array<ts.Statement>; 978 978 + schema: SchemaWithType<'object'>; 979 979 + }) => { 980 980 + let indexProperty: Property | undefined; 981 981 + const schemaProperties: Array<Property> = []; 982 982 + const indexPropertyItems: Array<IRSchemaObject> = []; 983 983 + const required = schema.required ?? []; 984 984 + let hasOptionalProperties = false; 985 985 + 986 986 + for (const name in schema.properties) { 987 987 + const property = schema.properties[name]; 988 988 + const isRequired = required.includes(name); 989 989 + schemaProperties.push({ 990 990 + comment: parseSchemaJsDoc({ schema: property }), 991 991 + isReadOnly: property.accessScope === 'read', 992 992 + isRequired, 993 993 + name, 994 994 + type: schemaToType({ 995 995 + $ref: `${irRef}${name}`, 996 996 + context, 997 997 + namespace, 998 998 + schema: property, 999 999 + }), 1000 1000 + }); 1001 1001 + indexPropertyItems.push(property); 1002 1002 + 1003 1003 + if (!isRequired) { 1004 1004 + hasOptionalProperties = true; 1005 1005 + } 1006 1006 + } 1007 1007 + 1008 1008 + if (schema.additionalProperties) { 1009 1009 + indexPropertyItems.unshift(schema.additionalProperties); 1010 1010 + 1011 1011 + if (hasOptionalProperties) { 1012 1012 + indexPropertyItems.push({ 1013 1013 + type: 'void', 1014 1014 + }); 1015 1015 + } 1016 1016 + 1017 1017 + indexProperty = { 1018 1018 + isRequired: true, 1019 1019 + name: 'key', 1020 1020 + type: schemaToType({ 1021 1021 + context, 1022 1022 + namespace, 1023 1023 + schema: { 1024 1024 + items: indexPropertyItems, 1025 1025 + logicalOperator: 'or', 1026 1026 + }, 1027 1027 + }), 1028 1028 + }; 1029 1029 + } 1030 1030 + 1031 1031 + return compiler.typeInterfaceNode({ 1032 1032 + indexProperty, 1033 1033 + properties: schemaProperties, 1034 1034 + useLegacyResolution: false, 1035 1035 + }); 1036 1036 + }; 1037 1037 + 1038 1038 + const stringTypeToIdentifier = ({ 1039 1039 + schema, 1040 1040 + }: { 1041 1041 + context: IRContext; 1042 1042 + namespace: Array<ts.Statement>; 1043 1043 + schema: SchemaWithType<'string'>; 1044 1044 + }) => { 1045 1045 + if (schema.const !== undefined) { 1046 1046 + return compiler.literalTypeNode({ 1047 1047 + literal: compiler.stringLiteral({ text: schema.const as string }), 1048 1048 + }); 1049 1049 + } 1050 1050 + 1051 1051 + if (schema.format) { 1052 1052 + if (schema.format === 'binary') { 1053 1053 + return compiler.typeUnionNode({ 1054 1054 + types: [ 1055 1055 + compiler.typeReferenceNode({ 1056 1056 + typeName: 'Blob', 1057 1057 + }), 1058 1058 + compiler.typeReferenceNode({ 1059 1059 + typeName: 'File', 1060 1060 + }), 1061 1061 + ], 1062 1062 + }); 1063 1063 + } 1064 1064 + } 1065 1065 + 1066 1066 + return compiler.keywordTypeNode({ 1067 1067 + keyword: 'string', 1068 1068 + }); 1069 1069 + }; 1070 1070 + 1071 1071 + const tupleTypeToIdentifier = ({ 1072 1072 + context, 1073 1073 + namespace, 1074 1074 + schema, 1075 1075 + }: { 1076 1076 + context: IRContext; 1077 1077 + namespace: Array<ts.Statement>; 1078 1078 + schema: SchemaWithType<'tuple'>; 1079 1079 + }) => { 1080 1080 + const itemTypes: Array<ts.TypeNode> = []; 1081 1081 + 1082 1082 + for (const item of schema.items ?? []) { 1083 1083 + itemTypes.push( 1084 1084 + schemaToType({ 1085 1085 + context, 1086 1086 + namespace, 1087 1087 + schema: item, 1088 1088 + }), 1089 1089 + ); 1090 1090 + } 1091 1091 + 1092 1092 + return compiler.typeTupleNode({ 1093 1093 + types: itemTypes, 1094 1094 + }); 1095 1095 + }; 1096 1096 + 1097 1097 + const schemaTypeToIdentifier = ({ 1098 1098 + $ref, 1099 1099 + context, 1100 1100 + namespace, 1101 1101 + schema, 1102 1102 + }: { 1103 1103 + $ref?: string; 1104 1104 + context: IRContext; 1105 1105 + namespace: Array<ts.Statement>; 1106 1106 + schema: IRSchemaObject; 1107 1107 + }): ts.TypeNode => { 1108 1108 + switch (schema.type as Required<IRSchemaObject>['type']) { 1109 1109 + case 'array': 1110 1110 + return arrayTypeToIdentifier({ 1111 1111 + context, 1112 1112 + namespace, 1113 1113 + schema: schema as SchemaWithType<'array'>, 1114 1114 + }); 1115 1115 + case 'boolean': 1116 1116 + return booleanTypeToIdentifier({ 1117 1117 + context, 1118 1118 + namespace, 1119 1119 + schema: schema as SchemaWithType<'boolean'>, 1120 1120 + }); 1121 1121 + case 'enum': 1122 1122 + return enumTypeToIdentifier({ 1123 1123 + $ref, 1124 1124 + context, 1125 1125 + namespace, 1126 1126 + schema: schema as SchemaWithType<'enum'>, 1127 1127 + }); 1128 1128 + case 'null': 1129 1129 + return compiler.literalTypeNode({ 1130 1130 + literal: compiler.null(), 1131 1131 + }); 1132 1132 + case 'number': 1133 1133 + return numberTypeToIdentifier({ 1134 1134 + context, 1135 1135 + namespace, 1136 1136 + schema: schema as SchemaWithType<'number'>, 1137 1137 + }); 1138 1138 + case 'object': 1139 1139 + return objectTypeToIdentifier({ 1140 1140 + context, 1141 1141 + namespace, 1142 1142 + schema: schema as SchemaWithType<'object'>, 1143 1143 + }); 1144 1144 + case 'string': 1145 1145 + return stringTypeToIdentifier({ 1146 1146 + context, 1147 1147 + namespace, 1148 1148 + schema: schema as SchemaWithType<'string'>, 1149 1149 + }); 1150 1150 + case 'tuple': 1151 1151 + return tupleTypeToIdentifier({ 1152 1152 + context, 1153 1153 + namespace, 1154 1154 + schema: schema as SchemaWithType<'tuple'>, 1155 1155 + }); 1156 1156 + case 'unknown': 1157 1157 + return compiler.keywordTypeNode({ 1158 1158 + keyword: 'unknown', 1159 1159 + }); 1160 1160 + case 'void': 1161 1161 + return compiler.keywordTypeNode({ 1162 1162 + keyword: 'undefined', 1163 1163 + }); 1164 1164 + } 1165 1165 + }; 1166 1166 + 1167 1167 + /** 1168 1168 + * Ensure we don't produce redundant types, e.g. string | string. 1169 1169 + */ 1170 1170 + const deduplicateSchema = ({ 1171 1171 + schema, 1172 1172 + }: { 1173 1173 + schema: IRSchemaObject; 1174 1174 + }): IRSchemaObject => { 1175 1175 + if (!schema.items) { 1176 1176 + return schema; 1177 1177 + } 1178 1178 + 1179 1179 + const uniqueItems: Array<IRSchemaObject> = []; 1180 1180 + const typeIds: Array<string> = []; 1181 1181 + 1182 1182 + for (const item of schema.items) { 1183 1183 + // skip nested schemas for now, handle if necessary 1184 1184 + if ( 1185 1185 + item.type === 'boolean' || 1186 1186 + item.type === 'null' || 1187 1187 + item.type === 'number' || 1188 1188 + item.type === 'string' || 1189 1189 + item.type === 'unknown' || 1190 1190 + item.type === 'void' 1191 1191 + ) { 1192 1192 + const typeId = `${item.$ref ?? ''}${item.type ?? ''}${item.const ?? ''}`; 1193 1193 + if (!typeIds.includes(typeId)) { 1194 1194 + typeIds.push(typeId); 1195 1195 + uniqueItems.push(item); 1196 1196 + } 1197 1197 + continue; 1198 1198 + } 1199 1199 + 1200 1200 + uniqueItems.push(item); 1201 1201 + } 1202 1202 + 1203 1203 + schema.items = uniqueItems; 1204 1204 + 1205 1205 + if ( 1206 1206 + schema.items.length <= 1 && 1207 1207 + schema.type !== 'array' && 1208 1208 + schema.type !== 'enum' && 1209 1209 + schema.type !== 'tuple' 1210 1210 + ) { 1211 1211 + // bring the only item up to clean up the schema 1212 1212 + const liftedSchema = schema.items[0]; 1213 1213 + delete schema.logicalOperator; 1214 1214 + delete schema.items; 1215 1215 + schema = { 1216 1216 + ...schema, 1217 1217 + ...liftedSchema, 1218 1218 + }; 1219 1219 + } 1220 1220 + 1221 1221 + // exclude unknown if it's the only type left 1222 1222 + if (schema.type === 'unknown') { 1223 1223 + return {}; 1224 1224 + } 1225 1225 + 1226 1226 + return schema; 1227 1227 + }; 1228 1228 + 1229 1229 + const irParametersToIrSchema = ({ 1230 1230 + parameters, 1231 1231 + }: { 1232 1232 + parameters: Record<string, IRParameterObject>; 1233 1233 + }): IRSchemaObject => { 1234 1234 + const irSchema: IRSchemaObject = { 1235 1235 + type: 'object', 1236 1236 + }; 1237 1237 + 1238 1238 + if (parameters) { 1239 1239 + const properties: Record<string, IRSchemaObject> = {}; 1240 1240 + const required: Array<string> = []; 1241 1241 + 1242 1242 + for (const name in parameters) { 1243 1243 + const parameter = parameters[name]; 1244 1244 + 1245 1245 + properties[name] = deduplicateSchema({ 1246 1246 + schema: parameter.schema, 1247 1247 + }); 1248 1248 + 1249 1249 + if (parameter.required) { 1250 1250 + required.push(name); 1251 1251 + } 1252 1252 + } 1253 1253 + 1254 1254 + irSchema.properties = properties; 1255 1255 + 1256 1256 + if (required.length) { 1257 1257 + irSchema.required = required; 1258 1258 + } 1259 1259 + } 1260 1260 + 1261 1261 + return irSchema; 1262 1262 + }; 1263 1263 + 1264 1264 + const operationToDataType = ({ 1265 1265 + context, 1266 1266 + operation, 1267 1267 + }: { 1268 1268 + context: IRContext; 1269 1269 + operation: IROperationObject; 1270 1270 + }) => { 1271 1271 + const data: IRSchemaObject = { 1272 1272 + type: 'object', 1273 1273 + }; 1274 1274 + const dataRequired: Array<string> = []; 1275 1275 + 1276 1276 + if (operation.body) { 1277 1277 + if (!data.properties) { 1278 1278 + data.properties = {}; 1279 1279 + } 1280 1280 + 1281 1281 + data.properties.body = operation.body.schema; 1282 1282 + 1283 1283 + if (operation.body.required) { 1284 1284 + dataRequired.push('body'); 1285 1285 + } 1286 1286 + } 1287 1287 + 1288 1288 + if (operation.parameters) { 1289 1289 + if (!data.properties) { 1290 1290 + data.properties = {}; 1291 1291 + } 1292 1292 + 1293 1293 + // TODO: parser - handle cookie parameters 1294 1294 + 1295 1295 + if (operation.parameters.header) { 1296 1296 + data.properties.headers = irParametersToIrSchema({ 1297 1297 + parameters: operation.parameters.header, 1298 1298 + }); 1299 1299 + 1300 1300 + if (data.properties.headers.required) { 1301 1301 + dataRequired.push('headers'); 1302 1302 + } 1303 1303 + } 1304 1304 + 1305 1305 + if (operation.parameters.path) { 1306 1306 + data.properties.path = irParametersToIrSchema({ 1307 1307 + parameters: operation.parameters.path, 1308 1308 + }); 1309 1309 + 1310 1310 + if (data.properties.path.required) { 1311 1311 + dataRequired.push('path'); 1312 1312 + } 1313 1313 + } 1314 1314 + 1315 1315 + if (operation.parameters.query) { 1316 1316 + data.properties.query = irParametersToIrSchema({ 1317 1317 + parameters: operation.parameters.query, 1318 1318 + }); 1319 1319 + 1320 1320 + if (data.properties.query.required) { 1321 1321 + dataRequired.push('query'); 1322 1322 + } 1323 1323 + } 1324 1324 + } 1325 1325 + 1326 1326 + data.required = dataRequired; 1327 1327 + 1328 1328 + if (data.properties) { 1329 1329 + const identifier = context.file({ id: typesId })!.identifier({ 1330 1330 + $ref: operationDataRef({ id: operation.id }), 1331 1331 + create: true, 1332 1332 + namespace: 'type', 1333 1333 + }); 1334 1334 + const node = compiler.typeAliasDeclaration({ 1335 1335 + exportType: true, 1336 1336 + name: identifier.name, 1337 1337 + type: schemaToType({ 1338 1338 + context, 1339 1339 + schema: data, 1340 1340 + }), 1341 1341 + }); 1342 1342 + context.file({ id: typesId })!.add(node); 1343 1343 + } 1344 1344 + }; 1345 1345 + 1346 1346 + type StatusGroup = '1XX' | '2XX' | '3XX' | '4XX' | '5XX' | 'default'; 1347 1347 + 1348 1348 + const statusCodeToGroup = ({ 1349 1349 + statusCode, 1350 1350 + }: { 1351 1351 + statusCode: string; 1352 1352 + }): StatusGroup => { 1353 1353 + switch (statusCode) { 1354 1354 + case '1XX': 1355 1355 + return '1XX'; 1356 1356 + case '2XX': 1357 1357 + return '2XX'; 1358 1358 + case '3XX': 1359 1359 + return '3XX'; 1360 1360 + case '4XX': 1361 1361 + return '4XX'; 1362 1362 + case '5XX': 1363 1363 + return '5XX'; 1364 1364 + case 'default': 1365 1365 + return 'default'; 1366 1366 + default: 1367 1367 + return `${statusCode[0]}XX` as StatusGroup; 1368 1368 + } 1369 1369 + }; 1370 1370 + 1371 1371 + const operationToResponseTypes = ({ 1372 1372 + context, 1373 1373 + operation, 1374 1374 + }: { 1375 1375 + context: IRContext; 1376 1376 + operation: IROperationObject; 1377 1377 + }) => { 1378 1378 + if (!operation.responses) { 1379 1379 + return; 1380 1380 + } 1381 1381 + 1382 1382 + const errors: IRSchemaObject = {}; 1383 1383 + const errorsItems: Array<IRSchemaObject> = []; 1384 1384 + 1385 1385 + const responses: IRSchemaObject = {}; 1386 1386 + const responsesItems: Array<IRSchemaObject> = []; 1387 1387 + 1388 1388 + let defaultResponse: IRResponseObject | undefined; 1389 1389 + 1390 1390 + for (const name in operation.responses) { 1391 1391 + const response = operation.responses[name]!; 1392 1392 + 1393 1393 + switch (statusCodeToGroup({ statusCode: name })) { 1394 1394 + case '1XX': 1395 1395 + case '3XX': 1396 1396 + // TODO: parser - handle informational and redirection status codes 1397 1397 + break; 1398 1398 + case '2XX': 1399 1399 + responsesItems.push(response.schema); 1400 1400 + break; 1401 1401 + case '4XX': 1402 1402 + case '5XX': 1403 1403 + errorsItems.push(response.schema); 1404 1404 + break; 1405 1405 + case 'default': 1406 1406 + // store default response to be evaluated last 1407 1407 + defaultResponse = response; 1408 1408 + break; 1409 1409 + } 1410 1410 + } 1411 1411 + 1412 1412 + // infer default response type 1413 1413 + if (defaultResponse) { 1414 1414 + let inferred = false; 1415 1415 + 1416 1416 + // assume default is intended for success if none exists yet 1417 1417 + if (!responsesItems.length) { 1418 1418 + responsesItems.push(defaultResponse.schema); 1419 1419 + inferred = true; 1420 1420 + } 1421 1421 + 1422 1422 + const description = ( 1423 1423 + defaultResponse.schema.description ?? '' 1424 1424 + ).toLocaleLowerCase(); 1425 1425 + const $ref = (defaultResponse.schema.$ref ?? '').toLocaleLowerCase(); 1426 1426 + 1427 1427 + // TODO: parser - this could be rewritten using regular expressions 1428 1428 + const successKeywords = ['success']; 1429 1429 + if ( 1430 1430 + successKeywords.some( 1431 1431 + (keyword) => description.includes(keyword) || $ref.includes(keyword), 1432 1432 + ) 1433 1433 + ) { 1434 1434 + responsesItems.push(defaultResponse.schema); 1435 1435 + inferred = true; 1436 1436 + } 1437 1437 + 1438 1438 + // TODO: parser - this could be rewritten using regular expressions 1439 1439 + const errorKeywords = ['error', 'problem']; 1440 1440 + if ( 1441 1441 + errorKeywords.some( 1442 1442 + (keyword) => description.includes(keyword) || $ref.includes(keyword), 1443 1443 + ) 1444 1444 + ) { 1445 1445 + errorsItems.push(defaultResponse.schema); 1446 1446 + inferred = true; 1447 1447 + } 1448 1448 + 1449 1449 + // if no keyword match, assume default schema is intended for error 1450 1450 + if (!inferred) { 1451 1451 + errorsItems.push(defaultResponse.schema); 1452 1452 + } 1453 1453 + } 1454 1454 + 1455 1455 + addItemsToSchema({ 1456 1456 + items: errorsItems, 1457 1457 + schema: errors, 1458 1458 + }); 1459 1459 + 1460 1460 + addItemsToSchema({ 1461 1461 + items: responsesItems, 1462 1462 + schema: responses, 1463 1463 + }); 1464 1464 + 1465 1465 + if (errors.items) { 1466 1466 + const deduplicatedSchema = deduplicateSchema({ 1467 1467 + schema: errors, 1468 1468 + }); 1469 1469 + if (Object.keys(deduplicatedSchema).length) { 1470 1470 + const identifier = context.file({ id: typesId })!.identifier({ 1471 1471 + $ref: operationErrorRef({ id: operation.id }), 1472 1472 + create: true, 1473 1473 + namespace: 'type', 1474 1474 + }); 1475 1475 + const node = compiler.typeAliasDeclaration({ 1476 1476 + exportType: true, 1477 1477 + name: identifier.name, 1478 1478 + type: schemaToType({ 1479 1479 + context, 1480 1480 + schema: deduplicatedSchema, 1481 1481 + }), 1482 1482 + }); 1483 1483 + context.file({ id: typesId })!.add(node); 1484 1484 + } 1485 1485 + } 1486 1486 + 1487 1487 + if (responses.items) { 1488 1488 + const deduplicatedSchema = deduplicateSchema({ 1489 1489 + schema: responses, 1490 1490 + }); 1491 1491 + if (Object.keys(deduplicatedSchema).length) { 1492 1492 + const identifier = context.file({ id: typesId })!.identifier({ 1493 1493 + $ref: operationResponseRef({ id: operation.id }), 1494 1494 + create: true, 1495 1495 + namespace: 'type', 1496 1496 + }); 1497 1497 + const node = compiler.typeAliasDeclaration({ 1498 1498 + exportType: true, 1499 1499 + name: identifier.name, 1500 1500 + type: schemaToType({ 1501 1501 + context, 1502 1502 + schema: deduplicatedSchema, 1503 1503 + }), 1504 1504 + }); 1505 1505 + context.file({ id: typesId })!.add(node); 1506 1506 + } 1507 1507 + } 1508 1508 + }; 1509 1509 + 1510 1510 + const operationToType = ({ 1511 1511 + context, 1512 1512 + operation, 1513 1513 + }: { 1514 1514 + context: IRContext; 1515 1515 + operation: IROperationObject; 1516 1516 + }) => { 1517 1517 + operationToDataType({ 1518 1518 + context, 1519 1519 + operation, 1520 1520 + }); 1521 1521 + 1522 1522 + operationToResponseTypes({ 1523 1523 + context, 1524 1524 + operation, 1525 1525 + }); 1526 1526 + }; 1527 1527 + 1528 1528 + const schemaToType = ({ 1529 1529 + $ref, 1530 1530 + context, 1531 1531 + namespace = [], 1532 1532 + schema, 1533 1533 + }: { 1534 1534 + $ref?: string; 1535 1535 + context: IRContext; 1536 1536 + namespace?: Array<ts.Statement>; 1537 1537 + schema: IRSchemaObject; 1538 1538 + }): ts.TypeNode => { 1539 1539 + let type: ts.TypeNode | undefined; 1540 1540 + 1541 1541 + if (schema.$ref) { 1542 1542 + const identifier = context.file({ id: typesId })!.identifier({ 1543 1543 + $ref: schema.$ref, 1544 1544 + create: true, 1545 1545 + namespace: 'type', 1546 1546 + }); 1547 1547 + type = compiler.typeReferenceNode({ 1548 1548 + typeName: identifier.name, 1549 1549 + }); 1550 1550 + } else if (schema.type) { 1551 1551 + type = schemaTypeToIdentifier({ 1552 1552 + $ref, 1553 1553 + context, 1554 1554 + namespace, 1555 1555 + schema, 1556 1556 + }); 1557 1557 + } else if (schema.items) { 1558 1558 + const itemTypes = schema.items.map((item) => 1559 1559 + schemaToType({ 1560 1560 + context, 1561 1561 + namespace, 1562 1562 + schema: item, 1563 1563 + }), 1564 1564 + ); 1565 1565 + type = 1566 1566 + schema.logicalOperator === 'and' 1567 1567 + ? compiler.typeIntersectionNode({ types: itemTypes }) 1568 1568 + : compiler.typeUnionNode({ types: itemTypes }); 1569 1569 + } else { 1570 1570 + // catch-all fallback for failed schemas 1571 1571 + type = schemaTypeToIdentifier({ 1572 1572 + context, 1573 1573 + namespace, 1574 1574 + schema: { 1575 1575 + type: 'unknown', 1576 1576 + }, 1577 1577 + }); 1578 1578 + } 1579 1579 + 1580 1580 + // emit nodes only if $ref points to a reusable component 1581 1581 + if ($ref && isRefOpenApiComponent($ref)) { 1582 1582 + // emit namespace if it has any members 1583 1583 + if (namespace.length) { 1584 1584 + const identifier = context.file({ id: typesId })!.identifier({ 1585 1585 + $ref, 1586 1586 + create: true, 1587 1587 + namespace: 'value', 1588 1588 + }); 1589 1589 + const node = compiler.namespaceDeclaration({ 1590 1590 + name: identifier.name, 1591 1591 + statements: namespace, 1592 1592 + }); 1593 1593 + context.file({ id: typesId })!.add(node); 1594 1594 + } 1595 1595 + 1596 1596 + // enum handler emits its own artifacts 1597 1597 + if (schema.type !== 'enum') { 1598 1598 + const identifier = context.file({ id: typesId })!.identifier({ 1599 1599 + $ref, 1600 1600 + create: true, 1601 1601 + namespace: 'type', 1602 1602 + }); 1603 1603 + const node = compiler.typeAliasDeclaration({ 1604 1604 + comment: parseSchemaJsDoc({ schema }), 1605 1605 + exportType: true, 1606 1606 + name: identifier.name, 1607 1607 + type, 1608 1608 + }); 1609 1609 + context.file({ id: typesId })!.add(node); 1610 1610 + } 1611 1611 + } 1612 1612 + 1613 1613 + return type; 1614 1614 + }; 1615 1615 + 603 1616 export const generateTypes = async ({ 604 1617 client, 1618 1618 + context, 605 1619 files, 606 1620 }: { 607 607 - client: Client; 1621 1621 + client: Client | undefined; 1622 1622 + context: IRContext | undefined; 608 1623 files: Files; 609 1624 }): Promise<void> => { 610 610 - const config = getConfig(); 1625 1625 + if (client) { 1626 1626 + const config = getConfig(); 1627 1627 + 1628 1628 + if (config.types.export) { 1629 1629 + files.types = new TypeScriptFile({ 1630 1630 + dir: config.output.path, 1631 1631 + name: 'types.ts', 1632 1632 + }); 1633 1633 + } 1634 1634 + 1635 1635 + const onNode: TypesProps['onNode'] = (node) => { 1636 1636 + files.types?.add(node); 1637 1637 + }; 1638 1638 + 1639 1639 + for (const model of client.models) { 1640 1640 + processModel({ client, model, onNode }); 1641 1641 + } 1642 1642 + 1643 1643 + processServiceTypes({ client, onNode }); 1644 1644 + return; 1645 1645 + } 611 1646 612 612 - if (config.types.export) { 613 613 - files.types = new TypeScriptFile({ 614 614 - dir: config.output.path, 615 615 - name: 'types.ts', 616 616 - }); 1647 1647 + if (!context) { 1648 1648 + return; 617 1649 } 618 1650 619 619 - const onNode: TypesProps['onNode'] = (node) => { 620 620 - files.types?.add(node); 621 621 - }; 1651 1651 + // TODO: parser - once types are a plugin, this logic can be simplified 1652 1652 + if (!context.config.types.export) { 1653 1653 + return; 1654 1654 + } 1655 1655 + 1656 1656 + context.createFile({ 1657 1657 + id: typesId, 1658 1658 + path: 'types', 1659 1659 + }); 1660 1660 + 1661 1661 + if (context.ir.components) { 1662 1662 + for (const name in context.ir.components.schemas) { 1663 1663 + const schema = context.ir.components.schemas[name]; 1664 1664 + 1665 1665 + schemaToType({ 1666 1666 + $ref: `#/components/schemas/${name}`, 1667 1667 + context, 1668 1668 + schema, 1669 1669 + }); 1670 1670 + } 1671 1671 + 1672 1672 + for (const name in context.ir.components.parameters) { 1673 1673 + const parameter = context.ir.components.parameters[name]; 622 1674 623 623 - for (const model of client.models) { 624 624 - processModel({ client, model, onNode }); 1675 1675 + schemaToType({ 1676 1676 + $ref: `#/components/parameters/${name}`, 1677 1677 + context, 1678 1678 + schema: parameter.schema, 1679 1679 + }); 1680 1680 + } 625 1681 } 626 1682 627 627 - processServiceTypes({ client, onNode }); 1683 1683 + if (context.config.services.export || context.config.types.tree) { 1684 1684 + for (const path in context.ir.paths) { 1685 1685 + const pathItem = context.ir.paths[path as keyof IRPathsObject]; 1686 1686 + 1687 1687 + if (pathItem.delete) { 1688 1688 + operationToType({ 1689 1689 + context, 1690 1690 + operation: pathItem.delete, 1691 1691 + }); 1692 1692 + } 1693 1693 + 1694 1694 + if (pathItem.get) { 1695 1695 + operationToType({ 1696 1696 + context, 1697 1697 + operation: pathItem.get, 1698 1698 + }); 1699 1699 + } 1700 1700 + 1701 1701 + if (pathItem.head) { 1702 1702 + operationToType({ 1703 1703 + context, 1704 1704 + operation: pathItem.head, 1705 1705 + }); 1706 1706 + } 1707 1707 + 1708 1708 + if (pathItem.options) { 1709 1709 + operationToType({ 1710 1710 + context, 1711 1711 + operation: pathItem.options, 1712 1712 + }); 1713 1713 + } 1714 1714 + 1715 1715 + if (pathItem.patch) { 1716 1716 + operationToType({ 1717 1717 + context, 1718 1718 + operation: pathItem.patch, 1719 1719 + }); 1720 1720 + } 1721 1721 + 1722 1722 + if (pathItem.post) { 1723 1723 + operationToType({ 1724 1724 + context, 1725 1725 + operation: pathItem.post, 1726 1726 + }); 1727 1727 + } 1728 1728 + 1729 1729 + if (pathItem.put) { 1730 1730 + operationToType({ 1731 1731 + context, 1732 1732 + operation: pathItem.put, 1733 1733 + }); 1734 1734 + } 1735 1735 + 1736 1736 + if (pathItem.trace) { 1737 1737 + operationToType({ 1738 1738 + context, 1739 1739 + operation: pathItem.trace, 1740 1740 + }); 1741 1741 + } 1742 1742 + } 1743 1743 + 1744 1744 + // TODO: parser - document removal of tree? migrate it? 1745 1745 + } 628 1746 };

+51 -38

packages/openapi-ts/src/index.ts

reviewed

··· 4 4 import { sync } from 'cross-spawn'; 5 5 6 6 import { generateOutput } from './generate/output'; 7 7 + import type { IRContext } from './ir/context'; 7 8 import { parse, parseExperimental } from './openApi'; 9 9 + import type { ParserConfig } from './openApi/config'; 10 10 + import { 11 11 + operationFilterFn, 12 12 + operationNameFn, 13 13 + operationParameterFilterFn, 14 14 + operationParameterNameFn, 15 15 + } from './openApi/config'; 8 16 import { defaultPluginConfigs } from './plugins'; 9 17 import type { Client } from './types/client'; 10 18 import type { ClientConfig, Config, UserConfig } from './types/config'; ··· 12 20 import { getConfig, isLegacyClient, setConfig } from './utils/config'; 13 21 import { getOpenApiSpec } from './utils/getOpenApiSpec'; 14 22 import { registerHandlebarTemplates } from './utils/handlebars'; 15 15 - import { 16 16 - operationFilterFn, 17 17 - operationNameFn, 18 18 - operationParameterFilterFn, 19 19 - operationParameterNameFn, 20 20 - } from './utils/parse'; 21 23 import { Performance, PerformanceReport } from './utils/performance'; 22 24 import { postProcessClient } from './utils/postprocess'; 23 25 ··· 339 341 >); 340 342 Performance.end('openapi'); 341 343 342 342 - if (config.experimental_parser) { 343 343 - Performance.start('experimental_parser'); 344 344 - parseExperimental({ 344 344 + let client: Client | undefined; 345 345 + let context: IRContext | undefined; 346 346 + 347 347 + Performance.start('parser'); 348 348 + const parserConfig: ParserConfig = { 349 349 + filterFn: { 350 350 + operation: operationFilterFn, 351 351 + operationParameter: operationParameterFilterFn, 352 352 + }, 353 353 + nameFn: { 354 354 + operation: operationNameFn, 355 355 + operationParameter: operationParameterNameFn, 356 356 + }, 357 357 + }; 358 358 + if (config.experimental_parser && !isLegacyClient(config)) { 359 359 + context = parseExperimental({ 360 360 + config, 361 361 + parserConfig, 345 362 spec: openApi, 346 363 }); 347 347 - Performance.end('experimental_parser'); 348 348 - } else { 349 349 - Performance.start('parser'); 364 364 + } 365 365 + 366 366 + if (!context) { 350 367 const parsed = parse({ 351 351 - config: { 352 352 - filterFn: { 353 353 - operation: operationFilterFn, 354 354 - operationParameter: operationParameterFilterFn, 355 355 - }, 356 356 - nameFn: { 357 357 - operation: operationNameFn, 358 358 - operationParameter: operationParameterNameFn, 359 359 - }, 360 360 - }, 361 368 openApi, 369 369 + parserConfig, 362 370 }); 363 363 - const client = postProcessClient(parsed); 364 364 - Performance.end('parser'); 371 371 + client = postProcessClient(parsed); 372 372 + } 373 373 + Performance.end('parser'); 365 374 366 366 - logClientMessage(); 375 375 + logClientMessage(); 367 376 368 368 - Performance.start('generator'); 369 369 - await generateOutput(openApi, client, templates); 370 370 - Performance.end('generator'); 377 377 + Performance.start('generator'); 378 378 + await generateOutput({ 379 379 + client, 380 380 + context, 381 381 + openApi, 382 382 + templates, 383 383 + }); 384 384 + Performance.end('generator'); 371 385 372 372 - Performance.start('postprocess'); 373 373 - if (!config.dryRun) { 374 374 - processOutput(); 386 386 + Performance.start('postprocess'); 387 387 + if (!config.dryRun) { 388 388 + processOutput(); 375 389 376 376 - console.log('✨ Done! Your client is located in:', config.output.path); 377 377 - } 378 378 - Performance.end('postprocess'); 390 390 + console.log('✨ Done! Your client is located in:', config.output.path); 391 391 + } 392 392 + Performance.end('postprocess'); 379 393 380 380 - return client; 381 381 - } 394 394 + return context || client; 382 395 }; 383 396 384 397 const clients: Array<Client> = []; ··· 386 399 const pClients = configs.map((config) => pCreateClient(config)); 387 400 for (const pClient of pClients) { 388 401 const client = await pClient(); 389 389 - if (client) { 402 402 + if (client && 'version' in client) { 390 403 clients.push(client); 391 404 } 392 405 } ··· 423 436 }; 424 437 425 438 export type { OpenApiV3_0_3 } from './openApi/3.0.3'; 426 426 - export type { OpenApiV3_1 } from './openApi/3.1'; 439 439 + export type { OpenApiV3_1_0 } from './openApi/3.1.0'; 427 440 export type { UserConfig } from './types/config';

+74

packages/openapi-ts/src/ir/context.ts

reviewed

··· 1 1 + import path from 'node:path'; 2 2 + 3 3 + import { TypeScriptFile } from '../generate/files'; 4 4 + import type { ParserConfig } from '../openApi/config'; 5 5 + import type { Config } from '../types/config'; 6 6 + import type { Files } from '../types/utils'; 7 7 + import { resolveRef } from '../utils/ref'; 8 8 + import type { IR } from './ir'; 9 9 + 10 10 + interface ContextFile { 11 11 + /** 12 12 + * Unique file identifier. 13 13 + */ 14 14 + id: string; 15 15 + /** 16 16 + * Relative file path to the output path. 17 17 + * @example 18 18 + * 'bar/foo.ts' 19 19 + */ 20 20 + path: string; 21 21 + } 22 22 + 23 23 + export class IRContext<Spec extends Record<string, any> = any> { 24 24 + public config: Config; 25 25 + public files: Files; 26 26 + public ir: IR; 27 27 + public parserConfig: ParserConfig; 28 28 + public spec: Spec; 29 29 + 30 30 + constructor({ 31 31 + config, 32 32 + parserConfig, 33 33 + spec, 34 34 + }: { 35 35 + config: Config; 36 36 + parserConfig: ParserConfig; 37 37 + spec: Spec; 38 38 + }) { 39 39 + this.config = config; 40 40 + this.files = {}; 41 41 + this.ir = {}; 42 42 + this.parserConfig = parserConfig; 43 43 + this.spec = spec; 44 44 + } 45 45 + 46 46 + /** 47 47 + * Create and return a new TypeScript file. Also set the current file context 48 48 + * to the newly created file. 49 49 + */ 50 50 + public createFile(file: ContextFile): TypeScriptFile { 51 51 + const outputParts = file.path.split('/'); 52 52 + const outputDir = path.resolve( 53 53 + this.config.output.path, 54 54 + ...outputParts.slice(0, outputParts.length - 1), 55 55 + ); 56 56 + const createdFile = new TypeScriptFile({ 57 57 + dir: outputDir, 58 58 + name: `${outputParts[outputParts.length - 1]}.ts`, 59 59 + }); 60 60 + this.files[file.id] = createdFile; 61 61 + return createdFile; 62 62 + } 63 63 + 64 64 + public file({ id }: Pick<ContextFile, 'id'>): TypeScriptFile | undefined { 65 65 + return this.files[id]; 66 66 + } 67 67 + 68 68 + public resolveRef<T>($ref: string) { 69 69 + return resolveRef<T>({ 70 70 + $ref, 71 71 + spec: this.spec, 72 72 + }); 73 73 + } 74 74 + }

+129

packages/openapi-ts/src/ir/ir.d.ts

reviewed

··· 1 1 + import type { JsonSchemaDraft2020_12 } from '../openApi/3.1.0/types/json-schema-draft-2020-12'; 2 2 + 3 3 + export interface IR { 4 4 + components?: IRComponentsObject; 5 5 + paths?: IRPathsObject; 6 6 + } 7 7 + 8 8 + interface IRComponentsObject { 9 9 + parameters?: Record<string, IRParameterObject>; 10 10 + schemas?: Record<string, IRSchemaObject>; 11 11 + } 12 12 + 13 13 + interface IRPathsObject { 14 14 + [path: `/${string}`]: IRPathItemObject; 15 15 + } 16 16 + 17 17 + interface IRPathItemObject { 18 18 + delete?: IROperationObject; 19 19 + get?: IROperationObject; 20 20 + head?: IROperationObject; 21 21 + options?: IROperationObject; 22 22 + patch?: IROperationObject; 23 23 + post?: IROperationObject; 24 24 + put?: IROperationObject; 25 25 + trace?: IROperationObject; 26 26 + } 27 27 + 28 28 + export interface IROperationObject { 29 29 + body?: IRBodyObject; 30 30 + deprecated?: boolean; 31 31 + description?: string; 32 32 + id: string; 33 33 + parameters?: IRParametersObject; 34 34 + responses?: IRResponsesObject; 35 35 + // TODO: parser - add more properties 36 36 + // security?: ReadonlyArray<SecurityRequirementObject>; 37 37 + // servers?: ReadonlyArray<ServerObject>; 38 38 + summary?: string; 39 39 + tags?: ReadonlyArray<string>; 40 40 + } 41 41 + 42 42 + export interface IRBodyObject { 43 43 + required?: boolean; 44 44 + schema: IRSchemaObject; 45 45 + } 46 46 + 47 47 + export interface IRParametersObject { 48 48 + cookie?: Record<string, IRParameterObject>; 49 49 + header?: Record<string, IRParameterObject>; 50 50 + path?: Record<string, IRParameterObject>; 51 51 + query?: Record<string, IRParameterObject>; 52 52 + } 53 53 + 54 54 + export interface IRParameterObject { 55 55 + /** 56 56 + * Endpoint parameters must specify their location. 57 57 + */ 58 58 + location: 'cookie' | 'header' | 'path' | 'query'; 59 59 + name: string; 60 60 + required?: boolean; 61 61 + schema: IRSchemaObject; 62 62 + } 63 63 + 64 64 + export interface IRResponsesObject { 65 65 + /** 66 66 + * Any {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#http-status-codes HTTP status code} can be used as the property name, but only one property per code, to describe the expected response for that HTTP status code. This field MUST be enclosed in quotation marks (for example, "200") for compatibility between JSON and YAML. To define a range of response codes, this field MAY contain the uppercase wildcard character `X`. For example, `2XX` represents all response codes between `[200-299]`. Only the following range definitions are allowed: `1XX`, `2XX`, `3XX`, `4XX`, and `5XX`. If a response is defined using an explicit code, the explicit code definition takes precedence over the range definition for that code. 67 67 + */ 68 68 + [statusCode: string]: IRResponseObject | undefined; 69 69 + /** 70 70 + * The documentation of responses other than the ones declared for specific HTTP response codes. Use this field to cover undeclared responses. 71 71 + */ 72 72 + default?: IRResponseObject; 73 73 + } 74 74 + 75 75 + export interface IRResponseObject { 76 76 + // TODO: parser - handle headers, links, and possibly other media types? 77 77 + schema: IRSchemaObject; 78 78 + } 79 79 + 80 80 + export interface IRSchemaObject 81 81 + extends Pick< 82 82 + JsonSchemaDraft2020_12, 83 83 + '$ref' | 'const' | 'deprecated' | 'description' | 'required' | 'title' 84 84 + > { 85 85 + /** 86 86 + * If the schema is intended to be used as an object property, it can be 87 87 + * marked as read-only or write-only. 88 88 + */ 89 89 + accessScope?: 'read' | 'write'; 90 90 + /** 91 91 + * If type is `object`, `additionalProperties` can be used to either define 92 92 + * a schema for properties not included in `properties` or disallow such 93 93 + * properties altogether. 94 94 + */ 95 95 + additionalProperties?: IRSchemaObject | false; 96 96 + /** 97 97 + * Any string value is accepted as `format`. 98 98 + */ 99 99 + format?: JsonSchemaDraft2020_12['format'] | 'binary' | 'integer'; 100 100 + /** 101 101 + * If schema resolves into multiple items instead of a simple `type`, they 102 102 + * will be included in `items` array. 103 103 + */ 104 104 + items?: ReadonlyArray<IRSchemaObject>; 105 105 + /** 106 106 + * When resolving a list of items, we need to know the relationship between 107 107 + * them. `logicalOperator` specifies this logical relationship. 108 108 + * @default 'or' 109 109 + */ 110 110 + logicalOperator?: 'and' | 'or'; 111 111 + /** 112 112 + * When type is `object`, `properties` will contain a map of its properties. 113 113 + */ 114 114 + properties?: Record<string, IRSchemaObject>; 115 115 + /** 116 116 + * Each schema eventually resolves into `type`. 117 117 + */ 118 118 + type?: 119 119 + | 'array' 120 120 + | 'boolean' 121 121 + | 'enum' 122 122 + | 'null' 123 123 + | 'number' 124 124 + | 'object' 125 125 + | 'string' 126 126 + | 'tuple' 127 127 + | 'unknown' 128 128 + | 'void'; 129 129 + }

+35

packages/openapi-ts/src/ir/parameter.ts

reviewed

··· 1 1 + import type { IRParametersObject } from './ir'; 2 2 + 3 3 + export const hasParametersObjectRequired = ( 4 4 + parameters: IRParametersObject | undefined, 5 5 + ): boolean => { 6 6 + if (!parameters) { 7 7 + return false; 8 8 + } 9 9 + 10 10 + for (const name in parameters.cookie) { 11 11 + if (parameters.cookie[name].required) { 12 12 + return true; 13 13 + } 14 14 + } 15 15 + 16 16 + for (const name in parameters.header) { 17 17 + if (parameters.header[name].required) { 18 18 + return true; 19 19 + } 20 20 + } 21 21 + 22 22 + for (const name in parameters.path) { 23 23 + if (parameters.path[name].required) { 24 24 + return true; 25 25 + } 26 26 + } 27 27 + 28 28 + for (const name in parameters.query) { 29 29 + if (parameters.query[name].required) { 30 30 + return true; 31 31 + } 32 32 + } 33 33 + 34 34 + return false; 35 35 + };

+25

packages/openapi-ts/src/ir/utils.ts

reviewed

··· 1 1 + import type { IRSchemaObject } from './ir'; 2 2 + 3 3 + /** 4 4 + * Simply adds `items` to the schema. Also handles setting the logical operator 5 5 + * and avoids setting it for a single item or tuples. 6 6 + */ 7 7 + export const addItemsToSchema = ({ 8 8 + items, 9 9 + schema, 10 10 + }: { 11 11 + items: Array<IRSchemaObject>; 12 12 + schema: IRSchemaObject; 13 13 + }) => { 14 14 + if (!items.length) { 15 15 + return; 16 16 + } 17 17 + 18 18 + schema.items = items; 19 19 + 20 20 + if (items.length === 1 || schema.type === 'tuple') { 21 21 + return; 22 22 + } 23 23 + 24 24 + schema.logicalOperator = 'or'; 25 25 + };

+3 -2

packages/openapi-ts/src/openApi/3.0.3/parser/index.ts

reviewed

··· 1 1 + import type { IRContext } from '../../../ir/context'; 1 2 import type { OpenApiV3_0_3 } from '../types/spec'; 2 3 3 3 - export const parseV3_0_3 = (spec: OpenApiV3_0_3) => { 4 4 + export const parseV3_0_3 = (context: IRContext<OpenApiV3_0_3>): undefined => { 4 5 // TODO 5 5 - console.log(spec); 6 6 + console.log(context.spec); 6 7 };

packages/openapi-ts/src/openApi/3.0.3/types/spec.ts packages/openapi-ts/src/openApi/3.0.3/types/spec.d.ts

reviewed

+2

packages/openapi-ts/src/openApi/3.1.0/index.ts

reviewed

··· 1 1 + export { parseV3_1_0 } from './parser'; 2 2 + export type { OpenApiV3_1_0 } from './types/spec';

+217

packages/openapi-ts/src/openApi/3.1.0/parser/index.ts

reviewed

··· 1 1 + import type { IRContext } from '../../../ir/context'; 2 2 + import type { 3 3 + OpenApiV3_1_0, 4 4 + ParameterObject, 5 5 + PathItemObject, 6 6 + PathsObject, 7 7 + } from '../types/spec'; 8 8 + import { parseOperation } from './operation'; 9 9 + import { 10 10 + mergeParametersObjects, 11 11 + parametersArrayToObject, 12 12 + parseParameter, 13 13 + } from './parameter'; 14 14 + import { parseSchema } from './schema'; 15 15 + 16 16 + export const parseV3_1_0 = (context: IRContext<OpenApiV3_1_0>) => { 17 17 + const operationIds = new Map<string, string>(); 18 18 + 19 19 + for (const path in context.spec.paths) { 20 20 + const pathItem = context.spec.paths[path as keyof PathsObject]; 21 21 + 22 22 + const finalPathItem = pathItem.$ref 23 23 + ? { 24 24 + ...context.resolveRef<PathItemObject>(pathItem.$ref), 25 25 + ...pathItem, 26 26 + } 27 27 + : pathItem; 28 28 + 29 29 + const operationArgs: Omit<Parameters<typeof parseOperation>[0], 'method'> = 30 30 + { 31 31 + context, 32 32 + operation: { 33 33 + description: finalPathItem.description, 34 34 + id: '', 35 35 + parameters: parametersArrayToObject({ 36 36 + context, 37 37 + parameters: finalPathItem.parameters, 38 38 + }), 39 39 + servers: finalPathItem.servers, 40 40 + summary: finalPathItem.summary, 41 41 + }, 42 42 + operationIds, 43 43 + path: path as keyof PathsObject, 44 44 + }; 45 45 + 46 46 + if (finalPathItem.delete) { 47 47 + parseOperation({ 48 48 + ...operationArgs, 49 49 + method: 'delete', 50 50 + operation: { 51 51 + ...operationArgs.operation, 52 52 + ...finalPathItem.delete, 53 53 + parameters: mergeParametersObjects({ 54 54 + source: parametersArrayToObject({ 55 55 + context, 56 56 + parameters: finalPathItem.delete.parameters, 57 57 + }), 58 58 + target: operationArgs.operation.parameters, 59 59 + }), 60 60 + }, 61 61 + }); 62 62 + } 63 63 + 64 64 + if (finalPathItem.get) { 65 65 + parseOperation({ 66 66 + ...operationArgs, 67 67 + method: 'get', 68 68 + operation: { 69 69 + ...operationArgs.operation, 70 70 + ...finalPathItem.get, 71 71 + parameters: mergeParametersObjects({ 72 72 + source: parametersArrayToObject({ 73 73 + context, 74 74 + parameters: finalPathItem.get.parameters, 75 75 + }), 76 76 + target: operationArgs.operation.parameters, 77 77 + }), 78 78 + }, 79 79 + }); 80 80 + } 81 81 + 82 82 + if (finalPathItem.head) { 83 83 + parseOperation({ 84 84 + ...operationArgs, 85 85 + method: 'head', 86 86 + operation: { 87 87 + ...operationArgs.operation, 88 88 + ...finalPathItem.head, 89 89 + parameters: mergeParametersObjects({ 90 90 + source: parametersArrayToObject({ 91 91 + context, 92 92 + parameters: finalPathItem.head.parameters, 93 93 + }), 94 94 + target: operationArgs.operation.parameters, 95 95 + }), 96 96 + }, 97 97 + }); 98 98 + } 99 99 + 100 100 + if (finalPathItem.options) { 101 101 + parseOperation({ 102 102 + ...operationArgs, 103 103 + method: 'options', 104 104 + operation: { 105 105 + ...operationArgs.operation, 106 106 + ...finalPathItem.options, 107 107 + parameters: mergeParametersObjects({ 108 108 + source: parametersArrayToObject({ 109 109 + context, 110 110 + parameters: finalPathItem.options.parameters, 111 111 + }), 112 112 + target: operationArgs.operation.parameters, 113 113 + }), 114 114 + }, 115 115 + }); 116 116 + } 117 117 + 118 118 + if (finalPathItem.patch) { 119 119 + parseOperation({ 120 120 + ...operationArgs, 121 121 + method: 'patch', 122 122 + operation: { 123 123 + ...operationArgs.operation, 124 124 + ...finalPathItem.patch, 125 125 + parameters: mergeParametersObjects({ 126 126 + source: parametersArrayToObject({ 127 127 + context, 128 128 + parameters: finalPathItem.patch.parameters, 129 129 + }), 130 130 + target: operationArgs.operation.parameters, 131 131 + }), 132 132 + }, 133 133 + }); 134 134 + } 135 135 + 136 136 + if (finalPathItem.post) { 137 137 + parseOperation({ 138 138 + ...operationArgs, 139 139 + method: 'post', 140 140 + operation: { 141 141 + ...operationArgs.operation, 142 142 + ...finalPathItem.post, 143 143 + parameters: mergeParametersObjects({ 144 144 + source: parametersArrayToObject({ 145 145 + context, 146 146 + parameters: finalPathItem.post.parameters, 147 147 + }), 148 148 + target: operationArgs.operation.parameters, 149 149 + }), 150 150 + }, 151 151 + }); 152 152 + } 153 153 + 154 154 + if (finalPathItem.put) { 155 155 + parseOperation({ 156 156 + ...operationArgs, 157 157 + method: 'put', 158 158 + operation: { 159 159 + ...operationArgs.operation, 160 160 + ...finalPathItem.put, 161 161 + parameters: mergeParametersObjects({ 162 162 + source: parametersArrayToObject({ 163 163 + context, 164 164 + parameters: finalPathItem.put.parameters, 165 165 + }), 166 166 + target: operationArgs.operation.parameters, 167 167 + }), 168 168 + }, 169 169 + }); 170 170 + } 171 171 + 172 172 + if (finalPathItem.trace) { 173 173 + parseOperation({ 174 174 + ...operationArgs, 175 175 + method: 'trace', 176 176 + operation: { 177 177 + ...operationArgs.operation, 178 178 + ...finalPathItem.trace, 179 179 + parameters: mergeParametersObjects({ 180 180 + source: parametersArrayToObject({ 181 181 + context, 182 182 + parameters: finalPathItem.trace.parameters, 183 183 + }), 184 184 + target: operationArgs.operation.parameters, 185 185 + }), 186 186 + }, 187 187 + }); 188 188 + } 189 189 + } 190 190 + 191 191 + // TODO: parser - handle more component types, old parser handles only parameters and schemas 192 192 + if (context.spec.components) { 193 193 + for (const name in context.spec.components.parameters) { 194 194 + const parameterOrReference = context.spec.components.parameters[name]; 195 195 + const parameter = 196 196 + '$ref' in parameterOrReference 197 197 + ? context.resolveRef<ParameterObject>(parameterOrReference.$ref) 198 198 + : parameterOrReference; 199 199 + 200 200 + parseParameter({ 201 201 + context, 202 202 + name, 203 203 + parameter, 204 204 + }); 205 205 + } 206 206 + 207 207 + for (const name in context.spec.components.schemas) { 208 208 + const schema = context.spec.components.schemas[name]; 209 209 + 210 210 + parseSchema({ 211 211 + context, 212 212 + name, 213 213 + schema, 214 214 + }); 215 215 + } 216 216 + } 217 217 + };

+40

packages/openapi-ts/src/openApi/3.1.0/parser/mediaType.ts

reviewed

··· 1 1 + import type { MediaTypeObject, SchemaObject } from '../types/spec'; 2 2 + 3 3 + const SUPPORTED_MEDIA_TYPES = [ 4 4 + 'application/json-patch+json', 5 5 + 'application/json', 6 6 + 'application/ld+json', 7 7 + 'application/x-www-form-urlencoded', 8 8 + 'audio/*', 9 9 + 'multipart/batch', 10 10 + 'multipart/form-data', 11 11 + 'multipart/mixed', 12 12 + 'multipart/related', 13 13 + 'text/json', 14 14 + 'text/plain', 15 15 + 'video/*', 16 16 + ] as const; 17 17 + 18 18 + type MediaType = (typeof SUPPORTED_MEDIA_TYPES)[number]; 19 19 + 20 20 + interface Content { 21 21 + mediaType: MediaType; 22 22 + schema: SchemaObject | undefined; 23 23 + } 24 24 + 25 25 + export const getMediaTypeSchema = ({ 26 26 + content, 27 27 + }: { 28 28 + content: Record<string, MediaTypeObject> | undefined; 29 29 + }): Content | undefined => { 30 30 + for (const rawMediaType in content) { 31 31 + const mediaTypeContent = content[rawMediaType]; 32 32 + const mediaType: MediaType = rawMediaType.split(';')[0].trim() as MediaType; 33 33 + if (SUPPORTED_MEDIA_TYPES.includes(mediaType)) { 34 34 + return { 35 35 + mediaType, 36 36 + schema: mediaTypeContent.schema, 37 37 + }; 38 38 + } 39 39 + } 40 40 + };

+199

packages/openapi-ts/src/openApi/3.1.0/parser/operation.ts

reviewed

··· 1 1 + import type { IRContext } from '../../../ir/context'; 2 2 + import type { IROperationObject, IRPathsObject } from '../../../ir/ir'; 3 3 + import type { 4 4 + OperationObject, 5 5 + PathItemObject, 6 6 + RequestBodyObject, 7 7 + ResponseObject, 8 8 + } from '../types/spec'; 9 9 + import { getMediaTypeSchema } from './mediaType'; 10 10 + import { schemaToIrSchema } from './schema'; 11 11 + 12 12 + interface Operation 13 13 + extends Omit<OperationObject, 'parameters'>, 14 14 + Pick<IROperationObject, 'id' | 'parameters'> {} 15 15 + 16 16 + const parseOperationJsDoc = ({ 17 17 + irOperation, 18 18 + operation, 19 19 + }: { 20 20 + irOperation: IROperationObject; 21 21 + operation: Operation; 22 22 + }) => { 23 23 + if (operation.deprecated !== undefined) { 24 24 + irOperation.deprecated = operation.deprecated; 25 25 + } 26 26 + 27 27 + if (operation.description) { 28 28 + irOperation.description = operation.description; 29 29 + } 30 30 + 31 31 + if (operation.summary) { 32 32 + irOperation.summary = operation.summary; 33 33 + } 34 34 + 35 35 + if (operation.tags && operation.tags.length) { 36 36 + irOperation.tags = operation.tags; 37 37 + } 38 38 + }; 39 39 + 40 40 + const initIrOperation = ({ 41 41 + operation, 42 42 + }: { 43 43 + operation: Operation; 44 44 + }): IROperationObject => { 45 45 + const irOperation: IROperationObject = { 46 46 + id: operation.id, 47 47 + }; 48 48 + 49 49 + parseOperationJsDoc({ 50 50 + irOperation, 51 51 + operation, 52 52 + }); 53 53 + 54 54 + return irOperation; 55 55 + }; 56 56 + 57 57 + const operationToIrOperation = ({ 58 58 + context, 59 59 + operation, 60 60 + }: { 61 61 + context: IRContext; 62 62 + operation: Operation; 63 63 + }): IROperationObject => { 64 64 + const irOperation = initIrOperation({ operation }); 65 65 + 66 66 + if (operation.parameters) { 67 67 + irOperation.parameters = operation.parameters; 68 68 + } 69 69 + 70 70 + if (operation.requestBody) { 71 71 + const requestBodyObject = 72 72 + '$ref' in operation.requestBody 73 73 + ? context.resolveRef<RequestBodyObject>(operation.requestBody.$ref) 74 74 + : operation.requestBody; 75 75 + const content = getMediaTypeSchema({ 76 76 + content: requestBodyObject.content, 77 77 + }); 78 78 + if (content) { 79 79 + irOperation.body = { 80 80 + schema: schemaToIrSchema({ 81 81 + context, 82 82 + schema: { 83 83 + description: requestBodyObject.description, 84 84 + ...content.schema, 85 85 + }, 86 86 + }), 87 87 + }; 88 88 + 89 89 + if (requestBodyObject.required) { 90 90 + irOperation.body.required = requestBodyObject.required; 91 91 + } 92 92 + } 93 93 + } 94 94 + 95 95 + for (const name in operation.responses) { 96 96 + const response = operation.responses[name]!; 97 97 + const responseObject = 98 98 + '$ref' in response 99 99 + ? context.resolveRef<ResponseObject>(response.$ref) 100 100 + : response; 101 101 + const content = getMediaTypeSchema({ 102 102 + content: responseObject.content, 103 103 + }); 104 104 + if (content) { 105 105 + if (!irOperation.responses) { 106 106 + irOperation.responses = {}; 107 107 + } 108 108 + 109 109 + irOperation.responses[name] = { 110 110 + schema: schemaToIrSchema({ 111 111 + context, 112 112 + schema: { 113 113 + description: responseObject.description, 114 114 + ...content.schema, 115 115 + }, 116 116 + }), 117 117 + }; 118 118 + } else if (name === '204') { 119 119 + if (!irOperation.responses) { 120 120 + irOperation.responses = {}; 121 121 + } 122 122 + 123 123 + irOperation.responses[name] = { 124 124 + schema: { 125 125 + description: responseObject.description, 126 126 + type: 'void', 127 127 + }, 128 128 + }; 129 129 + } 130 130 + } 131 131 + 132 132 + // TODO: parser - handle security 133 133 + // baz: operation.security 134 134 + 135 135 + // TODO: parser - handle servers 136 136 + // qux: operation.servers 137 137 + 138 138 + return irOperation; 139 139 + }; 140 140 + 141 141 + export const parseOperation = ({ 142 142 + context, 143 143 + method, 144 144 + operation, 145 145 + operationIds, 146 146 + path, 147 147 + }: { 148 148 + context: IRContext; 149 149 + method: Extract< 150 150 + keyof PathItemObject, 151 151 + 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace' 152 152 + >; 153 153 + operation: Operation; 154 154 + operationIds: Map<string, string>; 155 155 + path: keyof IRPathsObject; 156 156 + }) => { 157 157 + const operationKey = `${method.toUpperCase()} ${path}`; 158 158 + 159 159 + // TODO: parser - move services to plugin, cleaner syntax 160 160 + if ( 161 161 + !context.parserConfig.filterFn.operation({ 162 162 + config: context.config, 163 163 + operationKey, 164 164 + }) 165 165 + ) { 166 166 + return; 167 167 + } 168 168 + 169 169 + // TODO: parser - support throw on duplicate 170 170 + if (operation.operationId) { 171 171 + if (operationIds.has(operation.operationId)) { 172 172 + console.warn( 173 173 + `❗️ Duplicate operationId: ${operation.operationId} in ${operationKey}. Please ensure your operation IDs are unique. This behavior is not supported and will likely lead to unexpected results.`, 174 174 + ); 175 175 + } else { 176 176 + operationIds.set(operation.operationId, operationKey); 177 177 + } 178 178 + } 179 179 + 180 180 + if (!context.ir.paths) { 181 181 + context.ir.paths = {}; 182 182 + } 183 183 + 184 184 + if (!context.ir.paths[path]) { 185 185 + context.ir.paths[path] = {}; 186 186 + } 187 187 + 188 188 + operation.id = context.parserConfig.nameFn.operation({ 189 189 + config: context.config, 190 190 + method, 191 191 + operationId: operation.operationId, 192 192 + path, 193 193 + }); 194 194 + 195 195 + context.ir.paths[path][method] = operationToIrOperation({ 196 196 + context, 197 197 + operation, 198 198 + }); 199 199 + };

+163

packages/openapi-ts/src/openApi/3.1.0/parser/parameter.ts

reviewed

··· 1 1 + import type { IRContext } from '../../../ir/context'; 2 2 + import type { IRParameterObject, IRParametersObject } from '../../../ir/ir'; 3 3 + import type { ParameterObject, ReferenceObject } from '../types/spec'; 4 4 + import { getMediaTypeSchema } from './mediaType'; 5 5 + import { schemaToIrSchema } from './schema'; 6 6 + 7 7 + export const parametersArrayToObject = ({ 8 8 + context, 9 9 + parameters, 10 10 + }: { 11 11 + context: IRContext; 12 12 + parameters?: ReadonlyArray<ParameterObject | ReferenceObject>; 13 13 + }): IRParametersObject | undefined => { 14 14 + if (!parameters || !Object.keys(parameters).length) { 15 15 + return; 16 16 + } 17 17 + 18 18 + const parametersObject: IRParametersObject = {}; 19 19 + 20 20 + for (const parameterOrReference of parameters) { 21 21 + const parameter = 22 22 + '$ref' in parameterOrReference 23 23 + ? context.resolveRef<ParameterObject>(parameterOrReference.$ref) 24 24 + : parameterOrReference; 25 25 + 26 26 + if (!parametersObject[parameter.in]) { 27 27 + parametersObject[parameter.in] = {}; 28 28 + } 29 29 + 30 30 + parametersObject[parameter.in]![parameter.name] = parameterToIrParameter({ 31 31 + context, 32 32 + parameter, 33 33 + }); 34 34 + } 35 35 + 36 36 + return parametersObject; 37 37 + }; 38 38 + 39 39 + export const mergeParametersObjects = ({ 40 40 + source, 41 41 + target, 42 42 + }: { 43 43 + source: IRParametersObject | undefined; 44 44 + target: IRParametersObject | undefined; 45 45 + }): IRParametersObject | undefined => { 46 46 + const result = { ...target }; 47 47 + 48 48 + if (source) { 49 49 + if (source.cookie) { 50 50 + if (result.cookie) { 51 51 + result.cookie = { 52 52 + ...result.cookie, 53 53 + ...source.cookie, 54 54 + }; 55 55 + } else { 56 56 + result.cookie = source.cookie; 57 57 + } 58 58 + } 59 59 + 60 60 + if (source.header) { 61 61 + if (result.header) { 62 62 + result.header = { 63 63 + ...result.header, 64 64 + ...source.header, 65 65 + }; 66 66 + } else { 67 67 + result.header = source.header; 68 68 + } 69 69 + } 70 70 + 71 71 + if (source.path) { 72 72 + if (result.path) { 73 73 + result.path = { 74 74 + ...result.path, 75 75 + ...source.path, 76 76 + }; 77 77 + } else { 78 78 + result.path = source.path; 79 79 + } 80 80 + } 81 81 + 82 82 + if (source.query) { 83 83 + if (result.query) { 84 84 + result.query = { 85 85 + ...result.query, 86 86 + ...source.query, 87 87 + }; 88 88 + } else { 89 89 + result.query = source.query; 90 90 + } 91 91 + } 92 92 + } 93 93 + 94 94 + if (!Object.keys(result).length) { 95 95 + return; 96 96 + } 97 97 + 98 98 + return result; 99 99 + }; 100 100 + 101 101 + const parameterToIrParameter = ({ 102 102 + context, 103 103 + parameter, 104 104 + }: { 105 105 + context: IRContext; 106 106 + parameter: ParameterObject; 107 107 + }): IRParameterObject => { 108 108 + // TODO: parser - fix 109 109 + let schema = parameter.schema; 110 110 + 111 111 + if (!schema) { 112 112 + const content = getMediaTypeSchema({ 113 113 + content: parameter.content, 114 114 + }); 115 115 + if (content) { 116 116 + schema = content.schema; 117 117 + } 118 118 + } 119 119 + 120 120 + const irSchema = schemaToIrSchema({ 121 121 + context, 122 122 + schema: { 123 123 + deprecated: parameter.deprecated, 124 124 + description: parameter.description, 125 125 + ...schema, 126 126 + }, 127 127 + }); 128 128 + 129 129 + const irParameter: IRParameterObject = { 130 130 + location: parameter.in, 131 131 + name: parameter.name, 132 132 + schema: irSchema, 133 133 + }; 134 134 + 135 135 + if (parameter.required) { 136 136 + irParameter.required = parameter.required; 137 137 + } 138 138 + 139 139 + return irParameter; 140 140 + }; 141 141 + 142 142 + export const parseParameter = ({ 143 143 + context, 144 144 + name, 145 145 + parameter, 146 146 + }: { 147 147 + context: IRContext; 148 148 + name: string; 149 149 + parameter: ParameterObject; 150 150 + }) => { 151 151 + if (!context.ir.components) { 152 152 + context.ir.components = {}; 153 153 + } 154 154 + 155 155 + if (!context.ir.components.parameters) { 156 156 + context.ir.components.parameters = {}; 157 157 + } 158 158 + 159 159 + context.ir.components.parameters[name] = parameterToIrParameter({ 160 160 + context, 161 161 + parameter, 162 162 + }); 163 163 + };

+787

packages/openapi-ts/src/openApi/3.1.0/parser/schema.ts

reviewed

··· 1 1 + import type { IRContext } from '../../../ir/context'; 2 2 + import type { IRSchemaObject } from '../../../ir/ir'; 3 3 + import { addItemsToSchema } from '../../../ir/utils'; 4 4 + import type { SchemaObject } from '../types/spec'; 5 5 + 6 6 + type SchemaWithRequired<K extends keyof Required<SchemaObject>> = Omit< 7 7 + SchemaObject, 8 8 + K 9 9 + > & 10 10 + Pick<Required<SchemaObject>, K>; 11 11 + 12 12 + type SchemaType = Extract<Required<SchemaObject>['type'], string>; 13 13 + 14 14 + const getSchemaTypes = ({ 15 15 + schema, 16 16 + }: { 17 17 + schema: SchemaObject; 18 18 + }): ReadonlyArray<SchemaType> => 19 19 + typeof schema.type === 'string' ? [schema.type] : schema.type ?? []; 20 20 + 21 21 + const parseSchemaMeta = ({ 22 22 + irSchema, 23 23 + schema, 24 24 + }: { 25 25 + irSchema: IRSchemaObject; 26 26 + schema: SchemaObject; 27 27 + }) => { 28 28 + if (schema.const !== undefined) { 29 29 + irSchema.const = schema.const; 30 30 + 31 31 + // try to infer schema type 32 32 + if (!schema.type) { 33 33 + if (schema.const === null) { 34 34 + irSchema.type = 'null'; 35 35 + } else { 36 36 + switch (typeof schema.const) { 37 37 + case 'bigint': 38 38 + case 'number': 39 39 + irSchema.type = 'number'; 40 40 + break; 41 41 + case 'boolean': 42 42 + irSchema.type = 'boolean'; 43 43 + break; 44 44 + case 'string': 45 45 + irSchema.type = 'string'; 46 46 + break; 47 47 + } 48 48 + } 49 49 + } 50 50 + } 51 51 + 52 52 + if (schema.format) { 53 53 + irSchema.format = schema.format; 54 54 + } 55 55 + 56 56 + if (schema.readOnly) { 57 57 + irSchema.accessScope = 'read'; 58 58 + } else if (schema.writeOnly) { 59 59 + irSchema.accessScope = 'write'; 60 60 + } 61 61 + 62 62 + if (schema.title) { 63 63 + irSchema.title = schema.title; 64 64 + } 65 65 + }; 66 66 + 67 67 + const parseArray = ({ 68 68 + context, 69 69 + irSchema = {}, 70 70 + schema, 71 71 + }: { 72 72 + context: IRContext; 73 73 + irSchema?: IRSchemaObject; 74 74 + schema: SchemaObject; 75 75 + }): IRSchemaObject => { 76 76 + if ( 77 77 + (schema.prefixItems && schema.prefixItems.length) || 78 78 + (schema.maxItems && schema.maxItems === schema.minItems) 79 79 + ) { 80 80 + irSchema.type = 'tuple'; 81 81 + } else { 82 82 + irSchema.type = 'array'; 83 83 + } 84 84 + 85 85 + let schemaItems: Array<IRSchemaObject> = []; 86 86 + 87 87 + for (const item of schema.prefixItems ?? []) { 88 88 + schemaItems.push( 89 89 + schemaToIrSchema({ 90 90 + context, 91 91 + schema: item, 92 92 + }), 93 93 + ); 94 94 + } 95 95 + 96 96 + if (schema.items) { 97 97 + const isComposedSchema = Boolean( 98 98 + schema.items.allOf || schema.items.anyOf || schema.items.oneOf, 99 99 + ); 100 100 + const irItemsSchema = schemaToIrSchema({ 101 101 + context, 102 102 + schema: schema.items, 103 103 + }); 104 104 + 105 105 + if ( 106 106 + !schemaItems.length && 107 107 + schema.maxItems && 108 108 + schema.maxItems === schema.minItems 109 109 + ) { 110 110 + schemaItems = Array(schema.maxItems).fill(irItemsSchema); 111 111 + } else { 112 112 + if (isComposedSchema) { 113 113 + // bring composition up to avoid incorrectly nested arrays 114 114 + irSchema = { 115 115 + ...irSchema, 116 116 + ...irItemsSchema, 117 117 + }; 118 118 + } else { 119 119 + schemaItems.push(irItemsSchema); 120 120 + } 121 121 + } 122 122 + } 123 123 + 124 124 + addItemsToSchema({ 125 125 + items: schemaItems, 126 126 + schema: irSchema, 127 127 + }); 128 128 + 129 129 + return irSchema; 130 130 + }; 131 131 + 132 132 + const parseBoolean = ({ 133 133 + irSchema = {}, 134 134 + }: { 135 135 + context: IRContext; 136 136 + irSchema?: IRSchemaObject; 137 137 + schema: SchemaObject; 138 138 + }): IRSchemaObject => { 139 139 + irSchema.type = 'boolean'; 140 140 + 141 141 + return irSchema; 142 142 + }; 143 143 + 144 144 + const parseNull = ({ 145 145 + irSchema = {}, 146 146 + }: { 147 147 + context: IRContext; 148 148 + irSchema?: IRSchemaObject; 149 149 + schema: SchemaObject; 150 150 + }) => { 151 151 + irSchema.type = 'null'; 152 152 + 153 153 + return irSchema; 154 154 + }; 155 155 + 156 156 + const parseNumber = ({ 157 157 + irSchema = {}, 158 158 + }: { 159 159 + context: IRContext; 160 160 + irSchema?: IRSchemaObject; 161 161 + schema: SchemaObject; 162 162 + }): IRSchemaObject => { 163 163 + irSchema.type = 'number'; 164 164 + 165 165 + return irSchema; 166 166 + }; 167 167 + 168 168 + const parseObject = ({ 169 169 + context, 170 170 + irSchema = {}, 171 171 + schema, 172 172 + }: { 173 173 + context: IRContext; 174 174 + irSchema?: IRSchemaObject; 175 175 + schema: SchemaObject; 176 176 + }): IRSchemaObject => { 177 177 + irSchema.type = 'object'; 178 178 + 179 179 + const schemaProperties: Record<string, IRSchemaObject> = {}; 180 180 + 181 181 + for (const name in schema.properties) { 182 182 + const property = schema.properties[name]; 183 183 + if (typeof property === 'boolean') { 184 184 + // TODO: parser - handle boolean properties 185 185 + } else { 186 186 + schemaProperties[name] = schemaToIrSchema({ 187 187 + context, 188 188 + schema: property, 189 189 + }); 190 190 + } 191 191 + } 192 192 + 193 193 + if (Object.keys(schemaProperties).length) { 194 194 + irSchema.properties = schemaProperties; 195 195 + } 196 196 + 197 197 + if (schema.additionalProperties !== undefined) { 198 198 + if (typeof schema.additionalProperties === 'boolean') { 199 199 + if (schema.additionalProperties) { 200 200 + // no need to add "any" additional properties if there are no defined properties 201 201 + if (irSchema.properties) { 202 202 + irSchema.additionalProperties = { 203 203 + type: 'unknown', 204 204 + }; 205 205 + } 206 206 + } else { 207 207 + // TODO: parser - handle additional properties: false 208 208 + } 209 209 + } else { 210 210 + const irAdditionalPropertiesSchema = schemaToIrSchema({ 211 211 + context, 212 212 + schema: schema.additionalProperties, 213 213 + }); 214 214 + // no need to add "any" additional properties if there are no defined properties 215 215 + if ( 216 216 + irSchema.properties || 217 217 + irAdditionalPropertiesSchema.type !== 'unknown' 218 218 + ) { 219 219 + irSchema.additionalProperties = irAdditionalPropertiesSchema; 220 220 + } 221 221 + } 222 222 + } 223 223 + 224 224 + if (schema.required) { 225 225 + irSchema.required = schema.required; 226 226 + } 227 227 + 228 228 + return irSchema; 229 229 + }; 230 230 + 231 231 + const parseString = ({ 232 232 + irSchema = {}, 233 233 + }: { 234 234 + context: IRContext; 235 235 + irSchema?: IRSchemaObject; 236 236 + schema: SchemaObject; 237 237 + }): IRSchemaObject => { 238 238 + irSchema.type = 'string'; 239 239 + 240 240 + return irSchema; 241 241 + }; 242 242 + 243 243 + const parseSchemaJsDoc = ({ 244 244 + irSchema, 245 245 + schema, 246 246 + }: { 247 247 + irSchema: IRSchemaObject; 248 248 + schema: SchemaObject; 249 249 + }) => { 250 250 + if (schema.deprecated !== undefined) { 251 251 + irSchema.deprecated = schema.deprecated; 252 252 + } 253 253 + 254 254 + if (schema.description) { 255 255 + irSchema.description = schema.description; 256 256 + } 257 257 + }; 258 258 + 259 259 + const initIrSchema = ({ schema }: { schema: SchemaObject }): IRSchemaObject => { 260 260 + const irSchema: IRSchemaObject = {}; 261 261 + 262 262 + parseSchemaJsDoc({ 263 263 + irSchema, 264 264 + schema, 265 265 + }); 266 266 + 267 267 + return irSchema; 268 268 + }; 269 269 + 270 270 + const parseAllOf = ({ 271 271 + context, 272 272 + schema, 273 273 + }: { 274 274 + context: IRContext; 275 275 + schema: SchemaWithRequired<'allOf'>; 276 276 + }): IRSchemaObject => { 277 277 + let irSchema = initIrSchema({ schema }); 278 278 + 279 279 + const schemaItems: Array<IRSchemaObject> = []; 280 280 + const schemaTypes = getSchemaTypes({ schema }); 281 281 + 282 282 + const compositionSchemas = schema.allOf; 283 283 + 284 284 + for (const compositionSchema of compositionSchemas) { 285 285 + schemaItems.push( 286 286 + schemaToIrSchema({ 287 287 + context, 288 288 + schema: compositionSchema, 289 289 + }), 290 290 + ); 291 291 + } 292 292 + 293 293 + if (schemaTypes.includes('object')) { 294 294 + const irObjectSchema = parseOneType({ 295 295 + context, 296 296 + schema: { 297 297 + ...schema, 298 298 + type: 'object', 299 299 + }, 300 300 + }); 301 301 + 302 302 + if (irObjectSchema.properties) { 303 303 + for (const requiredProperty of irObjectSchema.required ?? []) { 304 304 + if (!irObjectSchema.properties[requiredProperty]) { 305 305 + for (const compositionSchema of compositionSchemas) { 306 306 + // TODO: parser - this could be probably resolved more accurately 307 307 + const finalCompositionSchema = compositionSchema.$ref 308 308 + ? context.resolveRef<SchemaObject>(compositionSchema.$ref) 309 309 + : compositionSchema; 310 310 + 311 311 + if ( 312 312 + getSchemaTypes({ schema: finalCompositionSchema }).includes( 313 313 + 'object', 314 314 + ) 315 315 + ) { 316 316 + const irCompositionSchema = parseOneType({ 317 317 + context, 318 318 + schema: { 319 319 + ...finalCompositionSchema, 320 320 + type: 'object', 321 321 + }, 322 322 + }); 323 323 + 324 324 + if (irCompositionSchema.properties?.[requiredProperty]) { 325 325 + irObjectSchema.properties[requiredProperty] = 326 326 + irCompositionSchema.properties[requiredProperty]; 327 327 + break; 328 328 + } 329 329 + } 330 330 + } 331 331 + } 332 332 + } 333 333 + schemaItems.push(irObjectSchema); 334 334 + } 335 335 + } 336 336 + 337 337 + if (schemaItems.length) { 338 338 + irSchema.items = schemaItems; 339 339 + irSchema.logicalOperator = 'and'; 340 340 + } 341 341 + 342 342 + if (schemaTypes.includes('null')) { 343 343 + // nest composition to avoid producing an intersection with null 344 344 + const nestedItems: Array<IRSchemaObject> = [ 345 345 + { 346 346 + type: 'null', 347 347 + }, 348 348 + ]; 349 349 + 350 350 + if (schemaItems.length) { 351 351 + nestedItems.unshift(irSchema); 352 352 + } 353 353 + 354 354 + irSchema = { 355 355 + items: nestedItems, 356 356 + logicalOperator: 'or', 357 357 + }; 358 358 + } 359 359 + 360 360 + if (schema.discriminator) { 361 361 + // TODO: parser - support discriminator 362 362 + // TODO: parser - maybe abstract discriminator from oneOf, anyOf, and allOf 363 363 + } 364 364 + 365 365 + return irSchema; 366 366 + }; 367 367 + 368 368 + const parseAnyOf = ({ 369 369 + context, 370 370 + schema, 371 371 + }: { 372 372 + context: IRContext; 373 373 + schema: SchemaWithRequired<'anyOf'>; 374 374 + }): IRSchemaObject => { 375 375 + let irSchema = initIrSchema({ schema }); 376 376 + 377 377 + const schemaItems: Array<IRSchemaObject> = []; 378 378 + const schemaTypes = getSchemaTypes({ schema }); 379 379 + 380 380 + for (const anyOf of schema.anyOf) { 381 381 + schemaItems.push( 382 382 + schemaToIrSchema({ 383 383 + context, 384 384 + schema: anyOf, 385 385 + }), 386 386 + ); 387 387 + } 388 388 + 389 389 + if (schemaTypes.includes('null')) { 390 390 + schemaItems.push({ type: 'null' }); 391 391 + } 392 392 + 393 393 + addItemsToSchema({ 394 394 + items: schemaItems, 395 395 + schema: irSchema, 396 396 + }); 397 397 + 398 398 + if (schemaTypes.includes('object')) { 399 399 + // nest composition to avoid producing a union with object properties 400 400 + const irObjectSchema = parseOneType({ 401 401 + context, 402 402 + schema: { 403 403 + ...schema, 404 404 + type: 'object', 405 405 + }, 406 406 + }); 407 407 + 408 408 + if (irObjectSchema.properties) { 409 409 + irSchema = { 410 410 + items: [irSchema, irObjectSchema], 411 411 + logicalOperator: 'and', 412 412 + }; 413 413 + } 414 414 + } 415 415 + 416 416 + if (schema.discriminator) { 417 417 + // TODO: parser - support discriminator 418 418 + // TODO: parser - maybe abstract discriminator from oneOf, anyOf, and allOf 419 419 + } 420 420 + 421 421 + return irSchema; 422 422 + }; 423 423 + 424 424 + const parseEnum = ({ 425 425 + context, 426 426 + schema, 427 427 + }: { 428 428 + context: IRContext; 429 429 + schema: SchemaWithRequired<'enum'>; 430 430 + }): IRSchemaObject => { 431 431 + const irSchema = initIrSchema({ schema }); 432 432 + 433 433 + irSchema.type = 'enum'; 434 434 + 435 435 + const schemaItems: Array<IRSchemaObject> = []; 436 436 + 437 437 + for (const [index, enumValue] of schema.enum.entries()) { 438 438 + const typeOfEnumValue = typeof enumValue; 439 439 + if ( 440 440 + typeOfEnumValue === 'string' || 441 441 + typeOfEnumValue === 'number' || 442 442 + typeOfEnumValue === 'boolean' 443 443 + ) { 444 444 + schemaItems.push( 445 445 + parseOneType({ 446 446 + context, 447 447 + schema: { 448 448 + const: enumValue, 449 449 + description: schema['x-enum-descriptions']?.[index], 450 450 + title: 451 451 + schema['x-enum-varnames']?.[index] ?? 452 452 + schema['x-enumNames']?.[index], 453 453 + type: typeOfEnumValue, 454 454 + }, 455 455 + }), 456 456 + ); 457 457 + } else { 458 458 + console.warn( 459 459 + '🚨', 460 460 + `unhandled "${typeOfEnumValue}" typeof value "${enumValue}" for enum`, 461 461 + schema.enum, 462 462 + ); 463 463 + } 464 464 + } 465 465 + 466 466 + addItemsToSchema({ 467 467 + items: schemaItems, 468 468 + schema: irSchema, 469 469 + }); 470 470 + 471 471 + return irSchema; 472 472 + }; 473 473 + 474 474 + const parseOneOf = ({ 475 475 + context, 476 476 + schema, 477 477 + }: { 478 478 + context: IRContext; 479 479 + schema: SchemaWithRequired<'oneOf'>; 480 480 + }): IRSchemaObject => { 481 481 + let irSchema = initIrSchema({ schema }); 482 482 + 483 483 + let schemaItems: Array<IRSchemaObject> = []; 484 484 + const schemaTypes = getSchemaTypes({ schema }); 485 485 + 486 486 + for (const oneOf of schema.oneOf) { 487 487 + const irOneOfSchema = schemaToIrSchema({ 488 488 + context, 489 489 + schema: oneOf, 490 490 + }); 491 491 + 492 492 + // since we know oneOf will be using "or" logical operator, if the parsed 493 493 + // composition schema also has an "or" operator, we can bring it up 494 494 + // to avoid unnecessary brackets 495 495 + if (irOneOfSchema.logicalOperator === 'or' && irOneOfSchema.items) { 496 496 + schemaItems = schemaItems.concat(irOneOfSchema.items); 497 497 + } else { 498 498 + schemaItems.push(irOneOfSchema); 499 499 + } 500 500 + } 501 501 + 502 502 + if (schemaTypes.includes('null')) { 503 503 + schemaItems.push({ type: 'null' }); 504 504 + } 505 505 + 506 506 + addItemsToSchema({ 507 507 + items: schemaItems, 508 508 + schema: irSchema, 509 509 + }); 510 510 + 511 511 + if (schemaTypes.includes('object')) { 512 512 + // nest composition to avoid producing a union with object properties 513 513 + const irObjectSchema = parseOneType({ 514 514 + context, 515 515 + schema: { 516 516 + ...schema, 517 517 + type: 'object', 518 518 + }, 519 519 + }); 520 520 + 521 521 + if (irObjectSchema.properties) { 522 522 + irSchema = { 523 523 + items: [irSchema, irObjectSchema], 524 524 + logicalOperator: 'and', 525 525 + }; 526 526 + } 527 527 + } 528 528 + 529 529 + if (schema.discriminator) { 530 530 + // TODO: parser - support discriminator 531 531 + // TODO: parser - maybe abstract discriminator from oneOf, anyOf, and allOf 532 532 + } 533 533 + 534 534 + return irSchema; 535 535 + }; 536 536 + 537 537 + const parseRef = ({ 538 538 + schema, 539 539 + }: { 540 540 + context: IRContext; 541 541 + schema: SchemaWithRequired<'$ref'>; 542 542 + }): IRSchemaObject => { 543 543 + const irSchema = initIrSchema({ schema }); 544 544 + 545 545 + // refs using unicode characters become encoded, didn't investigate why 546 546 + // but the suspicion is this comes from `@apidevtools/json-schema-ref-parser` 547 547 + irSchema.$ref = decodeURI(schema.$ref); 548 548 + 549 549 + return irSchema; 550 550 + }; 551 551 + 552 552 + const parseOneType = ({ 553 553 + context, 554 554 + irSchema, 555 555 + schema, 556 556 + }: { 557 557 + context: IRContext; 558 558 + irSchema?: IRSchemaObject; 559 559 + schema: Omit<SchemaObject, 'type'> & { 560 560 + type: SchemaType; 561 561 + }; 562 562 + }): IRSchemaObject => { 563 563 + if (!irSchema) { 564 564 + irSchema = initIrSchema({ schema }); 565 565 + 566 566 + parseSchemaMeta({ 567 567 + irSchema, 568 568 + schema, 569 569 + }); 570 570 + } 571 571 + 572 572 + switch (schema.type) { 573 573 + case 'array': 574 574 + return parseArray({ 575 575 + context, 576 576 + irSchema, 577 577 + schema, 578 578 + }); 579 579 + case 'boolean': 580 580 + return parseBoolean({ 581 581 + context, 582 582 + irSchema, 583 583 + schema, 584 584 + }); 585 585 + case 'integer': 586 586 + case 'number': 587 587 + return parseNumber({ 588 588 + context, 589 589 + irSchema, 590 590 + schema, 591 591 + }); 592 592 + case 'null': 593 593 + return parseNull({ 594 594 + context, 595 595 + irSchema, 596 596 + schema, 597 597 + }); 598 598 + case 'object': 599 599 + return parseObject({ 600 600 + context, 601 601 + irSchema, 602 602 + schema, 603 603 + }); 604 604 + case 'string': 605 605 + return parseString({ 606 606 + context, 607 607 + irSchema, 608 608 + schema, 609 609 + }); 610 610 + } 611 611 + }; 612 612 + 613 613 + const parseManyTypes = ({ 614 614 + context, 615 615 + irSchema, 616 616 + schema, 617 617 + }: { 618 618 + context: IRContext; 619 619 + irSchema?: IRSchemaObject; 620 620 + schema: Omit<SchemaObject, 'type'> & { 621 621 + type: ReadonlyArray<SchemaType>; 622 622 + }; 623 623 + }): IRSchemaObject => { 624 624 + if (!irSchema) { 625 625 + irSchema = initIrSchema({ schema }); 626 626 + 627 627 + parseSchemaMeta({ 628 628 + irSchema, 629 629 + schema, 630 630 + }); 631 631 + } 632 632 + 633 633 + const schemaItems: Array<IRSchemaObject> = []; 634 634 + 635 635 + for (const type of schema.type) { 636 636 + schemaItems.push( 637 637 + parseOneType({ 638 638 + context, 639 639 + irSchema: {}, 640 640 + schema: { 641 641 + ...schema, 642 642 + type, 643 643 + }, 644 644 + }), 645 645 + ); 646 646 + } 647 647 + 648 648 + addItemsToSchema({ 649 649 + items: schemaItems, 650 650 + schema: irSchema, 651 651 + }); 652 652 + 653 653 + return irSchema; 654 654 + }; 655 655 + 656 656 + const parseType = ({ 657 657 + context, 658 658 + schema, 659 659 + }: { 660 660 + context: IRContext; 661 661 + schema: SchemaWithRequired<'type'>; 662 662 + }): IRSchemaObject => { 663 663 + const irSchema = initIrSchema({ schema }); 664 664 + 665 665 + parseSchemaMeta({ 666 666 + irSchema, 667 667 + schema, 668 668 + }); 669 669 + 670 670 + const schemaTypes = getSchemaTypes({ schema }); 671 671 + 672 672 + if (schemaTypes.length === 1) { 673 673 + return parseOneType({ 674 674 + context, 675 675 + irSchema, 676 676 + schema: { 677 677 + ...schema, 678 678 + type: schemaTypes[0], 679 679 + }, 680 680 + }); 681 681 + } 682 682 + 683 683 + return parseManyTypes({ 684 684 + context, 685 685 + irSchema, 686 686 + schema: { 687 687 + ...schema, 688 688 + type: schemaTypes, 689 689 + }, 690 690 + }); 691 691 + }; 692 692 + 693 693 + const parseUnknown = ({ 694 694 + schema, 695 695 + }: { 696 696 + context: IRContext; 697 697 + schema: SchemaObject; 698 698 + }): IRSchemaObject => { 699 699 + const irSchema = initIrSchema({ schema }); 700 700 + 701 701 + irSchema.type = 'unknown'; 702 702 + 703 703 + parseSchemaMeta({ 704 704 + irSchema, 705 705 + schema, 706 706 + }); 707 707 + 708 708 + return irSchema; 709 709 + }; 710 710 + 711 711 + export const schemaToIrSchema = ({ 712 712 + context, 713 713 + schema, 714 714 + }: { 715 715 + context: IRContext; 716 716 + schema: SchemaObject; 717 717 + }): IRSchemaObject => { 718 718 + if (schema.$ref) { 719 719 + return parseRef({ 720 720 + context, 721 721 + schema: schema as SchemaWithRequired<'$ref'>, 722 722 + }); 723 723 + } 724 724 + 725 725 + if (schema.enum) { 726 726 + return parseEnum({ 727 727 + context, 728 728 + schema: schema as SchemaWithRequired<'enum'>, 729 729 + }); 730 730 + } 731 731 + 732 732 + if (schema.allOf) { 733 733 + return parseAllOf({ 734 734 + context, 735 735 + schema: schema as SchemaWithRequired<'allOf'>, 736 736 + }); 737 737 + } 738 738 + 739 739 + if (schema.anyOf) { 740 740 + return parseAnyOf({ 741 741 + context, 742 742 + schema: schema as SchemaWithRequired<'anyOf'>, 743 743 + }); 744 744 + } 745 745 + 746 746 + if (schema.oneOf) { 747 747 + return parseOneOf({ 748 748 + context, 749 749 + schema: schema as SchemaWithRequired<'oneOf'>, 750 750 + }); 751 751 + } 752 752 + 753 753 + if (schema.type) { 754 754 + return parseType({ 755 755 + context, 756 756 + schema: schema as SchemaWithRequired<'type'>, 757 757 + }); 758 758 + } 759 759 + 760 760 + return parseUnknown({ 761 761 + context, 762 762 + schema, 763 763 + }); 764 764 + }; 765 765 + 766 766 + export const parseSchema = ({ 767 767 + context, 768 768 + name, 769 769 + schema, 770 770 + }: { 771 771 + context: IRContext; 772 772 + name: string; 773 773 + schema: SchemaObject; 774 774 + }) => { 775 775 + if (!context.ir.components) { 776 776 + context.ir.components = {}; 777 777 + } 778 778 + 779 779 + if (!context.ir.components.schemas) { 780 780 + context.ir.components.schemas = {}; 781 781 + } 782 782 + 783 783 + context.ir.components.schemas[name] = schemaToIrSchema({ 784 784 + context, 785 785 + schema, 786 786 + }); 787 787 + };

+366

packages/openapi-ts/src/openApi/3.1.0/types/json-schema-draft-2020-12.d.ts

reviewed

··· 1 1 + import type { 2 2 + EnumExtensions, 3 3 + OpenApiSchemaExtensions, 4 4 + } from './spec-extensions'; 5 5 + 6 6 + // TODO: left out some keywords related to structuring a complex schema and declaring a dialect 7 7 + export interface JsonSchemaDraft2020_12 8 8 + extends ArrayKeywords, 9 9 + NumberKeywords, 10 10 + ObjectKeywords, 11 11 + StringKeywords, 12 12 + EnumExtensions, 13 13 + OpenApiSchemaExtensions { 14 14 + /** 15 15 + * The `$comment` {@link https://json-schema.org/learn/glossary#keyword keyword} is strictly intended for adding comments to a schema. Its value must always be a string. Unlike the annotations `title`, `description`, and `examples`, JSON schema {@link https://json-schema.org/learn/glossary#implementation implementations} aren't allowed to attach any meaning or behavior to it whatsoever, and may even strip them at any time. Therefore, they are useful for leaving notes to future editors of a JSON schema, but should not be used to communicate to users of the schema. 16 16 + */ 17 17 + $comment?: string; 18 18 + /** 19 19 + * A schema can reference another schema using the `$ref` keyword. The value of `$ref` is a URI-reference that is resolved against the schema's {@link https://json-schema.org/understanding-json-schema/structuring#base-uri Base URI}. When evaluating a `$ref`, an implementation uses the resolved identifier to retrieve the referenced schema and applies that schema to the {@link https://json-schema.org/learn/glossary#instance instance}. 20 20 + * 21 21 + * The `$ref` keyword may be used to create recursive schemas that refer to themselves. 22 22 + */ 23 23 + $ref?: string; 24 24 + /** 25 25 + * `allOf`: (AND) Must be valid against _all_ of the {@link https://json-schema.org/learn/glossary#subschema subschemas} 26 26 + * 27 27 + * To validate against `allOf`, the given data must be valid against all of the given subschemas. 28 28 + * 29 29 + * {@link https://json-schema.org/understanding-json-schema/reference/combining#allof allOf} can not be used to "extend" a schema to add more details to it in the sense of object-oriented inheritance. {@link https://json-schema.org/learn/glossary#instance Instances} must independently be valid against "all of" the schemas in the `allOf`. See the section on {@link https://json-schema.org/understanding-json-schema/reference/object#extending Extending Closed Schemas} for more information. 30 30 + */ 31 31 + allOf?: ReadonlyArray<JsonSchemaDraft2020_12>; 32 32 + /** 33 33 + * `anyOf`: (OR) Must be valid against _any_ of the subschemas 34 34 + * 35 35 + * To validate against `anyOf`, the given data must be valid against any (one or more) of the given subschemas. 36 36 + */ 37 37 + anyOf?: ReadonlyArray<JsonSchemaDraft2020_12>; 38 38 + /** 39 39 + * The `const` keyword is used to restrict a value to a single value. 40 40 + */ 41 41 + const?: unknown; 42 42 + /** 43 43 + * The `contentEncoding` keyword specifies the encoding used to store the contents, as specified in {@link https://tools.ietf.org/html/rfc2045 RFC 2054, part 6.1} and {@link https://datatracker.ietf.org/doc/html/rfc4648 RFC 4648}. 44 44 + * 45 45 + * The acceptable values are `quoted-printable`, `base16`, `base32`, and `base64`. If not specified, the encoding is the same as the containing JSON document. 46 46 + * 47 47 + * Without getting into the low-level details of each of these encodings, there are really only two options useful for modern usage: 48 48 + * - If the content is encoded in the same encoding as the enclosing JSON document (which for practical purposes, is almost always UTF-8), leave `contentEncoding` unspecified, and include the content in a string as-is. This includes text-based content types, such as `text/html` or `application/xml`. 49 49 + * - If the content is binary data, set `contentEncoding` to `base64` and encode the contents using {@link https://tools.ietf.org/html/rfc4648 Base64}. This would include many image types, such as `image/png` or audio types, such as `audio/mpeg`. 50 50 + */ 51 51 + contentEncoding?: 'base16' | 'base32' | 'base64' | 'quoted-printable'; 52 52 + /** 53 53 + * The `contentMediaType` keyword specifies the MIME type of the contents of a string, as described in {@link https://tools.ietf.org/html/rfc2046 RFC 2046}. There is a list of {@link http://www.iana.org/assignments/media-types/media-types.xhtml MIME types officially registered by the IANA}, but the set of types supported will be application and operating system dependent. Mozilla Developer Network also maintains a {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Complete_list_of_MIME_types shorter list of MIME types that are important for the web} 54 54 + */ 55 55 + contentMediaType?: string; 56 56 + /** 57 57 + * The `default` keyword specifies a default value. This value is not used to fill in missing values during the validation process. Non-validation tools such as documentation generators or form generators may use this value to give hints to users about how to use a value. However, `default` is typically used to express that if a value is missing, then the value is semantically the same as if the value was present with the default value. The value of `default` should validate against the schema in which it resides, but that isn't required. 58 58 + */ 59 59 + default?: unknown; 60 60 + /** 61 61 + * The `dependentRequired` {@link https://json-schema.org/learn/glossary#keyword keyword} conditionally requires that certain properties must be present if a given property is present in an object. For example, suppose we have a {@link https://json-schema.org/learn/glossary#schema schema} representing a customer. If you have their credit card number, you also want to ensure you have a billing address. If you don't have their credit card number, a billing address would not be required. We represent this dependency of one property on another using the `dependentRequired` keyword. The value of the `dependentRequired` keyword is an object. Each entry in the object maps from the name of a property, _p_, to an array of strings listing properties that are required if _p_ is present. 62 62 + */ 63 63 + dependentRequired?: Record<string, ReadonlyArray<string>>; 64 64 + /** 65 65 + * The `dependentSchemas` keyword conditionally applies a {@link https://json-schema.org/learn/glossary#subschema subschema} when a given property is present. This schema is applied in the same way {@link https://json-schema.org/understanding-json-schema/reference/combining#allof allOf} applies schemas. Nothing is merged or extended. Both schemas apply independently. 66 66 + */ 67 67 + dependentSchemas?: Record<string, JsonSchemaDraft2020_12>; 68 68 + /** 69 69 + * The `deprecated` keyword is a boolean that indicates that the {@link https://json-schema.org/learn/glossary#instance instance} value the keyword applies to should not be used and may be removed in the future. 70 70 + */ 71 71 + deprecated?: boolean; 72 72 + /** 73 73 + * The `title` and `description` keywords must be strings. A "title" will preferably be short, whereas a "description" will provide a more lengthy explanation about the purpose of the data described by the schema. 74 74 + */ 75 75 + description?: string; 76 76 + /** 77 77 + * The `if`, `then` and `else` keywords allow the application of a subschema based on the outcome of another schema, much like the `if`/`then`/`else` constructs you've probably seen in traditional programming languages. 78 78 + * 79 79 + * If `if` is valid, `then` must also be valid (and `else` is ignored.) If `if` is invalid, `else` must also be valid (and `then` is ignored). 80 80 + * 81 81 + * If `then` or `else` is not defined, `if` behaves as if they have a value of `true`. 82 82 + * 83 83 + * If `then` and/or `else` appear in a schema without `if`, `then` and `else` are ignored. 84 84 + */ 85 85 + else?: JsonSchemaDraft2020_12; 86 86 + /** 87 87 + * The `enum` {@link https://json-schema.org/learn/glossary#keyword keyword} is used to restrict a value to a fixed set of values. It must be an array with at least one element, where each element is unique. 88 88 + * 89 89 + * You can use `enum` even without a type, to accept values of different types. 90 90 + */ 91 91 + enum?: ReadonlyArray<unknown>; 92 92 + /** 93 93 + * The `examples` keyword is a place to provide an array of examples that validate against the schema. This isn't used for validation, but may help with explaining the effect and purpose of the schema to a reader. Each entry should validate against the schema in which it resides, but that isn't strictly required. There is no need to duplicate the `default` value in the `examples` array, since `default` will be treated as another example. 94 94 + */ 95 95 + examples?: ReadonlyArray<unknown>; 96 96 + /** 97 97 + * The `format` keyword allows for basic semantic identification of certain kinds of string values that are commonly used. For example, because JSON doesn't have a "DateTime" type, dates need to be encoded as strings. `format` allows the schema author to indicate that the string value should be interpreted as a date. By default, `format` is just an annotation and does not effect validation. 98 98 + * 99 99 + * Optionally, validator {@link https://json-schema.org/learn/glossary#implementation implementations} can provide a configuration option to enable `format` to function as an assertion rather than just an annotation. That means that validation will fail if, for example, a value with a `date` format isn't in a form that can be parsed as a date. This can allow values to be constrained beyond what the other tools in JSON Schema, including {@link https://json-schema.org/understanding-json-schema/reference/regular_expressions Regular Expressions} can do. 100 100 + * 101 101 + * There is a bias toward networking-related formats in the JSON Schema specification, most likely due to its heritage in web technologies. However, custom formats may also be used, as long as the parties exchanging the JSON documents also exchange information about the custom format types. A JSON Schema validator will ignore any format type that it does not understand. 102 102 + */ 103 103 + format?: JsonSchemaFormats; 104 104 + /** 105 105 + * The `if`, `then` and `else` keywords allow the application of a subschema based on the outcome of another schema, much like the `if`/`then`/`else` constructs you've probably seen in traditional programming languages. 106 106 + * 107 107 + * If `if` is valid, `then` must also be valid (and `else` is ignored.) If `if` is invalid, `else` must also be valid (and `then` is ignored). 108 108 + * 109 109 + * If `then` or `else` is not defined, `if` behaves as if they have a value of `true`. 110 110 + * 111 111 + * If `then` and/or `else` appear in a schema without `if`, `then` and `else` are ignored. 112 112 + */ 113 113 + if?: JsonSchemaDraft2020_12; 114 114 + /** 115 115 + * `not`: (NOT) Must _not_ be valid against the given schema 116 116 + * 117 117 + * The `not` keyword declares that an instance validates if it doesn't validate against the given subschema. 118 118 + */ 119 119 + not?: JsonSchemaDraft2020_12; 120 120 + /** 121 121 + * `oneOf`: (XOR) Must be valid against _exactly one_ of the subschemas 122 122 + * 123 123 + * To validate against `oneOf`, the given data must be valid against exactly one of the given subschemas. 124 124 + * 125 125 + * Careful consideration should be taken when using `oneOf` entries as the nature of it requires verification of _every_ sub-schema which can lead to increased processing times. Prefer `anyOf` where possible. 126 126 + */ 127 127 + oneOf?: ReadonlyArray<JsonSchemaDraft2020_12>; 128 128 + /** 129 129 + * The boolean keywords `readOnly` and `writeOnly` are typically used in an API context. `readOnly` indicates that a value should not be modified. It could be used to indicate that a `PUT` request that changes a value would result in a `400 Bad Request` response. `writeOnly` indicates that a value may be set, but will remain hidden. In could be used to indicate you can set a value with a `PUT` request, but it would not be included when retrieving that record with a `GET` request. 130 130 + */ 131 131 + readOnly?: boolean; 132 132 + /** 133 133 + * The `if`, `then` and `else` keywords allow the application of a subschema based on the outcome of another schema, much like the `if`/`then`/`else` constructs you've probably seen in traditional programming languages. 134 134 + * 135 135 + * If `if` is valid, `then` must also be valid (and `else` is ignored.) If `if` is invalid, `else` must also be valid (and `then` is ignored). 136 136 + * 137 137 + * If `then` or `else` is not defined, `if` behaves as if they have a value of `true`. 138 138 + * 139 139 + * If `then` and/or `else` appear in a schema without `if`, `then` and `else` are ignored. 140 140 + */ 141 141 + then?: JsonSchemaDraft2020_12; 142 142 + /** 143 143 + * The `title` and `description` keywords must be strings. A "title" will preferably be short, whereas a "description" will provide a more lengthy explanation about the purpose of the data described by the schema. 144 144 + */ 145 145 + title?: string; 146 146 + /** 147 147 + * If it is an array, it must be an array of strings, where each string is the name of one of the basic types, and each element is unique. In this case, the JSON snippet is valid if it matches any of the given types. 148 148 + */ 149 149 + type?: JsonSchemaTypes | ReadonlyArray<JsonSchemaTypes>; 150 150 + /** 151 151 + * The boolean keywords `readOnly` and `writeOnly` are typically used in an API context. `readOnly` indicates that a value should not be modified. It could be used to indicate that a `PUT` request that changes a value would result in a `400 Bad Request` response. `writeOnly` indicates that a value may be set, but will remain hidden. In could be used to indicate you can set a value with a `PUT` request, but it would not be included when retrieving that record with a `GET` request. 152 152 + */ 153 153 + writeOnly?: boolean; 154 154 + } 155 155 + 156 156 + interface ArrayKeywords { 157 157 + /** 158 158 + * While the `items` schema must be valid for every item in the array, the `contains` schema only needs to validate against one or more items in the array. 159 159 + */ 160 160 + contains?: JsonSchemaDraft2020_12; 161 161 + /** 162 162 + * List validation is useful for arrays of arbitrary length where each item matches the same schema. For this kind of array, set the `items` {@link https://json-schema.org/learn/glossary#keyword keyword} to a single schema that will be used to validate all of the items in the array. 163 163 + * 164 164 + * The `items` keyword can be used to control whether it's valid to have additional items in a tuple beyond what is defined in `prefixItems`. The value of the `items` keyword is a schema that all additional items must pass in order for the keyword to validate. 165 165 + * 166 166 + * Note that `items` doesn't "see inside" any {@link https://json-schema.org/learn/glossary#instance instances} of `allOf`, `anyOf`, or `oneOf` in the same {@link https://json-schema.org/learn/glossary#subschema subschema}. 167 167 + */ 168 168 + items?: JsonSchemaDraft2020_12 | false; 169 169 + /** 170 170 + * `minContains` and `maxContains` can be used with `contains` to further specify how many times a schema matches a `contains` constraint. These keywords can be any non-negative number including zero. 171 171 + */ 172 172 + maxContains?: number; 173 173 + /** 174 174 + * The length of the array can be specified using the `minItems` and `maxItems` keywords. The value of each keyword must be a non-negative number. These keywords work whether doing {@link https://json-schema.org/understanding-json-schema/reference/array#items list validation} or {@link https://json-schema.org/understanding-json-schema/reference/array#tupleValidation tuple-validation}. 175 175 + */ 176 176 + maxItems?: number; 177 177 + /** 178 178 + * `minContains` and `maxContains` can be used with `contains` to further specify how many times a schema matches a `contains` constraint. These keywords can be any non-negative number including zero. 179 179 + */ 180 180 + minContains?: number; 181 181 + /** 182 182 + * The length of the array can be specified using the `minItems` and `maxItems` keywords. The value of each keyword must be a non-negative number. These keywords work whether doing {@link https://json-schema.org/understanding-json-schema/reference/array#items list validation} or {@link https://json-schema.org/understanding-json-schema/reference/array#tupleValidation tuple-validation}. 183 183 + */ 184 184 + minItems?: number; 185 185 + /** 186 186 + * `prefixItems` is an array, where each item is a schema that corresponds to each index of the document's array. That is, an array where the first element validates the first element of the input array, the second element validates the second element of the input array, etc. 187 187 + */ 188 188 + prefixItems?: ReadonlyArray<JsonSchemaDraft2020_12>; 189 189 + /** 190 190 + * The `unevaluatedItems` keyword is useful mainly when you want to add or disallow extra items to an array. 191 191 + * 192 192 + * `unevaluatedItems` applies to any values not evaluated by an `items`, `prefixItems`, or `contains` keyword. Just as `unevaluatedProperties` affects only properties in an object, `unevaluatedItems` affects only items in an array. 193 193 + * 194 194 + * Watch out! The word "unevaluated" _does not mean_ "not evaluated by `items`, `prefixItems`, or `contains`." "Unevaluated" means "not successfully evaluated", or "does not evaluate to true". 195 195 + * 196 196 + * Like with `items`, if you set `unevaluatedItems` to false, you can disallow extra items in the array. 197 197 + */ 198 198 + unevaluatedItems?: JsonSchemaDraft2020_12 | false; 199 199 + /** 200 200 + * A schema can ensure that each of the items in an array is unique. Simply set the `uniqueItems` keyword to `true`. 201 201 + */ 202 202 + uniqueItems?: boolean; 203 203 + } 204 204 + 205 205 + interface NumberKeywords { 206 206 + /** 207 207 + * Ranges of numbers are specified using a combination of the `minimum` and `maximum` keywords, (or `exclusiveMinimum` and `exclusiveMaximum` for expressing exclusive range). 208 208 + * 209 209 + * If _x_ is the value being validated, the following must hold true: 210 210 + * 211 211 + * ``` 212 212 + * x ≥ minimum 213 213 + * x > exclusiveMinimum 214 214 + * x ≤ maximum 215 215 + * x < exclusiveMaximum 216 216 + * ``` 217 217 + * 218 218 + * While you can specify both of `minimum` and `exclusiveMinimum` or both of `maximum` and `exclusiveMaximum`, it doesn't really make sense to do so. 219 219 + */ 220 220 + exclusiveMaximum?: number; 221 221 + /** 222 222 + * Ranges of numbers are specified using a combination of the `minimum` and `maximum` keywords, (or `exclusiveMinimum` and `exclusiveMaximum` for expressing exclusive range). 223 223 + * 224 224 + * If _x_ is the value being validated, the following must hold true: 225 225 + * 226 226 + * ``` 227 227 + * x ≥ minimum 228 228 + * x > exclusiveMinimum 229 229 + * x ≤ maximum 230 230 + * x < exclusiveMaximum 231 231 + * ``` 232 232 + * 233 233 + * While you can specify both of `minimum` and `exclusiveMinimum` or both of `maximum` and `exclusiveMaximum`, it doesn't really make sense to do so. 234 234 + */ 235 235 + exclusiveMinimum?: number; 236 236 + /** 237 237 + * Ranges of numbers are specified using a combination of the `minimum` and `maximum` keywords, (or `exclusiveMinimum` and `exclusiveMaximum` for expressing exclusive range). 238 238 + * 239 239 + * If _x_ is the value being validated, the following must hold true: 240 240 + * 241 241 + * ``` 242 242 + * x ≥ minimum 243 243 + * x > exclusiveMinimum 244 244 + * x ≤ maximum 245 245 + * x < exclusiveMaximum 246 246 + * ``` 247 247 + * 248 248 + * While you can specify both of `minimum` and `exclusiveMinimum` or both of `maximum` and `exclusiveMaximum`, it doesn't really make sense to do so. 249 249 + */ 250 250 + maximum?: number; 251 251 + /** 252 252 + * Ranges of numbers are specified using a combination of the `minimum` and `maximum` keywords, (or `exclusiveMinimum` and `exclusiveMaximum` for expressing exclusive range). 253 253 + * 254 254 + * If _x_ is the value being validated, the following must hold true: 255 255 + * 256 256 + * ``` 257 257 + * x ≥ minimum 258 258 + * x > exclusiveMinimum 259 259 + * x ≤ maximum 260 260 + * x < exclusiveMaximum 261 261 + * ``` 262 262 + * 263 263 + * While you can specify both of `minimum` and `exclusiveMinimum` or both of `maximum` and `exclusiveMaximum`, it doesn't really make sense to do so. 264 264 + */ 265 265 + minimum?: number; 266 266 + /** 267 267 + * Numbers can be restricted to a multiple of a given number, using the `multipleOf` keyword. It may be set to any positive number. The multiple can be a floating point number. 268 268 + */ 269 269 + multipleOf?: number; 270 270 + } 271 271 + 272 272 + interface ObjectKeywords { 273 273 + /** 274 274 + * The `additionalProperties` keyword is used to control the handling of extra stuff, that is, properties whose names are not listed in the `properties` keyword or match any of the regular expressions in the `patternProperties` keyword. By default any additional properties are allowed. 275 275 + * 276 276 + * The value of the `additionalProperties` keyword is a schema that will be used to validate any properties in the {@link https://json-schema.org/learn/glossary#instance instance} that are not matched by `properties` or `patternProperties`. Setting the `additionalProperties` schema to `false` means no additional properties will be allowed. 277 277 + * 278 278 + * It's important to note that `additionalProperties` only recognizes properties declared in the same {@link https://json-schema.org/learn/glossary#subschema subschema} as itself. So, `additionalProperties` can restrict you from "extending" a schema using {@link https://json-schema.org/understanding-json-schema/reference/combining combining} keywords such as {@link https://json-schema.org/understanding-json-schema/reference/combining#allof allOf}. 279 279 + */ 280 280 + additionalProperties?: JsonSchemaDraft2020_12 | false; 281 281 + /** 282 282 + * The number of properties on an object can be restricted using the `minProperties` and `maxProperties` keywords. Each of these must be a non-negative integer. 283 283 + */ 284 284 + maxProperties?: number; 285 285 + /** 286 286 + * The number of properties on an object can be restricted using the `minProperties` and `maxProperties` keywords. Each of these must be a non-negative integer. 287 287 + */ 288 288 + minProperties?: number; 289 289 + /** 290 290 + * Sometimes you want to say that, given a particular kind of property name, the value should match a particular schema. That's where `patternProperties` comes in: it maps regular expressions to schemas. If a property name matches the given regular expression, the property value must validate against the corresponding schema. 291 291 + */ 292 292 + patternProperties?: Record<string, JsonSchemaDraft2020_12>; 293 293 + /** 294 294 + * The properties (key-value pairs) on an object are defined using the `properties` {@link https://json-schema.org/learn/glossary#keyword keyword}. The value of `properties` is an object, where each key is the name of a property and each value is a {@link https://json-schema.org/learn/glossary#schema schema} used to validate that property. Any property that doesn't match any of the property names in the `properties` keyword is ignored by this keyword. 295 295 + */ 296 296 + properties?: Record<string, JsonSchemaDraft2020_12 | true>; 297 297 + /** 298 298 + * The names of properties can be validated against a schema, irrespective of their values. This can be useful if you don't want to enforce specific properties, but you want to make sure that the names of those properties follow a specific convention. You might, for example, want to enforce that all names are valid ASCII tokens so they can be used as attributes in a particular programming language. 299 299 + * 300 300 + * Since object keys must always be strings anyway, it is implied that the schema given to `propertyNames` is always at least: 301 301 + * 302 302 + * ```json 303 303 + * { "type": "string" } 304 304 + * ``` 305 305 + */ 306 306 + propertyNames?: JsonSchemaDraft2020_12; 307 307 + /** 308 308 + * By default, the properties defined by the `properties` keyword are not required. However, one can provide a list of required properties using the `required` keyword. 309 309 + * 310 310 + * The `required` keyword takes an array of zero or more strings. Each of these strings must be unique. 311 311 + */ 312 312 + required?: ReadonlyArray<string>; 313 313 + /** 314 314 + * The `unevaluatedProperties` keyword is similar to `additionalProperties` except that it can recognize properties declared in subschemas. So, the example from the previous section can be rewritten without the need to redeclare properties. 315 315 + * 316 316 + * `unevaluatedProperties` works by collecting any properties that are successfully validated when processing the schemas and using those as the allowed list of properties. This allows you to do more complex things like conditionally adding properties. 317 317 + */ 318 318 + unevaluatedProperties?: JsonSchemaDraft2020_12 | false; 319 319 + } 320 320 + 321 321 + interface StringKeywords { 322 322 + /** 323 323 + * The length of a string can be constrained using the `minLength` and `maxLength` {@link https://json-schema.org/learn/glossary#keyword keywords}. For both keywords, the value must be a non-negative number. 324 324 + */ 325 325 + maxLength?: number; 326 326 + /** 327 327 + * The length of a string can be constrained using the `minLength` and `maxLength` {@link https://json-schema.org/learn/glossary#keyword keywords}. For both keywords, the value must be a non-negative number. 328 328 + */ 329 329 + minLength?: number; 330 330 + /** 331 331 + * The `pattern` keyword is used to restrict a string to a particular regular expression. The regular expression syntax is the one defined in JavaScript ({@link https://www.ecma-international.org/publications-and-standards/standards/ecma-262/ ECMA 262} specifically) with Unicode support. See {@link https://json-schema.org/understanding-json-schema/reference/regular_expressions Regular Expressions} for more information. 332 332 + */ 333 333 + pattern?: string; 334 334 + } 335 335 + 336 336 + type JsonSchemaFormats = 337 337 + | 'date' 338 338 + | 'date-time' 339 339 + | 'duration' 340 340 + | 'email' 341 341 + | 'hostname' 342 342 + | 'idn-email' 343 343 + | 'idn-hostname' 344 344 + | 'ipv4' 345 345 + | 'ipv6' 346 346 + | 'iri' 347 347 + | 'iri-reference' 348 348 + | 'json-pointer' 349 349 + | 'regex' 350 350 + | 'relative-json-pointer' 351 351 + | 'time' 352 352 + | 'uri' 353 353 + | 'uri-reference' 354 354 + | 'uri-template' 355 355 + | 'uuid' 356 356 + // eslint-disable-next-line @typescript-eslint/ban-types 357 357 + | (string & {}); 358 358 + 359 359 + type JsonSchemaTypes = 360 360 + | 'array' 361 361 + | 'boolean' 362 362 + | 'integer' 363 363 + | 'null' 364 364 + | 'number' 365 365 + | 'object' 366 366 + | 'string';

+41

packages/openapi-ts/src/openApi/3.1.0/types/spec-extensions.d.ts

reviewed

··· 1 1 + import type { 2 2 + DiscriminatorObject, 3 3 + ExternalDocumentationObject, 4 4 + XMLObject, 5 5 + } from './spec'; 6 6 + 7 7 + export interface EnumExtensions { 8 8 + /** 9 9 + * `x-enum-descriptions` are {@link https://stackoverflow.com/a/66471626 supported} by OpenAPI Generator. 10 10 + */ 11 11 + 'x-enum-descriptions'?: ReadonlyArray<string>; 12 12 + /** 13 13 + * `x-enum-varnames` are {@link https://stackoverflow.com/a/66471626 supported} by OpenAPI Generator. 14 14 + */ 15 15 + 'x-enum-varnames'?: ReadonlyArray<string>; 16 16 + /** 17 17 + * {@link https://github.com/RicoSuter/NSwag NSwag} generates `x-enumNames` field containing custom enum names. 18 18 + */ 19 19 + 'x-enumNames'?: ReadonlyArray<string>; 20 20 + } 21 21 + 22 22 + export interface OpenApiSchemaExtensions { 23 23 + /** 24 24 + * Adds support for polymorphism. The discriminator is an object name that is used to differentiate between other schemas which may satisfy the payload description. See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#composition-and-inheritance-polymorphism Composition and Inheritance} for more details. 25 25 + */ 26 26 + discriminator?: DiscriminatorObject; 27 27 + /** 28 28 + * A free-form property to include an example of an instance for this schema. To represent examples that cannot be naturally represented in JSON or YAML, a string value can be used to contain the example with escaping where necessary. 29 29 + * 30 30 + * **Deprecated**: The `example` property has been deprecated in favor of the JSON Schema `examples` keyword. Use of `example` is discouraged, and later versions of this specification may remove it. 31 31 + */ 32 32 + example?: unknown; 33 33 + /** 34 34 + * Additional external documentation for this schema. 35 35 + */ 36 36 + externalDocs?: ExternalDocumentationObject; 37 37 + /** 38 38 + * This MAY be used only on properties schemas. It has no effect on root schemas. Adds additional metadata to describe the XML representation of this property. 39 39 + */ 40 40 + xml?: XMLObject; 41 41 + }

-2

packages/openapi-ts/src/openApi/3.1/index.ts

reviewed

··· 1 1 - export { parseV3_1 } from './parser'; 2 2 - export type { OpenApiV3_1 } from './types/spec';

-82

packages/openapi-ts/src/openApi/3.1/parser/index.ts

reviewed

··· 1 1 - import type { OpenApiV3_1, PathsObject } from '../types/spec'; 2 2 - import { parseOperation } from './operation'; 3 3 - 4 4 - export const parseV3_1 = (spec: OpenApiV3_1) => { 5 5 - const operationIds = new Map<string, string>(); 6 6 - 7 7 - for (const path in spec.paths) { 8 8 - const pathItem = spec.paths[path as keyof PathsObject]; 9 9 - 10 10 - if (pathItem.delete) { 11 11 - parseOperation({ 12 12 - method: 'DELETE', 13 13 - operation: pathItem.delete, 14 14 - operationIds, 15 15 - path, 16 16 - }); 17 17 - } 18 18 - 19 19 - if (pathItem.get) { 20 20 - parseOperation({ 21 21 - method: 'GET', 22 22 - operation: pathItem.get, 23 23 - operationIds, 24 24 - path, 25 25 - }); 26 26 - } 27 27 - 28 28 - if (pathItem.head) { 29 29 - parseOperation({ 30 30 - method: 'HEAD', 31 31 - operation: pathItem.head, 32 32 - operationIds, 33 33 - path, 34 34 - }); 35 35 - } 36 36 - 37 37 - if (pathItem.options) { 38 38 - parseOperation({ 39 39 - method: 'OPTIONS', 40 40 - operation: pathItem.options, 41 41 - operationIds, 42 42 - path, 43 43 - }); 44 44 - } 45 45 - 46 46 - if (pathItem.patch) { 47 47 - parseOperation({ 48 48 - method: 'PATCH', 49 49 - operation: pathItem.patch, 50 50 - operationIds, 51 51 - path, 52 52 - }); 53 53 - } 54 54 - 55 55 - if (pathItem.post) { 56 56 - parseOperation({ 57 57 - method: 'POST', 58 58 - operation: pathItem.post, 59 59 - operationIds, 60 60 - path, 61 61 - }); 62 62 - } 63 63 - 64 64 - if (pathItem.put) { 65 65 - parseOperation({ 66 66 - method: 'PUT', 67 67 - operation: pathItem.put, 68 68 - operationIds, 69 69 - path, 70 70 - }); 71 71 - } 72 72 - 73 73 - if (pathItem.trace) { 74 74 - parseOperation({ 75 75 - method: 'TRACE', 76 76 - operation: pathItem.trace, 77 77 - operationIds, 78 78 - path, 79 79 - }); 80 80 - } 81 81 - } 82 82 - };

-39

packages/openapi-ts/src/openApi/3.1/parser/operation.ts

reviewed

··· 1 1 - import { getConfig } from '../../../utils/config'; 2 2 - import type { OperationObject } from '../types/spec'; 3 3 - 4 4 - export const parseOperation = ({ 5 5 - method, 6 6 - operation, 7 7 - operationIds, 8 8 - path, 9 9 - }: { 10 10 - method: string; 11 11 - operation: OperationObject; 12 12 - operationIds: Map<string, string>; 13 13 - path: string; 14 14 - }) => { 15 15 - const operationKey = `${method} ${path}`; 16 16 - 17 17 - const config = getConfig(); 18 18 - 19 19 - // TODO: filter function, move services to plugin, cleaner syntax 20 20 - const regexp = config.services.filter 21 21 - ? new RegExp(config.services.filter) 22 22 - : undefined; 23 23 - if (regexp && !regexp.test(operationKey)) { 24 24 - return; 25 25 - } 26 26 - 27 27 - // TODO: support throw on duplicate 28 28 - if (operation.operationId) { 29 29 - if (operationIds.has(operation.operationId)) { 30 30 - console.warn( 31 31 - `❗️ Duplicate operationId: ${operation.operationId} in ${operationKey}. Please ensure your operation IDs are unique. This behavior is not supported and will likely lead to unexpected results.`, 32 32 - ); 33 33 - } else { 34 34 - operationIds.set(operation.operationId, operationKey); 35 35 - } 36 36 - } 37 37 - 38 38 - console.log(operation); 39 39 - };

+4 -21

packages/openapi-ts/src/openApi/3.1/types/spec.ts packages/openapi-ts/src/openApi/3.1.0/types/spec.d.ts

reviewed

··· 1 1 + import type { JsonSchemaDraft2020_12 } from './json-schema-draft-2020-12'; 2 2 + 1 3 /** 2 4 * This is the root object of the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#openapi-document OpenAPI document}. 3 5 * 4 6 * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}. 5 7 */ 6 6 - export interface OpenApiV3_1 { 8 8 + export interface OpenApiV3_1_0 { 7 9 /** 8 10 * An element to hold various schemas for the document. 9 11 */ ··· 1651 1653 * 1652 1654 * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}, though as noted, additional properties MAY omit the `x-` prefix within this object. 1653 1655 */ 1654 1654 - export interface SchemaObject { 1655 1655 - /** 1656 1656 - * Adds support for polymorphism. The discriminator is an object name that is used to differentiate between other schemas which may satisfy the payload description. See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#composition-and-inheritance-polymorphism Composition and Inheritance} for more details. 1657 1657 - */ 1658 1658 - discriminator?: DiscriminatorObject; 1659 1659 - /** 1660 1660 - * A free-form property to include an example of an instance for this schema. To represent examples that cannot be naturally represented in JSON or YAML, a string value can be used to contain the example with escaping where necessary. 1661 1661 - * 1662 1662 - * **Deprecated**: The `example` property has been deprecated in favor of the JSON Schema `examples` keyword. Use of `example` is discouraged, and later versions of this specification may remove it. 1663 1663 - */ 1664 1664 - example?: unknown; 1665 1665 - /** 1666 1666 - * Additional external documentation for this schema. 1667 1667 - */ 1668 1668 - externalDocs?: ExternalDocumentationObject; 1669 1669 - /** 1670 1670 - * This MAY be used only on properties schemas. It has no effect on root schemas. Adds additional metadata to describe the XML representation of this property. 1671 1671 - */ 1672 1672 - xml?: XMLObject; 1673 1673 - } 1656 1656 + export interface SchemaObject extends JsonSchemaDraft2020_12 {} 1674 1657 1675 1658 /** 1676 1659 * Lists the required security schemes to execute this operation. The name used for each property MUST correspond to a security scheme declared in the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#componentsSecuritySchemes Security Schemes} under the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#components-object Components Object}.

+12 -8

packages/openapi-ts/src/openApi/__tests__/index.spec.ts

reviewed

··· 1 1 import { afterEach, describe, expect, it, vi } from 'vitest'; 2 2 3 3 import { type OpenApi, parse } from '..'; 4 4 - import type { Config } from '../common/interfaces/config'; 4 4 + import type { ParserConfig } from '../config'; 5 5 import * as parseV2 from '../v2'; 6 6 import * as parseV3 from '../v3'; 7 7 8 8 - const config: Config = { 8 8 + const parserConfig: ParserConfig = { 9 9 + filterFn: { 10 10 + operation: () => true, 11 11 + operationParameter: () => true, 12 12 + }, 9 13 nameFn: { 10 14 operation: () => 'operation', 11 15 operationParameter: () => 'operationParameter', ··· 28 32 paths: {}, 29 33 swagger: '2', 30 34 }; 31 31 - parse({ config, openApi: spec }); 35 35 + parse({ openApi: spec, parserConfig }); 32 36 expect(spy).toHaveBeenCalledWith(spec); 33 37 34 38 const spec2: OpenApi = { ··· 39 43 paths: {}, 40 44 swagger: '2.0', 41 45 }; 42 42 - parse({ config, openApi: spec2 }); 46 46 + parse({ openApi: spec2, parserConfig }); 43 47 expect(spy).toHaveBeenCalledWith(spec2); 44 48 }); 45 49 ··· 54 58 openapi: '3', 55 59 paths: {}, 56 60 }; 57 57 - parse({ config, openApi: spec }); 61 61 + parse({ openApi: spec, parserConfig }); 58 62 expect(spy).toHaveBeenCalledWith(spec); 59 63 60 64 const spec2: OpenApi = { ··· 65 69 openapi: '3.0', 66 70 paths: {}, 67 71 }; 68 68 - parse({ config, openApi: spec2 }); 72 72 + parse({ openApi: spec2, parserConfig }); 69 73 expect(spy).toHaveBeenCalledWith(spec2); 70 74 71 75 const spec3: OpenApi = { ··· 76 80 openapi: '3.1.0', 77 81 paths: {}, 78 82 }; 79 79 - parse({ config, openApi: spec3 }); 83 83 + parse({ openApi: spec3, parserConfig }); 80 84 expect(spy).toHaveBeenCalledWith(spec3); 81 85 }); 82 86 83 87 it('throws on unknown version', () => { 84 88 // @ts-expect-error 85 85 - expect(() => parse({ config, openApi: { foo: 'bar' } })).toThrow( 89 89 + expect(() => parse({ openApi: { foo: 'bar' }, parserConfig })).toThrow( 86 90 `Unsupported OpenAPI specification: ${JSON.stringify({ foo: 'bar' }, null, 2)}`, 87 91 ); 88 92 });

-13

packages/openapi-ts/src/openApi/common/interfaces/config.ts

reviewed

··· 1 1 - import type { Operation, OperationParameter } from './client'; 2 2 - 3 3 - export interface Config { 4 4 - debug?: boolean; 5 5 - filterFn?: { 6 6 - operation?: (operationKey: string) => boolean; 7 7 - operationParameter?: (parameter: OperationParameter) => boolean; 8 8 - }; 9 9 - nameFn: { 10 10 - operation: (operation: Omit<Operation, 'name'>) => string; 11 11 - operationParameter: (parameter: Omit<OperationParameter, 'name'>) => string; 12 12 - }; 13 13 - }

+1 -1

packages/openapi-ts/src/openApi/common/parser/operation.ts

reviewed

··· 7 7 method: string; 8 8 path: string; 9 9 }) => { 10 10 - const operationKey = `${operation.method} ${operation.path}`; 10 10 + const operationKey = `${operation.method.toUpperCase()} ${operation.path}`; 11 11 return operationKey; 12 12 }; 13 13

+5 -22

packages/openapi-ts/src/openApi/common/parser/sanitize.ts

reviewed

··· 1 1 import { illegalStartCharactersRegExp } from '../../../utils/regexp'; 2 2 3 3 - /** 4 4 - * Sanitizes names of types, so they are valid TypeScript identifiers of a certain form. 5 5 - * 6 6 - * 1: Remove any leading characters that are illegal as starting character of a TypeScript identifier. 7 7 - * 2: Replace illegal characters in remaining part of type name with underscore (_). 8 8 - * 9 9 - * Step 1 should perhaps instead also replace illegal characters with underscore, or prefix with it, like sanitizeEnumName 10 10 - * does. The way this is now one could perhaps end up removing all characters, if all are illegal start characters. It 11 11 - * would be sort of a breaking change to do so, though, previously generated code might change then. 12 12 - * 13 13 - * JavaScript identifier regexp pattern retrieved from https://developer.mozilla.org/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers 14 14 - */ 15 15 - const replaceInvalidTypeScriptJavaScriptIdentifier = (name: string) => 16 16 - name 17 17 - .replace(illegalStartCharactersRegExp, '') 18 18 - .replace(/[^$\u200c\u200d\p{ID_Continue}]/gu, '_'); 19 19 - 20 3 export const ensureValidTypeScriptJavaScriptIdentifier = (name: string) => { 21 4 illegalStartCharactersRegExp.lastIndex = 0; 22 22 - const startsWithIllegalCharacter = illegalStartCharactersRegExp.test(name); 23 23 - // avoid removing all characters in case they're all illegal 24 24 - const input = startsWithIllegalCharacter ? `_${name}` : name; 25 25 - const cleaned = replaceInvalidTypeScriptJavaScriptIdentifier(input); 26 26 - return cleaned; 5 5 + const replaced = name.replace(/[^$\u200c\u200d\p{ID_Continue}]/gu, '_'); 6 6 + const startsWithIllegalCharacter = 7 7 + illegalStartCharactersRegExp.test(replaced); 8 8 + const valid = startsWithIllegalCharacter ? `_${replaced}` : replaced; 9 9 + return valid; 27 10 }; 28 11 29 12 /**

+98 -5

packages/openapi-ts/src/openApi/config.ts

reviewed

··· 1 1 - import type { Config } from './common/interfaces/config'; 1 1 + import type { Config } from '../types/config'; 2 2 + import { camelCase } from '../utils/camelCase'; 3 3 + import { getConfig, isLegacyClient } from '../utils/config'; 4 4 + import { transformTypeKeyName } from '../utils/type'; 5 5 + import type { OperationParameter } from './common/interfaces/client'; 6 6 + import { sanitizeNamespaceIdentifier } from './common/parser/sanitize'; 2 7 3 3 - let _config: Config; 8 8 + export interface ParserConfig { 9 9 + debug?: boolean; 10 10 + filterFn: { 11 11 + operation: typeof operationFilterFn; 12 12 + operationParameter: typeof operationParameterFilterFn; 13 13 + }; 14 14 + nameFn: { 15 15 + operation: typeof operationNameFn; 16 16 + operationParameter: typeof operationParameterNameFn; 17 17 + }; 18 18 + } 4 19 5 5 - export const getConfig = () => _config; 20 20 + let _config: ParserConfig; 6 21 7 7 - export const setConfig = (config: Config) => { 22 22 + export const getParserConfig = () => _config; 23 23 + 24 24 + export const setParserConfig = (config: ParserConfig) => { 8 25 _config = config; 9 9 - return getConfig(); 26 26 + return getParserConfig(); 27 27 + }; 28 28 + 29 29 + export const operationFilterFn = ({ 30 30 + config, 31 31 + operationKey, 32 32 + }: { 33 33 + config: Config; 34 34 + operationKey: string; 35 35 + }): boolean => { 36 36 + const regexp = config.services.filter 37 37 + ? new RegExp(config.services.filter) 38 38 + : undefined; 39 39 + return !regexp || regexp.test(operationKey); 40 40 + }; 41 41 + 42 42 + export const operationParameterFilterFn = ( 43 43 + parameter: OperationParameter, 44 44 + ): boolean => { 45 45 + const config = getConfig(); 46 46 + 47 47 + // legacy clients ignore the "api-version" param since we do not want to 48 48 + // add it as the first/default parameter for each of the service calls 49 49 + return !isLegacyClient(config) || parameter.prop !== 'api-version'; 50 50 + }; 51 51 + 52 52 + /** 53 53 + * Convert the input value to a correct operation (method) class name. 54 54 + * This will use the operation ID - if available - and otherwise fallback 55 55 + * on a generated name from the URL 56 56 + */ 57 57 + export const operationNameFn = ({ 58 58 + config, 59 59 + method, 60 60 + operationId, 61 61 + path, 62 62 + }: { 63 63 + config: Config; 64 64 + method: string; 65 65 + operationId: string | undefined; 66 66 + path: string; 67 67 + }): string => { 68 68 + if (config.services.operationId && operationId) { 69 69 + return camelCase({ 70 70 + input: sanitizeNamespaceIdentifier(operationId), 71 71 + }); 72 72 + } 73 73 + 74 74 + let urlWithoutPlaceholders = path; 75 75 + 76 76 + // legacy clients ignore the "api-version" param since we do not want to 77 77 + // add it as the first/default parameter for each of the service calls 78 78 + if (isLegacyClient(config)) { 79 79 + urlWithoutPlaceholders = urlWithoutPlaceholders.replace( 80 80 + /[^/]*?{api-version}.*?\//g, 81 81 + '', 82 82 + ); 83 83 + } 84 84 + 85 85 + urlWithoutPlaceholders = urlWithoutPlaceholders 86 86 + .replace(/{(.*?)}/g, 'by-$1') 87 87 + // replace slashes with hyphens for camelcase method at the end 88 88 + .replace(/[/:]/g, '-'); 89 89 + 90 90 + return camelCase({ 91 91 + input: `${method}-${urlWithoutPlaceholders}`, 92 92 + }); 93 93 + }; 94 94 + 95 95 + export const operationParameterNameFn = ( 96 96 + parameter: Omit<OperationParameter, 'name'>, 97 97 + ): string => { 98 98 + const config = getConfig(); 99 99 + 100 100 + return !isLegacyClient(config) 101 101 + ? parameter.prop 102 102 + : transformTypeKeyName(parameter.prop); 10 103 };

+35 -13

packages/openapi-ts/src/openApi/index.ts

reviewed

··· 1 1 + import { IRContext } from '../ir/context'; 2 2 + import type { Config } from '../types/config'; 1 3 import { type OpenApiV3_0_3, parseV3_0_3 } from './3.0.3'; 2 2 - import { type OpenApiV3_1, parseV3_1 } from './3.1'; 4 4 + import { type OpenApiV3_1_0, parseV3_1_0 } from './3.1.0'; 3 5 import type { Client } from './common/interfaces/client'; 4 4 - import type { Config } from './common/interfaces/config'; 5 6 import type { OpenApi } from './common/interfaces/OpenApi'; 6 6 - import { setConfig } from './config'; 7 7 + import type { ParserConfig } from './config'; 8 8 + import { setParserConfig } from './config'; 7 9 import { parse as parseV2 } from './v2'; 8 10 import { parse as parseV3 } from './v3'; 9 11 ··· 17 19 OperationParameter, 18 20 OperationResponse, 19 21 } from './common/interfaces/client'; 20 20 - export type { Config } from './common/interfaces/config'; 21 22 export type { OpenApi } from './common/interfaces/OpenApi'; 22 23 export { isOperationParameterRequired } from './common/parser/operation'; 23 24 export { ··· 36 37 */ 37 38 export function parse({ 38 39 openApi, 39 39 - config, 40 40 + parserConfig, 40 41 }: { 41 41 - config: Config; 42 42 openApi: OpenApi; 43 43 + parserConfig: ParserConfig; 43 44 }): Client { 44 44 - setConfig(config); 45 45 + setParserConfig(parserConfig); 45 46 46 47 if ('openapi' in openApi) { 47 48 return parseV3(openApi); ··· 56 57 ); 57 58 } 58 59 59 59 - export const parseExperimental = ({ spec }: { spec: unknown }) => { 60 60 - const s = spec as OpenApiV3_0_3 | OpenApiV3_1; 60 60 + // TODO: parser - add JSDoc comment 61 61 + export const parseExperimental = ({ 62 62 + config, 63 63 + parserConfig, 64 64 + spec, 65 65 + }: { 66 66 + config: Config; 67 67 + parserConfig: ParserConfig; 68 68 + spec: unknown; 69 69 + }) => { 70 70 + const context = new IRContext({ 71 71 + config, 72 72 + parserConfig, 73 73 + spec: spec as OpenApiV3_0_3 | OpenApiV3_1_0, 74 74 + }); 61 75 62 62 - switch (s.openapi) { 76 76 + switch (context.spec.openapi) { 63 77 case '3.0.3': 64 64 - return parseV3_0_3(s); 78 78 + parseV3_0_3(context as IRContext<OpenApiV3_0_3>); 79 79 + break; 65 80 case '3.1.0': 66 66 - return parseV3_1(s); 81 81 + parseV3_1_0(context as IRContext<OpenApiV3_1_0>); 82 82 + break; 67 83 default: 68 68 - throw new Error('Unsupported OpenAPI specification'); 84 84 + // TODO: parser - uncomment after removing legacy parser. 85 85 + // For now, we fall back to legacy parser if spec version 86 86 + // is not supported 87 87 + break; 88 88 + // throw new Error('Unsupported OpenAPI specification'); 69 89 } 90 90 + 91 91 + return context; 70 92 };

+2 -2

packages/openapi-ts/src/openApi/v2/parser/getOperationParameter.ts

reviewed

··· 5 5 import { getPattern } from '../../common/parser/getPattern'; 6 6 import { getRef } from '../../common/parser/getRef'; 7 7 import { getType } from '../../common/parser/type'; 8 8 - import { getConfig } from '../../config'; 8 8 + import { getParserConfig } from '../../config'; 9 9 import type { OpenApi } from '../interfaces/OpenApi'; 10 10 import type { OpenApiParameter } from '../interfaces/OpenApiParameter'; 11 11 import type { OpenApiSchema } from '../interfaces/OpenApiSchema'; ··· 20 20 parameter: OpenApiParameter; 21 21 types: Client['types']; 22 22 }): OperationParameter => { 23 23 - const config = getConfig(); 23 23 + const config = getParserConfig(); 24 24 25 25 const operationParameterWithoutName: Omit<OperationParameter, 'name'> = { 26 26 $refs: [],

+3 -5

packages/openapi-ts/src/openApi/v2/parser/getOperationParameters.ts

reviewed

··· 1 1 import type { Client } from '../../../types/client'; 2 2 import type { OperationParameters } from '../../common/interfaces/client'; 3 3 import { getRef } from '../../common/parser/getRef'; 4 4 - import { getConfig } from '../../config'; 4 4 + import { getParserConfig } from '../../config'; 5 5 import type { OpenApi } from '../interfaces/OpenApi'; 6 6 import type { OpenApiParameter } from '../interfaces/OpenApiParameter'; 7 7 import { getOperationParameter } from './getOperationParameter'; ··· 17 17 parameters: OpenApiParameter[]; 18 18 types: Client['types']; 19 19 }): OperationParameters => { 20 20 - const config = getConfig(); 20 20 + const config = getParserConfig(); 21 21 22 22 const operationParameters: OperationParameters = { 23 23 $refs: [], ··· 42 42 types, 43 43 }); 44 44 45 45 - const skip = 46 46 - config.filterFn?.operationParameter && 47 47 - !config.filterFn?.operationParameter(parameter); 45 45 + const skip = !config.filterFn.operationParameter(parameter); 48 46 if (!allowedIn.includes(parameterDef.in) || skip) { 49 47 return; 50 48 }

+10 -7

packages/openapi-ts/src/openApi/v2/parser/getOperations.ts

reviewed

··· 1 1 + import { getConfig } from '../../../utils/config'; 1 2 import type { Client, Operation } from '../../common/interfaces/client'; 2 3 import { getOperationKey } from '../../common/parser/operation'; 3 4 import { allowedServiceMethods } from '../../common/parser/service'; 4 4 - import { getConfig } from '../../config'; 5 5 + import { getParserConfig } from '../../config'; 5 6 import type { OpenApi } from '../interfaces/OpenApi'; 6 7 import { getOperationParameters } from './getOperationParameters'; 7 8 import { getOperation } from './operation'; ··· 13 14 openApi: OpenApi; 14 15 types: Client['types']; 15 16 }): Operation[] => { 16 16 - const config = getConfig(); 17 17 + const config = getParserConfig(); 17 18 18 19 const operationIds = new Map<string, string>(); 19 20 const operations: Operation[] = []; ··· 26 27 types, 27 28 }); 28 29 29 29 - for (const key in pathItem) { 30 30 - const method = key as Lowercase<Operation['method']>; 30 30 + for (const name in pathItem) { 31 31 + const method = name as Lowercase<Operation['method']>; 31 32 32 33 const operationKey = getOperationKey({ 33 33 - method: method.toUpperCase(), 34 34 + method, 34 35 path, 35 36 }); 36 37 ··· 48 49 } 49 50 50 51 if ( 51 51 - !config.filterFn?.operation || 52 52 - config.filterFn?.operation(operationKey) 52 52 + config.filterFn.operation({ 53 53 + config: getConfig(), 54 54 + operationKey, 55 55 + }) 53 56 ) { 54 57 const operation = getOperation({ 55 58 method,

+9 -3

packages/openapi-ts/src/openApi/v2/parser/operation.ts

reviewed

··· 1 1 import type { Client } from '../../../types/client'; 2 2 + import { getConfig } from '../../../utils/config'; 2 3 import type { 3 4 Operation, 4 5 OperationParameters, 5 6 } from '../../common/interfaces/client'; 6 7 import { getOperationResponseHeader } from '../../common/parser/operation'; 7 8 import { toSortedByRequired } from '../../common/parser/sort'; 8 8 - import { getConfig } from '../../config'; 9 9 + import { getParserConfig } from '../../config'; 9 10 import type { OpenApi } from '../interfaces/OpenApi'; 10 11 import type { OpenApiOperation } from '../interfaces/OpenApiOperation'; 11 12 import { getOperationParameters } from './getOperationParameters'; ··· 26 27 types: Client['types']; 27 28 url: string; 28 29 }): Operation => { 29 29 - const config = getConfig(); 30 30 + const config = getParserConfig(); 30 31 31 32 const operationWithoutName: Omit<Operation, 'name'> = { 32 33 $refs: [], ··· 50 51 }; 51 52 const operation = { 52 53 ...operationWithoutName, 53 53 - name: config.nameFn.operation(operationWithoutName), 54 54 + name: config.nameFn.operation({ 55 55 + config: getConfig(), 56 56 + method: operationWithoutName.method, 57 57 + operationId: op.operationId, 58 58 + path: operationWithoutName.path, 59 59 + }), 54 60 }; 55 61 56 62 if (op.parameters) {

+2 -2

packages/openapi-ts/src/openApi/v3/parser/discriminator.ts

reviewed

··· 6 6 7 7 const inverseDictionary = (map: Dictionary<string>): Dictionary<string> => { 8 8 const m2: Dictionary<string> = {}; 9 9 - for (const key in map) { 10 10 - m2[map[key]] = key; 9 9 + for (const name in map) { 10 10 + m2[map[name]] = name; 11 11 } 12 12 return m2; 13 13 };

+2 -2

packages/openapi-ts/src/openApi/v3/parser/getModels.ts

reviewed

··· 1 1 import type { Client } from '../../../types/client'; 2 2 import { getParametersMeta, getSchemasMeta } from '../../../utils/meta'; 3 3 - import { getConfig } from '../../config'; 3 3 + import { getParserConfig } from '../../config'; 4 4 import type { OpenApi } from '../interfaces/OpenApi'; 5 5 import { getModel } from './getModel'; 6 6 import { getParameterSchema } from './parameter'; ··· 8 8 export const getModels = ( 9 9 openApi: OpenApi, 10 10 ): Pick<Client, 'models' | 'types'> => { 11 11 - const config = getConfig(); 11 11 + const config = getParserConfig(); 12 12 13 13 const types: Client['types'] = {}; 14 14 let models: Client['models'] = [];

+2 -2

packages/openapi-ts/src/openApi/v3/parser/getOperationParameter.ts

reviewed

··· 6 6 import { getPattern } from '../../common/parser/getPattern'; 7 7 import { getRef } from '../../common/parser/getRef'; 8 8 import { getType } from '../../common/parser/type'; 9 9 - import { getConfig } from '../../config'; 9 9 + import { getParserConfig } from '../../config'; 10 10 import type { OpenApi } from '../interfaces/OpenApi'; 11 11 import type { OpenApiParameter } from '../interfaces/OpenApiParameter'; 12 12 import type { OpenApiSchema } from '../interfaces/OpenApiSchema'; ··· 23 23 parameter: OpenApiParameter; 24 24 types: Client['types']; 25 25 }): OperationParameter => { 26 26 - const config = getConfig(); 26 26 + const config = getParserConfig(); 27 27 28 28 const operationParameterWithoutName: Omit<OperationParameter, 'name'> = { 29 29 $refs: [],

+3 -5

packages/openapi-ts/src/openApi/v3/parser/getOperationParameters.ts

reviewed

··· 1 1 import type { Client } from '../../../types/client'; 2 2 import type { OperationParameters } from '../../common/interfaces/client'; 3 3 import { getRef } from '../../common/parser/getRef'; 4 4 - import { getConfig } from '../../config'; 4 4 + import { getParserConfig } from '../../config'; 5 5 import type { OpenApi } from '../interfaces/OpenApi'; 6 6 import type { OpenApiParameter } from '../interfaces/OpenApiParameter'; 7 7 import { getOperationParameter } from './getOperationParameter'; ··· 17 17 parameters: OpenApiParameter[]; 18 18 types: Client['types']; 19 19 }): OperationParameters => { 20 20 - const config = getConfig(); 20 20 + const config = getParserConfig(); 21 21 22 22 const operationParameters: OperationParameters = { 23 23 $refs: [], ··· 42 42 types, 43 43 }); 44 44 45 45 - const skip = 46 46 - config.filterFn?.operationParameter && 47 47 - !config.filterFn?.operationParameter(parameter); 45 45 + const skip = !config.filterFn.operationParameter(parameter); 48 46 if (!allowedIn.includes(parameterDef.in) || skip) { 49 47 return; 50 48 }

+10 -7

packages/openapi-ts/src/openApi/v3/parser/getOperations.ts

reviewed

··· 1 1 + import { getConfig } from '../../../utils/config'; 1 2 import type { Client, Operation } from '../../common/interfaces/client'; 2 3 import { getOperationKey } from '../../common/parser/operation'; 3 4 import { allowedServiceMethods } from '../../common/parser/service'; 4 4 - import { getConfig } from '../../config'; 5 5 + import { getParserConfig } from '../../config'; 5 6 import type { OpenApi } from '../interfaces/OpenApi'; 6 7 import { getOperationParameters } from './getOperationParameters'; 7 8 import { getOperation } from './operation'; ··· 13 14 openApi: OpenApi; 14 15 types: Client['types']; 15 16 }): Operation[] => { 16 16 - const config = getConfig(); 17 17 + const config = getParserConfig(); 17 18 18 19 const operationIds = new Map<string, string>(); 19 20 const operations: Operation[] = []; ··· 26 27 types, 27 28 }); 28 29 29 29 - for (const key in pathItem) { 30 30 - const method = key as Lowercase<Operation['method']>; 30 30 + for (const name in pathItem) { 31 31 + const method = name as Lowercase<Operation['method']>; 31 32 32 33 const operationKey = getOperationKey({ 33 33 - method: method.toUpperCase(), 34 34 + method, 34 35 path, 35 36 }); 36 37 ··· 48 49 } 49 50 50 51 if ( 51 51 - !config.filterFn?.operation || 52 52 - config.filterFn?.operation(operationKey) 52 52 + config.filterFn.operation({ 53 53 + config: getConfig(), 54 54 + operationKey, 55 55 + }) 53 56 ) { 54 57 const operation = getOperation({ 55 58 method,

+9 -3

packages/openapi-ts/src/openApi/v3/parser/operation.ts

reviewed

··· 1 1 import type { Client } from '../../../types/client'; 2 2 + import { getConfig } from '../../../utils/config'; 2 3 import type { 3 4 Operation, 4 5 OperationParameter, ··· 7 8 import { getRef } from '../../common/parser/getRef'; 8 9 import { getOperationResponseHeader } from '../../common/parser/operation'; 9 10 import { toSortedByRequired } from '../../common/parser/sort'; 10 10 - import { getConfig } from '../../config'; 11 11 + import { getParserConfig } from '../../config'; 11 12 import type { OpenApi } from '../interfaces/OpenApi'; 12 13 import type { OpenApiOperation } from '../interfaces/OpenApiOperation'; 13 14 import type { OpenApiRequestBody } from '../interfaces/OpenApiRequestBody'; ··· 53 54 types: Client['types']; 54 55 url: string; 55 56 }): Operation => { 56 56 - const config = getConfig(); 57 57 + const config = getParserConfig(); 57 58 58 59 const operationWithoutName: Omit<Operation, 'name'> = { 59 60 $refs: [], ··· 77 78 }; 78 79 const operation = { 79 80 ...operationWithoutName, 80 80 - name: config.nameFn.operation(operationWithoutName), 81 81 + name: config.nameFn.operation({ 82 82 + config: getConfig(), 83 83 + method: operationWithoutName.method, 84 84 + operationId: op.operationId, 85 85 + path: operationWithoutName.path, 86 86 + }), 81 87 }; 82 88 83 89 if (op.parameters) {

+1

packages/openapi-ts/src/plugins/@hey-api/schemas/config.ts

reviewed

··· 2 2 3 3 export const defaultConfig: Required<PluginConfig> = { 4 4 handler: () => {}, 5 5 + handler_experimental: () => {}, 5 6 name: '@hey-api/schemas', 6 7 output: 'schemas', 7 8 };

+2 -1

packages/openapi-ts/src/plugins/@hey-api/schemas/types.ts

reviewed

··· 1 1 - import type { PluginHandler } from '../../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 2 2 3 3 interface Config { 4 4 /** ··· 14 14 15 15 export interface PluginConfig extends Config { 16 16 handler: PluginHandler<Config>; 17 17 + handler_experimental?: PluginHandlerExperimental<Config>; 17 18 } 18 19 19 20 export interface UserConfig extends Omit<Config, 'output'> {}

+1

packages/openapi-ts/src/plugins/@hey-api/services/config.ts

reviewed

··· 2 2 3 3 export const defaultConfig: Required<PluginConfig> = { 4 4 handler: () => {}, 5 5 + handler_experimental: () => {}, 5 6 name: '@hey-api/services', 6 7 output: 'services', 7 8 };

+2 -1

packages/openapi-ts/src/plugins/@hey-api/services/types.ts

reviewed

··· 1 1 - import type { PluginHandler } from '../../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 2 2 3 3 interface Config { 4 4 /** ··· 14 14 15 15 export interface PluginConfig extends Config { 16 16 handler: PluginHandler<Config>; 17 17 + handler_experimental?: PluginHandlerExperimental<Config>; 17 18 } 18 19 19 20 export interface UserConfig extends Omit<Config, 'output'> {}

+1

packages/openapi-ts/src/plugins/@hey-api/types/config.ts

reviewed

··· 2 2 3 3 export const defaultConfig: Required<PluginConfig> = { 4 4 handler: () => {}, 5 5 + handler_experimental: () => {}, 5 6 name: '@hey-api/types', 6 7 output: 'types', 7 8 };

+2 -1

packages/openapi-ts/src/plugins/@hey-api/types/types.ts

reviewed

··· 1 1 - import type { PluginHandler } from '../../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 2 2 3 3 interface Config { 4 4 /** ··· 14 14 15 15 export interface PluginConfig extends Config { 16 16 handler: PluginHandler<Config>; 17 17 + handler_experimental?: PluginHandlerExperimental<Config>; 17 18 } 18 19 19 20 export interface UserConfig extends Omit<Config, 'output'> {}

+331 -23

packages/openapi-ts/src/plugins/@tanstack/query-core/plugin.ts

reviewed

··· 16 16 toOperationName, 17 17 } from '../../../generate/services'; 18 18 import { relativeModulePath } from '../../../generate/utils'; 19 19 + import type { IROperationObject, IRPathsObject } from '../../../ir/ir'; 20 20 + import { hasParametersObjectRequired } from '../../../ir/parameter'; 19 21 import { isOperationParameterRequired } from '../../../openApi'; 20 22 import { getOperationKey } from '../../../openApi/common/parser/operation'; 21 23 import type { ··· 25 27 Operation, 26 28 OperationParameter, 27 29 } from '../../../types/client'; 30 30 + import type { Config } from '../../../types/config'; 28 31 import type { Files } from '../../../types/utils'; 29 32 import { getConfig } from '../../../utils/config'; 33 33 + import { getServiceName } from '../../../utils/postprocess'; 30 34 import { transformServiceName } from '../../../utils/transform'; 31 31 - import type { PluginHandler } from '../../types'; 35 35 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 32 36 import type { PluginConfig as ReactQueryPluginConfig } from '../react-query'; 33 37 import type { PluginConfig as SolidQueryPluginConfig } from '../solid-query'; 34 38 import type { PluginConfig as SvelteQueryPluginConfig } from '../svelte-query'; 35 39 import type { PluginConfig as VueQueryPluginConfig } from '../vue-query'; 36 40 37 41 const toInfiniteQueryOptionsName = (operation: Operation) => 38 38 - `${toOperationName(operation, false)}InfiniteOptions`; 42 42 + `${toOperationName({ 43 43 + config: getConfig(), 44 44 + id: operation.name, 45 45 + operation, 46 46 + })}InfiniteOptions`; 39 47 40 48 const toMutationOptionsName = (operation: Operation) => 41 41 - `${toOperationName(operation, false)}Mutation`; 49 49 + `${toOperationName({ 50 50 + config: getConfig(), 51 51 + id: operation.name, 52 52 + operation, 53 53 + })}Mutation`; 42 54 43 43 - const toQueryOptionsName = (operation: Operation) => 44 44 - `${toOperationName(operation, false)}Options`; 55 55 + const toQueryOptionsName = ({ 56 56 + config, 57 57 + id, 58 58 + operation, 59 59 + }: { 60 60 + config: Config; 61 61 + id: string; 62 62 + operation: IROperationObject | Operation; 63 63 + }) => 64 64 + `${toOperationName({ 65 65 + config, 66 66 + id, 67 67 + operation, 68 68 + })}Options`; 45 69 46 46 - const toQueryKeyName = (operation: Operation, isInfinite?: boolean) => 47 47 - `${toOperationName(operation, false)}${isInfinite ? 'Infinite' : ''}QueryKey`; 70 70 + const toQueryKeyName = ({ 71 71 + config, 72 72 + id, 73 73 + operation, 74 74 + isInfinite, 75 75 + }: { 76 76 + config: Config; 77 77 + id: string; 78 78 + isInfinite?: boolean; 79 79 + operation: IROperationObject | Operation; 80 80 + }) => 81 81 + `${toOperationName({ 82 82 + config, 83 83 + id, 84 84 + operation, 85 85 + })}${isInfinite ? 'Infinite' : ''}QueryKey`; 48 86 49 87 const checkPrerequisites = ({ files }: { files: Files }) => { 50 88 if (!files.services) { ··· 473 511 compiler.typeReferenceNode({ 474 512 typeName: `Pick<${TOptionsType}, '${getClientBaseUrlKey()}' | 'body' | 'headers' | 'path' | 'query'>`, 475 513 }), 476 476 - compiler.typeInterfaceNode({ properties }), 514 514 + compiler.typeInterfaceNode({ 515 515 + properties, 516 516 + useLegacyResolution: true, 517 517 + }), 477 518 ], 478 519 }), 479 520 ], ··· 624 665 625 666 const createQueryKeyLiteral = ({ 626 667 isInfinite, 627 627 - operation, 668 668 + id, 628 669 }: { 670 670 + id: string; 629 671 isInfinite?: boolean; 630 630 - operation: Operation; 631 672 }) => { 632 673 const queryKeyLiteral = compiler.arrayLiteralExpression({ 633 674 elements: [ 634 675 compiler.callExpression({ 635 676 functionName: createQueryKeyFn, 636 677 parameters: [ 637 637 - compiler.stringLiteral({ text: operation.name }), 678 678 + compiler.ots.string(id), 638 679 'options', 639 680 isInfinite ? compiler.ots.boolean(true) : undefined, 640 681 ], ··· 692 733 processedOperations.set(operationKey, true); 693 734 694 735 const queryFn = [ 695 695 - config.services.asClass && transformServiceName(service.name), 696 696 - toOperationName(operation, !config.services.asClass), 736 736 + config.services.asClass && 737 737 + transformServiceName({ 738 738 + config, 739 739 + name: service.name, 740 740 + }), 741 741 + toOperationName({ 742 742 + config, 743 743 + handleIllegal: !config.services.asClass, 744 744 + id: operation.name, 745 745 + operation, 746 746 + }), 697 747 ] 698 748 .filter(Boolean) 699 749 .join('.'); ··· 741 791 }, 742 792 ], 743 793 statements: createQueryKeyLiteral({ 744 744 - operation, 794 794 + id: operation.name, 745 795 }), 746 796 }), 747 747 - name: toQueryKeyName(operation), 797 797 + name: toQueryKeyName({ 798 798 + config, 799 799 + id: operation.name, 800 800 + operation, 801 801 + }), 748 802 }); 749 803 file.add(queryKeyStatement); 750 804 ··· 811 865 { 812 866 key: 'queryKey', 813 867 value: compiler.callExpression({ 814 814 - functionName: toQueryKeyName(operation), 868 868 + functionName: toQueryKeyName({ 869 869 + config, 870 870 + id: operation.name, 871 871 + operation, 872 872 + }), 815 873 parameters: ['options'], 816 874 }), 817 875 }, ··· 827 885 comment: [], 828 886 exportConst: true, 829 887 expression, 830 830 - name: toQueryOptionsName(operation), 888 888 + name: toQueryOptionsName({ 889 889 + config, 890 890 + id: operation.name, 891 891 + operation, 892 892 + }), 831 893 // TODO: add type error 832 894 // TODO: AxiosError<PutSubmissionMetaError> 833 895 }); ··· 943 1005 ], 944 1006 returnType: typeQueryKey, 945 1007 statements: createQueryKeyLiteral({ 1008 1008 + id: operation.name, 946 1009 isInfinite: true, 947 947 - operation, 948 1010 }), 949 1011 }), 950 950 - name: toQueryKeyName(operation, true), 1012 1012 + name: toQueryKeyName({ 1013 1013 + config, 1014 1014 + id: operation.name, 1015 1015 + isInfinite: true, 1016 1016 + operation, 1017 1017 + }), 951 1018 }); 952 1019 file.add(queryKeyStatement); 953 1020 ··· 1001 1068 text: 'pageParam', 1002 1069 }), 1003 1070 operator: '===', 1004 1004 - right: compiler.stringLiteral({ 1005 1005 - text: 'object', 1006 1006 - }), 1071 1071 + right: compiler.ots.string('object'), 1007 1072 }), 1008 1073 whenFalse: compiler.objectExpression({ 1009 1074 multiLine: true, ··· 1073 1138 { 1074 1139 key: 'queryKey', 1075 1140 value: compiler.callExpression({ 1076 1076 - functionName: toQueryKeyName(operation, true), 1141 1141 + functionName: toQueryKeyName({ 1142 1142 + config, 1143 1143 + id: operation.name, 1144 1144 + isInfinite: true, 1145 1145 + operation, 1146 1146 + }), 1077 1147 parameters: ['options'], 1078 1148 }), 1079 1149 }, ··· 1239 1309 } 1240 1310 } 1241 1311 }; 1312 1312 + 1313 1313 + export const handler_experimental: PluginHandlerExperimental< 1314 1314 + | ReactQueryPluginConfig 1315 1315 + | SolidQueryPluginConfig 1316 1316 + | SvelteQueryPluginConfig 1317 1317 + | VueQueryPluginConfig 1318 1318 + > = ({ context, files, plugin }) => { 1319 1319 + checkPrerequisites({ files }); 1320 1320 + 1321 1321 + const file = files[plugin.name]; 1322 1322 + 1323 1323 + // file.import({ 1324 1324 + // asType: true, 1325 1325 + // module: clientModulePath({ sourceOutput: plugin.output }), 1326 1326 + // name: clientOptionsTypeName(), 1327 1327 + // }); 1328 1328 + 1329 1329 + // const typesModulePath = relativeModulePath({ 1330 1330 + // moduleOutput: files.types.getName(false), 1331 1331 + // sourceOutput: plugin.output, 1332 1332 + // }); 1333 1333 + 1334 1334 + // @ts-ignore 1335 1335 + // eslint-disable-next-line @typescript-eslint/no-unused-vars 1336 1336 + const mutationsType = 1337 1337 + plugin.name === '@tanstack/svelte-query' || 1338 1338 + plugin.name === '@tanstack/solid-query' 1339 1339 + ? 'MutationOptions' 1340 1340 + : 'UseMutationOptions'; 1341 1341 + 1342 1342 + // @ts-ignore 1343 1343 + // eslint-disable-next-line @typescript-eslint/no-unused-vars 1344 1344 + let typeInfiniteData!: ImportExportItem; 1345 1345 + // let hasCreateInfiniteParamsFunction = false; 1346 1346 + let hasCreateQueryKeyParamsFunction = false; 1347 1347 + // eslint-disable-next-line prefer-const 1348 1348 + let hasInfiniteQueries = false; 1349 1349 + // let hasMutations = false; 1350 1350 + let hasQueries = false; 1351 1351 + 1352 1352 + for (const path in context.ir.paths) { 1353 1353 + const pathItem = context.ir.paths[path as keyof IRPathsObject]; 1354 1354 + 1355 1355 + const queryOperations: ReadonlyArray<IROperationObject> = [ 1356 1356 + pathItem.get, 1357 1357 + pathItem.post, 1358 1358 + ].filter(Boolean) as ReadonlyArray<IROperationObject>; 1359 1359 + 1360 1360 + // console.warn(pathItem) 1361 1361 + let hasUsedQueryFn = false; 1362 1362 + 1363 1363 + // queries 1364 1364 + if (plugin.queryOptions) { 1365 1365 + for (const operation of queryOperations) { 1366 1366 + const queryFn = [ 1367 1367 + context.config.services.asClass && 1368 1368 + transformServiceName({ 1369 1369 + config: context.config, 1370 1370 + // TODO: parser - handle import from services, it will be enough to 1371 1371 + // know one service that contains this operation 1372 1372 + // name: service.name, 1373 1373 + name: getServiceName('TODO'), 1374 1374 + }), 1375 1375 + toOperationName({ 1376 1376 + config: context.config, 1377 1377 + handleIllegal: !context.config.services.asClass, 1378 1378 + id: operation.id, 1379 1379 + operation, 1380 1380 + }), 1381 1381 + ] 1382 1382 + .filter(Boolean) 1383 1383 + .join('.'); 1384 1384 + 1385 1385 + if (!hasQueries) { 1386 1386 + hasQueries = true; 1387 1387 + 1388 1388 + if (!hasCreateQueryKeyParamsFunction) { 1389 1389 + createQueryKeyType({ file }); 1390 1390 + createQueryKeyFunction({ file }); 1391 1391 + hasCreateQueryKeyParamsFunction = true; 1392 1392 + } 1393 1393 + 1394 1394 + file.import({ 1395 1395 + module: plugin.name, 1396 1396 + name: queryOptionsFn, 1397 1397 + }); 1398 1398 + } 1399 1399 + 1400 1400 + hasUsedQueryFn = true; 1401 1401 + 1402 1402 + // TODO: parser - update this after rewriting services 1403 1403 + const typeData = 'TODO'; 1404 1404 + // const { typeData } = createTypeData({ 1405 1405 + // client, 1406 1406 + // file, 1407 1407 + // operation, 1408 1408 + // typesModulePath, 1409 1409 + // }); 1410 1410 + 1411 1411 + const isRequired = hasParametersObjectRequired(operation.parameters); 1412 1412 + 1413 1413 + const queryKeyStatement = compiler.constVariable({ 1414 1414 + exportConst: true, 1415 1415 + expression: compiler.arrowFunction({ 1416 1416 + parameters: [ 1417 1417 + { 1418 1418 + isRequired, 1419 1419 + name: 'options', 1420 1420 + type: typeData, 1421 1421 + }, 1422 1422 + ], 1423 1423 + statements: createQueryKeyLiteral({ 1424 1424 + id: operation.id, 1425 1425 + }), 1426 1426 + }), 1427 1427 + name: toQueryKeyName({ 1428 1428 + config: context.config, 1429 1429 + id: operation.id, 1430 1430 + operation, 1431 1431 + }), 1432 1432 + }); 1433 1433 + file.add(queryKeyStatement); 1434 1434 + 1435 1435 + const expression = compiler.arrowFunction({ 1436 1436 + parameters: [ 1437 1437 + { 1438 1438 + isRequired, 1439 1439 + name: 'options', 1440 1440 + type: typeData, 1441 1441 + }, 1442 1442 + ], 1443 1443 + statements: [ 1444 1444 + compiler.returnFunctionCall({ 1445 1445 + args: [ 1446 1446 + compiler.objectExpression({ 1447 1447 + obj: [ 1448 1448 + { 1449 1449 + key: 'queryFn', 1450 1450 + value: compiler.arrowFunction({ 1451 1451 + async: true, 1452 1452 + multiLine: true, 1453 1453 + parameters: [ 1454 1454 + { 1455 1455 + destructure: [ 1456 1456 + { 1457 1457 + name: 'queryKey', 1458 1458 + }, 1459 1459 + ], 1460 1460 + }, 1461 1461 + ], 1462 1462 + statements: [ 1463 1463 + compiler.constVariable({ 1464 1464 + destructure: true, 1465 1465 + expression: compiler.awaitExpression({ 1466 1466 + expression: compiler.callExpression({ 1467 1467 + functionName: queryFn, 1468 1468 + parameters: [ 1469 1469 + compiler.objectExpression({ 1470 1470 + multiLine: true, 1471 1471 + obj: [ 1472 1472 + { 1473 1473 + spread: 'options', 1474 1474 + }, 1475 1475 + { 1476 1476 + spread: 'queryKey[0]', 1477 1477 + }, 1478 1478 + { 1479 1479 + key: 'throwOnError', 1480 1480 + value: true, 1481 1481 + }, 1482 1482 + ], 1483 1483 + }), 1484 1484 + ], 1485 1485 + }), 1486 1486 + }), 1487 1487 + name: 'data', 1488 1488 + }), 1489 1489 + compiler.returnVariable({ 1490 1490 + expression: 'data', 1491 1491 + }), 1492 1492 + ], 1493 1493 + }), 1494 1494 + }, 1495 1495 + { 1496 1496 + key: 'queryKey', 1497 1497 + value: compiler.callExpression({ 1498 1498 + functionName: toQueryKeyName({ 1499 1499 + config: context.config, 1500 1500 + id: operation.id, 1501 1501 + operation, 1502 1502 + }), 1503 1503 + parameters: ['options'], 1504 1504 + }), 1505 1505 + }, 1506 1506 + ], 1507 1507 + }), 1508 1508 + ], 1509 1509 + name: queryOptionsFn, 1510 1510 + }), 1511 1511 + ], 1512 1512 + }); 1513 1513 + const statement = compiler.constVariable({ 1514 1514 + // TODO: describe options, same as the actual function call 1515 1515 + comment: [], 1516 1516 + exportConst: true, 1517 1517 + expression, 1518 1518 + name: toQueryOptionsName({ 1519 1519 + config: context.config, 1520 1520 + id: operation.id, 1521 1521 + operation, 1522 1522 + }), 1523 1523 + // TODO: add type error 1524 1524 + // TODO: AxiosError<PutSubmissionMetaError> 1525 1525 + }); 1526 1526 + file.add(statement); 1527 1527 + } 1528 1528 + } 1529 1529 + 1530 1530 + // const servicesModulePath = relativeModulePath({ 1531 1531 + // moduleOutput: files.services.getName(false), 1532 1532 + // sourceOutput: plugin.output, 1533 1533 + // }); 1534 1534 + 1535 1535 + if (hasQueries || hasInfiniteQueries) { 1536 1536 + // file.import({ 1537 1537 + // module: servicesModulePath, 1538 1538 + // name: 'client', 1539 1539 + // }); 1540 1540 + } 1541 1541 + 1542 1542 + if (hasUsedQueryFn) { 1543 1543 + // file.import({ 1544 1544 + // module: servicesModulePath, 1545 1545 + // name: queryFn.split('.')[0], 1546 1546 + // }); 1547 1547 + } 1548 1548 + } 1549 1549 + };

+2 -1

packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts

reviewed

··· 1 1 - import { handler } from '../query-core/plugin'; 1 1 + import { handler, handler_experimental } from '../query-core/plugin'; 2 2 import type { PluginConfig } from './types'; 3 3 4 4 export const defaultConfig: Required<PluginConfig> = { 5 5 handler, 6 6 + handler_experimental, 6 7 infiniteQueryOptions: true, 7 8 mutationOptions: true, 8 9 name: '@tanstack/react-query',

+2 -1

packages/openapi-ts/src/plugins/@tanstack/react-query/types.ts

reviewed

··· 1 1 - import type { PluginHandler } from '../../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 2 2 3 3 interface Config { 4 4 /** ··· 30 30 31 31 export interface PluginConfig extends Config { 32 32 handler: PluginHandler<Config>; 33 33 + handler_experimental?: PluginHandlerExperimental<Config>; 33 34 } 34 35 35 36 export interface UserConfig extends Omit<Config, 'output'> {}

+2 -1

packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts

reviewed

··· 1 1 - import { handler } from '../query-core/plugin'; 1 1 + import { handler, handler_experimental } from '../query-core/plugin'; 2 2 import type { PluginConfig } from './types'; 3 3 4 4 export const defaultConfig: Required<PluginConfig> = { 5 5 handler, 6 6 + handler_experimental, 6 7 infiniteQueryOptions: true, 7 8 mutationOptions: true, 8 9 name: '@tanstack/solid-query',

+2 -1

packages/openapi-ts/src/plugins/@tanstack/solid-query/types.ts

reviewed

··· 1 1 - import type { PluginHandler } from '../../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 2 2 3 3 interface Config { 4 4 /** ··· 30 30 31 31 export interface PluginConfig extends Config { 32 32 handler: PluginHandler<Config>; 33 33 + handler_experimental?: PluginHandlerExperimental<Config>; 33 34 } 34 35 35 36 export interface UserConfig extends Omit<Config, 'output'> {}

+2 -1

packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts

reviewed

··· 1 1 - import { handler } from '../query-core/plugin'; 1 1 + import { handler, handler_experimental } from '../query-core/plugin'; 2 2 import type { PluginConfig } from './types'; 3 3 4 4 export const defaultConfig: Required<PluginConfig> = { 5 5 handler, 6 6 + handler_experimental, 6 7 infiniteQueryOptions: true, 7 8 mutationOptions: true, 8 9 name: '@tanstack/svelte-query',

+2 -1

packages/openapi-ts/src/plugins/@tanstack/svelte-query/types.ts

reviewed

··· 1 1 - import type { PluginHandler } from '../../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 2 2 3 3 interface Config { 4 4 /** ··· 30 30 31 31 export interface PluginConfig extends Config { 32 32 handler: PluginHandler<Config>; 33 33 + handler_experimental?: PluginHandlerExperimental<Config>; 33 34 } 34 35 35 36 export interface UserConfig extends Omit<Config, 'output'> {}

+2 -1

packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts

reviewed

··· 1 1 - import { handler } from '../query-core/plugin'; 1 1 + import { handler, handler_experimental } from '../query-core/plugin'; 2 2 import type { PluginConfig } from './types'; 3 3 4 4 export const defaultConfig: Required<PluginConfig> = { 5 5 handler, 6 6 + handler_experimental, 6 7 infiniteQueryOptions: true, 7 8 mutationOptions: true, 8 9 name: '@tanstack/vue-query',

+2 -1

packages/openapi-ts/src/plugins/@tanstack/vue-query/types.ts

reviewed

··· 1 1 - import type { PluginHandler } from '../../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../../types'; 2 2 3 3 interface Config { 4 4 /** ··· 30 30 31 31 export interface PluginConfig extends Config { 32 32 handler: PluginHandler<Config>; 33 33 + handler_experimental?: PluginHandlerExperimental<Config>; 33 34 } 34 35 35 36 export interface UserConfig extends Omit<Config, 'output'> {}

+11 -1

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

reviewed

··· 1 1 + import type { IRContext } from '../ir/context'; 1 2 import type { Client } from '../types/client'; 2 3 import type { Files } from '../types/utils'; 3 4 4 5 export type PluginHandler<PluginConfig> = (args: { 5 6 client: Client; 6 7 files: Files; 7 7 - plugin: Omit<Required<PluginConfig>, 'handler'>; 8 8 + plugin: Omit<Required<PluginConfig>, 'handler' | 'handler_experimental'>; 9 9 + }) => void; 10 10 + 11 11 + export type PluginHandlerExperimental<PluginConfig> = (args: { 12 12 + context: IRContext; 13 13 + files: Files; 14 14 + plugin: Omit<Required<PluginConfig>, 'handler' | 'handler_experimental'>; 8 15 }) => void; 9 16 10 17 type KeyTypes = string | number | symbol; ··· 21 28 > = { 22 29 [K in U]: { 23 30 handler: PluginHandler<Required<Extract<T, { name: K }>>>; 31 31 + handler_experimental?: PluginHandlerExperimental< 32 32 + Required<Extract<T, { name: K }>> 33 33 + >; 24 34 name: string; 25 35 output?: string; 26 36 };

+1

packages/openapi-ts/src/plugins/zod/config.ts

reviewed

··· 3 3 4 4 export const defaultConfig: Required<PluginConfig> = { 5 5 handler, 6 6 + handler_experimental: () => {}, 6 7 name: 'zod', 7 8 output: 'zod', 8 9 };

+207 -2

packages/openapi-ts/src/plugins/zod/plugin.ts

reviewed

··· 1 1 + import { compiler } from '../../compiler'; 2 2 + import type { TypeScriptFile } from '../../generate/files'; 3 3 + import type { Client, Model } from '../../types/client'; 1 4 import type { PluginHandler } from '../types'; 2 5 import type { PluginConfig } from './types'; 3 6 4 4 - export const handler: PluginHandler<PluginConfig> = ({ plugin }) => { 5 5 - console.warn(plugin); 7 7 + interface TypesProps { 8 8 + client: Client; 9 9 + file: TypeScriptFile; 10 10 + model: Model; 11 11 + onRemoveNode?: VoidFunction; 12 12 + } 13 13 + 14 14 + const processArray = ({ file, model }: TypesProps) => { 15 15 + const identifier = file.identifier({ 16 16 + $ref: model.meta?.$ref || '', 17 17 + create: true, 18 18 + namespace: 'value', 19 19 + }); 20 20 + 21 21 + if (!identifier.created) { 22 22 + return; 23 23 + } 24 24 + 25 25 + const zArrayExpression = compiler.callExpression({ 26 26 + functionName: compiler.propertyAccessExpression({ 27 27 + expression: 'z', 28 28 + name: 'array', 29 29 + }), 30 30 + parameters: [ 31 31 + compiler.callExpression({ 32 32 + functionName: compiler.propertyAccessExpression({ 33 33 + expression: 'z', 34 34 + name: model.base, 35 35 + }), 36 36 + }), 37 37 + ], 38 38 + }); 39 39 + 40 40 + if (model.base === 'string' || model.base === 'boolean') { 41 41 + const statement = compiler.constVariable({ 42 42 + exportConst: true, 43 43 + expression: zArrayExpression, 44 44 + name: identifier.name, 45 45 + }); 46 46 + file.add(statement); 47 47 + return; 48 48 + } 49 49 + 50 50 + if (model.base === 'number') { 51 51 + let expression = zArrayExpression; 52 52 + 53 53 + if (model.minItems && model.maxItems && model.minItems === model.maxItems) { 54 54 + expression = compiler.callExpression({ 55 55 + functionName: compiler.propertyAccessExpression({ 56 56 + expression, 57 57 + name: 'length', 58 58 + }), 59 59 + parameters: [compiler.ots.number(model.minItems)], 60 60 + }); 61 61 + } else { 62 62 + if (model.minItems) { 63 63 + expression = compiler.callExpression({ 64 64 + functionName: compiler.propertyAccessExpression({ 65 65 + expression, 66 66 + name: 'min', 67 67 + }), 68 68 + parameters: [compiler.ots.number(model.minItems)], 69 69 + }); 70 70 + } 71 71 + 72 72 + if (model.maxItems) { 73 73 + expression = compiler.callExpression({ 74 74 + functionName: compiler.propertyAccessExpression({ 75 75 + expression, 76 76 + name: 'max', 77 77 + }), 78 78 + parameters: [compiler.ots.number(model.maxItems)], 79 79 + }); 80 80 + } 81 81 + } 82 82 + 83 83 + const statement = compiler.constVariable({ 84 84 + exportConst: true, 85 85 + expression, 86 86 + name: identifier.name, 87 87 + }); 88 88 + file.add(statement); 89 89 + return; 90 90 + } 91 91 + 92 92 + // console.warn('array!', model.base, model.name) 93 93 + const statement = compiler.constVariable({ 94 94 + exportConst: true, 95 95 + expression: compiler.callExpression({ 96 96 + functionName: compiler.propertyAccessExpression({ 97 97 + expression: 'z', 98 98 + name: 'object', 99 99 + }), 100 100 + parameters: [ 101 101 + compiler.objectExpression({ 102 102 + multiLine: true, 103 103 + obj: [], 104 104 + }), 105 105 + ], 106 106 + }), 107 107 + name: identifier.name, 108 108 + }); 109 109 + file.add(statement); 110 110 + }; 111 111 + 112 112 + const processGeneric = ({ file, model }: TypesProps) => { 113 113 + const identifier = file.identifier({ 114 114 + $ref: model.meta?.$ref || '', 115 115 + create: true, 116 116 + namespace: 'value', 117 117 + }); 118 118 + 119 119 + if (!identifier.created) { 120 120 + return; 121 121 + } 122 122 + 123 123 + if (model.base === 'string') { 124 124 + const statement = compiler.constVariable({ 125 125 + exportConst: true, 126 126 + expression: compiler.callExpression({ 127 127 + functionName: compiler.propertyAccessExpression({ 128 128 + expression: 'z', 129 129 + name: 'string', 130 130 + }), 131 131 + }), 132 132 + name: identifier.name, 133 133 + }); 134 134 + file.add(statement); 135 135 + return; 136 136 + } 137 137 + 138 138 + if (model.base === 'boolean') { 139 139 + // console.warn(model) 140 140 + const statement = compiler.constVariable({ 141 141 + exportConst: true, 142 142 + expression: compiler.callExpression({ 143 143 + functionName: compiler.propertyAccessExpression({ 144 144 + expression: 'z', 145 145 + name: 'boolean', 146 146 + }), 147 147 + }), 148 148 + name: identifier.name, 149 149 + }); 150 150 + file.add(statement); 151 151 + return; 152 152 + } 153 153 + 154 154 + // console.warn(model.base) 155 155 + const statement = compiler.constVariable({ 156 156 + exportConst: true, 157 157 + expression: compiler.callExpression({ 158 158 + functionName: compiler.propertyAccessExpression({ 159 159 + expression: 'z', 160 160 + name: 'object', 161 161 + }), 162 162 + parameters: [ 163 163 + compiler.objectExpression({ 164 164 + multiLine: true, 165 165 + obj: [], 166 166 + }), 167 167 + ], 168 168 + }), 169 169 + name: identifier.name, 170 170 + }); 171 171 + file.add(statement); 172 172 + }; 173 173 + 174 174 + const processModel = (props: TypesProps) => { 175 175 + switch (props.model.export) { 176 176 + case 'all-of': 177 177 + case 'any-of': 178 178 + case 'one-of': 179 179 + case 'interface': 180 180 + // return processComposition(props); 181 181 + return; 182 182 + case 'array': 183 183 + return processArray(props); 184 184 + case 'enum': 185 185 + // return processEnum(props); 186 186 + return; 187 187 + default: 188 188 + return processGeneric(props); 189 189 + } 190 190 + }; 191 191 + 192 192 + export const handler: PluginHandler<PluginConfig> = ({ 193 193 + client, 194 194 + files, 195 195 + plugin, 196 196 + }) => { 197 197 + const file = files[plugin.name]; 198 198 + 199 199 + file.import({ 200 200 + module: 'zod', 201 201 + name: 'z', 202 202 + }); 203 203 + 204 204 + for (const model of client.models) { 205 205 + processModel({ 206 206 + client, 207 207 + file, 208 208 + model, 209 209 + }); 210 210 + } 6 211 };

+2 -1

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

reviewed

··· 1 1 - import type { PluginHandler } from '../types'; 1 1 + import type { PluginHandler, PluginHandlerExperimental } from '../types'; 2 2 3 3 interface Config { 4 4 /** ··· 14 14 15 15 export interface PluginConfig extends Config { 16 16 handler: PluginHandler<Config>; 17 17 + handler_experimental?: PluginHandlerExperimental<Config>; 17 18 } 18 19 19 20 export interface UserConfig extends Omit<Config, 'output'> {}

+6 -2

packages/openapi-ts/src/types/config.ts

reviewed

··· 1 1 + import type { IROperationObject } from '../ir/ir'; 1 2 import type { OpenApiV2Schema, OpenApiV3Schema } from '../openApi'; 2 3 import type { ClientPlugins, UserPlugins } from '../plugins/'; 3 4 import type { Operation } from '../types/client'; ··· 175 176 */ 176 177 include?: string; 177 178 /** 178 178 - * Customise the name of methods within the service. By default, {@link Operation.name} is used. 179 179 + * Customise the name of methods within the service. By default, {@link IROperationObject.id} or {@link Operation.name} is used. 179 180 */ 180 180 - methodNameBuilder?: (operation: Operation) => string; 181 181 + methodNameBuilder?: ( 182 182 + operation: IROperationObject | Operation, 183 183 + ) => string; 181 184 /** 182 185 * Customize the generated service class names. The name variable is 183 186 * obtained from your OpenAPI specification tags. ··· 186 189 * @default '{{name}}Service' 187 190 */ 188 191 name?: string; 192 192 + // TODO: parser - rename operationId option to something like inferId?: boolean 189 193 /** 190 194 * Use operation ID to generate operation names? 191 195 * @default true

+1 -1

packages/openapi-ts/src/types/utils.ts

reviewed

··· 1 1 - import type { TypeScriptFile } from '../compiler'; 1 1 + import type { TypeScriptFile } from '../generate/files'; 2 2 3 3 type ExtractFromArray<T, Discriminator> = T extends Discriminator 4 4 ? Required<T>

+7 -3

packages/openapi-ts/src/utils/__tests__/parse.spec.ts

reviewed

··· 1 1 import { describe, expect, it } from 'vitest'; 2 2 3 3 - import type { Operation } from '../../openApi'; 3 3 + import { operationNameFn } from '../../openApi/config'; 4 4 import { setConfig } from '../config'; 5 5 - import { operationNameFn } from '../parse'; 6 5 7 6 describe('operationNameFn', () => { 8 7 const optionsCommon: Parameters<typeof setConfig>[0] = { ··· 277 276 ({ url, method, options, operationId, expected }) => { 278 277 setConfig(options); 279 278 expect( 280 280 - operationNameFn({ id: operationId, method, path: url } as Operation), 279 279 + operationNameFn({ 280 280 + config: options, 281 281 + method, 282 282 + operationId, 283 283 + path: url, 284 284 + }), 281 285 ).toBe(expected); 282 286 }, 283 287 );

+9 -4

packages/openapi-ts/src/utils/__tests__/postprocess.spec.ts

reviewed

··· 1 1 import { describe, expect, it } from 'vitest'; 2 2 3 3 - import { type Config, parse } from '../../openApi'; 3 3 + import { parse } from '../../openApi'; 4 4 + import type { ParserConfig } from '../../openApi/config'; 4 5 import { getServiceName, postProcessClient } from '../postprocess'; 5 6 6 6 - const config: Config = { 7 7 + const parserConfig: ParserConfig = { 8 8 + filterFn: { 9 9 + operation: () => true, 10 10 + operationParameter: () => true, 11 11 + }, 7 12 nameFn: { 8 13 operation: () => 'operation', 9 14 operationParameter: () => 'operationParameter', ··· 31 36 describe('getServices', () => { 32 37 it('should create a unnamed service if tags are empty', () => { 33 38 const parserClient = parse({ 34 34 - config, 35 39 openApi: { 36 40 info: { 37 41 title: 'x', ··· 54 58 }, 55 59 }, 56 60 }, 61 61 + parserConfig, 57 62 }); 58 63 const { services } = postProcessClient(parserClient); 59 64 ··· 65 70 describe('getServices', () => { 66 71 it('should create a unnamed service if tags are empty', () => { 67 72 const parserClient = parse({ 68 68 - config, 69 73 openApi: { 70 74 info: { 71 75 title: 'x', ··· 88 92 }, 89 93 }, 90 94 }, 95 95 + parserConfig, 91 96 }); 92 97 const { services } = postProcessClient(parserClient); 93 98

+10 -1

packages/openapi-ts/src/utils/handlebars.ts

reviewed

··· 89 89 // @ts-ignore 90 90 import xhrSendRequest from '../legacy/handlebars/compiled/core/xhr/sendRequest.js'; 91 91 import { camelCase } from './camelCase'; 92 92 + import { getConfig } from './config'; 92 93 import { transformServiceName } from './transform'; 93 94 94 95 export const registerHandlebarHelpers = (): void => { ··· 133 134 }, 134 135 ); 135 136 136 136 - Handlebars.registerHelper('transformServiceName', transformServiceName); 137 137 + Handlebars.registerHelper( 138 138 + 'transformServiceName', 139 139 + function (this: unknown, name: string) { 140 140 + return transformServiceName({ 141 141 + config: getConfig(), 142 142 + name, 143 143 + }); 144 144 + }, 145 145 + ); 137 146 }; 138 147 139 148 export interface Templates {

-68

packages/openapi-ts/src/utils/parse.ts

reviewed

··· 1 1 - import type { Operation, OperationParameter } from '../openApi'; 2 2 - import { sanitizeNamespaceIdentifier } from '../openApi'; 3 3 - import { camelCase } from './camelCase'; 4 4 - import { getConfig, isLegacyClient } from './config'; 5 5 - import { transformTypeKeyName } from './type'; 6 6 - 7 7 - export const operationFilterFn = (operationKey: string): boolean => { 8 8 - const config = getConfig(); 9 9 - const regexp = config.services.filter 10 10 - ? new RegExp(config.services.filter) 11 11 - : undefined; 12 12 - return !regexp || regexp.test(operationKey); 13 13 - }; 14 14 - 15 15 - export const operationParameterFilterFn = ( 16 16 - parameter: OperationParameter, 17 17 - ): boolean => { 18 18 - const config = getConfig(); 19 19 - 20 20 - // legacy clients ignore the "api-version" param since we do not want to 21 21 - // add it as the first/default parameter for each of the service calls 22 22 - return !isLegacyClient(config) || parameter.prop !== 'api-version'; 23 23 - }; 24 24 - 25 25 - /** 26 26 - * Convert the input value to a correct operation (method) class name. 27 27 - * This will use the operation ID - if available - and otherwise fallback 28 28 - * on a generated name from the URL 29 29 - */ 30 30 - export const operationNameFn = (operation: Omit<Operation, 'name'>): string => { 31 31 - const config = getConfig(); 32 32 - 33 33 - if (config.services.operationId && operation.id) { 34 34 - return camelCase({ 35 35 - input: sanitizeNamespaceIdentifier(operation.id), 36 36 - }); 37 37 - } 38 38 - 39 39 - let urlWithoutPlaceholders = operation.path; 40 40 - 41 41 - // legacy clients ignore the "api-version" param since we do not want to 42 42 - // add it as the first/default parameter for each of the service calls 43 43 - if (isLegacyClient(config)) { 44 44 - urlWithoutPlaceholders = urlWithoutPlaceholders.replace( 45 45 - /[^/]*?{api-version}.*?\//g, 46 46 - '', 47 47 - ); 48 48 - } 49 49 - 50 50 - urlWithoutPlaceholders = urlWithoutPlaceholders 51 51 - .replace(/{(.*?)}/g, 'by-$1') 52 52 - // replace slashes with hyphens for camelcase method at the end 53 53 - .replace(/[/:]/g, '-'); 54 54 - 55 55 - return camelCase({ 56 56 - input: `${operation.method}-${urlWithoutPlaceholders}`, 57 57 - }); 58 58 - }; 59 59 - 60 60 - export const operationParameterNameFn = ( 61 61 - parameter: Omit<OperationParameter, 'name'>, 62 62 - ): string => { 63 63 - const config = getConfig(); 64 64 - 65 65 - return !isLegacyClient(config) 66 66 - ? parameter.prop 67 67 - : transformTypeKeyName(parameter.prop); 68 68 - };

+35

packages/openapi-ts/src/utils/ref.ts

reviewed

··· 1 1 + export const irRef = '#/ir/'; 2 2 + 3 3 + export const isRefOpenApiComponent = ($ref: string): boolean => { 4 4 + const parts = refToParts($ref); 5 5 + // reusable components are nested within components/<namespace>/<name> 6 6 + return parts.length === 3 && parts[0] === 'components'; 7 7 + }; 8 8 + 9 9 + const refToParts = ($ref: string): string[] => { 10 10 + // Remove the leading `#` and split by `/` to traverse the object 11 11 + const parts = $ref.replace(/^#\//, '').split('/'); 12 12 + return parts; 13 13 + }; 14 14 + 15 15 + export const resolveRef = <T>({ 16 16 + $ref, 17 17 + spec, 18 18 + }: { 19 19 + $ref: string; 20 20 + spec: Record<string, any>; 21 21 + }): T => { 22 22 + const parts = refToParts($ref); 23 23 + 24 24 + let current = spec; 25 25 + 26 26 + for (const part of parts) { 27 27 + const p = part as keyof typeof current; 28 28 + if (current[p] === undefined) { 29 29 + throw new Error(`Reference not found: ${$ref}`); 30 30 + } 31 31 + current = current[p]; 32 32 + } 33 33 + 34 34 + return current as T; 35 35 + };

+9 -2

packages/openapi-ts/src/utils/transform.ts

reviewed

··· 1 1 import { ensureValidTypeScriptJavaScriptIdentifier } from '../openApi'; 2 2 + import type { Config } from '../types/config'; 2 3 import { camelCase } from './camelCase'; 3 4 import { getConfig } from './config'; 4 5 import { reservedWordsRegExp } from './regexp'; 5 6 6 6 - export const transformServiceName = (name: string) => { 7 7 - const config = getConfig(); 7 7 + export const transformServiceName = ({ 8 8 + config, 9 9 + name, 10 10 + }: { 11 11 + config: Config; 12 12 + name: string; 13 13 + }) => { 8 14 if (config.services.name) { 9 15 return config.services.name.replace('{{name}}', name); 10 16 } 17 17 + 11 18 return name; 12 19 }; 13 20

+2 -1

packages/openapi-ts/src/utils/type.ts

reviewed

··· 98 98 const typeDict = (model: Model) => { 99 99 const type = 100 100 model.link && !Array.isArray(model.link) ? toType(model.link) : base(model); 101 101 - return compiler.typeRecordNode(['string'], [type], model.isNullable); 101 101 + return compiler.typeRecordNode(['string'], [type], model.isNullable, true); 102 102 }; 103 103 104 104 const typeUnionOrIntersection = ({ ··· 187 187 return compiler.typeInterfaceNode({ 188 188 isNullable: model.isNullable, 189 189 properties, 190 190 + useLegacyResolution: !config.experimental_parser, 190 191 }); 191 192 }; 192 193

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 36 36 - createQueryKey("collectionFormat", options) 36 36 + createQueryKey('collectionFormat', options) 37 37 ]; 38 38 39 39 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 52 52 - createQueryKey("complexTypes", options) 52 52 + createQueryKey('complexTypes', options) 53 53 ]; 54 54 55 55 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const exportQueryKey = (options?: Options) => [ 79 79 - createQueryKey("export", options) 79 79 + createQueryKey('export', options) 80 80 ]; 81 81 82 82 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const importQueryKey = (options: Options<ImportData>) => [ 95 95 - createQueryKey("import", options) 95 95 + createQueryKey('import', options) 96 96 ]; 97 97 98 98 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 119 119 }; return mutationOptions; }; 120 120 121 121 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 122 122 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 122 122 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 123 123 ]; 124 124 125 125 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 135 135 }); }; 136 136 137 137 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 138 138 - createQueryKey("callWithDefaultParameters", options) 138 138 + createQueryKey('callWithDefaultParameters', options) 139 139 ]; 140 140 141 141 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 151 151 }); }; 152 152 153 153 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 154 154 - createQueryKey("callWithDefaultOptionalParameters", options) 154 154 + createQueryKey('callWithDefaultOptionalParameters', options) 155 155 ]; 156 156 157 157 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 189 189 }; return mutationOptions; }; 190 190 191 191 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 192 192 - createQueryKey("deprecatedCall", options) 192 192 + createQueryKey('deprecatedCall', options) 193 193 ]; 194 194 195 195 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 216 216 }; return mutationOptions; }; 217 217 218 218 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 219 219 - createQueryKey("callWithDescriptions", options) 219 219 + createQueryKey('callWithDescriptions', options) 220 220 ]; 221 221 222 222 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 243 243 }; return mutationOptions; }; 244 244 245 245 export const duplicateNameQueryKey = (options?: Options) => [ 246 246 - createQueryKey("duplicateName", options) 246 246 + createQueryKey('duplicateName', options) 247 247 ]; 248 248 249 249 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 259 259 }); }; 260 260 261 261 export const duplicateName1QueryKey = (options?: Options) => [ 262 262 - createQueryKey("duplicateName1", options) 262 262 + createQueryKey('duplicateName1', options) 263 263 ]; 264 264 265 265 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 308 308 }; return mutationOptions; }; 309 309 310 310 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 311 311 - createQueryKey("testErrorCode", options) 311 311 + createQueryKey('testErrorCode', options) 312 312 ]; 313 313 314 314 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 335 335 }; return mutationOptions; }; 336 336 337 337 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 338 338 - createQueryKey("fileResponse", options) 338 338 + createQueryKey('fileResponse', options) 339 339 ]; 340 340 341 341 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 351 351 }); }; 352 352 353 353 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 354 354 - createQueryKey("postApiVbyApiVersionFormData", options) 354 354 + createQueryKey('postApiVbyApiVersionFormData', options) 355 355 ]; 356 356 357 357 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 378 378 }; return mutationOptions; }; 379 379 380 380 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 381 381 - createQueryKey("callWithResultFromHeader", options) 381 381 + createQueryKey('callWithResultFromHeader', options) 382 382 ]; 383 383 384 384 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 405 405 }; return mutationOptions; }; 406 406 407 407 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 408 408 - createQueryKey("multipartRequest", options) 408 408 + createQueryKey('multipartRequest', options) 409 409 ]; 410 410 411 411 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 432 432 }; return mutationOptions; }; 433 433 434 434 export const multipartResponseQueryKey = (options?: Options) => [ 435 435 - createQueryKey("multipartResponse", options) 435 435 + createQueryKey('multipartResponse', options) 436 436 ]; 437 437 438 438 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 448 448 }); }; 449 449 450 450 export const dummyAQueryKey = (options?: Options) => [ 451 451 - createQueryKey("dummyA", options) 451 451 + createQueryKey('dummyA', options) 452 452 ]; 453 453 454 454 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 464 464 }); }; 465 465 466 466 export const dummyBQueryKey = (options?: Options) => [ 467 467 - createQueryKey("dummyB", options) 467 467 + createQueryKey('dummyB', options) 468 468 ]; 469 469 470 470 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 480 480 }); }; 481 481 482 482 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 483 483 - createQueryKey("callWithNoContentResponse", options) 483 483 + createQueryKey('callWithNoContentResponse', options) 484 484 ]; 485 485 486 486 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 496 496 }); }; 497 497 498 498 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 499 499 - createQueryKey("callWithResponseAndNoContentResponse", options) 499 499 + createQueryKey('callWithResponseAndNoContentResponse', options) 500 500 ]; 501 501 502 502 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 512 512 }); }; 513 513 514 514 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 515 515 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 515 515 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 516 516 ]; 517 517 518 518 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({ ··· 561 561 }; return mutationOptions; }; 562 562 563 563 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 564 564 - createQueryKey("callWithParameters", options) 564 564 + createQueryKey('callWithParameters', options) 565 565 ]; 566 566 567 567 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 606 606 }; 607 607 608 608 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 609 609 - createQueryKey("callWithParameters", options, true) 609 609 + createQueryKey('callWithParameters', options, true) 610 610 ]; 611 611 612 612 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 614 614 { 615 615 queryFn: async ({ pageParam, queryKey }) => { 616 616 // @ts-ignore 617 617 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 617 617 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 618 618 query: { 619 619 cursor: pageParam 620 620 } ··· 642 642 }; return mutationOptions; }; 643 643 644 644 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 645 645 - createQueryKey("callWithWeirdParameterNames", options) 645 645 + createQueryKey('callWithWeirdParameterNames', options) 646 646 ]; 647 647 648 648 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 669 669 }; return mutationOptions; }; 670 670 671 671 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 672 672 - createQueryKey("getCallWithOptionalParam", options) 672 672 + createQueryKey('getCallWithOptionalParam', options) 673 673 ]; 674 674 675 675 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 685 685 }); }; 686 686 687 687 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 688 688 - createQueryKey("getCallWithOptionalParam", options, true) 688 688 + createQueryKey('getCallWithOptionalParam', options, true) 689 689 ]; 690 690 691 691 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 693 693 { 694 694 queryFn: async ({ pageParam, queryKey }) => { 695 695 // @ts-ignore 696 696 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 696 696 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 697 697 query: { 698 698 page: pageParam 699 699 } ··· 710 710 }); }; 711 711 712 712 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 713 713 - createQueryKey("postCallWithOptionalParam", options) 713 713 + createQueryKey('postCallWithOptionalParam', options) 714 714 ]; 715 715 716 716 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 726 726 }); }; 727 727 728 728 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 729 729 - createQueryKey("postCallWithOptionalParam", options, true) 729 729 + createQueryKey('postCallWithOptionalParam', options, true) 730 730 ]; 731 731 732 732 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 734 734 { 735 735 queryFn: async ({ pageParam, queryKey }) => { 736 736 // @ts-ignore 737 737 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 737 737 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 738 738 body: { 739 739 offset: pageParam 740 740 } ··· 762 762 }; return mutationOptions; }; 763 763 764 764 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 765 765 - createQueryKey("postApiVbyApiVersionRequestBody", options) 765 765 + createQueryKey('postApiVbyApiVersionRequestBody', options) 766 766 ]; 767 767 768 768 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 789 789 }; return mutationOptions; }; 790 790 791 791 export const callWithResponseQueryKey = (options?: Options) => [ 792 792 - createQueryKey("callWithResponse", options) 792 792 + createQueryKey('callWithResponse', options) 793 793 ]; 794 794 795 795 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 805 805 }); }; 806 806 807 807 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 808 808 - createQueryKey("callWithDuplicateResponses", options) 808 808 + createQueryKey('callWithDuplicateResponses', options) 809 809 ]; 810 810 811 811 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 843 843 }; return mutationOptions; }; 844 844 845 845 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 846 846 - createQueryKey("apiVVersionOdataControllerCount", options) 846 846 + createQueryKey('apiVVersionOdataControllerCount', options) 847 847 ]; 848 848 849 849 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 859 859 }); }; 860 860 861 861 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("getCallWithoutParametersAndResponse", options) 862 862 + createQueryKey('getCallWithoutParametersAndResponse', options) 863 863 ]; 864 864 865 865 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 889 889 - createQueryKey("postCallWithoutParametersAndResponse", options) 889 889 + createQueryKey('postCallWithoutParametersAndResponse', options) 890 890 ]; 891 891 892 892 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 935 935 }; return mutationOptions; }; 936 936 937 937 export const typesQueryKey = (options: Options<TypesData>) => [ 938 938 - createQueryKey("types", options) 938 938 + createQueryKey('types', options) 939 939 ]; 940 940 941 941 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 951 951 }); }; 952 952 953 953 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 954 954 - createQueryKey("uploadFile", options) 954 954 + createQueryKey('uploadFile', options) 955 955 ]; 956 956 957 957 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts

reviewed

··· 34 34 }; 35 35 36 36 export const exportQueryKey = (options?: Options) => [ 37 37 - createQueryKey("export", options) 37 37 + createQueryKey('export', options) 38 38 ]; 39 39 40 40 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 50 50 }); }; 51 51 52 52 export const importQueryKey = (options: Options<ImportData>) => [ 53 53 - createQueryKey("import", options) 53 53 + createQueryKey('import', options) 54 54 ]; 55 55 56 56 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 77 77 }; return mutationOptions; }; 78 78 79 79 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 80 80 - createQueryKey("apiVVersionOdataControllerCount", options) 80 80 + createQueryKey('apiVVersionOdataControllerCount', options) 81 81 ]; 82 82 83 83 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 93 93 }); }; 94 94 95 95 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 96 96 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 96 96 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 97 97 ]; 98 98 99 99 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 109 109 }); }; 110 110 111 111 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 112 112 - createQueryKey("getCallWithoutParametersAndResponse", options) 112 112 + createQueryKey('getCallWithoutParametersAndResponse', options) 113 113 ]; 114 114 115 115 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 136 136 }; return mutationOptions; }; 137 137 138 138 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 139 139 - createQueryKey("postCallWithoutParametersAndResponse", options) 139 139 + createQueryKey('postCallWithoutParametersAndResponse', options) 140 140 ]; 141 141 142 142 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 196 196 }; return mutationOptions; }; 197 197 198 198 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 199 199 - createQueryKey("callWithDescriptions", options) 199 199 + createQueryKey('callWithDescriptions', options) 200 200 ]; 201 201 202 202 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 223 223 }; return mutationOptions; }; 224 224 225 225 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 226 226 - createQueryKey("deprecatedCall", options) 226 226 + createQueryKey('deprecatedCall', options) 227 227 ]; 228 228 229 229 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 250 250 }; return mutationOptions; }; 251 251 252 252 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 253 253 - createQueryKey("callWithParameters", options) 253 253 + createQueryKey('callWithParameters', options) 254 254 ]; 255 255 256 256 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 295 295 }; 296 296 297 297 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 298 298 - createQueryKey("callWithParameters", options, true) 298 298 + createQueryKey('callWithParameters', options, true) 299 299 ]; 300 300 301 301 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 303 303 { 304 304 queryFn: async ({ pageParam, queryKey }) => { 305 305 // @ts-ignore 306 306 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 306 306 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 307 307 query: { 308 308 cursor: pageParam 309 309 } ··· 331 331 }; return mutationOptions; }; 332 332 333 333 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 334 334 - createQueryKey("callWithWeirdParameterNames", options) 334 334 + createQueryKey('callWithWeirdParameterNames', options) 335 335 ]; 336 336 337 337 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 358 358 }; return mutationOptions; }; 359 359 360 360 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 361 361 - createQueryKey("getCallWithOptionalParam", options) 361 361 + createQueryKey('getCallWithOptionalParam', options) 362 362 ]; 363 363 364 364 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 374 374 }); }; 375 375 376 376 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 377 377 - createQueryKey("getCallWithOptionalParam", options, true) 377 377 + createQueryKey('getCallWithOptionalParam', options, true) 378 378 ]; 379 379 380 380 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 382 382 { 383 383 queryFn: async ({ pageParam, queryKey }) => { 384 384 // @ts-ignore 385 385 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 385 385 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 386 386 query: { 387 387 page: pageParam 388 388 } ··· 399 399 }); }; 400 400 401 401 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 402 402 - createQueryKey("postCallWithOptionalParam", options) 402 402 + createQueryKey('postCallWithOptionalParam', options) 403 403 ]; 404 404 405 405 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 415 415 }); }; 416 416 417 417 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 418 418 - createQueryKey("postCallWithOptionalParam", options, true) 418 418 + createQueryKey('postCallWithOptionalParam', options, true) 419 419 ]; 420 420 421 421 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<PostCallWithOptionalParamError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 423 423 { 424 424 queryFn: async ({ pageParam, queryKey }) => { 425 425 // @ts-ignore 426 426 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 426 426 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 427 427 body: { 428 428 offset: pageParam 429 429 } ··· 451 451 }; return mutationOptions; }; 452 452 453 453 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 454 454 - createQueryKey("postApiVbyApiVersionRequestBody", options) 454 454 + createQueryKey('postApiVbyApiVersionRequestBody', options) 455 455 ]; 456 456 457 457 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 478 478 }; return mutationOptions; }; 479 479 480 480 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 481 481 - createQueryKey("postApiVbyApiVersionFormData", options) 481 481 + createQueryKey('postApiVbyApiVersionFormData', options) 482 482 ]; 483 483 484 484 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 505 505 }; return mutationOptions; }; 506 506 507 507 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 508 508 - createQueryKey("callWithDefaultParameters", options) 508 508 + createQueryKey('callWithDefaultParameters', options) 509 509 ]; 510 510 511 511 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 521 521 }); }; 522 522 523 523 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 524 524 - createQueryKey("callWithDefaultOptionalParameters", options) 524 524 + createQueryKey('callWithDefaultOptionalParameters', options) 525 525 ]; 526 526 527 527 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 559 559 }; return mutationOptions; }; 560 560 561 561 export const duplicateNameQueryKey = (options?: Options) => [ 562 562 - createQueryKey("duplicateName", options) 562 562 + createQueryKey('duplicateName', options) 563 563 ]; 564 564 565 565 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 575 575 }); }; 576 576 577 577 export const duplicateName1QueryKey = (options?: Options) => [ 578 578 - createQueryKey("duplicateName1", options) 578 578 + createQueryKey('duplicateName1', options) 579 579 ]; 580 580 581 581 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 624 624 }; return mutationOptions; }; 625 625 626 626 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 627 627 - createQueryKey("callWithNoContentResponse", options) 627 627 + createQueryKey('callWithNoContentResponse', options) 628 628 ]; 629 629 630 630 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 640 640 }); }; 641 641 642 642 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 643 643 - createQueryKey("callWithResponseAndNoContentResponse", options) 643 643 + createQueryKey('callWithResponseAndNoContentResponse', options) 644 644 ]; 645 645 646 646 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 656 656 }); }; 657 657 658 658 export const dummyAQueryKey = (options?: Options) => [ 659 659 - createQueryKey("dummyA", options) 659 659 + createQueryKey('dummyA', options) 660 660 ]; 661 661 662 662 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 672 672 }); }; 673 673 674 674 export const dummyBQueryKey = (options?: Options) => [ 675 675 - createQueryKey("dummyB", options) 675 675 + createQueryKey('dummyB', options) 676 676 ]; 677 677 678 678 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 688 688 }); }; 689 689 690 690 export const callWithResponseQueryKey = (options?: Options) => [ 691 691 - createQueryKey("callWithResponse", options) 691 691 + createQueryKey('callWithResponse', options) 692 692 ]; 693 693 694 694 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 704 704 }); }; 705 705 706 706 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 707 707 - createQueryKey("callWithDuplicateResponses", options) 707 707 + createQueryKey('callWithDuplicateResponses', options) 708 708 ]; 709 709 710 710 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 742 742 }; return mutationOptions; }; 743 743 744 744 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 745 745 - createQueryKey("collectionFormat", options) 745 745 + createQueryKey('collectionFormat', options) 746 746 ]; 747 747 748 748 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 758 758 }); }; 759 759 760 760 export const typesQueryKey = (options: Options<TypesData>) => [ 761 761 - createQueryKey("types", options) 761 761 + createQueryKey('types', options) 762 762 ]; 763 763 764 764 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 774 774 }); }; 775 775 776 776 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 777 777 - createQueryKey("uploadFile", options) 777 777 + createQueryKey('uploadFile', options) 778 778 ]; 779 779 780 780 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 801 801 }; return mutationOptions; }; 802 802 803 803 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 804 804 - createQueryKey("fileResponse", options) 804 804 + createQueryKey('fileResponse', options) 805 805 ]; 806 806 807 807 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 817 817 }); }; 818 818 819 819 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 820 820 - createQueryKey("complexTypes", options) 820 820 + createQueryKey('complexTypes', options) 821 821 ]; 822 822 823 823 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 833 833 }); }; 834 834 835 835 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 836 836 - createQueryKey("multipartRequest", options) 836 836 + createQueryKey('multipartRequest', options) 837 837 ]; 838 838 839 839 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 860 860 }; return mutationOptions; }; 861 861 862 862 export const multipartResponseQueryKey = (options?: Options) => [ 863 863 - createQueryKey("multipartResponse", options) 863 863 + createQueryKey('multipartResponse', options) 864 864 ]; 865 865 866 866 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 887 887 }; return mutationOptions; }; 888 888 889 889 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 890 890 - createQueryKey("callWithResultFromHeader", options) 890 890 + createQueryKey('callWithResultFromHeader', options) 891 891 ]; 892 892 893 893 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 914 914 }; return mutationOptions; }; 915 915 916 916 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 917 917 - createQueryKey("testErrorCode", options) 917 917 + createQueryKey('testErrorCode', options) 918 918 ]; 919 919 920 920 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 941 941 }; return mutationOptions; }; 942 942 943 943 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 944 944 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 944 944 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 945 945 ]; 946 946 947 947 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const exportQueryKey = (options?: Options) => [ 36 36 - createQueryKey("export", options) 36 36 + createQueryKey('export', options) 37 37 ]; 38 38 39 39 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const importQueryKey = (options: Options<ImportData>) => [ 52 52 - createQueryKey("import", options) 52 52 + createQueryKey('import', options) 53 53 ]; 54 54 55 55 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 79 79 - createQueryKey("apiVVersionOdataControllerCount", options) 79 79 + createQueryKey('apiVVersionOdataControllerCount', options) 80 80 ]; 81 81 82 82 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 95 95 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 95 95 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 96 96 ]; 97 97 98 98 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 108 108 }); }; 109 109 110 110 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 111 111 - createQueryKey("getCallWithoutParametersAndResponse", options) 111 111 + createQueryKey('getCallWithoutParametersAndResponse', options) 112 112 ]; 113 113 114 114 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 135 135 }; return mutationOptions; }; 136 136 137 137 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 138 138 - createQueryKey("postCallWithoutParametersAndResponse", options) 138 138 + createQueryKey('postCallWithoutParametersAndResponse', options) 139 139 ]; 140 140 141 141 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 195 195 }; return mutationOptions; }; 196 196 197 197 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 198 198 - createQueryKey("callWithDescriptions", options) 198 198 + createQueryKey('callWithDescriptions', options) 199 199 ]; 200 200 201 201 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 222 222 }; return mutationOptions; }; 223 223 224 224 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 225 225 - createQueryKey("deprecatedCall", options) 225 225 + createQueryKey('deprecatedCall', options) 226 226 ]; 227 227 228 228 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 249 249 }; return mutationOptions; }; 250 250 251 251 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 252 252 - createQueryKey("callWithParameters", options) 252 252 + createQueryKey('callWithParameters', options) 253 253 ]; 254 254 255 255 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 294 294 }; 295 295 296 296 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 297 297 - createQueryKey("callWithParameters", options, true) 297 297 + createQueryKey('callWithParameters', options, true) 298 298 ]; 299 299 300 300 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 302 302 { 303 303 queryFn: async ({ pageParam, queryKey }) => { 304 304 // @ts-ignore 305 305 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 305 305 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 306 306 query: { 307 307 cursor: pageParam 308 308 } ··· 330 330 }; return mutationOptions; }; 331 331 332 332 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 333 333 - createQueryKey("callWithWeirdParameterNames", options) 333 333 + createQueryKey('callWithWeirdParameterNames', options) 334 334 ]; 335 335 336 336 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 357 357 }; return mutationOptions; }; 358 358 359 359 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 360 360 - createQueryKey("getCallWithOptionalParam", options) 360 360 + createQueryKey('getCallWithOptionalParam', options) 361 361 ]; 362 362 363 363 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 373 373 }); }; 374 374 375 375 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 376 376 - createQueryKey("getCallWithOptionalParam", options, true) 376 376 + createQueryKey('getCallWithOptionalParam', options, true) 377 377 ]; 378 378 379 379 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 381 381 { 382 382 queryFn: async ({ pageParam, queryKey }) => { 383 383 // @ts-ignore 384 384 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 384 384 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 385 385 query: { 386 386 page: pageParam 387 387 } ··· 398 398 }); }; 399 399 400 400 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 401 401 - createQueryKey("postCallWithOptionalParam", options) 401 401 + createQueryKey('postCallWithOptionalParam', options) 402 402 ]; 403 403 404 404 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 414 414 }); }; 415 415 416 416 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 417 417 - createQueryKey("postCallWithOptionalParam", options, true) 417 417 + createQueryKey('postCallWithOptionalParam', options, true) 418 418 ]; 419 419 420 420 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 422 422 { 423 423 queryFn: async ({ pageParam, queryKey }) => { 424 424 // @ts-ignore 425 425 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 425 425 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 426 426 body: { 427 427 offset: pageParam 428 428 } ··· 450 450 }; return mutationOptions; }; 451 451 452 452 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 453 453 - createQueryKey("postApiVbyApiVersionRequestBody", options) 453 453 + createQueryKey('postApiVbyApiVersionRequestBody', options) 454 454 ]; 455 455 456 456 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 477 477 }; return mutationOptions; }; 478 478 479 479 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 480 480 - createQueryKey("postApiVbyApiVersionFormData", options) 480 480 + createQueryKey('postApiVbyApiVersionFormData', options) 481 481 ]; 482 482 483 483 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 504 504 }; return mutationOptions; }; 505 505 506 506 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 507 507 - createQueryKey("callWithDefaultParameters", options) 507 507 + createQueryKey('callWithDefaultParameters', options) 508 508 ]; 509 509 510 510 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 520 520 }); }; 521 521 522 522 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 523 523 - createQueryKey("callWithDefaultOptionalParameters", options) 523 523 + createQueryKey('callWithDefaultOptionalParameters', options) 524 524 ]; 525 525 526 526 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 558 558 }; return mutationOptions; }; 559 559 560 560 export const duplicateNameQueryKey = (options?: Options) => [ 561 561 - createQueryKey("duplicateName", options) 561 561 + createQueryKey('duplicateName', options) 562 562 ]; 563 563 564 564 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 574 574 }); }; 575 575 576 576 export const duplicateName1QueryKey = (options?: Options) => [ 577 577 - createQueryKey("duplicateName1", options) 577 577 + createQueryKey('duplicateName1', options) 578 578 ]; 579 579 580 580 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 623 623 }; return mutationOptions; }; 624 624 625 625 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 626 626 - createQueryKey("callWithNoContentResponse", options) 626 626 + createQueryKey('callWithNoContentResponse', options) 627 627 ]; 628 628 629 629 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 639 639 }); }; 640 640 641 641 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 642 642 - createQueryKey("callWithResponseAndNoContentResponse", options) 642 642 + createQueryKey('callWithResponseAndNoContentResponse', options) 643 643 ]; 644 644 645 645 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 655 655 }); }; 656 656 657 657 export const dummyAQueryKey = (options?: Options) => [ 658 658 - createQueryKey("dummyA", options) 658 658 + createQueryKey('dummyA', options) 659 659 ]; 660 660 661 661 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 671 671 }); }; 672 672 673 673 export const dummyBQueryKey = (options?: Options) => [ 674 674 - createQueryKey("dummyB", options) 674 674 + createQueryKey('dummyB', options) 675 675 ]; 676 676 677 677 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 687 687 }); }; 688 688 689 689 export const callWithResponseQueryKey = (options?: Options) => [ 690 690 - createQueryKey("callWithResponse", options) 690 690 + createQueryKey('callWithResponse', options) 691 691 ]; 692 692 693 693 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 703 703 }); }; 704 704 705 705 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 706 706 - createQueryKey("callWithDuplicateResponses", options) 706 706 + createQueryKey('callWithDuplicateResponses', options) 707 707 ]; 708 708 709 709 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 741 741 }; return mutationOptions; }; 742 742 743 743 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 744 744 - createQueryKey("collectionFormat", options) 744 744 + createQueryKey('collectionFormat', options) 745 745 ]; 746 746 747 747 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 757 757 }); }; 758 758 759 759 export const typesQueryKey = (options: Options<TypesData>) => [ 760 760 - createQueryKey("types", options) 760 760 + createQueryKey('types', options) 761 761 ]; 762 762 763 763 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 773 773 }); }; 774 774 775 775 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 776 776 - createQueryKey("uploadFile", options) 776 776 + createQueryKey('uploadFile', options) 777 777 ]; 778 778 779 779 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 800 800 }; return mutationOptions; }; 801 801 802 802 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 803 803 - createQueryKey("fileResponse", options) 803 803 + createQueryKey('fileResponse', options) 804 804 ]; 805 805 806 806 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 816 816 }); }; 817 817 818 818 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 819 819 - createQueryKey("complexTypes", options) 819 819 + createQueryKey('complexTypes', options) 820 820 ]; 821 821 822 822 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 832 832 }); }; 833 833 834 834 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 835 835 - createQueryKey("multipartRequest", options) 835 835 + createQueryKey('multipartRequest', options) 836 836 ]; 837 837 838 838 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 859 859 }; return mutationOptions; }; 860 860 861 861 export const multipartResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("multipartResponse", options) 862 862 + createQueryKey('multipartResponse', options) 863 863 ]; 864 864 865 865 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 889 889 - createQueryKey("callWithResultFromHeader", options) 889 889 + createQueryKey('callWithResultFromHeader', options) 890 890 ]; 891 891 892 892 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 913 913 }; return mutationOptions; }; 914 914 915 915 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 916 916 - createQueryKey("testErrorCode", options) 916 916 + createQueryKey('testErrorCode', options) 917 917 ]; 918 918 919 919 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 940 940 }; return mutationOptions; }; 941 941 942 942 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 943 943 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 943 943 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 944 944 ]; 945 945 946 946 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 36 36 - createQueryKey("collectionFormat", options) 36 36 + createQueryKey('collectionFormat', options) 37 37 ]; 38 38 39 39 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 52 52 - createQueryKey("complexTypes", options) 52 52 + createQueryKey('complexTypes', options) 53 53 ]; 54 54 55 55 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const exportQueryKey = (options?: Options) => [ 79 79 - createQueryKey("export", options) 79 79 + createQueryKey('export', options) 80 80 ]; 81 81 82 82 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const importQueryKey = (options: Options<ImportData>) => [ 95 95 - createQueryKey("import", options) 95 95 + createQueryKey('import', options) 96 96 ]; 97 97 98 98 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 119 119 }; return mutationOptions; }; 120 120 121 121 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 122 122 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 122 122 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 123 123 ]; 124 124 125 125 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 135 135 }); }; 136 136 137 137 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 138 138 - createQueryKey("callWithDefaultParameters", options) 138 138 + createQueryKey('callWithDefaultParameters', options) 139 139 ]; 140 140 141 141 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 151 151 }); }; 152 152 153 153 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 154 154 - createQueryKey("callWithDefaultOptionalParameters", options) 154 154 + createQueryKey('callWithDefaultOptionalParameters', options) 155 155 ]; 156 156 157 157 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 189 189 }; return mutationOptions; }; 190 190 191 191 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 192 192 - createQueryKey("deprecatedCall", options) 192 192 + createQueryKey('deprecatedCall', options) 193 193 ]; 194 194 195 195 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 216 216 }; return mutationOptions; }; 217 217 218 218 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 219 219 - createQueryKey("callWithDescriptions", options) 219 219 + createQueryKey('callWithDescriptions', options) 220 220 ]; 221 221 222 222 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 243 243 }; return mutationOptions; }; 244 244 245 245 export const duplicateNameQueryKey = (options?: Options) => [ 246 246 - createQueryKey("duplicateName", options) 246 246 + createQueryKey('duplicateName', options) 247 247 ]; 248 248 249 249 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 259 259 }); }; 260 260 261 261 export const duplicateName1QueryKey = (options?: Options) => [ 262 262 - createQueryKey("duplicateName1", options) 262 262 + createQueryKey('duplicateName1', options) 263 263 ]; 264 264 265 265 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 308 308 }; return mutationOptions; }; 309 309 310 310 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 311 311 - createQueryKey("testErrorCode", options) 311 311 + createQueryKey('testErrorCode', options) 312 312 ]; 313 313 314 314 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 335 335 }; return mutationOptions; }; 336 336 337 337 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 338 338 - createQueryKey("fileResponse", options) 338 338 + createQueryKey('fileResponse', options) 339 339 ]; 340 340 341 341 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 351 351 }); }; 352 352 353 353 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 354 354 - createQueryKey("postApiVbyApiVersionFormData", options) 354 354 + createQueryKey('postApiVbyApiVersionFormData', options) 355 355 ]; 356 356 357 357 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 378 378 }; return mutationOptions; }; 379 379 380 380 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 381 381 - createQueryKey("callWithResultFromHeader", options) 381 381 + createQueryKey('callWithResultFromHeader', options) 382 382 ]; 383 383 384 384 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 405 405 }; return mutationOptions; }; 406 406 407 407 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 408 408 - createQueryKey("multipartRequest", options) 408 408 + createQueryKey('multipartRequest', options) 409 409 ]; 410 410 411 411 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 432 432 }; return mutationOptions; }; 433 433 434 434 export const multipartResponseQueryKey = (options?: Options) => [ 435 435 - createQueryKey("multipartResponse", options) 435 435 + createQueryKey('multipartResponse', options) 436 436 ]; 437 437 438 438 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 448 448 }); }; 449 449 450 450 export const dummyAQueryKey = (options?: Options) => [ 451 451 - createQueryKey("dummyA", options) 451 451 + createQueryKey('dummyA', options) 452 452 ]; 453 453 454 454 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 464 464 }); }; 465 465 466 466 export const dummyBQueryKey = (options?: Options) => [ 467 467 - createQueryKey("dummyB", options) 467 467 + createQueryKey('dummyB', options) 468 468 ]; 469 469 470 470 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 480 480 }); }; 481 481 482 482 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 483 483 - createQueryKey("callWithNoContentResponse", options) 483 483 + createQueryKey('callWithNoContentResponse', options) 484 484 ]; 485 485 486 486 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 496 496 }); }; 497 497 498 498 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 499 499 - createQueryKey("callWithResponseAndNoContentResponse", options) 499 499 + createQueryKey('callWithResponseAndNoContentResponse', options) 500 500 ]; 501 501 502 502 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 512 512 }); }; 513 513 514 514 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 515 515 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 515 515 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 516 516 ]; 517 517 518 518 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({ ··· 561 561 }; return mutationOptions; }; 562 562 563 563 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 564 564 - createQueryKey("callWithParameters", options) 564 564 + createQueryKey('callWithParameters', options) 565 565 ]; 566 566 567 567 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 606 606 }; 607 607 608 608 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 609 609 - createQueryKey("callWithParameters", options, true) 609 609 + createQueryKey('callWithParameters', options, true) 610 610 ]; 611 611 612 612 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 614 614 { 615 615 queryFn: async ({ pageParam, queryKey }) => { 616 616 // @ts-ignore 617 617 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 617 617 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 618 618 query: { 619 619 cursor: pageParam 620 620 } ··· 642 642 }; return mutationOptions; }; 643 643 644 644 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 645 645 - createQueryKey("callWithWeirdParameterNames", options) 645 645 + createQueryKey('callWithWeirdParameterNames', options) 646 646 ]; 647 647 648 648 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 669 669 }; return mutationOptions; }; 670 670 671 671 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 672 672 - createQueryKey("getCallWithOptionalParam", options) 672 672 + createQueryKey('getCallWithOptionalParam', options) 673 673 ]; 674 674 675 675 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 685 685 }); }; 686 686 687 687 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 688 688 - createQueryKey("getCallWithOptionalParam", options, true) 688 688 + createQueryKey('getCallWithOptionalParam', options, true) 689 689 ]; 690 690 691 691 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 693 693 { 694 694 queryFn: async ({ pageParam, queryKey }) => { 695 695 // @ts-ignore 696 696 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 696 696 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 697 697 query: { 698 698 page: pageParam 699 699 } ··· 710 710 }); }; 711 711 712 712 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 713 713 - createQueryKey("postCallWithOptionalParam", options) 713 713 + createQueryKey('postCallWithOptionalParam', options) 714 714 ]; 715 715 716 716 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 726 726 }); }; 727 727 728 728 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 729 729 - createQueryKey("postCallWithOptionalParam", options, true) 729 729 + createQueryKey('postCallWithOptionalParam', options, true) 730 730 ]; 731 731 732 732 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 734 734 { 735 735 queryFn: async ({ pageParam, queryKey }) => { 736 736 // @ts-ignore 737 737 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 737 737 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 738 738 body: { 739 739 offset: pageParam 740 740 } ··· 762 762 }; return mutationOptions; }; 763 763 764 764 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 765 765 - createQueryKey("postApiVbyApiVersionRequestBody", options) 765 765 + createQueryKey('postApiVbyApiVersionRequestBody', options) 766 766 ]; 767 767 768 768 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 789 789 }; return mutationOptions; }; 790 790 791 791 export const callWithResponseQueryKey = (options?: Options) => [ 792 792 - createQueryKey("callWithResponse", options) 792 792 + createQueryKey('callWithResponse', options) 793 793 ]; 794 794 795 795 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 805 805 }); }; 806 806 807 807 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 808 808 - createQueryKey("callWithDuplicateResponses", options) 808 808 + createQueryKey('callWithDuplicateResponses', options) 809 809 ]; 810 810 811 811 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 843 843 }; return mutationOptions; }; 844 844 845 845 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 846 846 - createQueryKey("apiVVersionOdataControllerCount", options) 846 846 + createQueryKey('apiVVersionOdataControllerCount', options) 847 847 ]; 848 848 849 849 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 859 859 }); }; 860 860 861 861 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("getCallWithoutParametersAndResponse", options) 862 862 + createQueryKey('getCallWithoutParametersAndResponse', options) 863 863 ]; 864 864 865 865 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 889 889 - createQueryKey("postCallWithoutParametersAndResponse", options) 889 889 + createQueryKey('postCallWithoutParametersAndResponse', options) 890 890 ]; 891 891 892 892 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 935 935 }; return mutationOptions; }; 936 936 937 937 export const typesQueryKey = (options: Options<TypesData>) => [ 938 938 - createQueryKey("types", options) 938 938 + createQueryKey('types', options) 939 939 ]; 940 940 941 941 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 951 951 }); }; 952 952 953 953 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 954 954 - createQueryKey("uploadFile", options) 954 954 + createQueryKey('uploadFile', options) 955 955 ]; 956 956 957 957 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts

reviewed

··· 34 34 }; 35 35 36 36 export const exportQueryKey = (options?: Options) => [ 37 37 - createQueryKey("export", options) 37 37 + createQueryKey('export', options) 38 38 ]; 39 39 40 40 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 50 50 }); }; 51 51 52 52 export const importQueryKey = (options: Options<ImportData>) => [ 53 53 - createQueryKey("import", options) 53 53 + createQueryKey('import', options) 54 54 ]; 55 55 56 56 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 77 77 }; return mutationOptions; }; 78 78 79 79 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 80 80 - createQueryKey("apiVVersionOdataControllerCount", options) 80 80 + createQueryKey('apiVVersionOdataControllerCount', options) 81 81 ]; 82 82 83 83 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 93 93 }); }; 94 94 95 95 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 96 96 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 96 96 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 97 97 ]; 98 98 99 99 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 109 109 }); }; 110 110 111 111 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 112 112 - createQueryKey("getCallWithoutParametersAndResponse", options) 112 112 + createQueryKey('getCallWithoutParametersAndResponse', options) 113 113 ]; 114 114 115 115 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 136 136 }; return mutationOptions; }; 137 137 138 138 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 139 139 - createQueryKey("postCallWithoutParametersAndResponse", options) 139 139 + createQueryKey('postCallWithoutParametersAndResponse', options) 140 140 ]; 141 141 142 142 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 196 196 }; return mutationOptions; }; 197 197 198 198 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 199 199 - createQueryKey("callWithDescriptions", options) 199 199 + createQueryKey('callWithDescriptions', options) 200 200 ]; 201 201 202 202 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 223 223 }; return mutationOptions; }; 224 224 225 225 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 226 226 - createQueryKey("deprecatedCall", options) 226 226 + createQueryKey('deprecatedCall', options) 227 227 ]; 228 228 229 229 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 250 250 }; return mutationOptions; }; 251 251 252 252 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 253 253 - createQueryKey("callWithParameters", options) 253 253 + createQueryKey('callWithParameters', options) 254 254 ]; 255 255 256 256 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 295 295 }; 296 296 297 297 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 298 298 - createQueryKey("callWithParameters", options, true) 298 298 + createQueryKey('callWithParameters', options, true) 299 299 ]; 300 300 301 301 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 303 303 { 304 304 queryFn: async ({ pageParam, queryKey }) => { 305 305 // @ts-ignore 306 306 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 306 306 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 307 307 query: { 308 308 cursor: pageParam 309 309 } ··· 331 331 }; return mutationOptions; }; 332 332 333 333 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 334 334 - createQueryKey("callWithWeirdParameterNames", options) 334 334 + createQueryKey('callWithWeirdParameterNames', options) 335 335 ]; 336 336 337 337 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 358 358 }; return mutationOptions; }; 359 359 360 360 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 361 361 - createQueryKey("getCallWithOptionalParam", options) 361 361 + createQueryKey('getCallWithOptionalParam', options) 362 362 ]; 363 363 364 364 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 374 374 }); }; 375 375 376 376 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 377 377 - createQueryKey("getCallWithOptionalParam", options, true) 377 377 + createQueryKey('getCallWithOptionalParam', options, true) 378 378 ]; 379 379 380 380 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 382 382 { 383 383 queryFn: async ({ pageParam, queryKey }) => { 384 384 // @ts-ignore 385 385 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 385 385 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 386 386 query: { 387 387 page: pageParam 388 388 } ··· 399 399 }); }; 400 400 401 401 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 402 402 - createQueryKey("postCallWithOptionalParam", options) 402 402 + createQueryKey('postCallWithOptionalParam', options) 403 403 ]; 404 404 405 405 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 415 415 }); }; 416 416 417 417 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 418 418 - createQueryKey("postCallWithOptionalParam", options, true) 418 418 + createQueryKey('postCallWithOptionalParam', options, true) 419 419 ]; 420 420 421 421 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<PostCallWithOptionalParamError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 423 423 { 424 424 queryFn: async ({ pageParam, queryKey }) => { 425 425 // @ts-ignore 426 426 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 426 426 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 427 427 body: { 428 428 offset: pageParam 429 429 } ··· 451 451 }; return mutationOptions; }; 452 452 453 453 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 454 454 - createQueryKey("postApiVbyApiVersionRequestBody", options) 454 454 + createQueryKey('postApiVbyApiVersionRequestBody', options) 455 455 ]; 456 456 457 457 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 478 478 }; return mutationOptions; }; 479 479 480 480 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 481 481 - createQueryKey("postApiVbyApiVersionFormData", options) 481 481 + createQueryKey('postApiVbyApiVersionFormData', options) 482 482 ]; 483 483 484 484 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 505 505 }; return mutationOptions; }; 506 506 507 507 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 508 508 - createQueryKey("callWithDefaultParameters", options) 508 508 + createQueryKey('callWithDefaultParameters', options) 509 509 ]; 510 510 511 511 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 521 521 }); }; 522 522 523 523 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 524 524 - createQueryKey("callWithDefaultOptionalParameters", options) 524 524 + createQueryKey('callWithDefaultOptionalParameters', options) 525 525 ]; 526 526 527 527 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 559 559 }; return mutationOptions; }; 560 560 561 561 export const duplicateNameQueryKey = (options?: Options) => [ 562 562 - createQueryKey("duplicateName", options) 562 562 + createQueryKey('duplicateName', options) 563 563 ]; 564 564 565 565 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 575 575 }); }; 576 576 577 577 export const duplicateName1QueryKey = (options?: Options) => [ 578 578 - createQueryKey("duplicateName1", options) 578 578 + createQueryKey('duplicateName1', options) 579 579 ]; 580 580 581 581 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 624 624 }; return mutationOptions; }; 625 625 626 626 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 627 627 - createQueryKey("callWithNoContentResponse", options) 627 627 + createQueryKey('callWithNoContentResponse', options) 628 628 ]; 629 629 630 630 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 640 640 }); }; 641 641 642 642 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 643 643 - createQueryKey("callWithResponseAndNoContentResponse", options) 643 643 + createQueryKey('callWithResponseAndNoContentResponse', options) 644 644 ]; 645 645 646 646 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 656 656 }); }; 657 657 658 658 export const dummyAQueryKey = (options?: Options) => [ 659 659 - createQueryKey("dummyA", options) 659 659 + createQueryKey('dummyA', options) 660 660 ]; 661 661 662 662 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 672 672 }); }; 673 673 674 674 export const dummyBQueryKey = (options?: Options) => [ 675 675 - createQueryKey("dummyB", options) 675 675 + createQueryKey('dummyB', options) 676 676 ]; 677 677 678 678 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 688 688 }); }; 689 689 690 690 export const callWithResponseQueryKey = (options?: Options) => [ 691 691 - createQueryKey("callWithResponse", options) 691 691 + createQueryKey('callWithResponse', options) 692 692 ]; 693 693 694 694 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 704 704 }); }; 705 705 706 706 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 707 707 - createQueryKey("callWithDuplicateResponses", options) 707 707 + createQueryKey('callWithDuplicateResponses', options) 708 708 ]; 709 709 710 710 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 742 742 }; return mutationOptions; }; 743 743 744 744 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 745 745 - createQueryKey("collectionFormat", options) 745 745 + createQueryKey('collectionFormat', options) 746 746 ]; 747 747 748 748 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 758 758 }); }; 759 759 760 760 export const typesQueryKey = (options: Options<TypesData>) => [ 761 761 - createQueryKey("types", options) 761 761 + createQueryKey('types', options) 762 762 ]; 763 763 764 764 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 774 774 }); }; 775 775 776 776 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 777 777 - createQueryKey("uploadFile", options) 777 777 + createQueryKey('uploadFile', options) 778 778 ]; 779 779 780 780 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 801 801 }; return mutationOptions; }; 802 802 803 803 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 804 804 - createQueryKey("fileResponse", options) 804 804 + createQueryKey('fileResponse', options) 805 805 ]; 806 806 807 807 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 817 817 }); }; 818 818 819 819 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 820 820 - createQueryKey("complexTypes", options) 820 820 + createQueryKey('complexTypes', options) 821 821 ]; 822 822 823 823 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 833 833 }); }; 834 834 835 835 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 836 836 - createQueryKey("multipartRequest", options) 836 836 + createQueryKey('multipartRequest', options) 837 837 ]; 838 838 839 839 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 860 860 }; return mutationOptions; }; 861 861 862 862 export const multipartResponseQueryKey = (options?: Options) => [ 863 863 - createQueryKey("multipartResponse", options) 863 863 + createQueryKey('multipartResponse', options) 864 864 ]; 865 865 866 866 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 887 887 }; return mutationOptions; }; 888 888 889 889 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 890 890 - createQueryKey("callWithResultFromHeader", options) 890 890 + createQueryKey('callWithResultFromHeader', options) 891 891 ]; 892 892 893 893 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 914 914 }; return mutationOptions; }; 915 915 916 916 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 917 917 - createQueryKey("testErrorCode", options) 917 917 + createQueryKey('testErrorCode', options) 918 918 ]; 919 919 920 920 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 941 941 }; return mutationOptions; }; 942 942 943 943 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 944 944 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 944 944 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 945 945 ]; 946 946 947 947 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const exportQueryKey = (options?: Options) => [ 36 36 - createQueryKey("export", options) 36 36 + createQueryKey('export', options) 37 37 ]; 38 38 39 39 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const importQueryKey = (options: Options<ImportData>) => [ 52 52 - createQueryKey("import", options) 52 52 + createQueryKey('import', options) 53 53 ]; 54 54 55 55 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 79 79 - createQueryKey("apiVVersionOdataControllerCount", options) 79 79 + createQueryKey('apiVVersionOdataControllerCount', options) 80 80 ]; 81 81 82 82 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 95 95 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 95 95 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 96 96 ]; 97 97 98 98 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 108 108 }); }; 109 109 110 110 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 111 111 - createQueryKey("getCallWithoutParametersAndResponse", options) 111 111 + createQueryKey('getCallWithoutParametersAndResponse', options) 112 112 ]; 113 113 114 114 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 135 135 }; return mutationOptions; }; 136 136 137 137 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 138 138 - createQueryKey("postCallWithoutParametersAndResponse", options) 138 138 + createQueryKey('postCallWithoutParametersAndResponse', options) 139 139 ]; 140 140 141 141 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 195 195 }; return mutationOptions; }; 196 196 197 197 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 198 198 - createQueryKey("callWithDescriptions", options) 198 198 + createQueryKey('callWithDescriptions', options) 199 199 ]; 200 200 201 201 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 222 222 }; return mutationOptions; }; 223 223 224 224 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 225 225 - createQueryKey("deprecatedCall", options) 225 225 + createQueryKey('deprecatedCall', options) 226 226 ]; 227 227 228 228 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 249 249 }; return mutationOptions; }; 250 250 251 251 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 252 252 - createQueryKey("callWithParameters", options) 252 252 + createQueryKey('callWithParameters', options) 253 253 ]; 254 254 255 255 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 294 294 }; 295 295 296 296 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 297 297 - createQueryKey("callWithParameters", options, true) 297 297 + createQueryKey('callWithParameters', options, true) 298 298 ]; 299 299 300 300 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 302 302 { 303 303 queryFn: async ({ pageParam, queryKey }) => { 304 304 // @ts-ignore 305 305 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 305 305 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 306 306 query: { 307 307 cursor: pageParam 308 308 } ··· 330 330 }; return mutationOptions; }; 331 331 332 332 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 333 333 - createQueryKey("callWithWeirdParameterNames", options) 333 333 + createQueryKey('callWithWeirdParameterNames', options) 334 334 ]; 335 335 336 336 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 357 357 }; return mutationOptions; }; 358 358 359 359 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 360 360 - createQueryKey("getCallWithOptionalParam", options) 360 360 + createQueryKey('getCallWithOptionalParam', options) 361 361 ]; 362 362 363 363 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 373 373 }); }; 374 374 375 375 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 376 376 - createQueryKey("getCallWithOptionalParam", options, true) 376 376 + createQueryKey('getCallWithOptionalParam', options, true) 377 377 ]; 378 378 379 379 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 381 381 { 382 382 queryFn: async ({ pageParam, queryKey }) => { 383 383 // @ts-ignore 384 384 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 384 384 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 385 385 query: { 386 386 page: pageParam 387 387 } ··· 398 398 }); }; 399 399 400 400 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 401 401 - createQueryKey("postCallWithOptionalParam", options) 401 401 + createQueryKey('postCallWithOptionalParam', options) 402 402 ]; 403 403 404 404 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 414 414 }); }; 415 415 416 416 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 417 417 - createQueryKey("postCallWithOptionalParam", options, true) 417 417 + createQueryKey('postCallWithOptionalParam', options, true) 418 418 ]; 419 419 420 420 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 422 422 { 423 423 queryFn: async ({ pageParam, queryKey }) => { 424 424 // @ts-ignore 425 425 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 425 425 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 426 426 body: { 427 427 offset: pageParam 428 428 } ··· 450 450 }; return mutationOptions; }; 451 451 452 452 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 453 453 - createQueryKey("postApiVbyApiVersionRequestBody", options) 453 453 + createQueryKey('postApiVbyApiVersionRequestBody', options) 454 454 ]; 455 455 456 456 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 477 477 }; return mutationOptions; }; 478 478 479 479 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 480 480 - createQueryKey("postApiVbyApiVersionFormData", options) 480 480 + createQueryKey('postApiVbyApiVersionFormData', options) 481 481 ]; 482 482 483 483 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 504 504 }; return mutationOptions; }; 505 505 506 506 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 507 507 - createQueryKey("callWithDefaultParameters", options) 507 507 + createQueryKey('callWithDefaultParameters', options) 508 508 ]; 509 509 510 510 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 520 520 }); }; 521 521 522 522 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 523 523 - createQueryKey("callWithDefaultOptionalParameters", options) 523 523 + createQueryKey('callWithDefaultOptionalParameters', options) 524 524 ]; 525 525 526 526 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 558 558 }; return mutationOptions; }; 559 559 560 560 export const duplicateNameQueryKey = (options?: Options) => [ 561 561 - createQueryKey("duplicateName", options) 561 561 + createQueryKey('duplicateName', options) 562 562 ]; 563 563 564 564 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 574 574 }); }; 575 575 576 576 export const duplicateName1QueryKey = (options?: Options) => [ 577 577 - createQueryKey("duplicateName1", options) 577 577 + createQueryKey('duplicateName1', options) 578 578 ]; 579 579 580 580 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 623 623 }; return mutationOptions; }; 624 624 625 625 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 626 626 - createQueryKey("callWithNoContentResponse", options) 626 626 + createQueryKey('callWithNoContentResponse', options) 627 627 ]; 628 628 629 629 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 639 639 }); }; 640 640 641 641 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 642 642 - createQueryKey("callWithResponseAndNoContentResponse", options) 642 642 + createQueryKey('callWithResponseAndNoContentResponse', options) 643 643 ]; 644 644 645 645 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 655 655 }); }; 656 656 657 657 export const dummyAQueryKey = (options?: Options) => [ 658 658 - createQueryKey("dummyA", options) 658 658 + createQueryKey('dummyA', options) 659 659 ]; 660 660 661 661 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 671 671 }); }; 672 672 673 673 export const dummyBQueryKey = (options?: Options) => [ 674 674 - createQueryKey("dummyB", options) 674 674 + createQueryKey('dummyB', options) 675 675 ]; 676 676 677 677 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 687 687 }); }; 688 688 689 689 export const callWithResponseQueryKey = (options?: Options) => [ 690 690 - createQueryKey("callWithResponse", options) 690 690 + createQueryKey('callWithResponse', options) 691 691 ]; 692 692 693 693 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 703 703 }); }; 704 704 705 705 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 706 706 - createQueryKey("callWithDuplicateResponses", options) 706 706 + createQueryKey('callWithDuplicateResponses', options) 707 707 ]; 708 708 709 709 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 741 741 }; return mutationOptions; }; 742 742 743 743 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 744 744 - createQueryKey("collectionFormat", options) 744 744 + createQueryKey('collectionFormat', options) 745 745 ]; 746 746 747 747 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 757 757 }); }; 758 758 759 759 export const typesQueryKey = (options: Options<TypesData>) => [ 760 760 - createQueryKey("types", options) 760 760 + createQueryKey('types', options) 761 761 ]; 762 762 763 763 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 773 773 }); }; 774 774 775 775 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 776 776 - createQueryKey("uploadFile", options) 776 776 + createQueryKey('uploadFile', options) 777 777 ]; 778 778 779 779 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 800 800 }; return mutationOptions; }; 801 801 802 802 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 803 803 - createQueryKey("fileResponse", options) 803 803 + createQueryKey('fileResponse', options) 804 804 ]; 805 805 806 806 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 816 816 }); }; 817 817 818 818 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 819 819 - createQueryKey("complexTypes", options) 819 819 + createQueryKey('complexTypes', options) 820 820 ]; 821 821 822 822 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 832 832 }); }; 833 833 834 834 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 835 835 - createQueryKey("multipartRequest", options) 835 835 + createQueryKey('multipartRequest', options) 836 836 ]; 837 837 838 838 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 859 859 }; return mutationOptions; }; 860 860 861 861 export const multipartResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("multipartResponse", options) 862 862 + createQueryKey('multipartResponse', options) 863 863 ]; 864 864 865 865 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 889 889 - createQueryKey("callWithResultFromHeader", options) 889 889 + createQueryKey('callWithResultFromHeader', options) 890 890 ]; 891 891 892 892 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 913 913 }; return mutationOptions; }; 914 914 915 915 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 916 916 - createQueryKey("testErrorCode", options) 916 916 + createQueryKey('testErrorCode', options) 917 917 ]; 918 918 919 919 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 940 940 }; return mutationOptions; }; 941 941 942 942 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 943 943 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 943 943 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 944 944 ]; 945 945 946 946 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 36 36 - createQueryKey("collectionFormat", options) 36 36 + createQueryKey('collectionFormat', options) 37 37 ]; 38 38 39 39 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 52 52 - createQueryKey("complexTypes", options) 52 52 + createQueryKey('complexTypes', options) 53 53 ]; 54 54 55 55 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const exportQueryKey = (options?: Options) => [ 79 79 - createQueryKey("export", options) 79 79 + createQueryKey('export', options) 80 80 ]; 81 81 82 82 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const importQueryKey = (options: Options<ImportData>) => [ 95 95 - createQueryKey("import", options) 95 95 + createQueryKey('import', options) 96 96 ]; 97 97 98 98 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 119 119 }; return mutationOptions; }; 120 120 121 121 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 122 122 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 122 122 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 123 123 ]; 124 124 125 125 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 135 135 }); }; 136 136 137 137 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 138 138 - createQueryKey("callWithDefaultParameters", options) 138 138 + createQueryKey('callWithDefaultParameters', options) 139 139 ]; 140 140 141 141 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 151 151 }); }; 152 152 153 153 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 154 154 - createQueryKey("callWithDefaultOptionalParameters", options) 154 154 + createQueryKey('callWithDefaultOptionalParameters', options) 155 155 ]; 156 156 157 157 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 189 189 }; return mutationOptions; }; 190 190 191 191 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 192 192 - createQueryKey("deprecatedCall", options) 192 192 + createQueryKey('deprecatedCall', options) 193 193 ]; 194 194 195 195 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 216 216 }; return mutationOptions; }; 217 217 218 218 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 219 219 - createQueryKey("callWithDescriptions", options) 219 219 + createQueryKey('callWithDescriptions', options) 220 220 ]; 221 221 222 222 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 243 243 }; return mutationOptions; }; 244 244 245 245 export const duplicateNameQueryKey = (options?: Options) => [ 246 246 - createQueryKey("duplicateName", options) 246 246 + createQueryKey('duplicateName', options) 247 247 ]; 248 248 249 249 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 259 259 }); }; 260 260 261 261 export const duplicateName1QueryKey = (options?: Options) => [ 262 262 - createQueryKey("duplicateName1", options) 262 262 + createQueryKey('duplicateName1', options) 263 263 ]; 264 264 265 265 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 308 308 }; return mutationOptions; }; 309 309 310 310 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 311 311 - createQueryKey("testErrorCode", options) 311 311 + createQueryKey('testErrorCode', options) 312 312 ]; 313 313 314 314 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 335 335 }; return mutationOptions; }; 336 336 337 337 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 338 338 - createQueryKey("fileResponse", options) 338 338 + createQueryKey('fileResponse', options) 339 339 ]; 340 340 341 341 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 351 351 }); }; 352 352 353 353 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 354 354 - createQueryKey("postApiVbyApiVersionFormData", options) 354 354 + createQueryKey('postApiVbyApiVersionFormData', options) 355 355 ]; 356 356 357 357 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 378 378 }; return mutationOptions; }; 379 379 380 380 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 381 381 - createQueryKey("callWithResultFromHeader", options) 381 381 + createQueryKey('callWithResultFromHeader', options) 382 382 ]; 383 383 384 384 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 405 405 }; return mutationOptions; }; 406 406 407 407 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 408 408 - createQueryKey("multipartRequest", options) 408 408 + createQueryKey('multipartRequest', options) 409 409 ]; 410 410 411 411 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 432 432 }; return mutationOptions; }; 433 433 434 434 export const multipartResponseQueryKey = (options?: Options) => [ 435 435 - createQueryKey("multipartResponse", options) 435 435 + createQueryKey('multipartResponse', options) 436 436 ]; 437 437 438 438 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 448 448 }); }; 449 449 450 450 export const dummyAQueryKey = (options?: Options) => [ 451 451 - createQueryKey("dummyA", options) 451 451 + createQueryKey('dummyA', options) 452 452 ]; 453 453 454 454 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 464 464 }); }; 465 465 466 466 export const dummyBQueryKey = (options?: Options) => [ 467 467 - createQueryKey("dummyB", options) 467 467 + createQueryKey('dummyB', options) 468 468 ]; 469 469 470 470 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 480 480 }); }; 481 481 482 482 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 483 483 - createQueryKey("callWithNoContentResponse", options) 483 483 + createQueryKey('callWithNoContentResponse', options) 484 484 ]; 485 485 486 486 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 496 496 }); }; 497 497 498 498 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 499 499 - createQueryKey("callWithResponseAndNoContentResponse", options) 499 499 + createQueryKey('callWithResponseAndNoContentResponse', options) 500 500 ]; 501 501 502 502 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 512 512 }); }; 513 513 514 514 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 515 515 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 515 515 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 516 516 ]; 517 517 518 518 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({ ··· 561 561 }; return mutationOptions; }; 562 562 563 563 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 564 564 - createQueryKey("callWithParameters", options) 564 564 + createQueryKey('callWithParameters', options) 565 565 ]; 566 566 567 567 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 606 606 }; 607 607 608 608 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 609 609 - createQueryKey("callWithParameters", options, true) 609 609 + createQueryKey('callWithParameters', options, true) 610 610 ]; 611 611 612 612 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 614 614 { 615 615 queryFn: async ({ pageParam, queryKey }) => { 616 616 // @ts-ignore 617 617 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 617 617 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 618 618 query: { 619 619 cursor: pageParam 620 620 } ··· 642 642 }; return mutationOptions; }; 643 643 644 644 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 645 645 - createQueryKey("callWithWeirdParameterNames", options) 645 645 + createQueryKey('callWithWeirdParameterNames', options) 646 646 ]; 647 647 648 648 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 669 669 }; return mutationOptions; }; 670 670 671 671 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 672 672 - createQueryKey("getCallWithOptionalParam", options) 672 672 + createQueryKey('getCallWithOptionalParam', options) 673 673 ]; 674 674 675 675 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 685 685 }); }; 686 686 687 687 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 688 688 - createQueryKey("getCallWithOptionalParam", options, true) 688 688 + createQueryKey('getCallWithOptionalParam', options, true) 689 689 ]; 690 690 691 691 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 693 693 { 694 694 queryFn: async ({ pageParam, queryKey }) => { 695 695 // @ts-ignore 696 696 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 696 696 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 697 697 query: { 698 698 page: pageParam 699 699 } ··· 710 710 }); }; 711 711 712 712 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 713 713 - createQueryKey("postCallWithOptionalParam", options) 713 713 + createQueryKey('postCallWithOptionalParam', options) 714 714 ]; 715 715 716 716 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 726 726 }); }; 727 727 728 728 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 729 729 - createQueryKey("postCallWithOptionalParam", options, true) 729 729 + createQueryKey('postCallWithOptionalParam', options, true) 730 730 ]; 731 731 732 732 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 734 734 { 735 735 queryFn: async ({ pageParam, queryKey }) => { 736 736 // @ts-ignore 737 737 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 737 737 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 738 738 body: { 739 739 offset: pageParam 740 740 } ··· 762 762 }; return mutationOptions; }; 763 763 764 764 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 765 765 - createQueryKey("postApiVbyApiVersionRequestBody", options) 765 765 + createQueryKey('postApiVbyApiVersionRequestBody', options) 766 766 ]; 767 767 768 768 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 789 789 }; return mutationOptions; }; 790 790 791 791 export const callWithResponseQueryKey = (options?: Options) => [ 792 792 - createQueryKey("callWithResponse", options) 792 792 + createQueryKey('callWithResponse', options) 793 793 ]; 794 794 795 795 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 805 805 }); }; 806 806 807 807 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 808 808 - createQueryKey("callWithDuplicateResponses", options) 808 808 + createQueryKey('callWithDuplicateResponses', options) 809 809 ]; 810 810 811 811 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 843 843 }; return mutationOptions; }; 844 844 845 845 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 846 846 - createQueryKey("apiVVersionOdataControllerCount", options) 846 846 + createQueryKey('apiVVersionOdataControllerCount', options) 847 847 ]; 848 848 849 849 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 859 859 }); }; 860 860 861 861 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("getCallWithoutParametersAndResponse", options) 862 862 + createQueryKey('getCallWithoutParametersAndResponse', options) 863 863 ]; 864 864 865 865 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 889 889 - createQueryKey("postCallWithoutParametersAndResponse", options) 889 889 + createQueryKey('postCallWithoutParametersAndResponse', options) 890 890 ]; 891 891 892 892 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 935 935 }; return mutationOptions; }; 936 936 937 937 export const typesQueryKey = (options: Options<TypesData>) => [ 938 938 - createQueryKey("types", options) 938 938 + createQueryKey('types', options) 939 939 ]; 940 940 941 941 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 951 951 }); }; 952 952 953 953 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 954 954 - createQueryKey("uploadFile", options) 954 954 + createQueryKey('uploadFile', options) 955 955 ]; 956 956 957 957 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts

reviewed

··· 34 34 }; 35 35 36 36 export const exportQueryKey = (options?: Options) => [ 37 37 - createQueryKey("export", options) 37 37 + createQueryKey('export', options) 38 38 ]; 39 39 40 40 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 50 50 }); }; 51 51 52 52 export const importQueryKey = (options: Options<ImportData>) => [ 53 53 - createQueryKey("import", options) 53 53 + createQueryKey('import', options) 54 54 ]; 55 55 56 56 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 77 77 }; return mutationOptions; }; 78 78 79 79 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 80 80 - createQueryKey("apiVVersionOdataControllerCount", options) 80 80 + createQueryKey('apiVVersionOdataControllerCount', options) 81 81 ]; 82 82 83 83 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 93 93 }); }; 94 94 95 95 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 96 96 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 96 96 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 97 97 ]; 98 98 99 99 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 109 109 }); }; 110 110 111 111 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 112 112 - createQueryKey("getCallWithoutParametersAndResponse", options) 112 112 + createQueryKey('getCallWithoutParametersAndResponse', options) 113 113 ]; 114 114 115 115 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 136 136 }; return mutationOptions; }; 137 137 138 138 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 139 139 - createQueryKey("postCallWithoutParametersAndResponse", options) 139 139 + createQueryKey('postCallWithoutParametersAndResponse', options) 140 140 ]; 141 141 142 142 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 196 196 }; return mutationOptions; }; 197 197 198 198 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 199 199 - createQueryKey("callWithDescriptions", options) 199 199 + createQueryKey('callWithDescriptions', options) 200 200 ]; 201 201 202 202 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 223 223 }; return mutationOptions; }; 224 224 225 225 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 226 226 - createQueryKey("deprecatedCall", options) 226 226 + createQueryKey('deprecatedCall', options) 227 227 ]; 228 228 229 229 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 250 250 }; return mutationOptions; }; 251 251 252 252 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 253 253 - createQueryKey("callWithParameters", options) 253 253 + createQueryKey('callWithParameters', options) 254 254 ]; 255 255 256 256 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 295 295 }; 296 296 297 297 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 298 298 - createQueryKey("callWithParameters", options, true) 298 298 + createQueryKey('callWithParameters', options, true) 299 299 ]; 300 300 301 301 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 303 303 { 304 304 queryFn: async ({ pageParam, queryKey }) => { 305 305 // @ts-ignore 306 306 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 306 306 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 307 307 query: { 308 308 cursor: pageParam 309 309 } ··· 331 331 }; return mutationOptions; }; 332 332 333 333 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 334 334 - createQueryKey("callWithWeirdParameterNames", options) 334 334 + createQueryKey('callWithWeirdParameterNames', options) 335 335 ]; 336 336 337 337 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 358 358 }; return mutationOptions; }; 359 359 360 360 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 361 361 - createQueryKey("getCallWithOptionalParam", options) 361 361 + createQueryKey('getCallWithOptionalParam', options) 362 362 ]; 363 363 364 364 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 374 374 }); }; 375 375 376 376 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 377 377 - createQueryKey("getCallWithOptionalParam", options, true) 377 377 + createQueryKey('getCallWithOptionalParam', options, true) 378 378 ]; 379 379 380 380 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 382 382 { 383 383 queryFn: async ({ pageParam, queryKey }) => { 384 384 // @ts-ignore 385 385 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 385 385 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 386 386 query: { 387 387 page: pageParam 388 388 } ··· 399 399 }); }; 400 400 401 401 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 402 402 - createQueryKey("postCallWithOptionalParam", options) 402 402 + createQueryKey('postCallWithOptionalParam', options) 403 403 ]; 404 404 405 405 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 415 415 }); }; 416 416 417 417 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 418 418 - createQueryKey("postCallWithOptionalParam", options, true) 418 418 + createQueryKey('postCallWithOptionalParam', options, true) 419 419 ]; 420 420 421 421 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<PostCallWithOptionalParamError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 423 423 { 424 424 queryFn: async ({ pageParam, queryKey }) => { 425 425 // @ts-ignore 426 426 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 426 426 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 427 427 body: { 428 428 offset: pageParam 429 429 } ··· 451 451 }; return mutationOptions; }; 452 452 453 453 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 454 454 - createQueryKey("postApiVbyApiVersionRequestBody", options) 454 454 + createQueryKey('postApiVbyApiVersionRequestBody', options) 455 455 ]; 456 456 457 457 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 478 478 }; return mutationOptions; }; 479 479 480 480 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 481 481 - createQueryKey("postApiVbyApiVersionFormData", options) 481 481 + createQueryKey('postApiVbyApiVersionFormData', options) 482 482 ]; 483 483 484 484 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 505 505 }; return mutationOptions; }; 506 506 507 507 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 508 508 - createQueryKey("callWithDefaultParameters", options) 508 508 + createQueryKey('callWithDefaultParameters', options) 509 509 ]; 510 510 511 511 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 521 521 }); }; 522 522 523 523 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 524 524 - createQueryKey("callWithDefaultOptionalParameters", options) 524 524 + createQueryKey('callWithDefaultOptionalParameters', options) 525 525 ]; 526 526 527 527 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 559 559 }; return mutationOptions; }; 560 560 561 561 export const duplicateNameQueryKey = (options?: Options) => [ 562 562 - createQueryKey("duplicateName", options) 562 562 + createQueryKey('duplicateName', options) 563 563 ]; 564 564 565 565 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 575 575 }); }; 576 576 577 577 export const duplicateName1QueryKey = (options?: Options) => [ 578 578 - createQueryKey("duplicateName1", options) 578 578 + createQueryKey('duplicateName1', options) 579 579 ]; 580 580 581 581 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 624 624 }; return mutationOptions; }; 625 625 626 626 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 627 627 - createQueryKey("callWithNoContentResponse", options) 627 627 + createQueryKey('callWithNoContentResponse', options) 628 628 ]; 629 629 630 630 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 640 640 }); }; 641 641 642 642 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 643 643 - createQueryKey("callWithResponseAndNoContentResponse", options) 643 643 + createQueryKey('callWithResponseAndNoContentResponse', options) 644 644 ]; 645 645 646 646 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 656 656 }); }; 657 657 658 658 export const dummyAQueryKey = (options?: Options) => [ 659 659 - createQueryKey("dummyA", options) 659 659 + createQueryKey('dummyA', options) 660 660 ]; 661 661 662 662 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 672 672 }); }; 673 673 674 674 export const dummyBQueryKey = (options?: Options) => [ 675 675 - createQueryKey("dummyB", options) 675 675 + createQueryKey('dummyB', options) 676 676 ]; 677 677 678 678 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 688 688 }); }; 689 689 690 690 export const callWithResponseQueryKey = (options?: Options) => [ 691 691 - createQueryKey("callWithResponse", options) 691 691 + createQueryKey('callWithResponse', options) 692 692 ]; 693 693 694 694 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 704 704 }); }; 705 705 706 706 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 707 707 - createQueryKey("callWithDuplicateResponses", options) 707 707 + createQueryKey('callWithDuplicateResponses', options) 708 708 ]; 709 709 710 710 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 742 742 }; return mutationOptions; }; 743 743 744 744 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 745 745 - createQueryKey("collectionFormat", options) 745 745 + createQueryKey('collectionFormat', options) 746 746 ]; 747 747 748 748 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 758 758 }); }; 759 759 760 760 export const typesQueryKey = (options: Options<TypesData>) => [ 761 761 - createQueryKey("types", options) 761 761 + createQueryKey('types', options) 762 762 ]; 763 763 764 764 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 774 774 }); }; 775 775 776 776 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 777 777 - createQueryKey("uploadFile", options) 777 777 + createQueryKey('uploadFile', options) 778 778 ]; 779 779 780 780 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 801 801 }; return mutationOptions; }; 802 802 803 803 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 804 804 - createQueryKey("fileResponse", options) 804 804 + createQueryKey('fileResponse', options) 805 805 ]; 806 806 807 807 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 817 817 }); }; 818 818 819 819 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 820 820 - createQueryKey("complexTypes", options) 820 820 + createQueryKey('complexTypes', options) 821 821 ]; 822 822 823 823 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 833 833 }); }; 834 834 835 835 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 836 836 - createQueryKey("multipartRequest", options) 836 836 + createQueryKey('multipartRequest', options) 837 837 ]; 838 838 839 839 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 860 860 }; return mutationOptions; }; 861 861 862 862 export const multipartResponseQueryKey = (options?: Options) => [ 863 863 - createQueryKey("multipartResponse", options) 863 863 + createQueryKey('multipartResponse', options) 864 864 ]; 865 865 866 866 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 887 887 }; return mutationOptions; }; 888 888 889 889 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 890 890 - createQueryKey("callWithResultFromHeader", options) 890 890 + createQueryKey('callWithResultFromHeader', options) 891 891 ]; 892 892 893 893 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 914 914 }; return mutationOptions; }; 915 915 916 916 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 917 917 - createQueryKey("testErrorCode", options) 917 917 + createQueryKey('testErrorCode', options) 918 918 ]; 919 919 920 920 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 941 941 }; return mutationOptions; }; 942 942 943 943 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 944 944 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 944 944 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 945 945 ]; 946 946 947 947 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const exportQueryKey = (options?: Options) => [ 36 36 - createQueryKey("export", options) 36 36 + createQueryKey('export', options) 37 37 ]; 38 38 39 39 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const importQueryKey = (options: Options<ImportData>) => [ 52 52 - createQueryKey("import", options) 52 52 + createQueryKey('import', options) 53 53 ]; 54 54 55 55 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 79 79 - createQueryKey("apiVVersionOdataControllerCount", options) 79 79 + createQueryKey('apiVVersionOdataControllerCount', options) 80 80 ]; 81 81 82 82 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 95 95 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 95 95 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 96 96 ]; 97 97 98 98 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 108 108 }); }; 109 109 110 110 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 111 111 - createQueryKey("getCallWithoutParametersAndResponse", options) 111 111 + createQueryKey('getCallWithoutParametersAndResponse', options) 112 112 ]; 113 113 114 114 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 135 135 }; return mutationOptions; }; 136 136 137 137 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 138 138 - createQueryKey("postCallWithoutParametersAndResponse", options) 138 138 + createQueryKey('postCallWithoutParametersAndResponse', options) 139 139 ]; 140 140 141 141 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 195 195 }; return mutationOptions; }; 196 196 197 197 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 198 198 - createQueryKey("callWithDescriptions", options) 198 198 + createQueryKey('callWithDescriptions', options) 199 199 ]; 200 200 201 201 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 222 222 }; return mutationOptions; }; 223 223 224 224 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 225 225 - createQueryKey("deprecatedCall", options) 225 225 + createQueryKey('deprecatedCall', options) 226 226 ]; 227 227 228 228 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 249 249 }; return mutationOptions; }; 250 250 251 251 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 252 252 - createQueryKey("callWithParameters", options) 252 252 + createQueryKey('callWithParameters', options) 253 253 ]; 254 254 255 255 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 294 294 }; 295 295 296 296 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 297 297 - createQueryKey("callWithParameters", options, true) 297 297 + createQueryKey('callWithParameters', options, true) 298 298 ]; 299 299 300 300 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 302 302 { 303 303 queryFn: async ({ pageParam, queryKey }) => { 304 304 // @ts-ignore 305 305 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 305 305 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 306 306 query: { 307 307 cursor: pageParam 308 308 } ··· 330 330 }; return mutationOptions; }; 331 331 332 332 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 333 333 - createQueryKey("callWithWeirdParameterNames", options) 333 333 + createQueryKey('callWithWeirdParameterNames', options) 334 334 ]; 335 335 336 336 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 357 357 }; return mutationOptions; }; 358 358 359 359 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 360 360 - createQueryKey("getCallWithOptionalParam", options) 360 360 + createQueryKey('getCallWithOptionalParam', options) 361 361 ]; 362 362 363 363 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 373 373 }); }; 374 374 375 375 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 376 376 - createQueryKey("getCallWithOptionalParam", options, true) 376 376 + createQueryKey('getCallWithOptionalParam', options, true) 377 377 ]; 378 378 379 379 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 381 381 { 382 382 queryFn: async ({ pageParam, queryKey }) => { 383 383 // @ts-ignore 384 384 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 384 384 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 385 385 query: { 386 386 page: pageParam 387 387 } ··· 398 398 }); }; 399 399 400 400 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 401 401 - createQueryKey("postCallWithOptionalParam", options) 401 401 + createQueryKey('postCallWithOptionalParam', options) 402 402 ]; 403 403 404 404 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 414 414 }); }; 415 415 416 416 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 417 417 - createQueryKey("postCallWithOptionalParam", options, true) 417 417 + createQueryKey('postCallWithOptionalParam', options, true) 418 418 ]; 419 419 420 420 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 422 422 { 423 423 queryFn: async ({ pageParam, queryKey }) => { 424 424 // @ts-ignore 425 425 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 425 425 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 426 426 body: { 427 427 offset: pageParam 428 428 } ··· 450 450 }; return mutationOptions; }; 451 451 452 452 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 453 453 - createQueryKey("postApiVbyApiVersionRequestBody", options) 453 453 + createQueryKey('postApiVbyApiVersionRequestBody', options) 454 454 ]; 455 455 456 456 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 477 477 }; return mutationOptions; }; 478 478 479 479 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 480 480 - createQueryKey("postApiVbyApiVersionFormData", options) 480 480 + createQueryKey('postApiVbyApiVersionFormData', options) 481 481 ]; 482 482 483 483 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 504 504 }; return mutationOptions; }; 505 505 506 506 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 507 507 - createQueryKey("callWithDefaultParameters", options) 507 507 + createQueryKey('callWithDefaultParameters', options) 508 508 ]; 509 509 510 510 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 520 520 }); }; 521 521 522 522 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 523 523 - createQueryKey("callWithDefaultOptionalParameters", options) 523 523 + createQueryKey('callWithDefaultOptionalParameters', options) 524 524 ]; 525 525 526 526 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 558 558 }; return mutationOptions; }; 559 559 560 560 export const duplicateNameQueryKey = (options?: Options) => [ 561 561 - createQueryKey("duplicateName", options) 561 561 + createQueryKey('duplicateName', options) 562 562 ]; 563 563 564 564 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 574 574 }); }; 575 575 576 576 export const duplicateName1QueryKey = (options?: Options) => [ 577 577 - createQueryKey("duplicateName1", options) 577 577 + createQueryKey('duplicateName1', options) 578 578 ]; 579 579 580 580 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 623 623 }; return mutationOptions; }; 624 624 625 625 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 626 626 - createQueryKey("callWithNoContentResponse", options) 626 626 + createQueryKey('callWithNoContentResponse', options) 627 627 ]; 628 628 629 629 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 639 639 }); }; 640 640 641 641 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 642 642 - createQueryKey("callWithResponseAndNoContentResponse", options) 642 642 + createQueryKey('callWithResponseAndNoContentResponse', options) 643 643 ]; 644 644 645 645 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 655 655 }); }; 656 656 657 657 export const dummyAQueryKey = (options?: Options) => [ 658 658 - createQueryKey("dummyA", options) 658 658 + createQueryKey('dummyA', options) 659 659 ]; 660 660 661 661 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 671 671 }); }; 672 672 673 673 export const dummyBQueryKey = (options?: Options) => [ 674 674 - createQueryKey("dummyB", options) 674 674 + createQueryKey('dummyB', options) 675 675 ]; 676 676 677 677 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 687 687 }); }; 688 688 689 689 export const callWithResponseQueryKey = (options?: Options) => [ 690 690 - createQueryKey("callWithResponse", options) 690 690 + createQueryKey('callWithResponse', options) 691 691 ]; 692 692 693 693 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 703 703 }); }; 704 704 705 705 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 706 706 - createQueryKey("callWithDuplicateResponses", options) 706 706 + createQueryKey('callWithDuplicateResponses', options) 707 707 ]; 708 708 709 709 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 741 741 }; return mutationOptions; }; 742 742 743 743 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 744 744 - createQueryKey("collectionFormat", options) 744 744 + createQueryKey('collectionFormat', options) 745 745 ]; 746 746 747 747 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 757 757 }); }; 758 758 759 759 export const typesQueryKey = (options: Options<TypesData>) => [ 760 760 - createQueryKey("types", options) 760 760 + createQueryKey('types', options) 761 761 ]; 762 762 763 763 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 773 773 }); }; 774 774 775 775 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 776 776 - createQueryKey("uploadFile", options) 776 776 + createQueryKey('uploadFile', options) 777 777 ]; 778 778 779 779 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 800 800 }; return mutationOptions; }; 801 801 802 802 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 803 803 - createQueryKey("fileResponse", options) 803 803 + createQueryKey('fileResponse', options) 804 804 ]; 805 805 806 806 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 816 816 }); }; 817 817 818 818 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 819 819 - createQueryKey("complexTypes", options) 819 819 + createQueryKey('complexTypes', options) 820 820 ]; 821 821 822 822 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 832 832 }); }; 833 833 834 834 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 835 835 - createQueryKey("multipartRequest", options) 835 835 + createQueryKey('multipartRequest', options) 836 836 ]; 837 837 838 838 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 859 859 }; return mutationOptions; }; 860 860 861 861 export const multipartResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("multipartResponse", options) 862 862 + createQueryKey('multipartResponse', options) 863 863 ]; 864 864 865 865 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 889 889 - createQueryKey("callWithResultFromHeader", options) 889 889 + createQueryKey('callWithResultFromHeader', options) 890 890 ]; 891 891 892 892 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 913 913 }; return mutationOptions; }; 914 914 915 915 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 916 916 - createQueryKey("testErrorCode", options) 916 916 + createQueryKey('testErrorCode', options) 917 917 ]; 918 918 919 919 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 940 940 }; return mutationOptions; }; 941 941 942 942 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 943 943 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 943 943 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 944 944 ]; 945 945 946 946 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 36 36 - createQueryKey("collectionFormat", options) 36 36 + createQueryKey('collectionFormat', options) 37 37 ]; 38 38 39 39 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 52 52 - createQueryKey("complexTypes", options) 52 52 + createQueryKey('complexTypes', options) 53 53 ]; 54 54 55 55 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const exportQueryKey = (options?: Options) => [ 79 79 - createQueryKey("export", options) 79 79 + createQueryKey('export', options) 80 80 ]; 81 81 82 82 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const importQueryKey = (options: Options<ImportData>) => [ 95 95 - createQueryKey("import", options) 95 95 + createQueryKey('import', options) 96 96 ]; 97 97 98 98 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 119 119 }; return mutationOptions; }; 120 120 121 121 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 122 122 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 122 122 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 123 123 ]; 124 124 125 125 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 135 135 }); }; 136 136 137 137 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 138 138 - createQueryKey("callWithDefaultParameters", options) 138 138 + createQueryKey('callWithDefaultParameters', options) 139 139 ]; 140 140 141 141 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 151 151 }); }; 152 152 153 153 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 154 154 - createQueryKey("callWithDefaultOptionalParameters", options) 154 154 + createQueryKey('callWithDefaultOptionalParameters', options) 155 155 ]; 156 156 157 157 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 189 189 }; return mutationOptions; }; 190 190 191 191 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 192 192 - createQueryKey("deprecatedCall", options) 192 192 + createQueryKey('deprecatedCall', options) 193 193 ]; 194 194 195 195 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 216 216 }; return mutationOptions; }; 217 217 218 218 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 219 219 - createQueryKey("callWithDescriptions", options) 219 219 + createQueryKey('callWithDescriptions', options) 220 220 ]; 221 221 222 222 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 243 243 }; return mutationOptions; }; 244 244 245 245 export const duplicateNameQueryKey = (options?: Options) => [ 246 246 - createQueryKey("duplicateName", options) 246 246 + createQueryKey('duplicateName', options) 247 247 ]; 248 248 249 249 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 259 259 }); }; 260 260 261 261 export const duplicateName1QueryKey = (options?: Options) => [ 262 262 - createQueryKey("duplicateName1", options) 262 262 + createQueryKey('duplicateName1', options) 263 263 ]; 264 264 265 265 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 308 308 }; return mutationOptions; }; 309 309 310 310 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 311 311 - createQueryKey("testErrorCode", options) 311 311 + createQueryKey('testErrorCode', options) 312 312 ]; 313 313 314 314 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 335 335 }; return mutationOptions; }; 336 336 337 337 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 338 338 - createQueryKey("fileResponse", options) 338 338 + createQueryKey('fileResponse', options) 339 339 ]; 340 340 341 341 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 351 351 }); }; 352 352 353 353 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 354 354 - createQueryKey("postApiVbyApiVersionFormData", options) 354 354 + createQueryKey('postApiVbyApiVersionFormData', options) 355 355 ]; 356 356 357 357 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 378 378 }; return mutationOptions; }; 379 379 380 380 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 381 381 - createQueryKey("callWithResultFromHeader", options) 381 381 + createQueryKey('callWithResultFromHeader', options) 382 382 ]; 383 383 384 384 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 405 405 }; return mutationOptions; }; 406 406 407 407 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 408 408 - createQueryKey("multipartRequest", options) 408 408 + createQueryKey('multipartRequest', options) 409 409 ]; 410 410 411 411 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 432 432 }; return mutationOptions; }; 433 433 434 434 export const multipartResponseQueryKey = (options?: Options) => [ 435 435 - createQueryKey("multipartResponse", options) 435 435 + createQueryKey('multipartResponse', options) 436 436 ]; 437 437 438 438 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 448 448 }); }; 449 449 450 450 export const dummyAQueryKey = (options?: Options) => [ 451 451 - createQueryKey("dummyA", options) 451 451 + createQueryKey('dummyA', options) 452 452 ]; 453 453 454 454 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 464 464 }); }; 465 465 466 466 export const dummyBQueryKey = (options?: Options) => [ 467 467 - createQueryKey("dummyB", options) 467 467 + createQueryKey('dummyB', options) 468 468 ]; 469 469 470 470 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 480 480 }); }; 481 481 482 482 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 483 483 - createQueryKey("callWithNoContentResponse", options) 483 483 + createQueryKey('callWithNoContentResponse', options) 484 484 ]; 485 485 486 486 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 496 496 }); }; 497 497 498 498 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 499 499 - createQueryKey("callWithResponseAndNoContentResponse", options) 499 499 + createQueryKey('callWithResponseAndNoContentResponse', options) 500 500 ]; 501 501 502 502 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 512 512 }); }; 513 513 514 514 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 515 515 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 515 515 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 516 516 ]; 517 517 518 518 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({ ··· 561 561 }; return mutationOptions; }; 562 562 563 563 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 564 564 - createQueryKey("callWithParameters", options) 564 564 + createQueryKey('callWithParameters', options) 565 565 ]; 566 566 567 567 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 606 606 }; 607 607 608 608 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 609 609 - createQueryKey("callWithParameters", options, true) 609 609 + createQueryKey('callWithParameters', options, true) 610 610 ]; 611 611 612 612 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 614 614 { 615 615 queryFn: async ({ pageParam, queryKey }) => { 616 616 // @ts-ignore 617 617 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 617 617 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 618 618 query: { 619 619 cursor: pageParam 620 620 } ··· 642 642 }; return mutationOptions; }; 643 643 644 644 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 645 645 - createQueryKey("callWithWeirdParameterNames", options) 645 645 + createQueryKey('callWithWeirdParameterNames', options) 646 646 ]; 647 647 648 648 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 669 669 }; return mutationOptions; }; 670 670 671 671 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 672 672 - createQueryKey("getCallWithOptionalParam", options) 672 672 + createQueryKey('getCallWithOptionalParam', options) 673 673 ]; 674 674 675 675 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 685 685 }); }; 686 686 687 687 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 688 688 - createQueryKey("getCallWithOptionalParam", options, true) 688 688 + createQueryKey('getCallWithOptionalParam', options, true) 689 689 ]; 690 690 691 691 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 693 693 { 694 694 queryFn: async ({ pageParam, queryKey }) => { 695 695 // @ts-ignore 696 696 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 696 696 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 697 697 query: { 698 698 page: pageParam 699 699 } ··· 710 710 }); }; 711 711 712 712 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 713 713 - createQueryKey("postCallWithOptionalParam", options) 713 713 + createQueryKey('postCallWithOptionalParam', options) 714 714 ]; 715 715 716 716 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 726 726 }); }; 727 727 728 728 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 729 729 - createQueryKey("postCallWithOptionalParam", options, true) 729 729 + createQueryKey('postCallWithOptionalParam', options, true) 730 730 ]; 731 731 732 732 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 734 734 { 735 735 queryFn: async ({ pageParam, queryKey }) => { 736 736 // @ts-ignore 737 737 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 737 737 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 738 738 body: { 739 739 offset: pageParam 740 740 } ··· 762 762 }; return mutationOptions; }; 763 763 764 764 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 765 765 - createQueryKey("postApiVbyApiVersionRequestBody", options) 765 765 + createQueryKey('postApiVbyApiVersionRequestBody', options) 766 766 ]; 767 767 768 768 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 789 789 }; return mutationOptions; }; 790 790 791 791 export const callWithResponseQueryKey = (options?: Options) => [ 792 792 - createQueryKey("callWithResponse", options) 792 792 + createQueryKey('callWithResponse', options) 793 793 ]; 794 794 795 795 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 805 805 }); }; 806 806 807 807 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 808 808 - createQueryKey("callWithDuplicateResponses", options) 808 808 + createQueryKey('callWithDuplicateResponses', options) 809 809 ]; 810 810 811 811 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 843 843 }; return mutationOptions; }; 844 844 845 845 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 846 846 - createQueryKey("apiVVersionOdataControllerCount", options) 846 846 + createQueryKey('apiVVersionOdataControllerCount', options) 847 847 ]; 848 848 849 849 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 859 859 }); }; 860 860 861 861 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("getCallWithoutParametersAndResponse", options) 862 862 + createQueryKey('getCallWithoutParametersAndResponse', options) 863 863 ]; 864 864 865 865 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 889 889 - createQueryKey("postCallWithoutParametersAndResponse", options) 889 889 + createQueryKey('postCallWithoutParametersAndResponse', options) 890 890 ]; 891 891 892 892 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 935 935 }; return mutationOptions; }; 936 936 937 937 export const typesQueryKey = (options: Options<TypesData>) => [ 938 938 - createQueryKey("types", options) 938 938 + createQueryKey('types', options) 939 939 ]; 940 940 941 941 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 951 951 }); }; 952 952 953 953 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 954 954 - createQueryKey("uploadFile", options) 954 954 + createQueryKey('uploadFile', options) 955 955 ]; 956 956 957 957 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts

reviewed

··· 34 34 }; 35 35 36 36 export const exportQueryKey = (options?: Options) => [ 37 37 - createQueryKey("export", options) 37 37 + createQueryKey('export', options) 38 38 ]; 39 39 40 40 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 50 50 }); }; 51 51 52 52 export const importQueryKey = (options: Options<ImportData>) => [ 53 53 - createQueryKey("import", options) 53 53 + createQueryKey('import', options) 54 54 ]; 55 55 56 56 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 77 77 }; return mutationOptions; }; 78 78 79 79 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 80 80 - createQueryKey("apiVVersionOdataControllerCount", options) 80 80 + createQueryKey('apiVVersionOdataControllerCount', options) 81 81 ]; 82 82 83 83 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 93 93 }); }; 94 94 95 95 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 96 96 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 96 96 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 97 97 ]; 98 98 99 99 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 109 109 }); }; 110 110 111 111 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 112 112 - createQueryKey("getCallWithoutParametersAndResponse", options) 112 112 + createQueryKey('getCallWithoutParametersAndResponse', options) 113 113 ]; 114 114 115 115 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 136 136 }; return mutationOptions; }; 137 137 138 138 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 139 139 - createQueryKey("postCallWithoutParametersAndResponse", options) 139 139 + createQueryKey('postCallWithoutParametersAndResponse', options) 140 140 ]; 141 141 142 142 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 196 196 }; return mutationOptions; }; 197 197 198 198 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 199 199 - createQueryKey("callWithDescriptions", options) 199 199 + createQueryKey('callWithDescriptions', options) 200 200 ]; 201 201 202 202 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 223 223 }; return mutationOptions; }; 224 224 225 225 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 226 226 - createQueryKey("deprecatedCall", options) 226 226 + createQueryKey('deprecatedCall', options) 227 227 ]; 228 228 229 229 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 250 250 }; return mutationOptions; }; 251 251 252 252 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 253 253 - createQueryKey("callWithParameters", options) 253 253 + createQueryKey('callWithParameters', options) 254 254 ]; 255 255 256 256 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 295 295 }; 296 296 297 297 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 298 298 - createQueryKey("callWithParameters", options, true) 298 298 + createQueryKey('callWithParameters', options, true) 299 299 ]; 300 300 301 301 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 303 303 { 304 304 queryFn: async ({ pageParam, queryKey }) => { 305 305 // @ts-ignore 306 306 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 306 306 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 307 307 query: { 308 308 cursor: pageParam 309 309 } ··· 331 331 }; return mutationOptions; }; 332 332 333 333 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 334 334 - createQueryKey("callWithWeirdParameterNames", options) 334 334 + createQueryKey('callWithWeirdParameterNames', options) 335 335 ]; 336 336 337 337 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 358 358 }; return mutationOptions; }; 359 359 360 360 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 361 361 - createQueryKey("getCallWithOptionalParam", options) 361 361 + createQueryKey('getCallWithOptionalParam', options) 362 362 ]; 363 363 364 364 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 374 374 }); }; 375 375 376 376 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 377 377 - createQueryKey("getCallWithOptionalParam", options, true) 377 377 + createQueryKey('getCallWithOptionalParam', options, true) 378 378 ]; 379 379 380 380 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, AxiosError<DefaultError>, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 382 382 { 383 383 queryFn: async ({ pageParam, queryKey }) => { 384 384 // @ts-ignore 385 385 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 385 385 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 386 386 query: { 387 387 page: pageParam 388 388 } ··· 399 399 }); }; 400 400 401 401 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 402 402 - createQueryKey("postCallWithOptionalParam", options) 402 402 + createQueryKey('postCallWithOptionalParam', options) 403 403 ]; 404 404 405 405 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 415 415 }); }; 416 416 417 417 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 418 418 - createQueryKey("postCallWithOptionalParam", options, true) 418 418 + createQueryKey('postCallWithOptionalParam', options, true) 419 419 ]; 420 420 421 421 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<PostCallWithOptionalParamError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 423 423 { 424 424 queryFn: async ({ pageParam, queryKey }) => { 425 425 // @ts-ignore 426 426 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 426 426 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 427 427 body: { 428 428 offset: pageParam 429 429 } ··· 451 451 }; return mutationOptions; }; 452 452 453 453 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 454 454 - createQueryKey("postApiVbyApiVersionRequestBody", options) 454 454 + createQueryKey('postApiVbyApiVersionRequestBody', options) 455 455 ]; 456 456 457 457 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 478 478 }; return mutationOptions; }; 479 479 480 480 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 481 481 - createQueryKey("postApiVbyApiVersionFormData", options) 481 481 + createQueryKey('postApiVbyApiVersionFormData', options) 482 482 ]; 483 483 484 484 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 505 505 }; return mutationOptions; }; 506 506 507 507 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 508 508 - createQueryKey("callWithDefaultParameters", options) 508 508 + createQueryKey('callWithDefaultParameters', options) 509 509 ]; 510 510 511 511 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 521 521 }); }; 522 522 523 523 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 524 524 - createQueryKey("callWithDefaultOptionalParameters", options) 524 524 + createQueryKey('callWithDefaultOptionalParameters', options) 525 525 ]; 526 526 527 527 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 559 559 }; return mutationOptions; }; 560 560 561 561 export const duplicateNameQueryKey = (options?: Options) => [ 562 562 - createQueryKey("duplicateName", options) 562 562 + createQueryKey('duplicateName', options) 563 563 ]; 564 564 565 565 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 575 575 }); }; 576 576 577 577 export const duplicateName1QueryKey = (options?: Options) => [ 578 578 - createQueryKey("duplicateName1", options) 578 578 + createQueryKey('duplicateName1', options) 579 579 ]; 580 580 581 581 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 624 624 }; return mutationOptions; }; 625 625 626 626 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 627 627 - createQueryKey("callWithNoContentResponse", options) 627 627 + createQueryKey('callWithNoContentResponse', options) 628 628 ]; 629 629 630 630 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 640 640 }); }; 641 641 642 642 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 643 643 - createQueryKey("callWithResponseAndNoContentResponse", options) 643 643 + createQueryKey('callWithResponseAndNoContentResponse', options) 644 644 ]; 645 645 646 646 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 656 656 }); }; 657 657 658 658 export const dummyAQueryKey = (options?: Options) => [ 659 659 - createQueryKey("dummyA", options) 659 659 + createQueryKey('dummyA', options) 660 660 ]; 661 661 662 662 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 672 672 }); }; 673 673 674 674 export const dummyBQueryKey = (options?: Options) => [ 675 675 - createQueryKey("dummyB", options) 675 675 + createQueryKey('dummyB', options) 676 676 ]; 677 677 678 678 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 688 688 }); }; 689 689 690 690 export const callWithResponseQueryKey = (options?: Options) => [ 691 691 - createQueryKey("callWithResponse", options) 691 691 + createQueryKey('callWithResponse', options) 692 692 ]; 693 693 694 694 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 704 704 }); }; 705 705 706 706 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 707 707 - createQueryKey("callWithDuplicateResponses", options) 707 707 + createQueryKey('callWithDuplicateResponses', options) 708 708 ]; 709 709 710 710 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 742 742 }; return mutationOptions; }; 743 743 744 744 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 745 745 - createQueryKey("collectionFormat", options) 745 745 + createQueryKey('collectionFormat', options) 746 746 ]; 747 747 748 748 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 758 758 }); }; 759 759 760 760 export const typesQueryKey = (options: Options<TypesData>) => [ 761 761 - createQueryKey("types", options) 761 761 + createQueryKey('types', options) 762 762 ]; 763 763 764 764 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 774 774 }); }; 775 775 776 776 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 777 777 - createQueryKey("uploadFile", options) 777 777 + createQueryKey('uploadFile', options) 778 778 ]; 779 779 780 780 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 801 801 }; return mutationOptions; }; 802 802 803 803 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 804 804 - createQueryKey("fileResponse", options) 804 804 + createQueryKey('fileResponse', options) 805 805 ]; 806 806 807 807 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 817 817 }); }; 818 818 819 819 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 820 820 - createQueryKey("complexTypes", options) 820 820 + createQueryKey('complexTypes', options) 821 821 ]; 822 822 823 823 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 833 833 }); }; 834 834 835 835 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 836 836 - createQueryKey("multipartRequest", options) 836 836 + createQueryKey('multipartRequest', options) 837 837 ]; 838 838 839 839 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 860 860 }; return mutationOptions; }; 861 861 862 862 export const multipartResponseQueryKey = (options?: Options) => [ 863 863 - createQueryKey("multipartResponse", options) 863 863 + createQueryKey('multipartResponse', options) 864 864 ]; 865 865 866 866 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 887 887 }; return mutationOptions; }; 888 888 889 889 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 890 890 - createQueryKey("callWithResultFromHeader", options) 890 890 + createQueryKey('callWithResultFromHeader', options) 891 891 ]; 892 892 893 893 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 914 914 }; return mutationOptions; }; 915 915 916 916 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 917 917 - createQueryKey("testErrorCode", options) 917 917 + createQueryKey('testErrorCode', options) 918 918 ]; 919 919 920 920 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 941 941 }; return mutationOptions; }; 942 942 943 943 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 944 944 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 944 944 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 945 945 ]; 946 946 947 947 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+40 -40

packages/openapi-ts/test/__snapshots__/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts

reviewed

··· 33 33 }; 34 34 35 35 export const exportQueryKey = (options?: Options) => [ 36 36 - createQueryKey("export", options) 36 36 + createQueryKey('export', options) 37 37 ]; 38 38 39 39 export const exportOptions = (options?: Options) => { return queryOptions({ ··· 49 49 }); }; 50 50 51 51 export const importQueryKey = (options: Options<ImportData>) => [ 52 52 - createQueryKey("import", options) 52 52 + createQueryKey('import', options) 53 53 ]; 54 54 55 55 export const importOptions = (options: Options<ImportData>) => { return queryOptions({ ··· 76 76 }; return mutationOptions; }; 77 77 78 78 export const apiVVersionOdataControllerCountQueryKey = (options?: Options) => [ 79 79 - createQueryKey("apiVVersionOdataControllerCount", options) 79 79 + createQueryKey('apiVVersionOdataControllerCount', options) 80 80 ]; 81 81 82 82 export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ ··· 92 92 }); }; 93 93 94 94 export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => [ 95 95 - createQueryKey("getApiVbyApiVersionSimpleOperation", options) 95 95 + createQueryKey('getApiVbyApiVersionSimpleOperation', options) 96 96 ]; 97 97 98 98 export const getApiVbyApiVersionSimpleOperationOptions = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => { return queryOptions({ ··· 108 108 }); }; 109 109 110 110 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 111 111 - createQueryKey("getCallWithoutParametersAndResponse", options) 111 111 + createQueryKey('getCallWithoutParametersAndResponse', options) 112 112 ]; 113 113 114 114 export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 135 135 }; return mutationOptions; }; 136 136 137 137 export const postCallWithoutParametersAndResponseQueryKey = (options?: Options) => [ 138 138 - createQueryKey("postCallWithoutParametersAndResponse", options) 138 138 + createQueryKey('postCallWithoutParametersAndResponse', options) 139 139 ]; 140 140 141 141 export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ ··· 195 195 }; return mutationOptions; }; 196 196 197 197 export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => [ 198 198 - createQueryKey("callWithDescriptions", options) 198 198 + createQueryKey('callWithDescriptions', options) 199 199 ]; 200 200 201 201 export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => { return queryOptions({ ··· 222 222 }; return mutationOptions; }; 223 223 224 224 export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => [ 225 225 - createQueryKey("deprecatedCall", options) 225 225 + createQueryKey('deprecatedCall', options) 226 226 ]; 227 227 228 228 export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => { return queryOptions({ ··· 249 249 }; return mutationOptions; }; 250 250 251 251 export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => [ 252 252 - createQueryKey("callWithParameters", options) 252 252 + createQueryKey('callWithParameters', options) 253 253 ]; 254 254 255 255 export const callWithParametersOptions = (options: Options<CallWithParametersData>) => { return queryOptions({ ··· 294 294 }; 295 295 296 296 export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => [ 297 297 - createQueryKey("callWithParameters", options, true) 297 297 + createQueryKey('callWithParameters', options, true) 298 298 ]; 299 299 300 300 export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<CallWithParametersData>>, string | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 302 302 { 303 303 queryFn: async ({ pageParam, queryKey }) => { 304 304 // @ts-ignore 305 305 - const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 305 305 + const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 306 306 query: { 307 307 cursor: pageParam 308 308 } ··· 330 330 }; return mutationOptions; }; 331 331 332 332 export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => [ 333 333 - createQueryKey("callWithWeirdParameterNames", options) 333 333 + createQueryKey('callWithWeirdParameterNames', options) 334 334 ]; 335 335 336 336 export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => { return queryOptions({ ··· 357 357 }; return mutationOptions; }; 358 358 359 359 export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => [ 360 360 - createQueryKey("getCallWithOptionalParam", options) 360 360 + createQueryKey('getCallWithOptionalParam', options) 361 361 ]; 362 362 363 363 export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => { return queryOptions({ ··· 373 373 }); }; 374 374 375 375 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => [ 376 376 - createQueryKey("getCallWithOptionalParam", options, true) 376 376 + createQueryKey('getCallWithOptionalParam', options, true) 377 377 ]; 378 378 379 379 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => { return infiniteQueryOptions<void, DefaultError, InfiniteData<void>, QueryKey<Options<GetCallWithOptionalParamData>>, number | Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 381 381 { 382 382 queryFn: async ({ pageParam, queryKey }) => { 383 383 // @ts-ignore 384 384 - const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 384 384 + const page: Pick<QueryKey<Options<GetCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 385 385 query: { 386 386 page: pageParam 387 387 } ··· 398 398 }); }; 399 399 400 400 export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => [ 401 401 - createQueryKey("postCallWithOptionalParam", options) 401 401 + createQueryKey('postCallWithOptionalParam', options) 402 402 ]; 403 403 404 404 export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => { return queryOptions({ ··· 414 414 }); }; 415 415 416 416 export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => [ 417 417 - createQueryKey("postCallWithOptionalParam", options, true) 417 417 + createQueryKey('postCallWithOptionalParam', options, true) 418 418 ]; 419 419 420 420 export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => { return infiniteQueryOptions<PostCallWithOptionalParamResponse, PostCallWithOptionalParamError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>( ··· 422 422 { 423 423 queryFn: async ({ pageParam, queryKey }) => { 424 424 // @ts-ignore 425 425 - const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === "object" ? pageParam : { 425 425 + const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : { 426 426 body: { 427 427 offset: pageParam 428 428 } ··· 450 450 }; return mutationOptions; }; 451 451 452 452 export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => [ 453 453 - createQueryKey("postApiVbyApiVersionRequestBody", options) 453 453 + createQueryKey('postApiVbyApiVersionRequestBody', options) 454 454 ]; 455 455 456 456 export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => { return queryOptions({ ··· 477 477 }; return mutationOptions; }; 478 478 479 479 export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => [ 480 480 - createQueryKey("postApiVbyApiVersionFormData", options) 480 480 + createQueryKey('postApiVbyApiVersionFormData', options) 481 481 ]; 482 482 483 483 export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => { return queryOptions({ ··· 504 504 }; return mutationOptions; }; 505 505 506 506 export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => [ 507 507 - createQueryKey("callWithDefaultParameters", options) 507 507 + createQueryKey('callWithDefaultParameters', options) 508 508 ]; 509 509 510 510 export const callWithDefaultParametersOptions = (options?: Options<CallWithDefaultParametersData>) => { return queryOptions({ ··· 520 520 }); }; 521 521 522 522 export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => [ 523 523 - createQueryKey("callWithDefaultOptionalParameters", options) 523 523 + createQueryKey('callWithDefaultOptionalParameters', options) 524 524 ]; 525 525 526 526 export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => { return queryOptions({ ··· 558 558 }; return mutationOptions; }; 559 559 560 560 export const duplicateNameQueryKey = (options?: Options) => [ 561 561 - createQueryKey("duplicateName", options) 561 561 + createQueryKey('duplicateName', options) 562 562 ]; 563 563 564 564 export const duplicateNameOptions = (options?: Options) => { return queryOptions({ ··· 574 574 }); }; 575 575 576 576 export const duplicateName1QueryKey = (options?: Options) => [ 577 577 - createQueryKey("duplicateName1", options) 577 577 + createQueryKey('duplicateName1', options) 578 578 ]; 579 579 580 580 export const duplicateName1Options = (options?: Options) => { return queryOptions({ ··· 623 623 }; return mutationOptions; }; 624 624 625 625 export const callWithNoContentResponseQueryKey = (options?: Options) => [ 626 626 - createQueryKey("callWithNoContentResponse", options) 626 626 + createQueryKey('callWithNoContentResponse', options) 627 627 ]; 628 628 629 629 export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 639 639 }); }; 640 640 641 641 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options) => [ 642 642 - createQueryKey("callWithResponseAndNoContentResponse", options) 642 642 + createQueryKey('callWithResponseAndNoContentResponse', options) 643 643 ]; 644 644 645 645 export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ ··· 655 655 }); }; 656 656 657 657 export const dummyAQueryKey = (options?: Options) => [ 658 658 - createQueryKey("dummyA", options) 658 658 + createQueryKey('dummyA', options) 659 659 ]; 660 660 661 661 export const dummyAOptions = (options?: Options) => { return queryOptions({ ··· 671 671 }); }; 672 672 673 673 export const dummyBQueryKey = (options?: Options) => [ 674 674 - createQueryKey("dummyB", options) 674 674 + createQueryKey('dummyB', options) 675 675 ]; 676 676 677 677 export const dummyBOptions = (options?: Options) => { return queryOptions({ ··· 687 687 }); }; 688 688 689 689 export const callWithResponseQueryKey = (options?: Options) => [ 690 690 - createQueryKey("callWithResponse", options) 690 690 + createQueryKey('callWithResponse', options) 691 691 ]; 692 692 693 693 export const callWithResponseOptions = (options?: Options) => { return queryOptions({ ··· 703 703 }); }; 704 704 705 705 export const callWithDuplicateResponsesQueryKey = (options?: Options) => [ 706 706 - createQueryKey("callWithDuplicateResponses", options) 706 706 + createQueryKey('callWithDuplicateResponses', options) 707 707 ]; 708 708 709 709 export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ ··· 741 741 }; return mutationOptions; }; 742 742 743 743 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => [ 744 744 - createQueryKey("collectionFormat", options) 744 744 + createQueryKey('collectionFormat', options) 745 745 ]; 746 746 747 747 export const collectionFormatOptions = (options: Options<CollectionFormatData>) => { return queryOptions({ ··· 757 757 }); }; 758 758 759 759 export const typesQueryKey = (options: Options<TypesData>) => [ 760 760 - createQueryKey("types", options) 760 760 + createQueryKey('types', options) 761 761 ]; 762 762 763 763 export const typesOptions = (options: Options<TypesData>) => { return queryOptions({ ··· 773 773 }); }; 774 774 775 775 export const uploadFileQueryKey = (options: Options<UploadFileData>) => [ 776 776 - createQueryKey("uploadFile", options) 776 776 + createQueryKey('uploadFile', options) 777 777 ]; 778 778 779 779 export const uploadFileOptions = (options: Options<UploadFileData>) => { return queryOptions({ ··· 800 800 }; return mutationOptions; }; 801 801 802 802 export const fileResponseQueryKey = (options: Options<FileResponseData>) => [ 803 803 - createQueryKey("fileResponse", options) 803 803 + createQueryKey('fileResponse', options) 804 804 ]; 805 805 806 806 export const fileResponseOptions = (options: Options<FileResponseData>) => { return queryOptions({ ··· 816 816 }); }; 817 817 818 818 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => [ 819 819 - createQueryKey("complexTypes", options) 819 819 + createQueryKey('complexTypes', options) 820 820 ]; 821 821 822 822 export const complexTypesOptions = (options: Options<ComplexTypesData>) => { return queryOptions({ ··· 832 832 }); }; 833 833 834 834 export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => [ 835 835 - createQueryKey("multipartRequest", options) 835 835 + createQueryKey('multipartRequest', options) 836 836 ]; 837 837 838 838 export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => { return queryOptions({ ··· 859 859 }; return mutationOptions; }; 860 860 861 861 export const multipartResponseQueryKey = (options?: Options) => [ 862 862 - createQueryKey("multipartResponse", options) 862 862 + createQueryKey('multipartResponse', options) 863 863 ]; 864 864 865 865 export const multipartResponseOptions = (options?: Options) => { return queryOptions({ ··· 886 886 }; return mutationOptions; }; 887 887 888 888 export const callWithResultFromHeaderQueryKey = (options?: Options) => [ 889 889 - createQueryKey("callWithResultFromHeader", options) 889 889 + createQueryKey('callWithResultFromHeader', options) 890 890 ]; 891 891 892 892 export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ ··· 913 913 }; return mutationOptions; }; 914 914 915 915 export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => [ 916 916 - createQueryKey("testErrorCode", options) 916 916 + createQueryKey('testErrorCode', options) 917 917 ]; 918 918 919 919 export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => { return queryOptions({ ··· 940 940 }; return mutationOptions; }; 941 941 942 942 export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => [ 943 943 - createQueryKey("nonAsciiæøåÆøÅöôêÊ字符串", options) 943 943 + createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options) 944 944 ]; 945 945 946 946 export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => { return queryOptions({

+6 -5

packages/openapi-ts/test/performance.spec.ts

reviewed

··· 4 4 import { Performance } from '../src/utils/performance'; 5 5 6 6 const V3_SPEC_PATH = './test/spec/v3.json'; 7 7 + const V3_1_SPEC_PATH = './test/spec/3.1.0/full.json'; 7 8 8 9 const OUTPUT_PREFIX = './test/generated/'; 9 10 ··· 40 41 expect(measures[0].duration).toBeLessThanOrEqual(500); 41 42 }); 42 43 43 43 - it('parses spec under 300ms (experimental)', async () => { 44 44 + it('parses spec under 500ms (experimental)', async () => { 44 45 Performance.clear(); 45 46 46 47 await createClient({ 47 48 client: '@hey-api/client-fetch', 48 49 experimental_parser: true, 49 49 - input: V3_SPEC_PATH, 50 50 + input: V3_1_SPEC_PATH, 50 51 output: toOutputPath('perf'), 51 52 }); 52 53 53 53 - Performance.measure('experimental_parser'); 54 54 - const measures = Performance.getEntriesByName('experimental_parser'); 54 54 + Performance.measure('parser'); 55 55 + const measures = Performance.getEntriesByName('parser'); 55 56 56 56 - expect(measures[0].duration).toBeLessThanOrEqual(300); 57 57 + expect(measures[0].duration).toBeLessThanOrEqual(500); 57 58 }); 58 59 });

+12 -8

packages/openapi-ts/test/sample.cjs

reviewed

··· 11 11 // debug: true, 12 12 // experimental_parser: true, 13 13 // input: './test/spec/v3-transforms.json', 14 14 - input: './test/spec/v3.json', 15 15 - // input: './test/spec/3.1.0/required-all-of-ref.json', 14 14 + // input: './test/spec/v3.json', 15 15 + input: './test/spec/3.1.0/full.json', 16 16 // input: './test/spec/v2.json', 17 17 // input: 'https://mongodb-mms-prod-build-server.s3.amazonaws.com/openapi/2caffd88277a4e27c95dcefc7e3b6a63a3b03297-v2-2023-11-15.json', 18 18 // name: 'foo', 19 19 output: { 20 20 + format: 'prettier', 21 21 + lint: 'eslint', 20 22 path: './test/generated/sample/', 21 23 }, 22 22 - plugins: [ 23 23 - // '@tanstack/react-query', 24 24 - // '@hey-api/services', 25 25 - 'zod', 26 26 - ], 24 24 + // plugins: [ 25 25 + // '@tanstack/react-query', 26 26 + // // '@hey-api/services', 27 27 + // // 'zod', 28 28 + // ], 27 29 schemas: { 28 30 export: false, 29 31 }, ··· 36 38 }, 37 39 types: { 38 40 // dates: 'types+transform', 39 39 - // enums: 'javascript', 41 41 + // enums: 'typescript', 42 42 + // enums: 'typescript+namespace', 43 43 + enums: 'javascript', 40 44 // export: false, 41 45 // include: 42 46 // '^(_400|CompositionWithOneOfAndProperties)',

+3622

packages/openapi-ts/test/spec/3.1.0/full.json

reviewed

··· 1 1 + { 2 2 + "openapi": "3.1.0", 3 3 + "info": { 4 4 + "title": "swagger", 5 5 + "version": "v1.0" 6 6 + }, 7 7 + "servers": [ 8 8 + { 9 9 + "url": "http://localhost:3000/base" 10 10 + } 11 11 + ], 12 12 + "paths": { 13 13 + "/api/v{api-version}/no-tag": { 14 14 + "tags": [], 15 15 + "get": { 16 16 + "operationId": "export" 17 17 + }, 18 18 + "post": { 19 19 + "operationId": "import", 20 20 + "requestBody": { 21 21 + "required": true, 22 22 + "content": { 23 23 + "application/json": { 24 24 + "schema": { 25 25 + "type": "object", 26 26 + "oneOf": [ 27 27 + { 28 28 + "$ref": "#/components/schemas/ModelWithReadOnlyAndWriteOnly" 29 29 + }, 30 30 + { 31 31 + "$ref": "#/components/schemas/ModelWithArrayReadOnlyAndWriteOnly" 32 32 + } 33 33 + ] 34 34 + } 35 35 + } 36 36 + } 37 37 + }, 38 38 + "responses": { 39 39 + "default": { 40 40 + "description": "Default success response", 41 41 + "content": { 42 42 + "application/json": { 43 43 + "schema": { 44 44 + "$ref": "#/components/schemas/ModelWithReadOnlyAndWriteOnly" 45 45 + } 46 46 + } 47 47 + } 48 48 + }, 49 49 + "200": { 50 50 + "description": "Success", 51 51 + "content": { 52 52 + "application/json; type=collection": { 53 53 + "schema": { 54 54 + "$ref": "#/components/schemas/Model-From.Zendesk" 55 55 + } 56 56 + } 57 57 + } 58 58 + } 59 59 + } 60 60 + } 61 61 + }, 62 62 + "/api/v{api-version}/simple/$count": { 63 63 + "get": { 64 64 + "tags": ["Simple"], 65 65 + "operationId": "api/v{version}/ODataController/$count", 66 66 + "responses": { 67 67 + "200": { 68 68 + "description": "Success", 69 69 + "content": { 70 70 + "application/json; type=collection": { 71 71 + "schema": { 72 72 + "$ref": "#/components/schemas/Model-From.Zendesk" 73 73 + } 74 74 + } 75 75 + } 76 76 + } 77 77 + } 78 78 + } 79 79 + }, 80 80 + "/api/v{api-version}/simple:operation": { 81 81 + "get": { 82 82 + "parameters": [ 83 83 + { 84 84 + "description": "foo in method", 85 85 + "in": "path", 86 86 + "name": "foo_param", 87 87 + "required": true, 88 88 + "schema": { 89 89 + "oneOf": [ 90 90 + { 91 91 + "type": "string" 92 92 + }, 93 93 + { 94 94 + "format": "uuid", 95 95 + "type": "string" 96 96 + } 97 97 + ] 98 98 + } 99 99 + } 100 100 + ], 101 101 + "responses": { 102 102 + "default": { 103 103 + "description": "Default error response", 104 104 + "content": { 105 105 + "application/json": { 106 106 + "schema": { 107 107 + "$ref": "#/components/schemas/ModelWithBoolean" 108 108 + } 109 109 + } 110 110 + } 111 111 + }, 112 112 + "200": { 113 113 + "description": "Response is a simple number", 114 114 + "content": { 115 115 + "application/json": { 116 116 + "schema": { 117 117 + "type": "number" 118 118 + } 119 119 + } 120 120 + } 121 121 + } 122 122 + } 123 123 + } 124 124 + }, 125 125 + "/api/v{api-version}/simple": { 126 126 + "get": { 127 127 + "tags": ["Simple"], 128 128 + "operationId": "GetCallWithoutParametersAndResponse" 129 129 + }, 130 130 + "put": { 131 131 + "tags": ["Simple"], 132 132 + "operationId": "PutCallWithoutParametersAndResponse" 133 133 + }, 134 134 + "post": { 135 135 + "tags": ["Simple"], 136 136 + "operationId": "PostCallWithoutParametersAndResponse" 137 137 + }, 138 138 + "delete": { 139 139 + "tags": ["Simple"], 140 140 + "operationId": "DeleteCallWithoutParametersAndResponse" 141 141 + }, 142 142 + "options": { 143 143 + "tags": ["Simple"], 144 144 + "operationId": "OptionsCallWithoutParametersAndResponse" 145 145 + }, 146 146 + "head": { 147 147 + "tags": ["Simple"], 148 148 + "operationId": "HeadCallWithoutParametersAndResponse" 149 149 + }, 150 150 + "patch": { 151 151 + "tags": ["Simple"], 152 152 + "operationId": "PatchCallWithoutParametersAndResponse" 153 153 + } 154 154 + }, 155 155 + "/api/v{api-version}/foo/{foo_param}/bar/{BarParam}": { 156 156 + "delete": { 157 157 + "tags": ["Parameters"], 158 158 + "operationId": "deleteFoo", 159 159 + "parameters": [ 160 160 + { 161 161 + "description": "foo in method", 162 162 + "in": "path", 163 163 + "name": "foo_param", 164 164 + "required": true, 165 165 + "schema": { 166 166 + "type": "string" 167 167 + } 168 168 + }, 169 169 + { 170 170 + "description": "bar in method", 171 171 + "in": "path", 172 172 + "name": "BarParam", 173 173 + "required": true, 174 174 + "schema": { 175 175 + "type": "string" 176 176 + } 177 177 + }, 178 178 + { 179 179 + "description": "Parameter with illegal characters", 180 180 + "name": "x-Foo-Bar", 181 181 + "in": "header", 182 182 + "required": true, 183 183 + "content": { 184 184 + "application/json": { 185 185 + "schema": { 186 186 + "$ref": "#/components/schemas/ModelWithString" 187 187 + } 188 188 + } 189 189 + } 190 190 + } 191 191 + ] 192 192 + }, 193 193 + "parameters": [ 194 194 + { 195 195 + "description": "foo in global parameters", 196 196 + "in": "path", 197 197 + "name": "foo_param", 198 198 + "required": true, 199 199 + "schema": { 200 200 + "type": "string" 201 201 + } 202 202 + }, 203 203 + { 204 204 + "description": "bar in global parameters", 205 205 + "in": "path", 206 206 + "name": "BarParam", 207 207 + "required": true, 208 208 + "schema": { 209 209 + "type": "string" 210 210 + } 211 211 + } 212 212 + ] 213 213 + }, 214 214 + "/api/v{api-version}/descriptions/": { 215 215 + "post": { 216 216 + "tags": ["Descriptions"], 217 217 + "operationId": "CallWithDescriptions", 218 218 + "parameters": [ 219 219 + { 220 220 + "description": "Testing multiline comments in string: First line\nSecond line\n\nFourth line", 221 221 + "name": "parameterWithBreaks", 222 222 + "in": "query", 223 223 + "schema": { 224 224 + "type": "string" 225 225 + } 226 226 + }, 227 227 + { 228 228 + "description": "Testing backticks in string: `backticks` and ```multiple backticks``` should work", 229 229 + "name": "parameterWithBackticks", 230 230 + "in": "query", 231 231 + "schema": { 232 232 + "type": "string" 233 233 + } 234 234 + }, 235 235 + { 236 236 + "description": "Testing slashes in string: \\backwards\\\\\\ and /forwards/// should work", 237 237 + "name": "parameterWithSlashes", 238 238 + "in": "query", 239 239 + "schema": { 240 240 + "type": "string" 241 241 + } 242 242 + }, 243 243 + { 244 244 + "description": "Testing expression placeholders in string: ${expression} should work", 245 245 + "name": "parameterWithExpressionPlaceholders", 246 246 + "in": "query", 247 247 + "schema": { 248 248 + "type": "string" 249 249 + } 250 250 + }, 251 251 + { 252 252 + "description": "Testing quotes in string: 'single quote''' and \"double quotes\"\"\" should work", 253 253 + "name": "parameterWithQuotes", 254 254 + "in": "query", 255 255 + "schema": { 256 256 + "type": "string" 257 257 + } 258 258 + }, 259 259 + { 260 260 + "description": "Testing reserved characters in string: /* inline */ and /** inline **/ should work", 261 261 + "name": "parameterWithReservedCharacters", 262 262 + "in": "query", 263 263 + "schema": { 264 264 + "type": "string" 265 265 + } 266 266 + } 267 267 + ] 268 268 + } 269 269 + }, 270 270 + "/api/v{api-version}/parameters/deprecated": { 271 271 + "post": { 272 272 + "tags": ["Deprecated"], 273 273 + "deprecated": true, 274 274 + "operationId": "DeprecatedCall", 275 275 + "parameters": [ 276 276 + { 277 277 + "deprecated": true, 278 278 + "description": "This parameter is deprecated", 279 279 + "name": "parameter", 280 280 + "in": "header", 281 281 + "required": true, 282 282 + "schema": { 283 283 + "oneOf": [ 284 284 + { 285 285 + "$ref": "#/components/schemas/DeprecatedModel" 286 286 + }, 287 287 + { 288 288 + "type": "null" 289 289 + } 290 290 + ] 291 291 + } 292 292 + } 293 293 + ] 294 294 + } 295 295 + }, 296 296 + "/api/v{api-version}/parameters/{parameterPath}": { 297 297 + "post": { 298 298 + "tags": ["Parameters"], 299 299 + "operationId": "CallWithParameters", 300 300 + "parameters": [ 301 301 + { 302 302 + "description": "This is the parameter that goes into the header", 303 303 + "name": "parameterHeader", 304 304 + "in": "header", 305 305 + "required": true, 306 306 + "schema": { 307 307 + "type": ["string", "null"] 308 308 + } 309 309 + }, 310 310 + { 311 311 + "required": false, 312 312 + "schema": { 313 313 + "$ref": "#/components/schemas/ModelWithNestedArrayEnumsDataFoo" 314 314 + }, 315 315 + "name": "foo_ref_enum", 316 316 + "in": "query" 317 317 + }, 318 318 + { 319 319 + "required": true, 320 320 + "schema": { 321 321 + "allOf": [ 322 322 + { 323 323 + "$ref": "#/components/schemas/ModelWithNestedArrayEnumsDataFoo" 324 324 + } 325 325 + ] 326 326 + }, 327 327 + "name": "foo_all_of_enum", 328 328 + "in": "query" 329 329 + }, 330 330 + { 331 331 + "description": "This is the parameter that goes into the query params", 332 332 + "name": "cursor", 333 333 + "in": "query", 334 334 + "required": true, 335 335 + "schema": { 336 336 + "type": ["string", "null"] 337 337 + } 338 338 + }, 339 339 + { 340 340 + "description": "This is the parameter that goes into the cookie", 341 341 + "name": "parameterCookie", 342 342 + "in": "cookie", 343 343 + "required": true, 344 344 + "schema": { 345 345 + "type": ["string", "null"] 346 346 + } 347 347 + }, 348 348 + { 349 349 + "description": "This is the parameter that goes into the path", 350 350 + "name": "parameterPath", 351 351 + "in": "path", 352 352 + "required": true, 353 353 + "schema": { 354 354 + "type": ["string", "null"] 355 355 + } 356 356 + }, 357 357 + { 358 358 + "description": "api-version should be required in standalone clients", 359 359 + "name": "api-version", 360 360 + "in": "path", 361 361 + "required": true, 362 362 + "schema": { 363 363 + "type": ["string", "null"] 364 364 + } 365 365 + } 366 366 + ], 367 367 + "requestBody": { 368 368 + "description": "This is the parameter that goes into the body", 369 369 + "required": true, 370 370 + "content": { 371 371 + "application/json": { 372 372 + "schema": { 373 373 + "properties": {}, 374 374 + "type": ["object", "null"] 375 375 + } 376 376 + } 377 377 + } 378 378 + } 379 379 + } 380 380 + }, 381 381 + "/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}": { 382 382 + "post": { 383 383 + "tags": ["Parameters"], 384 384 + "operationId": "CallWithWeirdParameterNames", 385 385 + "parameters": [ 386 386 + { 387 387 + "description": "This is the parameter that goes into the path", 388 388 + "name": "parameter.path.1", 389 389 + "in": "path", 390 390 + "required": false, 391 391 + "schema": { 392 392 + "type": "string" 393 393 + } 394 394 + }, 395 395 + { 396 396 + "description": "This is the parameter that goes into the path", 397 397 + "name": "parameter-path-2", 398 398 + "in": "path", 399 399 + "required": false, 400 400 + "schema": { 401 401 + "type": "string" 402 402 + } 403 403 + }, 404 404 + { 405 405 + "description": "This is the parameter that goes into the path", 406 406 + "name": "PARAMETER-PATH-3", 407 407 + "in": "path", 408 408 + "required": false, 409 409 + "schema": { 410 410 + "type": "string" 411 411 + } 412 412 + }, 413 413 + { 414 414 + "description": "This is the parameter with a reserved keyword", 415 415 + "name": "default", 416 416 + "in": "query", 417 417 + "required": false, 418 418 + "schema": { 419 419 + "type": "string" 420 420 + } 421 421 + }, 422 422 + { 423 423 + "description": "This is the parameter that goes into the request header", 424 424 + "name": "parameter.header", 425 425 + "in": "header", 426 426 + "required": true, 427 427 + "schema": { 428 428 + "type": ["string", "null"] 429 429 + } 430 430 + }, 431 431 + { 432 432 + "description": "This is the parameter that goes into the request query params", 433 433 + "name": "parameter-query", 434 434 + "in": "query", 435 435 + "required": true, 436 436 + "schema": { 437 437 + "type": ["string", "null"] 438 438 + } 439 439 + }, 440 440 + { 441 441 + "description": "This is the parameter that goes into the cookie", 442 442 + "name": "PARAMETER-COOKIE", 443 443 + "in": "cookie", 444 444 + "required": true, 445 445 + "schema": { 446 446 + "type": ["string", "null"] 447 447 + } 448 448 + }, 449 449 + { 450 450 + "description": "api-version should be required in standalone clients", 451 451 + "name": "api-version", 452 452 + "in": "path", 453 453 + "required": true, 454 454 + "schema": { 455 455 + "type": ["string", "null"] 456 456 + } 457 457 + } 458 458 + ], 459 459 + "requestBody": { 460 460 + "description": "This is the parameter that goes into the body", 461 461 + "required": true, 462 462 + "content": { 463 463 + "application/json": { 464 464 + "schema": { 465 465 + "oneOf": [ 466 466 + { 467 467 + "$ref": "#/components/schemas/ModelWithString" 468 468 + }, 469 469 + { 470 470 + "type": "null" 471 471 + } 472 472 + ] 473 473 + } 474 474 + } 475 475 + } 476 476 + } 477 477 + } 478 478 + }, 479 479 + "/api/v{api-version}/parameters/": { 480 480 + "get": { 481 481 + "tags": ["Parameters"], 482 482 + "operationId": "GetCallWithOptionalParam", 483 483 + "parameters": [ 484 484 + { 485 485 + "description": "This is an optional parameter", 486 486 + "name": "page", 487 487 + "in": "query", 488 488 + "required": false, 489 489 + "schema": { 490 490 + "type": "number" 491 491 + } 492 492 + } 493 493 + ], 494 494 + "requestBody": { 495 495 + "description": "This is a required parameter", 496 496 + "required": true, 497 497 + "content": { 498 498 + "application/json": { 499 499 + "schema": { 500 500 + "$ref": "#/components/schemas/ModelWithOneOfEnum" 501 501 + } 502 502 + } 503 503 + } 504 504 + } 505 505 + }, 506 506 + "post": { 507 507 + "tags": ["Parameters"], 508 508 + "operationId": "PostCallWithOptionalParam", 509 509 + "parameters": [ 510 510 + { 511 511 + "description": "This is a required parameter", 512 512 + "name": "parameter", 513 513 + "in": "query", 514 514 + "required": true, 515 515 + "schema": { 516 516 + "$ref": "#/components/schemas/Pageable" 517 517 + } 518 518 + } 519 519 + ], 520 520 + "requestBody": { 521 521 + "description": "This is an optional parameter", 522 522 + "required": false, 523 523 + "content": { 524 524 + "application/json": { 525 525 + "schema": { 526 526 + "properties": { 527 527 + "offset": { 528 528 + "required": true, 529 529 + "type": ["number", "null"] 530 530 + } 531 531 + }, 532 532 + "type": "object" 533 533 + } 534 534 + } 535 535 + } 536 536 + }, 537 537 + "responses": { 538 538 + "200": { 539 539 + "description": "Response is a simple number", 540 540 + "content": { 541 541 + "application/json": { 542 542 + "schema": { 543 543 + "type": "number" 544 544 + } 545 545 + } 546 546 + } 547 547 + }, 548 548 + "204": { 549 549 + "description": "Success" 550 550 + } 551 551 + } 552 552 + } 553 553 + }, 554 554 + "/api/v{api-version}/requestBody/": { 555 555 + "post": { 556 556 + "tags": ["RequestBody"], 557 557 + "parameters": [ 558 558 + { 559 559 + "$ref": "#/components/parameters/SimpleParameter" 560 560 + } 561 561 + ], 562 562 + "requestBody": { 563 563 + "$ref": "#/components/requestBodies/SimpleRequestBody" 564 564 + } 565 565 + } 566 566 + }, 567 567 + "/api/v{api-version}/formData/": { 568 568 + "post": { 569 569 + "tags": ["FormData"], 570 570 + "parameters": [ 571 571 + { 572 572 + "$ref": "#/components/parameters/SimpleParameter" 573 573 + } 574 574 + ], 575 575 + "requestBody": { 576 576 + "$ref": "#/components/requestBodies/SimpleFormData" 577 577 + } 578 578 + } 579 579 + }, 580 580 + "/api/v{api-version}/defaults": { 581 581 + "get": { 582 582 + "tags": ["Defaults"], 583 583 + "operationId": "CallWithDefaultParameters", 584 584 + "parameters": [ 585 585 + { 586 586 + "description": "This is a simple string with default value", 587 587 + "name": "parameterString", 588 588 + "in": "query", 589 589 + "schema": { 590 590 + "default": "Hello World!", 591 591 + "type": ["string", "null"] 592 592 + } 593 593 + }, 594 594 + { 595 595 + "description": "This is a simple number with default value", 596 596 + "name": "parameterNumber", 597 597 + "in": "query", 598 598 + "schema": { 599 599 + "default": 123, 600 600 + "type": ["number", "null"] 601 601 + } 602 602 + }, 603 603 + { 604 604 + "description": "This is a simple boolean with default value", 605 605 + "name": "parameterBoolean", 606 606 + "in": "query", 607 607 + "schema": { 608 608 + "default": true, 609 609 + "type": ["boolean", "null"] 610 610 + } 611 611 + }, 612 612 + { 613 613 + "description": "This is a simple enum with default value", 614 614 + "name": "parameterEnum", 615 615 + "in": "query", 616 616 + "schema": { 617 617 + "enum": ["Success", "Warning", "Error"], 618 618 + "default": 0 619 619 + } 620 620 + }, 621 621 + { 622 622 + "description": "This is a simple model with default value", 623 623 + "name": "parameterModel", 624 624 + "in": "query", 625 625 + "schema": { 626 626 + "oneOf": [ 627 627 + { 628 628 + "$ref": "#/components/schemas/ModelWithString", 629 629 + "default": { 630 630 + "prop": "Hello World!" 631 631 + } 632 632 + }, 633 633 + { 634 634 + "type": "null" 635 635 + } 636 636 + ] 637 637 + } 638 638 + } 639 639 + ] 640 640 + }, 641 641 + "post": { 642 642 + "tags": ["Defaults"], 643 643 + "operationId": "CallWithDefaultOptionalParameters", 644 644 + "parameters": [ 645 645 + { 646 646 + "description": "This is a simple string that is optional with default value", 647 647 + "name": "parameterString", 648 648 + "in": "query", 649 649 + "required": false, 650 650 + "schema": { 651 651 + "type": "string", 652 652 + "default": "Hello World!" 653 653 + } 654 654 + }, 655 655 + { 656 656 + "description": "This is a simple number that is optional with default value", 657 657 + "name": "parameterNumber", 658 658 + "in": "query", 659 659 + "required": false, 660 660 + "schema": { 661 661 + "type": "number", 662 662 + "default": 123 663 663 + } 664 664 + }, 665 665 + { 666 666 + "description": "This is a simple boolean that is optional with default value", 667 667 + "name": "parameterBoolean", 668 668 + "in": "query", 669 669 + "required": false, 670 670 + "schema": { 671 671 + "type": "boolean", 672 672 + "default": true 673 673 + } 674 674 + }, 675 675 + { 676 676 + "description": "This is a simple enum that is optional with default value", 677 677 + "name": "parameterEnum", 678 678 + "in": "query", 679 679 + "required": false, 680 680 + "schema": { 681 681 + "enum": ["Success", "Warning", "Error"], 682 682 + "default": 0 683 683 + } 684 684 + }, 685 685 + { 686 686 + "description": "This is a simple model that is optional with default value", 687 687 + "name": "parameterModel", 688 688 + "in": "query", 689 689 + "required": false, 690 690 + "schema": { 691 691 + "$ref": "#/components/schemas/ModelWithString", 692 692 + "default": { 693 693 + "prop": "Hello World!" 694 694 + } 695 695 + } 696 696 + } 697 697 + ] 698 698 + }, 699 699 + "put": { 700 700 + "tags": ["Defaults"], 701 701 + "operationId": "CallToTestOrderOfParams", 702 702 + "parameters": [ 703 703 + { 704 704 + "description": "This is a optional string with default", 705 705 + "name": "parameterOptionalStringWithDefault", 706 706 + "in": "query", 707 707 + "required": false, 708 708 + "schema": { 709 709 + "type": "string", 710 710 + "default": "Hello World!" 711 711 + } 712 712 + }, 713 713 + { 714 714 + "description": "This is a optional string with empty default", 715 715 + "name": "parameterOptionalStringWithEmptyDefault", 716 716 + "in": "query", 717 717 + "required": false, 718 718 + "schema": { 719 719 + "type": "string", 720 720 + "default": "" 721 721 + } 722 722 + }, 723 723 + { 724 724 + "description": "This is a optional string with no default", 725 725 + "name": "parameterOptionalStringWithNoDefault", 726 726 + "in": "query", 727 727 + "required": false, 728 728 + "schema": { 729 729 + "type": "string" 730 730 + } 731 731 + }, 732 732 + { 733 733 + "description": "This is a string with default", 734 734 + "name": "parameterStringWithDefault", 735 735 + "in": "query", 736 736 + "required": true, 737 737 + "schema": { 738 738 + "type": "string", 739 739 + "default": "Hello World!" 740 740 + } 741 741 + }, 742 742 + { 743 743 + "description": "This is a string with empty default", 744 744 + "name": "parameterStringWithEmptyDefault", 745 745 + "in": "query", 746 746 + "required": true, 747 747 + "schema": { 748 748 + "type": "string", 749 749 + "default": "" 750 750 + } 751 751 + }, 752 752 + { 753 753 + "description": "This is a string with no default", 754 754 + "name": "parameterStringWithNoDefault", 755 755 + "in": "query", 756 756 + "required": true, 757 757 + "schema": { 758 758 + "type": "string" 759 759 + } 760 760 + }, 761 761 + { 762 762 + "description": "This is a string that can be null with no default", 763 763 + "name": "parameterStringNullableWithNoDefault", 764 764 + "in": "query", 765 765 + "required": false, 766 766 + "schema": { 767 767 + "type": ["string", "null"] 768 768 + } 769 769 + }, 770 770 + { 771 771 + "description": "This is a string that can be null with default", 772 772 + "name": "parameterStringNullableWithDefault", 773 773 + "in": "query", 774 774 + "required": false, 775 775 + "schema": { 776 776 + "default": null, 777 777 + "type": ["string", "null"] 778 778 + } 779 779 + } 780 780 + ] 781 781 + } 782 782 + }, 783 783 + "/api/v{api-version}/duplicate": { 784 784 + "get": { 785 785 + "tags": ["Duplicate"], 786 786 + "operationId": "DuplicateName" 787 787 + }, 788 788 + "post": { 789 789 + "tags": ["Duplicate"], 790 790 + "operationId": "DuplicateName" 791 791 + }, 792 792 + "put": { 793 793 + "tags": ["Duplicate"], 794 794 + "operationId": "DuplicateName" 795 795 + }, 796 796 + "delete": { 797 797 + "tags": ["Duplicate"], 798 798 + "operationId": "DuplicateName" 799 799 + } 800 800 + }, 801 801 + "/api/v{api-version}/no-content": { 802 802 + "get": { 803 803 + "tags": ["NoContent"], 804 804 + "operationId": "CallWithNoContentResponse", 805 805 + "responses": { 806 806 + "204": { 807 807 + "description": "Success" 808 808 + } 809 809 + } 810 810 + } 811 811 + }, 812 812 + "/api/v{api-version}/multiple-tags/response-and-no-content": { 813 813 + "get": { 814 814 + "tags": ["Response", "NoContent"], 815 815 + "operationId": "CallWithResponseAndNoContentResponse", 816 816 + "responses": { 817 817 + "200": { 818 818 + "description": "Response is a simple number", 819 819 + "content": { 820 820 + "application/json": { 821 821 + "schema": { 822 822 + "type": "number" 823 823 + } 824 824 + } 825 825 + } 826 826 + }, 827 827 + "204": { 828 828 + "description": "Success" 829 829 + } 830 830 + } 831 831 + } 832 832 + }, 833 833 + "/api/v{api-version}/multiple-tags/a": { 834 834 + "get": { 835 835 + "tags": ["MultipleTags1", "MultipleTags2"], 836 836 + "operationId": "DummyA", 837 837 + "responses": { 838 838 + "200": { 839 839 + "content": { 840 840 + "application/json": { 841 841 + "schema": { 842 842 + "$ref": "#/components/schemas/400" 843 843 + } 844 844 + } 845 845 + } 846 846 + } 847 847 + } 848 848 + } 849 849 + }, 850 850 + "/api/v{api-version}/multiple-tags/b": { 851 851 + "get": { 852 852 + "tags": ["MultipleTags1", "MultipleTags2", "MultipleTags3"], 853 853 + "operationId": "DummyB", 854 854 + "responses": { 855 855 + "204": { 856 856 + "description": "Success" 857 857 + } 858 858 + } 859 859 + } 860 860 + }, 861 861 + "/api/v{api-version}/response": { 862 862 + "get": { 863 863 + "tags": ["Response"], 864 864 + "operationId": "CallWithResponse", 865 865 + "responses": { 866 866 + "default": { 867 867 + "content": { 868 868 + "application/json": { 869 869 + "schema": { 870 870 + "$ref": "#/components/schemas/import" 871 871 + } 872 872 + } 873 873 + } 874 874 + } 875 875 + } 876 876 + }, 877 877 + "post": { 878 878 + "tags": ["Response"], 879 879 + "operationId": "CallWithDuplicateResponses", 880 880 + "responses": { 881 881 + "default": { 882 882 + "description": "Default error response", 883 883 + "content": { 884 884 + "application/json": { 885 885 + "schema": { 886 886 + "$ref": "#/components/schemas/ModelWithBoolean" 887 887 + } 888 888 + } 889 889 + } 890 890 + }, 891 891 + "200": { 892 892 + "description": "Message for 200 response", 893 893 + "content": { 894 894 + "application/json": { 895 895 + "schema": { 896 896 + "allOf": [ 897 897 + { 898 898 + "$ref": "#/components/schemas/ModelWithBoolean" 899 899 + }, 900 900 + { 901 901 + "$ref": "#/components/schemas/ModelWithInteger" 902 902 + } 903 903 + ] 904 904 + } 905 905 + } 906 906 + } 907 907 + }, 908 908 + "201": { 909 909 + "description": "Message for 201 response", 910 910 + "content": { 911 911 + "application/json": { 912 912 + "schema": { 913 913 + "$ref": "#/components/schemas/ModelWithString" 914 914 + } 915 915 + } 916 916 + } 917 917 + }, 918 918 + "202": { 919 919 + "description": "Message for 202 response", 920 920 + "content": { 921 921 + "application/json": { 922 922 + "schema": { 923 923 + "$ref": "#/components/schemas/ModelWithString" 924 924 + } 925 925 + } 926 926 + } 927 927 + }, 928 928 + "4XX": { 929 929 + "description": "Message for 4XX errors", 930 930 + "content": { 931 931 + "application/json": { 932 932 + "schema": { 933 933 + "$ref": "#/components/schemas/DictionaryWithArray" 934 934 + } 935 935 + } 936 936 + } 937 937 + }, 938 938 + "500": { 939 939 + "description": "Message for 500 error", 940 940 + "content": { 941 941 + "application/json": { 942 942 + "schema": { 943 943 + "$ref": "#/components/schemas/ModelWithStringError" 944 944 + } 945 945 + } 946 946 + } 947 947 + }, 948 948 + "501": { 949 949 + "description": "Message for 501 error", 950 950 + "content": { 951 951 + "application/json": { 952 952 + "schema": { 953 953 + "$ref": "#/components/schemas/ModelWithStringError" 954 954 + } 955 955 + } 956 956 + } 957 957 + }, 958 958 + "502": { 959 959 + "description": "Message for 502 error", 960 960 + "content": { 961 961 + "application/json": { 962 962 + "schema": { 963 963 + "$ref": "#/components/schemas/ModelWithStringError" 964 964 + } 965 965 + } 966 966 + } 967 967 + } 968 968 + } 969 969 + }, 970 970 + "put": { 971 971 + "tags": ["Response"], 972 972 + "operationId": "CallWithResponses", 973 973 + "responses": { 974 974 + "default": { 975 975 + "description": "Message for default response", 976 976 + "content": { 977 977 + "application/json": { 978 978 + "schema": { 979 979 + "$ref": "#/components/schemas/ModelWithStringError" 980 980 + } 981 981 + } 982 982 + } 983 983 + }, 984 984 + "200": { 985 985 + "description": "Message for 200 response", 986 986 + "content": { 987 987 + "application/json": { 988 988 + "schema": { 989 989 + "type": "object", 990 990 + "properties": { 991 991 + "@namespace.string": { 992 992 + "type": "string", 993 993 + "readOnly": true 994 994 + }, 995 995 + "@namespace.integer": { 996 996 + "type": "integer", 997 997 + "readOnly": true 998 998 + }, 999 999 + "value": { 1000 1000 + "type": "array", 1001 1001 + "items": { 1002 1002 + "$ref": "#/components/schemas/ModelWithString" 1003 1003 + }, 1004 1004 + "readOnly": true 1005 1005 + } 1006 1006 + } 1007 1007 + } 1008 1008 + } 1009 1009 + } 1010 1010 + }, 1011 1011 + "201": { 1012 1012 + "description": "Message for 201 response", 1013 1013 + "content": { 1014 1014 + "application/json": { 1015 1015 + "schema": { 1016 1016 + "$ref": "#/components/schemas/ModelThatExtends" 1017 1017 + } 1018 1018 + } 1019 1019 + } 1020 1020 + }, 1021 1021 + "202": { 1022 1022 + "description": "Message for 202 response", 1023 1023 + "content": { 1024 1024 + "application/json": { 1025 1025 + "schema": { 1026 1026 + "$ref": "#/components/schemas/ModelThatExtendsExtends" 1027 1027 + } 1028 1028 + } 1029 1029 + } 1030 1030 + }, 1031 1031 + "500": { 1032 1032 + "description": "Message for 500 error", 1033 1033 + "content": { 1034 1034 + "application/json": { 1035 1035 + "schema": { 1036 1036 + "$ref": "#/components/schemas/ModelWithStringError" 1037 1037 + } 1038 1038 + } 1039 1039 + } 1040 1040 + }, 1041 1041 + "501": { 1042 1042 + "description": "Message for 501 error", 1043 1043 + "content": { 1044 1044 + "application/json": { 1045 1045 + "schema": { 1046 1046 + "$ref": "#/components/schemas/ModelWithStringError" 1047 1047 + } 1048 1048 + } 1049 1049 + } 1050 1050 + }, 1051 1051 + "502": { 1052 1052 + "description": "Message for 502 error", 1053 1053 + "content": { 1054 1054 + "application/json": { 1055 1055 + "schema": { 1056 1056 + "$ref": "#/components/schemas/ModelWithStringError" 1057 1057 + } 1058 1058 + } 1059 1059 + } 1060 1060 + } 1061 1061 + } 1062 1062 + } 1063 1063 + }, 1064 1064 + "/api/v{api-version}/collectionFormat": { 1065 1065 + "get": { 1066 1066 + "tags": ["CollectionFormat"], 1067 1067 + "operationId": "CollectionFormat", 1068 1068 + "parameters": [ 1069 1069 + { 1070 1070 + "description": "This is an array parameter that is sent as csv format (comma-separated values)", 1071 1071 + "name": "parameterArrayCSV", 1072 1072 + "in": "query", 1073 1073 + "required": true, 1074 1074 + "schema": { 1075 1075 + "type": ["array", "null"], 1076 1076 + "items": { 1077 1077 + "type": "string" 1078 1078 + } 1079 1079 + }, 1080 1080 + "collectionFormat": "csv" 1081 1081 + }, 1082 1082 + { 1083 1083 + "description": "This is an array parameter that is sent as ssv format (space-separated values)", 1084 1084 + "name": "parameterArraySSV", 1085 1085 + "in": "query", 1086 1086 + "required": true, 1087 1087 + "schema": { 1088 1088 + "type": ["array", "null"], 1089 1089 + "items": { 1090 1090 + "type": "string" 1091 1091 + } 1092 1092 + }, 1093 1093 + "collectionFormat": "ssv" 1094 1094 + }, 1095 1095 + { 1096 1096 + "description": "This is an array parameter that is sent as tsv format (tab-separated values)", 1097 1097 + "name": "parameterArrayTSV", 1098 1098 + "in": "query", 1099 1099 + "required": true, 1100 1100 + "schema": { 1101 1101 + "type": ["array", "null"], 1102 1102 + "items": { 1103 1103 + "type": "string" 1104 1104 + } 1105 1105 + }, 1106 1106 + "collectionFormat": "tsv" 1107 1107 + }, 1108 1108 + { 1109 1109 + "description": "This is an array parameter that is sent as pipes format (pipe-separated values)", 1110 1110 + "name": "parameterArrayPipes", 1111 1111 + "in": "query", 1112 1112 + "required": true, 1113 1113 + "schema": { 1114 1114 + "type": ["array", "null"], 1115 1115 + "items": { 1116 1116 + "type": "string" 1117 1117 + } 1118 1118 + }, 1119 1119 + "collectionFormat": "pipes" 1120 1120 + }, 1121 1121 + { 1122 1122 + "description": "This is an array parameter that is sent as multi format (multiple parameter instances)", 1123 1123 + "name": "parameterArrayMulti", 1124 1124 + "in": "query", 1125 1125 + "required": true, 1126 1126 + "schema": { 1127 1127 + "type": ["array", "null"], 1128 1128 + "items": { 1129 1129 + "type": "string" 1130 1130 + } 1131 1131 + }, 1132 1132 + "collectionFormat": "multi" 1133 1133 + } 1134 1134 + ] 1135 1135 + } 1136 1136 + }, 1137 1137 + "/api/v{api-version}/types": { 1138 1138 + "get": { 1139 1139 + "tags": ["Types"], 1140 1140 + "operationId": "Types", 1141 1141 + "parameters": [ 1142 1142 + { 1143 1143 + "description": "This is a number parameter", 1144 1144 + "name": "parameterNumber", 1145 1145 + "in": "query", 1146 1146 + "required": true, 1147 1147 + "schema": { 1148 1148 + "type": "number", 1149 1149 + "default": 123 1150 1150 + } 1151 1151 + }, 1152 1152 + { 1153 1153 + "description": "This is a string parameter", 1154 1154 + "name": "parameterString", 1155 1155 + "in": "query", 1156 1156 + "required": true, 1157 1157 + "schema": { 1158 1158 + "type": ["string", "null"], 1159 1159 + "default": "default" 1160 1160 + } 1161 1161 + }, 1162 1162 + { 1163 1163 + "description": "This is a boolean parameter", 1164 1164 + "name": "parameterBoolean", 1165 1165 + "in": "query", 1166 1166 + "required": true, 1167 1167 + "schema": { 1168 1168 + "type": ["boolean", "null"], 1169 1169 + "default": true 1170 1170 + } 1171 1171 + }, 1172 1172 + { 1173 1173 + "description": "This is an object parameter", 1174 1174 + "name": "parameterObject", 1175 1175 + "in": "query", 1176 1176 + "required": true, 1177 1177 + "schema": { 1178 1178 + "type": ["object", "null"], 1179 1179 + "default": null 1180 1180 + } 1181 1181 + }, 1182 1182 + { 1183 1183 + "description": "This is an array parameter", 1184 1184 + "name": "parameterArray", 1185 1185 + "in": "query", 1186 1186 + "required": true, 1187 1187 + "schema": { 1188 1188 + "type": ["array", "null"], 1189 1189 + "items": { 1190 1190 + "type": "string" 1191 1191 + } 1192 1192 + } 1193 1193 + }, 1194 1194 + { 1195 1195 + "description": "This is a dictionary parameter", 1196 1196 + "name": "parameterDictionary", 1197 1197 + "in": "query", 1198 1198 + "required": true, 1199 1199 + "schema": { 1200 1200 + "type": ["object", "null"], 1201 1201 + "items": { 1202 1202 + "type": "string" 1203 1203 + } 1204 1204 + } 1205 1205 + }, 1206 1206 + { 1207 1207 + "description": "This is an enum parameter", 1208 1208 + "name": "parameterEnum", 1209 1209 + "in": "query", 1210 1210 + "required": true, 1211 1211 + "schema": { 1212 1212 + "oneOf": [ 1213 1213 + { 1214 1214 + "enum": ["Success", "Warning", "Error"] 1215 1215 + }, 1216 1216 + { 1217 1217 + "type": "null" 1218 1218 + } 1219 1219 + ] 1220 1220 + } 1221 1221 + }, 1222 1222 + { 1223 1223 + "description": "This is a number parameter", 1224 1224 + "name": "id", 1225 1225 + "in": "path", 1226 1226 + "schema": { 1227 1227 + "type": "integer", 1228 1228 + "format": "int32" 1229 1229 + } 1230 1230 + } 1231 1231 + ], 1232 1232 + "responses": { 1233 1233 + "200": { 1234 1234 + "description": "Response is a simple number", 1235 1235 + "content": { 1236 1236 + "application/json": { 1237 1237 + "schema": { 1238 1238 + "type": "number" 1239 1239 + } 1240 1240 + } 1241 1241 + } 1242 1242 + }, 1243 1243 + "201": { 1244 1244 + "description": "Response is a simple string", 1245 1245 + "content": { 1246 1246 + "application/json": { 1247 1247 + "schema": { 1248 1248 + "type": "string" 1249 1249 + } 1250 1250 + } 1251 1251 + } 1252 1252 + }, 1253 1253 + "202": { 1254 1254 + "description": "Response is a simple boolean", 1255 1255 + "content": { 1256 1256 + "application/json": { 1257 1257 + "schema": { 1258 1258 + "type": "boolean" 1259 1259 + } 1260 1260 + } 1261 1261 + } 1262 1262 + }, 1263 1263 + "203": { 1264 1264 + "description": "Response is a simple object", 1265 1265 + "content": { 1266 1266 + "application/json": { 1267 1267 + "schema": { 1268 1268 + "type": "object" 1269 1269 + } 1270 1270 + } 1271 1271 + } 1272 1272 + } 1273 1273 + } 1274 1274 + } 1275 1275 + }, 1276 1276 + "/api/v{api-version}/upload": { 1277 1277 + "post": { 1278 1278 + "tags": ["Upload"], 1279 1279 + "operationId": "UploadFile", 1280 1280 + "parameters": [ 1281 1281 + { 1282 1282 + "description": "api-version should be required in standalone clients", 1283 1283 + "name": "api-version", 1284 1284 + "in": "path", 1285 1285 + "required": true, 1286 1286 + "schema": { 1287 1287 + "type": ["string", "null"] 1288 1288 + } 1289 1289 + } 1290 1290 + ], 1291 1291 + "requestBody": { 1292 1292 + "content": { 1293 1293 + "application/x-www-form-urlencoded": { 1294 1294 + "description": "Supply a file reference for upload", 1295 1295 + "schema": { 1296 1296 + "format": "binary", 1297 1297 + "type": "string" 1298 1298 + } 1299 1299 + } 1300 1300 + }, 1301 1301 + "required": true 1302 1302 + }, 1303 1303 + "responses": { 1304 1304 + "200": { 1305 1305 + "content": { 1306 1306 + "application/json": { 1307 1307 + "schema": { 1308 1308 + "type": "boolean" 1309 1309 + } 1310 1310 + } 1311 1311 + } 1312 1312 + } 1313 1313 + } 1314 1314 + } 1315 1315 + }, 1316 1316 + "/api/v{api-version}/file/{id}": { 1317 1317 + "get": { 1318 1318 + "tags": ["FileResponse"], 1319 1319 + "operationId": "FileResponse", 1320 1320 + "parameters": [ 1321 1321 + { 1322 1322 + "name": "id", 1323 1323 + "in": "path", 1324 1324 + "required": true, 1325 1325 + "schema": { 1326 1326 + "type": "string" 1327 1327 + } 1328 1328 + }, 1329 1329 + { 1330 1330 + "description": "api-version should be required in standalone clients", 1331 1331 + "name": "api-version", 1332 1332 + "in": "path", 1333 1333 + "required": true, 1334 1334 + "schema": { 1335 1335 + "type": "string" 1336 1336 + } 1337 1337 + } 1338 1338 + ], 1339 1339 + "responses": { 1340 1340 + "200": { 1341 1341 + "description": "Success", 1342 1342 + "content": { 1343 1343 + "audio/*": { 1344 1344 + "schema": { 1345 1345 + "format": "binary", 1346 1346 + "type": "string" 1347 1347 + } 1348 1348 + }, 1349 1349 + "video/*": { 1350 1350 + "schema": { 1351 1351 + "format": "binary", 1352 1352 + "type": "string" 1353 1353 + } 1354 1354 + } 1355 1355 + } 1356 1356 + } 1357 1357 + } 1358 1358 + } 1359 1359 + }, 1360 1360 + "/api/v{api-version}/complex": { 1361 1361 + "get": { 1362 1362 + "tags": ["Complex"], 1363 1363 + "operationId": "ComplexTypes", 1364 1364 + "parameters": [ 1365 1365 + { 1366 1366 + "description": "Parameter containing object", 1367 1367 + "name": "parameterObject", 1368 1368 + "in": "query", 1369 1369 + "required": true, 1370 1370 + "schema": { 1371 1371 + "type": "object", 1372 1372 + "properties": { 1373 1373 + "first": { 1374 1374 + "type": "object", 1375 1375 + "properties": { 1376 1376 + "second": { 1377 1377 + "type": "object", 1378 1378 + "properties": { 1379 1379 + "third": { 1380 1380 + "type": "string" 1381 1381 + } 1382 1382 + } 1383 1383 + } 1384 1384 + } 1385 1385 + } 1386 1386 + } 1387 1387 + } 1388 1388 + }, 1389 1389 + { 1390 1390 + "description": "Parameter containing reference", 1391 1391 + "name": "parameterReference", 1392 1392 + "in": "query", 1393 1393 + "required": true, 1394 1394 + "schema": { 1395 1395 + "$ref": "#/components/schemas/ModelWithString" 1396 1396 + } 1397 1397 + } 1398 1398 + ], 1399 1399 + "responses": { 1400 1400 + "200": { 1401 1401 + "description": "Successful response", 1402 1402 + "content": { 1403 1403 + "application/json": { 1404 1404 + "schema": { 1405 1405 + "type": "array", 1406 1406 + "items": { 1407 1407 + "$ref": "#/components/schemas/ModelWithString" 1408 1408 + } 1409 1409 + } 1410 1410 + } 1411 1411 + } 1412 1412 + }, 1413 1413 + "400": { 1414 1414 + "description": "400 `server` error" 1415 1415 + }, 1416 1416 + "500": { 1417 1417 + "description": "500 server error" 1418 1418 + } 1419 1419 + } 1420 1420 + } 1421 1421 + }, 1422 1422 + "/api/v{api-version}/multipart": { 1423 1423 + "post": { 1424 1424 + "tags": ["multipart"], 1425 1425 + "operationId": "MultipartRequest", 1426 1426 + "requestBody": { 1427 1427 + "content": { 1428 1428 + "multipart/form-data": { 1429 1429 + "schema": { 1430 1430 + "type": "object", 1431 1431 + "properties": { 1432 1432 + "content": { 1433 1433 + "type": "string", 1434 1434 + "format": "binary" 1435 1435 + }, 1436 1436 + "data": { 1437 1437 + "oneOf": [ 1438 1438 + { 1439 1439 + "$ref": "#/components/schemas/ModelWithString" 1440 1440 + }, 1441 1441 + { 1442 1442 + "type": "null" 1443 1443 + } 1444 1444 + ] 1445 1445 + } 1446 1446 + } 1447 1447 + }, 1448 1448 + "encoding": { 1449 1449 + "content": { 1450 1450 + "style": "form" 1451 1451 + }, 1452 1452 + "data": { 1453 1453 + "style": "form" 1454 1454 + } 1455 1455 + } 1456 1456 + } 1457 1457 + } 1458 1458 + } 1459 1459 + }, 1460 1460 + "get": { 1461 1461 + "tags": ["multipart"], 1462 1462 + "operationId": "MultipartResponse", 1463 1463 + "responses": { 1464 1464 + "200": { 1465 1465 + "description": "OK", 1466 1466 + "content": { 1467 1467 + "multipart/mixed": { 1468 1468 + "schema": { 1469 1469 + "type": "object", 1470 1470 + "properties": { 1471 1471 + "file": { 1472 1472 + "type": "string", 1473 1473 + "format": "binary" 1474 1474 + }, 1475 1475 + "metadata": { 1476 1476 + "type": "object", 1477 1477 + "properties": { 1478 1478 + "foo": { 1479 1479 + "type": "string" 1480 1480 + }, 1481 1481 + "bar": { 1482 1482 + "type": "string" 1483 1483 + } 1484 1484 + } 1485 1485 + } 1486 1486 + } 1487 1487 + } 1488 1488 + } 1489 1489 + } 1490 1490 + } 1491 1491 + } 1492 1492 + } 1493 1493 + }, 1494 1494 + "/api/v{api-version}/complex/{id}": { 1495 1495 + "put": { 1496 1496 + "tags": ["Complex"], 1497 1497 + "operationId": "ComplexParams", 1498 1498 + "parameters": [ 1499 1499 + { 1500 1500 + "name": "id", 1501 1501 + "in": "path", 1502 1502 + "required": true, 1503 1503 + "schema": { 1504 1504 + "type": "integer", 1505 1505 + "format": "int32" 1506 1506 + } 1507 1507 + }, 1508 1508 + { 1509 1509 + "description": "api-version should be required in standalone clients", 1510 1510 + "name": "api-version", 1511 1511 + "in": "path", 1512 1512 + "required": true, 1513 1513 + "schema": { 1514 1514 + "type": "string" 1515 1515 + } 1516 1516 + } 1517 1517 + ], 1518 1518 + "requestBody": { 1519 1519 + "content": { 1520 1520 + "application/json-patch+json": { 1521 1521 + "schema": { 1522 1522 + "required": ["key", "name", "parameters", "type"], 1523 1523 + "type": "object", 1524 1524 + "properties": { 1525 1525 + "key": { 1526 1526 + "maxLength": 64, 1527 1527 + "pattern": "^[a-zA-Z0-9_]*$", 1528 1528 + "type": ["string", "null"], 1529 1529 + "readOnly": true 1530 1530 + }, 1531 1531 + "name": { 1532 1532 + "maxLength": 255, 1533 1533 + "type": ["string", "null"] 1534 1534 + }, 1535 1535 + "enabled": { 1536 1536 + "type": "boolean", 1537 1537 + "default": true 1538 1538 + }, 1539 1539 + "type": { 1540 1540 + "enum": ["Monkey", "Horse", "Bird"], 1541 1541 + "type": "string", 1542 1542 + "readOnly": true 1543 1543 + }, 1544 1544 + "listOfModels": { 1545 1545 + "type": ["array", "null"], 1546 1546 + "items": { 1547 1547 + "$ref": "#/components/schemas/ModelWithString" 1548 1548 + } 1549 1549 + }, 1550 1550 + "listOfStrings": { 1551 1551 + "type": ["array", "null"], 1552 1552 + "items": { 1553 1553 + "type": "string" 1554 1554 + } 1555 1555 + }, 1556 1556 + "parameters": { 1557 1557 + "type": "object", 1558 1558 + "oneOf": [ 1559 1559 + { 1560 1560 + "$ref": "#/components/schemas/ModelWithString" 1561 1561 + }, 1562 1562 + { 1563 1563 + "$ref": "#/components/schemas/ModelWithEnum" 1564 1564 + }, 1565 1565 + { 1566 1566 + "$ref": "#/components/schemas/ModelWithArray" 1567 1567 + }, 1568 1568 + { 1569 1569 + "$ref": "#/components/schemas/ModelWithDictionary" 1570 1570 + } 1571 1571 + ] 1572 1572 + }, 1573 1573 + "user": { 1574 1574 + "type": "object", 1575 1575 + "properties": { 1576 1576 + "id": { 1577 1577 + "type": "integer", 1578 1578 + "format": "int32", 1579 1579 + "readOnly": true 1580 1580 + }, 1581 1581 + "name": { 1582 1582 + "type": ["string", "null"], 1583 1583 + "readOnly": true 1584 1584 + } 1585 1585 + }, 1586 1586 + "readOnly": true 1587 1587 + } 1588 1588 + } 1589 1589 + } 1590 1590 + } 1591 1591 + } 1592 1592 + }, 1593 1593 + "responses": { 1594 1594 + "200": { 1595 1595 + "description": "Success", 1596 1596 + "content": { 1597 1597 + "application/json; type=collection": { 1598 1598 + "schema": { 1599 1599 + "$ref": "#/components/schemas/ModelWithString" 1600 1600 + } 1601 1601 + } 1602 1602 + } 1603 1603 + } 1604 1604 + } 1605 1605 + } 1606 1606 + }, 1607 1607 + "/api/v{api-version}/header": { 1608 1608 + "post": { 1609 1609 + "tags": ["Header"], 1610 1610 + "operationId": "CallWithResultFromHeader", 1611 1611 + "responses": { 1612 1612 + "200": { 1613 1613 + "description": "Successful response", 1614 1614 + "headers": { 1615 1615 + "operation-location": { 1616 1616 + "schema": { 1617 1617 + "type": "string" 1618 1618 + } 1619 1619 + } 1620 1620 + } 1621 1621 + }, 1622 1622 + "400": { 1623 1623 + "description": "400 server error" 1624 1624 + }, 1625 1625 + "500": { 1626 1626 + "description": "500 server error" 1627 1627 + } 1628 1628 + } 1629 1629 + } 1630 1630 + }, 1631 1631 + "/api/v{api-version}/error": { 1632 1632 + "post": { 1633 1633 + "tags": ["Error"], 1634 1634 + "operationId": "testErrorCode", 1635 1635 + "parameters": [ 1636 1636 + { 1637 1637 + "description": "Status code to return", 1638 1638 + "name": "status", 1639 1639 + "in": "query", 1640 1640 + "required": true, 1641 1641 + "schema": { 1642 1642 + "type": "integer" 1643 1643 + } 1644 1644 + } 1645 1645 + ], 1646 1646 + "responses": { 1647 1647 + "200": { 1648 1648 + "description": "Custom message: Successful response" 1649 1649 + }, 1650 1650 + "500": { 1651 1651 + "description": "Custom message: Internal Server Error" 1652 1652 + }, 1653 1653 + "501": { 1654 1654 + "description": "Custom message: Not Implemented" 1655 1655 + }, 1656 1656 + "502": { 1657 1657 + "description": "Custom message: Bad Gateway" 1658 1658 + }, 1659 1659 + "503": { 1660 1660 + "description": "Custom message: Service Unavailable" 1661 1661 + } 1662 1662 + } 1663 1663 + } 1664 1664 + }, 1665 1665 + "/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串": { 1666 1666 + "post": { 1667 1667 + "tags": ["Non-Ascii-æøåÆØÅöôêÊ"], 1668 1668 + "operationId": "nonAsciiæøåÆØÅöôêÊ字符串", 1669 1669 + "parameters": [ 1670 1670 + { 1671 1671 + "description": "Dummy input param", 1672 1672 + "name": "nonAsciiParamæøåÆØÅöôêÊ", 1673 1673 + "in": "query", 1674 1674 + "required": true, 1675 1675 + "schema": { 1676 1676 + "type": "integer" 1677 1677 + } 1678 1678 + } 1679 1679 + ], 1680 1680 + "responses": { 1681 1681 + "200": { 1682 1682 + "description": "Successful response", 1683 1683 + "content": { 1684 1684 + "application/json": { 1685 1685 + "schema": { 1686 1686 + "type": "array", 1687 1687 + "items": { 1688 1688 + "$ref": "#/components/schemas/NonAsciiStringæøåÆØÅöôêÊ字符串" 1689 1689 + } 1690 1690 + } 1691 1691 + } 1692 1692 + } 1693 1693 + } 1694 1694 + } 1695 1695 + }, 1696 1696 + "put": { 1697 1697 + "tags": ["Non-Ascii-æøåÆØÅöôêÊ"], 1698 1698 + "summary": "Login User", 1699 1699 + "operationId": "putWithFormUrlEncoded", 1700 1700 + "requestBody": { 1701 1701 + "content": { 1702 1702 + "application/x-www-form-urlencoded": { 1703 1703 + "schema": { 1704 1704 + "$ref": "#/components/schemas/ArrayWithStrings" 1705 1705 + } 1706 1706 + } 1707 1707 + }, 1708 1708 + "required": true 1709 1709 + } 1710 1710 + } 1711 1711 + } 1712 1712 + }, 1713 1713 + "components": { 1714 1714 + "requestBodies": { 1715 1715 + "SimpleRequestBody": { 1716 1716 + "x-body-name": "foo", 1717 1717 + "description": "A reusable request body", 1718 1718 + "required": false, 1719 1719 + "content": { 1720 1720 + "application/json": { 1721 1721 + "schema": { 1722 1722 + "$ref": "#/components/schemas/ModelWithString" 1723 1723 + } 1724 1724 + } 1725 1725 + } 1726 1726 + }, 1727 1727 + "SimpleFormData": { 1728 1728 + "description": "A reusable request body", 1729 1729 + "required": false, 1730 1730 + "content": { 1731 1731 + "multipart/form-data": { 1732 1732 + "schema": { 1733 1733 + "$ref": "#/components/schemas/ModelWithString" 1734 1734 + } 1735 1735 + } 1736 1736 + } 1737 1737 + } 1738 1738 + }, 1739 1739 + "parameters": { 1740 1740 + "SimpleParameter": { 1741 1741 + "description": "This is a reusable parameter", 1742 1742 + "name": "parameter", 1743 1743 + "in": "query", 1744 1744 + "required": false, 1745 1745 + "schema": { 1746 1746 + "type": "string" 1747 1747 + } 1748 1748 + }, 1749 1749 + "x-Foo-Bar": { 1750 1750 + "description": "Parameter with illegal characters", 1751 1751 + "name": "x-Foo-Bar", 1752 1752 + "in": "header", 1753 1753 + "required": true, 1754 1754 + "content": { 1755 1755 + "application/json": { 1756 1756 + "schema": { 1757 1757 + "$ref": "#/components/schemas/ModelWithString" 1758 1758 + } 1759 1759 + } 1760 1760 + } 1761 1761 + } 1762 1762 + }, 1763 1763 + "schemas": { 1764 1764 + "camelCaseCommentWithBreaks": { 1765 1765 + "description": "Testing multiline comments in string: First line\nSecond line\n\nFourth line", 1766 1766 + "type": "integer" 1767 1767 + }, 1768 1768 + "CommentWithBreaks": { 1769 1769 + "description": "Testing multiline comments in string: First line\nSecond line\n\nFourth line", 1770 1770 + "type": "integer" 1771 1771 + }, 1772 1772 + "CommentWithBackticks": { 1773 1773 + "description": "Testing backticks in string: `backticks` and ```multiple backticks``` should work", 1774 1774 + "type": "integer" 1775 1775 + }, 1776 1776 + "CommentWithBackticksAndQuotes": { 1777 1777 + "description": "Testing backticks and quotes in string: `backticks`, 'quotes', \"double quotes\" and ```multiple backticks``` should work", 1778 1778 + "type": "integer" 1779 1779 + }, 1780 1780 + "CommentWithSlashes": { 1781 1781 + "description": "Testing slashes in string: \\backwards\\\\\\ and /forwards/// should work", 1782 1782 + "type": "integer" 1783 1783 + }, 1784 1784 + "CommentWithExpressionPlaceholders": { 1785 1785 + "description": "Testing expression placeholders in string: ${expression} should work", 1786 1786 + "type": "integer" 1787 1787 + }, 1788 1788 + "CommentWithQuotes": { 1789 1789 + "description": "Testing quotes in string: 'single quote''' and \"double quotes\"\"\" should work", 1790 1790 + "type": "integer" 1791 1791 + }, 1792 1792 + "CommentWithReservedCharacters": { 1793 1793 + "description": "Testing reserved characters in string: /* inline */ and /** inline **/ should work", 1794 1794 + "type": "integer" 1795 1795 + }, 1796 1796 + "SimpleInteger": { 1797 1797 + "description": "This is a simple number", 1798 1798 + "type": "integer" 1799 1799 + }, 1800 1800 + "SimpleBoolean": { 1801 1801 + "description": "This is a simple boolean", 1802 1802 + "type": "boolean" 1803 1803 + }, 1804 1804 + "SimpleString": { 1805 1805 + "description": "This is a simple string", 1806 1806 + "type": "string" 1807 1807 + }, 1808 1808 + "NonAsciiStringæøåÆØÅöôêÊ字符串": { 1809 1809 + "description": "A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串)", 1810 1810 + "type": "string" 1811 1811 + }, 1812 1812 + "SimpleFile": { 1813 1813 + "description": "This is a simple file", 1814 1814 + "format": "binary", 1815 1815 + "type": "string" 1816 1816 + }, 1817 1817 + "SimpleReference": { 1818 1818 + "description": "This is a simple reference", 1819 1819 + "$ref": "#/components/schemas/ModelWithString" 1820 1820 + }, 1821 1821 + "SimpleStringWithPattern": { 1822 1822 + "description": "This is a simple string", 1823 1823 + "maxLength": 64, 1824 1824 + "pattern": "^[a-zA-Z0-9_]*$", 1825 1825 + "type": ["string", "null"] 1826 1826 + }, 1827 1827 + "EnumWithStrings": { 1828 1828 + "description": "This is a simple enum with strings", 1829 1829 + "enum": [ 1830 1830 + "Success", 1831 1831 + "Warning", 1832 1832 + "Error", 1833 1833 + "'Single Quote'", 1834 1834 + "\"Double Quotes\"", 1835 1835 + "Non-ascii: øæåôöØÆÅÔÖ字符串" 1836 1836 + ] 1837 1837 + }, 1838 1838 + "EnumWithReplacedCharacters": { 1839 1839 + "enum": [ 1840 1840 + "'Single Quote'", 1841 1841 + "\"Double Quotes\"", 1842 1842 + "øæåôöØÆÅÔÖ字符串", 1843 1843 + 3.1, 1844 1844 + "" 1845 1845 + ], 1846 1846 + "type": "string" 1847 1847 + }, 1848 1848 + "EnumWithNumbers": { 1849 1849 + "description": "This is a simple enum with numbers", 1850 1850 + "enum": [ 1851 1851 + 1, 2, 3, 1.1, 1.2, 1.3, 100, 200, 300, -100, -200, -300, -1.1, -1.2, 1852 1852 + -1.3 1853 1853 + ], 1854 1854 + "default": 200 1855 1855 + }, 1856 1856 + "EnumFromDescription": { 1857 1857 + "description": "Success=1,Warning=2,Error=3", 1858 1858 + "type": "number" 1859 1859 + }, 1860 1860 + "EnumWithExtensions": { 1861 1861 + "description": "This is a simple enum with numbers", 1862 1862 + "enum": [200, 400, 500], 1863 1863 + "x-enum-varnames": ["CUSTOM_SUCCESS", "CUSTOM_WARNING", "CUSTOM_ERROR"], 1864 1864 + "x-enum-descriptions": [ 1865 1865 + "Used when the status of something is successful", 1866 1866 + "Used when the status of something has a warning", 1867 1867 + "Used when the status of something has an error" 1868 1868 + ] 1869 1869 + }, 1870 1870 + "EnumWithXEnumNames": { 1871 1871 + "enum": [0, 1, 2], 1872 1872 + "x-enumNames": ["zero", "one", "two"] 1873 1873 + }, 1874 1874 + "ArrayWithNumbers": { 1875 1875 + "description": "This is a simple array with numbers", 1876 1876 + "type": "array", 1877 1877 + "items": { 1878 1878 + "type": "integer" 1879 1879 + } 1880 1880 + }, 1881 1881 + "ArrayWithBooleans": { 1882 1882 + "description": "This is a simple array with booleans", 1883 1883 + "type": "array", 1884 1884 + "items": { 1885 1885 + "type": "boolean" 1886 1886 + } 1887 1887 + }, 1888 1888 + "ArrayWithStrings": { 1889 1889 + "description": "This is a simple array with strings", 1890 1890 + "type": "array", 1891 1891 + "items": { 1892 1892 + "type": "string" 1893 1893 + }, 1894 1894 + "default": ["test"] 1895 1895 + }, 1896 1896 + "ArrayWithReferences": { 1897 1897 + "description": "This is a simple array with references", 1898 1898 + "type": "array", 1899 1899 + "items": { 1900 1900 + "$ref": "#/components/schemas/ModelWithString" 1901 1901 + } 1902 1902 + }, 1903 1903 + "ArrayWithArray": { 1904 1904 + "description": "This is a simple array containing an array", 1905 1905 + "type": "array", 1906 1906 + "items": { 1907 1907 + "type": "array", 1908 1908 + "items": { 1909 1909 + "$ref": "#/components/schemas/ModelWithString" 1910 1910 + } 1911 1911 + } 1912 1912 + }, 1913 1913 + "ArrayWithProperties": { 1914 1914 + "description": "This is a simple array with properties", 1915 1915 + "type": "array", 1916 1916 + "items": { 1917 1917 + "type": "object", 1918 1918 + "properties": { 1919 1919 + "16x16": { 1920 1920 + "$ref": "#/components/schemas/camelCaseCommentWithBreaks" 1921 1921 + }, 1922 1922 + "bar": { 1923 1923 + "type": "string" 1924 1924 + } 1925 1925 + } 1926 1926 + } 1927 1927 + }, 1928 1928 + "ArrayWithAnyOfProperties": { 1929 1929 + "description": "This is a simple array with any of properties", 1930 1930 + "type": "array", 1931 1931 + "items": { 1932 1932 + "anyOf": [ 1933 1933 + { 1934 1934 + "type": "object", 1935 1935 + "properties": { 1936 1936 + "foo": { 1937 1937 + "type": "string", 1938 1938 + "default": "test" 1939 1939 + } 1940 1940 + } 1941 1941 + }, 1942 1942 + { 1943 1943 + "type": "object", 1944 1944 + "properties": { 1945 1945 + "bar": { 1946 1946 + "type": "string" 1947 1947 + } 1948 1948 + } 1949 1949 + } 1950 1950 + ] 1951 1951 + } 1952 1952 + }, 1953 1953 + "AnyOfAnyAndNull": { 1954 1954 + "type": "object", 1955 1955 + "properties": { 1956 1956 + "data": { 1957 1957 + "anyOf": [ 1958 1958 + {}, 1959 1959 + { 1960 1960 + "type": "null" 1961 1961 + } 1962 1962 + ] 1963 1963 + } 1964 1964 + } 1965 1965 + }, 1966 1966 + "AnyOfArrays": { 1967 1967 + "description": "This is a simple array with any of properties", 1968 1968 + "type": "object", 1969 1969 + "properties": { 1970 1970 + "results": { 1971 1971 + "items": { 1972 1972 + "anyOf": [ 1973 1973 + { 1974 1974 + "type": "object", 1975 1975 + "properties": { 1976 1976 + "foo": { 1977 1977 + "type": "string" 1978 1978 + } 1979 1979 + } 1980 1980 + }, 1981 1981 + { 1982 1982 + "type": "object", 1983 1983 + "properties": { 1984 1984 + "bar": { 1985 1985 + "type": "string" 1986 1986 + } 1987 1987 + } 1988 1988 + } 1989 1989 + ] 1990 1990 + }, 1991 1991 + "type": "array" 1992 1992 + } 1993 1993 + } 1994 1994 + }, 1995 1995 + "DictionaryWithString": { 1996 1996 + "description": "This is a string dictionary", 1997 1997 + "type": "object", 1998 1998 + "additionalProperties": { 1999 1999 + "type": "string" 2000 2000 + } 2001 2001 + }, 2002 2002 + "DictionaryWithPropertiesAndAdditionalProperties": { 2003 2003 + "type": "object", 2004 2004 + "properties": { 2005 2005 + "foo": { 2006 2006 + "type": "number" 2007 2007 + }, 2008 2008 + "bar": { 2009 2009 + "type": "boolean" 2010 2010 + } 2011 2011 + }, 2012 2012 + "additionalProperties": { 2013 2013 + "type": "string" 2014 2014 + } 2015 2015 + }, 2016 2016 + "DictionaryWithReference": { 2017 2017 + "description": "This is a string reference", 2018 2018 + "type": "object", 2019 2019 + "additionalProperties": { 2020 2020 + "$ref": "#/components/schemas/ModelWithString" 2021 2021 + } 2022 2022 + }, 2023 2023 + "DictionaryWithArray": { 2024 2024 + "description": "This is a complex dictionary", 2025 2025 + "type": "object", 2026 2026 + "additionalProperties": { 2027 2027 + "type": "array", 2028 2028 + "items": { 2029 2029 + "$ref": "#/components/schemas/ModelWithString" 2030 2030 + } 2031 2031 + } 2032 2032 + }, 2033 2033 + "DictionaryWithDictionary": { 2034 2034 + "description": "This is a string dictionary", 2035 2035 + "type": "object", 2036 2036 + "additionalProperties": { 2037 2037 + "type": "object", 2038 2038 + "additionalProperties": { 2039 2039 + "type": "string" 2040 2040 + } 2041 2041 + } 2042 2042 + }, 2043 2043 + "DictionaryWithProperties": { 2044 2044 + "description": "This is a complex dictionary", 2045 2045 + "type": "object", 2046 2046 + "additionalProperties": { 2047 2047 + "type": "object", 2048 2048 + "properties": { 2049 2049 + "foo": { 2050 2050 + "type": "string" 2051 2051 + }, 2052 2052 + "bar": { 2053 2053 + "type": "string" 2054 2054 + } 2055 2055 + } 2056 2056 + } 2057 2057 + }, 2058 2058 + "ModelWithInteger": { 2059 2059 + "description": "This is a model with one number property", 2060 2060 + "type": "object", 2061 2061 + "properties": { 2062 2062 + "prop": { 2063 2063 + "description": "This is a simple number property", 2064 2064 + "type": "integer" 2065 2065 + } 2066 2066 + } 2067 2067 + }, 2068 2068 + "ModelWithBoolean": { 2069 2069 + "description": "This is a model with one boolean property", 2070 2070 + "type": "object", 2071 2071 + "properties": { 2072 2072 + "prop": { 2073 2073 + "description": "This is a simple boolean property", 2074 2074 + "type": "boolean" 2075 2075 + } 2076 2076 + } 2077 2077 + }, 2078 2078 + "ModelWithString": { 2079 2079 + "description": "This is a model with one string property", 2080 2080 + "type": "object", 2081 2081 + "properties": { 2082 2082 + "prop": { 2083 2083 + "description": "This is a simple string property", 2084 2084 + "type": "string" 2085 2085 + } 2086 2086 + } 2087 2087 + }, 2088 2088 + "ModelWithStringError": { 2089 2089 + "description": "This is a model with one string property", 2090 2090 + "type": "object", 2091 2091 + "properties": { 2092 2092 + "prop": { 2093 2093 + "description": "This is a simple string property", 2094 2094 + "type": "string" 2095 2095 + } 2096 2096 + } 2097 2097 + }, 2098 2098 + "Model-From.Zendesk": { 2099 2099 + "description": "`Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets)", 2100 2100 + "type": "string" 2101 2101 + }, 2102 2102 + "ModelWithNullableString": { 2103 2103 + "description": "This is a model with one string property", 2104 2104 + "type": "object", 2105 2105 + "required": ["nullableRequiredProp1", "nullableRequiredProp2"], 2106 2106 + "properties": { 2107 2107 + "nullableProp1": { 2108 2108 + "description": "This is a simple string property", 2109 2109 + "type": ["string", "null"] 2110 2110 + }, 2111 2111 + "nullableRequiredProp1": { 2112 2112 + "description": "This is a simple string property", 2113 2113 + "type": ["string", "null"] 2114 2114 + }, 2115 2115 + "nullableProp2": { 2116 2116 + "description": "This is a simple string property", 2117 2117 + "type": ["string", "null"] 2118 2118 + }, 2119 2119 + "nullableRequiredProp2": { 2120 2120 + "description": "This is a simple string property", 2121 2121 + "type": ["string", "null"] 2122 2122 + }, 2123 2123 + "foo_bar-enum": { 2124 2124 + "description": "This is a simple enum with strings", 2125 2125 + "enum": ["Success", "Warning", "Error", "ØÆÅ字符串"] 2126 2126 + } 2127 2127 + } 2128 2128 + }, 2129 2129 + "ModelWithEnum": { 2130 2130 + "description": "This is a model with one enum", 2131 2131 + "type": "object", 2132 2132 + "properties": { 2133 2133 + "foo_bar-enum": { 2134 2134 + "description": "This is a simple enum with strings", 2135 2135 + "enum": ["Success", "Warning", "Error", "ØÆÅ字符串"] 2136 2136 + }, 2137 2137 + "statusCode": { 2138 2138 + "description": "These are the HTTP error code enums", 2139 2139 + "enum": [ 2140 2140 + "100", 2141 2141 + "200 FOO", 2142 2142 + "300 FOO_BAR", 2143 2143 + "400 foo-bar", 2144 2144 + "500 foo.bar", 2145 2145 + "600 foo&bar" 2146 2146 + ] 2147 2147 + }, 2148 2148 + "bool": { 2149 2149 + "description": "Simple boolean enum", 2150 2150 + "type": "boolean", 2151 2151 + "enum": [true] 2152 2152 + } 2153 2153 + } 2154 2154 + }, 2155 2155 + "ModelWithEnumWithHyphen": { 2156 2156 + "description": "This is a model with one enum with escaped name", 2157 2157 + "type": "object", 2158 2158 + "properties": { 2159 2159 + "foo-bar-baz-qux": { 2160 2160 + "type": "string", 2161 2161 + "enum": ["3.0"], 2162 2162 + "title": "Foo-Bar-Baz-Qux", 2163 2163 + "default": "3.0" 2164 2164 + } 2165 2165 + } 2166 2166 + }, 2167 2167 + "ModelWithEnumFromDescription": { 2168 2168 + "description": "This is a model with one enum", 2169 2169 + "type": "object", 2170 2170 + "properties": { 2171 2171 + "test": { 2172 2172 + "type": "integer", 2173 2173 + "description": "Success=1,Warning=2,Error=3" 2174 2174 + } 2175 2175 + } 2176 2176 + }, 2177 2177 + "ModelWithNestedEnums": { 2178 2178 + "description": "This is a model with nested enums", 2179 2179 + "type": "object", 2180 2180 + "properties": { 2181 2181 + "dictionaryWithEnum": { 2182 2182 + "type": "object", 2183 2183 + "additionalProperties": { 2184 2184 + "enum": ["Success", "Warning", "Error"] 2185 2185 + } 2186 2186 + }, 2187 2187 + "dictionaryWithEnumFromDescription": { 2188 2188 + "type": "object", 2189 2189 + "additionalProperties": { 2190 2190 + "type": "integer", 2191 2191 + "description": "Success=1,Warning=2,Error=3" 2192 2192 + } 2193 2193 + }, 2194 2194 + "arrayWithEnum": { 2195 2195 + "type": "array", 2196 2196 + "items": { 2197 2197 + "enum": ["Success", "Warning", "Error"] 2198 2198 + } 2199 2199 + }, 2200 2200 + "arrayWithDescription": { 2201 2201 + "type": "array", 2202 2202 + "items": { 2203 2203 + "type": "integer", 2204 2204 + "description": "Success=1,Warning=2,Error=3" 2205 2205 + } 2206 2206 + }, 2207 2207 + "foo_bar-enum": { 2208 2208 + "description": "This is a simple enum with strings", 2209 2209 + "enum": ["Success", "Warning", "Error", "ØÆÅ字符串"] 2210 2210 + } 2211 2211 + } 2212 2212 + }, 2213 2213 + "ModelWithReference": { 2214 2214 + "description": "This is a model with one property containing a reference", 2215 2215 + "type": "object", 2216 2216 + "properties": { 2217 2217 + "prop": { 2218 2218 + "$ref": "#/components/schemas/ModelWithProperties" 2219 2219 + } 2220 2220 + } 2221 2221 + }, 2222 2222 + "ModelWithArrayReadOnlyAndWriteOnly": { 2223 2223 + "description": "This is a model with one property containing an array", 2224 2224 + "type": "object", 2225 2225 + "properties": { 2226 2226 + "prop": { 2227 2227 + "type": "array", 2228 2228 + "items": { 2229 2229 + "$ref": "#/components/schemas/ModelWithReadOnlyAndWriteOnly" 2230 2230 + } 2231 2231 + }, 2232 2232 + "propWithFile": { 2233 2233 + "type": "array", 2234 2234 + "items": { 2235 2235 + "format": "binary", 2236 2236 + "type": "string" 2237 2237 + } 2238 2238 + }, 2239 2239 + "propWithNumber": { 2240 2240 + "type": "array", 2241 2241 + "items": { 2242 2242 + "type": "number" 2243 2243 + } 2244 2244 + } 2245 2245 + } 2246 2246 + }, 2247 2247 + "ModelWithArray": { 2248 2248 + "description": "This is a model with one property containing an array", 2249 2249 + "type": "object", 2250 2250 + "properties": { 2251 2251 + "prop": { 2252 2252 + "type": "array", 2253 2253 + "items": { 2254 2254 + "$ref": "#/components/schemas/ModelWithString" 2255 2255 + } 2256 2256 + }, 2257 2257 + "propWithFile": { 2258 2258 + "type": "array", 2259 2259 + "items": { 2260 2260 + "format": "binary", 2261 2261 + "type": "string" 2262 2262 + } 2263 2263 + }, 2264 2264 + "propWithNumber": { 2265 2265 + "type": "array", 2266 2266 + "items": { 2267 2267 + "type": "number" 2268 2268 + } 2269 2269 + } 2270 2270 + } 2271 2271 + }, 2272 2272 + "ModelWithDictionary": { 2273 2273 + "description": "This is a model with one property containing a dictionary", 2274 2274 + "type": "object", 2275 2275 + "properties": { 2276 2276 + "prop": { 2277 2277 + "type": "object", 2278 2278 + "additionalProperties": { 2279 2279 + "type": "string" 2280 2280 + } 2281 2281 + } 2282 2282 + } 2283 2283 + }, 2284 2284 + "DeprecatedModel": { 2285 2285 + "deprecated": true, 2286 2286 + "description": "This is a deprecated model with a deprecated property", 2287 2287 + "type": "object", 2288 2288 + "properties": { 2289 2289 + "prop": { 2290 2290 + "deprecated": true, 2291 2291 + "description": "This is a deprecated property", 2292 2292 + "type": "string" 2293 2293 + } 2294 2294 + } 2295 2295 + }, 2296 2296 + "ModelWithCircularReference": { 2297 2297 + "description": "This is a model with one property containing a circular reference", 2298 2298 + "type": "object", 2299 2299 + "properties": { 2300 2300 + "prop": { 2301 2301 + "$ref": "#/components/schemas/ModelWithCircularReference" 2302 2302 + } 2303 2303 + } 2304 2304 + }, 2305 2305 + "CompositionWithOneOf": { 2306 2306 + "description": "This is a model with one property with a 'one of' relationship", 2307 2307 + "type": "object", 2308 2308 + "properties": { 2309 2309 + "propA": { 2310 2310 + "type": "object", 2311 2311 + "oneOf": [ 2312 2312 + { 2313 2313 + "$ref": "#/components/schemas/ModelWithString" 2314 2314 + }, 2315 2315 + { 2316 2316 + "$ref": "#/components/schemas/ModelWithEnum" 2317 2317 + }, 2318 2318 + { 2319 2319 + "$ref": "#/components/schemas/ModelWithArray" 2320 2320 + }, 2321 2321 + { 2322 2322 + "$ref": "#/components/schemas/ModelWithDictionary" 2323 2323 + } 2324 2324 + ] 2325 2325 + } 2326 2326 + } 2327 2327 + }, 2328 2328 + "CompositionWithOneOfAnonymous": { 2329 2329 + "description": "This is a model with one property with a 'one of' relationship where the options are not $ref", 2330 2330 + "type": "object", 2331 2331 + "properties": { 2332 2332 + "propA": { 2333 2333 + "type": "object", 2334 2334 + "oneOf": [ 2335 2335 + { 2336 2336 + "description": "Anonymous object type", 2337 2337 + "type": "object", 2338 2338 + "properties": { 2339 2339 + "propA": { 2340 2340 + "type": "string" 2341 2341 + } 2342 2342 + } 2343 2343 + }, 2344 2344 + { 2345 2345 + "description": "Anonymous string type", 2346 2346 + "type": "string" 2347 2347 + }, 2348 2348 + { 2349 2349 + "description": "Anonymous integer type", 2350 2350 + "type": "integer" 2351 2351 + } 2352 2352 + ] 2353 2353 + } 2354 2354 + } 2355 2355 + }, 2356 2356 + "ModelCircle": { 2357 2357 + "description": "Circle", 2358 2358 + "type": "object", 2359 2359 + "required": ["kind"], 2360 2360 + "properties": { 2361 2361 + "kind": { 2362 2362 + "type": "string" 2363 2363 + }, 2364 2364 + "radius": { 2365 2365 + "type": "number" 2366 2366 + } 2367 2367 + } 2368 2368 + }, 2369 2369 + "ModelSquare": { 2370 2370 + "description": "Square", 2371 2371 + "type": "object", 2372 2372 + "required": ["kind"], 2373 2373 + "properties": { 2374 2374 + "kind": { 2375 2375 + "type": "string" 2376 2376 + }, 2377 2377 + "sideLength": { 2378 2378 + "type": "number" 2379 2379 + } 2380 2380 + } 2381 2381 + }, 2382 2382 + "CompositionWithOneOfDiscriminator": { 2383 2383 + "description": "This is a model with one property with a 'one of' relationship where the options are not $ref", 2384 2384 + "type": "object", 2385 2385 + "oneOf": [ 2386 2386 + { 2387 2387 + "$ref": "#/components/schemas/ModelCircle" 2388 2388 + }, 2389 2389 + { 2390 2390 + "$ref": "#/components/schemas/ModelSquare" 2391 2391 + } 2392 2392 + ], 2393 2393 + "discriminator": { 2394 2394 + "propertyName": "kind", 2395 2395 + "mapping": { 2396 2396 + "circle": "#/components/schemas/ModelCircle", 2397 2397 + "square": "#/components/schemas/ModelSquare" 2398 2398 + } 2399 2399 + } 2400 2400 + }, 2401 2401 + "CompositionWithAnyOf": { 2402 2402 + "description": "This is a model with one property with a 'any of' relationship", 2403 2403 + "type": "object", 2404 2404 + "properties": { 2405 2405 + "propA": { 2406 2406 + "type": "object", 2407 2407 + "anyOf": [ 2408 2408 + { 2409 2409 + "$ref": "#/components/schemas/ModelWithString" 2410 2410 + }, 2411 2411 + { 2412 2412 + "$ref": "#/components/schemas/ModelWithEnum" 2413 2413 + }, 2414 2414 + { 2415 2415 + "$ref": "#/components/schemas/ModelWithArray" 2416 2416 + }, 2417 2417 + { 2418 2418 + "$ref": "#/components/schemas/ModelWithDictionary" 2419 2419 + } 2420 2420 + ] 2421 2421 + } 2422 2422 + } 2423 2423 + }, 2424 2424 + "CompositionWithAnyOfAnonymous": { 2425 2425 + "description": "This is a model with one property with a 'any of' relationship where the options are not $ref", 2426 2426 + "type": "object", 2427 2427 + "properties": { 2428 2428 + "propA": { 2429 2429 + "type": "object", 2430 2430 + "anyOf": [ 2431 2431 + { 2432 2432 + "description": "Anonymous object type", 2433 2433 + "type": "object", 2434 2434 + "properties": { 2435 2435 + "propA": { 2436 2436 + "type": "string" 2437 2437 + } 2438 2438 + } 2439 2439 + }, 2440 2440 + { 2441 2441 + "description": "Anonymous string type", 2442 2442 + "type": "string" 2443 2443 + }, 2444 2444 + { 2445 2445 + "description": "Anonymous integer type", 2446 2446 + "type": "integer" 2447 2447 + } 2448 2448 + ] 2449 2449 + } 2450 2450 + } 2451 2451 + }, 2452 2452 + "CompositionWithNestedAnyAndTypeNull": { 2453 2453 + "description": "This is a model with nested 'any of' property with a type null", 2454 2454 + "type": "object", 2455 2455 + "properties": { 2456 2456 + "propA": { 2457 2457 + "type": "object", 2458 2458 + "anyOf": [ 2459 2459 + { 2460 2460 + "items": { 2461 2461 + "anyOf": [ 2462 2462 + { 2463 2463 + "$ref": "#/components/schemas/ModelWithDictionary" 2464 2464 + }, 2465 2465 + { 2466 2466 + "type": "null" 2467 2467 + } 2468 2468 + ] 2469 2469 + }, 2470 2470 + "type": "array" 2471 2471 + }, 2472 2472 + { 2473 2473 + "items": { 2474 2474 + "anyOf": [ 2475 2475 + { 2476 2476 + "$ref": "#/components/schemas/ModelWithArray" 2477 2477 + }, 2478 2478 + { 2479 2479 + "type": "null" 2480 2480 + } 2481 2481 + ] 2482 2482 + }, 2483 2483 + "type": "array" 2484 2484 + } 2485 2485 + ] 2486 2486 + } 2487 2487 + } 2488 2488 + }, 2489 2489 + "3e-num_1Период": { 2490 2490 + "enum": ["Bird", "Dog"], 2491 2491 + "type": "string" 2492 2492 + }, 2493 2493 + "ConstValue": { 2494 2494 + "type": "string", 2495 2495 + "const": "ConstValue" 2496 2496 + }, 2497 2497 + "CompositionWithNestedAnyOfAndNull": { 2498 2498 + "description": "This is a model with one property with a 'any of' relationship where the options are not $ref", 2499 2499 + "type": "object", 2500 2500 + "properties": { 2501 2501 + "propA": { 2502 2502 + "anyOf": [ 2503 2503 + { 2504 2504 + "items": { 2505 2505 + "anyOf": [ 2506 2506 + { 2507 2507 + "$ref": "#/components/schemas/3e-num_1Период" 2508 2508 + }, 2509 2509 + { 2510 2510 + "$ref": "#/components/schemas/ConstValue" 2511 2511 + } 2512 2512 + ] 2513 2513 + }, 2514 2514 + "type": "array" 2515 2515 + }, 2516 2516 + { 2517 2517 + "type": "null" 2518 2518 + } 2519 2519 + ], 2520 2520 + "title": "Scopes" 2521 2521 + } 2522 2522 + } 2523 2523 + }, 2524 2524 + "CompositionWithOneOfAndNullable": { 2525 2525 + "description": "This is a model with one property with a 'one of' relationship", 2526 2526 + "type": "object", 2527 2527 + "properties": { 2528 2528 + "propA": { 2529 2529 + "type": ["object", "null"], 2530 2530 + "oneOf": [ 2531 2531 + { 2532 2532 + "type": "object", 2533 2533 + "properties": { 2534 2534 + "boolean": { 2535 2535 + "type": "boolean" 2536 2536 + } 2537 2537 + } 2538 2538 + }, 2539 2539 + { 2540 2540 + "$ref": "#/components/schemas/ModelWithEnum" 2541 2541 + }, 2542 2542 + { 2543 2543 + "$ref": "#/components/schemas/ModelWithArray" 2544 2544 + }, 2545 2545 + { 2546 2546 + "$ref": "#/components/schemas/ModelWithDictionary" 2547 2547 + } 2548 2548 + ] 2549 2549 + } 2550 2550 + } 2551 2551 + }, 2552 2552 + "CompositionWithOneOfAndSimpleDictionary": { 2553 2553 + "description": "This is a model that contains a simple dictionary within composition", 2554 2554 + "type": "object", 2555 2555 + "properties": { 2556 2556 + "propA": { 2557 2557 + "oneOf": [ 2558 2558 + { 2559 2559 + "type": "boolean" 2560 2560 + }, 2561 2561 + { 2562 2562 + "type": "object", 2563 2563 + "additionalProperties": { 2564 2564 + "type": "number" 2565 2565 + } 2566 2566 + } 2567 2567 + ] 2568 2568 + } 2569 2569 + } 2570 2570 + }, 2571 2571 + "CompositionWithOneOfAndSimpleArrayDictionary": { 2572 2572 + "description": "This is a model that contains a dictionary of simple arrays within composition", 2573 2573 + "type": "object", 2574 2574 + "properties": { 2575 2575 + "propA": { 2576 2576 + "oneOf": [ 2577 2577 + { 2578 2578 + "type": "boolean" 2579 2579 + }, 2580 2580 + { 2581 2581 + "type": "object", 2582 2582 + "additionalProperties": { 2583 2583 + "type": "array", 2584 2584 + "items": { 2585 2585 + "type": "boolean" 2586 2586 + } 2587 2587 + } 2588 2588 + } 2589 2589 + ] 2590 2590 + } 2591 2591 + } 2592 2592 + }, 2593 2593 + "CompositionWithOneOfAndComplexArrayDictionary": { 2594 2594 + "description": "This is a model that contains a dictionary of complex arrays (composited) within composition", 2595 2595 + "type": "object", 2596 2596 + "properties": { 2597 2597 + "propA": { 2598 2598 + "oneOf": [ 2599 2599 + { 2600 2600 + "type": "boolean" 2601 2601 + }, 2602 2602 + { 2603 2603 + "type": "object", 2604 2604 + "additionalProperties": { 2605 2605 + "type": "array", 2606 2606 + "items": { 2607 2607 + "oneOf": [ 2608 2608 + { 2609 2609 + "type": "number" 2610 2610 + }, 2611 2611 + { 2612 2612 + "type": "string" 2613 2613 + } 2614 2614 + ] 2615 2615 + } 2616 2616 + } 2617 2617 + } 2618 2618 + ] 2619 2619 + } 2620 2620 + } 2621 2621 + }, 2622 2622 + "CompositionWithAllOfAndNullable": { 2623 2623 + "description": "This is a model with one property with a 'all of' relationship", 2624 2624 + "type": "object", 2625 2625 + "properties": { 2626 2626 + "propA": { 2627 2627 + "type": ["object", "null"], 2628 2628 + "allOf": [ 2629 2629 + { 2630 2630 + "type": "object", 2631 2631 + "properties": { 2632 2632 + "boolean": { 2633 2633 + "type": "boolean" 2634 2634 + } 2635 2635 + } 2636 2636 + }, 2637 2637 + { 2638 2638 + "$ref": "#/components/schemas/ModelWithEnum" 2639 2639 + }, 2640 2640 + { 2641 2641 + "$ref": "#/components/schemas/ModelWithArray" 2642 2642 + }, 2643 2643 + { 2644 2644 + "$ref": "#/components/schemas/ModelWithDictionary" 2645 2645 + } 2646 2646 + ] 2647 2647 + } 2648 2648 + } 2649 2649 + }, 2650 2650 + "CompositionWithAnyOfAndNullable": { 2651 2651 + "description": "This is a model with one property with a 'any of' relationship", 2652 2652 + "type": "object", 2653 2653 + "properties": { 2654 2654 + "propA": { 2655 2655 + "type": ["object", "null"], 2656 2656 + "anyOf": [ 2657 2657 + { 2658 2658 + "type": "object", 2659 2659 + "properties": { 2660 2660 + "boolean": { 2661 2661 + "type": "boolean" 2662 2662 + } 2663 2663 + } 2664 2664 + }, 2665 2665 + { 2666 2666 + "$ref": "#/components/schemas/ModelWithEnum" 2667 2667 + }, 2668 2668 + { 2669 2669 + "$ref": "#/components/schemas/ModelWithArray" 2670 2670 + }, 2671 2671 + { 2672 2672 + "$ref": "#/components/schemas/ModelWithDictionary" 2673 2673 + } 2674 2674 + ] 2675 2675 + } 2676 2676 + } 2677 2677 + }, 2678 2678 + "CompositionBaseModel": { 2679 2679 + "description": "This is a base model with two simple optional properties", 2680 2680 + "type": "object", 2681 2681 + "properties": { 2682 2682 + "firstName": { 2683 2683 + "type": "string" 2684 2684 + }, 2685 2685 + "lastname": { 2686 2686 + "type": "string" 2687 2687 + } 2688 2688 + } 2689 2689 + }, 2690 2690 + "CompositionExtendedModel": { 2691 2691 + "description": "This is a model that extends the base model", 2692 2692 + "type": "object", 2693 2693 + "allOf": [ 2694 2694 + { 2695 2695 + "$ref": "#/components/schemas/CompositionBaseModel" 2696 2696 + } 2697 2697 + ], 2698 2698 + "properties": { 2699 2699 + "age": { 2700 2700 + "type": "number" 2701 2701 + } 2702 2702 + }, 2703 2703 + "required": ["firstName", "lastname", "age"] 2704 2704 + }, 2705 2705 + "ModelWithProperties": { 2706 2706 + "description": "This is a model with one nested property", 2707 2707 + "type": "object", 2708 2708 + "required": ["required", "requiredAndReadOnly", "requiredAndNullable"], 2709 2709 + "properties": { 2710 2710 + "required": { 2711 2711 + "type": "string" 2712 2712 + }, 2713 2713 + "requiredAndReadOnly": { 2714 2714 + "type": "string", 2715 2715 + "readOnly": true 2716 2716 + }, 2717 2717 + "requiredAndNullable": { 2718 2718 + "type": ["string", "null"] 2719 2719 + }, 2720 2720 + "string": { 2721 2721 + "type": "string" 2722 2722 + }, 2723 2723 + "number": { 2724 2724 + "type": "number" 2725 2725 + }, 2726 2726 + "boolean": { 2727 2727 + "type": "boolean" 2728 2728 + }, 2729 2729 + "reference": { 2730 2730 + "$ref": "#/components/schemas/ModelWithString" 2731 2731 + }, 2732 2732 + "property with space": { 2733 2733 + "type": "string" 2734 2734 + }, 2735 2735 + "default": { 2736 2736 + "type": "string" 2737 2737 + }, 2738 2738 + "try": { 2739 2739 + "type": "string" 2740 2740 + }, 2741 2741 + "@namespace.string": { 2742 2742 + "type": "string", 2743 2743 + "readOnly": true 2744 2744 + }, 2745 2745 + "@namespace.integer": { 2746 2746 + "type": "integer", 2747 2747 + "readOnly": true 2748 2748 + } 2749 2749 + } 2750 2750 + }, 2751 2751 + "ModelWithNestedProperties": { 2752 2752 + "description": "This is a model with one nested property", 2753 2753 + "type": "object", 2754 2754 + "required": ["first"], 2755 2755 + "properties": { 2756 2756 + "first": { 2757 2757 + "type": ["object", "null"], 2758 2758 + "required": ["second"], 2759 2759 + "readOnly": true, 2760 2760 + "properties": { 2761 2761 + "second": { 2762 2762 + "type": ["object", "null"], 2763 2763 + "required": ["third"], 2764 2764 + "readOnly": true, 2765 2765 + "properties": { 2766 2766 + "third": { 2767 2767 + "type": ["string", "null"], 2768 2768 + "required": true, 2769 2769 + "readOnly": true 2770 2770 + } 2771 2771 + } 2772 2772 + } 2773 2773 + } 2774 2774 + } 2775 2775 + } 2776 2776 + }, 2777 2777 + "ModelWithDuplicateProperties": { 2778 2778 + "description": "This is a model with duplicated properties", 2779 2779 + "type": "object", 2780 2780 + "properties": { 2781 2781 + "prop": { 2782 2782 + "$ref": "#/components/schemas/ModelWithString" 2783 2783 + }, 2784 2784 + "prop": { 2785 2785 + "$ref": "#/components/schemas/ModelWithString" 2786 2786 + }, 2787 2787 + "prop": { 2788 2788 + "$ref": "#/components/schemas/ModelWithString" 2789 2789 + } 2790 2790 + } 2791 2791 + }, 2792 2792 + "ModelWithOrderedProperties": { 2793 2793 + "description": "This is a model with ordered properties", 2794 2794 + "type": "object", 2795 2795 + "properties": { 2796 2796 + "zebra": { 2797 2797 + "type": "string" 2798 2798 + }, 2799 2799 + "apple": { 2800 2800 + "type": "string" 2801 2801 + }, 2802 2802 + "hawaii": { 2803 2803 + "type": "string" 2804 2804 + } 2805 2805 + } 2806 2806 + }, 2807 2807 + "ModelWithDuplicateImports": { 2808 2808 + "description": "This is a model with duplicated imports", 2809 2809 + "type": "object", 2810 2810 + "properties": { 2811 2811 + "propA": { 2812 2812 + "$ref": "#/components/schemas/ModelWithString" 2813 2813 + }, 2814 2814 + "propB": { 2815 2815 + "$ref": "#/components/schemas/ModelWithString" 2816 2816 + }, 2817 2817 + "propC": { 2818 2818 + "$ref": "#/components/schemas/ModelWithString" 2819 2819 + } 2820 2820 + } 2821 2821 + }, 2822 2822 + "ModelThatExtends": { 2823 2823 + "description": "This is a model that extends another model", 2824 2824 + "type": "object", 2825 2825 + "allOf": [ 2826 2826 + { 2827 2827 + "$ref": "#/components/schemas/ModelWithString" 2828 2828 + }, 2829 2829 + { 2830 2830 + "type": "object", 2831 2831 + "properties": { 2832 2832 + "propExtendsA": { 2833 2833 + "type": "string" 2834 2834 + }, 2835 2835 + "propExtendsB": { 2836 2836 + "$ref": "#/components/schemas/ModelWithString" 2837 2837 + } 2838 2838 + } 2839 2839 + } 2840 2840 + ] 2841 2841 + }, 2842 2842 + "ModelThatExtendsExtends": { 2843 2843 + "description": "This is a model that extends another model", 2844 2844 + "type": "object", 2845 2845 + "allOf": [ 2846 2846 + { 2847 2847 + "$ref": "#/components/schemas/ModelWithString" 2848 2848 + }, 2849 2849 + { 2850 2850 + "$ref": "#/components/schemas/ModelThatExtends" 2851 2851 + }, 2852 2852 + { 2853 2853 + "type": "object", 2854 2854 + "properties": { 2855 2855 + "propExtendsC": { 2856 2856 + "type": "string" 2857 2857 + }, 2858 2858 + "propExtendsD": { 2859 2859 + "$ref": "#/components/schemas/ModelWithString" 2860 2860 + } 2861 2861 + } 2862 2862 + } 2863 2863 + ] 2864 2864 + }, 2865 2865 + "ModelWithPattern": { 2866 2866 + "description": "This is a model that contains a some patterns", 2867 2867 + "type": "object", 2868 2868 + "required": ["key", "name"], 2869 2869 + "properties": { 2870 2870 + "key": { 2871 2871 + "maxLength": 64, 2872 2872 + "pattern": "^[a-zA-Z0-9_]*$", 2873 2873 + "type": "string" 2874 2874 + }, 2875 2875 + "name": { 2876 2876 + "maxLength": 255, 2877 2877 + "type": "string" 2878 2878 + }, 2879 2879 + "enabled": { 2880 2880 + "type": "boolean", 2881 2881 + "readOnly": true 2882 2882 + }, 2883 2883 + "modified": { 2884 2884 + "type": "string", 2885 2885 + "format": "date-time", 2886 2886 + "readOnly": true 2887 2887 + }, 2888 2888 + "id": { 2889 2889 + "type": "string", 2890 2890 + "pattern": "^\\d{2}-\\d{3}-\\d{4}$" 2891 2891 + }, 2892 2892 + "text": { 2893 2893 + "type": "string", 2894 2894 + "pattern": "^\\w+$" 2895 2895 + }, 2896 2896 + "patternWithSingleQuotes": { 2897 2897 + "type": "string", 2898 2898 + "pattern": "^[a-zA-Z0-9']*$" 2899 2899 + }, 2900 2900 + "patternWithNewline": { 2901 2901 + "type": "string", 2902 2902 + "pattern": "aaa\nbbb" 2903 2903 + }, 2904 2904 + "patternWithBacktick": { 2905 2905 + "type": "string", 2906 2906 + "pattern": "aaa`bbb" 2907 2907 + } 2908 2908 + } 2909 2909 + }, 2910 2910 + "File": { 2911 2911 + "required": ["mime"], 2912 2912 + "type": "object", 2913 2913 + "properties": { 2914 2914 + "id": { 2915 2915 + "title": "Id", 2916 2916 + "type": "string", 2917 2917 + "readOnly": true, 2918 2918 + "minLength": 1 2919 2919 + }, 2920 2920 + "updated_at": { 2921 2921 + "title": "Updated at", 2922 2922 + "type": "string", 2923 2923 + "format": "date-time", 2924 2924 + "readOnly": true 2925 2925 + }, 2926 2926 + "created_at": { 2927 2927 + "title": "Created at", 2928 2928 + "type": "string", 2929 2929 + "format": "date-time", 2930 2930 + "readOnly": true 2931 2931 + }, 2932 2932 + "mime": { 2933 2933 + "title": "Mime", 2934 2934 + "type": "string", 2935 2935 + "maxLength": 24, 2936 2936 + "minLength": 1 2937 2937 + }, 2938 2938 + "file": { 2939 2939 + "title": "File", 2940 2940 + "type": "string", 2941 2941 + "readOnly": true, 2942 2942 + "format": "uri" 2943 2943 + } 2944 2944 + } 2945 2945 + }, 2946 2946 + "default": { 2947 2947 + "type": "object", 2948 2948 + "properties": { 2949 2949 + "name": { 2950 2950 + "type": "string" 2951 2951 + } 2952 2952 + } 2953 2953 + }, 2954 2954 + "Pageable": { 2955 2955 + "type": "object", 2956 2956 + "properties": { 2957 2957 + "page": { 2958 2958 + "minimum": 0, 2959 2959 + "type": "integer", 2960 2960 + "format": "int32", 2961 2961 + "default": 0 2962 2962 + }, 2963 2963 + "size": { 2964 2964 + "minimum": 1, 2965 2965 + "type": "integer", 2966 2966 + "format": "int32" 2967 2967 + }, 2968 2968 + "sort": { 2969 2969 + "type": "array", 2970 2970 + "items": { 2971 2971 + "type": "string" 2972 2972 + } 2973 2973 + } 2974 2974 + } 2975 2975 + }, 2976 2976 + "FreeFormObjectWithoutAdditionalProperties": { 2977 2977 + "description": "This is a free-form object without additionalProperties.", 2978 2978 + "type": "object" 2979 2979 + }, 2980 2980 + "FreeFormObjectWithAdditionalPropertiesEqTrue": { 2981 2981 + "description": "This is a free-form object with additionalProperties: true.", 2982 2982 + "type": "object", 2983 2983 + "additionalProperties": true 2984 2984 + }, 2985 2985 + "FreeFormObjectWithAdditionalPropertiesEqEmptyObject": { 2986 2986 + "description": "This is a free-form object with additionalProperties: {}.", 2987 2987 + "type": "object", 2988 2988 + "additionalProperties": {} 2989 2989 + }, 2990 2990 + "ModelWithConst": { 2991 2991 + "type": "object", 2992 2992 + "properties": { 2993 2993 + "String": { 2994 2994 + "const": "String" 2995 2995 + }, 2996 2996 + "number": { 2997 2997 + "const": 0 2998 2998 + }, 2999 2999 + "null": { 3000 3000 + "const": null 3001 3001 + }, 3002 3002 + "withType": { 3003 3003 + "type": "string", 3004 3004 + "const": "Some string" 3005 3005 + } 3006 3006 + } 3007 3007 + }, 3008 3008 + "ModelWithAdditionalPropertiesEqTrue": { 3009 3009 + "description": "This is a model with one property and additionalProperties: true", 3010 3010 + "type": "object", 3011 3011 + "properties": { 3012 3012 + "prop": { 3013 3013 + "description": "This is a simple string property", 3014 3014 + "type": "string" 3015 3015 + } 3016 3016 + }, 3017 3017 + "additionalProperties": true 3018 3018 + }, 3019 3019 + "NestedAnyOfArraysNullable": { 3020 3020 + "properties": { 3021 3021 + "nullableArray": { 3022 3022 + "anyOf": [ 3023 3023 + { 3024 3024 + "items": { 3025 3025 + "anyOf": [ 3026 3026 + { 3027 3027 + "type": "string" 3028 3028 + }, 3029 3029 + { 3030 3030 + "type": "boolean" 3031 3031 + } 3032 3032 + ] 3033 3033 + }, 3034 3034 + "type": "array" 3035 3035 + }, 3036 3036 + { 3037 3037 + "type": "null" 3038 3038 + } 3039 3039 + ] 3040 3040 + } 3041 3041 + }, 3042 3042 + "type": "object" 3043 3043 + }, 3044 3044 + "CompositionWithOneOfAndProperties": { 3045 3045 + "type": "object", 3046 3046 + "oneOf": [ 3047 3047 + { 3048 3048 + "type": "object", 3049 3049 + "required": ["foo"], 3050 3050 + "properties": { 3051 3051 + "foo": { 3052 3052 + "$ref": "#/components/parameters/SimpleParameter" 3053 3053 + } 3054 3054 + }, 3055 3055 + "additionalProperties": false 3056 3056 + }, 3057 3057 + { 3058 3058 + "type": "object", 3059 3059 + "required": ["bar"], 3060 3060 + "properties": { 3061 3061 + "bar": { 3062 3062 + "$ref": "#/components/schemas/NonAsciiStringæøåÆØÅöôêÊ字符串" 3063 3063 + } 3064 3064 + }, 3065 3065 + "additionalProperties": false 3066 3066 + } 3067 3067 + ], 3068 3068 + "required": ["baz", "qux"], 3069 3069 + "properties": { 3070 3070 + "baz": { 3071 3071 + "type": ["integer", "null"], 3072 3072 + "format": "uint16", 3073 3073 + "minimum": 0.0 3074 3074 + }, 3075 3075 + "qux": { 3076 3076 + "type": "integer", 3077 3077 + "format": "uint8", 3078 3078 + "minimum": 0.0 3079 3079 + } 3080 3080 + } 3081 3081 + }, 3082 3082 + "NullableObject": { 3083 3083 + "type": ["object", "null"], 3084 3084 + "description": "An object that can be null", 3085 3085 + "properties": { 3086 3086 + "foo": { 3087 3087 + "type": "string" 3088 3088 + } 3089 3089 + }, 3090 3090 + "default": null 3091 3091 + }, 3092 3092 + "CharactersInDescription": { 3093 3093 + "type": "string", 3094 3094 + "description": "Some % character" 3095 3095 + }, 3096 3096 + "ModelWithNullableObject": { 3097 3097 + "type": "object", 3098 3098 + "properties": { 3099 3099 + "data": { 3100 3100 + "$ref": "#/components/schemas/NullableObject" 3101 3101 + } 3102 3102 + } 3103 3103 + }, 3104 3104 + "ModelWithOneOfEnum": { 3105 3105 + "oneOf": [ 3106 3106 + { 3107 3107 + "type": "object", 3108 3108 + "required": ["foo"], 3109 3109 + "properties": { 3110 3110 + "foo": { 3111 3111 + "type": "string", 3112 3112 + "enum": ["Bar"] 3113 3113 + } 3114 3114 + } 3115 3115 + }, 3116 3116 + { 3117 3117 + "type": "object", 3118 3118 + "required": ["foo"], 3119 3119 + "properties": { 3120 3120 + "foo": { 3121 3121 + "type": "string", 3122 3122 + "enum": ["Baz"] 3123 3123 + } 3124 3124 + } 3125 3125 + }, 3126 3126 + { 3127 3127 + "type": "object", 3128 3128 + "required": ["foo"], 3129 3129 + "properties": { 3130 3130 + "foo": { 3131 3131 + "type": "string", 3132 3132 + "enum": ["Qux"] 3133 3133 + } 3134 3134 + } 3135 3135 + }, 3136 3136 + { 3137 3137 + "type": "object", 3138 3138 + "required": ["content", "foo"], 3139 3139 + "properties": { 3140 3140 + "content": { 3141 3141 + "type": "string", 3142 3142 + "format": "date-time" 3143 3143 + }, 3144 3144 + "foo": { 3145 3145 + "type": "string", 3146 3146 + "enum": ["Quux"] 3147 3147 + } 3148 3148 + } 3149 3149 + }, 3150 3150 + { 3151 3151 + "type": "object", 3152 3152 + "required": ["content", "foo"], 3153 3153 + "properties": { 3154 3154 + "content": { 3155 3155 + "type": "array", 3156 3156 + "prefixItems": [ 3157 3157 + { 3158 3158 + "type": "string", 3159 3159 + "format": "date-time" 3160 3160 + }, 3161 3161 + { 3162 3162 + "type": "string" 3163 3163 + } 3164 3164 + ], 3165 3165 + "maxItems": 2, 3166 3166 + "minItems": 2 3167 3167 + }, 3168 3168 + "foo": { 3169 3169 + "type": "string", 3170 3170 + "enum": ["Corge"] 3171 3171 + } 3172 3172 + } 3173 3173 + } 3174 3174 + ] 3175 3175 + }, 3176 3176 + "ModelWithNestedArrayEnumsDataFoo": { 3177 3177 + "enum": ["foo", "bar"], 3178 3178 + "type": "string" 3179 3179 + }, 3180 3180 + "ModelWithNestedArrayEnumsDataBar": { 3181 3181 + "enum": ["baz", "qux"], 3182 3182 + "type": "string" 3183 3183 + }, 3184 3184 + "ModelWithNestedArrayEnumsData": { 3185 3185 + "type": "object", 3186 3186 + "properties": { 3187 3187 + "foo": { 3188 3188 + "type": "array", 3189 3189 + "items": { 3190 3190 + "$ref": "#/components/schemas/ModelWithNestedArrayEnumsDataFoo" 3191 3191 + } 3192 3192 + }, 3193 3193 + "bar": { 3194 3194 + "type": "array", 3195 3195 + "items": { 3196 3196 + "$ref": "#/components/schemas/ModelWithNestedArrayEnumsDataBar" 3197 3197 + } 3198 3198 + } 3199 3199 + } 3200 3200 + }, 3201 3201 + "ModelWithNestedArrayEnums": { 3202 3202 + "type": "object", 3203 3203 + "properties": { 3204 3204 + "array_strings": { 3205 3205 + "type": "array", 3206 3206 + "items": { 3207 3207 + "type": "string" 3208 3208 + } 3209 3209 + }, 3210 3210 + "data": { 3211 3211 + "allOf": [ 3212 3212 + { 3213 3213 + "$ref": "#/components/schemas/ModelWithNestedArrayEnumsData" 3214 3214 + } 3215 3215 + ] 3216 3216 + } 3217 3217 + } 3218 3218 + }, 3219 3219 + "ModelWithNestedCompositionEnums": { 3220 3220 + "type": "object", 3221 3221 + "properties": { 3222 3222 + "foo": { 3223 3223 + "allOf": [ 3224 3224 + { 3225 3225 + "$ref": "#/components/schemas/ModelWithNestedArrayEnumsDataFoo" 3226 3226 + } 3227 3227 + ] 3228 3228 + } 3229 3229 + } 3230 3230 + }, 3231 3231 + "ModelWithReadOnlyAndWriteOnly": { 3232 3232 + "type": "object", 3233 3233 + "required": ["foo", "bar", "baz"], 3234 3234 + "properties": { 3235 3235 + "foo": { 3236 3236 + "type": "string" 3237 3237 + }, 3238 3238 + "bar": { 3239 3239 + "readOnly": true, 3240 3240 + "type": "string" 3241 3241 + }, 3242 3242 + "baz": { 3243 3243 + "type": "string", 3244 3244 + "writeOnly": true 3245 3245 + } 3246 3246 + } 3247 3247 + }, 3248 3248 + "ModelWithConstantSizeArray": { 3249 3249 + "type": "array", 3250 3250 + "items": { 3251 3251 + "type": "number" 3252 3252 + }, 3253 3253 + "minItems": 2, 3254 3254 + "maxItems": 2 3255 3255 + }, 3256 3256 + "ModelWithAnyOfConstantSizeArray": { 3257 3257 + "type": "array", 3258 3258 + "items": { 3259 3259 + "oneOf": [ 3260 3260 + { 3261 3261 + "type": "number" 3262 3262 + }, 3263 3263 + { 3264 3264 + "type": "string" 3265 3265 + } 3266 3266 + ] 3267 3267 + }, 3268 3268 + "minItems": 3, 3269 3269 + "maxItems": 3 3270 3270 + }, 3271 3271 + "ModelWithPrefixItemsConstantSizeArray": { 3272 3272 + "type": "array", 3273 3273 + "prefixItems": [ 3274 3274 + { 3275 3275 + "$ref": "#/components/schemas/ModelWithInteger" 3276 3276 + }, 3277 3277 + { 3278 3278 + "oneOf": [ 3279 3279 + { 3280 3280 + "type": "number" 3281 3281 + }, 3282 3282 + { 3283 3283 + "type": "string" 3284 3284 + } 3285 3285 + ] 3286 3286 + }, 3287 3287 + { 3288 3288 + "type": "string" 3289 3289 + } 3290 3290 + ] 3291 3291 + }, 3292 3292 + "ModelWithAnyOfConstantSizeArrayNullable": { 3293 3293 + "type": ["array"], 3294 3294 + "items": { 3295 3295 + "oneOf": [ 3296 3296 + { 3297 3297 + "type": ["number", "null"] 3298 3298 + }, 3299 3299 + { 3300 3300 + "type": "string" 3301 3301 + } 3302 3302 + ] 3303 3303 + }, 3304 3304 + "minItems": 3, 3305 3305 + "maxItems": 3 3306 3306 + }, 3307 3307 + "ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions": { 3308 3308 + "type": "array", 3309 3309 + "items": { 3310 3310 + "oneOf": [ 3311 3311 + { 3312 3312 + "type": "number" 3313 3313 + }, 3314 3314 + { 3315 3315 + "$ref": "#/components/schemas/import" 3316 3316 + } 3317 3317 + ] 3318 3318 + }, 3319 3319 + "minItems": 2, 3320 3320 + "maxItems": 2 3321 3321 + }, 3322 3322 + "ModelWithAnyOfConstantSizeArrayAndIntersect": { 3323 3323 + "type": "array", 3324 3324 + "items": { 3325 3325 + "allOf": [ 3326 3326 + { 3327 3327 + "type": "number" 3328 3328 + }, 3329 3329 + { 3330 3330 + "type": "string" 3331 3331 + } 3332 3332 + ] 3333 3333 + }, 3334 3334 + "minItems": 2, 3335 3335 + "maxItems": 2 3336 3336 + }, 3337 3337 + "ModelWithNumericEnumUnion": { 3338 3338 + "type": "object", 3339 3339 + "properties": { 3340 3340 + "value": { 3341 3341 + "type": "number", 3342 3342 + "description": "Период", 3343 3343 + "enum": [-10, -1, 0, 1, 3, 6, 12] 3344 3344 + } 3345 3345 + } 3346 3346 + }, 3347 3347 + "ModelWithBackticksInDescription": { 3348 3348 + "description": "Some description with `back ticks`", 3349 3349 + "type": "object", 3350 3350 + "properties": { 3351 3351 + "template": { 3352 3352 + "type": "string", 3353 3353 + "description": "The template `that` should be used for parsing and importing the contents of the CSV file.\n\n<br/><p>There is one placeholder currently supported:<ul> <li><b>${x}</b> - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)</li></ul><p>Example of a correct JSON template:</p>\n<pre>\n[\n {\n \"resourceType\": \"Asset\",\n \"identifier\": {\n \"name\": \"${1}\",\n \"domain\": {\n \"name\": \"${2}\",\n \"community\": {\n \"name\": \"Some Community\"\n }\n }\n },\n \"attributes\" : {\n \"00000000-0000-0000-0000-000000003115\" : [ {\n \"value\" : \"${3}\" \n } ],\n \"00000000-0000-0000-0000-000000000222\" : [ {\n \"value\" : \"${4}\"\n } ]\n }\n }\n]\n</pre>" 3354 3354 + } 3355 3355 + } 3356 3356 + }, 3357 3357 + "ModelWithOneOfAndProperties": { 3358 3358 + "type": "object", 3359 3359 + "oneOf": [ 3360 3360 + { 3361 3361 + "$ref": "#/components/parameters/SimpleParameter" 3362 3362 + }, 3363 3363 + { 3364 3364 + "$ref": "#/components/schemas/NonAsciiStringæøåÆØÅöôêÊ字符串" 3365 3365 + } 3366 3366 + ], 3367 3367 + "required": ["baz", "qux"], 3368 3368 + "properties": { 3369 3369 + "baz": { 3370 3370 + "type": ["integer", "null"], 3371 3371 + "format": "uint16", 3372 3372 + "minimum": 0.0 3373 3373 + }, 3374 3374 + "qux": { 3375 3375 + "type": "integer", 3376 3376 + "format": "uint8", 3377 3377 + "minimum": 0.0 3378 3378 + } 3379 3379 + } 3380 3380 + }, 3381 3381 + "ParameterSimpleParameterUnused": { 3382 3382 + "description": "Model used to test deduplication strategy (unused)", 3383 3383 + "type": "string" 3384 3384 + }, 3385 3385 + "PostServiceWithEmptyTagResponse": { 3386 3386 + "description": "Model used to test deduplication strategy", 3387 3387 + "type": "string" 3388 3388 + }, 3389 3389 + "PostServiceWithEmptyTagResponse2": { 3390 3390 + "description": "Model used to test deduplication strategy", 3391 3391 + "type": "string" 3392 3392 + }, 3393 3393 + "DeleteFooData": { 3394 3394 + "description": "Model used to test deduplication strategy", 3395 3395 + "type": "string" 3396 3396 + }, 3397 3397 + "DeleteFooData2": { 3398 3398 + "description": "Model used to test deduplication strategy", 3399 3399 + "type": "string" 3400 3400 + }, 3401 3401 + "import": { 3402 3402 + "description": "Model with restricted keyword name", 3403 3403 + "type": "string" 3404 3404 + }, 3405 3405 + "400": { 3406 3406 + "description": "Model with number-only name", 3407 3407 + "type": "string" 3408 3408 + }, 3409 3409 + "SchemaWithFormRestrictedKeys": { 3410 3410 + "type": "object", 3411 3411 + "properties": { 3412 3412 + "description": { 3413 3413 + "type": "string" 3414 3414 + }, 3415 3415 + "x-enum-descriptions": { 3416 3416 + "type": "string" 3417 3417 + }, 3418 3418 + "x-enum-varnames": { 3419 3419 + "type": "string" 3420 3420 + }, 3421 3421 + "x-enumNames": { 3422 3422 + "type": "string" 3423 3423 + }, 3424 3424 + "title": { 3425 3425 + "type": "string" 3426 3426 + }, 3427 3427 + "object": { 3428 3428 + "type": "object", 3429 3429 + "properties": { 3430 3430 + "description": { 3431 3431 + "type": "string" 3432 3432 + }, 3433 3433 + "x-enum-descriptions": { 3434 3434 + "type": "string" 3435 3435 + }, 3436 3436 + "x-enum-varnames": { 3437 3437 + "type": "string" 3438 3438 + }, 3439 3439 + "x-enumNames": { 3440 3440 + "type": "string" 3441 3441 + }, 3442 3442 + "title": { 3443 3443 + "type": "string" 3444 3444 + } 3445 3445 + } 3446 3446 + }, 3447 3447 + "array": { 3448 3448 + "type": "array", 3449 3449 + "items": { 3450 3450 + "type": "object", 3451 3451 + "properties": { 3452 3452 + "description": { 3453 3453 + "type": "string" 3454 3454 + }, 3455 3455 + "x-enum-descriptions": { 3456 3456 + "type": "string" 3457 3457 + }, 3458 3458 + "x-enum-varnames": { 3459 3459 + "type": "string" 3460 3460 + }, 3461 3461 + "x-enumNames": { 3462 3462 + "type": "string" 3463 3463 + }, 3464 3464 + "title": { 3465 3465 + "type": "string" 3466 3466 + } 3467 3467 + } 3468 3468 + } 3469 3469 + } 3470 3470 + } 3471 3471 + }, 3472 3472 + "io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions": { 3473 3473 + "description": "This schema was giving PascalCase transformations a hard time", 3474 3474 + "properties": { 3475 3475 + "preconditions": { 3476 3476 + "allOf": [ 3477 3477 + { 3478 3478 + "$ref": "#/components/schemas/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions" 3479 3479 + } 3480 3480 + ], 3481 3481 + "description": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned." 3482 3482 + } 3483 3483 + }, 3484 3484 + "type": "object" 3485 3485 + }, 3486 3486 + "io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions": { 3487 3487 + "description": "This schema was giving PascalCase transformations a hard time", 3488 3488 + "properties": { 3489 3489 + "resourceVersion": { 3490 3490 + "description": "Specifies the target ResourceVersion", 3491 3491 + "type": "string" 3492 3492 + }, 3493 3493 + "uid": { 3494 3494 + "description": "Specifies the target UID.", 3495 3495 + "type": "string" 3496 3496 + } 3497 3497 + }, 3498 3498 + "type": "object" 3499 3499 + }, 3500 3500 + "AdditionalPropertiesUnknownIssue": { 3501 3501 + "type": "object", 3502 3502 + "properties": {}, 3503 3503 + "additionalProperties": { 3504 3504 + "anyOf": [ 3505 3505 + { 3506 3506 + "type": "string" 3507 3507 + }, 3508 3508 + { 3509 3509 + "type": "number" 3510 3510 + } 3511 3511 + ] 3512 3512 + } 3513 3513 + }, 3514 3514 + "AdditionalPropertiesUnknownIssue2": { 3515 3515 + "type": "object", 3516 3516 + "additionalProperties": { 3517 3517 + "anyOf": [ 3518 3518 + { 3519 3519 + "type": "string" 3520 3520 + }, 3521 3521 + { 3522 3522 + "type": "number" 3523 3523 + } 3524 3524 + ] 3525 3525 + } 3526 3526 + }, 3527 3527 + "AdditionalPropertiesUnknownIssue3": { 3528 3528 + "type": "object", 3529 3529 + "allOf": [ 3530 3530 + { 3531 3531 + "type": "string" 3532 3532 + }, 3533 3533 + { 3534 3534 + "type": "object", 3535 3535 + "required": ["entries"], 3536 3536 + "properties": { 3537 3537 + "entries": { 3538 3538 + "type": "object", 3539 3539 + "additionalProperties": { 3540 3540 + "$ref": "#/components/schemas/AdditionalPropertiesUnknownIssue" 3541 3541 + } 3542 3542 + } 3543 3543 + } 3544 3544 + } 3545 3545 + ] 3546 3546 + }, 3547 3547 + "AdditionalPropertiesIntegerIssue": { 3548 3548 + "type": "object", 3549 3549 + "required": ["value"], 3550 3550 + "properties": { 3551 3551 + "value": { 3552 3552 + "type": "integer" 3553 3553 + } 3554 3554 + }, 3555 3555 + "additionalProperties": { 3556 3556 + "type": "integer" 3557 3557 + } 3558 3558 + }, 3559 3559 + "OneOfAllOfIssue": { 3560 3560 + "oneOf": [ 3561 3561 + { 3562 3562 + "allOf": [ 3563 3563 + { 3564 3564 + "oneOf": [ 3565 3565 + { 3566 3566 + "$ref": "#/components/schemas/ConstValue" 3567 3567 + }, 3568 3568 + { 3569 3569 + "$ref": "#/components/schemas/Generic.Schema.Duplicate.Issue`1[System.Boolean]" 3570 3570 + } 3571 3571 + ] 3572 3572 + }, 3573 3573 + { 3574 3574 + "$ref": "#/components/schemas/3e-num_1Период" 3575 3575 + } 3576 3576 + ] 3577 3577 + }, 3578 3578 + { 3579 3579 + "$ref": "#/components/schemas/Generic.Schema.Duplicate.Issue`1[System.String]" 3580 3580 + } 3581 3581 + ] 3582 3582 + }, 3583 3583 + "Generic.Schema.Duplicate.Issue`1[System.Boolean]": { 3584 3584 + "type": "object", 3585 3585 + "properties": { 3586 3586 + "item": { 3587 3587 + "type": "boolean" 3588 3588 + }, 3589 3589 + "error": { 3590 3590 + "type": ["string", "null"] 3591 3591 + }, 3592 3592 + "hasError": { 3593 3593 + "type": "boolean", 3594 3594 + "readOnly": true 3595 3595 + }, 3596 3596 + "data": { 3597 3597 + "type": "object", 3598 3598 + "properties": {}, 3599 3599 + "additionalProperties": false 3600 3600 + } 3601 3601 + }, 3602 3602 + "additionalProperties": false 3603 3603 + }, 3604 3604 + "Generic.Schema.Duplicate.Issue`1[System.String]": { 3605 3605 + "type": "object", 3606 3606 + "properties": { 3607 3607 + "item": { 3608 3608 + "type": ["string", "null"] 3609 3609 + }, 3610 3610 + "error": { 3611 3611 + "type": ["string", "null"] 3612 3612 + }, 3613 3613 + "hasError": { 3614 3614 + "type": "boolean", 3615 3615 + "readOnly": true 3616 3616 + } 3617 3617 + }, 3618 3618 + "additionalProperties": false 3619 3619 + } 3620 3620 + } 3621 3621 + } 3622 3622 + }

+68 -36

pnpm-lock.yaml

reviewed

··· 568 568 typescript: 569 569 specifier: 5.5.3 570 570 version: 5.5.3 571 571 + zod: 572 572 + specifier: 3.23.8 573 573 + version: 3.23.8 571 574 572 575 packages: 573 576 ··· 8426 8429 dependencies: 8427 8430 '@ampproject/remapping': 2.3.0 8428 8431 '@angular-devkit/architect': 0.1703.7(chokidar@3.6.0) 8429 8429 - '@angular-devkit/build-webpack': 0.1703.7(chokidar@3.6.0)(webpack-dev-server@4.15.1(webpack@5.90.3(esbuild@0.20.1)))(webpack@5.90.3(esbuild@0.20.1)) 8432 8432 + '@angular-devkit/build-webpack': 0.1703.7(chokidar@3.6.0)(webpack-dev-server@4.15.1(webpack@5.90.3))(webpack@5.90.3(esbuild@0.20.1)) 8430 8433 '@angular-devkit/core': 17.3.7(chokidar@3.6.0) 8431 8434 '@angular/compiler-cli': 17.3.9(@angular/compiler@17.3.9(@angular/core@17.3.9(rxjs@7.8.1)(zone.js@0.14.7)))(typescript@5.5.3) 8432 8435 '@babel/core': 7.24.0 ··· 8484 8487 undici: 6.11.1 8485 8488 vite: 5.1.7(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.29.1) 8486 8489 watchpack: 2.4.0 8487 8487 - webpack: 5.90.3(esbuild@0.23.1) 8490 8490 + webpack: 5.90.3(esbuild@0.20.1) 8488 8491 webpack-dev-middleware: 6.1.2(webpack@5.90.3(esbuild@0.20.1)) 8489 8489 - webpack-dev-server: 4.15.1(webpack@5.90.3(esbuild@0.20.1)) 8492 8492 + webpack-dev-server: 4.15.1(webpack@5.90.3) 8490 8493 webpack-merge: 5.10.0 8491 8494 webpack-subresource-integrity: 5.1.0(webpack@5.90.3(esbuild@0.20.1)) 8492 8495 optionalDependencies: ··· 8511 8514 - utf-8-validate 8512 8515 - webpack-cli 8513 8516 8514 8514 - '@angular-devkit/build-webpack@0.1703.7(chokidar@3.6.0)(webpack-dev-server@4.15.1(webpack@5.90.3(esbuild@0.20.1)))(webpack@5.90.3(esbuild@0.20.1))': 8517 8517 + '@angular-devkit/build-webpack@0.1703.7(chokidar@3.6.0)(webpack-dev-server@4.15.1(webpack@5.90.3))(webpack@5.90.3(esbuild@0.20.1))': 8515 8518 dependencies: 8516 8519 '@angular-devkit/architect': 0.1703.7(chokidar@3.6.0) 8517 8520 rxjs: 7.8.1 8518 8518 - webpack: 5.90.3(esbuild@0.23.1) 8519 8519 - webpack-dev-server: 4.15.1(webpack@5.90.3(esbuild@0.20.1)) 8521 8521 + webpack: 5.90.3(esbuild@0.20.1) 8522 8522 + webpack-dev-server: 4.15.1(webpack@5.90.3) 8520 8523 transitivePeerDependencies: 8521 8524 - chokidar 8522 8525 ··· 10326 10329 dependencies: 10327 10330 '@angular/compiler-cli': 17.3.9(@angular/compiler@17.3.9(@angular/core@17.3.9(rxjs@7.8.1)(zone.js@0.14.7)))(typescript@5.5.3) 10328 10331 typescript: 5.5.3 10329 10329 - webpack: 5.90.3(esbuild@0.23.1) 10332 10332 + webpack: 5.90.3(esbuild@0.20.1) 10330 10333 10331 10334 '@nodelib/fs.scandir@2.1.5': 10332 10335 dependencies: ··· 12419 12422 '@babel/core': 7.24.0 12420 12423 find-cache-dir: 4.0.0 12421 12424 schema-utils: 4.2.0 12422 12422 - webpack: 5.90.3(esbuild@0.23.1) 12425 12425 + webpack: 5.90.3(esbuild@0.20.1) 12423 12426 12424 12427 babel-plugin-istanbul@6.1.1: 12425 12428 dependencies: ··· 12858 12861 normalize-path: 3.0.0 12859 12862 schema-utils: 4.2.0 12860 12863 serialize-javascript: 6.0.2 12861 12861 - webpack: 5.90.3(esbuild@0.23.1) 12864 12864 + webpack: 5.90.3(esbuild@0.20.1) 12862 12865 12863 12866 core-js-compat@3.37.1: 12864 12867 dependencies: ··· 12910 12913 postcss-value-parser: 4.2.0 12911 12914 semver: 7.6.2 12912 12915 optionalDependencies: 12913 12913 - webpack: 5.90.3(esbuild@0.23.1) 12916 12916 + webpack: 5.90.3(esbuild@0.20.1) 12914 12917 12915 12918 css-select@5.1.0: 12916 12919 dependencies: ··· 12923 12926 css-tree@2.3.1: 12924 12927 dependencies: 12925 12928 mdn-data: 2.0.30 12926 12926 - source-map-js: 1.2.0 12929 12929 + source-map-js: 1.2.1 12927 12930 12928 12931 css-what@6.1.0: {} 12929 12932 ··· 14331 14334 dependencies: 14332 14335 klona: 2.0.6 14333 14336 less: 4.2.0 14334 14334 - webpack: 5.90.3(esbuild@0.23.1) 14337 14337 + webpack: 5.90.3(esbuild@0.20.1) 14335 14338 14336 14339 less@4.2.0: 14337 14340 dependencies: ··· 14356 14359 dependencies: 14357 14360 webpack-sources: 3.2.3 14358 14361 optionalDependencies: 14359 14359 - webpack: 5.90.3(esbuild@0.23.1) 14362 14362 + webpack: 5.90.3(esbuild@0.20.1) 14360 14363 14361 14364 lilconfig@2.1.0: {} 14362 14365 ··· 14575 14578 dependencies: 14576 14579 schema-utils: 4.2.0 14577 14580 tapable: 2.2.1 14578 14578 - webpack: 5.90.3(esbuild@0.23.1) 14581 14581 + webpack: 5.90.3(esbuild@0.20.1) 14579 14582 14580 14583 minimalistic-assert@1.0.1: {} 14581 14584 ··· 15124 15127 read-cache: 1.0.0 15125 15128 resolve: 1.22.8 15126 15129 15130 15130 + postcss-import@15.1.0(postcss@8.4.47): 15131 15131 + dependencies: 15132 15132 + postcss: 8.4.47 15133 15133 + postcss-value-parser: 4.2.0 15134 15134 + read-cache: 1.0.0 15135 15135 + resolve: 1.22.8 15136 15136 + optional: true 15137 15137 + 15127 15138 postcss-js@4.0.1(postcss@8.4.39): 15128 15139 dependencies: 15129 15140 camelcase-css: 2.0.1 15130 15141 postcss: 8.4.39 15142 15142 + 15143 15143 + postcss-js@4.0.1(postcss@8.4.47): 15144 15144 + dependencies: 15145 15145 + camelcase-css: 2.0.1 15146 15146 + postcss: 8.4.47 15147 15147 + optional: true 15131 15148 15132 15149 postcss-load-config@3.1.4(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)): 15133 15150 dependencies: ··· 15153 15170 postcss: 8.4.39 15154 15171 ts-node: 10.9.2(@types/node@20.14.5)(typescript@5.5.3) 15155 15172 15173 15173 + postcss-load-config@4.0.2(postcss@8.4.47)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)): 15174 15174 + dependencies: 15175 15175 + lilconfig: 3.1.2 15176 15176 + yaml: 2.4.5 15177 15177 + optionalDependencies: 15178 15178 + postcss: 8.4.47 15179 15179 + ts-node: 10.9.2(@types/node@20.14.10)(typescript@5.5.3) 15180 15180 + optional: true 15181 15181 + 15156 15182 postcss-load-config@6.0.1(jiti@2.3.1)(postcss@8.4.47)(tsx@4.19.1)(yaml@2.4.5): 15157 15183 dependencies: 15158 15184 lilconfig: 3.1.2 ··· 15169 15195 postcss: 8.4.35 15170 15196 semver: 7.6.2 15171 15197 optionalDependencies: 15172 15172 - webpack: 5.90.3(esbuild@0.23.1) 15198 15198 + webpack: 5.90.3(esbuild@0.20.1) 15173 15199 transitivePeerDependencies: 15174 15200 - typescript 15175 15201 ··· 15200 15226 dependencies: 15201 15227 postcss: 8.4.39 15202 15228 postcss-selector-parser: 6.1.0 15229 15229 + 15230 15230 + postcss-nested@6.0.1(postcss@8.4.47): 15231 15231 + dependencies: 15232 15232 + postcss: 8.4.47 15233 15233 + postcss-selector-parser: 6.1.0 15234 15234 + optional: true 15203 15235 15204 15236 postcss-safe-parser@6.0.0(postcss@8.4.39): 15205 15237 dependencies: ··· 15601 15633 neo-async: 2.6.2 15602 15634 optionalDependencies: 15603 15635 sass: 1.71.1 15604 15604 - webpack: 5.90.3(esbuild@0.23.1) 15636 15636 + webpack: 5.90.3(esbuild@0.20.1) 15605 15637 15606 15638 sass@1.71.1: 15607 15639 dependencies: ··· 15835 15867 dependencies: 15836 15868 iconv-lite: 0.6.3 15837 15869 source-map-js: 1.2.0 15838 15838 - webpack: 5.90.3(esbuild@0.23.1) 15870 15870 + webpack: 5.90.3(esbuild@0.20.1) 15839 15871 15840 15872 source-map-support@0.5.21: 15841 15873 dependencies: ··· 16059 16091 '@jridgewell/sourcemap-codec': 1.5.0 16060 16092 '@jridgewell/trace-mapping': 0.3.25 16061 16093 '@types/estree': 1.0.5 16062 16062 - acorn: 8.12.0 16094 16094 + acorn: 8.12.1 16063 16095 aria-query: 5.3.0 16064 16096 axobject-query: 4.1.0 16065 16097 code-red: 1.0.4 ··· 16125 16157 micromatch: 4.0.7 16126 16158 normalize-path: 3.0.0 16127 16159 object-hash: 3.0.0 16128 16128 - picocolors: 1.0.1 16129 16129 - postcss: 8.4.39 16130 16130 - postcss-import: 15.1.0(postcss@8.4.39) 16131 16131 - postcss-js: 4.0.1(postcss@8.4.39) 16132 16132 - postcss-load-config: 4.0.2(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)) 16133 16133 - postcss-nested: 6.0.1(postcss@8.4.39) 16160 16160 + picocolors: 1.1.0 16161 16161 + postcss: 8.4.47 16162 16162 + postcss-import: 15.1.0(postcss@8.4.47) 16163 16163 + postcss-js: 4.0.1(postcss@8.4.47) 16164 16164 + postcss-load-config: 4.0.2(postcss@8.4.47)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)) 16165 16165 + postcss-nested: 6.0.1(postcss@8.4.47) 16134 16166 postcss-selector-parser: 6.1.0 16135 16167 resolve: 1.22.8 16136 16168 sucrase: 3.35.0 ··· 16192 16224 16193 16225 term-size@2.2.1: {} 16194 16226 16195 16195 - terser-webpack-plugin@5.3.10(esbuild@0.23.1)(webpack@5.90.3(esbuild@0.20.1)): 16227 16227 + terser-webpack-plugin@5.3.10(esbuild@0.20.1)(webpack@5.90.3): 16196 16228 dependencies: 16197 16229 '@jridgewell/trace-mapping': 0.3.25 16198 16230 jest-worker: 27.5.1 16199 16231 schema-utils: 3.3.0 16200 16232 serialize-javascript: 6.0.2 16201 16233 terser: 5.29.1 16202 16202 - webpack: 5.90.3(esbuild@0.23.1) 16234 16234 + webpack: 5.90.3(esbuild@0.20.1) 16203 16235 optionalDependencies: 16204 16204 - esbuild: 0.23.1 16236 16236 + esbuild: 0.20.1 16205 16237 16206 16238 terser@5.29.1: 16207 16239 dependencies: ··· 16915 16947 16916 16948 webidl-conversions@7.0.0: {} 16917 16949 16918 16918 - webpack-dev-middleware@5.3.4(webpack@5.90.3(esbuild@0.20.1)): 16950 16950 + webpack-dev-middleware@5.3.4(webpack@5.90.3): 16919 16951 dependencies: 16920 16952 colorette: 2.0.20 16921 16953 memfs: 3.5.3 16922 16954 mime-types: 2.1.35 16923 16955 range-parser: 1.2.1 16924 16956 schema-utils: 4.2.0 16925 16925 - webpack: 5.90.3(esbuild@0.23.1) 16957 16957 + webpack: 5.90.3(esbuild@0.20.1) 16926 16958 16927 16959 webpack-dev-middleware@6.1.2(webpack@5.90.3(esbuild@0.20.1)): 16928 16960 dependencies: ··· 16932 16964 range-parser: 1.2.1 16933 16965 schema-utils: 4.2.0 16934 16966 optionalDependencies: 16935 16935 - webpack: 5.90.3(esbuild@0.23.1) 16967 16967 + webpack: 5.90.3(esbuild@0.20.1) 16936 16968 16937 16937 - webpack-dev-server@4.15.1(webpack@5.90.3(esbuild@0.20.1)): 16969 16969 + webpack-dev-server@4.15.1(webpack@5.90.3): 16938 16970 dependencies: 16939 16971 '@types/bonjour': 3.5.13 16940 16972 '@types/connect-history-api-fallback': 1.5.4 ··· 16964 16996 serve-index: 1.9.1 16965 16997 sockjs: 0.3.24 16966 16998 spdy: 4.0.2 16967 16967 - webpack-dev-middleware: 5.3.4(webpack@5.90.3(esbuild@0.20.1)) 16999 16999 + webpack-dev-middleware: 5.3.4(webpack@5.90.3) 16968 17000 ws: 8.17.1 16969 17001 optionalDependencies: 16970 16970 - webpack: 5.90.3(esbuild@0.23.1) 17002 17002 + webpack: 5.90.3(esbuild@0.20.1) 16971 17003 transitivePeerDependencies: 16972 17004 - bufferutil 16973 17005 - debug ··· 16985 17017 webpack-subresource-integrity@5.1.0(webpack@5.90.3(esbuild@0.20.1)): 16986 17018 dependencies: 16987 17019 typed-assert: 1.0.9 16988 16988 - webpack: 5.90.3(esbuild@0.23.1) 17020 17020 + webpack: 5.90.3(esbuild@0.20.1) 16989 17021 16990 16990 - webpack@5.90.3(esbuild@0.23.1): 17022 17022 + webpack@5.90.3(esbuild@0.20.1): 16991 17023 dependencies: 16992 17024 '@types/eslint-scope': 3.7.7 16993 17025 '@types/estree': 1.0.5 ··· 17010 17042 neo-async: 2.6.2 17011 17043 schema-utils: 3.3.0 17012 17044 tapable: 2.2.1 17013 17013 - terser-webpack-plugin: 5.3.10(esbuild@0.23.1)(webpack@5.90.3(esbuild@0.20.1)) 17045 17045 + terser-webpack-plugin: 5.3.10(esbuild@0.20.1)(webpack@5.90.3) 17014 17046 watchpack: 2.4.0 17015 17047 webpack-sources: 3.2.3 17016 17048 transitivePeerDependencies: