@zcatalyst/transport 0.0.1 → 0.0.3

package/dist-cjs/http-handler.js

@@ -0,0 +1,404 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizedHttpClient = exports.HttpClient = exports.DefaultHttpResponse = void 0;
+const auth_admin_1 = require("@zcatalyst/auth-admin");
+const utils_1 = require("@zcatalyst/utils");
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const web_1 = require("node:stream/web");
+const querystring_1 = require("querystring");
+const stream_1 = require("stream");
+const url_1 = require("url");
+const util_1 = require("util");
+const package_json_1 = __importDefault(require("../package.json"));
+const { version } = package_json_1.default;
+const errors_1 = require("./utils/errors");
+const form_data_1 = __importDefault(require("./utils/form-data"));
+const helpers_1 = require("./utils/helpers");
+const request_agent_1 = __importDefault(require("./utils/request-agent"));
+const { IS_LOCAL, USER_KEY_NAME, CREDENTIAL_USER, CATALYST_ORIGIN, USER_AGENT, APM_INSIGHT, ACCEPT_HEADER, REQ_RETRY_THRESHOLD, IS_APM } = utils_1.CONSTANTS;
+class DefaultHttpResponse {
+    constructor(resp) {
+        this.statusCode = resp.statusCode;
+        this.headers = resp.headers;
+        this.config = resp.config;
+        this.resp = resp;
+    }
+    get data() {
+        switch (this.config.expecting) {
+            case "string":
+                if (this.resp.data === undefined) {
+                    throw new errors_1.CatalystAPIError('UNPARSABLE_RESPONSE', `Error while processing response data. Raw server ` +
+                        `response: "${this.resp.data}". Status code: "${this.statusCode}".`, '', this.statusCode);
+                }
+                return this.resp.data;
+            case "buffer":
+                if (this.resp.buffer === undefined) {
+                    throw new errors_1.CatalystAPIError('UNPARSABLE_RESPONSE', `Error while processing response buffer. Raw server ` +
+                        `response: "${this.resp.data}". Status code: "${this.statusCode}".`, '', this.statusCode);
+                }
+                return this.resp.buffer;
+            case "raw":
+                return this.resp.stream;
+            default:
+                try {
+                    return JSON.parse(this.resp.data);
+                }
+                catch (e) {
+                    throw new errors_1.CatalystAPIError('UNPARSABLE_RESPONSE', `Error while parsing response data: "${(0, util_1.inspect)(e)}". Raw server ` +
+                        `response: "${this.resp.data}". Status code: "${this.statusCode}".`, '', this.statusCode);
+                }
+        }
+    }
+}
+exports.DefaultHttpResponse = DefaultHttpResponse;
+function rejectWithContext(reject, statusCode, data) {
+    try {
+        const catalystError = JSON.parse(data);
+        reject({
+            statusCode,
+            code: catalystError.data.error_code,
+            message: catalystError.data.message
+        });
+        return;
+    }
+    catch {
+        reject({
+            statusCode,
+            message: (0, util_1.inspect)(data)
+        });
+    }
+}
+async function streamToBuffer(stream) {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream.destroyed && reject('Invalid response stream');
+        stream.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        stream.on('error', reject);
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+}
+function constructFormData(data) {
+    const formData = new form_data_1.default();
+    const keyData = Object.keys(data);
+    keyData.forEach((key) => {
+        formData.append(key, data[key]);
+    });
+    return formData;
+}
+async function _finalizeRequest(resolve, reject, response) {
+    if (response.statusCode === undefined) {
+        reject(new errors_1.CatalystAPIError('UNKNOWN_STATUSCODE', 'unable to obtain status code from response', response));
+        return;
+    }
+    if (response.statusCode >= 200 && response.statusCode < 300) {
+        resolve(response);
+        return;
+    }
+    if (response.stream?.pipe === undefined) {
+        rejectWithContext(reject, response.statusCode, response.data);
+        return;
+    }
+    try {
+        if (response.stream !== undefined && response.data === undefined) {
+            const responseBuffer = await streamToBuffer(response.stream);
+            response.data = responseBuffer.toString();
+        }
+        if (response.statusCode === 404) {
+            rejectWithContext(reject, response.statusCode, response.data || 'Not Found');
+        }
+        else if (response.statusCode === 403) {
+            rejectWithContext(reject, response.statusCode, response.data || 'Access Denied');
+        }
+        else if (response.statusCode === 401) {
+            rejectWithContext(reject, response.statusCode, response.data || 'Unauthorized');
+        }
+        else {
+            rejectWithContext(reject, response.statusCode, response.data || 'Unknown response');
+        }
+    }
+    catch (e) {
+        const errMsg = e instanceof Error ? e.message : (0, util_1.inspect)(e);
+        rejectWithContext(reject, response.statusCode, errMsg);
+    }
+}
+function _appendQueryData(url, data) {
+    if (data && Object.keys(data).length > 0) {
+        url += url.includes('?') ? '&' : '?';
+        url += (0, querystring_1.stringify)(data);
+    }
+    return url;
+}
+async function _request(transport, options, config, data, retryCount = 0) {
+    const clonedData = data === undefined
+        ? undefined
+        : config.type !== "file"
+            ?
+                data
+            :
+                data.createClone();
+    return new Promise(async (resolve, reject) => {
+        const retryRequest = async (err) => {
+            utils_1.LOGGER.warn('>>> RETRYING REQUEST ');
+            if (retryCount++ === REQ_RETRY_THRESHOLD) {
+                reject(err);
+                return;
+            }
+            try {
+                options.agent = new request_agent_1.default((0, helpers_1.isHttps)(config.url), options.hostname, true).agent;
+                const resp = await _request(transport, options, config, clonedData, retryCount);
+                resolve(resp);
+            }
+            catch (e) {
+                reject(e);
+            }
+        };
+        const startTimeStamp = Date.now();
+        const req = transport.request(options, async (res) => {
+            if (req.destroyed) {
+                return;
+            }
+            const response = {
+                headers: res.headers,
+                request: req,
+                stream: res,
+                statusCode: res.statusCode,
+                config
+            };
+            utils_1.LOGGER.debug(`>>> HTTP REQUEST : ${req.method?.toUpperCase()} ${req.protocol}//${req.host}${req.path}`);
+            process.env.ZC_SECURE?.toLowerCase() === 'override' &&
+                utils_1.LOGGER.fine(`>>> REQUEST HEADERS : ${JSON.stringify(options.headers)}`);
+            utils_1.LOGGER.debug(`<<< HTTP RESPONSE : ${res.statusCode} : ${Date.now() - startTimeStamp} ms`);
+            process.env.ZC_SECURE?.toLowerCase() === 'override' &&
+                utils_1.LOGGER.fine(`<<< RESPONSE HEADERS : ${JSON.stringify(res.headers)}`);
+            if (config.expecting === "raw") {
+                return _finalizeRequest(resolve, reject, response);
+            }
+            try {
+                const responseBuffer = await streamToBuffer(res);
+                response.data = responseBuffer.toString();
+                response.buffer = responseBuffer;
+            }
+            catch (err) {
+                if (req.destroyed || (config.abortSignal && config.abortSignal.aborted)) {
+                    req.destroy();
+                    return;
+                }
+                reject(err);
+            }
+            _finalizeRequest(resolve, reject, response);
+        });
+        req.on('error', (err) => {
+            utils_1.LOGGER.debug(`>>> HTTP REQUEST : ${req.method?.toUpperCase()} ${req.protocol}//${req.host}${req.path}`);
+            process.env.ZC_SECURE?.toLowerCase() === 'override' &&
+                utils_1.LOGGER.fine(`>>> REQUEST HEADERS : ${JSON.stringify(options.headers)}`);
+            utils_1.LOGGER.debug(`<<< HTTP REQUEST ERROR : ${(0, util_1.inspect)(err)} : ${Date.now() - startTimeStamp} ms`);
+            if (req.destroyed || config.type === "raw") {
+                return reject(err);
+            }
+            retryRequest(err);
+        });
+        if (data === undefined) {
+            req.end();
+            return;
+        }
+        if (config.type !== "file" && config.type !== "raw") {
+            req.write(data);
+            req.end();
+            return;
+        }
+        if (data instanceof web_1.ReadableStream) {
+            data = webStreamToNodeStream(data);
+        }
+        if (typeof data === 'string' || Buffer.isBuffer(data)) {
+            req.write(data);
+            req.end();
+            return;
+        }
+        data.on('error', (er) => {
+            reject(er);
+            req.end();
+        });
+        data.pipe(req).on('finish', req.end);
+    });
+}
+function webStreamToNodeStream(webStream) {
+    const reader = webStream.getReader();
+    return new stream_1.Readable({
+        async read() {
+            const { done, value } = await reader.read();
+            if (done) {
+                this.push(null);
+            }
+            else {
+                this.push(value);
+            }
+        }
+    });
+}
+async function sendRequest(config, componentName, componentVersion) {
+    let data;
+    let userAgent = USER_AGENT.PREFIX + version;
+    if (componentName) {
+        userAgent += ` ${componentName}/${componentVersion || 'unknown'}`;
+    }
+    let headers = Object.assign({
+        [USER_AGENT.KEY]: userAgent
+    }, config.headers);
+    if (config.data !== undefined) {
+        switch (config.type) {
+            case "json":
+                data = JSON.stringify(config.data);
+                headers['Content-Type'] = 'application/json';
+                break;
+            case "file":
+                data = constructFormData(config.data);
+                headers = data.getHeaders(headers);
+                break;
+            case "raw":
+                data = config.data;
+                if (headers['Content-Type'] === undefined) {
+                    headers['Content-Type'] = 'application/octet-stream';
+                }
+                break;
+            default:
+                data = (0, querystring_1.stringify)(config.data);
+                headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                headers['Content-Length'] = Buffer.byteLength(data) + '';
+        }
+    }
+    const origin = config.origin || CATALYST_ORIGIN;
+    config.url = config.url || new url_1.URL(config.path || '', origin).href;
+    if (config.qs !== undefined) {
+        config.url = _appendQueryData(config.url, config.qs);
+    }
+    const parsedUrl = new url_1.URL(config.url);
+    if (parsedUrl.hostname === null) {
+        throw new errors_1.CatalystAPIError('UNPARSABLE_CONFIG', 'Hostname cannot be null', config.path, 400);
+    }
+    const isHttpsProtocol = (0, helpers_1.isHttps)(parsedUrl);
+    const requestAgent = new request_agent_1.default(isHttpsProtocol, parsedUrl.hostname, false);
+    parsedUrl.searchParams?.sort();
+    const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: config.method,
+        headers,
+        agent: requestAgent.agent
+    };
+    const transport = isHttpsProtocol ? https_1.default : http_1.default;
+    return _request(transport, options, config, data);
+}
+class HttpClient {
+    constructor(app) {
+        this.app = app;
+    }
+    async send(req, apmTrackerName, componentVersion) {
+        req.headers = Object.assign({}, req.headers);
+        req.qs = Object.assign({}, req.qs);
+        req.retry = req.retry || true;
+        if (this.app !== undefined && req.service !== "external") {
+            const user = this.app.credential.getCurrentUser();
+            req.headers = (0, auth_admin_1.addDefaultAppHeaders)(req.headers, this.app.config);
+            req.headers[USER_KEY_NAME] = this.app.credential.getCurrentUserType();
+            if (IS_LOCAL === 'true') {
+                switch (user) {
+                    case CREDENTIAL_USER.admin:
+                        req.origin =
+                            'https://' +
+                                CATALYST_ORIGIN.replace('https://', '').replace('http://', '');
+                        break;
+                    case CREDENTIAL_USER.user:
+                        req.origin = 'https://' + this.app.config.projectDomain;
+                        break;
+                }
+            }
+            if (req.service === "baas") {
+                req.headers[ACCEPT_HEADER.KEY] =
+                    ACCEPT_HEADER.VALUE + ', ' + (req.headers[ACCEPT_HEADER.KEY] || '');
+            }
+            req.path =
+                (0, utils_1.getServicePath)(req.service) + `/project/${this.app.config.projectId}` + req.path;
+        }
+        try {
+            let resp;
+            if (req.track && apmTrackerName && IS_APM === 'true') {
+                try {
+                    const apminsight = await Promise.resolve().then(() => __importStar(require('apminsight')));
+                    resp = await apminsight.startTracker(APM_INSIGHT.tracker_name, apmTrackerName, () => sendRequest(req, apmTrackerName, componentVersion));
+                }
+                catch (err) {
+                    throw new errors_1.CatalystAPIError('APM_TRACKER_ERROR', 'To enable APM tracking locally, please download the apminsight package from the UI and place it in the node_modules directory of your project.', err, 400);
+                }
+            }
+            else {
+                resp = await sendRequest(req, apmTrackerName, componentVersion);
+            }
+            return new DefaultHttpResponse(resp);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw new errors_1.CatalystAPIError('REQUEST_FAILURE', err.message, err, err.message.includes('ECONNREFUSED') ? 503 : 400);
+            }
+            throw err;
+        }
+    }
+}
+exports.HttpClient = HttpClient;
+class AuthorizedHttpClient extends HttpClient {
+    constructor(app, component) {
+        super(app);
+        if (component) {
+            this.componentName = component.getComponentName();
+            this.componentVersion = component.getComponentVersion?.();
+        }
+    }
+    async send(request) {
+        const requestCopy = Object.assign({ user: CREDENTIAL_USER.user }, request);
+        requestCopy.headers = Object.assign({}, request.headers);
+        if (request.auth !== false) {
+            await this.app?.authenticateRequest(requestCopy);
+        }
+        return await super.send(requestCopy, this.componentName, this.componentVersion);
+    }
+}
+exports.AuthorizedHttpClient = AuthorizedHttpClient;

package/dist-cjs/index.browser.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalystAPIError = exports.ResponseType = exports.RequestType = exports.Handler = exports.PrefixedCatalystError = exports.CONSTANTS = exports.CatalystService = void 0;
+const fetch_handler_1 = require("./fetch-handler");
+var utils_1 = require("@zcatalyst/utils");
+Object.defineProperty(exports, "CatalystService", { enumerable: true, get: function () { return utils_1.CatalystService; } });
+Object.defineProperty(exports, "CONSTANTS", { enumerable: true, get: function () { return utils_1.CONSTANTS; } });
+var utils_2 = require("@zcatalyst/utils");
+Object.defineProperty(exports, "PrefixedCatalystError", { enumerable: true, get: function () { return utils_2.PrefixedCatalystError; } });
+class Handler {
+    constructor(app, component) {
+        this.component = component;
+    }
+    async send(options) {
+        return (await fetch_handler_1.ResponseHandler.send(options, this.component?.getComponentName(), this.component?.getComponentVersion?.()));
+    }
+}
+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/index.js

@@ -0,0 +1,34 @@
+"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 = exports.PrefixedCatalystError = exports.CONSTANTS = exports.CatalystService = void 0;
+const auth_admin_1 = require("@zcatalyst/auth-admin");
+const http_handler_1 = require("./http-handler");
+const form_data_1 = __importDefault(require("./utils/form-data"));
+exports.FormData = form_data_1.default;
+var utils_1 = require("@zcatalyst/utils");
+Object.defineProperty(exports, "CatalystService", { enumerable: true, get: function () { return utils_1.CatalystService; } });
+Object.defineProperty(exports, "CONSTANTS", { enumerable: true, get: function () { return utils_1.CONSTANTS; } });
+var utils_2 = require("@zcatalyst/utils");
+Object.defineProperty(exports, "PrefixedCatalystError", { enumerable: true, get: function () { return utils_2.PrefixedCatalystError; } });
+class Handler {
+    constructor(app, component) {
+        if (!app) {
+            app = new auth_admin_1.ZCAuth().getDefaultCredentials();
+        }
+        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;