@qrvey/object-storage 2.0.2-1167 → 2.0.3-beta

package/dist/esm/index.mjs

@@ -1,11 +1,57 @@
-import { __name, __publicField, __spreadProps, __spreadValues, __forAwait, __objRest } from './chunk-66BQA4WX.mjs';
-import stream from 'stream';
+import stream2, { Readable, PassThrough } from 'stream';
 import { BlobServiceClient, BlobSASPermissions } from '@azure/storage-blob';
 import { S3Client, S3, ListObjectsV2Command, HeadObjectCommand, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, HeadBucketCommand, UploadPartCommand } from '@aws-sdk/client-s3';
 import { defaultProvider } from '@aws-sdk/credential-provider-node';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { Upload } from '@aws-sdk/lib-storage';
-import { NodeHttpHandler } from '@smithy/node-http-handler';
+import { Agent, request as request$1 } from 'http';
+import { Agent as Agent$1, request } from 'https';
+import { Client } from 'basic-ftp';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => {
+  if (symbol = Symbol[name])
+    return symbol;
+  throw Error("Symbol." + name + " is not defined");
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 
 // src/shared/utils/errorHandler.ts
 var errorMessages = {
@@ -32,7 +78,7 @@ var errorMessages = {
   ObjectNotFound: "ObjectNotFound - The specified key does not exist. (404)",
   DEFAULT: "An unknown error occurred"
 };
-var _ErrorHandler = class _ErrorHandler {
+var ErrorHandler = class {
   static handleError(errorCode, errorMessage, errorObj) {
     const errorResponse = {
       code: errorCode,
@@ -47,8 +93,6 @@ var _ErrorHandler = class _ErrorHandler {
     return errorResponse;
   }
 };
-__name(_ErrorHandler, "ErrorHandler");
-var ErrorHandler = _ErrorHandler;
 
 // src/services/storage/blob/blobHelpers.ts
 function BlobPropertiesResponseToObjectResponse(blobProperties) {
@@ -64,12 +108,11 @@ function BlobPropertiesResponseToObjectResponse(blobProperties) {
     contentLanguage: blobProperties.contentLanguage
   };
 }
-__name(BlobPropertiesResponseToObjectResponse, "BlobPropertiesResponseToObjectResponse");
 
 // src/services/storage/blob/blocIdStorage.ts
-var _BlockIdStorage = class _BlockIdStorage {
+var BlockIdStorage = class _BlockIdStorage {
   constructor() {
-    __publicField(this, "blockIdMap", {});
+    this.blockIdMap = {};
   }
   static getInstance() {
     if (!_BlockIdStorage.instance) {
@@ -90,30 +133,21 @@ var _BlockIdStorage = class _BlockIdStorage {
     delete this.blockIdMap[blobName];
   }
 };
-__name(_BlockIdStorage, "BlockIdStorage");
-__publicField(_BlockIdStorage, "instance");
-var BlockIdStorage = _BlockIdStorage;
 
 // src/services/storage/blob/blobStorage.service.ts
-var _BlobStorageService = class _BlobStorageService {
+var BlobStorageService = class {
   /**
    * Retrieves the properties of a blob from the container by its name.
    *
    * @param {string} blobName - The name of the blob.
+   * @param {ObjectStorageOptions} options - The options for the object storage service.
    * @return {Promise<GetObjectResponse>} A promise that resolves to the blob properties.
    */
-  constructor(containerName) {
-    __publicField(this, "blobServiceClient");
-    __publicField(this, "containerName");
+  constructor(containerName, options) {
     this.containerName = containerName;
-    let connectionString;
-    if (process.env.DATA_LAKE_BUCKET && process.env.DATA_LAKE_BUCKET === this.containerName) {
-      connectionString = process.env.AZURE_DATALAKE_CONNECTION_STRING;
-    }
-    if (!connectionString) {
-      connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
-    }
-    this.blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+    this.blobServiceClient = BlobServiceClient.fromConnectionString(
+      (options == null ? void 0 : options.connectionString) || process.env.AZURE_STORAGE_CONNECTION_STRING
+    );
   }
   /**
    * Creates a writable stream for uploading a file to the Blob storage.
@@ -122,16 +156,15 @@ var _BlobStorageService = class _BlobStorageService {
    * @return {CreateUploadWriteStreamResponse} An object containing the key of the uploaded blob, the writable stream, and a promise that resolves when the upload is complete.
    */
   createUploadWriteStream(blobName) {
-    const streamPassThrough = new stream.PassThrough();
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const streamPassThrough = new stream2.PassThrough();
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     const blockBlobClient = containerClient.getBlockBlobClient(blobName);
     const uploadPromise = blockBlobClient.uploadStream(streamPassThrough, void 0, void 0, {
       onProgress: (ev) => console.log(ev)
     }).then(() => {
-      return {
-        Bucket: this.containerName,
-        Key: blobName
-      };
+      return { Bucket: this.containerName, Key: blobName };
     });
     return {
       key: blobName,
@@ -147,7 +180,9 @@ var _BlobStorageService = class _BlobStorageService {
    */
   async getHeadObject(blobName) {
     try {
-      const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+      const containerClient = this.blobServiceClient.getContainerClient(
+        this.containerName
+      );
       const blockBlobClient = containerClient.getBlockBlobClient(blobName);
       const blobProperties = await blockBlobClient.getProperties();
       return BlobPropertiesResponseToObjectResponse(blobProperties);
@@ -166,13 +201,18 @@ var _BlobStorageService = class _BlobStorageService {
     var _a;
     try {
       let downloadBlockBlobResponse;
-      const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+      const containerClient = this.blobServiceClient.getContainerClient(
+        this.containerName
+      );
       const blockBlobClient = containerClient.getBlockBlobClient(blobName);
       const expression = (options == null ? void 0 : options.range) || "";
       const matches = expression.match(/\d+/g);
       if (expression && (matches == null ? void 0 : matches.length)) {
         const [start, end] = matches.map(Number);
-        downloadBlockBlobResponse = await blockBlobClient.download(start, end);
+        downloadBlockBlobResponse = await blockBlobClient.download(
+          start,
+          end
+        );
       } else {
         downloadBlockBlobResponse = await blockBlobClient.download(0);
       }
@@ -192,7 +232,9 @@ var _BlobStorageService = class _BlobStorageService {
   }
   async getSignatureUrl(blobName, expiresInMinutes, permissions) {
     try {
-      const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+      const containerClient = this.blobServiceClient.getContainerClient(
+        this.containerName
+      );
       const blockBlobClient = containerClient.getBlockBlobClient(blobName);
       const startDate = /* @__PURE__ */ new Date();
       const expiryDate = new Date(startDate);
@@ -208,11 +250,12 @@ var _BlobStorageService = class _BlobStorageService {
   }
   async getUploadUrl(blobName, expiresInMinutes) {
     try {
-      const sasUrl = await this.getSignatureUrl(blobName, expiresInMinutes, "w");
-      return {
-        key: blobName,
-        signedUrl: sasUrl
-      };
+      const sasUrl = await this.getSignatureUrl(
+        blobName,
+        expiresInMinutes,
+        "w"
+      );
+      return { key: blobName, signedUrl: sasUrl };
     } catch (error) {
       throw ErrorHandler.handleError("DEFAULT", "", error);
     }
@@ -226,7 +269,11 @@ var _BlobStorageService = class _BlobStorageService {
    */
   async getDownloadUrl(blobName, expiresInMinutes) {
     try {
-      const sasUrl = await this.getSignatureUrl(blobName, expiresInMinutes, "r");
+      const sasUrl = await this.getSignatureUrl(
+        blobName,
+        expiresInMinutes,
+        "r"
+      );
       return sasUrl;
     } catch (error) {
       throw ErrorHandler.handleError("DEFAULT", "", error);
@@ -242,16 +289,17 @@ var _BlobStorageService = class _BlobStorageService {
    */
   async upload(blobName, body, metadata = {}) {
     try {
-      const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+      const containerClient = this.blobServiceClient.getContainerClient(
+        this.containerName
+      );
       const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-      Buffer.isBuffer(body) ? await blockBlobClient.upload(body, body.length, {
-        metadata
-      }) : await blockBlobClient.uploadStream(body, void 0, void 0, {
-        metadata
-      });
-      return {
-        key: blobName
-      };
+      Buffer.isBuffer(body) ? await blockBlobClient.upload(body, body.length, { metadata }) : await blockBlobClient.uploadStream(
+        body,
+        void 0,
+        void 0,
+        { metadata }
+      );
+      return { key: blobName };
     } catch (error) {
       throw ErrorHandler.handleError("DEFAULT", "", error);
     }
@@ -264,7 +312,9 @@ var _BlobStorageService = class _BlobStorageService {
    */
   async delete(data) {
     try {
-      const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+      const containerClient = this.blobServiceClient.getContainerClient(
+        this.containerName
+      );
       return this.deleteObject(containerClient, data);
     } catch (error) {
       throw ErrorHandler.handleError("DEFAULT", "", error);
@@ -306,9 +356,16 @@ var _BlobStorageService = class _BlobStorageService {
     let continuationToken = options.pagination;
     const limit = (_a = options.limit) != null ? _a : 1e3;
     let continueListing = true;
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     while (continueListing) {
-      const response = await this.listChunk(options, continuationToken, limit - responseContents.length, containerClient);
+      const response = await this.listChunk(
+        options,
+        continuationToken,
+        limit - responseContents.length,
+        containerClient
+      );
       continuationToken = response.continuationToken;
       responseContents = responseContents.concat(response.items);
       if (responseContents.length >= limit || !continuationToken) {
@@ -357,16 +414,10 @@ var _BlobStorageService = class _BlobStorageService {
         pagination
       }));
       if ((_a = response.items) == null ? void 0 : _a.length)
-        allItems = [
-          ...allItems,
-          ...response.items
-        ];
+        allItems = [...allItems, ...response.items];
       pagination = (_b = response.pagination) != null ? _b : void 0;
     } while (pagination);
-    return {
-      items: allItems,
-      count: allItems.length
-    };
+    return { items: allItems, count: allItems.length };
   }
   /**
    * Deletes a blob from the blob storage service.
@@ -390,15 +441,14 @@ var _BlobStorageService = class _BlobStorageService {
    * @return {Promise<{ key: string; deleted: boolean; error?: string }[]>} - A promise that resolves to an array of objects containing the key, deleted status, and an optional error message for each blob deleted.
    */
   async deleteObjects(blobNames) {
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     const deleteBlobPromises = blobNames.map(async (blobName) => {
       var _a;
       try {
         await this.deleteObject(containerClient, blobName);
-        return {
-          key: blobName,
-          deleted: true
-        };
+        return { key: blobName, deleted: true };
       } catch (error) {
         return {
           key: blobName,
@@ -416,15 +466,21 @@ var _BlobStorageService = class _BlobStorageService {
    */
   async getHeadBucket() {
     try {
-      const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+      const containerClient = this.blobServiceClient.getContainerClient(
+        this.containerName
+      );
       const properties = await containerClient.getProperties();
       return properties;
     } catch (error) {
-      throw new Error("Error in Azure getHeadContainer. Container: " + this.containerName + " Error: " + error);
+      throw new Error(
+        "Error in Azure getHeadContainer. Container: " + this.containerName + " Error: " + error
+      );
     }
   }
   async listMultipartUploadsForBucket() {
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     const blobList = containerClient.listBlobsFlat();
     const uploads = [];
     try {
@@ -459,12 +515,15 @@ var _BlobStorageService = class _BlobStorageService {
    */
   async listMultipartUploadsForKey(blobName) {
     var _a;
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     const blobClient = containerClient.getBlockBlobClient(blobName);
     const listResponse = await blobClient.getBlockList("all");
     const parts = ((_a = listResponse == null ? void 0 : listResponse.uncommittedBlocks) == null ? void 0 : _a.map((block, index) => ({
       PartNumber: index + 1,
       LastModified: /* @__PURE__ */ new Date(),
+      // Azure Blob Storage doesn't provide the last modified date for individual parts
       ETag: block.name,
       Size: block.size
     }))) || [];
@@ -493,7 +552,9 @@ var _BlobStorageService = class _BlobStorageService {
    * @return {Promise<string>} A Promise that resolves to a string representing the base64 encoded block ID of the uploaded part.
    */
   async uploadMultipart(blobName, file, partNumber, uploadId) {
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     const blobClient = containerClient.getBlockBlobClient(blobName);
     const blockIdBase = uploadId || await this.generateUploadIdMultipart();
     const partId = partNumber.toString().padStart(6, "0");
@@ -505,13 +566,14 @@ var _BlobStorageService = class _BlobStorageService {
    * Completes a multipart upload by committing the blocks to create the blob.
    *
    * @param {string} blobName - The name of the blob for which the multipart upload is being completed.
-   * @param {string} uploadId - The ID of the multipart upload to be completed.
    * @return {Promise<void>} A Promise that resolves when the multipart upload is successfully completed.
    * @throws {Error} If no block IDs are found in the metadata.
    */
-  async completeMultipartUpload(blobName, uploadId) {
+  async completeMultipartUpload(blobName) {
     var _a;
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     const blobClient = containerClient.getBlockBlobClient(blobName);
     const listMultipartUploads = await this.listMultipartUploadsForKey(blobName);
     const blockIds = ((_a = listMultipartUploads == null ? void 0 : listMultipartUploads.Parts) == null ? void 0 : _a.map((part) => part.ETag)) || [];
@@ -528,7 +590,9 @@ var _BlobStorageService = class _BlobStorageService {
    * @return {Promise<void>} A promise that resolves when the multipart upload is successfully aborted.
    */
   async abortMultipartUpload(blobName, uploadId) {
-    const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
     const blobClient = containerClient.getBlockBlobClient(blobName);
     const blockIdStorage = BlockIdStorage.getInstance();
     blockIdStorage.clearBlockIds(uploadId);
@@ -537,13 +601,15 @@ var _BlobStorageService = class _BlobStorageService {
   async getMultipartUploadPresignedUrl(blobName, uploadId, partNumber, expiresInMinutes = 2) {
     const partId = partNumber.toString().padStart(6, "0");
     const partIdBase64 = Buffer.from(partId).toString("base64");
-    const sasUrl = await this.getSignatureUrl(blobName, expiresInMinutes, "w");
+    const sasUrl = await this.getSignatureUrl(
+      blobName,
+      expiresInMinutes,
+      "w"
+    );
     const url = `${sasUrl}&comp=block&blockid=${partIdBase64}`;
     return url;
   }
 };
-__name(_BlobStorageService, "BlobStorageService");
-var BlobStorageService = _BlobStorageService;
 
 // src/services/storage/s3/s3Helpers.ts
 function listResponseContentsToListResponseItems(responseContents) {
@@ -556,7 +622,6 @@ function listResponseContentsToListResponseItems(responseContents) {
     };
   });
 }
-__name(listResponseContentsToListResponseItems, "listResponseContentsToListResponseItems");
 function s3ObjectToObjectResponse(s3Object) {
   return {
     body: s3Object.Body,
@@ -571,23 +636,469 @@ function s3ObjectToObjectResponse(s3Object) {
     lastModified: s3Object.LastModified
   };
 }
-__name(s3ObjectToObjectResponse, "s3ObjectToObjectResponse");
-var _S3StorageService = class _S3StorageService {
+
+// node_modules/@smithy/types/dist-es/auth/auth.js
+var HttpAuthLocation;
+(function(HttpAuthLocation2) {
+  HttpAuthLocation2["HEADER"] = "header";
+  HttpAuthLocation2["QUERY"] = "query";
+})(HttpAuthLocation || (HttpAuthLocation = {}));
+
+// node_modules/@smithy/types/dist-es/auth/HttpApiKeyAuth.js
+var HttpApiKeyAuthLocation;
+(function(HttpApiKeyAuthLocation2) {
+  HttpApiKeyAuthLocation2["HEADER"] = "header";
+  HttpApiKeyAuthLocation2["QUERY"] = "query";
+})(HttpApiKeyAuthLocation || (HttpApiKeyAuthLocation = {}));
+
+// node_modules/@smithy/types/dist-es/endpoint.js
+var EndpointURLScheme;
+(function(EndpointURLScheme2) {
+  EndpointURLScheme2["HTTP"] = "http";
+  EndpointURLScheme2["HTTPS"] = "https";
+})(EndpointURLScheme || (EndpointURLScheme = {}));
+
+// node_modules/@smithy/types/dist-es/extensions/checksum.js
+var AlgorithmId;
+(function(AlgorithmId2) {
+  AlgorithmId2["MD5"] = "md5";
+  AlgorithmId2["CRC32"] = "crc32";
+  AlgorithmId2["CRC32C"] = "crc32c";
+  AlgorithmId2["SHA1"] = "sha1";
+  AlgorithmId2["SHA256"] = "sha256";
+})(AlgorithmId || (AlgorithmId = {}));
+
+// node_modules/@smithy/types/dist-es/http.js
+var FieldPosition;
+(function(FieldPosition2) {
+  FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER";
+  FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER";
+})(FieldPosition || (FieldPosition = {}));
+
+// node_modules/@smithy/types/dist-es/profile.js
+var IniSectionType;
+(function(IniSectionType2) {
+  IniSectionType2["PROFILE"] = "profile";
+  IniSectionType2["SSO_SESSION"] = "sso-session";
+  IniSectionType2["SERVICES"] = "services";
+})(IniSectionType || (IniSectionType = {}));
+
+// node_modules/@smithy/types/dist-es/transfer.js
+var RequestHandlerProtocol;
+(function(RequestHandlerProtocol2) {
+  RequestHandlerProtocol2["HTTP_0_9"] = "http/0.9";
+  RequestHandlerProtocol2["HTTP_1_0"] = "http/1.0";
+  RequestHandlerProtocol2["TDS_8_0"] = "tds/8.0";
+})(RequestHandlerProtocol || (RequestHandlerProtocol = {}));
+
+// node_modules/@smithy/protocol-http/dist-es/httpResponse.js
+var HttpResponse = class {
+  constructor(options) {
+    this.statusCode = options.statusCode;
+    this.reason = options.reason;
+    this.headers = options.headers || {};
+    this.body = options.body;
+  }
+  static isInstance(response) {
+    if (!response)
+      return false;
+    const resp = response;
+    return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+  }
+};
+
+// node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js
+var escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
+var hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+
+// node_modules/@smithy/querystring-builder/dist-es/index.js
+function buildQueryString(query) {
+  const parts = [];
+  for (let key of Object.keys(query).sort()) {
+    const value = query[key];
+    key = escapeUri(key);
+    if (Array.isArray(value)) {
+      for (let i = 0, iLen = value.length; i < iLen; i++) {
+        parts.push(`${key}=${escapeUri(value[i])}`);
+      }
+    } else {
+      let qsEntry = key;
+      if (value || typeof value === "string") {
+        qsEntry += `=${escapeUri(value)}`;
+      }
+      parts.push(qsEntry);
+    }
+  }
+  return parts.join("&");
+}
+
+// node_modules/@smithy/node-http-handler/dist-es/constants.js
+var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
+
+// node_modules/@smithy/node-http-handler/dist-es/get-transformed-headers.js
+var getTransformedHeaders = (headers) => {
+  const transformedHeaders = {};
+  for (const name of Object.keys(headers)) {
+    const headerValues = headers[name];
+    transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
+  }
+  return transformedHeaders;
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/timing.js
+var timing = {
+  setTimeout: (cb, ms) => setTimeout(cb, ms),
+  clearTimeout: (timeoutId) => clearTimeout(timeoutId)
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
+var DEFER_EVENT_LISTENER_TIME = 1e3;
+var setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
+  if (!timeoutInMs) {
+    return -1;
+  }
+  const registerTimeout = (offset) => {
+    const timeoutId = timing.setTimeout(() => {
+      request.destroy();
+      reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
+        name: "TimeoutError"
+      }));
+    }, timeoutInMs - offset);
+    const doWithSocket = (socket) => {
+      if (socket == null ? void 0 : socket.connecting) {
+        socket.on("connect", () => {
+          timing.clearTimeout(timeoutId);
+        });
+      } else {
+        timing.clearTimeout(timeoutId);
+      }
+    };
+    if (request.socket) {
+      doWithSocket(request.socket);
+    } else {
+      request.on("socket", doWithSocket);
+    }
+  };
+  if (timeoutInMs < 2e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js
+var DEFER_EVENT_LISTENER_TIME2 = 3e3;
+var setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME2) => {
+  if (keepAlive !== true) {
+    return -1;
+  }
+  const registerListener = () => {
+    if (request.socket) {
+      request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+    } else {
+      request.on("socket", (socket) => {
+        socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+      });
+    }
+  };
+  if (deferTimeMs === 0) {
+    registerListener();
+    return 0;
+  }
+  return timing.setTimeout(registerListener, deferTimeMs);
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js
+var DEFER_EVENT_LISTENER_TIME3 = 3e3;
+var setSocketTimeout = (request, reject, timeoutInMs = DEFAULT_REQUEST_TIMEOUT) => {
+  const registerTimeout = (offset) => {
+    const timeout = timeoutInMs - offset;
+    const onTimeout = () => {
+      request.destroy();
+      reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
+    };
+    if (request.socket) {
+      request.socket.setTimeout(timeout, onTimeout);
+      request.on("close", () => {
+        var _a;
+        return (_a = request.socket) == null ? void 0 : _a.removeListener("timeout", onTimeout);
+      });
+    } else {
+      request.setTimeout(timeout, onTimeout);
+    }
+  };
+  if (0 < timeoutInMs && timeoutInMs < 6e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME3), DEFER_EVENT_LISTENER_TIME3);
+};
+var MIN_WAIT_TIME = 6e3;
+async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
+  var _a;
+  const headers = (_a = request.headers) != null ? _a : {};
+  const expect = headers["Expect"] || headers["expect"];
+  let timeoutId = -1;
+  let sendBody = true;
+  if (expect === "100-continue") {
+    sendBody = await Promise.race([
+      new Promise((resolve) => {
+        timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+      }),
+      new Promise((resolve) => {
+        httpRequest.on("continue", () => {
+          timing.clearTimeout(timeoutId);
+          resolve(true);
+        });
+        httpRequest.on("response", () => {
+          timing.clearTimeout(timeoutId);
+          resolve(false);
+        });
+        httpRequest.on("error", () => {
+          timing.clearTimeout(timeoutId);
+          resolve(false);
+        });
+      })
+    ]);
+  }
+  if (sendBody) {
+    writeBody(httpRequest, request.body);
+  }
+}
+function writeBody(httpRequest, body) {
+  if (body instanceof Readable) {
+    body.pipe(httpRequest);
+    return;
+  }
+  if (body) {
+    if (Buffer.isBuffer(body) || typeof body === "string") {
+      httpRequest.end(body);
+      return;
+    }
+    const uint8 = body;
+    if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
+      httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
+      return;
+    }
+    httpRequest.end(Buffer.from(body));
+    return;
+  }
+  httpRequest.end();
+}
+
+// node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
+var DEFAULT_REQUEST_TIMEOUT = 0;
+var NodeHttpHandler = class _NodeHttpHandler {
+  static create(instanceOrOptions) {
+    if (typeof (instanceOrOptions == null ? void 0 : instanceOrOptions.handle) === "function") {
+      return instanceOrOptions;
+    }
+    return new _NodeHttpHandler(instanceOrOptions);
+  }
+  static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
+    var _a, _b, _c, _d, _e;
+    const { sockets, requests, maxSockets } = agent;
+    if (typeof maxSockets !== "number" || maxSockets === Infinity) {
+      return socketWarningTimestamp;
+    }
+    const interval = 15e3;
+    if (Date.now() - interval < socketWarningTimestamp) {
+      return socketWarningTimestamp;
+    }
+    if (sockets && requests) {
+      for (const origin in sockets) {
+        const socketsInUse = (_b = (_a = sockets[origin]) == null ? void 0 : _a.length) != null ? _b : 0;
+        const requestsEnqueued = (_d = (_c = requests[origin]) == null ? void 0 : _c.length) != null ? _d : 0;
+        if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
+          (_e = logger == null ? void 0 : logger.warn) == null ? void 0 : _e.call(logger, `@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
+See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
+or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
+          return Date.now();
+        }
+      }
+    }
+    return socketWarningTimestamp;
+  }
+  constructor(options) {
+    this.socketWarningTimestamp = 0;
+    this.metadata = { handlerProtocol: "http/1.1" };
+    this.configProvider = new Promise((resolve, reject) => {
+      if (typeof options === "function") {
+        options().then((_options) => {
+          resolve(this.resolveDefaultConfig(_options));
+        }).catch(reject);
+      } else {
+        resolve(this.resolveDefaultConfig(options));
+      }
+    });
+  }
+  resolveDefaultConfig(options) {
+    const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent } = options || {};
+    const keepAlive = true;
+    const maxSockets = 50;
+    return {
+      connectionTimeout,
+      requestTimeout: requestTimeout != null ? requestTimeout : socketTimeout,
+      socketAcquisitionWarningTimeout,
+      httpAgent: (() => {
+        if (httpAgent instanceof Agent || typeof (httpAgent == null ? void 0 : httpAgent.destroy) === "function") {
+          return httpAgent;
+        }
+        return new Agent(__spreadValues({ keepAlive, maxSockets }, httpAgent));
+      })(),
+      httpsAgent: (() => {
+        if (httpsAgent instanceof Agent$1 || typeof (httpsAgent == null ? void 0 : httpsAgent.destroy) === "function") {
+          return httpsAgent;
+        }
+        return new Agent$1(__spreadValues({ keepAlive, maxSockets }, httpsAgent));
+      })(),
+      logger: console
+    };
+  }
+  destroy() {
+    var _a, _b, _c, _d;
+    (_b = (_a = this.config) == null ? void 0 : _a.httpAgent) == null ? void 0 : _b.destroy();
+    (_d = (_c = this.config) == null ? void 0 : _c.httpsAgent) == null ? void 0 : _d.destroy();
+  }
+  async handle(request$2, { abortSignal, requestTimeout } = {}) {
+    if (!this.config) {
+      this.config = await this.configProvider;
+    }
+    return new Promise((_resolve, _reject) => {
+      var _a, _b, _c, _d, _e, _f;
+      let writeRequestBodyPromise = void 0;
+      const timeouts = [];
+      const resolve = async (arg) => {
+        await writeRequestBodyPromise;
+        timeouts.forEach(timing.clearTimeout);
+        _resolve(arg);
+      };
+      const reject = async (arg) => {
+        await writeRequestBodyPromise;
+        timeouts.forEach(timing.clearTimeout);
+        _reject(arg);
+      };
+      if (!this.config) {
+        throw new Error("Node HTTP request handler config is not resolved");
+      }
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        const abortError = new Error("Request aborted");
+        abortError.name = "AbortError";
+        reject(abortError);
+        return;
+      }
+      const isSSL = request$2.protocol === "https:";
+      const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
+      timeouts.push(timing.setTimeout(() => {
+        this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, this.config.logger);
+      }, (_c = this.config.socketAcquisitionWarningTimeout) != null ? _c : ((_a = this.config.requestTimeout) != null ? _a : 2e3) + ((_b = this.config.connectionTimeout) != null ? _b : 1e3)));
+      const queryString = buildQueryString(request$2.query || {});
+      let auth = void 0;
+      if (request$2.username != null || request$2.password != null) {
+        const username = (_d = request$2.username) != null ? _d : "";
+        const password = (_e = request$2.password) != null ? _e : "";
+        auth = `${username}:${password}`;
+      }
+      let path = request$2.path;
+      if (queryString) {
+        path += `?${queryString}`;
+      }
+      if (request$2.fragment) {
+        path += `#${request$2.fragment}`;
+      }
+      let hostname = (_f = request$2.hostname) != null ? _f : "";
+      if (hostname[0] === "[" && hostname.endsWith("]")) {
+        hostname = request$2.hostname.slice(1, -1);
+      } else {
+        hostname = request$2.hostname;
+      }
+      const nodeHttpsOptions = {
+        headers: request$2.headers,
+        host: hostname,
+        method: request$2.method,
+        path,
+        port: request$2.port,
+        agent,
+        auth
+      };
+      const requestFunc = isSSL ? request : request$1;
+      const req = requestFunc(nodeHttpsOptions, (res) => {
+        const httpResponse = new HttpResponse({
+          statusCode: res.statusCode || -1,
+          reason: res.statusMessage,
+          headers: getTransformedHeaders(res.headers),
+          body: res
+        });
+        resolve({ response: httpResponse });
+      });
+      req.on("error", (err) => {
+        if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
+          reject(Object.assign(err, { name: "TimeoutError" }));
+        } else {
+          reject(err);
+        }
+      });
+      if (abortSignal) {
+        const onAbort = () => {
+          req.destroy();
+          const abortError = new Error("Request aborted");
+          abortError.name = "AbortError";
+          reject(abortError);
+        };
+        if (typeof abortSignal.addEventListener === "function") {
+          const signal = abortSignal;
+          signal.addEventListener("abort", onAbort, { once: true });
+          req.once("close", () => signal.removeEventListener("abort", onAbort));
+        } else {
+          abortSignal.onabort = onAbort;
+        }
+      }
+      const effectiveRequestTimeout = requestTimeout != null ? requestTimeout : this.config.requestTimeout;
+      timeouts.push(setConnectionTimeout(req, reject, this.config.connectionTimeout));
+      timeouts.push(setSocketTimeout(req, reject, effectiveRequestTimeout));
+      const httpAgent = nodeHttpsOptions.agent;
+      if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
+        timeouts.push(setSocketKeepAlive(req, {
+          keepAlive: httpAgent.keepAlive,
+          keepAliveMsecs: httpAgent.keepAliveMsecs
+        }));
+      }
+      writeRequestBodyPromise = writeRequestBody(req, request$2, effectiveRequestTimeout).catch((e) => {
+        timeouts.forEach(timing.clearTimeout);
+        return _reject(e);
+      });
+    });
+  }
+  updateHttpClientConfig(key, value) {
+    this.config = void 0;
+    this.configProvider = this.configProvider.then((config) => {
+      return __spreadProps(__spreadValues({}, config), {
+        [key]: value
+      });
+    });
+  }
+  httpHandlerConfigs() {
+    var _a;
+    return (_a = this.config) != null ? _a : {};
+  }
+};
+
+// src/services/storage/s3/s3Storage.service.ts
+var S3StorageService = class {
   constructor(bucketName, options) {
-    __publicField(this, "httpHandler", new NodeHttpHandler({
+    this.httpHandler = new NodeHttpHandler({
       socketTimeout: 6e5
-    }));
-    __publicField(this, "s3Client", new S3Client({
+    });
+    this.s3Client = new S3Client({
       region: process.env.AWS_DEFAULT_REGION,
       requestHandler: this.httpHandler,
       credentials: defaultProvider()
-    }));
-    __publicField(this, "s3", new S3({
+    });
+    this.s3 = new S3({
       region: process.env.AWS_DEFAULT_REGION,
       requestHandler: this.httpHandler,
       credentials: defaultProvider()
-    }));
-    __publicField(this, "bucketName");
+    });
     var _a, _b, _c, _d;
     this.bucketName = bucketName;
     if (((_a = options == null ? void 0 : options.credentials) == null ? void 0 : _a.accessKeyId) && ((_b = options == null ? void 0 : options.credentials) == null ? void 0 : _b.secretAccessKey)) {
@@ -632,7 +1143,11 @@ var _S3StorageService = class _S3StorageService {
     let continueListing = true;
     while (continueListing) {
       const listChunkLimit = limit - responseContents.length;
-      const response = await this.listChunk(options, continuationToken, listChunkLimit);
+      const response = await this.listChunk(
+        options,
+        continuationToken,
+        listChunkLimit
+      );
       continuationToken = response.NextContinuationToken;
       responseContents = responseContents.concat((_b = response.Contents) != null ? _b : []);
       if (responseContents.length >= limit || !continuationToken) {
@@ -674,16 +1189,10 @@ var _S3StorageService = class _S3StorageService {
         pagination
       }));
       if ((_a = response.items) == null ? void 0 : _a.length)
-        allItems = [
-          ...allItems,
-          ...response.items
-        ];
+        allItems = [...allItems, ...response.items];
       pagination = response.pagination === null ? void 0 : response.pagination;
     } while (pagination);
-    return {
-      items: allItems,
-      count: allItems.length
-    };
+    return { items: allItems, count: allItems.length };
   }
   /**
    * Retrieves an object from the S3 bucket.
@@ -723,9 +1232,7 @@ var _S3StorageService = class _S3StorageService {
       Bucket: this.bucketName,
       Key: key
     });
-    return getSignedUrl(this.s3Client, command, {
-      expiresIn
-    });
+    return getSignedUrl(this.s3Client, command, { expiresIn });
   }
   /**
    * Retrieves a signed URL for uploading an object to the S3 bucket.
@@ -758,6 +1265,22 @@ var _S3StorageService = class _S3StorageService {
    * @returns A promise that resolves to the response containing the key of the uploaded object.
    */
   async upload(key, body, metadata) {
+    if (body instanceof stream2.Readable) {
+      const upload = new Upload({
+        client: this.s3Client,
+        params: {
+          Bucket: this.bucketName,
+          Key: key,
+          Body: body,
+          Metadata: metadata
+        },
+        queueSize: 5,
+        partSize: 8 * 1024 * 1024
+        // 8MB parts
+      });
+      await upload.done();
+      return { key };
+    }
     const command = new PutObjectCommand({
       Bucket: this.bucketName,
       Key: key,
@@ -765,9 +1288,7 @@ var _S3StorageService = class _S3StorageService {
       Metadata: metadata
     });
     await this.s3Client.send(command);
-    return {
-      key
-    };
+    return { key };
   }
   /**
    * Creates a writable stream for uploading a file to the S3 bucket.
@@ -776,7 +1297,7 @@ var _S3StorageService = class _S3StorageService {
    * @return {CreateUploadWriteStreamResponse} An object containing the key of the uploaded object, the writable stream, and a promise that resolves when the upload is complete.
    */
   createUploadWriteStream(key) {
-    const streamPassThrough = new stream.PassThrough();
+    const streamPassThrough = new stream2.PassThrough();
     const params = {
       Bucket: this.bucketName,
       Key: key,
@@ -814,7 +1335,9 @@ var _S3StorageService = class _S3StorageService {
       });
       return this.s3Client.send(command);
     } catch (error) {
-      throw new Error("Error in S3 getHeadContainer. bucketName: " + this.bucketName + " Error: " + error);
+      throw new Error(
+        "Error in S3 getHeadContainer. bucketName: " + this.bucketName + " Error: " + error
+      );
     }
   }
   /**
@@ -891,7 +1414,10 @@ var _S3StorageService = class _S3StorageService {
     return upId;
   }
   async completeMultipartUpload(key, uploadId) {
-    const partsResponse = await this.listMultipartUploadsForKey(key, uploadId);
+    const partsResponse = await this.listMultipartUploadsForKey(
+      key,
+      uploadId
+    );
     const partsList = (partsResponse == null ? void 0 : partsResponse.Parts) && partsResponse.Parts.map(
       // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
       (_a) => {
@@ -925,23 +1451,353 @@ var _S3StorageService = class _S3StorageService {
       PartNumber: parseInt(partNumber, 10)
     };
     const expiresIn = expiresInMinutes * 60;
-    const presignedUrl = await getSignedUrl(this.s3Client, new UploadPartCommand(uploadPartParams), {
-      expiresIn
-    });
+    const presignedUrl = await getSignedUrl(
+      this.s3Client,
+      new UploadPartCommand(uploadPartParams),
+      { expiresIn }
+    );
     return presignedUrl;
   }
 };
-__name(_S3StorageService, "S3StorageService");
-var S3StorageService = _S3StorageService;
+var SftpClient = __require("ssh2-sftp-client");
+var SftpStorageService = class {
+  constructor(bucketName, options) {
+    this.bucketName = bucketName;
+    this.options = options || {};
+    this.client = new SftpClient();
+  }
+  async initializeClient() {
+    const host = this.options.host || process.env.SFTP_HOST;
+    const port = parseInt(
+      String(this.options.port || process.env.SFTP_PORT)
+    );
+    const user = this.options.user || process.env.SFTP_USER;
+    const password = this.options.password || process.env.SFTP_PASSWORD;
+    const privateKey = this.options.privateKey || process.env.SFTP_PRIVATE_KEY;
+    if (!password && !privateKey) {
+      throw new Error(
+        "Either password or private key must be provided for SFTP connection"
+      );
+    }
+    await this.client.connect({
+      host,
+      port,
+      username: user,
+      password,
+      privateKey,
+      readyTimeout: 4e3,
+      retries: 1,
+      retry_factor: 2,
+      retry_minTimeout: 2e3
+    });
+  }
+  async withClient(fn) {
+    try {
+      await this.initializeClient();
+      return await fn();
+    } finally {
+      await this.client.end().catch(() => {
+      });
+    }
+  }
+  async list(options) {
+    return this.withClient(async () => {
+      const prefix = options.prefix || "";
+      const path = this.bucketName + (prefix ? "/" + prefix : "");
+      const list = await this.client.list(path);
+      const items = list.map((item) => ({
+        key: item.name,
+        lastModified: item.modifyTime ? new Date(item.modifyTime) : /* @__PURE__ */ new Date(),
+        size: item.size,
+        eTag: ""
+      }));
+      return {
+        items,
+        pagination: null,
+        count: items.length
+      };
+    });
+  }
+  async ensureDirectoriesExist(remotePath) {
+    var _a, _b;
+    const parts = remotePath.split("/");
+    parts.pop();
+    let current = "";
+    for (const part of parts) {
+      if (!part)
+        continue;
+      current += `/${part}`;
+      try {
+        await this.client.stat(current);
+      } catch (err) {
+        const isNoEntry = err.code === "ENOENT" || ((_a = err.message) == null ? void 0 : _a.includes("No such file")) || ((_b = err.message) == null ? void 0 : _b.includes("does not exist"));
+        if (isNoEntry) {
+          try {
+            await this.client.mkdir(current);
+          } catch (mkdirErr) {
+            throw new Error(
+              `Failed to create directory ${current}: ${mkdirErr.message}`
+            );
+          }
+        } else {
+          throw new Error(
+            `Failed to check directory ${current}: ${err.message}`
+          );
+        }
+      }
+    }
+  }
+  async upload(key, body) {
+    return this.withClient(async () => {
+      let remotePath = `${this.bucketName}/${key}`;
+      remotePath = remotePath + "";
+      await this.ensureDirectoriesExist(remotePath);
+      if (body instanceof Readable) {
+        await this.client.put(body, remotePath);
+      } else if (body instanceof Buffer) {
+        await this.client.put(Buffer.from(body), remotePath);
+      } else {
+        await this.client.put(Buffer.from(String(body)), remotePath);
+      }
+      return { key };
+    });
+  }
+  async delete(key) {
+    return this.withClient(async () => {
+      await this.client.delete(`${this.bucketName}/${key}`);
+      return true;
+    });
+  }
+  async getObject(key) {
+    await this.initializeClient();
+    const remotePath = `${this.bucketName}/${key}`;
+    const stats = await this.client.stat(remotePath);
+    const data = await this.client.get(remotePath);
+    let stream3;
+    if (Buffer.isBuffer(data) || typeof data === "string") {
+      stream3 = Readable.from(data);
+    } else if (data instanceof Readable) {
+      stream3 = data;
+    } else {
+      throw new Error("Unsupported stream type returned by SFTP client");
+    }
+    const cleanup = async () => {
+      try {
+        await this.client.end();
+      } catch (e) {
+      }
+    };
+    stream3.on("end", cleanup);
+    stream3.on("error", cleanup);
+    return {
+      body: stream3,
+      contentLength: stats.size,
+      lastModified: stats.modifyTime ? new Date(stats.modifyTime) : /* @__PURE__ */ new Date(),
+      metadata: {}
+    };
+  }
+  listAll(options) {
+    throw new Error("Method not implemented.");
+  }
+  getHeadObject(key) {
+    throw new Error("Method not implemented.");
+  }
+  getDownloadUrl(key, expiresInMinutes) {
+    throw new Error("Method not implemented.");
+  }
+  getUploadUrl(key, expiresInMinutes) {
+    throw new Error("Method not implemented.");
+  }
+  createUploadWriteStream(key) {
+    throw new Error("Method not implemented.");
+  }
+  getHeadBucket() {
+    throw new Error("Method not implemented.");
+  }
+  generateUploadIdMultipart(key) {
+    throw new Error("Method not implemented.");
+  }
+  listMultipartUploadsForBucket() {
+    throw new Error("Method not implemented.");
+  }
+  listMultipartUploadsForKey(key, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  uploadMultipart(key, file, partNumber, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  completeMultipartUpload(key, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  abortMultipartUpload(key, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  getMultipartUploadPresignedUrl(key, uploadId, partNumber, expiresInMinutes) {
+    throw new Error("Method not implemented.");
+  }
+};
+var FtpStorageService = class {
+  constructor(bucketName, options) {
+    this.bucketName = bucketName;
+    this.options = options || {};
+    this.client = new Client();
+  }
+  listAll(options) {
+    throw new Error("Method not implemented.");
+  }
+  async initializeClient() {
+    var _a, _b, _c, _d, _e;
+    const host = ((_a = this == null ? void 0 : this.options) == null ? void 0 : _a.host) || process.env.FTP_HOST;
+    const port = parseInt(
+      String(((_b = this == null ? void 0 : this.options) == null ? void 0 : _b.port) || process.env.FTP_PORT),
+      10
+    );
+    const user = ((_c = this == null ? void 0 : this.options) == null ? void 0 : _c.user) || process.env.FTP_USER;
+    const password = ((_d = this == null ? void 0 : this.options) == null ? void 0 : _d.password) || process.env.FTP_PASSWORD;
+    await this.client.access({
+      host,
+      port,
+      user,
+      password,
+      secure: ((_e = this == null ? void 0 : this.options) == null ? void 0 : _e.secure) || false
+    });
+  }
+  async withClient(fn) {
+    try {
+      await this.initializeClient();
+      return await fn();
+    } finally {
+      this.client.close();
+    }
+  }
+  async list(options) {
+    return this.withClient(async () => {
+      const prefix = options.prefix || "";
+      const path = `${this.bucketName}/${prefix}`;
+      try {
+        const list = await this.client.list(path);
+        const items = list.map(
+          (item) => ({
+            key: prefix + item.name,
+            lastModified: item.modifiedAt || /* @__PURE__ */ new Date(),
+            size: item.size,
+            eTag: ""
+          })
+        );
+        return {
+          items,
+          pagination: null,
+          count: items.length
+        };
+      } catch (e) {
+        return { items: [], pagination: null, count: 0 };
+      }
+    });
+  }
+  async getObject(key) {
+    await this.initializeClient();
+    const passThrough = new PassThrough();
+    const path = `${this.bucketName}/${key}`;
+    const stats = await this.client.size(path);
+    this.client.downloadTo(passThrough, path).then(() => passThrough.end()).catch((err) => passThrough.emit("error", err));
+    const cleanup = () => {
+      this.client.close();
+    };
+    passThrough.on("end", cleanup);
+    passThrough.on("error", cleanup);
+    return {
+      body: passThrough,
+      contentLength: stats,
+      lastModified: /* @__PURE__ */ new Date(),
+      metadata: {}
+    };
+  }
+  async upload(key, body) {
+    return this.withClient(async () => {
+      await this.client.cd("/");
+      try {
+        await this.client.cd(this.bucketName);
+      } catch (e) {
+        await this.client.send(`MKD ${this.bucketName}`);
+        await this.client.cd(this.bucketName);
+      }
+      const parts = key.split("/");
+      parts.pop();
+      for (const part of parts) {
+        if (!part)
+          continue;
+        try {
+          await this.client.cd(part);
+        } catch (e) {
+          await this.client.send(`MKD ${part}`);
+          await this.client.cd(part);
+        }
+      }
+      await this.client.cd("/");
+      const fullPath = `${this.bucketName}/${key}`;
+      const stream3 = body instanceof Readable ? body : Readable.from([body]);
+      await this.client.uploadFrom(stream3, fullPath);
+      return { key };
+    });
+  }
+  async delete(key) {
+    return this.withClient(async () => {
+      await this.client.remove(`${this.bucketName}/${key}`);
+      return true;
+    });
+  }
+  async close() {
+    this.client.close();
+  }
+  // Unsupported Operations
+  async getDownloadUrl(_key, _expiresInMinutes) {
+    throw new Error("FTP does not support pre-signed URLs");
+  }
+  async getUploadUrl(_key, _expiresInMinutes) {
+    throw new Error("FTP does not support pre-signed URLs");
+  }
+  async getHeadObject(_key) {
+    throw new Error("Operation not supported");
+  }
+  createUploadWriteStream(_key) {
+    throw new Error("Operation not supported");
+  }
+  async getHeadBucket() {
+    throw new Error("Operation not supported");
+  }
+  async generateUploadIdMultipart(_key) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async listMultipartUploadsForBucket() {
+    throw new Error("Multipart upload is not supported");
+  }
+  async listMultipartUploadsForKey(_key, _uploadId) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async uploadMultipart(_key, _file, _partNumber, _uploadId) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async completeMultipartUpload(_key, _uploadId) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async abortMultipartUpload(_key, _uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  async getMultipartUploadPresignedUrl(_key, _uploadId, _partNumber, _expiresInMinutes) {
+    throw new Error("Multipart upload is not supported");
+  }
+};
 
 // src/shared/utils/constants.ts
 var OBJECT_STORAGE_SERVICE_TYPES = {
   AWS_S3: "aws_s3",
-  AZURE_BLOB_STORAGE: "azure_blob_storage"
+  AZURE_BLOB_STORAGE: "azure_blob_storage",
+  FTP: "ftp",
+  SFTP: "sftp"
 };
 
 // src/services/objectStorageFactory.service.ts
-var _ObjectStorageFactory = class _ObjectStorageFactory {
+var ObjectStorageFactory = class {
   static async instance(bucketName, options) {
     var _a, _b;
     const provider = ((_a = options == null ? void 0 : options.provider) == null ? void 0 : _a.toLowerCase()) || ((_b = process.env.OBJECT_STORAGE_SERVICE) == null ? void 0 : _b.toLowerCase());
@@ -949,17 +1805,21 @@ var _ObjectStorageFactory = class _ObjectStorageFactory {
       case OBJECT_STORAGE_SERVICE_TYPES.AWS_S3:
         return new S3StorageService(bucketName, options);
       case OBJECT_STORAGE_SERVICE_TYPES.AZURE_BLOB_STORAGE:
-        return new BlobStorageService(bucketName);
+        return new BlobStorageService(bucketName, options);
+      case OBJECT_STORAGE_SERVICE_TYPES.FTP:
+        return new FtpStorageService(bucketName, options);
+      case OBJECT_STORAGE_SERVICE_TYPES.SFTP:
+        return new SftpStorageService(bucketName, options);
       default:
-        throw new Error(`Unsupported object storage provider: ${provider}`);
+        throw new Error(
+          `Unsupported object storage provider: ${provider}`
+        );
     }
   }
 };
-__name(_ObjectStorageFactory, "ObjectStorageFactory");
-var ObjectStorageFactory = _ObjectStorageFactory;
 
 // src/services/objectStorage.service.ts
-var _ObjectStorageService = class _ObjectStorageService {
+var ObjectStorageService = class _ObjectStorageService {
   constructor(bucketName, options) {
     _ObjectStorageService.bucketName = bucketName;
     if (options)
@@ -975,38 +1835,56 @@ var _ObjectStorageService = class _ObjectStorageService {
    *
    * @param {ListRequestOptions} options - The options to apply to the list operation.
    * @param {string} [bucketName] - The name of the bucket to list objects from. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListResponse>} A promise that resolves to the list of objects.
    */
-  static async list(options, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.list(options));
+  static async list(options, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.list(options));
   }
   /**
    * Retrieves a list of all objects from the object storage service.
    *
    * @param {ListRequestOptions} options - The options to apply to the list operation.
    * @param {string} [bucketName] - The name of the bucket to list objects from. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListResponse>} A promise that resolves to the list of all objects.
    */
-  static async listAll(options, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.listAll(options));
+  static async listAll(options, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.listAll(options));
   }
   /**
    * Retrieves an object from the object storage service.
    *
    * @param {string} key - The key of the object to retrieve.
    * @param {string} [bucketName] - The name of the bucket where the object is stored. If not provided, the default bucket name will be used.
+   * @param {IGetObjectOptions} [options] - The options to apply to the get operation.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<GetObjectResponse>} A promise that resolves to the retrieved object.
    */
-  static async getObject(key, bucketName, options) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getObject(key, options));
+  static async getObject(key, bucketName, options, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.getObject(key, options));
   }
   /**
    * Retrieves an object info (without file content) from the object storage service.
    * @param key - The key of the object to retrieve.
+   * @param bucketName - The name of the bucket where the object is stored. If not provided, the default bucket name will be used.
+   * @param objectStorageOptions - The options for the object storage service.
    * @returns A promise that resolves to the info of the file.
    */
-  static async getHeadObject(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getHeadObject(key));
+  static async getHeadObject(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.getHeadObject(key));
   }
   /**
    * Retrieves a signed URL for the specified object in the object storage service.
@@ -1014,10 +1892,14 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object for which to generate the signed URL.
    * @param {number} expiresInMinutes - The number of minutes until the signed URL expires.
    * @param {string} [bucketName] - The name of the bucket where the object is stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A promise that resolves to the generated signed URL.
    */
-  static async getDownloadUrl(key, expiresInMinutes, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getDownloadUrl(key, expiresInMinutes));
+  static async getDownloadUrl(key, expiresInMinutes, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.getDownloadUrl(key, expiresInMinutes));
   }
   /**
    * Retrieves an upload URL for the specified object in the object storage service.
@@ -1025,10 +1907,14 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object for which to generate the upload URL.
    * @param {number} expiresInMinutes - The number of minutes until the upload URL expires.
    * @param {string} [bucketName] - The name of the bucket where the object will be stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A promise that resolves to the generated upload URL.
    */
-  static async getUploadUrl(key, expiresInMinutes, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getUploadUrl(key, expiresInMinutes));
+  static async getUploadUrl(key, expiresInMinutes, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.getUploadUrl(key, expiresInMinutes));
   }
   /**
    * Uploads a file to the object storage service.
@@ -1037,39 +1923,48 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {FileContent} body - The content of the file to upload.
    * @param {Object} [metadata] - Optional metadata to associate with the object.
    * @param {string} [bucketName] - The name of the bucket where the object will be stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<UploadResponse>} A promise that resolves to the response of the upload operation.
    */
-  static async upload(key, body, metadata, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.upload(key, body, metadata));
+  static async upload(key, body, metadata, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.upload(key, body, metadata));
   }
   /**
    * Creates an upload write stream for the specified key in the object storage service.
    *
    * @param {string} key - The key of the object to create the upload write stream for.
    * @param {string} [bucketName] - The name of the bucket where the object will be stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<CreateUploadWriteStreamResponse>} A promise that resolves to the response of the upload operation.
    */
-  static async createUploadWriteStream(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.createUploadWriteStream(key));
+  static async createUploadWriteStream(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.createUploadWriteStream(key));
   }
   /**
    * Deletes an object or multiple objects from the object storage service.
    *
    * @param {string | string[]} key - The key or array of keys of the objects to delete.
    * @param {string} [bucketName] - The name of the bucket where the objects are stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<{ key: string; deleted: boolean; error?: string }[] | boolean>} A promise that resolves to an array of objects containing the key, deleted status, and an optional error message for each object deleted, or a boolean value indicating the success of the deletion.
    */
-  static async delete(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then(async (instance) => {
+  static async delete(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then(async (instance) => {
       if (Array.isArray(key)) {
         const deleteBlobPromises = key.map(async (blobName) => {
           var _a;
           try {
             await instance.delete(blobName);
-            return {
-              key: blobName,
-              deleted: true
-            };
+            return { key: blobName, deleted: true };
           } catch (error) {
             return {
               key: blobName,
@@ -1088,20 +1983,28 @@ var _ObjectStorageService = class _ObjectStorageService {
    * Retrieves the head bucket from the object storage service.
    *
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<HeadBucketResponse>} A promise that resolves to the head bucket response.
    */
-  static async getHeadBucket(bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getHeadBucket());
+  static async getHeadBucket(bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.getHeadBucket());
   }
   /**
    * Generates a unique upload ID for a multipart upload.
    *
    * @param {string} key - The key of the object to upload.
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A promise that resolves to the generated upload ID.
    */
-  static async generateUploadIdMultipart(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.generateUploadIdMultipart(key));
+  static async generateUploadIdMultipart(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.generateUploadIdMultipart(key));
   }
   /**
    * Retrieves a list of multipart uploads for a specified key in the object storage service.
@@ -1109,19 +2012,29 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object to retrieve uploads for.
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
    * @param {string} [uploadId] - The upload ID to filter the results by.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListPartsMultipartUploadResponse>} A promise that resolves to the list of multipart uploads for the specified key.
    */
-  static async listMultipartUploadsForKey(key, bucketName, uploadId) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.listMultipartUploadsForKey(key, uploadId));
+  static async listMultipartUploadsForKey(key, bucketName, uploadId, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then(
+      (instance) => instance.listMultipartUploadsForKey(key, uploadId)
+    );
   }
   /**
    * Retrieves a list of all multipart uploads for a specified bucket in the object storage service.
    *
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListMultipartUploadsResponse>} A promise that resolves to the list of multipart uploads for the specified bucket.
    */
-  static async listMultipartUploadsForBucket(bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.listMultipartUploadsForBucket());
+  static async listMultipartUploadsForBucket(bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.listMultipartUploadsForBucket());
   }
   /**
    * Uploads a multipart file to the specified bucket in the object storage service.
@@ -1131,10 +2044,16 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {number} partNumber - The number of the part being uploaded.
    * @param {string} [uploadId] - The ID of the multipart upload.
    * @param {string} [bucketName] - The name of the bucket to upload the file to. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A Promise that resolves to the base64 encoded block ID of the uploaded part.
    */
-  static async uploadMultipart(key, file, partNumber, uploadId, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.uploadMultipart(key, file, partNumber, uploadId));
+  static async uploadMultipart(key, file, partNumber, uploadId, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then(
+      (instance) => instance.uploadMultipart(key, file, partNumber, uploadId)
+    );
   }
   /**
    * Completes a multipart upload for the specified object in the object storage service.
@@ -1142,10 +2061,14 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object to complete the multipart upload for.
    * @param {string} uploadId - The ID of the multipart upload to complete.
    * @param {string} [bucketName] - The name of the bucket to complete the multipart upload in. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<void>} A Promise that resolves when the multipart upload is completed.
    */
-  static async completeMultipartUpload(key, uploadId, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.completeMultipartUpload(key, uploadId));
+  static async completeMultipartUpload(key, uploadId, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.completeMultipartUpload(key, uploadId));
   }
   /**
    * Aborts a multipart upload for the specified object in the object storage service.
@@ -1153,10 +2076,14 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object to abort the multipart upload for.
    * @param {string} uploadId - The ID of the multipart upload to abort.
    * @param {string} [bucketName] - The name of the bucket to abort the multipart upload in. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<void>} A Promise that resolves when the multipart upload is aborted.
    */
-  static async abortMultipartUpload(key, uploadId, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.abortMultipartUpload(key, uploadId));
+  static async abortMultipartUpload(key, uploadId, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(
+      bucketName,
+      objectStorageOptions
+    ).then((instance) => instance.abortMultipartUpload(key, uploadId));
   }
   /**
    * Retrieves a presigned URL for a specific part of a multipart upload.
@@ -1168,13 +2095,16 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @return {Promise<string>} A Promise that resolves to the presigned URL for the specified part of the multipart upload.
    */
   static async getMultipartUploadPresignedUrl(key, uploadId, partNumber, expiresInMinutes) {
-    return _ObjectStorageService.getObjectStorageServiceInstance().then((instance) => instance.getMultipartUploadPresignedUrl(key, uploadId, partNumber, expiresInMinutes));
+    return _ObjectStorageService.getObjectStorageServiceInstance().then(
+      (instance) => instance.getMultipartUploadPresignedUrl(
+        key,
+        uploadId,
+        partNumber,
+        expiresInMinutes
+      )
+    );
   }
 };
-__name(_ObjectStorageService, "ObjectStorageService");
-__publicField(_ObjectStorageService, "bucketName");
-__publicField(_ObjectStorageService, "objectStorageOptions");
-var ObjectStorageService = _ObjectStorageService;
 
 export { ObjectStorageService };
 //# sourceMappingURL=out.js.map