@jnode/request 1.0.4 → 1.1.0

package/README.md

@@ -1,2 +1,126 @@
 # JustRequest
 
+Simple HTTP(s) package for Node.js.
+
+## Installation
+
+```shell
+npm install @jnode/request
+```
+
+## Usage
+
+### Import JustRequest
+
+```javascript
+const { request, generateMultipartBody, RequestResponse } = require('@jnode/request');
+```
+
+### Making a request
+
+```javascript
+async function fetchData() {
+  try {
+    const response = await request('GET', 'https://example.com/api/data');
+    console.log('Status Code:', response.statusCode);
+    console.log('Body:', response.text()); // Use response.json() if expecting a JSON response
+  } catch (error) {
+    console.error('Request failed:', error);
+  }
+}
+
+fetchData();
+```
+
+### Sending data with the request
+
+```javascript
+async function postData() {
+  try {
+      const headers = {
+        'Content-Type': 'application/json'
+      };
+      const body = JSON.stringify({ key: 'value' });
+      const response = await request('POST', 'https://example.com/api/post', headers, body);
+      console.log('Status Code:', response.statusCode);
+      console.log('Response:', response.text());
+  } catch (error) {
+      console.error('Request failed:', error);
+  }
+}
+
+postData();
+```
+
+### Generating a `multipart/form-data` body
+
+```javascript
+const fs = require('fs');
+
+async function uploadFile() {
+  const fileData = await fs.promises.readFile('./example.txt');
+  const parts = [{
+    disposition: 'form-data; name="file"; filename="example.txt"',
+    contentType: 'text/plain',
+    data: fileData
+  }, {
+      disposition: 'form-data; name="key"',
+      data: 'value'
+  }];
+  const body = generateMultipartBody(parts);
+  
+  const headers = {
+    'Content-Type': 'multipart/form-data; boundary=----JustNodeFormBoundary'
+  };
+
+  try {
+      const response = await request('POST', 'https://example.com/api/upload', headers, body);
+      console.log('Status Code:', response.statusCode);
+      console.log('Response:', response.text());
+  } catch (error) {
+      console.error('Request failed:', error);
+  }
+}
+
+uploadFile();
+```
+
+## Functions
+
+### `request(method, url, headers = {}, body)`
+
+Makes an HTTP(S) request.
+
+-   `method`: HTTP method (`GET`, `POST`, `PUT`, `DELETE`, etc.).
+-   `url`: The request URL.
+-   `headers`: An object containing request headers. Defaults to an empty object.
+-   `body`: The request body (string or Buffer).
+
+**Returns:** A Promise that resolves to a `RequestResponse` object.
+
+### `generateMultipartBody(parts = [])`
+
+Generates the body for a `multipart/form-data` request.
+
+-   `parts`: An array of objects, where each object represents a part of the form data.
+    -   `disposition` (Optional): Content disposition.
+    -   `contentType` (Optional): Content type of the data. Defaults to `application/octet-stream`.
+    -   `data`: Data (string or Buffer) of this part.
+    -    `encoded` (Optional): If provided, the data is already base64 encoded, you may skip the default base64 encoding.
+
+**Returns:** A string representing the multipart body.
+
+## Class `RequestResponse`
+
+A class representing the response from an HTTP(S) request.
+
+### Properties
+
+-   `statusCode`: The HTTP status code of the response.
+-   `headers`: An object containing the response headers.
+-   `body`: The raw response body (Buffer).
+
+### Methods
+
+-   `text(encoding = 'utf8')`: Returns the response body as a string with optional encoding.
+-   `json()`: Attempts to parse the response body as JSON. Returns a JSON object or `undefined` if parsing fails.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jnode/request",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Simple HTTP(s) package for Node.js.",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -1,6 +1,6 @@
 /*
 JustRequest
-v.1.0.0
+v.1.1.0
 
 Simple HTTP(s) package for Node.js.
 
@@ -10,6 +10,10 @@ by JustNode Dev Team / JustApple
 //load node packages
 const http = require('http');
 const https = require('https');
+const fs = require('fs');
+const { URL } = require('url');
+const { pipeline } = require('stream/promises');
+const crypto = require('crypto');
 
 //https request in async/await
 function request(method, url, headers = {}, body) {
@@ -26,7 +30,7 @@ function request(method, url, headers = {}, body) {
 			headers: headers
 		}, (res) => {
 			let chunks = [];
-			res.on('data', (chunk) => chunks.push(chunk));
+			res.on('data', chunks.push);
 			res.on('end', () => {
 				resolve(new RequestResponse(res, Buffer.concat(chunks)));
 			});
@@ -53,6 +57,80 @@ function generateMultipartBody(parts = []) {
 	return result;
 }
 
+//http multipart/form-data request
+async function multipartRequest(method, url, headers, parts, options) {
+	return new Promise(async (resolve, reject) => {
+		const parsedUrl = new URL(url); //parse url
+		const isHttps = parsedUrl.protocol === 'https:'; //check protocol
+		const reqModule = isHttps ? https : http; //select module from http and https
+		
+		const boundary = `----WebKitFormBoundary${Date.now().toString(16)}${crypto.randomUUID()}`; //create a random boundary
+		headers['Content-Type'] = `multipart/form-data; boundary=${boundary}`; //set header
+		
+		//set options
+		options = {
+			method,
+			headers,
+			...options
+		};
+		
+		//make a request
+		const req = reqModule.request(url, options, (res) => {
+			//save buffers
+			let chunks = [];
+			res.on('data', chunks.push);
+			
+			res.on('end', () => {
+				resolve(new RequestResponse(res, Buffer.concat(chunks)));
+			});
+			
+			res.on('error', (err) => {
+				reject(err);
+			});
+		});
+		
+		req.on('error', (err) => {
+			reject(err);
+		});
+		
+		//send every parts
+		for (const part of parts) {
+			req.write(`--${boundary}\r\n`); //write boundary
+			
+			//write disposition
+			if (part.disposition) {
+				req.write(`Content-Disposition: ${part.disposition}\r\n`);
+			}
+			
+			//write content type
+			let contentType = part.type ?? 'application/octet-stream';
+			req.write(`Content-Type: ${contentType}\r\n`);
+			
+			//send data
+			if (part.file) { //local file, using streams
+				req.write('\r\n');
+				const fileStream = fs.createReadStream(part.file);
+				await pipeline(fileStream, req, { end: false }); //pipe stream but not end
+				req.write('\r\n');
+			} else if (part.data) { //string or buffer data
+				req.write('\r\n');
+				req.write(part.data + '\r\n');
+			} else if (part.base64) { //base64 data
+				req.write('Content-Transfer-Encoding: base64\r\n\r\n'); //using base64 encoding
+				req.write(part.base64 + '\r\n');
+			} else if (part.stream) { //any readable stream
+				req.write('\r\n');
+				await pipeline(part.stream, req, { end: false });
+				req.write('\r\n');
+			}
+		}
+		
+		//end request
+		req.write(`--${boundary}--\r\n`);
+		req.end();
+	});
+}
+
 //request response
 class RequestResponse {
 	constructor(res, body) {
@@ -79,4 +157,4 @@ class RequestResponse {
 }
 
 //export
-module.exports = { request, generateMultipartBody, RequestResponse };
+module.exports = { request, multipartRequest, generateMultipartBody, RequestResponse };