@aws-cdk/toolkit-lib 0.1.7 → 0.1.8

package/lib/api/cloud-assembly/private/prepare-source.d.ts

@@ -2,51 +2,61 @@ import * as cxapi from '@aws-cdk/cx-api';
 import type { ToolkitServices } from '../../../toolkit/private';
 import type { IoHelper } from '../../shared-private';
 import type { AppSynthOptions, LoadAssemblyOptions } from '../source-builder';
-export { guessExecutable } from '../../../api/aws-cdk';
 type Env = {
     [key: string]: string;
 };
 type Context = {
     [key: string]: any;
 };
-/**
- * Turn the given optional output directory into a fixed output directory
- */
-export declare function determineOutputDirectory(outdir?: string): string;
-/**
- * If we don't have region/account defined in context, we fall back to the default SDK behavior
- * where region is retrieved from ~/.aws/config and account is based on default credentials provider
- * chain and then STS is queried.
- *
- * This is done opportunistically: for example, if we can't access STS for some reason or the region
- * is not configured, the context value will be 'null' and there could failures down the line. In
- * some cases, synthesis does not require region/account information at all, so that might be perfectly
- * fine in certain scenarios.
- *
- * @param context The context key/value bash.
- */
-export declare function prepareDefaultEnvironment(services: ToolkitServices, props?: {
-    outdir?: string;
-}): Promise<Env>;
-/**
- * Run code from a different working directory
- */
-export declare function changeDir<T>(block: () => Promise<T>, workingDir?: string): Promise<T>;
-/**
- * Run code with additional environment variables
- */
-export declare function withEnv<T>(env: Env | undefined, block: () => Promise<T>): Promise<T>;
-/**
- * Run code with context setup inside the environment
- */
-export declare function withContext<T>(inputContext: Context, env: Env, synthOpts: AppSynthOptions | undefined, block: (env: Env, context: Context) => Promise<T>): Promise<T>;
-/**
- * Checks if a given assembly supports context overflow, warn otherwise.
- *
- * @param assembly the assembly to check
- */
-export declare function checkContextOverflowSupport(assembly: cxapi.CloudAssembly, ioHelper: IoHelper): Promise<void>;
+export declare class ExecutionEnvironment {
+    private readonly ioHelper;
+    private readonly sdkProvider;
+    private readonly debugFn;
+    private _outdir;
+    constructor(services: ToolkitServices, props?: {
+        outdir?: string;
+    });
+    /**
+     * Turn the given optional output directory into a fixed output directory
+     */
+    get outdir(): string;
+    /**
+     * Guess the executable from the command-line argument
+     *
+     * Only do this if the file is NOT marked as executable. If it is,
+     * we'll defer to the shebang inside the file itself.
+     *
+     * If we're on Windows, we ALWAYS take the handler, since it's hard to
+     * verify if registry associations have or have not been set up for this
+     * file type, so we'll assume the worst and take control.
+     */
+    guessExecutable(app: string): Promise<any>;
+    /**
+     * If we don't have region/account defined in context, we fall back to the default SDK behavior
+     * where region is retrieved from ~/.aws/config and account is based on default credentials provider
+     * chain and then STS is queried.
+     *
+     * This is done opportunistically: for example, if we can't access STS for some reason or the region
+     * is not configured, the context value will be 'null' and there could failures down the line. In
+     * some cases, synthesis does not require region/account information at all, so that might be perfectly
+     * fine in certain scenarios.
+     */
+    defaultEnvVars(): Promise<Env>;
+    /**
+     * Run code from a different working directory
+     */
+    changeDir<T>(block: () => Promise<T>, workingDir?: string): Promise<T>;
+    /**
+     * Run code with additional environment variables
+     */
+    withEnv<T>(env: Env | undefined, block: () => Promise<T>): Promise<T>;
+    /**
+     * Run code with context setup inside the environment
+     */
+    withContext<T>(inputContext: Context, env: Env, synthOpts: AppSynthOptions | undefined, block: (env: Env, context: Context) => Promise<T>): Promise<T>;
+}
 /**
  * Safely create an assembly from a cloud assembly directory
  */
-export declare function assemblyFromDirectory(assemblyDir: string, ioHost: IoHelper, loadOptions?: LoadAssemblyOptions): Promise<cxapi.CloudAssembly>;
+export declare function assemblyFromDirectory(assemblyDir: string, ioHelper: IoHelper, loadOptions?: LoadAssemblyOptions): Promise<cxapi.CloudAssembly>;
+export {};

package/lib/api/cloud-assembly/private/prepare-source.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.guessExecutable = void 0;
-exports.determineOutputDirectory = determineOutputDirectory;
-exports.prepareDefaultEnvironment = prepareDefaultEnvironment;
-exports.changeDir = changeDir;
-exports.withEnv = withEnv;
-exports.withContext = withContext;
-exports.checkContextOverflowSupport = checkContextOverflowSupport;
+exports.ExecutionEnvironment = void 0;
 exports.assemblyFromDirectory = assemblyFromDirectory;
 const os = require("node:os");
 const path = require("node:path");
@@ -19,106 +13,131 @@ const aws_cdk_1 = require("../../../api/aws-cdk");
 const util_1 = require("../../../private/util");
 const private_1 = require("../../io/private");
 const shared_public_1 = require("../../shared-public");
-var aws_cdk_2 = require("../../../api/aws-cdk");
-Object.defineProperty(exports, "guessExecutable", { enumerable: true, get: function () { return aws_cdk_2.guessExecutable; } });
-/**
- * Turn the given optional output directory into a fixed output directory
- */
-function determineOutputDirectory(outdir) {
-    return outdir ?? fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));
-}
-/**
- * If we don't have region/account defined in context, we fall back to the default SDK behavior
- * where region is retrieved from ~/.aws/config and account is based on default credentials provider
- * chain and then STS is queried.
- *
- * This is done opportunistically: for example, if we can't access STS for some reason or the region
- * is not configured, the context value will be 'null' and there could failures down the line. In
- * some cases, synthesis does not require region/account information at all, so that might be perfectly
- * fine in certain scenarios.
- *
- * @param context The context key/value bash.
- */
-async function prepareDefaultEnvironment(services, props = {}) {
-    const logFn = (msg, ...args) => services.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0010.msg((0, node_util_1.format)(msg, ...args)));
-    const env = await (0, aws_cdk_1.prepareDefaultEnvironment)(services.sdkProvider, logFn);
-    if (props.outdir) {
-        env[cxapi.OUTDIR_ENV] = props.outdir;
-        await logFn('outdir:', props.outdir);
+class ExecutionEnvironment {
+    ioHelper;
+    sdkProvider;
+    debugFn;
+    _outdir;
+    constructor(services, props = {}) {
+        this.ioHelper = services.ioHelper;
+        this.sdkProvider = services.sdkProvider;
+        this.debugFn = (msg) => this.ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_DEBUG.msg(msg));
+        this._outdir = props.outdir;
     }
-    // CLI version information
-    env[cxapi.CLI_ASM_VERSION_ENV] = cxschema.Manifest.version();
-    env[cxapi.CLI_VERSION_ENV] = (0, aws_cdk_1.versionNumber)();
-    await logFn('env:', env);
-    return env;
-}
-/**
- * Run code from a different working directory
- */
-async function changeDir(block, workingDir) {
-    const originalWorkingDir = process.cwd();
-    try {
-        if (workingDir) {
-            process.chdir(workingDir);
+    /**
+     * Turn the given optional output directory into a fixed output directory
+     */
+    get outdir() {
+        if (!this._outdir) {
+            const outdir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));
+            this._outdir = outdir;
         }
-        return await block();
+        return this._outdir;
     }
-    finally {
-        if (workingDir) {
-            process.chdir(originalWorkingDir);
-        }
+    /**
+     * Guess the executable from the command-line argument
+     *
+     * Only do this if the file is NOT marked as executable. If it is,
+     * we'll defer to the shebang inside the file itself.
+     *
+     * If we're on Windows, we ALWAYS take the handler, since it's hard to
+     * verify if registry associations have or have not been set up for this
+     * file type, so we'll assume the worst and take control.
+     */
+    guessExecutable(app) {
+        return (0, aws_cdk_1.guessExecutable)(app, this.debugFn);
     }
-}
-/**
- * Run code with additional environment variables
- */
-async function withEnv(env = {}, block) {
-    const originalEnv = process.env;
-    try {
-        process.env = {
-            ...originalEnv,
-            ...env,
-        };
-        return await block();
+    /**
+     * If we don't have region/account defined in context, we fall back to the default SDK behavior
+     * where region is retrieved from ~/.aws/config and account is based on default credentials provider
+     * chain and then STS is queried.
+     *
+     * This is done opportunistically: for example, if we can't access STS for some reason or the region
+     * is not configured, the context value will be 'null' and there could failures down the line. In
+     * some cases, synthesis does not require region/account information at all, so that might be perfectly
+     * fine in certain scenarios.
+     */
+    async defaultEnvVars() {
+        const debugFn = (msg) => this.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0010.msg(msg));
+        const env = await (0, aws_cdk_1.prepareDefaultEnvironment)(this.sdkProvider, debugFn);
+        env[cxapi.OUTDIR_ENV] = this.outdir;
+        await debugFn((0, node_util_1.format)('outdir:', this.outdir));
+        // CLI version information
+        env[cxapi.CLI_ASM_VERSION_ENV] = cxschema.Manifest.version();
+        env[cxapi.CLI_VERSION_ENV] = (0, aws_cdk_1.versionNumber)();
+        await debugFn((0, node_util_1.format)('env:', env));
+        return env;
     }
-    finally {
-        process.env = originalEnv;
+    /**
+     * Run code from a different working directory
+     */
+    async changeDir(block, workingDir) {
+        const originalWorkingDir = process.cwd();
+        try {
+            if (workingDir) {
+                process.chdir(workingDir);
+            }
+            return await block();
+        }
+        finally {
+            if (workingDir) {
+                process.chdir(originalWorkingDir);
+            }
+        }
     }
-}
-/**
- * Run code with context setup inside the environment
- */
-async function withContext(inputContext, env, synthOpts = {}, block) {
-    const context = await (0, aws_cdk_1.prepareContext)(synthOptsDefaults(synthOpts), inputContext, env);
-    let contextOverflowLocation = null;
-    try {
-        const envVariableSizeLimit = os.platform() === 'win32' ? 32760 : 131072;
-        const [smallContext, overflow] = (0, util_1.splitBySize)(context, (0, aws_cdk_1.spaceAvailableForContext)(env, envVariableSizeLimit));
-        // Store the safe part in the environment variable
-        env[cxapi.CONTEXT_ENV] = JSON.stringify(smallContext);
-        // If there was any overflow, write it to a temporary file
-        if (Object.keys(overflow ?? {}).length > 0) {
-            const contextDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-context'));
-            contextOverflowLocation = path.join(contextDir, 'context-overflow.json');
-            fs.writeJSONSync(contextOverflowLocation, overflow);
-            env[cxapi.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;
+    /**
+     * Run code with additional environment variables
+     */
+    async withEnv(env = {}, block) {
+        const originalEnv = process.env;
+        try {
+            process.env = {
+                ...originalEnv,
+                ...env,
+            };
+            return await block();
+        }
+        finally {
+            process.env = originalEnv;
         }
-        // call the block code with new environment
-        return await block(env, context);
     }
-    finally {
-        if (contextOverflowLocation) {
-            fs.removeSync(path.dirname(contextOverflowLocation));
+    /**
+     * Run code with context setup inside the environment
+     */
+    async withContext(inputContext, env, synthOpts = {}, block) {
+        const context = await (0, aws_cdk_1.prepareContext)(synthOptsDefaults(synthOpts), inputContext, env, this.debugFn);
+        let contextOverflowLocation = null;
+        try {
+            const envVariableSizeLimit = os.platform() === 'win32' ? 32760 : 131072;
+            const [smallContext, overflow] = (0, util_1.splitBySize)(context, (0, aws_cdk_1.spaceAvailableForContext)(env, envVariableSizeLimit));
+            // Store the safe part in the environment variable
+            env[cxapi.CONTEXT_ENV] = JSON.stringify(smallContext);
+            // If there was any overflow, write it to a temporary file
+            if (Object.keys(overflow ?? {}).length > 0) {
+                const contextDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-context'));
+                contextOverflowLocation = path.join(contextDir, 'context-overflow.json');
+                fs.writeJSONSync(contextOverflowLocation, overflow);
+                env[cxapi.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;
+            }
+            // call the block code with new environment
+            return await block(env, context);
+        }
+        finally {
+            if (contextOverflowLocation) {
+                fs.removeSync(path.dirname(contextOverflowLocation));
+            }
         }
     }
 }
+exports.ExecutionEnvironment = ExecutionEnvironment;
 /**
  * Checks if a given assembly supports context overflow, warn otherwise.
  *
  * @param assembly the assembly to check
  */
 async function checkContextOverflowSupport(assembly, ioHelper) {
-    const tree = (0, aws_cdk_1.loadTree)(assembly, (msg) => void ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_TRACE.msg(msg)));
+    const traceFn = (msg) => ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_TRACE.msg(msg));
+    const tree = await (0, aws_cdk_1.loadTree)(assembly, traceFn);
     const frameworkDoesNotSupportContextOverflow = (0, aws_cdk_1.some)(tree, node => {
         const fqn = node.constructInfo?.fqn;
         const version = node.constructInfo?.version;
@@ -134,7 +153,7 @@ async function checkContextOverflowSupport(assembly, ioHelper) {
 /**
  * Safely create an assembly from a cloud assembly directory
  */
-async function assemblyFromDirectory(assemblyDir, ioHost, loadOptions = {}) {
+async function assemblyFromDirectory(assemblyDir, ioHelper, loadOptions = {}) {
     try {
         const assembly = new cxapi.CloudAssembly(assemblyDir, {
             skipVersionCheck: !(loadOptions.checkVersion ?? true),
@@ -142,7 +161,7 @@ async function assemblyFromDirectory(assemblyDir, ioHost, loadOptions = {}) {
             // We sort as we deploy
             topoSort: false,
         });
-        await checkContextOverflowSupport(assembly, ioHost);
+        await checkContextOverflowSupport(assembly, ioHelper);
         return assembly;
     }
     catch (err) {
@@ -150,7 +169,7 @@ async function assemblyFromDirectory(assemblyDir, ioHost, loadOptions = {}) {
             // this means the CLI version is too old.
             // we instruct the user to upgrade.
             const message = 'This AWS CDK Toolkit is not compatible with the AWS CDK library used by your application. Please upgrade to the latest version.';
-            await ioHost.notify(private_1.IO.CDK_ASSEMBLY_E1111.msg(message, { error: err }));
+            await ioHelper.notify(private_1.IO.CDK_ASSEMBLY_E1111.msg(message, { error: err }));
             throw new shared_public_1.ToolkitError(`${message}\n(${err.message}`);
         }
         throw err;
@@ -166,4 +185,4 @@ function synthOptsDefaults(synthOpts = {}) {
         ...synthOpts,
     }, true);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prepare-source.js","sourceRoot":"","sources":["prepare-source.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'node:os';\nimport * as path from 'node:path';\nimport { format } from 'node:util';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport { lte } from 'semver';\nimport { prepareDefaultEnvironment as oldPrepare, prepareContext, spaceAvailableForContext, Settings, loadTree, some, versionNumber } from '../../../api/aws-cdk';\nimport { splitBySize } from '../../../private/util';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport { IO } from '../../io/private';\nimport type { IoHelper } from '../../shared-private';\nimport { ToolkitError } from '../../shared-public';\nimport type { AppSynthOptions, LoadAssemblyOptions } from '../source-builder';\n\nexport { guessExecutable } from '../../../api/aws-cdk';\n\ntype Env = { [key: string]: string };\ntype Context = { [key: string]: any };\n\n/**\n * Turn the given optional output directory into a fixed output directory\n */\nexport function determineOutputDirectory(outdir?: string) {\n  return outdir ?? fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));\n}\n\n/**\n * If we don't have region/account defined in context, we fall back to the default SDK behavior\n * where region is retrieved from ~/.aws/config and account is based on default credentials provider\n * chain and then STS is queried.\n *\n * This is done opportunistically: for example, if we can't access STS for some reason or the region\n * is not configured, the context value will be 'null' and there could failures down the line. In\n * some cases, synthesis does not require region/account information at all, so that might be perfectly\n * fine in certain scenarios.\n *\n * @param context The context key/value bash.\n */\nexport async function prepareDefaultEnvironment(services: ToolkitServices, props: { outdir?: string } = {}): Promise<Env> {\n  const logFn = (msg: string, ...args: any) => services.ioHelper.notify(IO.CDK_ASSEMBLY_I0010.msg(format(msg, ...args)));\n  const env = await oldPrepare(services.sdkProvider, logFn);\n\n  if (props.outdir) {\n    env[cxapi.OUTDIR_ENV] = props.outdir;\n    await logFn('outdir:', props.outdir);\n  }\n\n  // CLI version information\n  env[cxapi.CLI_ASM_VERSION_ENV] = cxschema.Manifest.version();\n  env[cxapi.CLI_VERSION_ENV] = versionNumber();\n\n  await logFn('env:', env);\n  return env;\n}\n\n/**\n * Run code from a different working directory\n */\nexport async function changeDir<T>(block: () => Promise<T>, workingDir?: string) {\n  const originalWorkingDir = process.cwd();\n  try {\n    if (workingDir) {\n      process.chdir(workingDir);\n    }\n\n    return await block();\n  } finally {\n    if (workingDir) {\n      process.chdir(originalWorkingDir);\n    }\n  }\n}\n\n/**\n * Run code with additional environment variables\n */\nexport async function withEnv<T>(env: Env = {}, block: () => Promise<T>) {\n  const originalEnv = process.env;\n  try {\n    process.env = {\n      ...originalEnv,\n      ...env,\n    };\n\n    return await block();\n  } finally {\n    process.env = originalEnv;\n  }\n}\n\n/**\n * Run code with context setup inside the environment\n */\nexport async function withContext<T>(\n  inputContext: Context,\n  env: Env,\n  synthOpts: AppSynthOptions = {},\n  block: (env: Env, context: Context) => Promise<T>,\n) {\n  const context = await prepareContext(synthOptsDefaults(synthOpts), inputContext, env);\n  let contextOverflowLocation = null;\n\n  try {\n    const envVariableSizeLimit = os.platform() === 'win32' ? 32760 : 131072;\n    const [smallContext, overflow] = splitBySize(context, spaceAvailableForContext(env, envVariableSizeLimit));\n\n    // Store the safe part in the environment variable\n    env[cxapi.CONTEXT_ENV] = JSON.stringify(smallContext);\n\n    // If there was any overflow, write it to a temporary file\n    if (Object.keys(overflow ?? {}).length > 0) {\n      const contextDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-context'));\n      contextOverflowLocation = path.join(contextDir, 'context-overflow.json');\n      fs.writeJSONSync(contextOverflowLocation, overflow);\n      env[cxapi.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;\n    }\n\n    // call the block code with new environment\n    return await block(env, context);\n  } finally {\n    if (contextOverflowLocation) {\n      fs.removeSync(path.dirname(contextOverflowLocation));\n    }\n  }\n}\n\n/**\n * Checks if a given assembly supports context overflow, warn otherwise.\n *\n * @param assembly the assembly to check\n */\nexport async function checkContextOverflowSupport(assembly: cxapi.CloudAssembly, ioHelper: IoHelper): Promise<void> {\n  const tree = loadTree(assembly, (msg: string) => void ioHelper.notify(IO.DEFAULT_ASSEMBLY_TRACE.msg(msg)));\n  const frameworkDoesNotSupportContextOverflow = some(tree, node => {\n    const fqn = node.constructInfo?.fqn;\n    const version = node.constructInfo?.version;\n    return (fqn === 'aws-cdk-lib.App' && version != null && lte(version, '2.38.0')) // v2\n    || fqn === '@aws-cdk/core.App'; // v1\n  });\n\n  // We're dealing with an old version of the framework here. It is unaware of the temporary\n  // file, which means that it will ignore the context overflow.\n  if (frameworkDoesNotSupportContextOverflow) {\n    await ioHelper.notify(IO.CDK_ASSEMBLY_W0010.msg('Part of the context could not be sent to the application. Please update the AWS CDK library to the latest version.'));\n  }\n}\n\n/**\n * Safely create an assembly from a cloud assembly directory\n */\nexport async function assemblyFromDirectory(assemblyDir: string, ioHost: IoHelper, loadOptions: LoadAssemblyOptions = {}) {\n  try {\n    const assembly = new cxapi.CloudAssembly(assemblyDir, {\n      skipVersionCheck: !(loadOptions.checkVersion ?? true),\n      skipEnumCheck: !(loadOptions.checkEnums ?? true),\n      // We sort as we deploy\n      topoSort: false,\n    });\n    await checkContextOverflowSupport(assembly, ioHost);\n    return assembly;\n  } catch (err: any) {\n    if (err.message.includes(cxschema.VERSION_MISMATCH)) {\n      // this means the CLI version is too old.\n      // we instruct the user to upgrade.\n      const message = 'This AWS CDK Toolkit is not compatible with the AWS CDK library used by your application. Please upgrade to the latest version.';\n      await ioHost.notify(IO.CDK_ASSEMBLY_E1111.msg(message, { error: err }));\n      throw new ToolkitError(`${message}\\n(${err.message}`);\n    }\n    throw err;\n  }\n}\n\nfunction synthOptsDefaults(synthOpts: AppSynthOptions = {}): Settings {\n  return new Settings({\n    debug: false,\n    pathMetadata: true,\n    versionReporting: true,\n    assetMetadata: true,\n    assetStaging: true,\n    ...synthOpts,\n  }, true);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prepare-source.js","sourceRoot":"","sources":["prepare-source.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'node:os';\nimport * as path from 'node:path';\nimport { format } from 'node:util';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport { lte } from 'semver';\nimport type { SdkProvider } from '../../../api/aws-cdk';\nimport { prepareDefaultEnvironment as oldPrepare, prepareContext, spaceAvailableForContext, Settings, loadTree, some, versionNumber, guessExecutable } from '../../../api/aws-cdk';\nimport { splitBySize } from '../../../private/util';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport { IO } from '../../io/private';\nimport type { IoHelper } from '../../shared-private';\nimport { ToolkitError } from '../../shared-public';\nimport type { AppSynthOptions, LoadAssemblyOptions } from '../source-builder';\n\ntype Env = { [key: string]: string };\ntype Context = { [key: string]: any };\n\nexport class ExecutionEnvironment {\n  private readonly ioHelper: IoHelper;\n  private readonly sdkProvider: SdkProvider;\n  private readonly debugFn: (msg: string) => Promise<void>;\n  private _outdir: string | undefined;\n\n  public constructor(services: ToolkitServices, props: { outdir?: string } = {}) {\n    this.ioHelper = services.ioHelper;\n    this.sdkProvider = services.sdkProvider;\n    this.debugFn = (msg: string) => this.ioHelper.notify(IO.DEFAULT_ASSEMBLY_DEBUG.msg(msg));\n    this._outdir = props.outdir;\n  }\n\n  /**\n   * Turn the given optional output directory into a fixed output directory\n   */\n  public get outdir(): string {\n    if (!this._outdir) {\n      const outdir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));\n      this._outdir = outdir;\n    }\n    return this._outdir;\n  }\n\n  /**\n   * Guess the executable from the command-line argument\n   *\n   * Only do this if the file is NOT marked as executable. If it is,\n   * we'll defer to the shebang inside the file itself.\n   *\n   * If we're on Windows, we ALWAYS take the handler, since it's hard to\n   * verify if registry associations have or have not been set up for this\n   * file type, so we'll assume the worst and take control.\n   */\n  public guessExecutable(app: string) {\n    return guessExecutable(app, this.debugFn);\n  }\n\n  /**\n   * If we don't have region/account defined in context, we fall back to the default SDK behavior\n   * where region is retrieved from ~/.aws/config and account is based on default credentials provider\n   * chain and then STS is queried.\n   *\n   * This is done opportunistically: for example, if we can't access STS for some reason or the region\n   * is not configured, the context value will be 'null' and there could failures down the line. In\n   * some cases, synthesis does not require region/account information at all, so that might be perfectly\n   * fine in certain scenarios.\n   */\n  public async defaultEnvVars(): Promise<Env> {\n    const debugFn = (msg: string) => this.ioHelper.notify(IO.CDK_ASSEMBLY_I0010.msg(msg));\n    const env = await oldPrepare(this.sdkProvider, debugFn);\n\n    env[cxapi.OUTDIR_ENV] = this.outdir;\n    await debugFn(format('outdir:', this.outdir));\n\n    // CLI version information\n    env[cxapi.CLI_ASM_VERSION_ENV] = cxschema.Manifest.version();\n    env[cxapi.CLI_VERSION_ENV] = versionNumber();\n\n    await debugFn(format('env:', env));\n    return env;\n  }\n\n  /**\n   * Run code from a different working directory\n   */\n  public async changeDir<T>(block: () => Promise<T>, workingDir?: string) {\n    const originalWorkingDir = process.cwd();\n    try {\n      if (workingDir) {\n        process.chdir(workingDir);\n      }\n\n      return await block();\n    } finally {\n      if (workingDir) {\n        process.chdir(originalWorkingDir);\n      }\n    }\n  }\n\n  /**\n   * Run code with additional environment variables\n   */\n  public async withEnv<T>(env: Env = {}, block: () => Promise<T>) {\n    const originalEnv = process.env;\n    try {\n      process.env = {\n        ...originalEnv,\n        ...env,\n      };\n\n      return await block();\n    } finally {\n      process.env = originalEnv;\n    }\n  }\n\n  /**\n   * Run code with context setup inside the environment\n   */\n  public async withContext<T>(\n    inputContext: Context,\n    env: Env,\n    synthOpts: AppSynthOptions = {},\n    block: (env: Env, context: Context) => Promise<T>,\n  ) {\n    const context = await prepareContext(synthOptsDefaults(synthOpts), inputContext, env, this.debugFn);\n    let contextOverflowLocation = null;\n\n    try {\n      const envVariableSizeLimit = os.platform() === 'win32' ? 32760 : 131072;\n      const [smallContext, overflow] = splitBySize(context, spaceAvailableForContext(env, envVariableSizeLimit));\n\n      // Store the safe part in the environment variable\n      env[cxapi.CONTEXT_ENV] = JSON.stringify(smallContext);\n\n      // If there was any overflow, write it to a temporary file\n      if (Object.keys(overflow ?? {}).length > 0) {\n        const contextDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-context'));\n        contextOverflowLocation = path.join(contextDir, 'context-overflow.json');\n        fs.writeJSONSync(contextOverflowLocation, overflow);\n        env[cxapi.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;\n      }\n\n      // call the block code with new environment\n      return await block(env, context);\n    } finally {\n      if (contextOverflowLocation) {\n        fs.removeSync(path.dirname(contextOverflowLocation));\n      }\n    }\n  }\n}\n\n/**\n * Checks if a given assembly supports context overflow, warn otherwise.\n *\n * @param assembly the assembly to check\n */\nasync function checkContextOverflowSupport(assembly: cxapi.CloudAssembly, ioHelper: IoHelper): Promise<void> {\n  const traceFn = (msg: string) => ioHelper.notify(IO.DEFAULT_ASSEMBLY_TRACE.msg(msg));\n  const tree = await loadTree(assembly, traceFn);\n  const frameworkDoesNotSupportContextOverflow = some(tree, node => {\n    const fqn = node.constructInfo?.fqn;\n    const version = node.constructInfo?.version;\n    return (fqn === 'aws-cdk-lib.App' && version != null && lte(version, '2.38.0')) // v2\n    || fqn === '@aws-cdk/core.App'; // v1\n  });\n\n  // We're dealing with an old version of the framework here. It is unaware of the temporary\n  // file, which means that it will ignore the context overflow.\n  if (frameworkDoesNotSupportContextOverflow) {\n    await ioHelper.notify(IO.CDK_ASSEMBLY_W0010.msg('Part of the context could not be sent to the application. Please update the AWS CDK library to the latest version.'));\n  }\n}\n\n/**\n * Safely create an assembly from a cloud assembly directory\n */\nexport async function assemblyFromDirectory(assemblyDir: string, ioHelper: IoHelper, loadOptions: LoadAssemblyOptions = {}) {\n  try {\n    const assembly = new cxapi.CloudAssembly(assemblyDir, {\n      skipVersionCheck: !(loadOptions.checkVersion ?? true),\n      skipEnumCheck: !(loadOptions.checkEnums ?? true),\n      // We sort as we deploy\n      topoSort: false,\n    });\n    await checkContextOverflowSupport(assembly, ioHelper);\n    return assembly;\n  } catch (err: any) {\n    if (err.message.includes(cxschema.VERSION_MISMATCH)) {\n      // this means the CLI version is too old.\n      // we instruct the user to upgrade.\n      const message = 'This AWS CDK Toolkit is not compatible with the AWS CDK library used by your application. Please upgrade to the latest version.';\n      await ioHelper.notify(IO.CDK_ASSEMBLY_E1111.msg(message, { error: err }));\n      throw new ToolkitError(`${message}\\n(${err.message}`);\n    }\n    throw err;\n  }\n}\n\nfunction synthOptsDefaults(synthOpts: AppSynthOptions = {}): Settings {\n  return new Settings({\n    debug: false,\n    pathMetadata: true,\n    versionReporting: true,\n    assetMetadata: true,\n    assetStaging: true,\n    ...synthOpts,\n  }, true);\n}\n"]}

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

@@ -26,12 +26,12 @@ class CloudAssemblySourceBuilder {
         };
         return new context_aware_source_1.ContextAwareCloudAssembly({
             produce: async () => {
-                const outdir = (0, prepare_source_1.determineOutputDirectory)(props.outdir);
-                const env = await (0, prepare_source_1.prepareDefaultEnvironment)(services, { outdir });
-                const assembly = await (0, prepare_source_1.changeDir)(async () => (0, prepare_source_1.withContext)(context.all, env, props.synthOptions ?? {}, async (envWithContext, ctx) => (0, prepare_source_1.withEnv)(envWithContext, () => {
+                const execution = new prepare_source_1.ExecutionEnvironment(services, { outdir: props.outdir });
+                const env = await execution.defaultEnvVars();
+                const assembly = await execution.changeDir(async () => execution.withContext(context.all, env, props.synthOptions ?? {}, async (envWithContext, ctx) => execution.withEnv(envWithContext, () => {
                     try {
                         return builder({
-                            outdir,
+                            outdir: execution.outdir,
                             context: ctx,
                         });
                     }
@@ -94,7 +94,6 @@ class CloudAssemblySourceBuilder {
                     // if (build) {
                     //   await execInChildProcess(build, { cwd: props.workingDirectory });
                     // }
-                    const commandLine = await (0, prepare_source_1.guessExecutable)(app);
                     const outdir = props.outdir ?? 'cdk.out';
                     try {
                         fs.mkdirpSync(outdir);
@@ -103,8 +102,10 @@ class CloudAssemblySourceBuilder {
                         throw new shared_public_1.ToolkitError(`Could not create output directory at '${outdir}' (${e.message}).`);
                     }
                     lock = await new aws_cdk_1.RWLock(outdir).acquireWrite();
-                    const env = await (0, prepare_source_1.prepareDefaultEnvironment)(services, { outdir });
-                    return await (0, prepare_source_1.withContext)(context.all, env, props.synthOptions, async (envWithContext, _ctx) => {
+                    const execution = new prepare_source_1.ExecutionEnvironment(services, { outdir });
+                    const commandLine = await execution.guessExecutable(app);
+                    const env = await execution.defaultEnvVars();
+                    return await execution.withContext(context.all, env, props.synthOptions, async (envWithContext, _ctx) => {
                         await (0, exec_1.execInChildProcess)(commandLine.join(' '), {
                             eventPublisher: async (type, line) => {
                                 switch (type) {
@@ -130,4 +131,4 @@ class CloudAssemblySourceBuilder {
     }
 }
 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 cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { AssemblyDirectoryProps, AssemblySourceProps, ICloudAssemblySource } from '../';\nimport type { ContextAwareCloudAssemblyProps } from './context-aware-source';\nimport { ContextAwareCloudAssembly } from './context-aware-source';\nimport { execInChildProcess } from './exec';\nimport { assemblyFromDirectory, changeDir, determineOutputDirectory, guessExecutable, prepareDefaultEnvironment, withContext, withEnv } from './prepare-source';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport type { ILock } from '../../aws-cdk';\nimport { Context, RWLock, Settings } from '../../aws-cdk';\nimport { IO } from '../../io/private';\nimport { ToolkitError, AssemblyError } from '../../shared-public';\nimport type { AssemblyBuilder } from '../source-builder';\n\nexport abstract class CloudAssemblySourceBuilder {\n  /**\n   * Helper to provide the CloudAssemblySourceBuilder with required toolkit services\n   * @deprecated this should move to the toolkit really.\n   */\n  protected abstract sourceBuilderServices(): Promise<ToolkitServices>;\n\n  /**\n   * Create a Cloud Assembly from a Cloud Assembly builder function.\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: AssemblySourceProps = {},\n  ): Promise<ICloudAssemblySource> {\n    const services = await this.sourceBuilderServices();\n    const context = new Context({ bag: new Settings(props.context ?? {}) });\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      context,\n      lookups: props.lookups,\n    };\n\n    return new ContextAwareCloudAssembly(\n      {\n        produce: async () => {\n          const outdir = determineOutputDirectory(props.outdir);\n          const env = await prepareDefaultEnvironment(services, { outdir });\n          const assembly = await changeDir(async () =>\n            withContext(context.all, env, props.synthOptions ?? {}, async (envWithContext, ctx) =>\n              withEnv(envWithContext, () => {\n                try {\n                  return builder({\n                    outdir,\n                    context: ctx,\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                }\n              }),\n            ), props.workingDirectory);\n\n          if (cxapi.CloudAssembly.isCloudAssembly(assembly)) {\n            return assembly;\n          }\n\n          return assemblyFromDirectory(assembly.directory, services.ioHelper, props.loadAssemblyOptions);\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n\n  /**\n   * Creates a Cloud Assembly from an existing assembly directory.\n   * @param 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      context: new Context(), // @todo there is probably a difference between contextaware and contextlookup sources\n      lookups: false,\n    };\n\n    return new ContextAwareCloudAssembly(\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          return assemblyFromDirectory(directory, services.ioHelper, props.loadAssemblyOptions);\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n  /**\n   * Use a directory containing an AWS CDK app as source.\n   * @param props additional configuration properties\n   * @returns the CloudAssembly source\n   */\n  public async fromCdkApp(app: string, props: AssemblySourceProps = {}): Promise<ICloudAssemblySource> {\n    const services: ToolkitServices = await this.sourceBuilderServices();\n    // @todo this definitely needs to read files from the CWD\n    const context = new Context({ bag: new Settings(props.context ?? {}) });\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      context,\n      lookups: props.lookups,\n    };\n\n    return new ContextAwareCloudAssembly(\n      {\n        produce: async () => {\n          let lock: ILock | undefined = undefined;\n          try {\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            const commandLine = await guessExecutable(app);\n            const outdir = props.outdir ?? 'cdk.out';\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            lock = await new RWLock(outdir).acquireWrite();\n\n            const env = await prepareDefaultEnvironment(services, { outdir });\n            return await withContext(context.all, env, props.synthOptions, async (envWithContext, _ctx) => {\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                extraEnv: envWithContext,\n                cwd: props.workingDirectory,\n              });\n              return assemblyFromDirectory(outdir, services.ioHelper, props.loadAssemblyOptions);\n            });\n          } finally {\n            await lock?.release();\n          }\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n}\n\n"]}
+//# 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 cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { AssemblyDirectoryProps, AssemblySourceProps, ICloudAssemblySource } from '../';\nimport type { ContextAwareCloudAssemblyProps } from './context-aware-source';\nimport { ContextAwareCloudAssembly } from './context-aware-source';\nimport { execInChildProcess } from './exec';\nimport { ExecutionEnvironment, assemblyFromDirectory } from './prepare-source';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport type { ILock } from '../../aws-cdk';\nimport { Context, RWLock, Settings } from '../../aws-cdk';\nimport { IO } from '../../io/private';\nimport { ToolkitError, AssemblyError } from '../../shared-public';\nimport type { AssemblyBuilder } from '../source-builder';\n\nexport abstract class CloudAssemblySourceBuilder {\n  /**\n   * Helper to provide the CloudAssemblySourceBuilder with required toolkit services\n   * @deprecated this should move to the toolkit really.\n   */\n  protected abstract sourceBuilderServices(): Promise<ToolkitServices>;\n\n  /**\n   * Create a Cloud Assembly from a Cloud Assembly builder function.\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: AssemblySourceProps = {},\n  ): Promise<ICloudAssemblySource> {\n    const services = await this.sourceBuilderServices();\n    const context = new Context({ bag: new Settings(props.context ?? {}) });\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      context,\n      lookups: props.lookups,\n    };\n\n    return new ContextAwareCloudAssembly(\n      {\n        produce: async () => {\n          const execution = new ExecutionEnvironment(services, { outdir: props.outdir });\n          const env = await execution.defaultEnvVars();\n          const assembly = await execution.changeDir(async () =>\n            execution.withContext(context.all, env, props.synthOptions ?? {}, async (envWithContext, ctx) =>\n              execution.withEnv(envWithContext, () => {\n                try {\n                  return builder({\n                    outdir: execution.outdir,\n                    context: ctx,\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                }\n              }),\n            ), props.workingDirectory);\n\n          if (cxapi.CloudAssembly.isCloudAssembly(assembly)) {\n            return assembly;\n          }\n\n          return assemblyFromDirectory(assembly.directory, services.ioHelper, props.loadAssemblyOptions);\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n\n  /**\n   * Creates a Cloud Assembly from an existing assembly directory.\n   * @param 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      context: new Context(), // @todo there is probably a difference between contextaware and contextlookup sources\n      lookups: false,\n    };\n\n    return new ContextAwareCloudAssembly(\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          return assemblyFromDirectory(directory, services.ioHelper, props.loadAssemblyOptions);\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n  /**\n   * Use a directory containing an AWS CDK app as source.\n   * @param props additional configuration properties\n   * @returns the CloudAssembly source\n   */\n  public async fromCdkApp(app: string, props: AssemblySourceProps = {}): Promise<ICloudAssemblySource> {\n    const services: ToolkitServices = await this.sourceBuilderServices();\n    // @todo this definitely needs to read files from the CWD\n    const context = new Context({ bag: new Settings(props.context ?? {}) });\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      context,\n      lookups: props.lookups,\n    };\n\n    return new ContextAwareCloudAssembly(\n      {\n        produce: async () => {\n          let lock: ILock | undefined = undefined;\n          try {\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            const outdir = props.outdir ?? 'cdk.out';\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            lock = await new RWLock(outdir).acquireWrite();\n\n            const execution = new ExecutionEnvironment(services, { outdir });\n            const commandLine = await execution.guessExecutable(app);\n            const env = await execution.defaultEnvVars();\n            return await execution.withContext(context.all, env, props.synthOptions, async (envWithContext, _ctx) => {\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                extraEnv: envWithContext,\n                cwd: props.workingDirectory,\n              });\n              return assemblyFromDirectory(outdir, services.ioHelper, props.loadAssemblyOptions);\n            });\n          } finally {\n            await lock?.release();\n          }\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n}\n\n"]}

package/lib/api/cloud-assembly/private/stack-assembly.d.ts

@@ -12,7 +12,7 @@ export declare class StackAssembly extends CloudAssembly implements ICloudAssemb
      * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`
      * @throws when individual selection strategies are not satisfied
      */
-    selectStacksV2(selector: StackSelector): StackCollection;
+    selectStacksV2(selector: StackSelector): Promise<StackCollection>;
     /**
      * Select all stacks.
      *

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

@@ -17,7 +17,7 @@ class StackAssembly extends aws_cdk_1.CloudAssembly {
      * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`
      * @throws when individual selection strategies are not satisfied
      */
-    selectStacksV2(selector) {
+    async selectStacksV2(selector) {
         const asm = this.assembly;
         const topLevelStacks = asm.stacks;
         const allStacks = (0, semver_1.major)(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;
@@ -43,7 +43,7 @@ class StackAssembly extends aws_cdk_1.CloudAssembly {
                 }
                 return new aws_cdk_1.StackCollection(this, topLevelStacks);
             default:
-                const matched = this.selectMatchingStacks(allStacks, patterns, extend);
+                const matched = await this.selectMatchingStacks(allStacks, patterns, extend);
                 if (selector.strategy === stack_selector_1.StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE
                     && matched.stackCount !== 1) {
                     // @todo text should probably be handled in io host
@@ -91,4 +91,4 @@ function expandToExtendEnum(extend) {
             return undefined;
     }
 }
-//# 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 { major } from 'semver';\nimport { CloudAssembly, sanitizePatterns, StackCollection, ExtendedStackSelection as CliExtendedStackSelection } from '../../aws-cdk';\nimport { ToolkitError } from '../../shared-public';\nimport type { StackSelector } from '../stack-selector';\nimport { ExpandStackSelection, StackSelectionStrategy } from '../stack-selector';\nimport type { ICloudAssemblySource } from '../types';\n\n/**\n * A single Cloud Assembly wrapped to provide additional stack operations.\n */\nexport class StackAssembly extends CloudAssembly implements ICloudAssemblySource {\n  public async produce(): Promise<cxapi.CloudAssembly> {\n    return this.assembly;\n  }\n\n  /**\n   * Improved stack selection interface with a single selector\n   * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`\n   * @throws when individual selection strategies are not satisfied\n   */\n  public selectStacksV2(selector: StackSelector): StackCollection {\n    const asm = this.assembly;\n    const topLevelStacks = asm.stacks;\n    const allStacks = major(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;\n\n    if (allStacks.length === 0 && (selector.failOnEmpty ?? true)) {\n      throw new ToolkitError('This app contains no stacks');\n    }\n\n    const extend = expandToExtendEnum(selector.expand);\n    const patterns = sanitizePatterns(selector.patterns ?? []);\n\n    switch (selector.strategy) {\n      case StackSelectionStrategy.ALL_STACKS:\n        return new StackCollection(this, allStacks);\n      case StackSelectionStrategy.MAIN_ASSEMBLY:\n        if (topLevelStacks.length < 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('No stack found in the main cloud assembly. Use \"list\" to print manifest');\n        }\n        return this.extendStacks(topLevelStacks, allStacks, extend);\n      case StackSelectionStrategy.ONLY_SINGLE:\n        if (topLevelStacks.length !== 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('Since this app includes more than a single stack, specify which stacks to use (wildcards are supported) or specify `--all`\\n' +\n          `Stacks: ${allStacks.map(x => x.hierarchicalId).join(' · ')}`);\n        }\n        return new StackCollection(this, topLevelStacks);\n      default:\n        const matched = this.selectMatchingStacks(allStacks, patterns, extend);\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE\n          && matched.stackCount !== 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH\n          && matched.stackCount < 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n\n        return matched;\n    }\n  }\n\n  /**\n   * Select all stacks.\n   *\n   * This method never throws and can safely be used as a basis for other calculations.\n   *\n   * @returns a `StackCollection` of all stacks\n   */\n  public selectAllStacks() {\n    const allStacks = major(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;\n    return new StackCollection(this, allStacks);\n  }\n\n  /**\n   * Select all stacks that have the validateOnSynth flag et.\n   *\n   * @returns a `StackCollection` of all stacks that needs to be validated\n   */\n  public selectStacksForValidation() {\n    const allStacks = this.selectAllStacks();\n    return allStacks.filter((art) => art.validateOnSynth ?? false);\n  }\n}\n\nfunction expandToExtendEnum(extend?: ExpandStackSelection): CliExtendedStackSelection | undefined {\n  switch (extend) {\n    case ExpandStackSelection.DOWNSTREAM:\n      return CliExtendedStackSelection.Downstream;\n    case ExpandStackSelection.UPSTREAM:\n      return CliExtendedStackSelection.Upstream;\n    case ExpandStackSelection.NONE:\n      return CliExtendedStackSelection.None;\n    default:\n      return undefined;\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 { major } from 'semver';\nimport { CloudAssembly, sanitizePatterns, StackCollection, ExtendedStackSelection as CliExtendedStackSelection } from '../../aws-cdk';\nimport { ToolkitError } from '../../shared-public';\nimport type { StackSelector } from '../stack-selector';\nimport { ExpandStackSelection, StackSelectionStrategy } from '../stack-selector';\nimport type { ICloudAssemblySource } from '../types';\n\n/**\n * A single Cloud Assembly wrapped to provide additional stack operations.\n */\nexport class StackAssembly extends CloudAssembly implements ICloudAssemblySource {\n  public async produce(): Promise<cxapi.CloudAssembly> {\n    return this.assembly;\n  }\n\n  /**\n   * Improved stack selection interface with a single selector\n   * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`\n   * @throws when individual selection strategies are not satisfied\n   */\n  public async selectStacksV2(selector: StackSelector): Promise<StackCollection> {\n    const asm = this.assembly;\n    const topLevelStacks = asm.stacks;\n    const allStacks = major(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;\n\n    if (allStacks.length === 0 && (selector.failOnEmpty ?? true)) {\n      throw new ToolkitError('This app contains no stacks');\n    }\n\n    const extend = expandToExtendEnum(selector.expand);\n    const patterns = sanitizePatterns(selector.patterns ?? []);\n\n    switch (selector.strategy) {\n      case StackSelectionStrategy.ALL_STACKS:\n        return new StackCollection(this, allStacks);\n      case StackSelectionStrategy.MAIN_ASSEMBLY:\n        if (topLevelStacks.length < 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('No stack found in the main cloud assembly. Use \"list\" to print manifest');\n        }\n        return this.extendStacks(topLevelStacks, allStacks, extend);\n      case StackSelectionStrategy.ONLY_SINGLE:\n        if (topLevelStacks.length !== 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('Since this app includes more than a single stack, specify which stacks to use (wildcards are supported) or specify `--all`\\n' +\n          `Stacks: ${allStacks.map(x => x.hierarchicalId).join(' · ')}`);\n        }\n        return new StackCollection(this, topLevelStacks);\n      default:\n        const matched = await this.selectMatchingStacks(allStacks, patterns, extend);\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE\n          && matched.stackCount !== 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH\n          && matched.stackCount < 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n\n        return matched;\n    }\n  }\n\n  /**\n   * Select all stacks.\n   *\n   * This method never throws and can safely be used as a basis for other calculations.\n   *\n   * @returns a `StackCollection` of all stacks\n   */\n  public selectAllStacks() {\n    const allStacks = major(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;\n    return new StackCollection(this, allStacks);\n  }\n\n  /**\n   * Select all stacks that have the validateOnSynth flag et.\n   *\n   * @returns a `StackCollection` of all stacks that needs to be validated\n   */\n  public selectStacksForValidation() {\n    const allStacks = this.selectAllStacks();\n    return allStacks.filter((art) => art.validateOnSynth ?? false);\n  }\n}\n\nfunction expandToExtendEnum(extend?: ExpandStackSelection): CliExtendedStackSelection | undefined {\n  switch (extend) {\n    case ExpandStackSelection.DOWNSTREAM:\n      return CliExtendedStackSelection.Downstream;\n    case ExpandStackSelection.UPSTREAM:\n      return CliExtendedStackSelection.Upstream;\n    case ExpandStackSelection.NONE:\n      return CliExtendedStackSelection.None;\n    default:\n      return undefined;\n  }\n}\n"]}