aws-cdk 0.0.0

package/lib/api/bootstrap/deploy-bootstrap.d.ts

@@ -0,0 +1,37 @@
+import { Environment } from '@aws-cdk/cx-api';
+import { BootstrapEnvironmentOptions } from './bootstrap-props';
+import type { SDK, SdkProvider } from '../aws-auth';
+import { SuccessfulDeployStackResult } from '../deployments';
+import { ToolkitInfo } from '../toolkit-info';
+/**
+ * A class to hold state around stack bootstrapping
+ *
+ * This class exists so we can break bootstrapping into 2 phases:
+ *
+ * ```ts
+ * const current = BootstrapStack.lookup(...);
+ * // ...
+ * current.update(newTemplate, ...);
+ * ```
+ *
+ * And do something in between the two phases (such as look at the
+ * current bootstrap stack and doing something intelligent).
+ */
+export declare class BootstrapStack {
+    private readonly sdkProvider;
+    private readonly sdk;
+    private readonly resolvedEnvironment;
+    private readonly toolkitStackName;
+    private readonly currentToolkitInfo;
+    static lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName?: string): Promise<BootstrapStack>;
+    protected constructor(sdkProvider: SdkProvider, sdk: SDK, resolvedEnvironment: Environment, toolkitStackName: string, currentToolkitInfo: ToolkitInfo);
+    get parameters(): Record<string, string>;
+    get terminationProtection(): boolean | undefined;
+    partition(): Promise<string>;
+    /**
+     * Perform the actual deployment of a bootstrap stack, given a template and some parameters
+     */
+    update(template: any, parameters: Record<string, string | undefined>, options: Omit<BootstrapEnvironmentOptions, 'parameters'>): Promise<SuccessfulDeployStackResult>;
+}
+export declare function bootstrapVersionFromTemplate(template: any): number;
+export declare function bootstrapVariantFromTemplate(template: any): string;

package/lib/api/bootstrap/deploy-bootstrap.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootstrapStack = void 0;
+exports.bootstrapVersionFromTemplate = bootstrapVersionFromTemplate;
+exports.bootstrapVariantFromTemplate = bootstrapVariantFromTemplate;
+const os = require("os");
+const path = require("path");
+const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+const cx_api_1 = require("@aws-cdk/cx-api");
+const fs = require("fs-extra");
+const bootstrap_props_1 = require("./bootstrap-props");
+const logging = require("../../logging");
+const deployments_1 = require("../deployments");
+const deploy_stack_1 = require("../deployments/deploy-stack");
+const environment_resources_1 = require("../environment-resources");
+const mode_1 = require("../plugin/mode");
+const toolkit_info_1 = require("../toolkit-info");
+/**
+ * A class to hold state around stack bootstrapping
+ *
+ * This class exists so we can break bootstrapping into 2 phases:
+ *
+ * ```ts
+ * const current = BootstrapStack.lookup(...);
+ * // ...
+ * current.update(newTemplate, ...);
+ * ```
+ *
+ * And do something in between the two phases (such as look at the
+ * current bootstrap stack and doing something intelligent).
+ */
+class BootstrapStack {
+    static async lookup(sdkProvider, environment, toolkitStackName) {
+        toolkitStackName = toolkitStackName !== null && toolkitStackName !== void 0 ? toolkitStackName : toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME;
+        const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);
+        const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, mode_1.Mode.ForWriting)).sdk;
+        const currentToolkitInfo = await toolkit_info_1.ToolkitInfo.lookup(resolvedEnvironment, sdk, toolkitStackName);
+        return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo);
+    }
+    constructor(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo) {
+        this.sdkProvider = sdkProvider;
+        this.sdk = sdk;
+        this.resolvedEnvironment = resolvedEnvironment;
+        this.toolkitStackName = toolkitStackName;
+        this.currentToolkitInfo = currentToolkitInfo;
+    }
+    get parameters() {
+        return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {};
+    }
+    get terminationProtection() {
+        return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : undefined;
+    }
+    async partition() {
+        return (await this.sdk.currentAccount()).partition;
+    }
+    /**
+     * Perform the actual deployment of a bootstrap stack, given a template and some parameters
+     */
+    async update(template, parameters, options) {
+        var _a, _b;
+        if (this.currentToolkitInfo.found && !options.force) {
+            // Safety checks
+            const abortResponse = {
+                type: 'did-deploy-stack',
+                noOp: true,
+                outputs: {},
+                stackArn: this.currentToolkitInfo.bootstrapStack.stackId,
+            };
+            // Validate that the bootstrap stack we're trying to replace is from the same variant as the one we're trying to deploy
+            const currentVariant = this.currentToolkitInfo.variant;
+            const newVariant = bootstrapVariantFromTemplate(template);
+            if (currentVariant !== newVariant) {
+                logging.warning(`Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`);
+                return abortResponse;
+            }
+            // Validate that we're not downgrading the bootstrap stack
+            const newVersion = bootstrapVersionFromTemplate(template);
+            const currentVersion = this.currentToolkitInfo.version;
+            if (newVersion < currentVersion) {
+                logging.warning(`Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`);
+                if (newVersion === 0) {
+                    // A downgrade with 0 as target version means we probably have a new-style bootstrap in the account,
+                    // and an old-style bootstrap as current target, which means the user probably forgot to put this flag in.
+                    logging.warning("(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)");
+                }
+                return abortResponse;
+            }
+        }
+        const outdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-bootstrap'));
+        const builder = new cx_api_1.CloudAssemblyBuilder(outdir);
+        const templateFile = `${this.toolkitStackName}.template.json`;
+        await fs.writeJson(path.join(builder.outdir, templateFile), template, {
+            spaces: 2,
+        });
+        builder.addArtifact(this.toolkitStackName, {
+            type: cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK,
+            environment: cx_api_1.EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),
+            properties: {
+                templateFile,
+                terminationProtection: (_a = options.terminationProtection) !== null && _a !== void 0 ? _a : false,
+            },
+        });
+        const assembly = builder.buildAssembly();
+        const ret = await (0, deploy_stack_1.deployStack)({
+            stack: assembly.getStackByName(this.toolkitStackName),
+            resolvedEnvironment: this.resolvedEnvironment,
+            sdk: this.sdk,
+            sdkProvider: this.sdkProvider,
+            force: options.force,
+            roleArn: options.roleArn,
+            tags: options.tags,
+            deploymentMethod: { method: 'change-set', execute: options.execute },
+            parameters,
+            usePreviousParameters: (_b = options.usePreviousParameters) !== null && _b !== void 0 ? _b : true,
+            // Obviously we can't need a bootstrap stack to deploy a bootstrap stack
+            envResources: new environment_resources_1.NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk),
+        });
+        (0, deployments_1.assertIsSuccessfulDeployStackResult)(ret);
+        return ret;
+    }
+}
+exports.BootstrapStack = BootstrapStack;
+function bootstrapVersionFromTemplate(template) {
+    var _a, _b, _c, _d, _e;
+    const versionSources = [
+        (_b = (_a = template.Outputs) === null || _a === void 0 ? void 0 : _a[bootstrap_props_1.BOOTSTRAP_VERSION_OUTPUT]) === null || _b === void 0 ? void 0 : _b.Value,
+        (_e = (_d = (_c = template.Resources) === null || _c === void 0 ? void 0 : _c[bootstrap_props_1.BOOTSTRAP_VERSION_RESOURCE]) === null || _d === void 0 ? void 0 : _d.Properties) === null || _e === void 0 ? void 0 : _e.Value,
+    ];
+    for (const vs of versionSources) {
+        if (typeof vs === 'number') {
+            return vs;
+        }
+        if (typeof vs === 'string' && !isNaN(parseInt(vs, 10))) {
+            return parseInt(vs, 10);
+        }
+    }
+    return 0;
+}
+function bootstrapVariantFromTemplate(template) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = template.Parameters) === null || _a === void 0 ? void 0 : _a[bootstrap_props_1.BOOTSTRAP_VARIANT_PARAMETER]) === null || _b === void 0 ? void 0 : _b.Default) !== null && _c !== void 0 ? _c : bootstrap_props_1.DEFAULT_BOOTSTRAP_VARIANT;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-bootstrap.js","sourceRoot":"","sources":["deploy-bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport * as path from 'path';\nimport { ArtifactType } from '@aws-cdk/cloud-assembly-schema';\nimport { CloudAssemblyBuilder, Environment, EnvironmentUtils } from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport {\n  BOOTSTRAP_VARIANT_PARAMETER,\n  BOOTSTRAP_VERSION_OUTPUT,\n  BOOTSTRAP_VERSION_RESOURCE,\n  BootstrapEnvironmentOptions,\n  DEFAULT_BOOTSTRAP_VARIANT,\n} from './bootstrap-props';\nimport * as logging from '../../logging';\nimport type { SDK, SdkProvider } from '../aws-auth';\nimport { assertIsSuccessfulDeployStackResult, SuccessfulDeployStackResult } from '../deployments';\nimport { deployStack } from '../deployments/deploy-stack';\nimport { NoBootstrapStackEnvironmentResources } from '../environment-resources';\nimport { Mode } from '../plugin/mode';\nimport { DEFAULT_TOOLKIT_STACK_NAME, ToolkitInfo } from '../toolkit-info';\n\n/**\n * A class to hold state around stack bootstrapping\n *\n * This class exists so we can break bootstrapping into 2 phases:\n *\n * ```ts\n * const current = BootstrapStack.lookup(...);\n * // ...\n * current.update(newTemplate, ...);\n * ```\n *\n * And do something in between the two phases (such as look at the\n * current bootstrap stack and doing something intelligent).\n */\nexport class BootstrapStack {\n  public static async lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName?: string) {\n    toolkitStackName = toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;\n\n    const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);\n    const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, Mode.ForWriting)).sdk;\n\n    const currentToolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, sdk, toolkitStackName);\n\n    return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo);\n  }\n\n  protected constructor(\n    private readonly sdkProvider: SdkProvider,\n    private readonly sdk: SDK,\n    private readonly resolvedEnvironment: Environment,\n    private readonly toolkitStackName: string,\n    private readonly currentToolkitInfo: ToolkitInfo,\n  ) {}\n\n  public get parameters(): Record<string, string> {\n    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {};\n  }\n\n  public get terminationProtection() {\n    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : undefined;\n  }\n\n  public async partition(): Promise<string> {\n    return (await this.sdk.currentAccount()).partition;\n  }\n\n  /**\n   * Perform the actual deployment of a bootstrap stack, given a template and some parameters\n   */\n  public async update(\n    template: any,\n    parameters: Record<string, string | undefined>,\n    options: Omit<BootstrapEnvironmentOptions, 'parameters'>,\n  ): Promise<SuccessfulDeployStackResult> {\n    if (this.currentToolkitInfo.found && !options.force) {\n      // Safety checks\n      const abortResponse = {\n        type: 'did-deploy-stack',\n        noOp: true,\n        outputs: {},\n        stackArn: this.currentToolkitInfo.bootstrapStack.stackId,\n      } satisfies SuccessfulDeployStackResult;\n\n      // Validate that the bootstrap stack we're trying to replace is from the same variant as the one we're trying to deploy\n      const currentVariant = this.currentToolkitInfo.variant;\n      const newVariant = bootstrapVariantFromTemplate(template);\n      if (currentVariant !== newVariant) {\n        logging.warning(\n          `Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`,\n        );\n        return abortResponse;\n      }\n\n      // Validate that we're not downgrading the bootstrap stack\n      const newVersion = bootstrapVersionFromTemplate(template);\n      const currentVersion = this.currentToolkitInfo.version;\n      if (newVersion < currentVersion) {\n        logging.warning(\n          `Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`,\n        );\n        if (newVersion === 0) {\n          // A downgrade with 0 as target version means we probably have a new-style bootstrap in the account,\n          // and an old-style bootstrap as current target, which means the user probably forgot to put this flag in.\n          logging.warning(\"(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)\");\n        }\n        return abortResponse;\n      }\n    }\n\n    const outdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-bootstrap'));\n    const builder = new CloudAssemblyBuilder(outdir);\n    const templateFile = `${this.toolkitStackName}.template.json`;\n    await fs.writeJson(path.join(builder.outdir, templateFile), template, {\n      spaces: 2,\n    });\n\n    builder.addArtifact(this.toolkitStackName, {\n      type: ArtifactType.AWS_CLOUDFORMATION_STACK,\n      environment: EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),\n      properties: {\n        templateFile,\n        terminationProtection: options.terminationProtection ?? false,\n      },\n    });\n\n    const assembly = builder.buildAssembly();\n\n    const ret = await deployStack({\n      stack: assembly.getStackByName(this.toolkitStackName),\n      resolvedEnvironment: this.resolvedEnvironment,\n      sdk: this.sdk,\n      sdkProvider: this.sdkProvider,\n      force: options.force,\n      roleArn: options.roleArn,\n      tags: options.tags,\n      deploymentMethod: { method: 'change-set', execute: options.execute },\n      parameters,\n      usePreviousParameters: options.usePreviousParameters ?? true,\n      // Obviously we can't need a bootstrap stack to deploy a bootstrap stack\n      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk),\n    });\n\n    assertIsSuccessfulDeployStackResult(ret);\n\n    return ret;\n  }\n}\n\nexport function bootstrapVersionFromTemplate(template: any): number {\n  const versionSources = [\n    template.Outputs?.[BOOTSTRAP_VERSION_OUTPUT]?.Value,\n    template.Resources?.[BOOTSTRAP_VERSION_RESOURCE]?.Properties?.Value,\n  ];\n\n  for (const vs of versionSources) {\n    if (typeof vs === 'number') {\n      return vs;\n    }\n    if (typeof vs === 'string' && !isNaN(parseInt(vs, 10))) {\n      return parseInt(vs, 10);\n    }\n  }\n  return 0;\n}\n\nexport function bootstrapVariantFromTemplate(template: any): string {\n  return template.Parameters?.[BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? DEFAULT_BOOTSTRAP_VARIANT;\n}\n"]}

package/lib/api/bootstrap/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bootstrap-environment';
+export * from './bootstrap-props';

package/lib/api/bootstrap/index.js

@@ -0,0 +1,19 @@
+"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("./bootstrap-environment"), exports);
+__exportStar(require("./bootstrap-props"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMERBQXdDO0FBQ3hDLG9EQUFrQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLWVudmlyb25tZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLXByb3BzJztcbiJdfQ==

package/lib/api/bootstrap/legacy-template.d.ts

@@ -0,0 +1,2 @@
+import { BootstrappingParameters } from './bootstrap-props';
+export declare function legacyBootstrapTemplate(params: BootstrappingParameters): any;

package/lib/api/bootstrap/legacy-template.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyBootstrapTemplate = legacyBootstrapTemplate;
+const bootstrap_props_1 = require("./bootstrap-props");
+function legacyBootstrapTemplate(params) {
+    return {
+        Description: 'The CDK Toolkit Stack. It was created by `cdk bootstrap` and manages resources necessary for managing your Cloud Applications with AWS CDK.',
+        Conditions: {
+            UsePublicAccessBlockConfiguration: {
+                'Fn::Equals': [
+                    params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === undefined ? 'true' : 'false',
+                    'true',
+                ],
+            },
+        },
+        Resources: {
+            StagingBucket: {
+                Type: 'AWS::S3::Bucket',
+                Properties: {
+                    BucketName: params.bucketName,
+                    AccessControl: 'Private',
+                    BucketEncryption: {
+                        ServerSideEncryptionConfiguration: [{
+                                ServerSideEncryptionByDefault: {
+                                    SSEAlgorithm: 'aws:kms',
+                                    KMSMasterKeyID: params.kmsKeyId,
+                                },
+                            }],
+                    },
+                    PublicAccessBlockConfiguration: {
+                        'Fn::If': [
+                            'UsePublicAccessBlockConfiguration',
+                            {
+                                BlockPublicAcls: true,
+                                BlockPublicPolicy: true,
+                                IgnorePublicAcls: true,
+                                RestrictPublicBuckets: true,
+                            },
+                            { Ref: 'AWS::NoValue' },
+                        ],
+                    },
+                },
+            },
+            StagingBucketPolicy: {
+                Type: 'AWS::S3::BucketPolicy',
+                Properties: {
+                    Bucket: { Ref: 'StagingBucket' },
+                    PolicyDocument: {
+                        Id: 'AccessControl',
+                        Version: '2012-10-17',
+                        Statement: [
+                            {
+                                Sid: 'AllowSSLRequestsOnly',
+                                Action: 's3:*',
+                                Effect: 'Deny',
+                                Resource: [
+                                    { 'Fn::Sub': '${StagingBucket.Arn}' },
+                                    { 'Fn::Sub': '${StagingBucket.Arn}/*' },
+                                ],
+                                Condition: {
+                                    Bool: { 'aws:SecureTransport': 'false' },
+                                },
+                                Principal: '*',
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+        Outputs: {
+            [bootstrap_props_1.BUCKET_NAME_OUTPUT]: {
+                Description: 'The name of the S3 bucket owned by the CDK toolkit stack',
+                Value: { Ref: 'StagingBucket' },
+            },
+            [bootstrap_props_1.BUCKET_DOMAIN_NAME_OUTPUT]: {
+                Description: 'The domain name of the S3 bucket owned by the CDK toolkit stack',
+                Value: { 'Fn::GetAtt': ['StagingBucket', 'RegionalDomainName'] },
+            },
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/context.d.ts

@@ -0,0 +1,40 @@
+import { Settings } from './settings';
+export { TRANSIENT_CONTEXT_KEY } from './settings';
+export declare const PROJECT_CONTEXT = "cdk.context.json";
+interface ContextBag {
+    /**
+     * The file name of the context. Will be used to potentially
+     * save new context back to the original file.
+     */
+    fileName?: string;
+    /**
+     * The context values.
+     */
+    bag: Settings;
+}
+/**
+ * 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.
+ */
+export declare class Context {
+    private readonly bags;
+    private readonly fileNames;
+    constructor(...bags: ContextBag[]);
+    get keys(): string[];
+    has(key: string): boolean;
+    get all(): {
+        [key: string]: any;
+    };
+    get(key: string): any;
+    set(key: string, value: any): void;
+    unset(key: string): void;
+    clear(): void;
+    /**
+     * Save a specific context file
+     */
+    save(fileName: string): Promise<this>;
+}

package/lib/api/context.js

@@ -0,0 +1,82 @@
+"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 error_1 = require("../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 {
+    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 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/cxapp/cloud-assembly.d.ts

@@ -0,0 +1,150 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+export declare enum DefaultSelection {
+    /**
+     * Returns an empty selection in case there are no selectors.
+     */
+    None = "none",
+    /**
+     * If the app includes a single stack, returns it. Otherwise throws an exception.
+     * This behavior is used by "deploy".
+     */
+    OnlySingle = "single",
+    /**
+     * Returns all stacks in the main (top level) assembly only.
+     */
+    MainAssembly = "main",
+    /**
+     * If no selectors are provided, returns all stacks in the app,
+     * including stacks inside nested assemblies.
+     */
+    AllStacks = "all"
+}
+export interface SelectStacksOptions {
+    /**
+     * Extend the selection to upstread/downstream stacks
+     * @default ExtendedStackSelection.None only select the specified stacks.
+     */
+    extend?: ExtendedStackSelection;
+    /**
+     * The behavior if no selectors are provided.
+     */
+    defaultBehavior: DefaultSelection;
+    /**
+     * Whether to deploy if the app contains no stacks.
+     *
+     * @default false
+     */
+    ignoreNoStacks?: boolean;
+}
+/**
+ * When selecting stacks, what other stacks to include because of dependencies
+ */
+export declare enum ExtendedStackSelection {
+    /**
+     * Don't select any extra stacks
+     */
+    None = 0,
+    /**
+     * Include stacks that this stack depends on
+     */
+    Upstream = 1,
+    /**
+     * Include stacks that depend on this stack
+     */
+    Downstream = 2
+}
+/**
+ * A specification of which stacks should be selected
+ */
+export interface StackSelector {
+    /**
+     * Whether all stacks at the top level assembly should
+     * be selected and nothing else
+     */
+    allTopLevel?: boolean;
+    /**
+     * A list of patterns to match the stack hierarchical ids
+     */
+    patterns: string[];
+}
+/**
+ * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside
+ */
+export declare class CloudAssembly {
+    readonly assembly: cxapi.CloudAssembly;
+    /**
+     * The directory this CloudAssembly was read from
+     */
+    readonly directory: string;
+    constructor(assembly: cxapi.CloudAssembly);
+    selectStacks(selector: StackSelector, options: SelectStacksOptions): Promise<StackCollection>;
+    private selectTopLevelStacks;
+    protected selectMatchingStacks(stacks: cxapi.CloudFormationStackArtifact[], patterns: string[], extend?: ExtendedStackSelection): StackCollection;
+    private selectDefaultStacks;
+    protected extendStacks(matched: cxapi.CloudFormationStackArtifact[], all: cxapi.CloudFormationStackArtifact[], extend?: ExtendedStackSelection): StackCollection;
+    /**
+     * Select a single stack by its ID
+     */
+    stackById(stackId: string): StackCollection;
+}
+/**
+ * The dependencies of a stack.
+ */
+export type StackDependency = {
+    id: string;
+    dependencies: StackDependency[];
+};
+/**
+ * Details of a stack.
+ */
+export type StackDetails = {
+    id: string;
+    name: string;
+    environment: cxapi.Environment;
+    dependencies: StackDependency[];
+};
+/**
+ * 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: CloudAssembly;
+    readonly stackArtifacts: cxapi.CloudFormationStackArtifact[];
+    constructor(assembly: CloudAssembly, 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>;
+}
+export interface MetadataMessageOptions {
+    /**
+     * Whether to be verbose
+     *
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Don't stop on error metadata
+     *
+     * @default false
+     */
+    ignoreErrors?: boolean;
+    /**
+     * Treat warnings in metadata as errors
+     *
+     * @default false
+     */
+    strict?: boolean;
+}
+export declare function sanitizePatterns(patterns: string[]): string[];