@aws-cdk/cloud-assembly-api 0.0.1 → 2.0.1

package/lib/cloud-assembly.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudAssemblyBuilder = exports.CloudAssembly = void 0;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const cxschema = require("@aws-cdk/cloud-assembly-schema/lib");
+const cloudformation_artifact_1 = require("./artifacts/cloudformation-artifact");
+const nested_cloud_assembly_artifact_1 = require("./artifacts/nested-cloud-assembly-artifact");
+const tree_cloud_artifact_1 = require("./artifacts/tree-cloud-artifact");
+const cloud_artifact_1 = require("./cloud-artifact");
+const error_1 = require("./private/error");
+const toposort_1 = require("./private/toposort");
+const CLOUD_ASSEMBLY_SYMBOL = Symbol.for('@aws-cdk/cx-api.CloudAssembly');
+/**
+ * The name of the root manifest file of the assembly.
+ */
+const MANIFEST_FILE = 'manifest.json';
+/**
+ * Represents a deployable cloud application.
+ */
+class CloudAssembly {
+    /**
+     * Return whether the given object is a CloudAssembly.
+     *
+     * We do attribute detection since we can't reliably use 'instanceof'.
+     */
+    static isCloudAssembly(x) {
+        return x !== null && typeof (x) === 'object' && CLOUD_ASSEMBLY_SYMBOL in x;
+    }
+    /**
+     * Cleans up any temporary assembly directories that got created in this process
+     *
+     * If a Cloud Assembly is emitted to a temporary directory, its directory gets
+     * added to a list. This function iterates over that list and deletes each
+     * directory in it, to free up disk space.
+     *
+     * This function will normally be called automatically during Node process
+     * exit and so you don't need to call this. However, some test environments do
+     * not properly trigger Node's `exit` event. Notably: Jest does not trigger
+     * the `exit` event (<https://github.com/jestjs/jest/issues/10927>).
+     *
+     * ## Cleaning up temporary directories in jest
+     *
+     * For Jest, you have to make sure this function is called at the end of the
+     * test suite instead:
+     *
+     * ```js
+     * import { CloudAssembly } from 'aws-cdk-lib/cx-api';
+     *
+     * afterAll(CloudAssembly.cleanupTemporaryDirectories);
+     * ```
+     *
+     * Alternatively, you can use the `setupFilesAfterEnv` feature and use a
+     * provided helper script to automatically inject the above into every
+     * test file, so you don't have to do it by hand.
+     *
+     * ```
+     * $ npx jest --setupFilesAfterEnv aws-cdk-lib/testhelpers/jest-autoclean
+     * ```
+     *
+     * Or put the following into `jest.config.js`:
+     *
+     * ```js
+     * module.exports = {
+     *   // ...
+     *   setupFilesAfterEnv: ['aws-cdk-lib/testhelpers/jest-cleanup'],
+     * };
+     * ```
+     */
+    static cleanupTemporaryDirectories() {
+        for (const dir of TEMPORARY_ASSEMBLY_DIRS) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        TEMPORARY_ASSEMBLY_DIRS.splice(0, TEMPORARY_ASSEMBLY_DIRS.length);
+    }
+    /**
+     * Reads a cloud assembly from the specified directory.
+     * @param directory - The root directory of the assembly.
+     */
+    constructor(directory, loadOptions) {
+        this.directory = directory;
+        this.manifest = cxschema.Manifest.loadAssemblyManifest(path.join(directory, MANIFEST_FILE), loadOptions);
+        this.version = this.manifest.version;
+        this.artifacts = this.renderArtifacts(loadOptions?.topoSort ?? true);
+        this.runtime = this.manifest.runtime || { libraries: {} };
+        Object.defineProperty(this, CLOUD_ASSEMBLY_SYMBOL, { value: true });
+        // force validation of deps by accessing 'depends' on all artifacts
+        this.validateDeps();
+    }
+    /**
+     * Attempts to find an artifact with a specific identity.
+     * @returns A `CloudArtifact` object or `undefined` if the artifact does not exist in this assembly.
+     * @param id - The artifact ID
+     */
+    tryGetArtifact(id) {
+        return this.artifacts.find(a => a.id === id);
+    }
+    /**
+     * Returns a CloudFormation stack artifact from this assembly.
+     *
+     * Will only search the current assembly.
+     *
+     * @param stackName - the name of the CloudFormation stack.
+     * @throws if there is no stack artifact by that name
+     * @throws if there is more than one stack with the same stack name. You can
+     * use `getStackArtifact(stack.artifactId)` instead.
+     * @returns a `CloudFormationStackArtifact` object.
+     */
+    getStackByName(stackName) {
+        const artifacts = this.artifacts.filter(a => a instanceof cloudformation_artifact_1.CloudFormationStackArtifact && a.stackName === stackName);
+        if (!artifacts || artifacts.length === 0) {
+            throw new error_1.CloudAssemblyError(`Unable to find stack with stack name "${stackName}"`);
+        }
+        if (artifacts.length > 1) {
+            throw new error_1.CloudAssemblyError(`There are multiple stacks with the stack name "${stackName}" (${artifacts.map(a => a.id).join(',')}). Use "getStackArtifact(id)" instead`);
+        }
+        return artifacts[0];
+    }
+    /**
+     * Returns a CloudFormation stack artifact by name from this assembly.
+     * @deprecated renamed to `getStackByName` (or `getStackArtifact(id)`)
+     */
+    getStack(stackName) {
+        return this.getStackByName(stackName);
+    }
+    /**
+     * Returns a CloudFormation stack artifact from this assembly.
+     *
+     * @param artifactId - the artifact id of the stack (can be obtained through `stack.artifactId`).
+     * @throws if there is no stack artifact with that id
+     * @returns a `CloudFormationStackArtifact` object.
+     */
+    getStackArtifact(artifactId) {
+        const artifact = this.tryGetArtifactRecursively(artifactId);
+        if (!artifact) {
+            throw new error_1.CloudAssemblyError(`Unable to find artifact with id "${artifactId}"`);
+        }
+        if (!(artifact instanceof cloudformation_artifact_1.CloudFormationStackArtifact)) {
+            throw new error_1.CloudAssemblyError(`Artifact ${artifactId} is not a CloudFormation stack`);
+        }
+        return artifact;
+    }
+    tryGetArtifactRecursively(artifactId) {
+        return this.stacksRecursively.find(a => a.id === artifactId);
+    }
+    /**
+     * Returns all the stacks, including the ones in nested assemblies
+     */
+    get stacksRecursively() {
+        function search(stackArtifacts, assemblies) {
+            if (assemblies.length === 0) {
+                return stackArtifacts;
+            }
+            const [head, ...tail] = assemblies;
+            const nestedAssemblies = head.nestedAssemblies.map(asm => asm.nestedAssembly);
+            return search(stackArtifacts.concat(head.stacks), tail.concat(nestedAssemblies));
+        }
+        return search([], [this]);
+    }
+    /**
+     * Returns a nested assembly artifact.
+     *
+     * @param artifactId - The artifact ID of the nested assembly
+     */
+    getNestedAssemblyArtifact(artifactId) {
+        const artifact = this.tryGetArtifact(artifactId);
+        if (!artifact) {
+            throw new error_1.CloudAssemblyError(`Unable to find artifact with id "${artifactId}"`);
+        }
+        if (!(artifact instanceof nested_cloud_assembly_artifact_1.NestedCloudAssemblyArtifact)) {
+            throw new error_1.CloudAssemblyError(`Found artifact '${artifactId}' but it's not a nested cloud assembly`);
+        }
+        return artifact;
+    }
+    /**
+     * Returns a nested assembly.
+     *
+     * @param artifactId - The artifact ID of the nested assembly
+     */
+    getNestedAssembly(artifactId) {
+        return this.getNestedAssemblyArtifact(artifactId).nestedAssembly;
+    }
+    /**
+     * Returns the tree metadata artifact from this assembly.
+     * @throws if there is no metadata artifact by that name
+     * @returns a `TreeCloudArtifact` object if there is one defined in the manifest, `undefined` otherwise.
+     */
+    tree() {
+        const trees = this.artifacts.filter(a => a.manifest.type === cxschema.ArtifactType.CDK_TREE);
+        if (trees.length === 0) {
+            return undefined;
+        }
+        else if (trees.length > 1) {
+            throw new error_1.CloudAssemblyError(`Multiple artifacts of type ${cxschema.ArtifactType.CDK_TREE} found in manifest`);
+        }
+        const tree = trees[0];
+        if (!(tree instanceof tree_cloud_artifact_1.TreeCloudArtifact)) {
+            throw new error_1.CloudAssemblyError('"Tree" artifact is not of expected type');
+        }
+        return tree;
+    }
+    /**
+     * @returns all the CloudFormation stack artifacts that are included in this assembly.
+     */
+    get stacks() {
+        return this.artifacts.filter(isCloudFormationStackArtifact);
+        function isCloudFormationStackArtifact(x) {
+            return x instanceof cloudformation_artifact_1.CloudFormationStackArtifact;
+        }
+    }
+    /**
+     * The nested assembly artifacts in this assembly
+     */
+    get nestedAssemblies() {
+        return this.artifacts.filter(isNestedCloudAssemblyArtifact);
+        function isNestedCloudAssemblyArtifact(x) {
+            return x instanceof nested_cloud_assembly_artifact_1.NestedCloudAssemblyArtifact;
+        }
+    }
+    validateDeps() {
+        for (const artifact of this.artifacts) {
+            ignore(artifact.dependencies);
+        }
+    }
+    renderArtifacts(topoSort) {
+        const result = new Array();
+        for (const [name, artifact] of Object.entries(this.manifest.artifacts || {})) {
+            const cloudartifact = cloud_artifact_1.CloudArtifact.fromManifest(this, name, artifact);
+            if (cloudartifact) {
+                result.push(cloudartifact);
+            }
+        }
+        return topoSort ? (0, toposort_1.topologicalSort)(result, x => x.id, x => x._dependencyIDs) : result;
+    }
+}
+exports.CloudAssembly = CloudAssembly;
+/**
+ * Can be used to build a cloud assembly.
+ */
+class CloudAssemblyBuilder {
+    /**
+     * Initializes a cloud assembly builder.
+     * @param outdir - The output directory, uses temporary directory if undefined
+     */
+    constructor(outdir, props = {}) {
+        this.artifacts = {};
+        this.missing = new Array();
+        this.outdir = determineOutputDirectory(outdir);
+        this.assetOutdir = props.assetOutdir ?? this.outdir;
+        this.parentBuilder = props.parentBuilder;
+        // we leverage the fact that outdir is long-lived to avoid staging assets into it
+        // that were already staged (copying can be expensive). this is achieved by the fact
+        // that assets use a source hash as their name. other artifacts, and the manifest itself,
+        // will overwrite existing files as needed.
+        ensureDirSync(this.outdir);
+    }
+    /**
+     * Adds an artifact into the cloud assembly.
+     * @param id - The ID of the artifact.
+     * @param manifest - The artifact manifest
+     */
+    addArtifact(id, manifest) {
+        this.artifacts[id] = filterUndefined(manifest);
+    }
+    /**
+     * Reports that some context is missing in order for this cloud assembly to be fully synthesized.
+     * @param missing - Missing context information.
+     */
+    addMissing(missing) {
+        if (this.missing.every(m => m.key !== missing.key)) {
+            this.missing.push(missing);
+        }
+        // Also report in parent
+        this.parentBuilder?.addMissing(missing);
+    }
+    /**
+     * Finalizes the cloud assembly into the output directory returns a
+     * `CloudAssembly` object that can be used to inspect the assembly.
+     */
+    buildAssembly(options = {}) {
+        // explicitly initializing this type will help us detect
+        // breaking changes. (For example adding a required property will break compilation).
+        let manifest = {
+            version: cxschema.Manifest.version(),
+            artifacts: this.artifacts,
+            runtime: options.runtimeInfo,
+            missing: this.missing.length > 0 ? this.missing : undefined,
+        };
+        // now we can filter
+        manifest = filterUndefined(manifest);
+        const manifestFilePath = path.join(this.outdir, MANIFEST_FILE);
+        cxschema.Manifest.saveAssemblyManifest(manifest, manifestFilePath);
+        // "backwards compatibility": in order for the old CLI to tell the user they
+        // need a new version, we'll emit the legacy manifest with only "version".
+        // this will result in an error "CDK Toolkit >= CLOUD_ASSEMBLY_VERSION is required in order to interact with this program."
+        fs.writeFileSync(path.join(this.outdir, 'cdk.out'), JSON.stringify({ version: manifest.version }));
+        return new CloudAssembly(this.outdir);
+    }
+    /**
+     * Creates a nested cloud assembly
+     */
+    createNestedAssembly(artifactId, displayName) {
+        const directoryName = artifactId;
+        const innerAsmDir = path.join(this.outdir, directoryName);
+        this.addArtifact(artifactId, {
+            type: cxschema.ArtifactType.NESTED_CLOUD_ASSEMBLY,
+            properties: {
+                directoryName,
+                displayName,
+            },
+        });
+        return new CloudAssemblyBuilder(innerAsmDir, {
+            // Reuse the same asset output directory as the current Casm builder
+            assetOutdir: this.assetOutdir,
+            parentBuilder: this,
+        });
+    }
+    /**
+     * Delete the cloud assembly directory
+     */
+    delete() {
+        fs.rmSync(this.outdir, { recursive: true, force: true });
+    }
+}
+exports.CloudAssemblyBuilder = CloudAssemblyBuilder;
+/**
+ * Returns a copy of `obj` without undefined values in maps or arrays.
+ */
+function filterUndefined(obj) {
+    if (Array.isArray(obj)) {
+        return obj.filter(x => x !== undefined).map(x => filterUndefined(x));
+    }
+    if (typeof (obj) === 'object') {
+        const ret = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value === undefined) {
+                continue;
+            }
+            ret[key] = filterUndefined(value);
+        }
+        return ret;
+    }
+    return obj;
+}
+function ignore(_x) {
+    return;
+}
+/**
+ * Turn the given optional output directory into a fixed output directory
+ */
+function determineOutputDirectory(outdir) {
+    if (outdir) {
+        return outdir;
+    }
+    // Make a temporary directory; clean it up automatically if this is done for testing.
+    const tmpDir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));
+    TEMPORARY_ASSEMBLY_DIRS.push(tmpDir);
+    return outdir ?? tmpDir;
+}
+function ensureDirSync(dir) {
+    if (fs.existsSync(dir)) {
+        if (!fs.statSync(dir).isDirectory()) {
+            throw new error_1.CloudAssemblyError(`${dir} must be a directory`);
+        }
+    }
+    else {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+// On process exit, delete all temporary assembly directories
+const TEMPORARY_ASSEMBLY_DIRS = [];
+process.on('exit', () => CloudAssembly.cleanupTemporaryDirectories());
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-assembly.js","sourceRoot":"","sources":["cloud-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport type { ICloudAssembly } from '@aws-cdk/cloud-assembly-schema';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema/lib';\nimport { CloudFormationStackArtifact } from './artifacts/cloudformation-artifact';\nimport { NestedCloudAssemblyArtifact } from './artifacts/nested-cloud-assembly-artifact';\nimport { TreeCloudArtifact } from './artifacts/tree-cloud-artifact';\nimport { CloudArtifact } from './cloud-artifact';\nimport { CloudAssemblyError } from './private/error';\nimport { topologicalSort } from './private/toposort';\n\nconst CLOUD_ASSEMBLY_SYMBOL = Symbol.for('@aws-cdk/cx-api.CloudAssembly');\n\n/**\n * The name of the root manifest file of the assembly.\n */\nconst MANIFEST_FILE = 'manifest.json';\n\n/**\n * Represents a deployable cloud application.\n */\nexport class CloudAssembly implements ICloudAssembly {\n  /**\n   * Return whether the given object is a CloudAssembly.\n   *\n   * We do attribute detection since we can't reliably use 'instanceof'.\n   */\n  public static isCloudAssembly(x: any): x is CloudAssembly {\n    return x !== null && typeof(x) === 'object' && CLOUD_ASSEMBLY_SYMBOL in x;\n  }\n\n  /**\n   * Cleans up any temporary assembly directories that got created in this process\n   *\n   * If a Cloud Assembly is emitted to a temporary directory, its directory gets\n   * added to a list. This function iterates over that list and deletes each\n   * directory in it, to free up disk space.\n   *\n   * This function will normally be called automatically during Node process\n   * exit and so you don't need to call this. However, some test environments do\n   * not properly trigger Node's `exit` event. Notably: Jest does not trigger\n   * the `exit` event (<https://github.com/jestjs/jest/issues/10927>).\n   *\n   * ## Cleaning up temporary directories in jest\n   *\n   * For Jest, you have to make sure this function is called at the end of the\n   * test suite instead:\n   *\n   * ```js\n   * import { CloudAssembly } from 'aws-cdk-lib/cx-api';\n   *\n   * afterAll(CloudAssembly.cleanupTemporaryDirectories);\n   * ```\n   *\n   * Alternatively, you can use the `setupFilesAfterEnv` feature and use a\n   * provided helper script to automatically inject the above into every\n   * test file, so you don't have to do it by hand.\n   *\n   * ```\n   * $ npx jest --setupFilesAfterEnv aws-cdk-lib/testhelpers/jest-autoclean\n   * ```\n   *\n   * Or put the following into `jest.config.js`:\n   *\n   * ```js\n   * module.exports = {\n   *   // ...\n   *   setupFilesAfterEnv: ['aws-cdk-lib/testhelpers/jest-cleanup'],\n   * };\n   * ```\n   */\n  public static cleanupTemporaryDirectories() {\n    for (const dir of TEMPORARY_ASSEMBLY_DIRS) {\n      fs.rmSync(dir, { recursive: true, force: true });\n    }\n    TEMPORARY_ASSEMBLY_DIRS.splice(0, TEMPORARY_ASSEMBLY_DIRS.length);\n  }\n\n  /**\n   * The root directory of the cloud assembly.\n   */\n  public readonly directory: string;\n\n  /**\n   * The schema version of the assembly manifest.\n   */\n  public readonly version: string;\n\n  /**\n   * All artifacts included in this assembly.\n   */\n  public readonly artifacts: CloudArtifact[];\n\n  /**\n   * Runtime information such as module versions used to synthesize this assembly.\n   */\n  public readonly runtime: cxschema.RuntimeInfo;\n\n  /**\n   * The raw assembly manifest.\n   */\n  public readonly manifest: cxschema.AssemblyManifest;\n\n  /**\n   * Reads a cloud assembly from the specified directory.\n   * @param directory - The root directory of the assembly.\n   */\n  constructor(directory: string, loadOptions?: cxschema.LoadManifestOptions) {\n    this.directory = directory;\n\n    this.manifest = cxschema.Manifest.loadAssemblyManifest(path.join(directory, MANIFEST_FILE), loadOptions);\n    this.version = this.manifest.version;\n    this.artifacts = this.renderArtifacts(loadOptions?.topoSort ?? true);\n    this.runtime = this.manifest.runtime || { libraries: { } };\n\n    Object.defineProperty(this, CLOUD_ASSEMBLY_SYMBOL, { value: true });\n\n    // force validation of deps by accessing 'depends' on all artifacts\n    this.validateDeps();\n  }\n\n  /**\n   * Attempts to find an artifact with a specific identity.\n   * @returns A `CloudArtifact` object or `undefined` if the artifact does not exist in this assembly.\n   * @param id - The artifact ID\n   */\n  public tryGetArtifact(id: string): CloudArtifact | undefined {\n    return this.artifacts.find(a => a.id === id);\n  }\n\n  /**\n   * Returns a CloudFormation stack artifact from this assembly.\n   *\n   * Will only search the current assembly.\n   *\n   * @param stackName - the name of the CloudFormation stack.\n   * @throws if there is no stack artifact by that name\n   * @throws if there is more than one stack with the same stack name. You can\n   * use `getStackArtifact(stack.artifactId)` instead.\n   * @returns a `CloudFormationStackArtifact` object.\n   */\n  public getStackByName(stackName: string): CloudFormationStackArtifact {\n    const artifacts = this.artifacts.filter(a => a instanceof CloudFormationStackArtifact && a.stackName === stackName);\n    if (!artifacts || artifacts.length === 0) {\n      throw new CloudAssemblyError(`Unable to find stack with stack name \"${stackName}\"`);\n    }\n\n    if (artifacts.length > 1) {\n      throw new CloudAssemblyError(`There are multiple stacks with the stack name \"${stackName}\" (${artifacts.map(a => a.id).join(',')}). Use \"getStackArtifact(id)\" instead`);\n    }\n\n    return artifacts[0] as CloudFormationStackArtifact;\n  }\n\n  /**\n   * Returns a CloudFormation stack artifact by name from this assembly.\n   * @deprecated renamed to `getStackByName` (or `getStackArtifact(id)`)\n   */\n  public getStack(stackName: string) {\n    return this.getStackByName(stackName);\n  }\n\n  /**\n   * Returns a CloudFormation stack artifact from this assembly.\n   *\n   * @param artifactId - the artifact id of the stack (can be obtained through `stack.artifactId`).\n   * @throws if there is no stack artifact with that id\n   * @returns a `CloudFormationStackArtifact` object.\n   */\n  public getStackArtifact(artifactId: string): CloudFormationStackArtifact {\n    const artifact = this.tryGetArtifactRecursively(artifactId);\n\n    if (!artifact) {\n      throw new CloudAssemblyError(`Unable to find artifact with id \"${artifactId}\"`);\n    }\n\n    if (!(artifact instanceof CloudFormationStackArtifact)) {\n      throw new CloudAssemblyError(`Artifact ${artifactId} is not a CloudFormation stack`);\n    }\n\n    return artifact;\n  }\n\n  private tryGetArtifactRecursively(artifactId: string): CloudArtifact | undefined {\n    return this.stacksRecursively.find(a => a.id === artifactId);\n  }\n\n  /**\n   * Returns all the stacks, including the ones in nested assemblies\n   */\n  public get stacksRecursively(): CloudFormationStackArtifact[] {\n    function search(stackArtifacts: CloudFormationStackArtifact[], assemblies: CloudAssembly[]): CloudFormationStackArtifact[] {\n      if (assemblies.length === 0) {\n        return stackArtifacts;\n      }\n\n      const [head, ...tail] = assemblies;\n      const nestedAssemblies = head.nestedAssemblies.map(asm => asm.nestedAssembly);\n      return search(stackArtifacts.concat(head.stacks), tail.concat(nestedAssemblies));\n    }\n\n    return search([], [this]);\n  }\n\n  /**\n   * Returns a nested assembly artifact.\n   *\n   * @param artifactId - The artifact ID of the nested assembly\n   */\n  public getNestedAssemblyArtifact(artifactId: string): NestedCloudAssemblyArtifact {\n    const artifact = this.tryGetArtifact(artifactId);\n    if (!artifact) {\n      throw new CloudAssemblyError(`Unable to find artifact with id \"${artifactId}\"`);\n    }\n\n    if (!(artifact instanceof NestedCloudAssemblyArtifact)) {\n      throw new CloudAssemblyError(`Found artifact '${artifactId}' but it's not a nested cloud assembly`);\n    }\n\n    return artifact;\n  }\n\n  /**\n   * Returns a nested assembly.\n   *\n   * @param artifactId - The artifact ID of the nested assembly\n   */\n  public getNestedAssembly(artifactId: string): CloudAssembly {\n    return this.getNestedAssemblyArtifact(artifactId).nestedAssembly;\n  }\n\n  /**\n   * Returns the tree metadata artifact from this assembly.\n   * @throws if there is no metadata artifact by that name\n   * @returns a `TreeCloudArtifact` object if there is one defined in the manifest, `undefined` otherwise.\n   */\n  public tree(): TreeCloudArtifact | undefined {\n    const trees = this.artifacts.filter(a => a.manifest.type === cxschema.ArtifactType.CDK_TREE);\n    if (trees.length === 0) {\n      return undefined;\n    } else if (trees.length > 1) {\n      throw new CloudAssemblyError(`Multiple artifacts of type ${cxschema.ArtifactType.CDK_TREE} found in manifest`);\n    }\n    const tree = trees[0];\n\n    if (!(tree instanceof TreeCloudArtifact)) {\n      throw new CloudAssemblyError('\"Tree\" artifact is not of expected type');\n    }\n\n    return tree;\n  }\n\n  /**\n   * @returns all the CloudFormation stack artifacts that are included in this assembly.\n   */\n  public get stacks(): CloudFormationStackArtifact[] {\n    return this.artifacts.filter(isCloudFormationStackArtifact);\n\n    function isCloudFormationStackArtifact(x: any): x is CloudFormationStackArtifact {\n      return x instanceof CloudFormationStackArtifact;\n    }\n  }\n\n  /**\n   * The nested assembly artifacts in this assembly\n   */\n  public get nestedAssemblies(): NestedCloudAssemblyArtifact[] {\n    return this.artifacts.filter(isNestedCloudAssemblyArtifact);\n\n    function isNestedCloudAssemblyArtifact(x: any): x is NestedCloudAssemblyArtifact {\n      return x instanceof NestedCloudAssemblyArtifact;\n    }\n  }\n\n  private validateDeps() {\n    for (const artifact of this.artifacts) {\n      ignore(artifact.dependencies);\n    }\n  }\n\n  private renderArtifacts(topoSort: boolean) {\n    const result = new Array<CloudArtifact>();\n    for (const [name, artifact] of Object.entries(this.manifest.artifacts || { })) {\n      const cloudartifact = CloudArtifact.fromManifest(this, name, artifact);\n      if (cloudartifact) {\n        result.push(cloudartifact);\n      }\n    }\n\n    return topoSort ? topologicalSort(result, x => x.id, x => x._dependencyIDs) : result;\n  }\n}\n\n/**\n * Construction properties for CloudAssemblyBuilder\n */\nexport interface CloudAssemblyBuilderProps {\n  /**\n   * Use the given asset output directory\n   *\n   * @default - Same as the manifest outdir\n   */\n  readonly assetOutdir?: string;\n\n  /**\n   * If this builder is for a nested assembly, the parent assembly builder\n   *\n   * @default - This is a root assembly\n   */\n  readonly parentBuilder?: CloudAssemblyBuilder;\n}\n\n/**\n * Can be used to build a cloud assembly.\n */\nexport class CloudAssemblyBuilder {\n  /**\n   * The root directory of the resulting cloud assembly.\n   */\n  public readonly outdir: string;\n\n  /**\n   * The directory where assets of this Cloud Assembly should be stored\n   */\n  public readonly assetOutdir: string;\n\n  private readonly artifacts: { [id: string]: cxschema.ArtifactManifest } = { };\n  private readonly missing = new Array<cxschema.MissingContext>();\n  private readonly parentBuilder?: CloudAssemblyBuilder;\n\n  /**\n   * Initializes a cloud assembly builder.\n   * @param outdir - The output directory, uses temporary directory if undefined\n   */\n  constructor(outdir?: string, props: CloudAssemblyBuilderProps = {}) {\n    this.outdir = determineOutputDirectory(outdir);\n    this.assetOutdir = props.assetOutdir ?? this.outdir;\n    this.parentBuilder = props.parentBuilder;\n\n    // we leverage the fact that outdir is long-lived to avoid staging assets into it\n    // that were already staged (copying can be expensive). this is achieved by the fact\n    // that assets use a source hash as their name. other artifacts, and the manifest itself,\n    // will overwrite existing files as needed.\n    ensureDirSync(this.outdir);\n  }\n\n  /**\n   * Adds an artifact into the cloud assembly.\n   * @param id - The ID of the artifact.\n   * @param manifest - The artifact manifest\n   */\n  public addArtifact(id: string, manifest: cxschema.ArtifactManifest) {\n    this.artifacts[id] = filterUndefined(manifest);\n  }\n\n  /**\n   * Reports that some context is missing in order for this cloud assembly to be fully synthesized.\n   * @param missing - Missing context information.\n   */\n  public addMissing(missing: cxschema.MissingContext) {\n    if (this.missing.every(m => m.key !== missing.key)) {\n      this.missing.push(missing);\n    }\n    // Also report in parent\n    this.parentBuilder?.addMissing(missing);\n  }\n\n  /**\n   * Finalizes the cloud assembly into the output directory returns a\n   * `CloudAssembly` object that can be used to inspect the assembly.\n   */\n  public buildAssembly(options: AssemblyBuildOptions = { }): CloudAssembly {\n    // explicitly initializing this type will help us detect\n    // breaking changes. (For example adding a required property will break compilation).\n    let manifest: cxschema.AssemblyManifest = {\n      version: cxschema.Manifest.version(),\n      artifacts: this.artifacts,\n      runtime: options.runtimeInfo,\n      missing: this.missing.length > 0 ? this.missing : undefined,\n    };\n\n    // now we can filter\n    manifest = filterUndefined(manifest);\n\n    const manifestFilePath = path.join(this.outdir, MANIFEST_FILE);\n    cxschema.Manifest.saveAssemblyManifest(manifest, manifestFilePath);\n\n    // \"backwards compatibility\": in order for the old CLI to tell the user they\n    // need a new version, we'll emit the legacy manifest with only \"version\".\n    // this will result in an error \"CDK Toolkit >= CLOUD_ASSEMBLY_VERSION is required in order to interact with this program.\"\n    fs.writeFileSync(path.join(this.outdir, 'cdk.out'), JSON.stringify({ version: manifest.version }));\n\n    return new CloudAssembly(this.outdir);\n  }\n\n  /**\n   * Creates a nested cloud assembly\n   */\n  public createNestedAssembly(artifactId: string, displayName: string) {\n    const directoryName = artifactId;\n    const innerAsmDir = path.join(this.outdir, directoryName);\n\n    this.addArtifact(artifactId, {\n      type: cxschema.ArtifactType.NESTED_CLOUD_ASSEMBLY,\n      properties: {\n        directoryName,\n        displayName,\n      } as cxschema.NestedCloudAssemblyProperties,\n    });\n\n    return new CloudAssemblyBuilder(innerAsmDir, {\n      // Reuse the same asset output directory as the current Casm builder\n      assetOutdir: this.assetOutdir,\n      parentBuilder: this,\n    });\n  }\n\n  /**\n   * Delete the cloud assembly directory\n   */\n  public delete() {\n    fs.rmSync(this.outdir, { recursive: true, force: true });\n  }\n}\n\n/**\n * Backwards compatibility for when `RuntimeInfo`\n * was defined here. This is necessary because its used as an input in the stable\n * @aws-cdk/core library.\n *\n * @deprecated moved to package 'cloud-assembly-schema'\n * @see core.ConstructNode.synth\n */\nexport interface RuntimeInfo extends cxschema.RuntimeInfo {\n\n}\n\n/**\n * Backwards compatibility for when `MetadataEntry`\n * was defined here. This is necessary because its used as an input in the stable\n * @aws-cdk/core library.\n *\n * @deprecated moved to package 'cloud-assembly-schema'\n * @see core.ConstructNode.metadata\n */\nexport interface MetadataEntry extends cxschema.MetadataEntry {\n\n}\n\n/**\n * Backwards compatibility for when `MissingContext`\n * was defined here. This is necessary because its used as an input in the stable\n * @aws-cdk/core library.\n *\n * @deprecated moved to package 'cloud-assembly-schema'\n * @see core.Stack.reportMissingContext\n */\nexport interface MissingContext {\n  /**\n   * The missing context key.\n   */\n  readonly key: string;\n\n  /**\n   * The provider from which we expect this context key to be obtained.\n   *\n   * (This is the old untyped definition, which is necessary for backwards compatibility.\n   * See cxschema for a type definition.)\n   */\n  readonly provider: string;\n\n  /**\n   * A set of provider-specific options.\n   *\n   * (This is the old untyped definition, which is necessary for backwards compatibility.\n   * See cxschema for a type definition.)\n   */\n  readonly props: Record<string, any>;\n}\n\nexport interface AssemblyBuildOptions {\n  /**\n   * Include the specified runtime information (module versions) in manifest.\n   * @default - if this option is not specified, runtime info will not be included\n   * @deprecated All template modifications that should result from this should\n   * have already been inserted into the template.\n   */\n  readonly runtimeInfo?: RuntimeInfo;\n}\n\n/**\n * Returns a copy of `obj` without undefined values in maps or arrays.\n */\nfunction filterUndefined(obj: any): any {\n  if (Array.isArray(obj)) {\n    return obj.filter(x => x !== undefined).map(x => filterUndefined(x));\n  }\n\n  if (typeof(obj) === 'object') {\n    const ret: any = { };\n    for (const [key, value] of Object.entries(obj)) {\n      if (value === undefined) {\n        continue;\n      }\n      ret[key] = filterUndefined(value);\n    }\n    return ret;\n  }\n\n  return obj;\n}\n\nfunction ignore(_x: any) {\n  return;\n}\n\n/**\n * Turn the given optional output directory into a fixed output directory\n */\nfunction determineOutputDirectory(outdir?: string) {\n  if (outdir) {\n    return outdir;\n  }\n\n  // Make a temporary directory; clean it up automatically if this is done for testing.\n  const tmpDir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));\n  TEMPORARY_ASSEMBLY_DIRS.push(tmpDir);\n  return outdir ?? tmpDir;\n}\n\nfunction ensureDirSync(dir: string) {\n  if (fs.existsSync(dir)) {\n    if (!fs.statSync(dir).isDirectory()) {\n      throw new CloudAssemblyError(`${dir} must be a directory`);\n    }\n  } else {\n    fs.mkdirSync(dir, { recursive: true });\n  }\n}\n\n// On process exit, delete all temporary assembly directories\nconst TEMPORARY_ASSEMBLY_DIRS: string[] = [];\nprocess.on('exit', () => CloudAssembly.cleanupTemporaryDirectories());\n"]}

package/lib/context/ami.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns just an AMI ID
+ */
+export type AmiContextResponse = string;

package/lib/context/ami.js

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

package/lib/context/availability-zones.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This context key is used to determine the value of `stack.availabilityZones`
+ * when a stack is not associated with a specific account/region (env-agnostic).
+ *
+ * If this key is passed in the context, the values will be used. Otherwise, a
+ * system-fallback which uses `Fn::GetAZs` will be used.
+ */
+export declare const AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY = "aws:cdk:availability-zones:fallback";
+/**
+ * Response of the AZ provider looks like this
+ */
+export type AvailabilityZonesContextResponse = string[];

package/lib/context/availability-zones.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY = void 0;
+/**
+ * This context key is used to determine the value of `stack.availabilityZones`
+ * when a stack is not associated with a specific account/region (env-agnostic).
+ *
+ * If this key is passed in the context, the values will be used. Otherwise, a
+ * system-fallback which uses `Fn::GetAZs` will be used.
+ */
+exports.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY = 'aws:cdk:availability-zones:fallback';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZhaWxhYmlsaXR5LXpvbmVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYXZhaWxhYmlsaXR5LXpvbmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7R0FNRztBQUNVLFFBQUEsc0NBQXNDLEdBQUcscUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoaXMgY29udGV4dCBrZXkgaXMgdXNlZCB0byBkZXRlcm1pbmUgdGhlIHZhbHVlIG9mIGBzdGFjay5hdmFpbGFiaWxpdHlab25lc2BcbiAqIHdoZW4gYSBzdGFjayBpcyBub3QgYXNzb2NpYXRlZCB3aXRoIGEgc3BlY2lmaWMgYWNjb3VudC9yZWdpb24gKGVudi1hZ25vc3RpYykuXG4gKlxuICogSWYgdGhpcyBrZXkgaXMgcGFzc2VkIGluIHRoZSBjb250ZXh0LCB0aGUgdmFsdWVzIHdpbGwgYmUgdXNlZC4gT3RoZXJ3aXNlLCBhXG4gKiBzeXN0ZW0tZmFsbGJhY2sgd2hpY2ggdXNlcyBgRm46OkdldEFac2Agd2lsbCBiZSB1c2VkLlxuICovXG5leHBvcnQgY29uc3QgQVZBSUxBQklMSVRZX1pPTkVfRkFMTEJBQ0tfQ09OVEVYVF9LRVkgPSAnYXdzOmNkazphdmFpbGFiaWxpdHktem9uZXM6ZmFsbGJhY2snO1xuXG4vKipcbiAqIFJlc3BvbnNlIG9mIHRoZSBBWiBwcm92aWRlciBsb29rcyBsaWtlIHRoaXNcbiAqL1xuZXhwb3J0IHR5cGUgQXZhaWxhYmlsaXR5Wm9uZXNDb250ZXh0UmVzcG9uc2UgPSBzdHJpbmdbXTtcbiJdfQ==

package/lib/context/endpoint-service-availability-zones.d.ts

@@ -0,0 +1,22 @@
+export declare const ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = "endpoint-service-availability-zones";
+/**
+ * Query to hosted zone context provider
+ */
+export interface EndpointServiceAvailabilityZonesContextQuery {
+    /**
+     * Query account
+     */
+    readonly account?: string;
+    /**
+     * Query region
+     */
+    readonly region?: string;
+    /**
+     * Query service name
+     */
+    readonly serviceName?: string;
+}
+/**
+ * Response of the AZ provider looks like this
+ */
+export type EndpointServiceAvailabilityZonesContextResponse = string[];

package/lib/context/endpoint-service-availability-zones.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = void 0;
+exports.ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = 'endpoint-service-availability-zones';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5kcG9pbnQtc2VydmljZS1hdmFpbGFiaWxpdHktem9uZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJlbmRwb2ludC1zZXJ2aWNlLWF2YWlsYWJpbGl0eS16b25lcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLDJDQUEyQyxHQUFHLHFDQUFxQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IEVORFBPSU5UX1NFUlZJQ0VfQVZBSUxBQklMSVRZX1pPTkVfUFJPVklERVIgPSAnZW5kcG9pbnQtc2VydmljZS1hdmFpbGFiaWxpdHktem9uZXMnO1xuXG4vKipcbiAqIFF1ZXJ5IHRvIGhvc3RlZCB6b25lIGNvbnRleHQgcHJvdmlkZXJcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFbmRwb2ludFNlcnZpY2VBdmFpbGFiaWxpdHlab25lc0NvbnRleHRRdWVyeSB7XG4gIC8qKlxuICAgKiBRdWVyeSBhY2NvdW50XG4gICAqL1xuICByZWFkb25seSBhY2NvdW50Pzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBRdWVyeSByZWdpb25cbiAgICovXG4gIHJlYWRvbmx5IHJlZ2lvbj86IHN0cmluZztcblxuICAvKipcbiAgICogUXVlcnkgc2VydmljZSBuYW1lXG4gICAqL1xuICByZWFkb25seSBzZXJ2aWNlTmFtZT86IHN0cmluZztcbn1cblxuLyoqXG4gKiBSZXNwb25zZSBvZiB0aGUgQVogcHJvdmlkZXIgbG9va3MgbGlrZSB0aGlzXG4gKi9cbmV4cG9ydCB0eXBlIEVuZHBvaW50U2VydmljZUF2YWlsYWJpbGl0eVpvbmVzQ29udGV4dFJlc3BvbnNlID0gc3RyaW5nW107XG4iXX0=

package/lib/context/generic.d.ts

@@ -0,0 +1,4 @@
+/**
+ * If a context value is an object with this key, it indicates an error
+ */
+export declare const PROVIDER_ERROR_KEY = "$providerError";

package/lib/context/generic.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_ERROR_KEY = void 0;
+/**
+ * If a context value is an object with this key, it indicates an error
+ */
+exports.PROVIDER_ERROR_KEY = '$providerError';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJpYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImdlbmVyaWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7O0dBRUc7QUFDVSxRQUFBLGtCQUFrQixHQUFHLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBJZiBhIGNvbnRleHQgdmFsdWUgaXMgYW4gb2JqZWN0IHdpdGggdGhpcyBrZXksIGl0IGluZGljYXRlcyBhbiBlcnJvclxuICovXG5leHBvcnQgY29uc3QgUFJPVklERVJfRVJST1JfS0VZID0gJyRwcm92aWRlckVycm9yJztcbiJdfQ==

package/lib/context/key.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Properties of a discovered key
+ */
+export interface KeyContextResponse {
+    /**
+     * Id of the key
+     */
+    readonly keyId: string;
+}

package/lib/context/key.js

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

package/lib/context/load-balancer.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Load balancer ip address type.
+ */
+export declare enum LoadBalancerIpAddressType {
+    /**
+     * IPV4 ip address
+     */
+    IPV4 = "ipv4",
+    /**
+     * Dual stack address
+     */
+    DUAL_STACK = "dualstack",
+    /**
+     * IPv6 only public addresses, with private IPv4 and IPv6 addresses
+     */
+    DUAL_STACK_WITHOUT_PUBLIC_IPV4 = "dualstack-without-public-ipv4"
+}
+/**
+ * Properties of a discovered load balancer
+ */
+export interface LoadBalancerContextResponse {
+    /**
+     * The ARN of the load balancer.
+     */
+    readonly loadBalancerArn: string;
+    /**
+     * The hosted zone ID of the load balancer's name.
+     */
+    readonly loadBalancerCanonicalHostedZoneId: string;
+    /**
+     * Load balancer's DNS name
+     */
+    readonly loadBalancerDnsName: string;
+    /**
+     * Type of IP address
+     */
+    readonly ipAddressType: LoadBalancerIpAddressType;
+    /**
+     * Load balancer's security groups
+     */
+    readonly securityGroupIds: string[];
+    /**
+     * Load balancer's VPC
+     */
+    readonly vpcId: string;
+}
+/**
+ * Properties of a discovered load balancer listener.
+ */
+export interface LoadBalancerListenerContextResponse {
+    /**
+     * The ARN of the listener.
+     */
+    readonly listenerArn: string;
+    /**
+     * The port the listener is listening on.
+     */
+    readonly listenerPort: number;
+    /**
+     * The security groups of the load balancer.
+     */
+    readonly securityGroupIds: string[];
+}

package/lib/context/load-balancer.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancerIpAddressType = void 0;
+/**
+ * Load balancer ip address type.
+ */
+var LoadBalancerIpAddressType;
+(function (LoadBalancerIpAddressType) {
+    /**
+     * IPV4 ip address
+     */
+    LoadBalancerIpAddressType["IPV4"] = "ipv4";
+    /**
+     * Dual stack address
+     */
+    LoadBalancerIpAddressType["DUAL_STACK"] = "dualstack";
+    /**
+     * IPv6 only public addresses, with private IPv4 and IPv6 addresses
+     */
+    LoadBalancerIpAddressType["DUAL_STACK_WITHOUT_PUBLIC_IPV4"] = "dualstack-without-public-ipv4";
+})(LoadBalancerIpAddressType || (exports.LoadBalancerIpAddressType = LoadBalancerIpAddressType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/context/security-group.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Properties of a discovered SecurityGroup.
+ */
+export interface SecurityGroupContextResponse {
+    /**
+     * The security group's id.
+     */
+    readonly securityGroupId: string;
+    /**
+     * Whether the security group allows all outbound traffic. This will be true
+     * when the security group has all-protocol egress permissions to access both
+     * `0.0.0.0/0` and `::/0`.
+     */
+    readonly allowAllOutbound: boolean;
+}