@superdangerous/app-framework 4.9.0

package/src/middleware/fileUpload.ts

@@ -0,0 +1,252 @@
+/**
+ * File Upload Middleware
+ * Simple file upload handling for Express
+ */
+
+import { Request, Response, NextFunction } from "express";
+import multer from "multer";
+import path from "path";
+import { getStorageService } from "../core/storageService.js";
+import { createLogger } from "../core/index.js";
+
+let logger: any; // Will be initialized when needed
+
+function ensureLogger() {
+  if (!logger) {
+    logger = createLogger("FileUpload");
+  }
+  return logger;
+}
+
+export interface FileUploadConfig {
+  destination?: string;
+  maxSize?: number;
+  allowedTypes?: string[];
+  fieldName?: string;
+  multiple?: boolean;
+  maxCount?: number;
+}
+
+/**
+ * Create file upload middleware
+ */
+export function createFileUpload(config: FileUploadConfig = {}) {
+  const {
+    destination = "uploads",
+    maxSize = 10 * 1024 * 1024, // 10MB default
+    allowedTypes = [],
+    fieldName = "file",
+    multiple = false,
+    maxCount = 10,
+  } = config;
+
+  // Configure multer storage
+  const storage = multer.memoryStorage();
+
+  // Configure multer
+  const upload = multer({
+    storage,
+    limits: {
+      fileSize: maxSize,
+      files: maxCount,
+    },
+    fileFilter: (_req, file, cb) => {
+      // Check file type if restrictions are set
+      if (allowedTypes.length > 0) {
+        const ext = path.extname(file.originalname).toLowerCase();
+        if (!allowedTypes.includes(ext)) {
+          return cb(new Error(`File type ${ext} not allowed`));
+        }
+      }
+      cb(null, true);
+    },
+  });
+
+  // Return appropriate middleware
+  const multerMiddleware = multiple
+    ? upload.array(fieldName, maxCount)
+    : upload.single(fieldName);
+
+  return async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    multerMiddleware(req, res, async (err) => {
+      if (err) {
+        ensureLogger().error("Upload error:", err);
+
+        if (err instanceof multer.MulterError) {
+          if (err.code === "LIMIT_FILE_SIZE") {
+            res.status(400).json({
+              success: false,
+              error: "File too large",
+              message: `File size exceeds maximum of ${maxSize} bytes`,
+            });
+            return;
+          }
+          if (err.code === "LIMIT_FILE_COUNT") {
+            res.status(400).json({
+              success: false,
+              error: "Too many files",
+              message: `Maximum ${maxCount} files allowed`,
+            });
+            return;
+          }
+        }
+
+        res.status(400).json({
+          success: false,
+          error: "Upload failed",
+          message: err.message,
+        });
+        return;
+      }
+
+      // Process uploaded files via StorageService to keep a single path for uploads
+      try {
+        const storage = getStorageService();
+
+        if (multiple && req.files && Array.isArray(req.files)) {
+          // Multiple files
+          const uploadedFiles = [];
+
+          for (const file of req.files) {
+            const uploaded = await storage.saveUserUpload(
+              file.buffer,
+              file.originalname,
+              {
+                allowedTypes,
+                maxSize,
+                destination,
+              },
+            );
+            uploadedFiles.push({
+              ...uploaded,
+              mimetype: file.mimetype,
+            });
+          }
+
+          req.uploadedFiles = uploadedFiles;
+          ensureLogger().info(`Uploaded ${uploadedFiles.length} files`);
+        } else if (req.file) {
+          // Single file
+          const uploaded = await storage.saveUserUpload(
+            req.file.buffer,
+            req.file.originalname,
+            {
+              allowedTypes,
+              maxSize,
+              destination,
+            },
+          );
+
+          req.uploadedFile = {
+            ...uploaded,
+            mimetype: req.file.mimetype,
+          };
+          ensureLogger().info(`Uploaded file: ${uploaded.filename}`);
+        }
+
+        next();
+      } catch (_error: any) {
+        ensureLogger().error("File processing error:", _error);
+        res.status(500).json({
+          success: false,
+          error: "File processing failed",
+          message: _error.message,
+        });
+      }
+    });
+  };
+}
+
+/**
+ * Parse form data middleware (for mixed file/data uploads)
+ */
+export function parseFormData(fields: string[] = []) {
+  const upload = multer();
+  return upload.fields(fields.map((field) => ({ name: field })));
+}
+
+/**
+ * Download file helper
+ */
+export function sendFile(filePath: string, filename?: string) {
+  return (_req: Request, res: Response) => {
+    const resolvedPath = path.resolve(filePath);
+    const downloadName = filename || path.basename(filePath);
+
+    res.download(resolvedPath, downloadName, (err) => {
+      if (err) {
+        ensureLogger().error("Download error:", err);
+        if (!res.headersSent) {
+          res.status(404).json({
+            success: false,
+            error: "File not found",
+          });
+        }
+      }
+    });
+  };
+}
+
+/**
+ * Express middleware to clean old temp files periodically
+ */
+export function createTempCleaner(
+  tempDir: string = "./temp",
+  maxAge: number = 24 * 60 * 60 * 1000, // 24 hours
+  interval: number = 60 * 60 * 1000, // 1 hour
+) {
+  const storage = getStorageService();
+
+  // Start periodic cleaning
+  setInterval(async () => {
+    try {
+      const deleted = await storage.cleanTempFiles(maxAge, tempDir);
+      if (deleted > 0) {
+        ensureLogger().info(`Cleaned ${deleted} old temporary files`);
+      }
+    } catch (_error: any) {
+      ensureLogger().error("Temp file cleanup error:", _error);
+    }
+  }, interval);
+
+  // Return middleware that does nothing (just starts the cleaner)
+  return (_req: Request, _res: Response, next: NextFunction) => next();
+}
+
+// Extend Express Request type
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Express {
+    interface Request {
+      uploadedFile?: {
+        originalName: string;
+        filename: string;
+        path: string;
+        size: number;
+        mimetype?: string;
+        extension: string;
+        hash?: string;
+      };
+      uploadedFiles?: Array<{
+        originalName: string;
+        filename: string;
+        path: string;
+        size: number;
+        mimetype?: string;
+        extension: string;
+        hash?: string;
+      }>;
+    }
+  }
+}
+
+export default {
+  createFileUpload,
+  parseFormData,
+  sendFile,
+  createTempCleaner,
+};

package/src/middleware/health.ts

@@ -0,0 +1,206 @@
+/**
+ * Standardized Health Check Middleware
+ * Provides consistent health monitoring across all applications
+ */
+
+import { Request, Response, Router } from "express";
+import os from "os";
+
+export interface HealthCheckOptions {
+  includeDetails?: boolean;
+  checkComponents?: () => Promise<ComponentHealth>;
+  version?: string;
+  serviceName?: string;
+}
+
+export interface ComponentHealth {
+  [key: string]: {
+    status: "healthy" | "degraded" | "unhealthy";
+    message?: string;
+    latency?: number;
+  };
+}
+
+export interface HealthResponse {
+  status: "healthy" | "degraded" | "unhealthy";
+  timestamp: string;
+  version: string;
+  uptime: number;
+  service?: string;
+  components?: ComponentHealth;
+  resources?: {
+    memory: {
+      used: number;
+      total: number;
+      percentage: number;
+    };
+    cpu: {
+      usage: number;
+      cores: number;
+    };
+  };
+}
+
+/**
+ * Get system resource usage
+ */
+function getSystemResources() {
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  const usedMem = totalMem - freeMem;
+
+  // Simplified CPU usage calculation
+  const cpus = os.cpus();
+  let totalIdle = 0;
+  let totalTick = 0;
+
+  cpus.forEach((cpu) => {
+    for (const type in cpu.times) {
+      totalTick += cpu.times[type as keyof typeof cpu.times];
+    }
+    totalIdle += cpu.times.idle;
+  });
+
+  const idle = totalIdle / cpus.length;
+  const total = totalTick / cpus.length;
+  const usage = Math.round(100 - (100 * idle) / total);
+
+  return {
+    memory: {
+      used: usedMem,
+      total: totalMem,
+      percentage: Math.round((usedMem / totalMem) * 100),
+    },
+    cpu: {
+      usage,
+      cores: cpus.length,
+    },
+  };
+}
+
+/**
+ * Determine overall health status based on components
+ */
+function determineOverallHealth(
+  components?: ComponentHealth,
+): "healthy" | "degraded" | "unhealthy" {
+  if (!components) return "healthy";
+
+  const statuses = Object.values(components).map((c) => c.status);
+
+  if (statuses.some((s) => s === "unhealthy")) {
+    return "unhealthy";
+  }
+
+  if (statuses.some((s) => s === "degraded")) {
+    return "degraded";
+  }
+
+  return "healthy";
+}
+
+/**
+ * Create standardized health check endpoint
+ * @param {HealthCheckOptions} options - Health check configuration
+ * @returns {Router} Express router with health endpoint
+ */
+export function createHealthCheck(options: HealthCheckOptions = {}): Router {
+  const router = Router();
+  const {
+    includeDetails = true,
+    checkComponents,
+    version = process.env.npm_package_version || "1.0.0",
+    serviceName,
+  } = options;
+
+  /**
+   * GET /health
+   * Standard health check endpoint
+   */
+  router.get("/health", async (_req: Request, res: Response) => {
+    try {
+      // Check component health if provided
+      const components = checkComponents ? await checkComponents() : undefined;
+
+      // Build health response
+      const health: HealthResponse = {
+        status: determineOverallHealth(components),
+        timestamp: new Date().toISOString(),
+        version,
+        uptime: process.uptime(),
+      };
+
+      if (serviceName) {
+        health.service = serviceName;
+      }
+
+      if (includeDetails) {
+        health.resources = getSystemResources();
+      }
+
+      if (components) {
+        health.components = components;
+      }
+
+      // Set appropriate status code
+      const statusCode =
+        health.status === "healthy"
+          ? 200
+          : health.status === "degraded"
+            ? 200
+            : 503;
+
+      res.status(statusCode).json(health);
+    } catch (_error: any) {
+      res.status(503).json({
+        status: "unhealthy",
+        timestamp: new Date().toISOString(),
+        version,
+        error: _error.message,
+      });
+    }
+  });
+
+  /**
+   * GET /health/ready
+   * Readiness check (for k8s)
+   */
+  router.get("/health/ready", async (_req: Request, res: Response) => {
+    try {
+      const components = checkComponents ? await checkComponents() : undefined;
+      const status = determineOverallHealth(components);
+
+      if (status === "healthy") {
+        res.status(200).json({ ready: true });
+      } else {
+        res.status(503).json({ ready: false, status });
+      }
+    } catch (_error) {
+      res.status(503).json({ ready: false });
+    }
+  });
+
+  /**
+   * GET /health/live
+   * Liveness check (for k8s)
+   */
+  router.get("/health/live", (_req: Request, res: Response) => {
+    res.status(200).json({ alive: true });
+  });
+
+  return router;
+}
+
+/**
+ * Simple health check middleware for basic use
+ */
+export function healthCheck(_req: Request, res: Response) {
+  const health: HealthResponse = {
+    status: "healthy",
+    timestamp: new Date().toISOString(),
+    version: process.env.npm_package_version || "1.0.0",
+    uptime: process.uptime(),
+  };
+
+  res.json(health);
+}

package/src/middleware/index.ts

@@ -0,0 +1,71 @@
+/**
+ * Middleware Module Exports
+ */
+
+export {
+  schemas,
+  validate,
+  validateParams,
+  validateQuery,
+  validateAsync,
+  validateRequest,
+  validateIf,
+  compose,
+  z,
+  zod,
+} from "./validation.js";
+
+export { aiErrorHandler } from "./aiErrorHandler.js";
+export {
+  errorHandler,
+  notFoundHandler,
+  asyncHandler,
+  AppError,
+} from "./errorHandler.js";
+export {
+  createFileUpload,
+  parseFormData,
+  sendFile,
+  createTempCleaner,
+} from "./fileUpload.js";
+export type { FileUploadConfig } from "./fileUpload.js";
+export { createHealthCheck, healthCheck } from "./health.js";
+export type {
+  HealthCheckOptions,
+  ComponentHealth,
+  HealthResponse,
+} from "./health.js";
+export {
+  setupOpenAPIDocumentation,
+  generateOpenAPISpec,
+  ApiOperation,
+} from "./openapi.js";
+export type { OpenAPIConfig } from "./openapi.js";
+
+// Auth middleware exports
+export {
+  createAuthMiddleware,
+  createLoginHandler,
+  createLogoutHandler,
+  createAuthCheckHandler,
+  SimpleAuthService,
+} from "./auth.js";
+export type { AuthConfig } from "./auth.js";
+
+// Session middleware exports
+export { configureSession } from "./session.js";
+export type { SessionConfig as SessionMiddlewareConfig } from "./session.js";
+
+// CORS middleware exports
+export {
+  createDynamicCors,
+  createProductionCors,
+  createDevCors,
+} from "./cors.js";
+export type { DynamicCorsOptions } from "./cors.js";
+
+// Request logging / context
+export {
+  createRequestLoggingMiddleware,
+  type RequestLoggingOptions,
+} from "./requestLogging.js";