@hdriel/aws-utils 1.0.0

package/dist/index.js

@@ -0,0 +1,1631 @@
+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) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __pow = Math.pow;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+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/aws/iam.ts
+import { IAMClient, ListUsersCommand } from "@aws-sdk/client-iam";
+
+// src/aws/configuration.ts
+var _AWSConfigSharingUtil = class _AWSConfigSharingUtil {
+  constructor() {
+  }
+  static setConfig({
+    accessKeyId,
+    secretAccessKey,
+    endpoint,
+    region
+  }) {
+    _AWSConfigSharingUtil.accessKeyId = accessKeyId;
+    _AWSConfigSharingUtil.secretAccessKey = secretAccessKey;
+    _AWSConfigSharingUtil.endpoint = endpoint;
+    _AWSConfigSharingUtil.region = region;
+  }
+  static getConfig() {
+    return {
+      accessKeyId: _AWSConfigSharingUtil.accessKeyId,
+      secretAccessKey: _AWSConfigSharingUtil.secretAccessKey,
+      region: _AWSConfigSharingUtil.region,
+      endpoint: _AWSConfigSharingUtil.endpoint
+    };
+  }
+};
+__publicField(_AWSConfigSharingUtil, "accessKeyId");
+__publicField(_AWSConfigSharingUtil, "secretAccessKey");
+__publicField(_AWSConfigSharingUtil, "endpoint");
+__publicField(_AWSConfigSharingUtil, "region");
+var AWSConfigSharingUtil = _AWSConfigSharingUtil;
+
+// src/aws/iam.ts
+var IAMUtil = class {
+  constructor({
+    accessKeyId = AWSConfigSharingUtil.accessKeyId,
+    secretAccessKey = AWSConfigSharingUtil.secretAccessKey,
+    endpoint = AWSConfigSharingUtil.endpoint,
+    region = AWSConfigSharingUtil.region,
+    debug = false
+  } = {}) {
+    __publicField(this, "iam");
+    const credentials = { accessKeyId, secretAccessKey };
+    const options = __spreadValues(__spreadValues(__spreadValues({}, accessKeyId && secretAccessKey && { credentials }), endpoint && { endpoint }), region && { region });
+    if (debug) {
+      console.log("IAMUtil client options", options);
+    }
+    this.iam = new IAMClient(options);
+  }
+  get client() {
+    return this.iam;
+  }
+  getUserList() {
+    return __async(this, null, function* () {
+      const command = new ListUsersCommand({});
+      return this.iam.send(command);
+    });
+  }
+  listUsers(maxItems) {
+    return __async(this, null, function* () {
+      try {
+        const command = new ListUsersCommand({ MaxItems: maxItems });
+        const response = yield this.iam.send(command);
+        return response.Users;
+      } catch (error) {
+        console.error("Error listing IAM users:", error);
+        return null;
+      }
+    });
+  }
+};
+
+// src/aws/lambda.ts
+import { Lambda, InvocationType, InvokeCommand } from "@aws-sdk/client-lambda";
+
+// src/utils/logger.ts
+import { Logger } from "stack-trace-logger";
+var includeCloudWatchOptions = process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY && process.env.AWS_REGION && process.env.AWS_LOG_GROUP_NAME && process.env.AWS_LOG_STREAM_NAME;
+var _a;
+var logger = new Logger(__spreadValues({
+  serviceName: process.env.SERVICE_NAME || "SERVER",
+  loggingModeLevel: process.env.LOGGING_MODE,
+  lineTraceLevels: (_a = process.env.LOGGING_STACK_TRACE_LEVELS) == null ? void 0 : _a.split(","),
+  stackTraceLines: { error: 3, warn: 3, info: 1 },
+  tags: ["reqId?", "url?"],
+  runLocally: true
+}, includeCloudWatchOptions && {
+  transportCloudWatchOptions: {
+    awsAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    awsSecretKey: process.env.AWS_SECRET_ACCESS_KEY,
+    awsRegion: process.env.AWS_REGION,
+    logGroupName: process.env.AWS_LOG_GROUP_NAME,
+    logStreamName: process.env.AWS_LOG_STREAM_NAME,
+    retentionInDays: +process.env.AWS_LOG_RETENTION_IN_DAY
+  }
+}));
+
+// src/aws/lambda.ts
+var LambdaUtil = class {
+  constructor({
+    accessKeyId = AWSConfigSharingUtil.accessKeyId,
+    secretAccessKey = AWSConfigSharingUtil.secretAccessKey,
+    endpoint = AWSConfigSharingUtil.endpoint,
+    region = AWSConfigSharingUtil.region,
+    serviceFunctionName,
+    debug = false
+  }) {
+    __publicField(this, "lambda");
+    __publicField(this, "serviceFunctionName");
+    const credentials = { accessKeyId, secretAccessKey };
+    const options = __spreadValues(__spreadValues(__spreadValues({}, accessKeyId && secretAccessKey && { credentials }), endpoint && { endpoint }), region && { region });
+    if (debug) {
+      console.log("LambdaUtil client options", options);
+    }
+    this.serviceFunctionName = serviceFunctionName;
+    this.lambda = new Lambda(__spreadValues(__spreadValues(__spreadValues({}, credentials && { credentials }), endpoint && { endpoint }), region && { region }));
+  }
+  directInvoke(_0) {
+    return __async(this, arguments, function* ({
+      payload = {},
+      invocationType = InvocationType.Event
+    }) {
+      var _a2;
+      const Payload = JSON.stringify(payload);
+      try {
+        const command = new InvokeCommand({
+          FunctionName: this.serviceFunctionName,
+          Payload,
+          InvocationType: invocationType
+        });
+        const data = yield this.lambda.send(command);
+        if (invocationType === InvocationType.RequestResponse) {
+          logger.info(null, "directInvoke lambda function response", { FunctionName, data });
+        }
+        const status = (_a2 = data.StatusCode) != null ? _a2 : 200;
+        const result = data.Payload;
+        return status >= 200 && status < 300 ? result : Promise.reject(result);
+      } catch (err) {
+        logger.error(null, "failed to directInvoke lambda function", {
+          err,
+          Payload,
+          FunctionName
+        });
+        throw err;
+      }
+    });
+  }
+  runLambdaInDryRunMode(payload) {
+    return __async(this, null, function* () {
+      return this.directInvoke({
+        payload,
+        invocationType: InvocationType.DryRun
+      });
+    });
+  }
+  triggerLambdaEvent(payload) {
+    return __async(this, null, function* () {
+      return this.directInvoke({
+        payload,
+        invocationType: InvocationType.Event
+      });
+    });
+  }
+  runAndGetLambdaResponse(payload) {
+    return __async(this, null, function* () {
+      return this.directInvoke({
+        payload,
+        invocationType: InvocationType.RequestResponse
+      });
+    });
+  }
+};
+
+// src/aws/s3-bucket.ts
+import ms from "ms";
+import path from "pathe";
+import http from "http";
+import https from "https";
+import { pipeline } from "stream";
+import { promisify } from "util";
+import { Upload } from "@aws-sdk/lib-storage";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { NodeHttpHandler } from "@smithy/node-http-handler";
+import { Buffer as Buffer2 } from "buffer";
+import archiver from "archiver";
+import { Readable } from "stream";
+import {
+  CreateBucketCommand,
+  GetObjectCommand,
+  S3Client,
+  DeleteBucketCommand,
+  HeadBucketCommand,
+  PutPublicAccessBlockCommand,
+  PutBucketPolicyCommand,
+  ListBucketsCommand,
+  GetBucketPolicyCommand,
+  GetBucketVersioningCommand,
+  GetBucketEncryptionCommand,
+  GetPublicAccessBlockCommand,
+  GetBucketAclCommand,
+  PutObjectCommand,
+  HeadObjectCommand,
+  ListObjectsCommand,
+  PutObjectTaggingCommand,
+  GetObjectTaggingCommand,
+  DeleteObjectCommand,
+  ListObjectsV2Command,
+  DeleteObjectsCommand
+} from "@aws-sdk/client-s3";
+
+// src/utils/consts.ts
+var ACLs = /* @__PURE__ */ ((ACLs2) => {
+  ACLs2["private"] = "private";
+  ACLs2["publicRead"] = "public-read";
+  ACLs2["publicReadWrite"] = "public-read-write";
+  return ACLs2;
+})(ACLs || {});
+
+// src/utils/concurrency.ts
+import pLimit from "p-limit";
+var s3Limiter = pLimit(4);
+
+// src/aws/s3-bucket.ts
+import multer from "multer";
+import multerS3 from "multer-s3";
+import bytes from "bytes";
+var pump = promisify(pipeline);
+var parseRangeHeader = (range, contentLength, chunkSize) => {
+  if (!range || !range.startsWith("bytes=")) return null;
+  const rangeParts = range.replace("bytes=", "").split("-");
+  const start = parseInt(rangeParts[0], 10);
+  let end = parseInt(rangeParts[1], 10);
+  end = end || start + chunkSize - 1;
+  if (isNaN(start) || start < 0 || start >= contentLength) return null;
+  if (isNaN(end) || end < start || end >= contentLength) {
+    return [start, contentLength - 1];
+  }
+  return [start, Math.min(end, end)];
+};
+var S3BucketUtil = class _S3BucketUtil {
+  constructor({
+    logger: logger2,
+    bucket,
+    reqId,
+    accessKeyId = AWSConfigSharingUtil.accessKeyId,
+    secretAccessKey = AWSConfigSharingUtil.secretAccessKey,
+    endpoint = AWSConfigSharingUtil.endpoint,
+    region = AWSConfigSharingUtil.region,
+    s3ForcePathStyle = true,
+    maxUploadFileSizeRestriction = "10GB"
+  }) {
+    __publicField(this, "s3Client");
+    __publicField(this, "bucket");
+    __publicField(this, "endpoint");
+    __publicField(this, "region");
+    __publicField(this, "logger");
+    __publicField(this, "reqId");
+    __publicField(this, "maxUploadFileSizeRestriction");
+    const credentials = { accessKeyId, secretAccessKey };
+    const options = __spreadValues(__spreadValues(__spreadValues({}, accessKeyId && secretAccessKey && { credentials }), endpoint && { endpoint }), region && { region });
+    this.endpoint = endpoint;
+    this.region = region;
+    this.bucket = bucket;
+    this.logger = logger2;
+    this.reqId = reqId != null ? reqId : null;
+    this.maxUploadFileSizeRestriction = maxUploadFileSizeRestriction;
+    const s3ClientParams = __spreadProps(__spreadValues(__spreadValues({}, options), s3ForcePathStyle && { forcePathStyle: s3ForcePathStyle }), {
+      requestHandler: new NodeHttpHandler({
+        httpAgent: new http.Agent({ keepAlive: true, maxSockets: 300 }),
+        httpsAgent: new https.Agent({ keepAlive: true, maxSockets: 300 }),
+        connectionTimeout: 3e3,
+        socketTimeout: 3e4
+      })
+    });
+    this.s3Client = new S3Client(s3ClientParams);
+  }
+  get link() {
+    return this.endpoint === "http://localhost:4566" ? `${this.endpoint}/${this.bucket}/` : `https://s3.${this.region}.amazonaws.com/${this.bucket}/`;
+  }
+  execute(command, options) {
+    return __async(this, null, function* () {
+      return this.s3Client.send(command, options);
+    });
+  }
+  // ##### BUCKET BLOCK ##########################
+  getBucketList() {
+    return __async(this, arguments, function* (options = {}, includePublicAccess = false) {
+      const command = new ListBucketsCommand(options);
+      const response = yield this.execute(command);
+      const responseData = (response == null ? void 0 : response.Buckets) || null;
+      if (!responseData) return null;
+      if (includePublicAccess) {
+        yield Promise.allSettled(
+          responseData.map((data) => __async(this, null, function* () {
+            const result = yield this.execute(
+              new GetPublicAccessBlockCommand({ Bucket: data.Name })
+            );
+            data.PublicAccessBlockConfiguration = result.PublicAccessBlockConfiguration;
+          }))
+        );
+      }
+      return responseData;
+    });
+  }
+  isBucketExists() {
+    return __async(this, null, function* () {
+      var _a2, _b;
+      const bucketName = this.bucket;
+      try {
+        yield this.execute(new HeadBucketCommand({ Bucket: bucketName }));
+        return true;
+      } catch (err) {
+        if (err.name !== "NotFound" && ((_a2 = err.$metadata) == null ? void 0 : _a2.httpStatusCode) !== 404) {
+          (_b = this.logger) == null ? void 0 : _b.error(this.reqId, "Error checking bucket:", err);
+          throw err;
+        } else {
+          return false;
+        }
+      }
+    });
+  }
+  initAsPublicBucket() {
+    return __async(this, null, function* () {
+      var _a2, _b;
+      const bucketName = this.bucket;
+      const isExists = yield this.isBucketExists();
+      if (isExists) {
+        (_a2 = this.logger) == null ? void 0 : _a2.info(this.reqId, `Bucket already exists.`, { bucketName });
+        return;
+      }
+      const data = yield this.execute(new CreateBucketCommand({ Bucket: bucketName }));
+      CREATE_PUBLICK_ACCESS_BLOCK: {
+        const command = new PutPublicAccessBlockCommand({
+          Bucket: bucketName,
+          PublicAccessBlockConfiguration: {
+            BlockPublicAcls: false,
+            IgnorePublicAcls: false,
+            BlockPublicPolicy: false,
+            RestrictPublicBuckets: false
+          }
+        });
+        yield this.execute(command);
+      }
+      UPDATE_PUBLICK_ACCESS_POLICY: {
+        const policy = {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Sid: "PublicReadGetObject",
+              Effect: "Allow",
+              Principal: "*",
+              Action: "s3:GetObject",
+              Resource: `arn:aws:s3:::${bucketName}/*`
+            }
+          ]
+        };
+        const command = new PutBucketPolicyCommand({ Bucket: bucketName, Policy: JSON.stringify(policy) });
+        yield this.execute(command);
+      }
+      (_b = this.logger) == null ? void 0 : _b.info(this.reqId, `Public bucket created successfully.`, { bucketName });
+      return data;
+    });
+  }
+  initAsPrivateBucket(includeConstraintLocation) {
+    return __async(this, null, function* () {
+      var _a2, _b;
+      const bucketName = this.bucket;
+      const isExists = yield this.isBucketExists();
+      if (isExists) {
+        (_a2 = this.logger) == null ? void 0 : _a2.info(this.reqId, `Bucket already exists.`, { bucketName });
+        return;
+      }
+      const createParams = __spreadValues({
+        Bucket: bucketName
+      }, includeConstraintLocation && {
+        CreateBucketConfiguration: { LocationConstraint: this.region }
+      });
+      const data = yield this.execute(new CreateBucketCommand(createParams));
+      (_b = this.logger) == null ? void 0 : _b.info(this.reqId, `Private bucket created successfully.`, { bucketName });
+      return data;
+    });
+  }
+  initBucket() {
+    return __async(this, arguments, function* (acl = "private" /* private */, includeConstraintLocation = false) {
+      var _a2;
+      const bucketName = this.bucket;
+      const isExists = yield this.isBucketExists();
+      if (isExists) {
+        (_a2 = this.logger) == null ? void 0 : _a2.info(this.reqId, `Bucket already exists.`, { bucketName });
+        return;
+      }
+      const data = acl === "private" /* private */ ? yield this.initAsPrivateBucket(includeConstraintLocation) : yield this.initAsPublicBucket();
+      return data;
+    });
+  }
+  emptyBucket() {
+    return __async(this, null, function* () {
+      let ContinuationToken = void 0;
+      do {
+        const listResp = yield this.execute(
+          new ListObjectsV2Command({
+            Bucket: this.bucket,
+            ContinuationToken
+          })
+        );
+        if (listResp.Contents && listResp.Contents.length > 0) {
+          yield this.execute(
+            new DeleteObjectsCommand({
+              Bucket: this.bucket,
+              Delete: {
+                Objects: listResp.Contents.map((obj) => ({ Key: obj.Key }))
+              }
+            })
+          );
+        }
+        ContinuationToken = listResp.NextContinuationToken;
+      } while (ContinuationToken);
+    });
+  }
+  bucketInfo(options) {
+    return __async(this, null, function* () {
+      var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
+      const bucketName = this.bucket;
+      const info = {
+        name: bucketName,
+        region: this.region,
+        endpoint: this.endpoint,
+        exists: false
+      };
+      try {
+        try {
+          const headBucketResponse = yield this.execute(
+            new HeadBucketCommand(__spreadValues({ Bucket: bucketName }, options))
+          );
+          (_a2 = this.logger) == null ? void 0 : _a2.debug("bucketInfo", "HeadBucketCommandOutput", headBucketResponse);
+          info.exists = true;
+          info.bucketRegion = headBucketResponse.BucketRegion;
+          info.accessPointAlias = headBucketResponse.AccessPointAlias;
+        } catch (err) {
+          if (err.name === "NotFound" || ((_b = err.$metadata) == null ? void 0 : _b.httpStatusCode) === 404) {
+            return info;
+          }
+          throw err;
+        }
+        try {
+          const buckets = yield this.getBucketList({ Prefix: this.bucket, BucketRegion: this.region });
+          (_c = this.logger) == null ? void 0 : _c.debug("bucketInfo", "getBucketList", { buckets });
+          const bucket = buckets == null ? void 0 : buckets.find((b) => b.Name === bucketName);
+          if (bucket == null ? void 0 : bucket.CreationDate) {
+            info.creationDate = bucket.CreationDate;
+          }
+        } catch (error) {
+          (_d = this.logger) == null ? void 0 : _d.warn(this.reqId, "Failed to get bucket creation date", { bucketName, error });
+        }
+        try {
+          const aclResponse = yield this.execute(
+            new GetBucketAclCommand({ Bucket: bucketName })
+          );
+          (_e = this.logger) == null ? void 0 : _e.debug("bucketInfo", "GetBucketAclCommandOutput", aclResponse);
+          info.acl = (_f = aclResponse.Grants) == null ? void 0 : _f.map((grant) => {
+            var _a3;
+            return {
+              grantee: (_a3 = grant.Grantee) == null ? void 0 : _a3.Type,
+              permission: grant.Permission
+            };
+          });
+        } catch (error) {
+          (_g = this.logger) == null ? void 0 : _g.warn(this.reqId, "Failed to get bucket ACL", { bucketName, error });
+        }
+        try {
+          const publicAccessResponse = yield this.execute(
+            new GetPublicAccessBlockCommand({ Bucket: bucketName })
+          );
+          (_h = this.logger) == null ? void 0 : _h.debug("bucketInfo", "GetPublicAccessBlockCommandOutput", publicAccessResponse);
+          info.publicAccessBlock = publicAccessResponse.PublicAccessBlockConfiguration;
+        } catch (error) {
+          if (error.name !== "NoSuchPublicAccessBlockConfiguration") {
+            (_i = this.logger) == null ? void 0 : _i.warn(this.reqId, "Failed to get public access block", { bucketName, error });
+          }
+        }
+        try {
+          const policyResponse = yield this.execute(
+            new GetBucketPolicyCommand({ Bucket: bucketName })
+          );
+          (_j = this.logger) == null ? void 0 : _j.debug("bucketInfo", "GetBucketPolicyCommandOutput", policyResponse);
+          if (policyResponse.Policy) {
+            info.policy = JSON.parse(policyResponse.Policy);
+          }
+        } catch (error) {
+          if (error.name !== "NoSuchBucketPolicy") {
+            (_k = this.logger) == null ? void 0 : _k.warn(this.reqId, "Failed to get bucket policy", { bucketName, error });
+          }
+        }
+        try {
+          const versioningResponse = yield this.execute(
+            new GetBucketVersioningCommand({ Bucket: bucketName })
+          );
+          (_l = this.logger) == null ? void 0 : _l.debug("bucketInfo", "GetBucketVersioningCommandOutput", versioningResponse);
+          info.versioning = versioningResponse.Status || "Disabled";
+        } catch (error) {
+          (_m = this.logger) == null ? void 0 : _m.warn(this.reqId, "Failed to get bucket versioning", { bucketName, error });
+        }
+        try {
+          const encryptionResponse = yield this.execute(
+            new GetBucketEncryptionCommand({ Bucket: bucketName })
+          );
+          (_n = this.logger) == null ? void 0 : _n.debug("bucketInfo", "GetBucketEncryptionCommandOutput", encryptionResponse);
+          info.encryption = {
+            enabled: true,
+            type: (_r = (_q = (_p = (_o = encryptionResponse.ServerSideEncryptionConfiguration) == null ? void 0 : _o.Rules) == null ? void 0 : _p[0]) == null ? void 0 : _q.ApplyServerSideEncryptionByDefault) == null ? void 0 : _r.SSEAlgorithm
+          };
+        } catch (error) {
+          if (error.name === "ServerSideEncryptionConfigurationNotFoundError") {
+            info.encryption = { enabled: false };
+          } else {
+            (_s = this.logger) == null ? void 0 : _s.warn(this.reqId, "Failed to get bucket encryption", { bucketName, error });
+            info.encryption = { enabled: false };
+          }
+        }
+        (_t = this.logger) == null ? void 0 : _t.debug("bucketInfo", "bucket info response", info);
+        return info;
+      } catch (error) {
+        (_u = this.logger) == null ? void 0 : _u.error(this.reqId, "Failed to get bucket info", { bucketName, error });
+        throw error;
+      }
+    });
+  }
+  destroyBucket(forceDeleteAllFilesBeforeDestroyBucket = false) {
+    return __async(this, null, function* () {
+      var _a2;
+      const bucketName = this.bucket;
+      const isExists = yield this.isBucketExists();
+      if (!isExists) {
+        (_a2 = this.logger) == null ? void 0 : _a2.debug(this.reqId, `Bucket not exists.`, { bucketName });
+        return;
+      }
+      if (forceDeleteAllFilesBeforeDestroyBucket) {
+        yield this.emptyBucket();
+      }
+      const createParams = { Bucket: bucketName };
+      const data = yield this.execute(new DeleteBucketCommand(createParams));
+      return data;
+    });
+  }
+  // ##### DIRECTORY BLOCK ##########################
+  createDirectory(directoryPath) {
+    return __async(this, null, function* () {
+      let normalizedPath = decodeURIComponent((directoryPath == null ? void 0 : directoryPath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedPath) throw new Error("No directory path provided");
+      if (normalizedPath === "/") normalizedPath = "";
+      const command = new PutObjectCommand({ Bucket: this.bucket, Key: `${normalizedPath}/` });
+      const result = yield this.execute(command);
+      return result;
+    });
+  }
+  deleteDirectory(directoryPath) {
+    return __async(this, null, function* () {
+      var _a2, _b, _c, _d, _e, _f, _g;
+      let normalizedPath = decodeURIComponent((directoryPath == null ? void 0 : directoryPath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedPath) {
+        throw new Error("No directory path provided");
+      }
+      if (normalizedPath === "/") normalizedPath = "";
+      let totalDeletedCount = 0;
+      let ContinuationToken = void 0;
+      do {
+        const listResp = yield this.execute(
+          new ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: normalizedPath,
+            ContinuationToken
+          })
+        );
+        if (listResp.Contents && listResp.Contents.length > 0) {
+          const deleteResult = yield this.execute(
+            new DeleteObjectsCommand({
+              Bucket: this.bucket,
+              Delete: {
+                Objects: listResp.Contents.map((obj) => ({ Key: obj.Key })),
+                Quiet: false
+              }
+            })
+          );
+          totalDeletedCount += (_b = (_a2 = deleteResult.Deleted) == null ? void 0 : _a2.length) != null ? _b : 0;
+          if (deleteResult.Errors && deleteResult.Errors.length > 0) {
+            (_c = this.logger) == null ? void 0 : _c.warn(this.reqId, `Some objects failed to delete`, {
+              directoryPath: normalizedPath,
+              errors: deleteResult.Errors
+            });
+          }
+        }
+        ContinuationToken = listResp.NextContinuationToken;
+      } while (ContinuationToken);
+      if (totalDeletedCount === 0) {
+        const directoryExists = yield this.fileExists(normalizedPath);
+        if (!directoryExists) {
+          (_d = this.logger) == null ? void 0 : _d.debug(this.reqId, `Directory not found`, { directoryPath: normalizedPath });
+          return null;
+        }
+      }
+      try {
+        yield this.execute(
+          new DeleteObjectCommand({
+            Bucket: this.bucket,
+            Key: normalizedPath
+          })
+        );
+        totalDeletedCount++;
+      } catch (error) {
+        if (error.name !== "NotFound" && ((_e = error.$metadata) == null ? void 0 : _e.httpStatusCode) !== 404) {
+          (_f = this.logger) == null ? void 0 : _f.warn(this.reqId, `Failed to delete directory marker`, {
+            directoryPath: normalizedPath,
+            error
+          });
+        }
+      }
+      (_g = this.logger) == null ? void 0 : _g.info(this.reqId, `Directory deleted successfully`, {
+        directoryPath: normalizedPath,
+        deletedCount: totalDeletedCount
+      });
+      return {
+        Deleted: [{ Key: normalizedPath }],
+        $metadata: {}
+      };
+    });
+  }
+  directoryList(directoryPath) {
+    return __async(this, null, function* () {
+      let normalizedPath = decodeURIComponent((directoryPath == null ? void 0 : directoryPath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (directoryPath !== "/" && directoryPath !== "" && directoryPath !== void 0) normalizedPath += "/";
+      else normalizedPath = "";
+      const result = yield this.execute(
+        new ListObjectsV2Command({
+          Bucket: this.bucket,
+          Prefix: normalizedPath,
+          Delimiter: "/"
+        })
+      );
+      const directories = (result.CommonPrefixes || []).map((prefix) => prefix.Prefix).map((prefix) => {
+        const relativePath = prefix.replace(normalizedPath, "");
+        const dir = relativePath.replace(/\/$/, "");
+        return dir;
+      }).filter((dir) => dir);
+      const files = (result.Contents || []).filter((content) => {
+        var _a2;
+        return content.Key !== normalizedPath && !((_a2 = content.Key) == null ? void 0 : _a2.endsWith("/"));
+      }).map((content) => __spreadProps(__spreadValues({}, content), {
+        Name: content.Key.replace(normalizedPath, "") || content.Key,
+        LastModified: new Date(content.LastModified)
+      }));
+      return { directories, files };
+    });
+  }
+  /**
+   * Get all files recursively (example for search/indexing)
+   * @param directoryPath
+   */
+  directoryListRecursive(directoryPath) {
+    return __async(this, null, function* () {
+      let normalizedPath = decodeURIComponent((directoryPath == null ? void 0 : directoryPath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (directoryPath !== "/" && directoryPath !== "" && directoryPath !== void 0) normalizedPath += "/";
+      else normalizedPath = "";
+      const allDirectories = [];
+      const allFiles = [];
+      let ContinuationToken = void 0;
+      do {
+        const command = new ListObjectsV2Command({
+          Bucket: this.bucket,
+          Prefix: normalizedPath,
+          ContinuationToken
+        });
+        const result = yield this.execute(command);
+        if (result.Contents) {
+          for (const content of result.Contents) {
+            const fullPath = content.Key;
+            const relativePath = fullPath.replace(normalizedPath, "");
+            const filename = fullPath.split("/").pop();
+            if (fullPath.endsWith("/")) {
+              allDirectories.push(relativePath.slice(0, -1));
+            } else {
+              allFiles.push(__spreadProps(__spreadValues({}, content), {
+                Name: filename,
+                Path: fullPath,
+                LastModified: new Date(content.LastModified)
+              }));
+            }
+          }
+        }
+        ContinuationToken = result.NextContinuationToken;
+      } while (ContinuationToken);
+      return { directories: allDirectories, files: allFiles };
+    });
+  }
+  /**
+   * Get tree files recursively (example for build file explorer UI)
+   * @param directoryPath - the directory start from
+   * @example
+   * const tree = await s3Util.getDirectoryTree('uploads');
+   * // {
+   * //   name: 'uploads',
+   * //   path: 'uploads/',
+   * //   type: 'directory',
+   * //   children: [
+   * //     {
+   * //       name: 'logo.png',
+   * //       path: 'uploads/logo.png',
+   * //       type: 'file',
+   * //       size: 12345,
+   * //       lastModified: Date
+   * //     },
+   * //     {
+   * //       name: 'images',
+   * //       path: 'uploads/images/',
+   * //       type: 'directory',
+   * //       children: [
+   * //         { name: 'photo1.jpg', type: 'file', ... },
+   * //         { name: 'photo2.jpg', type: 'file', ... }
+   * //       ]
+   * //     }
+   * //   ]
+   * // }
+   */
+  directoryTree(directoryPath) {
+    return __async(this, null, function* () {
+      let normalizedPath = decodeURIComponent((directoryPath == null ? void 0 : directoryPath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      const lastDirectory = directoryPath == null ? void 0 : directoryPath.split("/").pop();
+      const { directories, files } = yield this.directoryList(normalizedPath);
+      if (directoryPath !== "/" && directoryPath !== "" && directoryPath !== void 0) normalizedPath += "/";
+      else normalizedPath = "";
+      const treeNode = {
+        path: "/" + normalizedPath,
+        name: lastDirectory || this.bucket,
+        type: "directory",
+        children: []
+      };
+      for (const file of files) {
+        treeNode.children.push({
+          path: "/" + file.Key,
+          name: file.Name,
+          type: "file",
+          size: file.Size,
+          lastModified: file.LastModified
+        });
+      }
+      for (const dir of directories) {
+        const subPath = treeNode.path + dir;
+        const subTree = yield this.directoryTree(subPath);
+        treeNode.children.push(subTree);
+      }
+      return treeNode;
+    });
+  }
+  // ##### FILES BLOCK ##########################
+  fileInfo(filePath) {
+    return __async(this, null, function* () {
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      const command = new HeadObjectCommand({ Bucket: this.bucket, Key: normalizedKey });
+      return yield this.execute(command);
+    });
+  }
+  fileListInfo(directoryPath, fileNamePrefix) {
+    return __async(this, null, function* () {
+      var _a2, _b;
+      let normalizedPath = decodeURIComponent((directoryPath == null ? void 0 : directoryPath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (directoryPath !== "/" && directoryPath !== "" && directoryPath !== void 0) normalizedPath += "/";
+      else normalizedPath = "";
+      const prefix = normalizedPath + (fileNamePrefix || "");
+      const command = new ListObjectsCommand({
+        Bucket: this.bucket,
+        Prefix: prefix,
+        Delimiter: "/"
+      });
+      const result = yield this.execute(command);
+      const files = ((_a2 = result.Contents) != null ? _a2 : []).filter((v) => v).map(
+        (content) => {
+          var _a3, _b2;
+          return __spreadProps(__spreadValues({}, content), {
+            Name: (_b2 = (_a3 = content.Key) == null ? void 0 : _a3.replace(prefix, "")) != null ? _b2 : content.Key,
+            LastModified: content.LastModified ? new Date(content.LastModified) : null
+          });
+        }
+      ).filter((content) => content.Name);
+      (_b = this.logger) == null ? void 0 : _b.debug(null, "file list info", { prefix, files });
+      return files;
+    });
+  }
+  taggingFile(filePath, tagVersion = "1.0.0") {
+    return __async(this, null, function* () {
+      try {
+        const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+        if (!normalizedKey || normalizedKey === "/") {
+          throw new Error("No file key provided");
+        }
+        const command = new PutObjectTaggingCommand({
+          Bucket: this.bucket,
+          Key: normalizedKey,
+          Tagging: { TagSet: [{ Key: "version", Value: tagVersion }] }
+        });
+        yield this.execute(command);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    });
+  }
+  fileVersion(filePath) {
+    return __async(this, null, function* () {
+      var _a2, _b;
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      const command = new GetObjectTaggingCommand({ Bucket: this.bucket, Key: normalizedKey });
+      const result = yield this.execute(command);
+      const tag = (_a2 = result.TagSet) == null ? void 0 : _a2.find((tag2) => tag2.Key === "version");
+      return (_b = tag == null ? void 0 : tag.Value) != null ? _b : "";
+    });
+  }
+  fileUrl(filePath, expiresIn = "15m") {
+    return __async(this, null, function* () {
+      var _a2;
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      const expiresInSeconds = typeof expiresIn === "number" ? expiresIn : ms(expiresIn) / 1e3;
+      const command = new GetObjectCommand({ Bucket: this.bucket, Key: normalizedKey });
+      const url = yield getSignedUrl(this.s3Client, command, {
+        expiresIn: expiresInSeconds
+        // is using 3600 it's will expire in 1 hour (default is 900 seconds = 15 minutes)
+      });
+      (_a2 = this.logger) == null ? void 0 : _a2.info(null, "generate signed file url", { url, filePath: normalizedKey, expiresIn });
+      return url;
+    });
+  }
+  sizeOf(filePath, unit = "bytes") {
+    return __async(this, null, function* () {
+      var _a2, _b, _c;
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      try {
+        const command = new HeadObjectCommand({ Bucket: this.bucket, Key: normalizedKey });
+        const headObject = yield this.execute(command);
+        const bytes2 = (_a2 = headObject.ContentLength) != null ? _a2 : 0;
+        switch (unit) {
+          case "KB":
+            return bytes2 / 1024;
+          case "MB":
+            return bytes2 / (1024 * 1024);
+          case "GB":
+            return bytes2 / (1024 * 1024 * 1024);
+          default:
+            return bytes2;
+        }
+      } catch (error) {
+        if (error.name === "NotFound" || ((_b = error.$metadata) == null ? void 0 : _b.httpStatusCode) === 404) {
+          (_c = this.logger) == null ? void 0 : _c.warn(this.reqId, "File not found", { filePath: normalizedKey });
+          return 0;
+        }
+        throw error;
+      }
+    });
+  }
+  fileExists(filePath) {
+    return __async(this, null, function* () {
+      var _a2;
+      try {
+        const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+        if (!normalizedKey || normalizedKey === "/") {
+          throw new Error("No file key provided");
+        }
+        const command = new HeadObjectCommand({ Bucket: this.bucket, Key: normalizedKey });
+        yield this.execute(command);
+        return true;
+      } catch (error) {
+        if (error.name === "NotFound" || ((_a2 = error.$metadata) == null ? void 0 : _a2.httpStatusCode) === 404) {
+          return false;
+        }
+        throw error;
+      }
+    });
+  }
+  fileContent(filePath, format = "buffer") {
+    return __async(this, null, function* () {
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      const command = new GetObjectCommand({ Bucket: this.bucket, Key: normalizedKey });
+      const result = yield this.execute(command);
+      if (!result.Body) {
+        throw new Error("File body is empty");
+      }
+      const stream = result.Body;
+      const chunks = [];
+      try {
+        for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+          const chunk = temp.value;
+          chunks.push(chunk);
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield temp.call(iter));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      const buffer = Buffer2.concat(chunks);
+      if (format === "base64" || format === "utf8") {
+        return buffer.toString(format);
+      }
+      return buffer;
+    });
+  }
+  uploadFile(_0, _1) {
+    return __async(this, arguments, function* (filePath, fileData, acl = "private" /* private */, version = "1.0.0") {
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      const upload = new Upload({
+        client: this.s3Client,
+        params: {
+          Bucket: this.bucket,
+          ACL: acl,
+          Key: normalizedKey,
+          Body: fileData,
+          Tagging: `version=${version}`
+        }
+      });
+      const result = yield upload.done();
+      return {
+        Bucket: this.bucket,
+        Key: normalizedKey,
+        Location: `https://${this.bucket}.s3.amazonaws.com/${normalizedKey}`,
+        test: `${this.link}/${normalizedKey}`,
+        ETag: result.ETag
+      };
+    });
+  }
+  deleteFile(filePath) {
+    return __async(this, null, function* () {
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      const command = new DeleteObjectCommand({ Bucket: this.bucket, Key: normalizedKey });
+      return yield this.execute(command);
+    });
+  }
+  // ##### STREAMING BLOCK ##########################
+  streamObjectFile(_0) {
+    return __async(this, arguments, function* (filePath, {
+      Range,
+      checkFileExists = true,
+      abortSignal
+    } = {}) {
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      if (checkFileExists) {
+        const isExists = yield this.fileExists(normalizedKey);
+        if (!isExists) return null;
+      }
+      const command = new GetObjectCommand(__spreadValues({
+        Bucket: this.bucket,
+        Key: normalizedKey
+      }, Range ? { Range } : {}));
+      const response = yield this.execute(command, { abortSignal });
+      if (!response.Body || !(response.Body instanceof Readable)) {
+        throw new Error("Invalid response body: not a Readable stream");
+      }
+      return response.Body;
+    });
+  }
+  streamVideoFile(_0) {
+    return __async(this, arguments, function* ({
+      filePath,
+      Range,
+      abortSignal
+    }) {
+      var _a2;
+      const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+      if (!normalizedKey || normalizedKey === "/") {
+        throw new Error("No file key provided");
+      }
+      try {
+        const cmd = new GetObjectCommand(__spreadValues({
+          Bucket: this.bucket,
+          Key: normalizedKey
+        }, Range ? { Range } : {}));
+        const data = yield s3Limiter(() => this.execute(cmd, { abortSignal }));
+        const body = data.Body;
+        if (!body) return null;
+        return {
+          body,
+          meta: {
+            contentType: data.ContentType,
+            contentLength: data.ContentLength,
+            contentRange: data.ContentRange,
+            acceptRanges: data.AcceptRanges,
+            etag: data.ETag,
+            lastModified: data.LastModified
+          }
+        };
+      } catch (error) {
+        (_a2 = this.logger) == null ? void 0 : _a2.warn(this.reqId, "getS3VideoStream error", {
+          Bucket: this.bucket,
+          filePath: normalizedKey,
+          Range,
+          error
+        });
+        return null;
+      }
+    });
+  }
+  getStreamZipFileCtr(_0) {
+    return __async(this, arguments, function* ({
+      filePath,
+      filename: _filename,
+      compressionLevel = 5
+    }) {
+      return (req, res, next) => __async(this, null, function* () {
+        var _a2, _b, _c, _d, _e;
+        const filePaths = [].concat(filePath).map((filePath2) => {
+          return decodeURIComponent((filePath2 == null ? void 0 : filePath2.replace(/^\//, "").replace(/\/$/, "")) || "");
+        }).filter((v) => v && v !== "/");
+        if (!filePaths.length) {
+          throw new Error("No file keys provided");
+        }
+        let filename = _filename || (/* @__PURE__ */ new Date()).toISOString();
+        filename = filename.endsWith(".zip") ? filename : `${filename}.zip`;
+        const abort = new AbortController();
+        const onClose = () => {
+          abort.abort();
+        };
+        req.once("close", onClose);
+        try {
+          (_a2 = this.logger) == null ? void 0 : _a2.info(this.reqId, "Starting parallel file download...", { fileCount: filePaths.length });
+          const downloadPromises = filePaths.map((filePath2) => __async(this, null, function* () {
+            var _a3, _b2, _c2;
+            try {
+              if (abort.signal.aborted) return null;
+              const stream = yield this.streamObjectFile(filePath2, { abortSignal: abort.signal });
+              if (!stream) {
+                (_a3 = this.logger) == null ? void 0 : _a3.warn(this.reqId, "File not found", { filePath: filePath2 });
+                return null;
+              }
+              const chunks = [];
+              try {
+                for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+                  const chunk = temp.value;
+                  if (abort.signal.aborted) {
+                    stream.destroy();
+                    return null;
+                  }
+                  chunks.push(Buffer2.from(chunk));
+                }
+              } catch (temp) {
+                error = [temp];
+              } finally {
+                try {
+                  more && (temp = iter.return) && (yield temp.call(iter));
+                } finally {
+                  if (error)
+                    throw error[0];
+                }
+              }
+              const buffer = Buffer2.concat(chunks);
+              const fileName = filePath2.split("/").pop() || filePath2;
+              (_b2 = this.logger) == null ? void 0 : _b2.debug(this.reqId, "File downloaded", {
+                filePath: filePath2,
+                sizeMB: (buffer.length / (1024 * 1024)).toFixed(2)
+              });
+              return { buffer, name: fileName, path: filePath2 };
+            } catch (error2) {
+              (_c2 = this.logger) == null ? void 0 : _c2.warn(this.reqId, "Failed to download file", { filePath: filePath2, error: error2 });
+              return null;
+            }
+          }));
+          const fileBuffers = (yield Promise.all(downloadPromises)).filter(Boolean);
+          if (abort.signal.aborted || fileBuffers.length === 0) {
+            req.off("close", onClose);
+            if (fileBuffers.length === 0) {
+              next(new Error("No files available to zip"));
+            }
+            return;
+          }
+          (_b = this.logger) == null ? void 0 : _b.info(this.reqId, "All files downloaded, measuring zip size...", {
+            fileCount: fileBuffers.length,
+            totalSizeMB: (fileBuffers.reduce((sum, f) => sum + f.buffer.length, 0) / (1024 * 1024)).toFixed(2)
+          });
+          const measureArchive = archiver("zip", { zlib: { level: compressionLevel } });
+          let actualZipSize = 0;
+          measureArchive.on("data", (chunk) => {
+            actualZipSize += chunk.length;
+          });
+          for (const file of fileBuffers) {
+            if (abort.signal.aborted) break;
+            measureArchive.append(file.buffer, { name: file.name });
+          }
+          yield measureArchive.finalize();
+          if (abort.signal.aborted) {
+            req.off("close", onClose);
+            return;
+          }
+          (_c = this.logger) == null ? void 0 : _c.info(this.reqId, "Zip size calculated", {
+            actualZipSize,
+            sizeMB: (actualZipSize / (1024 * 1024)).toFixed(2)
+          });
+          const actualArchive = archiver("zip", { zlib: { level: compressionLevel } });
+          res.setHeader("Content-Type", "application/zip");
+          res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+          res.setHeader("Content-Length", String(actualZipSize));
+          res.setHeader("Access-Control-Expose-Headers", "Content-Type, Content-Disposition, Content-Length");
+          actualArchive.on("error", (err) => {
+            var _a3;
+            (_a3 = this.logger) == null ? void 0 : _a3.error(this.reqId, "Archive error", { error: err });
+            abort.abort();
+            if (!res.headersSent) {
+              next(err);
+            }
+          });
+          actualArchive.pipe(res);
+          for (const file of fileBuffers) {
+            if (abort.signal.aborted) break;
+            actualArchive.append(file.buffer, { name: file.name });
+          }
+          yield actualArchive.finalize();
+          (_d = this.logger) == null ? void 0 : _d.info(this.reqId, "Zip download completed", {
+            fileCount: fileBuffers.length,
+            totalSize: actualZipSize
+          });
+          req.off("close", onClose);
+        } catch (error) {
+          abort.abort();
+          const isBenignError = (error == null ? void 0 : error.code) === "ERR_STREAM_PREMATURE_CLOSE" || (error == null ? void 0 : error.name) === "AbortError" || (error == null ? void 0 : error.code) === "ECONNRESET";
+          if (isBenignError) {
+            return;
+          }
+          if (!res.headersSent) {
+            (_e = this.logger) == null ? void 0 : _e.error(this.reqId, "Failed to create zip archive", { error });
+            next(error);
+          } else if (!res.writableEnded) {
+            try {
+              res.end();
+            } catch (e) {
+            }
+          }
+        } finally {
+          req.off("close", onClose);
+        }
+      });
+    });
+  }
+  getStreamFileCtrl(_0) {
+    return __async(this, arguments, function* ({ filePath, filename }) {
+      return (req, res, next) => __async(this, null, function* () {
+        var _a2, _b;
+        const abort = new AbortController();
+        let stream = null;
+        const onClose = () => {
+          var _a3;
+          abort.abort();
+          (_a3 = stream == null ? void 0 : stream.destroy) == null ? void 0 : _a3.call(stream);
+        };
+        req.once("close", onClose);
+        const normalizedKey = decodeURIComponent((filePath == null ? void 0 : filePath.replace(/^\//, "").replace(/\/$/, "")) || "");
+        if (!normalizedKey || normalizedKey === "/") {
+          throw new Error("No file key provided");
+        }
+        try {
+          const isExists = yield this.fileExists(normalizedKey);
+          if (!isExists) {
+            req.off("close", onClose);
+            next(Error(`File not found: "${normalizedKey}"`));
+            return;
+          }
+          stream = yield this.streamObjectFile(normalizedKey, {
+            abortSignal: abort.signal,
+            checkFileExists: false
+          });
+          if (!stream) {
+            req.off("close", onClose);
+            next(Error(`Failed to get file stream: "${normalizedKey}"`));
+            return;
+          }
+          const fileInfo = yield this.fileInfo(normalizedKey);
+          const fileName = filename || normalizedKey.split("/").pop() || "download";
+          res.setHeader("Content-Type", fileInfo.ContentType || "application/octet-stream");
+          res.setHeader("Content-Disposition", `attachment; filename="${fileName}"`);
+          if (fileInfo.ContentLength) {
+            res.setHeader("Content-Length", String(fileInfo.ContentLength));
+          }
+          stream.on("error", (err) => {
+            var _a3, _b2;
+            (_a3 = this.logger) == null ? void 0 : _a3.warn(this.reqId, "Stream error", { filePath: normalizedKey, error: err });
+            abort.abort();
+            (_b2 = stream == null ? void 0 : stream.destroy) == null ? void 0 : _b2.call(stream);
+          });
+          res.once("close", () => {
+            var _a3;
+            (_a3 = stream == null ? void 0 : stream.destroy) == null ? void 0 : _a3.call(stream);
+            req.off("close", onClose);
+          });
+          yield pump(stream, res);
+          req.off("close", onClose);
+        } catch (error) {
+          abort.abort();
+          if (stream) {
+            (_a2 = stream.destroy) == null ? void 0 : _a2.call(stream);
+          }
+          const isBenignStreamError = (error == null ? void 0 : error.code) === "ERR_STREAM_PREMATURE_CLOSE" || (error == null ? void 0 : error.name) === "AbortError" || (error == null ? void 0 : error.code) === "ECONNRESET";
+          if (isBenignStreamError) {
+            return;
+          }
+          (_b = this.logger) == null ? void 0 : _b.error(this.reqId, "Failed to stream file", { filePath: normalizedKey, error });
+          if (!res.headersSent) {
+            next(error);
+          } else if (!res.writableEnded) {
+            try {
+              res.end();
+            } catch (e) {
+            }
+          }
+        } finally {
+          req.off("close", onClose);
+        }
+      });
+    });
+  }
+  getStreamVideoFileCtrl(_0) {
+    return __async(this, arguments, function* ({
+      fileKey,
+      allowedWhitelist,
+      contentType = "video/mp4",
+      streamTimeoutMS = 3e4,
+      bufferMB = 5
+    }) {
+      return (req, res, next) => __async(this, null, function* () {
+        var _a2, _b, _c, _d, _e, _f;
+        const normalizedKey = decodeURIComponent((fileKey == null ? void 0 : fileKey.replace(/^\//, "").replace(/\/$/, "")) || "");
+        if (!normalizedKey || normalizedKey === "/") {
+          throw new Error("No file key provided");
+        }
+        const isExists = yield this.fileExists(normalizedKey);
+        const fileSize = yield this.sizeOf(normalizedKey);
+        let Range;
+        if (!isExists) {
+          next(Error(`File does not exist: "${normalizedKey}"`));
+          return;
+        }
+        try {
+          if (req.method === "HEAD") {
+            res.setHeader("Content-Type", contentType);
+            res.setHeader("Accept-Ranges", "bytes");
+            if (fileSize) res.setHeader("Content-Length", String(fileSize));
+            return res.status(200).end();
+          }
+          const bufferSize = bufferMB;
+          const CHUNK_SIZE = __pow(10, 6) * bufferSize;
+          const rangeValues = parseRangeHeader(req.headers.range, fileSize, CHUNK_SIZE);
+          let [start, end] = rangeValues || [];
+          if (!rangeValues || start < 0 || start >= fileSize || end < 0 || end >= fileSize || start > end) {
+            res.status(416).send("Requested Range Not Satisfiable");
+            return;
+          }
+          res.statusCode = 206;
+          const chunkLength = end - start + 1;
+          res.setHeader("Content-Length", chunkLength);
+          res.setHeader("Content-Range", `bytes ${start}-${end}/${fileSize}`);
+          res.setHeader("Accept-Ranges", "bytes");
+          res.setHeader("Content-Type", "video/mp4");
+          Range = `bytes=${start}-${end}`;
+        } catch (error) {
+          next(error);
+          return;
+        }
+        const abort = new AbortController();
+        const onClose = () => abort.abort();
+        req.once("close", onClose);
+        try {
+          const result = yield this.streamVideoFile({
+            filePath: normalizedKey,
+            Range,
+            abortSignal: abort.signal
+          });
+          const { body, meta } = result;
+          const origin = Array.isArray(allowedWhitelist) ? allowedWhitelist.includes((_a2 = req.headers.origin) != null ? _a2 : "") ? req.headers.origin : void 0 : allowedWhitelist;
+          if (origin) {
+            res.setHeader("Access-Control-Allow-Origin", origin);
+            res.setHeader("Vary", "Origin");
+          }
+          const finalContentType = contentType.startsWith("video/") ? contentType : `video/${contentType}`;
+          res.setHeader("Content-Type", (_b = meta.contentType) != null ? _b : finalContentType);
+          res.setHeader("Accept-Ranges", (_c = meta.acceptRanges) != null ? _c : "bytes");
+          if (Range && meta.contentRange) {
+            res.status(206);
+            res.setHeader("Content-Range", meta.contentRange);
+            if (typeof meta.contentLength === "number") {
+              res.setHeader("Content-Length", String(meta.contentLength));
+            }
+          } else if (fileSize) {
+            res.setHeader("Content-Length", String(fileSize));
+          }
+          if (meta.etag) res.setHeader("ETag", meta.etag);
+          if (meta.lastModified) res.setHeader("Last-Modified", meta.lastModified.toUTCString());
+          const timeout = setTimeout(() => {
+            abort.abort();
+            if (!res.headersSent) res.status(504);
+            res.end();
+          }, streamTimeoutMS);
+          res.once("close", () => {
+            var _a3;
+            clearTimeout(timeout);
+            (_a3 = body.destroy) == null ? void 0 : _a3.call(body);
+            req.off("close", onClose);
+          });
+          yield pump(body, res);
+          clearTimeout(timeout);
+        } catch (error) {
+          const isBenignStreamError = (error == null ? void 0 : error.code) === "ERR_STREAM_PREMATURE_CLOSE" || (error == null ? void 0 : error.name) === "AbortError" || (error == null ? void 0 : error.code) === "ECONNRESET";
+          if (isBenignStreamError) {
+            return;
+          }
+          if (!res.headersSent) {
+            (_f = this.logger) == null ? void 0 : _f.warn(req.id, "caught exception in stream controller", {
+              error: (_d = error == null ? void 0 : error.message) != null ? _d : String(error),
+              key: fileKey,
+              url: req.originalUrl,
+              userId: (_e = req.user) == null ? void 0 : _e._id
+            });
+            next(error);
+            return;
+          }
+          if (!res.writableEnded) {
+            try {
+              res.end();
+            } catch (e) {
+            }
+          }
+          return;
+        }
+      });
+    });
+  }
+  static fileFilter(types, fileExt) {
+    const fileTypesChecker = (fileExt == null ? void 0 : fileExt.length) ? new RegExp(`\\.(${fileExt.join("|")})$`, "i") : void 0;
+    return function(_req, file, cb) {
+      const fileExtension = path.extname(file.originalname).substring(1);
+      const extname = fileTypesChecker ? fileTypesChecker.test(`.${fileExtension}`) : true;
+      const mimeType = (types == null ? void 0 : types.length) ? types.some((type) => file.mimetype.startsWith(`${type}/`)) : true;
+      if (mimeType && extname) {
+        return cb(null, true);
+      }
+      const errorMsg = !extname ? `Upload File Ext Error: Allowed extensions: [${fileExt == null ? void 0 : fileExt.join(", ")}]. Got: ${fileExtension}` : `Upload File Type Error: Allowed types: [${types == null ? void 0 : types.join(", ")}]. Got: ${file.mimetype}`;
+      return cb(new Error(errorMsg));
+    };
+  }
+  getFileSize(maxFileSize) {
+    var _a2;
+    const fileSizeUnitValue = maxFileSize != null ? maxFileSize : this.maxUploadFileSizeRestriction;
+    const fileSize = typeof fileSizeUnitValue === "number" ? fileSizeUnitValue : bytes(fileSizeUnitValue);
+    if (!fileSize) {
+      (_a2 = this.logger) == null ? void 0 : _a2.warn(this.reqId, "Failed to convert fileSize restriction, proceeding without limit", {
+        maxFileSize,
+        maxUploadFileSizeRestriction: this.maxUploadFileSizeRestriction
+      });
+      return void 0;
+    }
+    return fileSize;
+  }
+  getUploadFileMW(directory, {
+    acl = "private" /* private */,
+    maxFileSize,
+    filename: _filename,
+    fileType = [],
+    fileExt = [],
+    metadata: customMetadata
+  } = {}) {
+    let normalizedPath = decodeURIComponent((directory == null ? void 0 : directory.replace(/^\//, "").replace(/\/$/, "")) || "");
+    if (directory !== "/" && directory !== "" && directory !== void 0) normalizedPath += "/";
+    else normalizedPath = "";
+    const fileSize = this.getFileSize(maxFileSize);
+    const fileTypes = [].concat(fileType);
+    const fileExts = [].concat(fileExt);
+    const fileFilter = (fileTypes == null ? void 0 : fileTypes.length) || (fileExts == null ? void 0 : fileExts.length) ? _S3BucketUtil.fileFilter(fileTypes, fileExts) : void 0;
+    return multer({
+      fileFilter,
+      limits: __spreadValues({}, fileSize && { fileSize }),
+      storage: multerS3({
+        acl,
+        s3: this.s3Client,
+        bucket: this.bucket,
+        contentType: multerS3.AUTO_CONTENT_TYPE,
+        metadata: (req, file, cb) => __async(this, null, function* () {
+          const baseMetadata = __spreadProps(__spreadValues({}, file), { directory: normalizedPath });
+          if (customMetadata) {
+            const additionalMetadata = typeof customMetadata === "function" ? yield customMetadata(req, file) : customMetadata;
+            Object.assign(baseMetadata, additionalMetadata);
+          }
+          cb(null, baseMetadata);
+        }),
+        key: (req, file, cb) => __async(this, null, function* () {
+          let filename;
+          if (typeof _filename === "function") {
+            filename = yield _filename(req, file);
+          } else if (_filename) {
+            filename = _filename;
+          } else {
+            filename = file.originalname;
+          }
+          filename = decodeURIComponent(filename);
+          const key = `${normalizedPath}${filename}`;
+          cb(null, key);
+        })
+      })
+    });
+  }
+  /**
+   * Middleware for uploading a single file
+   * Adds the uploaded file info to req.s3File
+   */
+  uploadSingleFile(fieldName, directory, options = {}) {
+    const upload = this.getUploadFileMW(directory, options);
+    return (req, res, next) => {
+      const mw = upload.single(fieldName);
+      mw(req, res, (err) => {
+        var _a2, _b;
+        if (err) {
+          (_a2 = this.logger) == null ? void 0 : _a2.error(this.reqId, "Single file upload error", { fieldName, error: err.message });
+          return next(err);
+        }
+        if (req.file) {
+          req.s3File = req.file;
+          (_b = this.logger) == null ? void 0 : _b.info(this.reqId, "Single file uploaded successfully", {
+            fieldName,
+            key: req.s3File.key,
+            location: req.s3File.location,
+            size: req.s3File.size
+          });
+        }
+        next();
+      });
+    };
+  }
+  /**
+   * Middleware for uploading multiple files with the same field name
+   * Adds the uploaded files info to req.s3Files
+   */
+  uploadMultipleFiles(fieldName, directory, options = {}) {
+    const upload = this.getUploadFileMW(directory, options);
+    return (req, res, next) => {
+      const mw = upload.array(fieldName, options.maxFilesCount || void 0);
+      mw(req, res, (err) => {
+        var _a2, _b;
+        if (err) {
+          (_a2 = this.logger) == null ? void 0 : _a2.error(this.reqId, "Multiple files upload error", { fieldName, error: err.message });
+          return next(err);
+        }
+        if (Array.isArray(req.files)) {
+          req.s3Files = req.files;
+          (_b = this.logger) == null ? void 0 : _b.info(this.reqId, "Multiple files uploaded successfully", {
+            fieldName,
+            count: req.s3Files.length,
+            keys: req.s3Files.map((f) => f.key)
+          });
+        }
+        next();
+      });
+    };
+  }
+  /**
+   * Middleware for uploading multiple files with different field names
+   * Adds the uploaded files info to req.s3FilesByField
+   */
+  uploadFieldsFiles(fields) {
+    const fieldConfigs = fields.map((field) => {
+      const upload = this.getUploadFileMW(field.directory, field.options || {});
+      return {
+        name: field.name,
+        maxCount: field.maxCount || 1,
+        upload,
+        directory: field.directory
+      };
+    });
+    return (req, res, next) => __async(this, null, function* () {
+      const multerFields = fieldConfigs.map((f) => ({ name: f.name, maxCount: f.maxCount }));
+      const upload = this.getUploadFileMW(fieldConfigs[0].directory);
+      const mw = upload.fields(multerFields);
+      mw(req, res, (err) => {
+        var _a2, _b;
+        if (err) {
+          (_a2 = this.logger) == null ? void 0 : _a2.error(this.reqId, "Fields upload error", { error: err.message });
+          return next(err);
+        }
+        if (req.files && typeof req.files === "object" && !Array.isArray(req.files)) {
+          req.s3FilesByField = req.files;
+          const uploadSummary = Object.entries(req.s3FilesByField).map(([field, files]) => ({
+            field,
+            count: files.length,
+            keys: files.map((f) => f.key)
+          }));
+          (_b = this.logger) == null ? void 0 : _b.info(this.reqId, "Fields uploaded successfully", { uploadSummary });
+        }
+        next();
+      });
+    });
+  }
+  /**
+   * Middleware for uploading any files (mixed field names)
+   * Adds the uploaded files info to req.s3AllFiles
+   */
+  uploadAnyFiles(directory, maxCount, options = {}) {
+    const upload = this.getUploadFileMW(directory, options);
+    return (req, res, next) => {
+      const anyUpload = maxCount ? upload.any() : upload.any();
+      anyUpload(req, res, (err) => {
+        var _a2, _b;
+        if (err) {
+          (_a2 = this.logger) == null ? void 0 : _a2.error(this.reqId, "Any files upload error", { error: err.message });
+          return next(err);
+        }
+        if (req.files && Array.isArray(req.files)) {
+          req.s3AllFiles = req.files;
+          if (maxCount && req.s3AllFiles.length > maxCount) {
+            return next(new Error(`Too many files uploaded. Maximum is ${maxCount}`));
+          }
+          (_b = this.logger) == null ? void 0 : _b.info(this.reqId, "Any files uploaded successfully", {
+            count: req.s3AllFiles.length,
+            keys: req.s3AllFiles.map((f) => f.key)
+          });
+        }
+        next();
+      });
+    };
+  }
+};
+
+// src/aws/sns.ts
+import { SNS } from "@aws-sdk/client-sns";
+var SNSUtil = class {
+  constructor({
+    accessKeyId = AWSConfigSharingUtil.accessKeyId,
+    secretAccessKey = AWSConfigSharingUtil.secretAccessKey,
+    endpoint = AWSConfigSharingUtil.endpoint,
+    region = AWSConfigSharingUtil.region,
+    topicArn,
+    debug = false
+  }) {
+    __publicField(this, "sns");
+    __publicField(this, "topicArn");
+    const credentials = { accessKeyId, secretAccessKey };
+    const options = __spreadValues(__spreadValues(__spreadValues({}, accessKeyId && secretAccessKey && { credentials }), endpoint && { endpoint }), region && { region });
+    if (debug) {
+      console.log("LambdaUtil client options", options);
+    }
+    this.topicArn = topicArn;
+    this.sns = new SNS(__spreadValues(__spreadValues(__spreadValues({}, credentials && { credentials }), endpoint && { endpoint }), region && { region }));
+  }
+  publishTopicMessage(message) {
+    return __async(this, null, function* () {
+      this.sns.publish({
+        Message: typeof message === "string" ? message : JSON.stringify(message),
+        TopicArn: this.topicArn
+      });
+    });
+  }
+};
+export {
+  ACLs,
+  AWSConfigSharingUtil,
+  IAMUtil,
+  LambdaUtil,
+  S3BucketUtil,
+  SNSUtil
+};