@aws-cdk/toolkit-lib 0.1.0

package/lib/api/cloud-assembly/private/source-builder.d.ts

@@ -0,0 +1,29 @@
+import type { ICloudAssemblySource } from '../';
+import { ToolkitServices } from '../../../toolkit/private';
+import { AssemblyBuilder, AssemblySourceProps } from '../source-builder';
+export declare abstract class CloudAssemblySourceBuilder {
+    /**
+     * Helper to provide the CloudAssemblySourceBuilder with required toolkit services
+     * @deprecated this should move to the toolkit really.
+     */
+    protected abstract sourceBuilderServices(): Promise<ToolkitServices>;
+    /**
+     * Create a Cloud Assembly from a Cloud Assembly builder function.
+     * @param builder the builder function
+     * @param props additional configuration properties
+     * @returns the CloudAssembly source
+     */
+    fromAssemblyBuilder(builder: AssemblyBuilder, props?: AssemblySourceProps): Promise<ICloudAssemblySource>;
+    /**
+     * Creates a Cloud Assembly from an existing assembly directory.
+     * @param directory the directory of a already produced Cloud Assembly.
+     * @returns the CloudAssembly source
+     */
+    fromAssemblyDirectory(directory: string): Promise<ICloudAssemblySource>;
+    /**
+     * Use a directory containing an AWS CDK app as source.
+     * @param props additional configuration properties
+     * @returns the CloudAssembly source
+     */
+    fromCdkApp(app: string, props?: AssemblySourceProps): Promise<ICloudAssemblySource>;
+}

package/lib/api/cloud-assembly/private/source-builder.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudAssemblySourceBuilder = void 0;
+const cxapi = require("@aws-cdk/cx-api");
+const fs = require("fs-extra");
+const context_aware_source_1 = require("./context-aware-source");
+const exec_1 = require("./exec");
+const prepare_source_1 = require("./prepare-source");
+const aws_cdk_1 = require("../../aws-cdk");
+const errors_1 = require("../../errors");
+const private_1 = require("../../io/private");
+class CloudAssemblySourceBuilder {
+    /**
+     * Create a Cloud Assembly from a Cloud Assembly builder function.
+     * @param builder the builder function
+     * @param props additional configuration properties
+     * @returns the CloudAssembly source
+     */
+    async fromAssemblyBuilder(builder, props = {}) {
+        const services = await this.sourceBuilderServices();
+        const context = new aws_cdk_1.Context({ bag: new aws_cdk_1.Settings(props.context ?? {}) });
+        const contextAssemblyProps = {
+            services,
+            context,
+            lookups: props.lookups,
+        };
+        return new context_aware_source_1.ContextAwareCloudAssembly({
+            produce: async () => {
+                const outdir = (0, prepare_source_1.determineOutputDirectory)(props.outdir);
+                const env = await (0, prepare_source_1.prepareDefaultEnvironment)(services, { outdir });
+                const assembly = await (0, prepare_source_1.changeDir)(async () => (0, prepare_source_1.withContext)(context.all, env, props.synthOptions ?? {}, async (envWithContext, ctx) => (0, prepare_source_1.withEnv)(envWithContext, () => builder({
+                    outdir,
+                    context: ctx,
+                }))), props.workingDirectory);
+                if (cxapi.CloudAssembly.isCloudAssembly(assembly)) {
+                    return assembly;
+                }
+                return new cxapi.CloudAssembly(assembly.directory);
+            },
+        }, contextAssemblyProps);
+    }
+    /**
+     * Creates a Cloud Assembly from an existing assembly directory.
+     * @param directory the directory of a already produced Cloud Assembly.
+     * @returns the CloudAssembly source
+     */
+    async fromAssemblyDirectory(directory) {
+        const services = await this.sourceBuilderServices();
+        const contextAssemblyProps = {
+            services,
+            context: new aws_cdk_1.Context(), // @todo there is probably a difference between contextaware and contextlookup sources
+            lookups: false,
+        };
+        return new context_aware_source_1.ContextAwareCloudAssembly({
+            produce: async () => {
+                // @todo build
+                await services.ioHost.notify((0, private_1.debug)('--app points to a cloud assembly, so we bypass synth'));
+                return (0, prepare_source_1.assemblyFromDirectory)(directory, services.ioHost);
+            },
+        }, contextAssemblyProps);
+    }
+    /**
+     * Use a directory containing an AWS CDK app as source.
+     * @param props additional configuration properties
+     * @returns the CloudAssembly source
+     */
+    async fromCdkApp(app, props = {}) {
+        const services = await this.sourceBuilderServices();
+        // @todo this definitely needs to read files from the CWD
+        const context = new aws_cdk_1.Context({ bag: new aws_cdk_1.Settings(props.context ?? {}) });
+        const contextAssemblyProps = {
+            services,
+            context,
+            lookups: props.lookups,
+        };
+        return new context_aware_source_1.ContextAwareCloudAssembly({
+            produce: async () => {
+                let lock = undefined;
+                try {
+                    // @todo build
+                    // const build = this.props.configuration.settings.get(['build']);
+                    // if (build) {
+                    //   await execInChildProcess(build, { cwd: props.workingDirectory });
+                    // }
+                    const commandLine = await (0, prepare_source_1.guessExecutable)(app);
+                    const outdir = props.outdir ?? 'cdk.out';
+                    try {
+                        fs.mkdirpSync(outdir);
+                    }
+                    catch (e) {
+                        throw new errors_1.ToolkitError(`Could not create output directory at '${outdir}' (${e.message}).`);
+                    }
+                    lock = await new aws_cdk_1.RWLock(outdir).acquireWrite();
+                    const env = await (0, prepare_source_1.prepareDefaultEnvironment)(services, { outdir });
+                    return await (0, prepare_source_1.withContext)(context.all, env, props.synthOptions, async (envWithContext, _ctx) => {
+                        await (0, exec_1.execInChildProcess)(commandLine.join(' '), {
+                            eventPublisher: async (type, line) => {
+                                switch (type) {
+                                    case 'data_stdout':
+                                        await services.ioHost.notify((0, private_1.info)(line, 'CDK_ASSEMBLY_I1001'));
+                                        break;
+                                    case 'data_stderr':
+                                        await services.ioHost.notify((0, private_1.error)(line, 'CDK_ASSEMBLY_E1002'));
+                                        break;
+                                }
+                            },
+                            extraEnv: envWithContext,
+                            cwd: props.workingDirectory,
+                        });
+                        return (0, prepare_source_1.assemblyFromDirectory)(outdir, services.ioHost);
+                    });
+                }
+                finally {
+                    await lock?.release();
+                }
+            },
+        }, contextAssemblyProps);
+    }
+}
+exports.CloudAssemblySourceBuilder = CloudAssemblySourceBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-builder.js","sourceRoot":"","sources":["source-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { ICloudAssemblySource } from '../';\nimport { ContextAwareCloudAssembly, ContextAwareCloudAssemblyProps } from './context-aware-source';\nimport { execInChildProcess } from './exec';\nimport { assemblyFromDirectory, changeDir, determineOutputDirectory, guessExecutable, prepareDefaultEnvironment, withContext, withEnv } from './prepare-source';\nimport { ToolkitServices } from '../../../toolkit/private';\nimport { Context, ILock, RWLock, Settings } from '../../aws-cdk';\nimport { ToolkitError } from '../../errors';\nimport { debug, error, info } from '../../io/private';\nimport { AssemblyBuilder, AssemblySourceProps } from '../source-builder';\n\nexport abstract class CloudAssemblySourceBuilder {\n  /**\n   * Helper to provide the CloudAssemblySourceBuilder with required toolkit services\n   * @deprecated this should move to the toolkit really.\n   */\n  protected abstract sourceBuilderServices(): Promise<ToolkitServices>;\n\n  /**\n   * Create a Cloud Assembly from a Cloud Assembly builder function.\n   * @param builder the builder function\n   * @param props additional configuration properties\n   * @returns the CloudAssembly source\n   */\n  public async fromAssemblyBuilder(\n    builder: AssemblyBuilder,\n    props: AssemblySourceProps = {},\n  ): Promise<ICloudAssemblySource> {\n    const services = await this.sourceBuilderServices();\n    const context = new Context({ bag: new Settings(props.context ?? {}) });\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      context,\n      lookups: props.lookups,\n    };\n\n    return new ContextAwareCloudAssembly(\n      {\n        produce: async () => {\n          const outdir = determineOutputDirectory(props.outdir);\n          const env = await prepareDefaultEnvironment(services, { outdir });\n          const assembly = await changeDir(async () =>\n            withContext(context.all, env, props.synthOptions ?? {}, async (envWithContext, ctx) =>\n              withEnv(envWithContext, () => builder({\n                outdir,\n                context: ctx,\n              })),\n            ), props.workingDirectory);\n\n          if (cxapi.CloudAssembly.isCloudAssembly(assembly)) {\n            return assembly;\n          }\n\n          return new cxapi.CloudAssembly(assembly.directory);\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n\n  /**\n   * Creates a Cloud Assembly from an existing assembly directory.\n   * @param directory the directory of a already produced Cloud Assembly.\n   * @returns the CloudAssembly source\n   */\n  public async fromAssemblyDirectory(directory: string): Promise<ICloudAssemblySource> {\n    const services: ToolkitServices = await this.sourceBuilderServices();\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      context: new Context(), // @todo there is probably a difference between contextaware and contextlookup sources\n      lookups: false,\n    };\n\n    return new ContextAwareCloudAssembly(\n      {\n        produce: async () => {\n          // @todo build\n          await services.ioHost.notify(debug('--app points to a cloud assembly, so we bypass synth'));\n          return assemblyFromDirectory(directory, services.ioHost);\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n  /**\n   * Use a directory containing an AWS CDK app as source.\n   * @param props additional configuration properties\n   * @returns the CloudAssembly source\n   */\n  public async fromCdkApp(app: string, props: AssemblySourceProps = {}): Promise<ICloudAssemblySource> {\n    const services: ToolkitServices = await this.sourceBuilderServices();\n    // @todo this definitely needs to read files from the CWD\n    const context = new Context({ bag: new Settings(props.context ?? {}) });\n    const contextAssemblyProps: ContextAwareCloudAssemblyProps = {\n      services,\n      context,\n      lookups: props.lookups,\n    };\n\n    return new ContextAwareCloudAssembly(\n      {\n        produce: async () => {\n          let lock: ILock | undefined = undefined;\n          try {\n            // @todo build\n            // const build = this.props.configuration.settings.get(['build']);\n            // if (build) {\n            //   await execInChildProcess(build, { cwd: props.workingDirectory });\n            // }\n\n            const commandLine = await guessExecutable(app);\n            const outdir = props.outdir ?? 'cdk.out';\n\n            try {\n              fs.mkdirpSync(outdir);\n            } catch (e: any) {\n              throw new ToolkitError(`Could not create output directory at '${outdir}' (${e.message}).`);\n            }\n\n            lock = await new RWLock(outdir).acquireWrite();\n\n            const env = await prepareDefaultEnvironment(services, { outdir });\n            return await withContext(context.all, env, props.synthOptions, async (envWithContext, _ctx) => {\n              await execInChildProcess(commandLine.join(' '), {\n                eventPublisher: async (type, line) => {\n                  switch (type) {\n                    case 'data_stdout':\n                      await services.ioHost.notify(info(line, 'CDK_ASSEMBLY_I1001'));\n                      break;\n                    case 'data_stderr':\n                      await services.ioHost.notify(error(line, 'CDK_ASSEMBLY_E1002'));\n                      break;\n                  }\n                },\n                extraEnv: envWithContext,\n                cwd: props.workingDirectory,\n              });\n              return assemblyFromDirectory(outdir, services.ioHost);\n            });\n          } finally {\n            await lock?.release();\n          }\n        },\n      },\n      contextAssemblyProps,\n    );\n  }\n}\n\n"]}

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

@@ -0,0 +1,30 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import { CloudAssembly, StackCollection } from '../../aws-cdk';
+import { StackSelector } from '../stack-selector';
+import { ICloudAssemblySource } from '../types';
+/**
+ * A single Cloud Assembly wrapped to provide additional stack operations.
+ */
+export declare class StackAssembly extends CloudAssembly implements ICloudAssemblySource {
+    produce(): Promise<cxapi.CloudAssembly>;
+    /**
+     * Improved stack selection interface with a single selector
+     * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`
+     * @throws when individual selection strategies are not satisfied
+     */
+    selectStacksV2(selector: StackSelector): StackCollection;
+    /**
+     * Select all stacks.
+     *
+     * This method never throws and can safely be used as a basis for other calculations.
+     *
+     * @returns a `StackCollection` of all stacks
+     */
+    selectAllStacks(): StackCollection;
+    /**
+     * Select all stacks that have the validateOnSynth flag et.
+     *
+     * @returns a `StackCollection` of all stacks that needs to be validated
+     */
+    selectStacksForValidation(): StackCollection;
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackAssembly = void 0;
+const semver_1 = require("semver");
+const aws_cdk_1 = require("../../aws-cdk");
+const errors_1 = require("../../errors");
+const stack_selector_1 = require("../stack-selector");
+/**
+ * A single Cloud Assembly wrapped to provide additional stack operations.
+ */
+class StackAssembly extends aws_cdk_1.CloudAssembly {
+    async produce() {
+        return this.assembly;
+    }
+    /**
+     * Improved stack selection interface with a single selector
+     * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`
+     * @throws when individual selection strategies are not satisfied
+     */
+    selectStacksV2(selector) {
+        const asm = this.assembly;
+        const topLevelStacks = asm.stacks;
+        const allStacks = (0, semver_1.major)(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;
+        if (allStacks.length === 0 && (selector.failOnEmpty ?? true)) {
+            throw new errors_1.ToolkitError('This app contains no stacks');
+        }
+        const extend = expandToExtendEnum(selector.expand);
+        const patterns = (0, aws_cdk_1.sanitizePatterns)(selector.patterns ?? []);
+        switch (selector.strategy) {
+            case stack_selector_1.StackSelectionStrategy.ALL_STACKS:
+                return new aws_cdk_1.StackCollection(this, allStacks);
+            case stack_selector_1.StackSelectionStrategy.MAIN_ASSEMBLY:
+                if (topLevelStacks.length < 1) {
+                    // @todo text should probably be handled in io host
+                    throw new errors_1.ToolkitError('No stack found in the main cloud assembly. Use "list" to print manifest');
+                }
+                return this.extendStacks(topLevelStacks, allStacks, extend);
+            case stack_selector_1.StackSelectionStrategy.ONLY_SINGLE:
+                if (topLevelStacks.length !== 1) {
+                    // @todo text should probably be handled in io host
+                    throw new errors_1.ToolkitError('Since this app includes more than a single stack, specify which stacks to use (wildcards are supported) or specify `--all`\n' +
+                        `Stacks: ${allStacks.map(x => x.hierarchicalId).join(' · ')}`);
+                }
+                return new aws_cdk_1.StackCollection(this, topLevelStacks);
+            default:
+                const matched = this.selectMatchingStacks(allStacks, patterns, extend);
+                if (selector.strategy === stack_selector_1.StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE
+                    && matched.stackCount !== 1) {
+                    // @todo text should probably be handled in io host
+                    throw new errors_1.ToolkitError(`Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`);
+                }
+                if (selector.strategy === stack_selector_1.StackSelectionStrategy.PATTERN_MUST_MATCH
+                    && matched.stackCount < 1) {
+                    // @todo text should probably be handled in io host
+                    throw new errors_1.ToolkitError(`Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`);
+                }
+                return matched;
+        }
+    }
+    /**
+     * Select all stacks.
+     *
+     * This method never throws and can safely be used as a basis for other calculations.
+     *
+     * @returns a `StackCollection` of all stacks
+     */
+    selectAllStacks() {
+        const allStacks = (0, semver_1.major)(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;
+        return new aws_cdk_1.StackCollection(this, allStacks);
+    }
+    /**
+     * Select all stacks that have the validateOnSynth flag et.
+     *
+     * @returns a `StackCollection` of all stacks that needs to be validated
+     */
+    selectStacksForValidation() {
+        const allStacks = this.selectAllStacks();
+        return allStacks.filter((art) => art.validateOnSynth ?? false);
+    }
+}
+exports.StackAssembly = StackAssembly;
+function expandToExtendEnum(extend) {
+    switch (extend) {
+        case stack_selector_1.ExpandStackSelection.DOWNSTREAM:
+            return aws_cdk_1.ExtendedStackSelection.Downstream;
+        case stack_selector_1.ExpandStackSelection.UPSTREAM:
+            return aws_cdk_1.ExtendedStackSelection.Upstream;
+        case stack_selector_1.ExpandStackSelection.NONE:
+            return aws_cdk_1.ExtendedStackSelection.None;
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-assembly.js","sourceRoot":"","sources":["stack-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport { major } from 'semver';\nimport { CloudAssembly, sanitizePatterns, StackCollection, ExtendedStackSelection as CliExtendedStackSelection } from '../../aws-cdk';\nimport { ToolkitError } from '../../errors';\nimport { ExpandStackSelection, StackSelectionStrategy, StackSelector } from '../stack-selector';\nimport { ICloudAssemblySource } from '../types';\n\n/**\n * A single Cloud Assembly wrapped to provide additional stack operations.\n */\nexport class StackAssembly extends CloudAssembly implements ICloudAssemblySource {\n  public async produce(): Promise<cxapi.CloudAssembly> {\n    return this.assembly;\n  }\n\n  /**\n   * Improved stack selection interface with a single selector\n   * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`\n   * @throws when individual selection strategies are not satisfied\n   */\n  public selectStacksV2(selector: StackSelector): StackCollection {\n    const asm = this.assembly;\n    const topLevelStacks = asm.stacks;\n    const allStacks = major(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;\n\n    if (allStacks.length === 0 && (selector.failOnEmpty ?? true)) {\n      throw new ToolkitError('This app contains no stacks');\n    }\n\n    const extend = expandToExtendEnum(selector.expand);\n    const patterns = sanitizePatterns(selector.patterns ?? []);\n\n    switch (selector.strategy) {\n      case StackSelectionStrategy.ALL_STACKS:\n        return new StackCollection(this, allStacks);\n      case StackSelectionStrategy.MAIN_ASSEMBLY:\n        if (topLevelStacks.length < 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('No stack found in the main cloud assembly. Use \"list\" to print manifest');\n        }\n        return this.extendStacks(topLevelStacks, allStacks, extend);\n      case StackSelectionStrategy.ONLY_SINGLE:\n        if (topLevelStacks.length !== 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('Since this app includes more than a single stack, specify which stacks to use (wildcards are supported) or specify `--all`\\n' +\n          `Stacks: ${allStacks.map(x => x.hierarchicalId).join(' · ')}`);\n        }\n        return new StackCollection(this, topLevelStacks);\n      default:\n        const matched = this.selectMatchingStacks(allStacks, patterns, extend);\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE\n          && matched.stackCount !== 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH\n          && matched.stackCount < 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n\n        return matched;\n    }\n  }\n\n  /**\n   * Select all stacks.\n   *\n   * This method never throws and can safely be used as a basis for other calculations.\n   *\n   * @returns a `StackCollection` of all stacks\n   */\n  public selectAllStacks() {\n    const allStacks = major(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;\n    return new StackCollection(this, allStacks);\n  }\n\n  /**\n   * Select all stacks that have the validateOnSynth flag et.\n   *\n   * @returns a `StackCollection` of all stacks that needs to be validated\n   */\n  public selectStacksForValidation() {\n    const allStacks = this.selectAllStacks();\n    return allStacks.filter((art) => art.validateOnSynth ?? false);\n  }\n}\n\nfunction expandToExtendEnum(extend?: ExpandStackSelection): CliExtendedStackSelection | undefined {\n  switch (extend) {\n    case ExpandStackSelection.DOWNSTREAM:\n      return CliExtendedStackSelection.Downstream;\n    case ExpandStackSelection.UPSTREAM:\n      return CliExtendedStackSelection.Upstream;\n    case ExpandStackSelection.NONE:\n      return CliExtendedStackSelection.None;\n    default:\n      return undefined;\n  }\n}\n"]}

package/lib/api/cloud-assembly/private/stack-selectors.d.ts

@@ -0,0 +1,2 @@
+import { StackSelector } from '../stack-selector';
+export declare const ALL_STACKS: StackSelector;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_STACKS = void 0;
+const stack_selector_1 = require("../stack-selector");
+exports.ALL_STACKS = {
+    strategy: stack_selector_1.StackSelectionStrategy.ALL_STACKS,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhY2stc2VsZWN0b3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic3RhY2stc2VsZWN0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHNEQUEwRTtBQUU3RCxRQUFBLFVBQVUsR0FBa0I7SUFDdkMsUUFBUSxFQUFFLHVDQUFzQixDQUFDLFVBQVU7Q0FDNUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFN0YWNrU2VsZWN0aW9uU3RyYXRlZ3ksIFN0YWNrU2VsZWN0b3IgfSBmcm9tICcuLi9zdGFjay1zZWxlY3Rvcic7XG5cbmV4cG9ydCBjb25zdCBBTExfU1RBQ0tTOiBTdGFja1NlbGVjdG9yID0ge1xuICBzdHJhdGVneTogU3RhY2tTZWxlY3Rpb25TdHJhdGVneS5BTExfU1RBQ0tTLFxufTtcbiJdfQ==

package/lib/api/cloud-assembly/source-builder.d.ts

@@ -0,0 +1,113 @@
+import type * as cxschema from '@aws-cdk/cloud-assembly-schema';
+/**
+ * Properties the builder function receives.
+ */
+export interface AssemblyBuilderProps {
+    /**
+     * The output directory into which to the builder app will emit synthesized artifacts.
+     */
+    readonly outdir?: string;
+    /**
+     * The context provided tp the builder app to synthesize the Cloud Assembly, including looked-up context.
+     */
+    readonly context?: {
+        [key: string]: any;
+    };
+}
+export type AssemblyBuilder = (props: AssemblyBuilderProps) => Promise<cxschema.ICloudAssembly>;
+/**
+ * Configuration for creating a CLI from an AWS CDK App directory
+ */
+export interface AssemblySourceProps {
+    /**
+     * Execute the application in this working directory.
+     *
+     * @default - current working directory
+     */
+    readonly workingDirectory?: string;
+    /**
+     * Emits the synthesized cloud assembly into a directory
+     *
+     * @default cdk.out
+     */
+    readonly outdir?: string;
+    /**
+     * Perform context lookups.
+     *
+     * Synthesis fails if this is disabled and context lookups need to be performed.
+     *
+     * @default true
+     */
+    readonly lookups?: boolean;
+    /**
+     * Context values for the application.
+     *
+     * Context can be read in the app from any construct using `node.getContext(key)`.
+     *
+     * @default - no context
+     */
+    readonly context?: {
+        [key: string]: any;
+    };
+    /**
+     * Options that are passed through the context to a CDK app on synth
+     */
+    readonly synthOptions?: AppSynthOptions;
+}
+/**
+ * Settings that are passed to a CDK app via the context
+ */
+export interface AppSynthOptions {
+    /**
+     * Debug the CDK app.
+     * Logs additional information during synthesis, such as creation stack traces of tokens.
+     * This also sets the `CDK_DEBUG` env variable and will slow down synthesis.
+     *
+     * @default false
+     */
+    readonly debug?: boolean;
+    /**
+     * Enables the embedding of the "aws:cdk:path" in CloudFormation template metadata.
+     *
+     * @default true
+     */
+    readonly pathMetadata?: boolean;
+    /**
+     * Enable the collection and reporting of version information.
+     *
+     * @default true
+     */
+    readonly versionReporting?: boolean;
+    /**
+     * Whe enabled, `aws:asset:xxx` metadata entries are added to the template.
+     *
+     * Disabling this can be useful in certain cases like integration tests.
+     *
+     * @default true
+     */
+    readonly assetMetadata?: boolean;
+    /**
+     * Enable asset staging.
+     *
+     * Disabling asset staging means that copyable assets will not be copied to the
+     * output directory and will be referenced with absolute paths.
+     *
+     * Not copied to the output directory: this is so users can iterate on the
+     * Lambda source and run SAM CLI without having to re-run CDK (note: we
+     * cannot achieve this for bundled assets, if assets are bundled they
+     * will have to re-run CDK CLI to re-bundle updated versions).
+     *
+     * Absolute path: SAM CLI expects `cwd`-relative paths in a resource's
+     * `aws:asset:path` metadata. In order to be predictable, we will always output
+     * absolute paths.
+     *
+     * @default true
+     */
+    readonly assetStaging?: boolean;
+    /**
+     * Select which stacks should have asset bundling enabled
+     *
+     * @default ["**"] - all stacks
+     */
+    readonly bundlingForStacks?: string;
+}

package/lib/api/cloud-assembly/source-builder.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

package/lib/api/cloud-assembly/types.d.ts

@@ -0,0 +1,7 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+export interface ICloudAssemblySource {
+    /**
+     * Produce a CloudAssembly from the current source
+     */
+    produce(): Promise<cxapi.CloudAssembly>;
+}

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

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