@zcatalyst/transport 0.0.1 → 0.0.3

package/dist-es/http-handler.js

@@ -0,0 +1,362 @@
+import { addDefaultAppHeaders } from '@zcatalyst/auth-admin';
+import { CONSTANTS, getServicePath, LOGGER } from '@zcatalyst/utils';
+import http from 'http';
+import https from 'https';
+import { ReadableStream } from 'node:stream/web';
+import { stringify } from 'querystring';
+import { Readable } from 'stream';
+import { URL } from 'url';
+import { inspect } from 'util';
+import pkg from '../package.json';
+const { version } = pkg;
+import { CatalystAPIError } from './utils/errors';
+import FORM from './utils/form-data';
+import { isHttps } from './utils/helpers';
+import RequestAgent from './utils/request-agent';
+const { IS_LOCAL, USER_KEY_NAME, CREDENTIAL_USER, CATALYST_ORIGIN, USER_AGENT, APM_INSIGHT, ACCEPT_HEADER, REQ_RETRY_THRESHOLD, IS_APM } = CONSTANTS;
+export 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 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 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 CatalystAPIError('UNPARSABLE_RESPONSE', `Error while parsing response data: "${inspect(e)}". Raw server ` +
+                        `response: "${this.resp.data}". Status code: "${this.statusCode}".`, '', this.statusCode);
+                }
+        }
+    }
+}
+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: 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();
+    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 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 : inspect(e);
+        rejectWithContext(reject, response.statusCode, errMsg);
+    }
+}
+function _appendQueryData(url, data) {
+    if (data && Object.keys(data).length > 0) {
+        url += url.includes('?') ? '&' : '?';
+        url += 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) => {
+            LOGGER.warn('>>> RETRYING REQUEST ');
+            if (retryCount++ === REQ_RETRY_THRESHOLD) {
+                reject(err);
+                return;
+            }
+            try {
+                options.agent = new RequestAgent(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
+            };
+            LOGGER.debug(`>>> HTTP REQUEST : ${req.method?.toUpperCase()} ${req.protocol}//${req.host}${req.path}`);
+            process.env.ZC_SECURE?.toLowerCase() === 'override' &&
+                LOGGER.fine(`>>> REQUEST HEADERS : ${JSON.stringify(options.headers)}`);
+            LOGGER.debug(`<<< HTTP RESPONSE : ${res.statusCode} : ${Date.now() - startTimeStamp} ms`);
+            process.env.ZC_SECURE?.toLowerCase() === 'override' &&
+                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) => {
+            LOGGER.debug(`>>> HTTP REQUEST : ${req.method?.toUpperCase()} ${req.protocol}//${req.host}${req.path}`);
+            process.env.ZC_SECURE?.toLowerCase() === 'override' &&
+                LOGGER.fine(`>>> REQUEST HEADERS : ${JSON.stringify(options.headers)}`);
+            LOGGER.debug(`<<< HTTP REQUEST ERROR : ${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 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 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 = 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(config.path || '', origin).href;
+    if (config.qs !== undefined) {
+        config.url = _appendQueryData(config.url, config.qs);
+    }
+    const parsedUrl = new URL(config.url);
+    if (parsedUrl.hostname === null) {
+        throw new CatalystAPIError('UNPARSABLE_CONFIG', 'Hostname cannot be null', config.path, 400);
+    }
+    const isHttpsProtocol = isHttps(parsedUrl);
+    const requestAgent = new RequestAgent(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 : http;
+    return _request(transport, options, config, data);
+}
+export 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 = 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 =
+                getServicePath(req.service) + `/project/${this.app.config.projectId}` + req.path;
+        }
+        try {
+            let resp;
+            if (req.track && apmTrackerName && IS_APM === 'true') {
+                try {
+                    const apminsight = await import('apminsight');
+                    resp = await apminsight.startTracker(APM_INSIGHT.tracker_name, apmTrackerName, () => sendRequest(req, apmTrackerName, componentVersion));
+                }
+                catch (err) {
+                    throw new 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 CatalystAPIError('REQUEST_FAILURE', err.message, err, err.message.includes('ECONNREFUSED') ? 503 : 400);
+            }
+            throw err;
+        }
+    }
+}
+export 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);
+    }
+}

package/dist-es/index.browser.js

@@ -0,0 +1,13 @@
+import { ResponseHandler } from './fetch-handler';
+export { CatalystService, CONSTANTS } from '@zcatalyst/utils';
+export { PrefixedCatalystError } from '@zcatalyst/utils';
+export class Handler {
+    constructor(app, component) {
+        this.component = component;
+    }
+    async send(options) {
+        return (await ResponseHandler.send(options, this.component?.getComponentName(), this.component?.getComponentVersion?.()));
+    }
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';

package/dist-es/index.js

@@ -0,0 +1,21 @@
+import { ZCAuth } from '@zcatalyst/auth-admin';
+import { AuthorizedHttpClient } from './http-handler';
+import FormData from './utils/form-data';
+export { CatalystService, CONSTANTS } from '@zcatalyst/utils';
+export { PrefixedCatalystError } from '@zcatalyst/utils';
+export class Handler {
+    constructor(app, component) {
+        if (!app) {
+            app = new ZCAuth().getDefaultCredentials();
+        }
+        this.app = app;
+        this.component = component;
+    }
+    async send(options) {
+        const _httpRequester = new AuthorizedHttpClient(this.app, this.component);
+        return (await _httpRequester.send(options));
+    }
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';
+export { FormData };

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

@@ -0,0 +1,104 @@
+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);
+    }
+}