@nmakarov/cli-toolkit 0.14.2 → 0.18.0

package/dist/mock-server.cjs

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var mock_server_exports = {};
 __export(mock_server_exports, {
   MockServer: () => MockServer,
+  MockStorage: () => MockStorage,
+  computeMockKey: () => computeMockKey,
   createMockServer: () => createMockServer
 });
 module.exports = __toCommonJS(mock_server_exports);
@@ -40,6 +42,9 @@ var import_express = __toESM(require("express"), 1);
 var import_http = __toESM(require("http"), 1);
 var import_morgan = __toESM(require("morgan"), 1);
 
+// src/mock-server/mock-storage.ts
+var import_crypto = require("crypto");
+
 // src/filedatabase/index.ts
 var import_fs3 = __toESM(require("fs"), 1);
 var import_path3 = __toESM(require("path"), 1);
@@ -161,15 +166,15 @@ var ParamError = class extends FrameworkError {
     this.name = "ParamError";
   }
 };
-
-// src/filedatabase/index.ts
-var FileDatabaseError = class extends Error {
+var FileDatabaseError = class extends FrameworkError {
   constructor(message) {
     super(message);
     this.name = "FileDatabaseError";
   }
 };
-var FileDatabase = class {
+
+// src/filedatabase/index.ts
+var FileDatabase = class _FileDatabase {
   basePath;
   namespace;
   tableName = null;
@@ -206,18 +211,8 @@ var FileDatabase = class {
         maxVersions: "number default 5",
         pageSize: "number default 5000"
       };
-      const paramsConfig = context.params.getAll(defs);
-      config = {
-        basePath: opts.basePath ?? paramsConfig.basePath,
-        namespace: opts.namespace ?? paramsConfig.namespace,
-        tableName: opts.tableName ?? paramsConfig.tableName ?? null,
-        versioned: opts.versioned ?? true,
-        maxVersions: opts.maxVersions ?? paramsConfig.maxVersions,
-        pageSize: opts.pageSize ?? paramsConfig.pageSize,
-        useMetadata: opts.useMetadata ?? true,
-        freeSpaceThreshold: opts.freeSpaceThreshold ?? 100 * 1024 * 1024,
-        logger: context.logger
-      };
+      const discovered = context.params.getAllForModule(defs);
+      config = { ...discovered, ...opts, logger: context.logger };
     } else {
       config = contextOrConfig;
     }
@@ -235,6 +230,13 @@ var FileDatabase = class {
     this.logger = config.logger || console;
     this.metadata = this.getDefaultMetadata();
   }
+  /**
+   * Initialize FileDatabase from context and options.
+   * Params are read via getAllForModule("filedatabase", defs) for --showUsedParams grouping.
+   */
+  static init(context, options) {
+    return new _FileDatabase(context, options ?? {});
+  }
   /**
    * Get default metadata structure
    */
@@ -302,7 +304,7 @@ var FileDatabase = class {
     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}`);
+      this.logger.silly?.(`[FileDatabase] Deleting old version: ${versionToDelete}`);
       await import_fs3.default.promises.rm(versionToDelete, { recursive: true, force: true });
     }
     return versionName;
@@ -580,7 +582,7 @@ var FileDatabase = class {
     };
     this.metadata.files.push(fileEntry);
     this.lastFileData = null;
-    this.logger.debug?.(`[FileDatabase] Created new file: ${fileEntry.fileName}, fileNumber: ${this.currentFileNumber}`);
+    this.logger.silly?.(`[FileDatabase] Created new file: ${fileEntry.fileName}, fileNumber: ${this.currentFileNumber}`);
   }
   /**
    * Figure out what data to write and which file to use (for pagination)
@@ -613,7 +615,7 @@ var FileDatabase = class {
       const filesBeforeCreate = this.metadata.files.length;
       this.makeNewFile();
       newlyCreatedFileIndex = filesBeforeCreate;
-      this.logger.debug?.(`[FileDatabase] Creating new file for unique custom metadata combination, fileNumber: ${this.currentFileNumber}`);
+      this.logger.silly?.(`[FileDatabase] Creating new file for unique custom metadata combination, fileNumber: ${this.currentFileNumber}`);
     } else if (this.metadata.files.length === 0) {
       this.makeNewFile();
     }
@@ -662,7 +664,7 @@ var FileDatabase = class {
       dataLeftOver = null;
     }
     const fileName = this.metadata.files[this.metadata.files.length - 1].fileName;
-    this.logger.debug?.(
+    this.logger.silly?.(
       `[FileDatabase] figureOutDataAndFileToWrite: filename=${fileName}, forceNewFile=${forceNewFile}, targetFileIndex=${targetFileIndex}, dataToWrite.length=${Array.isArray(dataToWrite) ? dataToWrite.length : "N/A"}, lastFileRecordsCount=${lastFileRecordsCount}`
     );
     return { dataToWrite, dataLeftOver, fileName };
@@ -717,7 +719,7 @@ var FileDatabase = class {
     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?.(
+    this.logger.silly?.(
       `[FileDatabase] Updated metadata for file ${currentFile.fileName}: recordsCount=${recordsCount}, totalRecords=${this.metadata.totalRecords}`
     );
   }
@@ -741,7 +743,7 @@ var FileDatabase = class {
     }
     try {
       await import_fs3.default.promises.writeFile(filePath, serializedData, "utf8");
-      this.logger.debug?.(`[FileDatabase] Wrote ${bytesToHumanReadable(requiredBytes)} to ${filePath}`);
+      this.logger.silly?.(`[FileDatabase] Wrote ${bytesToHumanReadable(requiredBytes)} to ${filePath}`);
     } catch (error) {
       throw new FileDatabaseError(`Failed to write file ${filePath}: ${error.message}`);
     }
@@ -823,7 +825,8 @@ var FileDatabase = class {
           this.useMetadata = format.hasMetadata;
         }
         if (this.useMetadata) {
-          const metadataPath = import_path3.default.join(this.getDestinationPath(), "metadata.json");
+          const destPath = this.getDestinationPath();
+          const metadataPath = import_path3.default.join(destPath, "metadata.json");
           if (import_fs3.default.existsSync(metadataPath)) {
             try {
               const rawData = await import_fs3.default.promises.readFile(metadataPath, "utf8");
@@ -837,7 +840,9 @@ var FileDatabase = class {
               throw new FileDatabaseError(`Failed to read metadata: ${e.message}`);
             }
           } else {
-            throw new FileDatabaseError("[FileDatabase] No metadata found in non-versioned mode");
+            throw new FileDatabaseError(
+              `[FileDatabase] No metadata found in non-versioned mode. Looked for: ${metadataPath} (table path: ${destPath})`
+            );
           }
         } else {
           this.metadata = await this.figureMetadataFromVersionFiles("");
@@ -854,6 +859,13 @@ var FileDatabase = class {
    * Write data to the file database
    */
   async write(data, options = {}) {
+    if (options.filename) {
+      const destPath2 = this.getDestinationPath();
+      await ensurePath(destPath2);
+      const filePath = import_path3.default.join(destPath2, options.filename);
+      await this.safeWrite(filePath, data);
+      return;
+    }
     if (options.forceNewVersion && !this.versioned) {
       throw new FileDatabaseError("Cannot use forceNewVersion in non-versioned mode");
     }
@@ -877,17 +889,17 @@ var FileDatabase = class {
         });
         if (matches) {
           targetFileIndex = i;
-          this.logger.debug?.(`[FileDatabase] Found existing file with matching custom metadata: ${fileEntry.fileName}, metadata: ${JSON.stringify(options.customMetadata)}`);
+          this.logger.silly?.(`[FileDatabase] Found existing file with matching custom metadata: ${fileEntry.fileName}, metadata: ${JSON.stringify(options.customMetadata)}`);
           break;
         } else {
-          this.logger.debug?.(`[FileDatabase] File ${fileEntry.fileName} does not match custom metadata: ${JSON.stringify(options.customMetadata)}`);
+          this.logger.silly?.(`[FileDatabase] File ${fileEntry.fileName} does not match custom metadata: ${JSON.stringify(options.customMetadata)}`);
         }
       }
       if (targetFileIndex === null) {
-        this.logger.debug?.(`[FileDatabase] No existing file found with custom metadata: ${JSON.stringify(options.customMetadata)}, will create new file`);
+        this.logger.silly?.(`[FileDatabase] No existing file found with custom metadata: ${JSON.stringify(options.customMetadata)}, will create new file`);
       }
     } else {
-      this.logger.debug?.(`[FileDatabase] No custom metadata provided, will create new file`);
+      this.logger.silly?.(`[FileDatabase] No custom metadata provided, will create new file`);
     }
     if (targetFileIndex !== null) {
       const targetFile = this.metadata.files[targetFileIndex];
@@ -916,7 +928,17 @@ var FileDatabase = class {
    * Read data from the file database
    */
   async read(options = {}) {
-    const { version, nextPage = false, pageSize } = options;
+    const { version, nextPage = false, pageSize, filename } = options;
+    if (filename) {
+      const destPath = this.getDestinationPath(version);
+      const filePath = import_path3.default.join(destPath, filename);
+      try {
+        const rawData = await import_fs3.default.promises.readFile(filePath, "utf8");
+        return JSON.parse(rawData);
+      } catch (error) {
+        throw new FileDatabaseError(`Failed to read file ${filename}: ${error.message}`);
+      }
+    }
     await this.prepare({ read: true, version });
     const isNonPaginatedData = this.metadata.dataType === "text" || this.metadata.dataType === "xml" || this.metadata.dataType === "json-object";
     if (isNonPaginatedData) {
@@ -997,6 +1019,67 @@ var FileDatabase = class {
     this.currentRecord = 0;
     this.hasReadFirstPage = false;
   }
+  /**
+   * List filenames in the table directory.
+   * For catalog/key-value usage (files written with { filename }).
+   * Returns data file names (.json, .txt, .xml) excluding metadata.json.
+   */
+  async listFilenames() {
+    const destPath = this.versioned && this.currentVersion ? import_path3.default.join(this.getDestinationPath(), this.currentVersion) : this.getDestinationPath();
+    try {
+      const entries = await import_fs3.default.promises.readdir(destPath, { withFileTypes: true });
+      return entries.filter((e) => e.isFile() && e.name !== "metadata.json" && /\.(json|txt|xml)$/i.test(e.name)).map((e) => e.name);
+    } catch (err) {
+      if (err?.code === "ENOENT") return [];
+      throw new FileDatabaseError(`Failed to list files: ${err.message}`);
+    }
+  }
+  /**
+   * Remove a file from the table directory (catalog mode).
+   * Use with listFilenames() to manage individual files.
+   */
+  async removeFile(filename) {
+    const destPath = this.versioned && this.currentVersion ? import_path3.default.join(this.getDestinationPath(), this.currentVersion) : this.getDestinationPath();
+    const filePath = import_path3.default.join(destPath, filename);
+    try {
+      await import_fs3.default.promises.unlink(filePath);
+    } catch (err) {
+      if (err?.code === "ENOENT") return;
+      throw new FileDatabaseError(`Failed to remove file ${filename}: ${err.message}`);
+    }
+  }
+  /**
+   * Remove a file and its metadata entry (non-versioned mode with useMetadata).
+   * Use with findData() to get fileName, then call removeFileEntry to delete.
+   */
+  async removeFileEntry(filename) {
+    if (this.versioned) {
+      throw new FileDatabaseError("removeFileEntry is only supported in non-versioned mode");
+    }
+    await this.prepare({ read: true });
+    const idx = this.metadata.files.findIndex((f) => f.fileName === filename);
+    if (idx === -1) {
+      throw new FileDatabaseError(`File entry ${filename} not found in metadata`);
+    }
+    const entry = this.metadata.files[idx];
+    const recordsCount = entry.recordsCount || 0;
+    this.metadata.files.splice(idx, 1);
+    this.metadata.totalRecords = Math.max(0, (this.metadata.totalRecords || 0) - recordsCount);
+    const destPath = this.getDestinationPath();
+    const filePath = import_path3.default.join(destPath, filename);
+    try {
+      await import_fs3.default.promises.unlink(filePath);
+    } catch (err) {
+      if (err?.code === "ENOENT") {
+        this.logger.warn?.(`[FileDatabase] File ${filename} already missing on disk`);
+      } else {
+        throw new FileDatabaseError(`Failed to remove file ${filename}: ${err.message}`);
+      }
+    }
+    if (this.useMetadata) {
+      await this.saveVersionMetadata(this.metadata);
+    }
+  }
   /**
    * Set file-level synopsis calculation function
    */
@@ -1080,335 +1163,106 @@ var FileDatabase = class {
   }
 };
 
-// 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;
+// src/mock-server/mock-storage.ts
+function stableStringify(obj) {
+  if (obj === null) return "null";
+  if (obj === void 0) return "undefined";
+  if (typeof obj !== "object") return JSON.stringify(obj);
+  if (Array.isArray(obj)) return "[" + obj.map(stableStringify).join(",") + "]";
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
 }
-function sanitizeResponseData(data, keysToSanitize) {
-  if (typeof data === "object" && data !== null) {
-    return sanitizeObject(data, keysToSanitize);
-  }
-  return data;
+function normalizeQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams(query);
+  const sorted = [...params.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  return new URLSearchParams(sorted).toString();
 }
-function sanitizeRequest(params, sensitiveKeys) {
-  const { query, requestData, headers = {}, data } = params;
+function buildCriteria(method, host, pathname, query, requestData) {
   return {
-    query: sanitizeUrlEncodedString(query, sensitiveKeys),
-    requestData: requestData ? sanitizeRequestData(requestData, sensitiveKeys) : void 0,
-    headers: sanitizeHeaders(headers, sensitiveKeys),
-    data: data ? sanitizeResponseData(data, sensitiveKeys) : data
+    method: method.toUpperCase(),
+    host,
+    pathname: pathname || "/",
+    query: normalizeQuery(query),
+    requestBody: requestData != null ? stableStringify(requestData) : ""
   };
 }
-
-// src/mock-server/catalog.ts
-var MockCatalog = class {
+function computeMockKey(method, host, pathname, query, requestData) {
+  const criteria = buildCriteria(method, host, pathname, query, requestData);
+  const str = JSON.stringify(criteria);
+  return (0, import_crypto.createHash)("sha256").update(str).digest("hex").slice(0, 32);
+}
+var MockStorage = class {
   fileDb;
-  catalogPath;
   logger;
-  constructor(fileDb, catalogPath, logger = console) {
-    this.fileDb = fileDb;
-    this.catalogPath = catalogPath;
-    this.logger = logger;
+  constructor(config) {
+    this.logger = config.logger ?? console;
+    this.fileDb = new FileDatabase({
+      basePath: config.basePath,
+      namespace: "mocks",
+      tableName: "responses",
+      versioned: false,
+      useMetadata: true,
+      logger: this.logger
+    });
   }
   /**
-   * Store a mock response in the catalog
+   * Store a mock response.
    */
-  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;
-    }
+  async store(method, requestUrl, requestData, responseData) {
+    const url = new URL(requestUrl);
+    const criteria = buildCriteria(method, url.host, url.pathname, url.search.slice(1), requestData);
+    await this.fileDb.write(responseData, { customMetadata: criteria });
   }
   /**
-   * Find mock response for a request
+   * Find a mock response by request criteria. Returns null if not found.
    */
-  async findMock(criteria) {
+  async find(method, host, pathname, query, requestData) {
+    const criteria = buildCriteria(method, host, pathname, query, requestData);
     try {
-      const exactMatch = await this.findExactMatch(criteria);
-      if (exactMatch) {
-        return exactMatch;
+      const results = await this.fileDb.findData(criteria);
+      if (results.length === 0) return null;
+      return results[0].data;
+    } catch (err) {
+      if (err instanceof FileDatabaseError && /No metadata found/.test(err.message)) {
+        return null;
       }
-      const fuzzyMatch = await this.findFuzzyMatch(criteria);
-      if (fuzzyMatch) {
-        return fuzzyMatch;
-      }
-      return null;
-    } catch (error) {
-      this.logger.error?.("Error finding mock:", error);
-      return null;
+      throw err;
     }
   }
   /**
-   * Find exact match for request criteria
+   * List all stored mock keys (opaque identifiers for remove)
    */
-  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;
-    }
+  async listKeys() {
+    const files = await this.fileDb.listFilenames();
+    return files.sort();
   }
   /**
-   * Find fuzzy match for request criteria
+   * Remove a mock by key (from listKeys)
    */
-  async findFuzzyMatch(criteria) {
+  async remove(fileName) {
+    const name = fileName.endsWith(".json") ? fileName : `${fileName}.json`;
     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) {
+      await this.fileDb.removeFileEntry(name);
       return true;
-    }
-    if (!storedData || !requestData) {
+    } catch {
       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
+   * Remove a mock by request criteria (method, host, pathname, query, requestData)
    */
-  async listEntries() {
+  async removeByCriteria(method, host, pathname, query, requestData) {
+    const criteria = buildCriteria(method, host, pathname, query, requestData);
     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);
-      }
+      const results = await this.fileDb.findData(criteria);
+      if (results.length === 0) return false;
+      await this.fileDb.removeFileEntry(results[0].fileName);
       return true;
-    } catch (error) {
-      this.logger.error?.("Error removing entry:", error);
+    } catch {
       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
@@ -1427,8 +1281,7 @@ var MockServer = class {
   config;
   app;
   server = null;
-  fileDb;
-  catalog;
+  storage;
   stats;
   startTime;
   constructor(config) {
@@ -1454,15 +1307,7 @@ var MockServer = class {
       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.storage = new MockStorage({ basePath: this.config.basePath, logger: this.config.logger });
     this.setupMiddleware();
     this.setupRoutes();
   }
@@ -1605,14 +1450,7 @@ var MockServer = class {
       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);
+      return await this.storage.find(method, url.host, pathname, query, requestData);
     } catch (error) {
       this.config.logger.error?.("Error finding mock response:", error);
       return null;
@@ -1633,33 +1471,39 @@ var MockServer = class {
   /**
    * 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
-    );
+  async storeMock(requestUrl, requestData, responseData, method = "GET") {
+    await this.storage.store(method, requestUrl, requestData, responseData);
   }
   /**
-   * List all stored mock responses
+   * List all stored mock keys
    */
   async listMocks() {
-    return await this.catalog.listEntries();
+    return await this.storage.listKeys();
   }
   /**
-   * Remove a mock response by filename
+   * Remove a mock by key (from listMocks)
    */
-  async removeMock(filename) {
-    return await this.catalog.removeEntry(filename);
+  async removeMock(key) {
+    return await this.storage.remove(key);
+  }
+  /**
+   * Remove a mock by request criteria (method, requestUrl, requestData)
+   */
+  async removeMockByCriteria(requestUrl, requestData, method = "GET") {
+    const url = new URL(requestUrl);
+    return await this.storage.removeByCriteria(
+      method,
+      url.host,
+      url.pathname,
+      url.search.slice(1),
+      requestData
+    );
   }
   /**
-   * Run maintenance to clean up orphaned files
+   * No-op (mocks are self-contained, no orphans)
    */
   async maintenance() {
-    return await this.catalog.maintenance();
+    return { cleaned: 0 };
   }
   /**
    * Get current configuration
@@ -1684,6 +1528,8 @@ async function createMockServer(config) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MockServer,
+  MockStorage,
+  computeMockKey,
   createMockServer
 });
 //# sourceMappingURL=mock-server.cjs.map