@awesomeness-js/server 1.0.0

package/server/koa/routeRequest.js

@@ -0,0 +1,288 @@
+import fetchPage from '../fetchPage.js';
+import pageInfo from '../pageInfo.js';
+import validateRequest from '../validateRequest.js';
+import { staticFiles } from './staticFiles.js';
+import finalFormat from './finalFormat.js';
+
+async function routeRequest(ctx, next){
+
+	const awesomenessRequest = ctx.awesomenessRequest;
+
+	// make sure there is no dots in the path
+	// regex non alphanumeric or forward slash
+	if(awesomenessRequest.pageRoute.match(/[^a-zA-Z0-9\/\_\-]/)){
+
+		ctx.status = 404;
+		
+		ctx.body = {
+			success: false,
+			message: 'Invalid path',
+		};
+
+		finalFormat(awesomenessRequest, ctx);
+
+		return;
+	
+	}
+
+	console.log(awesomenessRequest.awesomenessType, awesomenessRequest.pageRoute);
+
+
+	if(awesomenessRequest.awesomenessType === 'page'){
+
+		try {
+
+			let { 
+				about, 
+				cssPath, 
+				jsPath,
+				getData
+			} = await pageInfo(awesomenessRequest);
+
+			awesomenessRequest.routeInfo = about;
+
+			try {
+
+				await validateRequest(awesomenessRequest);
+
+			} catch (error) {
+
+				ctx.status = 422;
+			
+				ctx.body = {
+					success: false,
+					... error,
+					stack: error.stack,
+				};
+
+				finalFormat(awesomenessRequest, ctx);
+				
+				return;
+
+			}
+
+
+			const page = awesomenessRequest.mdContent ? '_md' : awesomenessRequest.pageRoute;
+
+			try {
+					
+				const pageData = await fetchPage(awesomenessRequest, {
+					getData,
+					about, 
+					cssPath, 
+					jsPath,
+					page
+				});
+
+				ctx.body = {
+					success: true,
+					meta: awesomenessRequest.updatedMeta,
+					... pageData
+				};
+
+				finalFormat(awesomenessRequest, ctx);
+					
+				return;
+
+			} catch (error) {
+					
+				ctx.status = 500;
+					
+				ctx.body = {
+					success: false,
+					message: 'Page exists but error fetching data.',
+					meta: awesomenessRequest.updatedMeta,
+					error,
+					page,
+					errMessage: error?.message || 'Error in getData function', 
+					stack: error.stack
+				};
+
+				finalFormat(awesomenessRequest, ctx);
+					
+				return;
+
+			}
+
+
+
+		} catch(error) {
+
+			ctx.status = 404;
+
+			ctx.body = {
+				success: false,
+				error,
+				message: error?.message || 'Error fetching page',
+				stack: error.stack,
+			};
+
+			finalFormat(awesomenessRequest, ctx);
+			
+			return;
+
+		}
+
+	} else if(awesomenessRequest.awesomenessType === 'api'){
+
+		const siteSpecificRoute = new URL(`../../sites/${awesomenessRequest.site}/api/routes/${awesomenessRequest.pageRoute}/index.js`, import.meta.url);
+		const genericRoute = new URL(`../../api/routes/${awesomenessRequest.pageRoute}/index.js`, import.meta.url);
+
+		const siteSpecific_info = new URL(`../../sites/${awesomenessRequest.site}/api/routes/${awesomenessRequest.pageRoute}/_info.js`, import.meta.url);
+		const generic_info = new URL(`../../api/routes/${awesomenessRequest.pageRoute}/_info.js`, import.meta.url);
+
+		let routeIndex;
+		let routeInfo;
+
+		let specific = false;
+
+		try {	
+
+			routeIndex = await import(siteSpecificRoute);
+			routeInfo = await import(siteSpecific_info);
+			routeInfo = routeInfo.default;
+
+			specific = true;
+
+		} catch (error) {
+
+			try {
+									
+				routeIndex = await import(genericRoute);
+				routeInfo = await import(generic_info);
+				routeInfo = routeInfo.default;
+
+				specific = false;
+
+			} catch (error) {
+				
+				ctx.status = 404;
+			
+				ctx.body = {
+					success: false,
+					message: 'route not found',
+					error,
+					siteSpecificRoute,
+					genericRoute,
+				};
+
+				finalFormat(awesomenessRequest, ctx);		
+				
+				return;
+
+			}
+
+		}
+
+		
+
+		try {
+
+			// store routeInfo
+			awesomenessRequest.specific = specific;
+			awesomenessRequest.routeInfo = routeInfo;
+
+			// validate data
+			try {
+
+				await validateRequest(awesomenessRequest);
+
+			} catch (error) {
+
+				ctx.status = 422;
+			
+				ctx.body = {
+					success: false,
+					... error,
+					stack: error.stack,
+				};
+
+				finalFormat(awesomenessRequest, ctx);
+				
+				return;
+
+			}
+
+			const data = await routeIndex.default(awesomenessRequest);
+
+			ctx.body = {
+				success: true,
+				meta: awesomenessRequest.updatedMeta,
+				...data
+			};
+
+			finalFormat(awesomenessRequest, ctx);
+		
+		} catch (error) {
+		
+			ctx.status = 500;
+
+			if(awesomenessRequest.status){
+
+				ctx.status = awesomenessRequest.status;
+			
+			}
+			
+			ctx.body = {
+				success: false,
+				meta: awesomenessRequest.updatedMeta,
+				message: error?.message || 'Error in route function',
+				error,
+				stack: error.stack,
+			};
+
+			finalFormat(awesomenessRequest, ctx);
+			
+			return;
+		
+		}
+		
+
+	} else {
+
+		// if its a get request
+		// a static file should have been served already
+		// if the application is working correctly then ctx.awesomenessType === 'page' should be true
+		// if it is not true, they are hitting a url cold or reloading 
+		// so load the app
+
+		if(awesomenessRequest.method != 'GET'){
+
+			ctx.status = 405;
+			ctx.body = {
+				success: false,
+				message: 'Method Not Allowed',
+			};
+
+			finalFormat(awesomenessRequest, ctx);			
+			
+			return;
+		
+		}
+
+		if(awesomenessRequest.path === '/test'){
+
+			ctx.body = {
+				success: true,
+				message: 'Hello, World! (just a test)',
+			};
+
+			finalFormat(awesomenessRequest, ctx);
+			
+			return;
+
+		}
+
+		awesomenessRequest.path = '/';
+		await staticFiles(ctx, next);
+		
+		return;
+
+	}
+
+
+}
+
+
+
+export { routeRequest };

package/server/koa/serverUp.js

@@ -0,0 +1,7 @@
+const serverUp = async () => {
+
+	console.log(`Server running on port ${process.env.PORT}`);
+	
+};
+
+export { serverUp };

package/server/koa/staticFiles.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import send from 'koa-send';
+import { fileURLToPath } from "node:url";
+import { getConfig } from '../../config.js';
+
+const staticFiles = async (ctx, next) => {
+
+	const {
+		method, 
+		path: reqPath, 
+		site 
+	} = ctx.awesomenessRequest;
+
+	const {
+		siteURL, 
+		commonPublicDir 
+	} = getConfig();
+
+	if (method !== "GET" && method !== "HEAD") {
+
+		await next();
+		
+		return;
+	
+	}
+
+	if (!(siteURL instanceof URL) || !(commonPublicDir instanceof URL)) {
+
+		ctx.throw(500, new Error("Config must provide siteURL and commonPublicDir as file: URLs"));
+		
+		return;
+	
+	}
+
+	const sitesRoot = fileURLToPath(siteURL);
+	const commonRoot = fileURLToPath(commonPublicDir);
+
+	const domainRoot = path.join(sitesRoot, site, "public");
+
+	const relativePath =
+    reqPath === "/" ? "index.html" : reqPath.replace(/^\//, "");
+
+	const domainFilePath = path.join(domainRoot, relativePath);
+	const commonFilePath = path.join(commonRoot, relativePath);
+
+	let fileServed = false;
+
+	try {	
+
+		// Try to serve from the domain-specific directory
+		await fs.promises.access(domainFilePath);
+		ctx.set('X-Awesomeness-Place', 'Domain');
+		await send(ctx, relativePath, { root: domainRoot });
+		fileServed = true;
+	
+	} catch (err) {
+
+		if (err.code !== 'ENOENT') {
+
+			ctx.throw(500, new Error('Internal Server Error'));
+		
+		}
+	
+	}
+
+	if (!fileServed) {
+
+		try {
+
+			// Try to serve from the common directory
+			await fs.promises.access(commonFilePath);
+			ctx.set('X-Awesomeness-Place', 'Common');
+			await send(ctx, relativePath, { root: commonRoot });
+			fileServed = true;
+		
+		} catch (err2) {
+
+			if (err2.code !== 'ENOENT') {
+
+				ctx.throw(500, new Error('Internal Server Error'));
+			
+			}
+		
+		}
+	
+	}
+
+	if (!fileServed) {
+
+		await next(); // Proceed to next middleware if no static file was served
+	
+	}
+
+};
+
+export { staticFiles };

package/server/koa/timeout.js

@@ -0,0 +1,42 @@
+// Timeout middleware
+const timeout = (ms) => {
+
+	return async (ctx, next) => {
+
+	  // Create a promise that rejects after `ms` milliseconds
+	  const timer = new Promise((_, reject) => {
+
+			const id = setTimeout(() => {
+
+		  reject(new Error('Request timed out'));
+			
+			}, ms);
+  
+			// Clear the timer if the request finishes early
+			ctx.res.on('finish', () => clearTimeout(id));
+	  
+		});
+  
+	  try {
+
+			// Race the timer and the next middleware
+			await Promise.race([ next(), timer ]);
+	  
+		} catch (err) {
+
+			// If an error occurs (such as a timeout), set the response
+			ctx.status = 408; // 408 Request Timeout
+			ctx.body = {
+		  success: false,
+		  message: err.message
+			};
+			
+			return;
+	  
+		}
+	
+	};
+
+};
+
+export { timeout };

package/server/pageInfo.js

@@ -0,0 +1,121 @@
+import { getConfig } from "../config.js";
+
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { existsSync } from "fs";
+import { promises as fs } from "fs";
+import { resolveRealCasePath } from "./resolveRealCasePath.js";
+
+export default async function pageInfo(awesomenessRequest, { page = null } = {}) {
+
+	const awesomenessConfig = getConfig();
+
+	if (!page) {
+
+		page = awesomenessRequest.pageRoute;
+	
+	}
+
+	const slug = page.split("/").pop().split(".")[0].split("?")[0];
+
+	// awesomenessConfig.siteURL points at the /sites/ directory (as a URL)
+	const sitesRootPath =
+		awesomenessConfig.siteURL instanceof URL
+			? fileURLToPath(awesomenessConfig.siteURL)
+			: awesomenessConfig.siteURL;
+
+	const siteRootPath = path.join(sitesRootPath, awesomenessRequest.site);
+	const pagesRootPath = path.join(siteRootPath, "pages");
+
+	const mainPath = resolveRealCasePath(path.join(pagesRootPath, page));
+
+	let getDataPath = mainPath ? path.join(mainPath, "getData.js") : null;
+	let aboutPath = mainPath ? path.join(mainPath, "_info.js") : null;
+	let cssPath = mainPath ? path.join(mainPath, "css") : null;
+	let jsPath = mainPath ? path.join(mainPath, "js") : null;
+
+	let aboutExists = aboutPath ? existsSync(aboutPath) : false;
+	let getDataExists = getDataPath ? existsSync(getDataPath) : false;
+
+	if (aboutExists) {
+
+		const { default: about } = await import(pathToFileURL(aboutPath).href);
+
+		let getData = null;
+
+		if (getDataExists) {
+
+			({ default: getData } = await import(pathToFileURL(getDataPath).href));
+		
+		}
+
+		return {
+			getData,
+			about,
+			cssPath,
+			jsPath,
+		};
+	
+	}
+
+	// is it a simple blog page?
+	getDataPath = path.join(pagesRootPath, "_md", "getData.js");
+	aboutPath = path.join(pagesRootPath, "_md", "_info.js");
+	cssPath = path.join(pagesRootPath, "_md", "css");
+	jsPath = path.join(pagesRootPath, "_md", "js");
+
+	aboutExists = existsSync(aboutPath);
+	getDataExists = existsSync(getDataPath);
+
+	if (!aboutExists) {
+
+		throw {
+			message: "page not found",
+			aboutPath,
+			cssPath,
+			jsPath,
+			awesomenessRequest,
+		};
+	
+	}
+
+	const blogPageLocation = path.join(pagesRootPath, "_md", "pages", `${slug}.md`);
+	const relativePath = resolveRealCasePath(blogPageLocation);
+
+	const { default: about } = await import(pathToFileURL(aboutPath).href);
+
+	let getData = null;
+
+	if (getDataExists) {
+
+		({ default: getData } = await import(pathToFileURL(getDataPath).href));
+	
+	}
+
+	const out = {
+		getData,
+		about,
+		cssPath,
+		jsPath,
+	};
+
+	if (relativePath) {
+
+		out.mdContent = await fs.readFile(relativePath, "utf-8");
+		awesomenessRequest.mdContent = out.mdContent;
+	
+	} else {
+
+		console.log("relative path does not exist, no content found");
+
+		throw {
+			code: 404,
+			message: "page not found. tried specific, MD, and database",
+			url: slug,
+		};
+	
+	}
+
+	return out;
+
+}

package/server/reRoute.js

@@ -0,0 +1,54 @@
+import specialPaths from './specialPaths.js';
+import fetchPage from './fetchPage.js';
+import { getConfig } from "../config.js";
+
+export default async function reRoute({
+	goToPage, 
+	awesomenessRequest
+}){
+
+	const awesomenessConfig = getConfig();
+
+	if(!goToPage){
+
+		return {
+			pageData: {},
+			pageRouteFixed: awesomenessRequest.pageRoute
+		};
+	
+	}
+	
+	if(!awesomenessRequest.reRoutes){
+
+		awesomenessRequest.reRoutes = [];
+	
+	}
+
+	awesomenessRequest.reRoutes.push(awesomenessRequest.pageRoute);
+	
+	// re-route
+	awesomenessRequest.path = goToPage;
+	
+	// page route - replace leading and trailing slash
+	goToPage = goToPage.replace(/^\/+|\/+$/g, '');
+	awesomenessRequest.pageRoute = goToPage;
+
+	// slug
+	const slug = goToPage.split('/').pop().split('.')[0].split('?')[0];
+
+	awesomenessRequest.slug = slug;
+
+	const routes = awesomenessConfig.specialRoutes[awesomenessRequest.site] || [];
+
+	await specialPaths(awesomenessRequest, routes);
+
+	const pageData = await fetchPage(awesomenessRequest);
+
+	const out = {
+		pageData,
+		pageRouteFixed: awesomenessRequest.pageRoute
+	};
+
+	return out;
+
+}

package/server/resolveRealCasePath.js

@@ -0,0 +1,56 @@
+import { readdirSync } from "fs";
+import path from "path";
+
+/**
+ * Case-insensitive real path resolver.
+ * Works correctly on Windows, macOS, and Linux/Docker.
+ */
+export function resolveRealCasePath(inputPath, returnAbsolute = false) {
+
+	if (!inputPath) return null;
+
+	const absPath = path.resolve(inputPath);
+	const { root } = path.parse(absPath);
+	const parts = absPath.split(path.sep).filter(Boolean);
+
+	let current = root || path.sep;
+
+	// ✅ Only skip the first part if it's a Windows drive letter (e.g., "C:\")
+	const startIndex = process.platform === "win32" ? 1 : 0;
+
+	for (const part of parts.slice(startIndex)) {
+
+		try {
+
+			const entries = readdirSync(current);
+			const match = entries.find((e) => e.toLowerCase() === part.toLowerCase());
+
+			if (!match) return null;
+			current = path.join(current, match);
+		
+		} catch {
+
+			return null;
+		
+		}
+	
+	}
+
+	let finalPath;
+
+
+	if (returnAbsolute) {
+
+		finalPath = current;
+	
+	} else {
+
+		const rel = path.relative(process.cwd(), current);
+
+		finalPath = rel.startsWith(".") ? rel : `./${rel}`;
+	
+	}
+
+	return finalPath.split(path.sep).join("/");
+
+}