exrout 1.0.0

package/LICENSE

@@ -0,0 +1,27 @@
+
+---
+
+## 6️⃣ LICENSE (MIT)
+
+```text
+MIT License
+
+Copyright (c) 2025 [Marouane Akrich]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# EXROUT
+
+Automatically load and register Express routes based on your folder structure.  
+Stop manually importing every route file.
+
+## ✨ Features
+
+- 📂 Auto-load routes from folders & subfolders
+- 📄 `index.js / index.ts` maps to the folder root
+- 🔁 Supports JavaScript **and** TypeScript
+- 🔌 Works with **CommonJS** and **ES Modules**
+- 🧩 Global middleware support
+- 🧭 Optional route prefix (e.g. `/api`)
+- 🧠 File-based route params (`[id].ts` → `:id`)
+- ⚡ Async / dynamic route modules
+- 🔥 Optional route logging
+- ♻️ Hot reload in development
+
+---
+
+## 📦 Installation
+
+```bash
+npm install exrout
+```
+
+# 🚀 Basic Usage
+ES Modules
+```js
+import express from "express";
+import autoRoutes from "express-auto-routes";
+
+const app = express();
+
+autoRoutes(app, "./routes", { prefix: "/api" });
+
+app.listen(3000);
+```
+CommonJS
+```js
+const express = require("express");
+const autoRoutes = require("express-auto-routes");
+
+const app = express();
+
+autoRoutes(app, "./routes");
+
+app.listen(3000);
+```
+# 📁 Folder Structure → Routes
+```bash
+routes/
+ ├── users.ts            → /users
+ ├── posts.ts            → /posts
+ └── auth/
+      ├── index.ts       → /auth
+      ├── login.ts       → /auth/login
+      └── [id].ts        → /auth/:id
+```
+# 🧩 Writing a Route
+```ts
+import { Router } from "express";
+
+const router = Router();
+
+router.get("/", (req, res) => {
+  res.json({ message: "Hello users" });
+});
+
+export default router;
+```
+# ⚙️ Options
+```ts
+autoRoutes(app, "./routes", {
+  prefix: "/api",
+  middleware: [logger],
+  log: true,
+  watch: true
+});
+```
+## Available Options
+| Option       | Type         | Description                             |
+| ------------ | ------------ | --------------------------------------- |
+| `prefix`     | `string`     | Prefix all routes (e.g. `/api`)         |
+| `middleware` | `Function[]` | Global middleware applied to all routes |
+| `log`        | `boolean`    | Log loaded routes to the console        |
+| `watch`      | `boolean`    | Hot reload routes in development        |
+
+
+# 🧠 File-based Route Params
+```bash
+routes/
+ └── users/
+      └── [id].ts → /users/:id
+ts
+Copy code
+router.get("/", (req, res) => {
+  res.json({ id: req.params.id });
+});
+```
+# ⚡ Async Route Modules
+```ts
+import { Router } from "express";
+
+export default async function createRouter() {
+  const router = Router();
+
+  router.get("/", async (req, res) => {
+    res.json({ status: "ok" });
+  });
+
+  return router;
+}
+```
+# 🔥 Hot Reload (Dev Only)
+```ts
+autoRoutes(app, "./routes", { watch: true });
+```
+Routes automatically reload when files change.
+
+
+

package/dist/cjs/index.d.ts

@@ -0,0 +1,8 @@
+import { Express, RequestHandler } from "express";
+export interface Options {
+    prefix?: string;
+    middleware?: RequestHandler[];
+    log?: boolean;
+    watch?: boolean;
+}
+export default function autoRoutes(app: Express, routesDir: string, options?: Options): void;

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = autoRoutes;
+const loadRoutes_1 = __importDefault(require("./loadRoutes"));
+function autoRoutes(app, routesDir, options = {}) {
+    const { prefix = "", middleware = [], log = false, watch = false } = options;
+    (0, loadRoutes_1.default)(app, routesDir, prefix, middleware, log);
+    if (watch) {
+        const chokidar = require("chokidar");
+        const watcher = chokidar.watch(routesDir);
+        watcher.on("all", async () => {
+            console.clear();
+            console.log("[auto-routes] Reloading routes...");
+            (0, loadRoutes_1.default)(app, routesDir, prefix, middleware, log);
+        });
+    }
+}

package/dist/cjs/loadRoutes.d.ts

@@ -0,0 +1,2 @@
+import { Express, RequestHandler } from "express";
+export default function loadRoutes(app: Express, dir: string, baseRoute: string, middleware: RequestHandler[], log?: boolean): Promise<void>;

package/dist/cjs/loadRoutes.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadRoutes;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+async function loadRoutes(app, dir, baseRoute, middleware, log = false) {
+    for (const file of fs_1.default.readdirSync(dir)) {
+        const fullPath = path_1.default.join(dir, file);
+        const stat = fs_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            await loadRoutes(app, fullPath, (0, utils_1.cleanSlashes)(`${baseRoute}/${(0, utils_1.normalizeRouteName)(file)}`), middleware, log);
+            continue;
+        }
+        if (!file.match(/\.(js|ts)$/))
+            continue;
+        const name = file.replace(/\.(js|ts)$/, "");
+        const isIndex = name === "index";
+        const routePath = (0, utils_1.cleanSlashes)(isIndex
+            ? baseRoute
+            : `${baseRoute}/${(0, utils_1.normalizeRouteName)(name)}`);
+        let mod = await Promise.resolve(`${fullPath}`).then(s => __importStar(require(s)));
+        let router = mod.default || mod;
+        // Async router factory support
+        if (typeof router === "function" && router.length === 0) {
+            router = await router();
+        }
+        app.use(routePath, ...middleware, router);
+        if (log) {
+            console.log(`[auto-routes] ${routePath}`);
+        }
+    }
+}

package/dist/cjs/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeRouteName(name: string): string;
+export declare function cleanSlashes(path: string): string;

package/dist/cjs/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRouteName = normalizeRouteName;
+exports.cleanSlashes = cleanSlashes;
+function normalizeRouteName(name) {
+    return name.replace(/\[(.+?)\]/g, ":$1");
+}
+function cleanSlashes(path) {
+    return path.replace(/\/+/g, "/");
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "exrout",
+  "version": "1.0.0",
+  "description": "Automatically load and register Express routes from folder structure",
+  "main": "dist/index.cjs.js",      
+  "module": "dist/index.esm.js",    
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && tsc-esm",
+    "test": "jest"
+  },
+  "dependencies": {
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/jest": "^29.5.3",
+    "jest": "^29.6.1",
+    "supertest": "^6.3.3",
+    "typescript": "^5.2.2",
+    "tsc-alias": "^1.8.16"
+  },
+  "keywords": ["express", "routes", "auto", "typescript", "commonjs", "esm"],
+  "license": "MIT",
+  "type": "module"
+}