websom.carb

#include "core/services.carb"
#include "Oxygen/oxygen.carb"

namespace Websom {

}

class Websom.Server {
	<Websom.Bucket>array buckets = new <Websom.Bucket>array();
	map bucketReference = null;

	string version = "1.0";

	Websom.Services.Security security = null;
	Websom.Services.Module module = null;
	Websom.Services.Resource resource = null;
	Websom.Services.Router router = null;
	Websom.Services.View view = null;
	Websom.Services.Theme theme = null;
	Websom.Services.Database database = null;
	Websom.Services.Input input = null;
	Websom.Services.Crypto crypto = null;
	Websom.Services.Email email = null;
	Websom.Services.Render render = null;
	Websom.Services.Pack pack = null;
	Websom.Services.Notification notification = null;
	Websom.Services.Confirmation confirmation = null;
	Websom.Services.Micro micro = null;
	Websom.Services.Adaptation adaptation = null;
	Websom.Services.API api = null;
	Websom.Services.Session session = null;
	
	//Websom.Standard.Dashboard.Module dashboard = null;
	Websom.Standard.UserSystem.Module userSystem = null;
	Websom.Standard.CommerceSystem.Module commerceSystem = null;
	Websom.Standard.CoreModule coreModule = null;
	//Websom.Standard.PaymentSystem.Module paymentSystem = null;

	Websom.Config config = null;
	Websom.Services.Config configService = null;

	map rawInputConfig = null;

	string devDeploy = "development";

	string scriptPath = "";
	string websomRoot = "";

	string apiHost = "http://localhost:8970";
	string apiDomain = "localhost:8970";
	string clientHost = "http://localhost:8080";
	string clientDomain = "localhost:8080";
	string websiteName = "Websom site";


	// A location to store temporary files. This is changed to /tmp in serverless environments.
	string tmp = "";

	Websom.Status status = new Websom.Status();

	Websom.Server developmentServer = null;

	<void>function restartHandler = null;

	void expressServer = null;

	Websom.AdapterInterface bucketAdapter = null;

	Websom.Adapters.Bucket.Adapter bucket = null;

	<Websom.Bucket>array buckets = new <Websom.Bucket>array();

	`This is the legacy constructor, use the construct(map config) overload instead.`
	void @construct(Websom.Config config) {
		native php {
			$this->scriptPath = __FILE__;
		}

		native javascript {
			this.scriptPath = __filename;
		}

		this.websomRoot = FileSystem.resolve(FileSystem.dirName(this.scriptPath) + "/../../");

		this.config = config;
		this.config.legacy = true;

		// Async/await calls in a constructor are not allowed.
		native javascript {
			this.startServices();
		}

		native php {
			$this->startServices();
		}

		if (this.config.bucket)
			if ("reference" in this.config.bucket)
				this.bucketReference = this.config.bucket["reference"];
	}

	void @construct(map config) {
		this.rawInputConfig = config;

		native php {
			$this->scriptPath = __FILE__;
		}

		native javascript {
			this.scriptPath = __filename;
		}

		let basePath = "./";
		if (config["base"])
			basePath = config["base"];

		this.websomRoot = FileSystem.resolve(FileSystem.dirName(this.scriptPath) + "/../../");

		this.config = new Websom.Config();

		native javascript {
			const $path = require("path");

			this.config.absolute = $path.resolve(basePath);
			this.config.root = $path.resolve(basePath + "/" + config.assets);
		}

		native php {
			$this->config->absolute = dirname(__FILE__);
			$this->config->root = realpath($config->assets);
		}

		if (config["dev"]) {
			if (FileSystem.exists(this.config.absolute + "/tmp") == false)
				FileSystem.makeDir(this.config.absolute + "/tmp");
			
			this.tmp = this.config.absolute + "/tmp";
		}

		if ("dist" in config) {
			this.config.javascriptOutput = FileSystem.resolve(basePath + "/" + config["dist"]);
			this.config.cssOutput = FileSystem.resolve(basePath + "/" + config["dist"]);
		}

		if ("buckets" in config) {
			this.config.devBuckets = FileSystem.resolve(basePath + "/" + config["buckets"]);
		}

		if ("dev" in config) {
			this.config.dev = config["dev"] == true;
		}

		if ("headless" in config) {
			this.config.headless = config["headless"] == true;
		}

		if ("openInBrowser" in config) {
			this.config.openInBrowser = config["openInBrowser"] == true;
		}

		if ("verbose" in config) {
			this.config.verbose = config["verbose"] == true;
		}

		if ("deploy" in config) {
			this.devDeploy = config["deploy"];
		}

		if ("config" in config) {
			this.config.configOverrides = FileSystem.resolve(basePath + "/" + config["config"]);

			let deploys = FileSystem.resolve(basePath + "/" + config["config"] + "/deploy.json");
			if (FileSystem.exists(deploys)) {
				this.config.deploys = Websom.Json.parse(FileSystem.readSync(deploys, "utf8"));
			}

			if (this.devDeploy != "development") {
				let deploy = this.getDeploy(this.devDeploy);

				if (deploy != null and deploy["useApi"]) {
					//let data = Websom.Json.parse(FileSystem.readSync(FileSystem.resolve(this.config.configOverrides + "/" + deploy["useApi"]), "utf8"));
					this.apiHost = deploy["useApi"];
					this.apiDomain = this.apiHost.replace("https://", "").replace("http://", "");
					let splits = this.apiDomain.split("/");
					this.apiDomain = splits[0];
				}

				if (deploy != null and deploy["useClient"]) {
					//let data = Websom.Json.parse(FileSystem.readSync(FileSystem.resolve(this.config.configOverrides + "/" + deploy["useClient"]), "utf8"));
					this.clientHost = deploy["useClient"];
					this.clientDomain = this.clientHost.replace("https://", "").replace("http://", "");
					let splits = this.clientDomain.split("/");
					this.clientDomain = splits[0];
				}
			}
		}

		if ("name" in config) {
			this.config.name = config["name"];
		}else{
			this.config.name = "Websom Website";
		}

		this.config.bucketPrefix = this.config.name.replace(" ", "-").toLower();

		if ("bucketPrefix" in config) {
			this.config.bucketPrefix = config["bucketPrefix"];
		}

		// Check if the config dirs exist, and create them if not.
		if (this.config.dev) {
			if (FileSystem.exists(this.config.devBuckets) == false) {
				FileSystem.makeDir(this.config.devBuckets);
			}

			if (FileSystem.exists(this.config.root) == false) {
				FileSystem.makeDir(this.config.root);
			}

			if (this.config.configOverrides.length > 0 and FileSystem.exists(this.config.configOverrides) == false) {
				FileSystem.makeDir(this.config.configOverrides);
			}

			if (FileSystem.exists(this.config.javascriptOutput) == false) {
				FileSystem.makeDir(this.config.javascriptOutput);
			}
		}
	}

	void registerBucket(Websom.Bucket bucket) {
		if (this.config.dev) {
			this.bucket.registerBucket(bucket);
		}

		this.buckets.push(bucket);
	}

	trust void registerServiceCollection(Websom.Adapters.Database.Collection collection) {
		if (this.config.dev)
			if (collection.appliedSchema != null)
				collection.appliedSchema.register();
	}

	map getDeploy(string name) {
		if (this.config.deploys == null or this.config.deploys["deploys"] == null)
			return null;
		
		let <map>array deploys = this.config.deploys["deploys"];

		return deploys.find(bool (map d) => {
			return d["name"] == name;
		});
	}

	Websom.AdapterInterface adapt(string name) {
		return this.adaptation.adapt(name);
	}

	string getConfigString(string route, string option) {
		return this.configService.getString(route, option);
	}

	string getConfigPrimitive(string route, string option) {
		return this.configService.getPrimitive(route, option);
	}

	void logException(Exception e) {
		if (this.config.dev) {
			native javascript {
				const chalk = require("chalk");
				console.log("");
				console.log(chalk.white.bgRed.bold("--- ⚠️  Package Exception ⚠️  ---"));
				console.log("");
				console.log(chalk.red(e.stack));
				console.log("");
			}

			native php {
				die($e->getMessage());
			}
		}
	}

	void startServices() {
		this.configService = new Websom.Services.Config(this);
		this.status.inherit(this.configService.start());

		this.api = new Websom.Services.API(this);

		this.adaptation = new Websom.Services.Adaptation(this);
		this.status.inherit(this.adaptation.start());

		this.database = new Websom.Services.Database(this);
		this.session = new Websom.Services.Session(this);
		this.security = new Websom.Services.Security(this);
		this.module = new Websom.Services.Module(this);
		this.theme = new Websom.Services.Theme(this);
		this.resource = new Websom.Services.Resource(this);
		this.view = new Websom.Services.View(this);
		this.router = new Websom.Services.Router(this);
		this.pack = new Websom.Services.Pack(this);
		this.input = new Websom.Services.Input(this);
		this.crypto = new Websom.Services.Crypto(this);
		this.email = new Websom.Services.Email(this);
		this.micro = new Websom.Services.Micro(this);
		this.render = new Websom.Services.Render(this);
		this.notification = new Websom.Services.Notification(this);
		this.confirmation = new Websom.Services.Confirmation(this);

		this.bucketAdapter = this.adapt("bucket");
		this.bucketAdapter.exposeToClient = true;

		this.status.inherit(this.confirmation.start());

		this.status.inherit(this.session.start());
		this.status.inherit(this.module.start());

		let everything trickTheStupidCompiler = this.module.getModule("coreModule");
		this.coreModule = trickTheStupidCompiler;

		if (this.bucketAdapter.loadFromConfig() == false) {
			this.bucketAdapter.load(this.coreModule, "CoreModule.FileSystemBucket");
		}

		this.bucket = this.bucketAdapter.adapter;

		this.database.loadAdapter();
		this.security.loadAdapter();

		this.status.inherit(this.database.start());
		this.configService.loadFromDatabase();
		this.status.inherit(this.security.start());
		this.status.inherit(this.resource.start());
		this.status.inherit(this.view.start());
		this.status.inherit(this.theme.start());

		if (this.config.legacy == false) {
			this.configService.gatherOptions();
			this.module.startModules();
		}

		this.session.collection();

		this.status.inherit(this.router.start());
		this.status.inherit(this.pack.start());
		this.status.inherit(this.input.start());
		this.status.inherit(this.crypto.start());
		this.status.inherit(this.email.start());
		this.status.inherit(this.micro.start());
		this.status.inherit(this.render.start());
		this.status.inherit(this.notification.start());

		this.status.inherit(this.api.start());
	}

	Websom.Command command(string name) {
		return this.micro.command.register(name);
	}

	void injectExpression(string src) {
		this.router.injectScript = src;
	}

	Websom.Bucket getBucketFromReference(string referenceName) {
		if (referenceName in this.bucketReference)
			return this.getBucket(this.bucketReference[referenceName]["bucket"]);
		return null;
	}

	trust void log(everything value) {
		native javascript {
			console.log(value);
		}
	}

	Websom.RequestChain request(string url) {
		return new Websom.RequestChain(this, url);
	}

	Websom.Bucket getBucket(string name) {
		for (var int i in this.buckets) {
			if (this.buckets[i].name == name)
				return this.buckets[i];
		}

		var map buckets = this.config.bucket["buckets"];
		if (name in buckets)
			return this.loadBucket(name, buckets[name]);
	}

	Websom.Bucket loadBucket(string name, map raw) {
		var string type = raw["type"]; //TODO: Validate raw
		var bucket = Websom.Bucket.make(this, name, type, raw);
		this.buckets.push(bucket);
		return bucket;
	}

	void spawnRealServer() {
		this.developmentServer = new Websom.Server(this.rawInputConfig);
		this.developmentServer.start();
		let debounce = false;

		this.developmentServer.restartHandler = void () => {
			if (debounce == false) {
				debounce = true;
				Console.log("Restarting websom server");
				this.developmentServer.stop();
				this.spawnRealServer();
			}
		};
	}

	void startDevelopmentServer() {
		this.spawnRealServer();
		this.startWebpackServer(8080, 8970);
	}

	void start() {
		this.start(8080, 8970);
	}

	void stop() {
		native javascript {
			if (this.expressServer !== null)
				this.expressServer.close();
		}

		this.api.stop();
		this.adaptation.stop();
		this.database.stop();
		this.session.stop();
		this.security.stop();
		this.module.stop();
		this.theme.stop();
		this.resource.stop();
		this.view.stop();
		this.router.stop();
		this.pack.stop();
		this.input.stop();
		this.crypto.stop();
		this.email.stop();
		this.micro.stop();
		this.render.stop();
		this.notification.stop();
		this.confirmation.stop();
	}

	void sendResponse(Websom.Response response) {

	}

	Websom.Request makeRequestFromExpress(void req) {
		native javascript {
			var client = new Websom.Client(req.socket.remoteAddress, req.socket.remotePort);
			
			client.family = req.socket.remoteFamily;
			client.localAddress = req.socket.localAddress;
			client.localPort = req.socket.localPort;

			var websomRequest = new Websom.Request(this, client);
			websomRequest.path = req.path;
			websomRequest.cookies = req.cookies;
			websomRequest.headers = req.headers;
			websomRequest.body = req.body;
			websomRequest.jsRequest = req;

			return websomRequest;
		}
	}

	void expressAPIOptionsRequest(void req, void res, string path) {
		native javascript {
			res.header("Access-Control-Allow-Origin", "*");
			res.setHeader("Access-Control-Allow-Headers", "*");
			res.setHeader("X-Powered-By", "Websom");
			res.send("POST");
		}
	}

	void expressAPIRequest(void req, void res, string path, string method) {
		native javascript {
			var client = new Websom.Client(req.socket.remoteAddress, req.socket.remotePort);
			
			client.family = req.socket.remoteFamily;
			client.localAddress = req.socket.localAddress;
			client.localPort = req.socket.localPort;

			var websomRequest = new Websom.Request(this, client);
			websomRequest.path = decodeURIComponent(path);
			websomRequest.cookies = req.cookies;
			websomRequest.headers = req.headers;
			websomRequest.body = req.body;
			websomRequest.files = {};
			for (let file in req.files) websomRequest.files[file] = req.files[file].file;
			websomRequest.response.jsResponse = res;
			websomRequest.jsRequest = req;
			
			res.setHeader("X-Powered-By", "Websom");
			res.setHeader("Access-Control-Allow-Origin", "*");
			res.setHeader("Access-Control-Allow-Headers", "*");
			res.setHeader("Access-Control-Expose-Headers", "X-Set-Session");

			this.processAPIRequest(websomRequest, method);
		}
	}

	void startAPI(int port) {
		native javascript {
			const express = require("express");
			const busboy = require("express-busboy");
			const cookieParser = require("cookie-parser");
			const crypto = require("crypto");

			let server = express();
			
			//server.use(bodyParser.json());
			busboy.extend(server, {
				upload: true,
				limits: {
					fieldSize: 1024 * 1024 * 10 // 10mb (gcp max is 10mb, aws max is 6mb)
				}
			});

			server.use(cookieParser());

			server.options(/.*/, (req, res) => {
				this.expressAPIOptionsRequest(req, res, req.path);
			});

			server.post(/.*/, (req, res) => {
				this.expressAPIRequest(req, res, req.path, "post");
			});

			server.get(/.*/, (req, res) => {
				this.expressAPIRequest(req, res, req.path, "get");
			});

			this.expressServer = server.listen(port);

			console.log("API server listening on port " + port);
		}
	}

	void processAPIRequest(Websom.Request req, string method) {
		let apiPass = false;

		if (method == "post") {
			apiPass = this.api.request(req);
		}else if (method == "get") {
			apiPass = this.api.getRequest(req);
		}

		if (apiPass == false) {
			// Handle routes

			req.code(404);
			req.end("No endpoint here...");
		}
	}

	void startWebpackServer(int uiPort, int apiPort) {
		native javascript {
			const nodeDevPlatform = require(_c_this.websomRoot + "/platform/node/index.js");
			
			if (!_c_this.config.headless)
				nodeDevPlatform.startWebsomDevelopmentServer(() => {
					return this.developmentServer || this;
				}, uiPort, apiPort);
		}
	}

	void start(int uiPort, int apiPort) {
		this.startServices();

		if (this.config.dev) {
			native javascript {
				this.startAPI(apiPort);
			}

			native php {
				die("WEBSOM: Error, please use \$server->run(\$route) in php environments. Note: dev mode only works while running a node server.");
			}
		}else{
			// TODO: new production model.
		}
	}

	void listen(int port) {
		native javascript {
			var that = this;
			
			const express = require("express");
			const session = require("express-session");
			const fileStore = require("session-file-store")(session);
			const bodyParser = require("body-parser");
			const multer = require("multer");
			const crypto = require("crypto");
			const fs = require("fs");

			var server = express();
			if (!this.config.gzip) {
				server.use("/resources", express.static(this.config.resources));
			}else{
				server.use("/resources", require("express-static-gzip")(this.config.resources));
			}
			
			var sessionSecret = crypto.randomBytes(64).toString('hex');
			
			if (!fs.existsSync(this.config.root + "/secret.txt"))
				fs.writeFileSync(this.config.root + "/secret.txt", sessionSecret);
			else
				sessionSecret = fs.readFileSync(this.config.root + "/secret.txt", "utf8");

			var secure = false;

			if (this.config.https)
				secure = true;

			server.use(session({
				secret: sessionSecret,
				store: new fileStore(),
				resave: false,
				cookie: {
					secure: secure
				}
			}));

			server.get(/.*/, (req, res) => {
				if (that.config.dev)
					if (that.status.hadError) {
						console.log(that.status.display());
						that.status.clear();
					}
				
				var client = new Websom.Client(req.socket.remoteAddress, req.socket.remotePort);
				
				client.family = req.socket.remoteFamily;
				client.localAddress = req.socket.localAddress;
				client.localPort = req.socket.localPort;

				var websomRequest = new Websom.Request(that, client);
				websomRequest.path = req.path;
				websomRequest.response.jsResponse = res;
				websomRequest.jsRequest = req;
				that.router.handle(websomRequest);
			});

			server.post(/^((?!\/postInput|\/postBridge|\/postInputM).)*$/, bodyParser.urlencoded({limit: '160mb', extended: true}), (req, res) => {
				if (!req.body) {
					res.sendStatus(400);
					res.send("Invalid post");
				}else{
					var client = new Websom.Client(req.socket.remoteAddress, req.socket.remotePort);
			
					client.family = req.socket.remoteFamily;
					client.localAddress = req.socket.localAddress;
					client.localPort = req.socket.localPort;
					
					var websomRequest = new Websom.Request(that, client);
					websomRequest.path = req.path;
					websomRequest.response.jsResponse = res;
					websomRequest.jsRequest = req;
					that.router.handlePost(req.body, websomRequest);
				}
			});

			server.post("/postInput", bodyParser.urlencoded({limit: '160mb', extended: true}), (req, res) => {
				if (!req.body) {
					res.sendStatus(400);
					res.send("Invalid post"); //TODO: Make generic with Websom.Error...
				}else{
					if (("inputKey" in req.body) && typeof req.body.inputKey == "string" && req.body.inputKey.length > 0 && req.body.inputKey.length < 2048 && ("data" in req.body)) {
						var client = new Websom.Client(req.socket.remoteAddress, req.socket.remotePort);
				
						client.family = req.socket.remoteFamily;
						client.localAddress = req.socket.localAddress;
						client.localPort = req.socket.localPort;
						
						var websomRequest = new Websom.Request(that, client);
						websomRequest.path = req.path;
						websomRequest.response.jsResponse = res;
						websomRequest.jsRequest = req;
						this.input.handle(req.body.inputKey, req.body.data, websomRequest);
					}else{
						res.sendStatus(400);
						res.send("Invalid post");
					}
				}
			});

			server.post("/postInputM", multer({dest: "/tmp", limits: {files: 50, fileSize: 1024 * 1024 * 160}}).any(), (req, res) => { // Multipart form
				if (!req.body) {
					res.sendStatus(400);
					res.send("Invalid post"); //TODO: Make generic with Websom.Error...
				}else{
					if (("inputKey" in req.body) && typeof req.body.inputKey == "string" && req.body.inputKey.length > 0 && req.body.inputKey.length < 2048 && ("data" in req.body) && typeof req.body.data == "string") {
						var client = new Websom.Client(req.socket.remoteAddress, req.socket.remotePort);
				
						client.family = req.socket.remoteFamily;
						client.localAddress = req.socket.localAddress;
						client.localPort = req.socket.localPort;
						
						var websomRequest = new Websom.Request(that, client);
						websomRequest.path = req.path;
						websomRequest.response.jsResponse = res;
						websomRequest.jsRequest = req;
						let data = req.body.data;

						try {
							data = JSON.parse(data);
						}catch (e) {
							res.sendStatus(400);
							res.send("Invalid post");

							return;
						}

						this.input.handle(req.body.inputKey, data, websomRequest);
					}else{
						/*for (let files of req.files) {
							for (let file of files) {
								fs.unlinkSync(file);
							}
						}*/
						res.sendStatus(400);
						res.send("Invalid post");
					}
				}
			});

			server.post("/postBridge", bodyParser.urlencoded({limit: '160mb', extended: true}), (req, res) => {
				if (!req.body) {
					res.sendStatus(400);
					res.send("Invalid post"); //TODO: Make generic with Websom.Error...
				}else{
					if (("bridge" in req.body) && typeof req.body.bridge == "string" && req.body.bridge.length > 0 && req.body.bridge.length < 2048 &&
						("method" in req.body) && typeof req.body.method == "string" && req.body.method.length > 0 && req.body.method.length < 2048) {
						var client = new Websom.Client(req.socket.remoteAddress, req.socket.remotePort);
				
						client.family = req.socket.remoteFamily;
						client.localAddress = req.socket.localAddress;
						client.localPort = req.socket.localPort;
						
						var websomRequest = new Websom.Request(that, client);
						websomRequest.path = req.path;
						websomRequest.response.jsResponse = res;
						websomRequest.jsRequest = req;
						this.module.handleBridge(websomRequest, req.body.bridge, req.body.method, req.body.arguments || []);
					}
				}
			});

			server.listen(port);
		}

		native php {
			throw new Exception("Use Websom.Server.run(string route) for php servers");
		}
	}

	void run(string route) {
		native php {
			$client = new Websom_Client($_SERVER["REMOTE_ADDR"], $_SERVER["REMOTE_PORT"]);
			$request = new Websom_Request($this, $client);
			$request->path = $route;
			if ($this->status->hadError) {
				echo $this->status->display();
			}
			if (isset($_POST["inputKey"])) { //TODO: Add post method with generic helper
				if (gettype($_POST["inputKey"]) == "string" AND strlen($_POST["inputKey"]) > 0 AND strlen($_POST["inputKey"]) < 2048 AND ($_POST["data"])) {
					$data = $_POST["data"];
					if (gettype($data) == "string") {
						$data = json_decode($data, true);
					}

					$this->input->handle($_POST["inputKey"], $data, $request);
				}
			}else if (isset($_POST["bridge"])) {
				if (gettype($_POST["bridge"]) == "string" AND strlen($_POST["bridge"]) > 0 AND strlen($_POST["bridge"]) < 2048 AND 
					gettype($_POST["method"]) == "string" AND strlen($_POST["method"]) > 0 AND strlen($_POST["method"]) < 2048) {
					
					$this->module->handleBridge($request, $_POST["bridge"], $_POST["method"], isset($_POST["arguments"]) ? $_POST["arguments"] : []);
				}
			}else{
				$this->router->handle($request);
			}
		}
	}
}