473 lines
14 KiB
TypeScript
473 lines
14 KiB
TypeScript
/** @file
|
|
* @author Edouard DUPIN
|
|
* @copyright 2024, Edouard DUPIN, all right reserved
|
|
* @license MPL-2
|
|
*/
|
|
import { RestErrorResponse, isRestErrorResponse } from './model';
|
|
|
|
export enum HTTPRequestModel {
|
|
ARCHIVE = 'ARCHIVE',
|
|
DELETE = 'DELETE',
|
|
HEAD = 'HEAD',
|
|
GET = 'GET',
|
|
OPTION = 'OPTION',
|
|
PATCH = 'PATCH',
|
|
POST = 'POST',
|
|
PUT = 'PUT',
|
|
RESTORE = 'RESTORE',
|
|
}
|
|
export enum HTTPMimeType {
|
|
ALL = '*/*',
|
|
CSV = 'text/csv',
|
|
IMAGE = 'image/*',
|
|
IMAGE_JPEG = 'image/jpeg',
|
|
IMAGE_PNG = 'image/png',
|
|
JSON = 'application/json',
|
|
MULTIPART = 'multipart/form-data',
|
|
OCTET_STREAM = 'application/octet-stream',
|
|
TEXT_PLAIN = 'text/plain',
|
|
}
|
|
|
|
export interface RESTConfig {
|
|
// base of the server: http(s)://my.server.org/plop/api/
|
|
server: string;
|
|
// Token to access of the data.
|
|
token?: string;
|
|
}
|
|
|
|
export interface RESTModel {
|
|
// base of the local API request: "sheep/{id}".
|
|
endPoint: string;
|
|
// Type of the request.
|
|
requestType?: HTTPRequestModel;
|
|
// Input type requested.
|
|
accept?: HTTPMimeType;
|
|
// Content of the local data.
|
|
contentType?: HTTPMimeType;
|
|
// Mode of the TOKEN in URL or Header (?token:${tokenInUrl})
|
|
tokenInUrl?: boolean;
|
|
}
|
|
|
|
export interface ModelResponseHttp {
|
|
status: number;
|
|
data: any;
|
|
}
|
|
|
|
export type ErrorRestApiCallback = (response: Response) => void;
|
|
|
|
let errorApiGlobalCallback: ErrorRestApiCallback | undefined = undefined;
|
|
|
|
export const setErrorApiGlobalCallback = (callback: ErrorRestApiCallback) => {
|
|
errorApiGlobalCallback = callback;
|
|
};
|
|
|
|
function isNullOrUndefined(data: any): data is undefined | null {
|
|
return data === undefined || data === null;
|
|
}
|
|
|
|
// generic progression callback
|
|
export type ProgressCallback = (count: number, total: number) => void;
|
|
|
|
export interface RESTAbort {
|
|
abort?: () => boolean;
|
|
}
|
|
|
|
// Rest generic callback have a basic model to upload and download advancement.
|
|
export interface RESTCallbacks {
|
|
progressUpload?: ProgressCallback;
|
|
progressDownload?: ProgressCallback;
|
|
abortHandle?: RESTAbort;
|
|
}
|
|
|
|
export interface RESTRequestType {
|
|
restModel: RESTModel;
|
|
restConfig: RESTConfig;
|
|
data?: any;
|
|
params?: object;
|
|
queries?: object;
|
|
headers?: any;
|
|
callbacks?: RESTCallbacks;
|
|
}
|
|
|
|
function replaceAll(input, searchValue, replaceValue) {
|
|
return input.split(searchValue).join(replaceValue);
|
|
}
|
|
|
|
function removeTrailingSlashes(input: string): string {
|
|
if (isNullOrUndefined(input)) {
|
|
return 'undefined';
|
|
}
|
|
return input.replace(/\/+$/, '');
|
|
}
|
|
function removeLeadingSlashes(input: string): string {
|
|
if (isNullOrUndefined(input)) {
|
|
return '';
|
|
}
|
|
return input.replace(/^\/+/, '');
|
|
}
|
|
|
|
export function RESTUrl({
|
|
restModel,
|
|
restConfig,
|
|
params,
|
|
queries,
|
|
}: RESTRequestType): string {
|
|
// Create the URL PATH:
|
|
let generateUrl = `${removeTrailingSlashes(
|
|
restConfig.server
|
|
)}/${removeLeadingSlashes(restModel.endPoint)}`;
|
|
if (params !== undefined) {
|
|
for (let key of Object.keys(params)) {
|
|
generateUrl = replaceAll(generateUrl, `{${key}}`, `${params[key]}`);
|
|
}
|
|
}
|
|
if (
|
|
queries === undefined &&
|
|
(restConfig.token === undefined || restModel.tokenInUrl !== true)
|
|
) {
|
|
return generateUrl;
|
|
}
|
|
const searchParams = new URLSearchParams();
|
|
if (queries !== undefined) {
|
|
for (let key of Object.keys(queries)) {
|
|
const value = queries[key];
|
|
if (Array.isArray(value)) {
|
|
for (const element of value) {
|
|
searchParams.append(`${key}`, `${element}`);
|
|
}
|
|
} else {
|
|
searchParams.append(`${key}`, `${value}`);
|
|
}
|
|
}
|
|
}
|
|
if (restConfig.token !== undefined && restModel.tokenInUrl === true) {
|
|
searchParams.append('Authorization', `Bearer ${restConfig.token}`);
|
|
}
|
|
return generateUrl + '?' + searchParams.toString();
|
|
}
|
|
|
|
export function fetchProgress(
|
|
generateUrl: string,
|
|
{
|
|
method,
|
|
headers,
|
|
body,
|
|
}: {
|
|
method: HTTPRequestModel;
|
|
headers: any;
|
|
body: any;
|
|
},
|
|
{ progressUpload, progressDownload, abortHandle }: RESTCallbacks
|
|
): Promise<Response> {
|
|
const xhr: {
|
|
io?: XMLHttpRequest;
|
|
} = {
|
|
io: new XMLHttpRequest(),
|
|
};
|
|
return new Promise((resolve, reject) => {
|
|
// Stream the upload progress
|
|
if (progressUpload) {
|
|
xhr.io?.upload.addEventListener('progress', (dataEvent) => {
|
|
if (dataEvent.lengthComputable) {
|
|
progressUpload(dataEvent.loaded, dataEvent.total);
|
|
}
|
|
});
|
|
}
|
|
// Stream the download progress
|
|
if (progressDownload) {
|
|
xhr.io?.addEventListener('progress', (dataEvent) => {
|
|
if (dataEvent.lengthComputable) {
|
|
progressDownload(dataEvent.loaded, dataEvent.total);
|
|
}
|
|
});
|
|
}
|
|
if (abortHandle) {
|
|
abortHandle.abort = () => {
|
|
if (xhr.io) {
|
|
console.log(`Request abort on the XMLHttpRequest: ${generateUrl}`);
|
|
xhr.io.abort();
|
|
return true;
|
|
}
|
|
console.log(
|
|
`Request abort (FAIL) on the XMLHttpRequest: ${generateUrl}`
|
|
);
|
|
return false;
|
|
};
|
|
}
|
|
// Check if we have an internal Fail:
|
|
xhr.io?.addEventListener('error', () => {
|
|
xhr.io = undefined;
|
|
reject(new TypeError('Failed to fetch'));
|
|
});
|
|
|
|
// Capture the end of the stream
|
|
xhr.io?.addEventListener('loadend', () => {
|
|
if (xhr.io?.readyState !== XMLHttpRequest.DONE) {
|
|
return;
|
|
}
|
|
if (xhr.io?.status === 0) {
|
|
//the stream has been aborted
|
|
reject(new TypeError('Fetch has been aborted'));
|
|
return;
|
|
}
|
|
// Stream is ended, transform in a generic response:
|
|
const response = new Response(xhr.io.response, {
|
|
status: xhr.io.status,
|
|
statusText: xhr.io.statusText,
|
|
});
|
|
const headersArray = replaceAll(
|
|
xhr.io.getAllResponseHeaders().trim(),
|
|
'\r\n',
|
|
'\n'
|
|
).split('\n');
|
|
headersArray.forEach(function (header) {
|
|
const firstColonIndex = header.indexOf(':');
|
|
if (firstColonIndex !== -1) {
|
|
const key = header.substring(0, firstColonIndex).trim();
|
|
const value = header.substring(firstColonIndex + 1).trim();
|
|
response.headers.set(key, value);
|
|
} else {
|
|
response.headers.set(header, '');
|
|
}
|
|
});
|
|
xhr.io = undefined;
|
|
resolve(response);
|
|
});
|
|
xhr.io?.open(method, generateUrl, true);
|
|
if (!isNullOrUndefined(headers)) {
|
|
for (const [key, value] of Object.entries(headers)) {
|
|
xhr.io?.setRequestHeader(key, value as string);
|
|
}
|
|
}
|
|
xhr.io?.send(body);
|
|
});
|
|
}
|
|
|
|
export function RESTRequest({
|
|
restModel,
|
|
restConfig,
|
|
data,
|
|
params,
|
|
queries,
|
|
headers = {},
|
|
callbacks,
|
|
}: RESTRequestType): Promise<ModelResponseHttp> {
|
|
// Create the URL PATH:
|
|
let generateUrl = RESTUrl({ restModel, restConfig, data, params, queries });
|
|
if (restConfig.token !== undefined && restModel.tokenInUrl !== true) {
|
|
headers['Authorization'] = `Bearer ${restConfig.token}`;
|
|
}
|
|
if (restModel.accept !== undefined) {
|
|
headers['Accept'] = restModel.accept;
|
|
}
|
|
if (
|
|
restModel.requestType !== HTTPRequestModel.GET &&
|
|
restModel.requestType !== HTTPRequestModel.ARCHIVE &&
|
|
restModel.requestType !== HTTPRequestModel.RESTORE
|
|
) {
|
|
// if Get we have not a content type, the body is empty
|
|
if (
|
|
restModel.contentType !== HTTPMimeType.MULTIPART &&
|
|
restModel.contentType !== undefined
|
|
) {
|
|
// special case of multi-part ==> no content type otherwise the browser does not set the ";bundary=--****"
|
|
headers['Content-Type'] = restModel.contentType;
|
|
}
|
|
}
|
|
let body = data;
|
|
if (restModel.contentType === HTTPMimeType.JSON) {
|
|
body = JSON.stringify(data);
|
|
} else if (restModel.contentType === HTTPMimeType.MULTIPART) {
|
|
const formData = new FormData();
|
|
for (const name in data) {
|
|
formData.append(name, data[name]);
|
|
}
|
|
body = formData;
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
let action: undefined | Promise<Response> = undefined;
|
|
if (
|
|
isNullOrUndefined(callbacks) ||
|
|
(isNullOrUndefined(callbacks.progressDownload) &&
|
|
isNullOrUndefined(callbacks.progressUpload) &&
|
|
isNullOrUndefined(callbacks.abortHandle))
|
|
) {
|
|
// No information needed: call the generic fetch interface
|
|
action = fetch(generateUrl, {
|
|
method: restModel.requestType,
|
|
headers,
|
|
body,
|
|
});
|
|
} else {
|
|
// need progression information: call old fetch model (XMLHttpRequest) that permit to keep % upload and % download for HTTP1.x
|
|
action = fetchProgress(
|
|
generateUrl,
|
|
{
|
|
method: restModel.requestType ?? HTTPRequestModel.GET,
|
|
headers,
|
|
body,
|
|
},
|
|
callbacks
|
|
);
|
|
}
|
|
action
|
|
.then((response: Response) => {
|
|
if (
|
|
errorApiGlobalCallback &&
|
|
400 <= response.status &&
|
|
response.status <= 499
|
|
) {
|
|
// Detect an error and trigger the generic error callback:
|
|
errorApiGlobalCallback(response);
|
|
}
|
|
if (response.status >= 200 && response.status <= 299) {
|
|
const contentType = response.headers.get('Content-Type');
|
|
if (
|
|
!isNullOrUndefined(restModel.accept) &&
|
|
restModel.accept !== contentType
|
|
) {
|
|
reject({
|
|
name: 'Model accept type incompatible',
|
|
time: Date().toString(),
|
|
status: 901,
|
|
message: `REST Content type are not compatible: ${restModel.accept} != ${contentType}`,
|
|
statusMessage: 'Fetch error',
|
|
error: 'rest-tools.ts Wrong type in the message return type',
|
|
} as RestErrorResponse);
|
|
} else if (contentType === HTTPMimeType.JSON) {
|
|
response
|
|
.json()
|
|
.then((value: any) => {
|
|
resolve({ status: response.status, data: value });
|
|
})
|
|
.catch((reason: Error) => {
|
|
reject({
|
|
name: 'API serialization error',
|
|
time: Date().toString(),
|
|
status: 902,
|
|
message: `REST parse json fail: ${reason}`,
|
|
statusMessage: 'Fetch parse error',
|
|
error: 'rest-tools.ts Wrong message model to parse',
|
|
} as RestErrorResponse);
|
|
});
|
|
} else {
|
|
resolve({ status: response.status, data: response.body });
|
|
}
|
|
} else {
|
|
// the answer is not correct not a 2XX
|
|
// clone the response to keep the raw data if case of error:
|
|
response
|
|
.clone()
|
|
.json()
|
|
.then((value: any) => {
|
|
if (isRestErrorResponse(value)) {
|
|
reject(value);
|
|
} else {
|
|
response
|
|
.text()
|
|
.then((dataError: string) => {
|
|
reject({
|
|
name: 'API serialization error',
|
|
time: Date().toString(),
|
|
status: 903,
|
|
message: `REST parse error json with wrong type fail. ${dataError}`,
|
|
statusMessage: 'Fetch parse error',
|
|
error: 'rest-tools.ts Wrong message model to parse',
|
|
} as RestErrorResponse);
|
|
})
|
|
.catch((reason: any) => {
|
|
reject({
|
|
name: 'API serialization error',
|
|
time: Date().toString(),
|
|
status: response.status,
|
|
message: `unmanaged error model: ??? with error: ${reason}`,
|
|
statusMessage: 'Fetch ERROR parse error',
|
|
error: 'rest-tools.ts Wrong message model to parse',
|
|
} as RestErrorResponse);
|
|
});
|
|
}
|
|
})
|
|
.catch((reason: Error) => {
|
|
response
|
|
.text()
|
|
.then((dataError: string) => {
|
|
reject({
|
|
name: 'API serialization error',
|
|
time: Date().toString(),
|
|
status: response.status,
|
|
message: `unmanaged error model: ${dataError} with error: ${reason}`,
|
|
statusMessage: 'Fetch ERROR TEXT parse error',
|
|
error: 'rest-tools.ts Wrong message model to parse',
|
|
} as RestErrorResponse);
|
|
})
|
|
.catch((reason: any) => {
|
|
reject({
|
|
name: 'API serialization error',
|
|
time: Date().toString(),
|
|
status: response.status,
|
|
message: `unmanaged error model: ??? with error: ${reason}`,
|
|
statusMessage: 'Fetch ERROR TEXT FAIL',
|
|
error: 'rest-tools.ts Wrong message model to parse',
|
|
} as RestErrorResponse);
|
|
});
|
|
});
|
|
}
|
|
})
|
|
.catch((error: Error) => {
|
|
if (isRestErrorResponse(error)) {
|
|
reject(error);
|
|
} else {
|
|
reject({
|
|
name: 'Request fail',
|
|
time: Date(),
|
|
status: 999,
|
|
message: error,
|
|
statusMessage: 'Fetch catch error',
|
|
error: 'rest-tools.ts detect an error in the fetch request',
|
|
});
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
export function RESTRequestJson<TYPE>(
|
|
request: RESTRequestType,
|
|
checker?: (data: any) => data is TYPE
|
|
): Promise<TYPE> {
|
|
return new Promise((resolve, reject) => {
|
|
RESTRequest(request)
|
|
.then((value: ModelResponseHttp) => {
|
|
if (isNullOrUndefined(checker)) {
|
|
console.log(`Have no check of MODEL in API: ${RESTUrl(request)}`);
|
|
resolve(value.data);
|
|
} else if (checker === undefined || checker(value.data)) {
|
|
resolve(value.data);
|
|
} else {
|
|
reject({
|
|
name: 'Model check fail',
|
|
time: Date().toString(),
|
|
status: 950,
|
|
error: 'REST Fail to verify the data',
|
|
statusMessage: 'API cast ERROR',
|
|
message: 'api.ts Check type as fail',
|
|
} as RestErrorResponse);
|
|
}
|
|
})
|
|
.catch((reason: RestErrorResponse) => {
|
|
reject(reason);
|
|
});
|
|
});
|
|
}
|
|
|
|
export function RESTRequestVoid(request: RESTRequestType): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
RESTRequest(request)
|
|
.then((value: ModelResponseHttp) => {
|
|
resolve();
|
|
})
|
|
.catch((reason: RestErrorResponse) => {
|
|
reject(reason);
|
|
});
|
|
});
|
|
}
|