convert-csv-to-json 4.46.0 → 4.47.0

package/src/util/fileUtils.js

@@ -1,97 +1,220 @@
 'use strict';
 
 const fs = require('fs');
-const { FileOperationError } = require('./errors');
+const { FileOperationError } = require('../core/errors');
+
+const ENCODED_FILE_ENCODINGS = new Set(['base64', 'hex']);
 
 /**
- * File I/O utilities for reading and writing CSV/JSON files
- * Provides both synchronous and asynchronous file operations
+ * File I/O utilities for reading and writing CSV/JSON files.
+ * Provides both synchronous and asynchronous file operations.
  * @category Utilities
  */
 class FileUtils {
+    /**
+     * Determine whether the encoding represents a binary-encoded file.
+     * @param {string} encoding - File encoding label
+     * @returns {boolean} True when encoding is base64 or hex
+     * @private
+     */
+    _isEncodedFile(encoding) {
+        return ENCODED_FILE_ENCODINGS.has(encoding);
+    }
+
+    /**
+     * Decode raw file content that was stored as base64 or hex.
+     * @param {string} rawContent - Raw file content read from disk
+     * @param {string} encoding - Encoding used for the file
+     * @returns {string} UTF-8 decoded string content
+     * @private
+     */
+    _decodeContent(rawContent, encoding) {
+        if (this._isEncodedFile(encoding)) {
+            return Buffer.from(rawContent, encoding).toString('utf8');
+        }
+
+        return rawContent;
+    }
+
+    /**
+     * Convert raw file data into a string.
+     * @param {string|Buffer} data - Data read from fs
+     * @returns {string} String representation of the data
+     * @private
+     */
+    _toString(data) {
+        return typeof data === 'string' ? data : data.toString();
+    }
 
     /**
-     * Read a file synchronously with specified encoding
+     * Wrap a read error in a FileOperationError instance.
+     * @param {string} fileInputName - Path to file being read
+     * @param {Error} error - Original error from fs
+     * @returns {FileOperationError} Wrapped read error
+     * @private
+     */
+    _wrapReadError(fileInputName, error) {
+        return new FileOperationError('read', fileInputName, error);
+    }
+
+    /**
+     * Wrap a write error in a FileOperationError instance.
+     * @param {string} fileOutputName - Path to file being written
+     * @param {Error} error - Original error from fs
+     * @returns {FileOperationError} Wrapped write error
+     * @private
+     */
+    _wrapWriteError(fileOutputName, error) {
+        return new FileOperationError('write', fileOutputName, error);
+    }
+
+    /**
+     * Perform a synchronous file read using the provided encoding.
+     * @param {string} fileInputName - Path to file to read
+     * @param {string} encoding - File encoding to use when reading
+     * @returns {string} Decoded file content
+     * @private
+     */
+    _readFileSync(fileInputName, encoding) {
+        if (this._isEncodedFile(encoding)) {
+            const rawContent = fs.readFileSync(fileInputName, 'utf8');
+            return this._decodeContent(rawContent, encoding);
+        }
+
+        return this._toString(fs.readFileSync(fileInputName, encoding));
+    }
+
+    /**
+     * Read a file synchronously with specified encoding.
      * @param {string} fileInputName - Path to file to read
      * @param {string} encoding - File encoding (e.g., 'utf8', 'latin1')
      * @returns {string} File contents as string
      * @throws {FileOperationError} If file read fails
      */
-    readFile(fileInputName, encoding) {
+    readFile(fileInputName, encoding = 'utf8') {
         try {
-            return fs.readFileSync(fileInputName, encoding).toString();
+            return this._readFileSync(fileInputName, encoding);
         } catch (error) {
-            throw new FileOperationError('read', fileInputName, error);
+            throw this._wrapReadError(fileInputName, error);
         }
     }
 
     /**
-     * Read a file asynchronously with specified encoding
-     * Uses fs.promises when available, falls back to callback-based API
+     * Read a file using fs.promises and return decoded content.
+     * @param {string} fileInputName - Path to file to read
+     * @param {string} encoding - File encoding to use
+     * @returns {Promise<string>} Promise resolving to decoded file content
+     * @private
+     */
+    _readFileAsyncWithPromises(fileInputName, encoding) {
+        if (this._isEncodedFile(encoding)) {
+            return fs.promises.readFile(fileInputName, 'utf8')
+                .then(rawContent => this._decodeContent(rawContent, encoding));
+        }
+
+        return fs.promises.readFile(fileInputName, encoding)
+            .then(data => this._toString(data));
+    }
+
+    /**
+     * Read a file asynchronously with specified encoding.
+     * Uses fs.promises when available, falls back to callback-based API.
      * @param {string} fileInputName - Path to file to read
      * @param {string} encoding - File encoding (default: 'utf8')
      * @returns {Promise<string>} Promise resolving to file contents
      * @throws {FileOperationError} If file read fails
      */
     readFileAsync(fileInputName, encoding = 'utf8') {
-        // Use fs.promises when available for a Promise-based API
         if (fs.promises && typeof fs.promises.readFile === 'function') {
-            return fs.promises.readFile(fileInputName, encoding)
-                .then(buf => buf.toString())
+            return this._readFileAsyncWithPromises(fileInputName, encoding)
                 .catch(error => {
-                    throw new FileOperationError('read', fileInputName, error);
+                    throw this._wrapReadError(fileInputName, error);
                 });
         }
+
         return new Promise((resolve, reject) => {
-            fs.readFile(fileInputName, encoding, (err, data) => {
-                if (err) {
-                    reject(new FileOperationError('read', fileInputName, err));
+            const callback = (error, data) => {
+                if (error) {
+                    reject(this._wrapReadError(fileInputName, error));
                     return;
                 }
-                resolve(data.toString());
-            });
+
+                try {
+                    const content = this._isEncodedFile(encoding)
+                        ? this._decodeContent(this._toString(data), encoding)
+                        : this._toString(data);
+                    resolve(content);
+                } catch (decodeError) {
+                    reject(this._wrapReadError(fileInputName, decodeError));
+                }
+            };
+
+            const readEncoding = this._isEncodedFile(encoding) ? 'utf8' : encoding;
+            fs.readFile(fileInputName, readEncoding, callback);
         });
     }
 
     /**
-     * Write content to a file synchronously
-     * Logs confirmation message to console on success
-     * @param {string} json - Content to write to file
+     * Write content to a file synchronously.
+     * @param {string} fileOutputName - Path to output file
+     * @param {string} content - File content to write
+     * @private
+     */
+    _writeFileSync(fileOutputName, content) {
+        fs.writeFileSync(fileOutputName, content, 'utf8');
+    }
+
+    /**
+     * Write content to a file using fs.promises.
+     * @param {string} fileOutputName - Path to output file
+     * @param {string} content - File content to write
+     * @returns {Promise<void>} Promise that resolves when write completes
+     * @private
+     */
+    _writeFileAsyncWithPromises(fileOutputName, content) {
+        return fs.promises.writeFile(fileOutputName, content, 'utf8');
+    }
+
+    /**
+     * Write content to a file synchronously.
+     * @param {string} content - Content to write to file
      * @param {string} fileOutputName - Path to output file
      * @throws {FileOperationError} If file write fails
      */
-    writeFile(json, fileOutputName) {
-        fs.writeFile(fileOutputName, json, function (err) {
-            if (err) {
-                throw new FileOperationError('write', fileOutputName, err);
-            } else {
-                console.log('File saved: ' + fileOutputName);
-            }
-        });
+    writeFile(content, fileOutputName) {
+        try {
+            this._writeFileSync(fileOutputName, content);
+        } catch (error) {
+            throw this._wrapWriteError(fileOutputName, error);
+        }
     }
 
     /**
-     * Write content to a file asynchronously
-     * Uses fs.promises when available, falls back to callback-based API
-     * @param {string} json - Content to write to file
+     * Write content to a file asynchronously.
+     * Uses fs.promises when available, falls back to callback-based API.
+     * @param {string} content - Content to write to file
      * @param {string} fileOutputName - Path to output file
      * @returns {Promise<void>} Promise that resolves when write completes
      * @throws {FileOperationError} If file write fails
      */
-    writeFileAsync(json, fileOutputName) {
+    writeFileAsync(content, fileOutputName) {
         if (fs.promises && typeof fs.promises.writeFile === 'function') {
-            return fs.promises.writeFile(fileOutputName, json)
+            return this._writeFileAsyncWithPromises(fileOutputName, content)
                 .catch(error => {
-                    throw new FileOperationError('write', fileOutputName, error);
+                    throw this._wrapWriteError(fileOutputName, error);
                 });
         }
+
         return new Promise((resolve, reject) => {
-            fs.writeFile(fileOutputName, json, (err) => {
-                if (err) return reject(new FileOperationError('write', fileOutputName, err));
+            fs.writeFile(fileOutputName, content, 'utf8', (error) => {
+                if (error) {
+                    reject(this._wrapWriteError(fileOutputName, error));
+                    return;
+                }
                 resolve();
             });
         });
     }
-
 }
+
 module.exports = new FileUtils();

package/src/util/jsonUtils.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { JsonValidationError } = require('./errors');
+const { JsonValidationError } = require('../core/errors');
 
 /**
  * JSON validation utilities