@nmakarov/cli-toolkit 0.2.0 → 0.3.0

package/dist/mock-server.cjs

@@ -0,0 +1,1483 @@
+"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/mock-server.ts
+var mock_server_exports = {};
+__export(mock_server_exports, {
+  MockServer: () => MockServer,
+  createMockServer: () => createMockServer
+});
+module.exports = __toCommonJS(mock_server_exports);
+
+// src/mock-server/index.ts
+var import_express = __toESM(require("express"), 1);
+var import_http = __toESM(require("http"), 1);
+var import_morgan = __toESM(require("morgan"), 1);
+
+// src/filedatabase/index.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+
+// src/utils/os-utils.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+function getFreeDiskSpace(targetPath) {
+  try {
+    let pathToCheck = targetPath;
+    if (!import_fs.default.existsSync(targetPath)) {
+      const parentDir = import_path.default.dirname(targetPath);
+      if (import_fs.default.existsSync(parentDir)) {
+        pathToCheck = parentDir;
+      } else {
+        pathToCheck = process.platform === "win32" ? "C:\\" : "/";
+      }
+    }
+    if (process.platform === "win32") {
+      return null;
+    } else {
+      const stdout = (0, import_child_process.execSync)(`df -k "${pathToCheck}"`, { encoding: "utf8" });
+      const lines = stdout.trim().split("\n");
+      const parts = lines[1].split(/\s+/);
+      const freeKb = parseInt(parts[3], 10);
+      return freeKb * 1024;
+    }
+  } catch (error) {
+    return null;
+  }
+}
+
+// src/utils/fs-utils.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+async function ensurePath(...pathParts) {
+  const fullPath = import_path2.default.resolve(...pathParts);
+  if (!import_fs2.default.existsSync(fullPath)) {
+    await import_fs2.default.promises.mkdir(fullPath, { recursive: true });
+  }
+  return fullPath;
+}
+function getFileExtension(dataType) {
+  switch (dataType) {
+    case "json-array":
+    case "json-object":
+      return "json";
+    case "text":
+      return "txt";
+    case "xml":
+      return "xml";
+    default:
+      return "json";
+  }
+}
+
+// src/utils/format-utils.ts
+function bytesToHumanReadable(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+
+// src/utils/date-utils.ts
+function isTimestampFolder(folderName) {
+  const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|\.\d{3}Z)$/;
+  if (!isoRegex.test(folderName)) {
+    return false;
+  }
+  const date = new Date(folderName);
+  return !isNaN(date.getTime()) && date.getTime() > 0;
+}
+
+// src/filedatabase/serializers.ts
+function detectDataType(data) {
+  if (Array.isArray(data)) {
+    return "json-array";
+  } else if (typeof data === "object" && data !== null) {
+    return "json-object";
+  } else if (typeof data === "string") {
+    const trimmed = data.trim();
+    if (trimmed.startsWith("<?xml") || trimmed.startsWith("<")) {
+      return "xml";
+    }
+    return "text";
+  } else {
+    return "text";
+  }
+}
+function serializeData(data) {
+  const dataType = detectDataType(data);
+  if (dataType === "json-array" || dataType === "json-object") {
+    return JSON.stringify(data, null, 4);
+  } else {
+    return String(data);
+  }
+}
+function deserializeData(rawData, dataType) {
+  if (dataType === "json-array" || dataType === "json-object") {
+    return JSON.parse(rawData);
+  } else {
+    return rawData;
+  }
+}
+
+// src/errors.ts
+var FrameworkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FrameworkError";
+  }
+};
+var ParamError = class extends FrameworkError {
+  constructor(message) {
+    super(message);
+    this.name = "ParamError";
+  }
+};
+
+// src/filedatabase/index.ts
+var FileDatabaseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FileDatabaseError";
+  }
+};
+var FileDatabase = class {
+  basePath;
+  namespace;
+  tableName = null;
+  versioned;
+  maxVersions;
+  pageSize;
+  useMetadata;
+  freeSpaceThreshold;
+  logger;
+  // Current operation state
+  currentVersion = null;
+  currentVersionFolder = null;
+  currentFileNumber = 0;
+  currentRecord = 0;
+  hasReadFirstPage = false;
+  lastFileData = null;
+  metadata;
+  // Synopsis calculation functions
+  fileSynopsisFunction = null;
+  versionSynopsisFunction = null;
+  constructor(config) {
+    if (!config.basePath) {
+      throw new ParamError("[FileDatabase] basePath is required");
+    }
+    this.basePath = config.basePath;
+    this.namespace = config.namespace || "default";
+    this.tableName = config.tableName || null;
+    this.versioned = config.versioned ?? true;
+    this.maxVersions = config.maxVersions || 5;
+    this.pageSize = config.pageSize || 5e3;
+    this.useMetadata = config.useMetadata !== false;
+    this.freeSpaceThreshold = config.freeSpaceThreshold || 100 * 1024 * 1024;
+    this.logger = config.logger || console;
+    this.metadata = this.getDefaultMetadata();
+  }
+  /**
+   * Get default metadata structure
+   */
+  getDefaultMetadata() {
+    return {
+      version: this.currentVersion || null,
+      files: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      modifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalRecords: 0,
+      synopsis: null,
+      dataType: null
+    };
+  }
+  /**
+   * Get the destination path (basePath/namespace/tableName[/version])
+   */
+  getDestinationPath(version) {
+    const errors = ["basePath", "namespace", "tableName"].filter((prop) => !this[prop]).map((prop) => `${prop} is not set`);
+    if (errors.length) {
+      throw new FileDatabaseError(`[FileDatabase] ${errors.join("; ")}`);
+    }
+    let parts = [this.basePath, this.namespace];
+    if (this.tableName) {
+      parts.push(...this.tableName.split("/"));
+    }
+    if (this.versioned && version) {
+      parts.push(version);
+    }
+    return import_path3.default.resolve(...parts);
+  }
+  /**
+   * Set current version and version folder
+   */
+  async setCurrentVersion(version) {
+    this.currentVersion = version;
+    this.currentVersionFolder = await ensurePath(this.getDestinationPath(), version);
+  }
+  /**
+   * Create a new version folder with comprehensive timestamp logic
+   * Only works in versioned mode
+   */
+  async makeNewVersion() {
+    if (!this.versioned) {
+      throw new FileDatabaseError("makeNewVersion() only works in versioned mode");
+    }
+    this.metadata = this.getDefaultMetadata();
+    const existingVersions = await this.getVersions();
+    let versionName;
+    if (existingVersions.length > 0) {
+      const maxTimestamp = existingVersions.reduce((max, version) => {
+        const versionDate = new Date(version.replace("Z", ""));
+        const maxDate2 = new Date(max.replace("Z", ""));
+        return versionDate > maxDate2 ? version : max;
+      });
+      const maxDate = new Date(maxTimestamp.replace("Z", ""));
+      const nextDate = new Date(maxDate.getTime() + 1e3);
+      versionName = nextDate.toISOString().split(".")[0] + "Z";
+    } else {
+      const now = /* @__PURE__ */ new Date();
+      versionName = now.toISOString().split(".")[0] + "Z";
+    }
+    await this.setCurrentVersion(versionName);
+    this.currentFileNumber = 0;
+    const versions = await this.getVersions();
+    while (versions.length > this.maxVersions) {
+      const versionToDelete = import_path3.default.resolve(this.getDestinationPath(), versions.shift());
+      this.logger.debug?.(`[FileDatabase] Deleting old version: ${versionToDelete}`);
+      await import_fs3.default.promises.rm(versionToDelete, { recursive: true, force: true });
+    }
+    return versionName;
+  }
+  /**
+   * Get list of all versions (sorted chronologically)
+   * Only works in versioned mode
+   */
+  async getVersions() {
+    if (!this.versioned) {
+      return [];
+    }
+    const destPath = this.getDestinationPath();
+    try {
+      await ensurePath(destPath);
+      const items = await import_fs3.default.promises.readdir(destPath);
+      const versions = items.filter((item) => {
+        const itemPath = import_path3.default.join(destPath, item);
+        const stat = import_fs3.default.statSync(itemPath);
+        return stat.isDirectory() && isTimestampFolder(item);
+      });
+      return versions.sort();
+    } catch (error) {
+      return [];
+    }
+  }
+  /**
+   * Get the latest version (most recent timestamp)
+   * Only works in versioned mode
+   * @returns Latest version string or null if no versions
+   */
+  async getLatestVersion() {
+    if (!this.versioned) {
+      throw new FileDatabaseError("getLatestVersion() only works in versioned mode");
+    }
+    const versions = await this.getVersions();
+    if (versions.length === 0) {
+      return null;
+    }
+    return versions[versions.length - 1];
+  }
+  /**
+   * Check if any data exists in this table
+   * Works for both versioned and non-versioned modes
+   * @returns true if data exists
+   */
+  async hasData() {
+    const tablePath = this.getDestinationPath();
+    if (!import_fs3.default.existsSync(tablePath)) {
+      return false;
+    }
+    if (this.versioned) {
+      const versions = await this.getVersions();
+      return versions.length > 0;
+    } else {
+      const items = await import_fs3.default.promises.readdir(tablePath);
+      return items.some(
+        (item) => item === "metadata.json" || item.match(/^\d{6}\.(json|txt|xml)$/) || item.endsWith(".json")
+      );
+    }
+  }
+  /**
+   * Auto-detect the data format in this table
+   * Used when reading existing data
+   * @returns Format detection result
+   */
+  async detectDataFormat() {
+    const tablePath = this.getDestinationPath();
+    if (!import_fs3.default.existsSync(tablePath)) {
+      return { versioned: false, hasMetadata: false, dataType: null };
+    }
+    const items = await import_fs3.default.promises.readdir(tablePath);
+    if (items.includes("metadata.json")) {
+      const metadata = JSON.parse(
+        await import_fs3.default.promises.readFile(import_path3.default.join(tablePath, "metadata.json"), "utf8")
+      );
+      return {
+        versioned: false,
+        hasMetadata: true,
+        dataType: metadata.dataType || null
+      };
+    }
+    const versionFolders = items.filter((item) => {
+      const itemPath = import_path3.default.join(tablePath, item);
+      const stat = import_fs3.default.statSync(itemPath);
+      return stat.isDirectory() && isTimestampFolder(item);
+    });
+    if (versionFolders.length > 0) {
+      const latestVersion = versionFolders.sort().pop();
+      const versionMetadataPath = import_path3.default.join(tablePath, latestVersion, "metadata.json");
+      return {
+        versioned: true,
+        hasMetadata: import_fs3.default.existsSync(versionMetadataPath),
+        dataType: null
+      };
+    }
+    const dataFiles = items.filter((f) => f.match(/^\d{6}\.(json|txt|xml)$/));
+    if (dataFiles.length > 0) {
+      return {
+        versioned: false,
+        hasMetadata: false,
+        dataType: null
+      };
+    }
+    return { versioned: false, hasMetadata: false, dataType: null };
+  }
+  /**
+   * Load metadata from JSON file
+   */
+  async loadMetadataJson(version) {
+    const metadataFile = import_path3.default.join(this.getDestinationPath(), version, "metadata.json");
+    if (import_fs3.default.existsSync(metadataFile)) {
+      try {
+        const rawData = await import_fs3.default.promises.readFile(metadataFile, "utf8");
+        return JSON.parse(rawData);
+      } catch (e) {
+        throw new FileDatabaseError(`Failed to read metadata for version "${version}": ${e.message}`);
+      }
+    }
+    return null;
+  }
+  /**
+   * Build metadata by scanning files in a version folder (backward compatibility)
+   * Reads all files to get accurate counts - used when synopsis calculation is needed
+   */
+  async figureMetadataFromVersionFiles(version) {
+    const versionPath = import_path3.default.join(this.getDestinationPath(), version);
+    if (!import_fs3.default.existsSync(versionPath)) {
+      return this.getDefaultMetadata();
+    }
+    const files = (await import_fs3.default.promises.readdir(versionPath)).filter((file) => file !== "metadata.json" && !file.startsWith(".")).sort();
+    const metadata = this.getDefaultMetadata();
+    metadata.version = version;
+    metadata.files = [];
+    let totalRecords = 0;
+    let detectedDataType = null;
+    for (let i = 0; i < files.length; i++) {
+      const fileName = files[i];
+      const filePath = import_path3.default.join(versionPath, fileName);
+      try {
+        const rawData = await import_fs3.default.promises.readFile(filePath, "utf8");
+        const extension = import_path3.default.extname(fileName).toLowerCase();
+        let dataType = "text";
+        if (extension === ".json") {
+          dataType = "json-array";
+        } else if (extension === ".xml") {
+          dataType = "xml";
+        }
+        const fileData = deserializeData(rawData, dataType);
+        const recordsCount = Array.isArray(fileData) ? fileData.length : 1;
+        if (detectedDataType === null) {
+          detectedDataType = detectDataType(fileData);
+        }
+        const fileInfo = {
+          number: i + 1,
+          recordsCount,
+          fileName
+        };
+        metadata.files.push(fileInfo);
+        totalRecords += recordsCount;
+      } catch (error) {
+        this.logger.error?.(`[FileDatabase] Failed to read file ${fileName}: ${error.message}`);
+      }
+    }
+    metadata.totalRecords = totalRecords;
+    metadata.dataType = detectedDataType;
+    return metadata;
+  }
+  /**
+   * Build metadata optimized - only reads first and last files
+   * Assumes all middle files have the same record count as the first file
+   * Much faster for large datasets with many files
+   */
+  async buildMetadataOptimized(version) {
+    const versionPath = import_path3.default.join(this.getDestinationPath(), version);
+    if (!import_fs3.default.existsSync(versionPath)) {
+      return this.getDefaultMetadata();
+    }
+    const files = (await import_fs3.default.promises.readdir(versionPath)).filter((file) => file !== "metadata.json" && !file.startsWith(".")).sort();
+    if (files.length === 0) {
+      return this.getDefaultMetadata();
+    }
+    const metadata = this.getDefaultMetadata();
+    metadata.version = version;
+    metadata.files = files.map((fileName, index) => ({
+      number: index + 1,
+      recordsCount: 0,
+      fileName
+    }));
+    const firstFile = metadata.files[0];
+    const firstFilePath = import_path3.default.join(versionPath, firstFile.fileName);
+    const firstFileRaw = await import_fs3.default.promises.readFile(firstFilePath, "utf8");
+    let firstFileData;
+    try {
+      firstFileData = JSON.parse(firstFileRaw);
+    } catch (e) {
+      firstFileData = firstFileRaw;
+    }
+    metadata.dataType = detectDataType(firstFileData);
+    if (metadata.dataType === "json-array") {
+      const firstFileCount = Array.isArray(firstFileData) ? firstFileData.length : 1;
+      firstFile.recordsCount = firstFileCount;
+      for (let i = 1; i < metadata.files.length - 1; i++) {
+        metadata.files[i].recordsCount = firstFileCount;
+      }
+      if (files.length > 1) {
+        const lastFile = metadata.files[metadata.files.length - 1];
+        const lastFilePath = import_path3.default.join(versionPath, lastFile.fileName);
+        const lastFileRaw = await import_fs3.default.promises.readFile(lastFilePath, "utf8");
+        const lastFileData = deserializeData(lastFileRaw, metadata.dataType);
+        lastFile.recordsCount = Array.isArray(lastFileData) ? lastFileData.length : 1;
+      }
+      metadata.totalRecords = metadata.files.reduce((sum, file) => sum + file.recordsCount, 0);
+    } else {
+      metadata.files.forEach((file) => {
+        file.recordsCount = 1;
+      });
+      metadata.totalRecords = files.length;
+    }
+    return metadata;
+  }
+  /**
+   * Figure out metadata - tries JSON first, then builds from files
+   * Uses optimized building when no synopsis calculation is needed
+   */
+  async figureMetadata(version, useOptimized = true) {
+    if (this.useMetadata) {
+      const metadata = await this.loadMetadataJson(version);
+      if (metadata) {
+        return metadata;
+      }
+    }
+    if (useOptimized && !this.fileSynopsisFunction && !this.versionSynopsisFunction) {
+      return await this.buildMetadataOptimized(version);
+    }
+    return await this.figureMetadataFromVersionFiles(version);
+  }
+  /**
+   * Load version metadata (main entry point for loading)
+   */
+  async loadVersionMetadata(version) {
+    const metadata = await this.figureMetadata(version);
+    this.metadata = metadata;
+    return metadata;
+  }
+  /**
+   * Save version metadata to file
+   */
+  async saveVersionMetadata(metadata) {
+    if (!this.useMetadata) {
+      return;
+    }
+    const metadataToSave = metadata || this.metadata;
+    let metadataFile;
+    if (this.versioned) {
+      if (!this.currentVersion) {
+        return;
+      }
+      metadataFile = import_path3.default.join(this.getDestinationPath(), this.currentVersion, "metadata.json");
+    } else {
+      metadataFile = import_path3.default.join(this.getDestinationPath(), "metadata.json");
+    }
+    await import_fs3.default.promises.writeFile(metadataFile, JSON.stringify(metadataToSave, null, 4), "utf8");
+  }
+  /**
+   * Create a new file entry in metadata
+   */
+  makeNewFile() {
+    this.currentFileNumber = (this.currentFileNumber || 0) + 1;
+    const dataType = this.metadata.dataType || "json-array";
+    const fileEntry = {
+      number: this.currentFileNumber,
+      recordsCount: 0,
+      fileName: `${this.currentFileNumber.toString().padStart(6, "0")}.${getFileExtension(dataType)}`
+    };
+    this.metadata.files.push(fileEntry);
+    this.lastFileData = null;
+    this.logger.debug?.(`[FileDatabase] Created new file: ${fileEntry.fileName}, fileNumber: ${this.currentFileNumber}`);
+  }
+  /**
+   * Figure out what data to write and which file to use (for pagination)
+   */
+  figureOutDataAndFileToWrite(data) {
+    let dataToWrite;
+    let dataLeftOver;
+    const lastFile = this.metadata.files[this.metadata.files.length - 1];
+    const lastFileRecordsCount = lastFile.recordsCount;
+    if (Array.isArray(data)) {
+      if (lastFileRecordsCount < this.pageSize) {
+        dataToWrite = [...this.lastFileData || [], ...data.slice(0, this.pageSize - lastFileRecordsCount)];
+        dataLeftOver = data.slice(this.pageSize - lastFileRecordsCount);
+      } else {
+        this.makeNewFile();
+        dataToWrite = data.slice(0, this.pageSize);
+        dataLeftOver = data.slice(this.pageSize);
+      }
+      this.lastFileData = dataToWrite;
+    } else {
+      dataToWrite = data;
+      dataLeftOver = null;
+    }
+    const fileName = this.metadata.files[this.metadata.files.length - 1].fileName;
+    this.logger.debug?.(
+      `[FileDatabase] figureOutDataAndFileToWrite: filename=${fileName}, dataToWrite.length=${Array.isArray(dataToWrite) ? dataToWrite.length : "N/A"}, lastFileRecordsCount=${lastFileRecordsCount}`
+    );
+    return { dataToWrite, dataLeftOver, fileName };
+  }
+  /**
+   * Calculate file-level synopsis if function is set
+   */
+  calculateFileSynopsis(data, fileIndex = this.metadata.files.length - 1) {
+    if (!this.fileSynopsisFunction) {
+      return;
+    }
+    const fileInfo = this.metadata.files[fileIndex];
+    const enhancedFileInfo = this.fileSynopsisFunction(fileInfo, data);
+    this.metadata.files[fileIndex] = enhancedFileInfo;
+  }
+  /**
+   * Calculate version-level synopsis if function is set
+   */
+  calculateVersionSynopsis() {
+    if (!this.versionSynopsisFunction) {
+      return;
+    }
+    const enhancedMetadata = this.versionSynopsisFunction(this.metadata);
+    this.metadata = enhancedMetadata;
+  }
+  /**
+   * Update metadata after writing data
+   */
+  updateMetadata(dataToWrite, fileName) {
+    let currentFile;
+    if (fileName) {
+      const foundFile = this.metadata.files.find((file) => file.fileName === fileName);
+      if (!foundFile) {
+        this.logger.warn?.(`[FileDatabase] File ${fileName} not found in metadata, using last file`);
+        currentFile = this.metadata.files[this.metadata.files.length - 1];
+      } else {
+        currentFile = foundFile;
+      }
+    } else {
+      currentFile = this.metadata.files[this.metadata.files.length - 1];
+    }
+    const recordsCount = Array.isArray(dataToWrite) ? dataToWrite.length : 1;
+    currentFile.recordsCount = recordsCount;
+    const fileIndex = this.metadata.files.indexOf(currentFile);
+    if (fileIndex !== -1) {
+      this.calculateFileSynopsis(dataToWrite, fileIndex);
+    }
+    this.metadata.version = this.currentVersion;
+    this.metadata.modifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.metadata.dataType = detectDataType(dataToWrite);
+    this.metadata.totalRecords = this.metadata.files.reduce((sum, file) => sum + (file.recordsCount || 0), 0);
+    this.logger.debug?.(
+      `[FileDatabase] Updated metadata for file ${currentFile.fileName}: recordsCount=${recordsCount}, totalRecords=${this.metadata.totalRecords}`
+    );
+  }
+  /**
+   * Safe write with disk space check
+   */
+  async safeWrite(filePath, data) {
+    const serializedData = serializeData(data);
+    const dir = import_path3.default.dirname(filePath);
+    const requiredBytes = Buffer.byteLength(serializedData, "utf8");
+    const freeBytes = getFreeDiskSpace(dir);
+    if (freeBytes !== null) {
+      if (freeBytes < requiredBytes) {
+        throw new FileDatabaseError(
+          `Not enough disk space. Required: ${bytesToHumanReadable(requiredBytes)}, Free: ${bytesToHumanReadable(freeBytes)}`
+        );
+      }
+      if (freeBytes < this.freeSpaceThreshold) {
+        this.logger.warn?.(`Low disk space warning: only ${bytesToHumanReadable(freeBytes)} left`);
+      }
+    }
+    try {
+      await import_fs3.default.promises.writeFile(filePath, serializedData, "utf8");
+      this.logger.debug?.(`[FileDatabase] Wrote ${bytesToHumanReadable(requiredBytes)} to ${filePath}`);
+    } catch (error) {
+      throw new FileDatabaseError(`Failed to write file ${filePath}: ${error.message}`);
+    }
+  }
+  /**
+   * Prepare the instance for read or write operations
+   * This discovers state and sets up internal members based on mode and current data
+   */
+  async prepare({ write, read, version }) {
+    if (write) {
+      if (this.versioned) {
+        if (this.currentVersion === null) {
+          await this.makeNewVersion();
+          this.metadata = this.getDefaultMetadata();
+          this.metadata.version = this.currentVersion;
+          this.makeNewFile();
+        } else {
+          if (!this.metadata.files.length) {
+            this.metadata = await this.figureMetadata(this.currentVersion);
+          }
+        }
+      } else {
+        await ensurePath(this.getDestinationPath());
+        if (this.useMetadata === true) {
+          const metadataPath = import_path3.default.join(this.getDestinationPath(), "metadata.json");
+          if (import_fs3.default.existsSync(metadataPath)) {
+            try {
+              const rawData = await import_fs3.default.promises.readFile(metadataPath, "utf8");
+              this.metadata = JSON.parse(rawData);
+            } catch (e) {
+              this.metadata = this.getDefaultMetadata();
+            }
+          } else {
+            this.metadata = this.getDefaultMetadata();
+            this.makeNewFile();
+          }
+        } else {
+          this.metadata = this.getDefaultMetadata();
+          this.makeNewFile();
+        }
+      }
+    } else if (read) {
+      if (this.versioned) {
+        const versions = await this.getVersions();
+        if (versions.length === 0) {
+          throw new FileDatabaseError("[FileDatabase] No versions found, cannot read");
+        }
+        if (version) {
+          if (!versions.includes(version)) {
+            throw new FileDatabaseError(`[FileDatabase] Version "${version}" not found`);
+          }
+          await this.setCurrentVersion(version);
+        } else {
+          await this.setCurrentVersion(versions[versions.length - 1]);
+        }
+        if (!this.metadata.files.length) {
+          this.metadata = await this.figureMetadata(this.currentVersion);
+        }
+      } else {
+        this.currentVersion = null;
+        if (this.useMetadata === void 0) {
+          const format = await this.detectDataFormat();
+          this.useMetadata = format.hasMetadata;
+        }
+        if (this.useMetadata) {
+          const metadataPath = import_path3.default.join(this.getDestinationPath(), "metadata.json");
+          if (import_fs3.default.existsSync(metadataPath)) {
+            try {
+              const rawData = await import_fs3.default.promises.readFile(metadataPath, "utf8");
+              this.metadata = JSON.parse(rawData);
+            } catch (e) {
+              throw new FileDatabaseError(`Failed to read metadata: ${e.message}`);
+            }
+          } else {
+            throw new FileDatabaseError("[FileDatabase] No metadata found in non-versioned mode");
+          }
+        } else {
+          this.metadata = await this.figureMetadataFromVersionFiles("");
+        }
+      }
+    }
+  }
+  /**
+   * Write data to the file database
+   */
+  async write(data, options = {}) {
+    if (options.forceNewVersion && !this.versioned) {
+      throw new FileDatabaseError("Cannot use forceNewVersion in non-versioned mode");
+    }
+    await this.prepare({ write: true });
+    if (options.forceNewVersion) {
+      await this.makeNewVersion();
+      this.metadata = this.getDefaultMetadata();
+      this.metadata.version = this.currentVersion;
+      this.makeNewFile();
+    }
+    let { dataToWrite, dataLeftOver, fileName } = this.figureOutDataAndFileToWrite(data);
+    const destPath = this.getDestinationPath(this.currentVersion || void 0);
+    await this.safeWrite(import_path3.default.join(destPath, fileName), dataToWrite);
+    this.updateMetadata(dataToWrite, fileName);
+    while (dataLeftOver && dataLeftOver.length > 0) {
+      const writeContext = this.figureOutDataAndFileToWrite(dataLeftOver);
+      await this.safeWrite(import_path3.default.join(destPath, writeContext.fileName), writeContext.dataToWrite);
+      this.updateMetadata(writeContext.dataToWrite, writeContext.fileName);
+      dataLeftOver = writeContext.dataLeftOver;
+    }
+    this.calculateVersionSynopsis();
+    if (this.useMetadata) {
+      await this.saveVersionMetadata(this.metadata);
+    }
+  }
+  /**
+   * Read data from the file database
+   */
+  async read(options = {}) {
+    const { version, nextPage = false, pageSize } = options;
+    await this.prepare({ read: true, version });
+    const isNonPaginatedData = this.metadata.dataType === "text" || this.metadata.dataType === "xml" || this.metadata.dataType === "json-object";
+    if (isNonPaginatedData) {
+      const file = this.metadata.files[0];
+      const filePath = import_path3.default.join(this.getDestinationPath(this.currentVersion || void 0), file.fileName);
+      try {
+        const rawData = await import_fs3.default.promises.readFile(filePath, "utf8");
+        return deserializeData(rawData, this.metadata.dataType);
+      } catch (error) {
+        throw new FileDatabaseError(`Failed to read file ${file.fileName}: ${error.message}`);
+      }
+    }
+    let effectivePageSize;
+    if (nextPage && this.hasReadFirstPage) {
+      effectivePageSize = pageSize || this.pageSize;
+      this.currentRecord += effectivePageSize;
+    } else if (!nextPage) {
+      effectivePageSize = pageSize !== void 0 ? pageSize : this.metadata.totalRecords;
+      this.currentRecord = 0;
+    } else {
+      effectivePageSize = pageSize || this.pageSize;
+    }
+    if (this.currentRecord >= this.metadata.totalRecords) {
+      return [];
+    }
+    const result = [];
+    let recordsRead = 0;
+    let currentFileIndex = 0;
+    let currentFileOffset = 0;
+    let totalRecords = 0;
+    for (let i = 0; i < this.metadata.files.length; i++) {
+      const file = this.metadata.files[i];
+      if (this.currentRecord < totalRecords + file.recordsCount) {
+        currentFileIndex = i;
+        currentFileOffset = totalRecords;
+        break;
+      }
+      totalRecords += file.recordsCount;
+    }
+    let cumulativeRecords = currentFileOffset;
+    for (let i = currentFileIndex; i < this.metadata.files.length && recordsRead < effectivePageSize; i++) {
+      const file = this.metadata.files[i];
+      const filePath = import_path3.default.join(this.getDestinationPath(this.currentVersion || void 0), file.fileName);
+      try {
+        const rawData = await import_fs3.default.promises.readFile(filePath, "utf8");
+        const fileData = deserializeData(rawData, this.metadata.dataType);
+        let startIndex = 0;
+        if (i === currentFileIndex) {
+          startIndex = this.currentRecord - cumulativeRecords;
+        }
+        const endIndex = Math.min(startIndex + (effectivePageSize - recordsRead), fileData.length);
+        const recordsFromThisFile = fileData.slice(startIndex, endIndex);
+        result.push(...recordsFromThisFile);
+        recordsRead += recordsFromThisFile.length;
+        cumulativeRecords += file.recordsCount;
+      } catch (error) {
+        throw new FileDatabaseError(`Failed to read file ${file.fileName}: ${error.message}`);
+      }
+    }
+    if (result.length > 0) {
+      if (nextPage || pageSize !== void 0 && pageSize < this.metadata.totalRecords) {
+        this.hasReadFirstPage = true;
+      }
+    }
+    return result;
+  }
+  /**
+   * Set the starting record for pagination (1-based index)
+   */
+  setStartRecord(startRecord) {
+    this.currentRecord = startRecord - 1;
+    this.hasReadFirstPage = false;
+  }
+  /**
+   * Reset read pagination state
+   */
+  resetPagination() {
+    this.currentRecord = 0;
+    this.hasReadFirstPage = false;
+  }
+  /**
+   * Set file-level synopsis calculation function
+   */
+  setFileSynopsisFunction(fn) {
+    this.fileSynopsisFunction = fn;
+  }
+  /**
+   * Set version-level synopsis calculation function
+   */
+  setVersionSynopsisFunction(fn) {
+    this.versionSynopsisFunction = fn;
+  }
+  /**
+   * Get current version name
+   */
+  getCurrentVersion() {
+    return this.currentVersion;
+  }
+  /**
+   * Get current metadata
+   */
+  getMetadata() {
+    return { ...this.metadata };
+  }
+};
+
+// src/mock-server/catalog.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+
+// src/mock-server/sanitization.ts
+var import_crypto = require("crypto");
+var import_querystring = require("querystring");
+function maskValue2(value) {
+  return `[md5:${(0, import_crypto.createHash)("md5").update(value).digest("hex")}]`;
+}
+function sanitizeUrlEncodedString(input, keysToSanitize) {
+  const parsed = (0, import_querystring.parse)(input);
+  const sanitized = sanitizeObject(parsed, keysToSanitize);
+  return (0, import_querystring.stringify)(sanitized);
+}
+function sanitizeObject(obj, keysToSanitize) {
+  if (Array.isArray(obj)) {
+    return obj;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj || {})) {
+    if (keysToSanitize.includes(key.toLowerCase())) {
+      result[key] = maskValue2(String(value));
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = sanitizeObject(value, keysToSanitize);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function sanitizeHeaders(headers, additionalKeys = []) {
+  const sensitiveKeys = ["authorization", "x-api-key", "api-key", "bearer", ...additionalKeys.map((k) => k.toLowerCase())];
+  const sanitized = { ...headers };
+  for (const [key, value] of Object.entries(sanitized)) {
+    if (sensitiveKeys.includes(key.toLowerCase())) {
+      sanitized[key] = maskValue2(value);
+    }
+  }
+  return sanitized;
+}
+function sanitizeRequestData(data, keysToSanitize) {
+  if (typeof data === "string") {
+    if (data.includes("=")) {
+      try {
+        const parsed = (0, import_querystring.parse)(data);
+        return (0, import_querystring.stringify)(sanitizeObject(parsed, keysToSanitize));
+      } catch {
+        return data;
+      }
+    }
+    return data;
+  } else if (typeof data === "object" && data !== null) {
+    return sanitizeObject(data, keysToSanitize);
+  }
+  return data;
+}
+function sanitizeResponseData(data, keysToSanitize) {
+  if (typeof data === "object" && data !== null) {
+    return sanitizeObject(data, keysToSanitize);
+  }
+  return data;
+}
+function sanitizeRequest(params, sensitiveKeys) {
+  const { query, requestData, headers = {}, data } = params;
+  return {
+    query: sanitizeUrlEncodedString(query, sensitiveKeys),
+    requestData: requestData ? sanitizeRequestData(requestData, sensitiveKeys) : void 0,
+    headers: sanitizeHeaders(headers, sensitiveKeys),
+    data: data ? sanitizeResponseData(data, sensitiveKeys) : data
+  };
+}
+
+// src/mock-server/catalog.ts
+var MockCatalog = class {
+  fileDb;
+  catalogPath;
+  logger;
+  constructor(fileDb, catalogPath, logger = console) {
+    this.fileDb = fileDb;
+    this.catalogPath = catalogPath;
+    this.logger = logger;
+  }
+  /**
+   * Store a mock response in the catalog
+   */
+  async storeMock(requestUrl, requestData, responseData, operationId, mockName, sensitiveKeys = []) {
+    try {
+      const url = new URL(requestUrl);
+      const sanitized = sanitizeRequest({
+        query: url.search.slice(1),
+        requestData,
+        headers: {},
+        data: responseData.data
+      }, sensitiveKeys);
+      const entry = {
+        method: "GET",
+        // Will be passed from caller
+        host: url.host,
+        pathname: url.pathname,
+        query: sanitized.query,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...sanitized.requestData !== void 0 ? { requestData: sanitized.requestData } : {},
+        ...operationId ? { operationId } : {},
+        ...mockName ? { mockName } : {}
+      };
+      const filename = this.generateFilename(entry);
+      const catalogFilePath = path4.join(this.catalogPath, `${filename}.json`);
+      const responseFilename = `response_${filename}.json`;
+      await this.fileDb.write(responseData, { filename: responseFilename });
+      entry.file = responseFilename;
+      await fs4.mkdir(path4.dirname(catalogFilePath), { recursive: true });
+      await fs4.writeFile(catalogFilePath, JSON.stringify(entry, null, 2), "utf-8");
+      return filename;
+    } catch (error) {
+      this.logger.error?.("Error storing mock:", error);
+      throw error;
+    }
+  }
+  /**
+   * Find mock response for a request
+   */
+  async findMock(criteria) {
+    try {
+      const exactMatch = await this.findExactMatch(criteria);
+      if (exactMatch) {
+        return exactMatch;
+      }
+      const fuzzyMatch = await this.findFuzzyMatch(criteria);
+      if (fuzzyMatch) {
+        return fuzzyMatch;
+      }
+      return null;
+    } catch (error) {
+      this.logger.error?.("Error finding mock:", error);
+      return null;
+    }
+  }
+  /**
+   * Find exact match for request criteria
+   */
+  async findExactMatch(criteria) {
+    try {
+      const entries = await this.listEntries();
+      for (const entry of entries) {
+        if (this.matchesCriteria(entry, criteria)) {
+          return await this.loadResponseData(entry.file);
+        }
+      }
+      return null;
+    } catch (error) {
+      this.logger.error?.("Error in exact match:", error);
+      return null;
+    }
+  }
+  /**
+   * Find fuzzy match for request criteria
+   */
+  async findFuzzyMatch(criteria) {
+    try {
+      const fuzzyCriteria = {
+        ...criteria,
+        query: this.stripCommonParams(criteria.query)
+      };
+      return this.findExactMatch(fuzzyCriteria);
+    } catch (error) {
+      this.logger.error?.("Error in fuzzy match:", error);
+      return null;
+    }
+  }
+  /**
+   * Check if a catalog entry matches the request criteria
+   */
+  matchesCriteria(entry, criteria) {
+    return entry.method === criteria.method && entry.host === criteria.host && entry.pathname === criteria.pathname && this.queriesMatch(entry.query, criteria.query) && this.requestDataMatches(entry.requestData, criteria.requestData) && (!criteria.operationId || entry.operationId === criteria.operationId);
+  }
+  /**
+   * Check if query strings match (with sanitization)
+   */
+  queriesMatch(storedQuery, requestQuery) {
+    return storedQuery === requestQuery;
+  }
+  /**
+   * Check if request data matches
+   */
+  requestDataMatches(storedData, requestData) {
+    if (!storedData && !requestData) {
+      return true;
+    }
+    if (!storedData || !requestData) {
+      return false;
+    }
+    return JSON.stringify(storedData) === JSON.stringify(requestData);
+  }
+  /**
+   * Load response data from file
+   */
+  async loadResponseData(filename) {
+    try {
+      const data = await this.fileDb.read({ filename });
+      return data;
+    } catch (error) {
+      this.logger.error?.("Error loading response data:", error);
+      return null;
+    }
+  }
+  /**
+   * Strip common query parameters for fuzzy matching
+   */
+  stripCommonParams(query) {
+    const commonParams = ["timestamp", "nonce", "cache", "_"];
+    const params = new URLSearchParams(query);
+    for (const param of commonParams) {
+      params.delete(param);
+    }
+    return params.toString();
+  }
+  /**
+   * Generate unique filename for catalog entry
+   */
+  generateFilename(entry) {
+    const timestamp = Date.now();
+    const hash = this.simpleHash(`${entry.method}${entry.host}${entry.pathname}${entry.query}${entry.operationId || ""}`);
+    return `mock_${timestamp}_${hash}`;
+  }
+  /**
+   * Simple hash function for filename generation
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+  /**
+   * List all catalog entries
+   */
+  async listEntries() {
+    try {
+      const entries = [];
+      const files = await fs4.readdir(this.catalogPath).catch(() => []);
+      const jsonFiles = files.filter((file) => file.endsWith(".json") && !file.startsWith("response_"));
+      for (const file of jsonFiles) {
+        try {
+          const filePath = path4.join(this.catalogPath, file);
+          const content = await fs4.readFile(filePath, "utf-8");
+          const entry = JSON.parse(content);
+          entries.push(entry);
+        } catch (error) {
+          this.logger.warn?.(`Error reading catalog entry ${file}:`, error);
+        }
+      }
+      return entries;
+    } catch (error) {
+      this.logger.error?.("Error listing catalog entries:", error);
+      return [];
+    }
+  }
+  /**
+   * Remove a catalog entry and its response data
+   */
+  async removeEntry(filename) {
+    try {
+      const catalogFilePath = path4.join(this.catalogPath, `${filename}.json`);
+      const responseFilename = `response_${filename}.json`;
+      try {
+        await fs4.unlink(catalogFilePath);
+      } catch (error) {
+        this.logger.warn?.(`Could not remove catalog file ${catalogFilePath}:`, error);
+      }
+      try {
+        const responseFilePath = path4.join(this.catalogPath, responseFilename);
+        await fs4.unlink(responseFilePath);
+      } catch (error) {
+        this.logger.warn?.(`Could not remove response file ${responseFilename}:`, error);
+      }
+      return true;
+    } catch (error) {
+      this.logger.error?.("Error removing entry:", error);
+      return false;
+    }
+  }
+  /**
+   * Clean up orphaned files and invalid catalog entries
+   */
+  async maintenance() {
+    try {
+      let cleaned = 0;
+      const files = await fs4.readdir(this.catalogPath).catch(() => []);
+      const catalogFiles = files.filter((file) => file.endsWith(".json") && !file.startsWith("response_"));
+      const responseFiles = files.filter((file) => file.startsWith("response_"));
+      for (const catalogFile of catalogFiles) {
+        try {
+          const catalogPath = path4.join(this.catalogPath, catalogFile);
+          const content = await fs4.readFile(catalogPath, "utf-8");
+          const entry = JSON.parse(content);
+          const responseFile = entry.file;
+          const responsePath = path4.join(this.catalogPath, responseFile);
+          try {
+            await fs4.access(responsePath);
+          } catch {
+            await fs4.unlink(catalogPath);
+            cleaned++;
+            this.logger.info?.(`Removed orphaned catalog entry: ${catalogFile}`);
+          }
+        } catch (error) {
+          this.logger.warn?.(`Error processing catalog file ${catalogFile}:`, error);
+        }
+      }
+      const catalogResponseFiles = catalogFiles.map(
+        (file) => `response_${file.replace(".json", "")}.json`
+      );
+      for (const responseFile of responseFiles) {
+        if (!catalogResponseFiles.includes(responseFile)) {
+          const responsePath = path4.join(this.catalogPath, responseFile);
+          await fs4.unlink(responsePath);
+          cleaned++;
+          this.logger.info?.(`Removed orphaned response file: ${responseFile}`);
+        }
+      }
+      return { cleaned };
+    } catch (error) {
+      this.logger.error?.("Error during maintenance:", error);
+      return { cleaned: 0 };
+    }
+  }
+};
+
+// src/mock-server/index.ts
+var DEFAULT_SENSITIVE_KEYS = [
+  "client_id",
+  "client_secret",
+  "access_token",
+  "authorization",
+  "bearer",
+  "api_key",
+  "apikey",
+  "password",
+  "token"
+];
+var MockServer = class {
+  config;
+  app;
+  server = null;
+  fileDb;
+  catalog;
+  stats;
+  startTime;
+  constructor(config) {
+    this.config = {
+      port: 5029,
+      namespace: "mocks",
+      tableName: "responses",
+      sensitiveKeys: DEFAULT_SENSITIVE_KEYS,
+      logger: console,
+      debug: false,
+      middleware: [],
+      ...config
+    };
+    if (!this.config.basePath) {
+      throw new Error("MockServer: basePath is required");
+    }
+    this.app = (0, import_express.default)();
+    this.startTime = Date.now();
+    this.stats = {
+      totalRequests: 0,
+      mockResponses: 0,
+      fallbackResponses: 0,
+      errors: 0,
+      uptime: 0
+    };
+    this.fileDb = this.config.fileDb || new FileDatabase({
+      basePath: this.config.basePath,
+      namespace: this.config.namespace,
+      tableName: this.config.tableName,
+      versioned: false,
+      // Mock responses are typically not versioned
+      logger: this.config.logger
+    });
+    this.catalog = new MockCatalog(this.fileDb, this.config.basePath, this.config.logger);
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+  /**
+   * Start the mock server
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.server = import_http.default.createServer(this.app);
+        this.server.listen(this.config.port, () => {
+          this.config.logger.info?.(`MockServer listening on port ${this.config.port}`);
+          resolve({
+            server: this.server,
+            port: this.config.port,
+            close: () => this.stop(),
+            getStats: () => this.getCurrentStats()
+          });
+        });
+        this.server.on("error", (error) => {
+          reject(error);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stop the mock server
+   */
+  async stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          this.config.logger.info?.("MockServer stopped");
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  /**
+   * Get current server statistics (internal)
+   */
+  getCurrentStats() {
+    return {
+      ...this.stats,
+      uptime: Date.now() - this.startTime
+    };
+  }
+  /**
+   * Setup Express middleware
+   */
+  setupMiddleware() {
+    this.app.use(import_express.default.urlencoded({ extended: true }));
+    this.app.use(import_express.default.json());
+    import_morgan.default.token("urlDecoded", (req) => {
+      return decodeURIComponent(req.url || "");
+    });
+    this.app.use((0, import_morgan.default)(":method :urlDecoded :status :response-time", {
+      skip: (req, res) => req.url === "/version" || res.statusCode === 429,
+      stream: {
+        write: (message) => {
+          if (this.config.debug) {
+            this.config.logger.debug?.(message.trim());
+          }
+        }
+      }
+    }));
+    for (const middleware of this.config.middleware) {
+      this.app.use(middleware);
+    }
+  }
+  /**
+   * Setup API routes
+   */
+  setupRoutes() {
+    this.app.get("/version", (req, res) => {
+      res.json({ version: "1.0.0", server: "MockServer" });
+    });
+    this.app.get("/404", (req, res) => {
+      res.status(404).json({ code: "not_found", message: "not found" });
+    });
+    this.app.get("/test", async (req, res) => {
+      const delay = req.get("x-axios-delay");
+      const err = req.get("x-axios-err");
+      if (delay) {
+        await new Promise((resolve) => setTimeout(resolve, parseInt(delay)));
+      }
+      if (err) {
+        if (!isNaN(Number(err))) {
+          return res.status(Number(err)).json({
+            code: "error",
+            message: `expected error ${err}`
+          });
+        }
+        if (err === "econnreset") {
+          const connection = req.connection || req.socket;
+          connection?.destroy();
+          return;
+        }
+      }
+      const message = delay ? `success with delay ${delay}` : "success";
+      res.status(200).json({ code: "success", message });
+    });
+    this.app.all("/*", async (req, res) => {
+      this.stats.totalRequests++;
+      try {
+        const mockResponse = await this.findMockResponse(req);
+        if (mockResponse) {
+          this.stats.mockResponses++;
+          const safeHeaders = { ...mockResponse.headers };
+          delete safeHeaders["transfer-encoding"];
+          delete safeHeaders["Transfer-Encoding"];
+          res.set(safeHeaders);
+          res.status(mockResponse.status).send(mockResponse.data);
+        } else {
+          this.stats.fallbackResponses++;
+          res.status(200).json({ code: "ok", message: "catch all" });
+        }
+      } catch (error) {
+        this.stats.errors++;
+        this.config.logger.error?.("MockServer error:", error);
+        res.status(500).json({ code: "server_error", message: "Internal server error" });
+      }
+    });
+  }
+  /**
+   * Find mock response for a request
+   */
+  async findMockResponse(req) {
+    const headerValue = req.get("XAXIOSOrigin");
+    if (!headerValue) {
+      return null;
+    }
+    try {
+      const url = new URL(headerValue);
+      const method = req.method;
+      const pathname = url.pathname;
+      const query = url.search.slice(1);
+      const requestData = this.extractRequestData(req);
+      const criteria = {
+        method,
+        host: url.host,
+        pathname,
+        query,
+        requestData
+      };
+      return await this.catalog.findMock(criteria);
+    } catch (error) {
+      this.config.logger.error?.("Error finding mock response:", error);
+      return null;
+    }
+  }
+  /**
+   * Extract request data from Express request
+   */
+  extractRequestData(req) {
+    const contentType = req.get("content-type");
+    if (contentType?.includes("application/x-www-form-urlencoded")) {
+      return req.body;
+    } else if (contentType?.includes("application/json")) {
+      return req.body;
+    }
+    return req.body;
+  }
+  /**
+   * Store a mock response from an HTTP request/response
+   */
+  async storeMock(requestUrl, requestData, responseData, operationId, mockName) {
+    return await this.catalog.storeMock(
+      requestUrl,
+      requestData,
+      responseData,
+      operationId,
+      mockName,
+      this.config.sensitiveKeys
+    );
+  }
+  /**
+   * List all stored mock responses
+   */
+  async listMocks() {
+    return await this.catalog.listEntries();
+  }
+  /**
+   * Remove a mock response by filename
+   */
+  async removeMock(filename) {
+    return await this.catalog.removeEntry(filename);
+  }
+  /**
+   * Run maintenance to clean up orphaned files
+   */
+  async maintenance() {
+    return await this.catalog.maintenance();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get server statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      uptime: Date.now() - this.startTime
+    };
+  }
+};
+async function createMockServer(config) {
+  const server = new MockServer(config);
+  return server.start();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MockServer,
+  createMockServer
+});
+//# sourceMappingURL=mock-server.cjs.map