@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

package/lib/api/toolkit-info.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolkitInfo = exports.DEFAULT_TOOLKIT_STACK_NAME = void 0;
+const util_1 = require("util");
+const chalk = require("chalk");
+const bootstrap_props_1 = require("./bootstrap/bootstrap-props");
+const cfn_api_1 = require("./deployments/cfn-api");
+const private_1 = require("./io/private");
+const toolkit_error_1 = require("./toolkit-error");
+exports.DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';
+/**
+ * Information on the Bootstrap stack of the environment we're deploying to.
+ *
+ * This class serves to:
+ *
+ * - Inspect the bootstrap stack, and return various properties of it for successful
+ *   asset deployment (in case of legacy-synthesized stacks).
+ * - Validate the version of the target environment, and nothing else (in case of
+ *   default-synthesized stacks).
+ *
+ * An object of this type might represent a bootstrap stack that could not be found.
+ * This is not an issue unless any members are used that require the bootstrap stack
+ * to have been found, in which case an error is thrown (default-synthesized stacks
+ * should never run into this as they don't need information from the bootstrap
+ * stack, all information is already encoded into the Cloud Assembly Manifest).
+ *
+ * Nevertheless, an instance of this class exists to serve as a cache for SSM
+ * parameter lookups (otherwise, the "bootstrap stack version" parameter would
+ * need to be read repeatedly).
+ *
+ * Called "ToolkitInfo" for historical reasons.
+ *
+ */
+class ToolkitInfo {
+    static determineName(overrideName) {
+        return overrideName ?? exports.DEFAULT_TOOLKIT_STACK_NAME;
+    }
+    static async lookup(environment, sdk, ioHelper, stackName) {
+        const cfn = sdk.cloudFormation();
+        stackName = ToolkitInfo.determineName(stackName);
+        try {
+            const stack = await (0, cfn_api_1.stabilizeStack)(cfn, ioHelper, stackName);
+            if (!stack) {
+                await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg((0, util_1.format)("The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.", environment.name, stackName, chalk.blue(`cdk bootstrap "${environment.name}"`))));
+                return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
+            }
+            if (stack.stackStatus.isCreationFailure) {
+                // Treat a "failed to create" bootstrap stack as an absent one.
+                await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg((0, util_1.format)('The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.', environment.name, stackName, chalk.blue(`cdk bootstrap "${environment.name}"`))));
+                return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
+            }
+            return new ExistingToolkitInfo(stack);
+        }
+        catch (e) {
+            return ToolkitInfo.bootstrapStackLookupError(stackName, e);
+        }
+    }
+    static fromStack(stack) {
+        return new ExistingToolkitInfo(stack);
+    }
+    static bootstrapStackNotFoundInfo(stackName) {
+        return new BootstrapStackNotFoundInfo(stackName, "This deployment requires a bootstrap stack with a known name; pass '--toolkit-stack-name' or switch to using the 'DefaultStackSynthesizer' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)");
+    }
+    static bootstrapStackLookupError(stackName, e) {
+        return new BootstrapStackNotFoundInfo(stackName, `This deployment requires a bootstrap stack with a known name, but during its lookup the following error occurred: ${e}; pass \'--toolkit-stack-name\' or switch to using the \'DefaultStackSynthesizer\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`);
+    }
+    constructor() {
+    }
+}
+exports.ToolkitInfo = ToolkitInfo;
+/**
+ * Returned when a bootstrap stack is found
+ */
+class ExistingToolkitInfo extends ToolkitInfo {
+    bootstrapStack;
+    found = true;
+    constructor(bootstrapStack) {
+        super();
+        this.bootstrapStack = bootstrapStack;
+    }
+    get bucketUrl() {
+        return `https://${this.requireOutput(bootstrap_props_1.BUCKET_DOMAIN_NAME_OUTPUT)}`;
+    }
+    get bucketName() {
+        return this.requireOutput(bootstrap_props_1.BUCKET_NAME_OUTPUT);
+    }
+    get repositoryName() {
+        return this.requireOutput(bootstrap_props_1.REPOSITORY_NAME_OUTPUT);
+    }
+    get version() {
+        return parseInt(this.bootstrapStack.outputs[bootstrap_props_1.BOOTSTRAP_VERSION_OUTPUT] ?? '0', 10);
+    }
+    get variant() {
+        return this.bootstrapStack.parameters[bootstrap_props_1.BOOTSTRAP_VARIANT_PARAMETER] ?? bootstrap_props_1.DEFAULT_BOOTSTRAP_VARIANT;
+    }
+    get parameters() {
+        return this.bootstrapStack.parameters ?? {};
+    }
+    get terminationProtection() {
+        return this.bootstrapStack.terminationProtection ?? false;
+    }
+    get stackName() {
+        return this.bootstrapStack.stackName;
+    }
+    /**
+     * Prepare an ECR repository for uploading to using Docker
+     *
+     */
+    requireOutput(output) {
+        if (!(output in this.bootstrapStack.outputs)) {
+            throw new toolkit_error_1.ToolkitError(`The CDK toolkit stack (${this.bootstrapStack.stackName}) does not have an output named ${output}. Use 'cdk bootstrap' to correct this.`);
+        }
+        return this.bootstrapStack.outputs[output];
+    }
+}
+/**
+ * Returned when a bootstrap stack could not be found
+ *
+ * This is not an error in principle, UNTIL one of the members is called that requires
+ * the bootstrap stack to have been found, in which case the lookup error is still thrown
+ * belatedly.
+ *
+ * The errors below serve as a last stop-gap message--normally calling code should have
+ * checked `toolkit.found` and produced an appropriate error message.
+ */
+class BootstrapStackNotFoundInfo extends ToolkitInfo {
+    stackName;
+    errorMessage;
+    found = false;
+    constructor(stackName, errorMessage) {
+        super();
+        this.stackName = stackName;
+        this.errorMessage = errorMessage;
+    }
+    get bootstrapStack() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get bucketUrl() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get bucketName() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get repositoryName() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get version() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get variant() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    prepareEcrRepository() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolkit-info.js","sourceRoot":"","sources":["toolkit-info.ts"],"names":[],"mappings":"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","sourcesContent":["import { format } from 'util';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport type { SDK } from './aws-auth/private';\nimport {\n  BOOTSTRAP_VARIANT_PARAMETER,\n  BOOTSTRAP_VERSION_OUTPUT,\n  BUCKET_DOMAIN_NAME_OUTPUT,\n  BUCKET_NAME_OUTPUT,\n  DEFAULT_BOOTSTRAP_VARIANT,\n  REPOSITORY_NAME_OUTPUT,\n} from './bootstrap/bootstrap-props';\nimport type { CloudFormationStack } from './cloudformation';\nimport { stabilizeStack } from './deployments/cfn-api';\nimport { IO, type IoHelper } from './io/private';\nimport { ToolkitError } from './toolkit-error';\n\nexport const DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';\n\n/**\n * Information on the Bootstrap stack of the environment we're deploying to.\n *\n * This class serves to:\n *\n * - Inspect the bootstrap stack, and return various properties of it for successful\n *   asset deployment (in case of legacy-synthesized stacks).\n * - Validate the version of the target environment, and nothing else (in case of\n *   default-synthesized stacks).\n *\n * An object of this type might represent a bootstrap stack that could not be found.\n * This is not an issue unless any members are used that require the bootstrap stack\n * to have been found, in which case an error is thrown (default-synthesized stacks\n * should never run into this as they don't need information from the bootstrap\n * stack, all information is already encoded into the Cloud Assembly Manifest).\n *\n * Nevertheless, an instance of this class exists to serve as a cache for SSM\n * parameter lookups (otherwise, the \"bootstrap stack version\" parameter would\n * need to be read repeatedly).\n *\n * Called \"ToolkitInfo\" for historical reasons.\n *\n */\nexport abstract class ToolkitInfo {\n  public static determineName(overrideName?: string) {\n    return overrideName ?? DEFAULT_TOOLKIT_STACK_NAME;\n  }\n\n  public static async lookup(\n    environment: cxapi.Environment,\n    sdk: SDK,\n    ioHelper: IoHelper,\n    stackName: string | undefined,\n  ): Promise<ToolkitInfo> {\n    const cfn = sdk.cloudFormation();\n    stackName = ToolkitInfo.determineName(stackName);\n    try {\n      const stack = await stabilizeStack(cfn, ioHelper, stackName);\n      if (!stack) {\n        await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(\n          format(\n            \"The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.\",\n            environment.name,\n            stackName,\n            chalk.blue(`cdk bootstrap \"${environment.name}\"`),\n          ),\n        ));\n        return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);\n      }\n      if (stack.stackStatus.isCreationFailure) {\n        // Treat a \"failed to create\" bootstrap stack as an absent one.\n        await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(\n          format(\n            'The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.',\n            environment.name,\n            stackName,\n            chalk.blue(`cdk bootstrap \"${environment.name}\"`),\n          ),\n        ));\n        return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);\n      }\n\n      return new ExistingToolkitInfo(stack);\n    } catch (e: any) {\n      return ToolkitInfo.bootstrapStackLookupError(stackName, e);\n    }\n  }\n\n  public static fromStack(stack: CloudFormationStack): ToolkitInfo {\n    return new ExistingToolkitInfo(stack);\n  }\n\n  public static bootstrapStackNotFoundInfo(stackName: string): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(\n      stackName,\n      \"This deployment requires a bootstrap stack with a known name; pass '--toolkit-stack-name' or switch to using the 'DefaultStackSynthesizer' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)\",\n    );\n  }\n\n  public static bootstrapStackLookupError(stackName: string, e: Error): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(\n      stackName,\n      `This deployment requires a bootstrap stack with a known name, but during its lookup the following error occurred: ${e}; pass \\'--toolkit-stack-name\\' or switch to using the \\'DefaultStackSynthesizer\\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`,\n    );\n  }\n\n  public abstract readonly found: boolean;\n  public abstract readonly bucketUrl: string;\n  public abstract readonly bucketName: string;\n  public abstract readonly repositoryName: string;\n  public abstract readonly version: number;\n  public abstract readonly variant: string;\n  public abstract readonly bootstrapStack: CloudFormationStack;\n  public abstract readonly stackName: string;\n\n  constructor() {\n  }\n}\n\n/**\n * Returned when a bootstrap stack is found\n */\nclass ExistingToolkitInfo extends ToolkitInfo {\n  public readonly found = true;\n\n  constructor(public readonly bootstrapStack: CloudFormationStack) {\n    super();\n  }\n\n  public get bucketUrl() {\n    return `https://${this.requireOutput(BUCKET_DOMAIN_NAME_OUTPUT)}`;\n  }\n\n  public get bucketName() {\n    return this.requireOutput(BUCKET_NAME_OUTPUT);\n  }\n\n  public get repositoryName() {\n    return this.requireOutput(REPOSITORY_NAME_OUTPUT);\n  }\n\n  public get version() {\n    return parseInt(this.bootstrapStack.outputs[BOOTSTRAP_VERSION_OUTPUT] ?? '0', 10);\n  }\n\n  public get variant() {\n    return this.bootstrapStack.parameters[BOOTSTRAP_VARIANT_PARAMETER] ?? DEFAULT_BOOTSTRAP_VARIANT;\n  }\n\n  public get parameters(): Record<string, string> {\n    return this.bootstrapStack.parameters ?? {};\n  }\n\n  public get terminationProtection(): boolean {\n    return this.bootstrapStack.terminationProtection ?? false;\n  }\n\n  public get stackName(): string {\n    return this.bootstrapStack.stackName;\n  }\n\n  /**\n   * Prepare an ECR repository for uploading to using Docker\n   *\n   */\n  private requireOutput(output: string): string {\n    if (!(output in this.bootstrapStack.outputs)) {\n      throw new ToolkitError(\n        `The CDK toolkit stack (${this.bootstrapStack.stackName}) does not have an output named ${output}. Use 'cdk bootstrap' to correct this.`,\n      );\n    }\n    return this.bootstrapStack.outputs[output];\n  }\n}\n\n/**\n * Returned when a bootstrap stack could not be found\n *\n * This is not an error in principle, UNTIL one of the members is called that requires\n * the bootstrap stack to have been found, in which case the lookup error is still thrown\n * belatedly.\n *\n * The errors below serve as a last stop-gap message--normally calling code should have\n * checked `toolkit.found` and produced an appropriate error message.\n */\nclass BootstrapStackNotFoundInfo extends ToolkitInfo {\n  public readonly found = false;\n\n  constructor(\n    public readonly stackName: string,\n    private readonly errorMessage: string,\n  ) {\n    super();\n  }\n\n  public get bootstrapStack(): CloudFormationStack {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get bucketUrl(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get bucketName(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get repositoryName(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get version(): number {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get variant(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public prepareEcrRepository(): Promise<EcrRepositoryInfo> {\n    throw new ToolkitError(this.errorMessage);\n  }\n}\n\nexport interface EcrRepositoryInfo {\n  repositoryUri: string;\n}\n\nexport interface EcrCredentials {\n  username: string;\n  password: string;\n  endpoint: string;\n}\n"]}

package/lib/api/tree.d.ts

@@ -0,0 +1,31 @@
+import type { CloudAssembly } from '@aws-cdk/cx-api';
+/**
+ * Source information on a construct (class fqn and version)
+ */
+export interface ConstructInfo {
+    readonly fqn: string;
+    readonly version: string;
+}
+/**
+ * A node in the construct tree.
+ */
+export interface ConstructTreeNode {
+    readonly id: string;
+    readonly path: string;
+    readonly children?: {
+        [key: string]: ConstructTreeNode;
+    };
+    readonly attributes?: {
+        [key: string]: any;
+    };
+    /**
+     * Information on the construct class that led to this node, if available
+     */
+    readonly constructInfo?: ConstructInfo;
+}
+/**
+ * Whether the provided predicate is true for at least one element in the construct (sub-)tree.
+ */
+export declare function some(node: ConstructTreeNode | undefined, predicate: (n: ConstructTreeNode) => boolean): boolean;
+export declare function loadTree(assembly: CloudAssembly, trace: (msg: string) => Promise<void>): Promise<ConstructTreeNode | undefined>;
+export declare function loadTreeFromDir(outdir: string, trace: (msg: string) => void): ConstructTreeNode | undefined;

package/lib/api/tree.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.some = some;
+exports.loadTree = loadTree;
+exports.loadTreeFromDir = loadTreeFromDir;
+const path = require("node:path");
+const fs = require("fs-extra");
+/**
+ * Whether the provided predicate is true for at least one element in the construct (sub-)tree.
+ */
+function some(node, predicate) {
+    return node != null && (predicate(node) || findInChildren());
+    function findInChildren() {
+        return Object.values(node?.children ?? {}).some(child => some(child, predicate));
+    }
+}
+async function loadTree(assembly, trace) {
+    try {
+        const outdir = assembly.directory;
+        const fileName = assembly.tree()?.file;
+        return fileName ? fs.readJSONSync(path.join(outdir, fileName)).tree : {};
+    }
+    catch (e) {
+        await trace(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
+        return undefined;
+    }
+}
+function loadTreeFromDir(outdir, trace) {
+    try {
+        return fs.readJSONSync(path.join(outdir, 'tree.json')).tree;
+    }
+    catch (e) {
+        trace(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/work-graph/index.d.ts

@@ -0,0 +1,3 @@
+export * from './work-graph';
+export * from './work-graph-builder';
+export * from './work-graph-types';

package/lib/api/work-graph/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./work-graph"), exports);
+__exportStar(require("./work-graph-builder"), exports);
+__exportStar(require("./work-graph-types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0NBQTZCO0FBQzdCLHVEQUFxQztBQUNyQyxxREFBbUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dvcmstZ3JhcGgnO1xuZXhwb3J0ICogZnJvbSAnLi93b3JrLWdyYXBoLWJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi93b3JrLWdyYXBoLXR5cGVzJztcbiJdfQ==

package/lib/api/work-graph/work-graph-builder.d.ts

@@ -0,0 +1,34 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import { WorkGraph } from './work-graph';
+import type { WorkNode } from './work-graph-types';
+import type { IoHelper } from '../io/private';
+export declare class WorkGraphBuilder {
+    private readonly prebuildAssets;
+    private readonly idPrefix;
+    /**
+     * Default priorities for nodes
+     *
+     * Assets builds have higher priority than the other two operations, to make good on our promise that
+     * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the
+     * default :(
+     *
+     * But between stack dependencies and publish dependencies, stack dependencies go first
+     */
+    static PRIORITIES: Record<WorkNode['type'], number>;
+    private readonly graph;
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper, prebuildAssets: boolean, idPrefix?: string);
+    private addStack;
+    /**
+     * Oof, see this parameter list
+     */
+    private addAsset;
+    build(artifacts: cxapi.CloudArtifact[]): WorkGraph;
+    private stackArtifactIds;
+    private stackArtifactId;
+    /**
+     * We may have accidentally introduced cycles in an attempt to make the messages printed to the
+     * console not interfere with each other too much. Remove them again.
+     */
+    private removeStackPublishCycles;
+}

package/lib/api/work-graph/work-graph-builder.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkGraphBuilder = void 0;
+const cxapi = require("@aws-cdk/cx-api");
+const cdk_assets_1 = require("cdk-assets");
+const work_graph_1 = require("./work-graph");
+const work_graph_types_1 = require("./work-graph-types");
+const util_1 = require("../../util");
+const toolkit_error_1 = require("../toolkit-error");
+class WorkGraphBuilder {
+    prebuildAssets;
+    idPrefix;
+    /**
+     * Default priorities for nodes
+     *
+     * Assets builds have higher priority than the other two operations, to make good on our promise that
+     * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the
+     * default :(
+     *
+     * But between stack dependencies and publish dependencies, stack dependencies go first
+     */
+    static PRIORITIES = {
+        'asset-build': 10,
+        'asset-publish': 0,
+        'stack': 5,
+    };
+    graph;
+    ioHelper;
+    constructor(ioHelper, prebuildAssets, idPrefix = '') {
+        this.prebuildAssets = prebuildAssets;
+        this.idPrefix = idPrefix;
+        this.graph = new work_graph_1.WorkGraph({}, ioHelper);
+        this.ioHelper = ioHelper;
+    }
+    addStack(artifact) {
+        this.graph.addNodes({
+            type: 'stack',
+            id: `${this.idPrefix}${artifact.id}`,
+            dependencies: new Set(this.stackArtifactIds(onlyStacks(artifact.dependencies))),
+            stack: artifact,
+            deploymentState: work_graph_types_1.DeploymentState.PENDING,
+            priority: WorkGraphBuilder.PRIORITIES.stack,
+        });
+    }
+    /**
+     * Oof, see this parameter list
+     */
+    // eslint-disable-next-line max-len
+    addAsset(parentStack, assetManifestArtifact, assetManifest, asset) {
+        // Just the artifact identifier
+        const assetId = asset.id.assetId;
+        const buildId = `build-${assetId}-${(0, util_1.contentHashAny)([assetId, asset.genericSource]).substring(0, 10)}`;
+        const publishId = `publish-${assetId}-${(0, util_1.contentHashAny)([assetId, asset.genericDestination]).substring(0, 10)}`;
+        // Build node only gets added once because they are all the same
+        if (!this.graph.tryGetNode(buildId)) {
+            const node = {
+                type: 'asset-build',
+                id: buildId,
+                note: asset.displayName(false),
+                dependencies: new Set([
+                    ...this.stackArtifactIds(assetManifestArtifact.dependencies),
+                    // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack
+                    ...!this.prebuildAssets ? this.stackArtifactIds(onlyStacks(parentStack.dependencies)) : [],
+                ]),
+                parentStack: parentStack,
+                assetManifestArtifact,
+                assetManifest,
+                asset,
+                deploymentState: work_graph_types_1.DeploymentState.PENDING,
+                priority: WorkGraphBuilder.PRIORITIES['asset-build'],
+            };
+            this.graph.addNodes(node);
+        }
+        const publishNode = this.graph.tryGetNode(publishId);
+        if (!publishNode) {
+            this.graph.addNodes({
+                type: 'asset-publish',
+                id: publishId,
+                note: asset.displayName(true),
+                dependencies: new Set([
+                    buildId,
+                ]),
+                parentStack,
+                assetManifestArtifact,
+                assetManifest,
+                asset,
+                deploymentState: work_graph_types_1.DeploymentState.PENDING,
+                priority: WorkGraphBuilder.PRIORITIES['asset-publish'],
+            });
+        }
+        for (const inheritedDep of this.stackArtifactIds(onlyStacks(parentStack.dependencies))) {
+            // The asset publish step also depends on the stacks that the parent depends on.
+            // This is purely cosmetic: if we don't do this, the progress printing of asset publishing
+            // is going to interfere with the progress bar of the stack deployment. We could remove this
+            // for overall faster deployments if we ever have a better method of progress displaying.
+            // Note: this may introduce a cycle if one of the parent's dependencies is another stack that
+            // depends on this asset. To workaround this we remove these cycles once all nodes have
+            // been added to the graph.
+            this.graph.addDependency(publishId, inheritedDep);
+        }
+        // This will work whether the stack node has been added yet or not
+        this.graph.addDependency(`${this.idPrefix}${parentStack.id}`, publishId);
+    }
+    build(artifacts) {
+        const parentStacks = stacksFromAssets(artifacts);
+        for (const artifact of artifacts) {
+            if (cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {
+                this.addStack(artifact);
+            }
+            else if (cxapi.AssetManifestArtifact.isAssetManifestArtifact(artifact)) {
+                const manifest = cdk_assets_1.AssetManifest.fromFile(artifact.file);
+                for (const entry of manifest.entries) {
+                    const parentStack = parentStacks.get(artifact);
+                    if (parentStack === undefined) {
+                        throw new toolkit_error_1.ToolkitError('Found an asset manifest that is not associated with a stack');
+                    }
+                    this.addAsset(parentStack, artifact, manifest, entry);
+                }
+            }
+            else if (cxapi.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {
+                const assembly = new cxapi.CloudAssembly(artifact.fullPath, { topoSort: false });
+                const nestedGraph = new WorkGraphBuilder(this.ioHelper, this.prebuildAssets, `${this.idPrefix}${artifact.id}.`).build(assembly.artifacts);
+                this.graph.absorb(nestedGraph);
+            }
+            else {
+                // Ignore whatever else
+            }
+        }
+        this.graph.removeUnavailableDependencies();
+        // Remove any potentially introduced cycles between asset publishing and the stacks that depend on them.
+        this.removeStackPublishCycles();
+        return this.graph;
+    }
+    stackArtifactIds(deps) {
+        return deps.flatMap((d) => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(d) ? [this.stackArtifactId(d)] : []);
+    }
+    stackArtifactId(artifact) {
+        if (!cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {
+            throw new toolkit_error_1.ToolkitError(`Can only call this on CloudFormationStackArtifact, got: ${artifact.constructor.name}`);
+        }
+        return `${this.idPrefix}${artifact.id}`;
+    }
+    /**
+     * We may have accidentally introduced cycles in an attempt to make the messages printed to the
+     * console not interfere with each other too much. Remove them again.
+     */
+    removeStackPublishCycles() {
+        const publishSteps = this.graph.nodesOfType('asset-publish');
+        for (const publishStep of publishSteps) {
+            for (const dep of publishStep.dependencies) {
+                if (this.graph.reachable(dep, publishStep.id)) {
+                    publishStep.dependencies.delete(dep);
+                }
+            }
+        }
+    }
+}
+exports.WorkGraphBuilder = WorkGraphBuilder;
+function stacksFromAssets(artifacts) {
+    const ret = new Map();
+    for (const stack of artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x))) {
+        const assetArtifacts = stack.dependencies.filter((x) => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x));
+        for (const art of assetArtifacts) {
+            ret.set(art, stack);
+        }
+    }
+    return ret;
+}
+function onlyStacks(artifacts) {
+    return artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"work-graph-builder.js","sourceRoot":"","sources":["work-graph-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport { AssetManifest, type IManifestEntry } from 'cdk-assets';\nimport { WorkGraph } from './work-graph';\nimport type { AssetBuildNode, WorkNode } from './work-graph-types';\nimport { DeploymentState } from './work-graph-types';\nimport { contentHashAny } from '../../util';\nimport type { IoHelper } from '../io/private';\nimport { ToolkitError } from '../toolkit-error';\n\nexport class WorkGraphBuilder {\n  /**\n   * Default priorities for nodes\n   *\n   * Assets builds have higher priority than the other two operations, to make good on our promise that\n   * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the\n   * default :(\n   *\n   * But between stack dependencies and publish dependencies, stack dependencies go first\n   */\n  public static PRIORITIES: Record<WorkNode['type'], number> = {\n    'asset-build': 10,\n    'asset-publish': 0,\n    'stack': 5,\n  };\n  private readonly graph: WorkGraph;\n  private readonly ioHelper: IoHelper;\n\n  constructor(\n    ioHelper: IoHelper,\n    private readonly prebuildAssets: boolean,\n    private readonly idPrefix = '',\n  ) {\n    this.graph = new WorkGraph({}, ioHelper);\n    this.ioHelper = ioHelper;\n  }\n\n  private addStack(artifact: cxapi.CloudFormationStackArtifact) {\n    this.graph.addNodes({\n      type: 'stack',\n      id: `${this.idPrefix}${artifact.id}`,\n      dependencies: new Set(this.stackArtifactIds(onlyStacks(artifact.dependencies))),\n      stack: artifact,\n      deploymentState: DeploymentState.PENDING,\n      priority: WorkGraphBuilder.PRIORITIES.stack,\n    });\n  }\n\n  /**\n   * Oof, see this parameter list\n   */\n  // eslint-disable-next-line max-len\n  private addAsset(parentStack: cxapi.CloudFormationStackArtifact, assetManifestArtifact: cxapi.AssetManifestArtifact, assetManifest: AssetManifest, asset: IManifestEntry) {\n    // Just the artifact identifier\n    const assetId = asset.id.assetId;\n\n    const buildId = `build-${assetId}-${contentHashAny([assetId, asset.genericSource]).substring(0, 10)}`;\n    const publishId = `publish-${assetId}-${contentHashAny([assetId, asset.genericDestination]).substring(0, 10)}`;\n\n    // Build node only gets added once because they are all the same\n    if (!this.graph.tryGetNode(buildId)) {\n      const node: AssetBuildNode = {\n        type: 'asset-build',\n        id: buildId,\n        note: asset.displayName(false),\n        dependencies: new Set([\n          ...this.stackArtifactIds(assetManifestArtifact.dependencies),\n          // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack\n          ...!this.prebuildAssets ? this.stackArtifactIds(onlyStacks(parentStack.dependencies)) : [],\n        ]),\n        parentStack: parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-build'],\n      };\n      this.graph.addNodes(node);\n    }\n\n    const publishNode = this.graph.tryGetNode(publishId);\n    if (!publishNode) {\n      this.graph.addNodes({\n        type: 'asset-publish',\n        id: publishId,\n        note: asset.displayName(true),\n        dependencies: new Set([\n          buildId,\n        ]),\n        parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-publish'],\n      });\n    }\n\n    for (const inheritedDep of this.stackArtifactIds(onlyStacks(parentStack.dependencies))) {\n      // The asset publish step also depends on the stacks that the parent depends on.\n      // This is purely cosmetic: if we don't do this, the progress printing of asset publishing\n      // is going to interfere with the progress bar of the stack deployment. We could remove this\n      // for overall faster deployments if we ever have a better method of progress displaying.\n      // Note: this may introduce a cycle if one of the parent's dependencies is another stack that\n      // depends on this asset. To workaround this we remove these cycles once all nodes have\n      // been added to the graph.\n      this.graph.addDependency(publishId, inheritedDep);\n    }\n\n    // This will work whether the stack node has been added yet or not\n    this.graph.addDependency(`${this.idPrefix}${parentStack.id}`, publishId);\n  }\n\n  public build(artifacts: cxapi.CloudArtifact[]): WorkGraph {\n    const parentStacks = stacksFromAssets(artifacts);\n\n    for (const artifact of artifacts) {\n      if (cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n        this.addStack(artifact);\n      } else if (cxapi.AssetManifestArtifact.isAssetManifestArtifact(artifact)) {\n        const manifest = AssetManifest.fromFile(artifact.file);\n\n        for (const entry of manifest.entries) {\n          const parentStack = parentStacks.get(artifact);\n          if (parentStack === undefined) {\n            throw new ToolkitError('Found an asset manifest that is not associated with a stack');\n          }\n          this.addAsset(parentStack, artifact, manifest, entry);\n        }\n      } else if (cxapi.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {\n        const assembly = new cxapi.CloudAssembly(artifact.fullPath, { topoSort: false });\n        const nestedGraph = new WorkGraphBuilder(\n          this.ioHelper,\n          this.prebuildAssets,\n          `${this.idPrefix}${artifact.id}.`,\n        ).build(assembly.artifacts);\n        this.graph.absorb(nestedGraph);\n      } else {\n        // Ignore whatever else\n      }\n    }\n\n    this.graph.removeUnavailableDependencies();\n\n    // Remove any potentially introduced cycles between asset publishing and the stacks that depend on them.\n    this.removeStackPublishCycles();\n\n    return this.graph;\n  }\n\n  private stackArtifactIds(deps: cxapi.CloudArtifact[]): string[] {\n    return deps.flatMap((d) => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(d) ? [this.stackArtifactId(d)] : []);\n  }\n\n  private stackArtifactId(artifact: cxapi.CloudArtifact): string {\n    if (!cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n      throw new ToolkitError(`Can only call this on CloudFormationStackArtifact, got: ${artifact.constructor.name}`);\n    }\n    return `${this.idPrefix}${artifact.id}`;\n  }\n\n  /**\n   * We may have accidentally introduced cycles in an attempt to make the messages printed to the\n   * console not interfere with each other too much. Remove them again.\n   */\n  private removeStackPublishCycles() {\n    const publishSteps = this.graph.nodesOfType('asset-publish');\n    for (const publishStep of publishSteps) {\n      for (const dep of publishStep.dependencies) {\n        if (this.graph.reachable(dep, publishStep.id)) {\n          publishStep.dependencies.delete(dep);\n        }\n      }\n    }\n  }\n}\n\nfunction stacksFromAssets(artifacts: cxapi.CloudArtifact[]) {\n  const ret = new Map<cxapi.AssetManifestArtifact, cxapi.CloudFormationStackArtifact>();\n  for (const stack of artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x))) {\n    const assetArtifacts = stack.dependencies.filter((x) => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x));\n    for (const art of assetArtifacts) {\n      ret.set(art, stack);\n    }\n  }\n\n  return ret;\n}\n\nfunction onlyStacks(artifacts: cxapi.CloudArtifact[]) {\n  return artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x));\n}\n"]}

package/lib/api/work-graph/work-graph-types.d.ts

@@ -0,0 +1,50 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { AssetManifest, IManifestEntry } from 'cdk-assets';
+export declare enum DeploymentState {
+    PENDING = "pending",
+    QUEUED = "queued",
+    DEPLOYING = "deploying",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+export type WorkNode = StackNode | AssetBuildNode | AssetPublishNode;
+export interface WorkNodeCommon {
+    readonly id: string;
+    readonly dependencies: Set<string>;
+    deploymentState: DeploymentState;
+    /** Some readable information to attach to the id, which may be unreadable */
+    readonly note?: string;
+}
+export interface StackNode extends WorkNodeCommon {
+    readonly type: 'stack';
+    readonly stack: cxapi.CloudFormationStackArtifact;
+    /** Sort by priority when picking up work, higher is earlier */
+    readonly priority?: number;
+}
+export interface AssetBuildNode extends WorkNodeCommon {
+    readonly type: 'asset-build';
+    /** The asset manifest this asset resides in (artifact) */
+    readonly assetManifestArtifact: cxapi.AssetManifestArtifact;
+    /** The asset manifest this asset resides in */
+    readonly assetManifest: AssetManifest;
+    /** The stack this asset was defined in (used for environment settings) */
+    readonly parentStack: cxapi.CloudFormationStackArtifact;
+    /** The asset that needs to be built */
+    readonly asset: IManifestEntry;
+    /** Sort by priority when picking up work, higher is earlier */
+    readonly priority?: number;
+}
+export interface AssetPublishNode extends WorkNodeCommon {
+    readonly type: 'asset-publish';
+    /** The asset manifest this asset resides in (artifact) */
+    readonly assetManifestArtifact: cxapi.AssetManifestArtifact;
+    /** The asset manifest this asset resides in */
+    readonly assetManifest: AssetManifest;
+    /** The stack this asset was defined in (used for environment settings) */
+    readonly parentStack: cxapi.CloudFormationStackArtifact;
+    /** The asset that needs to be published */
+    readonly asset: IManifestEntry;
+    /** Sort by priority when picking up work, higher is earlier */
+    readonly priority?: number;
+}

package/lib/api/work-graph/work-graph-types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentState = void 0;
+var DeploymentState;
+(function (DeploymentState) {
+    DeploymentState["PENDING"] = "pending";
+    DeploymentState["QUEUED"] = "queued";
+    DeploymentState["DEPLOYING"] = "deploying";
+    DeploymentState["COMPLETED"] = "completed";
+    DeploymentState["FAILED"] = "failed";
+    DeploymentState["SKIPPED"] = "skipped";
+})(DeploymentState || (exports.DeploymentState = DeploymentState = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29yay1ncmFwaC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIndvcmstZ3JhcGgtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0EsSUFBWSxlQU9YO0FBUEQsV0FBWSxlQUFlO0lBQ3pCLHNDQUFtQixDQUFBO0lBQ25CLG9DQUFpQixDQUFBO0lBQ2pCLDBDQUF1QixDQUFBO0lBQ3ZCLDBDQUF1QixDQUFBO0lBQ3ZCLG9DQUFpQixDQUFBO0lBQ2pCLHNDQUFtQixDQUFBO0FBQ3JCLENBQUMsRUFQVyxlQUFlLCtCQUFmLGVBQWUsUUFPMUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSAqIGFzIGN4YXBpIGZyb20gJ0Bhd3MtY2RrL2N4LWFwaSc7XG5pbXBvcnQgdHlwZSB7IEFzc2V0TWFuaWZlc3QsIElNYW5pZmVzdEVudHJ5IH0gZnJvbSAnY2RrLWFzc2V0cyc7XG5cbmV4cG9ydCBlbnVtIERlcGxveW1lbnRTdGF0ZSB7XG4gIFBFTkRJTkcgPSAncGVuZGluZycsXG4gIFFVRVVFRCA9ICdxdWV1ZWQnLFxuICBERVBMT1lJTkcgPSAnZGVwbG95aW5nJyxcbiAgQ09NUExFVEVEID0gJ2NvbXBsZXRlZCcsXG4gIEZBSUxFRCA9ICdmYWlsZWQnLFxuICBTS0lQUEVEID0gJ3NraXBwZWQnLFxufVxuXG5leHBvcnQgdHlwZSBXb3JrTm9kZSA9IFN0YWNrTm9kZSB8IEFzc2V0QnVpbGROb2RlIHwgQXNzZXRQdWJsaXNoTm9kZTtcblxuZXhwb3J0IGludGVyZmFjZSBXb3JrTm9kZUNvbW1vbiB7XG4gIHJlYWRvbmx5IGlkOiBzdHJpbmc7XG4gIHJlYWRvbmx5IGRlcGVuZGVuY2llczogU2V0PHN0cmluZz47XG4gIGRlcGxveW1lbnRTdGF0ZTogRGVwbG95bWVudFN0YXRlO1xuICAvKiogU29tZSByZWFkYWJsZSBpbmZvcm1hdGlvbiB0byBhdHRhY2ggdG8gdGhlIGlkLCB3aGljaCBtYXkgYmUgdW5yZWFkYWJsZSAqL1xuICByZWFkb25seSBub3RlPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFN0YWNrTm9kZSBleHRlbmRzIFdvcmtOb2RlQ29tbW9uIHtcbiAgcmVhZG9ubHkgdHlwZTogJ3N0YWNrJztcbiAgcmVhZG9ubHkgc3RhY2s6IGN4YXBpLkNsb3VkRm9ybWF0aW9uU3RhY2tBcnRpZmFjdDtcbiAgLyoqIFNvcnQgYnkgcHJpb3JpdHkgd2hlbiBwaWNraW5nIHVwIHdvcmssIGhpZ2hlciBpcyBlYXJsaWVyICovXG4gIHJlYWRvbmx5IHByaW9yaXR5PzogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEFzc2V0QnVpbGROb2RlIGV4dGVuZHMgV29ya05vZGVDb21tb24ge1xuICByZWFkb25seSB0eXBlOiAnYXNzZXQtYnVpbGQnO1xuICAvKiogVGhlIGFzc2V0IG1hbmlmZXN0IHRoaXMgYXNzZXQgcmVzaWRlcyBpbiAoYXJ0aWZhY3QpICovXG4gIHJlYWRvbmx5IGFzc2V0TWFuaWZlc3RBcnRpZmFjdDogY3hhcGkuQXNzZXRNYW5pZmVzdEFydGlmYWN0O1xuICAvKiogVGhlIGFzc2V0IG1hbmlmZXN0IHRoaXMgYXNzZXQgcmVzaWRlcyBpbiAqL1xuICByZWFkb25seSBhc3NldE1hbmlmZXN0OiBBc3NldE1hbmlmZXN0O1xuICAvKiogVGhlIHN0YWNrIHRoaXMgYXNzZXQgd2FzIGRlZmluZWQgaW4gKHVzZWQgZm9yIGVudmlyb25tZW50IHNldHRpbmdzKSAqL1xuICByZWFkb25seSBwYXJlbnRTdGFjazogY3hhcGkuQ2xvdWRGb3JtYXRpb25TdGFja0FydGlmYWN0O1xuICAvKiogVGhlIGFzc2V0IHRoYXQgbmVlZHMgdG8gYmUgYnVpbHQgKi9cbiAgcmVhZG9ubHkgYXNzZXQ6IElNYW5pZmVzdEVudHJ5O1xuICAvKiogU29ydCBieSBwcmlvcml0eSB3aGVuIHBpY2tpbmcgdXAgd29yaywgaGlnaGVyIGlzIGVhcmxpZXIgKi9cbiAgcmVhZG9ubHkgcHJpb3JpdHk/OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQXNzZXRQdWJsaXNoTm9kZSBleHRlbmRzIFdvcmtOb2RlQ29tbW9uIHtcbiAgcmVhZG9ubHkgdHlwZTogJ2Fzc2V0LXB1Ymxpc2gnO1xuICAvKiogVGhlIGFzc2V0IG1hbmlmZXN0IHRoaXMgYXNzZXQgcmVzaWRlcyBpbiAoYXJ0aWZhY3QpICovXG4gIHJlYWRvbmx5IGFzc2V0TWFuaWZlc3RBcnRpZmFjdDogY3hhcGkuQXNzZXRNYW5pZmVzdEFydGlmYWN0O1xuICAvKiogVGhlIGFzc2V0IG1hbmlmZXN0IHRoaXMgYXNzZXQgcmVzaWRlcyBpbiAqL1xuICByZWFkb25seSBhc3NldE1hbmlmZXN0OiBBc3NldE1hbmlmZXN0O1xuICAvKiogVGhlIHN0YWNrIHRoaXMgYXNzZXQgd2FzIGRlZmluZWQgaW4gKHVzZWQgZm9yIGVudmlyb25tZW50IHNldHRpbmdzKSAqL1xuICByZWFkb25seSBwYXJlbnRTdGFjazogY3hhcGkuQ2xvdWRGb3JtYXRpb25TdGFja0FydGlmYWN0O1xuICAvKiogVGhlIGFzc2V0IHRoYXQgbmVlZHMgdG8gYmUgcHVibGlzaGVkICovXG4gIHJlYWRvbmx5IGFzc2V0OiBJTWFuaWZlc3RFbnRyeTtcbiAgLyoqIFNvcnQgYnkgcHJpb3JpdHkgd2hlbiBwaWNraW5nIHVwIHdvcmssIGhpZ2hlciBpcyBlYXJsaWVyICovXG4gIHJlYWRvbmx5IHByaW9yaXR5PzogbnVtYmVyO1xufVxuIl19