vtlab-generic-functions 1.0.24 → 1.0.26

package/ftp/ftp-promise-wrapper.js

@@ -1,21 +1,5 @@
 const promiseFTP = require("promise-ftp");
-/**
- *
- * Internal functions
- */
 
-const streamToBuffer = (stream) => {
-  let _buf = [];
-  return new Promise((resolve, reject) => {
-    try {
-      stream.once("close", resolve);
-      stream.once("error", reject);
-      stream.pipe((chunk) => Buffer.concat(chunk));
-    } catch (err) {
-      reject(err);
-    }
-  });
-};
 
 /**
  *
@@ -23,52 +7,53 @@ const streamToBuffer = (stream) => {
  */
 //downloadFromFTP
 const downloadFromFTP = async (ftp, remotePathWithFile) => {
-  let _buf = [];
-  let Stream = require("stream");
-  const writableStream = new Stream.Writable();
-  writableStream._write = (chunk, encoding, next) => {
-    _buf.push(chunk);
-    next();
-  };
-  return ftp
-    .get(remotePathWithFile)
-    .then((stream) => {
-      return new Promise(function (resolve, reject) {
-        stream.once("close", resolve);
-        stream.once("error", reject);
-        stream.pipe(writableStream);
-      });
-    })
-    .then(() => {
-      return _buf;
-    })
-    .catch((err) => {
-      throw err;
-    });
+	let _buf = [];
+	let Stream = require("stream");
+	const writableStream = new Stream.Writable();
+	writableStream._write = (chunk, encoding, next) => {
+		_buf.push(chunk);
+		next();
+	};
+	return ftp
+		.get(remotePathWithFile)
+		.then((stream) => {
+			return new Promise(function (resolve, reject) {
+				stream.once("close", resolve);
+				stream.once("error", reject);
+				stream.pipe(writableStream);
+			});
+		})
+		.then(() => {
+			return _buf;
+		})
+		.catch((err) => {
+			throw err;
+		});
 };
 
+
 //uploadFileToFTP
 const uploadFileToFTP = async (
-  config,
-  localPathWithFile,
-  remotePathWithFile
+	config,
+	localPathWithFile,
+	remotePathWithFile
 ) => {
-  /**
-   * config ={
-      host: 'ftp.islgrupo.com',
-      user: 'testpelikane',
-      password: 'Pelikane2021+',
-      port: <OPtional>
-    }
-   */
-  let ftp = new promiseFTP();
-  try {
-    await ftp.connect(config);
-    await ftp.put(localPathWithFile, remotePathWithFile);
-    return { code: 200, message: "FTP successfull ulpload" };
-  } catch (err) {
-    throw err;
-  }
+	/**
+	 * config ={
+		host: 'ftp.islgrupo.com',
+		user: 'testpelikane',
+		password: 'Pelikane2021+',
+		port: <OPtional>
+	  }
+	 */
+	let ftp = new promiseFTP();
+	try {
+		await ftp.connect(config);
+		await ftp.put(localPathWithFile, remotePathWithFile);
+		return { code: 200, message: "FTP successfull ulpload" };
+	} catch (err) {
+		throw err;
+	}
 };
 
 /**
@@ -78,12 +63,12 @@ const uploadFileToFTP = async (
  * @returns {Promise<boolean>}
  */
 const isFileExistsInFTP = async (ftp, filePath) => {
-  try {
-    let exists = await ftp.list(filePath);
-    return exists.length > 0;
-  } catch (e) {
-    throw e;
-  }
+	try {
+		let exists = await ftp.list(filePath);
+		return exists.length > 0;
+	} catch (e) {
+		throw e;
+	}
 };
 
 /**
@@ -93,17 +78,20 @@ const isFileExistsInFTP = async (ftp, filePath) => {
  * @returns {Promise<void>}
  */
 const deleteFileFromFTP = async (ftp, filePath) => {
-  try {
-    await ftp.delete(filePath);
-  } catch (e) {
-    throw e;
-  }
+	try {
+		await ftp.delete(filePath);
+	} catch (e) {
+		throw e;
+	}
 };
 
 
+
+
+
 module.exports = {
-  uploadFileToFTP,
-  downloadFromFTP,
-  isFileExistsInFTP,
-  deleteFileFromFTP
+	uploadFileToFTP,
+	downloadFromFTP,
+	isFileExistsInFTP,
+	deleteFileFromFTP
 };

package/ftp/ftpClientClass.js

@@ -0,0 +1,215 @@
+
+const promiseFTP = require("promise-ftp");
+const promiseSFTP = require("ssh2-sftp-client");
+
+
+/**
+ * Represents an FTP client for connecting to an FTP server and performing file operations.
+ */
+class FTPClientV2 {
+	/**
+	 * Constructs a new FTPClientV2 instance.
+	 */
+	constructor() {
+		/**
+		 * FTP server credentials.
+		 * @type {Object}
+		 * @private
+		 */
+		this._ftpCredentials = null;
+
+		/**
+		 * Indicates whether the client is connected to the FTP server.
+		 * @type {boolean}
+		 * @private
+		 */
+		this._isConnected = false;
+
+		/**
+		 * The FTP client instance.
+		 * @type {Object}
+		 * @private
+		 */
+		this._ftpInstance = null;
+	}
+
+	/**
+	 * Connects to the FTP server.
+	 * @param {Object} config FTP server configuration.
+	 *  @param {string} config.host The FTP server host.
+	 *  @param {number} [config.port] The FTP server port.
+	 *  @param {string} [config.username] The FTP server username.
+	 *  @param {string} [config.password] The FTP server password.
+	 *  @param {boolean} [config.autoReconnect] Indicates whether to automatically reconnect to the server.
+	 *  @param {string} [config.privateKey] Buffer or string that contains a private key for either key-based or host-based user authentication
+	 * 
+	 * @throws {Error} If FTP credentials are not provided or connection fails.
+	 */
+	async connect(config) {
+		if (!config) {
+			throw new Error("FTP credentials not provided");
+		}
+
+		// normalize username/user
+		config.username = config.username || config.user;
+		config.user = config.user || config.username;
+
+		try {
+			switch (config.type) {
+				case "sftpWithKey":
+					this._ftpInstance = new promiseSFTP();
+					break;
+				case "ftp":
+				case "sftp":
+				default:
+					this._ftpInstance = new promiseFTP();
+					break;
+			}
+			await this._ftpInstance.connect(config);
+			this._isConnected = true;
+			this._ftpCredentials = config;
+		} catch (error) {
+			this._isConnected = false;
+			this._ftpInstance = null;
+			throw new Error(`Failed to connect to FTP server: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Disconnects from the FTP server.
+	 * @throws {Error} If disconnection fails.
+	 */
+	async disconnect() {
+		if (this._isConnected && this._ftpInstance) {
+			try {
+				await this._ftpInstance.end();
+				this._isConnected = false;
+				this._ftpInstance = null;
+				this._ftpCredentials = null;
+			} catch (error) {
+				throw new Error(`Failed to disconnect from FTP server: ${error.message}`);
+			}
+		}
+	}
+
+	/**
+	 * Downloads a file from the FTP server.
+	 * @param {string} remotePathWithFile Remote path to the file.
+	 * @returns {Promise<Buffer>} A Promise resolving to the downloaded file content.
+	 * @throws {Error} If download fails.
+	 */
+	async downloadFile(remotePathWithFile) {
+		if (!this._isConnected) {
+			await this.connect(this._ftpCredentials);
+		}
+
+		switch (this._ftpCredentials.type) {
+			case 'sftpWithKey':
+				let file = await this._ftpInstance.get(remotePathWithFile);
+				return [file];
+			default:
+				let Stream = require("stream");
+				return new Promise((resolve, reject) => {
+					let _buf = [];
+					const writableStream = new Stream.Writable();
+					writableStream._write = (chunk, encoding, next) => {
+						_buf.push(chunk);
+						next();
+					};
+
+					this._ftpInstance.get(remotePathWithFile)
+						.then((stream) => {
+							return new Promise(function (resolve, reject) {
+								stream.once("close", resolve);
+								stream.once("error", reject);
+								stream.pipe(writableStream);
+							});
+						})
+						.then(() => {
+							return resolve(_buf);
+						})
+						.catch((err) => {
+							return reject(err);
+						});
+				});
+		}
+	}
+
+	/**
+	 * Uploads a file to the FTP server.
+	 * @param {string} localPathWithFile Local path to the file.
+	 * @param {string} remotePathWithFile Remote path to upload the file.
+	 * @returns {Promise<Object>} A Promise resolving to an object with upload status.
+	 * @throws {Error} If upload fails.
+	 */
+	async uploadFile(localPathWithFile, remotePathWithFile) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			await this._ftpInstance.put(localPathWithFile, remotePathWithFile);
+			return { code: 200, message: "FTP successful upload" };
+		} catch (error) {
+			throw new Error(`Failed to upload file to FTP server: ${error.message}`);
+		} finally {
+			await this.disconnect();
+		}
+	}
+
+	/**
+	 * Checks if a file exists on the FTP server.
+	 * @param {string} filePath Remote file path to check.
+	 * @returns {Promise<boolean>} A Promise resolving to true if the file exists, false otherwise.
+	 * @throws {Error} If the operation fails.
+	 */
+	async isFileExists(filePath) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			const exists = await this._ftpInstance.list(filePath);
+			return exists.length > 0;
+		} catch (error) {
+			throw new Error(`Failed to check file existence on FTP server: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Deletes a file from the FTP server.
+	 * @param {string} filePath Remote file path to delete.
+	 * @throws {Error} If deletion fails.
+	 */
+	async deleteFile(filePath) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			await this._ftpInstance.delete(filePath);
+		} catch (error) {
+			throw new Error(`Failed to delete file from FTP server: ${error.message}`);
+		}
+	}
+
+	/**
+	* Lists files in a folder on the FTP server.
+	* @param {string} folderPath Remote folder path to list files.
+	* @returns {Promise<Array<string>>} A Pro∏”mise resolving to an array of file names in the folder.
+	* @throws {Error} If listing files fails.
+	*/
+	async listFilesInFolder(folderPath) {
+		try {
+			if (!this._isConnected) {
+				await this.connect(this._ftpCredentials);
+			}
+			const files = await this._ftpInstance.list(folderPath);
+			const filesOnly = files && files.length ? files.filter(item => item.type !== 'd') : null;
+			return filesOnly ? filesOnly.map((file) => file.name) : files.map((file) => file.name)
+		} catch (error) {
+			throw new Error(`Failed to list files in folder on FTP server: ${error.message}`);
+		}
+	}
+}
+
+module.exports = {
+    FTPClientV2
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vtlab-generic-functions",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "scripts": {
     "test": "jest"
   },