@aws-cdk/toolkit-lib 0.1.8 → 0.3.0

package/lib/actions/diff/private/helpers.js

@@ -1,8 +1,104 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTemplateInfos = makeTemplateInfos;
 exports.determinePermissionType = determinePermissionType;
+exports.appendObject = appendObject;
 const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff");
+const fs = require("fs-extra");
+const uuid = require("uuid");
+const __1 = require("..");
+const shared_private_1 = require("../../../api/shared-private");
 const shared_public_1 = require("../../../api/shared-public");
+const util_1 = require("../../../private/util");
+function makeTemplateInfos(ioHelper, stacks, deployments, sdkProvider, options) {
+    switch (options.method?.method ?? __1.DiffMethod.ChangeSet().method) {
+        case 'local-file':
+            return localFileDiff(stacks, options);
+        case 'template-only':
+            return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, false);
+        case 'change-set':
+            return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, true);
+        default:
+            throw new shared_public_1.ToolkitError((0, util_1.formatErrorMessage)(`Unknown diff method ${options.method}`));
+    }
+}
+async function localFileDiff(stacks, options) {
+    const methodOptions = (options.method?.options ?? {});
+    // Compare single stack against fixed template
+    if (stacks.stackCount !== 1) {
+        throw new shared_public_1.ToolkitError('Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks.');
+    }
+    if (!(await fs.pathExists(methodOptions.path))) {
+        throw new shared_public_1.ToolkitError(`There is no file at ${methodOptions.path}`);
+    }
+    const file = fs.readFileSync(methodOptions.path).toString();
+    const template = (0, util_1.deserializeStructure)(file);
+    return [{
+            oldTemplate: template,
+            newTemplate: stacks.firstStack,
+        }];
+}
+async function cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, includeChangeSet) {
+    const templateInfos = [];
+    const methodOptions = (options.method?.options ?? {});
+    // Compare N stacks against deployed templates
+    for (const stack of stacks.stackArtifacts) {
+        const templateWithNestedStacks = await deployments.readCurrentTemplateWithNestedStacks(stack, methodOptions.compareAgainstProcessedTemplate);
+        const currentTemplate = templateWithNestedStacks.deployedRootTemplate;
+        const nestedStacks = templateWithNestedStacks.nestedStacks;
+        const migrator = new shared_private_1.ResourceMigrator({ deployments, ioHelper });
+        const resourcesToImport = await migrator.tryGetResources(await deployments.resolveEnvironment(stack));
+        if (resourcesToImport) {
+            (0, shared_private_1.removeNonImportResources)(stack);
+        }
+        const changeSet = includeChangeSet ? await changeSetDiff(ioHelper, deployments, stack, sdkProvider, resourcesToImport, methodOptions.parameters, methodOptions.fallbackToTemplate) : undefined;
+        templateInfos.push({
+            oldTemplate: currentTemplate,
+            newTemplate: stack,
+            isImport: !!resourcesToImport,
+            nestedStacks,
+            changeSet,
+        });
+    }
+    return templateInfos;
+}
+async function changeSetDiff(ioHelper, deployments, stack, sdkProvider, resourcesToImport, parameters = {}, fallBackToTemplate = true) {
+    let stackExists = false;
+    try {
+        stackExists = await deployments.stackExists({
+            stack,
+            deployName: stack.stackName,
+            tryLookupRole: true,
+        });
+    }
+    catch (e) {
+        if (!fallBackToTemplate) {
+            throw new shared_public_1.ToolkitError(`describeStacks call failed with ${e} for ${stack.stackName}, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);
+        }
+        await ioHelper.notify(shared_private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Checking if the stack ${stack.stackName} exists before creating the changeset has failed, will base the diff on template differences.\n`));
+        await ioHelper.notify(shared_private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg((0, util_1.formatErrorMessage)(e)));
+        stackExists = false;
+    }
+    if (stackExists) {
+        return shared_private_1.cfnApi.createDiffChangeSet(ioHelper, {
+            stack,
+            uuid: uuid.v4(),
+            deployments,
+            willExecute: false,
+            sdkProvider,
+            parameters: parameters,
+            resourcesToImport,
+            failOnError: !fallBackToTemplate,
+        });
+    }
+    else {
+        if (!fallBackToTemplate) {
+            throw new shared_public_1.ToolkitError(`the stack '${stack.stackName}' has not been deployed to CloudFormation, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);
+        }
+        await ioHelper.notify(shared_private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`the stack '${stack.stackName}' has not been deployed to CloudFormation, skipping changeset creation.`));
+        return;
+    }
+}
 /**
  * Return whether the diff has security-impacting changes that need confirmation.
  */
@@ -19,4 +115,21 @@ function determinePermissionType(oldTemplate, newTemplate, changeSet) {
         return shared_public_1.PermissionChangeType.NONE;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFRQSwwREFlQztBQXRCRCxzRUFBd0Q7QUFFeEQsOERBQWtFO0FBRWxFOztHQUVHO0FBQ0gsU0FBZ0IsdUJBQXVCLENBQ3JDLFdBQWdCLEVBQ2hCLFdBQThDLEVBQzlDLFNBQW1DO0lBRW5DLHFEQUFxRDtJQUNyRCxNQUFNLElBQUksR0FBRyxJQUFBLDhCQUFRLEVBQUMsV0FBVyxFQUFFLFdBQVcsQ0FBQyxRQUFRLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFFcEUsSUFBSSxJQUFJLENBQUMsb0JBQW9CLEVBQUUsQ0FBQztRQUM5QixPQUFPLG9DQUFvQixDQUFDLFVBQVUsQ0FBQztJQUN6QyxDQUFDO1NBQU0sSUFBSSxJQUFJLENBQUMscUJBQXFCLEVBQUUsQ0FBQztRQUN0QyxPQUFPLG9DQUFvQixDQUFDLGNBQWMsQ0FBQztJQUM3QyxDQUFDO1NBQU0sQ0FBQztRQUNOLE9BQU8sb0NBQW9CLENBQUMsSUFBSSxDQUFDO0lBQ25DLENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEZXNjcmliZUNoYW5nZVNldE91dHB1dCB9IGZyb20gJ0Bhd3MtY2RrL2Nsb3VkZm9ybWF0aW9uLWRpZmYnO1xuaW1wb3J0IHsgZnVsbERpZmYgfSBmcm9tICdAYXdzLWNkay9jbG91ZGZvcm1hdGlvbi1kaWZmJztcbmltcG9ydCB0eXBlICogYXMgY3hhcGkgZnJvbSAnQGF3cy1jZGsvY3gtYXBpJztcbmltcG9ydCB7IFBlcm1pc3Npb25DaGFuZ2VUeXBlIH0gZnJvbSAnLi4vLi4vLi4vYXBpL3NoYXJlZC1wdWJsaWMnO1xuXG4vKipcbiAqIFJldHVybiB3aGV0aGVyIHRoZSBkaWZmIGhhcyBzZWN1cml0eS1pbXBhY3RpbmcgY2hhbmdlcyB0aGF0IG5lZWQgY29uZmlybWF0aW9uLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZGV0ZXJtaW5lUGVybWlzc2lvblR5cGUoXG4gIG9sZFRlbXBsYXRlOiBhbnksXG4gIG5ld1RlbXBsYXRlOiBjeGFwaS5DbG91ZEZvcm1hdGlvblN0YWNrQXJ0aWZhY3QsXG4gIGNoYW5nZVNldD86IERlc2NyaWJlQ2hhbmdlU2V0T3V0cHV0LFxuKTogUGVybWlzc2lvbkNoYW5nZVR5cGUge1xuICAvLyBAdG9kbyByZXR1cm4gYSBwcmludGFibGUgdmVyc2lvbiBvZiB0aGUgZnVsbCBkaWZmLlxuICBjb25zdCBkaWZmID0gZnVsbERpZmYob2xkVGVtcGxhdGUsIG5ld1RlbXBsYXRlLnRlbXBsYXRlLCBjaGFuZ2VTZXQpO1xuXG4gIGlmIChkaWZmLnBlcm1pc3Npb25zQnJvYWRlbmVkKSB7XG4gICAgcmV0dXJuIFBlcm1pc3Npb25DaGFuZ2VUeXBlLkJST0FERU5JTkc7XG4gIH0gZWxzZSBpZiAoZGlmZi5wZXJtaXNzaW9uc0FueUNoYW5nZXMpIHtcbiAgICByZXR1cm4gUGVybWlzc2lvbkNoYW5nZVR5cGUuTk9OX0JST0FERU5JTkc7XG4gIH0gZWxzZSB7XG4gICAgcmV0dXJuIFBlcm1pc3Npb25DaGFuZ2VUeXBlLk5PTkU7XG4gIH1cbn1cbiJdfQ==
+/**
+ * Appends all properties from obj2 to obj1.
+ * obj2 values take priority in the case of collisions.
+ *
+ * @param obj1 The object to modify
+ * @param obj2 The object to consume
+ *
+ * @returns obj1 with all properties from obj2
+ */
+function appendObject(obj1, obj2) {
+    // Directly modify obj1 by adding all properties from obj2
+    for (const key in obj2) {
+        obj1[key] = obj2[key];
+    }
+    // Return the modified obj1
+    return obj1;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DescribeChangeSetOutput } from '@aws-cdk/cloudformation-diff';\nimport { fullDiff } from '@aws-cdk/cloudformation-diff';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport * as uuid from 'uuid';\nimport type { ChangeSetDiffOptions, DiffOptions, LocalFileDiffOptions } from '..';\nimport { DiffMethod } from '..';\nimport type { Deployments, ResourcesToImport, IoHelper, SdkProvider, StackCollection, TemplateInfo } from '../../../api/shared-private';\nimport { ResourceMigrator, IO, removeNonImportResources, cfnApi } from '../../../api/shared-private';\nimport { PermissionChangeType, ToolkitError } from '../../../api/shared-public';\nimport { deserializeStructure, formatErrorMessage } from '../../../private/util';\n\nexport function makeTemplateInfos(\n  ioHelper: IoHelper,\n  stacks: StackCollection,\n  deployments: Deployments,\n  sdkProvider: SdkProvider,\n  options: DiffOptions,\n): Promise<TemplateInfo[]> {\n  switch (options.method?.method ?? DiffMethod.ChangeSet().method) {\n    case 'local-file':\n      return localFileDiff(stacks, options);\n    case 'template-only':\n      return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, false);\n    case 'change-set':\n      return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, true);\n    default:\n      throw new ToolkitError(formatErrorMessage(`Unknown diff method ${options.method}`));\n  }\n}\n\nasync function localFileDiff(stacks: StackCollection, options: DiffOptions): Promise<TemplateInfo[]> {\n  const methodOptions = (options.method?.options ?? {}) as LocalFileDiffOptions;\n\n  // Compare single stack against fixed template\n  if (stacks.stackCount !== 1) {\n    throw new ToolkitError(\n      'Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks.',\n    );\n  }\n\n  if (!(await fs.pathExists(methodOptions.path))) {\n    throw new ToolkitError(`There is no file at ${methodOptions.path}`);\n  }\n\n  const file = fs.readFileSync(methodOptions.path).toString();\n  const template = deserializeStructure(file);\n\n  return [{\n    oldTemplate: template,\n    newTemplate: stacks.firstStack,\n  }];\n}\n\nasync function cfnDiff(\n  ioHelper: IoHelper,\n  stacks: StackCollection,\n  deployments: Deployments,\n  options: DiffOptions,\n  sdkProvider: SdkProvider,\n  includeChangeSet: boolean,\n): Promise<TemplateInfo[]> {\n  const templateInfos = [];\n  const methodOptions = (options.method?.options ?? {}) as ChangeSetDiffOptions;\n\n  // Compare N stacks against deployed templates\n  for (const stack of stacks.stackArtifacts) {\n    const templateWithNestedStacks = await deployments.readCurrentTemplateWithNestedStacks(\n      stack,\n      methodOptions.compareAgainstProcessedTemplate,\n    );\n    const currentTemplate = templateWithNestedStacks.deployedRootTemplate;\n    const nestedStacks = templateWithNestedStacks.nestedStacks;\n\n    const migrator = new ResourceMigrator({ deployments, ioHelper });\n    const resourcesToImport = await migrator.tryGetResources(await deployments.resolveEnvironment(stack));\n    if (resourcesToImport) {\n      removeNonImportResources(stack);\n    }\n\n    const changeSet = includeChangeSet ? await changeSetDiff(\n      ioHelper,\n      deployments,\n      stack,\n      sdkProvider,\n      resourcesToImport,\n      methodOptions.parameters,\n      methodOptions.fallbackToTemplate,\n    ) : undefined;\n\n    templateInfos.push({\n      oldTemplate: currentTemplate,\n      newTemplate: stack,\n      isImport: !!resourcesToImport,\n      nestedStacks,\n      changeSet,\n    });\n  }\n\n  return templateInfos;\n}\n\nasync function changeSetDiff(\n  ioHelper: IoHelper,\n  deployments: Deployments,\n  stack: cxapi.CloudFormationStackArtifact,\n  sdkProvider: SdkProvider,\n  resourcesToImport?: ResourcesToImport,\n  parameters: { [name: string]: string | undefined } = {},\n  fallBackToTemplate: boolean = true,\n): Promise<any | undefined> {\n  let stackExists = false;\n  try {\n    stackExists = await deployments.stackExists({\n      stack,\n      deployName: stack.stackName,\n      tryLookupRole: true,\n    });\n  } catch (e: any) {\n    if (!fallBackToTemplate) {\n      throw new ToolkitError(`describeStacks call failed with ${e} for ${stack.stackName}, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);\n    }\n\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Checking if the stack ${stack.stackName} exists before creating the changeset has failed, will base the diff on template differences.\\n`));\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(formatErrorMessage(e)));\n    stackExists = false;\n  }\n\n  if (stackExists) {\n    return cfnApi.createDiffChangeSet(ioHelper, {\n      stack,\n      uuid: uuid.v4(),\n      deployments,\n      willExecute: false,\n      sdkProvider,\n      parameters: parameters,\n      resourcesToImport,\n      failOnError: !fallBackToTemplate,\n    });\n  } else {\n    if (!fallBackToTemplate) {\n      throw new ToolkitError(`the stack '${stack.stackName}' has not been deployed to CloudFormation, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);\n    }\n\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`the stack '${stack.stackName}' has not been deployed to CloudFormation, skipping changeset creation.`));\n    return;\n  }\n}\n\n/**\n * Return whether the diff has security-impacting changes that need confirmation.\n */\nexport function determinePermissionType(\n  oldTemplate: any,\n  newTemplate: cxapi.CloudFormationStackArtifact,\n  changeSet?: DescribeChangeSetOutput,\n): PermissionChangeType {\n  // @todo return a printable version of the full diff.\n  const diff = fullDiff(oldTemplate, newTemplate.template, changeSet);\n\n  if (diff.permissionsBroadened) {\n    return PermissionChangeType.BROADENING;\n  } else if (diff.permissionsAnyChanges) {\n    return PermissionChangeType.NON_BROADENING;\n  } else {\n    return PermissionChangeType.NONE;\n  }\n}\n\n/**\n * Appends all properties from obj2 to obj1.\n * obj2 values take priority in the case of collisions.\n *\n * @param obj1 The object to modify\n * @param obj2 The object to consume\n *\n * @returns obj1 with all properties from obj2\n */\nexport function appendObject<T>(\n  obj1: { [name: string]: T },\n  obj2: { [name: string]: T },\n): { [name: string]: T } {\n  // Directly modify obj1 by adding all properties from obj2\n  for (const key in obj2) {\n    obj1[key] = obj2[key];\n  }\n\n  // Return the modified obj1\n  return obj1;\n}\n"]}

package/lib/actions/index.d.ts

@@ -3,6 +3,7 @@ export * from './deploy';
 export * from './destroy';
 export * from './diff';
 export * from './list';
+export * from './refactor';
 export * from './rollback';
 export * from './synth';
 export * from './watch';

package/lib/actions/index.js

@@ -19,7 +19,8 @@ __exportStar(require("./deploy"), exports);
 __exportStar(require("./destroy"), exports);
 __exportStar(require("./diff"), exports);
 __exportStar(require("./list"), exports);
+__exportStar(require("./refactor"), exports);
 __exportStar(require("./rollback"), exports);
 __exportStar(require("./synth"), exports);
 __exportStar(require("./watch"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFDMUIseUNBQXVCO0FBQ3ZCLHlDQUF1QjtBQUN2Qiw2Q0FBMkI7QUFDM0IsMENBQXdCO0FBQ3hCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwbG95JztcbmV4cG9ydCAqIGZyb20gJy4vZGVzdHJveSc7XG5leHBvcnQgKiBmcm9tICcuL2RpZmYnO1xuZXhwb3J0ICogZnJvbSAnLi9saXN0JztcbmV4cG9ydCAqIGZyb20gJy4vcm9sbGJhY2snO1xuZXhwb3J0ICogZnJvbSAnLi9zeW50aCc7XG5leHBvcnQgKiBmcm9tICcuL3dhdGNoJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFDMUIseUNBQXVCO0FBQ3ZCLHlDQUF1QjtBQUN2Qiw2Q0FBMkI7QUFDM0IsNkNBQTJCO0FBQzNCLDBDQUF3QjtBQUN4QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Jvb3RzdHJhcCc7XG5leHBvcnQgKiBmcm9tICcuL2RlcGxveSc7XG5leHBvcnQgKiBmcm9tICcuL2Rlc3Ryb3knO1xuZXhwb3J0ICogZnJvbSAnLi9kaWZmJztcbmV4cG9ydCAqIGZyb20gJy4vbGlzdCc7XG5leHBvcnQgKiBmcm9tICcuL3JlZmFjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vcm9sbGJhY2snO1xuZXhwb3J0ICogZnJvbSAnLi9zeW50aCc7XG5leHBvcnQgKiBmcm9tICcuL3dhdGNoJztcbiJdfQ==

package/lib/actions/refactor/index.d.ts

@@ -0,0 +1,15 @@
+import type { StackSelector } from '../../api/cloud-assembly';
+export interface RefactorOptions {
+    /**
+     * Whether to only show the proposed refactor, without applying it
+     *
+     * @default false
+     */
+    readonly dryRun?: boolean;
+    /**
+     * Criteria for selecting stacks to deploy
+     *
+     * @default - all stacks
+     */
+    stacks?: StackSelector;
+}

package/lib/actions/refactor/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTdGFja1NlbGVjdG9yIH0gZnJvbSAnLi4vLi4vYXBpL2Nsb3VkLWFzc2VtYmx5JztcblxuZXhwb3J0IGludGVyZmFjZSBSZWZhY3Rvck9wdGlvbnMge1xuICAvKipcbiAgICogV2hldGhlciB0byBvbmx5IHNob3cgdGhlIHByb3Bvc2VkIHJlZmFjdG9yLCB3aXRob3V0IGFwcGx5aW5nIGl0XG4gICAqXG4gICAqIEBkZWZhdWx0IGZhbHNlXG4gICAqL1xuICByZWFkb25seSBkcnlSdW4/OiBib29sZWFuO1xuXG4gIC8qKlxuICAgKiBDcml0ZXJpYSBmb3Igc2VsZWN0aW5nIHN0YWNrcyB0byBkZXBsb3lcbiAgICpcbiAgICogQGRlZmF1bHQgLSBhbGwgc3RhY2tzXG4gICAqL1xuICBzdGFja3M/OiBTdGFja1NlbGVjdG9yO1xufVxuIl19

package/lib/actions/watch/index.d.ts

@@ -1,11 +1,5 @@
 import type { BaseDeployOptions } from '../deploy/private';
 export interface WatchOptions extends BaseDeployOptions {
-    /**
-     * The extra string to append to the User-Agent header when performing AWS SDK calls.
-     *
-     * @default - nothing extra is appended to the User-Agent header
-     */
-    readonly extraUserAgent?: string;
     /**
      * Watch the files in this list
      *
@@ -24,12 +18,4 @@ export interface WatchOptions extends BaseDeployOptions {
      * @default process.cwd()
      */
     readonly watchDir?: string;
-    /**
-     * The output directory to write CloudFormation template to
-     *
-     * @deprecated this should be grabbed from the cloud assembly itself
-     *
-     * @default 'cdk.out'
-     */
-    readonly outdir?: string;
 }

package/lib/actions/watch/index.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBCYXNlRGVwbG95T3B0aW9ucyB9IGZyb20gJy4uL2RlcGxveS9wcml2YXRlJztcblxuZXhwb3J0IGludGVyZmFjZSBXYXRjaE9wdGlvbnMgZXh0ZW5kcyBCYXNlRGVwbG95T3B0aW9ucyB7XG4gIC8qKlxuICAgKiBUaGUgZXh0cmEgc3RyaW5nIHRvIGFwcGVuZCB0byB0aGUgVXNlci1BZ2VudCBoZWFkZXIgd2hlbiBwZXJmb3JtaW5nIEFXUyBTREsgY2FsbHMuXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gbm90aGluZyBleHRyYSBpcyBhcHBlbmRlZCB0byB0aGUgVXNlci1BZ2VudCBoZWFkZXJcbiAgICovXG4gIHJlYWRvbmx5IGV4dHJhVXNlckFnZW50Pzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBXYXRjaCB0aGUgZmlsZXMgaW4gdGhpcyBsaXN0XG4gICAqXG4gICAqIEBkZWZhdWx0IC0gW11cbiAgICovXG4gIHJlYWRvbmx5IGluY2x1ZGU/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogSWdub3JlIHdhdGNoaW5nIHRoZSBmaWxlcyBpbiB0aGlzIGxpc3RcbiAgICpcbiAgICogQGRlZmF1bHQgLSBbXVxuICAgKi9cbiAgcmVhZG9ubHkgZXhjbHVkZT86IHN0cmluZ1tdO1xuXG4gIC8qKlxuICAgKiBUaGUgcm9vdCBkaXJlY3RvcnkgdXNlZCBmb3Igd2F0Y2guXG4gICAqXG4gICAqIEBkZWZhdWx0IHByb2Nlc3MuY3dkKClcbiAgICovXG4gIHJlYWRvbmx5IHdhdGNoRGlyPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgb3V0cHV0IGRpcmVjdG9yeSB0byB3cml0ZSBDbG91ZEZvcm1hdGlvbiB0ZW1wbGF0ZSB0b1xuICAgKlxuICAgKiBAZGVwcmVjYXRlZCB0aGlzIHNob3VsZCBiZSBncmFiYmVkIGZyb20gdGhlIGNsb3VkIGFzc2VtYmx5IGl0c2VsZlxuICAgKlxuICAgKiBAZGVmYXVsdCAnY2RrLm91dCdcbiAgICovXG4gIHJlYWRvbmx5IG91dGRpcj86IHN0cmluZztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBCYXNlRGVwbG95T3B0aW9ucyB9IGZyb20gJy4uL2RlcGxveS9wcml2YXRlJztcblxuZXhwb3J0IGludGVyZmFjZSBXYXRjaE9wdGlvbnMgZXh0ZW5kcyBCYXNlRGVwbG95T3B0aW9ucyB7XG4gIC8qKlxuICAgKiBXYXRjaCB0aGUgZmlsZXMgaW4gdGhpcyBsaXN0XG4gICAqXG4gICAqIEBkZWZhdWx0IC0gW11cbiAgICovXG4gIHJlYWRvbmx5IGluY2x1ZGU/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogSWdub3JlIHdhdGNoaW5nIHRoZSBmaWxlcyBpbiB0aGlzIGxpc3RcbiAgICpcbiAgICogQGRlZmF1bHQgLSBbXVxuICAgKi9cbiAgcmVhZG9ubHkgZXhjbHVkZT86IHN0cmluZ1tdO1xuXG4gIC8qKlxuICAgKiBUaGUgcm9vdCBkaXJlY3RvcnkgdXNlZCBmb3Igd2F0Y2guXG4gICAqXG4gICAqIEBkZWZhdWx0IHByb2Nlc3MuY3dkKClcbiAgICovXG4gIHJlYWRvbmx5IHdhdGNoRGlyPzogc3RyaW5nO1xufVxuIl19

package/lib/api/cloud-assembly/cached-source.d.ts

@@ -0,0 +1,36 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { ICloudAssemblySource, IReadableCloudAssembly } from './types';
+/**
+ * A CloudAssemblySource that is caching its result once produced.
+ *
+ * Most Toolkit interactions should use a cached source. Not caching is
+ * relevant when the source changes frequently and it is to expensive to predict
+ * if the source has changed.
+ *
+ * The `CachedCloudAssembly` is both itself a readable CloudAssembly, as well as
+ * a Cloud Assembly Source. The lifetimes of cloud assemblies produced by this
+ * source are coupled to the lifetime of the `CachedCloudAssembly`. In other
+ * words: the `dispose()` functions of those cloud assemblies don't do anything;
+ * only the `dispose()` function of the `CachedCloudAssembly` will be used.
+ *
+ * NOTE: if we are concerned about borrowed assemblies outliving the parent
+ * (i.e. the parent getting disposed while someone is still working with the
+ * borrowed copies), we could consider referencing counting here. That seems
+ * unnecessarily complicated for now, we will just assume that everyone is
+ * being a good citizen an borrowed copies are only used by the toolkit and
+ * immediately disposed of.
+ *
+ * Because `dispose()` is a no-op on the borrowed assembly, you can omit it
+ * without changing behavior, but that would turn into a leak if we ever introduced
+ * reference counting. Failing to dispose the result if a `produce()` call of a
+ * `CachedCloudAssembly` is considered a bug.
+ */
+export declare class CachedCloudAssembly implements ICloudAssemblySource, IReadableCloudAssembly {
+    private asm;
+    constructor(asm: IReadableCloudAssembly);
+    get cloudAssembly(): cxapi.CloudAssembly;
+    produce(): Promise<IReadableCloudAssembly>;
+    _unlock(): Promise<void>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedCloudAssembly = void 0;
+const borrowed_assembly_1 = require("./private/borrowed-assembly");
+/**
+ * A CloudAssemblySource that is caching its result once produced.
+ *
+ * Most Toolkit interactions should use a cached source. Not caching is
+ * relevant when the source changes frequently and it is to expensive to predict
+ * if the source has changed.
+ *
+ * The `CachedCloudAssembly` is both itself a readable CloudAssembly, as well as
+ * a Cloud Assembly Source. The lifetimes of cloud assemblies produced by this
+ * source are coupled to the lifetime of the `CachedCloudAssembly`. In other
+ * words: the `dispose()` functions of those cloud assemblies don't do anything;
+ * only the `dispose()` function of the `CachedCloudAssembly` will be used.
+ *
+ * NOTE: if we are concerned about borrowed assemblies outliving the parent
+ * (i.e. the parent getting disposed while someone is still working with the
+ * borrowed copies), we could consider referencing counting here. That seems
+ * unnecessarily complicated for now, we will just assume that everyone is
+ * being a good citizen an borrowed copies are only used by the toolkit and
+ * immediately disposed of.
+ *
+ * Because `dispose()` is a no-op on the borrowed assembly, you can omit it
+ * without changing behavior, but that would turn into a leak if we ever introduced
+ * reference counting. Failing to dispose the result if a `produce()` call of a
+ * `CachedCloudAssembly` is considered a bug.
+ */
+class CachedCloudAssembly {
+    asm;
+    constructor(asm) {
+        this.asm = asm;
+    }
+    get cloudAssembly() {
+        return this.asm.cloudAssembly;
+    }
+    async produce() {
+        return new borrowed_assembly_1.BorrowedAssembly(this.asm.cloudAssembly);
+    }
+    _unlock() {
+        return this.asm._unlock();
+    }
+    dispose() {
+        return this.asm.dispose();
+    }
+    [Symbol.asyncDispose]() {
+        return this.dispose();
+    }
+}
+exports.CachedCloudAssembly = CachedCloudAssembly;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/cloud-assembly/index.d.ts

@@ -1,3 +1,4 @@
-export * from '../../api/shared-public';
+export { StackSelectionStrategy, StackSelector } from '../../api/shared-public';
+export * from './cached-source';
 export * from './source-builder';
 export * from './types';

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

@@ -14,7 +14,10 @@ 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("../../api/shared-public"), exports);
+exports.StackSelectionStrategy = void 0;
+var shared_public_1 = require("../../api/shared-public");
+Object.defineProperty(exports, "StackSelectionStrategy", { enumerable: true, get: function () { return shared_public_1.StackSelectionStrategy; } });
+__exportStar(require("./cached-source"), exports);
 __exportStar(require("./source-builder"), exports);
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMERBQXdDO0FBQ3hDLG1EQUFpQztBQUNqQywwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuLi8uLi9hcGkvc2hhcmVkLXB1YmxpYyc7XG5leHBvcnQgKiBmcm9tICcuL3NvdXJjZS1idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlEQUFnRjtBQUF2RSx1SEFBQSxzQkFBc0IsT0FBQTtBQUMvQixrREFBZ0M7QUFDaEMsbURBQWlDO0FBQ2pDLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFN0YWNrU2VsZWN0aW9uU3RyYXRlZ3ksIFN0YWNrU2VsZWN0b3IgfSBmcm9tICcuLi8uLi9hcGkvc2hhcmVkLXB1YmxpYyc7XG5leHBvcnQgKiBmcm9tICcuL2NhY2hlZC1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb3VyY2UtYnVpbGRlcic7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcblxuIl19

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

@@ -0,0 +1,14 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { IReadableCloudAssembly } from '../types';
+/**
+ * An implementation of `IReadableCloudAssembly` that does nothing except hold on to the CloudAssembly object
+ *
+ * It does not own a lock, and it does not clean the underlying directory.
+ */
+export declare class BorrowedAssembly implements IReadableCloudAssembly {
+    readonly cloudAssembly: cxapi.CloudAssembly;
+    constructor(cloudAssembly: cxapi.CloudAssembly);
+    _unlock(): Promise<void>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BorrowedAssembly = void 0;
+/**
+ * An implementation of `IReadableCloudAssembly` that does nothing except hold on to the CloudAssembly object
+ *
+ * It does not own a lock, and it does not clean the underlying directory.
+ */
+class BorrowedAssembly {
+    cloudAssembly;
+    constructor(cloudAssembly) {
+        this.cloudAssembly = cloudAssembly;
+    }
+    async _unlock() {
+    }
+    async dispose() {
+    }
+    async [Symbol.asyncDispose]() {
+    }
+}
+exports.BorrowedAssembly = BorrowedAssembly;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9ycm93ZWQtYXNzZW1ibHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJib3Jyb3dlZC1hc3NlbWJseS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQTs7OztHQUlHO0FBQ0gsTUFBYSxnQkFBZ0I7SUFDQztJQUE1QixZQUE0QixhQUFrQztRQUFsQyxrQkFBYSxHQUFiLGFBQWEsQ0FBcUI7SUFDOUQsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPO0lBQ3BCLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTztJQUNwQixDQUFDO0lBRU0sS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQztJQUNsQyxDQUFDO0NBQ0Y7QUFaRCw0Q0FZQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlICogYXMgY3hhcGkgZnJvbSAnQGF3cy1jZGsvY3gtYXBpJztcbmltcG9ydCB0eXBlIHsgSVJlYWRhYmxlQ2xvdWRBc3NlbWJseSB9IGZyb20gJy4uL3R5cGVzJztcblxuLyoqXG4gKiBBbiBpbXBsZW1lbnRhdGlvbiBvZiBgSVJlYWRhYmxlQ2xvdWRBc3NlbWJseWAgdGhhdCBkb2VzIG5vdGhpbmcgZXhjZXB0IGhvbGQgb24gdG8gdGhlIENsb3VkQXNzZW1ibHkgb2JqZWN0XG4gKlxuICogSXQgZG9lcyBub3Qgb3duIGEgbG9jaywgYW5kIGl0IGRvZXMgbm90IGNsZWFuIHRoZSB1bmRlcmx5aW5nIGRpcmVjdG9yeS5cbiAqL1xuZXhwb3J0IGNsYXNzIEJvcnJvd2VkQXNzZW1ibHkgaW1wbGVtZW50cyBJUmVhZGFibGVDbG91ZEFzc2VtYmx5IHtcbiAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IGNsb3VkQXNzZW1ibHk6IGN4YXBpLkNsb3VkQXNzZW1ibHkpIHtcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBfdW5sb2NrKCk6IFByb21pc2U8dm9pZD4ge1xuICB9XG5cbiAgcHVibGljIGFzeW5jIGRpc3Bvc2UoKTogUHJvbWlzZTx2b2lkPiB7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgW1N5bWJvbC5hc3luY0Rpc3Bvc2VdKCk6IFByb21pc2U8dm9pZD4ge1xuICB9XG59XG5cbiJdfQ==

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

@@ -1,7 +1,6 @@
-import type * as cxapi from '@aws-cdk/cx-api';
 import type { ToolkitServices } from '../../../toolkit/private';
-import { type Context } from '../../aws-cdk';
-import type { ICloudAssemblySource } from '../types';
+import { type Context } from '../../shared-private';
+import type { ICloudAssemblySource, IReadableCloudAssembly } from '../types';
 export interface ContextAwareCloudAssemblyProps {
     /**
      * AWS object (used by contextprovider)
@@ -28,9 +27,23 @@ export interface ContextAwareCloudAssemblyProps {
     readonly lookups?: boolean;
 }
 /**
- * Represent the Cloud Executable and the synthesis we can do on it
+ * A CloudAssemblySource that wraps another CloudAssemblySource and runs a lookup loop on it
+ *
+ * This means that if the underlying CloudAssemblySource produces a manifest
+ * with provider queries in it, the `ContextAwareCloudAssemblySource` will
+ * perform the necessary context lookups and invoke the underlying
+ * `CloudAssemblySource` again with thew missing context information.
+ *
+ * This is only useful if the underlying `CloudAssemblySource` can respond to
+ * this new context information (it must be a CDK app source); if it is just a
+ * static directory, then the contents of the assembly won't change in response
+ * to context.
+ *
+ * The context is passed between `ContextAwareCloudAssemblySource` and the wrapped
+ * cloud assembly source via a contex file on disk, so the wrapped assembly source
+ * should re-read the context file on every invocation.
  */
-export declare class ContextAwareCloudAssembly implements ICloudAssemblySource {
+export declare class ContextAwareCloudAssemblySource implements ICloudAssemblySource {
     private readonly source;
     private readonly props;
     private canLookup;
@@ -41,5 +54,5 @@ export declare class ContextAwareCloudAssembly implements ICloudAssemblySource {
     /**
      * Produce a Cloud Assembly, i.e. a set of stacks
      */
-    produce(): Promise<cxapi.CloudAssembly>;
+    produce(): Promise<IReadableCloudAssembly>;
 }

package/lib/api/cloud-assembly/private/context-aware-source.js

@@ -1,13 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextAwareCloudAssembly = void 0;
-const aws_cdk_1 = require("../../aws-cdk");
+exports.ContextAwareCloudAssemblySource = void 0;
 const private_1 = require("../../io/private");
+const shared_private_1 = require("../../shared-private");
+const shared_private_2 = require("../../shared-private");
 const shared_public_1 = require("../../shared-public");
 /**
- * Represent the Cloud Executable and the synthesis we can do on it
+ * A CloudAssemblySource that wraps another CloudAssemblySource and runs a lookup loop on it
+ *
+ * This means that if the underlying CloudAssemblySource produces a manifest
+ * with provider queries in it, the `ContextAwareCloudAssemblySource` will
+ * perform the necessary context lookups and invoke the underlying
+ * `CloudAssemblySource` again with thew missing context information.
+ *
+ * This is only useful if the underlying `CloudAssemblySource` can respond to
+ * this new context information (it must be a CDK app source); if it is just a
+ * static directory, then the contents of the assembly won't change in response
+ * to context.
+ *
+ * The context is passed between `ContextAwareCloudAssemblySource` and the wrapped
+ * cloud assembly source via a contex file on disk, so the wrapped assembly source
+ * should re-read the context file on every invocation.
  */
-class ContextAwareCloudAssembly {
+class ContextAwareCloudAssemblySource {
     source;
     props;
     canLookup;
@@ -19,7 +34,7 @@ class ContextAwareCloudAssembly {
         this.props = props;
         this.canLookup = props.lookups ?? true;
         this.context = props.context;
-        this.contextFile = props.contextFile ?? aws_cdk_1.PROJECT_CONTEXT; // @todo new feature not needed right now
+        this.contextFile = props.contextFile ?? shared_private_2.PROJECT_CONTEXT; // @todo new feature not needed right now
         this.ioHelper = props.services.ioHelper;
     }
     /**
@@ -32,7 +47,8 @@ class ContextAwareCloudAssembly {
         // again, until it doesn't complain anymore or we've stopped making progress).
         let previouslyMissingKeys;
         while (true) {
-            const assembly = await this.source.produce();
+            const readableAsm = await this.source.produce();
+            const assembly = readableAsm.cloudAssembly;
             if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {
                 const missingKeysSet = missingContextKeys(assembly.manifest.missing);
                 const missingKeys = Array.from(missingKeysSet);
@@ -49,22 +65,24 @@ class ContextAwareCloudAssembly {
                 previouslyMissingKeys = missingKeysSet;
                 if (tryLookup) {
                     await this.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));
-                    await aws_cdk_1.contextproviders.provideContextValues(assembly.manifest.missing, this.context, this.props.services.sdkProvider, this.ioHelper);
+                    await shared_private_1.contextproviders.provideContextValues(assembly.manifest.missing, this.context, this.props.services.sdkProvider, this.ioHelper);
                     // Cache the new context to disk
                     await this.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0042.msg(`Writing updated context to ${this.contextFile}...`, {
                         contextFile: this.contextFile,
                         context: this.context.all,
                     }));
                     await this.context.save(this.contextFile);
-                    // Execute again
+                    // Execute again. Unlock the assembly here so that the producer can acquire
+                    // a read lock on the directory again.
+                    await readableAsm._unlock();
                     continue;
                 }
             }
-            return assembly;
+            return readableAsm;
         }
     }
 }
-exports.ContextAwareCloudAssembly = ContextAwareCloudAssembly;
+exports.ContextAwareCloudAssemblySource = ContextAwareCloudAssemblySource;
 /**
  * Return all keys of missing context items
  */
@@ -85,4 +103,4 @@ function equalSets(a, b) {
     }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-aware-source.js","sourceRoot":"","sources":["context-aware-source.ts"],"names":[],"mappings":"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","sourcesContent":["import type { MissingContext } from '@aws-cdk/cloud-assembly-schema';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport { type Context, contextproviders, PROJECT_CONTEXT } from '../../aws-cdk';\nimport { IO } from '../../io/private';\nimport type { IoHelper } from '../../shared-private';\nimport { ToolkitError } from '../../shared-public';\nimport type { ICloudAssemblySource } from '../types';\n\nexport interface ContextAwareCloudAssemblyProps {\n  /**\n   * AWS object (used by contextprovider)\n   * @deprecated context should be moved to the toolkit itself\n   */\n  readonly services: ToolkitServices;\n\n  /**\n   * Application context\n   */\n  readonly context: Context;\n\n  /**\n   * The file used to store application context in (relative to cwd).\n   *\n   * @default \"cdk.context.json\"\n   */\n  readonly contextFile?: string;\n\n  /**\n   * Enable context lookups.\n   *\n   * Producing a `cxapi.CloudAssembly` will fail if this is disabled and context lookups need to be performed.\n   *\n   * @default true\n   */\n  readonly lookups?: boolean;\n}\n\n/**\n * Represent the Cloud Executable and the synthesis we can do on it\n */\nexport class ContextAwareCloudAssembly implements ICloudAssemblySource {\n  private canLookup: boolean;\n  private context: Context;\n  private contextFile: string;\n  private ioHelper: IoHelper;\n\n  constructor(private readonly source: ICloudAssemblySource, private readonly props: ContextAwareCloudAssemblyProps) {\n    this.canLookup = props.lookups ?? true;\n    this.context = props.context;\n    this.contextFile = props.contextFile ?? PROJECT_CONTEXT; // @todo new feature not needed right now\n    this.ioHelper = props.services.ioHelper;\n  }\n\n  /**\n   * Produce a Cloud Assembly, i.e. a set of stacks\n   */\n  public async produce(): Promise<cxapi.CloudAssembly> {\n    // We may need to run the cloud assembly source multiple times in order to satisfy all missing context\n    // (When the source producer 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.source.produce();\n\n      if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n        const missingKeysSet = missingContextKeys(assembly.manifest.missing);\n        const missingKeys = Array.from(missingKeysSet);\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: '${missingKeys.join(', ')}'`);\n        }\n\n        let tryLookup = true;\n        if (previouslyMissingKeys && equalSets(missingKeysSet, previouslyMissingKeys)) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0240.msg('Not making progress trying to resolve environmental context. Giving up.', { missingKeys }));\n          tryLookup = false;\n        }\n\n        previouslyMissingKeys = missingKeysSet;\n\n        if (tryLookup) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));\n          await contextproviders.provideContextValues(\n            assembly.manifest.missing,\n            this.context,\n            this.props.services.sdkProvider,\n            this.ioHelper,\n          );\n\n          // Cache the new context to disk\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0042.msg(`Writing updated context to ${this.contextFile}...`, {\n            contextFile: this.contextFile,\n            context: this.context.all,\n          }));\n          await this.context.save(this.contextFile);\n\n          // Execute again\n          continue;\n        }\n      }\n\n      return assembly;\n    }\n  }\n}\n\n/**\n * Return all keys of missing context items\n */\nfunction missingContextKeys(missing?: MissingContext[]): Set<string> {\n  return new Set((missing || []).map(m => m.key));\n}\n\n/**\n * Are two sets equal to each other\n */\nfunction equalSets<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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-aware-source.js","sourceRoot":"","sources":["context-aware-source.ts"],"names":[],"mappings":"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","sourcesContent":["import type { MissingContext } from '@aws-cdk/cloud-assembly-schema';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport { IO } from '../../io/private';\nimport { contextproviders } from '../../shared-private';\nimport { PROJECT_CONTEXT, type Context, type IoHelper } from '../../shared-private';\nimport { ToolkitError } from '../../shared-public';\nimport type { ICloudAssemblySource, IReadableCloudAssembly } from '../types';\n\nexport interface ContextAwareCloudAssemblyProps {\n  /**\n   * AWS object (used by contextprovider)\n   * @deprecated context should be moved to the toolkit itself\n   */\n  readonly services: ToolkitServices;\n\n  /**\n   * Application context\n   */\n  readonly context: Context;\n\n  /**\n   * The file used to store application context in (relative to cwd).\n   *\n   * @default \"cdk.context.json\"\n   */\n  readonly contextFile?: string;\n\n  /**\n   * Enable context lookups.\n   *\n   * Producing a `cxapi.CloudAssembly` will fail if this is disabled and context lookups need to be performed.\n   *\n   * @default true\n   */\n  readonly lookups?: boolean;\n}\n\n/**\n * A CloudAssemblySource that wraps another CloudAssemblySource and runs a lookup loop on it\n *\n * This means that if the underlying CloudAssemblySource produces a manifest\n * with provider queries in it, the `ContextAwareCloudAssemblySource` will\n * perform the necessary context lookups and invoke the underlying\n * `CloudAssemblySource` again with thew missing context information.\n *\n * This is only useful if the underlying `CloudAssemblySource` can respond to\n * this new context information (it must be a CDK app source); if it is just a\n * static directory, then the contents of the assembly won't change in response\n * to context.\n *\n * The context is passed between `ContextAwareCloudAssemblySource` and the wrapped\n * cloud assembly source via a contex file on disk, so the wrapped assembly source\n * should re-read the context file on every invocation.\n */\nexport class ContextAwareCloudAssemblySource implements ICloudAssemblySource {\n  private canLookup: boolean;\n  private context: Context;\n  private contextFile: string;\n  private ioHelper: IoHelper;\n\n  constructor(private readonly source: ICloudAssemblySource, private readonly props: ContextAwareCloudAssemblyProps) {\n    this.canLookup = props.lookups ?? true;\n    this.context = props.context;\n    this.contextFile = props.contextFile ?? PROJECT_CONTEXT; // @todo new feature not needed right now\n    this.ioHelper = props.services.ioHelper;\n  }\n\n  /**\n   * Produce a Cloud Assembly, i.e. a set of stacks\n   */\n  public async produce(): Promise<IReadableCloudAssembly> {\n    // We may need to run the cloud assembly source multiple times in order to satisfy all missing context\n    // (When the source producer 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 readableAsm = await this.source.produce();\n\n      const assembly = readableAsm.cloudAssembly;\n      if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n        const missingKeysSet = missingContextKeys(assembly.manifest.missing);\n        const missingKeys = Array.from(missingKeysSet);\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: '${missingKeys.join(', ')}'`);\n        }\n\n        let tryLookup = true;\n        if (previouslyMissingKeys && equalSets(missingKeysSet, previouslyMissingKeys)) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0240.msg('Not making progress trying to resolve environmental context. Giving up.', { missingKeys }));\n          tryLookup = false;\n        }\n\n        previouslyMissingKeys = missingKeysSet;\n\n        if (tryLookup) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));\n          await contextproviders.provideContextValues(\n            assembly.manifest.missing,\n            this.context,\n            this.props.services.sdkProvider,\n            this.ioHelper,\n          );\n\n          // Cache the new context to disk\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0042.msg(`Writing updated context to ${this.contextFile}...`, {\n            contextFile: this.contextFile,\n            context: this.context.all,\n          }));\n          await this.context.save(this.contextFile);\n\n          // Execute again. Unlock the assembly here so that the producer can acquire\n          // a read lock on the directory again.\n          await readableAsm._unlock();\n          continue;\n        }\n      }\n\n      return readableAsm;\n    }\n  }\n}\n\n/**\n * Return all keys of missing context items\n */\nfunction missingContextKeys(missing?: MissingContext[]): Set<string> {\n  return new Set((missing || []).map(m => m.key));\n}\n\n/**\n * Are two sets equal to each other\n */\nfunction equalSets<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/cloud-assembly/private/exec.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execInChildProcess = execInChildProcess;
 const child_process = require("node:child_process");
-const split2 = require("split2");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const split = require("split2");
 const shared_public_1 = require("../../shared-public");
 /**
  * Execute a command and args in a child process
@@ -40,8 +41,8 @@ async function execInChildProcess(commandAndArgs, options = {}) {
                     return;
             }
         });
-        proc.stdout.pipe(split2()).on('data', (line) => eventPublisher('data_stdout', line));
-        proc.stderr.pipe(split2()).on('data', (line) => eventPublisher('data_stderr', line));
+        proc.stdout.pipe(split()).on('data', (line) => eventPublisher('data_stdout', line));
+        proc.stderr.pipe(split()).on('data', (line) => eventPublisher('data_stderr', line));
         proc.on('error', fail);
         proc.on('exit', code => {
             if (code === 0) {
@@ -53,4 +54,4 @@ async function execInChildProcess(commandAndArgs, options = {}) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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