@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

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

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStackAssembly = exports.ExtendedStackSelection = void 0;
+const chalk = require("chalk");
+const minimatch_1 = require("minimatch");
+const stack_collection_1 = require("./stack-collection");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+/**
+ * When selecting stacks, what other stacks to include because of dependencies
+ */
+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 BaseStackAssembly {
+    assembly;
+    /**
+     * Sanitize a list of stack match patterns
+     */
+    static sanitizePatterns(patterns) {
+        let sanitized = patterns.filter(s => s != null); // filter null/undefined
+        sanitized = [...new Set(sanitized)]; // make them unique
+        return sanitized;
+    }
+    /**
+     * The directory this CloudAssembly was read from
+     */
+    directory;
+    /**
+     * The IoHelper used for messaging
+     */
+    ioHelper;
+    constructor(assembly, ioHelper) {
+        this.assembly = assembly;
+        this.directory = assembly.directory;
+        this.ioHelper = ioHelper;
+    }
+    /**
+     * Select a single stack by its ID
+     */
+    stackById(stackId) {
+        return new stack_collection_1.StackCollection(this, [this.assembly.getStackArtifact(stackId)]);
+    }
+    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);
+    }
+    async extendStacks(matched, all, extend = ExtendedStackSelection.None) {
+        const allStacks = new Map();
+        for (const stack of all) {
+            allStacks.set(stack.hierarchicalId, stack);
+        }
+        const index = indexByHierarchicalId(matched);
+        switch (extend) {
+            case ExtendedStackSelection.Downstream:
+                await includeDownstreamStacks(this.ioHelper, index, allStacks);
+                break;
+            case ExtendedStackSelection.Upstream:
+                await includeUpstreamStacks(this.ioHelper, index, allStacks);
+                break;
+        }
+        // Filter original array because it is in the right order
+        const selectedList = all.filter(s => index.has(s.hierarchicalId));
+        return new stack_collection_1.StackCollection(this, selectedList);
+    }
+}
+exports.BaseStackAssembly = BaseStackAssembly;
+function indexByHierarchicalId(stacks) {
+    const result = new Map();
+    for (const stack of stacks) {
+        result.set(stack.hierarchicalId, stack);
+    }
+    return result;
+}
+/**
+ * Calculate the transitive closure of stack dependents.
+ *
+ * Modifies `selectedStacks` in-place.
+ */
+async function includeDownstreamStacks(ioHelper, selectedStacks, allStacks) {
+    const added = new Array();
+    let madeProgress;
+    do {
+        madeProgress = false;
+        for (const [id, stack] of allStacks) {
+            // Select this stack if it's not selected yet AND it depends on a stack that's in the selected set
+            if (!selectedStacks.has(id) && (stack.dependencies || []).some(dep => selectedStacks.has(dep.id))) {
+                selectedStacks.set(id, stack);
+                added.push(id);
+                madeProgress = true;
+            }
+        }
+    } while (madeProgress);
+    if (added.length > 0) {
+        await ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_INFO.msg(`Including depending stacks: ${chalk.bold(added.join(', '))}`));
+    }
+}
+/**
+ * Calculate the transitive closure of stack dependencies.
+ *
+ * Modifies `selectedStacks` in-place.
+ */
+async function includeUpstreamStacks(ioHelper, selectedStacks, allStacks) {
+    const added = new Array();
+    let madeProgress = true;
+    while (madeProgress) {
+        madeProgress = false;
+        for (const stack of selectedStacks.values()) {
+            // Select an additional stack if it's not selected yet and a dependency of a selected stack (and exists, obviously)
+            for (const dependencyId of stack.dependencies.map(x => x.manifest.displayName ?? x.id)) {
+                if (!selectedStacks.has(dependencyId) && allStacks.has(dependencyId)) {
+                    added.push(dependencyId);
+                    selectedStacks.set(dependencyId, allStacks.get(dependencyId));
+                    madeProgress = true;
+                }
+            }
+        }
+    }
+    if (added.length > 0) {
+        await ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_INFO.msg(`Including dependency stacks: ${chalk.bold(added.join(', '))}`));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-assembly.js","sourceRoot":"","sources":["stack-assembly.ts"],"names":[],"mappings":";;;AACA,+BAA+B;AAC/B,yCAAsC;AACtC,yDAAqD;AACrD,qCAAqC;AACrC,2CAAmC;AAenC;;GAEG;AACH,IAAY,sBAeX;AAfD,WAAY,sBAAsB;IAChC;;OAEG;IACH,mEAAI,CAAA;IAEJ;;OAEG;IACH,2EAAQ,CAAA;IAER;;OAEG;IACH,+EAAU,CAAA;AACZ,CAAC,EAfW,sBAAsB,sCAAtB,sBAAsB,QAejC;AAED;;GAEG;AACH,MAAsB,iBAAiB;IAoBT;IAnB5B;;OAEG;IACO,MAAM,CAAC,gBAAgB,CAAC,QAAkB;QAClD,IAAI,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,wBAAwB;QACzE,SAAS,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,mBAAmB;QACxD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACa,SAAS,CAAS;IAElC;;OAEG;IACgB,QAAQ,CAAW;IAEtC,YAA4B,QAA6B,EAAE,QAAkB;QAAjD,aAAQ,GAAR,QAAQ,CAAqB;QACvD,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;QACpC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,OAAe;QAC9B,OAAO,IAAI,kCAAe,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9E,CAAC;IAES,KAAK,CAAC,oBAAoB,CAClC,MAA2C,EAC3C,QAAkB,EAClB,SAAiC,sBAAsB,CAAC,IAAI;QAE5D,MAAM,eAAe,GAAG,CAAC,OAAe,EAAE,EAAE,CAAC,CAAC,KAAwC,EAAE,EAAE,CAAC,IAAA,qBAAS,EAAC,KAAK,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QACpI,MAAM,aAAa,GAAG,IAAA,cAAO,EAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QAEhG,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1D,CAAC;IAES,KAAK,CAAC,YAAY,CAC1B,OAA4C,EAC5C,GAAwC,EACxC,SAAiC,sBAAsB,CAAC,IAAI;QAE5D,MAAM,SAAS,GAAG,IAAI,GAAG,EAA6C,CAAC;QACvE,KAAK,MAAM,KAAK,IAAI,GAAG,EAAE,CAAC;YACxB,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;QAC7C,CAAC;QAED,MAAM,KAAK,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;QAE7C,QAAQ,MAAM,EAAE,CAAC;YACf,KAAK,sBAAsB,CAAC,UAAU;gBACpC,MAAM,uBAAuB,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;gBAC/D,MAAM;YACR,KAAK,sBAAsB,CAAC,QAAQ;gBAClC,MAAM,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;gBAC7D,MAAM;QACV,CAAC;QAED,yDAAyD;QACzD,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC;QAElE,OAAO,IAAI,kCAAe,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IACjD,CAAC;CACF;AArED,8CAqEC;AAED,SAAS,qBAAqB,CAAC,MAA2C;IACxE,MAAM,MAAM,GAAG,IAAI,GAAG,EAA6C,CAAC;IAEpE,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,uBAAuB,CACpC,QAAkB,EAClB,cAA8D,EAC9D,SAAyD;IAEzD,MAAM,KAAK,GAAG,IAAI,KAAK,EAAU,CAAC;IAElC,IAAI,YAAY,CAAC;IACjB,GAAG,CAAC;QACF,YAAY,GAAG,KAAK,CAAC;QAErB,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,SAAS,EAAE,CAAC;YACpC,kGAAkG;YAClG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;gBAClG,cAAc,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;gBAC9B,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBACf,YAAY,GAAG,IAAI,CAAC;YACtB,CAAC;QACH,CAAC;IACH,CAAC,QAAQ,YAAY,EAAE;IAEvB,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,QAAQ,CAAC,MAAM,CAAC,YAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,+BAA+B,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACrH,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,qBAAqB,CAClC,QAAkB,EAClB,cAA8D,EAC9D,SAAyD;IAEzD,MAAM,KAAK,GAAG,IAAI,KAAK,EAAU,CAAC;IAClC,IAAI,YAAY,GAAG,IAAI,CAAC;IACxB,OAAO,YAAY,EAAE,CAAC;QACpB,YAAY,GAAG,KAAK,CAAC;QAErB,KAAK,MAAM,KAAK,IAAI,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC;YAC5C,mHAAmH;YACnH,KAAK,MAAM,YAAY,IAAI,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;gBACvF,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;oBACrE,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;oBACzB,cAAc,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG,CAAC,YAAY,CAAE,CAAC,CAAC;oBAC/D,YAAY,GAAG,IAAI,CAAC;gBACtB,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,QAAQ,CAAC,MAAM,CAAC,YAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,gCAAgC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACtH,CAAC;AACH,CAAC","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { minimatch } from 'minimatch';\nimport { StackCollection } from './stack-collection';\nimport { flatten } from '../../util';\nimport { IO } from '../io/private';\nimport type { IoHelper } from '../io/private/io-helper';\n\nexport interface IStackAssembly {\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  directory: string;\n\n  /**\n   * Select a single stack by its ID\n   */\n  stackById(stackId: string): StackCollection;\n}\n\n/**\n * When selecting stacks, what other stacks to include because of dependencies\n */\nexport enum ExtendedStackSelection {\n  /**\n   * Don't select any extra stacks\n   */\n  None,\n\n  /**\n   * Include stacks that this stack depends on\n   */\n  Upstream,\n\n  /**\n   * Include stacks that depend on this stack\n   */\n  Downstream,\n}\n\n/**\n * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside\n */\nexport abstract class BaseStackAssembly implements IStackAssembly {\n  /**\n   * Sanitize a list of stack match patterns\n   */\n  protected static sanitizePatterns(patterns: string[]): string[] {\n    let sanitized = patterns.filter(s => s != null); // filter null/undefined\n    sanitized = [...new Set(sanitized)]; // make them unique\n    return sanitized;\n  }\n\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  public readonly directory: string;\n\n  /**\n   * The IoHelper used for messaging\n   */\n  protected readonly ioHelper: IoHelper;\n\n  constructor(public readonly assembly: cxapi.CloudAssembly, ioHelper: IoHelper) {\n    this.directory = assembly.directory;\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Select a single stack by its ID\n   */\n  public stackById(stackId: string) {\n    return new StackCollection(this, [this.assembly.getStackArtifact(stackId)]);\n  }\n\n  protected async selectMatchingStacks(\n    stacks: cxapi.CloudFormationStackArtifact[],\n    patterns: string[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ): Promise<StackCollection> {\n    const matchingPattern = (pattern: string) => (stack: cxapi.CloudFormationStackArtifact) => minimatch(stack.hierarchicalId, pattern);\n    const matchedStacks = flatten(patterns.map(pattern => stacks.filter(matchingPattern(pattern))));\n\n    return this.extendStacks(matchedStacks, stacks, extend);\n  }\n\n  protected async extendStacks(\n    matched: cxapi.CloudFormationStackArtifact[],\n    all: cxapi.CloudFormationStackArtifact[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ) {\n    const allStacks = new Map<string, cxapi.CloudFormationStackArtifact>();\n    for (const stack of all) {\n      allStacks.set(stack.hierarchicalId, stack);\n    }\n\n    const index = indexByHierarchicalId(matched);\n\n    switch (extend) {\n      case ExtendedStackSelection.Downstream:\n        await includeDownstreamStacks(this.ioHelper, index, allStacks);\n        break;\n      case ExtendedStackSelection.Upstream:\n        await includeUpstreamStacks(this.ioHelper, index, allStacks);\n        break;\n    }\n\n    // Filter original array because it is in the right order\n    const selectedList = all.filter(s => index.has(s.hierarchicalId));\n\n    return new StackCollection(this, selectedList);\n  }\n}\n\nfunction indexByHierarchicalId(stacks: cxapi.CloudFormationStackArtifact[]): Map<string, cxapi.CloudFormationStackArtifact> {\n  const result = new Map<string, cxapi.CloudFormationStackArtifact>();\n\n  for (const stack of stacks) {\n    result.set(stack.hierarchicalId, stack);\n  }\n\n  return result;\n}\n\n/**\n * Calculate the transitive closure of stack dependents.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeDownstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n\n  let madeProgress;\n  do {\n    madeProgress = false;\n\n    for (const [id, stack] of allStacks) {\n      // Select this stack if it's not selected yet AND it depends on a stack that's in the selected set\n      if (!selectedStacks.has(id) && (stack.dependencies || []).some(dep => selectedStacks.has(dep.id))) {\n        selectedStacks.set(id, stack);\n        added.push(id);\n        madeProgress = true;\n      }\n    }\n  } while (madeProgress);\n\n  if (added.length > 0) {\n    await ioHelper.notify(IO.DEFAULT_ASSEMBLY_INFO.msg(`Including depending stacks: ${chalk.bold(added.join(', '))}`));\n  }\n}\n\n/**\n * Calculate the transitive closure of stack dependencies.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeUpstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n  let madeProgress = true;\n  while (madeProgress) {\n    madeProgress = false;\n\n    for (const stack of selectedStacks.values()) {\n      // Select an additional stack if it's not selected yet and a dependency of a selected stack (and exists, obviously)\n      for (const dependencyId of stack.dependencies.map(x => x.manifest.displayName ?? x.id)) {\n        if (!selectedStacks.has(dependencyId) && allStacks.has(dependencyId)) {\n          added.push(dependencyId);\n          selectedStacks.set(dependencyId, allStacks.get(dependencyId)!);\n          madeProgress = true;\n        }\n      }\n    }\n  }\n\n  if (added.length > 0) {\n    await ioHelper.notify(IO.DEFAULT_ASSEMBLY_INFO.msg(`Including dependency stacks: ${chalk.bold(added.join(', '))}`));\n  }\n}\n"]}

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

@@ -0,0 +1,27 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { IStackAssembly } from './stack-assembly';
+import { type StackDetails } from '../../payloads/stack-details';
+/**
+ * A collection of stacks and related artifacts
+ *
+ * In practice, not all artifacts in the CloudAssembly are created equal;
+ * stacks can be selected independently, but other artifacts such as asset
+ * bundles cannot.
+ */
+export declare class StackCollection {
+    readonly assembly: IStackAssembly;
+    readonly stackArtifacts: cxapi.CloudFormationStackArtifact[];
+    constructor(assembly: IStackAssembly, stackArtifacts: cxapi.CloudFormationStackArtifact[]);
+    get stackCount(): number;
+    get firstStack(): cxapi.CloudFormationStackArtifact;
+    get stackIds(): string[];
+    get hierarchicalIds(): string[];
+    withDependencies(): StackDetails[];
+    reversed(): StackCollection;
+    filter(predicate: (art: cxapi.CloudFormationStackArtifact) => boolean): StackCollection;
+    concat(...others: StackCollection[]): StackCollection;
+    /**
+     * Extracts 'aws:cdk:warning|info|error' metadata entries from the stack synthesis
+     */
+    validateMetadata(failAt?: 'warn' | 'error' | 'none', logger?: (level: 'info' | 'error' | 'warn', msg: cxapi.SynthesisMessage) => Promise<void>): Promise<void>;
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackCollection = void 0;
+const cx_api_1 = require("@aws-cdk/cx-api");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+/**
+ * A collection of stacks and related artifacts
+ *
+ * In practice, not all artifacts in the CloudAssembly are created equal;
+ * stacks can be selected independently, but other artifacts such as asset
+ * bundles cannot.
+ */
+class StackCollection {
+    assembly;
+    stackArtifacts;
+    constructor(assembly, stackArtifacts) {
+        this.assembly = assembly;
+        this.stackArtifacts = stackArtifacts;
+    }
+    get stackCount() {
+        return this.stackArtifacts.length;
+    }
+    get firstStack() {
+        if (this.stackCount < 1) {
+            throw new toolkit_error_1.ToolkitError('StackCollection contains no stack artifacts (trying to access the first one)');
+        }
+        return this.stackArtifacts[0];
+    }
+    get stackIds() {
+        return this.stackArtifacts.map(s => s.id);
+    }
+    get hierarchicalIds() {
+        return this.stackArtifacts.map(s => s.hierarchicalId);
+    }
+    withDependencies() {
+        const allData = [];
+        for (const stack of this.stackArtifacts) {
+            const data = {
+                id: stack.displayName ?? stack.id,
+                name: stack.stackName,
+                environment: stack.environment,
+                dependencies: [],
+            };
+            for (const dependencyId of stack.dependencies.map(x => x.id)) {
+                if (dependencyId.includes('.assets')) {
+                    continue;
+                }
+                const depStack = this.assembly.stackById(dependencyId);
+                if (depStack.firstStack.dependencies.filter((dep) => !(dep.id).includes('.assets')).length > 0) {
+                    for (const stackDetail of depStack.withDependencies()) {
+                        data.dependencies.push({
+                            id: stackDetail.id,
+                            dependencies: stackDetail.dependencies,
+                        });
+                    }
+                }
+                else {
+                    data.dependencies.push({
+                        id: depStack.firstStack.displayName ?? depStack.firstStack.id,
+                        dependencies: [],
+                    });
+                }
+            }
+            allData.push(data);
+        }
+        return allData;
+    }
+    reversed() {
+        const arts = [...this.stackArtifacts];
+        arts.reverse();
+        return new StackCollection(this.assembly, arts);
+    }
+    filter(predicate) {
+        return new StackCollection(this.assembly, this.stackArtifacts.filter(predicate));
+    }
+    concat(...others) {
+        return new StackCollection(this.assembly, this.stackArtifacts.concat(...others.map(o => o.stackArtifacts)));
+    }
+    /**
+     * Extracts 'aws:cdk:warning|info|error' metadata entries from the stack synthesis
+     */
+    async validateMetadata(failAt = 'error', logger = async () => {
+    }) {
+        let warnings = false;
+        let errors = false;
+        for (const stack of this.stackArtifacts) {
+            for (const message of stack.messages) {
+                switch (message.level) {
+                    case cx_api_1.SynthesisMessageLevel.WARNING:
+                        warnings = true;
+                        await logger('warn', message);
+                        break;
+                    case cx_api_1.SynthesisMessageLevel.ERROR:
+                        errors = true;
+                        await logger('error', message);
+                        break;
+                    case cx_api_1.SynthesisMessageLevel.INFO:
+                        await logger('info', message);
+                        break;
+                }
+            }
+        }
+        if (errors && failAt != 'none') {
+            throw toolkit_error_1.AssemblyError.withStacks('Found errors', this.stackArtifacts);
+        }
+        if (warnings && failAt === 'warn') {
+            throw toolkit_error_1.AssemblyError.withStacks('Found warnings (--strict mode)', this.stackArtifacts);
+        }
+    }
+}
+exports.StackCollection = StackCollection;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-collection.js","sourceRoot":"","sources":["stack-collection.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { SynthesisMessageLevel } from '@aws-cdk/cx-api';\nimport type { IStackAssembly } from './stack-assembly';\nimport { type StackDetails } from '../../payloads/stack-details';\nimport { AssemblyError, ToolkitError } from '../../toolkit/toolkit-error';\n\n/**\n * A collection of stacks and related artifacts\n *\n * In practice, not all artifacts in the CloudAssembly are created equal;\n * stacks can be selected independently, but other artifacts such as asset\n * bundles cannot.\n */\nexport class StackCollection {\n  constructor(public readonly assembly: IStackAssembly, public readonly stackArtifacts: cxapi.CloudFormationStackArtifact[]) {\n  }\n\n  public get stackCount() {\n    return this.stackArtifacts.length;\n  }\n\n  public get firstStack() {\n    if (this.stackCount < 1) {\n      throw new ToolkitError('StackCollection contains no stack artifacts (trying to access the first one)');\n    }\n    return this.stackArtifacts[0];\n  }\n\n  public get stackIds(): string[] {\n    return this.stackArtifacts.map(s => s.id);\n  }\n\n  public get hierarchicalIds(): string[] {\n    return this.stackArtifacts.map(s => s.hierarchicalId);\n  }\n\n  public withDependencies(): StackDetails[] {\n    const allData: StackDetails[] = [];\n\n    for (const stack of this.stackArtifacts) {\n      const data: StackDetails = {\n        id: stack.displayName ?? stack.id,\n        name: stack.stackName,\n        environment: stack.environment,\n        dependencies: [],\n      };\n\n      for (const dependencyId of stack.dependencies.map(x => x.id)) {\n        if (dependencyId.includes('.assets')) {\n          continue;\n        }\n\n        const depStack = this.assembly.stackById(dependencyId);\n\n        if (depStack.firstStack.dependencies.filter((dep) => !(dep.id).includes('.assets')).length > 0) {\n          for (const stackDetail of depStack.withDependencies()) {\n            data.dependencies.push({\n              id: stackDetail.id,\n              dependencies: stackDetail.dependencies,\n            });\n          }\n        } else {\n          data.dependencies.push({\n            id: depStack.firstStack.displayName ?? depStack.firstStack.id,\n            dependencies: [],\n          });\n        }\n      }\n\n      allData.push(data);\n    }\n\n    return allData;\n  }\n\n  public reversed() {\n    const arts = [...this.stackArtifacts];\n    arts.reverse();\n    return new StackCollection(this.assembly, arts);\n  }\n\n  public filter(predicate: (art: cxapi.CloudFormationStackArtifact) => boolean): StackCollection {\n    return new StackCollection(this.assembly, this.stackArtifacts.filter(predicate));\n  }\n\n  public concat(...others: StackCollection[]): StackCollection {\n    return new StackCollection(this.assembly, this.stackArtifacts.concat(...others.map(o => o.stackArtifacts)));\n  }\n\n  /**\n   * Extracts 'aws:cdk:warning|info|error' metadata entries from the stack synthesis\n   */\n  public async validateMetadata(\n    failAt: 'warn' | 'error' | 'none' = 'error',\n    logger: (level: 'info' | 'error' | 'warn', msg: cxapi.SynthesisMessage) => Promise<void> = async () => {\n    },\n  ) {\n    let warnings = false;\n    let errors = false;\n\n    for (const stack of this.stackArtifacts) {\n      for (const message of stack.messages) {\n        switch (message.level) {\n          case SynthesisMessageLevel.WARNING:\n            warnings = true;\n            await logger('warn', message);\n            break;\n          case SynthesisMessageLevel.ERROR:\n            errors = true;\n            await logger('error', message);\n            break;\n          case SynthesisMessageLevel.INFO:\n            await logger('info', message);\n            break;\n        }\n      }\n    }\n\n    if (errors && failAt != 'none') {\n      throw AssemblyError.withStacks('Found errors', this.stackArtifacts);\n    }\n\n    if (warnings && failAt === 'warn') {\n      throw AssemblyError.withStacks('Found warnings (--strict mode)', this.stackArtifacts);\n    }\n  }\n}\n"]}

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

@@ -1,2 +1,81 @@
-export type { StackSelector } from '../shared-public';
-export { ExpandStackSelection, StackSelectionStrategy } from '../shared-public';
+/**
+ * Which stacks should be selected from a cloud assembly
+ */
+export declare enum StackSelectionStrategy {
+    /**
+     * Returns all stacks in the app regardless of patterns,
+     * including stacks inside nested assemblies.
+     */
+    ALL_STACKS = "all-stacks",
+    /**
+     * Returns all stacks in the main (top level) assembly only.
+     */
+    MAIN_ASSEMBLY = "main-assembly",
+    /**
+     * If the assembly includes a single stack, returns it.
+     * Otherwise throws an exception.
+     */
+    ONLY_SINGLE = "only-single",
+    /**
+     * Return stacks matched by patterns.
+     * If no stacks are found, execution is halted successfully.
+     * Most likely you don't want to use this but `StackSelectionStrategy.MUST_MATCH_PATTERN`
+     */
+    PATTERN_MATCH = "pattern-match",
+    /**
+     * Return stacks matched by patterns.
+     * Throws an exception if the patterns don't match at least one stack in the assembly.
+     */
+    PATTERN_MUST_MATCH = "pattern-must-match",
+    /**
+     * Returns if exactly one stack is matched by the pattern(s).
+     * Throws an exception if no stack, or more than exactly one stack are matched.
+     */
+    PATTERN_MUST_MATCH_SINGLE = "pattern-must-match-single"
+}
+/**
+ * When selecting stacks, what other stacks to include because of dependencies
+ */
+export declare enum ExpandStackSelection {
+    /**
+     * Don't select any extra stacks
+     */
+    NONE = "none",
+    /**
+     * Include stacks that this stack depends on
+     */
+    UPSTREAM = "upstream",
+    /**
+     * Include stacks that depend on this stack
+     */
+    DOWNSTREAM = "downstream"
+}
+/**
+ * A specification of which stacks should be selected
+ */
+export interface StackSelector {
+    /**
+     * The behavior if if no selectors are provided.
+     */
+    strategy: StackSelectionStrategy;
+    /**
+     * A list of patterns to match the stack hierarchical ids
+     * Only used with `PATTERN_*` selection strategies.
+     */
+    patterns?: string[];
+    /**
+     * Expand the selection to upstream/downstream stacks.
+     * @default ExpandStackSelection.None only select the specified/matched stacks
+     */
+    expand?: ExpandStackSelection;
+    /**
+     * By default, we throw an exception if the assembly contains no stacks.
+     * Set to `false`, to halt execution for empty assemblies without error.
+     *
+     * Note that actions can still throw if a stack selection result is empty,
+     * but the assembly contains stacks in principle.
+     *
+     * @default true
+     */
+    failOnEmpty?: boolean;
+}

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

@@ -1,7 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StackSelectionStrategy = exports.ExpandStackSelection = void 0;
-var shared_public_1 = require("../shared-public");
-Object.defineProperty(exports, "ExpandStackSelection", { enumerable: true, get: function () { return shared_public_1.ExpandStackSelection; } });
-Object.defineProperty(exports, "StackSelectionStrategy", { enumerable: true, get: function () { return shared_public_1.StackSelectionStrategy; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhY2stc2VsZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzdGFjay1zZWxlY3Rvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxrREFBZ0Y7QUFBdkUscUhBQUEsb0JBQW9CLE9BQUE7QUFBRSx1SEFBQSxzQkFBc0IsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgU3RhY2tTZWxlY3RvciB9IGZyb20gJy4uL3NoYXJlZC1wdWJsaWMnO1xuZXhwb3J0IHsgRXhwYW5kU3RhY2tTZWxlY3Rpb24sIFN0YWNrU2VsZWN0aW9uU3RyYXRlZ3kgfSBmcm9tICcuLi9zaGFyZWQtcHVibGljJztcbiJdfQ==
+exports.ExpandStackSelection = exports.StackSelectionStrategy = void 0;
+/**
+ * Which stacks should be selected from a cloud assembly
+ */
+var StackSelectionStrategy;
+(function (StackSelectionStrategy) {
+    /**
+     * Returns all stacks in the app regardless of patterns,
+     * including stacks inside nested assemblies.
+     */
+    StackSelectionStrategy["ALL_STACKS"] = "all-stacks";
+    /**
+     * Returns all stacks in the main (top level) assembly only.
+     */
+    StackSelectionStrategy["MAIN_ASSEMBLY"] = "main-assembly";
+    /**
+     * If the assembly includes a single stack, returns it.
+     * Otherwise throws an exception.
+     */
+    StackSelectionStrategy["ONLY_SINGLE"] = "only-single";
+    /**
+     * Return stacks matched by patterns.
+     * If no stacks are found, execution is halted successfully.
+     * Most likely you don't want to use this but `StackSelectionStrategy.MUST_MATCH_PATTERN`
+     */
+    StackSelectionStrategy["PATTERN_MATCH"] = "pattern-match";
+    /**
+     * Return stacks matched by patterns.
+     * Throws an exception if the patterns don't match at least one stack in the assembly.
+     */
+    StackSelectionStrategy["PATTERN_MUST_MATCH"] = "pattern-must-match";
+    /**
+     * Returns if exactly one stack is matched by the pattern(s).
+     * Throws an exception if no stack, or more than exactly one stack are matched.
+     */
+    StackSelectionStrategy["PATTERN_MUST_MATCH_SINGLE"] = "pattern-must-match-single";
+})(StackSelectionStrategy || (exports.StackSelectionStrategy = StackSelectionStrategy = {}));
+/**
+ * When selecting stacks, what other stacks to include because of dependencies
+ */
+var ExpandStackSelection;
+(function (ExpandStackSelection) {
+    /**
+     * Don't select any extra stacks
+     */
+    ExpandStackSelection["NONE"] = "none";
+    /**
+     * Include stacks that this stack depends on
+     */
+    ExpandStackSelection["UPSTREAM"] = "upstream";
+    /**
+     * Include stacks that depend on this stack
+     */
+    ExpandStackSelection["DOWNSTREAM"] = "downstream";
+    /**
+     * @TODO
+     * Include both directions.
+     * I.e. stacks that this stack depends on, and stacks that depend on this stack.
+     */
+    // FULL = 'full',
+})(ExpandStackSelection || (exports.ExpandStackSelection = ExpandStackSelection = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/cloudformation/evaluate-cloudformation-template.d.ts

@@ -0,0 +1,85 @@
+import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';
+import type { Export, StackResourceSummary } from '@aws-sdk/client-cloudformation';
+import type { NestedStackTemplates } from './nested-stack-helpers';
+import type { Template } from './stack-helpers';
+import type { SDK } from '../aws-auth/private';
+import type { ResourceMetadata } from '../resource-metadata';
+export interface ListStackResources {
+    listStackResources(): Promise<StackResourceSummary[]>;
+}
+export declare class LazyListStackResources implements ListStackResources {
+    private readonly sdk;
+    private readonly stackName;
+    private stackResources;
+    constructor(sdk: SDK, stackName: string);
+    listStackResources(): Promise<StackResourceSummary[]>;
+}
+export interface LookupExport {
+    lookupExport(name: string): Promise<Export | undefined>;
+}
+export declare class LookupExportError extends Error {
+}
+export declare class LazyLookupExport implements LookupExport {
+    private readonly sdk;
+    private cachedExports;
+    constructor(sdk: SDK);
+    lookupExport(name: string): Promise<Export | undefined>;
+    private listExports;
+}
+export declare class CfnEvaluationException extends Error {
+}
+export interface ResourceDefinition {
+    readonly LogicalId: string;
+    readonly Type: string;
+    readonly Properties: {
+        [p: string]: any;
+    };
+}
+export interface EvaluateCloudFormationTemplateProps {
+    readonly stackArtifact: CloudFormationStackArtifact;
+    readonly stackName?: string;
+    readonly template?: Template;
+    readonly parameters: {
+        [parameterName: string]: string;
+    };
+    readonly account: string;
+    readonly region: string;
+    readonly partition: string;
+    readonly sdk: SDK;
+    readonly nestedStacks?: {
+        [nestedStackLogicalId: string]: NestedStackTemplates;
+    };
+}
+export declare class EvaluateCloudFormationTemplate {
+    readonly stackArtifact: CloudFormationStackArtifact;
+    private readonly stackName;
+    private readonly template;
+    private readonly context;
+    private readonly account;
+    private readonly region;
+    private readonly partition;
+    private readonly sdk;
+    private readonly nestedStacks;
+    private readonly stackResources;
+    private readonly lookupExport;
+    private cachedUrlSuffix;
+    constructor(props: EvaluateCloudFormationTemplateProps);
+    createNestedEvaluateCloudFormationTemplate(stackName: string, nestedTemplate: Template, nestedStackParameters: {
+        [parameterName: string]: any;
+    }): Promise<EvaluateCloudFormationTemplate>;
+    establishResourcePhysicalName(logicalId: string, physicalNameInCfnTemplate: any): Promise<string | undefined>;
+    findPhysicalNameFor(logicalId: string): Promise<string | undefined>;
+    findLogicalIdForPhysicalName(physicalName: string): Promise<string | undefined>;
+    findReferencesTo(logicalId: string): Array<ResourceDefinition>;
+    evaluateCfnExpression(cfnExpression: any): Promise<any>;
+    getResourceProperty(logicalId: string, propertyName: string): any;
+    metadataFor(logicalId: string): ResourceMetadata | undefined;
+    private references;
+    private parseIntrinsic;
+    private findRefTarget;
+    private findGetAttTarget;
+    private findNestedStack;
+    private formatResourceAttribute;
+    private getServiceOfResource;
+    private getResourceTypeArnPartOfResource;
+}