@basenjs/base-http 0.0.1

package/dist/cjs/index.cjs

@@ -0,0 +1,431 @@
+'use strict';
+
+var https = require('node:https');
+var base = require('@basenjs/base');
+var http = require('node:http');
+var qs = require('qs');
+var multiparty = require('multiparty');
+
+class BaseHttp extends base.BaseObject {
+    constructor() {
+        super();
+        this.logLevel = 'none';
+    }
+    static processResponse(response) {
+        return new Promise((resolve, reject) => {
+            // if(res.statusCode == '302') { // redirect
+            // 	if('location' in res.headers) {
+            // 		_.statusCode = 302;
+            // 		_.setHeader('Location', res.headers['location']);
+            // 	}
+            // } 
+        });
+    }
+    static buildOptions(options) {
+        let headers = options.headers || {}, r = {
+            hostname: options.hostname || 'localhost',
+            path: options.path || '/',
+            port: options.port || (options.protocol === 'https' ? 443 : 80),
+            method: options.method || 'GET',
+            headers: {
+                'Content-Type': headers['Content-Type'] || 'application/json',
+                'Connection': headers['Connection'] || 'keep-alive',
+                'Accept': headers['Accept'] || '*/*',
+                'Accept-Encoding': headers['Accept-Encoding'] || 'deflate, br, zstd',
+                ...headers
+            }
+        };
+        return r;
+    }
+    static head(options) {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'HEAD' });
+    }
+    static options(options) {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'OPTIONS' });
+    }
+    static get(options) {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'GET' });
+    }
+    static post(options, body) {
+        options.headers['Content-Length'] = body ? Buffer.byteLength(body) : 0;
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'POST' }, body);
+    }
+    static put(options, body) {
+        options.headers['Content-Length'] = body ? Buffer.byteLength(body) : 0;
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'PUT' }, body);
+    }
+    static patch(options, body) {
+        options.headers['Content-Length'] = body ? Buffer.byteLength(body) : 0;
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'PATCH' }, body);
+    }
+    static delete(options) {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'DELETE' });
+    }
+    static async request(options, body = null, callbacks = { request: () => { }, data: () => { }, end: () => { } }) {
+        var buffer = Buffer.alloc(0);
+        const req = https.request(options, (res) => {
+            console.log('<p>https://' + options.hostname + options.path + '</p>');
+            console.log(`<p>STATUS: ${res.statusCode}</p>`);
+            console.log(`<p>HEADERS: ${JSON.stringify(res.headers)}</p>`);
+            res.setEncoding('utf8');
+            callbacks.request(res);
+            res.on('data', (chunk) => {
+                // this.log.debug(`<p>BODY: ${chunk}</p>`);
+                buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+                callbacks.data(buffer);
+            });
+            res.on('end', () => {
+                // this.log.debug('No more data in response.');
+                callbacks.end(buffer);
+                return buffer;
+            });
+        });
+        req.on('error', (e) => {
+            console.log(`problem with request: ${e.message}`);
+            console.log(e.stack);
+            throw (e);
+        });
+        if (body && (options.method?.toLowerCase() in ['post', 'put', 'patch'])) {
+            req.write(body);
+        }
+        req.end();
+        return req;
+    }
+}
+
+class BaseHttpBody extends base.BaseObject {
+    _readable;
+    _chunks = [];
+    _dataWasRead = false;
+    _ended = false;
+    constructor(readable) {
+        super();
+        this._readable = readable;
+    }
+    get readable() {
+        return this._readable;
+    }
+    get dataWasRead() {
+        return this._dataWasRead;
+    }
+    async readAsBuffer() {
+        var _ = this;
+        return new Promise((resolve, reject) => {
+            var applyResolve = function () {
+                let readBody = '';
+                if (!_.dataWasRead && ('body' in _.readable) && _.readable.body) {
+                    // body can be an object
+                    readBody = typeof _.readable.body == 'object' ? JSON.stringify(_.readable.body) : _.readable.body + '';
+                    _.log.info('BodyReader::readBodyAsBuffer _readable.body: ' + readBody);
+                    _._chunks.push(Buffer.from(readBody));
+                }
+                resolve(Buffer.concat(_._chunks));
+            };
+            this._readable.on("data", (chunk) => {
+                _._dataWasRead = true;
+                _.log.debug('BodyReader event (data)');
+                _._chunks.push(chunk);
+            });
+            this._readable.on('close', () => {
+                _.log.debug('BodyReader event (close):');
+                if (!_._ended) {
+                    applyResolve();
+                }
+            });
+            this._readable.on("end", () => {
+                _.log.debug('BodyReader event (end):');
+                _._ended = true;
+                applyResolve();
+            });
+            this._readable.on("error", (error) => {
+                _.log.error('BodyReader event (error): ' + error.message);
+                throw new Error(error.message);
+            });
+        });
+    }
+    ;
+}
+
+class BaseMultipartData extends base.BaseObject {
+    _form = new multiparty.Form();
+    _bodyRaw = Buffer.alloc(0);
+    fields = [];
+    files = [];
+    get form() {
+        return this._form;
+    }
+    get bodyRaw() {
+        return this._bodyRaw;
+    }
+    constructor() {
+        super();
+    }
+    parse(request) {
+        return this._parse(request);
+    }
+    parseRawText(text = '') {
+        if (text.length < 1) {
+            return;
+        }
+    }
+    _parse(request) {
+        var _ = this;
+        return new Promise((resolve, reject) => {
+            let contentType = request.headers['content-type'] || '', chunks = new Array();
+            // Errors may be emitted
+            // Note that if you are listening to 'part' events, the same error may be
+            // emitted from the `form` and the `part`.
+            _.form.on('error', function (err) {
+                _.log.debug('initMultipart: Error parsing form: ' + err.stack);
+            });
+            _.form.on('pipe', function (readable) {
+                _.log.debug('initMultipart: pipe ');
+                if (readable) {
+                    readable.on('data', (chunk) => {
+                        _.log.debug('initMultipart: piped readable: data ');
+                        _.log.debug('initMultipart: piped readable:' + chunk);
+                        chunks.push(chunk);
+                    });
+                }
+            });
+            _.form.on('data', function (chunk) {
+                _.log.debug('initMultipart: data ');
+            });
+            // Parts are emitted when parsing the form
+            _.form.on('part', function (part) {
+                // You *must* act on the part by reading it
+                // NOTE: if you want to ignore it, just call "part.resume()"
+                if (part.filename === undefined) {
+                    // filename is not defined when this is a field and not a file
+                    _.log.debug('initMultipart: got field named ' + part.name);
+                    // ignore field's content
+                    part.resume();
+                }
+                if (part.filename !== undefined) {
+                    // filename is defined when this is a file
+                    // count++;
+                    _.log.debug('initMultipart: got file named ' + part.name);
+                    // ignore file's content here
+                    part.resume();
+                }
+                part.on('error', function (err) {
+                    // decide what to do
+                });
+            });
+            // Close emitted after form parsed
+            _.form.on('close', function () {
+                _.log.debug('initMultipart (requestIn): Upload completed!');
+                // res.setHeader('text/plain');
+                // res.end('Received ' + count + ' files');
+                _._bodyRaw = Buffer.concat(chunks);
+                resolve(_.bodyRaw);
+            });
+            if (contentType.match(/multipart/i) != null) {
+                // Parse req
+                _.form.parse(request);
+            }
+            else {
+                resolve('');
+            }
+        });
+    }
+}
+
+class BaseHttpProxy extends base.BaseObject {
+    requestIn;
+    responseOut;
+    forwardComplete = false;
+    _multipartData = new BaseMultipartData();
+    _requestInBodyReader;
+    ;
+    _responseInBodyReader;
+    forwardWaitCount = 0;
+    httpRequest = http.request({});
+    httpRequestInRawChunks = [];
+    httpRequestInRaw = Buffer.alloc(0);
+    httpResponseRawChunks = [];
+    httpResponseRaw = Buffer.alloc(0);
+    httpResponseRawChunksSize = 0;
+    WRITEABLE = {
+        'post': 'POST',
+        'patch': 'PATCH',
+        'put': 'PUT'
+    };
+    HOST = 'ws.anything-2493814af352';
+    PATH_BASE = '/_p';
+    MAX_WAIT_COUNT = 30; // in seconds
+    constructor(requestIn, responseOut) {
+        super();
+        this.requestIn = requestIn;
+        this.responseOut = responseOut;
+        this._requestInBodyReader = new BaseHttpBody(this.requestIn);
+        this._responseInBodyReader = new BaseHttpBody(this.responseOut);
+    }
+    async forwardRequest() {
+        this.log.info('forwardRequest()');
+        this._initForwardRequest();
+        // this.httpRequest.end(); // move this to areas after writing
+        while (!this.forwardComplete && this.forwardWaitCount < this.MAX_WAIT_COUNT) {
+            await this.sleep(1000);
+            this.forwardWaitCount++;
+        }
+    }
+    sleep(millis) {
+        return new Promise(resolve => setTimeout(resolve, millis));
+    }
+    initEvents() {
+        var _ = this;
+        this.httpRequest.on('socket', function (socket) {
+            _.log.debug('socket (httpRequest out)');
+            socket.on('data', (chunk) => {
+                _.httpResponseRawChunksSize += chunk.length;
+                _.httpResponseRawChunks.push(Buffer.from(chunk));
+                _.log.debug('socket data chunk size (httpRequest out): ' + _.httpResponseRawChunksSize);
+                _.log.debug('socket data chunk (httpRequest out): ' + chunk);
+            });
+            socket.on('end', () => {
+                _.log.debug('socket end (httpRequest out)');
+            });
+            socket.on('close', () => {
+                _.log.debug('socket close  (httpRequest out)');
+                _.log.debug('socket close chunk size (httpRequest out): ' + _.httpResponseRawChunksSize);
+            });
+            socket.resume();
+        });
+    }
+    _initHeaders() {
+        let contentType = this.requestIn.headers['content-type'];
+        this.requestIn.headers['host'] = this.HOST;
+        if (this.requestIn?.method?.toLowerCase() == 'post' && contentType?.match(/multipart/i) == null) {
+            this.log.info('setting content type for post');
+            this.requestIn.headers['content-type'] = 'application/x-www-form-urlencoded';
+            delete this.requestIn.headers['connection'];
+            // delete this.requestIn.headers['keep-alive'];
+        }
+    }
+    _initForwardRequest() {
+        var _ = this;
+        this.log.info('_initForwardRequest()');
+        this._initHeaders();
+        // DEBUG
+        this.log.debug('_initForwardRequest method (requestIn):' + this.requestIn.method);
+        // this.log.debug('_initForwardRequest body (requestIn):' + JSON.stringify(this.requestIn.body));
+        this.log.debug('_initForwardRequest headers (requestIn):' + JSON.stringify(this.requestIn.headers));
+        // this.log.debug('_initForwardRequest path (requestIn):' + JSON.stringify(this.requestIn.path));
+        this._requestInBodyReader = new BaseHttpBody(this.requestIn);
+        this._requestInBodyReader.readAsBuffer().then((data) => {
+            this.log.debug('_requestInBodyReader finished reading');
+            _.httpRequestInRaw.write(data.toString());
+            _._forwardRequest();
+        });
+    }
+    _forwardRequest() {
+        let url = new URL(this.requestIn.url || ''), query = qs.stringify(url.searchParams), path = url.pathname?.replace(this.PATH_BASE, '') + (query != '' ? '?' + query : '');
+        this.log.debug('_forwardRequest path (requestIn): ' + qs.stringify(url.pathname));
+        this.log.debug('_forwardRequest query (requestIn): ' + qs.stringify(url.searchParams));
+        const options = {
+            protocol: 'http:',
+            host: this.HOST,
+            port: 14599,
+            path: path,
+            method: this.requestIn.method,
+            headers: this.requestIn.headers,
+        };
+        this.log.debug(JSON.stringify(options));
+        var _ = this;
+        this.httpRequest = http.request(options);
+        this.httpRequest.on('response', (responseIn) => {
+            _.log.info('httpRequest response:');
+            _._responseInBodyReader = new BaseHttpBody(responseIn);
+            _._responseInBodyReader.readAsBuffer().then((data) => {
+                _.log.debug('_responseInBodyReader finished reading');
+                let headers = {}, dataBuffer = Buffer.alloc(0), contentType = responseIn.headers['Content-Type'] || '';
+                contentType = typeof contentType == 'string' ? contentType : contentType.join('; ');
+                _.log.debug('-- end event (callback)');
+                _.log.debug('-- chunks collected length: ' + Buffer.byteLength(data));
+                _.log.debug('-- chunks: ' + data.toString());
+                let fIsolateData = function (httpResponseRaw) {
+                    let EOH = '\r\n\r\n';
+                    return (httpResponseRaw.slice(httpResponseRaw.indexOf(EOH) + EOH.length));
+                };
+                dataBuffer = fIsolateData(Buffer.concat(_.httpResponseRawChunks));
+                if (contentType.length > 0) {
+                    headers['Content-Type'] = responseIn.headers['content-type'];
+                    if (contentType.match(/multipart|image/i) != null) {
+                        headers['Content-Length'] = Buffer.byteLength(dataBuffer);
+                    }
+                    // if(responseIn.headers['content-type'] == 'image/png') {
+                    // 	headers['Content-Length'] = Buffer.byteLength(dataBuffer);
+                    // }
+                }
+                else {
+                    headers['Content-Type'] = 'application/json';
+                }
+                _.log.debug('sending response with headers: ' + JSON.stringify(headers));
+                if (contentType.match(/json|text|html|xml/gim) != null) {
+                    _.log.debug('sending text');
+                    _.log.debug('sending text headers (responseOut):' + JSON.stringify(headers));
+                    _.responseOut.write(data);
+                }
+                else {
+                    _.log.debug('sending binary');
+                    _.log.debug('sending binary headers (responseOut):' + JSON.stringify(headers));
+                    // Logger.debug(data);
+                    _.responseOut.writeHead(responseIn.statusCode, headers);
+                    _.responseOut.write(dataBuffer);
+                }
+                // _.log.debug('buffer:');
+                // _.log.debug(data);
+                // _.log.debug('-- end buffer');
+                // this writes everything out and is not contexualized by content type above
+                // responseOut.send(data);
+                _.forwardComplete = true;
+            });
+        });
+        this.initEvents();
+        let method = this.requestIn?.method?.toLowerCase() || '';
+        if (method in this.WRITEABLE) {
+            this.log.info('writing writeable: ' + Buffer.byteLength(this.httpRequestInRaw));
+            this._writeWritable(this.httpRequestInRaw).then((bodyWritten) => {
+                this.httpRequest.end();
+            });
+        }
+        else {
+            this.httpRequest.end(this.httpRequestInRaw);
+        }
+        // 	this._multipartData.parse(this.requestIn).then(bodyRaw => {
+        // 		this.writePost();
+        // 	});
+    }
+    _writeWritable(bodyBuffer) {
+        var _ = this;
+        return new Promise((resolve, reject) => {
+            let contentType = _.requestIn.headers['Content-Type'] || '', bodyObject = null, dataPostParts = [], method = this.requestIn?.method?.toLowerCase() || '';
+            contentType = typeof contentType == 'string' ? contentType : contentType.join('; ');
+            if (!bodyBuffer || (!(method in _.WRITEABLE))) {
+                resolve([]);
+            }
+            if (method == 'post' && contentType.match(/multipart/i) == null) {
+                bodyObject = JSON.parse(bodyBuffer.toString());
+                _.log.debug('writing post:' + JSON.stringify(bodyObject));
+                _.log.debug('post data: ' + JSON.stringify(bodyObject));
+                for (let key in bodyObject) {
+                    dataPostParts.push(key + '=' + encodeURIComponent(bodyObject[key]));
+                }
+                _.log.debug('writing post data: ' + dataPostParts.join('&'));
+                _.httpRequest.write(dataPostParts.join('&'));
+                resolve(dataPostParts);
+            }
+            else {
+                _.log.debug('writing data: ' + JSON.stringify(bodyBuffer));
+                _.httpRequest.write(bodyBuffer);
+                resolve(bodyBuffer);
+            }
+        });
+    }
+}
+
+exports.BaseHttp = BaseHttp;
+exports.BaseHttpBody = BaseHttpBody;
+exports.BaseHttpProxy = BaseHttpProxy;
+exports.BaseMultipartData = BaseMultipartData;