@nmakarov/cli-toolkit 0.2.0 → 0.3.0

package/dist/index.js

@@ -1714,7 +1714,7 @@ function organizeFooterMessages(messages) {
   return lines;
 }
 
-// src/filestore/index.ts
+// src/filedatabase/index.ts
 import fs3 from "fs";
 import path3 from "path";
 
@@ -1790,7 +1790,7 @@ function isTimestampFolder(folderName) {
   return !isNaN(date.getTime()) && date.getTime() > 0;
 }
 
-// src/filestore/serializers.ts
+// src/filedatabase/serializers.ts
 function detectDataType(data) {
   if (Array.isArray(data)) {
     return "json-array";
@@ -1822,7 +1822,7 @@ function deserializeData(rawData, dataType) {
   }
 }
 
-// src/filestore/synopsis-functions.ts
+// src/filedatabase/synopsis-functions.ts
 function defaultFileSynopsisFunction(fileEntry, data) {
   if (!Array.isArray(data) || data.length === 0) {
     return { ...fileEntry };
@@ -1890,7 +1890,7 @@ function defaultVersionSynopsisFunction(metadata) {
   return result;
 }
 
-// src/filestore/index.ts
+// src/filedatabase/index.ts
 var FileDatabaseError = class extends Error {
   constructor(message) {
     super(message);
@@ -1901,6 +1901,7 @@ var FileDatabase = class {
   basePath;
   namespace;
   tableName = null;
+  versioned;
   maxVersions;
   pageSize;
   useMetadata;
@@ -1924,6 +1925,7 @@ var FileDatabase = class {
     this.basePath = config2.basePath;
     this.namespace = config2.namespace || "default";
     this.tableName = config2.tableName || null;
+    this.versioned = config2.versioned ?? true;
     this.maxVersions = config2.maxVersions || 5;
     this.pageSize = config2.pageSize || 5e3;
     this.useMetadata = config2.useMetadata !== false;
@@ -1946,14 +1948,21 @@ var FileDatabase = class {
     };
   }
   /**
-   * Get the destination path (basePath/namespace/tableName)
+   * Get the destination path (basePath/namespace/tableName[/version])
    */
-  getDestinationPath() {
+  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("; ")}`);
     }
-    return path3.resolve(this.basePath, this.namespace, this.tableName);
+    let parts = [this.basePath, this.namespace];
+    if (this.tableName) {
+      parts.push(...this.tableName.split("/"));
+    }
+    if (this.versioned && version) {
+      parts.push(version);
+    }
+    return path3.resolve(...parts);
   }
   /**
    * Set current version and version folder
@@ -1964,8 +1973,13 @@ var FileDatabase = class {
   }
   /**
    * 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) {
@@ -1993,8 +2007,12 @@ var FileDatabase = class {
   }
   /**
    * 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);
@@ -2009,6 +2027,86 @@ var FileDatabase = class {
       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 (!fs3.existsSync(tablePath)) {
+      return false;
+    }
+    if (this.versioned) {
+      const versions = await this.getVersions();
+      return versions.length > 0;
+    } else {
+      const items = await fs3.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 (!fs3.existsSync(tablePath)) {
+      return { versioned: false, hasMetadata: false, dataType: null };
+    }
+    const items = await fs3.promises.readdir(tablePath);
+    if (items.includes("metadata.json")) {
+      const metadata = JSON.parse(
+        await fs3.promises.readFile(path3.join(tablePath, "metadata.json"), "utf8")
+      );
+      return {
+        versioned: false,
+        hasMetadata: true,
+        dataType: metadata.dataType || null
+      };
+    }
+    const versionFolders = items.filter((item) => {
+      const itemPath = path3.join(tablePath, item);
+      const stat = fs3.statSync(itemPath);
+      return stat.isDirectory() && isTimestampFolder(item);
+    });
+    if (versionFolders.length > 0) {
+      const latestVersion = versionFolders.sort().pop();
+      const versionMetadataPath = path3.join(tablePath, latestVersion, "metadata.json");
+      return {
+        versioned: true,
+        hasMetadata: fs3.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
    */
@@ -2152,11 +2250,19 @@ var FileDatabase = class {
    * Save version metadata to file
    */
   async saveVersionMetadata(metadata) {
-    if (!this.useMetadata || !this.currentVersion) {
+    if (!this.useMetadata) {
       return;
     }
     const metadataToSave = metadata || this.metadata;
-    const metadataFile = path3.join(this.getDestinationPath(), this.currentVersion, "metadata.json");
+    let metadataFile;
+    if (this.versioned) {
+      if (!this.currentVersion) {
+        return;
+      }
+      metadataFile = path3.join(this.getDestinationPath(), this.currentVersion, "metadata.json");
+    } else {
+      metadataFile = path3.join(this.getDestinationPath(), "metadata.json");
+    }
     await fs3.promises.writeFile(metadataFile, JSON.stringify(metadataToSave, null, 4), "utf8");
   }
   /**
@@ -2284,31 +2390,75 @@ var FileDatabase = class {
    */
   async prepare({ write, read, version }) {
     if (write) {
-      if (this.currentVersion === null) {
-        await this.makeNewVersion();
-        this.metadata = this.getDefaultMetadata();
-        this.metadata.version = this.currentVersion;
-        this.makeNewFile();
+      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 {
-        if (!this.metadata.files.length) {
-          this.metadata = await this.figureMetadata(this.currentVersion);
+        await ensurePath(this.getDestinationPath());
+        if (this.useMetadata === true) {
+          const metadataPath = path3.join(this.getDestinationPath(), "metadata.json");
+          if (fs3.existsSync(metadataPath)) {
+            try {
+              const rawData = await fs3.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) {
-      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`);
+      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);
         }
-        await this.setCurrentVersion(version);
       } else {
-        await this.setCurrentVersion(versions[versions.length - 1]);
-      }
-      if (!this.metadata.files.length) {
-        this.metadata = await this.figureMetadata(this.currentVersion);
+        this.currentVersion = null;
+        if (this.useMetadata === void 0) {
+          const format = await this.detectDataFormat();
+          this.useMetadata = format.hasMetadata;
+        }
+        if (this.useMetadata) {
+          const metadataPath = path3.join(this.getDestinationPath(), "metadata.json");
+          if (fs3.existsSync(metadataPath)) {
+            try {
+              const rawData = await fs3.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("");
+        }
       }
     }
   }
@@ -2316,6 +2466,9 @@ var FileDatabase = class {
    * 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();
@@ -2324,11 +2477,12 @@ var FileDatabase = class {
       this.makeNewFile();
     }
     let { dataToWrite, dataLeftOver, fileName } = this.figureOutDataAndFileToWrite(data);
-    await this.safeWrite(path3.join(this.currentVersionFolder, fileName), dataToWrite);
+    const destPath = this.getDestinationPath(this.currentVersion || void 0);
+    await this.safeWrite(path3.join(destPath, fileName), dataToWrite);
     this.updateMetadata(dataToWrite, fileName);
     while (dataLeftOver && dataLeftOver.length > 0) {
       const writeContext = this.figureOutDataAndFileToWrite(dataLeftOver);
-      await this.safeWrite(path3.join(this.currentVersionFolder, writeContext.fileName), writeContext.dataToWrite);
+      await this.safeWrite(path3.join(destPath, writeContext.fileName), writeContext.dataToWrite);
       this.updateMetadata(writeContext.dataToWrite, writeContext.fileName);
       dataLeftOver = writeContext.dataLeftOver;
     }
@@ -2346,7 +2500,7 @@ var FileDatabase = class {
     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 = path3.join(this.getDestinationPath(), this.currentVersion, file.fileName);
+      const filePath = path3.join(this.getDestinationPath(this.currentVersion || void 0), file.fileName);
       try {
         const rawData = await fs3.promises.readFile(filePath, "utf8");
         return deserializeData(rawData, this.metadata.dataType);
@@ -2384,7 +2538,7 @@ var FileDatabase = class {
     let cumulativeRecords = currentFileOffset;
     for (let i = currentFileIndex; i < this.metadata.files.length && recordsRead < effectivePageSize; i++) {
       const file = this.metadata.files[i];
-      const filePath = path3.join(this.getDestinationPath(), this.currentVersion, file.fileName);
+      const filePath = path3.join(this.getDestinationPath(this.currentVersion || void 0), file.fileName);
       try {
         const rawData = await fs3.promises.readFile(filePath, "utf8");
         const fileData = deserializeData(rawData, this.metadata.dataType);