aws-cdk 2.1007.0 → 3.0.0

package/lib/cxapp/cloud-assembly.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudAssembly = exports.ExtendedStackSelection = exports.DefaultSelection = void 0;
+const minimatch_1 = require("minimatch");
+const semver = require("semver");
+const api_1 = require("../api");
+const util_1 = require("../util");
+var DefaultSelection;
+(function (DefaultSelection) {
+    /**
+     * Returns an empty selection in case there are no selectors.
+     */
+    DefaultSelection["None"] = "none";
+    /**
+     * If the app includes a single stack, returns it. Otherwise throws an exception.
+     * This behavior is used by "deploy".
+     */
+    DefaultSelection["OnlySingle"] = "single";
+    /**
+     * Returns all stacks in the main (top level) assembly only.
+     */
+    DefaultSelection["MainAssembly"] = "main";
+    /**
+     * If no selectors are provided, returns all stacks in the app,
+     * including stacks inside nested assemblies.
+     */
+    DefaultSelection["AllStacks"] = "all";
+})(DefaultSelection || (exports.DefaultSelection = DefaultSelection = {}));
+/**
+ * When selecting stacks, what other stacks to include because of dependencies
+ */
+var ExtendedStackSelection;
+(function (ExtendedStackSelection) {
+    /**
+     * Don't select any extra stacks
+     */
+    ExtendedStackSelection[ExtendedStackSelection["None"] = 0] = "None";
+    /**
+     * Include stacks that this stack depends on
+     */
+    ExtendedStackSelection[ExtendedStackSelection["Upstream"] = 1] = "Upstream";
+    /**
+     * Include stacks that depend on this stack
+     */
+    ExtendedStackSelection[ExtendedStackSelection["Downstream"] = 2] = "Downstream";
+})(ExtendedStackSelection || (exports.ExtendedStackSelection = ExtendedStackSelection = {}));
+/**
+ * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside
+ */
+class CloudAssembly extends api_1.BaseStackAssembly {
+    async selectStacks(selector, options) {
+        const asm = this.assembly;
+        const topLevelStacks = asm.stacks;
+        const stacks = semver.major(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;
+        const allTopLevel = selector.allTopLevel ?? false;
+        const patterns = CloudAssembly.sanitizePatterns(selector.patterns);
+        if (stacks.length === 0) {
+            if (options.ignoreNoStacks) {
+                return new api_1.StackCollection(this, []);
+            }
+            throw new api_1.ToolkitError('This app contains no stacks');
+        }
+        if (allTopLevel) {
+            return this.selectTopLevelStacks(stacks, topLevelStacks, options.extend);
+        }
+        else if (patterns.length > 0) {
+            return this.selectMatchingStacks(stacks, patterns, options.extend);
+        }
+        else {
+            return this.selectDefaultStacks(stacks, topLevelStacks, options.defaultBehavior);
+        }
+    }
+    async selectTopLevelStacks(stacks, topLevelStacks, extend = ExtendedStackSelection.None) {
+        if (topLevelStacks.length > 0) {
+            return this.extendStacks(topLevelStacks, stacks, extend);
+        }
+        else {
+            throw new api_1.ToolkitError('No stack found in the main cloud assembly. Use "list" to print manifest');
+        }
+    }
+    async selectMatchingStacks(stacks, patterns, extend = ExtendedStackSelection.None) {
+        const matchingPattern = (pattern) => (stack) => (0, minimatch_1.minimatch)(stack.hierarchicalId, pattern);
+        const matchedStacks = (0, util_1.flatten)(patterns.map(pattern => stacks.filter(matchingPattern(pattern))));
+        return this.extendStacks(matchedStacks, stacks, extend);
+    }
+    selectDefaultStacks(stacks, topLevelStacks, defaultSelection) {
+        switch (defaultSelection) {
+            case DefaultSelection.MainAssembly:
+                return new api_1.StackCollection(this, topLevelStacks);
+            case DefaultSelection.AllStacks:
+                return new api_1.StackCollection(this, stacks);
+            case DefaultSelection.None:
+                return new api_1.StackCollection(this, []);
+            case DefaultSelection.OnlySingle:
+                if (topLevelStacks.length === 1) {
+                    return new api_1.StackCollection(this, topLevelStacks);
+                }
+                else {
+                    throw new api_1.ToolkitError('Since this app includes more than a single stack, specify which stacks to use (wildcards are supported) or specify `--all`\n' +
+                        `Stacks: ${stacks.map(x => x.hierarchicalId).join(' · ')}`);
+                }
+            default:
+                throw new api_1.ToolkitError(`invalid default behavior: ${defaultSelection}`);
+        }
+    }
+}
+exports.CloudAssembly = CloudAssembly;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-assembly.js","sourceRoot":"","sources":["cloud-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { minimatch } from 'minimatch';\nimport * as semver from 'semver';\nimport { BaseStackAssembly, StackCollection, ToolkitError } from '../api';\nimport { flatten } from '../util';\n\nexport enum DefaultSelection {\n  /**\n   * Returns an empty selection in case there are no selectors.\n   */\n  None = 'none',\n\n  /**\n   * If the app includes a single stack, returns it. Otherwise throws an exception.\n   * This behavior is used by \"deploy\".\n   */\n  OnlySingle = 'single',\n\n  /**\n   * Returns all stacks in the main (top level) assembly only.\n   */\n  MainAssembly = 'main',\n\n  /**\n   * If no selectors are provided, returns all stacks in the app,\n   * including stacks inside nested assemblies.\n   */\n  AllStacks = 'all',\n}\n\nexport interface SelectStacksOptions {\n  /**\n   * Extend the selection to upstread/downstream stacks\n   * @default ExtendedStackSelection.None only select the specified stacks.\n   */\n  extend?: ExtendedStackSelection;\n\n  /**\n   * The behavior if no selectors are provided.\n   */\n  defaultBehavior: DefaultSelection;\n\n  /**\n   * Whether to deploy if the app contains no stacks.\n   *\n   * @default false\n   */\n  ignoreNoStacks?: boolean;\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 specification of which stacks should be selected\n */\nexport interface StackSelector {\n  /**\n   * Whether all stacks at the top level assembly should\n   * be selected and nothing else\n   */\n  allTopLevel?: boolean;\n\n  /**\n   * A list of patterns to match the stack hierarchical ids\n   */\n  patterns: string[];\n}\n\n/**\n * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside\n */\nexport class CloudAssembly extends BaseStackAssembly {\n  public async selectStacks(selector: StackSelector, options: SelectStacksOptions): Promise<StackCollection> {\n    const asm = this.assembly;\n    const topLevelStacks = asm.stacks;\n    const stacks = semver.major(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;\n    const allTopLevel = selector.allTopLevel ?? false;\n    const patterns = CloudAssembly.sanitizePatterns(selector.patterns);\n\n    if (stacks.length === 0) {\n      if (options.ignoreNoStacks) {\n        return new StackCollection(this, []);\n      }\n      throw new ToolkitError('This app contains no stacks');\n    }\n\n    if (allTopLevel) {\n      return this.selectTopLevelStacks(stacks, topLevelStacks, options.extend);\n    } else if (patterns.length > 0) {\n      return this.selectMatchingStacks(stacks, patterns, options.extend);\n    } else {\n      return this.selectDefaultStacks(stacks, topLevelStacks, options.defaultBehavior);\n    }\n  }\n\n  private async selectTopLevelStacks(\n    stacks: cxapi.CloudFormationStackArtifact[],\n    topLevelStacks: cxapi.CloudFormationStackArtifact[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ): Promise<StackCollection> {\n    if (topLevelStacks.length > 0) {\n      return this.extendStacks(topLevelStacks, stacks, extend);\n    } else {\n      throw new ToolkitError('No stack found in the main cloud assembly. Use \"list\" to print manifest');\n    }\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  private selectDefaultStacks(\n    stacks: cxapi.CloudFormationStackArtifact[],\n    topLevelStacks: cxapi.CloudFormationStackArtifact[],\n    defaultSelection: DefaultSelection,\n  ) {\n    switch (defaultSelection) {\n      case DefaultSelection.MainAssembly:\n        return new StackCollection(this, topLevelStacks);\n      case DefaultSelection.AllStacks:\n        return new StackCollection(this, stacks);\n      case DefaultSelection.None:\n        return new StackCollection(this, []);\n      case DefaultSelection.OnlySingle:\n        if (topLevelStacks.length === 1) {\n          return new StackCollection(this, topLevelStacks);\n        } else {\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: ${stacks.map(x => x.hierarchicalId).join(' · ')}`);\n        }\n      default:\n        throw new ToolkitError(`invalid default behavior: ${defaultSelection}`);\n    }\n  }\n}\n"]}

package/lib/{api/cxapp → cxapp}/cloud-executable.d.ts

@@ -1,8 +1,9 @@
 import type * as cxapi from '@aws-cdk/cx-api';
 import { CloudAssembly } from './cloud-assembly';
-import { type IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
-import type { Configuration } from '../../cli/user-configuration';
-import type { SdkProvider } from '../aws-auth';
+import type { ICloudAssemblySource } from '../../../@aws-cdk/toolkit-lib/lib/api/cloud-assembly';
+import type { SdkProvider } from '../api/aws-auth';
+import { type IoHelper } from '../api-private';
+import type { Configuration } from '../cli/user-configuration';
 /**
  * @returns output directory
  */
@@ -28,10 +29,11 @@ export interface CloudExecutableProps {
 /**
  * Represent the Cloud Executable and the synthesis we can do on it
  */
-export declare class CloudExecutable {
+export declare class CloudExecutable implements ICloudAssemblySource {
     private readonly props;
     private _cloudAssembly?;
     constructor(props: CloudExecutableProps);
+    produce(): Promise<cxapi.CloudAssembly>;
     /**
      * Return whether there is an app command from the configuration
      */

package/lib/cxapp/cloud-executable.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudExecutable = void 0;
+const cloud_assembly_1 = require("./cloud-assembly");
+const api_1 = require("../api");
+const api_private_1 = require("../api-private");
+const contextproviders = require("../context-providers");
+/**
+ * Represent the Cloud Executable and the synthesis we can do on it
+ */
+class CloudExecutable {
+    constructor(props) {
+        this.props = props;
+    }
+    async produce() {
+        return (await this.synthesize(true)).assembly;
+    }
+    /**
+     * Return whether there is an app command from the configuration
+     */
+    get hasApp() {
+        return !!this.props.configuration.settings.get(['app']);
+    }
+    /**
+     * Synthesize a set of stacks.
+     *
+     * @param cacheCloudAssembly whether to cache the Cloud Assembly after it has been first synthesized.
+     *   This is 'true' by default, and only set to 'false' for 'cdk watch',
+     *   which needs to re-synthesize the Assembly each time it detects a change to the project files
+     */
+    async synthesize(cacheCloudAssembly = true) {
+        if (!this._cloudAssembly || !cacheCloudAssembly) {
+            this._cloudAssembly = await this.doSynthesize();
+        }
+        return this._cloudAssembly;
+    }
+    async doSynthesize() {
+        // We may need to run the cloud executable multiple times in order to satisfy all missing context
+        // (When the executable runs, it will tell us about context it wants to use
+        // but it missing. We'll then look up the context and run the executable again, and
+        // again, until it doesn't complain anymore or we've stopped making progress).
+        let previouslyMissingKeys;
+        while (true) {
+            const assembly = await this.props.synthesizer(this.props.sdkProvider, this.props.configuration);
+            if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {
+                const missingKeys = missingContextKeys(assembly.manifest.missing);
+                if (!this.canLookup) {
+                    throw new api_1.ToolkitError('Context lookups have been disabled. '
+                        + 'Make sure all necessary context is already in \'cdk.context.json\' by running \'cdk synth\' on a machine with sufficient AWS credentials and committing the result. '
+                        + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);
+                }
+                let tryLookup = true;
+                if (previouslyMissingKeys && setsEqual(missingKeys, previouslyMissingKeys)) {
+                    await this.props.ioHelper.notify(api_private_1.IO.DEFAULT_ASSEMBLY_DEBUG.msg('Not making progress trying to resolve environmental context. Giving up.'));
+                    tryLookup = false;
+                }
+                previouslyMissingKeys = missingKeys;
+                if (tryLookup) {
+                    await this.props.ioHelper.notify(api_private_1.IO.DEFAULT_ASSEMBLY_DEBUG.msg('Some context information is missing. Fetching...'));
+                    await contextproviders.provideContextValues(assembly.manifest.missing, this.props.configuration.context, this.props.sdkProvider, this.props.ioHelper);
+                    // Cache the new context to disk
+                    await this.props.configuration.saveContext();
+                    // Execute again
+                    continue;
+                }
+            }
+            return new cloud_assembly_1.CloudAssembly(assembly, this.props.ioHelper);
+        }
+    }
+    get canLookup() {
+        return !!(this.props.configuration.settings.get(['lookups']) ?? true);
+    }
+}
+exports.CloudExecutable = CloudExecutable;
+/**
+ * Return all keys of missing context items
+ */
+function missingContextKeys(missing) {
+    return new Set((missing || []).map(m => m.key));
+}
+function setsEqual(a, b) {
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const x of a) {
+        if (!b.has(x)) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-executable.js","sourceRoot":"","sources":["cloud-executable.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { CloudAssembly } from './cloud-assembly';\nimport type { ICloudAssemblySource } from '../../../@aws-cdk/toolkit-lib/lib/api/cloud-assembly';\nimport { ToolkitError } from '../api';\nimport type { SdkProvider } from '../api/aws-auth';\nimport { IO, type IoHelper } from '../api-private';\nimport type { Configuration } from '../cli/user-configuration';\nimport * as contextproviders from '../context-providers';\n\n/**\n * @returns output directory\n */\nexport type Synthesizer = (aws: SdkProvider, config: Configuration) => Promise<cxapi.CloudAssembly>;\n\nexport interface CloudExecutableProps {\n  /**\n   * Application configuration (settings and context)\n   */\n  configuration: Configuration;\n\n  /**\n   * AWS object (used by synthesizer and contextprovider)\n   */\n  sdkProvider: SdkProvider;\n\n  /**\n   * Messaging helper\n   */\n  ioHelper: IoHelper;\n\n  /**\n   * Callback invoked to synthesize the actual stacks\n   */\n  synthesizer: Synthesizer;\n}\n\n/**\n * Represent the Cloud Executable and the synthesis we can do on it\n */\nexport class CloudExecutable implements ICloudAssemblySource {\n  private _cloudAssembly?: CloudAssembly;\n\n  constructor(private readonly props: CloudExecutableProps) {\n  }\n\n  public async produce(): Promise<cxapi.CloudAssembly> {\n    return (await this.synthesize(true)).assembly;\n  }\n\n  /**\n   * Return whether there is an app command from the configuration\n   */\n  public get hasApp() {\n    return !!this.props.configuration.settings.get(['app']);\n  }\n\n  /**\n   * Synthesize a set of stacks.\n   *\n   * @param cacheCloudAssembly whether to cache the Cloud Assembly after it has been first synthesized.\n   *   This is 'true' by default, and only set to 'false' for 'cdk watch',\n   *   which needs to re-synthesize the Assembly each time it detects a change to the project files\n   */\n  public async synthesize(cacheCloudAssembly: boolean = true): Promise<CloudAssembly> {\n    if (!this._cloudAssembly || !cacheCloudAssembly) {\n      this._cloudAssembly = await this.doSynthesize();\n    }\n    return this._cloudAssembly;\n  }\n\n  private async doSynthesize(): Promise<CloudAssembly> {\n    // We may need to run the cloud executable multiple times in order to satisfy all missing context\n    // (When the executable runs, it will tell us about context it wants to use\n    // but it missing. We'll then look up the context and run the executable again, and\n    // again, until it doesn't complain anymore or we've stopped making progress).\n    let previouslyMissingKeys: Set<string> | undefined;\n    while (true) {\n      const assembly = await this.props.synthesizer(this.props.sdkProvider, this.props.configuration);\n\n      if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n        const missingKeys = missingContextKeys(assembly.manifest.missing);\n\n        if (!this.canLookup) {\n          throw new ToolkitError(\n            'Context lookups have been disabled. '\n            + 'Make sure all necessary context is already in \\'cdk.context.json\\' by running \\'cdk synth\\' on a machine with sufficient AWS credentials and committing the result. '\n            + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);\n        }\n\n        let tryLookup = true;\n        if (previouslyMissingKeys && setsEqual(missingKeys, previouslyMissingKeys)) {\n          await this.props.ioHelper.notify(IO.DEFAULT_ASSEMBLY_DEBUG.msg('Not making progress trying to resolve environmental context. Giving up.'));\n          tryLookup = false;\n        }\n\n        previouslyMissingKeys = missingKeys;\n\n        if (tryLookup) {\n          await this.props.ioHelper.notify(IO.DEFAULT_ASSEMBLY_DEBUG.msg('Some context information is missing. Fetching...'));\n\n          await contextproviders.provideContextValues(\n            assembly.manifest.missing,\n            this.props.configuration.context,\n            this.props.sdkProvider,\n            this.props.ioHelper,\n          );\n\n          // Cache the new context to disk\n          await this.props.configuration.saveContext();\n\n          // Execute again\n          continue;\n        }\n      }\n\n      return new CloudAssembly(assembly, this.props.ioHelper);\n    }\n  }\n\n  private get canLookup() {\n    return !!(this.props.configuration.settings.get(['lookups']) ?? true);\n  }\n}\n\n/**\n * Return all keys of missing context items\n */\nfunction missingContextKeys(missing?: cxapi.MissingContext[]): Set<string> {\n  return new Set((missing || []).map(m => m.key));\n}\n\nfunction setsEqual<A>(a: Set<A>, b: Set<A>) {\n  if (a.size !== b.size) {\n    return false;\n  }\n  for (const x of a) {\n    if (!b.has(x)) {\n      return false;\n    }\n  }\n  return true;\n}\n"]}

package/lib/{api/cxapp → cxapp}/environments.d.ts

@@ -1,6 +1,5 @@
 import type * as cxapi from '@aws-cdk/cx-api';
-import type { StackCollection } from './cloud-assembly';
-import type { SdkProvider } from '../aws-auth';
+import type { SdkProvider, StackCollection } from '../api';
 export declare function looksLikeGlob(environment: string): boolean;
 export declare function globEnvironmentsFromStacks(stacks: StackCollection, environmentGlobs: string[], sdk: SdkProvider): Promise<cxapi.Environment[]>;
 /**

package/lib/{api/cxapp → cxapp}/environments.js

@@ -4,7 +4,7 @@ exports.looksLikeGlob = looksLikeGlob;
 exports.globEnvironmentsFromStacks = globEnvironmentsFromStacks;
 exports.environmentsFromDescriptors = environmentsFromDescriptors;
 const minimatch_1 = require("minimatch");
-const api_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api");
+const api_1 = require("../api");
 function looksLikeGlob(environment) {
     return environment.indexOf('*') > -1;
 }
@@ -63,4 +63,4 @@ function distinct(envs) {
     }
     return Object.values(unique);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cxapp/exec.d.ts

@@ -0,0 +1,14 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import type { SdkProvider, ILock } from '../api';
+import { type IoHelper } from '../api-private';
+import type { Configuration } from '../cli/user-configuration';
+export interface ExecProgramResult {
+    readonly assembly: cxapi.CloudAssembly;
+    readonly lock: ILock;
+}
+/** Invokes the cloud executable and returns JSON output */
+export declare function execProgram(aws: SdkProvider, ioHelper: IoHelper, config: Configuration): Promise<ExecProgramResult>;
+/**
+ * Creates an assembly with error handling
+ */
+export declare function createAssembly(appDir: string): cxapi.CloudAssembly;

package/lib/cxapp/exec.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execProgram = execProgram;
+exports.createAssembly = createAssembly;
+const childProcess = require("child_process");
+const os = require("os");
+const path = require("path");
+const util_1 = require("util");
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+const cxapi = require("@aws-cdk/cx-api");
+const fs = require("fs-extra");
+const semver = require("semver");
+const api_1 = require("../api");
+const api_private_1 = require("../api-private");
+const user_configuration_1 = require("../cli/user-configuration");
+const version_1 = require("../cli/version");
+const util_2 = require("../util");
+/** Invokes the cloud executable and returns JSON output */
+async function execProgram(aws, ioHelper, config) {
+    const debugFn = (msg) => ioHelper.notify(api_private_1.IO.DEFAULT_ASSEMBLY_DEBUG.msg(msg));
+    const env = await (0, api_1.prepareDefaultEnvironment)(aws, debugFn);
+    const context = await (0, api_1.prepareContext)(config.settings, config.context.all, env, debugFn);
+    const build = config.settings.get(['build']);
+    if (build) {
+        await exec(build);
+    }
+    const app = config.settings.get(['app']);
+    if (!app) {
+        throw new api_1.ToolkitError(`--app is required either in command-line, in ${user_configuration_1.PROJECT_CONFIG} or in ${user_configuration_1.USER_DEFAULTS}`);
+    }
+    // bypass "synth" if app points to a cloud assembly
+    if (await fs.pathExists(app) && (await fs.stat(app)).isDirectory()) {
+        await debugFn('--app points to a cloud assembly, so we bypass synth');
+        // Acquire a read lock on this directory
+        const lock = await new api_1.RWLock(app).acquireRead();
+        return { assembly: createAssembly(app), lock };
+    }
+    const commandLine = await (0, api_1.guessExecutable)(app, debugFn);
+    const outdir = config.settings.get(['output']);
+    if (!outdir) {
+        throw new api_1.ToolkitError('unexpected: --output is required');
+    }
+    if (typeof outdir !== 'string') {
+        throw new api_1.ToolkitError(`--output takes a string, got ${JSON.stringify(outdir)}`);
+    }
+    try {
+        await fs.mkdirp(outdir);
+    }
+    catch (error) {
+        throw new api_1.ToolkitError(`Could not create output directory ${outdir} (${error.message})`);
+    }
+    await debugFn(`outdir: ${outdir}`);
+    env[cxapi.OUTDIR_ENV] = outdir;
+    // Acquire a lock on the output directory
+    const writerLock = await new api_1.RWLock(outdir).acquireWrite();
+    try {
+        // Send version information
+        env[cxapi.CLI_ASM_VERSION_ENV] = cxschema.Manifest.version();
+        env[cxapi.CLI_VERSION_ENV] = (0, version_1.versionNumber)();
+        await debugFn((0, util_1.format)('env:', env));
+        const envVariableSizeLimit = os.platform() === 'win32' ? 32760 : 131072;
+        const [smallContext, overflow] = (0, util_2.splitBySize)(context, (0, api_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
+        let contextOverflowLocation;
+        if (Object.keys(overflow ?? {}).length > 0) {
+            const contextDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-context'));
+            contextOverflowLocation = path.join(contextDir, 'context-overflow.json');
+            fs.writeJSONSync(contextOverflowLocation, overflow);
+            env[cxapi.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;
+        }
+        await exec(commandLine.join(' '));
+        const assembly = createAssembly(outdir);
+        await contextOverflowCleanup(contextOverflowLocation, assembly, ioHelper);
+        return { assembly, lock: await writerLock.convertToReaderLock() };
+    }
+    catch (e) {
+        await writerLock.release();
+        throw e;
+    }
+    async function exec(commandAndArgs) {
+        try {
+            await new Promise((ok, fail) => {
+                // We use a slightly lower-level interface to:
+                //
+                // - Pass arguments in an array instead of a string, to get around a
+                //   number of quoting issues introduced by the intermediate shell layer
+                //   (which would be different between Linux and Windows).
+                //
+                // - Inherit stderr from controlling terminal. We don't use the captured value
+                //   anyway, and if the subprocess is printing to it for debugging purposes the
+                //   user gets to see it sooner. Plus, capturing doesn't interact nicely with some
+                //   processes like Maven.
+                const proc = childProcess.spawn(commandAndArgs, {
+                    stdio: ['ignore', 'inherit', 'inherit'],
+                    detached: false,
+                    shell: true,
+                    env: {
+                        ...process.env,
+                        ...env,
+                    },
+                });
+                proc.on('error', fail);
+                proc.on('exit', code => {
+                    if (code === 0) {
+                        return ok();
+                    }
+                    else {
+                        return fail(new api_1.ToolkitError(`Subprocess exited with error ${code}`));
+                    }
+                });
+            });
+        }
+        catch (e) {
+            await debugFn(`failed command: ${commandAndArgs}`);
+            throw e;
+        }
+    }
+}
+/**
+ * Creates an assembly with error handling
+ */
+function createAssembly(appDir) {
+    try {
+        return new cxapi.CloudAssembly(appDir, {
+            // We sort as we deploy
+            topoSort: false,
+        });
+    }
+    catch (error) {
+        if (error.message.includes(cxschema.VERSION_MISMATCH)) {
+            // this means the CLI version is too old.
+            // we instruct the user to upgrade.
+            throw new api_1.ToolkitError(`This CDK CLI is not compatible with the CDK library used by your application. Please upgrade the CLI to the latest version.\n(${error.message})`);
+        }
+        throw error;
+    }
+}
+async function contextOverflowCleanup(location, assembly, ioHelper) {
+    if (location) {
+        fs.removeSync(path.dirname(location));
+        const tree = await (0, api_1.loadTree)(assembly, (msg) => ioHelper.notify(api_private_1.IO.DEFAULT_ASSEMBLY_TRACE.msg(msg)));
+        const frameworkDoesNotSupportContextOverflow = (0, api_1.some)(tree, node => {
+            const fqn = node.constructInfo?.fqn;
+            const version = node.constructInfo?.version;
+            return (fqn === 'aws-cdk-lib.App' && version != null && semver.lte(version, '2.38.0'))
+                || fqn === '@aws-cdk/core.App'; // v1
+        });
+        // We're dealing with an old version of the framework here. It is unaware of the temporary
+        // file, which means that it will ignore the context overflow.
+        if (frameworkDoesNotSupportContextOverflow) {
+            await ioHelper.notify(api_private_1.IO.DEFAULT_ASSEMBLY_WARN.msg('Part of the context could not be sent to the application. Please update the AWS CDK library to the latest version.'));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exec.js","sourceRoot":"","sources":["exec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as childProcess from 'child_process';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { format } from '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 * as semver from 'semver';\nimport type { SdkProvider, ILock } from '../api';\nimport { RWLock, ToolkitError, guessExecutable, loadTree, prepareContext, prepareDefaultEnvironment, some, spaceAvailableForContext } from '../api';\nimport { IO, type IoHelper } from '../api-private';\nimport type { Configuration } from '../cli/user-configuration';\nimport { PROJECT_CONFIG, USER_DEFAULTS } from '../cli/user-configuration';\nimport { versionNumber } from '../cli/version';\nimport { splitBySize } from '../util';\n\nexport interface ExecProgramResult {\n  readonly assembly: cxapi.CloudAssembly;\n  readonly lock: ILock;\n}\n\n/** Invokes the cloud executable and returns JSON output */\nexport async function execProgram(aws: SdkProvider, ioHelper: IoHelper, config: Configuration): Promise<ExecProgramResult> {\n  const debugFn = (msg: string) => ioHelper.notify(IO.DEFAULT_ASSEMBLY_DEBUG.msg(msg));\n  const env = await prepareDefaultEnvironment(aws, debugFn);\n  const context = await prepareContext(config.settings, config.context.all, env, debugFn);\n\n  const build = config.settings.get(['build']);\n  if (build) {\n    await exec(build);\n  }\n\n  const app = config.settings.get(['app']);\n  if (!app) {\n    throw new ToolkitError(`--app is required either in command-line, in ${PROJECT_CONFIG} or in ${USER_DEFAULTS}`);\n  }\n\n  // bypass \"synth\" if app points to a cloud assembly\n  if (await fs.pathExists(app) && (await fs.stat(app)).isDirectory()) {\n    await debugFn('--app points to a cloud assembly, so we bypass synth');\n\n    // Acquire a read lock on this directory\n    const lock = await new RWLock(app).acquireRead();\n\n    return { assembly: createAssembly(app), lock };\n  }\n\n  const commandLine = await guessExecutable(app, debugFn);\n\n  const outdir = config.settings.get(['output']);\n  if (!outdir) {\n    throw new ToolkitError('unexpected: --output is required');\n  }\n  if (typeof outdir !== 'string') {\n    throw new ToolkitError(`--output takes a string, got ${JSON.stringify(outdir)}`);\n  }\n  try {\n    await fs.mkdirp(outdir);\n  } catch (error: any) {\n    throw new ToolkitError(`Could not create output directory ${outdir} (${error.message})`);\n  }\n\n  await debugFn(`outdir: ${outdir}`);\n  env[cxapi.OUTDIR_ENV] = outdir;\n\n  // Acquire a lock on the output directory\n  const writerLock = await new RWLock(outdir).acquireWrite();\n\n  try {\n    // Send 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\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    let contextOverflowLocation;\n    if (Object.keys(overflow ?? {}).length > 0) {\n      const contextDir = await fs.mkdtemp(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    await exec(commandLine.join(' '));\n\n    const assembly = createAssembly(outdir);\n\n    await contextOverflowCleanup(contextOverflowLocation, assembly, ioHelper);\n\n    return { assembly, lock: await writerLock.convertToReaderLock() };\n  } catch (e) {\n    await writerLock.release();\n    throw e;\n  }\n\n  async function exec(commandAndArgs: string) {\n    try {\n      await new Promise<void>((ok, fail) => {\n        // We use a slightly lower-level interface to:\n        //\n        // - Pass arguments in an array instead of a string, to get around a\n        //   number of quoting issues introduced by the intermediate shell layer\n        //   (which would be different between Linux and Windows).\n        //\n        // - Inherit stderr from controlling terminal. We don't use the captured value\n        //   anyway, and if the subprocess is printing to it for debugging purposes the\n        //   user gets to see it sooner. Plus, capturing doesn't interact nicely with some\n        //   processes like Maven.\n        const proc = childProcess.spawn(commandAndArgs, {\n          stdio: ['ignore', 'inherit', 'inherit'],\n          detached: false,\n          shell: true,\n          env: {\n            ...process.env,\n            ...env,\n          },\n        });\n\n        proc.on('error', fail);\n\n        proc.on('exit', code => {\n          if (code === 0) {\n            return ok();\n          } else {\n            return fail(new ToolkitError(`Subprocess exited with error ${code}`));\n          }\n        });\n      });\n    } catch (e: any) {\n      await debugFn(`failed command: ${commandAndArgs}`);\n      throw e;\n    }\n  }\n}\n\n/**\n * Creates an assembly with error handling\n */\nexport function createAssembly(appDir: string) {\n  try {\n    return new cxapi.CloudAssembly(appDir, {\n      // We sort as we deploy\n      topoSort: false,\n    });\n  } catch (error: any) {\n    if (error.message.includes(cxschema.VERSION_MISMATCH)) {\n      // this means the CLI version is too old.\n      // we instruct the user to upgrade.\n      throw new ToolkitError(`This CDK CLI is not compatible with the CDK library used by your application. Please upgrade the CLI to the latest version.\\n(${error.message})`);\n    }\n    throw error;\n  }\n}\n\nasync function contextOverflowCleanup(\n  location: string | undefined,\n  assembly: cxapi.CloudAssembly,\n  ioHelper: IoHelper,\n) {\n  if (location) {\n    fs.removeSync(path.dirname(location));\n\n    const tree = await loadTree(assembly, (msg: string) => 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 && semver.lte(version, '2.38.0'))\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.DEFAULT_ASSEMBLY_WARN.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"]}

package/lib/cxapp/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cloud-assembly';
+export * from './cloud-executable';
+export * from './environments';
+export * from './exec';

package/lib/{api/bootstrap → cxapp}/index.js

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./bootstrap-environment"), exports);
-__exportStar(require("./bootstrap-props"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMERBQXdDO0FBQ3hDLG9EQUFrQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLWVudmlyb25tZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLXByb3BzJztcbiJdfQ==
+__exportStar(require("./cloud-assembly"), exports);
+__exportStar(require("./cloud-executable"), exports);
+__exportStar(require("./environments"), exports);
+__exportStar(require("./exec"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDO0FBQ2pDLHFEQUFtQztBQUNuQyxpREFBK0I7QUFDL0IseUNBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbG91ZC1hc3NlbWJseSc7XG5leHBvcnQgKiBmcm9tICcuL2Nsb3VkLWV4ZWN1dGFibGUnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnZpcm9ubWVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9leGVjJztcbiJdfQ==