Add the ability to make a post request through a proxy

README.md

@@ -28,103 +28,107 @@ get()
 
 ## Functions
    
-### **get**       `request.get(url, headers)`
+### **get**              `request.get(url, headers)`
 
 Returns an object of functions that apply proccesing to the response. To get the raw response buffer, use `.buffer()`.  
 
     `.text()`  
     Returns the get response result as a string.    
         **Example:**  
-> ```js 
-> request.get('https://postman-echo.com/get').text().then(console.log)
-> ```
+```js 
+request.get('https://postman-echo.com/get').text().then(console.log)
+```
 
     `.json()`  
     Returns the response result as a JSON object.  
         **Example:**  
-> ```js 
-> request.get('https://postman-echo.com/get').json().then(console.log)
-> ```  
+```js 
+request.get('https://postman-echo.com/get').json().then(console.log)
+```  
 
     `.buffer()`  
     Returns the get response result as a buffer.  
         **Example:**
-> ```js 
-> request.get('https://postman-echo.com/get').buffer().then(console.log)
-> ```  
+```js 
+request.get('https://postman-echo.com/get').buffer().then(console.log)
+```  
 
     `.error()`  
     Useful to check if a request returns an error without stopping the Node proccess, returns `undefined` otherwise.  
         **Example:**  
-> ```js 
-> console.log(request.get('https://postman-echo.com/get').error())
-> //=> undefined
-> ```  
+```js 
+console.log(request.get('https://postman-echo.com/get').error())
+//=> undefined
+```  
 
    
-### **post**       `request.post(url, headers)`
+### **post**              `request.post(url, headers)`
 
 Returns an object of functions that apply proccesing to the response. To get the raw response buffer, use `.buffer()`.  
 
     `.text()`  
     Returns the post response result as a string.    
         **Example:**  
-> ```js 
-> request.post('https://postman-echo.com/post', {
->    data: JSON.stringify({
->        user: 'request',
->        password: 'requestx@node',
->        email: 'requestx@npm.org'
->    })
->}).text().then(console.log)
-> ``` 
+```js 
+ request.post('https://postman-echo.com/post', {
+    data: JSON.stringify({
+        user: 'request',
+        password: 'requestx@node',
+        email: 'requestx@npm.org'
+    })
+}).text().then(console.log)
+``` 
 
     `.json()`  
     Returns the response result as a JSON object.  
         **Example:**  
-> ```js 
-> request.post('https://postman-echo.com/post', {
->    data: JSON.stringify({
->        user: 'request',
->        password: 'requestx@node',
->        email: 'requestx@npm.org'
->    })
->}).json().then(console.log)
-> ``` 
+```js 
+ request.post('https://postman-echo.com/post', {
+    data: JSON.stringify({
+        user: 'request',
+        password: 'requestx@node',
+        email: 'requestx@npm.org'
+    })
+}).json().then(console.log)
+``` 
 
     `.buffer()`  
     Returns the get response result as a buffer.  
         **Example:**
-> ```js 
-> request.post('https://postman-echo.com/post', {
->    data: JSON.stringify({
->        user: 'request',
->        password: 'requestx@node',
->        email: 'requestx@npm.org'
->    })
->}).buffer().then(console.log)
-> ``` 
+```js 
+request.post('https://postman-echo.com/post', {
+    data: JSON.stringify({
+        user: 'request',
+        password: 'requestx@node',
+        email: 'requestx@npm.org'
+    })
+}).buffer().then(console.log)
+``` 
 
     `.error()`  
     Useful to check if a request returns an error without stopping the Node proccess, returns `undefined` otherwise.  
         **Example:**  
-> ```js 
-> console.log(request.post('https://postman-echo.com/post', {
->    data: JSON.stringify({
->        user: 'request',
->        password: 'requestx@node',
->        email: 'requestx@npm.org'
->    })
->}).error())
-> //=> undefined
-> ```  
+```js 
+console.log(request.post('https://postman-echo.com/post', {
+    data: JSON.stringify({
+        user: 'request',
+        password: 'requestx@node',
+        email: 'requestx@npm.org'
+    })
+}).error())
+//=> undefined
+```  
 
    
-### **proxy**       `request.proxy(proxyUrl)`
+### **proxy**              `request.proxy(proxyUrl)`
 
 Proxies a request. Format the string like `protocol://proxyIp:proxyPort` (e.g. `http://127.0.0.1:3000`). Returns the type of request you want to make. Then, request the resource like normal.  
+
+### ***Please note:***
+As of now, this proxy only works with HTTP proxy servers.
+
         **Example:**  
-> ```js
-> request.proxy('http://127.0.0.1:80').get('https://wtfismyip.com/json').text().then(console.log)
-> ```
+```js
+request.proxy('http://127.0.0.1:80').get('https://wtfismyip.com/json').text().then(console.log)
+```
 

examples/get.js

@@ -1,5 +1,7 @@
-const request = require('../index')
+// makes a simple get request to log your ip address.
 
-console.log(request.get('http://ip.jsontest.com/?callback=showMyIP').error())
+const request = require('../index');
+
+request.get('http://ip.jsontest.com/?callback=showMyIP').text().then(console.log)
 
 //=> showMyIP({"ip": "127.0.0.1"});

examples/proxyPost.js

@@ -0,0 +1,13 @@
+const request = require('../index.js')
+
+request.proxy('http://50.206.25.108:80').post('https://postman-echo.com/post', {
+    data: JSON.stringify({
+        user: 'request',
+        password: 'requestx@node',
+        email: 'requestx@npm.org'
+    })
+}).text().then(console.log)
+
+/*
+request.proxy( PROXY URL ).get( REQUEST URL, REQUEST HEADERS).text().then(console.log)
+*/

index.js

@@ -1,9 +1,14 @@
+// types of requests
 const getReq = require('./lib/get.js')
 const postReq = require('./lib/post.js')
+// proxy requests
 const getProxy = require('./lib/getproxy.js')
+const postProxy = require('./lib/postproxy.js')
+// workers
 const validate_request = require('./workers/complete_validation.js')
 const validate_headers = require('./workers/validate_headers.js')
 
+// standard get request
 function get(url, headers) {
     validate_request( url, JSON.stringify(headers) )
     if(headers) { headers = JSON.parse(validate_headers.addHeaders(JSON.stringify(headers))) }
@@ -24,6 +29,7 @@ function get(url, headers) {
     };
 }
 
+// standard post request
 function post(url, headers) {
     validate_request( url, JSON.stringify(headers) )
     if(headers) { headers = JSON.parse(validate_headers.addHeaders(JSON.stringify(headers))) }
@@ -47,6 +53,7 @@ function post(url, headers) {
     };
 }
 
+// proxy a get request
 function proxyget(url, headers, proxy) {
     validate_request( url, JSON.stringify(headers) )
     if(headers) { headers = JSON.parse(validate_headers.addHeaders(JSON.stringify(headers))) }
@@ -57,31 +64,55 @@ function proxyget(url, headers, proxy) {
             return getProxy(url, headers, proxy).text()
         },
         json: function() {
-            return getProxy(url, headers).json()
+            return getProxy(url, headers, proxy).json()
         },
         buffer: function() {
-            return getProxy(url, headers).buffer()
+            return getProxy(url, headers, proxy).buffer()
         },
         error: function() {
-            return getProxy(url, headers).error()
+            return getProxy(url, headers), proxy.error()
         },
     };
 }
 
+// proxy a post request
+function proxypost(url, headers, proxy) {
+    validate_request( url, JSON.stringify(headers) )
+    if(headers) { headers = JSON.parse(validate_headers.addHeaders(JSON.stringify(headers))) }
+    else headers = JSON.parse(validate_headers.addHeaders(headers))
+    data = headers.data
+    return {
+        text: function() {
+            return postProxy(url, headers, data, proxy).text()
+        },
+        json: function() {
+            return postProxy(url, headers, proxy).json()
+        },
+        buffer: function() {
+            return postProxy(url, headers, proxy).buffer()
+        },
+        error: function() {
+            return postProxy(url, headers, proxy).error()
+        },
+    };
+}
+
+// main proxy function
 function proxy(proxyurl){
     return {
         get: function(url, headers) {
             return proxyget(url, headers, proxyurl)
         },
-        post: function() {
-            return getProxy(url, headers).json()
+        post: function(url, headers) {
+            return proxypost(url, headers, proxyurl)
         },
-        put: function() {
-            return getProxy(url, headers).buffer()
+        put: function(url, headers) {
+            return proxyput(url, headers, proxyurl)
         },
     };
 }
 
+// export main functions
 module.exports = {
     get,
     post,

lib/post.js

@@ -24,12 +24,14 @@ const post = (req_url, options, data) => {
           'Content-Type': 'application/json',
           'Content-Length': data.length
         }
-      }
+    }
+
+    options = { ...options, ...reqOptions }
     if(!agents[proto])agents[proto] = new reqx.Agent({ rejectUnauthorized: false, keepAlive: true });
 
     var request = reqx.request({
             agent: agents[proto],
-            ...reqOptions
+            ...options
         }, res => {
             var chunks = [];
 

lib/postproxy.js

@@ -0,0 +1,67 @@
+const url = require('url')
+const http = require('http')
+const https = require('https')
+
+const external_promise = require('../workers/external_promise.js')
+agents = {}
+const get = (req_url, options, data, proxy) => {    
+    options.method = 'POST'
+    var parsed_url = url.parse(proxy),
+    proto = parsed_url.protocol,
+    reqx = proto == 'https:' ? https : http,
+    promises = {
+        buffer: external_promise(),
+        text: external_promise(),
+        json: external_promise(),
+        err: external_promise(),
+    };
+    const reqOptions = {
+        hostname: parsed_url.hostname,
+        port: parsed_url.port,
+        path: req_url,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': data.length
+        }
+    }
+
+    options = { ...options, ...reqOptions }
+
+    var request = http.request(options, res => {
+            var chunks = [];
+
+            res.on('data', chunk => chunks.push(chunk)).on('end', () => {
+                var buf = Buffer.concat(chunks),
+                str = buf.toString('utf8');
+
+                if( promises.buffer.needed ) promises.buffer.resolve(buf);
+                if( promises.text.needed ) promises.text.resolve(str);
+                if( promises.json.needed ) try{
+                    promises.json.resolve(JSON.parse(str));
+                } catch( err ){
+                    promises.json.reject( err );
+                }
+
+            });
+        });
+
+    request.write(data)
+
+    request.on('error', err => { 
+        if( promises.err.needed ) promises.err.resolve( err )
+            else console.log(err)
+     });
+
+    request.end()
+
+
+    return {
+        text: () => (promises.text.needed = true, promises.text),
+        json: () => (promises.json.needed = true, promises.json),
+        buffer: () => (promises.buffer.needed = true, promises.buffer),
+        error: () => (promises.err.needed = true, promises.error),
+    }
+};
+
+module.exports = get

package.json

@@ -4,7 +4,7 @@
   "description": "",
   "main": "index.js",
   "scripts": {
-    "start": "node examples/get.js",
+    "start": "node examples/proxypost.js",
     "imagereq": "node examples/image.js",
     "proxyget": "node examples/proxy.js",
     "getreq": "node examples/get.js",