@nmakarov/cli-toolkit 0.14.2 → 0.18.0

package/dist/filedatabase.cjs

@@ -34,7 +34,6 @@ __export(filedatabase_exports, {
   FileDatabaseError: () => FileDatabaseError,
   defaultFileSynopsisFunction: () => defaultFileSynopsisFunction,
   defaultVersionSynopsisFunction: () => defaultVersionSynopsisFunction,
-  fileDatabaseInit: () => fileDatabaseInit,
   listSources: () => listSources,
   listTables: () => listTables
 });
@@ -161,6 +160,12 @@ var ParamError = class extends FrameworkError {
     this.name = "ParamError";
   }
 };
+var FileDatabaseError = class extends FrameworkError {
+  constructor(message) {
+    super(message);
+    this.name = "FileDatabaseError";
+  }
+};
 
 // src/filedatabase/synopsis-functions.ts
 function defaultFileSynopsisFunction(fileEntry, data) {
@@ -231,13 +236,7 @@ function defaultVersionSynopsisFunction(metadata) {
 }
 
 // src/filedatabase/index.ts
-var FileDatabaseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FileDatabaseError";
-  }
-};
-var FileDatabase = class {
+var FileDatabase = class _FileDatabase {
   basePath;
   namespace;
   tableName = null;
@@ -274,18 +273,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;
     }
@@ -303,6 +292,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
    */
@@ -370,7 +366,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;
@@ -648,7 +644,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)
@@ -681,7 +677,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();
     }
@@ -730,7 +726,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 };
@@ -785,7 +781,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}`
     );
   }
@@ -809,7 +805,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}`);
     }
@@ -891,7 +887,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");
@@ -905,7 +902,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("");
@@ -922,6 +921,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");
     }
@@ -945,17 +951,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];
@@ -984,7 +990,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) {
@@ -1065,6 +1081,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
    */
@@ -1168,16 +1245,12 @@ function listSources(basePath) {
     return [];
   }
 }
-function fileDatabaseInit(context, options = {}) {
-  return new FileDatabase(context, options);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FileDatabase,
   FileDatabaseError,
   defaultFileSynopsisFunction,
   defaultVersionSynopsisFunction,
-  fileDatabaseInit,
   listSources,
   listTables
 });