@nmshd/transport 1.0.0

package/dist/core/backbone/ClientResult.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientResult = void 0;
+const CoreDate_1 = require("../types/CoreDate");
+class ClientResult {
+    constructor(isSuccess, value, error, platformParameters) {
+        if (isSuccess && error) {
+            throw new Error("InvalidOperation: A result cannot be successful and contain an error");
+        }
+        if (!isSuccess && !error) {
+            throw new Error("InvalidOperation: A failing result needs to contain an error");
+        }
+        if (value !== undefined && !isSuccess) {
+            throw new Error("InvalidOperation: A value is only useful in case of a success.");
+        }
+        this._value = value;
+        this._isSuccess = isSuccess;
+        this._error = error;
+        if (platformParameters) {
+            this.requestTime = platformParameters.requestTime
+                ? CoreDate_1.CoreDate.from(platformParameters.requestTime)
+                : undefined;
+            this.responseDuration = platformParameters.responseDuration
+                ? parseInt(platformParameters.responseDuration)
+                : undefined;
+            this.responseTime = platformParameters.responseTime
+                ? CoreDate_1.CoreDate.from(platformParameters.responseTime)
+                : undefined;
+            this.traceId = platformParameters.traceId;
+        }
+    }
+    get isSuccess() {
+        return this._isSuccess;
+    }
+    get isError() {
+        return !this._isSuccess;
+    }
+    get error() {
+        if (this._isSuccess) {
+            throw new Error("Can't get the error of an succeeded result. Use 'value' instead.");
+        }
+        return this._error;
+    }
+    get value() {
+        if (!this._isSuccess) {
+            throw this.error;
+        }
+        return this._value;
+    }
+    static fail(error, platformParameters) {
+        return new ClientResult(false, undefined, error, platformParameters);
+    }
+    static ok(value, platformParameters) {
+        return new ClientResult(true, value, undefined, platformParameters);
+    }
+}
+exports.ClientResult = ClientResult;
+//# sourceMappingURL=ClientResult.js.map

package/dist/core/backbone/ClientResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientResult.js","sourceRoot":"","sources":["../../../src/core/backbone/ClientResult.ts"],"names":[],"mappings":";;;AACA,gDAA4C;AAG5C,MAAa,YAAY;IAUrB,YACI,SAAkB,EAClB,KAAS,EACT,KAAwB,EACxB,kBAAuC;QAEvC,IAAI,SAAS,IAAI,KAAK,EAAE;YACpB,MAAM,IAAI,KAAK,CAAC,sEAAsE,CAAC,CAAA;SAC1F;QACD,IAAI,CAAC,SAAS,IAAI,CAAC,KAAK,EAAE;YACtB,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAA;SAClF;QAED,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,SAAS,EAAE;YACnC,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAA;SACpF;QAED,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QACnB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;QAC3B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QAEnB,IAAI,kBAAkB,EAAE;YACpB,IAAI,CAAC,WAAW,GAAG,kBAAkB,CAAC,WAAW;gBAC7C,CAAC,CAAC,mBAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC;gBAC/C,CAAC,CAAC,SAAS,CAAA;YAEf,IAAI,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,gBAAgB;gBACvD,CAAC,CAAC,QAAQ,CAAC,kBAAkB,CAAC,gBAAgB,CAAC;gBAC/C,CAAC,CAAC,SAAS,CAAA;YAEf,IAAI,CAAC,YAAY,GAAG,kBAAkB,CAAC,YAAY;gBAC/C,CAAC,CAAC,mBAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC;gBAChD,CAAC,CAAC,SAAS,CAAA;YAEf,IAAI,CAAC,OAAO,GAAG,kBAAkB,CAAC,OAAO,CAAA;SAC5C;IACL,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAA;IAC1B,CAAC;IAED,IAAW,OAAO;QACd,OAAO,CAAC,IAAI,CAAC,UAAU,CAAA;IAC3B,CAAC;IAED,IAAW,KAAK;QACZ,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAA;SACtF;QAED,OAAO,IAAI,CAAC,MAAO,CAAA;IACvB,CAAC;IAED,IAAW,KAAK;QACZ,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAClB,MAAM,IAAI,CAAC,KAAK,CAAA;SACnB;QAED,OAAO,IAAI,CAAC,MAAO,CAAA;IACvB,CAAC;IAEM,MAAM,CAAC,IAAI,CAAI,KAAuB,EAAE,kBAAuC;QAClF,OAAO,IAAI,YAAY,CAAI,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAA;IAC3E,CAAC;IAEM,MAAM,CAAC,EAAE,CAAI,KAAQ,EAAE,kBAAuC;QACjE,OAAO,IAAI,YAAY,CAAI,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,kBAAkB,CAAC,CAAA;IAC1E,CAAC;CACJ;AA/ED,oCA+EC"}

package/dist/core/backbone/Paginator.d.ts

@@ -0,0 +1,17 @@
+import { PaginationProperties } from "./PlatformResponse";
+export interface IPaginationDataSource<T> {
+    getPage(pageNumber: number): Promise<T[]>;
+}
+export declare class Paginator<T> implements AsyncIterable<T> {
+    private currentPage;
+    private readonly paginationProperties;
+    private readonly dataSource;
+    private currentItemIndex;
+    constructor(currentPage: T[], paginationProperties: PaginationProperties, dataSource: IPaginationDataSource<T>);
+    private hasNext;
+    private next;
+    private hasNextPage;
+    private nextPage;
+    collect(): Promise<T[]>;
+    [Symbol.asyncIterator](): AsyncIterator<T, any, undefined>;
+}

package/dist/core/backbone/Paginator.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Paginator = void 0;
+class Paginator {
+    constructor(currentPage, paginationProperties, dataSource) {
+        this.currentPage = currentPage;
+        this.paginationProperties = paginationProperties;
+        this.dataSource = dataSource;
+        this.currentItemIndex = 0;
+    }
+    hasNext() {
+        return this.hasNextPage() || this.currentItemIndex < this.currentPage.length;
+    }
+    async next() {
+        const isAtEndOfPage = this.currentItemIndex >= this.currentPage.length;
+        if (isAtEndOfPage && this.hasNextPage()) {
+            this.currentItemIndex = 0;
+            this.currentPage = await this.nextPage();
+        }
+        return this.currentPage[this.currentItemIndex++];
+    }
+    hasNextPage() {
+        return this.paginationProperties.pageNumber < this.paginationProperties.totalPages;
+    }
+    async nextPage() {
+        this.paginationProperties.pageNumber++;
+        const response = await this.dataSource.getPage(this.paginationProperties.pageNumber);
+        return response;
+    }
+    async collect() {
+        const collection = this.currentPage;
+        while (this.hasNextPage()) {
+            collection.push(...(await this.nextPage()));
+        }
+        return collection;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => this.hasNext() ? { value: await this.next(), done: false } : { value: undefined, done: true }
+        };
+    }
+}
+exports.Paginator = Paginator;
+//# sourceMappingURL=Paginator.js.map

package/dist/core/backbone/Paginator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Paginator.js","sourceRoot":"","sources":["../../../src/core/backbone/Paginator.ts"],"names":[],"mappings":";;;AAMA,MAAa,SAAS;IAGlB,YACY,WAAgB,EACP,oBAA0C,EAC1C,UAAoC;QAF7C,gBAAW,GAAX,WAAW,CAAK;QACP,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,eAAU,GAAV,UAAU,CAA0B;QALjD,qBAAgB,GAAG,CAAC,CAAA;IAMzB,CAAC;IAEI,OAAO;QACX,OAAO,IAAI,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAA;IAChF,CAAC;IAEO,KAAK,CAAC,IAAI;QACd,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,CAAA;QACtE,IAAI,aAAa,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACrC,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAA;YACzB,IAAI,CAAC,WAAW,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;SAC3C;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAA;IACpD,CAAC;IAEO,WAAW;QACf,OAAO,IAAI,CAAC,oBAAoB,CAAC,UAAU,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAA;IACtF,CAAC;IAEO,KAAK,CAAC,QAAQ;QAClB,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,CAAA;QACtC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAA;QACpF,OAAO,QAAQ,CAAA;IACnB,CAAC;IAEM,KAAK,CAAC,OAAO;QAChB,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAA;QAEnC,OAAO,IAAI,CAAC,WAAW,EAAE,EAAE;YACvB,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;SAC9C;QAED,OAAO,UAAU,CAAA;IACrB,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QACzB,OAAO;YACH,IAAI,EAAE,KAAK,IAAI,EAAE,CACb,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE;SACpG,CAAA;IACL,CAAC;CACJ;AAjDD,8BAiDC"}

package/dist/core/backbone/PlatformError.d.ts

@@ -0,0 +1,9 @@
+export interface PlatformError {
+    id: string;
+    code: string;
+    details: string | null;
+    message: string;
+    docs: string;
+    status: number | null;
+    time: string;
+}

package/dist/core/backbone/PlatformError.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PlatformError.js.map

package/dist/core/backbone/PlatformError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlatformError.js","sourceRoot":"","sources":["../../../src/core/backbone/PlatformError.ts"],"names":[],"mappings":""}

package/dist/core/backbone/PlatformParameters.d.ts

@@ -0,0 +1,6 @@
+export interface PlatformParameters {
+    requestTime?: string;
+    responseDuration?: string;
+    responseTime?: string;
+    traceId?: string;
+}

package/dist/core/backbone/PlatformParameters.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PlatformParameters.js.map

package/dist/core/backbone/PlatformParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlatformParameters.js","sourceRoot":"","sources":["../../../src/core/backbone/PlatformParameters.ts"],"names":[],"mappings":""}

package/dist/core/backbone/PlatformResponse.d.ts

@@ -0,0 +1,16 @@
+import { PlatformError } from "./PlatformError";
+export interface PlatformResponse<T> {
+    result?: T;
+    error?: PlatformError;
+}
+export interface PaginationProperties {
+    pageNumber: number;
+    pageSize: number;
+    totalPages: number;
+    totalRecords: number;
+}
+export interface PaginatedPlatformResponse<T> {
+    result?: T;
+    error?: PlatformError;
+    pagination?: PaginationProperties;
+}

package/dist/core/backbone/PlatformResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PlatformResponse.js.map

package/dist/core/backbone/PlatformResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlatformResponse.js","sourceRoot":"","sources":["../../../src/core/backbone/PlatformResponse.ts"],"names":[],"mappings":""}

package/dist/core/backbone/RESTClient.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { ILogger } from "@js-soft/logging-abstractions";
+import { AxiosInstance, AxiosRequestConfig } from "axios";
+import { Agent } from "http";
+import { Agent as HTTPSAgent } from "https";
+import { IConfig } from "../../core";
+import { ClientResult } from "./ClientResult";
+import { IPaginationDataSource, Paginator } from "./Paginator";
+export declare class RestPaginationDataSource<T> implements IPaginationDataSource<T> {
+    private readonly client;
+    private readonly path;
+    private args;
+    constructor(client: RESTClient, path: string, args: any);
+    getPage(pageNumber: number): Promise<T[]>;
+}
+export declare enum RESTClientLogDirective {
+    LogNone = 0,
+    LogRequest = 1,
+    LogResponse = 2,
+    LogAll = 3
+}
+export declare class RESTClient {
+    protected readonly config: IConfig;
+    protected requestConfig: AxiosRequestConfig;
+    protected _logger: ILogger;
+    protected _logDirective: RESTClientLogDirective;
+    private _httpAgent?;
+    private _httpsAgent?;
+    logRequest(): boolean;
+    logResponse(): boolean;
+    createHTTPAgent(): Agent;
+    createHTTPSAgent(): HTTPSAgent;
+    private generateRequestId;
+    constructor(config: IConfig, requestConfig?: AxiosRequestConfig);
+    protected createAxios(): AxiosInstance;
+    private addAxiosLoggingInterceptors;
+    private getResult;
+    private getPaginator;
+    get<T>(path: string, params?: any, config?: AxiosRequestConfig): Promise<ClientResult<T>>;
+    getPaged<T>(path: string, params?: any, config?: AxiosRequestConfig): Promise<ClientResult<Paginator<T>>>;
+    post<T>(path: string, data: any, params?: any, config?: AxiosRequestConfig): Promise<ClientResult<T>>;
+    postMultipart<T>(path: string, data: any, config?: AxiosRequestConfig): Promise<ClientResult<T>>;
+    put<T>(path: string, data: any, config?: AxiosRequestConfig): Promise<ClientResult<T>>;
+    delete<T>(path: string, config?: AxiosRequestConfig): Promise<ClientResult<T>>;
+    download<T>(path: string, config?: AxiosRequestConfig): Promise<ClientResult<T>>;
+}

package/dist/core/backbone/RESTClient.js

@@ -0,0 +1,425 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESTClient = exports.RESTClientLogDirective = exports.RestPaginationDataSource = void 0;
+const crypto_1 = require("@nmshd/crypto");
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const http_1 = require("http");
+const https_1 = require("https");
+const lodash_1 = __importDefault(require("lodash"));
+const qs_1 = __importDefault(require("qs"));
+const TransportLoggerFactory_1 = require("../TransportLoggerFactory");
+const types_1 = require("../types");
+const ClientResult_1 = require("./ClientResult");
+const Paginator_1 = require("./Paginator");
+const RequestError_1 = require("./RequestError");
+class RestPaginationDataSource {
+    constructor(client, path, args) {
+        this.client = client;
+        this.path = path;
+        this.args = args;
+    }
+    async getPage(pageNumber) {
+        this.args.pageNumber = pageNumber;
+        return (await this.client.get(this.path, this.args)).value;
+    }
+}
+exports.RestPaginationDataSource = RestPaginationDataSource;
+var RESTClientLogDirective;
+(function (RESTClientLogDirective) {
+    RESTClientLogDirective[RESTClientLogDirective["LogNone"] = 0] = "LogNone";
+    RESTClientLogDirective[RESTClientLogDirective["LogRequest"] = 1] = "LogRequest";
+    RESTClientLogDirective[RESTClientLogDirective["LogResponse"] = 2] = "LogResponse";
+    RESTClientLogDirective[RESTClientLogDirective["LogAll"] = 3] = "LogAll";
+})(RESTClientLogDirective = exports.RESTClientLogDirective || (exports.RESTClientLogDirective = {}));
+class RESTClient {
+    constructor(config, requestConfig = {}) {
+        this.config = config;
+        this.requestConfig = requestConfig;
+        this._logDirective = RESTClientLogDirective.LogAll;
+        const defaults = {
+            baseURL: config.baseUrl,
+            timeout: this.config.platformTimeout,
+            maxRedirects: this.config.platformMaxRedirects,
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity,
+            validateStatus: (status) => status < 300 || status === 400 || status === 404 || status === 500,
+            paramsSerializer: (params) => {
+                return qs_1.default.stringify(params, {
+                    arrayFormat: "repeat",
+                    encode: false,
+                    allowDots: true
+                });
+            }
+        };
+        if (this.config.platformAdditionalHeaders) {
+            defaults.headers = this.config.platformAdditionalHeaders;
+        }
+        if (typeof http_1.Agent !== "undefined" && typeof https_1.Agent !== "undefined") {
+            defaults.httpAgent = this.createHTTPAgent();
+            defaults.httpsAgent = this.createHTTPSAgent();
+        }
+        this.requestConfig = lodash_1.default.defaultsDeep(this.requestConfig, defaults);
+        this._logger = TransportLoggerFactory_1.TransportLoggerFactory.getLogger(RESTClient);
+    }
+    logRequest() {
+        return (this._logDirective === RESTClientLogDirective.LogRequest ||
+            this._logDirective === RESTClientLogDirective.LogAll);
+    }
+    logResponse() {
+        return (this._logDirective === RESTClientLogDirective.LogResponse ||
+            this._logDirective === RESTClientLogDirective.LogAll);
+    }
+    createHTTPAgent() {
+        if (this._httpAgent) {
+            return this._httpAgent;
+        }
+        this._httpAgent = new http_1.Agent(this.config.httpAgent);
+        return this._httpAgent;
+    }
+    createHTTPSAgent() {
+        if (this._httpsAgent) {
+            return this._httpsAgent;
+        }
+        this._httpsAgent = new https_1.Agent(this.config.httpsAgent);
+        return this._httpsAgent;
+    }
+    async generateRequestId() {
+        const id = await types_1.CoreId.generate("HTTP");
+        return id.toString();
+    }
+    createAxios() {
+        const axiosInstance = axios_1.default.create(this.requestConfig);
+        if (this.config.debug) {
+            this.addAxiosLoggingInterceptors(axiosInstance);
+        }
+        return axiosInstance;
+    }
+    addAxiosLoggingInterceptors(axiosInstance) {
+        axiosInstance.interceptors.request.use((config) => {
+            const requestAsAny = config;
+            requestAsAny.meta = config.meta || {};
+            requestAsAny.meta.startTime = new Date().getTime();
+            return config;
+        });
+        axiosInstance.interceptors.response.use((response) => {
+            logResponseTime(response);
+            return response;
+        });
+        const logResponseTime = (response) => {
+            var _a;
+            const requestStartTime = response.config.meta.startTime;
+            // Backbone Call duration
+            const backboneResponseDuration = ((_a = response.headers) === null || _a === void 0 ? void 0 : _a["x-response-duration-ms"])
+                ? Number.parseInt(response.headers["x-response-duration-ms"])
+                : undefined;
+            const backboneMessage = `${response.config.method.toUpperCase()} ${response.request.path} (backbone call): ${backboneResponseDuration ? `${backboneResponseDuration}ms` : "unknown"}`;
+            if (backboneResponseDuration && backboneResponseDuration > 200) {
+                this._logger.warn(backboneMessage);
+            }
+            else {
+                this._logger.debug(backboneMessage);
+            }
+            // Latency duration
+            const requestEndTime = new Date().getTime();
+            const callAndLatencyMilliseconds = requestEndTime - requestStartTime;
+            const latencyMilliseconds = backboneResponseDuration
+                ? callAndLatencyMilliseconds - backboneResponseDuration
+                : undefined;
+            const latencyMessage = `${response.config.method.toUpperCase()} ${response.request.path} (latency): ${latencyMilliseconds}ms`;
+            this._logger.debug(latencyMessage);
+            // Backbone Call + Latency duration
+            this._logger.debug(`${response.config.method.toUpperCase()} ${response.request.path} (backbone call + latency): ${callAndLatencyMilliseconds}ms`);
+        };
+    }
+    getResult(method, path, response, requestId) {
+        var _a, _b, _c;
+        const platformParameters = {
+            requestTime: response.headers["x-request-time"],
+            responseDuration: response.headers["x-response-duration-ms"],
+            responseTime: response.headers["x-response-time"],
+            traceId: response.headers["x-trace-id"]
+        };
+        if (response.data && this.logResponse()) {
+            const message = `Response ${requestId}: ${method} ${path} | TraceId: '${platformParameters.traceId}' | PlatformDuration: ${platformParameters.responseDuration}`;
+            try {
+                this._logger.trace(message, JSON.stringify(response.data, undefined, 2));
+            }
+            catch (e) {
+                this._logger.trace(message);
+            }
+        }
+        // Rare case: We receive status 400 JSON error from backbone when downloading a file
+        if (response.status === 400 &&
+            !((_a = response.data) === null || _a === void 0 ? void 0 : _a.error) &&
+            response.headers["content-type"] === "application/json; charset=utf-8") {
+            try {
+                const errorText = crypto_1.CoreBuffer.from(response.data).toUtf8();
+                response.data = JSON.parse(errorText);
+            }
+            catch (e) {
+                // Do nothing here: Error is handled below
+            }
+        }
+        if ((_b = response.data) === null || _b === void 0 ? void 0 : _b.error) {
+            const backboneError = response.data.error;
+            const error = new RequestError_1.RequestError(method, path, platformParameters, backboneError.code, backboneError.message, backboneError.docs, response.status, backboneError.time, {
+                id: backboneError.id,
+                details: backboneError.details
+            });
+            this._logger.debug(error);
+            return ClientResult_1.ClientResult.fail(error, platformParameters);
+        }
+        if (response.status === 204) {
+            return ClientResult_1.ClientResult.ok({}, platformParameters);
+        }
+        if (response.status === 404) {
+            const error = new RequestError_1.RequestError(method, path, platformParameters, "error.transport.request.notFound", "The requested entity was not found. Make sure the ID exists and the record is not expired.", "", 404);
+            this._logger.debug(error);
+            return ClientResult_1.ClientResult.fail(error, platformParameters);
+        }
+        if (response.status >= 400 && response.status <= 499) {
+            const error = new RequestError_1.RequestError(method, path, platformParameters, "error.transport.request.badRequest", "The platform responded with a Bad Request without giving any specific reason.", "", response.status).setObject(response.data);
+            this._logger.debug(error);
+            return ClientResult_1.ClientResult.fail(error, platformParameters);
+        }
+        if ((typeof Buffer === "function" && response.data instanceof Buffer) || response.data instanceof ArrayBuffer) {
+            // Casting is required for typescript to not complain => data is a buffer
+            return ClientResult_1.ClientResult.ok(response.data, platformParameters);
+        }
+        if (!((_c = response.data) === null || _c === void 0 ? void 0 : _c.result)) {
+            const error = new RequestError_1.RequestError(method, path, platformParameters, "error.transport.request.resultUndefined", "The Platform responded without a result.").setObject(response.data);
+            this._logger.debug(error);
+            return ClientResult_1.ClientResult.fail(error, platformParameters);
+        }
+        return ClientResult_1.ClientResult.ok(response.data.result, platformParameters);
+    }
+    getPaginator(path, response, requestId, args) {
+        var _a, _b;
+        const platformParameters = {
+            requestTime: response.headers["x-request-time"],
+            responseDuration: response.headers["x-response-duration-ms"],
+            responseTime: response.headers["x-response-time"],
+            traceId: response.headers["x-trace-id"]
+        };
+        if (response.data && this.logResponse()) {
+            const message = `Response ${requestId}: GET ${path} | TraceId: '${platformParameters.traceId}' | PlatformDuration: ${platformParameters.responseDuration}`;
+            try {
+                this._logger.trace(message, JSON.stringify(response.data, undefined, 2));
+            }
+            catch (e) {
+                this._logger.trace(message);
+            }
+        }
+        if ((_a = response.data) === null || _a === void 0 ? void 0 : _a.error) {
+            const backboneError = response.data.error;
+            const error = new RequestError_1.RequestError("GET", path, platformParameters, backboneError.code, backboneError.message, backboneError.docs, response.status, backboneError.time, {
+                id: backboneError.id,
+                details: backboneError.details
+            });
+            this._logger.debug(error);
+            return ClientResult_1.ClientResult.fail(error, platformParameters);
+        }
+        if (response.status >= 400 && response.status <= 499) {
+            const error = new RequestError_1.RequestError("GET", path, platformParameters, "error.transport.request.badRequest", "The platform responded with a Bad Request without giving any specific reason.", "", response.status).setObject(response.data);
+            this._logger.debug(error);
+            return ClientResult_1.ClientResult.fail(error, platformParameters);
+        }
+        if (!((_b = response.data) === null || _b === void 0 ? void 0 : _b.result)) {
+            const error = new RequestError_1.RequestError("GET", path, platformParameters, "error.transport.request.resultUndefined", "The Platform responded without a result.").setObject(response.data);
+            this._logger.debug(error);
+            return ClientResult_1.ClientResult.fail(error, platformParameters);
+        }
+        if (!response.data.pagination) {
+            response.data.pagination = {
+                pageNumber: 1,
+                pageSize: response.data.result.length,
+                totalPages: 1,
+                totalRecords: response.data.result.length
+            };
+        }
+        const paginationDataSource = new RestPaginationDataSource(this, path, args);
+        const paginator = new Paginator_1.Paginator(response.data.result, response.data.pagination, paginationDataSource);
+        return ClientResult_1.ClientResult.ok(paginator, platformParameters);
+    }
+    async get(path, params = {}, config) {
+        const id = await this.generateRequestId();
+        const conf = lodash_1.default.defaultsDeep({ params: params }, config, this.requestConfig);
+        if (this.logRequest()) {
+            const anyThis = this;
+            if (anyThis._username) {
+                this._logger.trace(`Request ${id} by ${anyThis._username}: GET ${path}`);
+            }
+            else {
+                this._logger.trace(`Request ${id}: GET ${path}`);
+            }
+        }
+        try {
+            const response = await this.createAxios().get(path, conf);
+            return this.getResult("GET", path, response, id);
+        }
+        catch (e) {
+            const err = RequestError_1.RequestError.fromAxiosError("GET", path, e, id);
+            this._logger.debug(err);
+            return ClientResult_1.ClientResult.fail(err);
+        }
+    }
+    async getPaged(path, params = {}, config) {
+        const id = await this.generateRequestId();
+        const conf = lodash_1.default.defaultsDeep({ params: params }, config, this.requestConfig);
+        try {
+            const response = await this.createAxios().get(path, conf);
+            return this.getPaginator(path, response, id, params);
+        }
+        catch (e) {
+            const err = RequestError_1.RequestError.fromAxiosError("GET", path, e, id);
+            this._logger.debug(err);
+            return ClientResult_1.ClientResult.fail(err);
+        }
+    }
+    async post(path, data, params = {}, config) {
+        const id = await this.generateRequestId();
+        const conf = lodash_1.default.defaultsDeep({ params: params }, config, this.requestConfig);
+        if (this.logRequest()) {
+            const anyThis = this;
+            if (anyThis._username) {
+                this._logger.trace(`Request ${id} by ${anyThis._username}: POST ${path}`, data);
+            }
+            else {
+                this._logger.trace(`Request ${id}: POST ${path}`, data);
+            }
+        }
+        try {
+            const response = await this.createAxios().post(path, data, conf);
+            return this.getResult("POST", path, response, id);
+        }
+        catch (e) {
+            const err = RequestError_1.RequestError.fromAxiosError("POST", path, e, id);
+            this._logger.debug(err);
+            return ClientResult_1.ClientResult.fail(err);
+        }
+    }
+    async postMultipart(path, data, config) {
+        const id = await this.generateRequestId();
+        const formData = new form_data_1.default();
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (key.toLowerCase() === "content") {
+                    let value = data[key];
+                    if (value instanceof Uint8Array && typeof Blob !== "undefined") {
+                        value = new Blob([value]);
+                        formData.append(key, value);
+                    }
+                    else {
+                        formData.append(key, Buffer.from(value), {
+                            filename: "cipher.bin"
+                        });
+                    }
+                }
+                else {
+                    formData.append(key, data[key]);
+                }
+            }
+        }
+        const conf = lodash_1.default.defaultsDeep({}, config, this.requestConfig);
+        let sendData = formData;
+        if (typeof formData.getHeaders !== "undefined") {
+            const h = formData.getHeaders();
+            conf["headers"] = conf["headers"] || {};
+            for (const key in h) {
+                conf["headers"][key] = h[key];
+            }
+            sendData = formData.getBuffer();
+        }
+        if (this.logRequest()) {
+            const anyThis = this;
+            if (anyThis._username) {
+                this._logger.trace(`Request ${id} by ${anyThis._username}: POST-Upload ${path}`);
+            }
+            else {
+                this._logger.trace(`Request ${id}: POST-Upload ${path}`);
+            }
+        }
+        try {
+            const response = await this.createAxios().post(path, sendData, conf);
+            return this.getResult("POST-Upload", path, response, id);
+        }
+        catch (e) {
+            const err = RequestError_1.RequestError.fromAxiosError("POST-Upload", path, e, id);
+            this._logger.debug(err);
+            return ClientResult_1.ClientResult.fail(err);
+        }
+    }
+    async put(path, data, config) {
+        const id = await this.generateRequestId();
+        const conf = lodash_1.default.defaultsDeep({}, config, this.requestConfig);
+        if (this.logRequest()) {
+            const anyThis = this;
+            if (anyThis._username) {
+                this._logger.trace(`Request ${id} by ${anyThis._username}: PUT ${path}`, data);
+            }
+            else {
+                this._logger.trace(`Request ${id}: PUT ${path}`, data);
+            }
+        }
+        try {
+            const response = await this.createAxios().put(path, data, conf);
+            return this.getResult("PUT", path, response, id);
+        }
+        catch (e) {
+            const err = RequestError_1.RequestError.fromAxiosError("PUT", path, e, id);
+            this._logger.debug(err);
+            return ClientResult_1.ClientResult.fail(err);
+        }
+    }
+    async delete(path, config) {
+        const id = await this.generateRequestId();
+        const conf = lodash_1.default.defaultsDeep({}, config, this.requestConfig);
+        if (this.logRequest()) {
+            const anyThis = this;
+            if (anyThis._username) {
+                this._logger.trace(`Request ${id} by ${anyThis._username}: DELETE ${path}`);
+            }
+            else {
+                this._logger.trace(`Request ${id}: DELETE ${path}`);
+            }
+        }
+        try {
+            const response = await this.createAxios().delete(path, conf);
+            return this.getResult("DELETE", path, response, id);
+        }
+        catch (e) {
+            const err = RequestError_1.RequestError.fromAxiosError("DELETE", path, e, id);
+            this._logger.debug(err);
+            return ClientResult_1.ClientResult.fail(err);
+        }
+    }
+    async download(path, config) {
+        const id = await this.generateRequestId();
+        const conf = lodash_1.default.defaultsDeep({}, config, this.requestConfig);
+        conf.responseType = "arraybuffer";
+        if (this.logRequest()) {
+            const anyThis = this;
+            if (anyThis._username) {
+                this._logger.trace(`Request ${id} by ${anyThis._username}: GET-Download ${path}`);
+            }
+            else {
+                this._logger.trace(`Request ${id}: GET-Download ${path}`);
+            }
+        }
+        try {
+            const response = await this.createAxios().get(path, conf);
+            return this.getResult("GET-Download", path, response, id);
+        }
+        catch (e) {
+            const err = RequestError_1.RequestError.fromAxiosError("GET-Download", path, e, id);
+            this._logger.debug(err);
+            return ClientResult_1.ClientResult.fail(err);
+        }
+    }
+}
+exports.RESTClient = RESTClient;
+//# sourceMappingURL=RESTClient.js.map