next-api-analyzer/dist/index.mjs

Next.js API routes analyzer for security, performance, and maintainability

#!/usr/bin/env node
import {
  NextApiAnalyzer,
  OpenApiPlugin,
  PluginManager,
  TestCoveragePlugin,
  analyzeApiRoutes,
  default_config_exports,
  file_utils_exports,
  logger,
  logger_exports,
  performance_analyzer_exports,
  program,
  security_analyzer_exports,
  withApiTracking
} from "./chunk-W4BQDOXZ.mjs";

// src/lib/cache-manager.ts
import fs from "fs/promises";
import path from "path";
import crypto from "crypto";
var CacheManager = class {
  constructor(config) {
    this.memoryCache = /* @__PURE__ */ new Map();
    this.config = config;
    this.startCleanupTimer();
  }
  async get(key) {
    if (!this.config.enabled) return null;
    try {
      const memoryEntry = this.memoryCache.get(key);
      if (memoryEntry && this.isValid(memoryEntry)) {
        return memoryEntry.data;
      }
      const diskEntry = await this.getDiskCache(key);
      if (diskEntry && this.isValid(diskEntry)) {
        this.memoryCache.set(key, diskEntry);
        return diskEntry.data;
      }
      return null;
    } catch (error) {
      logger.warn(`Cache get error for key ${key}:`, error);
      return null;
    }
  }
  async set(key, data, ttl) {
    if (!this.config.enabled) return;
    try {
      const entry = {
        data,
        timestamp: Date.now(),
        ttl: ttl || this.config.ttl
      };
      this.memoryCache.set(key, entry);
      await this.setDiskCache(key, entry);
    } catch (error) {
      logger.warn(`Cache set error for key ${key}:`, error);
    }
  }
  generateKey(...parts) {
    return crypto.createHash("md5").update(parts.join(":")).digest("hex");
  }
  isValid(entry) {
    return Date.now() - entry.timestamp < entry.ttl;
  }
  async getDiskCache(key) {
    try {
      const filePath = path.join(this.config.directory, `${key}.json`);
      const content = await fs.readFile(filePath, "utf-8");
      return JSON.parse(content);
    } catch {
      return null;
    }
  }
  async setDiskCache(key, entry) {
    try {
      const filePath = path.join(this.config.directory, `${key}.json`);
      await fs.mkdir(path.dirname(filePath), { recursive: true });
      await fs.writeFile(filePath, JSON.stringify(entry), "utf-8");
    } catch (error) {
      logger.debug(`Disk cache write error for ${key}:`, error);
    }
  }
  startCleanupTimer() {
    setInterval(() => {
      for (const [key, entry] of this.memoryCache.entries()) {
        if (!this.isValid(entry)) {
          this.memoryCache.delete(key);
        }
      }
    }, 6e4);
  }
};

// src/index.ts
var VERSION = "3.1.0";
var ENTERPRISE_CONFIG = {
  enableTrends: true,
  enablePerformanceAnalysis: true,
  enableSecurityAnalysis: true,
  parallel: true,
  maxConcurrency: 8,
  thresholds: {
    security: 95,
    performance: 90,
    maintainability: 85,
    testCoverage: 90,
    complexity: 6
  },
  cache: {
    enabled: true,
    ttl: 36e5,
    directory: ".cache/enterprise-analyzer"
  }
};
var SECURITY_FOCUSED_CONFIG = {
  enableSecurityAnalysis: true,
  enablePerformanceAnalysis: false,
  thresholds: {
    security: 90,
    performance: 50,
    maintainability: 50,
    testCoverage: 70,
    complexity: 10
  }
};
var PERFORMANCE_FOCUSED_CONFIG = {
  enablePerformanceAnalysis: true,
  enableSecurityAnalysis: false,
  thresholds: {
    security: 50,
    performance: 85,
    maintainability: 80,
    testCoverage: 60,
    complexity: 8
  }
};
function createSecurityAnalyzer(config) {
  return new NextApiAnalyzer({ ...SECURITY_FOCUSED_CONFIG, ...config });
}
function createPerformanceAnalyzer(config) {
  return new NextApiAnalyzer({ ...PERFORMANCE_FOCUSED_CONFIG, ...config });
}
function createEnterpriseAnalyzer(config) {
  return new NextApiAnalyzer({ ...ENTERPRISE_CONFIG, ...config });
}
async function quickSecurityAudit(apiDir) {
  const analyzer = createSecurityAnalyzer({ apiDir });
  return analyzer.analyzeRoutes();
}
async function quickPerformanceAudit(apiDir) {
  const analyzer = createPerformanceAnalyzer({ apiDir });
  return analyzer.analyzeRoutes();
}
async function quickEnterpriseAudit(apiDir) {
  const analyzer = createEnterpriseAnalyzer({ apiDir });
  return analyzer.analyzeRoutes();
}
export {
  CacheManager,
  ENTERPRISE_CONFIG,
  NextApiAnalyzer,
  OpenApiPlugin,
  PERFORMANCE_FOCUSED_CONFIG,
  PluginManager,
  SECURITY_FOCUSED_CONFIG,
  TestCoveragePlugin,
  VERSION,
  analyzeApiRoutes,
  createEnterpriseAnalyzer,
  createPerformanceAnalyzer,
  createSecurityAnalyzer,
  default_config_exports as defaultConfig,
  file_utils_exports as fileUtils,
  logger_exports as logger,
  performance_analyzer_exports as performanceAnalyzer,
  program,
  quickEnterpriseAudit,
  quickPerformanceAudit,
  quickSecurityAudit,
  security_analyzer_exports as securityAnalyzer,
  withApiTracking
};
//# sourceMappingURL=index.mjs.map