@aws-sdk/middleware-sdk-s3 3.485.0 → 3.495.0

package/dist-cjs/check-content-length-header.js

@@ -1,37 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCheckContentLengthHeaderPlugin = exports.checkContentLengthHeaderMiddlewareOptions = exports.checkContentLengthHeader = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
-const smithy_client_1 = require("@smithy/smithy-client");
-const CONTENT_LENGTH_HEADER = "content-length";
-function checkContentLengthHeader() {
-    return (next, context) => async (args) => {
-        var _a;
-        const { request } = args;
-        if (protocol_http_1.HttpRequest.isInstance(request)) {
-            if (!request.headers[CONTENT_LENGTH_HEADER]) {
-                const message = `Are you using a Stream of unknown length as the Body of a PutObject request? Consider using Upload instead from @aws-sdk/lib-storage.`;
-                if (typeof ((_a = context === null || context === void 0 ? void 0 : context.logger) === null || _a === void 0 ? void 0 : _a.warn) === "function" && !(context.logger instanceof smithy_client_1.NoOpLogger)) {
-                    context.logger.warn(message);
-                }
-                else {
-                    console.warn(message);
-                }
-            }
-        }
-        return next({ ...args });
-    };
-}
-exports.checkContentLengthHeader = checkContentLengthHeader;
-exports.checkContentLengthHeaderMiddlewareOptions = {
-    step: "finalizeRequest",
-    tags: ["CHECK_CONTENT_LENGTH_HEADER"],
-    name: "getCheckContentLengthHeaderPlugin",
-    override: true,
-};
-const getCheckContentLengthHeaderPlugin = (unused) => ({
-    applyToStack: (clientStack) => {
-        clientStack.add(checkContentLengthHeader(), exports.checkContentLengthHeaderMiddlewareOptions);
-    },
-});
-exports.getCheckContentLengthHeaderPlugin = getCheckContentLengthHeaderPlugin;
+module.exports = require("./index.js");

package/dist-cjs/index.js

@@ -1,10 +1,495 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./check-content-length-header"), exports);
-tslib_1.__exportStar(require("./region-redirect-endpoint-middleware"), exports);
-tslib_1.__exportStar(require("./region-redirect-middleware"), exports);
-tslib_1.__exportStar(require("./s3-express/index"), exports);
-tslib_1.__exportStar(require("./s3Configuration"), exports);
-tslib_1.__exportStar(require("./throw-200-exceptions"), exports);
-tslib_1.__exportStar(require("./validate-bucket-name"), exports);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS: () => NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS,
+  S3ExpressIdentityCache: () => S3ExpressIdentityCache,
+  S3ExpressIdentityCacheEntry: () => S3ExpressIdentityCacheEntry,
+  S3ExpressIdentityProviderImpl: () => S3ExpressIdentityProviderImpl,
+  SignatureV4S3Express: () => SignatureV4S3Express,
+  checkContentLengthHeader: () => checkContentLengthHeader,
+  checkContentLengthHeaderMiddlewareOptions: () => checkContentLengthHeaderMiddlewareOptions,
+  getCheckContentLengthHeaderPlugin: () => getCheckContentLengthHeaderPlugin,
+  getRegionRedirectMiddlewarePlugin: () => getRegionRedirectMiddlewarePlugin,
+  getS3ExpressPlugin: () => getS3ExpressPlugin,
+  getThrow200ExceptionsPlugin: () => getThrow200ExceptionsPlugin,
+  getValidateBucketNamePlugin: () => getValidateBucketNamePlugin,
+  regionRedirectEndpointMiddleware: () => regionRedirectEndpointMiddleware,
+  regionRedirectEndpointMiddlewareOptions: () => regionRedirectEndpointMiddlewareOptions,
+  regionRedirectMiddleware: () => regionRedirectMiddleware,
+  regionRedirectMiddlewareOptions: () => regionRedirectMiddlewareOptions,
+  resolveS3Config: () => resolveS3Config,
+  s3ExpressMiddleware: () => s3ExpressMiddleware,
+  s3ExpressMiddlewareOptions: () => s3ExpressMiddlewareOptions,
+  throw200ExceptionsMiddleware: () => throw200ExceptionsMiddleware,
+  throw200ExceptionsMiddlewareOptions: () => throw200ExceptionsMiddlewareOptions,
+  validateBucketNameMiddleware: () => validateBucketNameMiddleware,
+  validateBucketNameMiddlewareOptions: () => validateBucketNameMiddlewareOptions
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/check-content-length-header.ts
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var CONTENT_LENGTH_HEADER = "content-length";
+function checkContentLengthHeader() {
+  return (next, context) => async (args) => {
+    var _a;
+    const { request } = args;
+    if (import_protocol_http.HttpRequest.isInstance(request)) {
+      if (!request.headers[CONTENT_LENGTH_HEADER]) {
+        const message = `Are you using a Stream of unknown length as the Body of a PutObject request? Consider using Upload instead from @aws-sdk/lib-storage.`;
+        if (typeof ((_a = context == null ? void 0 : context.logger) == null ? void 0 : _a.warn) === "function" && !(context.logger instanceof import_smithy_client.NoOpLogger)) {
+          context.logger.warn(message);
+        } else {
+          console.warn(message);
+        }
+      }
+    }
+    return next({ ...args });
+  };
+}
+__name(checkContentLengthHeader, "checkContentLengthHeader");
+var checkContentLengthHeaderMiddlewareOptions = {
+  step: "finalizeRequest",
+  tags: ["CHECK_CONTENT_LENGTH_HEADER"],
+  name: "getCheckContentLengthHeaderPlugin",
+  override: true
+};
+var getCheckContentLengthHeaderPlugin = /* @__PURE__ */ __name((unused) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(checkContentLengthHeader(), checkContentLengthHeaderMiddlewareOptions);
+  }
+}), "getCheckContentLengthHeaderPlugin");
+
+// src/region-redirect-endpoint-middleware.ts
+var regionRedirectEndpointMiddleware = /* @__PURE__ */ __name((config) => {
+  return (next, context) => async (args) => {
+    const originalRegion = await config.region();
+    const regionProviderRef = config.region;
+    if (context.__s3RegionRedirect) {
+      config.region = async () => {
+        config.region = regionProviderRef;
+        return context.__s3RegionRedirect;
+      };
+    }
+    const result = await next(args);
+    if (context.__s3RegionRedirect) {
+      const region = await config.region();
+      if (originalRegion !== region) {
+        throw new Error("Region was not restored following S3 region redirect.");
+      }
+    }
+    return result;
+  };
+}, "regionRedirectEndpointMiddleware");
+var regionRedirectEndpointMiddlewareOptions = {
+  tags: ["REGION_REDIRECT", "S3"],
+  name: "regionRedirectEndpointMiddleware",
+  override: true,
+  relation: "before",
+  toMiddleware: "endpointV2Middleware"
+};
+
+// src/region-redirect-middleware.ts
+function regionRedirectMiddleware(clientConfig) {
+  return (next, context) => async (args) => {
+    var _a, _b;
+    try {
+      return await next(args);
+    } catch (err) {
+      if (clientConfig.followRegionRedirects && // err.name === "PermanentRedirect" && --> removing the error name check, as that allows for HEAD operations (which have the 301 status code, but not the same error name) to be covered for region redirection as well
+      ((_a = err == null ? void 0 : err.$metadata) == null ? void 0 : _a.httpStatusCode) === 301) {
+        try {
+          const actualRegion = err.$response.headers["x-amz-bucket-region"];
+          (_b = context.logger) == null ? void 0 : _b.debug(`Redirecting from ${await clientConfig.region()} to ${actualRegion}`);
+          context.__s3RegionRedirect = actualRegion;
+        } catch (e) {
+          throw new Error("Region redirect failed: " + e);
+        }
+        return next(args);
+      } else {
+        throw err;
+      }
+    }
+  };
+}
+__name(regionRedirectMiddleware, "regionRedirectMiddleware");
+var regionRedirectMiddlewareOptions = {
+  step: "initialize",
+  tags: ["REGION_REDIRECT", "S3"],
+  name: "regionRedirectMiddleware",
+  override: true
+};
+var getRegionRedirectMiddlewarePlugin = /* @__PURE__ */ __name((clientConfig) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(regionRedirectMiddleware(clientConfig), regionRedirectMiddlewareOptions);
+    clientStack.addRelativeTo(regionRedirectEndpointMiddleware(clientConfig), regionRedirectEndpointMiddlewareOptions);
+  }
+}), "getRegionRedirectMiddlewarePlugin");
+
+// src/s3-express/classes/S3ExpressIdentityCache.ts
+var _S3ExpressIdentityCache = class _S3ExpressIdentityCache {
+  constructor(data = {}) {
+    this.data = data;
+    this.lastPurgeTime = Date.now();
+  }
+  get(key) {
+    const entry = this.data[key];
+    if (!entry) {
+      return;
+    }
+    return entry;
+  }
+  set(key, entry) {
+    this.data[key] = entry;
+    return entry;
+  }
+  delete(key) {
+    delete this.data[key];
+  }
+  async purgeExpired() {
+    const now = Date.now();
+    if (this.lastPurgeTime + _S3ExpressIdentityCache.EXPIRED_CREDENTIAL_PURGE_INTERVAL_MS > now) {
+      return;
+    }
+    for (const key in this.data) {
+      const entry = this.data[key];
+      if (!entry.isRefreshing) {
+        const credential = await entry.identity;
+        if (credential.expiration) {
+          if (credential.expiration.getTime() < now) {
+            delete this.data[key];
+          }
+        }
+      }
+    }
+  }
+};
+__name(_S3ExpressIdentityCache, "S3ExpressIdentityCache");
+_S3ExpressIdentityCache.EXPIRED_CREDENTIAL_PURGE_INTERVAL_MS = 3e4;
+var S3ExpressIdentityCache = _S3ExpressIdentityCache;
+
+// src/s3-express/classes/S3ExpressIdentityCacheEntry.ts
+var _S3ExpressIdentityCacheEntry = class _S3ExpressIdentityCacheEntry {
+  /**
+   * @param identity - stored identity.
+   * @param accessed - timestamp of last access in epoch ms.
+   * @param isRefreshing - this key is currently in the process of being refreshed (background).
+   */
+  constructor(_identity, isRefreshing = false, accessed = Date.now()) {
+    this._identity = _identity;
+    this.isRefreshing = isRefreshing;
+    this.accessed = accessed;
+  }
+  get identity() {
+    this.accessed = Date.now();
+    return this._identity;
+  }
+};
+__name(_S3ExpressIdentityCacheEntry, "S3ExpressIdentityCacheEntry");
+var S3ExpressIdentityCacheEntry = _S3ExpressIdentityCacheEntry;
+
+// src/s3-express/classes/S3ExpressIdentityProviderImpl.ts
+var _S3ExpressIdentityProviderImpl = class _S3ExpressIdentityProviderImpl {
+  constructor(createSessionFn, cache = new S3ExpressIdentityCache()) {
+    this.createSessionFn = createSessionFn;
+    this.cache = cache;
+  }
+  async getS3ExpressIdentity(awsIdentity, identityProperties) {
+    const key = identityProperties.Bucket;
+    const { cache } = this;
+    const entry = cache.get(key);
+    if (entry) {
+      return entry.identity.then((identity) => {
+        var _a, _b;
+        const isExpired = (((_a = identity.expiration) == null ? void 0 : _a.getTime()) ?? 0) < Date.now();
+        if (isExpired) {
+          return cache.set(key, new S3ExpressIdentityCacheEntry(this.getIdentity(key))).identity;
+        }
+        const isExpiringSoon = (((_b = identity.expiration) == null ? void 0 : _b.getTime()) ?? 0) < Date.now() + _S3ExpressIdentityProviderImpl.REFRESH_WINDOW_MS;
+        if (isExpiringSoon && !entry.isRefreshing) {
+          entry.isRefreshing = true;
+          this.getIdentity(key).then((id) => {
+            cache.set(key, new S3ExpressIdentityCacheEntry(Promise.resolve(id)));
+          });
+        }
+        return identity;
+      });
+    }
+    return cache.set(key, new S3ExpressIdentityCacheEntry(this.getIdentity(key))).identity;
+  }
+  async getIdentity(key) {
+    var _a, _b;
+    await this.cache.purgeExpired().catch((error) => {
+      console.warn("Error while clearing expired entries in S3ExpressIdentityCache: \n" + error);
+    });
+    const session = await this.createSessionFn(key);
+    if (!((_a = session.Credentials) == null ? void 0 : _a.AccessKeyId) || !((_b = session.Credentials) == null ? void 0 : _b.SecretAccessKey)) {
+      throw new Error("s3#createSession response credential missing AccessKeyId or SecretAccessKey.");
+    }
+    const identity = {
+      accessKeyId: session.Credentials.AccessKeyId,
+      secretAccessKey: session.Credentials.SecretAccessKey,
+      sessionToken: session.Credentials.SessionToken,
+      expiration: session.Credentials.Expiration ? new Date(session.Credentials.Expiration) : void 0
+    };
+    return identity;
+  }
+};
+__name(_S3ExpressIdentityProviderImpl, "S3ExpressIdentityProviderImpl");
+_S3ExpressIdentityProviderImpl.REFRESH_WINDOW_MS = 6e4;
+var S3ExpressIdentityProviderImpl = _S3ExpressIdentityProviderImpl;
+
+// src/s3-express/classes/SignatureV4S3Express.ts
+var import_signature_v4 = require("@smithy/signature-v4");
+
+// src/s3-express/constants.ts
+var import_util_config_provider = require("@smithy/util-config-provider");
+var S3_EXPRESS_BUCKET_TYPE = "Directory";
+var S3_EXPRESS_BACKEND = "S3Express";
+var S3_EXPRESS_AUTH_SCHEME = "sigv4-s3express";
+var SESSION_TOKEN_QUERY_PARAM = "X-Amz-S3session-Token";
+var SESSION_TOKEN_HEADER = SESSION_TOKEN_QUERY_PARAM.toLowerCase();
+var NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_ENV_NAME = "AWS_S3_DISABLE_EXPRESS_SESSION_AUTH";
+var NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_INI_NAME = "s3_disable_express_session_auth";
+var NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS = {
+  environmentVariableSelector: (env) => (0, import_util_config_provider.booleanSelector)(env, NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_ENV_NAME, import_util_config_provider.SelectorType.ENV),
+  configFileSelector: (profile) => (0, import_util_config_provider.booleanSelector)(profile, NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_INI_NAME, import_util_config_provider.SelectorType.CONFIG),
+  default: false
+};
+
+// src/s3-express/classes/SignatureV4S3Express.ts
+var _SignatureV4S3Express = class _SignatureV4S3Express extends import_signature_v4.SignatureV4 {
+  /**
+   * Signs with alternate provided credentials instead of those provided in the
+   * constructor.
+   *
+   * Additionally omits the credential sessionToken and assigns it to the
+   * alternate header field for S3 Express.
+   */
+  async signWithCredentials(requestToSign, credentials, options) {
+    const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
+    requestToSign.headers[SESSION_TOKEN_HEADER] = credentials.sessionToken;
+    const privateAccess = this;
+    setSingleOverride(privateAccess, credentialsWithoutSessionToken);
+    return privateAccess.signRequest(requestToSign, options ?? {});
+  }
+  /**
+   * Similar to {@link SignatureV4S3Express#signWithCredentials} but for presigning.
+   */
+  async presignWithCredentials(requestToSign, credentials, options) {
+    const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
+    delete requestToSign.headers[SESSION_TOKEN_HEADER];
+    requestToSign.headers[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
+    requestToSign.query = requestToSign.query ?? {};
+    requestToSign.query[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
+    const privateAccess = this;
+    setSingleOverride(privateAccess, credentialsWithoutSessionToken);
+    return this.presign(requestToSign, options);
+  }
+};
+__name(_SignatureV4S3Express, "SignatureV4S3Express");
+var SignatureV4S3Express = _SignatureV4S3Express;
+function getCredentialsWithoutSessionToken(credentials) {
+  const credentialsWithoutSessionToken = {
+    accessKeyId: credentials.accessKeyId,
+    secretAccessKey: credentials.secretAccessKey,
+    expiration: credentials.expiration
+  };
+  return credentialsWithoutSessionToken;
+}
+__name(getCredentialsWithoutSessionToken, "getCredentialsWithoutSessionToken");
+function setSingleOverride(privateAccess, credentialsWithoutSessionToken) {
+  const id = setTimeout(() => {
+    throw new Error("SignatureV4S3Express credential override was created but not called.");
+  }, 10);
+  const currentCredentialProvider = privateAccess.credentialProvider;
+  const overrideCredentialsProviderOnce = /* @__PURE__ */ __name(() => {
+    clearTimeout(id);
+    privateAccess.credentialProvider = currentCredentialProvider;
+    return Promise.resolve(credentialsWithoutSessionToken);
+  }, "overrideCredentialsProviderOnce");
+  privateAccess.credentialProvider = overrideCredentialsProviderOnce;
+}
+__name(setSingleOverride, "setSingleOverride");
+
+// src/s3-express/functions/s3ExpressMiddleware.ts
+
+var s3ExpressMiddleware = /* @__PURE__ */ __name((options) => {
+  return (next, context) => async (args) => {
+    var _a, _b, _c, _d, _e;
+    if (context.endpointV2) {
+      const endpoint = context.endpointV2;
+      const isS3ExpressAuth = ((_c = (_b = (_a = endpoint.properties) == null ? void 0 : _a.authSchemes) == null ? void 0 : _b[0]) == null ? void 0 : _c.name) === S3_EXPRESS_AUTH_SCHEME;
+      const isS3ExpressBucket = ((_d = endpoint.properties) == null ? void 0 : _d.backend) === S3_EXPRESS_BACKEND || ((_e = endpoint.properties) == null ? void 0 : _e.bucketType) === S3_EXPRESS_BUCKET_TYPE;
+      if (isS3ExpressBucket) {
+        context.isS3ExpressBucket = true;
+      }
+      if (isS3ExpressAuth) {
+        const requestBucket = args.input.Bucket;
+        if (requestBucket) {
+          const s3ExpressIdentity = await options.s3ExpressIdentityProvider.getS3ExpressIdentity(
+            await options.credentials(),
+            {
+              Bucket: requestBucket
+            }
+          );
+          context.s3ExpressIdentity = s3ExpressIdentity;
+          if (import_protocol_http.HttpRequest.isInstance(args.request) && s3ExpressIdentity.sessionToken) {
+            args.request.headers[SESSION_TOKEN_HEADER] = s3ExpressIdentity.sessionToken;
+          }
+        }
+      }
+    }
+    return next(args);
+  };
+}, "s3ExpressMiddleware");
+var s3ExpressMiddlewareOptions = {
+  name: "s3ExpressMiddleware",
+  step: "build",
+  tags: ["S3", "S3_EXPRESS"],
+  override: true
+};
+var getS3ExpressPlugin = /* @__PURE__ */ __name((options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(s3ExpressMiddleware(options), s3ExpressMiddlewareOptions);
+  }
+}), "getS3ExpressPlugin");
+
+// src/s3Configuration.ts
+var resolveS3Config = /* @__PURE__ */ __name((input, {
+  session
+}) => {
+  const [s3ClientProvider, CreateSessionCommandCtor] = session;
+  return {
+    ...input,
+    forcePathStyle: input.forcePathStyle ?? false,
+    useAccelerateEndpoint: input.useAccelerateEndpoint ?? false,
+    disableMultiregionAccessPoints: input.disableMultiregionAccessPoints ?? false,
+    followRegionRedirects: input.followRegionRedirects ?? false,
+    s3ExpressIdentityProvider: input.s3ExpressIdentityProvider ?? new S3ExpressIdentityProviderImpl(
+      async (key) => s3ClientProvider().send(
+        new CreateSessionCommandCtor({
+          Bucket: key,
+          SessionMode: "ReadWrite"
+        })
+      )
+    )
+  };
+}, "resolveS3Config");
+
+// src/throw-200-exceptions.ts
+
+var throw200ExceptionsMiddleware = /* @__PURE__ */ __name((config) => (next) => async (args) => {
+  const result = await next(args);
+  const { response } = result;
+  if (!import_protocol_http.HttpResponse.isInstance(response))
+    return result;
+  const { statusCode, body } = response;
+  if (statusCode < 200 || statusCode >= 300)
+    return result;
+  const bodyBytes = await collectBody(body, config);
+  const bodyString = await collectBodyString(bodyBytes, config);
+  if (bodyBytes.length === 0) {
+    const err = new Error("S3 aborted request");
+    err.name = "InternalError";
+    throw err;
+  }
+  if (bodyString && bodyString.match("<Error>")) {
+    response.statusCode = 400;
+  }
+  response.body = bodyBytes;
+  return result;
+}, "throw200ExceptionsMiddleware");
+var collectBody = /* @__PURE__ */ __name((streamBody = new Uint8Array(), context) => {
+  if (streamBody instanceof Uint8Array) {
+    return Promise.resolve(streamBody);
+  }
+  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
+}, "collectBody");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throw200ExceptionsMiddlewareOptions = {
+  relation: "after",
+  toMiddleware: "deserializerMiddleware",
+  tags: ["THROW_200_EXCEPTIONS", "S3"],
+  name: "throw200ExceptionsMiddleware",
+  override: true
+};
+var getThrow200ExceptionsPlugin = /* @__PURE__ */ __name((config) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(throw200ExceptionsMiddleware(config), throw200ExceptionsMiddlewareOptions);
+  }
+}), "getThrow200ExceptionsPlugin");
+
+// src/validate-bucket-name.ts
+var import_util_arn_parser = require("@aws-sdk/util-arn-parser");
+function validateBucketNameMiddleware() {
+  return (next) => async (args) => {
+    const {
+      input: { Bucket }
+    } = args;
+    if (typeof Bucket === "string" && !(0, import_util_arn_parser.validate)(Bucket) && Bucket.indexOf("/") >= 0) {
+      const err = new Error(`Bucket name shouldn't contain '/', received '${Bucket}'`);
+      err.name = "InvalidBucketName";
+      throw err;
+    }
+    return next({ ...args });
+  };
+}
+__name(validateBucketNameMiddleware, "validateBucketNameMiddleware");
+var validateBucketNameMiddlewareOptions = {
+  step: "initialize",
+  tags: ["VALIDATE_BUCKET_NAME"],
+  name: "validateBucketNameMiddleware",
+  override: true
+};
+var getValidateBucketNamePlugin = /* @__PURE__ */ __name((unused) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(validateBucketNameMiddleware(), validateBucketNameMiddlewareOptions);
+  }
+}), "getValidateBucketNamePlugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS,
+  S3ExpressIdentityCache,
+  S3ExpressIdentityCacheEntry,
+  S3ExpressIdentityProviderImpl,
+  SignatureV4S3Express,
+  checkContentLengthHeader,
+  checkContentLengthHeaderMiddlewareOptions,
+  getCheckContentLengthHeaderPlugin,
+  getRegionRedirectMiddlewarePlugin,
+  getS3ExpressPlugin,
+  getThrow200ExceptionsPlugin,
+  getValidateBucketNamePlugin,
+  regionRedirectEndpointMiddleware,
+  regionRedirectEndpointMiddlewareOptions,
+  regionRedirectMiddleware,
+  regionRedirectMiddlewareOptions,
+  resolveS3Config,
+  s3ExpressMiddleware,
+  s3ExpressMiddlewareOptions,
+  throw200ExceptionsMiddleware,
+  throw200ExceptionsMiddlewareOptions,
+  validateBucketNameMiddleware,
+  validateBucketNameMiddlewareOptions
+});

package/dist-cjs/region-redirect-endpoint-middleware.js

@@ -1,31 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.regionRedirectEndpointMiddlewareOptions = exports.regionRedirectEndpointMiddleware = void 0;
-const regionRedirectEndpointMiddleware = (config) => {
-    return (next, context) => async (args) => {
-        const originalRegion = await config.region();
-        const regionProviderRef = config.region;
-        if (context.__s3RegionRedirect) {
-            config.region = async () => {
-                config.region = regionProviderRef;
-                return context.__s3RegionRedirect;
-            };
-        }
-        const result = await next(args);
-        if (context.__s3RegionRedirect) {
-            const region = await config.region();
-            if (originalRegion !== region) {
-                throw new Error("Region was not restored following S3 region redirect.");
-            }
-        }
-        return result;
-    };
-};
-exports.regionRedirectEndpointMiddleware = regionRedirectEndpointMiddleware;
-exports.regionRedirectEndpointMiddlewareOptions = {
-    tags: ["REGION_REDIRECT", "S3"],
-    name: "regionRedirectEndpointMiddleware",
-    override: true,
-    relation: "before",
-    toMiddleware: "endpointV2Middleware",
-};
+module.exports = require("./index.js");

package/dist-cjs/region-redirect-middleware.js

@@ -1,43 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRegionRedirectMiddlewarePlugin = exports.regionRedirectMiddlewareOptions = exports.regionRedirectMiddleware = void 0;
-const region_redirect_endpoint_middleware_1 = require("./region-redirect-endpoint-middleware");
-function regionRedirectMiddleware(clientConfig) {
-    return (next, context) => async (args) => {
-        var _a, _b;
-        try {
-            return await next(args);
-        }
-        catch (err) {
-            if (clientConfig.followRegionRedirects &&
-                ((_a = err === null || err === void 0 ? void 0 : err.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 301) {
-                try {
-                    const actualRegion = err.$response.headers["x-amz-bucket-region"];
-                    (_b = context.logger) === null || _b === void 0 ? void 0 : _b.debug(`Redirecting from ${await clientConfig.region()} to ${actualRegion}`);
-                    context.__s3RegionRedirect = actualRegion;
-                }
-                catch (e) {
-                    throw new Error("Region redirect failed: " + e);
-                }
-                return next(args);
-            }
-            else {
-                throw err;
-            }
-        }
-    };
-}
-exports.regionRedirectMiddleware = regionRedirectMiddleware;
-exports.regionRedirectMiddlewareOptions = {
-    step: "initialize",
-    tags: ["REGION_REDIRECT", "S3"],
-    name: "regionRedirectMiddleware",
-    override: true,
-};
-const getRegionRedirectMiddlewarePlugin = (clientConfig) => ({
-    applyToStack: (clientStack) => {
-        clientStack.add(regionRedirectMiddleware(clientConfig), exports.regionRedirectMiddlewareOptions);
-        clientStack.addRelativeTo((0, region_redirect_endpoint_middleware_1.regionRedirectEndpointMiddleware)(clientConfig), region_redirect_endpoint_middleware_1.regionRedirectEndpointMiddlewareOptions);
-    },
-});
-exports.getRegionRedirectMiddlewarePlugin = getRegionRedirectMiddlewarePlugin;
+module.exports = require("./index.js");

package/dist-cjs/s3-express/classes/S3ExpressIdentityCache.js

@@ -1,42 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3ExpressIdentityCache = void 0;
-class S3ExpressIdentityCache {
-    constructor(data = {}) {
-        this.data = data;
-        this.lastPurgeTime = Date.now();
-    }
-    get(key) {
-        const entry = this.data[key];
-        if (!entry) {
-            return;
-        }
-        return entry;
-    }
-    set(key, entry) {
-        this.data[key] = entry;
-        return entry;
-    }
-    delete(key) {
-        delete this.data[key];
-    }
-    async purgeExpired() {
-        const now = Date.now();
-        if (this.lastPurgeTime + S3ExpressIdentityCache.EXPIRED_CREDENTIAL_PURGE_INTERVAL_MS > now) {
-            return;
-        }
-        for (const key in this.data) {
-            const entry = this.data[key];
-            if (!entry.isRefreshing) {
-                const credential = await entry.identity;
-                if (credential.expiration) {
-                    if (credential.expiration.getTime() < now) {
-                        delete this.data[key];
-                    }
-                }
-            }
-        }
-    }
-}
-exports.S3ExpressIdentityCache = S3ExpressIdentityCache;
-S3ExpressIdentityCache.EXPIRED_CREDENTIAL_PURGE_INTERVAL_MS = 30000;
+module.exports = require("../../index.js");

package/dist-cjs/s3-express/classes/S3ExpressIdentityCacheEntry.js

@@ -1,15 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3ExpressIdentityCacheEntry = void 0;
-class S3ExpressIdentityCacheEntry {
-    constructor(_identity, isRefreshing = false, accessed = Date.now()) {
-        this._identity = _identity;
-        this.isRefreshing = isRefreshing;
-        this.accessed = accessed;
-    }
-    get identity() {
-        this.accessed = Date.now();
-        return this._identity;
-    }
-}
-exports.S3ExpressIdentityCacheEntry = S3ExpressIdentityCacheEntry;
+module.exports = require("../../index.js");

package/dist-cjs/s3-express/classes/S3ExpressIdentityProviderImpl.js

@@ -1,53 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3ExpressIdentityProviderImpl = void 0;
-const S3ExpressIdentityCache_1 = require("./S3ExpressIdentityCache");
-const S3ExpressIdentityCacheEntry_1 = require("./S3ExpressIdentityCacheEntry");
-class S3ExpressIdentityProviderImpl {
-    constructor(createSessionFn, cache = new S3ExpressIdentityCache_1.S3ExpressIdentityCache()) {
-        this.createSessionFn = createSessionFn;
-        this.cache = cache;
-    }
-    async getS3ExpressIdentity(awsIdentity, identityProperties) {
-        const key = identityProperties.Bucket;
-        const { cache } = this;
-        const entry = cache.get(key);
-        if (entry) {
-            return entry.identity.then((identity) => {
-                var _a, _b, _c, _d;
-                const isExpired = ((_b = (_a = identity.expiration) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : 0) < Date.now();
-                if (isExpired) {
-                    return cache.set(key, new S3ExpressIdentityCacheEntry_1.S3ExpressIdentityCacheEntry(this.getIdentity(key))).identity;
-                }
-                const isExpiringSoon = ((_d = (_c = identity.expiration) === null || _c === void 0 ? void 0 : _c.getTime()) !== null && _d !== void 0 ? _d : 0) < Date.now() + S3ExpressIdentityProviderImpl.REFRESH_WINDOW_MS;
-                if (isExpiringSoon && !entry.isRefreshing) {
-                    entry.isRefreshing = true;
-                    this.getIdentity(key).then((id) => {
-                        cache.set(key, new S3ExpressIdentityCacheEntry_1.S3ExpressIdentityCacheEntry(Promise.resolve(id)));
-                    });
-                }
-                return identity;
-            });
-        }
-        return cache.set(key, new S3ExpressIdentityCacheEntry_1.S3ExpressIdentityCacheEntry(this.getIdentity(key))).identity;
-    }
-    async getIdentity(key) {
-        var _a, _b;
-        await this.cache.purgeExpired().catch((error) => {
-            console.warn("Error while clearing expired entries in S3ExpressIdentityCache: \n" + error);
-        });
-        const session = await this.createSessionFn(key);
-        if (!((_a = session.Credentials) === null || _a === void 0 ? void 0 : _a.AccessKeyId) || !((_b = session.Credentials) === null || _b === void 0 ? void 0 : _b.SecretAccessKey)) {
-            throw new Error("s3#createSession response credential missing AccessKeyId or SecretAccessKey.");
-        }
-        const identity = {
-            accessKeyId: session.Credentials.AccessKeyId,
-            secretAccessKey: session.Credentials.SecretAccessKey,
-            sessionToken: session.Credentials.SessionToken,
-            expiration: session.Credentials.Expiration ? new Date(session.Credentials.Expiration) : undefined,
-        };
-        return identity;
-    }
-}
-exports.S3ExpressIdentityProviderImpl = S3ExpressIdentityProviderImpl;
-S3ExpressIdentityProviderImpl.REFRESH_WINDOW_MS = 60000;
+module.exports = require("../../index.js");

package/dist-cjs/s3-express/classes/SignatureV4S3Express.js

@@ -1,46 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignatureV4S3Express = void 0;
-const signature_v4_1 = require("@smithy/signature-v4");
-const constants_1 = require("../constants");
-class SignatureV4S3Express extends signature_v4_1.SignatureV4 {
-    async signWithCredentials(requestToSign, credentials, options) {
-        const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
-        requestToSign.headers[constants_1.SESSION_TOKEN_HEADER] = credentials.sessionToken;
-        const privateAccess = this;
-        setSingleOverride(privateAccess, credentialsWithoutSessionToken);
-        return privateAccess.signRequest(requestToSign, options !== null && options !== void 0 ? options : {});
-    }
-    async presignWithCredentials(requestToSign, credentials, options) {
-        var _a;
-        const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
-        delete requestToSign.headers[constants_1.SESSION_TOKEN_HEADER];
-        requestToSign.headers[constants_1.SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
-        requestToSign.query = (_a = requestToSign.query) !== null && _a !== void 0 ? _a : {};
-        requestToSign.query[constants_1.SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
-        const privateAccess = this;
-        setSingleOverride(privateAccess, credentialsWithoutSessionToken);
-        return this.presign(requestToSign, options);
-    }
-}
-exports.SignatureV4S3Express = SignatureV4S3Express;
-function getCredentialsWithoutSessionToken(credentials) {
-    const credentialsWithoutSessionToken = {
-        accessKeyId: credentials.accessKeyId,
-        secretAccessKey: credentials.secretAccessKey,
-        expiration: credentials.expiration,
-    };
-    return credentialsWithoutSessionToken;
-}
-function setSingleOverride(privateAccess, credentialsWithoutSessionToken) {
-    const id = setTimeout(() => {
-        throw new Error("SignatureV4S3Express credential override was created but not called.");
-    }, 10);
-    const currentCredentialProvider = privateAccess.credentialProvider;
-    const overrideCredentialsProviderOnce = () => {
-        clearTimeout(id);
-        privateAccess.credentialProvider = currentCredentialProvider;
-        return Promise.resolve(credentialsWithoutSessionToken);
-    };
-    privateAccess.credentialProvider = overrideCredentialsProviderOnce;
-}
+module.exports = require("../../index.js");

package/dist-cjs/s3-express/constants.js

@@ -1,16 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS = exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_INI_NAME = exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_ENV_NAME = exports.SESSION_TOKEN_HEADER = exports.SESSION_TOKEN_QUERY_PARAM = exports.S3_EXPRESS_AUTH_SCHEME = exports.S3_EXPRESS_BACKEND = exports.S3_EXPRESS_BUCKET_TYPE = void 0;
-const util_config_provider_1 = require("@smithy/util-config-provider");
-exports.S3_EXPRESS_BUCKET_TYPE = "Directory";
-exports.S3_EXPRESS_BACKEND = "S3Express";
-exports.S3_EXPRESS_AUTH_SCHEME = "sigv4-s3express";
-exports.SESSION_TOKEN_QUERY_PARAM = "X-Amz-S3session-Token";
-exports.SESSION_TOKEN_HEADER = exports.SESSION_TOKEN_QUERY_PARAM.toLowerCase();
-exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_ENV_NAME = "AWS_S3_DISABLE_EXPRESS_SESSION_AUTH";
-exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_INI_NAME = "s3_disable_express_session_auth";
-exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS = {
-    environmentVariableSelector: (env) => (0, util_config_provider_1.booleanSelector)(env, exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_ENV_NAME, util_config_provider_1.SelectorType.ENV),
-    configFileSelector: (profile) => (0, util_config_provider_1.booleanSelector)(profile, exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_INI_NAME, util_config_provider_1.SelectorType.CONFIG),
-    default: false,
-};
+module.exports = require("../index.js");

package/dist-cjs/s3-express/functions/s3ExpressMiddleware.js

@@ -1,45 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getS3ExpressPlugin = exports.s3ExpressMiddlewareOptions = exports.s3ExpressMiddleware = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
-const constants_1 = require("../constants");
-const s3ExpressMiddleware = (options) => {
-    return (next, context) => async (args) => {
-        var _a, _b, _c, _d, _e;
-        if (context.endpointV2) {
-            const endpoint = context.endpointV2;
-            const isS3ExpressAuth = ((_c = (_b = (_a = endpoint.properties) === null || _a === void 0 ? void 0 : _a.authSchemes) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.name) === constants_1.S3_EXPRESS_AUTH_SCHEME;
-            const isS3ExpressBucket = ((_d = endpoint.properties) === null || _d === void 0 ? void 0 : _d.backend) === constants_1.S3_EXPRESS_BACKEND ||
-                ((_e = endpoint.properties) === null || _e === void 0 ? void 0 : _e.bucketType) === constants_1.S3_EXPRESS_BUCKET_TYPE;
-            if (isS3ExpressBucket) {
-                context.isS3ExpressBucket = true;
-            }
-            if (isS3ExpressAuth) {
-                const requestBucket = args.input.Bucket;
-                if (requestBucket) {
-                    const s3ExpressIdentity = await options.s3ExpressIdentityProvider.getS3ExpressIdentity(await options.credentials(), {
-                        Bucket: requestBucket,
-                    });
-                    context.s3ExpressIdentity = s3ExpressIdentity;
-                    if (protocol_http_1.HttpRequest.isInstance(args.request) && s3ExpressIdentity.sessionToken) {
-                        args.request.headers[constants_1.SESSION_TOKEN_HEADER] = s3ExpressIdentity.sessionToken;
-                    }
-                }
-            }
-        }
-        return next(args);
-    };
-};
-exports.s3ExpressMiddleware = s3ExpressMiddleware;
-exports.s3ExpressMiddlewareOptions = {
-    name: "s3ExpressMiddleware",
-    step: "build",
-    tags: ["S3", "S3_EXPRESS"],
-    override: true,
-};
-const getS3ExpressPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-        clientStack.add((0, exports.s3ExpressMiddleware)(options), exports.s3ExpressMiddlewareOptions);
-    },
-});
-exports.getS3ExpressPlugin = getS3ExpressPlugin;
+module.exports = require("../../index.js");

package/dist-cjs/s3-express/index.js

@@ -1,17 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.s3ExpressMiddlewareOptions = exports.s3ExpressMiddleware = exports.getS3ExpressPlugin = exports.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS = exports.SignatureV4S3Express = exports.S3ExpressIdentityProviderImpl = exports.S3ExpressIdentityCacheEntry = exports.S3ExpressIdentityCache = void 0;
-var S3ExpressIdentityCache_1 = require("./classes/S3ExpressIdentityCache");
-Object.defineProperty(exports, "S3ExpressIdentityCache", { enumerable: true, get: function () { return S3ExpressIdentityCache_1.S3ExpressIdentityCache; } });
-var S3ExpressIdentityCacheEntry_1 = require("./classes/S3ExpressIdentityCacheEntry");
-Object.defineProperty(exports, "S3ExpressIdentityCacheEntry", { enumerable: true, get: function () { return S3ExpressIdentityCacheEntry_1.S3ExpressIdentityCacheEntry; } });
-var S3ExpressIdentityProviderImpl_1 = require("./classes/S3ExpressIdentityProviderImpl");
-Object.defineProperty(exports, "S3ExpressIdentityProviderImpl", { enumerable: true, get: function () { return S3ExpressIdentityProviderImpl_1.S3ExpressIdentityProviderImpl; } });
-var SignatureV4S3Express_1 = require("./classes/SignatureV4S3Express");
-Object.defineProperty(exports, "SignatureV4S3Express", { enumerable: true, get: function () { return SignatureV4S3Express_1.SignatureV4S3Express; } });
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS", { enumerable: true, get: function () { return constants_1.NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS; } });
-var s3ExpressMiddleware_1 = require("./functions/s3ExpressMiddleware");
-Object.defineProperty(exports, "getS3ExpressPlugin", { enumerable: true, get: function () { return s3ExpressMiddleware_1.getS3ExpressPlugin; } });
-Object.defineProperty(exports, "s3ExpressMiddleware", { enumerable: true, get: function () { return s3ExpressMiddleware_1.s3ExpressMiddleware; } });
-Object.defineProperty(exports, "s3ExpressMiddlewareOptions", { enumerable: true, get: function () { return s3ExpressMiddleware_1.s3ExpressMiddlewareOptions; } });
+module.exports = require("../index.js");

package/dist-cjs/s3-express/interfaces/S3ExpressIdentity.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = require("../../index.js");

package/dist-cjs/s3-express/interfaces/S3ExpressIdentityProvider.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = require("../../index.js");

package/dist-cjs/s3Configuration.js

@@ -1,20 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveS3Config = void 0;
-const s3_express_1 = require("./s3-express");
-const resolveS3Config = (input, { session, }) => {
-    var _a, _b, _c, _d, _e;
-    const [s3ClientProvider, CreateSessionCommandCtor] = session;
-    return {
-        ...input,
-        forcePathStyle: (_a = input.forcePathStyle) !== null && _a !== void 0 ? _a : false,
-        useAccelerateEndpoint: (_b = input.useAccelerateEndpoint) !== null && _b !== void 0 ? _b : false,
-        disableMultiregionAccessPoints: (_c = input.disableMultiregionAccessPoints) !== null && _c !== void 0 ? _c : false,
-        followRegionRedirects: (_d = input.followRegionRedirects) !== null && _d !== void 0 ? _d : false,
-        s3ExpressIdentityProvider: (_e = input.s3ExpressIdentityProvider) !== null && _e !== void 0 ? _e : new s3_express_1.S3ExpressIdentityProviderImpl(async (key) => s3ClientProvider().send(new CreateSessionCommandCtor({
-            Bucket: key,
-            SessionMode: "ReadWrite",
-        }))),
-    };
-};
-exports.resolveS3Config = resolveS3Config;
+module.exports = require("./index.js");

package/dist-cjs/throw-200-exceptions.js

@@ -1,46 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getThrow200ExceptionsPlugin = exports.throw200ExceptionsMiddlewareOptions = exports.throw200ExceptionsMiddleware = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
-const throw200ExceptionsMiddleware = (config) => (next) => async (args) => {
-    const result = await next(args);
-    const { response } = result;
-    if (!protocol_http_1.HttpResponse.isInstance(response))
-        return result;
-    const { statusCode, body } = response;
-    if (statusCode < 200 || statusCode >= 300)
-        return result;
-    const bodyBytes = await collectBody(body, config);
-    const bodyString = await collectBodyString(bodyBytes, config);
-    if (bodyBytes.length === 0) {
-        const err = new Error("S3 aborted request");
-        err.name = "InternalError";
-        throw err;
-    }
-    if (bodyString && bodyString.match("<Error>")) {
-        response.statusCode = 400;
-    }
-    response.body = bodyBytes;
-    return result;
-};
-exports.throw200ExceptionsMiddleware = throw200ExceptionsMiddleware;
-const collectBody = (streamBody = new Uint8Array(), context) => {
-    if (streamBody instanceof Uint8Array) {
-        return Promise.resolve(streamBody);
-    }
-    return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
-};
-const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-exports.throw200ExceptionsMiddlewareOptions = {
-    relation: "after",
-    toMiddleware: "deserializerMiddleware",
-    tags: ["THROW_200_EXCEPTIONS", "S3"],
-    name: "throw200ExceptionsMiddleware",
-    override: true,
-};
-const getThrow200ExceptionsPlugin = (config) => ({
-    applyToStack: (clientStack) => {
-        clientStack.addRelativeTo((0, exports.throw200ExceptionsMiddleware)(config), exports.throw200ExceptionsMiddlewareOptions);
-    },
-});
-exports.getThrow200ExceptionsPlugin = getThrow200ExceptionsPlugin;
+module.exports = require("./index.js");

package/dist-cjs/validate-bucket-name.js

@@ -1,28 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValidateBucketNamePlugin = exports.validateBucketNameMiddlewareOptions = exports.validateBucketNameMiddleware = void 0;
-const util_arn_parser_1 = require("@aws-sdk/util-arn-parser");
-function validateBucketNameMiddleware() {
-    return (next) => async (args) => {
-        const { input: { Bucket }, } = args;
-        if (typeof Bucket === "string" && !(0, util_arn_parser_1.validate)(Bucket) && Bucket.indexOf("/") >= 0) {
-            const err = new Error(`Bucket name shouldn't contain '/', received '${Bucket}'`);
-            err.name = "InvalidBucketName";
-            throw err;
-        }
-        return next({ ...args });
-    };
-}
-exports.validateBucketNameMiddleware = validateBucketNameMiddleware;
-exports.validateBucketNameMiddlewareOptions = {
-    step: "initialize",
-    tags: ["VALIDATE_BUCKET_NAME"],
-    name: "validateBucketNameMiddleware",
-    override: true,
-};
-const getValidateBucketNamePlugin = (unused) => ({
-    applyToStack: (clientStack) => {
-        clientStack.add(validateBucketNameMiddleware(), exports.validateBucketNameMiddlewareOptions);
-    },
-});
-exports.getValidateBucketNamePlugin = getValidateBucketNamePlugin;
+module.exports = require("./index.js");

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@aws-sdk/middleware-sdk-s3",
-  "version": "3.485.0",
+  "version": "3.495.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:cjs": "node ../../scripts/compilation/inline middleware-sdk-s3",
     "build:es": "tsc -p tsconfig.es.json",
     "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
     "build:types": "tsc -p tsconfig.types.json",
@@ -23,14 +23,14 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "3.485.0",
-    "@aws-sdk/util-arn-parser": "3.465.0",
-    "@smithy/node-config-provider": "^2.1.9",
-    "@smithy/protocol-http": "^3.0.12",
-    "@smithy/signature-v4": "^2.0.0",
-    "@smithy/smithy-client": "^2.2.1",
-    "@smithy/types": "^2.8.0",
-    "@smithy/util-config-provider": "^2.1.0",
+    "@aws-sdk/types": "3.495.0",
+    "@aws-sdk/util-arn-parser": "3.495.0",
+    "@smithy/node-config-provider": "^2.2.0",
+    "@smithy/protocol-http": "^3.1.0",
+    "@smithy/signature-v4": "^2.1.0",
+    "@smithy/smithy-client": "^2.3.0",
+    "@smithy/types": "^2.9.0",
+    "@smithy/util-config-provider": "^2.2.0",
     "tslib": "^2.5.0"
   },
   "devDependencies": {