@aetherframework/middleware 1.0.2

package/examples/router-demo.js

@@ -0,0 +1,369 @@
+// examples/router-demo.js
+import { AetherPipeline, middleware } from '../index.js';
+
+// Create application instance
+const app = new AetherPipeline();
+
+// Use global middlewares
+app.use(middleware.cors());
+app.use(middleware.security());
+app.use(middleware.bodyParser());
+app.use(middleware.json());
+
+// DEBUG: Check what middleware.router contains
+console.log('Debug: middleware.router type:', typeof middleware.router);
+console.log('Debug: middleware.router keys:', Object.keys(middleware.router || {}));
+
+// IMPORTANT FIX: The issue is that middleware.router is the createRouterMiddleware function
+// According to router.js, it exports both createRouterMiddleware and AetherRouter
+// We need to access the Router class from the exported object
+
+// Create router instance - CORRECT APPROACH
+let router;
+
+// Approach 1: Check if AetherRouter is available as a property
+if (middleware.router && middleware.router.AetherRouter) {
+    // Use the AetherRouter class from the exported object
+    const AetherRouter = middleware.router.AetherRouter;
+    router = new AetherRouter();
+    console.log('Router created using middleware.router.AetherRouter constructor');
+} 
+// Approach 2: Check if createRouterMiddleware has Router property
+else if (middleware.router && middleware.router.Router) {
+    // Use the Router property attached to createRouterMiddleware
+    router = new middleware.router.Router();
+    console.log('Router created using middleware.router.Router()');
+}
+// Approach 3: Check if middleware.router itself is the AetherRouter class
+else if (typeof middleware.router === 'function' && middleware.router.prototype && middleware.router.prototype.get) {
+    // middleware.router is the AetherRouter class itself
+    router = new middleware.router();
+    console.log('Router created using middleware.router() as constructor');
+}
+// Approach 4: Last resort - check the actual exports
+else {
+    console.error('Cannot create router instance. Checking exports...');
+    
+    // Try to import AetherRouter directly if possible
+    try {
+        // Based on router.js exports, we should have access to AetherRouter
+        // Let's check if it's available in the middleware.router object
+        if (middleware.router && typeof middleware.router === 'object') {
+            // The exports might be structured differently
+            for (const key in middleware.router) {
+                console.log(`Export key: ${key}, type: ${typeof middleware.router[key]}`);
+                if (key === 'AetherRouter' || key === 'Router') {
+                    const RouterClass = middleware.router[key];
+                    if (typeof RouterClass === 'function') {
+                        router = new RouterClass();
+                        console.log(`Router created using middleware.router.${key}`);
+                        break;
+                    }
+                }
+            }
+        }
+        
+        // If still no router, create a fallback
+        if (!router) {
+            console.error('Creating fallback router');
+            router = {
+                routes: new Map(),
+                get: function(path, handler) {
+                    this.routes.set(`GET:${path}`, handler);
+                    return this;
+                },
+                post: function(path, handler) {
+                    this.routes.set(`POST:${path}`, handler);
+                    return this;
+                },
+                middleware: function() {
+                    return async (ctx, next) => {
+                        const routeKey = `${ctx.method}:${ctx.url}`;
+                        const handler = this.routes.get(routeKey);
+                        if (handler) {
+                            await handler(ctx);
+                        } else if (typeof next === 'function') {
+                            await next();
+                        }
+                    };
+                }
+            };
+        }
+    } catch (error) {
+        console.error('Error creating router:', error);
+        throw error;
+    }
+}
+
+// ========== BASIC ROUTES ==========
+// Check if router.get exists before using it
+if (typeof router.get === 'function') {
+    router.get("/", (ctx) => {
+        ctx.json({ message: "Welcome to AetherJS API" });
+    });
+
+    // Path parameters - Use getState for query parameters
+    router.get("/users/:id", (ctx) => {
+        // Use getState to access query parameters instead of direct ctx.query
+        const query = ctx.getState("query") || {};
+        ctx.json({ 
+            userId: ctx.params.id,
+            query: query // Supports &id=1&name=test&sort=asc
+        });
+    });
+
+    // Query parameters - Use getState for query parameters
+    router.get("/search", (ctx) => {
+        const query = ctx.getState("query") || {};
+        const { q, page = 1, limit = 10, sort = "desc" } = query;
+        ctx.json({ 
+            query: q,
+            page: parseInt(page),
+            limit: parseInt(limit),
+            sort: sort
+        });
+    });
+
+    // POST with body parsing
+    router.post("/users", (ctx) => {
+        const userData = ctx.getState("parsedBody");
+        ctx.json({ 
+            success: true, 
+            data: userData,
+            created: new Date().toISOString()
+        });
+    });
+} else {
+    console.error('router.get() method not available. Router may not be properly initialized.');
+    throw new Error('Router not properly initialized');
+}
+
+// ========== ROUTE GROUPING ==========
+// Check if router.group exists before using it
+if (typeof router.group === 'function') {
+    router.group("/api", (api) => {
+        // /api/users
+        api.get("/users", (ctx) => {
+            ctx.json({ users: [] });
+        });
+        
+        // /api/users/:id
+        api.get("/users/:id", (ctx) => {
+            ctx.json({ user: { id: ctx.params.id } });
+        });
+        
+        // Nested grouping
+        api.group("/v1", (v1) => {
+            // /api/v1/products
+            v1.get("/products", (ctx) => {
+                ctx.json({ products: [] });
+            });
+            
+            // /api/v1/products/:id
+            v1.get("/products/:id", (ctx) => {
+                ctx.json({ productId: ctx.params.id });
+            });
+        });
+    });
+} else {
+    console.log('Router.group() method not available, using direct routes instead');
+    // Fallback: Define routes directly without grouping
+    router.get("/api/users", (ctx) => {
+        ctx.json({ users: [] });
+    });
+    
+    router.get("/api/users/:id", (ctx) => {
+        ctx.json({ user: { id: ctx.params.id } });
+    });
+    
+    router.get("/api/v1/products", (ctx) => {
+        ctx.json({ products: [] });
+    });
+    
+    router.get("/api/v1/products/:id", (ctx) => {
+        ctx.json({ productId: ctx.params.id });
+    });
+}
+
+// ========== API VERSIONING ==========
+// Check if version method exists before using it
+// If version() doesn't exist, use group() method as alternative
+if (typeof router.version === 'function') {
+    router.version("1", (v1) => {
+        v1.get("/users", (ctx) => {
+            ctx.json({ version: "v1", users: [] });
+        });
+        
+        v1.post("/users", (ctx) => {
+            ctx.json({ version: "v1", created: true });
+        });
+    });
+
+    router.version("2", (v2) => {
+        v2.get("/users", (ctx) => {
+            ctx.json({ 
+                version: "v2", 
+                users: [], 
+                features: ["enhanced", "pagination"] 
+            });
+        });
+    });
+} else {
+    console.log('Router.version() method not available, using group() for versioning');
+    // Alternative: Use group method for versioning
+    // First check if group method is available
+    if (typeof router.group === 'function') {
+        router.group("/v1", (v1) => {
+            v1.get("/users", (ctx) => {
+                ctx.json({ version: "v1", users: [] });
+            });
+            
+            v1.post("/users", (ctx) => {
+                ctx.json({ version: "v1", created: true });
+            });
+        });
+
+        router.group("/v2", (v2) => {
+            v2.get("/users", (ctx) => {
+                ctx.json({ 
+                    version: "v2", 
+                    users: [], 
+                    features: ["enhanced", "pagination"] 
+                });
+            });
+        });
+    } else {
+        // If group is also not available, define routes directly
+        router.get("/v1/users", (ctx) => {
+            ctx.json({ version: "v1", users: [] });
+        });
+        
+        router.post("/v1/users", (ctx) => {
+            ctx.json({ version: "v1", created: true });
+        });
+        
+        router.get("/v2/users", (ctx) => {
+            ctx.json({ 
+                version: "v2", 
+                users: [], 
+                features: ["enhanced", "pagination"] 
+            });
+        });
+    }
+}
+
+// ========== ROUTE MIDDLEWARE ==========
+const authMiddleware = async (ctx, next) => {
+    const token = ctx.getHeader("authorization");
+    if (!token) {
+        return ctx.setStatus(401).json({ error: "Unauthorized" });
+    }
+    await next();
+};
+
+const loggerMiddleware = async (ctx, next) => {
+    console.log(`[${new Date().toISOString()}] ${ctx.method} ${ctx.url}`);
+    await next();
+};
+
+// Apply middleware to specific routes
+router.get("/admin/dashboard", authMiddleware, loggerMiddleware, (ctx) => {
+    ctx.json({ admin: true, data: "Sensitive information" });
+});
+
+// ========== WILDCARD ROUTES ==========
+router.get("/files/*", (ctx) => {
+    const filePath = ctx.params["0"]; // Wildcard parameter
+    ctx.json({ file: filePath });
+});
+
+// ========== OPTIONAL PARAMETERS ==========
+router.get("/posts/:id?", (ctx) => {
+    if (ctx.params.id) {
+        ctx.json({ post: ctx.params.id });
+    } else {
+        ctx.json({ posts: [] });
+    }
+});
+
+// ========== REGEX CONSTRAINTS ==========
+router.get("/users/:id(\\d+)", (ctx) => {
+    // Only matches numeric IDs
+    ctx.json({ userId: parseInt(ctx.params.id) });
+});
+
+// ========== MULTIPLE PARAMETERS ==========
+router.get("/products/:category/:id", (ctx) => {
+    const query = ctx.getState("query") || {};
+    ctx.json({ 
+        category: ctx.params.category,
+        productId: ctx.params.id,
+        query: query
+    });
+});
+
+// ========== ARRAY QUERY PARAMETERS ==========
+// Supports: /api/filter?tags=js&tags=node&tags=express
+router.get("/api/filter", (ctx) => {
+    const query = ctx.getState("query") || {};
+    const { tags = [], page = 1 } = query;
+    ctx.json({ 
+        tags: Array.isArray(tags) ? tags : [tags],
+        page: parseInt(page)
+    });
+});
+
+// Add router middleware to pipeline
+if (typeof router.middleware === 'function') {
+    app.use(router.middleware());
+} else {
+    console.error('Router.middleware() method not available');
+    // Fallback: Add routes directly to pipeline
+    app.use(async (ctx, next) => {
+        const routeKey = `${ctx.method}:${ctx.url}`;
+        const handler = router.routes?.get(routeKey);
+        if (handler) {
+            await handler(ctx);
+        } else if (typeof next === 'function') {
+            await next();
+        }
+    });
+}
+
+// ========== ERROR HANDLING ==========
+app.use(async (ctx) => {
+    if (!ctx.isTerminated()) {
+        ctx.setStatus(404).json({
+            error: "Not Found",
+            message: `Cannot ${ctx.method} ${ctx.url}`,
+            timestamp: new Date().toISOString()
+        });
+    }
+});
+
+// Start server
+import http from "http";
+
+const server = http.createServer(async (req, res) => {
+    await app.handle(req, res);
+});
+
+server.listen(3000, () => {
+    console.log("🚀 AetherJS Server running on http://localhost:3000");
+    console.log("📋 Available routes:");
+    
+    // Check if getRoutes method exists
+    if (typeof router.getRoutes === 'function') {
+        console.log(router.getRoutes());
+    } else if (router.routes) {
+        // Fallback: Display routes from router.routes Map
+        const routes = [];
+        router.routes.forEach((handler, key) => {
+            const [method, path] = key.split(':');
+            routes.push({ method, path });
+        });
+        console.log(routes);
+    } else {
+        console.log('No route information available');
+    }
+});

package/index.js

@@ -0,0 +1,67 @@
+// index.js - ES Module version (updated)
+// --- Core Components ---
+import AetherContext from './src/core/AetherContext.js';
+import AetherPipeline from './src/core/AetherPipeline.js';
+import AetherStore from './src/core/AetherStore.js';
+import AetherCompiler from './src/core/AetherCompiler.js';
+import AetherRouter from './src/core/AetherRouter.js'; // Added
+
+// --- Utilities ---
+import envLoader from './src/utils/env-loader.js';
+import memoryPool from './src/utils/memory-pool.js';
+import atomicOps from './src/utils/atomic-ops.js';
+
+// --- Middleware Factories ---
+import createRateLimit from './src/middleware/rate-limit.js';
+import createSecurity from './src/middleware/security.js';
+import createBodyParser from './src/middleware/body-parser.js';
+import createCors from './src/middleware/cors.js';
+import createCompression from './src/middleware/compression.js';
+import createJwt from './src/middleware/jwt.js';
+import SessionManager from './src/middleware/session.js';
+import createJson from './src/middleware/json.js';
+
+// 修复：使用命名导入而不是默认导入
+import { createRouter } from './src/middleware/router.js'; // 改为命名导入
+import createParamsMiddleware from './src/middleware/params.js';
+
+// Export all components
+export {
+    AetherContext,
+    AetherPipeline,
+    AetherStore,
+    AetherCompiler,
+    AetherRouter // Added
+};
+
+// Export utility functions
+export const utils = {
+    envLoader,
+    memoryPool,
+    atomicOps
+};
+
+// Export middleware factory functions
+export const middleware = {
+    rateLimit: createRateLimit,
+    security: createSecurity,
+    bodyParser: createBodyParser,
+    cors: createCors,
+    compression: createCompression,
+    jwt: createJwt,
+    session: SessionManager,
+    json: createJson,
+    router: createRouter, // 这里使用导入的 createRouter
+    params: createParamsMiddleware 
+};
+
+// Default export
+export default {
+    AetherContext,
+    AetherPipeline,
+    AetherStore,
+    AetherCompiler,
+    AetherRouter, 
+    utils,
+    middleware
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+   "name": "@aetherframework/middleware",
+   "version": "1.0.2",
+   "description": "Ultra-performance, framework-agnostic middleware system for Aether Framework",
+   "main": "index.js",
+   "type": "module",
+   "scripts": {
+      "start:basic": "node examples/basic-server.js",
+      "start:advanced": "node examples/advanced-server.js",
+      "test": "node --test tests/**/*.test.js",
+      "benchmark": "node examples/benchmark.js",
+      "lint": "eslint src/",
+      "format": "prettier --write \"src/**/*.js\""
+   },
+   "keywords": [
+      "middleware",
+      "aetherjs",
+      "performance",
+      "framework-agnostic",
+      "http",
+      "server"
+   ],
+   "author": "Aether Framework Team",
+   "license": "MIT",
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/aetherjs/aetherframework-middleware.git"
+   },
+   "bugs": {
+      "url": "https://github.com/aetherjs/aetherframework-middleware/issues",
+      "email": "support@aetherjs.org"
+   },
+   "homepage": "https://www.aetherjs.org",
+   "engines": {
+      "node": ">=16.0.0"
+   },
+   "devDependencies": {
+      "autocannon": "^7.0.0",
+      "eslint": "^8.0.0",
+      "jest": "^29.0.0",
+      "prettier": "^3.0.0",
+      "supertest": "^6.0.0"
+   },
+   "jest": {
+      "testEnvironment": "node",
+      "collectCoverageFrom": [
+         "src/**/*.js",
+         "!src/**/*.test.js"
+      ],
+      "coverageThreshold": {
+         "global": {
+            "branches": 80,
+            "functions": 80,
+            "lines": 80,
+            "statements": 80
+         }
+      }
+   }
+}

package/src/core/AetherCompiler.js

@@ -0,0 +1,118 @@
+ /**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/middleware/core/AetherComplier
+ */
+class AetherCompiler {
+  constructor(options = {}) {
+    this.cache = new Map();
+    this.maxCacheSize = options.maxCacheSize || 128;
+  }
+
+  /**
+   * Compile middleware chain into high-speed execution unit
+   */
+  compile(middlewares) {
+    const cacheKey = this._generateCacheKey(middlewares);
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    const compiledFn = this._compileChain(middlewares);
+
+    if (this.cache.size >= this.maxCacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(cacheKey, compiledFn);
+
+    return compiledFn;
+  }
+
+  _generateCacheKey(middlewares) {
+    // Generate absolutely precise and fast cache keys using unique reference identifiers
+    let key = "";
+    for (let i = 0; i < middlewares.length; i++) {
+      key +=
+        (middlewares[i]._id ||
+          (middlewares[i]._id = Math.random().toString(36).substring(2))) + "|";
+    }
+    return key;
+  }
+
+  /**
+   * Ultimate compilation core: Completely strip signal closure allocation, use lossless index state machine pointers for iteration
+   */
+  _compileChain(middlewares) {
+    const len = middlewares.length;
+
+    if (len === 0) {
+      return function (context) {
+        context._finalize();
+      };
+    }
+
+    // Check if the entire chain is purely synchronous (no async/await/promise)
+    const isAllSync = middlewares.every((mw) => {
+      const str = mw.toString();
+      return (
+        !str.includes("async ") &&
+        !str.includes(".then") &&
+        !str.includes("await ")
+      );
+    });
+
+    // Path 1: Fully synchronous chain → Use the fastest flat `for` loop sequential execution with no extra function stack depth
+    if (isAllSync) {
+      return function executePureSyncChain(context) {
+        for (let i = 0; i < len; i++) {
+          middlewares[i](context, null); // No need to care about traditional next parameter passing in synchronous state
+          if (context.isTerminated()) return;
+        }
+        context._finalize();
+      };
+    }
+
+    // Path 2: Contains asynchronous chain → Strip closures. Achieve zero object allocation iteration by dynamically simulating 'state pointers' at runtime
+    return function executeAsyncChain(context) {
+      let index = 0;
+
+      // Reuse single-stack function, never allocate closures like `() => next()` for each middleware
+      function next() {
+        if (index >= len) {
+          if (!context.isTerminated()) context._finalize();
+          return Promise.resolve();
+        }
+
+        if (context.isTerminated()) return Promise.resolve();
+
+        const currMiddleware = middlewares[index++];
+        try {
+          const result = currMiddleware(context, next);
+
+          // Compatibility handling: If it's a Promise, mount subsequent chain; if synchronous return, directly accelerate progression
+          if (result && typeof result.then === "function") {
+            return result.then(next);
+          }
+          return next();
+        } catch (err) {
+          return Promise.reject(err);
+        }
+      }
+
+      return next();
+    };
+  }
+
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+// Maintain factory export format
+function createAetherCompiler(options = {}) {
+  return new AetherCompiler(options);
+}
+
+export default createAetherCompiler;