db-backup-logging 1.0.0

package/dist/index.js

@@ -0,0 +1,408 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  errorMiddleware: () => errorMiddleware,
+  initializeNoticePackage: () => initializeNoticePackage,
+  logCustomError: () => logCustomError,
+  manualBackupTrigger: () => manualBackupTrigger,
+  requestLogger: () => requestLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/config.ts
+var _config = null;
+function setConfig(config) {
+  _config = { ...config };
+}
+function getConfig() {
+  if (!_config) {
+    throw new Error(
+      "[notice-utility] Package not initialized. Call initializeNoticePackage() first."
+    );
+  }
+  return _config;
+}
+
+// src/utils/db.ts
+var import_mongoose = __toESM(require("mongoose"));
+var modelCache = /* @__PURE__ */ new Map();
+var localConnection = null;
+function getDbConnection() {
+  if (!localConnection) {
+    localConnection = import_mongoose.default.createConnection(getConfig().dbUri);
+  }
+  return localConnection;
+}
+function getModel(collectionName) {
+  if (modelCache.has(collectionName)) {
+    return modelCache.get(collectionName);
+  }
+  const schema = new import_mongoose.Schema(
+    {},
+    {
+      strict: false,
+      timestamps: false,
+      collection: collectionName
+    }
+  );
+  const conn = getDbConnection();
+  let model;
+  try {
+    model = conn.model(collectionName);
+  } catch {
+    model = conn.model(collectionName, schema);
+  }
+  modelCache.set(collectionName, model);
+  return model;
+}
+function getDbUri() {
+  return getConfig().dbUri;
+}
+
+// src/utils/queue.ts
+var queue = [];
+var isProcessing = false;
+var BATCH_SIZE = 50;
+var FLUSH_INTERVAL_MS = 5e3;
+var MAX_RETRIES = 3;
+var flushTimer = null;
+function enqueue(collectionName, data) {
+  queue.push({ collectionName, data });
+  if (!flushTimer) {
+    flushTimer = setInterval(() => {
+      flush().catch(() => {
+      });
+    }, FLUSH_INTERVAL_MS);
+    if (flushTimer && typeof flushTimer === "object" && "unref" in flushTimer) {
+      flushTimer.unref();
+    }
+  }
+  if (queue.length >= BATCH_SIZE) {
+    flush().catch(() => {
+    });
+  }
+}
+async function flush() {
+  if (isProcessing || queue.length === 0) return;
+  isProcessing = true;
+  const batch = queue.splice(0, BATCH_SIZE);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of batch) {
+    const list = grouped.get(item.collectionName) || [];
+    list.push(item.data);
+    grouped.set(item.collectionName, list);
+  }
+  for (const [collectionName, docs] of grouped) {
+    let retries = 0;
+    while (retries < MAX_RETRIES) {
+      try {
+        const Model2 = getModel(collectionName);
+        await Model2.insertMany(docs, { ordered: false });
+        break;
+      } catch (err) {
+        retries++;
+        if (retries >= MAX_RETRIES) {
+          console.error(
+            `[notice-utility] Failed to write ${docs.length} logs to "${collectionName}" after ${MAX_RETRIES} retries:`,
+            err instanceof Error ? err.message : err
+          );
+        } else {
+          await new Promise((r) => setTimeout(r, 100 * retries));
+        }
+      }
+    }
+  }
+  isProcessing = false;
+  if (queue.length > 0) {
+    flush().catch(() => {
+    });
+  }
+}
+
+// src/exceptions/index.ts
+function logError(error, context) {
+  try {
+    const config = getConfig();
+    const err = typeof error === "string" ? new Error(error) : error;
+    const logEntry = {
+      errorMessage: err.message,
+      stackTrace: err.stack || null,
+      requestContext: context?.req ? {
+        method: context.req.method,
+        url: context.req.originalUrl || context.req.url,
+        headers: context.req.headers,
+        body: context.req.body || null
+      } : null,
+      userId: context?.userId || context?.req?.user?.id || context?.req?.user?._id || null,
+      serviceName: config.serviceName || null,
+      environment: config.environment || process.env.NODE_ENV || null,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    enqueue(config.tables.errorLogs, logEntry);
+  } catch {
+  }
+}
+function registerExceptionHandlers() {
+  const existingUncaught = process.listeners("uncaughtException").slice();
+  const existingRejection = process.listeners("unhandledRejection").slice();
+  process.on("uncaughtException", (error) => {
+    logError(error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    logError(error);
+  });
+}
+function errorMiddleware() {
+  return (err, req, res, next) => {
+    logError(err, { req });
+    next(err);
+  };
+}
+function logCustomError(error, context) {
+  try {
+    const config = getConfig();
+    const err = typeof error === "string" ? new Error(error) : error;
+    const logEntry = {
+      errorMessage: err.message,
+      stackTrace: err.stack || null,
+      requestContext: context?.requestContext || null,
+      userId: context?.userId || null,
+      serviceName: config.serviceName || null,
+      environment: config.environment || process.env.NODE_ENV || null,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    enqueue(config.tables.errorLogs, logEntry);
+  } catch {
+  }
+}
+
+// src/init.ts
+function initializeNoticePackage(config) {
+  if (!config.dbType) {
+    throw new Error('[notice-utility] "dbType" is required in config.');
+  }
+  if (!config.dbUri) {
+    throw new Error('[notice-utility] "dbUri" is required in config.');
+  }
+  if (!config.tables) {
+    throw new Error('[notice-utility] "tables" configuration is required.');
+  }
+  if (!config.tables.requestLogs || !config.tables.errorLogs || !config.tables.backupLogs) {
+    throw new Error(
+      "[notice-utility] All table names (requestLogs, errorLogs, backupLogs) must be configured."
+    );
+  }
+  if (config.aws?.enabled) {
+    if (!config.aws.bucketName || !config.aws.region) {
+      throw new Error(
+        '[notice-utility] AWS "bucketName" and "region" are required when AWS is enabled.'
+      );
+    }
+    if (!config.aws.accessKeyId || !config.aws.secretAccessKey) {
+      throw new Error(
+        '[notice-utility] AWS "accessKeyId" and "secretAccessKey" are required when AWS is enabled.'
+      );
+    }
+  }
+  if (config.local?.enabled) {
+    if (!config.local.backupPath) {
+      throw new Error(
+        '[notice-utility] Local "backupPath" is required when local backup is enabled.'
+      );
+    }
+  }
+  setConfig(config);
+  registerExceptionHandlers();
+  console.log(
+    `[notice-utility] Initialized successfully (db: ${config.dbType}, service: ${config.serviceName || "default"}, env: ${config.environment || process.env.NODE_ENV || "development"})`
+  );
+}
+
+// src/logger/index.ts
+function requestLogger() {
+  return (req, res, next) => {
+    const startTime = Date.now();
+    const originalJson = res.json.bind(res);
+    let responseBody = void 0;
+    res.json = function(body) {
+      responseBody = body;
+      return originalJson(body);
+    };
+    res.on("finish", () => {
+      try {
+        const config = getConfig();
+        const responseTime = Date.now() - startTime;
+        const logEntry = {
+          method: req.method,
+          url: req.originalUrl || req.url,
+          headers: req.headers,
+          requestBody: req.body || null,
+          responseStatus: res.statusCode,
+          responseBody: responseBody ?? null,
+          responseTime,
+          userId: req.user?.id || req.user?._id || req.userId || null,
+          ipAddress: req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.socket?.remoteAddress || "unknown",
+          serviceName: config.serviceName || null,
+          environment: config.environment || process.env.NODE_ENV || null,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        enqueue(config.tables.requestLogs, logEntry);
+      } catch {
+      }
+    });
+    next();
+  };
+}
+
+// src/backup/index.ts
+var import_child_process = require("child_process");
+var import_util = require("util");
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+function getBackupFileName() {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[:.]/g, "-");
+  return `backup-${ts}`;
+}
+async function performBackup() {
+  const config = getConfig();
+  const dbUri = getDbUri();
+  const fileName = getBackupFileName();
+  const archiveName = `${fileName}.zip`;
+  const tempDir = path.resolve(process.cwd(), ".notice-backups-tmp");
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+  const dumpDir = path.join(tempDir, fileName);
+  const archivePath = path.join(tempDir, archiveName);
+  try {
+    console.log(`[notice-utility] Starting backup: ${archiveName}`);
+    await execAsync(`mongodump --uri="${dbUri}" --out="${dumpDir}"`);
+    await execAsync(`zip -r "${archivePath}" "${fileName}"`, { cwd: tempDir });
+    const stats = fs.statSync(archivePath);
+    const fileSize = stats.size;
+    if (config.local?.enabled) {
+      const localDir = path.resolve(process.cwd(), config.local.backupPath);
+      if (!fs.existsSync(localDir)) {
+        fs.mkdirSync(localDir, { recursive: true });
+      }
+      const localPath = path.join(localDir, archiveName);
+      fs.copyFileSync(archivePath, localPath);
+      console.log(`[notice-utility] Backup saved locally: ${localPath}`);
+      await logBackup({
+        backupFileName: archiveName,
+        backupType: "full",
+        location: "local",
+        fileSize,
+        status: "success"
+      });
+    }
+    if (config.aws?.enabled) {
+      await uploadToS3(archivePath, archiveName, fileSize);
+    }
+    if (fs.existsSync(archivePath)) {
+      fs.unlinkSync(archivePath);
+    }
+    if (fs.existsSync(dumpDir)) {
+      fs.rmSync(dumpDir, { recursive: true, force: true });
+    }
+    console.log(`[notice-utility] Backup completed: ${archiveName}`);
+  } catch (err) {
+    console.error("[notice-utility] Backup failed:", err instanceof Error ? err.message : err);
+    await logBackup({
+      backupFileName: archiveName,
+      backupType: "full",
+      location: config.aws?.enabled ? "s3" : "local",
+      fileSize: 0,
+      status: "failed",
+      errorMessage: err instanceof Error ? err.message : String(err)
+    }).catch(() => {
+    });
+  }
+}
+async function uploadToS3(filePath, fileName, fileSize) {
+  const config = getConfig();
+  if (!config.aws) throw new Error("AWS config not provided");
+  const { S3Client, PutObjectCommand } = await import("@aws-sdk/client-s3");
+  const s3Client = new S3Client({
+    region: config.aws.region,
+    credentials: {
+      accessKeyId: config.aws.accessKeyId,
+      secretAccessKey: config.aws.secretAccessKey
+    }
+  });
+  const fileBuffer = fs.readFileSync(filePath);
+  const command = new PutObjectCommand({
+    Bucket: config.aws.bucketName,
+    Key: `backups/${fileName}`,
+    Body: fileBuffer,
+    ContentType: "application/zip"
+  });
+  await s3Client.send(command);
+  console.log(`[notice-utility] Backup uploaded to S3: backups/${fileName}`);
+  await logBackup({
+    backupFileName: fileName,
+    backupType: "full",
+    location: "s3",
+    fileSize,
+    status: "success"
+  });
+}
+async function logBackup(entry) {
+  try {
+    const config = getConfig();
+    const Model2 = getModel(config.tables.backupLogs);
+    await Model2.create({
+      ...entry,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  } catch (err) {
+    console.error(
+      "[notice-utility] Failed to write backup log:",
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+async function manualBackupTrigger() {
+  await performBackup();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errorMiddleware,
+  initializeNoticePackage,
+  logCustomError,
+  manualBackupTrigger,
+  requestLogger
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/utils/config.ts","../src/utils/db.ts","../src/utils/queue.ts","../src/exceptions/index.ts","../src/init.ts","../src/logger/index.ts","../src/backup/index.ts"],"sourcesContent":["// ─── Public API ─────────────────────────────────────────────────────────────\n\nexport { initializeNoticePackage } from './init'\nexport { requestLogger } from './logger'\nexport { manualBackupTrigger } from './backup'\nexport { logCustomError, errorMiddleware } from './exceptions'\n\n// ─── Types ──────────────────────────────────────────────────────────────────\n\nexport type {\n  NoticeConfig,\n  AWSConfig,\n  LocalConfig,\n  NoticeTables,\n  RequestLogEntry,\n  ErrorLogEntry,\n  BackupLogEntry,\n} from './types'\n","import type { NoticeConfig } from '../types'\n\nlet _config: NoticeConfig | null = null\n\nexport function setConfig(config: NoticeConfig): void {\n  _config = { ...config }\n}\n\nexport function getConfig(): NoticeConfig {\n  if (!_config) {\n    throw new Error(\n      '[notice-utility] Package not initialized. Call initializeNoticePackage() first.'\n    )\n  }\n  return _config\n}\n","import mongoose, { Schema, Model, Connection } from 'mongoose'\nimport { getConfig } from './config'\n\nconst modelCache = new Map<string, Model<any>>()\n\nlet localConnection: Connection | null = null\n\nexport function getDbConnection(): Connection {\n  if (!localConnection) {\n    localConnection = mongoose.createConnection(getConfig().dbUri)\n  }\n  return localConnection\n}\n\n/**\n * Gets or creates a Mongoose model for the given collection name.\n * Uses a flexible mixed schema to support any log structure.\n */\nexport function getModel(collectionName: string): Model<any> {\n  if (modelCache.has(collectionName)) {\n    return modelCache.get(collectionName)!\n  }\n\n  const schema = new Schema(\n    {},\n    {\n      strict: false,\n      timestamps: false,\n      collection: collectionName,\n    }\n  )\n\n  // Use a dedicated connection for notice-utility to avoid 'npm link' duplication issues\n  const conn: Connection = getDbConnection()\n\n  // Avoid OverwriteModelError — check if model already exists\n  let model: Model<any>\n  try {\n    model = conn.model(collectionName)\n  } catch {\n    model = conn.model(collectionName, schema)\n  }\n\n  modelCache.set(collectionName, model)\n  return model\n}\n\n/**\n * Creates a separate Mongoose connection for backup purposes (mongodump URI).\n */\nexport function getDbUri(): string {\n  return getConfig().dbUri\n}\n","import { getModel } from './db'\n\ninterface QueueItem {\n  collectionName: string\n  data: Record<string, unknown>\n}\n\nconst queue: QueueItem[] = []\nlet isProcessing = false\nconst BATCH_SIZE = 50\nconst FLUSH_INTERVAL_MS = 5000\nconst MAX_RETRIES = 3\n\nlet flushTimer: ReturnType<typeof setInterval> | null = null\n\n/**\n * Enqueue a log entry for async writing to the database.\n * This never throws — all errors are silently logged to console.\n */\nexport function enqueue(collectionName: string, data: Record<string, unknown>): void {\n  queue.push({ collectionName, data })\n\n  // Start the flush interval if not already running\n  if (!flushTimer) {\n    flushTimer = setInterval(() => {\n      flush().catch(() => {})\n    }, FLUSH_INTERVAL_MS)\n\n    // Unref so the timer doesn't keep the process alive\n    if (flushTimer && typeof flushTimer === 'object' && 'unref' in flushTimer) {\n      flushTimer.unref()\n    }\n  }\n\n  // If queue reaches batch size, flush immediately\n  if (queue.length >= BATCH_SIZE) {\n    flush().catch(() => {})\n  }\n}\n\n/**\n * Flush all queued log entries to the database.\n */\nexport async function flush(): Promise<void> {\n  if (isProcessing || queue.length === 0) return\n  isProcessing = true\n\n  const batch = queue.splice(0, BATCH_SIZE)\n\n  // Group by collection\n  const grouped = new Map<string, Record<string, unknown>[]>()\n  for (const item of batch) {\n    const list = grouped.get(item.collectionName) || []\n    list.push(item.data)\n    grouped.set(item.collectionName, list)\n  }\n\n  for (const [collectionName, docs] of grouped) {\n    let retries = 0\n    while (retries < MAX_RETRIES) {\n      try {\n        const Model = getModel(collectionName)\n        await Model.insertMany(docs, { ordered: false })\n        break\n      } catch (err) {\n        retries++\n        if (retries >= MAX_RETRIES) {\n          console.error(\n            `[notice-utility] Failed to write ${docs.length} logs to \"${collectionName}\" after ${MAX_RETRIES} retries:`,\n            err instanceof Error ? err.message : err\n          )\n        } else {\n          // Brief delay before retry\n          await new Promise((r) => setTimeout(r, 100 * retries))\n        }\n      }\n    }\n  }\n\n  isProcessing = false\n\n  // If there are more items in the queue, continue flushing\n  if (queue.length > 0) {\n    flush().catch(() => {})\n  }\n}\n","import type { Request, Response, NextFunction } from 'express'\nimport { getConfig } from '../utils/config'\nimport { enqueue } from '../utils/queue'\n\n/**\n * Log an error entry to the configured errorLogs collection.\n */\nfunction logError(\n  error: Error | string,\n  context?: {\n    req?: Request\n    userId?: string\n  }\n): void {\n  try {\n    const config = getConfig()\n    const err = typeof error === 'string' ? new Error(error) : error\n\n    const logEntry: Record<string, unknown> = {\n      errorMessage: err.message,\n      stackTrace: err.stack || null,\n      requestContext: context?.req\n        ? {\n            method: context.req.method,\n            url: context.req.originalUrl || context.req.url,\n            headers: context.req.headers,\n            body: context.req.body || null,\n          }\n        : null,\n      userId:\n        context?.userId ||\n        (context?.req as any)?.user?.id ||\n        (context?.req as any)?.user?._id ||\n        null,\n      serviceName: config.serviceName || null,\n      environment: config.environment || process.env.NODE_ENV || null,\n      createdAt: new Date(),\n    }\n\n    enqueue(config.tables.errorLogs, logEntry)\n  } catch {\n    // Silent — error logging failure must never cause further errors\n  }\n}\n\n/**\n * Register global process-level exception handlers.\n * Chains with existing handlers — does NOT override them.\n */\nexport function registerExceptionHandlers(): void {\n  // Store references to any existing handlers so we can chain\n  const existingUncaught = process.listeners('uncaughtException').slice()\n  const existingRejection = process.listeners('unhandledRejection').slice()\n\n  // uncaughtException\n  process.on('uncaughtException', (error: Error) => {\n    logError(error)\n    // Don't prevent the default crash behavior for truly unrecoverable errors\n    // The existing handlers will still fire since we're adding, not replacing\n  })\n\n  // unhandledRejection\n  process.on('unhandledRejection', (reason: unknown) => {\n    const error = reason instanceof Error ? reason : new Error(String(reason))\n    logError(error)\n  })\n}\n\n/**\n * Express error-handling middleware.\n * Must be registered AFTER all routes: app.use(errorMiddleware())\n */\nexport function errorMiddleware() {\n  return (err: Error, req: Request, res: Response, next: NextFunction): void => {\n    logError(err, { req })\n\n    // Pass to the next error handler (don't swallow the error)\n    next(err)\n  }\n}\n\n/**\n * Public export — manually log a custom error with optional context.\n */\nexport function logCustomError(\n  error: Error | string,\n  context?: {\n    userId?: string\n    requestContext?: {\n      method?: string\n      url?: string\n      headers?: Record<string, string | string[] | undefined>\n      body?: unknown\n    }\n  }\n): void {\n  try {\n    const config = getConfig()\n    const err = typeof error === 'string' ? new Error(error) : error\n\n    const logEntry: Record<string, unknown> = {\n      errorMessage: err.message,\n      stackTrace: err.stack || null,\n      requestContext: context?.requestContext || null,\n      userId: context?.userId || null,\n      serviceName: config.serviceName || null,\n      environment: config.environment || process.env.NODE_ENV || null,\n      createdAt: new Date(),\n    }\n\n    enqueue(config.tables.errorLogs, logEntry)\n  } catch {\n    // Silent\n  }\n}\n","import type { NoticeConfig } from './types'\nimport { setConfig } from './utils/config'\nimport { registerExceptionHandlers } from './exceptions'\n\n/**\n * Initialize the notice-utility package.\n * Must be called once during application startup, after mongoose.connect().\n *\n * @param config - Full package configuration\n */\nexport function initializeNoticePackage(config: NoticeConfig): void {\n  // Validate required fields\n  if (!config.dbType) {\n    throw new Error('[notice-utility] \"dbType\" is required in config.')\n  }\n  if (!config.dbUri) {\n    throw new Error('[notice-utility] \"dbUri\" is required in config.')\n  }\n  if (!config.tables) {\n    throw new Error('[notice-utility] \"tables\" configuration is required.')\n  }\n  if (!config.tables.requestLogs || !config.tables.errorLogs || !config.tables.backupLogs) {\n    throw new Error(\n      '[notice-utility] All table names (requestLogs, errorLogs, backupLogs) must be configured.'\n    )\n  }\n\n  // Validate AWS config if enabled\n  if (config.aws?.enabled) {\n    if (!config.aws.bucketName || !config.aws.region) {\n      throw new Error(\n        '[notice-utility] AWS \"bucketName\" and \"region\" are required when AWS is enabled.'\n      )\n    }\n    if (!config.aws.accessKeyId || !config.aws.secretAccessKey) {\n      throw new Error(\n        '[notice-utility] AWS \"accessKeyId\" and \"secretAccessKey\" are required when AWS is enabled.'\n      )\n    }\n  }\n\n  // Validate local config if enabled\n  if (config.local?.enabled) {\n    if (!config.local.backupPath) {\n      throw new Error(\n        '[notice-utility] Local \"backupPath\" is required when local backup is enabled.'\n      )\n    }\n  }\n\n  // Store config\n  setConfig(config)\n\n  // Register global exception handlers\n  registerExceptionHandlers()\n\n  console.log(\n    `[notice-utility] Initialized successfully (db: ${config.dbType}, service: ${config.serviceName || 'default'}, env: ${config.environment || process.env.NODE_ENV || 'development'})`\n  )\n}\n","import type { Request, Response, NextFunction } from 'express'\nimport { getConfig } from '../utils/config'\nimport { enqueue } from '../utils/queue'\n\n/**\n * Express middleware factory for request/response logging.\n * Captures method, URL, headers, body, response, timing, user, IP.\n * All logging is non-blocking via the async queue.\n */\nexport function requestLogger() {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    const startTime = Date.now()\n\n    // Capture the original res.json to intercept the response body\n    const originalJson = res.json.bind(res)\n    let responseBody: unknown = undefined\n\n    res.json = function (body: any) {\n      responseBody = body\n      return originalJson(body)\n    }\n\n    // Hook into the 'finish' event to log after response is sent\n    res.on('finish', () => {\n      try {\n        const config = getConfig()\n        const responseTime = Date.now() - startTime\n\n        const logEntry: Record<string, unknown> = {\n          method: req.method,\n          url: req.originalUrl || req.url,\n          headers: req.headers,\n          requestBody: req.body || null,\n          responseStatus: res.statusCode,\n          responseBody: responseBody ?? null,\n          responseTime,\n          userId: (req as any).user?.id || (req as any).user?._id || (req as any).userId || null,\n          ipAddress:\n            (req.headers['x-forwarded-for'] as string)?.split(',')[0]?.trim() ||\n            req.socket?.remoteAddress ||\n            'unknown',\n          serviceName: config.serviceName || null,\n          environment: config.environment || process.env.NODE_ENV || null,\n          createdAt: new Date(),\n        }\n\n        enqueue(config.tables.requestLogs, logEntry)\n      } catch {\n        // Silent — logging failure must never affect the request\n      }\n    })\n\n    next()\n  }\n}\n","import { exec } from 'child_process'\nimport { promisify } from 'util'\nimport * as path from 'path'\nimport * as fs from 'fs'\nimport { getConfig } from '../utils/config'\nimport { getModel, getDbUri } from '../utils/db'\n\nconst execAsync = promisify(exec)\n\n/**\n * Generate a timestamp-based backup file name.\n */\nfunction getBackupFileName(): string {\n  const now = new Date()\n  const ts = now.toISOString().replace(/[:.]/g, '-')\n  return `backup-${ts}`\n}\n\n/**\n * Perform a full MongoDB backup using mongodump.\n * Saves to local filesystem and/or uploads to S3 based on config.\n */\nasync function performBackup(): Promise<void> {\n  const config = getConfig()\n  const dbUri = getDbUri()\n  const fileName = getBackupFileName()\n  const archiveName = `${fileName}.zip`\n\n  // Temp directory for backup\n  const tempDir = path.resolve(process.cwd(), '.notice-backups-tmp')\n  if (!fs.existsSync(tempDir)) {\n    fs.mkdirSync(tempDir, { recursive: true })\n  }\n\n  const dumpDir = path.join(tempDir, fileName)\n  const archivePath = path.join(tempDir, archiveName)\n\n  try {\n    // Run mongodump to a directory\n    console.log(`[notice-utility] Starting backup: ${archiveName}`)\n    await execAsync(`mongodump --uri=\"${dbUri}\" --out=\"${dumpDir}\"`)\n\n    // Zip the directory\n    await execAsync(`zip -r \"${archivePath}\" \"${fileName}\"`, { cwd: tempDir })\n\n    const stats = fs.statSync(archivePath)\n    const fileSize = stats.size\n\n    // ── Save to local storage ──\n    if (config.local?.enabled) {\n      const localDir = path.resolve(process.cwd(), config.local.backupPath)\n      if (!fs.existsSync(localDir)) {\n        fs.mkdirSync(localDir, { recursive: true })\n      }\n      const localPath = path.join(localDir, archiveName)\n      fs.copyFileSync(archivePath, localPath)\n      console.log(`[notice-utility] Backup saved locally: ${localPath}`)\n\n      // Log to database\n      await logBackup({\n        backupFileName: archiveName,\n        backupType: 'full',\n        location: 'local',\n        fileSize,\n        status: 'success',\n      })\n    }\n\n    // ── Upload to S3 ──\n    if (config.aws?.enabled) {\n      await uploadToS3(archivePath, archiveName, fileSize)\n    }\n\n    // Cleanup temp files\n    if (fs.existsSync(archivePath)) {\n      fs.unlinkSync(archivePath)\n    }\n    if (fs.existsSync(dumpDir)) {\n      fs.rmSync(dumpDir, { recursive: true, force: true })\n    }\n\n    console.log(`[notice-utility] Backup completed: ${archiveName}`)\n  } catch (err) {\n    console.error('[notice-utility] Backup failed:', err instanceof Error ? err.message : err)\n\n    await logBackup({\n      backupFileName: archiveName,\n      backupType: 'full',\n      location: config.aws?.enabled ? 's3' : 'local',\n      fileSize: 0,\n      status: 'failed',\n      errorMessage: err instanceof Error ? err.message : String(err),\n    }).catch(() => {})\n\n    // Don't rethrow — backup failure should not crash the host app\n  }\n}\n\n/**\n * Upload backup archive to AWS S3.\n */\nasync function uploadToS3(filePath: string, fileName: string, fileSize: number): Promise<void> {\n  const config = getConfig()\n  if (!config.aws) throw new Error('AWS config not provided')\n\n  const { S3Client, PutObjectCommand } = await import('@aws-sdk/client-s3')\n\n  const s3Client = new S3Client({\n    region: config.aws.region,\n    credentials: {\n      accessKeyId: config.aws.accessKeyId,\n      secretAccessKey: config.aws.secretAccessKey,\n    },\n  })\n\n  const fileBuffer = fs.readFileSync(filePath)\n\n  const command = new PutObjectCommand({\n    Bucket: config.aws.bucketName,\n    Key: `backups/${fileName}`,\n    Body: fileBuffer,\n    ContentType: 'application/zip',\n  })\n\n  await s3Client.send(command)\n  console.log(`[notice-utility] Backup uploaded to S3: backups/${fileName}`)\n\n  await logBackup({\n    backupFileName: fileName,\n    backupType: 'full',\n    location: 's3',\n    fileSize,\n    status: 'success',\n  })\n}\n\n/**\n * Write a backup log entry to the configured backupLogs collection.\n */\nasync function logBackup(entry: {\n  backupFileName: string\n  backupType: string\n  location: 'local' | 's3'\n  fileSize: number\n  status: 'success' | 'failed'\n  errorMessage?: string\n}): Promise<void> {\n  try {\n    const config = getConfig()\n    const Model = getModel(config.tables.backupLogs)\n    await Model.create({\n      ...entry,\n      createdAt: new Date(),\n    })\n  } catch (err) {\n    console.error(\n      '[notice-utility] Failed to write backup log:',\n      err instanceof Error ? err.message : err\n    )\n  }\n}\n\n/**\n * Public export — trigger a manual database backup.\n */\nexport async function manualBackupTrigger(): Promise<void> {\n  await performBackup()\n}\n"],"mappings":"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","names":["mongoose","Model","Model"]}