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

[typescript-rxjs] refactor to arrow functions and short hand object creation (#3077)

Browse Source 
* feat(typescript-rxjs): change BaseAPI to arrow functions, use shorthands where possible

* feat(typescript-rxjs): replace null checking with throwIfRequired helper function in api controllers

* feat(typescript-rxjs): use shorthand syntax for object creation of query and header params

* feat(typescript-rxjs): provide fallback for previously exported RequiredError and querystring

* refactor(typescript-rxjs): change order of query and headers definition

* feat(typescript-rxjs): regenerate samples

* fix(typescript-rxjs): missing closing curly

* fix(typescript-rxjs): add condition to prevent undefined parameters in header or query params
This commit is contained in:
Bernd
2019-06-25 06:04:40 +02:00
committed by William Cheng
parent 2b55413371
commit 9518e2a02e
18 changed files with 1175 additions and 1413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
modules/openapi-generator/src/main/resources/typescript-rxjs/apis.mustache vendored
View File

@@ -1,7 +1,7 @@
// tslint:disable
{{>licenseInfo}}
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
{{#imports.0}}
import {
{{#imports}}
@@ -37,105 +37,83 @@ export class {{classname}} extends BaseAPI {
* {{&summary}}
{{/summary}}
*/
{{nickname}}({{#allParams.0}}requestParameters: {{operationIdCamelCase}}Request{{/allParams.0}}): Observable<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}> {
{{nickname}} = ({{#allParams.0}}requestParameters: {{operationIdCamelCase}}Request{{/allParams.0}}): Observable<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}> => {
{{#allParams}}
{{#required}}
if (requestParameters.{{paramName}} === null || requestParameters.{{paramName}} === undefined) {
throw new RequiredError('{{paramName}}','Required parameter requestParameters.{{paramName}} was null or undefined when calling {{nickname}}.');
}
throwIfRequired(requestParameters, '{{paramName}}', '{{nickname}}');
{{/required}}
{{/allParams}}
const queryParameters: HttpQuery = {};
{{#queryParams}}
{{#isListContainer}}
if (requestParameters.{{paramName}}) {
const headers: HttpHeaders = {
{{#bodyParam}}
{{^consumes}}
'Content-Type': 'application/json',
{{/consumes}}
{{#consumes.0}}
'Content-Type': '{{{mediaType}}}',
{{/consumes.0}}
{{/bodyParam}}
{{#headerParams}}
{{#isListContainer}}
...(requestParameters.{{paramName}} && { '{{baseName}}': requestParameters.{{paramName}}.join(COLLECTION_FORMATS['{{collectionFormat}}'])) }),
{{/isListContainer}}
{{^isListContainer}}
...(requestParameters.{{paramName}} && { '{{baseName}}': String(requestParameters.{{paramName}}) }),
{{/isListContainer}}
{{/headerParams}}
{{#authMethods}}
{{#isBasic}}
...(this.configuration.username && this.configuration.password && { Authorization: `Basic ${btoa(this.configuration.username + ':' + this.configuration.password)}` }),
{{/isBasic}}
{{#isApiKey}}
{{#isKeyInHeader}}
...(this.configuration.apiKey && { '{{keyParamName}}': this.configuration.apiKey('{{keyParamName}}') }), // {{name}} authentication
{{/isKeyInHeader}}
{{/isApiKey}}
{{#isOAuth}}
// oauth required
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('{{name}}', [{{#scopes}}'{{{scope}}}'{{^-last}}, {{/-last}}{{/scopes}}])
: this.configuration.accessToken)
}),
{{/isOAuth}}
{{/authMethods}}
};
const query: HttpQuery = {
{{#queryParams}}
{{#isListContainer}}
{{#isCollectionFormatMulti}}
queryParameters['{{baseName}}'] = requestParameters.{{paramName}};
...(requestParameters.{{paramName}} && { '{{baseName}}': requestParameters.{{paramName}} }),
{{/isCollectionFormatMulti}}
{{^isCollectionFormatMulti}}
queryParameters['{{baseName}}'] = requestParameters.{{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]);
...(requestParameters.{{paramName}} && { '{{baseName}}': requestParameters.{{paramName}}.join(COLLECTION_FORMATS['{{collectionFormat}}']) }),
{{/isCollectionFormatMulti}}
}
{{/isListContainer}}
{{^isListContainer}}
if (requestParameters.{{paramName}} !== undefined && requestParameters.{{paramName}} !== null) {
{{/isListContainer}}
{{^isListContainer}}
{{#isDateTime}}
queryParameters['{{baseName}}'] = (requestParameters.{{paramName}} as any).toISOString();
...(requestParameters.{{paramName}} && { '{{baseName}}': (requestParameters.{{paramName}} as any).toISOString() }),
{{/isDateTime}}
{{^isDateTime}}
{{#isDate}}
queryParameters['{{baseName}}'] = (requestParameters.{{paramName}} as any).toISOString();
...(requestParameters.{{paramName}} && { '{{baseName}}': (requestParameters.{{paramName}} as any).toISOString() }),
{{/isDate}}
{{^isDate}}
queryParameters['{{baseName}}'] = requestParameters.{{paramName}};
...(requestParameters.{{paramName}} && { '{{baseName}}': requestParameters.{{paramName}} }),
{{/isDate}}
{{/isDateTime}}
}
{{/isListContainer}}
{{/queryParams}}
{{#authMethods}}
{{#isApiKey}}
{{#isKeyInQuery}}
...(this.configuration.apiKey && { '{{keyParamName}}': this.configuration.apiKey && this.configuration.apiKey('{{keyParamName}}') }), // {{name}} authentication
{{/isKeyInQuery}}
{{/isApiKey}}
{{/authMethods}}
};
{{/isListContainer}}
{{/queryParams}}
const headerParameters: HttpHeaders = {};
{{#bodyParam}}
{{^consumes}}
headerParameters['Content-Type'] = 'application/json';
{{/consumes}}
{{#consumes.0}}
headerParameters['Content-Type'] = '{{{mediaType}}}';
{{/consumes.0}}
{{/bodyParam}}
{{#headerParams}}
{{#isListContainer}}
if (requestParameters.{{paramName}}) {
headerParameters['{{baseName}}'] = requestParameters.{{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]));
}
{{/isListContainer}}
{{^isListContainer}}
if (requestParameters.{{paramName}} !== undefined && requestParameters.{{paramName}} !== null) {
headerParameters['{{baseName}}'] = String(requestParameters.{{paramName}});
}
{{/isListContainer}}
{{/headerParams}}
{{#authMethods}}
{{#isBasic}}
if (this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
}
{{/isBasic}}
{{#isApiKey}}
{{#isKeyInHeader}}
if (this.configuration && this.configuration.apiKey) {
headerParameters["{{keyParamName}}"] = this.configuration.apiKey("{{keyParamName}}"); // {{name}} authentication
}
{{/isKeyInHeader}}
{{#isKeyInQuery}}
if (this.configuration && this.configuration.apiKey) {
queryParameters["{{keyParamName}}"] = this.configuration.apiKey("{{keyParamName}}"); // {{name}} authentication
}
{{/isKeyInQuery}}
{{/isApiKey}}
{{#isOAuth}}
if (this.configuration && this.configuration.accessToken) {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("{{name}}", [{{#scopes}}"{{{scope}}}"{{^-last}}, {{/-last}}{{/scopes}}]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
{{/isOAuth}}
{{/authMethods}}
{{#hasFormParams}}
const formData = new FormData();
{{/hasFormParams}}
@@ -148,7 +126,7 @@ export class {{classname}} extends BaseAPI {
})
{{/isCollectionFormatMulti}}
{{^isCollectionFormatMulti}}
formData.append('{{baseName}}', requestParameters.{{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]));
formData.append('{{baseName}}', requestParameters.{{paramName}}.join(COLLECTION_FORMATS['{{collectionFormat}}']));
{{/isCollectionFormatMulti}}
}
@@ -161,10 +139,10 @@ export class {{classname}} extends BaseAPI {
{{/isListContainer}}
{{/formParams}}
return this.request<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}>({
path: `{{{path}}}`{{#pathParams}}.replace(`{${"{{baseName}}"}}`, encodeURIComponent(String(requestParameters.{{paramName}}))){{/pathParams}},
path: `{{{path}}}`{{#pathParams}}.replace({{=<% %>=}}`{<%baseName%>}`<%={{ }}=%>, encodeURIComponent(String(requestParameters.{{paramName}}))){{/pathParams}},
method: '{{httpMethod}}',
headers: headerParameters,
query: queryParameters,
headers,
query,
{{#hasBodyParam}}
{{#bodyParam}}
{{#isContainer}}
@@ -196,9 +174,9 @@ export class {{classname}} extends BaseAPI {
{{#allParams}}
{{#isEnum}}
/**
* @export
* @enum {string}
*/
* @export
* @enum {string}
*/
export enum {{operationIdCamelCase}}{{enumName}} {
{{#allowableValues}}
{{#enumVars}}

76
modules/openapi-generator/src/main/resources/typescript-rxjs/runtime.mustache vendored
View File

@@ -55,30 +55,26 @@ export class Configuration {
* This is the base class for all generated API classes.
*/
export class BaseAPI {
private middleware: Middleware[];
private middleware: Middleware[] = [];
constructor(protected configuration = new Configuration()) {
this.middleware = configuration.middleware;
}
withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
withMiddleware = <T extends BaseAPI>(middlewares: Middleware[]) => {
const next = this.clone<T>();
next.middleware = next.middleware.concat(...middlewares);
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);
}
withPreMiddleware = <T extends BaseAPI>(preMiddlewares: Array<Middleware['pre']>) =>
this.withMiddleware<T>(preMiddlewares.map((pre) => ({ pre })));
withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
const middlewares = postMiddlewares.map((post) => ({ post }));
return this.withMiddleware<T>(...middlewares);
}
withPostMiddleware = <T extends BaseAPI>(postMiddlewares: Array<Middleware['post']>) =>
this.withMiddleware<T>(postMiddlewares.map((post) => ({ post })));
protected request<T>(context: RequestOpts): Observable<T> {
return this.rxjsRequest(this.createRequestArgs(context)).pipe(
protected request = <T>(context: RequestOpts): Observable<T> =>
this.rxjsRequest(this.createRequestArgs(context)).pipe(
map((res) => {
if (res.status >= 200 && res.status < 300) {
return res.response as T;
@@ -86,15 +82,14 @@ export class BaseAPI {
throw res;
})
);
}
private createRequestArgs(context: RequestOpts): RequestArgs {
private createRequestArgs = (context: RequestOpts): RequestArgs => {
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.
// 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 += '?' + querystring(context.query);
url += '?' + queryString(context.query);
}
const body = context.body instanceof FormData ? context.body : JSON.stringify(context.body);
const options = {
@@ -105,9 +100,9 @@ export class BaseAPI {
return { url, options };
}
private rxjsRequest(params: RequestContext): Observable<AjaxResponse> {
const preMiddlewares = this.middleware && this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware && this.middleware.filter((item) => item.post);
private rxjsRequest = (params: RequestContext): Observable<AjaxResponse> => {
const preMiddlewares = this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware.filter((item) => item.post);
return of(params).pipe(
map((args) => {
@@ -133,19 +128,13 @@ export class BaseAPI {
* 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;
}
private clone = <T extends BaseAPI>(): T =>
Object.assign(Object.create(Object.getPrototypeOf(this)), this)
}
// export for not being a breaking change
export class RequiredError extends Error {
name: 'RequiredError' = 'RequiredError';
constructor(public field: string, msg?: string) {
super(msg);
}
}
export const COLLECTION_FORMATS = {
@@ -175,17 +164,24 @@ export interface RequestOpts {
body?: HttpBody;
}
export function querystring(params: HttpQuery): string {
return Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
const queryString = (params: HttpQuery): string => Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
// alias fallback for not being a breaking change
export const querystring = queryString;
export const throwIfRequired = (params: {[key: string]: any}, key: string, nickname: string) => {
if (!params || params[key] === null || params[key] === undefined) {
throw new RequiredError(`Required parameter ${key} was null or undefined when calling ${nickname}.`);
}
}
export interface RequestContext extends RequestArgs {}

275
samples/client/petstore/typescript-rxjs/builds/default/apis/PetApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
ApiResponse,
Pet,
@@ -63,31 +63,27 @@ export class PetApi extends BaseAPI {
/**
* Add a new pet to the store
*/
addPet(requestParameters: AddPetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling addPet.');
}
addPet = (requestParameters: AddPetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'addPet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -95,33 +91,27 @@ export class PetApi extends BaseAPI {
/**
* Deletes a pet
*/
deletePet(requestParameters: DeletePetRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
}
deletePet = (requestParameters: DeletePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'deletePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
headerParameters['api_key'] = String(requestParameters.apiKey);
}
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
...(requestParameters.apiKey && { 'api_key': String(requestParameters.apiKey) }),
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -129,33 +119,27 @@ export class PetApi extends BaseAPI {
* Multiple status values can be provided with comma separated strings
* Finds Pets by status
*/
findPetsByStatus(requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> {
if (requestParameters.status === null || requestParameters.status === undefined) {
throw new RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
}
findPetsByStatus = (requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'status', 'findPetsByStatus');
const queryParameters: HttpQuery = {};
if (requestParameters.status) {
queryParameters['status'] = requestParameters.status.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.status && { 'status': requestParameters.status.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByStatus`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -163,33 +147,27 @@ export class PetApi extends BaseAPI {
* Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
* Finds Pets by tags
*/
findPetsByTags(requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> {
if (requestParameters.tags === null || requestParameters.tags === undefined) {
throw new RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
}
findPetsByTags = (requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'tags', 'findPetsByTags');
const queryParameters: HttpQuery = {};
if (requestParameters.tags) {
queryParameters['tags'] = requestParameters.tags.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.tags && { 'tags': requestParameters.tags.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByTags`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -197,55 +175,48 @@ export class PetApi extends BaseAPI {
* Returns a single pet
* Find pet by ID
*/
getPetById(requestParameters: GetPetByIdRequest): Observable<Pet> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
}
getPetById = (requestParameters: GetPetByIdRequest): Observable<Pet> => {
throwIfRequired(requestParameters, 'petId', 'getPetById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<Pet>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Update an existing pet
*/
updatePet(requestParameters: UpdatePetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updatePet.');
}
updatePet = (requestParameters: UpdatePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'updatePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -253,23 +224,20 @@ export class PetApi extends BaseAPI {
/**
* Updates a pet in the store with form data
*/
updatePetWithForm(requestParameters: UpdatePetWithFormRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
}
updatePetWithForm = (requestParameters: UpdatePetWithFormRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'updatePetWithForm');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.name !== undefined) {
@@ -281,10 +249,10 @@ export class PetApi extends BaseAPI {
}
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -292,23 +260,20 @@ export class PetApi extends BaseAPI {
/**
* uploads an image
*/
uploadFile(requestParameters: UploadFileRequest): Observable<ApiResponse> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
}
uploadFile = (requestParameters: UploadFileRequest): Observable<ApiResponse> => {
throwIfRequired(requestParameters, 'petId', 'uploadFile');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.additionalMetadata !== undefined) {
@@ -320,10 +285,10 @@ export class PetApi extends BaseAPI {
}
return this.request<ApiResponse>({
path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}/uploadImage`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -331,9 +296,9 @@ export class PetApi extends BaseAPI {
}
/**
* @export
* @enum {string}
*/
* @export
* @enum {string}
*/
export enum FindPetsByStatusStatusEnum {
Available = 'available',
Pending = 'pending',

73
samples/client/petstore/typescript-rxjs/builds/default/apis/StoreApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
Order,
} from '../models';
@@ -38,20 +38,20 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
* Delete purchase order by ID
*/
deleteOrder(requestParameters: DeleteOrderRequest): Observable<void> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
}
deleteOrder = (requestParameters: DeleteOrderRequest): Observable<void> => {
throwIfRequired(requestParameters, 'orderId', 'deleteOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -59,20 +59,20 @@ export class StoreApi extends BaseAPI {
* Returns a map of status codes to quantities
* Returns pet inventories by status
*/
getInventory(): Observable<{ [key: string]: number; }> {
const queryParameters: HttpQuery = {};
getInventory = (): Observable<{ [key: string]: number; }> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<{ [key: string]: number; }>({
path: `/store/inventory`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -80,42 +80,41 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
* Find purchase order by ID
*/
getOrderById(requestParameters: GetOrderByIdRequest): Observable<Order> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
}
getOrderById = (requestParameters: GetOrderByIdRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'orderId', 'getOrderById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Place an order for a pet
*/
placeOrder(requestParameters: PlaceOrderRequest): Observable<Order> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling placeOrder.');
}
placeOrder = (requestParameters: PlaceOrderRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'body', 'placeOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

165
samples/client/petstore/typescript-rxjs/builds/default/apis/UserApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
User,
} from '../models';
@@ -56,22 +56,21 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Create user
*/
createUser(requestParameters: CreateUserRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUser.');
}
createUser = (requestParameters: CreateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -79,22 +78,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithArrayInput(requestParameters: CreateUsersWithArrayInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithArrayInput.');
}
createUsersWithArrayInput = (requestParameters: CreateUsersWithArrayInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithArrayInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithArray`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -102,22 +100,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithListInput(requestParameters: CreateUsersWithListInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithListInput.');
}
createUsersWithListInput = (requestParameters: CreateUsersWithListInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithListInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithList`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -126,88 +123,82 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Delete user
*/
deleteUser(requestParameters: DeleteUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
}
deleteUser = (requestParameters: DeleteUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'deleteUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Get user by user name
*/
getUserByName(requestParameters: GetUserByNameRequest): Observable<User> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
}
getUserByName = (requestParameters: GetUserByNameRequest): Observable<User> => {
throwIfRequired(requestParameters, 'username', 'getUserByName');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<User>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs user into the system
*/
loginUser(requestParameters: LoginUserRequest): Observable<string> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
}
loginUser = (requestParameters: LoginUserRequest): Observable<string> => {
throwIfRequired(requestParameters, 'username', 'loginUser');
throwIfRequired(requestParameters, 'password', 'loginUser');
if (requestParameters.password === null || requestParameters.password === undefined) {
throw new RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
}
const headers: HttpHeaders = {
};
const queryParameters: HttpQuery = {};
if (requestParameters.username !== undefined && requestParameters.username !== null) {
queryParameters['username'] = requestParameters.username;
}
if (requestParameters.password !== undefined && requestParameters.password !== null) {
queryParameters['password'] = requestParameters.password;
}
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
...(requestParameters.username && { 'username': requestParameters.username }),
...(requestParameters.password && { 'password': requestParameters.password }),
};
return this.request<string>({
path: `/user/login`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs out current logged in user session
*/
logoutUser(): Observable<void> {
const queryParameters: HttpQuery = {};
logoutUser = (): Observable<void> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/logout`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -215,26 +206,22 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Updated user
*/
updateUser(requestParameters: UpdateUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
}
updateUser = (requestParameters: UpdateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'updateUser');
throwIfRequired(requestParameters, 'body', 'updateUser');
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updateUser.');
}
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

76
samples/client/petstore/typescript-rxjs/builds/default/runtime.ts
View File

@@ -66,30 +66,26 @@ export class Configuration {
* This is the base class for all generated API classes.
*/
export class BaseAPI {
private middleware: Middleware[];
private middleware: Middleware[] = [];
constructor(protected configuration = new Configuration()) {
this.middleware = configuration.middleware;
}
withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
withMiddleware = <T extends BaseAPI>(middlewares: Middleware[]) => {
const next = this.clone<T>();
next.middleware = next.middleware.concat(...middlewares);
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);
}
withPreMiddleware = <T extends BaseAPI>(preMiddlewares: Array<Middleware['pre']>) =>
this.withMiddleware<T>(preMiddlewares.map((pre) => ({ pre })));
withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
const middlewares = postMiddlewares.map((post) => ({ post }));
return this.withMiddleware<T>(...middlewares);
}
withPostMiddleware = <T extends BaseAPI>(postMiddlewares: Array<Middleware['post']>) =>
this.withMiddleware<T>(postMiddlewares.map((post) => ({ post })));
protected request<T>(context: RequestOpts): Observable<T> {
return this.rxjsRequest(this.createRequestArgs(context)).pipe(
protected request = <T>(context: RequestOpts): Observable<T> =>
this.rxjsRequest(this.createRequestArgs(context)).pipe(
map((res) => {
if (res.status >= 200 && res.status < 300) {
return res.response as T;
@@ -97,15 +93,14 @@ export class BaseAPI {
throw res;
})
);
}
private createRequestArgs(context: RequestOpts): RequestArgs {
private createRequestArgs = (context: RequestOpts): RequestArgs => {
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.
// 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 += '?' + querystring(context.query);
url += '?' + queryString(context.query);
}
const body = context.body instanceof FormData ? context.body : JSON.stringify(context.body);
const options = {
@@ -116,9 +111,9 @@ export class BaseAPI {
return { url, options };
}
private rxjsRequest(params: RequestContext): Observable<AjaxResponse> {
const preMiddlewares = this.middleware && this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware && this.middleware.filter((item) => item.post);
private rxjsRequest = (params: RequestContext): Observable<AjaxResponse> => {
const preMiddlewares = this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware.filter((item) => item.post);
return of(params).pipe(
map((args) => {
@@ -144,19 +139,13 @@ export class BaseAPI {
* 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;
}
private clone = <T extends BaseAPI>(): T =>
Object.assign(Object.create(Object.getPrototypeOf(this)), this)
}
// export for not being a breaking change
export class RequiredError extends Error {
name: 'RequiredError' = 'RequiredError';
constructor(public field: string, msg?: string) {
super(msg);
}
}
export const COLLECTION_FORMATS = {
@@ -186,17 +175,24 @@ export interface RequestOpts {
body?: HttpBody;
}
export function querystring(params: HttpQuery): string {
return Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
const queryString = (params: HttpQuery): string => Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
// alias fallback for not being a breaking change
export const querystring = queryString;
export const throwIfRequired = (params: {[key: string]: any}, key: string, nickname: string) => {
if (!params || params[key] === null || params[key] === undefined) {
throw new RequiredError(`Required parameter ${key} was null or undefined when calling ${nickname}.`);
}
}
export interface RequestContext extends RequestArgs {}

275
samples/client/petstore/typescript-rxjs/builds/es6-target/apis/PetApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
ApiResponse,
Pet,
@@ -63,31 +63,27 @@ export class PetApi extends BaseAPI {
/**
* Add a new pet to the store
*/
addPet(requestParameters: AddPetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling addPet.');
}
addPet = (requestParameters: AddPetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'addPet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -95,33 +91,27 @@ export class PetApi extends BaseAPI {
/**
* Deletes a pet
*/
deletePet(requestParameters: DeletePetRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
}
deletePet = (requestParameters: DeletePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'deletePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
headerParameters['api_key'] = String(requestParameters.apiKey);
}
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
...(requestParameters.apiKey && { 'api_key': String(requestParameters.apiKey) }),
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -129,33 +119,27 @@ export class PetApi extends BaseAPI {
* Multiple status values can be provided with comma separated strings
* Finds Pets by status
*/
findPetsByStatus(requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> {
if (requestParameters.status === null || requestParameters.status === undefined) {
throw new RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
}
findPetsByStatus = (requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'status', 'findPetsByStatus');
const queryParameters: HttpQuery = {};
if (requestParameters.status) {
queryParameters['status'] = requestParameters.status.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.status && { 'status': requestParameters.status.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByStatus`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -163,33 +147,27 @@ export class PetApi extends BaseAPI {
* Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
* Finds Pets by tags
*/
findPetsByTags(requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> {
if (requestParameters.tags === null || requestParameters.tags === undefined) {
throw new RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
}
findPetsByTags = (requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'tags', 'findPetsByTags');
const queryParameters: HttpQuery = {};
if (requestParameters.tags) {
queryParameters['tags'] = requestParameters.tags.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.tags && { 'tags': requestParameters.tags.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByTags`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -197,55 +175,48 @@ export class PetApi extends BaseAPI {
* Returns a single pet
* Find pet by ID
*/
getPetById(requestParameters: GetPetByIdRequest): Observable<Pet> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
}
getPetById = (requestParameters: GetPetByIdRequest): Observable<Pet> => {
throwIfRequired(requestParameters, 'petId', 'getPetById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<Pet>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Update an existing pet
*/
updatePet(requestParameters: UpdatePetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updatePet.');
}
updatePet = (requestParameters: UpdatePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'updatePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -253,23 +224,20 @@ export class PetApi extends BaseAPI {
/**
* Updates a pet in the store with form data
*/
updatePetWithForm(requestParameters: UpdatePetWithFormRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
}
updatePetWithForm = (requestParameters: UpdatePetWithFormRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'updatePetWithForm');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.name !== undefined) {
@@ -281,10 +249,10 @@ export class PetApi extends BaseAPI {
}
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -292,23 +260,20 @@ export class PetApi extends BaseAPI {
/**
* uploads an image
*/
uploadFile(requestParameters: UploadFileRequest): Observable<ApiResponse> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
}
uploadFile = (requestParameters: UploadFileRequest): Observable<ApiResponse> => {
throwIfRequired(requestParameters, 'petId', 'uploadFile');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.additionalMetadata !== undefined) {
@@ -320,10 +285,10 @@ export class PetApi extends BaseAPI {
}
return this.request<ApiResponse>({
path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}/uploadImage`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -331,9 +296,9 @@ export class PetApi extends BaseAPI {
}
/**
* @export
* @enum {string}
*/
* @export
* @enum {string}
*/
export enum FindPetsByStatusStatusEnum {
Available = 'available',
Pending = 'pending',

73
samples/client/petstore/typescript-rxjs/builds/es6-target/apis/StoreApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
Order,
} from '../models';
@@ -38,20 +38,20 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
* Delete purchase order by ID
*/
deleteOrder(requestParameters: DeleteOrderRequest): Observable<void> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
}
deleteOrder = (requestParameters: DeleteOrderRequest): Observable<void> => {
throwIfRequired(requestParameters, 'orderId', 'deleteOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -59,20 +59,20 @@ export class StoreApi extends BaseAPI {
* Returns a map of status codes to quantities
* Returns pet inventories by status
*/
getInventory(): Observable<{ [key: string]: number; }> {
const queryParameters: HttpQuery = {};
getInventory = (): Observable<{ [key: string]: number; }> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<{ [key: string]: number; }>({
path: `/store/inventory`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -80,42 +80,41 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
* Find purchase order by ID
*/
getOrderById(requestParameters: GetOrderByIdRequest): Observable<Order> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
}
getOrderById = (requestParameters: GetOrderByIdRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'orderId', 'getOrderById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Place an order for a pet
*/
placeOrder(requestParameters: PlaceOrderRequest): Observable<Order> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling placeOrder.');
}
placeOrder = (requestParameters: PlaceOrderRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'body', 'placeOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

165
samples/client/petstore/typescript-rxjs/builds/es6-target/apis/UserApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
User,
} from '../models';
@@ -56,22 +56,21 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Create user
*/
createUser(requestParameters: CreateUserRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUser.');
}
createUser = (requestParameters: CreateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -79,22 +78,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithArrayInput(requestParameters: CreateUsersWithArrayInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithArrayInput.');
}
createUsersWithArrayInput = (requestParameters: CreateUsersWithArrayInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithArrayInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithArray`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -102,22 +100,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithListInput(requestParameters: CreateUsersWithListInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithListInput.');
}
createUsersWithListInput = (requestParameters: CreateUsersWithListInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithListInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithList`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -126,88 +123,82 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Delete user
*/
deleteUser(requestParameters: DeleteUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
}
deleteUser = (requestParameters: DeleteUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'deleteUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Get user by user name
*/
getUserByName(requestParameters: GetUserByNameRequest): Observable<User> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
}
getUserByName = (requestParameters: GetUserByNameRequest): Observable<User> => {
throwIfRequired(requestParameters, 'username', 'getUserByName');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<User>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs user into the system
*/
loginUser(requestParameters: LoginUserRequest): Observable<string> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
}
loginUser = (requestParameters: LoginUserRequest): Observable<string> => {
throwIfRequired(requestParameters, 'username', 'loginUser');
throwIfRequired(requestParameters, 'password', 'loginUser');
if (requestParameters.password === null || requestParameters.password === undefined) {
throw new RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
}
const headers: HttpHeaders = {
};
const queryParameters: HttpQuery = {};
if (requestParameters.username !== undefined && requestParameters.username !== null) {
queryParameters['username'] = requestParameters.username;
}
if (requestParameters.password !== undefined && requestParameters.password !== null) {
queryParameters['password'] = requestParameters.password;
}
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
...(requestParameters.username && { 'username': requestParameters.username }),
...(requestParameters.password && { 'password': requestParameters.password }),
};
return this.request<string>({
path: `/user/login`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs out current logged in user session
*/
logoutUser(): Observable<void> {
const queryParameters: HttpQuery = {};
logoutUser = (): Observable<void> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/logout`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -215,26 +206,22 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Updated user
*/
updateUser(requestParameters: UpdateUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
}
updateUser = (requestParameters: UpdateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'updateUser');
throwIfRequired(requestParameters, 'body', 'updateUser');
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updateUser.');
}
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

76
samples/client/petstore/typescript-rxjs/builds/es6-target/runtime.ts
View File

@@ -66,30 +66,26 @@ export class Configuration {
* This is the base class for all generated API classes.
*/
export class BaseAPI {
private middleware: Middleware[];
private middleware: Middleware[] = [];
constructor(protected configuration = new Configuration()) {
this.middleware = configuration.middleware;
}
withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
withMiddleware = <T extends BaseAPI>(middlewares: Middleware[]) => {
const next = this.clone<T>();
next.middleware = next.middleware.concat(...middlewares);
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);
}
withPreMiddleware = <T extends BaseAPI>(preMiddlewares: Array<Middleware['pre']>) =>
this.withMiddleware<T>(preMiddlewares.map((pre) => ({ pre })));
withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
const middlewares = postMiddlewares.map((post) => ({ post }));
return this.withMiddleware<T>(...middlewares);
}
withPostMiddleware = <T extends BaseAPI>(postMiddlewares: Array<Middleware['post']>) =>
this.withMiddleware<T>(postMiddlewares.map((post) => ({ post })));
protected request<T>(context: RequestOpts): Observable<T> {
return this.rxjsRequest(this.createRequestArgs(context)).pipe(
protected request = <T>(context: RequestOpts): Observable<T> =>
this.rxjsRequest(this.createRequestArgs(context)).pipe(
map((res) => {
if (res.status >= 200 && res.status < 300) {
return res.response as T;
@@ -97,15 +93,14 @@ export class BaseAPI {
throw res;
})
);
}
private createRequestArgs(context: RequestOpts): RequestArgs {
private createRequestArgs = (context: RequestOpts): RequestArgs => {
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.
// 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 += '?' + querystring(context.query);
url += '?' + queryString(context.query);
}
const body = context.body instanceof FormData ? context.body : JSON.stringify(context.body);
const options = {
@@ -116,9 +111,9 @@ export class BaseAPI {
return { url, options };
}
private rxjsRequest(params: RequestContext): Observable<AjaxResponse> {
const preMiddlewares = this.middleware && this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware && this.middleware.filter((item) => item.post);
private rxjsRequest = (params: RequestContext): Observable<AjaxResponse> => {
const preMiddlewares = this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware.filter((item) => item.post);
return of(params).pipe(
map((args) => {
@@ -144,19 +139,13 @@ export class BaseAPI {
* 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;
}
private clone = <T extends BaseAPI>(): T =>
Object.assign(Object.create(Object.getPrototypeOf(this)), this)
}
// export for not being a breaking change
export class RequiredError extends Error {
name: 'RequiredError' = 'RequiredError';
constructor(public field: string, msg?: string) {
super(msg);
}
}
export const COLLECTION_FORMATS = {
@@ -186,17 +175,24 @@ export interface RequestOpts {
body?: HttpBody;
}
export function querystring(params: HttpQuery): string {
return Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
const queryString = (params: HttpQuery): string => Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
// alias fallback for not being a breaking change
export const querystring = queryString;
export const throwIfRequired = (params: {[key: string]: any}, key: string, nickname: string) => {
if (!params || params[key] === null || params[key] === undefined) {
throw new RequiredError(`Required parameter ${key} was null or undefined when calling ${nickname}.`);
}
}
export interface RequestContext extends RequestArgs {}

275
samples/client/petstore/typescript-rxjs/builds/with-interfaces/apis/PetApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
ApiResponse,
Pet,
@@ -63,31 +63,27 @@ export class PetApi extends BaseAPI {
/**
* Add a new pet to the store
*/
addPet(requestParameters: AddPetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling addPet.');
}
addPet = (requestParameters: AddPetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'addPet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -95,33 +91,27 @@ export class PetApi extends BaseAPI {
/**
* Deletes a pet
*/
deletePet(requestParameters: DeletePetRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
}
deletePet = (requestParameters: DeletePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'deletePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
headerParameters['api_key'] = String(requestParameters.apiKey);
}
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
...(requestParameters.apiKey && { 'api_key': String(requestParameters.apiKey) }),
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -129,33 +119,27 @@ export class PetApi extends BaseAPI {
* Multiple status values can be provided with comma separated strings
* Finds Pets by status
*/
findPetsByStatus(requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> {
if (requestParameters.status === null || requestParameters.status === undefined) {
throw new RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
}
findPetsByStatus = (requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'status', 'findPetsByStatus');
const queryParameters: HttpQuery = {};
if (requestParameters.status) {
queryParameters['status'] = requestParameters.status.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.status && { 'status': requestParameters.status.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByStatus`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -163,33 +147,27 @@ export class PetApi extends BaseAPI {
* Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
* Finds Pets by tags
*/
findPetsByTags(requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> {
if (requestParameters.tags === null || requestParameters.tags === undefined) {
throw new RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
}
findPetsByTags = (requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'tags', 'findPetsByTags');
const queryParameters: HttpQuery = {};
if (requestParameters.tags) {
queryParameters['tags'] = requestParameters.tags.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.tags && { 'tags': requestParameters.tags.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByTags`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -197,55 +175,48 @@ export class PetApi extends BaseAPI {
* Returns a single pet
* Find pet by ID
*/
getPetById(requestParameters: GetPetByIdRequest): Observable<Pet> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
}
getPetById = (requestParameters: GetPetByIdRequest): Observable<Pet> => {
throwIfRequired(requestParameters, 'petId', 'getPetById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<Pet>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Update an existing pet
*/
updatePet(requestParameters: UpdatePetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updatePet.');
}
updatePet = (requestParameters: UpdatePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'updatePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -253,23 +224,20 @@ export class PetApi extends BaseAPI {
/**
* Updates a pet in the store with form data
*/
updatePetWithForm(requestParameters: UpdatePetWithFormRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
}
updatePetWithForm = (requestParameters: UpdatePetWithFormRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'updatePetWithForm');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.name !== undefined) {
@@ -281,10 +249,10 @@ export class PetApi extends BaseAPI {
}
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -292,23 +260,20 @@ export class PetApi extends BaseAPI {
/**
* uploads an image
*/
uploadFile(requestParameters: UploadFileRequest): Observable<ApiResponse> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
}
uploadFile = (requestParameters: UploadFileRequest): Observable<ApiResponse> => {
throwIfRequired(requestParameters, 'petId', 'uploadFile');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.additionalMetadata !== undefined) {
@@ -320,10 +285,10 @@ export class PetApi extends BaseAPI {
}
return this.request<ApiResponse>({
path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}/uploadImage`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -331,9 +296,9 @@ export class PetApi extends BaseAPI {
}
/**
* @export
* @enum {string}
*/
* @export
* @enum {string}
*/
export enum FindPetsByStatusStatusEnum {
Available = 'available',
Pending = 'pending',

73
samples/client/petstore/typescript-rxjs/builds/with-interfaces/apis/StoreApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
Order,
} from '../models';
@@ -38,20 +38,20 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
* Delete purchase order by ID
*/
deleteOrder(requestParameters: DeleteOrderRequest): Observable<void> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
}
deleteOrder = (requestParameters: DeleteOrderRequest): Observable<void> => {
throwIfRequired(requestParameters, 'orderId', 'deleteOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -59,20 +59,20 @@ export class StoreApi extends BaseAPI {
* Returns a map of status codes to quantities
* Returns pet inventories by status
*/
getInventory(): Observable<{ [key: string]: number; }> {
const queryParameters: HttpQuery = {};
getInventory = (): Observable<{ [key: string]: number; }> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<{ [key: string]: number; }>({
path: `/store/inventory`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -80,42 +80,41 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
* Find purchase order by ID
*/
getOrderById(requestParameters: GetOrderByIdRequest): Observable<Order> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
}
getOrderById = (requestParameters: GetOrderByIdRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'orderId', 'getOrderById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Place an order for a pet
*/
placeOrder(requestParameters: PlaceOrderRequest): Observable<Order> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling placeOrder.');
}
placeOrder = (requestParameters: PlaceOrderRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'body', 'placeOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

165
samples/client/petstore/typescript-rxjs/builds/with-interfaces/apis/UserApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
User,
} from '../models';
@@ -56,22 +56,21 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Create user
*/
createUser(requestParameters: CreateUserRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUser.');
}
createUser = (requestParameters: CreateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -79,22 +78,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithArrayInput(requestParameters: CreateUsersWithArrayInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithArrayInput.');
}
createUsersWithArrayInput = (requestParameters: CreateUsersWithArrayInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithArrayInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithArray`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -102,22 +100,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithListInput(requestParameters: CreateUsersWithListInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithListInput.');
}
createUsersWithListInput = (requestParameters: CreateUsersWithListInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithListInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithList`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -126,88 +123,82 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Delete user
*/
deleteUser(requestParameters: DeleteUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
}
deleteUser = (requestParameters: DeleteUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'deleteUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Get user by user name
*/
getUserByName(requestParameters: GetUserByNameRequest): Observable<User> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
}
getUserByName = (requestParameters: GetUserByNameRequest): Observable<User> => {
throwIfRequired(requestParameters, 'username', 'getUserByName');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<User>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs user into the system
*/
loginUser(requestParameters: LoginUserRequest): Observable<string> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
}
loginUser = (requestParameters: LoginUserRequest): Observable<string> => {
throwIfRequired(requestParameters, 'username', 'loginUser');
throwIfRequired(requestParameters, 'password', 'loginUser');
if (requestParameters.password === null || requestParameters.password === undefined) {
throw new RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
}
const headers: HttpHeaders = {
};
const queryParameters: HttpQuery = {};
if (requestParameters.username !== undefined && requestParameters.username !== null) {
queryParameters['username'] = requestParameters.username;
}
if (requestParameters.password !== undefined && requestParameters.password !== null) {
queryParameters['password'] = requestParameters.password;
}
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
...(requestParameters.username && { 'username': requestParameters.username }),
...(requestParameters.password && { 'password': requestParameters.password }),
};
return this.request<string>({
path: `/user/login`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs out current logged in user session
*/
logoutUser(): Observable<void> {
const queryParameters: HttpQuery = {};
logoutUser = (): Observable<void> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/logout`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -215,26 +206,22 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Updated user
*/
updateUser(requestParameters: UpdateUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
}
updateUser = (requestParameters: UpdateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'updateUser');
throwIfRequired(requestParameters, 'body', 'updateUser');
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updateUser.');
}
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

76
samples/client/petstore/typescript-rxjs/builds/with-interfaces/runtime.ts
View File

@@ -66,30 +66,26 @@ export class Configuration {
* This is the base class for all generated API classes.
*/
export class BaseAPI {
private middleware: Middleware[];
private middleware: Middleware[] = [];
constructor(protected configuration = new Configuration()) {
this.middleware = configuration.middleware;
}
withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
withMiddleware = <T extends BaseAPI>(middlewares: Middleware[]) => {
const next = this.clone<T>();
next.middleware = next.middleware.concat(...middlewares);
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);
}
withPreMiddleware = <T extends BaseAPI>(preMiddlewares: Array<Middleware['pre']>) =>
this.withMiddleware<T>(preMiddlewares.map((pre) => ({ pre })));
withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
const middlewares = postMiddlewares.map((post) => ({ post }));
return this.withMiddleware<T>(...middlewares);
}
withPostMiddleware = <T extends BaseAPI>(postMiddlewares: Array<Middleware['post']>) =>
this.withMiddleware<T>(postMiddlewares.map((post) => ({ post })));
protected request<T>(context: RequestOpts): Observable<T> {
return this.rxjsRequest(this.createRequestArgs(context)).pipe(
protected request = <T>(context: RequestOpts): Observable<T> =>
this.rxjsRequest(this.createRequestArgs(context)).pipe(
map((res) => {
if (res.status >= 200 && res.status < 300) {
return res.response as T;
@@ -97,15 +93,14 @@ export class BaseAPI {
throw res;
})
);
}
private createRequestArgs(context: RequestOpts): RequestArgs {
private createRequestArgs = (context: RequestOpts): RequestArgs => {
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.
// 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 += '?' + querystring(context.query);
url += '?' + queryString(context.query);
}
const body = context.body instanceof FormData ? context.body : JSON.stringify(context.body);
const options = {
@@ -116,9 +111,9 @@ export class BaseAPI {
return { url, options };
}
private rxjsRequest(params: RequestContext): Observable<AjaxResponse> {
const preMiddlewares = this.middleware && this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware && this.middleware.filter((item) => item.post);
private rxjsRequest = (params: RequestContext): Observable<AjaxResponse> => {
const preMiddlewares = this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware.filter((item) => item.post);
return of(params).pipe(
map((args) => {
@@ -144,19 +139,13 @@ export class BaseAPI {
* 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;
}
private clone = <T extends BaseAPI>(): T =>
Object.assign(Object.create(Object.getPrototypeOf(this)), this)
}
// export for not being a breaking change
export class RequiredError extends Error {
name: 'RequiredError' = 'RequiredError';
constructor(public field: string, msg?: string) {
super(msg);
}
}
export const COLLECTION_FORMATS = {
@@ -186,17 +175,24 @@ export interface RequestOpts {
body?: HttpBody;
}
export function querystring(params: HttpQuery): string {
return Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
const queryString = (params: HttpQuery): string => Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
// alias fallback for not being a breaking change
export const querystring = queryString;
export const throwIfRequired = (params: {[key: string]: any}, key: string, nickname: string) => {
if (!params || params[key] === null || params[key] === undefined) {
throw new RequiredError(`Required parameter ${key} was null or undefined when calling ${nickname}.`);
}
}
export interface RequestContext extends RequestArgs {}

275
samples/client/petstore/typescript-rxjs/builds/with-npm-version/apis/PetApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
ApiResponse,
Pet,
@@ -63,31 +63,27 @@ export class PetApi extends BaseAPI {
/**
* Add a new pet to the store
*/
addPet(requestParameters: AddPetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling addPet.');
}
addPet = (requestParameters: AddPetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'addPet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -95,33 +91,27 @@ export class PetApi extends BaseAPI {
/**
* Deletes a pet
*/
deletePet(requestParameters: DeletePetRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
}
deletePet = (requestParameters: DeletePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'deletePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
headerParameters['api_key'] = String(requestParameters.apiKey);
}
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
...(requestParameters.apiKey && { 'api_key': String(requestParameters.apiKey) }),
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -129,33 +119,27 @@ export class PetApi extends BaseAPI {
* Multiple status values can be provided with comma separated strings
* Finds Pets by status
*/
findPetsByStatus(requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> {
if (requestParameters.status === null || requestParameters.status === undefined) {
throw new RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
}
findPetsByStatus = (requestParameters: FindPetsByStatusRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'status', 'findPetsByStatus');
const queryParameters: HttpQuery = {};
if (requestParameters.status) {
queryParameters['status'] = requestParameters.status.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.status && { 'status': requestParameters.status.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByStatus`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -163,33 +147,27 @@ export class PetApi extends BaseAPI {
* Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
* Finds Pets by tags
*/
findPetsByTags(requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> {
if (requestParameters.tags === null || requestParameters.tags === undefined) {
throw new RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
}
findPetsByTags = (requestParameters: FindPetsByTagsRequest): Observable<Array<Pet>> => {
throwIfRequired(requestParameters, 'tags', 'findPetsByTags');
const queryParameters: HttpQuery = {};
if (requestParameters.tags) {
queryParameters['tags'] = requestParameters.tags.join(COLLECTION_FORMATS["csv"]);
}
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
...(requestParameters.tags && { 'tags': requestParameters.tags.join(COLLECTION_FORMATS['csv']) }),
};
return this.request<Array<Pet>>({
path: `/pet/findByTags`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -197,55 +175,48 @@ export class PetApi extends BaseAPI {
* Returns a single pet
* Find pet by ID
*/
getPetById(requestParameters: GetPetByIdRequest): Observable<Pet> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
}
getPetById = (requestParameters: GetPetByIdRequest): Observable<Pet> => {
throwIfRequired(requestParameters, 'petId', 'getPetById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<Pet>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Update an existing pet
*/
updatePet(requestParameters: UpdatePetRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updatePet.');
}
updatePet = (requestParameters: UpdatePetRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'updatePet');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
'Content-Type': 'application/json',
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/pet`,
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -253,23 +224,20 @@ export class PetApi extends BaseAPI {
/**
* Updates a pet in the store with form data
*/
updatePetWithForm(requestParameters: UpdatePetWithFormRequest): Observable<void> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
}
updatePetWithForm = (requestParameters: UpdatePetWithFormRequest): Observable<void> => {
throwIfRequired(requestParameters, 'petId', 'updatePetWithForm');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.name !== undefined) {
@@ -281,10 +249,10 @@ export class PetApi extends BaseAPI {
}
return this.request<void>({
path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -292,23 +260,20 @@ export class PetApi extends BaseAPI {
/**
* uploads an image
*/
uploadFile(requestParameters: UploadFileRequest): Observable<ApiResponse> {
if (requestParameters.petId === null || requestParameters.petId === undefined) {
throw new RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
}
uploadFile = (requestParameters: UploadFileRequest): Observable<ApiResponse> => {
throwIfRequired(requestParameters, 'petId', 'uploadFile');
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
if (this.configuration && this.configuration.accessToken) {
const headers: HttpHeaders = {
// oauth required
if (typeof this.configuration.accessToken === 'function') {
headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
} else {
headerParameters["Authorization"] = this.configuration.accessToken;
}
}
...(this.configuration.accessToken && {
Authorization: this.configuration.accessToken && (typeof this.configuration.accessToken === 'function'
? this.configuration.accessToken('petstore_auth', ['write:pets', 'read:pets'])
: this.configuration.accessToken)
}),
};
const query: HttpQuery = {
};
const formData = new FormData();
if (requestParameters.additionalMetadata !== undefined) {
@@ -320,10 +285,10 @@ export class PetApi extends BaseAPI {
}
return this.request<ApiResponse>({
path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
path: `/pet/{petId}/uploadImage`.replace(`{petId}`, encodeURIComponent(String(requestParameters.petId))),
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: formData,
});
}
@@ -331,9 +296,9 @@ export class PetApi extends BaseAPI {
}
/**
* @export
* @enum {string}
*/
* @export
* @enum {string}
*/
export enum FindPetsByStatusStatusEnum {
Available = 'available',
Pending = 'pending',

73
samples/client/petstore/typescript-rxjs/builds/with-npm-version/apis/StoreApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
Order,
} from '../models';
@@ -38,20 +38,20 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
* Delete purchase order by ID
*/
deleteOrder(requestParameters: DeleteOrderRequest): Observable<void> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
}
deleteOrder = (requestParameters: DeleteOrderRequest): Observable<void> => {
throwIfRequired(requestParameters, 'orderId', 'deleteOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -59,20 +59,20 @@ export class StoreApi extends BaseAPI {
* Returns a map of status codes to quantities
* Returns pet inventories by status
*/
getInventory(): Observable<{ [key: string]: number; }> {
const queryParameters: HttpQuery = {};
getInventory = (): Observable<{ [key: string]: number; }> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
...(this.configuration.apiKey && { 'api_key': this.configuration.apiKey('api_key') }), // api_key authentication
};
if (this.configuration && this.configuration.apiKey) {
headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
}
const query: HttpQuery = {
};
return this.request<{ [key: string]: number; }>({
path: `/store/inventory`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -80,42 +80,41 @@ export class StoreApi extends BaseAPI {
* For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
* Find purchase order by ID
*/
getOrderById(requestParameters: GetOrderByIdRequest): Observable<Order> {
if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
throw new RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
}
getOrderById = (requestParameters: GetOrderByIdRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'orderId', 'getOrderById');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
path: `/store/order/{orderId}`.replace(`{orderId}`, encodeURIComponent(String(requestParameters.orderId))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Place an order for a pet
*/
placeOrder(requestParameters: PlaceOrderRequest): Observable<Order> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling placeOrder.');
}
placeOrder = (requestParameters: PlaceOrderRequest): Observable<Order> => {
throwIfRequired(requestParameters, 'body', 'placeOrder');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<Order>({
path: `/store/order`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

165
samples/client/petstore/typescript-rxjs/builds/with-npm-version/apis/UserApi.ts
View File

@@ -12,7 +12,7 @@
*/
import { Observable } from 'rxjs';
import { BaseAPI, RequiredError, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import { BaseAPI, throwIfRequired, HttpHeaders, HttpQuery, COLLECTION_FORMATS } from '../runtime';
import {
User,
} from '../models';
@@ -56,22 +56,21 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Create user
*/
createUser(requestParameters: CreateUserRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUser.');
}
createUser = (requestParameters: CreateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -79,22 +78,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithArrayInput(requestParameters: CreateUsersWithArrayInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithArrayInput.');
}
createUsersWithArrayInput = (requestParameters: CreateUsersWithArrayInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithArrayInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithArray`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -102,22 +100,21 @@ export class UserApi extends BaseAPI {
/**
* Creates list of users with given input array
*/
createUsersWithListInput(requestParameters: CreateUsersWithListInputRequest): Observable<void> {
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithListInput.');
}
createUsersWithListInput = (requestParameters: CreateUsersWithListInputRequest): Observable<void> => {
throwIfRequired(requestParameters, 'body', 'createUsersWithListInput');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/createWithList`,
method: 'POST',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}
@@ -126,88 +123,82 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Delete user
*/
deleteUser(requestParameters: DeleteUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
}
deleteUser = (requestParameters: DeleteUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'deleteUser');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'DELETE',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Get user by user name
*/
getUserByName(requestParameters: GetUserByNameRequest): Observable<User> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
}
getUserByName = (requestParameters: GetUserByNameRequest): Observable<User> => {
throwIfRequired(requestParameters, 'username', 'getUserByName');
const queryParameters: HttpQuery = {};
const headers: HttpHeaders = {
};
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
};
return this.request<User>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs user into the system
*/
loginUser(requestParameters: LoginUserRequest): Observable<string> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
}
loginUser = (requestParameters: LoginUserRequest): Observable<string> => {
throwIfRequired(requestParameters, 'username', 'loginUser');
throwIfRequired(requestParameters, 'password', 'loginUser');
if (requestParameters.password === null || requestParameters.password === undefined) {
throw new RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
}
const headers: HttpHeaders = {
};
const queryParameters: HttpQuery = {};
if (requestParameters.username !== undefined && requestParameters.username !== null) {
queryParameters['username'] = requestParameters.username;
}
if (requestParameters.password !== undefined && requestParameters.password !== null) {
queryParameters['password'] = requestParameters.password;
}
const headerParameters: HttpHeaders = {};
const query: HttpQuery = {
...(requestParameters.username && { 'username': requestParameters.username }),
...(requestParameters.password && { 'password': requestParameters.password }),
};
return this.request<string>({
path: `/user/login`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
/**
* Logs out current logged in user session
*/
logoutUser(): Observable<void> {
const queryParameters: HttpQuery = {};
logoutUser = (): Observable<void> => {
const headerParameters: HttpHeaders = {};
const headers: HttpHeaders = {
};
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/logout`,
method: 'GET',
headers: headerParameters,
query: queryParameters,
headers,
query,
});
}
@@ -215,26 +206,22 @@ export class UserApi extends BaseAPI {
* This can only be done by the logged in user.
* Updated user
*/
updateUser(requestParameters: UpdateUserRequest): Observable<void> {
if (requestParameters.username === null || requestParameters.username === undefined) {
throw new RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
}
updateUser = (requestParameters: UpdateUserRequest): Observable<void> => {
throwIfRequired(requestParameters, 'username', 'updateUser');
throwIfRequired(requestParameters, 'body', 'updateUser');
if (requestParameters.body === null || requestParameters.body === undefined) {
throw new RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updateUser.');
}
const headers: HttpHeaders = {
'Content-Type': 'application/json',
};
const queryParameters: HttpQuery = {};
const headerParameters: HttpHeaders = {};
headerParameters['Content-Type'] = 'application/json';
const query: HttpQuery = {
};
return this.request<void>({
path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
path: `/user/{username}`.replace(`{username}`, encodeURIComponent(String(requestParameters.username))),
method: 'PUT',
headers: headerParameters,
query: queryParameters,
headers,
query,
body: requestParameters.body,
});
}

76
samples/client/petstore/typescript-rxjs/builds/with-npm-version/runtime.ts
View File

@@ -66,30 +66,26 @@ export class Configuration {
* This is the base class for all generated API classes.
*/
export class BaseAPI {
private middleware: Middleware[];
private middleware: Middleware[] = [];
constructor(protected configuration = new Configuration()) {
this.middleware = configuration.middleware;
}
withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
withMiddleware = <T extends BaseAPI>(middlewares: Middleware[]) => {
const next = this.clone<T>();
next.middleware = next.middleware.concat(...middlewares);
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);
}
withPreMiddleware = <T extends BaseAPI>(preMiddlewares: Array<Middleware['pre']>) =>
this.withMiddleware<T>(preMiddlewares.map((pre) => ({ pre })));
withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
const middlewares = postMiddlewares.map((post) => ({ post }));
return this.withMiddleware<T>(...middlewares);
}
withPostMiddleware = <T extends BaseAPI>(postMiddlewares: Array<Middleware['post']>) =>
this.withMiddleware<T>(postMiddlewares.map((post) => ({ post })));
protected request<T>(context: RequestOpts): Observable<T> {
return this.rxjsRequest(this.createRequestArgs(context)).pipe(
protected request = <T>(context: RequestOpts): Observable<T> =>
this.rxjsRequest(this.createRequestArgs(context)).pipe(
map((res) => {
if (res.status >= 200 && res.status < 300) {
return res.response as T;
@@ -97,15 +93,14 @@ export class BaseAPI {
throw res;
})
);
}
private createRequestArgs(context: RequestOpts): RequestArgs {
private createRequestArgs = (context: RequestOpts): RequestArgs => {
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.
// 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 += '?' + querystring(context.query);
url += '?' + queryString(context.query);
}
const body = context.body instanceof FormData ? context.body : JSON.stringify(context.body);
const options = {
@@ -116,9 +111,9 @@ export class BaseAPI {
return { url, options };
}
private rxjsRequest(params: RequestContext): Observable<AjaxResponse> {
const preMiddlewares = this.middleware && this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware && this.middleware.filter((item) => item.post);
private rxjsRequest = (params: RequestContext): Observable<AjaxResponse> => {
const preMiddlewares = this.middleware.filter((item) => item.pre);
const postMiddlewares = this.middleware.filter((item) => item.post);
return of(params).pipe(
map((args) => {
@@ -144,19 +139,13 @@ export class BaseAPI {
* 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;
}
private clone = <T extends BaseAPI>(): T =>
Object.assign(Object.create(Object.getPrototypeOf(this)), this)
}
// export for not being a breaking change
export class RequiredError extends Error {
name: 'RequiredError' = 'RequiredError';
constructor(public field: string, msg?: string) {
super(msg);
}
}
export const COLLECTION_FORMATS = {
@@ -186,17 +175,24 @@ export interface RequestOpts {
body?: HttpBody;
}
export function querystring(params: HttpQuery): string {
return Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
const queryString = (params: HttpQuery): string => Object.keys(params)
.map((key) => {
const value = params[key];
if (value instanceof Array) {
return value.map((val) => `${encodeURIComponent(key)}=${encodeURIComponent(String(val))}`)
.join('&');
}
return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
})
.join('&');
// alias fallback for not being a breaking change
export const querystring = queryString;
export const throwIfRequired = (params: {[key: string]: any}, key: string, nickname: string) => {
if (!params || params[key] === null || params[key] === undefined) {
throw new RequiredError(`Required parameter ${key} was null or undefined when calling ${nickname}.`);
}
}
export interface RequestContext extends RequestArgs {}