@awesomeness-js/server 1.0.0

package/server/fetchPage.js

@@ -0,0 +1,269 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { componentDependencies } from "./componentDependencies.js";
+import pageInfo from "./pageInfo.js";
+import { each, md5, combineFiles } from "@awesomeness-js/utils";
+import { getConfig } from "../config.js";
+
+const componentNamespace = "ui";
+const pageNamespaceBase = `app.pages`;
+
+export default async function fetchPage(
+	awesomenessRequest,
+	{
+		about,
+		cssPath,
+		jsPath,
+		getData,
+		showDetails = false,
+		page = null
+	} = {}
+) {
+
+	const awesomenessConfig = getConfig();
+
+	// normalize siteURL (expected to point at the /sites/ directory)
+	const sitesRootPath =
+		awesomenessConfig.siteURL instanceof URL
+			? fileURLToPath(awesomenessConfig.siteURL)
+			: awesomenessConfig.siteURL;
+
+	const sitePagesRoot = path.join(sitesRootPath, awesomenessRequest.site, "pages");
+
+	function pageFn(filePath){
+
+		// make file path relative to ".../sites/<site>/pages/"
+		let rel = path.relative(sitePagesRoot, filePath);
+
+		// normalize to posix-style so splitting works on Windows + *nix
+		rel = rel.split(path.sep).join("/");
+
+		// remove extension and split on /js/
+		const parts = rel.replace(/\.js$/i, "").split("/js/");
+
+		const pagePath = parts[0] || "";
+		const fnPath = (parts[1] || "").split("/").filter(Boolean).join(".");
+
+		const pageNamespace = `${pageNamespaceBase}.${pagePath.split("/").filter(Boolean).join(".")}`;
+		const pageFnName = `${pageNamespace}.${fnPath}`;
+
+		return pageFnName;
+		
+	}
+	
+
+	// initialize if not already available
+	if (!awesomenessRequest.updatedMeta) {
+
+		awesomenessRequest.updatedMeta = {};
+	
+	}
+
+	let forceRefresh = false;
+
+	if (!page) {
+
+		page = awesomenessRequest.pageRoute;
+	
+	} else {
+
+		forceRefresh = true;
+	
+	}
+
+	if (!about || !cssPath || !jsPath || !getData) {
+
+		let info = await pageInfo(awesomenessRequest, { page });
+
+		cssPath = info.cssPath;
+		jsPath = info.jsPath;
+		about = info.about;
+		getData = info.getData;
+
+		if (info.mdContent) {
+
+			page = "_md";
+		
+		}
+	
+	}
+
+	if (!about || !cssPath || !jsPath) {
+
+		throw {
+			reason: "page not found",
+			aboutPath,
+			cssPath,
+			jsPath,
+			awesomenessRequest,
+		};
+	
+	}
+
+	const meta = {
+		about,
+		pages: {},
+		components: {},
+	};
+
+	// CHECK PERMISSIONS
+	if (about?.permissions.length) {
+
+		const userPermissions = awesomenessRequest.user?.permissions || [];
+		const hasPermission = about.permissions.some((rp) => userPermissions.includes(rp) || rp === "*");
+
+		if (!hasPermission) {
+
+			if (process.env.NODE_ENV === "development") {
+
+				console.log("by  page passing access requirement.");
+			
+			} else {
+
+				throw {
+					message: "user does not have permission to view this page",
+					permissions: about.permissions,
+					userPermissions,
+				};
+			
+			}
+		
+		}
+	
+	}
+
+	// GET PAGE
+	if (
+		forceRefresh === true ||
+		awesomenessRequest.testing === true ||
+		about.version != awesomenessRequest.meta?.pages[page]
+	) {
+
+		meta.pages[page] = meta.pages[page] || {};
+
+		meta.pages[page].version = about.version;
+		meta.pages[page].about = about;
+
+		// GET ALL PAGE SCRIPTS
+		try {
+
+			let js = "";
+
+			js += combineFiles(jsPath, "js", {
+				processContent: ({
+					content, path 
+				}) => {
+
+					const fnName = pageFn(path, awesomenessRequest);
+
+					content = content.replaceAll(`import ui from '#ui';`, "");
+					content = content.replaceAll(`import ui from "#ui";`, "");
+
+					content = content.replaceAll("export default function", `${fnName} = function`);
+					content = content.replaceAll("export default async function", `${fnName} = async function`);
+					content = content.replaceAll("export default async", `${fnName} = async`);
+					content = content.replaceAll("export default", `${fnName} =`);
+
+					return content;
+				
+				},
+			});
+
+			meta.pages[page].js = js;
+		
+		} catch (err) {
+
+			console.log("failed to get page js", { err });
+		
+		}
+
+		// GET ALL PAGE CSS
+		try {
+
+			let css = "";
+
+			css += combineFiles(cssPath, "css");
+			meta.pages[page].css = css;
+		
+		} catch (err) {
+
+			meta.pages[page].css = "/* no css found */";
+		
+		}
+	
+	}
+
+	if (about?.components?.length) {
+
+		const allDependencies = componentDependencies(about.components, {
+			componentLocations: awesomenessConfig.componentLocations(awesomenessRequest),
+			namespace: componentNamespace,
+			showDetails,
+		});
+
+		each(allDependencies, (data, component) => {
+
+			try {
+
+				const css = data.css;
+				const js = data.js;
+				let hash = md5(css + js);
+
+				if (hash !== awesomenessRequest.meta.components[component]) {
+
+					meta.components[component] = {
+						css,
+						js,
+						hash 
+					};
+
+					if (showDetails) {
+
+						meta.components[component].css_details = data.css_details;
+						meta.components[component].js_details = data.js_details;
+					
+					}
+				
+				}
+			
+			} catch (err) {
+
+				console.log(`failed to get component: ${component}`, {
+					component,
+					err 
+				});
+			
+			}
+		
+		});
+	
+	}
+
+	const pages = awesomenessRequest.updatedMeta.pages || {};
+	const components = awesomenessRequest.updatedMeta.components || {};
+
+	if (Object.keys(meta.pages).length) {
+
+		awesomenessRequest.updatedMeta.pages = {
+			...pages,
+			...meta.pages 
+		};
+	
+	}
+
+	if (Object.keys(meta.components).length) {
+
+		awesomenessRequest.updatedMeta.components = {
+			...components,
+			...meta.components 
+		};
+	
+	}
+
+	const pageData = await getData(awesomenessRequest);
+
+	
+	return pageData;
+
+}

package/server/getMD.js

@@ -0,0 +1,22 @@
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export default async function getMD(relativePath, callerUrl) {
+
+	try {
+
+		const callerDir = path.dirname(fileURLToPath(callerUrl));
+		const fullPath = path.resolve(callerDir, relativePath);
+
+		console.log(`Loading MD file from: ${fullPath}`);
+    
+		return await readFile(fullPath, 'utf8');
+	
+	} catch {
+
+		return null;
+	
+	}
+
+}

package/server/koa/attachAwesomenessRequest.js

@@ -0,0 +1,24 @@
+import awesomenessNormalizeRequest  from '../awesomenessNormalizeRequest.js';
+import specialPaths from '../specialPaths.js';
+import { getConfig } from "../../config.js";
+
+async function attachAwesomenessRequest(ctx, next) {
+	
+	const awesomenessConfig = getConfig();
+
+	ctx.awesomenessRequest = await awesomenessNormalizeRequest({ req: ctx });
+
+	const routes = awesomenessConfig.specialRoutes[ctx.awesomenessRequest.site] || [];
+
+	if(ctx.awesomenessRequest.awesomenessType === 'page'){
+
+		await specialPaths(ctx.awesomenessRequest, routes);
+
+	}
+	
+	await next();
+	
+}
+
+export { attachAwesomenessRequest };
+export default attachAwesomenessRequest;

package/server/koa/cors.js

@@ -0,0 +1,22 @@
+const cors = async (ctx, next) => {
+
+	// Set CORS headers
+	ctx.set('Access-Control-Allow-Origin', '*');
+	ctx.set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+	ctx.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+  
+	// Handle OPTIONS requests
+	if (ctx.method === 'OPTIONS') {
+
+	  ctx.status = 204; // No Content
+	  
+		return;
+	
+	}
+  
+	// Proceed to the next middleware
+	await next();
+	
+};
+
+export { cors };

package/server/koa/errorHandler.js

@@ -0,0 +1,32 @@
+const errorHandler = async (ctx, next) => {
+	
+	try {
+
+	  await next();
+	
+	} catch (err) {
+
+	  if (err.code === 'EPIPE') {
+
+			console.error('EPIPE error: Client closed connection');
+			ctx.status = 499; // Client Closed Request
+			ctx.body = 'Client closed connection unexpectedly';
+			
+			return;
+	  
+		} else {
+
+			// Handle other errors normally
+			ctx.status = err.status || 500;
+			ctx.body = err.message || 'Internal Server Error';
+			ctx.app.emit('error', err, ctx);
+			
+			return;
+	  
+		}
+	
+	}
+
+};
+
+export { errorHandler };

package/server/koa/finalFormat.js

@@ -0,0 +1,34 @@
+function finalFormat(awesomenessRequest, ctx){
+
+	if(!ctx.body.meta){
+
+		ctx.body.meta = {};
+
+	}
+
+	if(awesomenessRequest.pageInit){
+
+		ctx.body.meta.pageInit = awesomenessRequest.pageInit;
+
+	}
+
+	// just a test
+	if(process.env.TESTING){
+
+		ctx.body.awesomenessRequest = awesomenessRequest;
+	
+	}
+
+	// meta update user
+	if(awesomenessRequest.user) {
+
+		ctx.body.meta.user = awesomenessRequest.user;
+	
+	}
+
+	return;
+
+}
+
+export { finalFormat };
+export default finalFormat;

package/server/koa/jsonBodyParser.js

@@ -0,0 +1,172 @@
+import Busboy from 'busboy';
+
+// ---------- helper for JSON ----------
+const parseBody = (req, limit) => {
+
+	return new Promise((resolve, reject) => {
+
+		let body = '';
+		let receivedLength = 0;
+
+		req.on('data', (chunk) => {
+
+			receivedLength += chunk.length;
+
+			if (receivedLength > limit) {
+
+				reject(new Error('Payload too large'));
+				req.destroy();
+				
+				return;
+			
+			}
+
+			body += chunk;
+		
+		});
+
+		req.on('end', () => resolve(body));
+		req.on('error', (err) => reject(err));
+	
+	});
+
+};
+
+// ---------- multipart with Busboy (in memory, preserves field structure) ----------
+const parseMultipart = (req, limit = 10 * 1024 * 1024) => {
+
+	return new Promise((resolve, reject) => {
+
+		const busboy = Busboy({
+			headers: req.headers,
+			limits: { fileSize: limit } 
+		});
+		const body = {};
+
+		busboy.on('field', (name, value) => {
+
+			// handle "name[]" style fields as arrays
+			if (name.endsWith('[]')) {
+
+				const clean = name.slice(0, -2);
+
+				body[clean] ??= [];
+				body[clean].push(value);
+			
+			} else if (body[name] !== undefined) {
+
+				// already exists → turn into array
+				if (!Array.isArray(body[name])) body[name] = [ body[name] ];
+				body[name].push(value);
+			
+			} else {
+
+				body[name] = value;
+			
+			}
+		
+		});
+
+		busboy.on('file', (name, file, info) => {
+
+			const {
+				filename, encoding, mimeType 
+			} = info;
+			const chunks = [];
+			let totalSize = 0;
+
+			file.on('data', (chunk) => {
+
+				totalSize += chunk.length;
+
+				if (totalSize > limit) {
+
+					reject(new Error('File too large'));
+					req.destroy();
+					
+					return;
+				
+				}
+
+				chunks.push(chunk);
+			
+			});
+
+			file.on('end', () => {
+
+				const fileObj = {
+					filename,
+					mimeType,
+					encoding,
+					buffer: Buffer.concat(chunks),
+				};
+
+				// name[] → array
+				if (name.endsWith('[]')) {
+
+					const clean = name.slice(0, -2);
+
+					body[clean] ??= [];
+					body[clean].push(fileObj);
+				
+				} else if (body[name] !== undefined) {
+
+					if (!Array.isArray(body[name])) body[name] = [ body[name] ];
+					body[name].push(fileObj);
+				
+				} else {
+
+					body[name] = fileObj;
+				
+				}
+			
+			});
+		
+		});
+
+		busboy.on('finish', () => resolve(body));
+		busboy.on('error', (err) => reject(err));
+
+		req.pipe(busboy);
+	
+	});
+
+};
+
+
+
+// ---------- middleware ----------
+const jsonBodyParser = async (ctx, next) => {
+
+	const method = ctx.method;
+	const isJson =
+    [ 'POST', 'PUT', 'PATCH' ].includes(method) && ctx.is('application/json');
+	const isMultipart =
+    [ 'POST', 'PUT', 'PATCH' ].includes(method) && ctx.is('multipart/form-data');
+
+
+	try {
+
+		if (isJson) {
+
+			const body = await parseBody(ctx.req, 10 * 1024 * 1024);
+
+			ctx.request.body = JSON.parse(body);
+		
+		} else if (isMultipart) {
+
+			ctx.request.body = await parseMultipart(ctx.req);
+		
+		}
+	
+	} catch (err) {
+
+		ctx.throw(413, new Error('Payload too large'));
+	
+	}
+
+	await next();
+
+};
+
+export { jsonBodyParser };