@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/aws-auth/credential-plugins.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialPlugins = void 0;
+const util_1 = require("util");
+const provider_caching_1 = require("./provider-caching");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const util_2 = require("../../util");
+const private_1 = require("../io/private");
+/**
+ * Cache for credential providers.
+ *
+ * Given an account and an operating mode (read or write) will return an
+ * appropriate credential provider for credentials for the given account. The
+ * credential provider will be cached so that multiple AWS clients for the same
+ * environment will not make multiple network calls to obtain credentials.
+ *
+ * Will use default credentials if they are for the right account; otherwise,
+ * all loaded credential provider plugins will be tried to obtain credentials
+ * for the given account.
+ */
+class CredentialPlugins {
+    host;
+    ioHelper;
+    cache = {};
+    constructor(host, ioHelper) {
+        this.host = host;
+        this.ioHelper = ioHelper;
+    }
+    async fetchCredentialsFor(awsAccountId, mode) {
+        const key = `${awsAccountId}-${mode}`;
+        if (!(key in this.cache)) {
+            this.cache[key] = await this.lookupCredentials(awsAccountId, mode);
+        }
+        return this.cache[key];
+    }
+    get availablePluginNames() {
+        return this.host.credentialProviderSources.map((s) => s.name);
+    }
+    async lookupCredentials(awsAccountId, mode) {
+        const triedSources = [];
+        // Otherwise, inspect the various credential sources we have
+        for (const source of this.host.credentialProviderSources) {
+            let available;
+            try {
+                available = await source.isAvailable();
+            }
+            catch (e) {
+                // This shouldn't happen, but let's guard against it anyway
+                await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${(0, util_2.formatErrorMessage)(e)}`));
+                available = false;
+            }
+            if (!available) {
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Credentials source ${source.name} is not available, ignoring it.`));
+                continue;
+            }
+            triedSources.push(source);
+            let canProvide;
+            try {
+                canProvide = await source.canProvideCredentials(awsAccountId);
+            }
+            catch (e) {
+                // This shouldn't happen, but let's guard against it anyway
+                await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${(0, util_2.formatErrorMessage)(e)}`));
+                canProvide = false;
+            }
+            if (!canProvide) {
+                continue;
+            }
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Using ${source.name} credentials for account ${awsAccountId}`));
+            return {
+                credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode, {
+                    supportsV3Providers: true,
+                })),
+                pluginName: source.name,
+            };
+        }
+        return undefined;
+    }
+}
+exports.CredentialPlugins = CredentialPlugins;
+/**
+ * Take a function that calls the plugin, and turn it into an SDKv3-compatible credential provider.
+ *
+ * What we will do is the following:
+ *
+ * - Query the plugin and see what kind of result it gives us.
+ * - If the result is self-refreshing or doesn't need refreshing, we turn it into an SDKv3 provider
+ *   and return it directly.
+ *   * If the underlying return value is a provider, we will make it a caching provider
+ *     (because we can't know if it will cache by itself or not).
+ *   * If the underlying return value is a static credential, caching isn't relevant.
+ *   * If the underlying return value is V2 credentials, those have caching built-in.
+ * - If the result is a static credential that expires, we will wrap it in an SDKv3 provider
+ *   that will query the plugin again when the credential expires.
+ */
+async function v3ProviderFromPlugin(producer) {
+    const initial = await producer();
+    if (isV3Provider(initial)) {
+        // Already a provider, make caching
+        return (0, provider_caching_1.makeCachingProvider)(initial);
+    }
+    else if (isV3Credentials(initial) && initial.expiration === undefined) {
+        // Static credentials that don't need refreshing nor caching
+        return () => Promise.resolve(initial);
+    }
+    else if (isV3Credentials(initial) && initial.expiration !== undefined) {
+        // Static credentials that do need refreshing and caching
+        return refreshFromPluginProvider(initial, producer);
+    }
+    else if (isV2Credentials(initial)) {
+        // V2 credentials that refresh and cache themselves
+        return v3ProviderFromV2Credentials(initial);
+    }
+    else {
+        throw new toolkit_error_1.AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, util_1.inspect)(initial)}`);
+    }
+}
+/**
+ * Converts a V2 credential into a V3-compatible provider
+ */
+function v3ProviderFromV2Credentials(x) {
+    return async () => {
+        // Get will fetch or refresh as necessary
+        await x.getPromise();
+        return {
+            accessKeyId: x.accessKeyId,
+            secretAccessKey: x.secretAccessKey,
+            sessionToken: x.sessionToken,
+            expiration: x.expireTime ?? undefined,
+        };
+    };
+}
+function refreshFromPluginProvider(current, producer) {
+    return async () => {
+        if ((0, provider_caching_1.credentialsAboutToExpire)(current)) {
+            const newCreds = await producer();
+            if (!isV3Credentials(newCreds)) {
+                throw new toolkit_error_1.AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, util_1.inspect)(newCreds)}`);
+            }
+            current = newCreds;
+        }
+        return current;
+    };
+}
+function isV3Provider(x) {
+    return typeof x === 'function';
+}
+function isV2Credentials(x) {
+    return !!(x && typeof x === 'object' && x.getPromise);
+}
+function isV3Credentials(x) {
+    return !!(x && typeof x === 'object' && x.accessKeyId && !isV2Credentials(x));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-plugins.js","sourceRoot":"","sources":["credential-plugins.ts"],"names":[],"mappings":"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","sourcesContent":["import { inspect } from 'util';\nimport type { CredentialProviderSource, ForReading, ForWriting, PluginProviderResult, SDKv2CompatibleCredentials, SDKv3CompatibleCredentialProvider, SDKv3CompatibleCredentials } from '@aws-cdk/cli-plugin-contract';\nimport type { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types';\nimport { credentialsAboutToExpire, makeCachingProvider } from './provider-caching';\nimport { AuthenticationError } from '../../toolkit/toolkit-error';\nimport { formatErrorMessage } from '../../util';\nimport { IO, type IoHelper } from '../io/private';\nimport type { PluginHost } from '../plugin';\nimport type { Mode } from '../plugin/mode';\n\n/**\n * Cache for credential providers.\n *\n * Given an account and an operating mode (read or write) will return an\n * appropriate credential provider for credentials for the given account. The\n * credential provider will be cached so that multiple AWS clients for the same\n * environment will not make multiple network calls to obtain credentials.\n *\n * Will use default credentials if they are for the right account; otherwise,\n * all loaded credential provider plugins will be tried to obtain credentials\n * for the given account.\n */\nexport class CredentialPlugins {\n  private readonly cache: { [key: string]: PluginCredentialsFetchResult | undefined } = {};\n\n  constructor(private readonly host: PluginHost, private readonly ioHelper: IoHelper) {\n  }\n\n  public async fetchCredentialsFor(awsAccountId: string, mode: Mode): Promise<PluginCredentialsFetchResult | undefined> {\n    const key = `${awsAccountId}-${mode}`;\n    if (!(key in this.cache)) {\n      this.cache[key] = await this.lookupCredentials(awsAccountId, mode);\n    }\n    return this.cache[key];\n  }\n\n  public get availablePluginNames(): string[] {\n    return this.host.credentialProviderSources.map((s) => s.name);\n  }\n\n  private async lookupCredentials(awsAccountId: string, mode: Mode): Promise<PluginCredentialsFetchResult | undefined> {\n    const triedSources: CredentialProviderSource[] = [];\n    // Otherwise, inspect the various credential sources we have\n    for (const source of this.host.credentialProviderSources) {\n      let available: boolean;\n      try {\n        available = await source.isAvailable();\n      } catch (e: any) {\n        // This shouldn't happen, but let's guard against it anyway\n        await this.ioHelper.notify(IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${formatErrorMessage(e)}`));\n        available = false;\n      }\n\n      if (!available) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Credentials source ${source.name} is not available, ignoring it.`));\n        continue;\n      }\n      triedSources.push(source);\n      let canProvide: boolean;\n      try {\n        canProvide = await source.canProvideCredentials(awsAccountId);\n      } catch (e: any) {\n        // This shouldn't happen, but let's guard against it anyway\n        await this.ioHelper.notify(IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${formatErrorMessage(e)}`));\n        canProvide = false;\n      }\n      if (!canProvide) {\n        continue;\n      }\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Using ${source.name} credentials for account ${awsAccountId}`));\n\n      return {\n        credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode as ForReading | ForWriting, {\n          supportsV3Providers: true,\n        })),\n        pluginName: source.name,\n      };\n    }\n    return undefined;\n  }\n}\n\n/**\n * Result from trying to fetch credentials from the Plugin host\n */\nexport interface PluginCredentialsFetchResult {\n  /**\n   * SDK-v3 compatible credential provider\n   */\n  readonly credentials: AwsCredentialIdentityProvider;\n\n  /**\n   * Name of plugin that successfully provided credentials\n   */\n  readonly pluginName: string;\n}\n\n/**\n * Take a function that calls the plugin, and turn it into an SDKv3-compatible credential provider.\n *\n * What we will do is the following:\n *\n * - Query the plugin and see what kind of result it gives us.\n * - If the result is self-refreshing or doesn't need refreshing, we turn it into an SDKv3 provider\n *   and return it directly.\n *   * If the underlying return value is a provider, we will make it a caching provider\n *     (because we can't know if it will cache by itself or not).\n *   * If the underlying return value is a static credential, caching isn't relevant.\n *   * If the underlying return value is V2 credentials, those have caching built-in.\n * - If the result is a static credential that expires, we will wrap it in an SDKv3 provider\n *   that will query the plugin again when the credential expires.\n */\nasync function v3ProviderFromPlugin(producer: () => Promise<PluginProviderResult>): Promise<AwsCredentialIdentityProvider> {\n  const initial = await producer();\n\n  if (isV3Provider(initial)) {\n    // Already a provider, make caching\n    return makeCachingProvider(initial);\n  } else if (isV3Credentials(initial) && initial.expiration === undefined) {\n    // Static credentials that don't need refreshing nor caching\n    return () => Promise.resolve(initial);\n  } else if (isV3Credentials(initial) && initial.expiration !== undefined) {\n    // Static credentials that do need refreshing and caching\n    return refreshFromPluginProvider(initial, producer);\n  } else if (isV2Credentials(initial)) {\n    // V2 credentials that refresh and cache themselves\n    return v3ProviderFromV2Credentials(initial);\n  } else {\n    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${inspect(initial)}`);\n  }\n}\n\n/**\n * Converts a V2 credential into a V3-compatible provider\n */\nfunction v3ProviderFromV2Credentials(x: SDKv2CompatibleCredentials): AwsCredentialIdentityProvider {\n  return async () => {\n    // Get will fetch or refresh as necessary\n    await x.getPromise();\n\n    return {\n      accessKeyId: x.accessKeyId,\n      secretAccessKey: x.secretAccessKey,\n      sessionToken: x.sessionToken,\n      expiration: x.expireTime ?? undefined,\n    };\n  };\n}\n\nfunction refreshFromPluginProvider(current: AwsCredentialIdentity, producer: () => Promise<PluginProviderResult>): AwsCredentialIdentityProvider {\n  return async () => {\n    if (credentialsAboutToExpire(current)) {\n      const newCreds = await producer();\n      if (!isV3Credentials(newCreds)) {\n        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${inspect(newCreds)}`);\n      }\n      current = newCreds;\n    }\n    return current;\n  };\n}\n\nfunction isV3Provider(x: PluginProviderResult): x is SDKv3CompatibleCredentialProvider {\n  return typeof x === 'function';\n}\n\nfunction isV2Credentials(x: PluginProviderResult): x is SDKv2CompatibleCredentials {\n  return !!(x && typeof x === 'object' && (x as SDKv2CompatibleCredentials).getPromise);\n}\n\nfunction isV3Credentials(x: PluginProviderResult): x is SDKv3CompatibleCredentials {\n  return !!(x && typeof x === 'object' && x.accessKeyId && !isV2Credentials(x));\n}\n"]}

package/lib/api/aws-auth/private/index.d.ts

@@ -0,0 +1,11 @@
+export * from '../proxy-agent';
+export * from '../sdk';
+export * from '../sdk-provider';
+export * from '../sdk-logger';
+export { AccountAccessKeyCache } from '../account-cache';
+export { cached } from '../cached';
+export { AwsCliCompatible } from '../awscli-compatible';
+export { setSdkTracing } from '../tracing';
+export { CredentialPlugins } from '../credential-plugins';
+export { credentialsAboutToExpire } from '../provider-caching';
+export { defaultCliUserAgent } from '../user-agent';

package/lib/api/aws-auth/private/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCliUserAgent = exports.credentialsAboutToExpire = exports.CredentialPlugins = exports.setSdkTracing = exports.AwsCliCompatible = exports.cached = exports.AccountAccessKeyCache = void 0;
+__exportStar(require("../proxy-agent"), exports);
+__exportStar(require("../sdk"), exports);
+__exportStar(require("../sdk-provider"), exports);
+__exportStar(require("../sdk-logger"), exports);
+// temporary testing exports
+var account_cache_1 = require("../account-cache");
+Object.defineProperty(exports, "AccountAccessKeyCache", { enumerable: true, get: function () { return account_cache_1.AccountAccessKeyCache; } });
+var cached_1 = require("../cached");
+Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return cached_1.cached; } });
+var awscli_compatible_1 = require("../awscli-compatible");
+Object.defineProperty(exports, "AwsCliCompatible", { enumerable: true, get: function () { return awscli_compatible_1.AwsCliCompatible; } });
+var tracing_1 = require("../tracing");
+Object.defineProperty(exports, "setSdkTracing", { enumerable: true, get: function () { return tracing_1.setSdkTracing; } });
+var credential_plugins_1 = require("../credential-plugins");
+Object.defineProperty(exports, "CredentialPlugins", { enumerable: true, get: function () { return credential_plugins_1.CredentialPlugins; } });
+var provider_caching_1 = require("../provider-caching");
+Object.defineProperty(exports, "credentialsAboutToExpire", { enumerable: true, get: function () { return provider_caching_1.credentialsAboutToExpire; } });
+var user_agent_1 = require("../user-agent");
+Object.defineProperty(exports, "defaultCliUserAgent", { enumerable: true, get: function () { return user_agent_1.defaultCliUserAgent; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUErQjtBQUMvQix5Q0FBdUI7QUFDdkIsa0RBQWdDO0FBQ2hDLGdEQUE4QjtBQUU5Qiw0QkFBNEI7QUFDNUIsa0RBQXlEO0FBQWhELHNIQUFBLHFCQUFxQixPQUFBO0FBQzlCLG9DQUFtQztBQUExQixnR0FBQSxNQUFNLE9BQUE7QUFDZiwwREFBd0Q7QUFBL0MscUhBQUEsZ0JBQWdCLE9BQUE7QUFDekIsc0NBQTJDO0FBQWxDLHdHQUFBLGFBQWEsT0FBQTtBQUN0Qiw0REFBMEQ7QUFBakQsdUhBQUEsaUJBQWlCLE9BQUE7QUFDMUIsd0RBQStEO0FBQXRELDRIQUFBLHdCQUF3QixPQUFBO0FBQ2pDLDRDQUFvRDtBQUEzQyxpSEFBQSxtQkFBbUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4uL3Byb3h5LWFnZW50JztcbmV4cG9ydCAqIGZyb20gJy4uL3Nkayc7XG5leHBvcnQgKiBmcm9tICcuLi9zZGstcHJvdmlkZXInO1xuZXhwb3J0ICogZnJvbSAnLi4vc2RrLWxvZ2dlcic7XG5cbi8vIHRlbXBvcmFyeSB0ZXN0aW5nIGV4cG9ydHNcbmV4cG9ydCB7IEFjY291bnRBY2Nlc3NLZXlDYWNoZSB9IGZyb20gJy4uL2FjY291bnQtY2FjaGUnO1xuZXhwb3J0IHsgY2FjaGVkIH0gZnJvbSAnLi4vY2FjaGVkJztcbmV4cG9ydCB7IEF3c0NsaUNvbXBhdGlibGUgfSBmcm9tICcuLi9hd3NjbGktY29tcGF0aWJsZSc7XG5leHBvcnQgeyBzZXRTZGtUcmFjaW5nIH0gZnJvbSAnLi4vdHJhY2luZyc7XG5leHBvcnQgeyBDcmVkZW50aWFsUGx1Z2lucyB9IGZyb20gJy4uL2NyZWRlbnRpYWwtcGx1Z2lucyc7XG5leHBvcnQgeyBjcmVkZW50aWFsc0Fib3V0VG9FeHBpcmUgfSBmcm9tICcuLi9wcm92aWRlci1jYWNoaW5nJztcbmV4cG9ydCB7IGRlZmF1bHRDbGlVc2VyQWdlbnQgfSBmcm9tICcuLi91c2VyLWFnZW50JztcbiJdfQ==

package/lib/api/aws-auth/provider-caching.d.ts

@@ -0,0 +1,13 @@
+import type { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types';
+/**
+ * Wrap a credential provider in a cache
+ *
+ * Some credential providers in the SDKv3 are cached (the default Node
+ * chain, specifically) but most others are not.
+ *
+ * Since we want to avoid duplicate calls to `AssumeRole`, or duplicate
+ * MFA prompts or what have you, we are going to liberally wrap providers
+ * in caches which will return the cached value until it expires.
+ */
+export declare function makeCachingProvider(provider: AwsCredentialIdentityProvider): AwsCredentialIdentityProvider;
+export declare function credentialsAboutToExpire(token: AwsCredentialIdentity): boolean;

package/lib/api/aws-auth/provider-caching.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCachingProvider = makeCachingProvider;
+exports.credentialsAboutToExpire = credentialsAboutToExpire;
+const property_provider_1 = require("@smithy/property-provider");
+/**
+ * Wrap a credential provider in a cache
+ *
+ * Some credential providers in the SDKv3 are cached (the default Node
+ * chain, specifically) but most others are not.
+ *
+ * Since we want to avoid duplicate calls to `AssumeRole`, or duplicate
+ * MFA prompts or what have you, we are going to liberally wrap providers
+ * in caches which will return the cached value until it expires.
+ */
+function makeCachingProvider(provider) {
+    return (0, property_provider_1.memoize)(provider, credentialsAboutToExpire, (token) => !!token.expiration);
+}
+function credentialsAboutToExpire(token) {
+    const expiryMarginSecs = 5;
+    // token.expiration is sometimes null
+    return !!token.expiration && token.expiration.getTime() - Date.now() < expiryMarginSecs * 1000;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/aws-auth/proxy-agent.d.ts

@@ -0,0 +1,13 @@
+import { ProxyAgent } from 'proxy-agent';
+import type { SdkHttpOptions } from './types';
+import { type IoHelper } from '../io/private';
+export declare class ProxyAgentProvider {
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper);
+    create(options: SdkHttpOptions): Promise<ProxyAgent>;
+    private tryGetCACert;
+    /**
+     * Find and return a CA certificate bundle path to be passed into the SDK.
+     */
+    private caBundlePathFromEnvironment;
+}

package/lib/api/aws-auth/proxy-agent.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyAgentProvider = void 0;
+const fs = require("fs-extra");
+const proxy_agent_1 = require("proxy-agent");
+const private_1 = require("../io/private");
+class ProxyAgentProvider {
+    ioHelper;
+    constructor(ioHelper) {
+        this.ioHelper = ioHelper;
+    }
+    async create(options) {
+        // Force it to use the proxy provided through the command line.
+        // Otherwise, let the ProxyAgent auto-detect the proxy using environment variables.
+        const getProxyForUrl = options.proxyAddress != null
+            ? () => Promise.resolve(options.proxyAddress)
+            : undefined;
+        return new proxy_agent_1.ProxyAgent({
+            ca: await this.tryGetCACert(options.caBundlePath),
+            getProxyForUrl,
+        });
+    }
+    async tryGetCACert(bundlePath) {
+        const path = bundlePath || this.caBundlePathFromEnvironment();
+        if (path) {
+            await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Using CA bundle path: ${path}`));
+            try {
+                if (!fs.pathExistsSync(path)) {
+                    return undefined;
+                }
+                return fs.readFileSync(path, { encoding: 'utf-8' });
+            }
+            catch (e) {
+                await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(String(e)));
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find and return a CA certificate bundle path to be passed into the SDK.
+     */
+    caBundlePathFromEnvironment() {
+        if (process.env.aws_ca_bundle) {
+            return process.env.aws_ca_bundle;
+        }
+        if (process.env.AWS_CA_BUNDLE) {
+            return process.env.AWS_CA_BUNDLE;
+        }
+        return undefined;
+    }
+}
+exports.ProxyAgentProvider = ProxyAgentProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/aws-auth/sdk-logger.d.ts

@@ -0,0 +1,69 @@
+import type { Logger } from '@smithy/types';
+import type { IoHelper } from '../io/private';
+export declare class SdkToCliLogger implements Logger {
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper);
+    private notify;
+    trace(..._content: any[]): void;
+    debug(..._content: any[]): void;
+    /**
+     * Info is called mostly (exclusively?) for successful API calls
+     *
+     * Payload:
+     *
+     * (Note the input contains entire CFN templates, for example)
+     *
+     * ```
+     * {
+     *   clientName: 'S3Client',
+     *   commandName: 'GetBucketLocationCommand',
+     *   input: {
+     *     Bucket: '.....',
+     *     ExpectedBucketOwner: undefined
+     *   },
+     *   output: { LocationConstraint: 'eu-central-1' },
+     *   metadata: {
+     *     httpStatusCode: 200,
+     *     requestId: '....',
+     *     extendedRequestId: '...',
+     *     cfId: undefined,
+     *     attempts: 1,
+     *     totalRetryDelay: 0
+     *   }
+     * }
+     * ```
+     */
+    info(...content: any[]): void;
+    warn(...content: any[]): void;
+    /**
+     * Error is called mostly (exclusively?) for failing API calls
+     *
+     * Payload (input would be the entire API call arguments).
+     *
+     * ```
+     * {
+     *   clientName: 'STSClient',
+     *   commandName: 'GetCallerIdentityCommand',
+     *   input: {},
+     *   error: AggregateError [ECONNREFUSED]:
+     *       at internalConnectMultiple (node:net:1121:18)
+     *       at afterConnectMultiple (node:net:1688:7) {
+     *     code: 'ECONNREFUSED',
+     *     '$metadata': { attempts: 3, totalRetryDelay: 600 },
+     *     [errors]: [ [Error], [Error] ]
+     *   },
+     *   metadata: { attempts: 3, totalRetryDelay: 600 }
+     * }
+     * ```
+     */
+    error(...content: any[]): void;
+}
+/**
+ * This can be anything.
+ *
+ * For debug, it seems to be mostly strings.
+ * For info, it seems to be objects.
+ *
+ * Stringify and join without separator.
+ */
+export declare function formatSdkLoggerContent(content: any[]): string;

package/lib/api/aws-auth/sdk-logger.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkToCliLogger = void 0;
+exports.formatSdkLoggerContent = formatSdkLoggerContent;
+const util_1 = require("util");
+const util_2 = require("../../util");
+const private_1 = require("../io/private");
+class SdkToCliLogger {
+    ioHelper;
+    constructor(ioHelper) {
+        this.ioHelper = ioHelper;
+    }
+    notify(level, ...content) {
+        void this.ioHelper.notify(private_1.IO.CDK_SDK_I0100.msg((0, util_1.format)('[SDK %s] %s', level, formatSdkLoggerContent(content)), {
+            sdkLevel: level,
+            content,
+        }));
+    }
+    trace(..._content) {
+        // This is too much detail for our logs
+        // this.notify('trace', ...content);
+    }
+    debug(..._content) {
+        // This is too much detail for our logs
+        // this.notify('debug', ...content);
+    }
+    /**
+     * Info is called mostly (exclusively?) for successful API calls
+     *
+     * Payload:
+     *
+     * (Note the input contains entire CFN templates, for example)
+     *
+     * ```
+     * {
+     *   clientName: 'S3Client',
+     *   commandName: 'GetBucketLocationCommand',
+     *   input: {
+     *     Bucket: '.....',
+     *     ExpectedBucketOwner: undefined
+     *   },
+     *   output: { LocationConstraint: 'eu-central-1' },
+     *   metadata: {
+     *     httpStatusCode: 200,
+     *     requestId: '....',
+     *     extendedRequestId: '...',
+     *     cfId: undefined,
+     *     attempts: 1,
+     *     totalRetryDelay: 0
+     *   }
+     * }
+     * ```
+     */
+    info(...content) {
+        this.notify('info', ...content);
+    }
+    warn(...content) {
+        this.notify('warn', ...content);
+    }
+    /**
+     * Error is called mostly (exclusively?) for failing API calls
+     *
+     * Payload (input would be the entire API call arguments).
+     *
+     * ```
+     * {
+     *   clientName: 'STSClient',
+     *   commandName: 'GetCallerIdentityCommand',
+     *   input: {},
+     *   error: AggregateError [ECONNREFUSED]:
+     *       at internalConnectMultiple (node:net:1121:18)
+     *       at afterConnectMultiple (node:net:1688:7) {
+     *     code: 'ECONNREFUSED',
+     *     '$metadata': { attempts: 3, totalRetryDelay: 600 },
+     *     [errors]: [ [Error], [Error] ]
+     *   },
+     *   metadata: { attempts: 3, totalRetryDelay: 600 }
+     * }
+     * ```
+     */
+    error(...content) {
+        this.notify('error', ...content);
+    }
+}
+exports.SdkToCliLogger = SdkToCliLogger;
+/**
+ * This can be anything.
+ *
+ * For debug, it seems to be mostly strings.
+ * For info, it seems to be objects.
+ *
+ * Stringify and join without separator.
+ */
+function formatSdkLoggerContent(content) {
+    if (content.length === 1) {
+        const apiFmt = formatApiCall(content[0]);
+        if (apiFmt) {
+            return apiFmt;
+        }
+    }
+    return content.map((x) => typeof x === 'string' ? x : (0, util_1.inspect)(x)).join('');
+}
+function formatApiCall(content) {
+    if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {
+        return undefined;
+    }
+    const service = content.clientName.replace(/Client$/, '');
+    const api = content.commandName.replace(/Command$/, '');
+    const parts = [];
+    if ((content.metadata?.attempts ?? 0) > 1) {
+        parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);
+    }
+    parts.push(`${service}.${api}(${JSON.stringify(content.input, util_2.replacerBufferWithInfo)})`);
+    if (isSdkApiCallSuccess(content)) {
+        parts.push('-> OK');
+    }
+    else {
+        parts.push(`-> ${content.error}`);
+    }
+    return parts.join(' ');
+}
+function isSdkApiCallSuccess(x) {
+    return x && typeof x === 'object' && x.commandName && x.output;
+}
+function isSdkApiCallError(x) {
+    return x && typeof x === 'object' && x.commandName && x.error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-logger.js","sourceRoot":"","sources":["sdk-logger.ts"],"names":[],"mappings":"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","sourcesContent":["import { inspect, format } from 'util';\nimport type { Logger } from '@smithy/types';\nimport { replacerBufferWithInfo } from '../../util';\nimport type { IoHelper } from '../io/private';\nimport { IO } from '../io/private';\n\nexport class SdkToCliLogger implements Logger {\n  private readonly ioHelper: IoHelper;\n\n  public constructor(ioHelper: IoHelper) {\n    this.ioHelper = ioHelper;\n  }\n\n  private notify(level: 'info' | 'warn' | 'error', ...content: any[]) {\n    void this.ioHelper.notify(IO.CDK_SDK_I0100.msg(format('[SDK %s] %s', level, formatSdkLoggerContent(content)), {\n      sdkLevel: level,\n      content,\n    }));\n  }\n\n  public trace(..._content: any[]) {\n    // This is too much detail for our logs\n    // this.notify('trace', ...content);\n  }\n\n  public debug(..._content: any[]) {\n    // This is too much detail for our logs\n    // this.notify('debug', ...content);\n  }\n\n  /**\n   * Info is called mostly (exclusively?) for successful API calls\n   *\n   * Payload:\n   *\n   * (Note the input contains entire CFN templates, for example)\n   *\n   * ```\n   * {\n   *   clientName: 'S3Client',\n   *   commandName: 'GetBucketLocationCommand',\n   *   input: {\n   *     Bucket: '.....',\n   *     ExpectedBucketOwner: undefined\n   *   },\n   *   output: { LocationConstraint: 'eu-central-1' },\n   *   metadata: {\n   *     httpStatusCode: 200,\n   *     requestId: '....',\n   *     extendedRequestId: '...',\n   *     cfId: undefined,\n   *     attempts: 1,\n   *     totalRetryDelay: 0\n   *   }\n   * }\n   * ```\n   */\n  public info(...content: any[]) {\n    this.notify('info', ...content);\n  }\n\n  public warn(...content: any[]) {\n    this.notify('warn', ...content);\n  }\n\n  /**\n   * Error is called mostly (exclusively?) for failing API calls\n   *\n   * Payload (input would be the entire API call arguments).\n   *\n   * ```\n   * {\n   *   clientName: 'STSClient',\n   *   commandName: 'GetCallerIdentityCommand',\n   *   input: {},\n   *   error: AggregateError [ECONNREFUSED]:\n   *       at internalConnectMultiple (node:net:1121:18)\n   *       at afterConnectMultiple (node:net:1688:7) {\n   *     code: 'ECONNREFUSED',\n   *     '$metadata': { attempts: 3, totalRetryDelay: 600 },\n   *     [errors]: [ [Error], [Error] ]\n   *   },\n   *   metadata: { attempts: 3, totalRetryDelay: 600 }\n   * }\n   * ```\n   */\n  public error(...content: any[]) {\n    this.notify('error', ...content);\n  }\n}\n\n/**\n * This can be anything.\n *\n * For debug, it seems to be mostly strings.\n * For info, it seems to be objects.\n *\n * Stringify and join without separator.\n */\nexport function formatSdkLoggerContent(content: any[]) {\n  if (content.length === 1) {\n    const apiFmt = formatApiCall(content[0]);\n    if (apiFmt) {\n      return apiFmt;\n    }\n  }\n  return content.map((x) => typeof x === 'string' ? x : inspect(x)).join('');\n}\n\nfunction formatApiCall(content: any): string | undefined {\n  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {\n    return undefined;\n  }\n\n  const service = content.clientName.replace(/Client$/, '');\n  const api = content.commandName.replace(/Command$/, '');\n\n  const parts = [];\n  if ((content.metadata?.attempts ?? 0) > 1) {\n    parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);\n  }\n\n  parts.push(`${service}.${api}(${JSON.stringify(content.input, replacerBufferWithInfo)})`);\n\n  if (isSdkApiCallSuccess(content)) {\n    parts.push('-> OK');\n  } else {\n    parts.push(`-> ${content.error}`);\n  }\n\n  return parts.join(' ');\n}\n\ninterface SdkApiCallBase {\n  clientName: string;\n  commandName: string;\n  input: Record<string, unknown>;\n  metadata?: {\n    httpStatusCode?: number;\n    requestId?: string;\n    extendedRequestId?: string;\n    cfId?: string;\n    attempts?: number;\n    totalRetryDelay?: number;\n  };\n}\n\ntype SdkApiCallSuccess = SdkApiCallBase & { output: Record<string, unknown> };\ntype SdkApiCallError = SdkApiCallBase & { error: Error };\n\nfunction isSdkApiCallSuccess(x: any): x is SdkApiCallSuccess {\n  return x && typeof x === 'object' && x.commandName && x.output;\n}\n\nfunction isSdkApiCallError(x: any): x is SdkApiCallError {\n  return x && typeof x === 'object' && x.commandName && x.error;\n}\n"]}