@awesomeness-js/server 1.0.2 → 1.1.1

package/{server → src}/koa/attachAwesomenessRequest.js

@@ -1,13 +1,15 @@
 import awesomenessNormalizeRequest  from '../awesomenessNormalizeRequest.js';
 import specialPaths from '../specialPaths.js';
-import { getConfig } from "../../config.js";
+import getConfig from "../getConfig.js";
 
-async function attachAwesomenessRequest(ctx, next) {
+export default async function attachAwesomenessRequest(ctx, next) {
 	
 	const awesomenessConfig = getConfig();
 
 	ctx.awesomenessRequest = await awesomenessNormalizeRequest({ req: ctx });
 
+	ctx.awesomenessRequest.log('Attached awesomenessRequest to Koa ctx');
+
 	const routes = awesomenessConfig.specialRoutes[ctx.awesomenessRequest.site] || [];
 
 	if(ctx.awesomenessRequest.awesomenessType === 'page'){
@@ -18,7 +20,4 @@ async function attachAwesomenessRequest(ctx, next) {
 	
 	await next();
 	
-}
-
-export { attachAwesomenessRequest };
-export default attachAwesomenessRequest;
+}

package/{server → src}/koa/cors.js

@@ -1,4 +1,4 @@
-const cors = async (ctx, next) => {
+export default async function cors(ctx, next){
 
 	// Set CORS headers
 	ctx.set('Access-Control-Allow-Origin', '*');
@@ -17,6 +17,4 @@ const cors = async (ctx, next) => {
 	// Proceed to the next middleware
 	await next();
 	
-};
-
-export { cors };
+}

package/{server → src}/koa/errorHandler.js

@@ -1,4 +1,4 @@
-const errorHandler = async (ctx, next) => {
+export default async function errorHandler(ctx, next){
 	
 	try {
 
@@ -27,6 +27,6 @@ const errorHandler = async (ctx, next) => {
 	
 	}
 
-};
+}
 
-export { errorHandler };
+;

package/{server → src}/koa/finalFormat.js

@@ -1,4 +1,4 @@
-function finalFormat(awesomenessRequest, ctx){
+export default function finalFormat(awesomenessRequest, ctx){
 
 	if(!ctx.body.meta){
 
@@ -28,7 +28,4 @@ function finalFormat(awesomenessRequest, ctx){
 
 	return;
 
-}
-
-export { finalFormat };
-export default finalFormat;
+}

package/{server → src}/koa/jsonBodyParser.js

@@ -136,7 +136,7 @@ const parseMultipart = (req, limit = 10 * 1024 * 1024) => {
 
 
 // ---------- middleware ----------
-const jsonBodyParser = async (ctx, next) => {
+export default async function jsonBodyParser(ctx, next) {
 
 	const method = ctx.method;
 	const isJson =
@@ -167,6 +167,6 @@ const jsonBodyParser = async (ctx, next) => {
 
 	await next();
 
-};
+}
 
-export { jsonBodyParser };
+;

package/src/koa/routeRequest.js

@@ -0,0 +1,334 @@
+import path from "path";
+import { promises as fs } from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
+
+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";
+import getConfig from "../getConfig.js";
+
+export default async function routeRequest(ctx, next) {
+
+	const awesomenessConfig = getConfig();
+
+	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;
+	
+	}
+
+	if (awesomenessRequest.awesomenessType === "page") {
+
+		awesomenessRequest.log('yeah we are live (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") {
+
+		awesomenessRequest.log('yeah we are live (API)');
+
+		const {
+			siteDir__URL, 
+			commonApiDir__URL
+		} = awesomenessConfig;
+
+		// siteDir__URL should point at the /sites/ directory (as a file: URL)
+		if (!(siteDir__URL instanceof URL) || !(commonApiDir__URL instanceof URL)) {
+
+			ctx.throw(
+				500,
+				new Error("Config must provide siteDir__URL and commonApiDir__URL as file: URLs")
+			);
+			
+			return;
+		
+		}
+
+		const sitesRoot = fileURLToPath(siteDir__URL);
+		const commonApiRoot = fileURLToPath(commonApiDir__URL);
+
+		const siteApiRoutesRoot = path.join(sitesRoot, awesomenessRequest.site, "api", "routes");
+		const commonApiRoutesRoot = path.join(commonApiRoot, "routes");
+
+		const routeRel = path.join(awesomenessRequest.pageRoute, "index.js");
+		const infoRel = path.join(awesomenessRequest.pageRoute, "_info.js");
+
+		const siteSpecificIndexPath = path.join(siteApiRoutesRoot, routeRel);
+		const siteSpecificInfoPath = path.join(siteApiRoutesRoot, infoRel);
+
+		const genericIndexPath = path.join(commonApiRoutesRoot, routeRel);
+		const genericInfoPath = path.join(commonApiRoutesRoot, infoRel);
+
+		let routeIndex;
+		let routeInfo;
+
+		let specific = false;
+
+		// Prefer filesystem existence checks so we don't rely on import() throwing for control flow
+		try {
+
+			awesomenessRequest.log('Trying site specific route.', {
+				siteSpecificIndexPath,
+				siteSpecificInfoPath 
+			});
+
+			await fs.access(siteSpecificIndexPath);
+			await fs.access(siteSpecificInfoPath);
+
+			awesomenessRequest.log('Site specific route found.', {
+				siteSpecificIndexPath,
+				siteSpecificInfoPath 
+			});
+
+			routeIndex = await import(pathToFileURL(siteSpecificIndexPath).href);
+			const infoMod = await import(pathToFileURL(siteSpecificInfoPath).href);
+
+			routeInfo = infoMod.default;
+
+			awesomenessRequest.log('Site specific route info loaded.', {
+				routeInfo 
+			});
+
+
+			specific = true;
+		
+		} catch (error) {
+
+			awesomenessRequest.log('Site specific route not found, trying generic route.', { error });
+
+			try {
+
+				await fs.access(genericIndexPath);
+				await fs.access(genericInfoPath);
+
+				routeIndex = await import(pathToFileURL(genericIndexPath).href);
+				const infoMod = await import(pathToFileURL(genericInfoPath).href);
+
+				routeInfo = infoMod.default;
+
+				specific = false;
+			
+			} catch (error2) {
+
+				ctx.status = 404;
+
+				ctx.body = {
+					success: false,
+					message: "route not found",
+					error: error2,
+					siteSpecificRoute: siteSpecificIndexPath,
+					genericRoute: genericIndexPath,
+				};
+
+				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;
+	
+	}
+
+}

package/{server → src}/koa/serverUp.js

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

package/{server → src}/koa/staticFiles.js

@@ -2,9 +2,9 @@ import fs from 'fs';
 import path from 'path';
 import send from 'koa-send';
 import { fileURLToPath } from "node:url";
-import { getConfig } from '../../config.js';
+import getConfig from "../getConfig.js";
 
-const staticFiles = async (ctx, next) => {
+export default async function staticFiles(ctx, next) {
 
 	const {
 		method, 
@@ -12,9 +12,10 @@ const staticFiles = async (ctx, next) => {
 		site 
 	} = ctx.awesomenessRequest;
 
+
 	const {
-		siteURL, 
-		commonPublicDir 
+		siteDir__URL, 
+		commonPublicDir__URL 
 	} = getConfig();
 
 	if (method !== "GET" && method !== "HEAD") {
@@ -25,16 +26,16 @@ const staticFiles = async (ctx, next) => {
 	
 	}
 
-	if (!(siteURL instanceof URL) || !(commonPublicDir instanceof URL)) {
+	if (!(siteDir__URL instanceof URL) || !(commonPublicDir__URL instanceof URL)) {
 
-		ctx.throw(500, new Error("Config must provide siteURL and commonPublicDir as file: URLs"));
+		ctx.throw(500, new Error("Config must provide siteDir__URL and commonPublicDir__URL as file: URLs"));
 		
 		return;
 	
 	}
 
-	const sitesRoot = fileURLToPath(siteURL);
-	const commonRoot = fileURLToPath(commonPublicDir);
+	const sitesRoot = fileURLToPath(siteDir__URL);
+	const commonRoot = fileURLToPath(commonPublicDir__URL);
 
 	const domainRoot = path.join(sitesRoot, site, "public");
 
@@ -92,6 +93,4 @@ const staticFiles = async (ctx, next) => {
 	
 	}
 
-};
-
-export { staticFiles };
+}

package/{server → src}/koa/timeout.js

@@ -1,5 +1,5 @@
 // Timeout middleware
-const timeout = (ms) => {
+export default function timeout(ms) {
 
 	return async (ctx, next) => {
 
@@ -37,6 +37,6 @@ const timeout = (ms) => {
 	
 	};
 
-};
+}
 
-export { timeout };
+;

package/{server → src}/pageInfo.js

@@ -1,10 +1,10 @@
-import { getConfig } from "../config.js";
+import getConfig from "./getConfig.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";
+import resolveRealCasePath from "./resolveRealCasePath.js";
 
 export default async function pageInfo(awesomenessRequest, { page = null } = {}) {
 
@@ -18,11 +18,11 @@ export default async function pageInfo(awesomenessRequest, { page = null } = {})
 
 	const slug = page.split("/").pop().split(".")[0].split("?")[0];
 
-	// awesomenessConfig.siteURL points at the /sites/ directory (as a URL)
+	// awesomenessConfig.siteDir__URL points at the /sites/ directory (as a URL)
 	const sitesRootPath =
-		awesomenessConfig.siteURL instanceof URL
-			? fileURLToPath(awesomenessConfig.siteURL)
-			: awesomenessConfig.siteURL;
+		awesomenessConfig.siteDir__URL instanceof URL
+			? fileURLToPath(awesomenessConfig.siteDir__URL)
+			: awesomenessConfig.siteDir__URL;
 
 	const siteRootPath = path.join(sitesRootPath, awesomenessRequest.site);
 	const pagesRootPath = path.join(siteRootPath, "pages");

package/{server → src}/reRoute.js

@@ -1,6 +1,6 @@
 import specialPaths from './specialPaths.js';
 import fetchPage from './fetchPage.js';
-import { getConfig } from "../config.js";
+import getConfig from "./getConfig.js";
 
 export default async function reRoute({
 	goToPage, 
@@ -17,7 +17,8 @@ export default async function reRoute({
 		};
 	
 	}
-	
+
+
 	if(!awesomenessRequest.reRoutes){
 
 		awesomenessRequest.reRoutes = [];

package/{server → src}/resolveRealCasePath.js

@@ -5,7 +5,7 @@ import path from "path";
  * Case-insensitive real path resolver.
  * Works correctly on Windows, macOS, and Linux/Docker.
  */
-export function resolveRealCasePath(inputPath, returnAbsolute = false) {
+export default function resolveRealCasePath(inputPath, returnAbsolute = false) {
 
 	if (!inputPath) return null;
 

package/{start.js → src/start.js}

@@ -2,23 +2,24 @@ 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 attachAwesomenessRequest from './koa/attachAwesomenessRequest.js';
+import cors from './koa/cors.js';
+import errorHandler from './koa/errorHandler.js';
+import jsonBodyParser from './koa/jsonBodyParser.js';
+import serverUp from './koa/serverUp.js';
+import timeout from './koa/timeout.js';
+import staticFiles from "./koa/staticFiles.js";
+import routeRequest from './koa/routeRequest.js';
+import attachWs from "./ws/index.js";
+import getConfig from './getConfig.js';
 
-import { attachWs } from "./server/ws/index.js";
-
-import { getConfig } from './config.js';
+import '../errors.js'; // handle errors
 
 
 export default async function start(){
 
+	console.log('Initializing Awesomeness server...');
+
 	const awesomenessConfig = getConfig();
 
 	console.log(`Starting Awesomeness server on port ${process.env.PORT}`);
@@ -119,4 +120,4 @@ export default async function start(){
 	});
 
 
-}
+}

package/{server → src}/validateRequest.js

@@ -1,6 +1,6 @@
 import { clean } from '@awesomeness-js/utils';
 import checkAccess from './checkAccess.js';
-import { getConfig } from "../config.js";
+import getConfig from "./getConfig.js";
 
 export default async (awesomenessRequest) => {
 

package/{server → src}/ws/handlers.js

@@ -1,12 +1,14 @@
-import { getConfig } from "../../config.js";
+import getConfig from "../getConfig.js";
 
-export function handleWsMessage({
+export default function handleWsMessage({
 	socket, 
 	raw
 }) {
 
+
 	const awesomenessConfig = getConfig();
 
+
 	let msg;
 
 	try {

package/{server → src}/ws/index.js

@@ -1,7 +1,7 @@
 import { WebSocketServer } from "ws";
-import { handleWsMessage } from "./handlers.js";
+import handleWsMessage from "./handlers.js";
 
-export function attachWs(server, path = "/ws") {
+export default function attachWs(server, path = "/ws") {
 
 	// noServer mode so we own upgrades
 	const wss = new WebSocketServer({ noServer: true });