@dynacom/blaze/lib/server.js

const Domain = require('./domain.js');
const BlazeError = require('./error.js');

const urlPattern = require('url-pattern');
const url = require('url');
const fs = require('fs-extra');
const path = require('path');
const mime = require('mime-types');
const protocols = {
	"https": require('https'),
	"http": require('http')
}

const Plugin = require('./plugins.js');
const form = require('./form.js');
const context = require('./context.js');

module.exports = class server {
	constructor(config) {
		this.Instances = [];
		this.Log = new require('./logger.js')(config.logger);

		let instances = [];
		config.http.ports.forEach(port => {
			instances.push({ protocol: 'http', port: port });
		});

		config.https.ports.forEach(port => {
			instances.push({ protocol: 'https', port: port });
		});
		instances.forEach(instanceConfig => {
			let serverInstance = protocols[instanceConfig.protocol].createServer({ SNICallback: Domain.handleSSL });
			serverInstance.on('request', async (request, response) => { await this.handleRequest(request, response, instanceConfig.protocol) });
			serverInstance.on('timeout', async (socket) => { await this.handleTimeout(socket.$_CONTEXT, new BlazeError('Request Timed Out', 408)); })
			serverInstance.on('error', async (error) => { await this.handleError({}, new BlazeError(error, 500)); });
			this.Instances.push({
				port: instanceConfig.port, server: serverInstance
			});
		});
	}

	async handleRequest(request, response, protocol) {
		let $_SOCKET = request.socket;
		let $_CONTEXT = $_SOCKET.$_CONTEXT = new context(request, response, this.Log);

		$_CONTEXT.$_REQUEST.uri = new URL(protocol + '://' + request.headers.host + request.url);
		$_CONTEXT.$_DOMAIN = await Domain.find(request.uri.host, protocol === 'https');

		try {
			if ($_CONTEXT.$_DOMAIN) {
				let filename = $_CONTEXT.$_REQUEST.uri.pathname;
				for (let pattern in $_CONTEXT.$_DOMAIN.redirects) {
					let match = new urlPattern(pattern)
						.match($_CONTEXT.$_REQUEST.uri.hostname + $_CONTEXT.$_REQUEST.uri.pathname);

					if (match) {
						let redirect = $_CONTEXT.$_DOMAIN.redirects[pattern];
						response.writeHead(redirect.code, { 'Location': $_CONTEXT.$_REQUEST.uri.protocol + '//' + eval('`' + redirect.rewrite.replace(/\$\{/g, '${match.') + '`') });
						break;
					}
				}
				for (let pattern in $_CONTEXT.$_DOMAIN.rewrites) {
					let match = new urlPattern(pattern)
						.match($_CONTEXT.$_REQUEST.uri.pathname);

					if (match) {
						let evaled = eval('`' + $_CONTEXT.$_DOMAIN.rewrites[pattern].replace(/\$\{/g, '${match.') + '`');
						let fileObject = new URL(evaled, $_CONTEXT.$_REQUEST.uri.origin + '/');
						filename = evaled.replace(fileObject.search, '')
						$_CONTEXT.$_REQUEST.uri.template = fileObject.searchParams;
						break;
					}
				}

				request.method = request.method.toLowerCase();

				$_CONTEXT.setFilePath(path.join($_CONTEXT.$_DOMAIN.root, decodeURIComponent(filename) || "/"));

				await Plugin.fire($_CONTEXT, Plugin.BEFORE_REQUEST);

				if (
					!fs.existsSync($_CONTEXT.$_SERVER.$_FILEPATH) ||
					!fs.statSync($_CONTEXT.$_SERVER.$_FILEPATH).isFile()
				) {
					throw (new BlazeError(request.uri.href + " not found", 404));
				}

				if (!$_CONTEXT.$_RESPONSE.finished) {
					let contentType = mime.contentType($_CONTEXT.$_FILENAME);
					$_CONTEXT.$_RESPONSE.setHeader("Content-Type", contentType);

					await $_CONTEXT.$_DOMAIN.parse($_CONTEXT, fs.readFileSync($_CONTEXT.$_SERVER.$_FILEPATH, mime.charset(contentType) || null))

					this.end($_CONTEXT);
				}
			}
		} catch (error) {
			this.handleError($_CONTEXT, error);
		}
	}

	async end($_CONTEXT) {
		if (!$_CONTEXT.$_RESPONSE.finished) {
			$_CONTEXT.$_RESPONSE.end($_CONTEXT.$_SERVER.Response);
			await Plugin.fire($_CONTEXT, Plugin.AFTER_REQUEST);
		}
	}

	async handleTimeout($_CONTEXT, error) {
		await Plugin.fire($_CONTEXT, Plugin.BEFORE_TIMEOUT);
		await this.handleError($_CONTEXT, error);
		await Plugin.fire($_CONTEXT, Plugin.AFTER_TIMEOUT);
	}

	async handleError($_CONTEXT, error) {
		await Plugin.fire($_CONTEXT, Plugin.BEFORE_ERROR);
		if (!(error instanceof BlazeError)) {
			error = new BlazeError(error, 500);
		}

		$_CONTEXT.$_LOG(error)
		$_CONTEXT.$_SERVER.Response = error.format();
		this.end($_CONTEXT);
		await Plugin.fire($_CONTEXT, Plugin.AFTER_ERROR);
	}

	async listen() {
		this.Instances.forEach(instance => {
			instance.server.listen(instance.port);
		});
	}
}