@qrvey/object-storage 0.0.10 → 0.0.11-beta

package/dist/cjs/index.js

@@ -5,6 +5,8 @@ var storageBlob = require('@azure/storage-blob');
 var clientS3 = require('@aws-sdk/client-s3');
 var s3RequestPresigner = require('@aws-sdk/s3-request-presigner');
 var libStorage = require('@aws-sdk/lib-storage');
+var http = require('http');
+var https = require('https');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -631,12 +633,392 @@ function s3ObjectToObjectResponse(s3Object) {
     lastModified: s3Object.LastModified
   };
 }
+
+// ../../node_modules/@smithy/types/dist-es/auth/auth.js
+var HttpAuthLocation;
+(function(HttpAuthLocation2) {
+  HttpAuthLocation2["HEADER"] = "header";
+  HttpAuthLocation2["QUERY"] = "query";
+})(HttpAuthLocation || (HttpAuthLocation = {}));
+
+// ../../node_modules/@smithy/types/dist-es/auth/HttpApiKeyAuth.js
+var HttpApiKeyAuthLocation;
+(function(HttpApiKeyAuthLocation2) {
+  HttpApiKeyAuthLocation2["HEADER"] = "header";
+  HttpApiKeyAuthLocation2["QUERY"] = "query";
+})(HttpApiKeyAuthLocation || (HttpApiKeyAuthLocation = {}));
+
+// ../../node_modules/@smithy/types/dist-es/endpoint.js
+var EndpointURLScheme;
+(function(EndpointURLScheme2) {
+  EndpointURLScheme2["HTTP"] = "http";
+  EndpointURLScheme2["HTTPS"] = "https";
+})(EndpointURLScheme || (EndpointURLScheme = {}));
+
+// ../../node_modules/@smithy/types/dist-es/extensions/checksum.js
+var AlgorithmId;
+(function(AlgorithmId2) {
+  AlgorithmId2["MD5"] = "md5";
+  AlgorithmId2["CRC32"] = "crc32";
+  AlgorithmId2["CRC32C"] = "crc32c";
+  AlgorithmId2["SHA1"] = "sha1";
+  AlgorithmId2["SHA256"] = "sha256";
+})(AlgorithmId || (AlgorithmId = {}));
+
+// ../../node_modules/@smithy/types/dist-es/http.js
+var FieldPosition;
+(function(FieldPosition2) {
+  FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER";
+  FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER";
+})(FieldPosition || (FieldPosition = {}));
+
+// ../../node_modules/@smithy/types/dist-es/profile.js
+var IniSectionType;
+(function(IniSectionType2) {
+  IniSectionType2["PROFILE"] = "profile";
+  IniSectionType2["SSO_SESSION"] = "sso-session";
+  IniSectionType2["SERVICES"] = "services";
+})(IniSectionType || (IniSectionType = {}));
+
+// ../../node_modules/@smithy/types/dist-es/transfer.js
+var RequestHandlerProtocol;
+(function(RequestHandlerProtocol2) {
+  RequestHandlerProtocol2["HTTP_0_9"] = "http/0.9";
+  RequestHandlerProtocol2["HTTP_1_0"] = "http/1.0";
+  RequestHandlerProtocol2["TDS_8_0"] = "tds/8.0";
+})(RequestHandlerProtocol || (RequestHandlerProtocol = {}));
+
+// ../../node_modules/@smithy/protocol-http/dist-es/httpResponse.js
+var HttpResponse = class {
+  constructor(options) {
+    this.statusCode = options.statusCode;
+    this.reason = options.reason;
+    this.headers = options.headers || {};
+    this.body = options.body;
+  }
+  static isInstance(response) {
+    if (!response)
+      return false;
+    const resp = response;
+    return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+  }
+};
+
+// ../../node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js
+var escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
+var hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+
+// ../../node_modules/@smithy/querystring-builder/dist-es/index.js
+function buildQueryString(query) {
+  const parts = [];
+  for (let key of Object.keys(query).sort()) {
+    const value = query[key];
+    key = escapeUri(key);
+    if (Array.isArray(value)) {
+      for (let i = 0, iLen = value.length; i < iLen; i++) {
+        parts.push(`${key}=${escapeUri(value[i])}`);
+      }
+    } else {
+      let qsEntry = key;
+      if (value || typeof value === "string") {
+        qsEntry += `=${escapeUri(value)}`;
+      }
+      parts.push(qsEntry);
+    }
+  }
+  return parts.join("&");
+}
+
+// ../../node_modules/@smithy/node-http-handler/dist-es/constants.js
+var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
+
+// ../../node_modules/@smithy/node-http-handler/dist-es/get-transformed-headers.js
+var getTransformedHeaders = (headers) => {
+  const transformedHeaders = {};
+  for (const name of Object.keys(headers)) {
+    const headerValues = headers[name];
+    transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
+  }
+  return transformedHeaders;
+};
+
+// ../../node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
+var setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
+  if (!timeoutInMs) {
+    return;
+  }
+  const timeoutId = setTimeout(() => {
+    request.destroy();
+    reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
+      name: "TimeoutError"
+    }));
+  }, timeoutInMs);
+  request.on("socket", (socket) => {
+    if (socket.connecting) {
+      socket.on("connect", () => {
+        clearTimeout(timeoutId);
+      });
+    } else {
+      clearTimeout(timeoutId);
+    }
+  });
+};
+
+// ../../node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js
+var setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }) => {
+  if (keepAlive !== true) {
+    return;
+  }
+  request.on("socket", (socket) => {
+    socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+  });
+};
+
+// ../../node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js
+var setSocketTimeout = (request, reject, timeoutInMs = 0) => {
+  request.setTimeout(timeoutInMs, () => {
+    request.destroy();
+    reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
+  });
+};
+var MIN_WAIT_TIME = 1e3;
+async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
+  var _a;
+  const headers = (_a = request.headers) != null ? _a : {};
+  const expect = headers["Expect"] || headers["expect"];
+  let timeoutId = -1;
+  let hasError = false;
+  if (expect === "100-continue") {
+    await Promise.race([
+      new Promise((resolve) => {
+        timeoutId = Number(setTimeout(resolve, Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+      }),
+      new Promise((resolve) => {
+        httpRequest.on("continue", () => {
+          clearTimeout(timeoutId);
+          resolve();
+        });
+        httpRequest.on("error", () => {
+          hasError = true;
+          clearTimeout(timeoutId);
+          resolve();
+        });
+      })
+    ]);
+  }
+  if (!hasError) {
+    writeBody(httpRequest, request.body);
+  }
+}
+function writeBody(httpRequest, body) {
+  if (body instanceof stream.Readable) {
+    body.pipe(httpRequest);
+    return;
+  }
+  if (body) {
+    if (Buffer.isBuffer(body) || typeof body === "string") {
+      httpRequest.end(body);
+      return;
+    }
+    const uint8 = body;
+    if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
+      httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
+      return;
+    }
+    httpRequest.end(Buffer.from(body));
+    return;
+  }
+  httpRequest.end();
+}
+
+// ../../node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
+var NodeHttpHandler = class _NodeHttpHandler {
+  static create(instanceOrOptions) {
+    if (typeof (instanceOrOptions == null ? void 0 : instanceOrOptions.handle) === "function") {
+      return instanceOrOptions;
+    }
+    return new _NodeHttpHandler(instanceOrOptions);
+  }
+  static checkSocketUsage(agent, socketWarningTimestamp) {
+    var _a, _b, _c, _d;
+    const { sockets, requests, maxSockets } = agent;
+    if (typeof maxSockets !== "number" || maxSockets === Infinity) {
+      return socketWarningTimestamp;
+    }
+    const interval = 15e3;
+    if (Date.now() - interval < socketWarningTimestamp) {
+      return socketWarningTimestamp;
+    }
+    if (sockets && requests) {
+      for (const origin in sockets) {
+        const socketsInUse = (_b = (_a = sockets[origin]) == null ? void 0 : _a.length) != null ? _b : 0;
+        const requestsEnqueued = (_d = (_c = requests[origin]) == null ? void 0 : _c.length) != null ? _d : 0;
+        if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
+          console.warn("@smithy/node-http-handler:WARN", `socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.`, "See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html", "or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.");
+          return Date.now();
+        }
+      }
+    }
+    return socketWarningTimestamp;
+  }
+  constructor(options) {
+    this.socketWarningTimestamp = 0;
+    this.metadata = { handlerProtocol: "http/1.1" };
+    this.configProvider = new Promise((resolve, reject) => {
+      if (typeof options === "function") {
+        options().then((_options) => {
+          resolve(this.resolveDefaultConfig(_options));
+        }).catch(reject);
+      } else {
+        resolve(this.resolveDefaultConfig(options));
+      }
+    });
+  }
+  resolveDefaultConfig(options) {
+    const { requestTimeout, connectionTimeout, socketTimeout, httpAgent, httpsAgent } = options || {};
+    const keepAlive = true;
+    const maxSockets = 50;
+    return {
+      connectionTimeout,
+      requestTimeout: requestTimeout != null ? requestTimeout : socketTimeout,
+      httpAgent: (() => {
+        if (httpAgent instanceof http.Agent || typeof (httpAgent == null ? void 0 : httpAgent.destroy) === "function") {
+          return httpAgent;
+        }
+        return new http.Agent(__spreadValues({ keepAlive, maxSockets }, httpAgent));
+      })(),
+      httpsAgent: (() => {
+        if (httpsAgent instanceof https.Agent || typeof (httpsAgent == null ? void 0 : httpsAgent.destroy) === "function") {
+          return httpsAgent;
+        }
+        return new https.Agent(__spreadValues({ keepAlive, maxSockets }, httpsAgent));
+      })()
+    };
+  }
+  destroy() {
+    var _a, _b, _c, _d;
+    (_b = (_a = this.config) == null ? void 0 : _a.httpAgent) == null ? void 0 : _b.destroy();
+    (_d = (_c = this.config) == null ? void 0 : _c.httpsAgent) == null ? void 0 : _d.destroy();
+  }
+  async handle(request, { abortSignal } = {}) {
+    if (!this.config) {
+      this.config = await this.configProvider;
+    }
+    let socketCheckTimeoutId;
+    return new Promise((_resolve, _reject) => {
+      var _a, _b, _c, _d, _e;
+      let writeRequestBodyPromise = void 0;
+      const resolve = async (arg) => {
+        await writeRequestBodyPromise;
+        clearTimeout(socketCheckTimeoutId);
+        _resolve(arg);
+      };
+      const reject = async (arg) => {
+        await writeRequestBodyPromise;
+        _reject(arg);
+      };
+      if (!this.config) {
+        throw new Error("Node HTTP request handler config is not resolved");
+      }
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        const abortError = new Error("Request aborted");
+        abortError.name = "AbortError";
+        reject(abortError);
+        return;
+      }
+      const isSSL = request.protocol === "https:";
+      const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
+      socketCheckTimeoutId = setTimeout(() => {
+        this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp);
+      }, (_c = this.config.socketAcquisitionWarningTimeout) != null ? _c : ((_a = this.config.requestTimeout) != null ? _a : 2e3) + ((_b = this.config.connectionTimeout) != null ? _b : 1e3));
+      const queryString = buildQueryString(request.query || {});
+      let auth = void 0;
+      if (request.username != null || request.password != null) {
+        const username = (_d = request.username) != null ? _d : "";
+        const password = (_e = request.password) != null ? _e : "";
+        auth = `${username}:${password}`;
+      }
+      let path = request.path;
+      if (queryString) {
+        path += `?${queryString}`;
+      }
+      if (request.fragment) {
+        path += `#${request.fragment}`;
+      }
+      const nodeHttpsOptions = {
+        headers: request.headers,
+        host: request.hostname,
+        method: request.method,
+        path,
+        port: request.port,
+        agent,
+        auth
+      };
+      const requestFunc = isSSL ? https.request : http.request;
+      const req = requestFunc(nodeHttpsOptions, (res) => {
+        const httpResponse = new HttpResponse({
+          statusCode: res.statusCode || -1,
+          reason: res.statusMessage,
+          headers: getTransformedHeaders(res.headers),
+          body: res
+        });
+        resolve({ response: httpResponse });
+      });
+      req.on("error", (err) => {
+        if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
+          reject(Object.assign(err, { name: "TimeoutError" }));
+        } else {
+          reject(err);
+        }
+      });
+      setConnectionTimeout(req, reject, this.config.connectionTimeout);
+      setSocketTimeout(req, reject, this.config.requestTimeout);
+      if (abortSignal) {
+        abortSignal.onabort = () => {
+          req.abort();
+          const abortError = new Error("Request aborted");
+          abortError.name = "AbortError";
+          reject(abortError);
+        };
+      }
+      const httpAgent = nodeHttpsOptions.agent;
+      if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
+        setSocketKeepAlive(req, {
+          keepAlive: httpAgent.keepAlive,
+          keepAliveMsecs: httpAgent.keepAliveMsecs
+        });
+      }
+      writeRequestBodyPromise = writeRequestBody(req, request, this.config.requestTimeout).catch(_reject);
+    });
+  }
+  updateHttpClientConfig(key, value) {
+    this.config = void 0;
+    this.configProvider = this.configProvider.then((config) => {
+      return __spreadProps(__spreadValues({}, config), {
+        [key]: value
+      });
+    });
+  }
+  httpHandlerConfigs() {
+    var _a;
+    return (_a = this.config) != null ? _a : {};
+  }
+};
+
+// src/services/storage/s3/s3Storage.service.ts
 var S3StorageService = class {
   constructor(bucketName, options) {
+    this.httpHandler = new NodeHttpHandler({
+      socketTimeout: 6e4
+    });
     this.s3Client = new clientS3.S3Client({
-      region: process.env.AWS_DEFAULT_REGION
+      region: process.env.AWS_DEFAULT_REGION,
+      requestHandler: this.httpHandler
+    });
+    this.s3 = new clientS3.S3({
+      region: process.env.AWS_DEFAULT_REGION,
+      requestHandler: this.httpHandler
     });
-    this.s3 = new clientS3.S3({ region: process.env.AWS_DEFAULT_REGION });
     var _a, _b, _c, _d;
     this.bucketName = bucketName;
     if (((_a = options == null ? void 0 : options.credentials) == null ? void 0 : _a.accessKeyId) && ((_b = options == null ? void 0 : options.credentials) == null ? void 0 : _b.secretAccessKey)) {