@basenjs/base-http 0.0.1

package/dist/esm/index.mjs

@@ -0,0 +1,426 @@
+import https from 'node:https';
+import { BaseObject } from '@basenjs/base';
+import http from 'node:http';
+import qs from 'qs';
+import multiparty from 'multiparty';
+
+class BaseHttp extends 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 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 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 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);
+            }
+        });
+    }
+}
+
+export { BaseHttp, BaseHttpBody, BaseHttpProxy, BaseMultipartData };

package/dist/types/index.d.ts

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

package/dist/types/lib/BaseHttp.d.ts

@@ -0,0 +1,20 @@
+import http from 'node:http';
+import { Url } from 'node:url';
+import { BaseObject } from '@basenjs/base';
+export declare class BaseHttp extends BaseObject {
+    constructor();
+    static processResponse(response: http.IncomingMessage): Promise<Buffer>;
+    static buildOptions(options: http.RequestOptions | any | Url): http.RequestOptions;
+    static head(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined>;
+    static options(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined>;
+    static get(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined>;
+    static post(options: http.RequestOptions | any | Url, body: any): Promise<http.ClientRequest | undefined>;
+    static put(options: http.RequestOptions | any | Url, body: any): Promise<http.ClientRequest | undefined>;
+    static patch(options: http.RequestOptions | any | Url, body: any): Promise<http.ClientRequest | undefined>;
+    static delete(options: http.RequestOptions | any | Url): Promise<http.ClientRequest | undefined>;
+    static request(options: http.RequestOptions | any | Url, body?: any, callbacks?: {
+        request: (response: http.IncomingMessage) => void;
+        data: (buffer: Buffer) => void;
+        end: (buffer: Buffer) => void;
+    }): Promise<http.ClientRequest | undefined>;
+}

package/dist/types/lib/BaseHttpBody.d.ts

@@ -0,0 +1,12 @@
+import http from 'node:http';
+import { BaseObject } from '@basenjs/base';
+export declare class BaseHttpBody extends BaseObject {
+    _readable: http.ClientRequest | http.IncomingMessage;
+    _chunks: Buffer[];
+    _dataWasRead: boolean;
+    _ended: boolean;
+    constructor(readable: http.ClientRequest | http.IncomingMessage | any);
+    get readable(): http.ClientRequest | http.IncomingMessage;
+    get dataWasRead(): boolean;
+    readAsBuffer(): Promise<Buffer>;
+}

package/dist/types/lib/BaseHttpProxy.d.ts

@@ -0,0 +1,35 @@
+import http from 'node:http';
+import { BaseObject } from '@basenjs/base';
+import { BaseHttpBody } from './BaseHttpBody';
+import { BaseMultipartData } from './BaseMultipartData';
+export declare class BaseHttpProxy extends BaseObject {
+    requestIn: http.IncomingMessage;
+    responseOut: http.ServerResponse;
+    forwardComplete: boolean;
+    _multipartData: BaseMultipartData;
+    _requestInBodyReader: BaseHttpBody;
+    _responseInBodyReader: BaseHttpBody;
+    forwardWaitCount: number;
+    httpRequest: http.ClientRequest;
+    httpRequestInRawChunks: Buffer[];
+    httpRequestInRaw: Buffer<ArrayBuffer>;
+    httpResponseRawChunks: Buffer[];
+    httpResponseRaw: Buffer<ArrayBuffer>;
+    httpResponseRawChunksSize: number;
+    WRITEABLE: {
+        post: string;
+        patch: string;
+        put: string;
+    };
+    HOST: string;
+    PATH_BASE: string;
+    MAX_WAIT_COUNT: number;
+    constructor(requestIn: any, responseOut: any);
+    forwardRequest(): Promise<void>;
+    sleep(millis: number): Promise<unknown>;
+    initEvents(): void;
+    _initHeaders(): void;
+    _initForwardRequest(): void;
+    _forwardRequest(): void;
+    _writeWritable(bodyBuffer: Buffer): Promise<unknown>;
+}

package/dist/types/lib/BaseMultipartData.d.ts

@@ -0,0 +1,14 @@
+import multiparty from 'multiparty';
+import { BaseObject } from '@basenjs/base';
+export declare class BaseMultipartData extends BaseObject {
+    _form: multiparty.Form;
+    _bodyRaw: Buffer<ArrayBuffer>;
+    fields: any[];
+    files: any[];
+    get form(): multiparty.Form;
+    get bodyRaw(): Buffer;
+    constructor();
+    parse(request: any): Promise<unknown>;
+    parseRawText(text?: string): void;
+    private _parse;
+}

package/dist/types/lib/index.d.ts

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

package/npm-build.bat

@@ -0,0 +1,4 @@
+@echo off
+cls
+call npm run build
+pause

package/npm-login.bat

@@ -0,0 +1,4 @@
+@echo off
+cls
+call npm login
+pause

package/npm-publish.bat

@@ -0,0 +1,4 @@
+@echo off
+cls
+call npm publish --access public
+pause

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@basenjs/base-http",
+    "version": "0.0.1",
+    "private": false,
+    "description": "A base HTTP library for Node.js projects.",
+    "type": "module",
+    "main": "dist/cjs/index.cjs",
+    "module": "dist/esm/index.mjs",
+    "types": "dist/types/index.d.ts",
+    "exports": {
+        ".": {
+            "require": {
+                "types": "./dist/cjs/index.cjs",
+                "default": "./dist/cjs/index.cjs"
+            },
+            "import": "./dist/esm/index.mjs",
+            "types": "./dist/types/index.d.ts"
+        }
+    },
+    "keywords": [],
+    "author": {
+        "name": "g-greene"
+    },
+    "scripts": {
+        "build": "rollup -c && npm run build:types",
+        "build:types": "tsc -p tsconfig.declarations.json",
+        "release": "npm run build && npm version patch && npm publish && git push --follow-tags",
+        "release:minor": "npm run build && npm version minor && npm publish && git push --follow-tags",
+        "release:major": "npm run build && npm version major && npm publish && git push --follow-tags"
+    },
+    "license": "ISC",
+    "devDependencies": {
+        "@rollup/plugin-typescript": "^12.1.2",
+        "@types/node": "^22.19.2",
+        "prettier": "^3.5.3",
+        "rollup": "^4.40.0",
+        "tslib": "^2.8.1",
+        "typescript": "^5.8.3"
+    },
+    "dependencies": {
+        "@basenjs/base": "^0.0.2",
+        "multiparty": "^4.2.3",
+        "qs": "^6.14.0"
+    }
+}

package/rollup.config.js

@@ -0,0 +1,22 @@
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  input: 'src/index.ts',
+  output: [
+    {
+      dir: 'dist/esm',
+      format: 'esm',
+      entryFileNames: '[name].mjs',
+    },
+    {
+      dir: 'dist/cjs',
+      format: 'cjs',
+      entryFileNames: '[name].cjs',
+    },
+  ],
+  plugins: [
+    typescript({
+      tsconfig: './tsconfig.json',
+    }),
+  ],
+};

package/src/index.ts

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