@aws-cdk/toolkit-lib 0.3.7 → 0.4.0

package/lib/api/cloud-assembly/source-builder.js

@@ -1,3 +1,309 @@
 "use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+exports.CloudAssemblySourceBuilder = void 0;
+const path = require("path");
+const util_1 = require("util");
+const cxapi = require("@aws-cdk/cx-api");
+const fs = require("fs-extra");
+const context_store_1 = require("./context-store");
+const rwlock_1 = require("../rwlock");
+const context_aware_source_1 = require("./private/context-aware-source");
+const exec_1 = require("./private/exec");
+const prepare_source_1 = require("./private/prepare-source");
+const readable_assembly_1 = require("./private/readable-assembly");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const util_2 = require("../../util");
+const private_1 = require("../io/private");
+const helpers_1 = require("./private/helpers");
+class CloudAssemblySourceBuilder {
+    /**
+     * Create a Cloud Assembly from a Cloud Assembly builder function.
+     *
+     * ## Outdir
+     *
+     * If no output directory is given, it will synthesize into a temporary system
+     * directory. The temporary directory will be cleaned up, unless
+     * `disposeOutdir: false`.
+     *
+     * A write lock will be acquired on the output directory for the duration of
+     * the CDK app synthesis (which means that no two apps can synthesize at the
+     * same time), and after synthesis a read lock will be acquired on the
+     * directory. This means that while the CloudAssembly is being used, no CDK
+     * app synthesis can take place into that directory.
+     *
+     * ## Context
+     *
+     * If no `contextStore` is given, a `MemoryContext` will be used. This means
+     * no provider lookups will be persisted anywhere by default. Use a different
+     * type of context store if you want persistence between synth operations.
+     *
+     * @param builder - the builder function
+     * @param props - additional configuration properties
+     * @returns the CloudAssembly source
+     */
+    async fromAssemblyBuilder(builder, props = {}) {
+        const services = await this.sourceBuilderServices();
+        const contextStore = props.contextStore ?? new context_store_1.MemoryContext();
+        const contextAssemblyProps = {
+            services,
+            contextStore,
+            lookups: props.lookups,
+        };
+        const outdir = props.outdir ? path.resolve(props.outdir) : undefined;
+        return new context_aware_source_1.ContextAwareCloudAssemblySource({
+            produce: async () => {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const execution = __addDisposableResource(env_1, await prepare_source_1.ExecutionEnvironment.create(services, { outdir }), true);
+                    const synthParams = (0, prepare_source_1.parametersFromSynthOptions)(props.synthOptions);
+                    const fullContext = {
+                        ...await contextStore.read(),
+                        ...synthParams.context,
+                    };
+                    await services.ioHelper.defaults.debug((0, util_1.format)('context:', fullContext));
+                    const env = (0, util_2.noUndefined)({
+                        // Versioning, outdir, default account and region
+                        ...await execution.defaultEnvVars(),
+                        // Environment variables derived from settings
+                        ...synthParams.env,
+                    });
+                    const cleanupContextTemp = (0, prepare_source_1.writeContextToEnv)(env, fullContext);
+                    const _cleanupEnv = __addDisposableResource(env_1, (props.clobberEnv ?? true) ? (0, helpers_1.temporarilyWriteEnv)(env) : undefined, false);
+                    let assembly;
+                    try {
+                        assembly = await builder({
+                            outdir: execution.outdir,
+                            context: fullContext,
+                            env,
+                        });
+                    }
+                    catch (error) {
+                        // re-throw toolkit errors unchanged
+                        if (toolkit_error_1.ToolkitError.isToolkitError(error)) {
+                            throw error;
+                        }
+                        // otherwise, wrap into an assembly error
+                        throw toolkit_error_1.AssemblyError.withCause('Assembly builder failed', error);
+                    }
+                    finally {
+                        await cleanupContextTemp();
+                    }
+                    // Convert what we got to the definitely correct type we're expecting, a cxapi.CloudAssembly
+                    const asm = cxapi.CloudAssembly.isCloudAssembly(assembly)
+                        ? assembly
+                        : await (0, prepare_source_1.assemblyFromDirectory)(assembly.directory, services.ioHelper, props.loadAssemblyOptions);
+                    const success = await execution.markSuccessful();
+                    const deleteOnDispose = props.disposeOutdir ?? execution.outDirIsTemporary;
+                    return new readable_assembly_1.ReadableCloudAssembly(asm, success.readLock, { deleteOnDispose });
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    const result_1 = __disposeResources(env_1);
+                    if (result_1)
+                        await result_1;
+                }
+            },
+        }, contextAssemblyProps);
+    }
+    /**
+     * Creates a Cloud Assembly from an existing assembly directory.
+     *
+     * A read lock will be acquired for the directory. This means that while
+     * the CloudAssembly is being used, no CDK app synthesis can take place into
+     * that directory.
+     *
+     * @param directory - directory the directory of a already produced Cloud Assembly.
+     * @returns the CloudAssembly source
+     */
+    async fromAssemblyDirectory(directory, props = {}) {
+        const services = await this.sourceBuilderServices();
+        const contextAssemblyProps = {
+            services,
+            contextStore: new context_store_1.MemoryContext(), // @todo We shouldn't be using a `ContextAwareCloudAssemblySource` at all.
+            lookups: false,
+        };
+        return new context_aware_source_1.ContextAwareCloudAssemblySource({
+            produce: async () => {
+                // @todo build
+                await services.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0150.msg('--app points to a cloud assembly, so we bypass synth'));
+                const readLock = await new rwlock_1.RWLock(directory).acquireRead();
+                try {
+                    const asm = await (0, prepare_source_1.assemblyFromDirectory)(directory, services.ioHelper, props.loadAssemblyOptions);
+                    return new readable_assembly_1.ReadableCloudAssembly(asm, readLock, { deleteOnDispose: false });
+                }
+                catch (e) {
+                    await readLock.release();
+                    throw e;
+                }
+            },
+        }, contextAssemblyProps);
+    }
+    /**
+     * Use a directory containing an AWS CDK app as source.
+     *
+     * The subprocess will execute in `workingDirectory`, which defaults to
+     * the current process' working directory if not given.
+     *
+     * ## Outdir
+     *
+     * If an output directory is supplied, relative paths are evaluated with
+     * respect to the current process' working directory. If an output directory
+     * is not supplied, the default is a `cdk.out` directory underneath
+     * `workingDirectory`. The output directory will not be cleaned up unless
+     * `disposeOutdir: true`.
+     *
+     * A write lock will be acquired on the output directory for the duration of
+     * the CDK app synthesis (which means that no two apps can synthesize at the
+     * same time), and after synthesis a read lock will be acquired on the
+     * directory.  This means that while the CloudAssembly is being used, no CDK
+     * app synthesis can take place into that directory.
+     *
+     * ## Context
+     *
+     * If no `contextStore` is given, a `CdkAppMultiContext` will be used, initialized
+     * to the app's `workingDirectory`. This means that context will be loaded from
+     * all the CDK's default context sources, and updates will be written to
+     * `cdk.context.json`.
+     *
+     * @param props - additional configuration properties
+     * @returns the CloudAssembly source
+     */
+    async fromCdkApp(app, props = {}) {
+        const services = await this.sourceBuilderServices();
+        const workingDirectory = props.workingDirectory ?? process.cwd();
+        const outdir = props.outdir ? path.resolve(props.outdir) : path.resolve(workingDirectory, 'cdk.out');
+        const contextStore = props.contextStore ?? new context_store_1.CdkAppMultiContext(workingDirectory);
+        const contextAssemblyProps = {
+            services,
+            contextStore,
+            lookups: props.lookups,
+        };
+        return new context_aware_source_1.ContextAwareCloudAssemblySource({
+            produce: async () => {
+                const env_2 = { stack: [], error: void 0, hasError: false };
+                try {
+                    // @todo build
+                    // const build = this.props.configuration.settings.get(['build']);
+                    // if (build) {
+                    //   await execInChildProcess(build, { cwd: props.workingDirectory });
+                    // }
+                    try {
+                        fs.mkdirpSync(outdir);
+                    }
+                    catch (e) {
+                        throw new toolkit_error_1.ToolkitError(`Could not create output directory at '${outdir}' (${e.message}).`);
+                    }
+                    const execution = __addDisposableResource(env_2, await prepare_source_1.ExecutionEnvironment.create(services, { outdir }), true);
+                    const commandLine = await execution.guessExecutable(app);
+                    const synthParams = (0, prepare_source_1.parametersFromSynthOptions)(props.synthOptions);
+                    const fullContext = {
+                        ...await contextStore.read(),
+                        ...synthParams.context,
+                    };
+                    await services.ioHelper.defaults.debug((0, util_1.format)('context:', fullContext));
+                    const env = (0, util_2.noUndefined)({
+                        // Need to start with full env of `writeContextToEnv` will not be able to do the size
+                        // calculation correctly.
+                        ...process.env,
+                        // User gave us something
+                        ...props.env,
+                        // Versioning, outdir, default account and region
+                        ...await execution.defaultEnvVars(),
+                        // Environment variables derived from settings
+                        ...synthParams.env,
+                    });
+                    const cleanupTemp = (0, prepare_source_1.writeContextToEnv)(env, fullContext);
+                    try {
+                        await (0, exec_1.execInChildProcess)(commandLine.join(' '), {
+                            eventPublisher: async (type, line) => {
+                                switch (type) {
+                                    case 'data_stdout':
+                                        await services.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I1001.msg(line));
+                                        break;
+                                    case 'data_stderr':
+                                        await services.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_E1002.msg(line));
+                                        break;
+                                }
+                            },
+                            env,
+                            cwd: workingDirectory,
+                        });
+                    }
+                    finally {
+                        await cleanupTemp();
+                    }
+                    const asm = await (0, prepare_source_1.assemblyFromDirectory)(outdir, services.ioHelper, props.loadAssemblyOptions);
+                    const success = await execution.markSuccessful();
+                    const deleteOnDispose = props.disposeOutdir ?? execution.outDirIsTemporary;
+                    return new readable_assembly_1.ReadableCloudAssembly(asm, success.readLock, { deleteOnDispose });
+                }
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
+                }
+                finally {
+                    const result_2 = __disposeResources(env_2);
+                    if (result_2)
+                        await result_2;
+                }
+            },
+        }, contextAssemblyProps);
+    }
+}
+exports.CloudAssemblySourceBuilder = CloudAssemblySourceBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-builder.js","sourceRoot":"","sources":["source-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { format } from 'util';\nimport type * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport { CdkAppMultiContext, MemoryContext, type IContextStore } from './context-store';\nimport { RWLock } from '../rwlock';\nimport type { ContextAwareCloudAssemblyProps } from './private/context-aware-source';\nimport { ContextAwareCloudAssemblySource } from './private/context-aware-source';\nimport { execInChildProcess } from './private/exec';\nimport { ExecutionEnvironment, assemblyFromDirectory, parametersFromSynthOptions, writeContextToEnv } from './private/prepare-source';\nimport { ReadableCloudAssembly } from './private/readable-assembly';\nimport type { ICloudAssemblySource } from './types';\nimport type { ToolkitServices } from '../../toolkit/private';\nimport { ToolkitError, AssemblyError } from '../../toolkit/toolkit-error';\nimport { noUndefined } from '../../util';\nimport { IO } from '../io/private';\nimport { temporarilyWriteEnv } from './private/helpers';\n\n/**\n * Properties the builder function receives.\n */\nexport interface AssemblyBuilderProps {\n  /**\n   * The output directory into which to the builder app will emit synthesized artifacts.\n   */\n  readonly outdir?: string;\n\n  /**\n   * The context provided tp the builder app to synthesize the Cloud Assembly, including looked-up context.\n   */\n  readonly context?: { [key: string]: any };\n\n  /**\n   * Additional configuration that would normally be passed to a CDK app using environment variables\n   *\n   * This contains variables intended for the user portion of a CDK app (notably\n   * `CDK_DEFAULT_ACCOUNT` and `CDK_DEFAULT_REGION`), which you can freely read.\n   *\n   * It also contains variables intended for the CDK Toolkit to communicate with\n   * the internals of the construct library, like `CDK_DEBUG` and\n   * `CDK_CLI_ASM_VERSION`. Reading these latter variables is possible but not\n   * recommended, as their meaning may change without notice.\n   */\n  readonly env: Record<string, string>;\n}\n\n/**\n * A function that takes synthesis parameters and produces a Cloud Assembly\n *\n * Most typically, the properties passed here will be used to construct a\n * `cdk.App`, and the return value is the return value of `app.synth()`.\n */\nexport type AssemblyBuilder = (props: AssemblyBuilderProps) => Promise<cxschema.ICloudAssembly>;\n\n/**\n * Configuration for creating a CLI from an AWS CDK App directory\n */\nexport interface AssemblyDirectoryProps {\n  /**\n   * Options to configure loading of the assembly after it has been synthesized\n   */\n  readonly loadAssemblyOptions?: LoadAssemblyOptions;\n}\n\n/**\n * Configuration for creating a CLI from an AWS CDK App directory\n */\nexport interface AssemblySourceProps {\n  /**\n   * Emits the synthesized cloud assembly into the given directory\n   *\n   * @default \"cdk.out\"\n   */\n  readonly outdir?: string;\n\n  /**\n   * Perform context lookups.\n   *\n   * Synthesis fails if this is disabled and context lookups need to be performed.\n   *\n   * @default true\n   */\n  readonly lookups?: boolean;\n\n  /**\n   * A context store for this operation\n   *\n   * The context store will be used to source initial context values,\n   * and updated values will be stored here.\n   *\n   * @default - depend on the operation\n   */\n  readonly contextStore?: IContextStore;\n\n  /**\n   * Options that are passed through the context to a CDK app on synth\n   */\n  readonly synthOptions?: AppSynthOptions;\n\n  /**\n   * Options to configure loading of the assembly after it has been synthesized\n   */\n  readonly loadAssemblyOptions?: LoadAssemblyOptions;\n\n  /**\n   * Delete the `outdir` when the assembly is disposed\n   *\n   * @default - `true` if `outdir` is not given, `false` otherwise\n   */\n  readonly disposeOutdir?: boolean;\n}\n\n/**\n * Options for the `fromAssemblyBuilder` Assembly Source constructor\n */\nexport interface FromAssemblyBuilderOptions extends AssemblySourceProps {\n  /**\n   * Mutate current process' environment variables to communicate with CDK app\n   *\n   * There are a number of environment variables the Toolkit uses to pass\n   * information to the CDK app.\n   *\n   * By default, these environment variables will be written to the current\n   * process' global shared environment variables before the builder is invoked,\n   * and you don't need to do anything else. However, because this mutates\n   * shared state it is not safe to run multiple builders concurrently.\n   *\n   * Set this to `false` to avoid mutating the shared environment. Instead,\n   * you will need to pass the `outdir` and `context` to the `App` constructor\n   * directly in your builder, and inspect the `env` map directly\n   * for information like the `CDK_DEFAULT_ACCOUNT` and `CDK_DEFAULT_REGION`.\n   *\n   * ```ts\n   * const cx = await toolkit.fromAssemblyBuilder(async (props) => {\n   *   // Important: pass on synthesis parameters\n   *   const app = new core.App({\n   *     outdir: props.outdir,\n   *     context: props.context,\n   *   });\n   *\n   *   new MyStack(app, 'MyStack', {\n   *     env: {\n   *       account: props.env.CDK_DEFAULT_ACCOUNT,\n   *       region: props.env.CDK_DEFAULT_REGION,\n   *     },\n   *   });\n   *\n   *   // ...\n   * }, {\n   *   clobberEnv: false,\n   * });\n   * ```\n   *\n   * @default true\n   */\n  readonly clobberEnv?: boolean;\n}\n\n/**\n * Options for the `fromCdkApp` Assembly Source constructor\n */\nexport interface FromCdkAppOptions extends AssemblySourceProps {\n  /**\n   * Execute the application in this working directory.\n   *\n   * @default - current working directory\n   */\n  readonly workingDirectory?: string;\n\n  /**\n   * Additional environment variables\n   *\n   * These environment variables will be set in addition to the environment\n   * variables currently set in the process. A value of `undefined` will\n   * unset a particular environment variable.\n   */\n  readonly env?: Record<string, string | undefined>;\n}\n\n/**\n * Settings that are passed to a CDK app via the context\n */\nexport interface AppSynthOptions {\n  /**\n   * Debug the CDK app.\n   * Logs additional information during synthesis, such as creation stack traces of tokens.\n   * This also sets the `CDK_DEBUG` env variable and will slow down synthesis.\n   *\n   * @default false\n   */\n  readonly debug?: boolean;\n\n  /**\n   * Enables the embedding of the \"aws:cdk:path\" in CloudFormation template metadata.\n   *\n   * @default true\n   */\n  readonly pathMetadata?: boolean;\n\n  /**\n   * Enable the collection and reporting of version information.\n   *\n   * @default true\n   */\n  readonly versionReporting?: boolean;\n\n  /**\n   * Whe enabled, `aws:asset:xxx` metadata entries are added to the template.\n   *\n   * Disabling this can be useful in certain cases like integration tests.\n   *\n   * @default true\n   */\n  readonly assetMetadata?: boolean;\n\n  /**\n   * Enable asset staging.\n   *\n   * Disabling asset staging means that copyable assets will not be copied to the\n   * output directory and will be referenced with absolute paths.\n   *\n   * Not copied to the output directory: this is so users can iterate on the\n   * Lambda source and run SAM CLI without having to re-run CDK (note: we\n   * cannot achieve this for bundled assets, if assets are bundled they\n   * will have to re-run CDK CLI to re-bundle updated versions).\n   *\n   * Absolute path: SAM CLI expects `cwd`-relative paths in a resource's\n   * `aws:asset:path` metadata. In order to be predictable, we will always output\n   * absolute paths.\n   *\n   * @default true\n   */\n  readonly assetStaging?: boolean;\n\n  /**\n   * Select which stacks should have asset bundling enabled\n   *\n   * @default [\"**\"] - all stacks\n   */\n  readonly bundlingForStacks?: string;\n}\n\n/**\n * Options to configure loading of the assembly after it has been synthesized\n */\nexport interface LoadAssemblyOptions {\n  /**\n   * Check the Toolkit supports the Cloud Assembly Schema version\n   *\n   * When disabled, allows to Toolkit to read a newer cloud assembly than the CX API is designed\n   * to support. Your application may not be aware of all features that in use in the Cloud Assembly.\n   *\n   * @default true\n   */\n  readonly checkVersion?: boolean;\n\n  /**\n   * Validate enums to only have known values\n   *\n   * When disabled, the Toolkit may read enum values it doesn't know about yet.\n   * You will have to make sure to always check the values of enums you encounter in the manifest.\n   *\n   * @default true\n   */\n  readonly checkEnums?: boolean;\n}\n\nexport abstract class CloudAssemblySourceBuilder {\n  /**\n   * Helper to provide the CloudAssemblySourceBuilder with required toolkit services\n   * @internal\n   */\n  protected abstract sourceBuilderServices(): Promise<ToolkitServices>;\n\n  /**\n   * Create a Cloud Assembly from a Cloud Assembly builder function.\n   *\n   * ## Outdir\n   *\n   * If no output directory is given, it will synthesize into a temporary system\n   * directory. The temporary directory will be cleaned up, unless\n   * `disposeOutdir: false`.\n   *\n   * A write lock will be acquired on the output directory for the duration of\n   * the CDK app synthesis (which means that no two apps can synthesize at the\n   * same time), and after synthesis a read lock will be acquired on the\n   * directory. This means that while the CloudAssembly is being used, no CDK\n   * app synthesis can take place into that directory.\n   *\n   * ## Context\n   *\n   * If no `contextStore` is given, a `MemoryContext` will be used. This means\n   * no provider lookups will be persisted anywhere by default. Use a different\n   * type of context store if you want persistence between synth operations.\n   *\n   * @param builder - the builder function\n   * @param props - additional configuration properties\n   * @returns the CloudAssembly source\n   */\n  public async fromAssemblyBuilder(\n    builder: AssemblyBuilder,\n    props: FromAssemblyBuilderOptions = {},\n  ): Promise<ICloudAssemblySource> {\n    const services = await this.sourceBuilderServices();\n    const contextStore = props.contextStore ?? new MemoryContext();\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      contextStore,\n      lookups: props.lookups,\n    };\n\n    const outdir = props.outdir ? path.resolve(props.outdir) : undefined;\n\n    return new ContextAwareCloudAssemblySource(\n      {\n        produce: async () => {\n          await using execution = await ExecutionEnvironment.create(services, { outdir });\n\n          const synthParams = parametersFromSynthOptions(props.synthOptions);\n\n          const fullContext = {\n            ...await contextStore.read(),\n            ...synthParams.context,\n          };\n\n          await services.ioHelper.defaults.debug(format('context:', fullContext));\n\n          const env = noUndefined({\n            // Versioning, outdir, default account and region\n            ...await execution.defaultEnvVars(),\n            // Environment variables derived from settings\n            ...synthParams.env,\n          });\n\n          const cleanupContextTemp = writeContextToEnv(env, fullContext);\n          using _cleanupEnv = (props.clobberEnv ?? true) ? temporarilyWriteEnv(env) : undefined;\n          let assembly;\n          try {\n            assembly = await builder({\n              outdir: execution.outdir,\n              context: fullContext,\n              env,\n            });\n          } catch (error: unknown) {\n            // re-throw toolkit errors unchanged\n            if (ToolkitError.isToolkitError(error)) {\n              throw error;\n            }\n            // otherwise, wrap into an assembly error\n            throw AssemblyError.withCause('Assembly builder failed', error);\n          } finally {\n            await cleanupContextTemp();\n          }\n\n          // Convert what we got to the definitely correct type we're expecting, a cxapi.CloudAssembly\n          const asm = cxapi.CloudAssembly.isCloudAssembly(assembly)\n            ? assembly\n            : await assemblyFromDirectory(assembly.directory, services.ioHelper, props.loadAssemblyOptions);\n\n          const success = await execution.markSuccessful();\n          const deleteOnDispose = props.disposeOutdir ?? execution.outDirIsTemporary;\n          return new ReadableCloudAssembly(asm, success.readLock, { deleteOnDispose });\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n\n  /**\n   * Creates a Cloud Assembly from an existing assembly directory.\n   *\n   * A read lock will be acquired for the directory. This means that while\n   * the CloudAssembly is being used, no CDK app synthesis can take place into\n   * that directory.\n   *\n   * @param directory - directory the directory of a already produced Cloud Assembly.\n   * @returns the CloudAssembly source\n   */\n  public async fromAssemblyDirectory(directory: string, props: AssemblyDirectoryProps = {}): Promise<ICloudAssemblySource> {\n    const services: ToolkitServices = await this.sourceBuilderServices();\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      contextStore: new MemoryContext(), // @todo We shouldn't be using a `ContextAwareCloudAssemblySource` at all.\n      lookups: false,\n    };\n\n    return new ContextAwareCloudAssemblySource(\n      {\n        produce: async () => {\n          // @todo build\n          await services.ioHelper.notify(IO.CDK_ASSEMBLY_I0150.msg('--app points to a cloud assembly, so we bypass synth'));\n\n          const readLock = await new RWLock(directory).acquireRead();\n          try {\n            const asm = await assemblyFromDirectory(directory, services.ioHelper, props.loadAssemblyOptions);\n            return new ReadableCloudAssembly(asm, readLock, { deleteOnDispose: false });\n          } catch (e) {\n            await readLock.release();\n            throw e;\n          }\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n  /**\n   * Use a directory containing an AWS CDK app as source.\n   *\n   * The subprocess will execute in `workingDirectory`, which defaults to\n   * the current process' working directory if not given.\n   *\n   * ## Outdir\n   *\n   * If an output directory is supplied, relative paths are evaluated with\n   * respect to the current process' working directory. If an output directory\n   * is not supplied, the default is a `cdk.out` directory underneath\n   * `workingDirectory`. The output directory will not be cleaned up unless\n   * `disposeOutdir: true`.\n   *\n   * A write lock will be acquired on the output directory for the duration of\n   * the CDK app synthesis (which means that no two apps can synthesize at the\n   * same time), and after synthesis a read lock will be acquired on the\n   * directory.  This means that while the CloudAssembly is being used, no CDK\n   * app synthesis can take place into that directory.\n   *\n   * ## Context\n   *\n   * If no `contextStore` is given, a `CdkAppMultiContext` will be used, initialized\n   * to the app's `workingDirectory`. This means that context will be loaded from\n   * all the CDK's default context sources, and updates will be written to\n   * `cdk.context.json`.\n   *\n   * @param props - additional configuration properties\n   * @returns the CloudAssembly source\n   */\n  public async fromCdkApp(app: string, props: FromCdkAppOptions = {}): Promise<ICloudAssemblySource> {\n    const services: ToolkitServices = await this.sourceBuilderServices();\n    const workingDirectory = props.workingDirectory ?? process.cwd();\n    const outdir = props.outdir ? path.resolve(props.outdir) : path.resolve(workingDirectory, 'cdk.out');\n\n    const contextStore = props.contextStore ?? new CdkAppMultiContext(workingDirectory);\n\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      contextStore,\n      lookups: props.lookups,\n    };\n\n    return new ContextAwareCloudAssemblySource(\n      {\n        produce: async () => {\n          // @todo build\n          // const build = this.props.configuration.settings.get(['build']);\n          // if (build) {\n          //   await execInChildProcess(build, { cwd: props.workingDirectory });\n          // }\n\n          try {\n            fs.mkdirpSync(outdir);\n          } catch (e: any) {\n            throw new ToolkitError(`Could not create output directory at '${outdir}' (${e.message}).`);\n          }\n\n          await using execution = await ExecutionEnvironment.create(services, { outdir });\n\n          const commandLine = await execution.guessExecutable(app);\n\n          const synthParams = parametersFromSynthOptions(props.synthOptions);\n\n          const fullContext = {\n            ...await contextStore.read(),\n            ...synthParams.context,\n          };\n\n          await services.ioHelper.defaults.debug(format('context:', fullContext));\n\n          const env = noUndefined({\n            // Need to start with full env of `writeContextToEnv` will not be able to do the size\n            // calculation correctly.\n            ...process.env,\n            // User gave us something\n            ...props.env,\n            // Versioning, outdir, default account and region\n            ...await execution.defaultEnvVars(),\n            // Environment variables derived from settings\n            ...synthParams.env,\n          });\n          const cleanupTemp = writeContextToEnv(env, fullContext);\n          try {\n            await execInChildProcess(commandLine.join(' '), {\n              eventPublisher: async (type, line) => {\n                switch (type) {\n                  case 'data_stdout':\n                    await services.ioHelper.notify(IO.CDK_ASSEMBLY_I1001.msg(line));\n                    break;\n                  case 'data_stderr':\n                    await services.ioHelper.notify(IO.CDK_ASSEMBLY_E1002.msg(line));\n                    break;\n                }\n              },\n              env,\n              cwd: workingDirectory,\n            });\n          } finally {\n            await cleanupTemp();\n          }\n\n          const asm = await assemblyFromDirectory(outdir, services.ioHelper, props.loadAssemblyOptions);\n\n          const success = await execution.markSuccessful();\n          const deleteOnDispose = props.disposeOutdir ?? execution.outDirIsTemporary;\n          return new ReadableCloudAssembly(asm, success.readLock, { deleteOnDispose });\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n}\n\n"]}

package/lib/api/cloud-assembly/stack-assembly.js

@@ -5,7 +5,6 @@ const chalk = require("chalk");
 const minimatch_1 = require("minimatch");
 const stack_collection_1 = require("./stack-collection");
 const util_1 = require("../../util");
-const private_1 = require("../io/private");
 /**
  * When selecting stacks, what other stacks to include because of dependencies
  */
@@ -108,7 +107,7 @@ async function includeDownstreamStacks(ioHelper, selectedStacks, allStacks) {
         }
     } while (madeProgress);
     if (added.length > 0) {
-        await ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_INFO.msg(`Including depending stacks: ${chalk.bold(added.join(', '))}`));
+        await ioHelper.defaults.info(`Including depending stacks: ${chalk.bold(added.join(', '))}`);
     }
 }
 /**
@@ -133,7 +132,7 @@ async function includeUpstreamStacks(ioHelper, selectedStacks, allStacks) {
         }
     }
     if (added.length > 0) {
-        await ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_INFO.msg(`Including dependency stacks: ${chalk.bold(added.join(', '))}`));
+        await ioHelper.defaults.info(`Including dependency stacks: ${chalk.bold(added.join(', '))}`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-assembly.js","sourceRoot":"","sources":["stack-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { minimatch } from 'minimatch';\nimport { StackCollection } from './stack-collection';\nimport { flatten } from '../../util';\nimport { IO } from '../io/private';\nimport type { IoHelper } from '../io/private/io-helper';\n\nexport interface IStackAssembly {\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  directory: string;\n\n  /**\n   * Select a single stack by its ID\n   */\n  stackById(stackId: string): StackCollection;\n}\n\n/**\n * When selecting stacks, what other stacks to include because of dependencies\n */\nexport enum ExtendedStackSelection {\n  /**\n   * Don't select any extra stacks\n   */\n  None,\n\n  /**\n   * Include stacks that this stack depends on\n   */\n  Upstream,\n\n  /**\n   * Include stacks that depend on this stack\n   */\n  Downstream,\n}\n\n/**\n * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside\n */\nexport abstract class BaseStackAssembly implements IStackAssembly {\n  /**\n   * Sanitize a list of stack match patterns\n   */\n  protected static sanitizePatterns(patterns: string[]): string[] {\n    let sanitized = patterns.filter(s => s != null); // filter null/undefined\n    sanitized = [...new Set(sanitized)]; // make them unique\n    return sanitized;\n  }\n\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  public readonly directory: string;\n\n  /**\n   * The IoHelper used for messaging\n   */\n  protected readonly ioHelper: IoHelper;\n\n  constructor(public readonly assembly: cxapi.CloudAssembly, ioHelper: IoHelper) {\n    this.directory = assembly.directory;\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Select a single stack by its ID\n   */\n  public stackById(stackId: string) {\n    return new StackCollection(this, [this.assembly.getStackArtifact(stackId)]);\n  }\n\n  protected async selectMatchingStacks(\n    stacks: cxapi.CloudFormationStackArtifact[],\n    patterns: string[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ): Promise<StackCollection> {\n    const matchingPattern = (pattern: string) => (stack: cxapi.CloudFormationStackArtifact) => minimatch(stack.hierarchicalId, pattern);\n    const matchedStacks = flatten(patterns.map(pattern => stacks.filter(matchingPattern(pattern))));\n\n    return this.extendStacks(matchedStacks, stacks, extend);\n  }\n\n  protected async extendStacks(\n    matched: cxapi.CloudFormationStackArtifact[],\n    all: cxapi.CloudFormationStackArtifact[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ) {\n    const allStacks = new Map<string, cxapi.CloudFormationStackArtifact>();\n    for (const stack of all) {\n      allStacks.set(stack.hierarchicalId, stack);\n    }\n\n    const index = indexByHierarchicalId(matched);\n\n    switch (extend) {\n      case ExtendedStackSelection.Downstream:\n        await includeDownstreamStacks(this.ioHelper, index, allStacks);\n        break;\n      case ExtendedStackSelection.Upstream:\n        await includeUpstreamStacks(this.ioHelper, index, allStacks);\n        break;\n    }\n\n    // Filter original array because it is in the right order\n    const selectedList = all.filter(s => index.has(s.hierarchicalId));\n\n    return new StackCollection(this, selectedList);\n  }\n}\n\nfunction indexByHierarchicalId(stacks: cxapi.CloudFormationStackArtifact[]): Map<string, cxapi.CloudFormationStackArtifact> {\n  const result = new Map<string, cxapi.CloudFormationStackArtifact>();\n\n  for (const stack of stacks) {\n    result.set(stack.hierarchicalId, stack);\n  }\n\n  return result;\n}\n\n/**\n * Calculate the transitive closure of stack dependents.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeDownstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n\n  let madeProgress;\n  do {\n    madeProgress = false;\n\n    for (const [id, stack] of allStacks) {\n      // Select this stack if it's not selected yet AND it depends on a stack that's in the selected set\n      if (!selectedStacks.has(id) && (stack.dependencies || []).some(dep => selectedStacks.has(dep.id))) {\n        selectedStacks.set(id, stack);\n        added.push(id);\n        madeProgress = true;\n      }\n    }\n  } while (madeProgress);\n\n  if (added.length > 0) {\n    await ioHelper.notify(IO.DEFAULT_ASSEMBLY_INFO.msg(`Including depending stacks: ${chalk.bold(added.join(', '))}`));\n  }\n}\n\n/**\n * Calculate the transitive closure of stack dependencies.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeUpstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n  let madeProgress = true;\n  while (madeProgress) {\n    madeProgress = false;\n\n    for (const stack of selectedStacks.values()) {\n      // Select an additional stack if it's not selected yet and a dependency of a selected stack (and exists, obviously)\n      for (const dependencyId of stack.dependencies.map(x => x.manifest.displayName ?? x.id)) {\n        if (!selectedStacks.has(dependencyId) && allStacks.has(dependencyId)) {\n          added.push(dependencyId);\n          selectedStacks.set(dependencyId, allStacks.get(dependencyId)!);\n          madeProgress = true;\n        }\n      }\n    }\n  }\n\n  if (added.length > 0) {\n    await ioHelper.notify(IO.DEFAULT_ASSEMBLY_INFO.msg(`Including dependency stacks: ${chalk.bold(added.join(', '))}`));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-assembly.js","sourceRoot":"","sources":["stack-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { minimatch } from 'minimatch';\nimport { StackCollection } from './stack-collection';\nimport { flatten } from '../../util';\nimport type { IoHelper } from '../io/private/io-helper';\n\nexport interface IStackAssembly {\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  directory: string;\n\n  /**\n   * Select a single stack by its ID\n   */\n  stackById(stackId: string): StackCollection;\n}\n\n/**\n * When selecting stacks, what other stacks to include because of dependencies\n */\nexport enum ExtendedStackSelection {\n  /**\n   * Don't select any extra stacks\n   */\n  None,\n\n  /**\n   * Include stacks that this stack depends on\n   */\n  Upstream,\n\n  /**\n   * Include stacks that depend on this stack\n   */\n  Downstream,\n}\n\n/**\n * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside\n */\nexport abstract class BaseStackAssembly implements IStackAssembly {\n  /**\n   * Sanitize a list of stack match patterns\n   */\n  protected static sanitizePatterns(patterns: string[]): string[] {\n    let sanitized = patterns.filter(s => s != null); // filter null/undefined\n    sanitized = [...new Set(sanitized)]; // make them unique\n    return sanitized;\n  }\n\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  public readonly directory: string;\n\n  /**\n   * The IoHelper used for messaging\n   */\n  protected readonly ioHelper: IoHelper;\n\n  constructor(public readonly assembly: cxapi.CloudAssembly, ioHelper: IoHelper) {\n    this.directory = assembly.directory;\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Select a single stack by its ID\n   */\n  public stackById(stackId: string) {\n    return new StackCollection(this, [this.assembly.getStackArtifact(stackId)]);\n  }\n\n  protected async selectMatchingStacks(\n    stacks: cxapi.CloudFormationStackArtifact[],\n    patterns: string[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ): Promise<StackCollection> {\n    const matchingPattern = (pattern: string) => (stack: cxapi.CloudFormationStackArtifact) => minimatch(stack.hierarchicalId, pattern);\n    const matchedStacks = flatten(patterns.map(pattern => stacks.filter(matchingPattern(pattern))));\n\n    return this.extendStacks(matchedStacks, stacks, extend);\n  }\n\n  protected async extendStacks(\n    matched: cxapi.CloudFormationStackArtifact[],\n    all: cxapi.CloudFormationStackArtifact[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ) {\n    const allStacks = new Map<string, cxapi.CloudFormationStackArtifact>();\n    for (const stack of all) {\n      allStacks.set(stack.hierarchicalId, stack);\n    }\n\n    const index = indexByHierarchicalId(matched);\n\n    switch (extend) {\n      case ExtendedStackSelection.Downstream:\n        await includeDownstreamStacks(this.ioHelper, index, allStacks);\n        break;\n      case ExtendedStackSelection.Upstream:\n        await includeUpstreamStacks(this.ioHelper, index, allStacks);\n        break;\n    }\n\n    // Filter original array because it is in the right order\n    const selectedList = all.filter(s => index.has(s.hierarchicalId));\n\n    return new StackCollection(this, selectedList);\n  }\n}\n\nfunction indexByHierarchicalId(stacks: cxapi.CloudFormationStackArtifact[]): Map<string, cxapi.CloudFormationStackArtifact> {\n  const result = new Map<string, cxapi.CloudFormationStackArtifact>();\n\n  for (const stack of stacks) {\n    result.set(stack.hierarchicalId, stack);\n  }\n\n  return result;\n}\n\n/**\n * Calculate the transitive closure of stack dependents.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeDownstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n\n  let madeProgress;\n  do {\n    madeProgress = false;\n\n    for (const [id, stack] of allStacks) {\n      // Select this stack if it's not selected yet AND it depends on a stack that's in the selected set\n      if (!selectedStacks.has(id) && (stack.dependencies || []).some(dep => selectedStacks.has(dep.id))) {\n        selectedStacks.set(id, stack);\n        added.push(id);\n        madeProgress = true;\n      }\n    }\n  } while (madeProgress);\n\n  if (added.length > 0) {\n    await ioHelper.defaults.info(`Including depending stacks: ${chalk.bold(added.join(', '))}`);\n  }\n}\n\n/**\n * Calculate the transitive closure of stack dependencies.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeUpstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n  let madeProgress = true;\n  while (madeProgress) {\n    madeProgress = false;\n\n    for (const stack of selectedStacks.values()) {\n      // Select an additional stack if it's not selected yet and a dependency of a selected stack (and exists, obviously)\n      for (const dependencyId of stack.dependencies.map(x => x.manifest.displayName ?? x.id)) {\n        if (!selectedStacks.has(dependencyId) && allStacks.has(dependencyId)) {\n          added.push(dependencyId);\n          selectedStacks.set(dependencyId, allStacks.get(dependencyId)!);\n          madeProgress = true;\n        }\n      }\n    }\n  }\n\n  if (added.length > 0) {\n    await ioHelper.defaults.info(`Including dependency stacks: ${chalk.bold(added.join(', '))}`);\n  }\n}\n"]}

package/lib/api/cloudformation/template-body-parameter.d.ts

@@ -1,7 +1,7 @@
 import { type CloudFormationStackArtifact, type Environment } from '@aws-cdk/cx-api';
 import type { AssetManifestBuilder } from '../deployments';
 import type { EnvironmentResources } from '../environment';
-import { type IoHelper } from '../io/private';
+import type { IoHelper } from '../io/private';
 export type TemplateBodyParameter = {
     TemplateBody?: string;
     TemplateURL?: string;

package/lib/api/cloudformation/template-body-parameter.js

@@ -10,7 +10,6 @@ const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
 const chalk = require("chalk");
 const toolkit_error_1 = require("../../toolkit/toolkit-error");
 const util_1 = require("../../util");
-const private_1 = require("../io/private");
 const LARGE_TEMPLATE_SIZE_KB = 50;
 /**
  * Prepares the body parameter for +CreateChangeSet+.
@@ -39,9 +38,9 @@ async function makeBodyParameter(ioHelper, stack, resolvedEnvironment, assetMani
     }
     const toolkitInfo = await resources.lookupToolkit();
     if (!toolkitInfo.found) {
-        await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_ERROR.msg(util.format(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
+        await ioHelper.defaults.error(util.format(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
             `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\n` +
-            'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\n\n', chalk.blue(`\t$ cdk bootstrap ${resolvedEnvironment.name}\n`))));
+            'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\n\n', chalk.blue(`\t$ cdk bootstrap ${resolvedEnvironment.name}\n`)));
         throw new toolkit_error_1.ToolkitError('Template too large to deploy ("cdk bootstrap" is required)');
     }
     const templateHash = (0, util_1.contentHash)(templateJson);
@@ -60,7 +59,7 @@ async function makeBodyParameter(ioHelper, stack, resolvedEnvironment, assetMani
         objectKey: key,
     });
     const templateURL = `${toolkitInfo.bucketUrl}/${key}`;
-    await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing template in S3 at: ${templateURL}`));
+    await ioHelper.defaults.debug(`Storing template in S3 at: ${templateURL}`);
     return { TemplateURL: templateURL };
 }
 /**
@@ -101,4 +100,4 @@ async function restUrlFromManifest(url, environment) {
     endpoint.url.hostname;
     return `${endpoint.url.origin}/${bucketName}/${objectKey}`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-body-parameter.js","sourceRoot":"","sources":["template-body-parameter.ts"],"names":[],"mappings":";;AAiCA,8CA6DC;AA9FD,uCAAuC;AACvC,kCAAkC;AAClC,kCAAkC;AAClC,4CAA8G;AAC9G,kDAAiE;AACjE,qEAA0E;AAC1E,+BAA+B;AAC/B,+DAA2D;AAC3D,qCAAiD;AAGjD,2CAAkD;AAOlD,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAElC;;;;;;;;;;;;GAYG;AACI,KAAK,UAAU,iBAAiB,CACrC,QAAkB,EAClB,KAAkC,EAClC,mBAAgC,EAChC,aAAmC,EACnC,SAA+B,EAC/B,gBAAsB;IAEtB,2EAA2E;IAC3E,IAAI,KAAK,CAAC,2BAA2B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC3D,OAAO;YACL,WAAW,EAAE,MAAM,mBAAmB,CAAC,KAAK,CAAC,2BAA2B,EAAE,mBAAmB,CAAC;SAC/F,CAAC;IACJ,CAAC;IAED,oEAAoE;IACpE,MAAM,YAAY,GAAG,IAAA,aAAM,EAAC,gBAAgB,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;IAEhE,IAAI,YAAY,CAAC,MAAM,IAAI,sBAAsB,GAAG,IAAI,EAAE,CAAC;QACzD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;IACxC,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,SAAS,CAAC,aAAa,EAAE,CAAC;IACpD,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACvB,MAAM,QAAQ,CAAC,MAAM,CACnB,YAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CACtC,2BAA2B,KAAK,CAAC,WAAW,QAAQ,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO;YACjG,yBAAyB,sBAAsB,+BAA+B;YAC9E,uGAAuG,EACvG,KAAK,CAAC,IAAI,CAAC,qBAAqB,mBAAmB,CAAC,IAAI,IAAI,CAAC,CAC9D,CAAC,CACH,CAAC;QAEF,MAAM,IAAI,4BAAY,CAAC,4DAA4D,CAAC,CAAC;IACvF,CAAC;IAED,MAAM,YAAY,GAAG,IAAA,kBAAW,EAAC,YAAY,CAAC,CAAC;IAC/C,MAAM,GAAG,GAAG,OAAO,KAAK,CAAC,EAAE,IAAI,YAAY,MAAM,CAAC;IAElD,IAAI,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;IACtC,IAAI,gBAAgB,EAAE,CAAC;QACrB,iCAAiC;QACjC,YAAY,GAAG,GAAG,KAAK,CAAC,YAAY,IAAI,YAAY,OAAO,CAAC;QAC5D,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QAC3E,MAAM,EAAE,CAAC,SAAS,CAAC,gBAAgB,EAAE,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IAC5E,CAAC;IAED,aAAa,CAAC,YAAY,CACxB,YAAY,EACZ;QACE,IAAI,EAAE,YAAY;KACnB,EACD;QACE,UAAU,EAAE,WAAW,CAAC,UAAU;QAClC,SAAS,EAAE,GAAG;KACf,CACF,CAAC;IAEF,MAAM,WAAW,GAAG,GAAG,WAAW,CAAC,SAAS,IAAI,GAAG,EAAE,CAAC;IACtD,MAAM,QAAQ,CAAC,MAAM,CAAC,YAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,8BAA8B,WAAW,EAAE,CAAC,CAAC,CAAC;IACjG,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,mBAAmB,CAAC,GAAW,EAAE,WAAwB;IACtE,MAAM,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAClC,gEAAgE;IAChE,GAAG,GAAG,gCAAuB,CAAC,OAAO,CAAC,GAAG,EAAE;QACzC,SAAS,EAAE,WAAW,CAAC,OAAO;QAC9B,MAAM;QACN,SAAS,EAAE,cAAc;KAC1B,CAAC,CAAC;IAEH,6FAA6F;IAC7F,qEAAqE;IACrE,IAAI,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,4BAAY,CAAC,2EAA2E,CAAC,CAAC;IACtG,CAAC;IAED,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACjD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,GAAG,CAAC;IACb,CAAC;IAED,wGAAwG;IACxG,4EAA4E;IAC5E,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAE3B,kEAAkE;IAClE,oDAAoD;IACpD,MAAM,EAAE,GAAG,IAAI,oBAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACpC,MAAM,QAAQ,GAAG,MAAM,IAAA,iDAA2B,EAAC,EAAE,EAAE,6BAAiB,EAAE;QACxE,GAAG,EAAE,CAAC,MAAM;KACb,CAAC,CAAC;IACH,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC;IAEtB,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,IAAI,UAAU,IAAI,SAAS,EAAE,CAAC;AAC7D,CAAC","sourcesContent":["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as util from 'node:util';\nimport { type CloudFormationStackArtifact, type Environment, EnvironmentPlaceholders } from '@aws-cdk/cx-api';\nimport { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';\nimport { getEndpointFromInstructions } from '@smithy/middleware-endpoint';\nimport * as chalk from 'chalk';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport { contentHash, toYAML } from '../../util';\nimport type { AssetManifestBuilder } from '../deployments';\nimport type { EnvironmentResources } from '../environment';\nimport { IO, type IoHelper } from '../io/private';\n\nexport type TemplateBodyParameter = {\n  TemplateBody?: string;\n  TemplateURL?: string;\n};\n\nconst LARGE_TEMPLATE_SIZE_KB = 50;\n\n/**\n * Prepares the body parameter for +CreateChangeSet+.\n *\n * If the template is small enough to be inlined into the API call, just return\n * it immediately.\n *\n * Otherwise, add it to the asset manifest to get uploaded to the staging\n * bucket and return its coordinates. If there is no staging bucket, an error\n * is thrown.\n *\n * @param stack     the synthesized stack that provides the CloudFormation template\n * @param toolkitInfo information about the toolkit stack\n */\nexport async function makeBodyParameter(\n  ioHelper: IoHelper,\n  stack: CloudFormationStackArtifact,\n  resolvedEnvironment: Environment,\n  assetManifest: AssetManifestBuilder,\n  resources: EnvironmentResources,\n  overrideTemplate?: any,\n): Promise<TemplateBodyParameter> {\n  // If the template has already been uploaded to S3, just use it from there.\n  if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {\n    return {\n      TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),\n    };\n  }\n\n  // Otherwise, pass via API call (if small) or upload here (if large)\n  const templateJson = toYAML(overrideTemplate ?? stack.template);\n\n  if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {\n    return { TemplateBody: templateJson };\n  }\n\n  const toolkitInfo = await resources.lookupToolkit();\n  if (!toolkitInfo.found) {\n    await ioHelper.notify(\n      IO.DEFAULT_TOOLKIT_ERROR.msg(util.format(\n        `The template for stack \"${stack.displayName}\" is ${Math.round(templateJson.length / 1024)}KiB. ` +\n        `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\\n` +\n        'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\\n\\n',\n        chalk.blue(`\\t$ cdk bootstrap ${resolvedEnvironment.name}\\n`),\n      )),\n    );\n\n    throw new ToolkitError('Template too large to deploy (\"cdk bootstrap\" is required)');\n  }\n\n  const templateHash = contentHash(templateJson);\n  const key = `cdk/${stack.id}/${templateHash}.yml`;\n\n  let templateFile = stack.templateFile;\n  if (overrideTemplate) {\n    // Add a variant of this template\n    templateFile = `${stack.templateFile}-${templateHash}.yaml`;\n    const templateFilePath = path.join(stack.assembly.directory, templateFile);\n    await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });\n  }\n\n  assetManifest.addFileAsset(\n    templateHash,\n    {\n      path: templateFile,\n    },\n    {\n      bucketName: toolkitInfo.bucketName,\n      objectKey: key,\n    },\n  );\n\n  const templateURL = `${toolkitInfo.bucketUrl}/${key}`;\n  await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing template in S3 at: ${templateURL}`));\n  return { TemplateURL: templateURL };\n}\n\n/**\n * Format an S3 URL in the manifest for use with CloudFormation\n *\n * Replaces environment placeholders (which this field may contain),\n * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation\n * expects)\n */\nasync function restUrlFromManifest(url: string, environment: Environment): Promise<string> {\n  const doNotUseMarker = '**DONOTUSE**';\n  const region = environment.region;\n  // This URL may contain placeholders, so still substitute those.\n  url = EnvironmentPlaceholders.replace(url, {\n    accountId: environment.account,\n    region,\n    partition: doNotUseMarker,\n  });\n\n  // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend\n  // a lot of effort trying to thread the right value to this location.\n  if (url.indexOf(doNotUseMarker) > -1) {\n    throw new ToolkitError(\"Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field\");\n  }\n\n  const s3Url = url.match(/s3:\\/\\/([^/]+)\\/(.*)$/);\n  if (!s3Url) {\n    return url;\n  }\n\n  // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we\n  // got an 's3://bucket/object' URL instead. Construct the rest API URL here.\n  const bucketName = s3Url[1];\n  const objectKey = s3Url[2];\n\n  // SDK v3 no longer allows for getting endpoints from only region.\n  // A command and client config must now be provided.\n  const s3 = new S3Client({ region });\n  const endpoint = await getEndpointFromInstructions({}, HeadObjectCommand, {\n    ...s3.config,\n  });\n  endpoint.url.hostname;\n\n  return `${endpoint.url.origin}/${bucketName}/${objectKey}`;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-body-parameter.js","sourceRoot":"","sources":["template-body-parameter.ts"],"names":[],"mappings":";;AAiCA,8CA6DC;AA9FD,uCAAuC;AACvC,kCAAkC;AAClC,kCAAkC;AAClC,4CAA8G;AAC9G,kDAAiE;AACjE,qEAA0E;AAC1E,+BAA+B;AAC/B,+DAA2D;AAC3D,qCAAiD;AAUjD,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAElC;;;;;;;;;;;;GAYG;AACI,KAAK,UAAU,iBAAiB,CACrC,QAAkB,EAClB,KAAkC,EAClC,mBAAgC,EAChC,aAAmC,EACnC,SAA+B,EAC/B,gBAAsB;IAEtB,2EAA2E;IAC3E,IAAI,KAAK,CAAC,2BAA2B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC3D,OAAO;YACL,WAAW,EAAE,MAAM,mBAAmB,CAAC,KAAK,CAAC,2BAA2B,EAAE,mBAAmB,CAAC;SAC/F,CAAC;IACJ,CAAC;IAED,oEAAoE;IACpE,MAAM,YAAY,GAAG,IAAA,aAAM,EAAC,gBAAgB,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;IAEhE,IAAI,YAAY,CAAC,MAAM,IAAI,sBAAsB,GAAG,IAAI,EAAE,CAAC;QACzD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;IACxC,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,SAAS,CAAC,aAAa,EAAE,CAAC;IACpD,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACvB,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAC3B,IAAI,CAAC,MAAM,CACT,2BAA2B,KAAK,CAAC,WAAW,QAAQ,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO;YACjG,yBAAyB,sBAAsB,+BAA+B;YAC9E,uGAAuG,EACvG,KAAK,CAAC,IAAI,CAAC,qBAAqB,mBAAmB,CAAC,IAAI,IAAI,CAAC,CAC9D,CACF,CAAC;QAEF,MAAM,IAAI,4BAAY,CAAC,4DAA4D,CAAC,CAAC;IACvF,CAAC;IAED,MAAM,YAAY,GAAG,IAAA,kBAAW,EAAC,YAAY,CAAC,CAAC;IAC/C,MAAM,GAAG,GAAG,OAAO,KAAK,CAAC,EAAE,IAAI,YAAY,MAAM,CAAC;IAElD,IAAI,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;IACtC,IAAI,gBAAgB,EAAE,CAAC;QACrB,iCAAiC;QACjC,YAAY,GAAG,GAAG,KAAK,CAAC,YAAY,IAAI,YAAY,OAAO,CAAC;QAC5D,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QAC3E,MAAM,EAAE,CAAC,SAAS,CAAC,gBAAgB,EAAE,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IAC5E,CAAC;IAED,aAAa,CAAC,YAAY,CACxB,YAAY,EACZ;QACE,IAAI,EAAE,YAAY;KACnB,EACD;QACE,UAAU,EAAE,WAAW,CAAC,UAAU;QAClC,SAAS,EAAE,GAAG;KACf,CACF,CAAC;IAEF,MAAM,WAAW,GAAG,GAAG,WAAW,CAAC,SAAS,IAAI,GAAG,EAAE,CAAC;IACtD,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,8BAA8B,WAAW,EAAE,CAAC,CAAC;IAC3E,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,mBAAmB,CAAC,GAAW,EAAE,WAAwB;IACtE,MAAM,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAClC,gEAAgE;IAChE,GAAG,GAAG,gCAAuB,CAAC,OAAO,CAAC,GAAG,EAAE;QACzC,SAAS,EAAE,WAAW,CAAC,OAAO;QAC9B,MAAM;QACN,SAAS,EAAE,cAAc;KAC1B,CAAC,CAAC;IAEH,6FAA6F;IAC7F,qEAAqE;IACrE,IAAI,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,4BAAY,CAAC,2EAA2E,CAAC,CAAC;IACtG,CAAC;IAED,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACjD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,GAAG,CAAC;IACb,CAAC;IAED,wGAAwG;IACxG,4EAA4E;IAC5E,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAE3B,kEAAkE;IAClE,oDAAoD;IACpD,MAAM,EAAE,GAAG,IAAI,oBAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACpC,MAAM,QAAQ,GAAG,MAAM,IAAA,iDAA2B,EAAC,EAAE,EAAE,6BAAiB,EAAE;QACxE,GAAG,EAAE,CAAC,MAAM;KACb,CAAC,CAAC;IACH,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC;IAEtB,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,IAAI,UAAU,IAAI,SAAS,EAAE,CAAC;AAC7D,CAAC","sourcesContent":["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as util from 'node:util';\nimport { type CloudFormationStackArtifact, type Environment, EnvironmentPlaceholders } from '@aws-cdk/cx-api';\nimport { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';\nimport { getEndpointFromInstructions } from '@smithy/middleware-endpoint';\nimport * as chalk from 'chalk';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport { contentHash, toYAML } from '../../util';\nimport type { AssetManifestBuilder } from '../deployments';\nimport type { EnvironmentResources } from '../environment';\nimport type { IoHelper } from '../io/private';\n\nexport type TemplateBodyParameter = {\n  TemplateBody?: string;\n  TemplateURL?: string;\n};\n\nconst LARGE_TEMPLATE_SIZE_KB = 50;\n\n/**\n * Prepares the body parameter for +CreateChangeSet+.\n *\n * If the template is small enough to be inlined into the API call, just return\n * it immediately.\n *\n * Otherwise, add it to the asset manifest to get uploaded to the staging\n * bucket and return its coordinates. If there is no staging bucket, an error\n * is thrown.\n *\n * @param stack     the synthesized stack that provides the CloudFormation template\n * @param toolkitInfo information about the toolkit stack\n */\nexport async function makeBodyParameter(\n  ioHelper: IoHelper,\n  stack: CloudFormationStackArtifact,\n  resolvedEnvironment: Environment,\n  assetManifest: AssetManifestBuilder,\n  resources: EnvironmentResources,\n  overrideTemplate?: any,\n): Promise<TemplateBodyParameter> {\n  // If the template has already been uploaded to S3, just use it from there.\n  if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {\n    return {\n      TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),\n    };\n  }\n\n  // Otherwise, pass via API call (if small) or upload here (if large)\n  const templateJson = toYAML(overrideTemplate ?? stack.template);\n\n  if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {\n    return { TemplateBody: templateJson };\n  }\n\n  const toolkitInfo = await resources.lookupToolkit();\n  if (!toolkitInfo.found) {\n    await ioHelper.defaults.error(\n      util.format(\n        `The template for stack \"${stack.displayName}\" is ${Math.round(templateJson.length / 1024)}KiB. ` +\n        `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\\n` +\n        'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\\n\\n',\n        chalk.blue(`\\t$ cdk bootstrap ${resolvedEnvironment.name}\\n`),\n      ),\n    );\n\n    throw new ToolkitError('Template too large to deploy (\"cdk bootstrap\" is required)');\n  }\n\n  const templateHash = contentHash(templateJson);\n  const key = `cdk/${stack.id}/${templateHash}.yml`;\n\n  let templateFile = stack.templateFile;\n  if (overrideTemplate) {\n    // Add a variant of this template\n    templateFile = `${stack.templateFile}-${templateHash}.yaml`;\n    const templateFilePath = path.join(stack.assembly.directory, templateFile);\n    await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });\n  }\n\n  assetManifest.addFileAsset(\n    templateHash,\n    {\n      path: templateFile,\n    },\n    {\n      bucketName: toolkitInfo.bucketName,\n      objectKey: key,\n    },\n  );\n\n  const templateURL = `${toolkitInfo.bucketUrl}/${key}`;\n  await ioHelper.defaults.debug(`Storing template in S3 at: ${templateURL}`);\n  return { TemplateURL: templateURL };\n}\n\n/**\n * Format an S3 URL in the manifest for use with CloudFormation\n *\n * Replaces environment placeholders (which this field may contain),\n * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation\n * expects)\n */\nasync function restUrlFromManifest(url: string, environment: Environment): Promise<string> {\n  const doNotUseMarker = '**DONOTUSE**';\n  const region = environment.region;\n  // This URL may contain placeholders, so still substitute those.\n  url = EnvironmentPlaceholders.replace(url, {\n    accountId: environment.account,\n    region,\n    partition: doNotUseMarker,\n  });\n\n  // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend\n  // a lot of effort trying to thread the right value to this location.\n  if (url.indexOf(doNotUseMarker) > -1) {\n    throw new ToolkitError(\"Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field\");\n  }\n\n  const s3Url = url.match(/s3:\\/\\/([^/]+)\\/(.*)$/);\n  if (!s3Url) {\n    return url;\n  }\n\n  // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we\n  // got an 's3://bucket/object' URL instead. Construct the rest API URL here.\n  const bucketName = s3Url[1];\n  const objectKey = s3Url[2];\n\n  // SDK v3 no longer allows for getting endpoints from only region.\n  // A command and client config must now be provided.\n  const s3 = new S3Client({ region });\n  const endpoint = await getEndpointFromInstructions({}, HeadObjectCommand, {\n    ...s3.config,\n  });\n  endpoint.url.hostname;\n\n  return `${endpoint.url.origin}/${bucketName}/${objectKey}`;\n}\n"]}

package/lib/api/context.d.ts

@@ -1,7 +1,7 @@
 import { Settings } from './settings';
 export { TRANSIENT_CONTEXT_KEY } from './settings';
 export declare const PROJECT_CONTEXT = "cdk.context.json";
-interface ContextBag {
+export interface ContextBag {
     /**
      * The file name of the context. Will be used to potentially
      * save new context back to the original file.

package/lib/api/context.js

@@ -81,4 +81,4 @@ class Context {
     }
 }
 exports.Context = Context;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImNvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEseUNBQXNDO0FBQ3RDLDREQUF3RDtBQUV4RCx1Q0FBbUQ7QUFBMUMsaUhBQUEscUJBQXFCLE9BQUE7QUFDakIsUUFBQSxlQUFlLEdBQUcsa0JBQWtCLENBQUM7QUFlbEQ7Ozs7Ozs7R0FPRztBQUNILE1BQWEsT0FBTztJQUNELElBQUksQ0FBYTtJQUNqQixTQUFTLENBQXlCO0lBRW5ELFlBQVksR0FBRyxJQUFrQjtRQUMvQixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxtQkFBUSxFQUFFLENBQUMsQ0FBQztRQUN4RSxJQUFJLENBQUMsU0FBUztZQUNaLElBQUksQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUVELElBQVcsSUFBSTtRQUNiLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVNLEdBQUcsQ0FBQyxHQUFXO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVELElBQVcsR0FBRztRQUNaLElBQUksR0FBRyxHQUFHLElBQUksbUJBQVEsRUFBRSxDQUFDO1FBRXpCLDJFQUEyRTtRQUMzRSxLQUFLLE1BQU0sR0FBRyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQztZQUMzQyxHQUFHLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUN2QixDQUFDO1FBRUQsT0FBTyxHQUFHLENBQUMsR0FBRyxDQUFDO0lBQ2pCLENBQUM7SUFFTSxHQUFHLENBQUMsR0FBVztRQUNwQixLQUFLLE1BQU0sR0FBRyxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUM1QixNQUFNLENBQUMsR0FBRyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztZQUN6QixJQUFJLENBQUMsS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDcEIsT0FBTyxDQUFDLENBQUM7WUFDWCxDQUFDO1FBQ0gsQ0FBQztRQUNELE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFTSxHQUFHLENBQUMsR0FBVyxFQUFFLEtBQVU7UUFDaEMsS0FBSyxNQUFNLEdBQUcsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDNUIsSUFBSSxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUM7Z0JBQ2pCLFNBQVM7WUFDWCxDQUFDO1lBRUQsb0RBQW9EO1lBQ3BELEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztZQUN0QixLQUFLLEdBQUcsU0FBUyxDQUFDO1FBQ3BCLENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLEdBQVc7UUFDdEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVNLEtBQUs7UUFDVixLQUFLLE1BQU0sR0FBRyxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUM1QixJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ2xCLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsSUFBSSxDQUFDLFFBQWdCO1FBQ2hDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBRS9DLHFEQUFxRDtRQUNyRCxJQUFJLEtBQUssS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQ2pCLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUVELE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDN0IsSUFBSSxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDakIsTUFBTSxJQUFJLDRCQUFZLENBQUMsZ0JBQWdCLFFBQVEsZ0JBQWdCLENBQUMsQ0FBQztRQUNuRSxDQUFDO1FBRUQsTUFBTSxHQUFHLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ3pCLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztDQUNGO0FBaEZELDBCQWdGQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNldHRpbmdzIH0gZnJvbSAnLi9zZXR0aW5ncyc7XG5pbXBvcnQgeyBUb29sa2l0RXJyb3IgfSBmcm9tICcuLi90b29sa2l0L3Rvb2xraXQtZXJyb3InO1xuXG5leHBvcnQgeyBUUkFOU0lFTlRfQ09OVEVYVF9LRVkgfSBmcm9tICcuL3NldHRpbmdzJztcbmV4cG9ydCBjb25zdCBQUk9KRUNUX0NPTlRFWFQgPSAnY2RrLmNvbnRleHQuanNvbic7XG5cbmludGVyZmFjZSBDb250ZXh0QmFnIHtcbiAgLyoqXG4gICAqIFRoZSBmaWxlIG5hbWUgb2YgdGhlIGNvbnRleHQuIFdpbGwgYmUgdXNlZCB0byBwb3RlbnRpYWxseVxuICAgKiBzYXZlIG5ldyBjb250ZXh0IGJhY2sgdG8gdGhlIG9yaWdpbmFsIGZpbGUuXG4gICAqL1xuICBmaWxlTmFtZT86IHN0cmluZztcblxuICAvKipcbiAgICogVGhlIGNvbnRleHQgdmFsdWVzLlxuICAgKi9cbiAgYmFnOiBTZXR0aW5ncztcbn1cblxuLyoqXG4gKiBDbGFzcyB0aGF0IHN1cHBvcnRzIG92ZXJsYXlpbmcgcHJvcGVydHkgYmFnc1xuICpcbiAqIFJlYWRzIGNvbWUgZnJvbSB0aGUgZmlyc3QgcHJvcGVydHkgYmFnIHRoYXQgY2FuIGhhcyB0aGUgZ2l2ZW4ga2V5LFxuICogd3JpdGVzIGdvIHRvIHRoZSBmaXJzdCBwcm9wZXJ0eSBiYWcgdGhhdCBpcyBub3QgcmVhZG9ubHkuIEEgd3JpdGVcbiAqIHdpbGwgcmVtb3ZlIHRoZSB2YWx1ZSBmcm9tIGFsbCBwcm9wZXJ0eSBiYWdzIGFmdGVyIHRoZSBmaXJzdFxuICogd3JpdGFibGUgb25lLlxuICovXG5leHBvcnQgY2xhc3MgQ29udGV4dCB7XG4gIHByaXZhdGUgcmVhZG9ubHkgYmFnczogU2V0dGluZ3NbXTtcbiAgcHJpdmF0ZSByZWFkb25seSBmaWxlTmFtZXM6IChzdHJpbmcgfCB1bmRlZmluZWQpW107XG5cbiAgY29uc3RydWN0b3IoLi4uYmFnczogQ29udGV4dEJhZ1tdKSB7XG4gICAgdGhpcy5iYWdzID0gYmFncy5sZW5ndGggPiAwID8gYmFncy5tYXAoKGIpID0+IGIuYmFnKSA6IFtuZXcgU2V0dGluZ3MoKV07XG4gICAgdGhpcy5maWxlTmFtZXMgPVxuICAgICAgYmFncy5sZW5ndGggPiAwID8gYmFncy5tYXAoKGIpID0+IGIuZmlsZU5hbWUpIDogWydkZWZhdWx0J107XG4gIH1cblxuICBwdWJsaWMgZ2V0IGtleXMoKTogc3RyaW5nW10ge1xuICAgIHJldHVybiBPYmplY3Qua2V5cyh0aGlzLmFsbCk7XG4gIH1cblxuICBwdWJsaWMgaGFzKGtleTogc3RyaW5nKSB7XG4gICAgcmV0dXJuIHRoaXMua2V5cy5pbmRleE9mKGtleSkgPiAtMTtcbiAgfVxuXG4gIHB1YmxpYyBnZXQgYWxsKCk6IHsgW2tleTogc3RyaW5nXTogYW55IH0ge1xuICAgIGxldCByZXQgPSBuZXcgU2V0dGluZ3MoKTtcblxuICAgIC8vIEluIHJldmVyc2Ugb3JkZXIgc28ga2V5cyB0byB0aGUgbGVmdCBvdmVyd3JpdGUga2V5cyB0byB0aGUgcmlnaHQgb2YgdGhlbVxuICAgIGZvciAoY29uc3QgYmFnIG9mIFsuLi50aGlzLmJhZ3NdLnJldmVyc2UoKSkge1xuICAgICAgcmV0ID0gcmV0Lm1lcmdlKGJhZyk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHJldC5hbGw7XG4gIH1cblxuICBwdWJsaWMgZ2V0KGtleTogc3RyaW5nKTogYW55IHtcbiAgICBmb3IgKGNvbnN0IGJhZyBvZiB0aGlzLmJhZ3MpIHtcbiAgICAgIGNvbnN0IHYgPSBiYWcuZ2V0KFtrZXldKTtcbiAgICAgIGlmICh2ICE9PSB1bmRlZmluZWQpIHtcbiAgICAgICAgcmV0dXJuIHY7XG4gICAgICB9XG4gICAgfVxuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cblxuICBwdWJsaWMgc2V0KGtleTogc3RyaW5nLCB2YWx1ZTogYW55KSB7XG4gICAgZm9yIChjb25zdCBiYWcgb2YgdGhpcy5iYWdzKSB7XG4gICAgICBpZiAoYmFnLnJlYWRPbmx5KSB7XG4gICAgICAgIGNvbnRpbnVlO1xuICAgICAgfVxuXG4gICAgICAvLyBBbGwgYmFncyBwYXN0IHRoZSBmaXJzdCBvbmUgaGF2ZSB0aGUgdmFsdWUgZXJhc2VkXG4gICAgICBiYWcuc2V0KFtrZXldLCB2YWx1ZSk7XG4gICAgICB2YWx1ZSA9IHVuZGVmaW5lZDtcbiAgICB9XG4gIH1cblxuICBwdWJsaWMgdW5zZXQoa2V5OiBzdHJpbmcpIHtcbiAgICB0aGlzLnNldChrZXksIHVuZGVmaW5lZCk7XG4gIH1cblxuICBwdWJsaWMgY2xlYXIoKSB7XG4gICAgZm9yIChjb25zdCBrZXkgb2YgdGhpcy5rZXlzKSB7XG4gICAgICB0aGlzLnVuc2V0KGtleSk7XG4gICAgfVxuICB9XG5cbiAgLyoqXG4gICAqIFNhdmUgYSBzcGVjaWZpYyBjb250ZXh0IGZpbGVcbiAgICovXG4gIHB1YmxpYyBhc3luYyBzYXZlKGZpbGVOYW1lOiBzdHJpbmcpOiBQcm9taXNlPHRoaXM+IHtcbiAgICBjb25zdCBpbmRleCA9IHRoaXMuZmlsZU5hbWVzLmluZGV4T2YoZmlsZU5hbWUpO1xuXG4gICAgLy8gRmlsZSBub3QgZm91bmQsIGRvbid0IGRvIGFueXRoaW5nIGluIHRoaXMgc2NlbmFyaW9cbiAgICBpZiAoaW5kZXggPT09IC0xKSB7XG4gICAgICByZXR1cm4gdGhpcztcbiAgICB9XG5cbiAgICBjb25zdCBiYWcgPSB0aGlzLmJhZ3NbaW5kZXhdO1xuICAgIGlmIChiYWcucmVhZE9ubHkpIHtcbiAgICAgIHRocm93IG5ldyBUb29sa2l0RXJyb3IoYENvbnRleHQgZmlsZSAke2ZpbGVOYW1lfSBpcyByZWFkIG9ubHkhYCk7XG4gICAgfVxuXG4gICAgYXdhaXQgYmFnLnNhdmUoZmlsZU5hbWUpO1xuICAgIHJldHVybiB0aGlzO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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