loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

[typescript-fetch] Add option to generate validation attributes of model properties (#19448)

Browse Source
This commit is contained in:
Matthias Schwarz 2024-08-27 14:13:59 +02:00 committed by GitHub
parent aae3ab3154
commit 4330b2f46d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
22 changed files with 3047 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bin/configs/typescript-fetch-validation-attributes.yaml Normal file
View File

@ -0,0 +1,6 @@
generatorName: typescript-fetch
outputDir: samples/client/petstore/typescript-fetch/builds/validation-attributes
inputSpec: modules/openapi-generator/src/test/resources/3_0/typescript-fetch/validation-attributes.yaml
templateDir: modules/openapi-generator/src/main/resources/typescript-fetch
additionalProperties:
validationAttributes: true

1
docs/generators/typescript-fetch.md
View File

@ -44,6 +44,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
|supportsES6|Generate code that conforms to ES6.| |false| |supportsES6|Generate code that conforms to ES6.| |false|
|useSingleRequestParameter|Setting this property to true will generate functions with a single argument containing all API endpoint parameters instead of one argument per parameter.| |true| |useSingleRequestParameter|Setting this property to true will generate functions with a single argument containing all API endpoint parameters instead of one argument per parameter.| |true|
|useSquareBracketsInArrayNames|Setting this property to true will add brackets to array attribute names, e.g. my_values[].| |false| |useSquareBracketsInArrayNames|Setting this property to true will add brackets to array attribute names, e.g. my_values[].| |false|
|validationAttributes|Setting this property to true will generate the validation attributes of model properties.| |false|
|withInterfaces|Setting this property to true will generate interfaces next to the default class implementations.| |false| |withInterfaces|Setting this property to true will generate interfaces next to the default class implementations.| |false|
|withoutRuntimeChecks|Setting this property to true will remove any runtime checks on the request and response payloads. Payloads will be casted to their expected types.| |false| |withoutRuntimeChecks|Setting this property to true will remove any runtime checks on the request and response payloads. Payloads will be casted to their expected types.| |false|

7
modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/TypeScriptFetchClientCodegen.java
View File

@ -60,6 +60,7 @@ public class TypeScriptFetchClientCodegen extends AbstractTypeScriptClientCodege
public static final String CAMEL_CASE = "camelCase"; public static final String CAMEL_CASE = "camelCase";
public static final String PASCAL_CASE = "PascalCase"; public static final String PASCAL_CASE = "PascalCase";
public static final String USE_SQUARE_BRACKETS_IN_ARRAY_NAMES = "useSquareBracketsInArrayNames"; public static final String USE_SQUARE_BRACKETS_IN_ARRAY_NAMES = "useSquareBracketsInArrayNames";
public static final String VALIDATION_ATTRIBUTES = "validationAttributes";
@Getter @Setter @Getter @Setter
protected String npmRepository = null; protected String npmRepository = null;
@ -92,7 +93,8 @@ public class TypeScriptFetchClientCodegen extends AbstractTypeScriptClientCodege
@Getter @Setter @Getter @Setter
protected String inferEntityFromUniqueIdWithName = null; protected String inferEntityFromUniqueIdWithName = null;
@Setter protected boolean packageAsSourceOnlyLibrary = false; @Setter protected boolean packageAsSourceOnlyLibrary = false;
@Getter @Setter
protected Boolean generateValidationAttributes = false;
public TypeScriptFetchClientCodegen() { public TypeScriptFetchClientCodegen() {
super(); super();
@ -123,6 +125,7 @@ public class TypeScriptFetchClientCodegen extends AbstractTypeScriptClientCodege
this.cliOptions.add(new CliOption(IMPORT_FILE_EXTENSION_SWITCH, IMPORT_FILE_EXTENSION_SWITCH_DESC).defaultValue("")); this.cliOptions.add(new CliOption(IMPORT_FILE_EXTENSION_SWITCH, IMPORT_FILE_EXTENSION_SWITCH_DESC).defaultValue(""));
this.cliOptions.add(new CliOption(FILE_NAMING, "Naming convention for the output files: 'PascalCase', 'camelCase', 'kebab-case'.").defaultValue(this.fileNaming)); this.cliOptions.add(new CliOption(FILE_NAMING, "Naming convention for the output files: 'PascalCase', 'camelCase', 'kebab-case'.").defaultValue(this.fileNaming));
this.cliOptions.add(new CliOption(USE_SQUARE_BRACKETS_IN_ARRAY_NAMES, "Setting this property to true will add brackets to array attribute names, e.g. my_values[].", SchemaTypeUtil.BOOLEAN_TYPE).defaultValue(Boolean.FALSE.toString())); this.cliOptions.add(new CliOption(USE_SQUARE_BRACKETS_IN_ARRAY_NAMES, "Setting this property to true will add brackets to array attribute names, e.g. my_values[].", SchemaTypeUtil.BOOLEAN_TYPE).defaultValue(Boolean.FALSE.toString()));
this.cliOptions.add(new CliOption(VALIDATION_ATTRIBUTES, "Setting this property to true will generate the validation attributes of model properties.", SchemaTypeUtil.BOOLEAN_TYPE).defaultValue(Boolean.FALSE.toString()));
} }
@Override @Override
@ -308,6 +311,8 @@ public class TypeScriptFetchClientCodegen extends AbstractTypeScriptClientCodege
} }
} }
} }
setGenerateValidationAttributes(convertPropertyToBooleanAndWriteBack(VALIDATION_ATTRIBUTES));
} }
@Override @Override

65
modules/openapi-generator/src/main/resources/typescript-fetch/modelGeneric.mustache vendored
View File

@ -158,3 +158,68 @@ export function {{classname}}ToJSON(value?: {{#hasReadOnly}}Omit<{{classname}},
return value; return value;
{{/hasVars}} {{/hasVars}}
} }
{{#validationAttributes}}
export const {{classname}}PropertyValidationAttributesMap: {
[property: string]: {
maxLength?: number,
minLength?: number,
pattern?: string,
maximum?: number,
exclusiveMaximum?: boolean,
minimum?: number,
exclusiveMinimum?: boolean,
multipleOf?: number,
maxItems?: number,
minItems?: number,
uniqueItems?: boolean
}
} = {
{{#vars}}
{{#hasValidation}}
{{name}}: {
{{#maxLength}}
maxLength: {{maxLength}},
{{/maxLength}}
{{#minLength}}
minLength: {{minLength}},
{{/minLength}}
{{#pattern}}
pattern: '{{pattern}}',
{{/pattern}}
{{#maximum}}
maximum: {{maximum}},
exclusiveMaximum: {{exclusiveMaximum}},
{{/maximum}}
{{#minimum}}
minimum: {{minimum}},
exclusiveMinimum: {{exclusiveMinimum}},
{{/minimum}}
{{#multipleOf}}
multipleOf: {{multipleOf}},
{{/multipleOf}}
{{#maxItems}}
maxItems: {{maxItems}},
{{/maxItems}}
{{#minItems}}
minItems: {{minItems}},
{{/minItems}}
{{#isArray}}
uniqueItems: {{uniqueItems}},
{{/isArray}}
},
{{/hasValidation}}
{{/vars}}
}
{{#isAdditionalPropertiesTrue}}
export const {{classname}}AdditionalPropertiesValidationAttributes: { maxProperties?: number, minProperties?: number } = {
{{#maxProperties}}
maxProperties: {{maxProperties}},
{{/maxProperties}}
{{#minProperties}}
minProperties: {{minProperties}},
{{/minProperties}}
}
{{/isAdditionalPropertiesTrue}}
{{/validationAttributes}}

1
modules/openapi-generator/src/test/java/org/openapitools/codegen/options/TypeScriptFetchClientOptionsProvider.java
View File

@ -86,6 +86,7 @@ public class TypeScriptFetchClientOptionsProvider implements OptionsProvider {
.put(CodegenConstants.ENUM_UNKNOWN_DEFAULT_CASE, ENUM_UNKNOWN_DEFAULT_CASE_VALUE) .put(CodegenConstants.ENUM_UNKNOWN_DEFAULT_CASE, ENUM_UNKNOWN_DEFAULT_CASE_VALUE)
.put(TypeScriptFetchClientCodegen.STRING_ENUMS, STRING_ENUMS) .put(TypeScriptFetchClientCodegen.STRING_ENUMS, STRING_ENUMS)
.put(TypeScriptFetchClientCodegen.USE_SQUARE_BRACKETS_IN_ARRAY_NAMES, Boolean.FALSE.toString()) .put(TypeScriptFetchClientCodegen.USE_SQUARE_BRACKETS_IN_ARRAY_NAMES, Boolean.FALSE.toString())
.put(TypeScriptFetchClientCodegen.VALIDATION_ATTRIBUTES, Boolean.FALSE.toString())
.build(); .build();
} }

755
modules/openapi-generator/src/test/resources/3_0/typescript-fetch/validation-attributes.yaml Normal file
View File

@ -0,0 +1,755 @@
openapi: 3.0.0
servers:
- url: 'http://petstore.swagger.io/v2'
info:
description: >-
This is a sample server Petstore server. For this sample, you can use the api key
`special-key` to test the authorization filters.
version: 1.0.0
title: OpenAPI Petstore
license:
name: Apache-2.0
url: 'https://www.apache.org/licenses/LICENSE-2.0.html'
tags:
- name: pet
description: Everything about your Pets
- name: store
description: Access to Petstore orders
- name: user
description: Operations about user
paths:
/pet:
post:
tags:
- pet
summary: Add a new pet to the store
description: ''
operationId: addPet
responses:
'200':
description: successful operation
content:
application/xml:
schema:
$ref: '#/components/schemas/Pet'
application/json:
schema:
$ref: '#/components/schemas/Pet'
'405':
description: Invalid input
security:
- petstore_auth:
- 'write:pets'
- 'read:pets'
requestBody:
$ref: '#/components/requestBodies/Pet'
put:
tags:
- pet
summary: Update an existing pet
description: ''
operationId: updatePet
externalDocs:
url: "http://petstore.swagger.io/v2/doc/updatePet"
description: "API documentation for the updatePet operation"
responses:
'200':
description: successful operation
content:
application/xml:
schema:
$ref: '#/components/schemas/Pet'
application/json:
schema:
$ref: '#/components/schemas/Pet'
'400':
description: Invalid ID supplied
'404':
description: Pet not found
'405':
description: Validation exception
security:
- petstore_auth:
- 'write:pets'
- 'read:pets'
requestBody:
$ref: '#/components/requestBodies/Pet'
/pet/findByStatus:
get:
tags:
- pet
summary: Finds Pets by status
description: Multiple status values can be provided with comma separated strings
operationId: findPetsByStatus
parameters:
- name: status
in: query
description: Status values that need to be considered for filter
required: true
style: form
explode: false
deprecated: true
schema:
type: array
items:
type: string
enum:
- available
- pending
- sold
default: available
responses:
'200':
description: successful operation
content:
application/xml:
schema:
type: array
items:
$ref: '#/components/schemas/Pet'
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/Pet'
'400':
description: Invalid status value
security:
- petstore_auth:
- 'read:pets'
/pet/findByTags:
get:
tags:
- pet
summary: Finds Pets by tags
description: >-
Multiple tags can be provided with comma separated strings. Use tag1,
tag2, tag3 for testing.
operationId: findPetsByTags
parameters:
- name: tags
in: query
description: Tags to filter by
required: true
style: form
explode: false
schema:
type: array
items:
type: string
responses:
'200':
description: successful operation
content:
application/xml:
schema:
type: array
items:
$ref: '#/components/schemas/Pet'
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/Pet'
'400':
description: Invalid tag value
security:
- petstore_auth:
- 'read:pets'
deprecated: true
'/pet/{petId}':
get:
tags:
- pet
summary: Find pet by ID
description: Returns a single pet
operationId: getPetById
parameters:
- name: petId
in: path
description: ID of pet to return
required: true
schema:
type: integer
format: int64
responses:
'200':
description: successful operation
content:
application/xml:
schema:
$ref: '#/components/schemas/Pet'
application/json:
schema:
$ref: '#/components/schemas/Pet'
'400':
description: Invalid ID supplied
'404':
description: Pet not found
security:
- api_key: []
post:
tags:
- pet
summary: Updates a pet in the store with form data
description: ''
operationId: updatePetWithForm
parameters:
- name: petId
in: path
description: ID of pet that needs to be updated
required: true
schema:
type: integer
format: int64
responses:
'405':
description: Invalid input
security:
- petstore_auth:
- 'write:pets'
- 'read:pets'
requestBody:
content:
application/x-www-form-urlencoded:
schema:
type: object
properties:
name:
description: Updated name of the pet
type: string
status:
description: Updated status of the pet
type: string
delete:
tags:
- pet
summary: Deletes a pet
description: ''
operationId: deletePet
parameters:
- name: api_key
in: header
required: false
schema:
type: string
- name: petId
in: path
description: Pet id to delete
required: true
schema:
type: integer
format: int64
responses:
'400':
description: Invalid pet value
security:
- petstore_auth:
- 'write:pets'
- 'read:pets'
'/pet/{petId}/uploadImage':
post:
tags:
- pet
summary: uploads an image
description: ''
operationId: uploadFile
parameters:
- name: petId
in: path
description: ID of pet to update
required: true
schema:
type: integer
format: int64
responses:
'200':
description: successful operation
content:
application/json:
schema:
$ref: '#/components/schemas/ApiResponse'
security:
- petstore_auth:
- 'write:pets'
- 'read:pets'
requestBody:
content:
multipart/form-data:
schema:
type: object
properties:
additionalMetadata:
description: Additional data to pass to server
type: string
file:
description: file to upload
type: string
format: binary
/store/inventory:
get:
tags:
- store
summary: Returns pet inventories by status
description: Returns a map of status codes to quantities
operationId: getInventory
responses:
'200':
description: successful operation
content:
application/json:
schema:
type: object
additionalProperties:
type: integer
format: int32
security:
- api_key: []
/store/order:
post:
tags:
- store
summary: Place an order for a pet
description: ''
operationId: placeOrder
responses:
'200':
description: successful operation
content:
application/xml:
schema:
$ref: '#/components/schemas/Order'
application/json:
schema:
$ref: '#/components/schemas/Order'
'400':
description: Invalid Order
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/Order'
description: order placed for purchasing the pet
required: true
'/store/order/{orderId}':
get:
tags:
- store
summary: Find purchase order by ID
description: >-
For valid response try integer IDs with value <= 5 or > 10. Other values
will generate exceptions
operationId: getOrderById
parameters:
- name: orderId
in: path
description: ID of pet that needs to be fetched
required: true
schema:
type: integer
format: int64
minimum: 1
maximum: 5
responses:
'200':
description: successful operation
content:
application/xml:
schema:
$ref: '#/components/schemas/Order'
application/json:
schema:
$ref: '#/components/schemas/Order'
'400':
description: Invalid ID supplied
'404':
description: Order not found
delete:
tags:
- store
summary: Delete purchase order by ID
description: >-
For valid response try integer IDs with value < 1000. Anything above
1000 or nonintegers will generate API errors
operationId: deleteOrder
parameters:
- name: orderId
in: path
description: ID of the order that needs to be deleted
required: true
schema:
type: string
responses:
'400':
description: Invalid ID supplied
'404':
description: Order not found
/user:
post:
tags:
- user
summary: Create user
description: This can only be done by the logged in user.
operationId: createUser
responses:
default:
description: successful operation
security:
- api_key: []
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/User'
description: Created user object
required: true
/user/createWithArray:
post:
tags:
- user
summary: Creates list of users with given input array
description: ''
operationId: createUsersWithArrayInput
responses:
default:
description: successful operation
security:
- api_key: []
requestBody:
$ref: '#/components/requestBodies/UserArray'
/user/createWithList:
post:
tags:
- user
summary: Creates list of users with given input array
description: ''
operationId: createUsersWithListInput
responses:
default:
description: successful operation
security:
- api_key: []
requestBody:
$ref: '#/components/requestBodies/UserArray'
/user/login:
get:
tags:
- user
summary: Logs user into the system
description: ''
operationId: loginUser
parameters:
- name: username
in: query
description: The user name for login
required: true
schema:
type: string
pattern: '^[a-zA-Z0-9]+[a-zA-Z0-9\.\-_]*[a-zA-Z0-9]+$'
- name: password
in: query
description: The password for login in clear text
required: true
schema:
type: string
responses:
'200':
description: successful operation
headers:
Set-Cookie:
description: >-
Cookie authentication key for use with the `api_key`
apiKey authentication.
schema:
type: string
example: AUTH_KEY=abcde12345; Path=/; HttpOnly
X-Rate-Limit:
description: calls per hour allowed by the user
schema:
type: integer
format: int32
X-Expires-After:
description: date in UTC when token expires
schema:
type: string
format: date-time
content:
application/xml:
schema:
type: string
application/json:
schema:
type: string
'400':
description: Invalid username/password supplied
/user/logout:
get:
tags:
- user
summary: Logs out current logged in user session
description: ''
operationId: logoutUser
responses:
default:
description: successful operation
security:
- api_key: []
'/user/{username}':
get:
tags:
- user
summary: Get user by user name
description: ''
operationId: getUserByName
parameters:
- name: username
in: path
description: The name that needs to be fetched. Use user1 for testing.
required: true
schema:
type: string
responses:
'200':
description: successful operation
content:
application/xml:
schema:
$ref: '#/components/schemas/User'
application/json:
schema:
$ref: '#/components/schemas/User'
'400':
description: Invalid username supplied
'404':
description: User not found
put:
tags:
- user
summary: Updated user
description: This can only be done by the logged in user.
operationId: updateUser
parameters:
- name: username
in: path
description: name that need to be deleted
required: true
schema:
type: string
responses:
'400':
description: Invalid user supplied
'404':
description: User not found
security:
- api_key: []
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/User'
description: Updated user object
required: true
delete:
tags:
- user
summary: Delete user
description: This can only be done by the logged in user.
operationId: deleteUser
parameters:
- name: username
in: path
description: The name that needs to be deleted
required: true
schema:
type: string
responses:
'400':
description: Invalid username supplied
'404':
description: User not found
security:
- api_key: []
externalDocs:
description: Find out more about Swagger
url: 'http://swagger.io'
components:
requestBodies:
UserArray:
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/User'
description: List of user object
required: true
Pet:
content:
application/json:
schema:
$ref: '#/components/schemas/Pet'
application/xml:
schema:
$ref: '#/components/schemas/Pet'
description: Pet object that needs to be added to the store
required: true
securitySchemes:
petstore_auth:
type: oauth2
flows:
implicit:
authorizationUrl: 'http://petstore.swagger.io/api/oauth/dialog'
scopes:
'write:pets': modify pets in your account
'read:pets': read your pets
api_key:
type: apiKey
name: api_key
in: header
schemas:
Order:
title: Pet Order
description: An order for a pets from the pet store
type: object
additionalProperties:
type: string
minProperties: 2
maxProperties: 10
properties:
id:
type: integer
format: int64
petId:
type: integer
format: int64
quantity:
type: integer
format: int32
shipDate:
type: string
format: date-time
status:
type: string
description: Order Status
enum:
- placed
- approved
- delivered
complete:
type: boolean
default: false
xml:
name: Order
Category:
title: Pet category
description: A category for a pet
type: object
properties:
id:
type: integer
format: int64
name:
type: string
pattern: '^[a-zA-Z0-9]+[a-zA-Z0-9\.\-_]*[a-zA-Z0-9]+$'
xml:
name: Category
User:
title: a User
description: A User who is purchasing from the pet store
type: object
properties:
id:
type: integer
format: int64
username:
type: string
firstName:
type: string
lastName:
type: string
email:
type: string
password:
type: string
minLength: 8
maxLength: 256
phone:
type: string
userStatus:
type: integer
format: int32
description: User Status
maximum: 100
exclusiveMaximum: true
minimum: 0
exclusiveMinimum: true
multipleOf: 10
xml:
name: User
Tag:
title: Pet Tag
description: A tag for a pet
type: object
properties:
id:
type: integer
format: int64
name:
type: string
xml:
name: Tag
Pet:
title: a Pet
description: A pet for sale in the pet store
type: object
required:
- name
- photoUrls
properties:
id:
type: integer
format: int64
category:
$ref: '#/components/schemas/Category'
name:
type: string
example: doggie
photoUrls:
type: array
maxItems: 8
minItems: 1
uniqueItems: true
xml:
name: photoUrl
wrapped: true
items:
type: string
tags:
type: array
xml:
name: tag
wrapped: true
items:
$ref: '#/components/schemas/Tag'
status:
type: string
description: pet status in the store
deprecated: true
enum:
- available
- pending
- sold
xml:
name: Pet
ApiResponse:
title: An uploaded response
description: Describes the result of uploading an image resource
type: object
properties:
code:
type: integer
format: int32
type:
type: string
message:
type: string

23
samples/client/petstore/typescript-fetch/builds/validation-attributes/.openapi-generator-ignore Normal file
View File

@ -0,0 +1,23 @@
# OpenAPI Generator Ignore
# Generated by openapi-generator https://github.com/openapitools/openapi-generator
# Use this file to prevent files from being overwritten by the generator.
# The patterns follow closely to .gitignore or .dockerignore.
# As an example, the C# client generator defines ApiClient.cs.
# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
#ApiClient.cs
# You can match any string of characters against a directory, file or extension with a single asterisk (*):
#foo/*/qux
# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
#foo/**/qux
# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
# You can also negate patterns with an exclamation (!).
# For example, you can ignore all files in a docs folder with the file extension .md:
#docs/*.md
# Then explicitly reverse the ignore rule for a single file:
#!docs/README.md

13
samples/client/petstore/typescript-fetch/builds/validation-attributes/.openapi-generator/FILES Normal file
View File

@ -0,0 +1,13 @@
apis/PetApi.ts
apis/StoreApi.ts
apis/UserApi.ts
apis/index.ts
index.ts
models/Category.ts
models/ModelApiResponse.ts
models/Order.ts
models/Pet.ts
models/Tag.ts
models/User.ts
models/index.ts
runtime.ts

1
samples/client/petstore/typescript-fetch/builds/validation-attributes/.openapi-generator/VERSION Normal file
View File

@ -0,0 +1 @@
7.9.0-SNAPSHOT

465
samples/client/petstore/typescript-fetch/builds/validation-attributes/apis/PetApi.ts Normal file
View File

@ -0,0 +1,465 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import * as runtime from '../runtime';
import type {
ModelApiResponse,
Pet,
} from '../models/index';
import {
ModelApiResponseFromJSON,
ModelApiResponseToJSON,
PetFromJSON,
PetToJSON,
} from '../models/index';
export interface AddPetRequest {
pet: Pet;
}
export interface DeletePetRequest {
petId: number;
apiKey?: string;
}
export interface FindPetsByStatusRequest {
status: Array<FindPetsByStatusStatusEnum>;
}
export interface FindPetsByTagsRequest {
tags: Array<string>;
}
export interface GetPetByIdRequest {
petId: number;
}
export interface UpdatePetRequest {
pet: Pet;
}
export interface UpdatePetWithFormRequest {
petId: number;
name?: string;
status?: string;
}
export interface UploadFileRequest {
petId: number;
additionalMetadata?: string;
file?: Blob;
}
/**
*
*/
export class PetApi extends runtime.BaseAPI {
/**
*
* Add a new pet to the store
*/
async addPetRaw(requestParameters: AddPetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Pet>> {
if (requestParameters['pet'] == null) {
throw new runtime.RequiredError(
'pet',
'Required parameter "pet" was null or undefined when calling addPet().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
// oauth required
headerParameters["Authorization"] = await this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
}
const response = await this.request({
path: `/pet`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
body: PetToJSON(requestParameters['pet']),
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => PetFromJSON(jsonValue));
}
/**
*
* Add a new pet to the store
*/
async addPet(requestParameters: AddPetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Pet> {
const response = await this.addPetRaw(requestParameters, initOverrides);
return await response.value();
}
/**
*
* Deletes a pet
*/
async deletePetRaw(requestParameters: DeletePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['petId'] == null) {
throw new runtime.RequiredError(
'petId',
'Required parameter "petId" was null or undefined when calling deletePet().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
if (requestParameters['apiKey'] != null) {
headerParameters['api_key'] = String(requestParameters['apiKey']);
}
if (this.configuration && this.configuration.accessToken) {
// oauth required
headerParameters["Authorization"] = await this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
}
const response = await this.request({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
*
* Deletes a pet
*/
async deletePet(requestParameters: DeletePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.deletePetRaw(requestParameters, initOverrides);
}
/**
* Multiple status values can be provided with comma separated strings
* Finds Pets by status
*/
async findPetsByStatusRaw(requestParameters: FindPetsByStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
if (requestParameters['status'] == null) {
throw new runtime.RequiredError(
'status',
'Required parameter "status" was null or undefined when calling findPetsByStatus().'
);
}
const queryParameters: any = {};
if (requestParameters['status'] != null) {
queryParameters['status'] = requestParameters['status']!.join(runtime.COLLECTION_FORMATS["csv"]);
}
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.accessToken) {
// oauth required
headerParameters["Authorization"] = await this.configuration.accessToken("petstore_auth", ["read:pets"]);
}
const response = await this.request({
path: `/pet/findByStatus`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(PetFromJSON));
}
/**
* Multiple status values can be provided with comma separated strings
* Finds Pets by status
*/
async findPetsByStatus(requestParameters: FindPetsByStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Pet>> {
const response = await this.findPetsByStatusRaw(requestParameters, initOverrides);
return await response.value();
}
/**
* Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
* Finds Pets by tags
* @deprecated
*/
async findPetsByTagsRaw(requestParameters: FindPetsByTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
if (requestParameters['tags'] == null) {
throw new runtime.RequiredError(
'tags',
'Required parameter "tags" was null or undefined when calling findPetsByTags().'
);
}
const queryParameters: any = {};
if (requestParameters['tags'] != null) {
queryParameters['tags'] = requestParameters['tags']!.join(runtime.COLLECTION_FORMATS["csv"]);
}
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.accessToken) {
// oauth required
headerParameters["Authorization"] = await this.configuration.accessToken("petstore_auth", ["read:pets"]);
}
const response = await this.request({
path: `/pet/findByTags`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(PetFromJSON));
}
/**
* Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
* Finds Pets by tags
* @deprecated
*/
async findPetsByTags(requestParameters: FindPetsByTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Pet>> {
const response = await this.findPetsByTagsRaw(requestParameters, initOverrides);
return await response.value();
}
/**
* Returns a single pet
* Find pet by ID
*/
async getPetByIdRaw(requestParameters: GetPetByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Pet>> {
if (requestParameters['petId'] == null) {
throw new runtime.RequiredError(
'petId',
'Required parameter "petId" was null or undefined when calling getPetById().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => PetFromJSON(jsonValue));
}
/**
* Returns a single pet
* Find pet by ID
*/
async getPetById(requestParameters: GetPetByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Pet> {
const response = await this.getPetByIdRaw(requestParameters, initOverrides);
return await response.value();
}
/**
*
* Update an existing pet
*/
async updatePetRaw(requestParameters: UpdatePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Pet>> {
if (requestParameters['pet'] == null) {
throw new runtime.RequiredError(
'pet',
'Required parameter "pet" was null or undefined when calling updatePet().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
// oauth required
headerParameters["Authorization"] = await this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
}
const response = await this.request({
path: `/pet`,
method: 'PUT',
headers: headerParameters,
query: queryParameters,
body: PetToJSON(requestParameters['pet']),
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => PetFromJSON(jsonValue));
}
/**
*
* Update an existing pet
*/
async updatePet(requestParameters: UpdatePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Pet> {
const response = await this.updatePetRaw(requestParameters, initOverrides);
return await response.value();
}
/**
*
* Updates a pet in the store with form data
*/
async updatePetWithFormRaw(requestParameters: UpdatePetWithFormRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['petId'] == null) {
throw new runtime.RequiredError(
'petId',
'Required parameter "petId" was null or undefined when calling updatePetWithForm().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.accessToken) {
// oauth required
headerParameters["Authorization"] = await this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
}
const consumes: runtime.Consume[] = [
{ contentType: 'application/x-www-form-urlencoded' },
];
// @ts-ignore: canConsumeForm may be unused
const canConsumeForm = runtime.canConsumeForm(consumes);
let formParams: { append(param: string, value: any): any };
let useForm = false;
if (useForm) {
formParams = new FormData();
} else {
formParams = new URLSearchParams();
}
if (requestParameters['name'] != null) {
formParams.append('name', requestParameters['name'] as any);
}
if (requestParameters['status'] != null) {
formParams.append('status', requestParameters['status'] as any);
}
const response = await this.request({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
body: formParams,
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
*
* Updates a pet in the store with form data
*/
async updatePetWithForm(requestParameters: UpdatePetWithFormRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.updatePetWithFormRaw(requestParameters, initOverrides);
}
/**
*
* uploads an image
*/
async uploadFileRaw(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ModelApiResponse>> {
if (requestParameters['petId'] == null) {
throw new runtime.RequiredError(
'petId',
'Required parameter "petId" was null or undefined when calling uploadFile().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.accessToken) {
// oauth required
headerParameters["Authorization"] = await this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
}
const consumes: runtime.Consume[] = [
{ contentType: 'multipart/form-data' },
];
// @ts-ignore: canConsumeForm may be unused
const canConsumeForm = runtime.canConsumeForm(consumes);
let formParams: { append(param: string, value: any): any };
let useForm = false;
// use FormData to transmit files using content-type "multipart/form-data"
useForm = canConsumeForm;
if (useForm) {
formParams = new FormData();
} else {
formParams = new URLSearchParams();
}
if (requestParameters['additionalMetadata'] != null) {
formParams.append('additionalMetadata', requestParameters['additionalMetadata'] as any);
}
if (requestParameters['file'] != null) {
formParams.append('file', requestParameters['file'] as any);
}
const response = await this.request({
path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
body: formParams,
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => ModelApiResponseFromJSON(jsonValue));
}
/**
*
* uploads an image
*/
async uploadFile(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ModelApiResponse> {
const response = await this.uploadFileRaw(requestParameters, initOverrides);
return await response.value();
}
}
/**
* @export
*/
export const FindPetsByStatusStatusEnum = {
Available: 'available',
Pending: 'pending',
Sold: 'sold'
} as const;
export type FindPetsByStatusStatusEnum = typeof FindPetsByStatusStatusEnum[keyof typeof FindPetsByStatusStatusEnum];

181
samples/client/petstore/typescript-fetch/builds/validation-attributes/apis/StoreApi.ts Normal file
View File

@ -0,0 +1,181 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import * as runtime from '../runtime';
import type {
Order,
} from '../models/index';
import {
OrderFromJSON,
OrderToJSON,
} from '../models/index';
export interface DeleteOrderRequest {
orderId: string;
}
export interface GetOrderByIdRequest {
orderId: number;
}
export interface PlaceOrderRequest {
order: Order;
}
/**
*
*/
export class StoreApi extends runtime.BaseAPI {
/**
* For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
* Delete purchase order by ID
*/
async deleteOrderRaw(requestParameters: DeleteOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['orderId'] == null) {
throw new runtime.RequiredError(
'orderId',
'Required parameter "orderId" was null or undefined when calling deleteOrder().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
const response = await this.request({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
* For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
* Delete purchase order by ID
*/
async deleteOrder(requestParameters: DeleteOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.deleteOrderRaw(requestParameters, initOverrides);
}
/**
* Returns a map of status codes to quantities
* Returns pet inventories by status
*/
async getInventoryRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: number; }>> {
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/store/inventory`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.JSONApiResponse<any>(response);
}
/**
* Returns a map of status codes to quantities
* Returns pet inventories by status
*/
async getInventory(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: number; }> {
const response = await this.getInventoryRaw(initOverrides);
return await response.value();
}
/**
* For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
* Find purchase order by ID
*/
async getOrderByIdRaw(requestParameters: GetOrderByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
if (requestParameters['orderId'] == null) {
throw new runtime.RequiredError(
'orderId',
'Required parameter "orderId" was null or undefined when calling getOrderById().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
const response = await this.request({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));
}
/**
* For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
* Find purchase order by ID
*/
async getOrderById(requestParameters: GetOrderByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Order> {
const response = await this.getOrderByIdRaw(requestParameters, initOverrides);
return await response.value();
}
/**
*
* Place an order for a pet
*/
async placeOrderRaw(requestParameters: PlaceOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
if (requestParameters['order'] == null) {
throw new runtime.RequiredError(
'order',
'Required parameter "order" was null or undefined when calling placeOrder().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const response = await this.request({
path: `/store/order`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
body: OrderToJSON(requestParameters['order']),
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));
}
/**
*
* Place an order for a pet
*/
async placeOrder(requestParameters: PlaceOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Order> {
const response = await this.placeOrderRaw(requestParameters, initOverrides);
return await response.value();
}
}

389
samples/client/petstore/typescript-fetch/builds/validation-attributes/apis/UserApi.ts Normal file
View File

@ -0,0 +1,389 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import * as runtime from '../runtime';
import type {
User,
} from '../models/index';
import {
UserFromJSON,
UserToJSON,
} from '../models/index';
export interface CreateUserRequest {
user: User;
}
export interface CreateUsersWithArrayInputRequest {
user: Array<User>;
}
export interface CreateUsersWithListInputRequest {
user: Array<User>;
}
export interface DeleteUserRequest {
username: string;
}
export interface GetUserByNameRequest {
username: string;
}
export interface LoginUserRequest {
username: string;
password: string;
}
export interface UpdateUserRequest {
username: string;
user: User;
}
/**
*
*/
export class UserApi extends runtime.BaseAPI {
/**
* This can only be done by the logged in user.
* Create user
*/
async createUserRaw(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['user'] == null) {
throw new runtime.RequiredError(
'user',
'Required parameter "user" was null or undefined when calling createUser().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/user`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
body: UserToJSON(requestParameters['user']),
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
* This can only be done by the logged in user.
* Create user
*/
async createUser(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.createUserRaw(requestParameters, initOverrides);
}
/**
*
* Creates list of users with given input array
*/
async createUsersWithArrayInputRaw(requestParameters: CreateUsersWithArrayInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['user'] == null) {
throw new runtime.RequiredError(
'user',
'Required parameter "user" was null or undefined when calling createUsersWithArrayInput().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/user/createWithArray`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
body: requestParameters['user']!.map(UserToJSON),
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
*
* Creates list of users with given input array
*/
async createUsersWithArrayInput(requestParameters: CreateUsersWithArrayInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.createUsersWithArrayInputRaw(requestParameters, initOverrides);
}
/**
*
* Creates list of users with given input array
*/
async createUsersWithListInputRaw(requestParameters: CreateUsersWithListInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['user'] == null) {
throw new runtime.RequiredError(
'user',
'Required parameter "user" was null or undefined when calling createUsersWithListInput().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/user/createWithList`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
body: requestParameters['user']!.map(UserToJSON),
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
*
* Creates list of users with given input array
*/
async createUsersWithListInput(requestParameters: CreateUsersWithListInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.createUsersWithListInputRaw(requestParameters, initOverrides);
}
/**
* This can only be done by the logged in user.
* Delete user
*/
async deleteUserRaw(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['username'] == null) {
throw new runtime.RequiredError(
'username',
'Required parameter "username" was null or undefined when calling deleteUser().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
* This can only be done by the logged in user.
* Delete user
*/
async deleteUser(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.deleteUserRaw(requestParameters, initOverrides);
}
/**
*
* Get user by user name
*/
async getUserByNameRaw(requestParameters: GetUserByNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
if (requestParameters['username'] == null) {
throw new runtime.RequiredError(
'username',
'Required parameter "username" was null or undefined when calling getUserByName().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
const response = await this.request({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.JSONApiResponse(response, (jsonValue) => UserFromJSON(jsonValue));
}
/**
*
* Get user by user name
*/
async getUserByName(requestParameters: GetUserByNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<User> {
const response = await this.getUserByNameRaw(requestParameters, initOverrides);
return await response.value();
}
/**
*
* Logs user into the system
*/
async loginUserRaw(requestParameters: LoginUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
if (requestParameters['username'] == null) {
throw new runtime.RequiredError(
'username',
'Required parameter "username" was null or undefined when calling loginUser().'
);
}
if (requestParameters['password'] == null) {
throw new runtime.RequiredError(
'password',
'Required parameter "password" was null or undefined when calling loginUser().'
);
}
const queryParameters: any = {};
if (requestParameters['username'] != null) {
queryParameters['username'] = requestParameters['username'];
}
if (requestParameters['password'] != null) {
queryParameters['password'] = requestParameters['password'];
}
const headerParameters: runtime.HTTPHeaders = {};
const response = await this.request({
path: `/user/login`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
if (this.isJsonMime(response.headers.get('content-type'))) {
return new runtime.JSONApiResponse<string>(response);
} else {
return new runtime.TextApiResponse(response) as any;
}
}
/**
*
* Logs user into the system
*/
async loginUser(requestParameters: LoginUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
const response = await this.loginUserRaw(requestParameters, initOverrides);
return await response.value();
}
/**
*
* Logs out current logged in user session
*/
async logoutUserRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/user/logout`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
*
* Logs out current logged in user session
*/
async logoutUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.logoutUserRaw(initOverrides);
}
/**
* This can only be done by the logged in user.
* Updated user
*/
async updateUserRaw(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
if (requestParameters['username'] == null) {
throw new runtime.RequiredError(
'username',
'Required parameter "username" was null or undefined when calling updateUser().'
);
}
if (requestParameters['user'] == null) {
throw new runtime.RequiredError(
'user',
'Required parameter "user" was null or undefined when calling updateUser().'
);
}
const queryParameters: any = {};
const headerParameters: runtime.HTTPHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = await this.configuration.apiKey("api_key"); // api_key authentication
}
const response = await this.request({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
method: 'PUT',
headers: headerParameters,
query: queryParameters,
body: UserToJSON(requestParameters['user']),
}, initOverrides);
return new runtime.VoidApiResponse(response);
}
/**
* This can only be done by the logged in user.
* Updated user
*/
async updateUser(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
await this.updateUserRaw(requestParameters, initOverrides);
}
}

5
samples/client/petstore/typescript-fetch/builds/validation-attributes/apis/index.ts Normal file
View File

@ -0,0 +1,5 @@
/* tslint:disable */
/* eslint-disable */
export * from './PetApi';
export * from './StoreApi';
export * from './UserApi';

5
samples/client/petstore/typescript-fetch/builds/validation-attributes/index.ts Normal file
View File

@ -0,0 +1,5 @@
/* tslint:disable */
/* eslint-disable */
export * from './runtime';
export * from './apis/index';
export * from './models/index';

88
samples/client/petstore/typescript-fetch/builds/validation-attributes/models/Category.ts Normal file
View File

@ -0,0 +1,88 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import { mapValues } from '../runtime';
/**
* A category for a pet
* @export
* @interface Category
*/
export interface Category {
/**
*
* @type {number}
* @memberof Category
*/
id?: number;
/**
*
* @type {string}
* @memberof Category
*/
name?: string;
}
/**
* Check if a given object implements the Category interface.
*/
export function instanceOfCategory(value: object): value is Category {
return true;
}
export function CategoryFromJSON(json: any): Category {
return CategoryFromJSONTyped(json, false);
}
export function CategoryFromJSONTyped(json: any, ignoreDiscriminator: boolean): Category {
if (json == null) {
return json;
}
return {
'id': json['id'] == null ? undefined : json['id'],
'name': json['name'] == null ? undefined : json['name'],
};
}
export function CategoryToJSON(value?: Category | null): any {
if (value == null) {
return value;
}
return {
'id': value['id'],
'name': value['name'],
};
}
export const CategoryPropertyValidationAttributesMap: {
[property: string]: {
maxLength?: number,
minLength?: number,
pattern?: string,
maximum?: number,
exclusiveMaximum?: boolean,
minimum?: number,
exclusiveMinimum?: boolean,
multipleOf?: number,
maxItems?: number,
minItems?: number,
uniqueItems?: boolean
}
} = {
name: {
pattern: '/^[a-zA-Z0-9]+[a-zA-Z0-9\\.\\-_]*[a-zA-Z0-9]+$/',
},
}

93
samples/client/petstore/typescript-fetch/builds/validation-attributes/models/ModelApiResponse.ts Normal file
View File

@ -0,0 +1,93 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import { mapValues } from '../runtime';
/**
* Describes the result of uploading an image resource
* @export
* @interface ModelApiResponse
*/
export interface ModelApiResponse {
/**
*
* @type {number}
* @memberof ModelApiResponse
*/
code?: number;
/**
*
* @type {string}
* @memberof ModelApiResponse
*/
type?: string;
/**
*
* @type {string}
* @memberof ModelApiResponse
*/
message?: string;
}
/**
* Check if a given object implements the ModelApiResponse interface.
*/
export function instanceOfModelApiResponse(value: object): value is ModelApiResponse {
return true;
}
export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
return ModelApiResponseFromJSONTyped(json, false);
}
export function ModelApiResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelApiResponse {
if (json == null) {
return json;
}
return {
'code': json['code'] == null ? undefined : json['code'],
'type': json['type'] == null ? undefined : json['type'],
'message': json['message'] == null ? undefined : json['message'],
};
}
export function ModelApiResponseToJSON(value?: ModelApiResponse | null): any {
if (value == null) {
return value;
}
return {
'code': value['code'],
'type': value['type'],
'message': value['message'],
};
}
export const ModelApiResponsePropertyValidationAttributesMap: {
[property: string]: {
maxLength?: number,
minLength?: number,
pattern?: string,
maximum?: number,
exclusiveMaximum?: boolean,
minimum?: number,
exclusiveMinimum?: boolean,
multipleOf?: number,
maxItems?: number,
minItems?: number,
uniqueItems?: boolean
}
} = {
}

137
samples/client/petstore/typescript-fetch/builds/validation-attributes/models/Order.ts Normal file
View File

@ -0,0 +1,137 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import { mapValues } from '../runtime';
/**
* An order for a pets from the pet store
* @export
* @interface Order
*/
export interface Order {
[key: string]: string | any;
/**
*
* @type {number}
* @memberof Order
*/
id?: number;
/**
*
* @type {number}
* @memberof Order
*/
petId?: number;
/**
*
* @type {number}
* @memberof Order
*/
quantity?: number;
/**
*
* @type {Date}
* @memberof Order
*/
shipDate?: Date;
/**
* Order Status
* @type {string}
* @memberof Order
*/
status?: OrderStatusEnum;
/**
*
* @type {boolean}
* @memberof Order
*/
complete?: boolean;
}
/**
* @export
*/
export const OrderStatusEnum = {
Placed: 'placed',
Approved: 'approved',
Delivered: 'delivered'
} as const;
export type OrderStatusEnum = typeof OrderStatusEnum[keyof typeof OrderStatusEnum];
/**
* Check if a given object implements the Order interface.
*/
export function instanceOfOrder(value: object): value is Order {
return true;
}
export function OrderFromJSON(json: any): Order {
return OrderFromJSONTyped(json, false);
}
export function OrderFromJSONTyped(json: any, ignoreDiscriminator: boolean): Order {
if (json == null) {
return json;
}
return {
...json,
'id': json['id'] == null ? undefined : json['id'],
'petId': json['petId'] == null ? undefined : json['petId'],
'quantity': json['quantity'] == null ? undefined : json['quantity'],
'shipDate': json['shipDate'] == null ? undefined : (new Date(json['shipDate'])),
'status': json['status'] == null ? undefined : json['status'],
'complete': json['complete'] == null ? undefined : json['complete'],
};
}
export function OrderToJSON(value?: Order | null): any {
if (value == null) {
return value;
}
return {
...value,
'id': value['id'],
'petId': value['petId'],
'quantity': value['quantity'],
'shipDate': value['shipDate'] == null ? undefined : ((value['shipDate']).toISOString()),
'status': value['status'],
'complete': value['complete'],
};
}
export const OrderPropertyValidationAttributesMap: {
[property: string]: {
maxLength?: number,
minLength?: number,
pattern?: string,
maximum?: number,
exclusiveMaximum?: boolean,
minimum?: number,
exclusiveMinimum?: boolean,
multipleOf?: number,
maxItems?: number,
minItems?: number,
uniqueItems?: boolean
}
} = {
}
export const OrderAdditionalPropertiesValidationAttributes: { maxProperties?: number, minProperties?: number } = {
maxProperties: 10,
minProperties: 2,
}

150
samples/client/petstore/typescript-fetch/builds/validation-attributes/models/Pet.ts Normal file
View File

@ -0,0 +1,150 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import { mapValues } from '../runtime';
import type { Category } from './Category';
import {
CategoryFromJSON,
CategoryFromJSONTyped,
CategoryToJSON,
} from './Category';
import type { Tag } from './Tag';
import {
TagFromJSON,
TagFromJSONTyped,
TagToJSON,
} from './Tag';
/**
* A pet for sale in the pet store
* @export
* @interface Pet
*/
export interface Pet {
/**
*
* @type {number}
* @memberof Pet
*/
id?: number;
/**
*
* @type {Category}
* @memberof Pet
*/
category?: Category;
/**
*
* @type {string}
* @memberof Pet
*/
name: string;
/**
*
* @type {Set<string>}
* @memberof Pet
*/
photoUrls: Set<string>;
/**
*
* @type {Array<Tag>}
* @memberof Pet
*/
tags?: Array<Tag>;
/**
* pet status in the store
* @type {string}
* @memberof Pet
* @deprecated
*/
status?: PetStatusEnum;
}
/**
* @export
*/
export const PetStatusEnum = {
Available: 'available',
Pending: 'pending',
Sold: 'sold'
} as const;
export type PetStatusEnum = typeof PetStatusEnum[keyof typeof PetStatusEnum];
/**
* Check if a given object implements the Pet interface.
*/
export function instanceOfPet(value: object): value is Pet {
if (!('name' in value) || value['name'] === undefined) return false;
if (!('photoUrls' in value) || value['photoUrls'] === undefined) return false;
return true;
}
export function PetFromJSON(json: any): Pet {
return PetFromJSONTyped(json, false);
}
export function PetFromJSONTyped(json: any, ignoreDiscriminator: boolean): Pet {
if (json == null) {
return json;
}
return {
'id': json['id'] == null ? undefined : json['id'],
'category': json['category'] == null ? undefined : CategoryFromJSON(json['category']),
'name': json['name'],
'photoUrls': json['photoUrls'],
'tags': json['tags'] == null ? undefined : ((json['tags'] as Array<any>).map(TagFromJSON)),
'status': json['status'] == null ? undefined : json['status'],
};
}
export function PetToJSON(value?: Pet | null): any {
if (value == null) {
return value;
}
return {
'id': value['id'],
'category': CategoryToJSON(value['category']),
'name': value['name'],
'photoUrls': Array.from(value['photoUrls'] as Set<any>),
'tags': value['tags'] == null ? undefined : ((value['tags'] as Array<any>).map(TagToJSON)),
'status': value['status'],
};
}
export const PetPropertyValidationAttributesMap: {
[property: string]: {
maxLength?: number,
minLength?: number,
pattern?: string,
maximum?: number,
exclusiveMaximum?: boolean,
minimum?: number,
exclusiveMinimum?: boolean,
multipleOf?: number,
maxItems?: number,
minItems?: number,
uniqueItems?: boolean
}
} = {
photoUrls: {
maxItems: 8,
minItems: 1,
uniqueItems: true,
},
}

85
samples/client/petstore/typescript-fetch/builds/validation-attributes/models/Tag.ts Normal file
View File

@ -0,0 +1,85 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import { mapValues } from '../runtime';
/**
* A tag for a pet
* @export
* @interface Tag
*/
export interface Tag {
/**
*
* @type {number}
* @memberof Tag
*/
id?: number;
/**
*
* @type {string}
* @memberof Tag
*/
name?: string;
}
/**
* Check if a given object implements the Tag interface.
*/
export function instanceOfTag(value: object): value is Tag {
return true;
}
export function TagFromJSON(json: any): Tag {
return TagFromJSONTyped(json, false);
}
export function TagFromJSONTyped(json: any, ignoreDiscriminator: boolean): Tag {
if (json == null) {
return json;
}
return {
'id': json['id'] == null ? undefined : json['id'],
'name': json['name'] == null ? undefined : json['name'],
};
}
export function TagToJSON(value?: Tag | null): any {
if (value == null) {
return value;
}
return {
'id': value['id'],
'name': value['name'],
};
}
export const TagPropertyValidationAttributesMap: {
[property: string]: {
maxLength?: number,
minLength?: number,
pattern?: string,
maximum?: number,
exclusiveMaximum?: boolean,
minimum?: number,
exclusiveMinimum?: boolean,
multipleOf?: number,
maxItems?: number,
minItems?: number,
uniqueItems?: boolean
}
} = {
}

144
samples/client/petstore/typescript-fetch/builds/validation-attributes/models/User.ts Normal file
View File

@ -0,0 +1,144 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
import { mapValues } from '../runtime';
/**
* A User who is purchasing from the pet store
* @export
* @interface User
*/
export interface User {
/**
*
* @type {number}
* @memberof User
*/
id?: number;
/**
*
* @type {string}
* @memberof User
*/
username?: string;
/**
*
* @type {string}
* @memberof User
*/
firstName?: string;
/**
*
* @type {string}
* @memberof User
*/
lastName?: string;
/**
*
* @type {string}
* @memberof User
*/
email?: string;
/**
*
* @type {string}
* @memberof User
*/
password?: string;
/**
*
* @type {string}
* @memberof User
*/
phone?: string;
/**
* User Status
* @type {number}
* @memberof User
*/
userStatus?: number;
}
/**
* Check if a given object implements the User interface.
*/
export function instanceOfUser(value: object): value is User {
return true;
}
export function UserFromJSON(json: any): User {
return UserFromJSONTyped(json, false);
}
export function UserFromJSONTyped(json: any, ignoreDiscriminator: boolean): User {
if (json == null) {
return json;
}
return {
'id': json['id'] == null ? undefined : json['id'],
'username': json['username'] == null ? undefined : json['username'],
'firstName': json['firstName'] == null ? undefined : json['firstName'],
'lastName': json['lastName'] == null ? undefined : json['lastName'],
'email': json['email'] == null ? undefined : json['email'],
'password': json['password'] == null ? undefined : json['password'],
'phone': json['phone'] == null ? undefined : json['phone'],
'userStatus': json['userStatus'] == null ? undefined : json['userStatus'],
};
}
export function UserToJSON(value?: User | null): any {
if (value == null) {
return value;
}
return {
'id': value['id'],
'username': value['username'],
'firstName': value['firstName'],
'lastName': value['lastName'],
'email': value['email'],
'password': value['password'],
'phone': value['phone'],
'userStatus': value['userStatus'],
};
}
export const UserPropertyValidationAttributesMap: {
[property: string]: {
maxLength?: number,
minLength?: number,
pattern?: string,
maximum?: number,
exclusiveMaximum?: boolean,
minimum?: number,
exclusiveMinimum?: boolean,
multipleOf?: number,
maxItems?: number,
minItems?: number,
uniqueItems?: boolean
}
} = {
password: {
maxLength: 256,
minLength: 8,
},
userStatus: {
maximum: 100,
exclusiveMaximum: true,
minimum: 0,
exclusiveMinimum: true,
multipleOf: 10,
},
}

8
samples/client/petstore/typescript-fetch/builds/validation-attributes/models/index.ts Normal file
View File

@ -0,0 +1,8 @@
/* tslint:disable */
/* eslint-disable */
export * from './Category';
export * from './ModelApiResponse';
export * from './Order';
export * from './Pet';
export * from './Tag';
export * from './User';

426
samples/client/petstore/typescript-fetch/builds/validation-attributes/runtime.ts Normal file
View File

@ -0,0 +1,426 @@
/* tslint:disable */
/* eslint-disable */
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
export const BASE_PATH = "http://petstore.swagger.io/v2".replace(/\/+$/, "");
export interface ConfigurationParameters {
basePath?: string; // override base path
fetchApi?: FetchAPI; // override for fetch implementation
middleware?: Middleware[]; // middleware to apply before/after fetch requests
queryParamsStringify?: (params: HTTPQuery) => string; // stringify function for query strings
username?: string; // parameter for basic security
password?: string; // parameter for basic security
apiKey?: string | Promise<string> | ((name: string) => string | Promise<string>); // parameter for apiKey security
accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string | Promise<string>); // parameter for oauth2 security
headers?: HTTPHeaders; //header params we want to use on every request
credentials?: RequestCredentials; //value for the credentials param we want to use on each request
}
export class Configuration {
constructor(private configuration: ConfigurationParameters = {}) {}
set config(configuration: Configuration) {
this.configuration = configuration;
}
get basePath(): string {
return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
}
get fetchApi(): FetchAPI | undefined {
return this.configuration.fetchApi;
}
get middleware(): Middleware[] {
return this.configuration.middleware || [];
}
get queryParamsStringify(): (params: HTTPQuery) => string {
return this.configuration.queryParamsStringify || querystring;
}
get username(): string | undefined {
return this.configuration.username;
}
get password(): string | undefined {
return this.configuration.password;
}
get apiKey(): ((name: string) => string | Promise<string>) | undefined {
const apiKey = this.configuration.apiKey;
if (apiKey) {
return typeof apiKey === 'function' ? apiKey : () => apiKey;
}
return undefined;
}
get accessToken(): ((name?: string, scopes?: string[]) => string | Promise<string>) | undefined {
const accessToken = this.configuration.accessToken;
if (accessToken) {
return typeof accessToken === 'function' ? accessToken : async () => accessToken;
}
return undefined;
}
get headers(): HTTPHeaders | undefined {
return this.configuration.headers;
}
get credentials(): RequestCredentials | undefined {
return this.configuration.credentials;
}
}
export const DefaultConfig = new Configuration();
/**
* This is the base class for all generated API classes.
*/
export class BaseAPI {
private static readonly jsonRegex = new RegExp('^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
private middleware: Middleware[];
constructor(protected configuration = DefaultConfig) {
this.middleware = configuration.middleware;
}
withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
const next = this.clone<T>();
next.middleware = next.middleware.concat(...middlewares);
return next;
}
withPreMiddleware<T extends BaseAPI>(this: T, ...preMiddlewares: Array<Middleware['pre']>) {
const middlewares = preMiddlewares.map((pre) => ({ pre }));
return this.withMiddleware<T>(...middlewares);
}
withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
const middlewares = postMiddlewares.map((post) => ({ post }));
return this.withMiddleware<T>(...middlewares);
}
/**
* Check if the given MIME is a JSON MIME.
* JSON MIME examples:
* application/json
* application/json; charset=UTF8
* APPLICATION/JSON
* application/vnd.company+json
* @param mime - MIME (Multipurpose Internet Mail Extensions)
* @return True if the given MIME is JSON, false otherwise.
*/
protected isJsonMime(mime: string | null | undefined): boolean {
if (!mime) {
return false;
}
return BaseAPI.jsonRegex.test(mime);
}
protected async request(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction): Promise<Response> {
const { url, init } = await this.createFetchParams(context, initOverrides);
const response = await this.fetchApi(url, init);
if (response && (response.status >= 200 && response.status < 300)) {
return response;
}
throw new ResponseError(response, 'Response returned an error code');
}
private async createFetchParams(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction) {
let url = this.configuration.basePath + context.path;
if (context.query !== undefined && Object.keys(context.query).length !== 0) {
// only add the querystring to the URL if there are query parameters.
// this is done to avoid urls ending with a "?" character which buggy webservers
// do not handle correctly sometimes.
url += '?' + this.configuration.queryParamsStringify(context.query);
}
const headers = Object.assign({}, this.configuration.headers, context.headers);
Object.keys(headers).forEach(key => headers[key] === undefined ? delete headers[key] : {});
const initOverrideFn =
typeof initOverrides === "function"
? initOverrides
: async () => initOverrides;
const initParams = {
method: context.method,
headers,
body: context.body,
credentials: this.configuration.credentials,
};
const overriddenInit: RequestInit = {
...initParams,
...(await initOverrideFn({
init: initParams,
context,
}))
};
let body: any;
if (isFormData(overriddenInit.body)
|| (overriddenInit.body instanceof URLSearchParams)
|| isBlob(overriddenInit.body)) {
body = overriddenInit.body;
} else if (this.isJsonMime(headers['Content-Type'])) {
body = JSON.stringify(overriddenInit.body);
} else {
body = overriddenInit.body;
}
const init: RequestInit = {
...overriddenInit,
body
};
return { url, init };
}
private fetchApi = async (url: string, init: RequestInit) => {
let fetchParams = { url, init };
for (const middleware of this.middleware) {
if (middleware.pre) {
fetchParams = await middleware.pre({
fetch: this.fetchApi,
...fetchParams,
}) || fetchParams;
}
}
let response: Response | undefined = undefined;
try {
response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
} catch (e) {
for (const middleware of this.middleware) {
if (middleware.onError) {
response = await middleware.onError({
fetch: this.fetchApi,
url: fetchParams.url,
init: fetchParams.init,
error: e,
response: response ? response.clone() : undefined,
}) || response;
}
}
if (response === undefined) {
if (e instanceof Error) {
throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
} else {
throw e;
}
}
}
for (const middleware of this.middleware) {
if (middleware.post) {
response = await middleware.post({
fetch: this.fetchApi,
url: fetchParams.url,
init: fetchParams.init,
response: response.clone(),
}) || response;
}
}
return response;
}
/**
* Create a shallow clone of `this` by constructing a new instance
* and then shallow cloning data members.
*/
private clone<T extends BaseAPI>(this: T): T {
const constructor = this.constructor as any;
const next = new constructor(this.configuration);
next.middleware = this.middleware.slice();
return next;
}
};
function isBlob(value: any): value is Blob {
return typeof Blob !== 'undefined' && value instanceof Blob;
}
function isFormData(value: any): value is FormData {
return typeof FormData !== "undefined" && value instanceof FormData;
}
export class ResponseError extends Error {
override name: "ResponseError" = "ResponseError";
constructor(public response: Response, msg?: string) {
super(msg);
}
}
export class FetchError extends Error {
override name: "FetchError" = "FetchError";
constructor(public cause: Error, msg?: string) {
super(msg);
}
}
export class RequiredError extends Error {
override name: "RequiredError" = "RequiredError";
constructor(public field: string, msg?: string) {
super(msg);
}
}
export const COLLECTION_FORMATS = {
csv: ",",
ssv: " ",
tsv: "\t",
pipes: "|",
};
export type FetchAPI = WindowOrWorkerGlobalScope['fetch'];
export type Json = any;
export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
export type HTTPHeaders = { [key: string]: string };
export type HTTPQuery = { [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery };
export type HTTPBody = Json | FormData | URLSearchParams;
export type HTTPRequestInit = { headers?: HTTPHeaders; method: HTTPMethod; credentials?: RequestCredentials; body?: HTTPBody };
export type ModelPropertyNaming = 'camelCase' | 'snake_case' | 'PascalCase' | 'original';
export type InitOverrideFunction = (requestContext: { init: HTTPRequestInit, context: RequestOpts }) => Promise<RequestInit>
export interface FetchParams {
url: string;
init: RequestInit;
}
export interface RequestOpts {
path: string;
method: HTTPMethod;
headers: HTTPHeaders;
query?: HTTPQuery;
body?: HTTPBody;
}
export function querystring(params: HTTPQuery, prefix: string = ''): string {
return Object.keys(params)
.map(key => querystringSingleKey(key, params[key], prefix))
.filter(part => part.length > 0)
.join('&');
}
function querystringSingleKey(key: string, value: string | number | null | undefined | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery, keyPrefix: string = ''): string {
const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
if (value instanceof Array) {
const multiValue = value.map(singleValue => encodeURIComponent(String(singleValue)))
.join(`&${encodeURIComponent(fullKey)}=`);
return `${encodeURIComponent(fullKey)}=${multiValue}`;
}
if (value instanceof Set) {
const valueAsArray = Array.from(value);
return querystringSingleKey(key, valueAsArray, keyPrefix);
}
if (value instanceof Date) {
return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
}
if (value instanceof Object) {
return querystring(value as HTTPQuery, fullKey);
}
return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
}
export function mapValues(data: any, fn: (item: any) => any) {
return Object.keys(data).reduce(
(acc, key) => ({ ...acc, [key]: fn(data[key]) }),
{}
);
}
export function canConsumeForm(consumes: Consume[]): boolean {
for (const consume of consumes) {
if ('multipart/form-data' === consume.contentType) {
return true;
}
}
return false;
}
export interface Consume {
contentType: string;
}
export interface RequestContext {
fetch: FetchAPI;
url: string;
init: RequestInit;
}
export interface ResponseContext {
fetch: FetchAPI;
url: string;
init: RequestInit;
response: Response;
}
export interface ErrorContext {
fetch: FetchAPI;
url: string;
init: RequestInit;
error: unknown;
response?: Response;
}
export interface Middleware {
pre?(context: RequestContext): Promise<FetchParams | void>;
post?(context: ResponseContext): Promise<Response | void>;
onError?(context: ErrorContext): Promise<Response | void>;
}
export interface ApiResponse<T> {
raw: Response;
value(): Promise<T>;
}
export interface ResponseTransformer<T> {
(json: any): T;
}
export class JSONApiResponse<T> {
constructor(public raw: Response, private transformer: ResponseTransformer<T> = (jsonValue: any) => jsonValue) {}
async value(): Promise<T> {
return this.transformer(await this.raw.json());
}
}
export class VoidApiResponse {
constructor(public raw: Response) {}
async value(): Promise<void> {
return undefined;
}
}
export class BlobApiResponse {
constructor(public raw: Response) {}
async value(): Promise<Blob> {
return await this.raw.blob();
};
}
export class TextApiResponse {
constructor(public raw: Response) {}
async value(): Promise<string> {
return await this.raw.text();
};
}