11.1.4

changelog.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 2025-01-07 - 11.1.4 - fix(fs)
+Fix file existence check in waitForFileToBeReady method.
+
+- Ensured that the directory and file exist before setting up the watcher in waitForFileToBeReady.
+- Changed ensureDirectoryExists to ensureFileExists for correct file path verification.
+- Handled ENOENT errors correctly to retry file existence checks until timeout is reached.
+
+## 2025-01-07 - 11.1.3 - fix(fs)
+Fix TypeScript type issue in fs module
+
+- Corrected a TypeScript type in the fs module's checkFileStability function.
+
+## 2025-01-07 - 11.1.2 - fix(fs)
+Fix issues in file stability check and directory existence verification in fs module
+
+- Removed unused variable 'isFileAvailable' in 'waitForFileToBeReady'.
+- Fixed logic for ensuring the target directory exists before setting up file stability watcher.
+- Refactored directory existence logic into 'ensureDirectoryExists' function.
+
+## 2025-01-07 - 11.1.1 - fix(fs)
+Improve waitForFileToBeReady function for file stability detection
+
+- Enhanced error handling and file stability checks in waitForFileToBeReady function
+- Added timeout feature for file readiness check
+- Improved directory access check before file availability check
+
+## 2025-01-07 - 11.1.0 - feat(SmartFile)
+Add rename functionality to SmartFile class
+
+- Implemented a new method to rename a file within the SmartFile class.
+- The rename method updates the file path and optionally writes the renamed file to the disk.
+
 ## 2024-12-15 - 11.0.23 - fix(fs)
 Handle errors in toObjectSync method
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@push.rocks/smartfile",
   "private": false,
-  "version": "11.0.23",
+  "version": "11.1.4",
   "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
@@ -49,7 +49,7 @@
     "@push.rocks/smartjson": "^5.0.20",
     "@push.rocks/smartmime": "^2.0.4",
     "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartpromise": "^4.0.4",
+    "@push.rocks/smartpromise": "^4.1.0",
     "@push.rocks/smartrequest": "^2.0.23",
     "@push.rocks/smartstream": "^3.2.5",
     "@types/fs-extra": "^11.0.4",
@@ -63,8 +63,8 @@
     "@git.zone/tsbuild": "^2.2.0",
     "@git.zone/tsrun": "^1.3.3",
     "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.5.3",
-    "@types/node": "^22.10.2"
+    "@push.rocks/tapbundle": "^5.5.4",
+    "@types/node": "^22.10.5"
   },
   "files": [
     "ts/**/*",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartfile',
-  version: '11.0.23',
+  version: '11.1.4',
   description: 'Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.'
 }

ts/classes.smartfile.ts

@@ -91,7 +91,7 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     });
   }
 
-  public static async fromUrl (urlArg: string) {
+  public static async fromUrl(urlArg: string) {
     const response = await plugins.smartrequest.getBinary(urlArg);
     const smartfile = await SmartFile.fromBuffer(urlArg, response.body);
     return smartfile;
@@ -212,6 +212,43 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     await fs.remove(plugins.path.join(this.base, this.path));
   }
 
+  /**
+   * Renames the file to the specified new name.
+   * - Updates the `path` property with the new name.
+   * - Writes the file to the new location if it exists on disk.
+   * @param newName The new name of the file (including extension if applicable).
+   * @param writeToDisk (optional) If true, also renames the file on the disk.
+   * @returns The updated file path after renaming.
+   */
+  public async rename(newName: string, writeToDisk: boolean = false): Promise<string> {
+    // Validate the new name
+    if (!newName || typeof newName !== 'string') {
+      throw new Error('Invalid new name provided.');
+    }
+
+    // Extract the directory path
+    const oldFilePath = this.path;
+    const dirPath = plugins.path.dirname(this.path);
+
+    // Create the new file path
+    const newFilePath = plugins.path.join(dirPath, newName);
+
+    // Update the `path` property
+    this.path = newFilePath;
+
+    // Optionally write the renamed file to disk
+    if (writeToDisk) {
+      const oldAbsolutePath = plugins.smartpath.transform.makeAbsolute(oldFilePath, this.base);
+      const newAbsolutePath = plugins.smartpath.transform.makeAbsolute(newFilePath, this.base);
+
+      // Rename the file on disk
+      await plugins.fsExtra.rename(oldAbsolutePath, newAbsolutePath);
+    }
+
+    // Return the new path
+    return this.path;
+  }
+
   // -----------------------------------------------
   // vinyl compatibility
   // -----------------------------------------------

ts/fs.ts

@@ -205,7 +205,7 @@ export const toObjectSync = (filePathArg, fileTypeArg?) => {
   } catch (err) {
     err.message = `Failed to read file at ${filePathArg}` + err.message;
     throw err;
-  };
+  }
 };
 
 /**
@@ -397,37 +397,68 @@ export const listFileTree = async (
 
 /**
  * Watches for file stability before resolving the promise.
+ * Ensures that the directory and file exist before setting up the watcher.
+ * @param filePathArg The path of the file to monitor.
+ * @param timeoutMs The maximum time to wait for the file to stabilize (in milliseconds). Default is 60 seconds.
+ * @returns A promise that resolves when the file is stable or rejects on timeout or error.
  */
-export const waitForFileToBeReady = (filePathArg: string): Promise<void> => {
+export const waitForFileToBeReady = (
+  filePathArg: string,
+  timeoutMs: number = 60000
+): Promise<void> => {
   return new Promise(async (resolve, reject) => {
     let lastFileSize = -1;
     let fileIsStable = false;
 
-    const checkFileStability = async () => {
-      let currentFileSize: number;
-      const deferred = plugins.smartpromise.defer();
-      plugins.fs.stat(filePathArg, (err, stats) => {
-        if (err) {
-          fileIsStable = true;
-          watcher.close();
-          reject(err);
+    const startTime = Date.now();
+    const fileDir = plugins.path.dirname(filePathArg);
+
+    const ensureFileExists = async () => {
+      while (true) {
+        try {
+          // Check if the file exists
+          await plugins.smartpromise.fromCallback((cb) =>
+            plugins.fs.access(filePathArg, plugins.fs.constants.F_OK, cb)
+          );
+          break; // Exit the loop if the file exists
+        } catch (err: any) {
+          if (err.code !== 'ENOENT') {
+            throw err; // Propagate unexpected errors
+          }
+          if (Date.now() - startTime > timeoutMs) {
+            reject(new Error(`Timeout waiting for file to exist: ${filePathArg}`));
             return;
           }
-        currentFileSize = stats.size;
-        deferred.resolve();
-      });
-      await deferred.promise;
-      if (currentFileSize === lastFileSize) {
-        fileIsStable = true;
-        await plugins.smartdelay.delayFor(100);
-        resolve();
+          // Wait and retry
+          await plugins.smartdelay.delayFor(500);
+        }
       }
-      lastFileSize = currentFileSize;
     };
 
-    const watcher = plugins.fs.watch(filePathArg, (eventType, filename) => {
-      if (eventType === 'change') {
-        checkFileStability();
+    const checkFileStability = async () => {
+      try {
+        const stats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
+          plugins.fs.stat(filePathArg, cb)
+        );
+        if (stats.size === lastFileSize) {
+          fileIsStable = true;
+        } else {
+          lastFileSize = stats.size;
+          fileIsStable = false;
+        }
+      } catch (err: any) {
+        if (err.code !== 'ENOENT') {
+          throw err; // Only ignore ENOENT (file not found) errors
+        }
+      }
+    };
+
+    // Ensure the file exists before setting up the watcher
+    await ensureFileExists();
+
+    const watcher = plugins.fs.watch(filePathArg, { persistent: true }, async () => {
+      if (!fileIsStable) {
+        await checkFileStability();
       }
     });
 
@@ -436,13 +467,28 @@ export const waitForFileToBeReady = (filePathArg: string): Promise<void> => {
       reject(error);
     });
 
+    try {
       while (!fileIsStable) {
+        // Check for timeout
+        if (Date.now() - startTime > timeoutMs) {
+          watcher.close();
+          reject(new Error(`Timeout waiting for file to stabilize: ${filePathArg}`));
+          return;
+        }
+
+        // Check file stability
         await checkFileStability();
         if (!fileIsStable) {
-        await plugins.smartdelay.delayFor(5000);
+          await plugins.smartdelay.delayFor(1000); // Polling interval
         }
       }
+
       watcher.close();
+      resolve();
+    } catch (err) {
+      watcher.close();
+      reject(err);
+    }
   });
 };
 
@@ -493,4 +539,4 @@ export let toFs = async (
 
 export const stat = async (filePathArg: string) => {
   return plugins.fsPromises.stat(filePathArg);
-}
+};