@basenjs/base-http 0.0.1

package/src/lib/BaseHttp.ts

@@ -0,0 +1,116 @@
+import http from 'node:http';
+import https from 'node:https';
+import { Url } from 'node:url';
+
+import { BaseObject } from '@basenjs/base';
+
+export class BaseHttp extends BaseObject {
+    constructor() {
+        super();
+        this.logLevel = 'none';
+    }
+
+    public static processResponse(response: http.IncomingMessage): Promise<Buffer> {
+        return new Promise<Buffer>((resolve, reject) => {
+            const chunks: Buffer[] = [];
+            // if(res.statusCode == '302') { // redirect
+            // 	if('location' in res.headers) {
+            // 		_.statusCode = 302;
+            // 		_.setHeader('Location', res.headers['location']);
+            // 	}
+            // } 
+        });
+    }
+
+    public static buildOptions(options: http.RequestOptions | any | Url): http.RequestOptions {
+        let headers = options.headers || {},
+            r : http.RequestOptions = {
+                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;
+    }
+
+    public static head(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined> {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'HEAD' });
+    }
+
+    public static options(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined> {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'OPTIONS' });
+    }
+
+    public static get(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined> {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'GET' });
+    }
+
+    public static post(options: http.RequestOptions | any | Url, body: any): Promise<http.ClientRequest | undefined> {
+        options.headers['Content-Length'] = body ? Buffer.byteLength(body) : 0;
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'POST' }, body);
+    }
+
+    public static put(options: http.RequestOptions | any | Url, body: any): Promise<http.ClientRequest | undefined> {
+        options.headers['Content-Length'] = body ? Buffer.byteLength(body) : 0;
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'PUT' }, body);
+    }
+
+    public static patch(options: http.RequestOptions | any | Url, body: any): Promise<http.ClientRequest | undefined> {
+        options.headers['Content-Length'] = body ? Buffer.byteLength(body) : 0;
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'PATCH' }, body);
+    }
+
+    public static delete(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined> {
+        return BaseHttp.request({ ...BaseHttp.buildOptions(options), method: 'DELETE' });
+    }
+
+    public static async request(options: http.RequestOptions | any | Url, body: any = null, callbacks: {request: (response: http.IncomingMessage) => void, data: (buffer: Buffer) => void, end: (buffer: Buffer) => void} = {request: () => {}, data: () => {}, end: () => {}}): Promise<http.ClientRequest | undefined> {
+        var _ = this,
+        buffer: 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;
+    }
+}

package/src/lib/BaseHttpBody.ts

@@ -0,0 +1,67 @@
+import http from 'node:http';
+
+import { BaseObject } from '@basenjs/base';
+
+export class BaseHttpBody extends BaseObject {
+    _readable: http.ClientRequest | http.IncomingMessage;
+    _chunks: Buffer[] = [];
+    _dataWasRead: boolean = false;
+    _ended: boolean = false;
+
+    constructor(readable: http.ClientRequest | http.IncomingMessage | any) {
+        super();
+        this._readable = readable;
+    }
+
+    public get readable(): http.ClientRequest | http.IncomingMessage {
+        return this._readable;
+    }
+
+    public get dataWasRead(): boolean {
+        return this._dataWasRead;
+    }
+
+    async readAsBuffer(): Promise<Buffer> {
+        var _ = this;
+
+        return new Promise<Buffer>((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: Buffer) => {
+                _._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);
+            });
+
+        });
+    };
+}

package/src/lib/BaseHttpProxy.ts

@@ -0,0 +1,285 @@
+import http from 'node:http';
+import { Url } from 'node:url';
+
+import qs from 'qs';
+
+import { BaseObject } from '@basenjs/base';
+
+import { BaseHttpBody } from './BaseHttpBody';
+import { BaseMultipartData } from './BaseMultipartData';
+
+export class BaseHttpProxy extends BaseObject {
+    requestIn: http.IncomingMessage;
+    responseOut: http.ServerResponse;
+    forwardComplete = false;
+    _multipartData = new BaseMultipartData();
+
+    _requestInBodyReader: BaseHttpBody;;
+    _responseInBodyReader: BaseHttpBody;
+
+    forwardWaitCount = 0;
+
+    httpRequest: http.ClientRequest = http.request({});
+
+    httpRequestInRawChunks: Buffer[] = [];
+    httpRequestInRaw = Buffer.alloc(0);
+
+    httpResponseRawChunks: Buffer[] = [];
+    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: any, responseOut: any) {
+        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: number) {
+        return new Promise(resolve => setTimeout(resolve, millis));
+    }
+
+    initEvents() {
+        var _ = this;
+
+        this.httpRequest.on('socket', function (socket: any) {
+            _.log.debug('socket (httpRequest out)');
+
+            socket.on('data', (chunk: string) => {
+                _.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: Buffer) => {
+            this.log.debug('_requestInBodyReader finished reading');
+            _.httpRequestInRaw.write(data.toString());
+            _._forwardRequest();
+        });
+    }
+
+    _forwardRequest() {
+        let url: 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: http.OutgoingHttpHeaders = {},
+                dataBuffer = Buffer.alloc(0),
+                contentType: string | string[] = 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: Buffer) {
+                    let EOH = '\r\n\r\n',
+                    eohPos = -1;
+                    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: Buffer) {
+
+        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);
+            }
+        });
+    }
+}

package/src/lib/BaseMultipartData.ts

@@ -0,0 +1,106 @@
+import multiparty from 'multiparty';
+import { BaseObject } from '@basenjs/base';
+
+export class BaseMultipartData extends BaseObject {
+    _form = new multiparty.Form();
+    _bodyRaw = Buffer.alloc(0);
+
+    fields: any[] = [];
+    files: any[] = [];
+    
+    public get form(): multiparty.Form {
+        return this._form;
+    }
+
+    public get bodyRaw(): Buffer {
+        return this._bodyRaw;
+    }
+
+    constructor() {
+        super();
+    }
+
+    parse(request: any) {
+        return this._parse(request);
+    }
+
+    parseRawText(text = '') {
+        if(text.length < 1) {
+            return;
+        }
+    }
+
+    private _parse(request: any) {
+        var _ = this;
+
+        return new Promise((resolve, reject) => {
+
+            let contentType = request.headers['content-type'] || '',
+                chunks: Buffer[] = new Array<Buffer>();
+
+            // 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: any) {
+                _.log.debug('initMultipart: Error parsing form: ' + err.stack);
+            });
+
+            _.form.on('pipe', function(readable: any) {
+                _.log.debug('initMultipart: pipe ');
+                if(readable) {
+                    readable.on('data', (chunk: any) => {
+                        _.log.debug('initMultipart: piped readable: data ');
+                        _.log.debug('initMultipart: piped readable:' + chunk);
+                        chunks.push(chunk);
+                    });
+                }
+            });
+
+            _.form.on('data', function(chunk: any) {
+                _.log.debug('initMultipart: data ');
+            });
+
+            // Parts are emitted when parsing the form
+            _.form.on('part', function(part: any) {
+                // 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: any) {
+                    // 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('');
+            }
+        });
+    }
+}

package/src/lib/index.ts

@@ -0,0 +1,4 @@
+export { BaseHttp } from './BaseHttp';
+export { BaseHttpBody } from './BaseHttpBody';
+export { BaseHttpProxy } from './BaseHttpProxy';
+export { BaseMultipartData } from './BaseMultipartData';

package/tsconfig.declarations.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist/types"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "esModuleInterop": true,
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleResolution": "bundler",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"]
+}