@qrvey/object-storage 1.0.2-beta → 1.0.3-beta

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-import stream, { Readable } from 'stream';
+import stream, { 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';
@@ -6,6 +6,7 @@ import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { Upload } from '@aws-sdk/lib-storage';
 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;
@@ -31,6 +32,13 @@ var __spreadValues = (a, b) => {
   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)
@@ -132,12 +140,13 @@ 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) {
+  constructor(containerName, options) {
     this.containerName = containerName;
     this.blobServiceClient = BlobServiceClient.fromConnectionString(
-      process.env.AZURE_STORAGE_CONNECTION_STRING
+      (options == null ? void 0 : options.connectionString) || process.env.AZURE_STORAGE_CONNECTION_STRING
     );
   }
   /**
@@ -557,11 +566,10 @@ var BlobStorageService = class {
    * 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
@@ -629,28 +637,28 @@ function s3ObjectToObjectResponse(s3Object) {
   };
 }
 
-// ../../node_modules/@smithy/types/dist-es/auth/auth.js
+// 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
+// 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
+// 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
+// node_modules/@smithy/types/dist-es/extensions/checksum.js
 var AlgorithmId;
 (function(AlgorithmId2) {
   AlgorithmId2["MD5"] = "md5";
@@ -660,14 +668,14 @@ var AlgorithmId;
   AlgorithmId2["SHA256"] = "sha256";
 })(AlgorithmId || (AlgorithmId = {}));
 
-// ../../node_modules/@smithy/types/dist-es/http.js
+// 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
+// node_modules/@smithy/types/dist-es/profile.js
 var IniSectionType;
 (function(IniSectionType2) {
   IniSectionType2["PROFILE"] = "profile";
@@ -675,7 +683,7 @@ var IniSectionType;
   IniSectionType2["SERVICES"] = "services";
 })(IniSectionType || (IniSectionType = {}));
 
-// ../../node_modules/@smithy/types/dist-es/transfer.js
+// node_modules/@smithy/types/dist-es/transfer.js
 var RequestHandlerProtocol;
 (function(RequestHandlerProtocol2) {
   RequestHandlerProtocol2["HTTP_0_9"] = "http/0.9";
@@ -683,7 +691,7 @@ var RequestHandlerProtocol;
   RequestHandlerProtocol2["TDS_8_0"] = "tds/8.0";
 })(RequestHandlerProtocol || (RequestHandlerProtocol = {}));
 
-// ../../node_modules/@smithy/protocol-http/dist-es/httpResponse.js
+// node_modules/@smithy/protocol-http/dist-es/httpResponse.js
 var HttpResponse = class {
   constructor(options) {
     this.statusCode = options.statusCode;
@@ -699,11 +707,11 @@ var HttpResponse = class {
   }
 };
 
-// ../../node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js
+// 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
+// node_modules/@smithy/querystring-builder/dist-es/index.js
 function buildQueryString(query) {
   const parts = [];
   for (let key of Object.keys(query).sort()) {
@@ -724,10 +732,10 @@ function buildQueryString(query) {
   return parts.join("&");
 }
 
-// ../../node_modules/@smithy/node-http-handler/dist-es/constants.js
+// 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
+// node_modules/@smithy/node-http-handler/dist-es/get-transformed-headers.js
 var getTransformedHeaders = (headers) => {
   const transformedHeaders = {};
   for (const name of Object.keys(headers)) {
@@ -737,71 +745,123 @@ var getTransformedHeaders = (headers) => {
   return transformedHeaders;
 };
 
-// ../../node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
+// 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;
+    return -1;
   }
-  const timeoutId = setTimeout(() => {
-    request.destroy();
-    reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
-      name: "TimeoutError"
-    }));
-  }, timeoutInMs);
-  request.on("socket", (socket) => {
-    if (socket.connecting) {
-      socket.on("connect", () => {
-        clearTimeout(timeoutId);
-      });
+  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 {
-      clearTimeout(timeoutId);
+      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 setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }) => {
+// 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;
+    return -1;
   }
-  request.on("socket", (socket) => {
-    socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
-  });
+  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 setSocketTimeout = (request, reject, timeoutInMs = 0) => {
-  request.setTimeout(timeoutInMs, () => {
-    request.destroy();
-    reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
-  });
+// 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 = 1e3;
+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 hasError = false;
+  let sendBody = true;
   if (expect === "100-continue") {
-    await Promise.race([
+    sendBody = await Promise.race([
       new Promise((resolve) => {
-        timeoutId = Number(setTimeout(resolve, Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+        timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
       }),
       new Promise((resolve) => {
         httpRequest.on("continue", () => {
-          clearTimeout(timeoutId);
-          resolve();
+          timing.clearTimeout(timeoutId);
+          resolve(true);
+        });
+        httpRequest.on("response", () => {
+          timing.clearTimeout(timeoutId);
+          resolve(false);
         });
         httpRequest.on("error", () => {
-          hasError = true;
-          clearTimeout(timeoutId);
-          resolve();
+          timing.clearTimeout(timeoutId);
+          resolve(false);
         });
       })
     ]);
   }
-  if (!hasError) {
+  if (sendBody) {
     writeBody(httpRequest, request.body);
   }
 }
@@ -826,7 +886,8 @@ function writeBody(httpRequest, body) {
   httpRequest.end();
 }
 
-// ../../node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
+// 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") {
@@ -834,8 +895,8 @@ var NodeHttpHandler = class _NodeHttpHandler {
     }
     return new _NodeHttpHandler(instanceOrOptions);
   }
-  static checkSocketUsage(agent, socketWarningTimestamp) {
-    var _a, _b, _c, _d;
+  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;
@@ -849,7 +910,9 @@ var NodeHttpHandler = class _NodeHttpHandler {
         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) {
-          console.warn("@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.");
+          (_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();
         }
       }
@@ -870,12 +933,13 @@ var NodeHttpHandler = class _NodeHttpHandler {
     });
   }
   resolveDefaultConfig(options) {
-    const { requestTimeout, connectionTimeout, socketTimeout, httpAgent, httpsAgent } = 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;
@@ -887,7 +951,8 @@ var NodeHttpHandler = class _NodeHttpHandler {
           return httpsAgent;
         }
         return new Agent$1(__spreadValues({ keepAlive, maxSockets }, httpsAgent));
-      })()
+      })(),
+      logger: console
     };
   }
   destroy() {
@@ -895,21 +960,22 @@ var NodeHttpHandler = class _NodeHttpHandler {
     (_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 } = {}) {
+  async handle(request$2, { abortSignal, requestTimeout } = {}) {
     if (!this.config) {
       this.config = await this.configProvider;
     }
-    let socketCheckTimeoutId;
     return new Promise((_resolve, _reject) => {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       let writeRequestBodyPromise = void 0;
+      const timeouts = [];
       const resolve = async (arg) => {
         await writeRequestBodyPromise;
-        clearTimeout(socketCheckTimeoutId);
+        timeouts.forEach(timing.clearTimeout);
         _resolve(arg);
       };
       const reject = async (arg) => {
         await writeRequestBodyPromise;
+        timeouts.forEach(timing.clearTimeout);
         _reject(arg);
       };
       if (!this.config) {
@@ -923,9 +989,9 @@ var NodeHttpHandler = class _NodeHttpHandler {
       }
       const isSSL = request$2.protocol === "https:";
       const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
-      socketCheckTimeoutId = setTimeout(() => {
-        this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp);
-      }, (_c = this.config.socketAcquisitionWarningTimeout) != null ? _c : ((_a = this.config.requestTimeout) != null ? _a : 2e3) + ((_b = this.config.connectionTimeout) != null ? _b : 1e3));
+      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) {
@@ -940,9 +1006,15 @@ var NodeHttpHandler = class _NodeHttpHandler {
       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: request$2.hostname,
+        host: hostname,
         method: request$2.method,
         path,
         port: request$2.port,
@@ -966,24 +1038,35 @@ var NodeHttpHandler = class _NodeHttpHandler {
           reject(err);
         }
       });
-      setConnectionTimeout(req, reject, this.config.connectionTimeout);
-      setSocketTimeout(req, reject, this.config.requestTimeout);
       if (abortSignal) {
-        abortSignal.onabort = () => {
-          req.abort();
+        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) {
-        setSocketKeepAlive(req, {
+        timeouts.push(setSocketKeepAlive(req, {
           keepAlive: httpAgent.keepAlive,
           keepAliveMsecs: httpAgent.keepAliveMsecs
-        });
+        }));
       }
-      writeRequestBodyPromise = writeRequestBody(req, request$2, this.config.requestTimeout).catch(_reject);
+      writeRequestBodyPromise = writeRequestBody(req, request$2, effectiveRequestTimeout).catch((e) => {
+        timeouts.forEach(timing.clearTimeout);
+        return _reject(e);
+      });
     });
   }
   updateHttpClientConfig(key, value) {
@@ -1360,11 +1443,310 @@ var S3StorageService = class {
     return presignedUrl;
   }
 };
+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 upload(key, body) {
+    return this.withClient(async () => {
+      const remotePath = `${this.bucketName}/${key}`;
+      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
@@ -1376,7 +1758,11 @@ var ObjectStorageFactory = class {
       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}`
@@ -1402,11 +1788,13 @@ 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) {
+  static async list(options, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.list(options));
   }
   /**
@@ -1414,11 +1802,13 @@ 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 all objects.
    */
-  static async listAll(options, bucketName) {
+  static async listAll(options, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.listAll(options));
   }
   /**
@@ -1426,21 +1816,27 @@ var ObjectStorageService = class _ObjectStorageService {
    *
    * @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) {
+  static async getObject(key, bucketName, options, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      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) {
+  static async getHeadObject(key, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.getHeadObject(key));
   }
   /**
@@ -1449,11 +1845,13 @@ 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) {
+  static async getDownloadUrl(key, expiresInMinutes, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.getDownloadUrl(key, expiresInMinutes));
   }
   /**
@@ -1462,11 +1860,13 @@ 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) {
+  static async getUploadUrl(key, expiresInMinutes, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.getUploadUrl(key, expiresInMinutes));
   }
   /**
@@ -1476,11 +1876,13 @@ 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) {
+  static async upload(key, body, metadata, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.upload(key, body, metadata));
   }
   /**
@@ -1488,11 +1890,13 @@ var ObjectStorageService = class _ObjectStorageService {
    *
    * @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) {
+  static async createUploadWriteStream(key, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.createUploadWriteStream(key));
   }
   /**
@@ -1500,11 +1904,13 @@ var ObjectStorageService = class _ObjectStorageService {
    *
    * @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) {
+  static async delete(key, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then(async (instance) => {
       if (Array.isArray(key)) {
         const deleteBlobPromises = key.map(async (blobName) => {
@@ -1530,11 +1936,13 @@ 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) {
+  static async getHeadBucket(bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.getHeadBucket());
   }
   /**
@@ -1542,11 +1950,13 @@ var ObjectStorageService = class _ObjectStorageService {
    *
    * @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) {
+  static async generateUploadIdMultipart(key, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.generateUploadIdMultipart(key));
   }
   /**
@@ -1555,11 +1965,13 @@ 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) {
+  static async listMultipartUploadsForKey(key, bucketName, uploadId, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then(
       (instance) => instance.listMultipartUploadsForKey(key, uploadId)
     );
@@ -1568,11 +1980,13 @@ var ObjectStorageService = class _ObjectStorageService {
    * 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) {
+  static async listMultipartUploadsForBucket(bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.listMultipartUploadsForBucket());
   }
   /**
@@ -1583,11 +1997,13 @@ 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) {
+  static async uploadMultipart(key, file, partNumber, uploadId, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then(
       (instance) => instance.uploadMultipart(key, file, partNumber, uploadId)
     );
@@ -1598,11 +2014,13 @@ 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) {
+  static async completeMultipartUpload(key, uploadId, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.completeMultipartUpload(key, uploadId));
   }
   /**
@@ -1611,11 +2029,13 @@ 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) {
+  static async abortMultipartUpload(key, uploadId, bucketName, objectStorageOptions) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
-      bucketName
+      bucketName,
+      objectStorageOptions
     ).then((instance) => instance.abortMultipartUpload(key, uploadId));
   }
   /**