telos-autocors 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# AutoCORS
+
+## 1 - Abstract
+
+***You Shall Pass!***
+
+AutoCORS is a JavaScript IO library, which, among other things, provides a set utilities, built
+upon associated conventions, which enable in-browser HTTP requests to be automatically routed
+through CORS proxies.
+
+## 2 - Contents
+
+### 2.1 - Conventions
+
+#### 2.1.1 - HTTP JSON
+
+HTTP JSON is a JSON object format for representing HTTP requests and responses.
+
+An HTTP JSON object shall have a "request" field if representing a request, and a "response" field
+if representing a response. Either type may optionally have a "headers" field and a "body" field.
+
+The request field shall contain an object which shall have the string fields "method", specifying
+the HTTP method of the request "uri", specifying the URI or URL of the request, and, optionally,
+"version", specifying the version of the request.
+
+The response field shall contain an object which shall have the string fields "version", specifying
+the HTTP version of the response, "status", specifying the status code of the response, and
+"reason", specifying the reason for said status code.
+
+The headers field, if present, contains an object where each field's alias defines the alias of an
+HTTP header, and the corresponding value is a string specifying the value of said header.
+
+The body field, if present, contains a string specifying the body of the HTTP request or response.
+
+##### 2.1.1.1 - HTTP JSON Examples
+
+An HTTP JSON GET request to example.com:
+
+    { "request": { "method: "GET", uri: "https://example.com/" } }
+
+An HTTP JSON POST request to example.com:
+
+    {
+    	"request": { "method: "POST", uri: "https://example.com/" },
+    	"headers": {
+    		"Host": "example.com",
+    		"Content-Type": "application/x-www-form-urlencoded",
+    		"Content-Length": "27"
+    	},
+    	"body": "field1=value1\nfield2=value2"
+    }
+
+### 2.2 - Usage
+
+AutoCORS may be used on any page via the AutoCORS script.
+
+Once included,  sthe scripehall place an object with the alias "autoCORS" into the global namespace
+of the page.
+
+The default functionality of AutoCORS can be activated by running:
+
+    autoCORS.applyDefault();
+
+This will modify the XMLHttpRequest and fetch APIs to automatically route all requests through a
+CORS proxy.
+
+Manual customization of the behavior of AutoCORS is possible, though it requires an understanding
+of HTTP JSON.
+
+#### 2.2.1 - Script CDN
+
+The AutoCORS script can be included in your website from the following CDN link:
+
+    https://cdn.jsdelivr.net/gh/Telos-Project/AutoCORS/Code/autoCORS.js
+
+#### 2.2.2 - Supported Proxies
+
+The AutoCORS script makes use of [https://corsproxy.io/](https://corsproxy.io/) by default.

package/apintUtils.js

@@ -0,0 +1,114 @@
+var apintUtils = {
+	buildAPInt: (apint, path) => {
+
+		apint = JSON.parse(JSON.stringify(apint));
+		path = path != null ? path : [];
+
+		if(apint.packages == null)
+			return apint;
+
+		Object.keys(apint.packages).forEach(key => {
+
+			if(typeof apint.packages[key] == "string") {
+
+				if(path.includes(apint.packages[key]))
+					return;
+
+				apint.packages[key] = apintUtils.buildAPInt(
+					use(apint.packages[key]),
+					path.concat(apint.packages[key])
+				);
+			}
+
+			else {
+
+				apint.packages[key] = apintUtils.buildAPInt(
+					apint.packages[key], path
+				);
+			}
+		})
+
+		return apint;
+	},
+	queryUtilities: (apint, path, properties, inheritance) => {
+
+		path = path != null ? path : [];
+
+		if(typeof path == "string")
+			path = path.split(".").map(item => item.toLowerCase());
+
+		inheritance = inheritance != null ?
+			JSON.parse(JSON.stringify(inheritance)) : { };
+
+		properties = properties != null ? properties : { };
+
+		if(apint.properties != null)
+			Object.assign(inheritance, apint.properties);
+
+		let utilities = [];
+
+		if(path.length <= 1 && apint.utilities != null) {
+
+			Object.keys(apint.utilities).forEach(key => {
+
+				let utility = JSON.parse(JSON.stringify(apint.utilities[key]));
+
+				utility.properties = Object.assign(
+					Object.assign({ }, inheritance),
+					utility.properties != null ? utility.properties : { }
+				);
+
+				let match = true;
+
+				Object.keys(properties).forEach((item) => {
+					
+					if(JSON.stringify(properties[item]) !=
+						JSON.stringify(utility.properties[item])) {
+						
+						match = false;
+					}
+				});
+
+				if(match)
+					utilities.push(utility);
+			});
+		}
+
+		if(apint.packages != null) {
+
+			Object.keys(apint.packages).forEach(key => {
+
+				if(typeof apint.packages[key] == "string")
+					return;
+
+				if(path.length > 0) {
+
+					if(key.toLowerCase() == path[0])
+						path = path.slice(1);
+				}
+
+				utilities = utilities.concat(
+					apintUtils.queryUtilities(
+						apint.packages[key], path, properties, inheritance
+					)
+				);
+			});
+		}
+
+		return utilities;
+	},
+	loadUtility: (apint, query) => {
+
+		let utility = apintUtils.queryUtilities(apint, query)[0];
+
+		if(utility == null)
+			return null;
+
+		return use(
+			Array.isArray(utility.source) ? utility.source[0] : utility.source
+		);
+	}
+};
+
+if(typeof module == "object")
+	module.exports = apintUtils;

package/autoCORS.js

@@ -0,0 +1,468 @@
+var autoCORS = {
+	applyDefault: () => {
+
+		autoCORS.proxy = autoCORS.utils.proxies.corsProxy;
+
+		autoCORS.onSend(autoCORS.onRequestDefault);
+	},
+	defaultFetch: typeof window != "undefined" ? window.fetch : null,
+	DefaultXMLHttpRequest: typeof window != "undefined" ?
+		window.XMLHttpRequest : null,
+	getPlatform: () => {
+
+		if(typeof process === 'object') {
+
+			if(typeof process.versions === 'object') {
+
+				if(typeof process.versions.node !== 'undefined') {
+					return "node";
+				}
+			}
+		}
+
+		return "browser";
+	},
+	disable: () => {
+		window.XMLHttpRequest = autoCORS.DefaultXMLHttpRequest;
+		window.fetch = autoCORS.defaultFetch;
+	},
+	input: (text) => {
+
+		return autoCORS.getPlatform() == "browser" ?
+			prompt(text) : require("readline-sync").question(text);
+	},
+	onRequestDefault: (request) => {
+		return autoCORS.proxy != null ? autoCORS.proxy(request) : null;
+	},
+	onSend: (onRequest, onResponse) => {
+
+		window.XMLHttpRequest = class extends autoCORS.DefaultXMLHttpRequest {
+
+			constructor() {
+
+				super();
+
+				this.request = {
+					request: {
+						method: "",
+						uri: ""
+					},
+					headers: {
+
+					},
+					body: null
+				};
+
+				this.sync = false;
+			}
+
+			open(method, uri, sync) {
+
+				this.request.request.method = method;
+				this.request.request.uri = uri;
+
+				this.sync = sync;
+			}
+
+			setRequestHeader(name, value) {
+				this.request.headers[name] = value;
+			}
+
+			send(body) {
+
+				this.request.body = body;
+
+				this.request = onRequest(this.request);
+
+				let response = onResponse != null ?
+					onResponse(this.request) : null;
+
+				if(response != null) {
+
+					Object.defineProperty(this, 'readyState', {
+						value: 4,
+						writable: true
+					});
+
+					Object.defineProperty(this, 'status', {
+						value: 200,
+						writable: true
+					});
+
+					Object.defineProperty(this, 'responseText', {
+						value: "" + response,
+						writable: true
+					});
+
+					if(this.onreadystatechange != null)
+						this.onreadystatechange();
+				}
+
+				else {
+					
+					super.open(
+						this.request.request.method,
+						this.request.request.uri,
+						this.sync
+					);
+
+					Object.keys(this.request.headers).forEach(key => {
+						super.setRequestHeader(key, this.request.headers[key]);
+					});
+
+					super.send(this.request.body);
+				}
+			}
+		}
+
+		window.fetch = (uri, options) => {
+
+			options = options != null ? options : { };
+
+			let request = {
+				request: {
+					method: options.method != null ?
+						options.method : "GET", uri: uri
+				},
+				headers: options.headers,
+				body: options.body
+			}
+
+			request = onRequest != null ? onRequest(request) : request;
+
+			let response = onResponse != null ? onResponse(request) : null;
+
+			return onResponse == null ?
+				autoCORS.defaultFetch(url, options) :
+				new Promise(
+					(resolve) => {
+						resolve({ text: () => { return response; } });
+					}
+				);
+		}
+	},
+	proxy: null,
+	read: (path, callback) => {
+
+		if(typeof path == "function") {
+
+			let input = document.createElement("input");
+	
+			input.setAttribute("type", "file");
+			input.setAttribute("style", "display: none");
+	
+			let listener = function(event) {
+	
+				let upload = event.target.files[0];
+	
+				if(!upload)
+					return;
+				
+				let reader = new FileReader();
+	
+				reader.onload = function(event) {
+					path(event.target.result, upload.name);
+				};
+	
+				reader.readAsText(upload);
+			}
+	
+			input.addEventListener(
+				'change',
+				listener,
+				false
+			);
+	
+			document.documentElement.appendChild(input);
+	
+			input.click();
+	
+			document.documentElement.removeChild(input);
+
+			return;
+		}
+
+		if(autoCORS.getPlatform() == "browser" ||
+			path.startsWith("http://") ||
+			path.startsWith("https://")) {
+
+			let response = autoCORS.send(
+				{ request: { method: "GET", uri: path } },
+				callback != null ?
+					(response) => { callback(response.body); } : null
+			);
+
+			return callback != null ? null : response.body;
+		}
+
+		return callback != null ?
+			require("fs").readFile(path, "utf-8", callback) :
+			require("fs").readFileSync(path, "utf-8");
+	},
+	send: (request, callback) => {
+
+		if(typeof request == "string")
+			request = autoCORS.toJSON(request);
+
+		let call = autoCORS.getPlatform() == "browser" ?
+			new XMLHttpRequest() :
+			new (require("xmlhttprequest").XMLHttpRequest)();
+		
+		call.open(
+			request.request.method, request.request.uri, callback != null
+		);
+
+		if(request.headers != null) {
+			
+			let keys = Object.keys(request.headers);
+
+			for(let i = 0; i < keys.length; i++)
+				call.setRequestHeader(keys[i], request.headers[keys[i]]);
+		}
+		
+		var response = {
+			response: { version: "", status: "" },
+			headers: { },
+			body: ""
+		};
+		
+		call.onreadystatechange = function() {
+		
+			if(call.readyState === 4) {
+
+				response.response.status = call.status;
+
+				let headers = call.getAllResponseHeaders().trim();
+
+				if(headers != null) {
+
+					headers = headers.split("\r\n");
+
+					for(let i = 0; i < headers.length; i++) {
+
+						let header = headers[i].split(":");
+
+						if(header.length >= 2) {
+
+							response.headers[header[0].trim()] =
+								header[1].trim();
+						}
+
+						else
+							response.headers[header[0].trim()] = "";
+					}
+				}
+		
+				response.body = call.responseText;
+
+				if(callback != null)
+					callback(response);
+			}
+		}
+		
+		call.send(request.body);
+		
+		if(callback == null)
+			return response;
+	},
+	toHTTP: (json) => {
+
+		let http = "";
+
+		if(json.request != null) {
+
+			http += json.request.method + " ";
+			http += json.request.uri;
+
+			if(json.request.version != null)
+				http += " " + json.request.version;
+		}
+
+		else {
+
+			if(json.response.version != null)
+				http += " " + json.response.version;
+
+			if(json.response.status != null)
+				http += " " + json.response.status;
+
+			if(json.response.reason != null)
+				http += " " + json.response.reason;
+		}
+
+		if(json.headers != null) {
+
+			let keys = Object.keys(json.headers);
+
+			for(let i = 0; i < keys.length; i++)
+				http += "\n" + keys[i] + ": " + json.headers[keys[i]];
+		}
+
+		if(json.body != null)
+			http += "\n\n" + json.body;
+
+		return http;
+	},
+	toJSON: (http) => {
+
+		let json = { };
+
+		let lines = http.split("\n");
+		let definition = lines[0].split(" ");
+
+		if(!definition[0].includes("/")) {
+
+			json.request = {
+				method: definition[0],
+				uri: definition[1]
+			};
+
+			if(definition.length >= 3)
+				json.request.version = definition[2];
+		}
+
+		else {
+
+			json.response = {
+				version: definition[0],
+				status: definition[1]
+			};
+
+			if(definition.length >= 3) {
+
+				json.response.reason = lines[0].substring(
+					definition[0].length + definition[1].length + 2
+				);
+			}
+		}
+
+		for(let i = 1; i < lines.length; i++) {
+
+			if(lines[i].trim() != "") {
+
+				if(json.headers == null)
+					json.headers = { };
+
+				let alias =
+					lines[i].substring(0, lines[i].indexOf(":")).trim();
+
+				let value =
+					lines[i].substring(lines[i].indexOf(":") + 1).trim();
+
+				json.headers[alias] = value;
+			}
+
+			else {
+
+				json.body = lines.slice(i + 1).join("\n");
+
+				break;
+			}
+		}
+
+		return json;
+	},
+	utils: {
+		checkWhitelist: (uri) => {
+
+			return autoCORS.utils.whitelist.filter(
+				item => item.endsWith("/") ?
+					uri.toLowerCase().startsWith(item.toLowerCase()) :
+					uri.toLowerCase() == item.toLowerCase()
+			).length == 0;
+		},
+		formatGithubURI: (uri) => {
+
+			uri = uri.substring(34);
+			let user = uri.substring(0, uri.indexOf("/"));
+
+			uri = uri.substring(uri.indexOf("/") + 1);
+			let repo = uri.substring(0, uri.indexOf("/"));
+
+			uri = uri.substring(uri.indexOf("/") + 1);
+
+			return "https://cdn.jsdelivr.net/gh/" +
+				user +
+				"/" +
+				repo +
+				"/" +
+				uri.substring(uri.indexOf("/") + 1);
+		},
+		proxies: {
+			corsProxy: (request) => {
+
+				if(!autoCORS.utils.checkWhitelist(request.request.uri))
+					return request;
+
+				request = JSON.parse(JSON.stringify(request));
+
+				if(request.request.uri.startsWith(
+					"https://raw.githubusercontent.com/")) {
+
+					request.request.uri =
+						autoCORS.utils.formatGithubURI(
+							request.request.uri
+						);
+				}
+
+				else {
+				
+					request.request.uri =
+						"https://corsproxy.io/?url=" +
+							encodeURIComponent(
+								request.request.uri
+							).split("%20").join("%2520");
+				}
+
+				return request;
+			}
+		},
+		whitelist: [
+			"http://127.0.0.1",
+			"https://127.0.0.1",
+			"http://localhost",
+			"https://localhost",
+			"https://cdn.jsdelivr.net/"
+		]
+	},
+	write: (path, content, callback) => {
+
+		if(autoCORS.getPlatform() == "browser") {
+
+			if(callback == true) {
+
+				let element = document.createElement('a');
+		
+				element.setAttribute(
+					'href',
+					'data:text/plain;charset=utf-8,' +
+						encodeURIComponent(content));
+			
+				if(path != null)
+					element.setAttribute('download', path);
+			
+				element.style.display = 'none';
+				document.documentElement.appendChild(element);
+			
+				element.click();
+			
+				document.documentElement.removeChild(element);
+			}
+
+			// STUB - DOWNLOAD / VIRTUAL SYSTEM
+
+			return;
+		}
+
+		if(callback != null)
+			require("fs").writeFile(path, content, "utf-8", callback);
+
+		else
+			require("fs").writeFileSync(path, content);
+
+		// STUB - FILL IN NON-EXISTENT PATHS
+	}
+};
+
+if(typeof module == "object")
+	module.exports = autoCORS;

package/package.json

@@ -0,0 +1,13 @@
+{
+	"name": "telos-autocors",
+	"version": "1.0.0",
+	"description": "IO Library Featuring Automatic CORS Proxy Routing for HTTP Requests",
+	"main": "autoCORS.js",
+	"dependencies": {
+		"readline-sync": "~1.0.0",
+		"xmlhttprequest": "^1.8.0"
+	},
+	"author": "",
+	"license": "Apache-2.0",
+	"homepage": "https://github.com/Telos-Project/AutoCORS"
+}