@aws-cdk/toolkit-lib 0.1.0

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

@@ -0,0 +1,3 @@
+export * from './source-builder';
+export * from './stack-selector';
+export * from './types';

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./source-builder"), exports);
+__exportStar(require("./stack-selector"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDO0FBQ2pDLG1EQUFpQztBQUNqQywwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NvdXJjZS1idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2stc2VsZWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5cbiJdfQ==

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

@@ -0,0 +1,15 @@
+import { CloudAssembly } from '@aws-cdk/cx-api';
+import { ICloudAssemblySource } from '../types';
+/**
+ * A CloudAssemblySource that is caching its result once produced.
+ *
+ * Most Toolkit interactions should use a cached source.
+ * Not caching is relevant when the source changes frequently
+ * and it is to expensive to predict if the source has changed.
+ */
+export declare class CachedCloudAssemblySource implements ICloudAssemblySource {
+    private source;
+    private cloudAssembly;
+    constructor(source: ICloudAssemblySource);
+    produce(): Promise<CloudAssembly>;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedCloudAssemblySource = void 0;
+/**
+ * A CloudAssemblySource that is caching its result once produced.
+ *
+ * Most Toolkit interactions should use a cached source.
+ * Not caching is relevant when the source changes frequently
+ * and it is to expensive to predict if the source has changed.
+ */
+class CachedCloudAssemblySource {
+    source;
+    cloudAssembly;
+    constructor(source) {
+        this.source = source;
+    }
+    async produce() {
+        if (!this.cloudAssembly) {
+            this.cloudAssembly = await this.source.produce();
+        }
+        return this.cloudAssembly;
+    }
+}
+exports.CachedCloudAssemblySource = CachedCloudAssemblySource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkLXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImNhY2hlZC1zb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0E7Ozs7OztHQU1HO0FBQ0gsTUFBYSx5QkFBeUI7SUFDNUIsTUFBTSxDQUF1QjtJQUM3QixhQUFhLENBQTRCO0lBRWpELFlBQW1CLE1BQTRCO1FBQzdDLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO0lBQ3ZCLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTztRQUNsQixJQUFJLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQ3hCLElBQUksQ0FBQyxhQUFhLEdBQUcsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ25ELENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUM7SUFDNUIsQ0FBQztDQUNGO0FBZEQsOERBY0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDbG91ZEFzc2VtYmx5IH0gZnJvbSAnQGF3cy1jZGsvY3gtYXBpJztcbmltcG9ydCB7IElDbG91ZEFzc2VtYmx5U291cmNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG4vKipcbiAqIEEgQ2xvdWRBc3NlbWJseVNvdXJjZSB0aGF0IGlzIGNhY2hpbmcgaXRzIHJlc3VsdCBvbmNlIHByb2R1Y2VkLlxuICpcbiAqIE1vc3QgVG9vbGtpdCBpbnRlcmFjdGlvbnMgc2hvdWxkIHVzZSBhIGNhY2hlZCBzb3VyY2UuXG4gKiBOb3QgY2FjaGluZyBpcyByZWxldmFudCB3aGVuIHRoZSBzb3VyY2UgY2hhbmdlcyBmcmVxdWVudGx5XG4gKiBhbmQgaXQgaXMgdG8gZXhwZW5zaXZlIHRvIHByZWRpY3QgaWYgdGhlIHNvdXJjZSBoYXMgY2hhbmdlZC5cbiAqL1xuZXhwb3J0IGNsYXNzIENhY2hlZENsb3VkQXNzZW1ibHlTb3VyY2UgaW1wbGVtZW50cyBJQ2xvdWRBc3NlbWJseVNvdXJjZSB7XG4gIHByaXZhdGUgc291cmNlOiBJQ2xvdWRBc3NlbWJseVNvdXJjZTtcbiAgcHJpdmF0ZSBjbG91ZEFzc2VtYmx5OiBDbG91ZEFzc2VtYmx5IHwgdW5kZWZpbmVkO1xuXG4gIHB1YmxpYyBjb25zdHJ1Y3Rvcihzb3VyY2U6IElDbG91ZEFzc2VtYmx5U291cmNlKSB7XG4gICAgdGhpcy5zb3VyY2UgPSBzb3VyY2U7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgcHJvZHVjZSgpOiBQcm9taXNlPENsb3VkQXNzZW1ibHk+IHtcbiAgICBpZiAoIXRoaXMuY2xvdWRBc3NlbWJseSkge1xuICAgICAgdGhpcy5jbG91ZEFzc2VtYmx5ID0gYXdhaXQgdGhpcy5zb3VyY2UucHJvZHVjZSgpO1xuICAgIH1cbiAgICByZXR1cm4gdGhpcy5jbG91ZEFzc2VtYmx5O1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,45 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import { ToolkitServices } from '../../../toolkit/private';
+import { type Context } from '../../aws-cdk';
+import { ICloudAssemblySource } from '../types';
+export interface ContextAwareCloudAssemblyProps {
+    /**
+     * AWS object (used by contextprovider)
+     * @deprecated context should be moved to the toolkit itself
+     */
+    readonly services: ToolkitServices;
+    /**
+     * Application context
+     */
+    readonly context: Context;
+    /**
+     * The file used to store application context in (relative to cwd).
+     *
+     * @default "cdk.context.json"
+     */
+    readonly contextFile?: string;
+    /**
+     * Enable context lookups.
+     *
+     * Producing a `cxapi.CloudAssembly` will fail if this is disabled and context lookups need to be performed.
+     *
+     * @default true
+     */
+    readonly lookups?: boolean;
+}
+/**
+ * Represent the Cloud Executable and the synthesis we can do on it
+ */
+export declare class ContextAwareCloudAssembly implements ICloudAssemblySource {
+    private readonly source;
+    private readonly props;
+    private canLookup;
+    private context;
+    private contextFile;
+    private ioHost;
+    constructor(source: ICloudAssemblySource, props: ContextAwareCloudAssemblyProps);
+    /**
+     * Produce a Cloud Assembly, i.e. a set of stacks
+     */
+    produce(): Promise<cxapi.CloudAssembly>;
+}

package/lib/api/cloud-assembly/private/context-aware-source.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextAwareCloudAssembly = void 0;
+const aws_cdk_1 = require("../../aws-cdk");
+const errors_1 = require("../../errors");
+const private_1 = require("../../io/private");
+/**
+ * Represent the Cloud Executable and the synthesis we can do on it
+ */
+class ContextAwareCloudAssembly {
+    source;
+    props;
+    canLookup;
+    context;
+    contextFile;
+    ioHost;
+    constructor(source, props) {
+        this.source = source;
+        this.props = props;
+        this.canLookup = props.lookups ?? true;
+        this.context = props.context;
+        this.contextFile = props.contextFile ?? aws_cdk_1.PROJECT_CONTEXT; // @todo new feature not needed right now
+        this.ioHost = props.services.ioHost;
+    }
+    /**
+     * Produce a Cloud Assembly, i.e. a set of stacks
+     */
+    async produce() {
+        // We may need to run the cloud assembly source multiple times in order to satisfy all missing context
+        // (When the source producer runs, it will tell us about context it wants to use
+        // but it missing. We'll then look up the context and run the executable again, and
+        // again, until it doesn't complain anymore or we've stopped making progress).
+        let previouslyMissingKeys;
+        while (true) {
+            const assembly = await this.source.produce();
+            if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {
+                const missingKeys = missingContextKeys(assembly.manifest.missing);
+                if (!this.canLookup) {
+                    throw new errors_1.ToolkitError('Context lookups have been disabled. '
+                        + 'Make sure all necessary context is already in \'cdk.context.json\' by running \'cdk synth\' on a machine with sufficient AWS credentials and committing the result. '
+                        + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);
+                }
+                let tryLookup = true;
+                if (previouslyMissingKeys && equalSets(missingKeys, previouslyMissingKeys)) {
+                    await this.ioHost.notify((0, private_1.debug)('Not making progress trying to resolve environmental context. Giving up.'));
+                    tryLookup = false;
+                }
+                previouslyMissingKeys = missingKeys;
+                if (tryLookup) {
+                    await this.ioHost.notify((0, private_1.debug)('Some context information is missing. Fetching...', 'CDK_ASSEMBLY_I0241', {
+                        missingKeys: Array.from(missingKeys),
+                    }));
+                    await aws_cdk_1.contextproviders.provideContextValues(assembly.manifest.missing, this.context, this.props.services.sdkProvider);
+                    // Cache the new context to disk
+                    await this.ioHost.notify((0, private_1.debug)(`Writing updated context to ${this.contextFile}...`, 'CDK_ASSEMBLY_I0042', {
+                        contextFile: this.contextFile,
+                        context: this.context.all,
+                    }));
+                    await this.context.save(this.contextFile);
+                    // Execute again
+                    continue;
+                }
+            }
+            return assembly;
+        }
+    }
+}
+exports.ContextAwareCloudAssembly = ContextAwareCloudAssembly;
+/**
+ * Return all keys of missing context items
+ */
+function missingContextKeys(missing) {
+    return new Set((missing || []).map(m => m.key));
+}
+/**
+ * Are two sets equal to each other
+ */
+function equalSets(a, b) {
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const x of a) {
+        if (!b.has(x)) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-aware-source.js","sourceRoot":"","sources":["context-aware-source.ts"],"names":[],"mappings":"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","sourcesContent":["import type { MissingContext } from '@aws-cdk/cloud-assembly-schema';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport { ToolkitServices } from '../../../toolkit/private';\nimport { type Context, contextproviders, PROJECT_CONTEXT } from '../../aws-cdk';\nimport { ToolkitError } from '../../errors';\nimport { ActionAwareIoHost, debug } from '../../io/private';\nimport { ICloudAssemblySource } from '../types';\n\nexport interface ContextAwareCloudAssemblyProps {\n  /**\n   * AWS object (used by contextprovider)\n   * @deprecated context should be moved to the toolkit itself\n   */\n  readonly services: ToolkitServices;\n\n  /**\n   * Application context\n   */\n  readonly context: Context;\n\n  /**\n   * The file used to store application context in (relative to cwd).\n   *\n   * @default \"cdk.context.json\"\n   */\n  readonly contextFile?: string;\n\n  /**\n   * Enable context lookups.\n   *\n   * Producing a `cxapi.CloudAssembly` will fail if this is disabled and context lookups need to be performed.\n   *\n   * @default true\n   */\n  readonly lookups?: boolean;\n}\n\n/**\n * Represent the Cloud Executable and the synthesis we can do on it\n */\nexport class ContextAwareCloudAssembly implements ICloudAssemblySource {\n  private canLookup: boolean;\n  private context: Context;\n  private contextFile: string;\n  private ioHost: ActionAwareIoHost;\n\n  constructor(private readonly source: ICloudAssemblySource, private readonly props: ContextAwareCloudAssemblyProps) {\n    this.canLookup = props.lookups ?? true;\n    this.context = props.context;\n    this.contextFile = props.contextFile ?? PROJECT_CONTEXT; // @todo new feature not needed right now\n    this.ioHost = props.services.ioHost;\n  }\n\n  /**\n   * Produce a Cloud Assembly, i.e. a set of stacks\n   */\n  public async produce(): Promise<cxapi.CloudAssembly> {\n    // We may need to run the cloud assembly source multiple times in order to satisfy all missing context\n    // (When the source producer runs, it will tell us about context it wants to use\n    // but it missing. We'll then look up the context and run the executable again, and\n    // again, until it doesn't complain anymore or we've stopped making progress).\n    let previouslyMissingKeys: Set<string> | undefined;\n    while (true) {\n      const assembly = await this.source.produce();\n\n      if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n        const missingKeys = missingContextKeys(assembly.manifest.missing);\n\n        if (!this.canLookup) {\n          throw new ToolkitError(\n            'Context lookups have been disabled. '\n            + 'Make sure all necessary context is already in \\'cdk.context.json\\' by running \\'cdk synth\\' on a machine with sufficient AWS credentials and committing the result. '\n            + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);\n        }\n\n        let tryLookup = true;\n        if (previouslyMissingKeys && equalSets(missingKeys, previouslyMissingKeys)) {\n          await this.ioHost.notify(debug('Not making progress trying to resolve environmental context. Giving up.'));\n          tryLookup = false;\n        }\n\n        previouslyMissingKeys = missingKeys;\n\n        if (tryLookup) {\n          await this.ioHost.notify(debug('Some context information is missing. Fetching...', 'CDK_ASSEMBLY_I0241', {\n            missingKeys: Array.from(missingKeys),\n          }));\n          await contextproviders.provideContextValues(\n            assembly.manifest.missing,\n            this.context,\n            this.props.services.sdkProvider,\n          );\n\n          // Cache the new context to disk\n          await this.ioHost.notify(debug(`Writing updated context to ${this.contextFile}...`, 'CDK_ASSEMBLY_I0042', {\n            contextFile: this.contextFile,\n            context: this.context.all,\n          }));\n          await this.context.save(this.contextFile);\n\n          // Execute again\n          continue;\n        }\n      }\n\n      return assembly;\n    }\n  }\n}\n\n/**\n * Return all keys of missing context items\n */\nfunction missingContextKeys(missing?: MissingContext[]): Set<string> {\n  return new Set((missing || []).map(m => m.key));\n}\n\n/**\n * Are two sets equal to each other\n */\nfunction equalSets<A>(a: Set<A>, b: Set<A>) {\n  if (a.size !== b.size) {\n    return false;\n  }\n  for (const x of a) {\n    if (!b.has(x)) {\n      return false;\n    }\n  }\n  return true;\n}\n"]}

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

@@ -0,0 +1,13 @@
+type EventPublisher = (event: 'open' | 'data_stdout' | 'data_stderr' | 'close', line: string) => void;
+interface ExecOptions {
+    eventPublisher?: EventPublisher;
+    extraEnv?: {
+        [key: string]: string | undefined;
+    };
+    cwd?: string;
+}
+/**
+ * Execute a command and args in a child process
+ */
+export declare function execInChildProcess(commandAndArgs: string, options?: ExecOptions): Promise<void>;
+export {};

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execInChildProcess = execInChildProcess;
+const child_process = require("node:child_process");
+const split2 = require("split2");
+const errors_1 = require("../../errors");
+/**
+ * Execute a command and args in a child process
+ */
+async function execInChildProcess(commandAndArgs, options = {}) {
+    return new Promise((ok, fail) => {
+        // We use a slightly lower-level interface to:
+        //
+        // - Pass arguments in an array instead of a string, to get around a
+        //   number of quoting issues introduced by the intermediate shell layer
+        //   (which would be different between Linux and Windows).
+        //
+        // - We have to capture any output to stdout and stderr sp we can pass it on to the IoHost
+        //   To ensure messages get to the user fast, we will emit every full line we receive.
+        const proc = child_process.spawn(commandAndArgs, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: false,
+            shell: true,
+            cwd: options.cwd,
+            env: {
+                ...process.env,
+                ...(options.extraEnv ?? {}),
+            },
+        });
+        const eventPublisher = options.eventPublisher ?? ((type, line) => {
+            switch (type) {
+                case 'data_stdout':
+                    process.stdout.write(line);
+                    return;
+                case 'data_stderr':
+                    process.stderr.write(line);
+                    return;
+                case 'open':
+                case 'close':
+                    return;
+            }
+        });
+        proc.stdout.pipe(split2()).on('data', (line) => eventPublisher('data_stdout', line));
+        proc.stderr.pipe(split2()).on('data', (line) => eventPublisher('data_stderr', line));
+        proc.on('error', fail);
+        proc.on('exit', code => {
+            if (code === 0) {
+                return ok();
+            }
+            else {
+                return fail(new errors_1.ToolkitError(`Subprocess exited with error ${code}`));
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import { ICloudAssemblySource } from '../types';
+/**
+ * A CloudAssemblySource that is representing a already existing and produced CloudAssembly.
+ */
+export declare class IdentityCloudAssemblySource implements ICloudAssemblySource {
+    private readonly cloudAssembly;
+    constructor(cloudAssembly: cxapi.CloudAssembly);
+    produce(): Promise<cxapi.CloudAssembly>;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityCloudAssemblySource = void 0;
+/**
+ * A CloudAssemblySource that is representing a already existing and produced CloudAssembly.
+ */
+class IdentityCloudAssemblySource {
+    cloudAssembly;
+    constructor(cloudAssembly) {
+        this.cloudAssembly = cloudAssembly;
+    }
+    async produce() {
+        return this.cloudAssembly;
+    }
+}
+exports.IdentityCloudAssemblySource = IdentityCloudAssemblySource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRlbnRpdHktc291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaWRlbnRpdHktc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBOztHQUVHO0FBQ0gsTUFBYSwyQkFBMkI7SUFDRjtJQUFwQyxZQUFvQyxhQUFrQztRQUFsQyxrQkFBYSxHQUFiLGFBQWEsQ0FBcUI7SUFDdEUsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQztJQUM1QixDQUFDO0NBQ0Y7QUFQRCxrRUFPQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlICogYXMgY3hhcGkgZnJvbSAnQGF3cy1jZGsvY3gtYXBpJztcbmltcG9ydCB7IElDbG91ZEFzc2VtYmx5U291cmNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG4vKipcbiAqIEEgQ2xvdWRBc3NlbWJseVNvdXJjZSB0aGF0IGlzIHJlcHJlc2VudGluZyBhIGFscmVhZHkgZXhpc3RpbmcgYW5kIHByb2R1Y2VkIENsb3VkQXNzZW1ibHkuXG4gKi9cbmV4cG9ydCBjbGFzcyBJZGVudGl0eUNsb3VkQXNzZW1ibHlTb3VyY2UgaW1wbGVtZW50cyBJQ2xvdWRBc3NlbWJseVNvdXJjZSB7XG4gIHB1YmxpYyBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGNsb3VkQXNzZW1ibHk6IGN4YXBpLkNsb3VkQXNzZW1ibHkpIHtcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBwcm9kdWNlKCk6IFByb21pc2U8Y3hhcGkuQ2xvdWRBc3NlbWJseT4ge1xuICAgIHJldHVybiB0aGlzLmNsb3VkQXNzZW1ibHk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,8 @@
+export * from './context-aware-source';
+export * from './cached-source';
+export * from './identity-source';
+export * from './stack-assembly';
+export * from './exec';
+export * from './prepare-source';
+export * from './source-builder';
+export * from './stack-selectors';

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

@@ -0,0 +1,25 @@
+"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("./context-aware-source"), exports);
+__exportStar(require("./cached-source"), exports);
+__exportStar(require("./identity-source"), exports);
+__exportStar(require("./stack-assembly"), exports);
+__exportStar(require("./exec"), exports);
+__exportStar(require("./prepare-source"), exports);
+__exportStar(require("./source-builder"), exports);
+__exportStar(require("./stack-selectors"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseURBQXVDO0FBQ3ZDLGtEQUFnQztBQUNoQyxvREFBa0M7QUFDbEMsbURBQWlDO0FBQ2pDLHlDQUF1QjtBQUN2QixtREFBaUM7QUFDakMsbURBQWlDO0FBQ2pDLG9EQUFrQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC1hd2FyZS1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jYWNoZWQtc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vaWRlbnRpdHktc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2stYXNzZW1ibHknO1xuZXhwb3J0ICogZnJvbSAnLi9leGVjJztcbmV4cG9ydCAqIGZyb20gJy4vcHJlcGFyZS1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb3VyY2UtYnVpbGRlcic7XG5leHBvcnQgKiBmcm9tICcuL3N0YWNrLXNlbGVjdG9ycyc7XG4iXX0=

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

@@ -0,0 +1,52 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import { ToolkitServices } from '../../../toolkit/private';
+import { ActionAwareIoHost } from '../../io/private';
+import type { AppSynthOptions } from '../source-builder';
+export { guessExecutable } from '../../../api/aws-cdk';
+type Env = {
+    [key: string]: string;
+};
+type Context = {
+    [key: string]: any;
+};
+/**
+ * Turn the given optional output directory into a fixed output directory
+ */
+export declare function determineOutputDirectory(outdir?: string): string;
+/**
+ * If we don't have region/account defined in context, we fall back to the default SDK behavior
+ * where region is retrieved from ~/.aws/config and account is based on default credentials provider
+ * chain and then STS is queried.
+ *
+ * This is done opportunistically: for example, if we can't access STS for some reason or the region
+ * is not configured, the context value will be 'null' and there could failures down the line. In
+ * some cases, synthesis does not require region/account information at all, so that might be perfectly
+ * fine in certain scenarios.
+ *
+ * @param context The context key/value bash.
+ */
+export declare function prepareDefaultEnvironment(services: ToolkitServices, props?: {
+    outdir?: string;
+}): Promise<Env>;
+/**
+ * Run code from a different working directory
+ */
+export declare function changeDir<T>(block: () => Promise<T>, workingDir?: string): Promise<T>;
+/**
+ * Run code with additional environment variables
+ */
+export declare function withEnv<T>(env: Env | undefined, block: () => Promise<T>): Promise<T>;
+/**
+ * Run code with context setup inside the environment
+ */
+export declare function withContext<T>(inputContext: Context, env: Env, synthOpts: AppSynthOptions | undefined, block: (env: Env, context: Context) => Promise<T>): Promise<T>;
+/**
+ * Checks if a given assembly supports context overflow, warn otherwise.
+ *
+ * @param assembly the assembly to check
+ */
+export declare function checkContextOverflowSupport(assembly: cxapi.CloudAssembly, ioHost: ActionAwareIoHost): Promise<void>;
+/**
+ * Safely create an assembly from a cloud assembly directory
+ */
+export declare function assemblyFromDirectory(assemblyDir: string, ioHost: ActionAwareIoHost): Promise<cxapi.CloudAssembly>;

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessExecutable = void 0;
+exports.determineOutputDirectory = determineOutputDirectory;
+exports.prepareDefaultEnvironment = prepareDefaultEnvironment;
+exports.changeDir = changeDir;
+exports.withEnv = withEnv;
+exports.withContext = withContext;
+exports.checkContextOverflowSupport = checkContextOverflowSupport;
+exports.assemblyFromDirectory = assemblyFromDirectory;
+const os = require("node:os");
+const path = require("node:path");
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+const cxapi = require("@aws-cdk/cx-api");
+const fs = require("fs-extra");
+const semver_1 = require("semver");
+const aws_cdk_1 = require("../../../api/aws-cdk");
+const errors_1 = require("../../errors");
+const private_1 = require("../../io/private");
+var aws_cdk_2 = require("../../../api/aws-cdk");
+Object.defineProperty(exports, "guessExecutable", { enumerable: true, get: function () { return aws_cdk_2.guessExecutable; } });
+/**
+ * Turn the given optional output directory into a fixed output directory
+ */
+function determineOutputDirectory(outdir) {
+    return outdir ?? fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));
+}
+/**
+ * If we don't have region/account defined in context, we fall back to the default SDK behavior
+ * where region is retrieved from ~/.aws/config and account is based on default credentials provider
+ * chain and then STS is queried.
+ *
+ * This is done opportunistically: for example, if we can't access STS for some reason or the region
+ * is not configured, the context value will be 'null' and there could failures down the line. In
+ * some cases, synthesis does not require region/account information at all, so that might be perfectly
+ * fine in certain scenarios.
+ *
+ * @param context The context key/value bash.
+ */
+async function prepareDefaultEnvironment(services, props = {}) {
+    const logFn = (0, private_1.asLogger)(services.ioHost, 'ASSEMBLY').debug;
+    const env = await (0, aws_cdk_1.prepareDefaultEnvironment)(services.sdkProvider, logFn);
+    if (props.outdir) {
+        env[cxapi.OUTDIR_ENV] = props.outdir;
+        await logFn('outdir:', props.outdir);
+    }
+    // CLI version information
+    env[cxapi.CLI_ASM_VERSION_ENV] = cxschema.Manifest.version();
+    env[cxapi.CLI_VERSION_ENV] = (0, aws_cdk_1.versionNumber)();
+    await logFn('env:', env);
+    return env;
+}
+/**
+ * Run code from a different working directory
+ */
+async function changeDir(block, workingDir) {
+    const originalWorkingDir = process.cwd();
+    try {
+        if (workingDir) {
+            process.chdir(workingDir);
+        }
+        return await block();
+    }
+    finally {
+        if (workingDir) {
+            process.chdir(originalWorkingDir);
+        }
+    }
+}
+/**
+ * Run code with additional environment variables
+ */
+async function withEnv(env = {}, block) {
+    const originalEnv = process.env;
+    try {
+        process.env = {
+            ...originalEnv,
+            ...env,
+        };
+        return await block();
+    }
+    finally {
+        process.env = originalEnv;
+    }
+}
+/**
+ * Run code with context setup inside the environment
+ */
+async function withContext(inputContext, env, synthOpts = {}, block) {
+    const context = await (0, aws_cdk_1.prepareContext)(synthOptsDefaults(synthOpts), inputContext, env);
+    let contextOverflowLocation = null;
+    try {
+        const envVariableSizeLimit = os.platform() === 'win32' ? 32760 : 131072;
+        const [smallContext, overflow] = (0, aws_cdk_1.splitBySize)(context, (0, aws_cdk_1.spaceAvailableForContext)(env, envVariableSizeLimit));
+        // Store the safe part in the environment variable
+        env[cxapi.CONTEXT_ENV] = JSON.stringify(smallContext);
+        // If there was any overflow, write it to a temporary file
+        if (Object.keys(overflow ?? {}).length > 0) {
+            const contextDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-context'));
+            contextOverflowLocation = path.join(contextDir, 'context-overflow.json');
+            fs.writeJSONSync(contextOverflowLocation, overflow);
+            env[cxapi.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;
+        }
+        // call the block code with new environment
+        return await block(env, context);
+    }
+    finally {
+        if (contextOverflowLocation) {
+            fs.removeSync(path.dirname(contextOverflowLocation));
+        }
+    }
+}
+/**
+ * Checks if a given assembly supports context overflow, warn otherwise.
+ *
+ * @param assembly the assembly to check
+ */
+async function checkContextOverflowSupport(assembly, ioHost) {
+    const logFn = (0, private_1.asLogger)(ioHost, 'ASSEMBLY').warn;
+    const tree = (0, aws_cdk_1.loadTree)(assembly);
+    const frameworkDoesNotSupportContextOverflow = (0, aws_cdk_1.some)(tree, node => {
+        const fqn = node.constructInfo?.fqn;
+        const version = node.constructInfo?.version;
+        return (fqn === 'aws-cdk-lib.App' && version != null && (0, semver_1.lte)(version, '2.38.0')) // v2
+            || fqn === '@aws-cdk/core.App'; // v1
+    });
+    // We're dealing with an old version of the framework here. It is unaware of the temporary
+    // file, which means that it will ignore the context overflow.
+    if (frameworkDoesNotSupportContextOverflow) {
+        await logFn('Part of the context could not be sent to the application. Please update the AWS CDK library to the latest version.');
+    }
+}
+/**
+ * Safely create an assembly from a cloud assembly directory
+ */
+async function assemblyFromDirectory(assemblyDir, ioHost) {
+    try {
+        const assembly = new cxapi.CloudAssembly(assemblyDir, {
+            // We sort as we deploy
+            topoSort: false,
+        });
+        await checkContextOverflowSupport(assembly, ioHost);
+        return assembly;
+    }
+    catch (err) {
+        if (err.message.includes(cxschema.VERSION_MISMATCH)) {
+            // this means the CLI version is too old.
+            // we instruct the user to upgrade.
+            const message = 'This AWS CDK Toolkit is not compatible with the AWS CDK library used by your application. Please upgrade to the latest version.';
+            await ioHost.notify((0, private_1.error)(message, 'CDK_ASSEMBLY_E1111', { error: err.message }));
+            throw new errors_1.ToolkitError(`${message}\n(${err.message}`);
+        }
+        throw err;
+    }
+}
+function synthOptsDefaults(synthOpts = {}) {
+    return new aws_cdk_1.Settings({
+        debug: false,
+        pathMetadata: true,
+        versionReporting: true,
+        assetMetadata: true,
+        assetStaging: true,
+        ...synthOpts,
+    }, true);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prepare-source.js","sourceRoot":"","sources":["prepare-source.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'node:os';\nimport * as path from 'node:path';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport { lte } from 'semver';\nimport { prepareDefaultEnvironment as oldPrepare, prepareContext, spaceAvailableForContext, Settings, loadTree, some, splitBySize, versionNumber } from '../../../api/aws-cdk';\nimport { ToolkitServices } from '../../../toolkit/private';\nimport { ToolkitError } from '../../errors';\nimport { ActionAwareIoHost, asLogger, error } from '../../io/private';\nimport type { AppSynthOptions } from '../source-builder';\n\nexport { guessExecutable } from '../../../api/aws-cdk';\n\ntype Env = { [key: string]: string };\ntype Context = { [key: string]: any };\n\n/**\n * Turn the given optional output directory into a fixed output directory\n */\nexport function determineOutputDirectory(outdir?: string) {\n  return outdir ?? fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'cdk.out'));\n}\n\n/**\n * If we don't have region/account defined in context, we fall back to the default SDK behavior\n * where region is retrieved from ~/.aws/config and account is based on default credentials provider\n * chain and then STS is queried.\n *\n * This is done opportunistically: for example, if we can't access STS for some reason or the region\n * is not configured, the context value will be 'null' and there could failures down the line. In\n * some cases, synthesis does not require region/account information at all, so that might be perfectly\n * fine in certain scenarios.\n *\n * @param context The context key/value bash.\n */\nexport async function prepareDefaultEnvironment(services: ToolkitServices, props: { outdir?: string } = {}): Promise<Env> {\n  const logFn = asLogger(services.ioHost, 'ASSEMBLY').debug;\n  const env = await oldPrepare(services.sdkProvider, logFn);\n\n  if (props.outdir) {\n    env[cxapi.OUTDIR_ENV] = props.outdir;\n    await logFn('outdir:', props.outdir);\n  }\n\n  // CLI version information\n  env[cxapi.CLI_ASM_VERSION_ENV] = cxschema.Manifest.version();\n  env[cxapi.CLI_VERSION_ENV] = versionNumber();\n\n  await logFn('env:', env);\n  return env;\n}\n\n/**\n * Run code from a different working directory\n */\nexport async function changeDir<T>(block: () => Promise<T>, workingDir?: string) {\n  const originalWorkingDir = process.cwd();\n  try {\n    if (workingDir) {\n      process.chdir(workingDir);\n    }\n\n    return await block();\n  } finally {\n    if (workingDir) {\n      process.chdir(originalWorkingDir);\n    }\n  }\n}\n\n/**\n * Run code with additional environment variables\n */\nexport async function withEnv<T>(env: Env = {}, block: () => Promise<T>) {\n  const originalEnv = process.env;\n  try {\n    process.env = {\n      ...originalEnv,\n      ...env,\n    };\n\n    return await block();\n  } finally {\n    process.env = originalEnv;\n  }\n}\n\n/**\n * Run code with context setup inside the environment\n */\nexport async function withContext<T>(\n  inputContext: Context,\n  env: Env,\n  synthOpts: AppSynthOptions = {},\n  block: (env: Env, context: Context) => Promise<T>,\n) {\n  const context = await prepareContext(synthOptsDefaults(synthOpts), inputContext, env);\n  let contextOverflowLocation = null;\n\n  try {\n    const envVariableSizeLimit = os.platform() === 'win32' ? 32760 : 131072;\n    const [smallContext, overflow] = splitBySize(context, spaceAvailableForContext(env, envVariableSizeLimit));\n\n    // Store the safe part in the environment variable\n    env[cxapi.CONTEXT_ENV] = JSON.stringify(smallContext);\n\n    // If there was any overflow, write it to a temporary file\n    if (Object.keys(overflow ?? {}).length > 0) {\n      const contextDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-context'));\n      contextOverflowLocation = path.join(contextDir, 'context-overflow.json');\n      fs.writeJSONSync(contextOverflowLocation, overflow);\n      env[cxapi.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;\n    }\n\n    // call the block code with new environment\n    return await block(env, context);\n  } finally {\n    if (contextOverflowLocation) {\n      fs.removeSync(path.dirname(contextOverflowLocation));\n    }\n  }\n}\n\n/**\n * Checks if a given assembly supports context overflow, warn otherwise.\n *\n * @param assembly the assembly to check\n */\nexport async function checkContextOverflowSupport(assembly: cxapi.CloudAssembly, ioHost: ActionAwareIoHost): Promise<void> {\n  const logFn = asLogger(ioHost, 'ASSEMBLY').warn;\n  const tree = loadTree(assembly);\n  const frameworkDoesNotSupportContextOverflow = some(tree, node => {\n    const fqn = node.constructInfo?.fqn;\n    const version = node.constructInfo?.version;\n    return (fqn === 'aws-cdk-lib.App' && version != null && lte(version, '2.38.0')) // v2\n    || fqn === '@aws-cdk/core.App'; // v1\n  });\n\n  // We're dealing with an old version of the framework here. It is unaware of the temporary\n  // file, which means that it will ignore the context overflow.\n  if (frameworkDoesNotSupportContextOverflow) {\n    await logFn('Part of the context could not be sent to the application. Please update the AWS CDK library to the latest version.');\n  }\n}\n\n/**\n * Safely create an assembly from a cloud assembly directory\n */\nexport async function assemblyFromDirectory(assemblyDir: string, ioHost: ActionAwareIoHost) {\n  try {\n    const assembly = new cxapi.CloudAssembly(assemblyDir, {\n      // We sort as we deploy\n      topoSort: false,\n    });\n    await checkContextOverflowSupport(assembly, ioHost);\n    return assembly;\n  } catch (err: any) {\n    if (err.message.includes(cxschema.VERSION_MISMATCH)) {\n      // this means the CLI version is too old.\n      // we instruct the user to upgrade.\n      const message = 'This AWS CDK Toolkit is not compatible with the AWS CDK library used by your application. Please upgrade to the latest version.';\n      await ioHost.notify(error(message, 'CDK_ASSEMBLY_E1111', { error: err.message }));\n      throw new ToolkitError(`${message}\\n(${err.message}`);\n    }\n    throw err;\n  }\n}\n\nfunction synthOptsDefaults(synthOpts: AppSynthOptions = {}): Settings {\n  return new Settings({\n    debug: false,\n    pathMetadata: true,\n    versionReporting: true,\n    assetMetadata: true,\n    assetStaging: true,\n    ...synthOpts,\n  }, true);\n}\n"]}