aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
327 lines • 46.5 kB
JavaScript
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var SDK_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.isUnrecoverableAwsError = exports.SDK = void 0;
const AWS = require("aws-sdk");
const _env_1 = require("./_env");
const account_cache_1 = require("./account-cache");
const cached_1 = require("./cached");
const tracing_1 = require("../../util/tracing");
// We need to map regions to domain suffixes, and the SDK already has a function to do this.
// It's not part of the public API, but it's also unlikely to go away.
//
// Reuse that function, and add a safety check, so we don't accidentally break if they ever
// refactor that away.
/* eslint-disable @typescript-eslint/no-require-imports */
const regionUtil = require('aws-sdk/lib/region_config');
require('aws-sdk/lib/maintenance_mode_message').suppress = true;
/* eslint-enable @typescript-eslint/no-require-imports */
if (!regionUtil.getEndpointSuffix) {
throw new Error('This version of AWS SDK for JS does not have the \'getEndpointSuffix\' function!');
}
/**
* Base functionality of SDK without credential fetching
*/
let SDK = exports.SDK = SDK_1 = class SDK {
constructor(_credentials, region, httpOptions = {}, sdkOptions = {}) {
this._credentials = _credentials;
this.sdkOptions = sdkOptions;
/**
* Default retry options for SDK clients.
*/
this.retryOptions = { maxRetries: 6, retryDelayOptions: { base: 300 } };
/**
* The more generous retry policy for CloudFormation, which has a 1 TPM limit on certain APIs,
* which are abundantly used for deployment tracking, ...
*
* So we're allowing way more retries, but waiting a bit more.
*/
this.cloudFormationRetryOptions = { maxRetries: 10, retryDelayOptions: { base: 1000 } };
/**
* STS is used to check credential validity, don't do too many retries.
*/
this.stsRetryOptions = { maxRetries: 3, retryDelayOptions: { base: 100 } };
/**
* Whether we have proof that the credentials have not expired
*
* We need to do some manual plumbing around this because the JS SDKv2 treats `ExpiredToken`
* as retriable and we have hefty retries on CFN calls making the CLI hang for a good 15 minutes
* if the credentials have expired.
*/
this._credentialsValidated = false;
this.config = {
...httpOptions,
...this.retryOptions,
credentials: _credentials,
region,
logger: { log: (...messages) => messages.forEach(m => (0, _env_1.trace)('%s', m)) },
};
this.currentRegion = region;
}
appendCustomUserAgent(userAgentData) {
if (!userAgentData) {
return;
}
const currentCustomUserAgent = this.config.customUserAgent;
this.config.customUserAgent = currentCustomUserAgent
? `${currentCustomUserAgent} ${userAgentData}`
: userAgentData;
}
removeCustomUserAgent(userAgentData) {
this.config.customUserAgent = this.config.customUserAgent?.replace(userAgentData, '');
}
lambda() {
return this.wrapServiceErrorHandling(new AWS.Lambda(this.config));
}
cloudFormation() {
return this.wrapServiceErrorHandling(new AWS.CloudFormation({
...this.config,
...this.cloudFormationRetryOptions,
}));
}
ec2() {
return this.wrapServiceErrorHandling(new AWS.EC2(this.config));
}
iam() {
return this.wrapServiceErrorHandling(new AWS.IAM(this.config));
}
ssm() {
return this.wrapServiceErrorHandling(new AWS.SSM(this.config));
}
s3() {
return this.wrapServiceErrorHandling(new AWS.S3(this.config));
}
route53() {
return this.wrapServiceErrorHandling(new AWS.Route53(this.config));
}
ecr() {
return this.wrapServiceErrorHandling(new AWS.ECR(this.config));
}
ecs() {
return this.wrapServiceErrorHandling(new AWS.ECS(this.config));
}
elbv2() {
return this.wrapServiceErrorHandling(new AWS.ELBv2(this.config));
}
secretsManager() {
return this.wrapServiceErrorHandling(new AWS.SecretsManager(this.config));
}
kms() {
return this.wrapServiceErrorHandling(new AWS.KMS(this.config));
}
stepFunctions() {
return this.wrapServiceErrorHandling(new AWS.StepFunctions(this.config));
}
codeBuild() {
return this.wrapServiceErrorHandling(new AWS.CodeBuild(this.config));
}
cloudWatchLogs() {
return this.wrapServiceErrorHandling(new AWS.CloudWatchLogs(this.config));
}
appsync() {
return this.wrapServiceErrorHandling(new AWS.AppSync(this.config));
}
async currentAccount() {
// Get/refresh if necessary before we can access `accessKeyId`
await this.forceCredentialRetrieval();
return (0, cached_1.cached)(this, CURRENT_ACCOUNT_KEY, () => SDK_1.accountCache.fetch(this._credentials.accessKeyId, async () => {
// if we don't have one, resolve from STS and store in cache.
(0, _env_1.debug)('Looking up default account ID from STS');
const result = await new AWS.STS({ ...this.config, ...this.stsRetryOptions }).getCallerIdentity().promise();
const accountId = result.Account;
const partition = result.Arn.split(':')[1];
if (!accountId) {
throw new Error('STS didn\'t return an account ID');
}
(0, _env_1.debug)('Default account ID:', accountId);
// Save another STS call later if this one already succeeded
this._credentialsValidated = true;
return { accountId, partition };
}));
}
/**
* Return the current credentials
*
* Don't use -- only used to write tests around assuming roles.
*/
async currentCredentials() {
await this.forceCredentialRetrieval();
return this._credentials;
}
/**
* Force retrieval of the current credentials
*
* Relevant if the current credentials are AssumeRole credentials -- do the actual
* lookup, and translate any error into a useful error message (taking into
* account credential provenance).
*/
async forceCredentialRetrieval() {
try {
await this._credentials.getPromise();
}
catch (e) {
if (isUnrecoverableAwsError(e)) {
throw e;
}
// Only reason this would fail is if it was an AssumRole. Otherwise,
// reading from an INI file or reading env variables is unlikely to fail.
(0, _env_1.debug)(`Assuming role failed: ${e.message}`);
throw new Error([
'Could not assume role in target account',
...this.sdkOptions.assumeRoleCredentialsSourceDescription
? [`using ${this.sdkOptions.assumeRoleCredentialsSourceDescription}`]
: [],
e.message,
'. Please make sure that this role exists in the account. If it doesn\'t exist, (re)-bootstrap the environment ' +
'with the right \'--trust\', using the latest version of the CDK CLI.',
].join(' '));
}
}
/**
* Make sure the the current credentials are not expired
*/
async validateCredentials() {
if (this._credentialsValidated) {
return;
}
await new AWS.STS({ ...this.config, ...this.stsRetryOptions }).getCallerIdentity().promise();
this._credentialsValidated = true;
}
getEndpointSuffix(region) {
return regionUtil.getEndpointSuffix(region);
}
/**
* Return a wrapping object for the underlying service object
*
* Responds to failures in the underlying service calls, in two different
* ways:
*
* - When errors are encountered, log the failing call and the error that
* it triggered (at debug level). This is necessary because the lack of
* stack traces in NodeJS otherwise makes it very hard to suss out where
* a certain AWS error occurred.
* - The JS SDK has a funny business of wrapping any credential-based error
* in a super-generic (and in our case wrong) exception. If we then use a
* 'ChainableTemporaryCredentials' and the target role doesn't exist,
* the error message that shows up by default is super misleading
* (https://github.com/aws/aws-sdk-js/issues/3272). We can fix this because
* the exception contains the "inner exception", so we unwrap and throw
* the correct error ("cannot assume role").
*
* The wrapping business below is slightly more complicated than you'd think
* because we must hook into the `promise()` method of the object that's being
* returned from the methods of the object that we wrap, so there's two
* levels of wrapping going on, and also some exceptions to the wrapping magic.
*/
wrapServiceErrorHandling(serviceObject) {
const classObject = serviceObject.constructor.prototype;
const self = this;
return new Proxy(serviceObject, {
get(obj, prop) {
const real = obj[prop];
// Things we don't want to intercept:
// - Anything that's not a function.
// - 'constructor', s3.upload() will use this to do some magic and we need the underlying constructor.
// - Any method that's not on the service class (do not intercept 'makeRequest' and other helpers).
if (prop === 'constructor' || !classObject.hasOwnProperty(prop) || !isFunction(real)) {
return real;
}
// NOTE: This must be a function() and not an () => {
// because I need 'this' to be dynamically bound and not statically bound.
// If your linter complains don't listen to it!
return function () {
// Call the underlying function. If it returns an object with a promise()
// method on it, wrap that 'promise' method.
const args = [].slice.call(arguments, 0);
const response = real.apply(this, args);
// Don't intercept unless the return value is an object with a '.promise()' method.
if (typeof response !== 'object' || !response) {
return response;
}
if (!('promise' in response)) {
return response;
}
// Return an object with the promise method replaced with a wrapper which will
// do additional things to errors.
return Object.assign(Object.create(response), {
promise() {
return response.promise().catch((e) => {
e = self.makeDetailedException(e);
(0, _env_1.debug)(`Call failed: ${prop}(${JSON.stringify(args[0])}) => ${e.message} (code=${e.code})`);
return Promise.reject(e); // Re-'throw' the new error
});
},
});
};
},
});
}
/**
* Extract a more detailed error out of a generic error if we can
*
* If this is an error about Assuming Roles, add in the context showing the
* chain of credentials we used to try to assume the role.
*/
makeDetailedException(e) {
// This is the super-generic "something's wrong" error that the JS SDK wraps other errors in.
// https://github.com/aws/aws-sdk-js/blob/f0ac2e53457c7512883d0677013eacaad6cd8a19/lib/event_listeners.js#L84
if (typeof e.message === 'string' && e.message.startsWith('Missing credentials in config')) {
const original = e.originalError;
if (original) {
// When the SDK does a 'util.copy', they lose the Error-ness of the inner error
// (they copy the Error's properties into a plain object) so make it an Error object again.
e = Object.assign(new Error(), original);
}
}
// At this point, the error might still be a generic "ChainableTemporaryCredentials failed"
// error which wraps the REAL error (AssumeRole failed). We're going to replace the error
// message with one that's more likely to help users, and tell them the most probable
// fix (bootstrapping). The underlying service call failure will be appended below.
if (e.message === 'Could not load credentials from ChainableTemporaryCredentials') {
e.message = [
'Could not assume role in target account',
...this.sdkOptions.assumeRoleCredentialsSourceDescription
? [`using ${this.sdkOptions.assumeRoleCredentialsSourceDescription}`]
: [],
'(did you bootstrap the environment with the right \'--trust\'s?)',
].join(' ');
}
// Replace the message on this error with a concatenation of all inner error messages.
// Must more clear what's going on that way.
e.message = allChainedExceptionMessages(e);
return e;
}
};
SDK.accountCache = new account_cache_1.AccountAccessKeyCache();
exports.SDK = SDK = SDK_1 = __decorate([
tracing_1.traceMethods
], SDK);
const CURRENT_ACCOUNT_KEY = Symbol('current_account_key');
function isFunction(x) {
return x && {}.toString.call(x) === '[object Function]';
}
/**
* Return the concatenated message of all exceptions in the AWS exception chain
*/
function allChainedExceptionMessages(e) {
const ret = new Array();
while (e) {
ret.push(e.message);
e = e.originalError;
}
return ret.join(': ');
}
/**
* Return whether an error should not be recovered from
*/
function isUnrecoverableAwsError(e) {
return e.code === 'ExpiredToken';
}
exports.isUnrecoverableAwsError = isUnrecoverableAwsError;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk.js","sourceRoot":"","sources":["sdk.ts"],"names":[],"mappings":"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","sourcesContent":["import * as AWS from 'aws-sdk';\nimport type { ConfigurationOptions } from 'aws-sdk/lib/config-base';\nimport { debug, trace } from './_env';\nimport { AccountAccessKeyCache } from './account-cache';\nimport { cached } from './cached';\nimport { Account } from './sdk-provider';\nimport { traceMethods } from '../../util/tracing';\n\n// We need to map regions to domain suffixes, and the SDK already has a function to do this.\n// It's not part of the public API, but it's also unlikely to go away.\n//\n// Reuse that function, and add a safety check, so we don't accidentally break if they ever\n// refactor that away.\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst regionUtil = require('aws-sdk/lib/region_config');\nrequire('aws-sdk/lib/maintenance_mode_message').suppress = true;\n/* eslint-enable @typescript-eslint/no-require-imports */\n\nif (!regionUtil.getEndpointSuffix) {\n  throw new Error('This version of AWS SDK for JS does not have the \\'getEndpointSuffix\\' function!');\n}\n\nexport interface ISDK {\n  /**\n   * The region this SDK has been instantiated for\n   *\n   * (As distinct from the `defaultRegion()` on SdkProvider which\n   * represents the region configured in the default config).\n   */\n  readonly currentRegion: string;\n\n  /**\n   * The Account this SDK has been instantiated for\n   *\n   * (As distinct from the `defaultAccount()` on SdkProvider which\n   * represents the account available by using default credentials).\n   */\n  currentAccount(): Promise<Account>;\n\n  getEndpointSuffix(region: string): string;\n\n  /**\n   * Appends the given string as the extra information to put into the User-Agent header for any requests invoked by this SDK.\n   * If the string is 'undefined', this method has no effect.\n   */\n  appendCustomUserAgent(userAgentData?: string): void;\n\n  /**\n   * Removes the given string from the extra User-Agent header data used for requests invoked by this SDK.\n   */\n  removeCustomUserAgent(userAgentData: string): void;\n\n  lambda(): AWS.Lambda;\n  cloudFormation(): AWS.CloudFormation;\n  ec2(): AWS.EC2;\n  iam(): AWS.IAM;\n  ssm(): AWS.SSM;\n  s3(): AWS.S3;\n  route53(): AWS.Route53;\n  ecr(): AWS.ECR;\n  ecs(): AWS.ECS;\n  elbv2(): AWS.ELBv2;\n  secretsManager(): AWS.SecretsManager;\n  kms(): AWS.KMS;\n  stepFunctions(): AWS.StepFunctions;\n  codeBuild(): AWS.CodeBuild\n  cloudWatchLogs(): AWS.CloudWatchLogs;\n  appsync(): AWS.AppSync;\n}\n\n/**\n * Additional SDK configuration options\n */\nexport interface SdkOptions {\n  /**\n   * Additional descriptive strings that indicate where the \"AssumeRole\" credentials are coming from\n   *\n   * Will be printed in an error message to help users diagnose auth problems.\n   */\n  readonly assumeRoleCredentialsSourceDescription?: string;\n}\n\n/**\n * Base functionality of SDK without credential fetching\n */\n@traceMethods\nexport class SDK implements ISDK {\n  private static readonly accountCache = new AccountAccessKeyCache();\n\n  public readonly currentRegion: string;\n\n  private readonly config: ConfigurationOptions;\n\n  /**\n   * Default retry options for SDK clients.\n   */\n  private readonly retryOptions = { maxRetries: 6, retryDelayOptions: { base: 300 } };\n\n  /**\n   * The more generous retry policy for CloudFormation, which has a 1 TPM limit on certain APIs,\n   * which are abundantly used for deployment tracking, ...\n   *\n   * So we're allowing way more retries, but waiting a bit more.\n   */\n  private readonly cloudFormationRetryOptions = { maxRetries: 10, retryDelayOptions: { base: 1_000 } };\n\n  /**\n   * STS is used to check credential validity, don't do too many retries.\n   */\n  private readonly stsRetryOptions = { maxRetries: 3, retryDelayOptions: { base: 100 } };\n\n  /**\n   * Whether we have proof that the credentials have not expired\n   *\n   * We need to do some manual plumbing around this because the JS SDKv2 treats `ExpiredToken`\n   * as retriable and we have hefty retries on CFN calls making the CLI hang for a good 15 minutes\n   * if the credentials have expired.\n   */\n  private _credentialsValidated = false;\n\n  constructor(\n    private readonly _credentials: AWS.Credentials,\n    region: string,\n    httpOptions: ConfigurationOptions = {},\n    private readonly sdkOptions: SdkOptions = {}) {\n\n    this.config = {\n      ...httpOptions,\n      ...this.retryOptions,\n      credentials: _credentials,\n      region,\n      logger: { log: (...messages) => messages.forEach(m => trace('%s', m)) },\n    };\n    this.currentRegion = region;\n  }\n\n  public appendCustomUserAgent(userAgentData?: string): void {\n    if (!userAgentData) {\n      return;\n    }\n\n    const currentCustomUserAgent = this.config.customUserAgent;\n    this.config.customUserAgent = currentCustomUserAgent\n      ? `${currentCustomUserAgent} ${userAgentData}`\n      : userAgentData;\n  }\n\n  public removeCustomUserAgent(userAgentData: string): void {\n    this.config.customUserAgent = this.config.customUserAgent?.replace(userAgentData, '');\n  }\n\n  public lambda(): AWS.Lambda {\n    return this.wrapServiceErrorHandling(new AWS.Lambda(this.config));\n  }\n\n  public cloudFormation(): AWS.CloudFormation {\n    return this.wrapServiceErrorHandling(new AWS.CloudFormation({\n      ...this.config,\n      ...this.cloudFormationRetryOptions,\n    }));\n  }\n\n  public ec2(): AWS.EC2 {\n    return this.wrapServiceErrorHandling(new AWS.EC2(this.config));\n  }\n\n  public iam(): AWS.IAM {\n    return this.wrapServiceErrorHandling(new AWS.IAM(this.config));\n  }\n\n  public ssm(): AWS.SSM {\n    return this.wrapServiceErrorHandling(new AWS.SSM(this.config));\n  }\n\n  public s3(): AWS.S3 {\n    return this.wrapServiceErrorHandling(new AWS.S3(this.config));\n  }\n\n  public route53(): AWS.Route53 {\n    return this.wrapServiceErrorHandling(new AWS.Route53(this.config));\n  }\n\n  public ecr(): AWS.ECR {\n    return this.wrapServiceErrorHandling(new AWS.ECR(this.config));\n  }\n\n  public ecs(): AWS.ECS {\n    return this.wrapServiceErrorHandling(new AWS.ECS(this.config));\n  }\n\n  public elbv2(): AWS.ELBv2 {\n    return this.wrapServiceErrorHandling(new AWS.ELBv2(this.config));\n  }\n\n  public secretsManager(): AWS.SecretsManager {\n    return this.wrapServiceErrorHandling(new AWS.SecretsManager(this.config));\n  }\n\n  public kms(): AWS.KMS {\n    return this.wrapServiceErrorHandling(new AWS.KMS(this.config));\n  }\n\n  public stepFunctions(): AWS.StepFunctions {\n    return this.wrapServiceErrorHandling(new AWS.StepFunctions(this.config));\n  }\n\n  public codeBuild(): AWS.CodeBuild {\n    return this.wrapServiceErrorHandling(new AWS.CodeBuild(this.config));\n  }\n\n  public cloudWatchLogs(): AWS.CloudWatchLogs {\n    return this.wrapServiceErrorHandling(new AWS.CloudWatchLogs(this.config));\n  }\n\n  public appsync(): AWS.AppSync {\n    return this.wrapServiceErrorHandling(new AWS.AppSync(this.config));\n  }\n\n  public async currentAccount(): Promise<Account> {\n    // Get/refresh if necessary before we can access `accessKeyId`\n    await this.forceCredentialRetrieval();\n\n    return cached(this, CURRENT_ACCOUNT_KEY, () => SDK.accountCache.fetch(this._credentials.accessKeyId, async () => {\n      // if we don't have one, resolve from STS and store in cache.\n      debug('Looking up default account ID from STS');\n      const result = await new AWS.STS({ ...this.config, ...this.stsRetryOptions }).getCallerIdentity().promise();\n      const accountId = result.Account;\n      const partition = result.Arn!.split(':')[1];\n      if (!accountId) {\n        throw new Error('STS didn\\'t return an account ID');\n      }\n      debug('Default account ID:', accountId);\n\n      // Save another STS call later if this one already succeeded\n      this._credentialsValidated = true;\n      return { accountId, partition };\n    }));\n  }\n\n  /**\n   * Return the current credentials\n   *\n   * Don't use -- only used to write tests around assuming roles.\n   */\n  public async currentCredentials(): Promise<AWS.Credentials> {\n    await this.forceCredentialRetrieval();\n    return this._credentials;\n  }\n\n  /**\n   * Force retrieval of the current credentials\n   *\n   * Relevant if the current credentials are AssumeRole credentials -- do the actual\n   * lookup, and translate any error into a useful error message (taking into\n   * account credential provenance).\n   */\n  public async forceCredentialRetrieval() {\n    try {\n      await this._credentials.getPromise();\n    } catch (e: any) {\n      if (isUnrecoverableAwsError(e)) {\n        throw e;\n      }\n\n      // Only reason this would fail is if it was an AssumRole. Otherwise,\n      // reading from an INI file or reading env variables is unlikely to fail.\n      debug(`Assuming role failed: ${e.message}`);\n      throw new Error([\n        'Could not assume role in target account',\n        ...this.sdkOptions.assumeRoleCredentialsSourceDescription\n          ? [`using ${this.sdkOptions.assumeRoleCredentialsSourceDescription}`]\n          : [],\n        e.message,\n        '. Please make sure that this role exists in the account. If it doesn\\'t exist, (re)-bootstrap the environment ' +\n        'with the right \\'--trust\\', using the latest version of the CDK CLI.',\n      ].join(' '));\n    }\n  }\n\n  /**\n   * Make sure the the current credentials are not expired\n   */\n  public async validateCredentials() {\n    if (this._credentialsValidated) {\n      return;\n    }\n\n    await new AWS.STS({ ...this.config, ...this.stsRetryOptions }).getCallerIdentity().promise();\n    this._credentialsValidated = true;\n  }\n\n  public getEndpointSuffix(region: string): string {\n    return regionUtil.getEndpointSuffix(region);\n  }\n\n  /**\n   * Return a wrapping object for the underlying service object\n   *\n   * Responds to failures in the underlying service calls, in two different\n   * ways:\n   *\n   * - When errors are encountered, log the failing call and the error that\n   *   it triggered (at debug level). This is necessary because the lack of\n   *   stack traces in NodeJS otherwise makes it very hard to suss out where\n   *   a certain AWS error occurred.\n   * - The JS SDK has a funny business of wrapping any credential-based error\n   *   in a super-generic (and in our case wrong) exception. If we then use a\n   *   'ChainableTemporaryCredentials' and the target role doesn't exist,\n   *   the error message that shows up by default is super misleading\n   *   (https://github.com/aws/aws-sdk-js/issues/3272). We can fix this because\n   *   the exception contains the \"inner exception\", so we unwrap and throw\n   *   the correct error (\"cannot assume role\").\n   *\n   * The wrapping business below is slightly more complicated than you'd think\n   * because we must hook into the `promise()` method of the object that's being\n   * returned from the methods of the object that we wrap, so there's two\n   * levels of wrapping going on, and also some exceptions to the wrapping magic.\n   */\n  private wrapServiceErrorHandling<A extends object>(serviceObject: A): A {\n    const classObject = serviceObject.constructor.prototype;\n    const self = this;\n\n    return new Proxy(serviceObject, {\n      get(obj: A, prop: string) {\n        const real = (obj as any)[prop];\n        // Things we don't want to intercept:\n        // - Anything that's not a function.\n        // - 'constructor', s3.upload() will use this to do some magic and we need the underlying constructor.\n        // - Any method that's not on the service class (do not intercept 'makeRequest' and other helpers).\n        if (prop === 'constructor' || !classObject.hasOwnProperty(prop) || !isFunction(real)) { return real; }\n\n        // NOTE: This must be a function() and not an () => {\n        // because I need 'this' to be dynamically bound and not statically bound.\n        // If your linter complains don't listen to it!\n        return function(this: any) {\n          // Call the underlying function. If it returns an object with a promise()\n          // method on it, wrap that 'promise' method.\n          const args = [].slice.call(arguments, 0);\n          const response = real.apply(this, args);\n\n          // Don't intercept unless the return value is an object with a '.promise()' method.\n          if (typeof response !== 'object' || !response) { return response; }\n          if (!('promise' in response)) { return response; }\n\n          // Return an object with the promise method replaced with a wrapper which will\n          // do additional things to errors.\n          return Object.assign(Object.create(response), {\n            promise() {\n              return response.promise().catch((e: Error & { code?: string }) => {\n                e = self.makeDetailedException(e);\n                debug(`Call failed: ${prop}(${JSON.stringify(args[0])}) => ${e.message} (code=${e.code})`);\n                return Promise.reject(e); // Re-'throw' the new error\n              });\n            },\n          });\n        };\n      },\n    });\n  }\n\n  /**\n   * Extract a more detailed error out of a generic error if we can\n   *\n   * If this is an error about Assuming Roles, add in the context showing the\n   * chain of credentials we used to try to assume the role.\n   */\n  private makeDetailedException(e: Error): Error {\n    // This is the super-generic \"something's wrong\" error that the JS SDK wraps other errors in.\n    // https://github.com/aws/aws-sdk-js/blob/f0ac2e53457c7512883d0677013eacaad6cd8a19/lib/event_listeners.js#L84\n    if (typeof e.message === 'string' && e.message.startsWith('Missing credentials in config')) {\n      const original = (e as any).originalError;\n      if (original) {\n        // When the SDK does a 'util.copy', they lose the Error-ness of the inner error\n        // (they copy the Error's properties into a plain object) so make it an Error object again.\n        e = Object.assign(new Error(), original);\n      }\n    }\n\n    // At this point, the error might still be a generic \"ChainableTemporaryCredentials failed\"\n    // error which wraps the REAL error (AssumeRole failed). We're going to replace the error\n    // message with one that's more likely to help users, and tell them the most probable\n    // fix (bootstrapping). The underlying service call failure will be appended below.\n    if (e.message === 'Could not load credentials from ChainableTemporaryCredentials') {\n      e.message = [\n        'Could not assume role in target account',\n        ...this.sdkOptions.assumeRoleCredentialsSourceDescription\n          ? [`using ${this.sdkOptions.assumeRoleCredentialsSourceDescription}`]\n          : [],\n        '(did you bootstrap the environment with the right \\'--trust\\'s?)',\n      ].join(' ');\n    }\n\n    // Replace the message on this error with a concatenation of all inner error messages.\n    // Must more clear what's going on that way.\n    e.message = allChainedExceptionMessages(e);\n    return e;\n  }\n}\n\nconst CURRENT_ACCOUNT_KEY = Symbol('current_account_key');\n\nfunction isFunction(x: any): x is (...args: any[]) => any {\n  return x && {}.toString.call(x) === '[object Function]';\n}\n\n/**\n * Return the concatenated message of all exceptions in the AWS exception chain\n */\nfunction allChainedExceptionMessages(e: Error | undefined) {\n  const ret = new Array<string>();\n  while (e) {\n    ret.push(e.message);\n    e = (e as any).originalError;\n  }\n  return ret.join(': ');\n}\n\n/**\n * Return whether an error should not be recovered from\n */\nexport function isUnrecoverableAwsError(e: Error) {\n  return (e as any).code === 'ExpiredToken';\n}\n"]}