Alejandra
2 years ago
committed by
GitHub
GitHub
29 changed files with 1346 additions and 26 deletions
@ -0,0 +1,29 @@ |
|||
import * as fs from "fs"; |
|||
|
|||
const filePath = "./openapi.json"; |
|||
|
|||
fs.readFile(filePath, (err, data) => { |
|||
const openapiContent = JSON.parse(data); |
|||
if (err) throw err; |
|||
|
|||
const paths = openapiContent.paths; |
|||
|
|||
Object.keys(paths).forEach((pathKey) => { |
|||
const pathData = paths[pathKey]; |
|||
Object.keys(pathData).forEach((method) => { |
|||
const operation = pathData[method]; |
|||
if (operation.tags && operation.tags.length > 0) { |
|||
const tag = operation.tags[0]; |
|||
const operationId = operation.operationId; |
|||
const toRemove = `${tag}-`; |
|||
if (operationId.startsWith(toRemove)) { |
|||
const newOperationId = operationId.substring(toRemove.length); |
|||
operation.operationId = newOperationId; |
|||
} |
|||
} |
|||
}); |
|||
}); |
|||
fs.writeFile(filePath, JSON.stringify(openapiContent, null, 2), (err) => { |
|||
if (err) throw err; |
|||
}); |
|||
}); |
|||
@ -0,0 +1,25 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
import type { ApiRequestOptions } from './ApiRequestOptions'; |
|||
import type { ApiResult } from './ApiResult'; |
|||
|
|||
export class ApiError extends Error { |
|||
public readonly url: string; |
|||
public readonly status: number; |
|||
public readonly statusText: string; |
|||
public readonly body: any; |
|||
public readonly request: ApiRequestOptions; |
|||
|
|||
constructor(request: ApiRequestOptions, response: ApiResult, message: string) { |
|||
super(message); |
|||
|
|||
this.name = 'ApiError'; |
|||
this.url = response.url; |
|||
this.status = response.status; |
|||
this.statusText = response.statusText; |
|||
this.body = response.body; |
|||
this.request = request; |
|||
} |
|||
} |
|||
@ -0,0 +1,17 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
export type ApiRequestOptions = { |
|||
readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH'; |
|||
readonly url: string; |
|||
readonly path?: Record<string, any>; |
|||
readonly cookies?: Record<string, any>; |
|||
readonly headers?: Record<string, any>; |
|||
readonly query?: Record<string, any>; |
|||
readonly formData?: Record<string, any>; |
|||
readonly body?: any; |
|||
readonly mediaType?: string; |
|||
readonly responseHeader?: string; |
|||
readonly errors?: Record<number, string>; |
|||
}; |
|||
@ -0,0 +1,11 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
export type ApiResult = { |
|||
readonly url: string; |
|||
readonly ok: boolean; |
|||
readonly status: number; |
|||
readonly statusText: string; |
|||
readonly body: any; |
|||
}; |
|||
@ -0,0 +1,131 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
export class CancelError extends Error { |
|||
|
|||
constructor(message: string) { |
|||
super(message); |
|||
this.name = 'CancelError'; |
|||
} |
|||
|
|||
public get isCancelled(): boolean { |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
export interface OnCancel { |
|||
readonly isResolved: boolean; |
|||
readonly isRejected: boolean; |
|||
readonly isCancelled: boolean; |
|||
|
|||
(cancelHandler: () => void): void; |
|||
} |
|||
|
|||
export class CancelablePromise<T> implements Promise<T> { |
|||
#isResolved: boolean; |
|||
#isRejected: boolean; |
|||
#isCancelled: boolean; |
|||
readonly #cancelHandlers: (() => void)[]; |
|||
readonly #promise: Promise<T>; |
|||
#resolve?: (value: T | PromiseLike<T>) => void; |
|||
#reject?: (reason?: any) => void; |
|||
|
|||
constructor( |
|||
executor: ( |
|||
resolve: (value: T | PromiseLike<T>) => void, |
|||
reject: (reason?: any) => void, |
|||
onCancel: OnCancel |
|||
) => void |
|||
) { |
|||
this.#isResolved = false; |
|||
this.#isRejected = false; |
|||
this.#isCancelled = false; |
|||
this.#cancelHandlers = []; |
|||
this.#promise = new Promise<T>((resolve, reject) => { |
|||
this.#resolve = resolve; |
|||
this.#reject = reject; |
|||
|
|||
const onResolve = (value: T | PromiseLike<T>): void => { |
|||
if (this.#isResolved || this.#isRejected || this.#isCancelled) { |
|||
return; |
|||
} |
|||
this.#isResolved = true; |
|||
this.#resolve?.(value); |
|||
}; |
|||
|
|||
const onReject = (reason?: any): void => { |
|||
if (this.#isResolved || this.#isRejected || this.#isCancelled) { |
|||
return; |
|||
} |
|||
this.#isRejected = true; |
|||
this.#reject?.(reason); |
|||
}; |
|||
|
|||
const onCancel = (cancelHandler: () => void): void => { |
|||
if (this.#isResolved || this.#isRejected || this.#isCancelled) { |
|||
return; |
|||
} |
|||
this.#cancelHandlers.push(cancelHandler); |
|||
}; |
|||
|
|||
Object.defineProperty(onCancel, 'isResolved', { |
|||
get: (): boolean => this.#isResolved, |
|||
}); |
|||
|
|||
Object.defineProperty(onCancel, 'isRejected', { |
|||
get: (): boolean => this.#isRejected, |
|||
}); |
|||
|
|||
Object.defineProperty(onCancel, 'isCancelled', { |
|||
get: (): boolean => this.#isCancelled, |
|||
}); |
|||
|
|||
return executor(onResolve, onReject, onCancel as OnCancel); |
|||
}); |
|||
} |
|||
|
|||
get [Symbol.toStringTag]() { |
|||
return "Cancellable Promise"; |
|||
} |
|||
|
|||
public then<TResult1 = T, TResult2 = never>( |
|||
onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, |
|||
onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null |
|||
): Promise<TResult1 | TResult2> { |
|||
return this.#promise.then(onFulfilled, onRejected); |
|||
} |
|||
|
|||
public catch<TResult = never>( |
|||
onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null |
|||
): Promise<T | TResult> { |
|||
return this.#promise.catch(onRejected); |
|||
} |
|||
|
|||
public finally(onFinally?: (() => void) | null): Promise<T> { |
|||
return this.#promise.finally(onFinally); |
|||
} |
|||
|
|||
public cancel(): void { |
|||
if (this.#isResolved || this.#isRejected || this.#isCancelled) { |
|||
return; |
|||
} |
|||
this.#isCancelled = true; |
|||
if (this.#cancelHandlers.length) { |
|||
try { |
|||
for (const cancelHandler of this.#cancelHandlers) { |
|||
cancelHandler(); |
|||
} |
|||
} catch (error) { |
|||
console.warn('Cancellation threw an error', error); |
|||
return; |
|||
} |
|||
} |
|||
this.#cancelHandlers.length = 0; |
|||
this.#reject?.(new CancelError('Request aborted')); |
|||
} |
|||
|
|||
public get isCancelled(): boolean { |
|||
return this.#isCancelled; |
|||
} |
|||
} |
|||
@ -0,0 +1,32 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
import type { ApiRequestOptions } from './ApiRequestOptions'; |
|||
|
|||
type Resolver<T> = (options: ApiRequestOptions) => Promise<T>; |
|||
type Headers = Record<string, string>; |
|||
|
|||
export type OpenAPIConfig = { |
|||
BASE: string; |
|||
VERSION: string; |
|||
WITH_CREDENTIALS: boolean; |
|||
CREDENTIALS: 'include' | 'omit' | 'same-origin'; |
|||
TOKEN?: string | Resolver<string> | undefined; |
|||
USERNAME?: string | Resolver<string> | undefined; |
|||
PASSWORD?: string | Resolver<string> | undefined; |
|||
HEADERS?: Headers | Resolver<Headers> | undefined; |
|||
ENCODE_PATH?: ((path: string) => string) | undefined; |
|||
}; |
|||
|
|||
export const OpenAPI: OpenAPIConfig = { |
|||
BASE: '', |
|||
VERSION: '0.1.0', |
|||
WITH_CREDENTIALS: false, |
|||
CREDENTIALS: 'include', |
|||
TOKEN: undefined, |
|||
USERNAME: undefined, |
|||
PASSWORD: undefined, |
|||
HEADERS: undefined, |
|||
ENCODE_PATH: undefined, |
|||
}; |
|||
@ -0,0 +1,319 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
import axios from 'axios'; |
|||
import type { AxiosError, AxiosRequestConfig, AxiosResponse, AxiosInstance } from 'axios'; |
|||
import FormData from 'form-data'; |
|||
|
|||
import { ApiError } from './ApiError'; |
|||
import type { ApiRequestOptions } from './ApiRequestOptions'; |
|||
import type { ApiResult } from './ApiResult'; |
|||
import { CancelablePromise } from './CancelablePromise'; |
|||
import type { OnCancel } from './CancelablePromise'; |
|||
import type { OpenAPIConfig } from './OpenAPI'; |
|||
|
|||
export const isDefined = <T>(value: T | null | undefined): value is Exclude<T, null | undefined> => { |
|||
return value !== undefined && value !== null; |
|||
}; |
|||
|
|||
export const isString = (value: any): value is string => { |
|||
return typeof value === 'string'; |
|||
}; |
|||
|
|||
export const isStringWithValue = (value: any): value is string => { |
|||
return isString(value) && value !== ''; |
|||
}; |
|||
|
|||
export const isBlob = (value: any): value is Blob => { |
|||
return ( |
|||
typeof value === 'object' && |
|||
typeof value.type === 'string' && |
|||
typeof value.stream === 'function' && |
|||
typeof value.arrayBuffer === 'function' && |
|||
typeof value.constructor === 'function' && |
|||
typeof value.constructor.name === 'string' && |
|||
/^(Blob|File)$/.test(value.constructor.name) && |
|||
/^(Blob|File)$/.test(value[Symbol.toStringTag]) |
|||
); |
|||
}; |
|||
|
|||
export const isFormData = (value: any): value is FormData => { |
|||
return value instanceof FormData; |
|||
}; |
|||
|
|||
export const isSuccess = (status: number): boolean => { |
|||
return status >= 200 && status < 300; |
|||
}; |
|||
|
|||
export const base64 = (str: string): string => { |
|||
try { |
|||
return btoa(str); |
|||
} catch (err) { |
|||
// @ts-ignore
|
|||
return Buffer.from(str).toString('base64'); |
|||
} |
|||
}; |
|||
|
|||
export const getQueryString = (params: Record<string, any>): string => { |
|||
const qs: string[] = []; |
|||
|
|||
const append = (key: string, value: any) => { |
|||
qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`); |
|||
}; |
|||
|
|||
const process = (key: string, value: any) => { |
|||
if (isDefined(value)) { |
|||
if (Array.isArray(value)) { |
|||
value.forEach(v => { |
|||
process(key, v); |
|||
}); |
|||
} else if (typeof value === 'object') { |
|||
Object.entries(value).forEach(([k, v]) => { |
|||
process(`${key}[${k}]`, v); |
|||
}); |
|||
} else { |
|||
append(key, value); |
|||
} |
|||
} |
|||
}; |
|||
|
|||
Object.entries(params).forEach(([key, value]) => { |
|||
process(key, value); |
|||
}); |
|||
|
|||
if (qs.length > 0) { |
|||
return `?${qs.join('&')}`; |
|||
} |
|||
|
|||
return ''; |
|||
}; |
|||
|
|||
const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => { |
|||
const encoder = config.ENCODE_PATH || encodeURI; |
|||
|
|||
const path = options.url |
|||
.replace('{api-version}', config.VERSION) |
|||
.replace(/{(.*?)}/g, (substring: string, group: string) => { |
|||
if (options.path?.hasOwnProperty(group)) { |
|||
return encoder(String(options.path[group])); |
|||
} |
|||
return substring; |
|||
}); |
|||
|
|||
const url = `${config.BASE}${path}`; |
|||
if (options.query) { |
|||
return `${url}${getQueryString(options.query)}`; |
|||
} |
|||
return url; |
|||
}; |
|||
|
|||
export const getFormData = (options: ApiRequestOptions): FormData | undefined => { |
|||
if (options.formData) { |
|||
const formData = new FormData(); |
|||
|
|||
const process = (key: string, value: any) => { |
|||
if (isString(value) || isBlob(value)) { |
|||
formData.append(key, value); |
|||
} else { |
|||
formData.append(key, JSON.stringify(value)); |
|||
} |
|||
}; |
|||
|
|||
Object.entries(options.formData) |
|||
.filter(([_, value]) => isDefined(value)) |
|||
.forEach(([key, value]) => { |
|||
if (Array.isArray(value)) { |
|||
value.forEach(v => process(key, v)); |
|||
} else { |
|||
process(key, value); |
|||
} |
|||
}); |
|||
|
|||
return formData; |
|||
} |
|||
return undefined; |
|||
}; |
|||
|
|||
type Resolver<T> = (options: ApiRequestOptions) => Promise<T>; |
|||
|
|||
export const resolve = async <T>(options: ApiRequestOptions, resolver?: T | Resolver<T>): Promise<T | undefined> => { |
|||
if (typeof resolver === 'function') { |
|||
return (resolver as Resolver<T>)(options); |
|||
} |
|||
return resolver; |
|||
}; |
|||
|
|||
export const getHeaders = async (config: OpenAPIConfig, options: ApiRequestOptions, formData?: FormData): Promise<Record<string, string>> => { |
|||
const token = await resolve(options, config.TOKEN); |
|||
const username = await resolve(options, config.USERNAME); |
|||
const password = await resolve(options, config.PASSWORD); |
|||
const additionalHeaders = await resolve(options, config.HEADERS); |
|||
const formHeaders = typeof formData?.getHeaders === 'function' && formData?.getHeaders() || {} |
|||
|
|||
const headers = Object.entries({ |
|||
Accept: 'application/json', |
|||
...additionalHeaders, |
|||
...options.headers, |
|||
...formHeaders, |
|||
}) |
|||
.filter(([_, value]) => isDefined(value)) |
|||
.reduce((headers, [key, value]) => ({ |
|||
...headers, |
|||
[key]: String(value), |
|||
}), {} as Record<string, string>); |
|||
|
|||
if (isStringWithValue(token)) { |
|||
headers['Authorization'] = `Bearer ${token}`; |
|||
} |
|||
|
|||
if (isStringWithValue(username) && isStringWithValue(password)) { |
|||
const credentials = base64(`${username}:${password}`); |
|||
headers['Authorization'] = `Basic ${credentials}`; |
|||
} |
|||
|
|||
if (options.body) { |
|||
if (options.mediaType) { |
|||
headers['Content-Type'] = options.mediaType; |
|||
} else if (isBlob(options.body)) { |
|||
headers['Content-Type'] = options.body.type || 'application/octet-stream'; |
|||
} else if (isString(options.body)) { |
|||
headers['Content-Type'] = 'text/plain'; |
|||
} else if (!isFormData(options.body)) { |
|||
headers['Content-Type'] = 'application/json'; |
|||
} |
|||
} |
|||
|
|||
return headers; |
|||
}; |
|||
|
|||
export const getRequestBody = (options: ApiRequestOptions): any => { |
|||
if (options.body) { |
|||
return options.body; |
|||
} |
|||
return undefined; |
|||
}; |
|||
|
|||
export const sendRequest = async <T>( |
|||
config: OpenAPIConfig, |
|||
options: ApiRequestOptions, |
|||
url: string, |
|||
body: any, |
|||
formData: FormData | undefined, |
|||
headers: Record<string, string>, |
|||
onCancel: OnCancel, |
|||
axiosClient: AxiosInstance |
|||
): Promise<AxiosResponse<T>> => { |
|||
const source = axios.CancelToken.source(); |
|||
|
|||
const requestConfig: AxiosRequestConfig = { |
|||
url, |
|||
headers, |
|||
data: body ?? formData, |
|||
method: options.method, |
|||
withCredentials: config.WITH_CREDENTIALS, |
|||
cancelToken: source.token, |
|||
}; |
|||
|
|||
onCancel(() => source.cancel('The user aborted a request.')); |
|||
|
|||
try { |
|||
return await axiosClient.request(requestConfig); |
|||
} catch (error) { |
|||
const axiosError = error as AxiosError<T>; |
|||
if (axiosError.response) { |
|||
return axiosError.response; |
|||
} |
|||
throw error; |
|||
} |
|||
}; |
|||
|
|||
export const getResponseHeader = (response: AxiosResponse<any>, responseHeader?: string): string | undefined => { |
|||
if (responseHeader) { |
|||
const content = response.headers[responseHeader]; |
|||
if (isString(content)) { |
|||
return content; |
|||
} |
|||
} |
|||
return undefined; |
|||
}; |
|||
|
|||
export const getResponseBody = (response: AxiosResponse<any>): any => { |
|||
if (response.status !== 204) { |
|||
return response.data; |
|||
} |
|||
return undefined; |
|||
}; |
|||
|
|||
export const catchErrorCodes = (options: ApiRequestOptions, result: ApiResult): void => { |
|||
const errors: Record<number, string> = { |
|||
400: 'Bad Request', |
|||
401: 'Unauthorized', |
|||
403: 'Forbidden', |
|||
404: 'Not Found', |
|||
500: 'Internal Server Error', |
|||
502: 'Bad Gateway', |
|||
503: 'Service Unavailable', |
|||
...options.errors, |
|||
} |
|||
|
|||
const error = errors[result.status]; |
|||
if (error) { |
|||
throw new ApiError(options, result, error); |
|||
} |
|||
|
|||
if (!result.ok) { |
|||
const errorStatus = result.status ?? 'unknown'; |
|||
const errorStatusText = result.statusText ?? 'unknown'; |
|||
const errorBody = (() => { |
|||
try { |
|||
return JSON.stringify(result.body, null, 2); |
|||
} catch (e) { |
|||
return undefined; |
|||
} |
|||
})(); |
|||
|
|||
throw new ApiError(options, result, |
|||
`Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}` |
|||
); |
|||
} |
|||
}; |
|||
|
|||
/** |
|||
* Request method |
|||
* @param config The OpenAPI configuration object |
|||
* @param options The request options from the service |
|||
* @param axiosClient The axios client instance to use |
|||
* @returns CancelablePromise<T> |
|||
* @throws ApiError |
|||
*/ |
|||
export const request = <T>(config: OpenAPIConfig, options: ApiRequestOptions, axiosClient: AxiosInstance = axios): CancelablePromise<T> => { |
|||
return new CancelablePromise(async (resolve, reject, onCancel) => { |
|||
try { |
|||
const url = getUrl(config, options); |
|||
const formData = getFormData(options); |
|||
const body = getRequestBody(options); |
|||
const headers = await getHeaders(config, options, formData); |
|||
|
|||
if (!onCancel.isCancelled) { |
|||
const response = await sendRequest<T>(config, options, url, body, formData, headers, onCancel, axiosClient); |
|||
const responseBody = getResponseBody(response); |
|||
const responseHeader = getResponseHeader(response, options.responseHeader); |
|||
|
|||
const result: ApiResult = { |
|||
url, |
|||
ok: isSuccess(response.status), |
|||
status: response.status, |
|||
statusText: response.statusText, |
|||
body: responseHeader ?? responseBody, |
|||
}; |
|||
|
|||
catchErrorCodes(options, result); |
|||
|
|||
resolve(result.body); |
|||
} |
|||
} catch (error) { |
|||
reject(error); |
|||
} |
|||
}); |
|||
}; |
|||
@ -0,0 +1,27 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
export { ApiError } from './core/ApiError'; |
|||
export { CancelablePromise, CancelError } from './core/CancelablePromise'; |
|||
export { OpenAPI } from './core/OpenAPI'; |
|||
export type { OpenAPIConfig } from './core/OpenAPI'; |
|||
|
|||
export type { Body_login_login_access_token } from './models/Body_login_login_access_token'; |
|||
export type { Body_login_reset_password } from './models/Body_login_reset_password'; |
|||
export type { HTTPValidationError } from './models/HTTPValidationError'; |
|||
export type { ItemCreate } from './models/ItemCreate'; |
|||
export type { ItemOut } from './models/ItemOut'; |
|||
export type { ItemUpdate } from './models/ItemUpdate'; |
|||
export type { Msg } from './models/Msg'; |
|||
export type { Token } from './models/Token'; |
|||
export type { User } from './models/User'; |
|||
export type { UserCreate } from './models/UserCreate'; |
|||
export type { UserCreateOpen } from './models/UserCreateOpen'; |
|||
export type { UserOut } from './models/UserOut'; |
|||
export type { ValidationError } from './models/ValidationError'; |
|||
|
|||
export { ItemsService } from './services/ItemsService'; |
|||
export { LoginService } from './services/LoginService'; |
|||
export { UsersService } from './services/UsersService'; |
|||
export { UtilsService } from './services/UtilsService'; |
|||
@ -0,0 +1,13 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type Body_login_login_access_token = { |
|||
grant_type?: string; |
|||
username: string; |
|||
password: string; |
|||
scope?: string; |
|||
client_id?: string; |
|||
client_secret?: string; |
|||
}; |
|||
@ -0,0 +1,9 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type Body_login_reset_password = { |
|||
token: string; |
|||
new_password: string; |
|||
}; |
|||
@ -0,0 +1,10 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
import type { ValidationError } from './ValidationError'; |
|||
|
|||
export type HTTPValidationError = { |
|||
detail?: Array<ValidationError>; |
|||
}; |
|||
@ -0,0 +1,9 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type ItemCreate = { |
|||
title: string; |
|||
description?: string; |
|||
}; |
|||
@ -0,0 +1,10 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type ItemOut = { |
|||
title: string; |
|||
description?: string; |
|||
id: number; |
|||
}; |
|||
@ -0,0 +1,9 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type ItemUpdate = { |
|||
title?: string; |
|||
description?: string; |
|||
}; |
|||
@ -0,0 +1,8 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type Msg = { |
|||
msg: string; |
|||
}; |
|||
@ -0,0 +1,9 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type Token = { |
|||
access_token: string; |
|||
token_type: string; |
|||
}; |
|||
@ -0,0 +1,12 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type User = { |
|||
email?: string; |
|||
is_active?: boolean; |
|||
is_superuser?: boolean; |
|||
full_name?: string; |
|||
id?: number; |
|||
}; |
|||
@ -0,0 +1,12 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type UserCreate = { |
|||
email: string; |
|||
is_active?: boolean; |
|||
is_superuser?: boolean; |
|||
full_name?: string; |
|||
password: string; |
|||
}; |
|||
@ -0,0 +1,10 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type UserCreateOpen = { |
|||
email: string; |
|||
password: string; |
|||
full_name?: string; |
|||
}; |
|||
@ -0,0 +1,12 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type UserOut = { |
|||
email: string; |
|||
is_active?: boolean; |
|||
is_superuser?: boolean; |
|||
full_name?: string; |
|||
id: number; |
|||
}; |
|||
@ -0,0 +1,10 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
|
|||
export type ValidationError = { |
|||
loc: Array<(string | number)>; |
|||
msg: string; |
|||
type: string; |
|||
}; |
|||
@ -0,0 +1,136 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
import type { ItemCreate } from '../models/ItemCreate'; |
|||
import type { ItemOut } from '../models/ItemOut'; |
|||
import type { ItemUpdate } from '../models/ItemUpdate'; |
|||
|
|||
import type { CancelablePromise } from '../core/CancelablePromise'; |
|||
import { OpenAPI } from '../core/OpenAPI'; |
|||
import { request as __request } from '../core/request'; |
|||
|
|||
export class ItemsService { |
|||
|
|||
/** |
|||
* Read Items |
|||
* Retrieve items. |
|||
* @returns ItemOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static readItems({ |
|||
skip, |
|||
limit = 100, |
|||
}: { |
|||
skip?: number, |
|||
limit?: number, |
|||
}): CancelablePromise<Array<ItemOut>> { |
|||
return __request(OpenAPI, { |
|||
method: 'GET', |
|||
url: '/api/v1/items/', |
|||
query: { |
|||
'skip': skip, |
|||
'limit': limit, |
|||
}, |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Create Item |
|||
* Create new item. |
|||
* @returns ItemOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static createItem({ |
|||
requestBody, |
|||
}: { |
|||
requestBody: ItemCreate, |
|||
}): CancelablePromise<ItemOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/items/', |
|||
body: requestBody, |
|||
mediaType: 'application/json', |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Read Item |
|||
* Get item by ID. |
|||
* @returns ItemOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static readItem({ |
|||
id, |
|||
}: { |
|||
id: number, |
|||
}): CancelablePromise<ItemOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'GET', |
|||
url: '/api/v1/items/{id}', |
|||
path: { |
|||
'id': id, |
|||
}, |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Update Item |
|||
* Update an item. |
|||
* @returns ItemOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static updateItem({ |
|||
id, |
|||
requestBody, |
|||
}: { |
|||
id: number, |
|||
requestBody: ItemUpdate, |
|||
}): CancelablePromise<ItemOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'PUT', |
|||
url: '/api/v1/items/{id}', |
|||
path: { |
|||
'id': id, |
|||
}, |
|||
body: requestBody, |
|||
mediaType: 'application/json', |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Delete Item |
|||
* Delete an item. |
|||
* @returns ItemOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static deleteItem({ |
|||
id, |
|||
}: { |
|||
id: number, |
|||
}): CancelablePromise<ItemOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'DELETE', |
|||
url: '/api/v1/items/{id}', |
|||
path: { |
|||
'id': id, |
|||
}, |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,97 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
import type { Body_login_login_access_token } from '../models/Body_login_login_access_token'; |
|||
import type { Body_login_reset_password } from '../models/Body_login_reset_password'; |
|||
import type { Msg } from '../models/Msg'; |
|||
import type { Token } from '../models/Token'; |
|||
import type { User } from '../models/User'; |
|||
|
|||
import type { CancelablePromise } from '../core/CancelablePromise'; |
|||
import { OpenAPI } from '../core/OpenAPI'; |
|||
import { request as __request } from '../core/request'; |
|||
|
|||
export class LoginService { |
|||
|
|||
/** |
|||
* Login Access Token |
|||
* OAuth2 compatible token login, get an access token for future requests |
|||
* @returns Token Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static loginAccessToken({ |
|||
formData, |
|||
}: { |
|||
formData: Body_login_login_access_token, |
|||
}): CancelablePromise<Token> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/login/access-token', |
|||
formData: formData, |
|||
mediaType: 'application/x-www-form-urlencoded', |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Test Token |
|||
* Test access token |
|||
* @returns User Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static testToken(): CancelablePromise<User> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/login/test-token', |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Recover Password |
|||
* Password Recovery |
|||
* @returns Msg Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static recoverPassword({ |
|||
email, |
|||
}: { |
|||
email: string, |
|||
}): CancelablePromise<Msg> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/password-recovery/{email}', |
|||
path: { |
|||
'email': email, |
|||
}, |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Reset Password |
|||
* Reset password |
|||
* @returns Msg Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static resetPassword({ |
|||
requestBody, |
|||
}: { |
|||
requestBody: Body_login_reset_password, |
|||
}): CancelablePromise<Msg> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/reset-password/', |
|||
body: requestBody, |
|||
mediaType: 'application/json', |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,121 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
import type { UserCreate } from '../models/UserCreate'; |
|||
import type { UserCreateOpen } from '../models/UserCreateOpen'; |
|||
import type { UserOut } from '../models/UserOut'; |
|||
|
|||
import type { CancelablePromise } from '../core/CancelablePromise'; |
|||
import { OpenAPI } from '../core/OpenAPI'; |
|||
import { request as __request } from '../core/request'; |
|||
|
|||
export class UsersService { |
|||
|
|||
/** |
|||
* Read Users |
|||
* Retrieve users. |
|||
* @returns UserOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static readUsers({ |
|||
skip, |
|||
limit = 100, |
|||
}: { |
|||
skip?: number, |
|||
limit?: number, |
|||
}): CancelablePromise<Array<UserOut>> { |
|||
return __request(OpenAPI, { |
|||
method: 'GET', |
|||
url: '/api/v1/users/', |
|||
query: { |
|||
'skip': skip, |
|||
'limit': limit, |
|||
}, |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Create User |
|||
* Create new user. |
|||
* @returns UserOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static createUser({ |
|||
requestBody, |
|||
}: { |
|||
requestBody: UserCreate, |
|||
}): CancelablePromise<UserOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/users/', |
|||
body: requestBody, |
|||
mediaType: 'application/json', |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Read User Me |
|||
* Get current user. |
|||
* @returns UserOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static readUserMe(): CancelablePromise<UserOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'GET', |
|||
url: '/api/v1/users/me', |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Create User Open |
|||
* Create new user without the need to be logged in. |
|||
* @returns UserOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static createUserOpen({ |
|||
requestBody, |
|||
}: { |
|||
requestBody: UserCreateOpen, |
|||
}): CancelablePromise<UserOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/users/open', |
|||
body: requestBody, |
|||
mediaType: 'application/json', |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Read User By Id |
|||
* Get a specific user by id. |
|||
* @returns UserOut Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static readUserById({ |
|||
userId, |
|||
}: { |
|||
userId: number, |
|||
}): CancelablePromise<UserOut> { |
|||
return __request(OpenAPI, { |
|||
method: 'GET', |
|||
url: '/api/v1/users/{user_id}', |
|||
path: { |
|||
'user_id': userId, |
|||
}, |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,58 @@ |
|||
/* generated using openapi-typescript-codegen -- do no edit */ |
|||
/* istanbul ignore file */ |
|||
/* tslint:disable */ |
|||
/* eslint-disable */ |
|||
import type { Msg } from '../models/Msg'; |
|||
|
|||
import type { CancelablePromise } from '../core/CancelablePromise'; |
|||
import { OpenAPI } from '../core/OpenAPI'; |
|||
import { request as __request } from '../core/request'; |
|||
|
|||
export class UtilsService { |
|||
|
|||
/** |
|||
* Test Celery |
|||
* Test Celery worker. |
|||
* @returns Msg Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static testCelery({ |
|||
requestBody, |
|||
}: { |
|||
requestBody: Msg, |
|||
}): CancelablePromise<Msg> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/utils/test-celery/', |
|||
body: requestBody, |
|||
mediaType: 'application/json', |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Test Email |
|||
* Test emails. |
|||
* @returns Msg Successful Response |
|||
* @throws ApiError |
|||
*/ |
|||
public static testEmail({ |
|||
emailTo, |
|||
}: { |
|||
emailTo: string, |
|||
}): CancelablePromise<Msg> { |
|||
return __request(OpenAPI, { |
|||
method: 'POST', |
|||
url: '/api/v1/utils/test-email/', |
|||
query: { |
|||
'email_to': emailTo, |
|||
}, |
|||
errors: { |
|||
422: `Validation Error`, |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
} |
|||
Loading…
Reference in new issue