maxserver 0.0.16 → 0.0.18

package/README.md

@@ -64,7 +64,9 @@ Any fastify options can be passed to maxserver() too.
 | `mongodb` | *-* | MongoDB URI, if set auto-connects db |
 | `public` | `false` | Set `true` to expose the server publicly (binds to `0.0.0.0`) |
 | `static` | *-* | If set, serves this directory statically |
-<br><br>
+---
+
+<br>
 
 ## 🗂️ Project Structure 
 Our golden rule: **1 route = 1 handler file + 1 schema file**
@@ -82,21 +84,16 @@ src/
 ```
 <br>
 
-## 🛣️ Handlers
+## 🤖 Auto Routing
 
-#### 1) Define method + path
-Start each route file with a comment to define the path.  
-That comment is what the route loader uses to auto-register the route.
+To auto-register routes, simple add a comment of the form:  
+**// METHOD /path**  
+**// GET /user**  
+**// POST /feedback/something**  
+...
 
 ```js
-// GET /teams/:id
-```
-
-#### 2) Export default handler
-
-
-```js
-// GET /teams/:id
+// GET /example/:id
 
 export default async function (req, res) {
 
@@ -105,17 +102,23 @@ export default async function (req, res) {
 	return team;
 }
 ```
+<br>
+  
+And remember to use default export for your handler.
+If you don't want to autoregister some routes, then simply don't add that magic comment 😃
+That's it.
+
 
 <br>
 <br>
 
 
 ## 🧾 Schemas
-Create a sibling file ending with **`.schema.js`**, so it will be auto registered.  
-For example: **hello.js** and **hello.schema.js**  
+Create a sibling file ending with **`.schema.js`**, so it will be auto registered. For example: **hello.js** and **hello.schema.js** 
+
+Besides the basic validation fields we can set fields like summary and description, which will appear in the docs. Mostly you don't need to write schemas yourself, chat gpt and gemini do it excelently.
+
 
-Besides the basic validation fields we can set fields like summary and description,
-which will appear in the docs. Mostly you don't need to write schemas yourself, chat gpt and gemini do it excelently.
 
 
 ```js
@@ -139,14 +142,27 @@ export default {
 };
 ```
 
-**`‼️ Important use export default`**
+**‼️ Important use export default
+**
 
 <br>
 
-## Route Options
-Though we don't register routes manually, we don't set route options on the register call. If needed, route options can be set on the schema object.
-For example **schema.auth = true** to enable authentication.
-So the schema holds all configs about a root and handlers the pure logic.
+## 🛠️ Route Options
+Though we don't mostly register routes manually, we don't set route options on the register call.  
+If needed, you can wether register that route manually or just set them on the schema.
+
+```js
+// Inside schema
+
+export default {
+	routeOptions: {
+		config: {
+			preHandler: ...
+		},
+	},
+	...
+```
+
 
 <br>
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "maxserver",
-	"version": "0.0.16",
+	"version": "0.0.18",
 	"description": "Node server setup based fastify",
 	"author": "Max Matinpalo",
 	"type": "module",

package/src/index.js

@@ -25,6 +25,7 @@ export default async function maxserver(config = {}) {
 		mongodb = process.env.MONGODB,
 		docs = process.env.DOCS !== "false",
 		cors = process.env.CORS || "*",
+		env = process.env.NODE_ENV || "development",
 		openapiInfo,
 		static: isStatic = process.env.STATIC,
 		public: isPublic = process.env.PUBLIC === "true",

package/src/routeLoader.js

@@ -1,89 +1,91 @@
-// Scans src/** for files whose first line looks like:
-// POST /teams/create
-// Imports handler + schema and registers them with Fastify.
+/**
+ * 🚀 AUTO-LOADER
+ * Scans src/ for files with "// METHOD /url" comments.
+ * Automatically registers them as Fastify routes.
+ */
 
 import fs from "fs";
 import path from "path";
+import { pathToFileURL } from "url";
 
-const ROUTE_OPTION_KEYS = new Set([
-	"config",
-	"preHandler",
-	"onRequest",
-	"preValidation",
-	"preSerialization",
-	"errorHandler",
-	"logLevel",
-	"bodyLimit",
-	"attachValidation",
-	"exposeHeadRoute",
-	"constraints",
-	"timeout",
-	"websocket",
-	"prefixTrailingSlash",
-]);
 
+// Matches lines like: // GET /api/v1/users
+const ROUTE_REGEX = /^\/\/\s*(GET|POST|PUT|PATCH|DELETE)\s+(.+)$/gm;
+
+
+/**
+ * Recursively finds all .js files in a directory.
+ * Skips node_modules and dotfiles.
+ */
 function walk(dir, out = []) {
 	if (!fs.existsSync(dir)) return out;
-	const entries = fs.readdirSync(dir, { withFileTypes: true });
 
-	for (const entry of entries) {
-		if (entry.name === "node_modules") continue;
-		if (entry.name.startsWith(".")) continue;
-		const full = path.join(dir, entry.name);
+	for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+		if (e.name === "node_modules") continue;
+		if (e.name.startsWith(".")) continue;
 
-		if (entry.isDirectory()) {
+		const full = path.join(dir, e.name);
+		if (e.isDirectory()) {
 			walk(full, out);
-		} else if (entry.name.endsWith(".js")) {
-			out.push(full);
+			continue;
 		}
+
+		if (!e.name.endsWith(".js")) continue;
+		out.push(full);
 	}
+
 	return out;
 }
 
-function getFirstLine(file) {
+
+/**
+ * Extracts method and URL from the file's "magic comment".
+ * Enforces strict "One Route Per File" policy.
+ */
+function getRoute(file) {
 	const text = fs.readFileSync(file, "utf8");
-	const lines = text.split("\n");
-	const firstContent = lines.find((line) => line.trim().length > 0);
+	const matches = [...text.matchAll(ROUTE_REGEX)];
 
-	return (firstContent || "").trim().replace(/^\uFEFF/, "");
-}
+	if (matches.length === 0) return null;
 
-const ROUTE_REGEX = /^\/\/\s*(GET|POST|PUT|PATCH|DELETE)\s+(.+)$/;
+	// Warn if user accidentally defines multiple routes in one file
+	if (matches.length > 1) {
+		console.warn(
+			`⚠️ Ignored "${file}": Found ${matches.length} route comments. ` +
+			`Only 1 allowed per file.`
+		);
+		return null;
+	}
 
-function parseRouteComment(file) {
-	const line = getFirstLine(file);
-	const m = line.match(ROUTE_REGEX);
-	if (!m) return null;
+	const m = matches[0];
+	const method = m[1].toLowerCase();
+	// Normalize URL: Remove all leading slashes, then add exactly one
+	const url = "/" + m[2].trim().replace(/^\/+/, "");
 
-	return { method: m[1].toLowerCase(), url: m[2] };
+	return { method, url };
 }
 
-function splitSchemaExport(raw) {
-	const routeOptions = {};
-	const schema = {};
-
-	for (const [key, value] of Object.entries(raw || {})) {
-		if (ROUTE_OPTION_KEYS.has(key)) {
-			routeOptions[key] = value;
-			continue;
-		}
-		schema[key] = value;
-	}
 
-	return { routeOptions, schema };
+/**
+ * Safe dynamic import that handles Windows paths correctly.
+ */
+async function importDefault(file) {
+	return (await import(pathToFileURL(file).href)).default;
 }
 
+
 export async function loadRoutes(fastify) {
-	const ROOT = path.join(process.cwd(), "src");
-	const files = walk(ROOT);
 	const seen = new Map();
+	const root = path.join(process.cwd(), "src");
 
-	for (const file of files) {
+	for (const file of walk(root)) {
+		// Skip schema files; they are loaded alongside their route file
 		if (file.endsWith(".schema.js")) continue;
 
-		const info = parseRouteComment(file);
+		const info = getRoute(file);
 		if (!info) continue;
 
+		// 🛡️ Collision Detection: Ensure no two files claim the same route
 		const key = info.method + " " + info.url;
 		if (seen.has(key)) {
 			throw new Error(
@@ -94,29 +96,35 @@ export async function loadRoutes(fastify) {
 		}
 		seen.set(key, file);
 
-		const handlerMod = await import("file://" + file);
-		const handler = handlerMod.default;
+		// Import the route handler
+		const handler = await importDefault(file);
+		if (typeof handler !== "function") {
+			throw new Error(
+				`Route "${key}" in "${file}" must export a default function.`
+			);
+		}
 
+		// 🤝 Schema Loading: Look for sibling .schema.js file
 		const schemaFile = file.replace(/\.js$/, ".schema.js");
-		let raw = null;
+		let raw = {};
 
 		if (fs.existsSync(schemaFile)) {
-			const schemaMod = await import("file://" + schemaFile);
-			raw = schemaMod.default || {};
-		} else {
-			fastify.log.warn(
-				`Route schema missing: ` +
-				`${info.method.toUpperCase()} ${info.url}`
-			);
-			raw = {};
+			const loaded = await importDefault(schemaFile);
+			// 🛡️ Guard: Ensure export is a valid object before using it
+			if (loaded && typeof loaded === "object") raw = loaded;
 		}
 
-		const parts = splitSchemaExport(raw);
+		// ✨ Magic: Extract 'auth' and 'routeOptions' specifically
+		let { auth, routeOptions = {}, ...schema } = raw;
 
-		fastify[info.method](
-			info.url,
-			{ ...parts.routeOptions, schema: parts.schema },
-			handler
-		);
+		// Inject 'auth' into config if present (Syntactic Sugar)
+		if (auth !== undefined) {
+			routeOptions = {
+				...routeOptions,
+				config: { ...(routeOptions.config || {}), auth: !!auth },
+			};
+		}
+
+		fastify[info.method](info.url, { ...routeOptions, schema }, handler);
 	}
-}
+}