kangaroo-and-rabbit/archidata
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FIX] Correct Rest tool interface for stric mode of Typescript

Browse Source
This commit is contained in:
Edouard DUPIN 2024-05-22 17:27:36 +02:00
parent 6f36f98cd6
commit 8c30336bdb
1 changed files with 200 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

350
src/resources/rest-tools.ts
View File

@ -4,25 +4,25 @@
* @license MPL-2 * @license MPL-2
*/ */
import { RestErrorResponse } from "./model" import { RestErrorResponse } from "./model";
export enum HTTPRequestModel { export enum HTTPRequestModel {
DELETE = 'DELETE', DELETE = "DELETE",
GET = 'GET', GET = "GET",
PATCH = 'PATCH', PATCH = "PATCH",
POST = 'POST', POST = "POST",
PUT = 'PUT', PUT = "PUT",
} }
export enum HTTPMimeType { export enum HTTPMimeType {
ALL = '*/*', ALL = "*/*",
CSV = 'text/csv', CSV = "text/csv",
IMAGE = 'image/*', IMAGE = "image/*",
IMAGE_JPEG = 'image/jpeg', IMAGE_JPEG = "image/jpeg",
IMAGE_PNG = 'image/png', IMAGE_PNG = "image/png",
JSON = 'application/json', JSON = "application/json",
MULTIPART = 'multipart/form-data', MULTIPART = "multipart/form-data",
OCTET_STREAM = 'application/octet-stream', OCTET_STREAM = "application/octet-stream",
TEXT_PLAIN = 'text/plain', TEXT_PLAIN = "text/plain",
} }
export interface RESTConfig { export interface RESTConfig {
@ -58,52 +58,61 @@ function isNullOrUndefined(data: any): data is undefined | null {
export type ProgressCallback = (count: number, total: number) => void; export type ProgressCallback = (count: number, total: number) => void;
export interface RESTAbort { export interface RESTAbort {
abort?: () => boolean abort?: () => boolean;
} }
// Rest generic callback have a basic model to upload and download advancement. // Rest generic callback have a basic model to upload and download advancement.
export interface RESTCallbacks { export interface RESTCallbacks {
progressUpload?: ProgressCallback, progressUpload?: ProgressCallback;
progressDownload?: ProgressCallback, progressDownload?: ProgressCallback;
abortHandle?: RESTAbort, abortHandle?: RESTAbort;
}; }
export interface RESTRequestType { export interface RESTRequestType {
restModel: RESTModel, restModel: RESTModel;
restConfig: RESTConfig, restConfig: RESTConfig;
data?: any, data?: any;
params?: object, params?: object;
queries?: object, queries?: object;
callback?: RESTCallbacks, callback?: RESTCallbacks;
}; }
function replaceAll(input, searchValue, replaceValue) { function replaceAll(input, searchValue, replaceValue) {
return input.split(searchValue).join(replaceValue); return input.split(searchValue).join(replaceValue);
} }
function removeTrailingSlashes(input: string): string { function removeTrailingSlashes(input: string): string {
if (isNullOrUndefined(input)) { if (isNullOrUndefined(input)) {
return "undefined"; return "undefined";
} }
return input.replace(/\/+$/, ''); return input.replace(/\/+$/, "");
} }
function removeLeadingSlashes(input: string): string { function removeLeadingSlashes(input: string): string {
if (isNullOrUndefined(input)) { if (isNullOrUndefined(input)) {
return ""; return "";
} }
return input.replace(/^\/+/, ''); return input.replace(/^\/+/, "");
} }
export function RESTUrl({ restModel, restConfig, params, queries }: RESTRequestType): string { export function RESTUrl({
restModel,
restConfig,
params,
queries,
}: RESTRequestType): string {
// Create the URL PATH: // Create the URL PATH:
let generateUrl = `${removeTrailingSlashes(restConfig.server)}/${removeLeadingSlashes(restModel.endPoint)}`; let generateUrl = `${removeTrailingSlashes(
restConfig.server
)}/${removeLeadingSlashes(restModel.endPoint)}`;
if (params !== undefined) { if (params !== undefined) {
for (let key of Object.keys(params)) { for (let key of Object.keys(params)) {
generateUrl = replaceAll(generateUrl, `{${key}}`, `${params[key]}`); generateUrl = replaceAll(generateUrl, `{${key}}`, `${params[key]}`);
} }
} }
if (queries === undefined && (restConfig.token === undefined || restModel.tokenInUrl !== true)) { if (
queries === undefined &&
(restConfig.token === undefined || restModel.tokenInUrl !== true)
) {
return generateUrl; return generateUrl;
} }
const searchParams = new URLSearchParams(); const searchParams = new URLSearchParams();
@ -111,8 +120,8 @@ export function RESTUrl({ restModel, restConfig, params, queries }: RESTRequestT
for (let key of Object.keys(queries)) { for (let key of Object.keys(queries)) {
const value = queries[key]; const value = queries[key];
if (Array.isArray(value)) { if (Array.isArray(value)) {
for (let iii = 0; iii < value.length; iii++) { for (const element of value) {
searchParams.append(`${key}`, `${value[iii]}`); searchParams.append(`${key}`, `${element}`);
} }
} else { } else {
searchParams.append(`${key}`, `${value}`); searchParams.append(`${key}`, `${value}`);
@ -120,36 +129,43 @@ export function RESTUrl({ restModel, restConfig, params, queries }: RESTRequestT
} }
} }
if (restConfig.token !== undefined && restModel.tokenInUrl === true) { if (restConfig.token !== undefined && restModel.tokenInUrl === true) {
searchParams.append('Authorization', `Bearer ${restConfig.token}`); searchParams.append("Authorization", `Bearer ${restConfig.token}`);
} }
return generateUrl + "?" + searchParams.toString(); return generateUrl + "?" + searchParams.toString();
} }
export function fetchProgress(
export function fetchProgress(generateUrl: string, { method, headers, body }: { generateUrl: string,
method: HTTPRequestModel, {
headers: any, method,
body: any, headers,
}, { progressUpload, progressDownload, abortHandle }: RESTCallbacks): Promise<Response> { body,
const xhr = { }: {
io: new XMLHttpRequest() method: HTTPRequestModel;
} headers: any;
body: any;
},
{ progressUpload, progressDownload, abortHandle }: RESTCallbacks
): Promise<Response> {
const xhr: {
io?: XMLHttpRequest;
} = {
io: new XMLHttpRequest(),
};
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
// Stream the upload progress // Stream the upload progress
if (progressUpload) { if (progressUpload) {
xhr.io.upload.addEventListener("progress", (dataEvent) => { xhr.io?.upload.addEventListener("progress", (dataEvent) => {
if (dataEvent.lengthComputable) { if (dataEvent.lengthComputable) {
//console.log(` ==> has a progress event: ${dataEvent.loaded} / ${dataEvent.total}`);
progressUpload(dataEvent.loaded, dataEvent.total); progressUpload(dataEvent.loaded, dataEvent.total);
} }
}); });
} }
// Stream the download progress // Stream the download progress
if (progressDownload) { if (progressDownload) {
xhr.io.addEventListener("progress", (dataEvent) => { xhr.io?.addEventListener("progress", (dataEvent) => {
if (dataEvent.lengthComputable) { if (dataEvent.lengthComputable) {
//console.log(` ==> download progress:: ${dataEvent.loaded} / ${dataEvent.total}`); progressDownload(dataEvent.loaded, dataEvent.total);
progressUpload(dataEvent.loaded, dataEvent.total);
} }
}); });
} }
@ -160,38 +176,43 @@ export function fetchProgress(generateUrl: string, { method, headers, body }: {
xhr.io.abort(); xhr.io.abort();
return true; return true;
} }
console.log(`Request abort (FAIL) on the XMLHttpRequest: ${generateUrl}`); console.log(
`Request abort (FAIL) on the XMLHttpRequest: ${generateUrl}`
);
return false; return false;
} };
} }
// Check if we have an internal Fail: // Check if we have an internal Fail:
xhr.io.addEventListener('error', () => { xhr.io?.addEventListener("error", () => {
xhr.io = undefined; xhr.io = undefined;
reject(new TypeError('Failed to fetch')) reject(new TypeError("Failed to fetch"));
}); });
// Capture the end of the stream // Capture the end of the stream
xhr.io.addEventListener("loadend", () => { xhr.io?.addEventListener("loadend", () => {
if (xhr.io.readyState !== XMLHttpRequest.DONE) { if (xhr.io?.readyState !== XMLHttpRequest.DONE) {
//console.log(` ==> READY state`);
return; return;
} }
if (xhr.io.status === 0) { if (xhr.io?.status === 0) {
//the stream has been aborted //the stream has been aborted
reject(new TypeError('Fetch has been aborted')); reject(new TypeError("Fetch has been aborted"));
return; return;
} }
// Stream is ended, transform in a generic response: // Stream is ended, transform in a generic response:
const response = new Response(xhr.io.response, { const response = new Response(xhr.io.response, {
status: xhr.io.status, status: xhr.io.status,
statusText: xhr.io.statusText statusText: xhr.io.statusText,
}); });
const headersArray = replaceAll(xhr.io.getAllResponseHeaders().trim(), "\r\n", "\n").split('\n'); const headersArray = replaceAll(
xhr.io.getAllResponseHeaders().trim(),
"\r\n",
"\n"
).split("\n");
headersArray.forEach(function (header) { headersArray.forEach(function (header) {
const firstColonIndex = header.indexOf(':'); const firstColonIndex = header.indexOf(":");
if (firstColonIndex !== -1) { if (firstColonIndex !== -1) {
var key = header.substring(0, firstColonIndex).trim(); const key = header.substring(0, firstColonIndex).trim();
var value = header.substring(firstColonIndex + 1).trim(); const value = header.substring(firstColonIndex + 1).trim();
response.headers.set(key, value); response.headers.set(key, value);
} else { } else {
response.headers.set(header, ""); response.headers.set(header, "");
@ -200,31 +221,38 @@ export function fetchProgress(generateUrl: string, { method, headers, body }: {
xhr.io = undefined; xhr.io = undefined;
resolve(response); resolve(response);
}); });
xhr.io.open(method, generateUrl, true); xhr.io?.open(method, generateUrl, true);
if (!isNullOrUndefined(headers)) { if (!isNullOrUndefined(headers)) {
for (const [key, value] of Object.entries(headers)) { for (const [key, value] of Object.entries(headers)) {
xhr.io.setRequestHeader(key, value as string); xhr.io?.setRequestHeader(key, value as string);
} }
} }
xhr.io.send(body); xhr.io?.send(body);
}); });
} }
export function RESTRequest({ restModel, restConfig, data, params, queries, callback }: RESTRequestType): Promise<ModelResponseHttp> { export function RESTRequest({
restModel,
restConfig,
data,
params,
queries,
callback,
}: RESTRequestType): Promise<ModelResponseHttp> {
// Create the URL PATH: // Create the URL PATH:
let generateUrl = RESTUrl({ restModel, restConfig, data, params, queries }); let generateUrl = RESTUrl({ restModel, restConfig, data, params, queries });
let headers: any = {}; let headers: any = {};
if (restConfig.token !== undefined && restModel.tokenInUrl !== true) { if (restConfig.token !== undefined && restModel.tokenInUrl !== true) {
headers['Authorization'] = `Bearer ${restConfig.token}`; headers["Authorization"] = `Bearer ${restConfig.token}`;
} }
if (restModel.accept !== undefined) { if (restModel.accept !== undefined) {
headers['Accept'] = restModel.accept; headers["Accept"] = restModel.accept;
} }
if (restModel.requestType !== HTTPRequestModel.GET) { if (restModel.requestType !== HTTPRequestModel.GET) {
// if Get we have not a content type, the body is empty // if Get we have not a content type, the body is empty
if (restModel.contentType !== HTTPMimeType.MULTIPART) { if (restModel.contentType !== HTTPMimeType.MULTIPART) {
// special case of multi-part ==> no content type otherwise the browser does not set the ";bundary=--****" // special case of multi-part ==> no content type otherwise the browser does not set the ";bundary=--****"
headers['Content-Type'] = restModel.contentType; headers["Content-Type"] = restModel.contentType;
} }
} }
let body = data; let body = data;
@ -235,14 +263,16 @@ export function RESTRequest({ restModel, restConfig, data, params, queries, call
for (const name in data) { for (const name in data) {
formData.append(name, data[name]); formData.append(name, data[name]);
} }
body = formData body = formData;
} }
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
let action: undefined | Promise<Response> = undefined; let action: undefined | Promise<Response> = undefined;
if (isNullOrUndefined(callback) if (
|| (isNullOrUndefined(callback.progressDownload) isNullOrUndefined(callback) ||
&& isNullOrUndefined(callback.progressUpload) (isNullOrUndefined(callback.progressDownload) &&
&& isNullOrUndefined(callback.abortHandle))) { isNullOrUndefined(callback.progressUpload) &&
isNullOrUndefined(callback.abortHandle))
) {
// No information needed: call the generic fetch interface // No information needed: call the generic fetch interface
action = fetch(generateUrl, { action = fetch(generateUrl, {
method: restModel.requestType, method: restModel.requestType,
@ -251,92 +281,112 @@ export function RESTRequest({ restModel, restConfig, data, params, queries, call
}); });
} else { } else {
// need progression information: call old fetch model (XMLHttpRequest) that permit to keep % upload and % download for HTTP1.x // need progression information: call old fetch model (XMLHttpRequest) that permit to keep % upload and % download for HTTP1.x
action = fetchProgress(generateUrl, { action = fetchProgress(
method: restModel.requestType ?? HTTPRequestModel.GET, generateUrl,
headers, {
body, method: restModel.requestType ?? HTTPRequestModel.GET,
}, callback); headers,
body,
},
callback
);
} }
action.then((response: Response) => { action
if (response.status >= 200 && response.status <= 299) { .then((response: Response) => {
const contentType = response.headers.get('Content-Type'); if (response.status >= 200 && response.status <= 299) {
if (!isNullOrUndefined(restModel.accept) && restModel.accept !== contentType) { const contentType = response.headers.get("Content-Type");
reject({ if (
time: Date().toString(), !isNullOrUndefined(restModel.accept) &&
status: 901, restModel.accept !== contentType
error: `REST check wrong type: ${restModel.accept} != ${contentType}`, ) {
statusMessage: "Fetch error", reject({
message: "rest-tools.ts Wrong type in the message return type" name: "Model accept type incompatible",
} as RestErrorResponse); time: Date().toString(),
} else if (contentType === HTTPMimeType.JSON) { status: 901,
response error: `REST check wrong type: ${restModel.accept} != ${contentType}`,
.json() statusMessage: "Fetch error",
.then((value: any) => { message: "rest-tools.ts Wrong type in the message return type",
//console.log(`RECEIVE ==> ${response.status}=${ JSON.stringify(value, null, 2)}`); } as RestErrorResponse);
resolve({ status: response.status, data: value }); } else if (contentType === HTTPMimeType.JSON) {
}) response
.catch((reason: any) => { .json()
reject({ .then((value: any) => {
time: Date().toString(), resolve({ status: response.status, data: value });
status: 902, })
error: `REST parse json fail: ${reason}`, .catch((reason: any) => {
statusMessage: "Fetch parse error", reject({
message: "rest-tools.ts Wrong message model to parse" name: "API serialization error",
} as RestErrorResponse); time: Date().toString(),
}); status: 902,
error: `REST parse json fail: ${reason}`,
statusMessage: "Fetch parse error",
message: "rest-tools.ts Wrong message model to parse",
} as RestErrorResponse);
});
} else {
resolve({ status: response.status, data: response.body });
}
} else { } else {
resolve({ status: response.status, data: response.body }); reject({
name: "REST return no OK status",
time: Date().toString(),
status: response.status,
error: `${response.body}`,
statusMessage: "Fetch code error",
message: "rest-tools.ts Wrong return code",
} as RestErrorResponse);
} }
} else { })
.catch((error: any) => {
reject({ reject({
time: Date().toString(), name: "Request fail",
status: response.status, time: Date(),
error: `${response.body}`, status: 999,
statusMessage: "Fetch code error", error: error,
message: "rest-tools.ts Wrong return code" statusMessage: "Fetch catch error",
} as RestErrorResponse); message: "rest-tools.ts detect an error in the fetch request",
} });
}).catch((error: any) => {
reject({
time: Date(),
status: 999,
error: error,
statusMessage: "Fetch catch error",
message: "rest-tools.ts detect an error in the fetch request"
}); });
});
}); });
} }
export function RESTRequestJson<TYPE>(request: RESTRequestType, checker: (data: any) => data is TYPE): Promise<TYPE> { export function RESTRequestJson<TYPE>(
request: RESTRequestType,
checker?: (data: any) => data is TYPE
): Promise<TYPE> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
RESTRequest(request).then((value: ModelResponseHttp) => { RESTRequest(request)
if (isNullOrUndefined(checker)) { .then((value: ModelResponseHttp) => {
console.log(`Have no check of MODEL in API: ${RESTUrl(request)}`); if (isNullOrUndefined(checker)) {
resolve(value.data); console.log(`Have no check of MODEL in API: ${RESTUrl(request)}`);
} else if (checker(value.data)) { resolve(value.data);
resolve(value.data); } else if (checker === undefined || checker(value.data)) {
} else { resolve(value.data);
reject({ } else {
time: Date().toString(), reject({
status: 950, name: "Model check fail",
error: "REST Fail to verify the data", time: Date().toString(),
statusMessage: "API cast ERROR", status: 950,
message: "api.ts Check type as fail" error: "REST Fail to verify the data",
} as RestErrorResponse); statusMessage: "API cast ERROR",
} message: "api.ts Check type as fail",
}).catch((reason: RestErrorResponse) => { } as RestErrorResponse);
reject(reason); }
}); })
.catch((reason: RestErrorResponse) => {
reject(reason);
});
}); });
} }
export function RESTRequestVoid(request: RESTRequestType): Promise<void> { export function RESTRequestVoid(request: RESTRequestType): Promise<void> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
RESTRequest(request).then((value: ModelResponseHttp) => { RESTRequest(request)
resolve(); .then((value: ModelResponseHttp) => {
}).catch((reason: RestErrorResponse) => { resolve();
reject(reason); })
}); .catch((reason: RestErrorResponse) => {
reject(reason);
});
}); });
} }