@aetherframework/middleware 1.0.2

package/src/middleware/session.js

@@ -0,0 +1,167 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/middleware/middleware/session
+ */
+
+import crypto from "crypto";
+
+//Ultimate optimization: Use the most primitive, zero object allocation for-loop for single-point cookie lookup, reducing GC overhead to absolute zero
+function getCookieValue(cookieHeader, name) {
+  if (!cookieHeader) return undefined;
+  const target = name + "=";
+  const len = cookieHeader.length;
+  let pos = 0;
+  while (pos < len) {
+    pos = cookieHeader.indexOf(target, pos);
+    if (pos === -1) break;
+    // Ensure it's an independent cookie name, not a prefix of another
+    if (
+      pos === 0 ||
+      cookieHeader.charCodeAt(pos - 1) === 32 ||
+      cookieHeader.charCodeAt(pos - 1) === 59
+    ) {
+      pos += target.length;
+      let end = cookieHeader.indexOf(";", pos);
+      if (end === -1) end = len;
+      return cookieHeader.substring(pos, end).trim();
+    }
+    pos += 1;
+  }
+  return undefined;
+}
+
+//Abandon long UUID, use 16-byte high-performance hexadecimal ID, shorten cookie length, reduce network and compression middleware overhead
+const genId = () => crypto.randomBytes(16).toString("hex");
+
+class MemoryStore {
+  constructor() {
+    this.cache = new Map();
+  }
+  async get(id) {
+    const s = this.cache.get(id);
+    if (!s) return null;
+    if (Date.now() > s.exp) {
+      this.cache.delete(id);
+      return null;
+    }
+    return s.data;
+  }
+  async set(id, data, ttl) {
+    this.cache.set(id, { data, exp: Date.now() + ttl });
+  }
+  async delete(id) {
+    this.cache.delete(id);
+  }
+  prune() {
+    const now = Date.now();
+    for (const [k, v] of this.cache) if (now > v.exp) this.cache.delete(k);
+  }
+}
+
+export class SessionManager {
+  constructor(options = {}) {
+    const { store, ...restOptions } = options;
+    this.config = {
+      enabled: process.env.SESSION_ENABLED !== "false",
+      maxAge: parseInt(process.env.SESSION_MAX_AGE) || 86400000,
+      cookieName: process.env.SESSION_COOKIE_NAME || "aether_sid",
+      ...restOptions,
+    };
+    this.config.store =
+      store && typeof store === "object" ? store : new MemoryStore();
+    if (this.config.store instanceof MemoryStore) {
+      this.cleanup = setInterval(
+        () => this.config.store.prune(),
+        60000,
+      ).unref();
+    }
+  }
+
+  middleware() {
+    if (!this.config.enabled)
+      return (ctx, next) => next && (next.next ? next.next() : next());
+
+    const { store, maxAge, cookieName } = this.config;
+    const cookieSuffix = `; HttpOnly; Secure; SameSite=Strict; Max-Age=${Math.floor(maxAge / 1000)}; Path=/`;
+
+    return async (ctx, next) => {
+      ctx.state ??= {};
+
+      const sid = getCookieValue(ctx.getHeader("cookie"), cookieName);
+      let sessionData = sid ? await store.get(sid) : null;
+
+      // 🚀 Strategy adjustment: If not obtained, first give an empty object, never write to storage early, never set cookie early
+      let isNew = false;
+      if (!sessionData) {
+        sessionData = {};
+        isNew = true;
+      }
+
+      const sessionState = { id: sid, data: sessionData, dirty: false };
+
+      ctx.session = {
+        get: (key) => sessionState.data[key],
+        set: (key, val) => {
+          sessionState.data[key] = val;
+          sessionState.dirty = true;
+        },
+        delete: (key) => {
+          delete sessionState.data[key];
+          sessionState.dirty = true;
+        },
+        clear: () => {
+          sessionState.data = {};
+          sessionState.dirty = true;
+        },
+        destroy: async () => {
+          if (sessionState.id) await store.delete(sessionState.id);
+          sessionState.id = null;
+          sessionState.data = {};
+          sessionState.dirty = false;
+          ctx.setHeader(
+            "Set-Cookie",
+            `${cookieName}=; HttpOnly; Secure; SameSite=Strict; Max-Age=0; Path=/`,
+          );
+        },
+        regenerate: async () => {
+          if (sessionState.id) await store.delete(sessionState.id);
+          sessionState.id = genId();
+          await store.set(sessionState.id, sessionState.data, maxAge);
+          ctx.setHeader(
+            "Set-Cookie",
+            `${cookieName}=${sessionState.id}${cookieSuffix}`,
+          );
+          sessionState.dirty = false;
+          isNew = false;
+        },
+      };
+
+      //Use the most reliable and well-isolated try...finally to ensure pipeline smoothness, while strictly limiting persistence logic to the "actually modified" checkpoint
+      try {
+        if (next) {
+          next.next ? await next.next() : await next();
+        }
+      } finally {
+        if (sessionState.dirty) {
+          // If it's a new session and the route has written data, only now generate the ID and issue the cookie
+          if (isNew || !sessionState.id) {
+            sessionState.id = genId();
+            ctx.setHeader(
+              "Set-Cookie",
+              `${cookieName}=${sessionState.id}${cookieSuffix}`,
+            );
+          }
+          await store.set(sessionState.id, sessionState.data, maxAge);
+        }
+      }
+    };
+  }
+
+  destroy() {
+    if (this.cleanup) clearInterval(this.cleanup);
+  }
+}
+
+export default SessionManager;

package/src/utils/atomic-ops.js

@@ -0,0 +1,127 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/middleware/utils/atomic-ops
+ */
+
+
+class AtomicCounter {
+    constructor(initialValue = 0) {
+        this.value = initialValue;
+    }
+    
+    /**
+     * Increment counter
+     * @param {number} delta - Amount to increment
+     * @returns {number} - New value
+     */
+    increment(delta = 1) {
+        this.value += delta;
+        return this.value;
+    }
+    
+    /**
+     * Decrement counter
+     * @param {number} delta - Amount to decrement
+     * @returns {number} - New value
+     */
+    decrement(delta = 1) {
+        this.value -= delta;
+        return this.value;
+    }
+    
+    /**
+     * Get current value
+     * @returns {number} - Current value
+     */
+    get() {
+        return this.value;
+    }
+    
+    /**
+     * Set value
+     * @param {number} value - New value
+     */
+    set(value) {
+        this.value = value;
+    }
+    
+    /**
+     * Compare and swap
+     * @param {number} expected - Expected value
+     * @param {number} newValue - New value
+     * @returns {boolean} - Whether swap succeeded
+     */
+    compareAndSwap(expected, newValue) {
+        if (this.value === expected) {
+            this.value = newValue;
+            return true;
+        }
+        return false;
+    }
+}
+
+/**
+ * AtomicFlag - Thread-safe boolean flag
+ */
+class AtomicFlag {
+    constructor(initialValue = false) {
+        this.value = initialValue;
+    }
+    
+    /**
+     * Set flag to true
+     * @returns {boolean} - Previous value
+     */
+    set() {
+        const prev = this.value;
+        this.value = true;
+        return prev;
+    }
+    
+    /**
+     * Set flag to false
+     * @returns {boolean} - Previous value
+     */
+    clear() {
+        const prev = this.value;
+        this.value = false;
+        return prev;
+    }
+    
+    /**
+     * Toggle flag
+     * @returns {boolean} - New value
+     */
+    toggle() {
+        this.value = !this.value;
+        return this.value;
+    }
+    
+    /**
+     * Get current value
+     * @returns {boolean} - Current value
+     */
+    get() {
+        return this.value;
+    }
+}
+
+/**
+ * Factory functions
+ */
+function createAtomicCounter(initialValue = 0) {
+    return new AtomicCounter(initialValue);
+}
+
+function createAtomicFlag(initialValue = false) {
+    return new AtomicFlag(initialValue);
+}
+
+export default {
+    createAtomicCounter,
+    createAtomicFlag,
+    AtomicCounter,
+    AtomicFlag
+};

package/src/utils/env-loader.js

@@ -0,0 +1,128 @@
+ /**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/middleware/utils/evn-loader
+ */
+
+import fs from 'fs';
+import path from 'path';
+/**
+ * Parse .env file content
+ * @param {string} content - .env file content
+ * @returns {Object} - Parsed environment variables
+ */
+function parseEnvContent(content) {
+    const env = {};
+    const lines = content.split('\n');
+    
+    for (const line of lines) {
+        // Skip comments and empty lines
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) {
+            continue;
+        }
+        
+        // Split key=value
+        const equalIndex = trimmedLine.indexOf('=');
+        if (equalIndex === -1) {
+            continue;
+        }
+        
+        const key = trimmedLine.substring(0, equalIndex).trim();
+        let value = trimmedLine.substring(equalIndex + 1).trim();
+        
+        // Remove quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.substring(1, value.length - 1);
+        }
+        
+        // Set environment variable
+        env[key] = value;
+    }
+    
+    return env;
+}
+
+/**
+ * Load environment variables from .env file
+ * @param {string} envPath - Path to .env file
+ * @param {boolean} override - Whether to override existing env vars
+ * @returns {Object} - Loaded environment variables
+ */
+function loadEnv(envPath = '.env', override = false) {
+    const absolutePath = path.resolve(process.cwd(), envPath);
+    
+    if (!fs.existsSync(absolutePath)) {
+        console.warn(`AetherJS: .env file not found at ${absolutePath}`);
+        return {};
+    }
+    
+    try {
+        const content = fs.readFileSync(absolutePath, 'utf8');
+        const env = parseEnvContent(content);
+        
+        // Set environment variables
+        for (const [key, value] of Object.entries(env)) {
+            if (override || process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        }
+        
+        return env;
+    } catch (error) {
+        console.error(`AetherJS: Error loading .env file: ${error.message}`);
+        return {};
+    }
+}
+
+/**
+ * Watch .env file for changes and reload
+ * @param {string} envPath - Path to .env file
+ * @param {Function} callback - Callback when env changes
+ * @returns {Object} - Watcher object with close method
+ */
+function watchEnv(envPath = '.env', callback) {
+    const absolutePath = path.resolve(process.cwd(), envPath);
+    
+    if (!fs.existsSync(absolutePath)) {
+        console.warn(`AetherJS: .env file not found at ${absolutePath}`);
+        return { close: () => {} };
+    }
+    
+    let lastContent = fs.readFileSync(absolutePath, 'utf8');
+    
+    const watcher = fs.watch(absolutePath, (eventType) => {
+        if (eventType === 'change') {
+            try {
+                const newContent = fs.readFileSync(absolutePath, 'utf8');
+                if (newContent !== lastContent) {
+                    lastContent = newContent;
+                    const newEnv = parseEnvContent(newContent);
+                    
+                    // Update process.env
+                    for (const [key, value] of Object.entries(newEnv)) {
+                        process.env[key] = value;
+                    }
+                    
+                    if (callback) {
+                        callback(newEnv);
+                    }
+                }
+            } catch (error) {
+                console.error(`AetherJS: Error reloading .env file: ${error.message}`);
+            }
+        }
+    });
+    
+    return {
+        close: () => watcher.close()
+    };
+}
+export default {
+    loadEnv,
+    watchEnv,
+    parseEnvContent
+};
+

package/src/utils/memory-pool.js

@@ -0,0 +1,93 @@
+ /**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/middleware/utils/memory-pool
+ */
+class MemoryPool {
+    constructor(options = {}) {
+        this.bufferSize = options.bufferSize || 8192; // 8KB default
+        this.poolSize = options.poolSize || 100;
+        this.buffers = [];
+        this.available = [];
+        this.stats = {
+            allocated: 0,
+            reused: 0,
+            created: 0
+        };
+        
+        // Initialize pool
+        for (let i = 0; i < this.poolSize; i++) {
+            const buffer = Buffer.allocUnsafe(this.bufferSize);
+            this.buffers.push(buffer);
+            this.available.push(i);
+        }
+    }
+    
+    /**
+     * Get a buffer from the pool
+     * @returns {Buffer} - Buffer from pool
+     */
+    get() {
+        if (this.available.length > 0) {
+            const index = this.available.pop();
+            this.stats.reused++;
+            return this.buffers[index];
+        }
+        
+        // Pool exhausted, create new buffer
+        const buffer = Buffer.allocUnsafe(this.bufferSize);
+        this.buffers.push(buffer);
+        this.stats.created++;
+        this.stats.allocated++;
+        return buffer;
+    }
+    
+    /**
+     * Return a buffer to the pool
+     * @param {Buffer} buffer - Buffer to return
+     */
+    release(buffer) {
+        const index = this.buffers.indexOf(buffer);
+        if (index !== -1 && !this.available.includes(index)) {
+            // Clear buffer content for security
+            buffer.fill(0);
+            this.available.push(index);
+        }
+    }
+    
+    /**
+     * Get pool statistics
+     * @returns {Object} - Pool stats
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            totalBuffers: this.buffers.length,
+            availableBuffers: this.available.length,
+            utilization: ((this.buffers.length - this.available.length) / this.buffers.length * 100).toFixed(2) + '%'
+        };
+    }
+    
+    /**
+     * Destroy pool and free memory
+     */
+    destroy() {
+        this.buffers = [];
+        this.available = [];
+        this.stats = { allocated: 0, reused: 0, created: 0 };
+    }
+}
+
+/**
+ * Factory function to create memory pool instances
+ * @param {Object} options - Pool configuration
+ * @returns {MemoryPool} - Memory pool instance
+ */
+function createMemoryPool(options = {}) {
+    return new MemoryPool(options);
+}
+
+
+
+export default createMemoryPool;