@awesomeness-js/server 1.0.0

package/server/specialPaths.js

@@ -0,0 +1,107 @@
+// cache: site -> pattern -> { regex, keys }
+const __routeCache = new Map();
+
+function compile(site, pattern) {
+
+	let siteMap = __routeCache.get(site);
+
+	if (!siteMap) {
+
+		siteMap = new Map();
+		__routeCache.set(site, siteMap);
+	
+	}
+
+	let compiled = siteMap.get(pattern);
+
+	if (!compiled) {
+
+		const esc = (s) => s.replace(/([.+^=!:${}()|[\]\\])/g, '\\$1');
+		const keys = [];
+		const re = '^/' + pattern
+			.split('/').filter(Boolean)
+			.map((seg) => {
+
+				if (seg.startsWith(':')) {
+
+					keys.push(seg.slice(1));
+					
+					return '([^/]+)';
+				
+				}
+
+				return esc(seg);
+			
+			})
+			.join('/') + '/?$';
+
+		compiled = {
+			regex: new RegExp(re),
+			keys 
+		};
+		siteMap.set(pattern, compiled);
+	
+	}
+
+	return compiled;
+
+}
+
+export function matchPathSite(site, pattern, path) {
+
+	const {
+		regex, keys 
+	} = compile(site, pattern);
+	const m = regex.exec(path);
+
+	if (!m) return null;
+
+	const params = {};
+
+	for (let i = 0; i < keys.length; i++) params[keys[i]] = m[i + 1];
+	
+	return params;
+
+}
+
+export async function specialPaths(awesomenessRequest, routes) {
+
+	for (const route of routes) {
+
+		// console.log('Checking route:', {
+		// 	pattern: route.pattern,
+		// 	path: awesomenessRequest.path,
+		// 	site: awesomenessRequest.site
+		// });
+
+
+		const params = matchPathSite(awesomenessRequest.site, route.pattern, awesomenessRequest.path);
+
+		if (params) {
+
+			// console.log('Matched route:', {
+			// 	pattern: route.pattern,
+			// 	path: awesomenessRequest.path,
+			// 	site: awesomenessRequest.site,
+			// 	params
+			// });
+
+			await route.handler(awesomenessRequest, params, route);
+			
+			return; // stop the chain here
+		
+		} else {
+
+			// console.log('No match for route:', {
+			// 	pattern: route.pattern,
+			// 	path: awesomenessRequest.path,
+			// 	site: awesomenessRequest.site
+			// });
+
+		}
+	
+	}
+
+}
+
+export default specialPaths;

package/server/validateRequest.js

@@ -0,0 +1,127 @@
+import { clean } from '@awesomeness-js/utils';
+import checkAccess from './checkAccess.js';
+import { getConfig } from "../config.js";
+
+export default async (awesomenessRequest) => {
+
+	const awesomenessConfig = getConfig();
+
+	const {
+		data,
+		routeInfo 
+	} = awesomenessRequest;
+
+	// IS SESSION VALID	
+
+	try {
+
+		await awesomenessConfig.checkSession(awesomenessRequest);
+
+
+	} catch(e){
+
+		if(
+			routeInfo?.permissions.length
+			&& !routeInfo?.permissions.includes('*')
+		){
+
+			if(
+				process.env.NODE_ENV === 'development'
+				&& awesomenessConfig.byPassAccessRequirementsInDev === true
+			){
+
+				if(awesomenessConfig.debug){
+
+					console.log('by passing access requirement: NODE_ENV is development && byPassAccessRequirementsInDev is true');
+				
+				}
+
+			} else {
+
+				throw {
+					message: 'session check failed',
+					error: e
+				};
+
+			}
+
+		
+		}
+
+	}
+	
+
+	if(routeInfo?.permissions.length){
+
+		await checkAccess({
+			permissionsAllowed: routeInfo.permissions,
+			awesomenessRequest,
+		});
+
+	}
+
+	// DOES USER HAVE THE RIGHT PERMISSIONS
+	
+	// CLEAN THE DATA
+	try {
+
+		if(!routeInfo.properties){
+
+			// nothing to clean
+			return true;
+		
+		}
+		
+		if(typeof data === 'object' && Object.keys(data).length){
+		
+			const testing = data.testing || false;
+
+			delete data.testing;
+
+			if(awesomenessConfig.debug){
+
+				console.log({ data });
+			
+			}
+
+			let cleanedObject = clean.object(data, routeInfo.properties, {
+				testMode: awesomenessConfig.debug,
+			});
+
+			
+			data.testing = testing;
+
+			if(!awesomenessRequest.cleanData){
+
+				awesomenessRequest.cleanData = {};
+		
+			}
+
+			// awesomenessRequest.cleanData = data;
+
+			awesomenessRequest.cleanData = {
+				... awesomenessRequest.cleanData,
+				... cleanedObject
+			};
+		
+		}
+
+		
+		return true;
+
+
+
+	} catch (err) {
+
+		throw {
+			message: 'validation error',
+			err: {
+				details: err,
+				message: err.message,
+				stack: err.stack
+			}
+		};
+		
+	}
+
+};

package/server/ws/handlers.js

@@ -0,0 +1,67 @@
+import { getConfig } from "../../config.js";
+
+export function handleWsMessage({
+	socket, 
+	raw
+}) {
+
+	const awesomenessConfig = getConfig();
+
+	let msg;
+
+	try {
+
+		msg = JSON.parse(raw.toString());
+	
+	} catch (err) {
+
+		socket.send(JSON.stringify({
+			type: "error",
+			error: "Invalid JSON",
+			ts: Date.now()
+		}));
+		
+		return;
+	
+	}
+
+	if (awesomenessConfig.debug) {
+
+		// Example: log which client sent the message
+		console.log("client", socket.clientId, "sent", msg);
+	
+	}
+
+	if (msg?.type === "ping") {
+
+		socket.send(JSON.stringify({
+			type: "pong",
+			clientId: socket.clientId,
+			echo: msg.data ?? null,
+			ts: Date.now()
+		}));
+		
+		return;
+	
+	}
+
+	if(typeof awesomenessConfig.wsHandler === 'function'){
+
+		awesomenessConfig.wsHandler({
+			socket,
+			message: msg,
+		});
+	
+	} else {
+		
+		socket.send(JSON.stringify({
+			type: msg.type ?? "echo",
+			clientId: socket.clientId,
+			echo: msg,
+			ts: Date.now()
+		}));
+
+	}
+
+
+}

package/server/ws/index.js

@@ -0,0 +1,50 @@
+import { WebSocketServer } from "ws";
+import { handleWsMessage } from "./handlers.js";
+
+export function attachWs(server, path = "/ws") {
+
+	// noServer mode so we own upgrades
+	const wss = new WebSocketServer({ noServer: true });
+
+	wss.on("connection", (socket, req) => {
+
+		const clientId = Math.random().toString(36).slice(2, 8);
+
+		socket.clientId = clientId;
+
+		socket.send(JSON.stringify({
+			type: "welcome",
+			clientId,
+			ts: Date.now()
+		}));
+
+		socket.on("message", (raw) => handleWsMessage({
+			socket,
+			raw,
+		}));
+	
+	});
+
+	server.on("upgrade", (req, socket, head) => {
+
+		const { url } = req;
+
+		if (url === path) {
+
+			wss.handleUpgrade(req, socket, head, (ws) => {
+
+				wss.emit("connection", ws, req);
+			
+			});
+		
+		} else {
+
+			socket.destroy();
+		
+		}
+	
+	});
+
+	return wss;
+
+}

package/start.js

@@ -0,0 +1,122 @@
+import Koa from 'koa';
+import compress from 'koa-compress';
+import http from "http";
+
+import { attachAwesomenessRequest } from './server/koa/attachAwesomenessRequest.js';
+import { cors } from './server/koa/cors.js';
+import { errorHandler } from './server/koa/errorHandler.js';
+import { jsonBodyParser } from './server/koa/jsonBodyParser.js';
+import { serverUp } from './server/koa/serverUp.js';
+import { timeout } from './server/koa/timeout.js';
+import { staticFiles } from "./server/koa/staticFiles.js";
+import { routeRequest } from './server/koa/routeRequest.js';
+import './server/errors.js'; // handle errors
+
+import { attachWs } from "./server/ws/index.js";
+
+import { getConfig } from './config.js';
+
+
+export default async function start(){
+
+	const awesomenessConfig = getConfig();
+
+	console.log(`Starting Awesomeness server on port ${process.env.PORT}`);
+
+	// Koa app
+	const app = new Koa();
+
+	app.use(compress());
+
+	// error handling
+	app.use(errorHandler);
+
+	// limits
+	app.use(jsonBodyParser);
+	app.use(timeout(1000 * 60 * 5)); // 5 minutes
+
+	// enable cors
+	app.use(cors);
+
+	// where we going
+	app.use(attachAwesomenessRequest);
+
+	// default static files
+	app.use(staticFiles);
+
+	if(Array.isArray(awesomenessConfig.beforeRouteMiddleware)){
+
+		awesomenessConfig.beforeRouteMiddleware.forEach((middlewareFunction) => {
+
+			app.use(middlewareFunction);
+
+		});
+
+	} else {
+
+		if(awesomenessConfig.debug){
+
+			console.log('No customMiddleware array found in awesomenessConfig');
+
+		}
+
+	}
+
+
+	// dynamic routing
+	app.use(routeRequest);
+
+	// create HTTP server manually so WS can hook upgrade
+
+	const server = http.createServer(app.callback());
+
+	if(typeof awesomenessConfig.wsHandler === 'function'){
+
+		attachWs(server);
+
+	} else {
+
+		console.log('No wsHandler function found in awesomenessConfig');
+
+	}
+
+	// init DB
+	if(typeof awesomenessConfig.initDB === 'function'){
+
+		await awesomenessConfig.initDB();
+
+	} else {
+
+		console.log('No initDB function found in awesomenessConfig');
+
+	}
+
+
+	server.listen(process.env.PORT, serverUp);
+
+  
+	[ 'SIGINT', 'SIGTERM' ].forEach(async (signal) => {
+
+		process.on(signal, async () => {
+
+			console.log(`Received ${signal}, shutting down gracefully...`);
+			server.close(() => {
+
+		  console.log('Server closed');
+		  process.exit(0);
+		
+			});
+		
+			setTimeout(() => {
+
+		  console.error('Force shutdown');
+		  process.exit(1);
+		
+			}, 5000);
+	  
+		});
+
+	});
+
+
+}

package/vitest.config.js

@@ -0,0 +1,15 @@
+export default {
+	test: {
+		globals: true,
+		cache: false,
+		environment: 'node',
+		watchExclude: [
+			'**/node_modules/**',
+			'**/.git/**',
+		],
+		testMatch: [
+			'**/*.test.js'
+		],
+		setupFiles: './tests/setup.js',
+	}
+};