@zcatalyst/transport 0.0.1 → 0.0.3

package/dist-cjs/utils/form-data.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const stream_1 = require("stream");
+const util_1 = require("util");
+const clonable_stream_1 = __importDefault(require("./clonable-stream"));
+class FormData extends stream_1.Stream {
+    constructor(streams) {
+        super();
+        this.writable = false;
+        this.readable = true;
+        this.released = false;
+        this.streams = streams || [];
+        this.insideLoop = false;
+        this.pendingNext = false;
+    }
+    isStream(value) {
+        return (value !== undefined &&
+            value !== null &&
+            ((typeof value.on === 'function' &&
+                typeof value.pipe === 'function') ||
+                value instanceof stream_1.Readable));
+    }
+    _multiPartHeader(field, value) {
+        const contentDisposition = this._getContentDisposition(value);
+        const contentType = this._getContentType(value);
+        let contents = '';
+        const headers = {
+            'Content-Disposition': ['form-data', 'name="' + field + '"'].concat(contentDisposition || []),
+            'Content-Type': [contentType]
+        };
+        for (const prop in headers) {
+            if (headers[prop]) {
+                const header = headers[prop];
+                if (header.length > 0) {
+                    contents += prop + ': ' + header.join('; ') + FormData.LINE_BREAK;
+                }
+            }
+        }
+        return '--' + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
+    }
+    _getContentDisposition(value) {
+        let filename = '';
+        let contentDisposition = '';
+        if (typeof value === 'object' && value !== null && ('name' in value || 'path' in value)) {
+            const val = value;
+            filename = (0, path_1.basename)(val.name || val.path || '');
+        }
+        else if (typeof value === 'object' &&
+            value !== null &&
+            'readable' in value &&
+            'httpVersion' in value &&
+            'client' in value) {
+            const httpValue = value;
+            filename = (0, path_1.basename)(httpValue.client._httpMessage.path || '');
+        }
+        if (filename) {
+            contentDisposition = 'filename="' + filename + '"';
+        }
+        return contentDisposition;
+    }
+    _getContentType(value) {
+        let contentType = '';
+        if (value.readable && value.hasOwnProperty('httpVersion')) {
+            contentType = value.headers['content-type'];
+        }
+        if (!contentType) {
+            contentType = FormData.CONTENT_TYPE;
+        }
+        return contentType;
+    }
+    _lastBoundary() {
+        return '--' + this.getBoundary() + '--' + FormData.LINE_BREAK;
+    }
+    _generateBoundary() {
+        let boundary = '--------------------------';
+        for (let i = 0; i < 24; i++) {
+            boundary += Math.floor(Math.random() * 10).toString(16);
+        }
+        this.boundary = boundary;
+        return boundary;
+    }
+    _error(err) {
+        this._reset();
+        this.emit('error', err);
+    }
+    _handleStreamErrors(stream) {
+        stream.on('error', (err) => {
+            this._error(err);
+        });
+    }
+    _pipeNext(stream) {
+        this.currentStream = stream;
+        if (this.isStream(stream)) {
+            stream.on('end', this._getNext.bind(this));
+            stream.pipe(this, {
+                end: false
+            });
+            return;
+        }
+        const value = stream;
+        this.write(value);
+        this._getNext();
+    }
+    _getNext() {
+        this.currentStream = undefined;
+        if (this.insideLoop) {
+            this.pendingNext = true;
+            return;
+        }
+        this.insideLoop = true;
+        try {
+            do {
+                this.pendingNext = false;
+                const stream = this.streams.shift();
+                if (typeof stream === 'undefined') {
+                    this.end();
+                }
+                else {
+                    this._pipeNext(stream);
+                }
+            } while (this.pendingNext);
+        }
+        finally {
+            this.insideLoop = false;
+        }
+    }
+    _reset() {
+        this.writable = false;
+        this.streams = [];
+        this.currentStream = undefined;
+    }
+    createClone() {
+        const newStreams = [];
+        this.streams.forEach((stream) => {
+            const clone = this.isStream(stream)
+                ? new clonable_stream_1.default(stream).clone()
+                : stream;
+            newStreams.push(clone);
+        });
+        return new FormData(newStreams);
+    }
+    append(field, value) {
+        if (Array.isArray(value)) {
+            this._error(new Error('Arrays are not supported.'));
+            return this;
+        }
+        if (typeof value !== 'string' && !Buffer.isBuffer(value) && !this.isStream(value)) {
+            value = (0, util_1.inspect)(value);
+        }
+        if (this.isStream(value)) {
+            this._handleStreamErrors(value);
+        }
+        this.streams.push(this._multiPartHeader(field, value));
+        this.streams.push(value);
+        this.streams.push(FormData.LINE_BREAK);
+        return this;
+    }
+    getHeaders(userHeaders) {
+        const formHeaders = {};
+        for (const header in userHeaders) {
+            if (userHeaders[header]) {
+                formHeaders[header.toLowerCase()] = userHeaders[header];
+            }
+        }
+        formHeaders['content-type'] = 'multipart/form-data; boundary=' + this.getBoundary();
+        return formHeaders;
+    }
+    getBoundary() {
+        if (this.boundary === undefined) {
+            return this._generateBoundary();
+        }
+        return this.boundary;
+    }
+    pipe(dest, options) {
+        stream_1.Stream.prototype.pipe.call(this, dest, options);
+        this.resume();
+        return dest;
+    }
+    write(data) {
+        const lastPart = this.streams.length === 0;
+        this.emit('data', data);
+        if (lastPart) {
+            this.emit('data', this._lastBoundary());
+        }
+        return true;
+    }
+    pause() {
+        if (this.currentStream !== undefined &&
+            typeof this.currentStream.pause === 'function') {
+            this.currentStream.pause();
+        }
+        this.emit('pause');
+    }
+    resume() {
+        if (!this.released) {
+            this.released = true;
+            this.writable = true;
+            this._getNext();
+        }
+        if (this.currentStream && typeof this.currentStream.resume === 'function') {
+            this.currentStream.resume();
+        }
+        this.emit('resume');
+    }
+    end() {
+        this._reset();
+        this.emit('end');
+    }
+    destroy() {
+        this._reset();
+        this.emit('close');
+    }
+    toString() {
+        return '[object FormData]';
+    }
+}
+FormData.LINE_BREAK = '\r\n';
+FormData.CONTENT_TYPE = 'application/octet-stream';
+exports.default = FormData;

package/dist-cjs/utils/helpers.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttps = isHttps;
+function isHttps(url) {
+    if (url === undefined) {
+        return false;
+    }
+    const parsedUrl = url instanceof URL ? url : new URL(url);
+    return parsedUrl.protocol === 'https:';
+}

package/dist-cjs/utils/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/utils/request-agent.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@zcatalyst/utils");
+const http_1 = require("http");
+const https_1 = require("https");
+const agentMap = {};
+class RequestAgent {
+    constructor(isHttps, host, replaceAgent) {
+        const protocol = isHttps ? utils_1.CONSTANTS.PROTOCOL.HTTPS : utils_1.CONSTANTS.PROTOCOL.HTTP;
+        if (agentMap[protocol] === undefined) {
+            agentMap[protocol] = {};
+        }
+        const protocolMap = agentMap[protocol];
+        if (protocolMap[host] === undefined || replaceAgent) {
+            protocolMap[host] = isHttps
+                ? new https_1.Agent({ keepAlive: true })
+                : new http_1.Agent({ keepAlive: true });
+        }
+        this.agent = protocolMap[host];
+    }
+}
+exports.default = RequestAgent;

package/dist-cjs/utils/request-timeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestTimeout = requestTimeout;
+function requestTimeout(timeoutInMs = 0) {
+    return new Promise((resolve, reject) => {
+        if (timeoutInMs) {
+            setTimeout(() => {
+                const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
+                timeoutError.name = 'TimeoutError';
+                reject(timeoutError);
+            }, timeoutInMs);
+        }
+    });
+}

package/dist-es/fetch-handler.js

@@ -0,0 +1,261 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _ResponseHandler_attachAppSpecificHeaders, _ResponseHandler_followZcrfTokenProtocol, _ResponseHandler_followJwtZCAuthProtocol, _ResponseHandler_sendRequest;
+import { addDefaultAppHeaders, Auth_Protocol, collectZCRFToken, ConfigStore, getToken, JWT_COOKIE_PREFIX, PROJECT_ID } from '@zcatalyst/auth-client';
+import { CONSTANTS, getServicePath } from '@zcatalyst/utils';
+import pkg from '../package.json';
+const { version } = pkg;
+import { HTTP_HEADER_MAP as HEADER_MAP, HTTP_HEADER_MAP, X_ZCSRF_TOKEN, ZD_CSRPARAM } from './utils/constants';
+import { CatalystAPIError } from './utils/errors';
+import { requestTimeout } from './utils/request-timeout';
+const { REQ_METHOD } = CONSTANTS;
+export class DefaultHttpResponse {
+    constructor(resp) {
+        this.statusCode = resp.statusCode;
+        this.headers = resp.headers;
+        this.config = resp.config;
+        this.resp = resp;
+    }
+    get data() {
+        if (this.resp.data === undefined) {
+            throw new CatalystAPIError('UNPARSABLE_RESPONSE', `Error while processing response data. Raw server ` +
+                `response: "${this.resp.data}". `, '', this.statusCode);
+        }
+        return this.resp.data;
+    }
+}
+export class ResponseHandler {
+    constructor() { }
+    static async fireGeneralRequest({ requestCore, url }, requestOptions = {}) {
+        try {
+            const headers = requestCore.headers || {};
+            const method = requestCore.method;
+            const methodAllowsBody = method !== REQ_METHOD.get && method !== REQ_METHOD.head;
+            const options = {
+                method,
+                headers,
+                credentials: requestOptions.auth ? 'include' : 'omit',
+                body: methodAllowsBody ? requestCore.body : undefined
+            };
+            const isExternal = requestOptions.service === "external";
+            if (requestOptions.auth && !isExternal) {
+                options.headers = await _a.attachZCAuthHeaders(headers);
+                options.headers = __classPrivateFieldGet(this, _a, "m", _ResponseHandler_attachAppSpecificHeaders).call(this, headers);
+            }
+            const controller = new AbortController();
+            if (requestOptions.abortSignal) {
+                requestOptions.abortSignal.addEventListener('abort', () => controller.abort());
+            }
+            options.signal = controller.signal;
+            const response = await Promise.race([
+                fetch(url, options),
+                requestTimeout(requestOptions?.requestTimeout)
+            ]);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => null);
+                throw new CatalystAPIError(`HTTP_ERROR_${response.status}`, errorData?.message || response.statusText, errorData, response.status);
+            }
+            if (requestOptions.retry && requestOptions.retry > 0) {
+                try {
+                    return await _a.wrapResponse(response, {
+                        ...requestOptions,
+                        request: requestCore
+                    });
+                }
+                catch {
+                    requestOptions.retry--;
+                    return this.fireGeneralRequest({ requestCore, url }, requestOptions);
+                }
+            }
+            return await _a.wrapResponse(response, {
+                ...requestOptions,
+                request: requestCore
+            });
+        }
+        catch (error) {
+            if (error instanceof CatalystAPIError) {
+                throw error;
+            }
+            if (error.name === 'AbortError') {
+                throw new CatalystAPIError('REQUEST_ABORTED', 'The request was aborted', error);
+            }
+            if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
+                throw new CatalystAPIError('NETWORK_ERROR', 'Network error occurred while making the request', error);
+            }
+            throw new CatalystAPIError('REQUEST_FAILED', error.message || 'Request failed', error, error.statusCode);
+        }
+    }
+    static async wrapResponse(response, options) {
+        try {
+            const method = options?.request?.method?.toUpperCase();
+            const hasNoBody = method === REQ_METHOD.head || response.status === 204 || response.status === 304;
+            let data;
+            if (hasNoBody) {
+                data = '';
+            }
+            else {
+                switch (options?.expecting || "json") {
+                    case "buffer":
+                        data = await response.arrayBuffer();
+                        break;
+                    case "raw":
+                        data = await response.blob();
+                        break;
+                    case "json":
+                        data = await response.json();
+                        break;
+                    case "string":
+                        data = await response.text();
+                        break;
+                    default:
+                        throw new CatalystAPIError('UNSUPPORTED_RESPONSE_TYPE', `Unsupported response type: ${options?.expecting}`);
+                }
+            }
+            return new DefaultHttpResponse({
+                headers: response.headers,
+                statusCode: response.status,
+                data,
+                request: options?.request || {},
+                config: options || {}
+            });
+        }
+        catch (error) {
+            throw new CatalystAPIError('RESPONSE_PARSE_ERROR', 'Failed to parse response data', error);
+        }
+    }
+    static async fireRawRequest(requestCore, reqOptions) {
+        let headers = requestCore.headers;
+        if (reqOptions.auth) {
+            headers = await _a.attachZCAuthHeaders(headers);
+            headers = __classPrivateFieldGet(this, _a, "m", _ResponseHandler_attachAppSpecificHeaders).call(this, headers);
+            headers = { ...headers, credentials: 'include' };
+        }
+        const options = {
+            method: requestCore.method,
+            headers
+        };
+        if (requestCore.method !== REQ_METHOD.get && requestCore.body !== null)
+            options.body = requestCore.body;
+        const url = this.apiDomain ? `${this.apiDomain}${requestCore.url}` : requestCore.url;
+        return await this.wrapResponse(await fetch(url, options));
+    }
+    static async attachZCAuthHeaders(headers) {
+        const authProtocol = ConfigStore.get('AUTH_PROTOCOL');
+        switch (authProtocol) {
+            case Auth_Protocol.ZcrfTokenProtocol:
+                return await __classPrivateFieldGet(_a, _a, "m", _ResponseHandler_followZcrfTokenProtocol).call(_a, headers);
+            case Auth_Protocol.JwtTokenProtocol:
+                return await __classPrivateFieldGet(_a, _a, "m", _ResponseHandler_followJwtZCAuthProtocol).call(_a, headers);
+            default:
+                return Promise.resolve(headers);
+        }
+    }
+    static getJWTZCAuthToken() {
+        const jwtPrefix = ConfigStore.get(JWT_COOKIE_PREFIX);
+        return new Promise((resolve, reject) => {
+            const jwtZCAuthToken = getToken();
+            if (jwtZCAuthToken === '') {
+                reject('Unable to get the JWT Access Token.');
+            }
+            else {
+                resolve({
+                    access_token: `${jwtPrefix} ${jwtZCAuthToken}`
+                });
+            }
+        });
+    }
+    static appendQueryString(url, qs) {
+        if (!qs || Object.keys(qs).length === 0) {
+            return url;
+        }
+        const searchParams = new URLSearchParams();
+        Object.entries(qs)
+            .filter(([_, value]) => value != null)
+            .forEach(([key, value]) => searchParams.append(key, String(value)));
+        const baseUrl = url.split('?')[0];
+        const existingParams = url.split('?')[1] || '';
+        return `${baseUrl}?${existingParams ? `${existingParams}&` : ''}${searchParams.toString()}`;
+    }
+    static async send(options, componentName, componentVersion) {
+        const headers = options.headers || {};
+        const isExternal = options.service === "external";
+        if (!isExternal) {
+            let userAgent = CONSTANTS.USER_AGENT.PREFIX + version;
+            if (componentName) {
+                userAgent += ` ${componentName}/${componentVersion || 'unknown'}`;
+            }
+            headers['X-Catalyst-User-Agent'] = userAgent;
+        }
+        let data = options.data;
+        if (data !== undefined) {
+            switch (options.type) {
+                case "json":
+                    data = JSON.stringify(data);
+                    headers['Content-Type'] = HEADER_MAP.CONTENT_JSON;
+                    break;
+                case "file":
+                    const formData = new FormData();
+                    const keyData = Object.keys(data);
+                    keyData.forEach((key) => {
+                        formData.append(key, data[key]);
+                    });
+                    data = formData;
+                    break;
+                case "raw":
+                    if (headers['Content-Type'] === undefined) {
+                        headers['Content-Type'] = 'application/octet-stream';
+                    }
+                    data = new Blob([data], { type: headers['Content-Type'] });
+                    break;
+                default:
+                    data = JSON.stringify(data);
+                    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+            }
+        }
+        if (this.apiDomain === null && !options.origin) {
+            throw new CatalystAPIError('API_REQUEST_ERROR', 'Unable to get the base url');
+        }
+        if (!isExternal && options.path) {
+            options.path = `${getServicePath(options.service)}/project/${ConfigStore.get(PROJECT_ID)}${options.path}`;
+        }
+        const request = {
+            url: options.url ?? `${options.origin ?? this.apiDomain}${options.path}`,
+            method: options.method,
+            ...(data ? { body: data } : {}),
+            headers
+        };
+        request.url = this.appendQueryString(request.url, options.qs);
+        return await __classPrivateFieldGet(this, _a, "m", _ResponseHandler_sendRequest).call(this, request, {
+            expecting: options.expecting,
+            auth: options.auth ?? true,
+            service: options.service
+        });
+    }
+}
+_a = ResponseHandler, _ResponseHandler_attachAppSpecificHeaders = function _ResponseHandler_attachAppSpecificHeaders(headers) {
+    let normalizedHeaders = headers;
+    normalizedHeaders = addDefaultAppHeaders(normalizedHeaders);
+    return normalizedHeaders;
+}, _ResponseHandler_followZcrfTokenProtocol = async function _ResponseHandler_followZcrfTokenProtocol(headers) {
+    await collectZCRFToken();
+    const csrfToken = ConfigStore.get('CSRF_TOKEN');
+    headers[X_ZCSRF_TOKEN] = `${ZD_CSRPARAM}=${csrfToken}`;
+    return headers;
+}, _ResponseHandler_followJwtZCAuthProtocol = async function _ResponseHandler_followJwtZCAuthProtocol(headers) {
+    return this.getJWTZCAuthToken()
+        .then((resp) => {
+        headers[HTTP_HEADER_MAP.AUTHORIZATION_KEY] =
+            resp.access_token;
+        return headers;
+    })
+        .catch((err) => {
+        throw new CatalystAPIError('API_ERROR', err.message, err.status);
+    });
+}, _ResponseHandler_sendRequest = async function _ResponseHandler_sendRequest(request, options) {
+    const { url, ...requestCore } = request;
+    return _a.fireGeneralRequest({ url, requestCore }, options);
+};
+ResponseHandler.apiDomain = typeof document !== 'undefined' ? document.location.origin : '';