@aws-sdk/middleware-sdk-s3 3.622.0 → 3.626.0

package/dist-cjs/index.js

@@ -31,6 +31,7 @@ __export(src_exports, {
   getCheckContentLengthHeaderPlugin: () => getCheckContentLengthHeaderPlugin,
   getRegionRedirectMiddlewarePlugin: () => getRegionRedirectMiddlewarePlugin,
   getS3ExpiresMiddlewarePlugin: () => getS3ExpiresMiddlewarePlugin,
+  getS3ExpressHttpSigningPlugin: () => getS3ExpressHttpSigningPlugin,
   getS3ExpressPlugin: () => getS3ExpressPlugin,
   getThrow200ExceptionsPlugin: () => getThrow200ExceptionsPlugin,
   getValidateBucketNamePlugin: () => getValidateBucketNamePlugin,
@@ -41,6 +42,8 @@ __export(src_exports, {
   resolveS3Config: () => resolveS3Config,
   s3ExpiresMiddleware: () => s3ExpiresMiddleware,
   s3ExpiresMiddlewareOptions: () => s3ExpiresMiddlewareOptions,
+  s3ExpressHttpSigningMiddleware: () => s3ExpressHttpSigningMiddleware,
+  s3ExpressHttpSigningMiddlewareOptions: () => s3ExpressHttpSigningMiddlewareOptions,
   s3ExpressMiddleware: () => s3ExpressMiddleware,
   s3ExpressMiddlewareOptions: () => s3ExpressMiddlewareOptions,
   throw200ExceptionsMiddleware: () => throw200ExceptionsMiddleware,
@@ -89,20 +92,34 @@ var regionRedirectEndpointMiddleware = /* @__PURE__ */ __name((config) => {
   return (next, context) => async (args) => {
     const originalRegion = await config.region();
     const regionProviderRef = config.region;
+    let unlock = /* @__PURE__ */ __name(() => {
+    }, "unlock");
     if (context.__s3RegionRedirect) {
-      config.region = async () => {
-        config.region = regionProviderRef;
-        return context.__s3RegionRedirect;
-      };
+      Object.defineProperty(config, "region", {
+        writable: false,
+        value: async () => {
+          return context.__s3RegionRedirect;
+        }
+      });
+      unlock = /* @__PURE__ */ __name(() => Object.defineProperty(config, "region", {
+        writable: true,
+        value: regionProviderRef
+      }), "unlock");
     }
-    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.");
+    try {
+      const result = await next(args);
+      if (context.__s3RegionRedirect) {
+        unlock();
+        const region = await config.region();
+        if (originalRegion !== region) {
+          throw new Error("Region was not restored following S3 region redirect.");
+        }
       }
+      return result;
+    } catch (e) {
+      unlock();
+      throw e;
     }
-    return result;
   };
 }, "regionRedirectEndpointMiddleware");
 var regionRedirectEndpointMiddlewareOptions = {
@@ -416,6 +433,68 @@ var getS3ExpressPlugin = /* @__PURE__ */ __name((options) => ({
   }
 }), "getS3ExpressPlugin");
 
+// src/s3-express/functions/s3ExpressHttpSigningMiddleware.ts
+var import_core = require("@smithy/core");
+
+var import_util_middleware = require("@smithy/util-middleware");
+
+// src/s3-express/functions/signS3Express.ts
+var signS3Express = /* @__PURE__ */ __name(async (s3ExpressIdentity, signingOptions, request, sigV4MultiRegionSigner) => {
+  const signedRequest = await sigV4MultiRegionSigner.signWithCredentials(request, s3ExpressIdentity, {});
+  if (signedRequest.headers["X-Amz-Security-Token"] || signedRequest.headers["x-amz-security-token"]) {
+    throw new Error("X-Amz-Security-Token must not be set for s3-express requests.");
+  }
+  return signedRequest;
+}, "signS3Express");
+
+// src/s3-express/functions/s3ExpressHttpSigningMiddleware.ts
+var defaultErrorHandler = /* @__PURE__ */ __name((signingProperties) => (error) => {
+  throw error;
+}, "defaultErrorHandler");
+var defaultSuccessHandler = /* @__PURE__ */ __name((httpResponse, signingProperties) => {
+}, "defaultSuccessHandler");
+var s3ExpressHttpSigningMiddlewareOptions = import_core.httpSigningMiddlewareOptions;
+var s3ExpressHttpSigningMiddleware = /* @__PURE__ */ __name((config) => (next, context) => async (args) => {
+  if (!import_protocol_http.HttpRequest.isInstance(args.request)) {
+    return next(args);
+  }
+  const smithyContext = (0, import_util_middleware.getSmithyContext)(context);
+  const scheme = smithyContext.selectedHttpAuthScheme;
+  if (!scheme) {
+    throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
+  }
+  const {
+    httpAuthOption: { signingProperties = {} },
+    identity,
+    signer
+  } = scheme;
+  let request;
+  if (context.s3ExpressIdentity) {
+    request = await signS3Express(
+      context.s3ExpressIdentity,
+      signingProperties,
+      args.request,
+      await config.signer()
+    );
+  } else {
+    request = await signer.sign(args.request, identity, signingProperties);
+  }
+  const output = await next({
+    ...args,
+    request
+  }).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
+  (signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
+  return output;
+}, "s3ExpressHttpSigningMiddleware");
+var getS3ExpressHttpSigningPlugin = /* @__PURE__ */ __name((config) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(
+      s3ExpressHttpSigningMiddleware(config),
+      import_core.httpSigningMiddlewareOptions
+    );
+  }
+}), "getS3ExpressHttpSigningPlugin");
+
 // src/s3Configuration.ts
 var resolveS3Config = /* @__PURE__ */ __name((input, {
   session
@@ -589,6 +668,9 @@ var getValidateBucketNamePlugin = /* @__PURE__ */ __name((options) => ({
   getS3ExpressPlugin,
   s3ExpressMiddleware,
   s3ExpressMiddlewareOptions,
+  getS3ExpressHttpSigningPlugin,
+  s3ExpressHttpSigningMiddleware,
+  s3ExpressHttpSigningMiddlewareOptions,
   resolveS3Config,
   throw200ExceptionsMiddleware,
   throw200ExceptionsMiddlewareOptions,

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

@@ -2,20 +2,34 @@ export const regionRedirectEndpointMiddleware = (config) => {
     return (next, context) => async (args) => {
         const originalRegion = await config.region();
         const regionProviderRef = config.region;
+        let unlock = () => { };
         if (context.__s3RegionRedirect) {
-            config.region = async () => {
-                config.region = regionProviderRef;
-                return context.__s3RegionRedirect;
-            };
+            Object.defineProperty(config, "region", {
+                writable: false,
+                value: async () => {
+                    return context.__s3RegionRedirect;
+                },
+            });
+            unlock = () => Object.defineProperty(config, "region", {
+                writable: true,
+                value: regionProviderRef,
+            });
         }
-        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.");
+        try {
+            const result = await next(args);
+            if (context.__s3RegionRedirect) {
+                unlock();
+                const region = await config.region();
+                if (originalRegion !== region) {
+                    throw new Error("Region was not restored following S3 region redirect.");
+                }
             }
+            return result;
+        }
+        catch (e) {
+            unlock();
+            throw e;
         }
-        return result;
     };
 };
 export const regionRedirectEndpointMiddlewareOptions = {

package/dist-es/s3-express/functions/s3ExpressHttpSigningMiddleware.js

@@ -0,0 +1,39 @@
+import { httpSigningMiddlewareOptions } from "@smithy/core";
+import { HttpRequest } from "@smithy/protocol-http";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { getSmithyContext } from "@smithy/util-middleware";
+import { signS3Express } from "./signS3Express";
+const defaultErrorHandler = (signingProperties) => (error) => {
+    throw error;
+};
+const defaultSuccessHandler = (httpResponse, signingProperties) => { };
+export const s3ExpressHttpSigningMiddlewareOptions = httpSigningMiddlewareOptions;
+export const s3ExpressHttpSigningMiddleware = (config) => (next, context) => async (args) => {
+    if (!HttpRequest.isInstance(args.request)) {
+        return next(args);
+    }
+    const smithyContext = getSmithyContext(context);
+    const scheme = smithyContext.selectedHttpAuthScheme;
+    if (!scheme) {
+        throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
+    }
+    const { httpAuthOption: { signingProperties = {} }, identity, signer, } = scheme;
+    let request;
+    if (context.s3ExpressIdentity) {
+        request = await signS3Express(context.s3ExpressIdentity, signingProperties, args.request, await config.signer());
+    }
+    else {
+        request = await signer.sign(args.request, identity, signingProperties);
+    }
+    const output = await next({
+        ...args,
+        request,
+    }).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
+    (signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
+    return output;
+};
+export const getS3ExpressHttpSigningPlugin = (config) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(s3ExpressHttpSigningMiddleware(config), httpSigningMiddlewareOptions);
+    },
+});

package/dist-es/s3-express/functions/signS3Express.js

@@ -0,0 +1,7 @@
+export const signS3Express = async (s3ExpressIdentity, signingOptions, request, sigV4MultiRegionSigner) => {
+    const signedRequest = await sigV4MultiRegionSigner.signWithCredentials(request, s3ExpressIdentity, {});
+    if (signedRequest.headers["X-Amz-Security-Token"] || signedRequest.headers["x-amz-security-token"]) {
+        throw new Error("X-Amz-Security-Token must not be set for s3-express requests.");
+    }
+    return signedRequest;
+};

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

@@ -4,3 +4,4 @@ export { S3ExpressIdentityProviderImpl } from "./classes/S3ExpressIdentityProvid
 export { SignatureV4S3Express } from "./classes/SignatureV4S3Express";
 export { NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS } from "./constants";
 export { getS3ExpressPlugin, s3ExpressMiddleware, s3ExpressMiddlewareOptions } from "./functions/s3ExpressMiddleware";
+export { getS3ExpressHttpSigningPlugin, s3ExpressHttpSigningMiddleware, s3ExpressHttpSigningMiddlewareOptions, } from "./functions/s3ExpressHttpSigningMiddleware";

package/dist-types/s3-express/functions/s3ExpressHttpSigningMiddleware.d.ts

@@ -0,0 +1,27 @@
+import { IHttpRequest } from "@smithy/protocol-http";
+import { AuthScheme, AwsCredentialIdentity, FinalizeRequestMiddleware, Pluggable, RequestSigner } from "@smithy/types";
+interface SigningProperties {
+    signingRegion: string;
+    signingDate: Date;
+    signingService: string;
+}
+interface PreviouslyResolved {
+    signer: (authScheme?: AuthScheme | undefined) => Promise<RequestSigner & {
+        signWithCredentials(req: IHttpRequest, identity: AwsCredentialIdentity, opts?: Partial<SigningProperties>): Promise<IHttpRequest>;
+    }>;
+}
+/**
+ * @internal
+ */
+export declare const s3ExpressHttpSigningMiddlewareOptions: import("@smithy/types").FinalizeRequestHandlerOptions & import("@smithy/types").RelativeLocation & Omit<import("@smithy/types").HandlerOptions, "step">;
+/**
+ * @internal
+ */
+export declare const s3ExpressHttpSigningMiddleware: <Input extends object, Output extends object>(config: PreviouslyResolved) => FinalizeRequestMiddleware<any, any>;
+/**
+ * @internal
+ */
+export declare const getS3ExpressHttpSigningPlugin: (config: {
+    signer: (authScheme?: AuthScheme | undefined) => Promise<RequestSigner>;
+}) => Pluggable<any, any>;
+export {};

package/dist-types/s3-express/functions/signS3Express.d.ts

@@ -0,0 +1,13 @@
+import type { AwsCredentialIdentity, HttpRequest as IHttpRequest } from "@smithy/types";
+import { S3ExpressIdentity } from "../interfaces/S3ExpressIdentity";
+export declare const signS3Express: (s3ExpressIdentity: S3ExpressIdentity, signingOptions: {
+    signingDate: Date;
+    signingRegion: string;
+    signingService: string;
+}, request: IHttpRequest, sigV4MultiRegionSigner: {
+    signWithCredentials(req: IHttpRequest, identity: AwsCredentialIdentity, opts?: Partial<{
+        signingDate: Date;
+        signingRegion: string;
+        signingService: string;
+    }> | undefined): Promise<IHttpRequest>;
+}) => Promise<IHttpRequest>;

package/dist-types/s3-express/index.d.ts

@@ -4,5 +4,6 @@ export { S3ExpressIdentityProviderImpl } from "./classes/S3ExpressIdentityProvid
 export { SignatureV4S3Express } from "./classes/SignatureV4S3Express";
 export { NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS } from "./constants";
 export { getS3ExpressPlugin, s3ExpressMiddleware, s3ExpressMiddlewareOptions } from "./functions/s3ExpressMiddleware";
+export { getS3ExpressHttpSigningPlugin, s3ExpressHttpSigningMiddleware, s3ExpressHttpSigningMiddlewareOptions, } from "./functions/s3ExpressHttpSigningMiddleware";
 export { S3ExpressIdentity } from "./interfaces/S3ExpressIdentity";
 export { S3ExpressIdentityProvider } from "./interfaces/S3ExpressIdentityProvider";

package/dist-types/ts3.4/s3-express/functions/s3ExpressHttpSigningMiddleware.d.ts

@@ -0,0 +1,40 @@
+import { IHttpRequest } from "@smithy/protocol-http";
+import {
+  AuthScheme,
+  AwsCredentialIdentity,
+  FinalizeRequestMiddleware,
+  Pluggable,
+  RequestSigner,
+} from "@smithy/types";
+interface SigningProperties {
+  signingRegion: string;
+  signingDate: Date;
+  signingService: string;
+}
+interface PreviouslyResolved {
+  signer: (authScheme?: AuthScheme | undefined) => Promise<
+    RequestSigner & {
+      signWithCredentials(
+        req: IHttpRequest,
+        identity: AwsCredentialIdentity,
+        opts?: Partial<SigningProperties>
+      ): Promise<IHttpRequest>;
+    }
+  >;
+}
+export declare const s3ExpressHttpSigningMiddlewareOptions: import("@smithy/types").FinalizeRequestHandlerOptions &
+  import("@smithy/types").RelativeLocation &
+  Pick<
+    import("@smithy/types").HandlerOptions,
+    Exclude<keyof import("@smithy/types").HandlerOptions, "step">
+  >;
+export declare const s3ExpressHttpSigningMiddleware: <
+  Input extends object,
+  Output extends object
+>(
+  config: PreviouslyResolved
+) => FinalizeRequestMiddleware<any, any>;
+export declare const getS3ExpressHttpSigningPlugin: (config: {
+  signer: (authScheme?: AuthScheme | undefined) => Promise<RequestSigner>;
+}) => Pluggable<any, any>;
+export {};

package/dist-types/ts3.4/s3-express/functions/signS3Express.d.ts

@@ -0,0 +1,27 @@
+import {
+  AwsCredentialIdentity,
+  HttpRequest as IHttpRequest,
+} from "@smithy/types";
+import { S3ExpressIdentity } from "../interfaces/S3ExpressIdentity";
+export declare const signS3Express: (
+  s3ExpressIdentity: S3ExpressIdentity,
+  signingOptions: {
+    signingDate: Date;
+    signingRegion: string;
+    signingService: string;
+  },
+  request: IHttpRequest,
+  sigV4MultiRegionSigner: {
+    signWithCredentials(
+      req: IHttpRequest,
+      identity: AwsCredentialIdentity,
+      opts?:
+        | Partial<{
+            signingDate: Date;
+            signingRegion: string;
+            signingService: string;
+          }>
+        | undefined
+    ): Promise<IHttpRequest>;
+  }
+) => Promise<IHttpRequest>;

package/dist-types/ts3.4/s3-express/index.d.ts

@@ -8,5 +8,10 @@ export {
   s3ExpressMiddleware,
   s3ExpressMiddlewareOptions,
 } from "./functions/s3ExpressMiddleware";
+export {
+  getS3ExpressHttpSigningPlugin,
+  s3ExpressHttpSigningMiddleware,
+  s3ExpressHttpSigningMiddlewareOptions,
+} from "./functions/s3ExpressHttpSigningMiddleware";
 export { S3ExpressIdentity } from "./interfaces/S3ExpressIdentity";
 export { S3ExpressIdentityProvider } from "./interfaces/S3ExpressIdentityProvider";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-sdk-s3",
-  "version": "3.622.0",
+  "version": "3.626.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline middleware-sdk-s3",
@@ -23,14 +23,17 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
+    "@aws-sdk/core": "3.624.0",
     "@aws-sdk/types": "3.609.0",
     "@aws-sdk/util-arn-parser": "3.568.0",
+    "@smithy/core": "^2.3.2",
     "@smithy/node-config-provider": "^3.1.4",
     "@smithy/protocol-http": "^4.1.0",
     "@smithy/signature-v4": "^4.1.0",
     "@smithy/smithy-client": "^3.1.12",
     "@smithy/types": "^3.3.0",
     "@smithy/util-config-provider": "^3.0.0",
+    "@smithy/util-middleware": "^3.0.3",
     "@smithy/util-stream": "^3.1.3",
     "@smithy/util-utf8": "^3.0.0",
     "tslib": "^2.6.2"