@zcatalyst/transport 0.0.1 → 0.0.2

package/dist-cjs/index.js

@@ -0,0 +1,32 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormData = exports.CatalystAPIError = exports.ResponseType = exports.RequestType = exports.Handler = void 0;
+const auth_1 = require("@zcatalyst/auth");
+const http_handler_1 = require("./http-handler");
+const form_data_1 = __importDefault(require("./utils/form-data"));
+exports.FormData = form_data_1.default;
+class Handler {
+    constructor(app, component) {
+        if (!app) {
+            app = new auth_1.ZCAuth().getDefaultCredentials();
+        }
+        if (!(app instanceof auth_1.CatalystApp)) {
+            throw new auth_1.CatalystAppError('INVALID_PROJECT_CREDENTIALS', 'Unable to process the project credentials. Please verify that the initialization is configured correctly.');
+        }
+        this.app = app;
+        this.component = component;
+    }
+    async send(options) {
+        const _httpRequester = new http_handler_1.AuthorizedHttpClient(this.app, this.component);
+        return (await _httpRequester.send(options));
+    }
+}
+exports.Handler = Handler;
+var enums_1 = require("./utils/enums");
+Object.defineProperty(exports, "RequestType", { enumerable: true, get: function () { return enums_1.RequestType; } });
+Object.defineProperty(exports, "ResponseType", { enumerable: true, get: function () { return enums_1.ResponseType; } });
+var errors_1 = require("./utils/errors");
+Object.defineProperty(exports, "CatalystAPIError", { enumerable: true, get: function () { return errors_1.CatalystAPIError; } });

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

@@ -0,0 +1,107 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_1 = require("process");
+const stream_1 = require("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();
+    }
+    (0, process_1.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 stream_1.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') {
+            (0, process_1.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);
+        (0, process_1.nextTick)(clonePiped, this.parent);
+    }
+    clone() {
+        return this.parent.clone();
+    }
+    isCloneable(stream) {
+        return stream instanceof CloneableStream || stream instanceof StreamClone;
+    }
+}
+class CloneableStream extends stream_1.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);
+            (0, process_1.nextTick)(clonePiped, this);
+        }
+    }
+    onResume() {
+        this._hasListener = false;
+        this.removeListener('newListener', this.onData);
+        this.removeListener('resume', this.onResume);
+        (0, process_1.nextTick)(clonePiped, this);
+    }
+    resume() {
+        if (this._internalPipe) {
+            return this;
+        }
+        stream_1.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;
+    }
+}
+exports.default = CloneableStream;

package/dist-cjs/utils/constants.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_CODE_REV_MAP = exports.ZD_CSRPARAM = exports.X_ZCSRF_TOKEN = exports.REQUEST_PROPERTY = exports.HTTP_HEADER_MAP = exports.HTTP_CODE_MAP = void 0;
+exports.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'
+    }
+};
+exports.HTTP_HEADER_MAP = {
+    CONTENT_JSON: 'application/json; charset=utf-8',
+    AUTHORIZATION_KEY: 'Authorization'
+};
+exports.REQUEST_PROPERTY = {
+    BLOB: 'blob'
+};
+exports.X_ZCSRF_TOKEN = 'X-ZCSRF-TOKEN';
+exports.ZD_CSRPARAM = 'zd_csrparam';
+const HTTP_CODE_REV_MAP = {};
+exports.HTTP_CODE_REV_MAP = HTTP_CODE_REV_MAP;
+const HTTP_CODE_MAP_KEYS = Object.keys(exports.HTTP_CODE_MAP);
+for (const KEY of HTTP_CODE_MAP_KEYS)
+    HTTP_CODE_REV_MAP[exports.HTTP_CODE_MAP[KEY].CODE] = exports.HTTP_CODE_MAP[KEY];

package/dist-cjs/utils/enums.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormDataKeys = exports.RequestType = exports.ResponseType = void 0;
+var ResponseType;
+(function (ResponseType) {
+    ResponseType["RAW"] = "raw";
+    ResponseType["JSON"] = "json";
+    ResponseType["STRING"] = "string";
+    ResponseType["BUFFER"] = "buffer";
+})(ResponseType || (exports.ResponseType = ResponseType = {}));
+var RequestType;
+(function (RequestType) {
+    RequestType["FILE"] = "file";
+    RequestType["JSON"] = "json";
+    RequestType["URL_ENCODED"] = "url_encoded";
+    RequestType["RAW"] = "raw";
+})(RequestType || (exports.RequestType = RequestType = {}));
+var FormDataKeys;
+(function (FormDataKeys) {
+    FormDataKeys["CODE"] = "code";
+    FormDataKeys["FILE_NAME"] = "file_name";
+})(FormDataKeys || (exports.FormDataKeys = FormDataKeys = {}));

package/dist-cjs/utils/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalystAPIError = void 0;
+const utils_1 = require("@zcatalyst/utils");
+class CatalystAPIError extends utils_1.PrefixedCatalystError {
+    constructor(code, message, value, statusCode) {
+        super('app', code, message, value, statusCode);
+    }
+}
+exports.CatalystAPIError = CatalystAPIError;

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

@@ -0,0 +1,217 @@
+'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 (value['name'] || value['path']) {
+            filename = (0, path_1.basename)(value['name'] || value['path']);
+        }
+        else if (value['readable'] && value.hasOwnProperty('httpVersion')) {
+            filename = (0, path_1.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 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);
+        }
+    });
+}