@awesomeness-js/server 1.0.0

package/server/applicationMap.js

@@ -0,0 +1,33 @@
+import { getConfig } from "../config.js";
+
+export default function(host){
+
+	const awesomenessConfig = getConfig();
+	
+	if (
+		awesomenessConfig.applicationMap
+		&& awesomenessConfig.applicationMap[host]
+	) { 
+
+		return awesomenessConfig.applicationMap[host];
+
+	} else {
+
+		// use the root domain
+		const parts = host.split('.');
+
+
+		if(parts.length > 2){
+
+			return parts.slice(-2).join('.');
+		
+		} else {
+
+			return host;
+
+		}
+
+	}
+
+
+}

package/server/awesomenessNormalizeRequest.js

@@ -0,0 +1,131 @@
+import { getConfig } from "../config.js";
+import applicationMap from './applicationMap.js';
+import reRoute from './reRoute.js';
+
+async function awesomenessNormalizeRequest({
+	req = {}
+} = {}) {
+
+	const awesomenessConfig = getConfig();
+
+	
+	const domain = req.headers.host;
+
+	// If the request is from API Gateway, use the requestContext to get the method
+	const method = req.method ?? req.requestContext?.http?.method;
+	const ip = req.ip ?? req.requestContext?.http?.sourceIp;
+	const userAgent = req.headers.userAgent;
+
+	let host = domain.toLowerCase();
+	
+	const domainParts = host.split('.');
+	const mainDomain = domainParts.slice(-2).join('.').toLowerCase();
+
+	let subDomain = '';
+
+
+	if (domainParts.length > 2) {
+
+		subDomain = domainParts.slice(0, -2).join('.');
+	
+	}
+
+	host = awesomenessConfig.hostMap({
+		host,
+		mainDomain
+	});
+
+	const applicationName = applicationMap(host);
+
+	let path = req.path ?? req.requestContext?.http?.path ?? '/';
+	let pageRoute = path.replace('/', '');
+
+	const slug = pageRoute.split('/').pop().split('.')[0].split('?')[0];
+
+	// top level keys
+	const topLevelKeys = [ 'awesomenessType', 'meta', 'device' ];
+
+	const newData = {};
+	const parts = req?.request?.body ?? {};
+
+	for (const key in parts) {
+
+		if (!topLevelKeys.includes(key)) {
+
+			newData[key] = parts[key];
+				
+		}
+			
+	}
+
+	const urlParams = {};
+
+	const queryString = req?.request?.url || '';
+
+	if (queryString.includes('?')) {
+
+		const queryPart = queryString.split('?').slice(1).join('?').split('#')[0];
+		const queryPairs = queryPart.split('&');
+
+		for (const pair of queryPairs) {
+
+			const [ key, value ] = pair.split('=');
+
+			urlParams[decodeURIComponent(key)] = decodeURIComponent(value || '');
+		
+		}
+	
+	}
+
+	const awesomenessRequest = {
+
+		// request info
+		headers: { ... req.headers },
+		ip,
+		userAgent,
+		method,
+		// our site info - fucked with
+		host,
+		mainDomain,
+		domain,
+		subDomain,
+		site: host, // might not be host with special mapping
+		application: applicationName,
+		path,
+		pageRoute,
+		slug,
+
+		// stuff to return
+		meta: {},
+
+		// stuff from sender
+		testing: req?.request?.body?.testing ?? false,
+		meta: req?.request?.body?.meta ?? {
+			components: {},
+			pages: {}
+		},
+		device: req?.request?.body?.device ?? {},
+		data: newData,
+		awesomenessType: req?.request?.body?.awesomenessType ?? 'generic',
+
+		urlParams,
+
+		// just because
+		_RAW: req
+	};
+
+	awesomenessRequest.reRoute = (destination)=>{
+
+		return reRoute({
+			goToPage: destination,
+			awesomenessRequest
+		});
+
+	};
+
+	return awesomenessRequest;
+	
+}
+
+export { awesomenessNormalizeRequest };
+export default awesomenessNormalizeRequest;

package/server/brotliJsonResponse.js

@@ -0,0 +1,28 @@
+import { brotliCompressSync, constants } from 'zlib';
+
+function brotliJsonResponse(data, {
+
+} = {}) {
+  
+	const json = JSON.stringify(data);
+  
+	const compressed = brotliCompressSync(Buffer.from(json), {
+		params: {
+			[constants.BROTLI_PARAM_QUALITY]: 5
+		}
+	});
+
+	return {
+		statusCode: 200,
+		isBase64Encoded: true,
+		headers: {
+			'Content-Type': 'application/json',
+			'Content-Encoding': 'br'
+		},
+		body: compressed.toString('base64')
+	};
+
+}
+
+export { brotliJsonResponse };
+export default brotliJsonResponse;

package/server/checkAccess.js

@@ -0,0 +1,34 @@
+export default async ({
+	permissionsAllowed,
+	awesomenessRequest,
+}) => {
+
+	const userPermissions = awesomenessRequest.user?.permissions || [];
+		
+	// has at lease one of the permissions
+	const hasPermission = permissionsAllowed.some((rp) => userPermissions.includes(rp) || rp === '*');
+
+	if(!hasPermission){
+
+		if(
+			process.env.NODE_ENV === 'development'
+			&& awesomenessConfig.byPassAccessRequirementsInDev === true
+		){
+
+			console.log('by passing access requirement. 2 - development env && byPassAccessRequirementsInDev is true');
+
+		} else {
+
+			throw {
+				message: 'user does not have permission',
+				permissionsAllowed,
+				userPermissions
+			};
+
+		}
+		
+	}
+
+	return true;
+
+};

package/server/componentDependencies.js

@@ -0,0 +1,301 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { each, getAllFiles } from "@awesomeness-js/utils";
+import { readFileSync } from "fs";
+
+function urlToFsPath(u) {
+
+	if (!(u instanceof URL)) {
+
+		throw new TypeError("componentLocations must be an array of URL objects");
+	
+	}
+
+	return fileURLToPath(u);
+
+}
+
+function extractUiFirstParts(str) {
+
+	const regex = /ui\.([a-zA-Z0-9_]+)(?:\.[a-zA-Z0-9_.]*)?\(/g;
+	const matches = new Set();
+	let match;
+
+	while ((match = regex.exec(str)) !== null) {
+
+		matches.add(match[1]);
+	
+	}
+
+	return [ ...matches ];
+
+}
+
+function componentDependencies(allComponents, {
+	componentLocations = [],
+	namespace = "ui",
+	showDetails = false,
+	ignore = [ "*.css.js", "*.css.php" ],
+} = {}) {
+
+	if (!Array.isArray(componentLocations) || componentLocations.length === 0) {
+
+		throw new TypeError("componentLocations must be a non-empty array of URL objects");
+	
+	}
+
+	let componentsToProcess = [ ...allComponents ];
+	const out = {};
+
+	while (componentsToProcess.length > 0) {
+
+		const newComponentsToProcess = [];
+
+		componentsToProcess.forEach((component) => {
+
+			// Build roots in priority order; last is default because it’s last
+			const candidateRoots = componentLocations.map((baseUrl) => {
+
+				// baseUrl should point at a directory; we resolve component under it
+				const componentUrl = new URL(`./${component}/`, baseUrl);
+
+        
+				return path.resolve(urlToFsPath(componentUrl));
+			
+			});
+
+			let allFiles;
+			let chosenRoot;
+
+			for (const root of candidateRoots) {
+
+				try {
+
+					allFiles = getAllFiles(".", {
+						dir: root,
+						ignore 
+					});
+					chosenRoot = root;
+					break; // first match wins
+				
+				} catch {
+					// try next
+				}
+			
+			}
+
+			if (!allFiles) {
+
+				throw {
+					message: "component does not exist (no location matched)",
+					component,
+					tried: candidateRoots,
+				};
+			
+			}
+
+			allFiles.forEach((file) => {
+
+				const normalizedPath = path.normalize(file);
+				const pathSegments = normalizedPath.split(path.sep);
+
+				const variableIndex = pathSegments.indexOf(component);
+
+				let fileNameFull = pathSegments[pathSegments.length - 1];
+				const fileTypeArr = fileNameFull.split(".");
+				const fileType = fileTypeArr[fileTypeArr.length - 1];
+				const fileName = fileTypeArr.slice(0, -1).join(".");
+
+				out[component] = out[component] || {};
+				out[component][fileType] = out[component][fileType] || {};
+
+				let arrAfterComponent = pathSegments.slice(variableIndex + 1);
+
+				arrAfterComponent.pop();
+
+				let tail = "";
+
+				if (fileType === "js" || fileType === "css") {
+
+					if (arrAfterComponent.length > 0) {
+
+						tail =
+              fileName === "index"
+              	? "." + arrAfterComponent.join(".")
+              	: `.${arrAfterComponent.join(".")}.${fileName}`;
+					
+					} else {
+
+						tail = fileName === "index" ? "" : `.${fileName}`;
+					
+					}
+				
+				}
+
+				const componentName = `${namespace}.${component}${tail}`;
+
+				try {
+
+					const fileContent = readFileSync(file, "utf-8");
+					const lines = fileContent.split("\n");
+					let fileWithImportsStripped = "";
+
+					try {
+
+						const newTest = extractUiFirstParts(fileContent);
+
+						if (newTest.length > 0) {
+
+							newTest.forEach((newComp) => {
+
+								if (!allComponents.includes(newComp)) {
+
+									allComponents.push(newComp);
+									newComponentsToProcess.push(newComp);
+								
+								}
+							
+							});
+						
+						}
+					
+					} catch (error) {
+
+						console.error("Error extracting UI parts:", error);
+					
+					}
+
+					lines.forEach((line) => {
+
+						if (line.startsWith("import ui")) {
+
+							if (line.includes(`import ui from '#ui'; // `)) {
+
+								const imports = line.split(`import ui from '#ui'; // `);
+
+								if (imports.length > 1) {
+
+									const importComponents = imports[1].split(",").map((c) => c.trim());
+
+									importComponents.forEach((importComponent) => {
+
+										if (!allComponents.includes(importComponent)) {
+
+											allComponents.push(importComponent);
+											newComponentsToProcess.push(importComponent);
+										
+										}
+									
+									});
+								
+								}
+							
+							}
+						
+						} else if (
+							line.startsWith("// awesomeness import") 
+							|| line.startsWith("/* awesomeness @import")
+						) {
+
+							const importPathMatch = line.match(/['"]([^'"]+)['"]/);
+
+							if (importPathMatch) {
+
+								const importedComponentName = importPathMatch[1].replace(/;$/, "").trim();
+
+								if (!allComponents.includes(importedComponentName)) {
+
+									allComponents.push(importedComponentName);
+									newComponentsToProcess.push(importedComponentName);
+								
+								}
+							
+							}
+						
+						} else {
+
+							fileWithImportsStripped += `${line}\n`;
+						
+						}
+					
+					});
+
+					if (fileType === "js") {
+
+						if (
+							fileWithImportsStripped.startsWith("(function") 
+							|| fileWithImportsStripped.startsWith("((")
+						) {
+
+							fileWithImportsStripped = `;${fileWithImportsStripped}`;
+						
+						} else {
+
+							fileWithImportsStripped = fileWithImportsStripped.replace(
+								"export default ",
+								`${componentName} = `
+							);
+						
+						}
+					
+					}
+
+					out[component][fileType][componentName] = fileWithImportsStripped;
+				
+				} catch (err) {
+
+					console.log("Failed to get dependencies", { component });
+				
+				}
+			
+			});
+
+			if (out[component]) {
+
+				each(out[component], (files, type) => {
+
+					if (type === "js" && !files[`${namespace}.${component}`]) {
+
+						files[`${namespace}.${component}`] = `${namespace}.${component} = {}; `;
+					
+					}
+
+					files = Object.keys(files)
+						.sort()
+						.reduce((obj, key) => {
+
+							obj[key] = files[key];
+							
+							return obj;
+						
+						}, {});
+
+					if (showDetails) {
+
+						out[component][type + "_details"] = files;
+					
+					}
+
+					out[component][type] = ` ${Object.values(files).join("\n")} `;
+				
+				});
+			
+			}
+
+			componentsToProcess = componentsToProcess.filter((f) => f !== component);
+		
+		});
+
+		if (newComponentsToProcess.length) {
+
+			componentsToProcess = componentsToProcess.concat(newComponentsToProcess);
+		
+		}
+	
+	}
+
+	return out;
+
+}
+
+export { componentDependencies };

package/server/errors.js

@@ -0,0 +1,11 @@
+process.on('uncaughtException', (err) => {
+
+	console.error('💥 Uncaught Exception:', err);
+
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+
+	console.error('💥 Unhandled Rejection:', reason);
+
+});