@qrvey/object-storage 0.0.1 → 0.0.3

package/dist/cjs/index.js

@@ -5,247 +5,594 @@ var clientS3 = require('@aws-sdk/client-s3');
 var s3RequestPresigner = require('@aws-sdk/s3-request-presigner');
 
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __knownSymbol = (name, symbol) => {
-  if (symbol = Symbol[name])
-    return symbol;
-  throw Error("Symbol." + name + " is not defined");
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+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 __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/shared/utils/errorHandler.ts
+var errorMessages = {
+  AccessDenied: "Access denied",
+  AccountProblem: "There is a problem with your account",
+  AllAccessDisabled: "All access to this resource has been disabled",
+  BucketAlreadyExists: "The requested bucket name is not available",
+  BucketNotEmpty: "The bucket you tried to delete is not empty",
+  EntityTooLarge: "The entity you are trying to upload is too large",
+  ExpiredToken: "The provided token has expired",
+  InternalError: "An internal server error has occurred",
+  InvalidAccessKeyId: "The AWS access key ID you provided does not exist in our records",
+  InvalidBucketName: "The specified bucket name is not valid",
+  InvalidObjectState: "The operation is not valid for the current state of the object",
+  InvalidToken: "The provided token is invalid",
+  NoSuchBucket: "The specified bucket does not exist",
+  NoSuchKey: "The specified key does not exist",
+  PreconditionFailed: "The condition specified in the request is not met",
+  RequestTimeout: "The request timed out",
+  ServiceUnavailable: "The service is currently unavailable",
+  SignatureDoesNotMatch: "The request signature we calculated does not match the signature you provided",
+  SlowDown: "Please reduce your request rate",
+  TemporaryRedirect: "Temporary redirect",
+  DEFAULT: "An unknown error occurred"
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var ErrorHandler = class {
+  static handleError(errorCode, errorMessage, errorObj) {
+    const errorResponse = {
+      code: errorCode,
+      message: errorMessage || errorMessages[errorCode] || errorMessages["DEFAULT"],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: errorObj ? {
+        name: errorObj.name,
+        message: errorObj.message,
+        stack: errorObj.stack || null
+      } : null
+    };
+    return errorResponse;
+  }
 };
-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/services/storage/blob/blobHelpers.ts
+function BlobPropertiesResponseToObjectResponse(blobProperties) {
+  return {
+    lastModified: blobProperties.lastModified,
+    contentLength: blobProperties.contentLength,
+    contentType: blobProperties.contentType,
+    eTag: blobProperties.etag,
+    metadata: blobProperties.metadata,
+    contentEncoding: blobProperties.contentEncoding,
+    cacheControl: blobProperties.cacheControl,
+    contentDisposition: blobProperties.contentDisposition,
+    contentLanguage: blobProperties.contentLanguage
+  };
+}
 
 // src/services/storage/blob/blobStorage.service.ts
-var blobStorage_service_exports = {};
-__export(blobStorage_service_exports, {
-  BlobStorageService: () => BlobStorageService
-});
-var BlobStorageService;
-var init_blobStorage_service = __esm({
-  "src/services/storage/blob/blobStorage.service.ts"() {
-    BlobStorageService = class {
-      constructor(containerName) {
-        this.containerName = containerName;
-        this.blobServiceClient = storageBlob.BlobServiceClient.fromConnectionString(
-          process.env.AZURE_STORAGE_CONNECTION_STRING
+var BlobStorageService = class {
+  /**
+   * Retrieves the properties of a blob from the container by its name.
+   *
+   * @param {string} blobName - The name of the blob.
+   * @return {Promise<GetObjectResponse>} A promise that resolves to the blob properties.
+   */
+  constructor(containerName) {
+    this.containerName = containerName;
+    this.blobServiceClient = storageBlob.BlobServiceClient.fromConnectionString(
+      process.env.AZURE_STORAGE_CONNECTION_STRING
+    );
+  }
+  getUploadUrl(key, expiresInMinutes) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Retrieves the properties of a blob from the container by its name.
+   *
+   * @param {string} blobName - The name of the blob.
+   * @return {Promise<GetObjectResponse>} A promise that resolves to the blob properties.
+   */
+  getHeadObject(blobName) {
+    return new Promise((resolve, reject) => {
+      try {
+        const containerClient = this.blobServiceClient.getContainerClient(
+          this.containerName
+        );
+        const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+        blockBlobClient.getProperties().then((blobProperties) => {
+          return resolve(
+            BlobPropertiesResponseToObjectResponse(
+              blobProperties
+            )
+          );
+        }).catch(
+          (error) => reject(
+            ErrorHandler.handleError(
+              "DEFAULT",
+              "",
+              error
+            )
+          )
+        );
+      } catch (error) {
+        return reject(
+          ErrorHandler.handleError("DEFAULT", "", error)
         );
       }
-      async list() {
-        const list = [];
+    });
+  }
+  /**
+   * Retrieves an object from the blob storage service.
+   *
+   * @param {string} blobName - The name of the blob to retrieve.
+   * @return {Promise<GetObjectResponse>} A promise that resolves to the object data, including the body, metadata, content type, and content length, or rejects with an error if there was an issue.
+   */
+  getObject(blobName) {
+    return new Promise((resolve, reject) => {
+      try {
         const containerClient = this.blobServiceClient.getContainerClient(
           this.containerName
         );
-        try {
-          for (var iter = __forAwait(containerClient.listBlobsFlat()), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-            const containerItem = temp.value;
-            list.push(containerItem.name);
-          }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && await temp.call(iter);
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-        return new Promise((resolve) => resolve({ keys: list }));
+        const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+        blockBlobClient.download(0).then((downloadBlockBlobResponse) => {
+          return resolve({
+            body: downloadBlockBlobResponse.readableStreamBody,
+            metadata: {},
+            contentType: "",
+            contentLength: 0
+          });
+        }).catch(
+          (error) => reject(
+            ErrorHandler.handleError(
+              "DEFAULT",
+              "",
+              error
+            )
+          )
+        );
+      } catch (error) {
+        return reject(
+          ErrorHandler.handleError("DEFAULT", "", error)
+        );
       }
-      getObject(blobName) {
-        return new Promise((resolve, reject) => {
-          try {
-            const containerClient = this.blobServiceClient.getContainerClient(
-              this.containerName
-            );
-            const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-            blockBlobClient.download(0).then((downloadBlockBlobResponse) => {
-              return resolve({
-                body: downloadBlockBlobResponse.readableStreamBody,
-                metadata: {},
-                contentType: "",
-                contentLength: 0
-              });
-            });
-          } catch (error) {
-            return reject(error);
-          }
-        });
+    });
+  }
+  /**
+   * Retrieves a signed URL for the blob with the specified name that expires after a certain period.
+   *
+   * @param {string} blobName - The name of the blob to generate the signed URL for.
+   * @param {number} expiresInMinutes - The duration in minutes until the signed URL expires.
+   * @return {Promise<string>} A Promise that resolves with the signed URL.
+   */
+  getDownloadUrl(blobName, expiresInMinutes) {
+    return new Promise((resolve, reject) => {
+      try {
+        const containerClient = this.blobServiceClient.getContainerClient(
+          this.containerName
+        );
+        const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+        const startDate = /* @__PURE__ */ new Date();
+        const expiryDate = new Date(startDate);
+        expiryDate.setMinutes(
+          startDate.getMinutes() + expiresInMinutes
+        );
+        blockBlobClient.generateSasUrl({
+          permissions: storageBlob.BlobSASPermissions.parse("r"),
+          startsOn: startDate,
+          expiresOn: expiryDate
+        }).then((sasUrl) => resolve(sasUrl)).catch(
+          (error) => reject(
+            ErrorHandler.handleError(
+              "DEFAULT",
+              "",
+              error
+            )
+          )
+        );
+      } catch (error) {
+        return reject(
+          ErrorHandler.handleError("DEFAULT", "", error)
+        );
       }
-      async getSignedUrl(blobName, expiresInMinutes) {
-        return new Promise((resolve, reject) => {
-          try {
-            const containerClient = this.blobServiceClient.getContainerClient(
-              this.containerName
-            );
-            const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-            const startDate = /* @__PURE__ */ new Date();
-            const expiryDate = new Date(startDate);
-            expiryDate.setMinutes(
-              startDate.getMinutes() + expiresInMinutes
-            );
-            blockBlobClient.generateSasUrl({
-              permissions: storageBlob.BlobSASPermissions.parse("r"),
-              startsOn: startDate,
-              expiresOn: expiryDate
-            }).then((sasUrl) => resolve(sasUrl));
-          } catch (error) {
-            return reject(error);
-          }
-        });
+    });
+  }
+  /**
+   * Uploads a file to the blob storage service.
+   *
+   * @param {string} blobName - The name of the blob to upload.
+   * @param {FileContent} body - The content of the file to upload.
+   * @param {{ [key: string]: string } | undefined} [metadata] - Optional metadata to associate with the blob.
+   * @return {Promise<UploadResponse>} A promise that resolves to the response object containing the key of the uploaded blob, or rejects with an error if there was an issue.
+   */
+  upload(blobName, body, metadata) {
+    return new Promise((resolve, reject) => {
+      try {
+        const containerClient = this.blobServiceClient.getContainerClient(
+          this.containerName
+        );
+        const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+        blockBlobClient.uploadStream(
+          body,
+          void 0,
+          void 0,
+          metadata
+        ).then(() => resolve({ key: blobName })).catch(
+          (error) => reject(
+            ErrorHandler.handleError(
+              "DEFAULT",
+              "",
+              error
+            )
+          )
+        );
+      } catch (error) {
+        return reject(
+          ErrorHandler.handleError("DEFAULT", "", error)
+        );
       }
-      async upload(blobName, body, metadata) {
-        return new Promise((resolve, reject) => {
-          try {
-            const containerClient = this.blobServiceClient.getContainerClient(
-              this.containerName
-            );
-            const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-            blockBlobClient.uploadStream(body).then(() => resolve({ key: blobName }));
-          } catch (error) {
-            return reject(error);
-          }
-        });
+    });
+  }
+  /**
+   * Deletes a blob from the blob storage service.
+   *
+   * @param {string} blobName - The name of the blob to be deleted.
+   * @return {Promise<boolean>} A promise that resolves to true if the blob is successfully deleted, or rejects with an error if there was an issue.
+   */
+  delete(blobName) {
+    return new Promise((resolve, reject) => {
+      try {
+        const containerClient = this.blobServiceClient.getContainerClient(
+          this.containerName
+        );
+        const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+        blockBlobClient.delete().then(() => resolve(true)).catch(
+          (error) => reject(
+            ErrorHandler.handleError(
+              "DEFAULT",
+              "",
+              error
+            )
+          )
+        );
+      } catch (error) {
+        return reject(
+          ErrorHandler.handleError("DEFAULT", "", error)
+        );
       }
-      delete(blobName) {
-        return new Promise((resolve, reject) => {
-          try {
-            const containerClient = this.blobServiceClient.getContainerClient(
-              this.containerName
-            );
-            const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-            blockBlobClient.delete().then(() => resolve(true));
-          } catch (error) {
-            return reject(error);
-          }
-        });
+    });
+  }
+  /**
+   * Lists a chunk of blobs from the specified container client based on the provided options and continuation token.
+   *
+   * @param {ListRequestOptions} options - The options for listing the blobs.
+   * @param {string | undefined} continuationToken - The continuation token for pagination.
+   * @param {number} limit - The maximum number of blobs to list in a single page.
+   * @param {ContainerClient} containerClient - The container client to list the blobs from.
+   * @return {Promise<{ items: BlobItem[]; continuationToken?: string }>} - A promise that resolves to an object containing the list of blob items and an optional continuation token.
+   */
+  async listChunk(options, continuationToken, limit, containerClient) {
+    const iterator = containerClient.listBlobsFlat({
+      prefix: options.prefix
+    }).byPage({
+      maxPageSize: limit,
+      continuationToken
+    });
+    const items = [];
+    const response = (await iterator.next()).value;
+    items.push(...response.segment.blobItems);
+    return {
+      items,
+      continuationToken: response.continuationToken
+    };
+  }
+  /**
+   * Retrieves a list of blob contents based on the provided options.
+   *
+   * @param {ListRequestOptions} options - The options for listing the blob contents.
+   * @return {Promise<{ contents: BlobItem[]; nextContinuationToken?: string }>} A promise that resolves to the list of blob contents and the next continuation token.
+   */
+  async listContents(options) {
+    var _a;
+    let responseContents = [];
+    let continuationToken = options.pagination;
+    const limit = (_a = options.limit) != null ? _a : 1e3;
+    let continueListing = true;
+    const containerClient = this.blobServiceClient.getContainerClient(
+      this.containerName
+    );
+    while (continueListing) {
+      const response = await this.listChunk(
+        options,
+        continuationToken,
+        limit - responseContents.length,
+        containerClient
+      );
+      continuationToken = response.continuationToken;
+      responseContents = responseContents.concat(response.items);
+      if (responseContents.length >= limit || !continuationToken) {
+        continueListing = false;
       }
+    }
+    return {
+      contents: responseContents,
+      nextContinuationToken: continuationToken
     };
   }
-});
+  /**
+   * Lists blobs in the Azure Blob Storage container with pagination.
+   * @param options - The options for listing blobs.
+   * @returns A promise that resolves to a paginated list of blob names.
+   */
+  async list(options) {
+    var _a;
+    let items = [];
+    const response = await this.listContents(options);
+    items = response.contents.length ? response.contents.map((blob) => {
+      return {
+        key: blob.name,
+        lastModified: blob.properties.lastModified,
+        size: blob.properties.contentLength,
+        eTag: blob.properties.etag
+      };
+    }) : [];
+    return {
+      items,
+      pagination: ((_a = response.nextContinuationToken) == null ? void 0 : _a.length) ? response.nextContinuationToken : null,
+      count: items.length
+    };
+  }
+  /**
+   * Lists all blobs in the Azure Blob Storage container.
+   * @param options - The options for listing blobs.
+   * @returns A promise that resolves to list of blob names.
+   */
+  async listAll(options) {
+    var _a, _b;
+    let allItems = [];
+    let pagination = void 0;
+    do {
+      const response = await this.list(__spreadProps(__spreadValues({}, options), {
+        pagination
+      }));
+      if ((_a = response.items) == null ? void 0 : _a.length)
+        allItems = [...allItems, ...response.items];
+      pagination = (_b = response.pagination) != null ? _b : void 0;
+    } while (pagination);
+    return { items: allItems, count: allItems.length };
+  }
+};
+
+// src/services/storage/s3/s3Helpers.ts
+function listResponseContentsToListResponseItems(responseContents) {
+  return responseContents.map((responseContent) => {
+    return {
+      key: responseContent.Key,
+      lastModified: new Date(responseContent.LastModified),
+      size: responseContent.Size,
+      eTag: responseContent.ETag
+    };
+  });
+}
+function s3ObjectToObjectResponse(s3Object) {
+  return {
+    body: s3Object.Body,
+    metadata: s3Object.Metadata,
+    contentType: s3Object.ContentType,
+    contentLength: s3Object.ContentLength,
+    contentEncoding: s3Object.ContentEncoding,
+    cacheControl: s3Object.CacheControl,
+    contentDisposition: s3Object.ContentDisposition,
+    contentLanguage: s3Object.ContentLanguage,
+    eTag: s3Object.ETag,
+    lastModified: s3Object.LastModified
+  };
+}
 
 // src/services/storage/s3/s3Storage.service.ts
-var s3Storage_service_exports = {};
-__export(s3Storage_service_exports, {
-  S3StorageService: () => S3StorageService
-});
-var S3StorageService;
-var init_s3Storage_service = __esm({
-  "src/services/storage/s3/s3Storage.service.ts"() {
-    S3StorageService = class {
-      constructor(bucketName) {
-        this.bucketName = bucketName;
-        this.s3Client = new clientS3.S3Client({});
-      }
-      /**
-       * Lists all objects in the S3 bucket.
-       * @returns A promise that resolves to a list of object keys.
-       */
-      async list() {
-        const allKeys = [];
-        let continuationToken = void 0;
-        do {
-          const command = new clientS3.ListObjectsV2Command({
-            Bucket: this.bucketName,
-            ContinuationToken: continuationToken
-          });
-          const response = await this.s3Client.send(command);
-          if (response.Contents) {
-            for (const item of response.Contents) {
-              if (item.Key)
-                allKeys.push(item.Key);
-            }
-          }
-          continuationToken = response.NextContinuationToken;
-        } while (continuationToken);
-        return { keys: allKeys };
-      }
-      /**
-       * Retrieves an object from the S3 bucket.
-       * @param key - The key of the object to retrieve.
-       * @returns A promise that resolves to the content of the file.
-       */
-      async getObject(key) {
-        var _a, _b;
-        const command = new clientS3.GetObjectCommand({
-          Bucket: this.bucketName,
-          Key: key
-        });
-        const response = await this.s3Client.send(command);
-        return {
-          body: response.Body,
-          metadata: (_a = response.Metadata) != null ? _a : {},
-          contentType: (_b = response.ContentType) != null ? _b : "",
-          contentLength: response.ContentLength
-        };
-      }
-      /**
-       * Generates a signed URL for accessing an object in the S3 bucket.
-       * @param key - The key of the object.
-       * @param expiresInMinutes - The number of minutes the signed URL should be valid for. Defaults to 60 minutes.
-       * @returns A promise that resolves to the signed URL.
-       */
-      getSignedUrl(key, expiresInMinutes = 60) {
-        const expiresIn = expiresInMinutes * 60;
-        const command = new clientS3.GetObjectCommand({
-          Bucket: this.bucketName,
-          Key: key
-        });
-        return s3RequestPresigner.getSignedUrl(this.s3Client, command, { expiresIn });
-      }
-      /**
-       * Uploads an object to the S3 bucket.
-       * @param key - The key of the object to upload.
-       * @param body - The content of the object to upload.
-       * @param metadata - Optional metadata to associate with the object.
-       * @returns A promise that resolves to the response containing the key of the uploaded object.
-       */
-      async upload(key, body, metadata) {
-        const command = new clientS3.PutObjectCommand({
-          Bucket: this.bucketName,
-          Key: key,
-          Body: body,
-          Metadata: metadata
-        });
-        await this.s3Client.send(command);
-        return { key };
-      }
-      /**
-       * Deletes an object from the S3 bucket.
-       * @param key - The key of the object to delete.
-       * @returns A promise that resolves to true if the object was deleted successfully.
-       */
-      async delete(key) {
-        const command = new clientS3.DeleteObjectCommand({
-          Bucket: this.bucketName,
-          Key: key
-        });
-        await this.s3Client.send(command);
-        return true;
+var S3StorageService = class {
+  constructor(bucketName) {
+    this.s3Client = new clientS3.S3Client({
+      region: process.env.AWS_REGION
+    });
+    this.bucketName = bucketName;
+  }
+  /**
+   * Retrieves a chunk of objects from the S3 bucket based on the provided options.
+   *
+   * @param {ListRequestOptions} options - The options for listing the objects.
+   * @param {string | undefined} continuationToken - The continuation token for pagination.
+   * @param {number} limit - The maximum number of objects to retrieve.
+   * @return {Promise<ListObjectsV2CommandOutput>} - A promise that resolves to the response containing the list of objects and metadata.
+   */
+  async listChunk(options, continuationToken, limit) {
+    const command = new clientS3.ListObjectsV2Command({
+      Bucket: this.bucketName,
+      ContinuationToken: continuationToken || options.pagination,
+      Prefix: options.prefix,
+      MaxKeys: limit
+    });
+    return this.s3Client.send(command);
+  }
+  /**
+   * Retrieves a list of contents from the S3 bucket based on the provided options.
+   *
+   * @param {ListRequestOptions} options - The options for listing the contents.
+   * @return {Promise<{ contents: unknown[]; nextContinuationToken?: string }>} - A promise that resolves to an object containing the list of contents and an optional next continuation token.
+   */
+  async listContents(options) {
+    var _a, _b;
+    let responseContents = [];
+    let continuationToken = void 0;
+    const limit = (_a = options.limit) != null ? _a : 1e3;
+    let continueListing = true;
+    while (continueListing) {
+      const listChunkLimit = limit - responseContents.length;
+      const response = await this.listChunk(
+        options,
+        continuationToken,
+        listChunkLimit
+      );
+      continuationToken = response.NextContinuationToken;
+      responseContents = responseContents.concat((_b = response.Contents) != null ? _b : []);
+      if (responseContents.length >= limit || !continuationToken) {
+        continueListing = false;
       }
+    }
+    return {
+      contents: responseContents,
+      nextContinuationToken: continuationToken
+    };
+  }
+  /**
+   * Lists objects in the S3 bucket with pagination.
+   * @param options - The options for listing objects.
+   * @returns A promise that resolves to a paginated list of object keys.
+   */
+  async list(options) {
+    var _a;
+    let items = [];
+    const response = await this.listContents(options);
+    items = response.contents.length ? listResponseContentsToListResponseItems(response.contents) : [];
+    return {
+      items,
+      pagination: (_a = response.nextContinuationToken) != null ? _a : null,
+      count: items.length
+    };
+  }
+  /**
+   * Lists all objects in the S3 bucket.
+   * @param options - The options for listing objects.
+   * @returns A promise that resolves to list of object keys.
+   */
+  async listAll(options) {
+    var _a;
+    let allItems = [];
+    let pagination = void 0;
+    do {
+      const response = await this.list(__spreadProps(__spreadValues({}, options), {
+        pagination
+      }));
+      if ((_a = response.items) == null ? void 0 : _a.length)
+        allItems = [...allItems, ...response.items];
+      pagination = response.pagination === null ? void 0 : response.pagination;
+    } while (pagination);
+    return { items: allItems, count: allItems.length };
+  }
+  /**
+   * Retrieves an object from the S3 bucket.
+   * @param key - The key of the object to retrieve.
+   * @returns A promise that resolves to the content of the file.
+   */
+  async getHeadObject(key) {
+    const command = new clientS3.HeadObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    });
+    const response = await this.s3Client.send(command);
+    return s3ObjectToObjectResponse(response);
+  }
+  /**
+   * Retrieves an object from the S3 bucket.
+   * @param key - The key of the object to retrieve.
+   * @returns A promise that resolves to the content of the file.
+   */
+  async getObject(key) {
+    const command = new clientS3.GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    });
+    const response = await this.s3Client.send(command);
+    return s3ObjectToObjectResponse(response);
+  }
+  /**
+   * Generates a signed URL for accessing an object in the S3 bucket.
+   * @param key - The key of the object.
+   * @param expiresInMinutes - The number of minutes the signed URL should be valid for. Defaults to 60 minutes.
+   * @returns A promise that resolves to the signed URL.
+   */
+  getDownloadUrl(key, expiresInMinutes = 60) {
+    const expiresIn = expiresInMinutes * 60;
+    const command = new clientS3.GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    });
+    return s3RequestPresigner.getSignedUrl(this.s3Client, command, { expiresIn });
+  }
+  /**
+   * Retrieves a signed URL for uploading an object to the S3 bucket.
+   *
+   * @param {string} key - The key of the object to be uploaded.
+   * @param {number} [expiresInMinutes=60] - The number of minutes the signed URL should be valid for. Defaults to 60 minutes.
+   * @returns A promise that resolves to the signed URL.
+   */
+  async getUploadUrl(key, expiresInMinutes = 60) {
+    const expiresIn = expiresInMinutes * 60;
+    const putObjectCommandParams = {
+      Bucket: process.env.UPLOAD_BUCKET_NAME,
+      Key: key,
+      ACL: "private"
+    };
+    const command = new clientS3.PutObjectCommand(putObjectCommandParams);
+    const signedUrl = await s3RequestPresigner.getSignedUrl(this.s3Client, command, {
+      expiresIn
+    });
+    return {
+      signedUrl,
+      key: `https://${process.env.UPLOAD_BUCKET_NAME}.s3.${process.env.AWS_DEFAULT_REGION}.amazonaws.com/${key}`
     };
   }
-});
+  /**
+   * Uploads an object to the S3 bucket.
+   * @param key - The key of the object to upload.
+   * @param body - The content of the object to upload.
+   * @param metadata - Optional metadata to associate with the object.
+   * @returns A promise that resolves to the response containing the key of the uploaded object.
+   */
+  async upload(key, body, metadata) {
+    const command = new clientS3.PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body,
+      Metadata: metadata
+    });
+    await this.s3Client.send(command);
+    return { key };
+  }
+  /**
+   * Deletes an object from the S3 bucket.
+   * @param key - The key of the object to delete.
+   * @returns A promise that resolves to true if the object was deleted successfully.
+   */
+  async delete(key) {
+    const command = new clientS3.DeleteObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    });
+    await this.s3Client.send(command);
+    return true;
+  }
+};
 
 // src/services/objectStorageFactory.service.ts
 var ObjectStorageFactory = class {
   static async instance(bucketName) {
     var _a;
     const isBlobStorageService = ((_a = process.env.OBJECT_STORAGE_SERVICE) == null ? void 0 : _a.toLowerCase()) === "azure_blob_storage";
-    let ObjectStorageService2;
     if (isBlobStorageService) {
-      const module = await Promise.resolve().then(() => (init_blobStorage_service(), blobStorage_service_exports));
-      ObjectStorageService2 = module.BlobStorageService;
+      return new BlobStorageService(bucketName);
     } else {
-      const module = await Promise.resolve().then(() => (init_s3Storage_service(), s3Storage_service_exports));
-      ObjectStorageService2 = module.S3StorageService;
+      return new S3StorageService(bucketName);
     }
-    return new ObjectStorageService2(bucketName);
   }
 };
 
@@ -259,26 +606,89 @@ var ObjectStorageService = class _ObjectStorageService {
       throw new Error("Bucket name not provided or not valid value");
     return ObjectStorageFactory.instance(bucketName);
   }
-  static async list(bucketName) {
+  /**
+   * Retrieves a list of 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.
+   * @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());
+    ).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.
+   * @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));
+  }
+  /**
+   * 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.
+   * @return {Promise<GetObjectResponse>} A promise that resolves to the retrieved object.
+   */
   static async getObject(key, bucketName) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
       bucketName
     ).then((instance) => instance.getObject(key));
   }
-  static async getSignedUrl(key, expiresInMinutes, bucketName) {
+  /**
+   * Retrieves a signed URL for the specified object in the object storage service.
+   *
+   * @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.
+   * @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));
+  }
+  /**
+   * Retrieves an upload URL for the specified object in the object storage service.
+   *
+   * @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.
+   * @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.getSignedUrl(key, expiresInMinutes));
+    ).then((instance) => instance.getUploadUrl(key, expiresInMinutes));
   }
+  /**
+   * Uploads a file to the object storage service.
+   *
+   * @param {string} key - The key of the object to upload.
+   * @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.
+   * @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));
   }
+  /**
+   * Deletes an object from the object storage service.
+   *
+   * @param {string} key - The key of the object to delete.
+   * @param {string} [bucketName] - The name of the bucket where the object is stored. If not provided, the default bucket name will be used.
+   * @return {Promise<boolean>} A promise that resolves to true if the object was successfully deleted, or false otherwise.
+   */
   static async delete(key, bucketName) {
     return _ObjectStorageService.getObjectStorageServiceInstance(
       bucketName