@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/context.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.PROJECT_CONTEXT = exports.TRANSIENT_CONTEXT_KEY = void 0;
+const settings_1 = require("./settings");
+const toolkit_error_1 = require("../toolkit/toolkit-error");
+var settings_2 = require("./settings");
+Object.defineProperty(exports, "TRANSIENT_CONTEXT_KEY", { enumerable: true, get: function () { return settings_2.TRANSIENT_CONTEXT_KEY; } });
+exports.PROJECT_CONTEXT = 'cdk.context.json';
+/**
+ * Class that supports overlaying property bags
+ *
+ * Reads come from the first property bag that can has the given key,
+ * writes go to the first property bag that is not readonly. A write
+ * will remove the value from all property bags after the first
+ * writable one.
+ */
+class Context {
+    bags;
+    fileNames;
+    constructor(...bags) {
+        this.bags = bags.length > 0 ? bags.map((b) => b.bag) : [new settings_1.Settings()];
+        this.fileNames =
+            bags.length > 0 ? bags.map((b) => b.fileName) : ['default'];
+    }
+    get keys() {
+        return Object.keys(this.all);
+    }
+    has(key) {
+        return this.keys.indexOf(key) > -1;
+    }
+    get all() {
+        let ret = new settings_1.Settings();
+        // In reverse order so keys to the left overwrite keys to the right of them
+        for (const bag of [...this.bags].reverse()) {
+            ret = ret.merge(bag);
+        }
+        return ret.all;
+    }
+    get(key) {
+        for (const bag of this.bags) {
+            const v = bag.get([key]);
+            if (v !== undefined) {
+                return v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        for (const bag of this.bags) {
+            if (bag.readOnly) {
+                continue;
+            }
+            // All bags past the first one have the value erased
+            bag.set([key], value);
+            value = undefined;
+        }
+    }
+    unset(key) {
+        this.set(key, undefined);
+    }
+    clear() {
+        for (const key of this.keys) {
+            this.unset(key);
+        }
+    }
+    /**
+     * Save a specific context file
+     */
+    async save(fileName) {
+        const index = this.fileNames.indexOf(fileName);
+        // File not found, don't do anything in this scenario
+        if (index === -1) {
+            return this;
+        }
+        const bag = this.bags[index];
+        if (bag.readOnly) {
+            throw new toolkit_error_1.ToolkitError(`Context file ${fileName} is read only!`);
+        }
+        await bag.save(fileName);
+        return this;
+    }
+}
+exports.Context = Context;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/deployments/asset-manifest-builder.d.ts

@@ -0,0 +1,8 @@
+import * as cxschema from '@aws-cdk/cloud-assembly-schema';
+import { AssetManifest } from 'cdk-assets';
+export declare class AssetManifestBuilder {
+    private readonly manifest;
+    addFileAsset(id: string, source: cxschema.FileSource, destination: cxschema.FileDestination): void;
+    addDockerImageAsset(id: string, source: cxschema.DockerImageSource, destination: cxschema.DockerImageDestination): void;
+    toManifest(directory: string): AssetManifest;
+}

package/lib/api/deployments/asset-manifest-builder.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetManifestBuilder = void 0;
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+const cdk_assets_1 = require("cdk-assets");
+class AssetManifestBuilder {
+    manifest = {
+        version: cxschema.Manifest.version(),
+        files: {},
+        dockerImages: {},
+    };
+    addFileAsset(id, source, destination) {
+        this.manifest.files[id] = {
+            source,
+            destinations: {
+                current: destination,
+            },
+        };
+    }
+    addDockerImageAsset(id, source, destination) {
+        this.manifest.dockerImages[id] = {
+            source,
+            destinations: {
+                current: destination,
+            },
+        };
+    }
+    toManifest(directory) {
+        return new cdk_assets_1.AssetManifest(directory, this.manifest);
+    }
+}
+exports.AssetManifestBuilder = AssetManifestBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/deployments/asset-publishing.d.ts

@@ -0,0 +1,60 @@
+import { type Environment } from '@aws-cdk/cx-api';
+import type { ClientOptions, EventType, Account, AssetManifest, IAws, IECRClient, IPublishProgress, IPublishProgressListener, IS3Client, ISecretsManagerClient } from 'cdk-assets';
+import type { SdkProvider } from '../aws-auth/private';
+import type { IoHelper } from '../io/private';
+interface PublishAssetsOptions {
+    /**
+     * Whether to build/publish assets in parallel
+     *
+     * @default true To remain backward compatible.
+     */
+    readonly parallel?: boolean;
+    /**
+     * Whether cdk-assets is allowed to do cross account publishing.
+     */
+    readonly allowCrossAccount: boolean;
+}
+/**
+ * Use cdk-assets to publish all assets in the given manifest.
+ *
+ * @deprecated used in legacy deployments only, should be migrated at some point
+ */
+export declare function publishAssets(manifest: AssetManifest, sdk: SdkProvider, targetEnv: Environment, options: PublishAssetsOptions, ioHelper: IoHelper): Promise<void>;
+export declare class PublishingAws implements IAws {
+    /**
+     * The base SDK to work with
+     */
+    private readonly aws;
+    /**
+     * Environment where the stack we're deploying is going
+     */
+    private readonly targetEnv;
+    private sdkCache;
+    constructor(
+    /**
+     * The base SDK to work with
+     */
+    aws: SdkProvider, 
+    /**
+     * Environment where the stack we're deploying is going
+     */
+    targetEnv: Environment);
+    discoverPartition(): Promise<string>;
+    discoverDefaultRegion(): Promise<string>;
+    discoverCurrentAccount(): Promise<Account>;
+    discoverTargetAccount(options: ClientOptions): Promise<Account>;
+    s3Client(options: ClientOptions): Promise<IS3Client>;
+    ecrClient(options: ClientOptions): Promise<IECRClient>;
+    secretsManagerClient(options: ClientOptions): Promise<ISecretsManagerClient>;
+    /**
+     * Get an SDK appropriate for the given client options
+     */
+    private sdk;
+}
+export declare abstract class BasePublishProgressListener implements IPublishProgressListener {
+    protected readonly ioHelper: IoHelper;
+    constructor(ioHelper: IoHelper);
+    protected abstract getMessage(type: EventType, event: IPublishProgress): string;
+    onPublishEvent(type: EventType, event: IPublishProgress): void;
+}
+export {};

package/lib/api/deployments/asset-publishing.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePublishProgressListener = exports.PublishingAws = void 0;
+exports.publishAssets = publishAssets;
+const cx_api_1 = require("@aws-cdk/cx-api");
+const cdk_assets_1 = require("cdk-assets");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const private_1 = require("../io/private");
+const plugin_1 = require("../plugin");
+/**
+ * Use cdk-assets to publish all assets in the given manifest.
+ *
+ * @deprecated used in legacy deployments only, should be migrated at some point
+ */
+async function publishAssets(manifest, sdk, targetEnv, options, ioHelper) {
+    // This shouldn't really happen (it's a programming error), but we don't have
+    // the types here to guide us. Do an runtime validation to be super super sure.
+    if (targetEnv.account === undefined ||
+        targetEnv.account === cx_api_1.UNKNOWN_ACCOUNT ||
+        targetEnv.region === undefined ||
+        targetEnv.account === cx_api_1.UNKNOWN_REGION) {
+        throw new toolkit_error_1.ToolkitError(`Asset publishing requires resolved account and region, got ${JSON.stringify(targetEnv)}`);
+    }
+    const publisher = new cdk_assets_1.AssetPublishing(manifest, {
+        aws: new PublishingAws(sdk, targetEnv),
+        progressListener: new PublishingProgressListener(ioHelper),
+        throwOnError: false,
+        publishInParallel: options.parallel ?? true,
+        buildAssets: true,
+        publishAssets: true,
+        quiet: false,
+    });
+    await publisher.publish({ allowCrossAccount: options.allowCrossAccount });
+    if (publisher.hasFailures) {
+        throw new toolkit_error_1.ToolkitError('Failed to publish one or more assets. See the error messages above for more information.');
+    }
+}
+class PublishingAws {
+    aws;
+    targetEnv;
+    sdkCache = new Map();
+    constructor(
+    /**
+     * The base SDK to work with
+     */
+    aws, 
+    /**
+     * Environment where the stack we're deploying is going
+     */
+    targetEnv) {
+        this.aws = aws;
+        this.targetEnv = targetEnv;
+    }
+    async discoverPartition() {
+        return (await this.aws.baseCredentialsPartition(this.targetEnv, plugin_1.Mode.ForWriting)) ?? 'aws';
+    }
+    async discoverDefaultRegion() {
+        return this.targetEnv.region;
+    }
+    async discoverCurrentAccount() {
+        const account = await this.aws.defaultAccount();
+        return (account ?? {
+            accountId: '<unknown account>',
+            partition: 'aws',
+        });
+    }
+    async discoverTargetAccount(options) {
+        return (await this.sdk(options)).currentAccount();
+    }
+    async s3Client(options) {
+        return (await this.sdk(options)).s3();
+    }
+    async ecrClient(options) {
+        return (await this.sdk(options)).ecr();
+    }
+    async secretsManagerClient(options) {
+        return (await this.sdk(options)).secretsManager();
+    }
+    /**
+     * Get an SDK appropriate for the given client options
+     */
+    async sdk(options) {
+        const env = {
+            ...this.targetEnv,
+            region: options.region ?? this.targetEnv.region, // Default: same region as the stack
+        };
+        const cacheKeyMap = {
+            env, // region, name, account
+            assumeRuleArn: options.assumeRoleArn,
+            assumeRoleExternalId: options.assumeRoleExternalId,
+            quiet: options.quiet,
+        };
+        if (options.assumeRoleAdditionalOptions) {
+            cacheKeyMap.assumeRoleAdditionalOptions = options.assumeRoleAdditionalOptions;
+        }
+        const cacheKey = JSON.stringify(cacheKeyMap);
+        const maybeSdk = this.sdkCache.get(cacheKey);
+        if (maybeSdk) {
+            return maybeSdk;
+        }
+        const sdk = (await this.aws.forEnvironment(env, plugin_1.Mode.ForWriting, {
+            assumeRoleArn: options.assumeRoleArn,
+            assumeRoleExternalId: options.assumeRoleExternalId,
+            assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,
+        }, options.quiet)).sdk;
+        this.sdkCache.set(cacheKey, sdk);
+        return sdk;
+    }
+}
+exports.PublishingAws = PublishingAws;
+const EVENT_TO_MSG_MAKER = {
+    build: private_1.IO.DEFAULT_TOOLKIT_DEBUG,
+    cached: private_1.IO.DEFAULT_TOOLKIT_DEBUG,
+    check: private_1.IO.DEFAULT_TOOLKIT_DEBUG,
+    debug: private_1.IO.DEFAULT_TOOLKIT_DEBUG,
+    fail: private_1.IO.DEFAULT_TOOLKIT_ERROR,
+    found: private_1.IO.DEFAULT_TOOLKIT_DEBUG,
+    start: private_1.IO.DEFAULT_TOOLKIT_INFO,
+    success: private_1.IO.DEFAULT_TOOLKIT_INFO,
+    upload: private_1.IO.DEFAULT_TOOLKIT_DEBUG,
+    shell_open: private_1.IO.DEFAULT_TOOLKIT_DEBUG,
+    shell_stderr: false,
+    shell_stdout: false,
+    shell_close: false,
+};
+class BasePublishProgressListener {
+    ioHelper;
+    constructor(ioHelper) {
+        this.ioHelper = ioHelper;
+    }
+    onPublishEvent(type, event) {
+        const maker = EVENT_TO_MSG_MAKER[type];
+        if (maker) {
+            void this.ioHelper.notify(maker.msg(this.getMessage(type, event)));
+        }
+    }
+}
+exports.BasePublishProgressListener = BasePublishProgressListener;
+class PublishingProgressListener extends BasePublishProgressListener {
+    getMessage(type, event) {
+        return `[${event.percentComplete}%] ${type}: ${event.message}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-publishing.js","sourceRoot":"","sources":["asset-publishing.ts"],"names":[],"mappings":"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","sourcesContent":["import { type Environment, UNKNOWN_ACCOUNT, UNKNOWN_REGION } from '@aws-cdk/cx-api';\nimport type {\n  ClientOptions,\n  EventType,\n  Account,\n  AssetManifest,\n  IAws,\n  IECRClient,\n  IPublishProgress,\n  IPublishProgressListener,\n  IS3Client,\n  ISecretsManagerClient,\n} from 'cdk-assets';\nimport {\n  AssetPublishing,\n} from 'cdk-assets';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport type { SDK, SdkProvider } from '../aws-auth/private';\nimport type { IoMessageMaker, IoHelper } from '../io/private';\nimport { IO } from '../io/private';\nimport { Mode } from '../plugin';\n\ninterface PublishAssetsOptions {\n  /**\n   * Whether to build/publish assets in parallel\n   *\n   * @default true To remain backward compatible.\n   */\n  readonly parallel?: boolean;\n\n  /**\n   * Whether cdk-assets is allowed to do cross account publishing.\n   */\n  readonly allowCrossAccount: boolean;\n}\n\n/**\n * Use cdk-assets to publish all assets in the given manifest.\n *\n * @deprecated used in legacy deployments only, should be migrated at some point\n */\nexport async function publishAssets(\n  manifest: AssetManifest,\n  sdk: SdkProvider,\n  targetEnv: Environment,\n  options: PublishAssetsOptions,\n  ioHelper: IoHelper,\n) {\n  // This shouldn't really happen (it's a programming error), but we don't have\n  // the types here to guide us. Do an runtime validation to be super super sure.\n  if (\n    targetEnv.account === undefined ||\n    targetEnv.account === UNKNOWN_ACCOUNT ||\n    targetEnv.region === undefined ||\n    targetEnv.account === UNKNOWN_REGION\n  ) {\n    throw new ToolkitError(`Asset publishing requires resolved account and region, got ${JSON.stringify(targetEnv)}`);\n  }\n\n  const publisher = new AssetPublishing(manifest, {\n    aws: new PublishingAws(sdk, targetEnv),\n    progressListener: new PublishingProgressListener(ioHelper),\n    throwOnError: false,\n    publishInParallel: options.parallel ?? true,\n    buildAssets: true,\n    publishAssets: true,\n    quiet: false,\n  });\n  await publisher.publish({ allowCrossAccount: options.allowCrossAccount });\n  if (publisher.hasFailures) {\n    throw new ToolkitError('Failed to publish one or more assets. See the error messages above for more information.');\n  }\n}\n\nexport class PublishingAws implements IAws {\n  private sdkCache: Map<String, SDK> = new Map();\n\n  constructor(\n    /**\n     * The base SDK to work with\n     */\n    private readonly aws: SdkProvider,\n\n    /**\n     * Environment where the stack we're deploying is going\n     */\n    private readonly targetEnv: Environment,\n  ) {\n  }\n\n  public async discoverPartition(): Promise<string> {\n    return (await this.aws.baseCredentialsPartition(this.targetEnv, Mode.ForWriting)) ?? 'aws';\n  }\n\n  public async discoverDefaultRegion(): Promise<string> {\n    return this.targetEnv.region;\n  }\n\n  public async discoverCurrentAccount(): Promise<Account> {\n    const account = await this.aws.defaultAccount();\n    return (\n      account ?? {\n        accountId: '<unknown account>',\n        partition: 'aws',\n      }\n    );\n  }\n\n  public async discoverTargetAccount(options: ClientOptions): Promise<Account> {\n    return (await this.sdk(options)).currentAccount();\n  }\n\n  public async s3Client(options: ClientOptions): Promise<IS3Client> {\n    return (await this.sdk(options)).s3();\n  }\n\n  public async ecrClient(options: ClientOptions): Promise<IECRClient> {\n    return (await this.sdk(options)).ecr();\n  }\n\n  public async secretsManagerClient(options: ClientOptions): Promise<ISecretsManagerClient> {\n    return (await this.sdk(options)).secretsManager();\n  }\n\n  /**\n   * Get an SDK appropriate for the given client options\n   */\n  private async sdk(options: ClientOptions): Promise<SDK> {\n    const env = {\n      ...this.targetEnv,\n      region: options.region ?? this.targetEnv.region, // Default: same region as the stack\n    };\n\n    const cacheKeyMap: any = {\n      env, // region, name, account\n      assumeRuleArn: options.assumeRoleArn,\n      assumeRoleExternalId: options.assumeRoleExternalId,\n      quiet: options.quiet,\n    };\n\n    if (options.assumeRoleAdditionalOptions) {\n      cacheKeyMap.assumeRoleAdditionalOptions = options.assumeRoleAdditionalOptions;\n    }\n\n    const cacheKey = JSON.stringify(cacheKeyMap);\n\n    const maybeSdk = this.sdkCache.get(cacheKey);\n    if (maybeSdk) {\n      return maybeSdk;\n    }\n\n    const sdk = (\n      await this.aws.forEnvironment(\n        env,\n        Mode.ForWriting,\n        {\n          assumeRoleArn: options.assumeRoleArn,\n          assumeRoleExternalId: options.assumeRoleExternalId,\n          assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,\n        },\n        options.quiet,\n      )\n    ).sdk;\n    this.sdkCache.set(cacheKey, sdk);\n\n    return sdk;\n  }\n}\n\nconst EVENT_TO_MSG_MAKER: Record<EventType, IoMessageMaker<any> | false> = {\n  build: IO.DEFAULT_TOOLKIT_DEBUG,\n  cached: IO.DEFAULT_TOOLKIT_DEBUG,\n  check: IO.DEFAULT_TOOLKIT_DEBUG,\n  debug: IO.DEFAULT_TOOLKIT_DEBUG,\n  fail: IO.DEFAULT_TOOLKIT_ERROR,\n  found: IO.DEFAULT_TOOLKIT_DEBUG,\n  start: IO.DEFAULT_TOOLKIT_INFO,\n  success: IO.DEFAULT_TOOLKIT_INFO,\n  upload: IO.DEFAULT_TOOLKIT_DEBUG,\n  shell_open: IO.DEFAULT_TOOLKIT_DEBUG,\n  shell_stderr: false,\n  shell_stdout: false,\n  shell_close: false,\n};\n\nexport abstract class BasePublishProgressListener implements IPublishProgressListener {\n  protected readonly ioHelper: IoHelper;\n\n  constructor(ioHelper: IoHelper) {\n    this.ioHelper = ioHelper;\n  }\n\n  protected abstract getMessage(type: EventType, event: IPublishProgress): string;\n\n  public onPublishEvent(type: EventType, event: IPublishProgress): void {\n    const maker = EVENT_TO_MSG_MAKER[type];\n    if (maker) {\n      void this.ioHelper.notify(maker.msg(this.getMessage(type, event)));\n    }\n  }\n}\n\nclass PublishingProgressListener extends BasePublishProgressListener {\n  protected getMessage(type: EventType, event: IPublishProgress): string {\n    return `[${event.percentComplete}%] ${type}: ${event.message}`;\n  }\n}\n"]}

package/lib/api/deployments/assets.d.ts

@@ -0,0 +1,11 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import type { AssetManifestBuilder } from './asset-manifest-builder';
+import type { EnvironmentResources } from '../environment';
+import { type IoHelper } from '../io/private';
+/**
+ * Take the metadata assets from the given stack and add them to the given asset manifest
+ *
+ * Returns the CloudFormation parameters that need to be sent to the template to
+ * pass Asset coordinates.
+ */
+export declare function addMetadataAssetsToManifest(ioHelper: IoHelper, stack: cxapi.CloudFormationStackArtifact, assetManifest: AssetManifestBuilder, envResources: EnvironmentResources, reuse?: string[]): Promise<Record<string, string>>;

package/lib/api/deployments/assets.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMetadataAssetsToManifest = addMetadataAssetsToManifest;
+const path = require("path");
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+const cxapi = require("@aws-cdk/cx-api");
+const chalk = require("chalk");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const private_1 = require("../io/private");
+/**
+ * Take the metadata assets from the given stack and add them to the given asset manifest
+ *
+ * Returns the CloudFormation parameters that need to be sent to the template to
+ * pass Asset coordinates.
+ */
+async function addMetadataAssetsToManifest(ioHelper, stack, assetManifest, envResources, reuse) {
+    reuse = reuse || [];
+    const assets = stack.assets;
+    if (assets.length === 0) {
+        return {};
+    }
+    const toolkitInfo = await envResources.lookupToolkit();
+    if (!toolkitInfo.found) {
+        // eslint-disable-next-line @stylistic/max-len
+        throw new toolkit_error_1.ToolkitError(`This stack uses assets, so the toolkit stack must be deployed to the environment (Run "${chalk.blue('cdk bootstrap ' + stack.environment.name)}")`);
+    }
+    const params = {};
+    for (const asset of assets) {
+        // FIXME: Should have excluded by construct path here instead of by unique ID, preferably using
+        // minimatch so we can support globs. Maybe take up during artifact refactoring.
+        const reuseAsset = reuse.indexOf(asset.id) > -1;
+        if (reuseAsset) {
+            await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));
+            continue;
+        }
+        await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));
+        if (!stack.assembly) {
+            throw new toolkit_error_1.ToolkitError('Unexpected: stack assembly is required in order to find assets in assembly directory');
+        }
+        Object.assign(params, await prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo));
+    }
+    return params;
+}
+// eslint-disable-next-line @stylistic/max-len
+async function prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo) {
+    switch (asset.packaging) {
+        case 'zip':
+        case 'file':
+            return prepareFileAsset(ioHelper, asset, assetManifest, toolkitInfo, asset.packaging === 'zip' ? cxschema.FileAssetPackaging.ZIP_DIRECTORY : cxschema.FileAssetPackaging.FILE);
+        case 'container-image':
+            return prepareDockerImageAsset(asset, assetManifest, envResources);
+        default:
+            // eslint-disable-next-line @stylistic/max-len
+            throw new toolkit_error_1.ToolkitError(`Unsupported packaging type: ${asset.packaging}. You might need to upgrade your aws-cdk toolkit to support this asset type.`);
+    }
+}
+async function prepareFileAsset(ioHelper, asset, assetManifest, toolkitInfo, packaging) {
+    const extension = packaging === cxschema.FileAssetPackaging.ZIP_DIRECTORY ? '.zip' : path.extname(asset.path);
+    const baseName = `${asset.sourceHash}${extension}`;
+    // Simplify key: assets/abcdef/abcdef.zip is kinda silly and unnecessary, so if they're the same just pick one component.
+    const s3Prefix = asset.id === asset.sourceHash ? 'assets/' : `assets/${asset.id}/`;
+    const key = `${s3Prefix}${baseName}`;
+    const s3url = `s3://${toolkitInfo.bucketName}/${key}`;
+    await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing asset ${asset.path} at ${s3url}`));
+    assetManifest.addFileAsset(asset.sourceHash, {
+        path: asset.path,
+        packaging,
+    }, {
+        bucketName: toolkitInfo.bucketName,
+        objectKey: key,
+    });
+    return {
+        [asset.s3BucketParameter]: toolkitInfo.bucketName,
+        [asset.s3KeyParameter]: `${s3Prefix}${cxapi.ASSET_PREFIX_SEPARATOR}${baseName}`,
+        [asset.artifactHashParameter]: asset.sourceHash,
+    };
+}
+async function prepareDockerImageAsset(asset, assetManifest, envResources) {
+    // Pre-1.21.0, repositoryName can be specified by the user or can be left out, in which case we make
+    // a per-asset repository which will get adopted and cleaned up along with the stack.
+    // Post-1.21.0, repositoryName will always be specified and it will be a shared repository between
+    // all assets, and asset will have imageTag specified as well. Validate the combination.
+    if (!asset.imageNameParameter && (!asset.repositoryName || !asset.imageTag)) {
+        throw new toolkit_error_1.ToolkitError('Invalid Docker image asset configuration: "repositoryName" and "imageTag" are required when "imageNameParameter" is left out');
+    }
+    const repositoryName = asset.repositoryName ?? 'cdk/' + asset.id.replace(/[:/]/g, '-').toLowerCase();
+    // Make sure the repository exists, since the 'cdk-assets' tool will not create it for us.
+    const { repositoryUri } = await envResources.prepareEcrRepository(repositoryName);
+    const imageTag = asset.imageTag ?? asset.sourceHash;
+    assetManifest.addDockerImageAsset(asset.sourceHash, {
+        directory: asset.path,
+        dockerBuildArgs: asset.buildArgs,
+        dockerBuildSsh: asset.buildSsh,
+        dockerBuildTarget: asset.target,
+        dockerFile: asset.file,
+        networkMode: asset.networkMode,
+        platform: asset.platform,
+        dockerOutputs: asset.outputs,
+    }, {
+        repositoryName,
+        imageTag,
+    });
+    if (!asset.imageNameParameter) {
+        return {};
+    }
+    return { [asset.imageNameParameter]: `${repositoryUri}:${imageTag}` };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assets.js","sourceRoot":"","sources":["assets.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport type { AssetManifestBuilder } from './asset-manifest-builder';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport type { EnvironmentResources } from '../environment';\nimport { IO, type IoHelper } from '../io/private';\nimport type { ToolkitInfo } from '../toolkit-info';\n\n/**\n * Take the metadata assets from the given stack and add them to the given asset manifest\n *\n * Returns the CloudFormation parameters that need to be sent to the template to\n * pass Asset coordinates.\n */\nexport async function addMetadataAssetsToManifest(\n  ioHelper: IoHelper,\n  stack: cxapi.CloudFormationStackArtifact,\n  assetManifest: AssetManifestBuilder,\n  envResources: EnvironmentResources,\n  reuse?: string[],\n): Promise<Record<string, string>> {\n  reuse = reuse || [];\n  const assets = stack.assets;\n\n  if (assets.length === 0) {\n    return {};\n  }\n\n  const toolkitInfo = await envResources.lookupToolkit();\n  if (!toolkitInfo.found) {\n    // eslint-disable-next-line @stylistic/max-len\n    throw new ToolkitError(`This stack uses assets, so the toolkit stack must be deployed to the environment (Run \"${chalk.blue('cdk bootstrap ' + stack.environment!.name)}\")`);\n  }\n\n  const params: Record<string, string> = {};\n\n  for (const asset of assets) {\n    // FIXME: Should have excluded by construct path here instead of by unique ID, preferably using\n    // minimatch so we can support globs. Maybe take up during artifact refactoring.\n    const reuseAsset = reuse.indexOf(asset.id) > -1;\n\n    if (reuseAsset) {\n      await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));\n      continue;\n    }\n\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));\n    if (!stack.assembly) {\n      throw new ToolkitError('Unexpected: stack assembly is required in order to find assets in assembly directory');\n    }\n\n    Object.assign(params, await prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo));\n  }\n\n  return params;\n}\n\n// eslint-disable-next-line @stylistic/max-len\nasync function prepareAsset(\n  ioHelper: IoHelper,\n  asset: cxschema.AssetMetadataEntry,\n  assetManifest: AssetManifestBuilder,\n  envResources: EnvironmentResources,\n  toolkitInfo: ToolkitInfo,\n): Promise<Record<string, string>> {\n  switch (asset.packaging) {\n    case 'zip':\n    case 'file':\n      return prepareFileAsset(\n        ioHelper,\n        asset,\n        assetManifest,\n        toolkitInfo,\n        asset.packaging === 'zip' ? cxschema.FileAssetPackaging.ZIP_DIRECTORY : cxschema.FileAssetPackaging.FILE);\n    case 'container-image':\n      return prepareDockerImageAsset(asset, assetManifest, envResources);\n    default:\n      // eslint-disable-next-line @stylistic/max-len\n      throw new ToolkitError(`Unsupported packaging type: ${(asset as any).packaging}. You might need to upgrade your aws-cdk toolkit to support this asset type.`);\n  }\n}\n\nasync function prepareFileAsset(\n  ioHelper: IoHelper,\n  asset: cxschema.FileAssetMetadataEntry,\n  assetManifest: AssetManifestBuilder,\n  toolkitInfo: ToolkitInfo,\n  packaging: cxschema.FileAssetPackaging,\n): Promise<Record<string, string>> {\n  const extension = packaging === cxschema.FileAssetPackaging.ZIP_DIRECTORY ? '.zip' : path.extname(asset.path);\n  const baseName = `${asset.sourceHash}${extension}`;\n  // Simplify key: assets/abcdef/abcdef.zip is kinda silly and unnecessary, so if they're the same just pick one component.\n  const s3Prefix = asset.id === asset.sourceHash ? 'assets/' : `assets/${asset.id}/`;\n  const key = `${s3Prefix}${baseName}`;\n  const s3url = `s3://${toolkitInfo.bucketName}/${key}`;\n\n  await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing asset ${asset.path} at ${s3url}`));\n\n  assetManifest.addFileAsset(asset.sourceHash, {\n    path: asset.path,\n    packaging,\n  }, {\n    bucketName: toolkitInfo.bucketName,\n    objectKey: key,\n  });\n\n  return {\n    [asset.s3BucketParameter]: toolkitInfo.bucketName,\n    [asset.s3KeyParameter]: `${s3Prefix}${cxapi.ASSET_PREFIX_SEPARATOR}${baseName}`,\n    [asset.artifactHashParameter]: asset.sourceHash,\n  };\n}\n\nasync function prepareDockerImageAsset(\n  asset: cxschema.ContainerImageAssetMetadataEntry,\n  assetManifest: AssetManifestBuilder,\n  envResources: EnvironmentResources): Promise<Record<string, string>> {\n  // Pre-1.21.0, repositoryName can be specified by the user or can be left out, in which case we make\n  // a per-asset repository which will get adopted and cleaned up along with the stack.\n  // Post-1.21.0, repositoryName will always be specified and it will be a shared repository between\n  // all assets, and asset will have imageTag specified as well. Validate the combination.\n  if (!asset.imageNameParameter && (!asset.repositoryName || !asset.imageTag)) {\n    throw new ToolkitError('Invalid Docker image asset configuration: \"repositoryName\" and \"imageTag\" are required when \"imageNameParameter\" is left out');\n  }\n\n  const repositoryName = asset.repositoryName ?? 'cdk/' + asset.id.replace(/[:/]/g, '-').toLowerCase();\n\n  // Make sure the repository exists, since the 'cdk-assets' tool will not create it for us.\n  const { repositoryUri } = await envResources.prepareEcrRepository(repositoryName);\n  const imageTag = asset.imageTag ?? asset.sourceHash;\n\n  assetManifest.addDockerImageAsset(asset.sourceHash, {\n    directory: asset.path,\n    dockerBuildArgs: asset.buildArgs,\n    dockerBuildSsh: asset.buildSsh,\n    dockerBuildTarget: asset.target,\n    dockerFile: asset.file,\n    networkMode: asset.networkMode,\n    platform: asset.platform,\n    dockerOutputs: asset.outputs,\n  }, {\n    repositoryName,\n    imageTag,\n  });\n\n  if (!asset.imageNameParameter) {\n    return {};\n  }\n  return { [asset.imageNameParameter]: `${repositoryUri}:${imageTag}` };\n}\n"]}