fortify2-js
Version:
MOST POWERFUL JavaScript Security Library! Military-grade cryptography + 19 enhanced object methods + quantum-resistant algorithms + perfect TypeScript support. More powerful than Lodash with built-in security.
350 lines (346 loc) • 12.9 kB
JavaScript
'use strict';
var express_middleware = require('../../../../../express.middleware.js');
var Logger = require('../../../utils/Logger.js');
/**
* MiddlewareAPI - User-friendly middleware interface that follows the specified pattern
* Returns a middleware object with register() method for custom middleware
*/
class MiddlewareAPI {
constructor(Manager, app, config = {}) {
this.nameToIdMap = new Map(); // Track middleware names to IDs
// Use process.stdout.write to ensure immediate output
Logger.logger.debug("middleware", "MiddlewareAPI constructor called\n");
Logger.logger.debug("middleware", `Config: ${JSON.stringify(config, null, 2)}\n`);
this.Manager = Manager;
this.app = app;
this.config = config;
// Apply default middleware based on configuration
Logger.logger.debug("middleware", "About to call applyDefaultMiddleware\n");
this.applyDefaultMiddleware();
Logger.logger.debug("middleware", "applyDefaultMiddleware completed\n");
}
/**
* Register custom middleware with options
*/
register(middleware, options) {
try {
const id = this.Manager.register(middleware, options);
const name = options?.name || `middleware-${id.slice(0, 8)}`;
// Track the name-to-ID mapping for easier removal
this.nameToIdMap.set(name, id);
Logger.logger.debug("middleware", `Custom middleware registered: ${name} (${id})`);
}
catch (error) {
Logger.logger.error("middleware", `Failed to register middleware: ${error}`);
}
return this;
}
/**
* Unregister middleware by ID
*/
unregister(id) {
try {
this.Manager.unregister(id);
Logger.logger.debug("middleware", `Middleware unregistered: ${id}`);
}
catch (error) {
Logger.logger.error("middleware", `Failed to unregister middleware: ${error}`);
}
return this;
}
/**
* Enable middleware by ID
*/
enable(id) {
try {
this.Manager.enable(id);
Logger.logger.debug("middleware", `Middleware enabled: ${id}`);
}
catch (error) {
Logger.logger.error("middleware", `Failed to enable middleware: ${error}`);
}
return this;
}
/**
* Disable middleware by ID
*/
disable(id) {
try {
this.Manager.disable(id);
Logger.logger.debug("middleware", `Middleware disabled: ${id}`);
}
catch (error) {
Logger.logger.error("middleware", `Failed to disable middleware: ${error}`);
}
return this;
}
/**
* Remove middleware by name
*/
removeByName(name) {
try {
const id = this.nameToIdMap.get(name);
if (id) {
const success = this.Manager.unregister(id);
if (success) {
this.nameToIdMap.delete(name);
Logger.logger.debug("middleware", `Middleware removed: ${name} (${id})`);
return true;
}
}
Logger.logger.warn("middleware", `Middleware not found: ${name}`);
return false;
}
catch (error) {
Logger.logger.error("middleware", `Failed to remove middleware: ${error}`);
return false;
}
}
/**
* Get middleware information
*/
getInfo(id) {
return this.Manager.getInfo(id);
}
/**
* Get middleware statistics
*/
getStats() {
return this.Manager.getStats();
}
/**
* Clear all middleware
*/
clear() {
try {
// Get all tracked middleware IDs and unregister them
const idsToRemove = [];
// Collect all IDs from our name-to-ID mapping
for (const [, id] of this.nameToIdMap.entries()) {
idsToRemove.push(id);
}
// Also get any middleware that might not be in our mapping
const allMiddleware = this.Manager.getInfo();
for (const middleware of allMiddleware) {
// Try to find the ID by looking up the middleware in the manager's registry
// Since MiddlewareInfo doesn't include ID, we need to use the name mapping
const mappedId = this.nameToIdMap.get(middleware.name);
if (mappedId && !idsToRemove.includes(mappedId)) {
idsToRemove.push(mappedId);
}
}
// Unregister all found middleware
let removedCount = 0;
for (const id of idsToRemove) {
if (this.Manager.unregister(id)) {
removedCount++;
// Remove from our tracking map
for (const [name, mappedId] of this.nameToIdMap.entries()) {
if (mappedId === id) {
this.nameToIdMap.delete(name);
break;
}
}
}
}
Logger.logger.debug("middleware", `Cleared ${removedCount} custom middleware`);
}
catch (error) {
Logger.logger.error("middleware", `Failed to clear middleware: ${error}`);
}
return this;
}
/**
* Optimize middleware execution
*/
async optimize() {
try {
await this.Manager.optimize();
Logger.logger.debug("middleware", "Middleware optimization completed");
}
catch (error) {
Logger.logger.error("middleware", `Failed to optimize middleware: ${error}`);
}
return this;
}
/**
* Apply default middleware based on configuration
*/
applyDefaultMiddleware() {
Logger.logger.debug("middleware", "applyDefaultMiddleware method entered\n");
Logger.logger.debug("middleware", `this.config: ${JSON.stringify(this.config, null, 2)}\n`);
Logger.logger.debug("middleware", "Applying default middleware configuration...");
// Apply FortifyJS middleware if security is enabled
if (this.config.security !== false) {
try {
const securityOptions = typeof this.config.security === "object"
? this.config.security
: {};
// Convert complex rateLimit config to boolean for FortifyJS middleware
const rateLimitEnabled = this.config.rateLimit !== false;
const maxRequestsPerMinute = typeof this.config.rateLimit === "object"
? this.config.rateLimit.max || 100
: 100;
const fortifyMiddlewareHandler = express_middleware.middleware({
...securityOptions,
csrfProtection: securityOptions.csrfProtection || false,
secureHeaders: securityOptions.helmet !== false,
rateLimit: rateLimitEnabled,
maxRequestsPerMinute,
customHeaders: securityOptions.customHeaders || {},
});
this.Manager.register(fortifyMiddlewareHandler, {
name: "fortify-security",
priority: "critical",
cacheable: false,
});
Logger.logger.debug("middleware", "FortifyJS security middleware applied");
}
catch (error) {
Logger.logger.warn("middleware", `Failed to apply FortifyJS middleware: ${error}`);
}
}
// Apply CORS if enabled
if (this.config.cors !== false) {
try {
const corsOptions = typeof this.config.cors === "object"
? this.config.cors
: {};
this.Manager.enableCors(corsOptions);
Logger.logger.debug("middleware", "CORS middleware applied");
}
catch (error) {
Logger.logger.warn("middleware", `Failed to apply CORS middleware: ${error}`);
}
}
// Apply compression if enabled
if (this.config.compression !== false) {
try {
const compressionOptions = typeof this.config.compression === "object"
? this.config.compression
: {};
this.Manager.enableCompression(compressionOptions);
Logger.logger.debug("middleware", "Compression middleware applied");
}
catch (error) {
Logger.logger.warn("middleware", `Failed to apply compression middleware: ${error}`);
}
}
// Apply rate limiting if enabled
if (this.config.rateLimit !== false) {
try {
const rateLimitOptions = typeof this.config.rateLimit === "object"
? this.config.rateLimit
: {};
this.Manager.enableRateLimit(rateLimitOptions);
Logger.logger.debug("middleware", "Rate limiting middleware applied");
}
catch (error) {
Logger.logger.warn("middleware", `Failed to apply rate limiting middleware: ${error}`);
}
}
// Apply custom headers if specified
if (this.config.customHeaders) {
try {
const customHeadersMiddleware = (req, res, next) => {
Object.entries(this.config.customHeaders).forEach(([key, value]) => {
res.setHeader(key, value);
});
next();
};
this.Manager.register(customHeadersMiddleware, {
name: "custom-headers",
priority: "high",
cacheable: true,
ttl: 3600000, // 1 hour
});
Logger.logger.debug("middleware", "Custom headers middleware applied");
}
catch (error) {
Logger.logger.warn("middleware", `Failed to apply custom headers middleware: ${error}`);
}
}
Logger.logger.debug("middleware", "Default middleware configuration applied");
}
/**
* Update configuration and reapply middleware
*/
updateConfig(newConfig) {
this.config = { ...this.config, ...newConfig };
this.Manager.configure(this.config);
// Reapply default middleware with new configuration
this.applyDefaultMiddleware();
Logger.logger.debug("middleware", "Middleware configuration updated");
return this;
}
/**
* Get current configuration
*/
getConfig() {
return { ...this.config };
}
/**
* Enable performance tracking for all middleware
*/
enablePerformanceTracking() {
this.config.enablePerformanceTracking = true;
this.Manager.configure(this.config);
Logger.logger.debug("middleware", "Performance tracking enabled for all middleware");
return this;
}
/**
* Disable performance tracking for all middleware
*/
disablePerformanceTracking() {
this.config.enablePerformanceTracking = false;
this.Manager.configure(this.config);
Logger.logger.debug("middleware", "Performance tracking disabled for all middleware");
return this;
}
/**
* Enable caching for all middleware
*/
enableCaching() {
this.config.enableCaching = true;
this.Manager.configure(this.config);
Logger.logger.debug("middleware", "Caching enabled for all middleware");
return this;
}
/**
* Disable caching for all middleware
*/
disableCaching() {
this.config.enableCaching = false;
this.Manager.configure(this.config);
Logger.logger.debug("middleware", "Caching disabled for all middleware");
return this;
}
/**
* Warm up middleware cache
*/
async warmCache() {
try {
await this.Manager.warmCache();
Logger.logger.debug("middleware", "Middleware cache warmed up");
}
catch (error) {
Logger.logger.error("middleware", `Failed to warm cache: ${error}`);
}
return this;
}
/**
* Clear middleware cache
*/
clearCache() {
try {
this.Manager.clearCache();
Logger.logger.debug("middleware", "Middleware cache cleared");
}
catch (error) {
Logger.logger.error("middleware", `Failed to clear cache: ${error}`);
}
return this;
}
}
exports.MiddlewareAPI = MiddlewareAPI;
//# sourceMappingURL=MiddlewareAPI.js.map