@zcatalyst/transport 0.0.1 → 0.0.2

package/dist-es/utils/clonable-stream.js

@@ -0,0 +1,105 @@
+'use strict';
+import { nextTick } from 'process';
+import { PassThrough } from 'stream';
+function clonePiped(that) {
+    if (--that._clonesCount === 0 && !that.destroyed) {
+        that._original?.pipe(that);
+        that._original = undefined;
+    }
+}
+function _destroy(error, callback) {
+    if (!error) {
+        this.push(null);
+        this.end();
+    }
+    nextTick(callback, error);
+}
+function forwardDestroy(src, dest) {
+    function destroy(err) {
+        src.removeListener('close', onClose);
+        dest.destroy(err);
+    }
+    function onClose() {
+        dest.end();
+    }
+    src.on('error', destroy);
+    src.on('close', onClose);
+}
+class StreamClone extends PassThrough {
+    constructor(parent) {
+        super({ objectMode: parent.readableObjectMode });
+        this.parent = parent;
+        forwardDestroy(parent, this);
+        parent._internalPipe = true;
+        parent.pipe(this);
+        parent._internalPipe = false;
+        this.on('newListener', this.onDataClone);
+        this.once('resume', this.onResumeClone);
+    }
+    onDataClone(event, _listener) {
+        if (event === 'data' || event === 'readable' || event === 'close') {
+            nextTick(clonePiped, this.parent);
+            this.removeListener('newListener', this.onDataClone);
+            this.removeListener('resume', this.onResumeClone);
+        }
+    }
+    onResumeClone() {
+        this.removeListener('newListener', this.onDataClone);
+        this.removeListener('resume', this.onResumeClone);
+        nextTick(clonePiped, this.parent);
+    }
+    clone() {
+        return this.parent.clone();
+    }
+    isCloneable(stream) {
+        return stream instanceof CloneableStream || stream instanceof StreamClone;
+    }
+}
+export default class CloneableStream extends PassThrough {
+    constructor(stream) {
+        super({ objectMode: stream.readableObjectMode });
+        this._original = stream;
+        this._clonesCount = 1;
+        this._internalPipe = false;
+        forwardDestroy(stream, this);
+        this.on('newListener', this.onData);
+        this.on('resume', this.onResume);
+        this._hasListener = true;
+        this._destroy = _destroy;
+    }
+    onData(event, _listener) {
+        if (event === 'data' || event === 'readable') {
+            this._hasListener = false;
+            this.removeListener('newListener', this.onData);
+            this.removeListener('resume', this.onResume);
+            nextTick(clonePiped, this);
+        }
+    }
+    onResume() {
+        this._hasListener = false;
+        this.removeListener('newListener', this.onData);
+        this.removeListener('resume', this.onResume);
+        nextTick(clonePiped, this);
+    }
+    resume() {
+        if (this._internalPipe) {
+            return this;
+        }
+        PassThrough.prototype.resume.call(this);
+        return this;
+    }
+    clone() {
+        if (!this._original) {
+            throw new Error('already started');
+        }
+        this._clonesCount++;
+        this.removeListener('newListener', this.onData);
+        this.removeListener('resume', this.onResume);
+        const clone = new StreamClone(this);
+        if (this._hasListener) {
+            this.on('newListener', this.onData);
+            this.on('resume', this.onResume);
+        }
+        return clone;
+    }
+}

package/dist-es/utils/constants.js

@@ -0,0 +1,52 @@
+export const HTTP_CODE_MAP = {
+    OK: {
+        CODE: 200,
+        TEXT: 'OK'
+    },
+    NO_CONTENT: {
+        CODE: 204,
+        TEXT: 'NO CONTENT'
+    },
+    INTERNAL_SERVER_ERROR: {
+        CODE: 500,
+        TEXT: 'INTERNAL SERVER ERROR'
+    },
+    RESOURCE_NOT_FOUND: {
+        CODE: 404,
+        TEXT: 'RESOURCE NOT FOUND'
+    },
+    BAD_REQUEST: {
+        CODE: 400,
+        TEXT: 'BAD REQUEST'
+    },
+    UNAUTHORIZED: {
+        CODE: 401,
+        TEXT: 'UNAUTHORIZED'
+    },
+    CONFLICT: {
+        CODE: 409,
+        TEXT: 'CONFLICT, MAY BE YOU ARE TRYING TO CREATE A RESOURCE THAT ALREADY EXIST!'
+    },
+    FORBIDDEN: {
+        CODE: 403,
+        TEXT: 'FORBIDDEN, MAY BE YOUR USAGE REACHED MAX ALLOWED LIMIT!'
+    },
+    UNEXPECTED: {
+        CODE: 101,
+        TEXT: 'UNEXPECTED RESPONSE FOUND'
+    }
+};
+export const HTTP_HEADER_MAP = {
+    CONTENT_JSON: 'application/json; charset=utf-8',
+    AUTHORIZATION_KEY: 'Authorization'
+};
+export const REQUEST_PROPERTY = {
+    BLOB: 'blob'
+};
+export const X_ZCSRF_TOKEN = 'X-ZCSRF-TOKEN';
+export const ZD_CSRPARAM = 'zd_csrparam';
+const HTTP_CODE_REV_MAP = {};
+const HTTP_CODE_MAP_KEYS = Object.keys(HTTP_CODE_MAP);
+for (const KEY of HTTP_CODE_MAP_KEYS)
+    HTTP_CODE_REV_MAP[HTTP_CODE_MAP[KEY].CODE] = HTTP_CODE_MAP[KEY];
+export { HTTP_CODE_REV_MAP };

package/dist-es/utils/enums.js

@@ -0,0 +1,19 @@
+export var ResponseType;
+(function (ResponseType) {
+    ResponseType["RAW"] = "raw";
+    ResponseType["JSON"] = "json";
+    ResponseType["STRING"] = "string";
+    ResponseType["BUFFER"] = "buffer";
+})(ResponseType || (ResponseType = {}));
+export var RequestType;
+(function (RequestType) {
+    RequestType["FILE"] = "file";
+    RequestType["JSON"] = "json";
+    RequestType["URL_ENCODED"] = "url_encoded";
+    RequestType["RAW"] = "raw";
+})(RequestType || (RequestType = {}));
+export var FormDataKeys;
+(function (FormDataKeys) {
+    FormDataKeys["CODE"] = "code";
+    FormDataKeys["FILE_NAME"] = "file_name";
+})(FormDataKeys || (FormDataKeys = {}));

package/dist-es/utils/errors.js

@@ -0,0 +1,6 @@
+import { PrefixedCatalystError } from '@zcatalyst/utils';
+export class CatalystAPIError extends PrefixedCatalystError {
+    constructor(code, message, value, statusCode) {
+        super('app', code, message, value, statusCode);
+    }
+}

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

@@ -0,0 +1,213 @@
+'use strict';
+import { basename } from 'path';
+import { Readable, Stream } from 'stream';
+import { inspect } from 'util';
+import CloneableStream from './clonable-stream';
+class FormData extends 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 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 (value['name'] || value['path']) {
+            filename = basename(value['name'] || value['path']);
+        }
+        else if (value['readable'] && value.hasOwnProperty('httpVersion')) {
+            filename = basename(value['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 CloneableStream(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 = 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.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';
+export default FormData;

package/dist-es/utils/helpers.js

@@ -0,0 +1,7 @@
+export function isHttps(url) {
+    if (url === undefined) {
+        return false;
+    }
+    const parsedUrl = url instanceof URL ? url : new URL(url);
+    return parsedUrl.protocol === 'https:';
+}

package/dist-es/utils/interfaces.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,20 @@
+'use strict';
+import { CONSTANTS } from '@zcatalyst/utils';
+import { Agent as httpAgent } from 'http';
+import { Agent as httpsAgent } from 'https';
+const agentMap = {};
+export default class RequestAgent {
+    constructor(isHttps, host, replaceAgent) {
+        const protocol = isHttps ? CONSTANTS.PROTOCOL.HTTPS : CONSTANTS.PROTOCOL.HTTP;
+        if (agentMap[protocol] === undefined) {
+            agentMap[protocol] = {};
+        }
+        const protocolMap = agentMap[protocol];
+        if (protocolMap[host] === undefined || replaceAgent) {
+            protocolMap[host] = isHttps
+                ? new httpsAgent({ keepAlive: true })
+                : new httpAgent({ keepAlive: true });
+        }
+        this.agent = protocolMap[host];
+    }
+}

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

@@ -0,0 +1,11 @@
+export 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-types/fetch-handler.d.ts

@@ -0,0 +1,40 @@
+import { ConfigManager } from '@zcatalyst/auth-client';
+import { CoreType, IRequestConfig, jwtAccessTokenResponse, RequestHandlerOptions } from './utils/interfaces';
+export declare const keepAliveSupport: {
+    supported: undefined | boolean;
+};
+type ICatalystDataRes = Record<string, string> | string | Blob | ArrayBuffer | ReadableStreamDefaultReader<Uint8Array> | FormData;
+export interface ICatalystClientRes {
+    request: RequestInit;
+    statusCode?: number;
+    headers: HeadersInit;
+    data?: ICatalystDataRes;
+    buffer?: Buffer;
+    blob?: Blob;
+    config: RequestHandlerOptions;
+    stream?: ArrayBuffer;
+}
+export declare class DefaultHttpResponse {
+    statusCode: number;
+    headers: HeadersInit;
+    config: RequestHandlerOptions;
+    resp: ICatalystClientRes;
+    constructor(resp: ICatalystClientRes);
+    get data(): ICatalystDataRes;
+}
+export declare class ResponseHandler {
+    #private;
+    static configManager: ConfigManager;
+    constructor();
+    static fireGeneralRequest({ requestCore, url }: {
+        requestCore: RequestInit;
+        url: string;
+    }, requestOptions?: RequestHandlerOptions): Promise<DefaultHttpResponse | void>;
+    static wrapResponse(response: Response, options?: RequestHandlerOptions): Promise<DefaultHttpResponse>;
+    static fireRawRequest(requestCore: CoreType, reqOptions: RequestHandlerOptions): Promise<DefaultHttpResponse>;
+    static attachZCAuthHeaders(headers: HeadersInit): Promise<HeadersInit>;
+    static getJWTZCAuthToken(): Promise<jwtAccessTokenResponse>;
+    static appendQueryString(url: string, qs?: Record<string, string | number | boolean | undefined>): string;
+    static send(options: IRequestConfig): Promise<DefaultHttpResponse | void>;
+}
+export {};

package/dist-types/http-handler.d.ts

@@ -0,0 +1,39 @@
+import { CatalystApp } from '@zcatalyst/auth';
+import { ClientRequest, IncomingHttpHeaders, IncomingMessage } from 'http';
+import { Component, IRequestConfig } from './utils/interfaces';
+export interface IAPIResponse {
+    request: ClientRequest;
+    statusCode?: number;
+    headers: IncomingHttpHeaders;
+    data?: string;
+    buffer?: Buffer;
+    config: IRequestConfig;
+    stream?: IncomingMessage;
+}
+export declare class DefaultHttpResponse {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    config: IRequestConfig;
+    resp: IAPIResponse;
+    constructor(resp: IAPIResponse);
+    get data(): any;
+}
+export declare class HttpClient {
+    app?: CatalystApp;
+    private user;
+    /**
+     * @param {CatalystApp} app The app used to fetch access tokens to sign API requests.
+     * @constructor
+     */
+    constructor(app?: CatalystApp);
+    send(req: IRequestConfig, apmTrackerName?: string): Promise<DefaultHttpResponse>;
+}
+export declare class AuthorizedHttpClient extends HttpClient {
+    readonly componentName?: string;
+    /**
+     * @param {unknown} app The app used to fetch access tokens to sign API requests.
+     * @constructor
+     */
+    constructor(app?: CatalystApp, component?: Component);
+    send(request: IRequestConfig): Promise<DefaultHttpResponse>;
+}

package/dist-types/index.browser.d.ts

@@ -0,0 +1,13 @@
+import { ICatalystClientRes } from './fetch-handler';
+import { Component, IRequestConfig } from './utils/interfaces';
+export declare class Handler {
+    component?: Component;
+    /**
+     * @constructor
+     */
+    constructor(app?: unknown, component?: Component);
+    send(options: IRequestConfig): Promise<ICatalystClientRes>;
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';
+export { IRequestConfig };

package/dist-types/index.d.ts

@@ -0,0 +1,16 @@
+import { DefaultHttpResponse } from './http-handler';
+import FormData from './utils/form-data';
+import { Component, IRequestConfig } from './utils/interfaces';
+export declare class Handler {
+    component?: Component;
+    app?: any;
+    /**
+     * @param {unknown} app The app used to fetch access tokens to sign API requests.
+     * @constructor
+     */
+    constructor(app?: unknown, component?: Component);
+    send(options: IRequestConfig): Promise<DefaultHttpResponse>;
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';
+export { FormData, IRequestConfig };

package/dist-types/ts3.4/fetch-handler.d.ts

@@ -0,0 +1,40 @@
+import { ConfigManager } from '@zcatalyst/auth-client';
+import { CoreType, IRequestConfig, jwtAccessTokenResponse, RequestHandlerOptions } from './utils/interfaces';
+export declare const keepAliveSupport: {
+    supported: undefined | boolean;
+};
+type ICatalystDataRes = Record<string, string> | string | Blob | ArrayBuffer | ReadableStreamDefaultReader<Uint8Array> | FormData;
+export interface ICatalystClientRes {
+    request: RequestInit;
+    statusCode?: number;
+    headers: HeadersInit;
+    data?: ICatalystDataRes;
+    buffer?: Buffer;
+    blob?: Blob;
+    config: RequestHandlerOptions;
+    stream?: ArrayBuffer;
+}
+export declare class DefaultHttpResponse {
+    statusCode: number;
+    headers: HeadersInit;
+    config: RequestHandlerOptions;
+    resp: ICatalystClientRes;
+    constructor(resp: ICatalystClientRes);
+    readonly data: ICatalystDataRes;
+}
+export declare class ResponseHandler {
+    private "ResponseHandler.#private";
+    static configManager: ConfigManager;
+    constructor();
+    static fireGeneralRequest({ requestCore, url }: {
+        requestCore: RequestInit;
+        url: string;
+    }, requestOptions?: RequestHandlerOptions): Promise<DefaultHttpResponse | void>;
+    static wrapResponse(response: Response, options?: RequestHandlerOptions): Promise<DefaultHttpResponse>;
+    static fireRawRequest(requestCore: CoreType, reqOptions: RequestHandlerOptions): Promise<DefaultHttpResponse>;
+    static attachZCAuthHeaders(headers: HeadersInit): Promise<HeadersInit>;
+    static getJWTZCAuthToken(): Promise<jwtAccessTokenResponse>;
+    static appendQueryString(url: string, qs?: Record<string, string | number | boolean | undefined>): string;
+    static send(options: IRequestConfig): Promise<DefaultHttpResponse | void>;
+}
+export {};

package/dist-types/ts3.4/http-handler.d.ts

@@ -0,0 +1,39 @@
+import { CatalystApp } from '@zcatalyst/auth';
+import { ClientRequest, IncomingHttpHeaders, IncomingMessage } from 'http';
+import { Component, IRequestConfig } from './utils/interfaces';
+export interface IAPIResponse {
+    request: ClientRequest;
+    statusCode?: number;
+    headers: IncomingHttpHeaders;
+    data?: string;
+    buffer?: Buffer;
+    config: IRequestConfig;
+    stream?: IncomingMessage;
+}
+export declare class DefaultHttpResponse {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    config: IRequestConfig;
+    resp: IAPIResponse;
+    constructor(resp: IAPIResponse);
+    readonly data: any;
+}
+export declare class HttpClient {
+    app?: CatalystApp;
+    private user;
+    /**
+     * @param {CatalystApp} app The app used to fetch access tokens to sign API requests.
+     * @constructor
+     */
+    constructor(app?: CatalystApp);
+    send(req: IRequestConfig, apmTrackerName?: string): Promise<DefaultHttpResponse>;
+}
+export declare class AuthorizedHttpClient extends HttpClient {
+    readonly componentName?: string;
+    /**
+     * @param {unknown} app The app used to fetch access tokens to sign API requests.
+     * @constructor
+     */
+    constructor(app?: CatalystApp, component?: Component);
+    send(request: IRequestConfig): Promise<DefaultHttpResponse>;
+}

package/dist-types/ts3.4/index.browser.d.ts

@@ -0,0 +1,13 @@
+import { ICatalystClientRes } from './fetch-handler';
+import { Component, IRequestConfig } from './utils/interfaces';
+export declare class Handler {
+    component?: Component;
+    /**
+     * @constructor
+     */
+    constructor(app?: unknown, component?: Component);
+    send(options: IRequestConfig): Promise<ICatalystClientRes>;
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';
+export { IRequestConfig };

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,16 @@
+import { DefaultHttpResponse } from './http-handler';
+import FormData from './utils/form-data';
+import { Component, IRequestConfig } from './utils/interfaces';
+export declare class Handler {
+    component?: Component;
+    app?: any;
+    /**
+     * @param {unknown} app The app used to fetch access tokens to sign API requests.
+     * @constructor
+     */
+    constructor(app?: unknown, component?: Component);
+    send(options: IRequestConfig): Promise<DefaultHttpResponse>;
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';
+export { FormData, IRequestConfig };