@aws-cdk/toolkit-lib 0.3.7 → 1.0.0

package/lib/api/cloud-assembly/context-store.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryContext = exports.FileContext = exports.CdkAppMultiContext = void 0;
+exports.persistableContext = persistableContext;
+const fs_1 = require("fs");
+const os = require("os");
+const path = require("path");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const context_1 = require("../context");
+const settings_1 = require("../settings");
+/**
+ * A context store as used by a CDK app.
+ *
+ * Will source context from the following locations:
+ *
+ * - Any context values passed to the constructor (expected
+ *   to come from the command line, treated as ephemeral).
+ * - The `context` key in `<appDirectory>/cdk.json`.
+ * - `<appDirectory>/cdk.context.json`.
+ * - The `context` key in `~/.cdk.json`.
+ *
+ * Updates will be written to `<appDirectory>/cdk.context.json`.
+ */
+class CdkAppMultiContext {
+    commandlineContext;
+    _context;
+    configContextFile;
+    projectContextFile;
+    userConfigFile;
+    constructor(appDirectory, commandlineContext) {
+        this.commandlineContext = commandlineContext;
+        this.configContextFile = path.join(appDirectory, 'cdk.json');
+        this.projectContextFile = path.join(appDirectory, 'cdk.context.json');
+        this.userConfigFile = path.join(os.homedir() ?? '/tmp', '.cdk.json');
+    }
+    async read() {
+        const context = await this.asyncInitialize();
+        return context.all;
+    }
+    async update(updates) {
+        const context = await this.asyncInitialize();
+        for (const [key, value] of Object.entries(updates)) {
+            context.set(key, value);
+        }
+        await context.save(this.projectContextFile);
+    }
+    /**
+     * Initialize the `Context` object
+     *
+     * This code all exists to reuse code that's already there, to minimize
+     * the chances of the new code behaving subtly differently than the
+     * old code.
+     *
+     * It might be most of this is unnecessary now...
+     */
+    async asyncInitialize() {
+        if (this._context) {
+            return this._context;
+        }
+        const contextSources = [
+            { bag: new settings_1.Settings(this.commandlineContext, true) },
+            {
+                fileName: this.configContextFile,
+                bag: (await settingsFromFile(this.configContextFile)).subSettings(['context']).makeReadOnly(),
+            },
+            {
+                fileName: this.projectContextFile,
+                bag: await settingsFromFile(this.projectContextFile),
+            },
+            {
+                fileName: this.userConfigFile,
+                bag: (await settingsFromFile(this.userConfigFile)).subSettings(['context']).makeReadOnly(),
+            },
+        ];
+        this._context = new context_1.Context(...contextSources);
+        return this._context;
+    }
+}
+exports.CdkAppMultiContext = CdkAppMultiContext;
+/**
+ * On-disk context stored in a single file
+ */
+class FileContext {
+    fileName;
+    _cache;
+    constructor(fileName) {
+        this.fileName = fileName;
+    }
+    async read() {
+        if (!this._cache) {
+            try {
+                this._cache = JSON.parse(await fs_1.promises.readFile(this.fileName, 'utf-8'));
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    this._cache = {};
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        if (!this._cache || typeof this._cache !== 'object') {
+            throw new toolkit_error_1.ToolkitError(`${this.fileName} must contain an object, got: ${JSON.stringify(this._cache)}`);
+        }
+        return this._cache;
+    }
+    async update(updates) {
+        this._cache = {
+            ...await this.read(),
+            ...updates,
+        };
+        const persistable = persistableContext(this._cache);
+        await fs_1.promises.writeFile(this.fileName, JSON.stringify(persistable, undefined, 2), 'utf-8');
+    }
+}
+exports.FileContext = FileContext;
+/**
+ * An in-memory context store
+ */
+class MemoryContext {
+    context = {};
+    constructor(initialContext) {
+        this.context = { ...initialContext };
+    }
+    read() {
+        return Promise.resolve(this.context);
+    }
+    update(updates) {
+        this.context = {
+            ...this.context,
+            ...updates,
+        };
+        return Promise.resolve();
+    }
+}
+exports.MemoryContext = MemoryContext;
+/**
+ * Filter the given context, leaving only entries that should be persisted
+ */
+function persistableContext(context) {
+    return Object.fromEntries(Object.entries(context)
+        .filter(([_, value]) => !isTransientValue(value)));
+}
+function isTransientValue(x) {
+    return x && typeof x === 'object' && x[settings_1.TRANSIENT_CONTEXT_KEY];
+}
+async function settingsFromFile(filename) {
+    try {
+        const data = JSON.parse(await fs_1.promises.readFile(filename, 'utf-8'));
+        return new settings_1.Settings(data);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return new settings_1.Settings();
+        }
+        throw e;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-store.js","sourceRoot":"","sources":["context-store.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs } from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport type { ContextBag } from '../context';\nimport { Context } from '../context';\nimport { Settings, TRANSIENT_CONTEXT_KEY } from '../settings';\n\n/**\n * A storage place for context used in synthesis\n */\nexport interface IContextStore {\n  /**\n   * Read the context from the context store, plus all updates we have made so far.\n   */\n  read(): Promise<Record<string, unknown>>;\n\n  /**\n   * Commit the given updates to the context store\n   *\n   * `undefined` is used as a value to indicate that the key needs to be removed.\n   *\n   * If a context value is an object that is a superset of `{ [TRANSIENT_CONTEXT_KEY]: true }`\n   * it *should* be returned by subsequent `read()` operations on this object,\n   * but it *should not* be persisted to permanent storage.\n   *\n   * You can use the `persistableContext()` function to filter a context dictionary\n   * down to remove all values that shouldn't be persisted.\n   */\n  update(updates: Record<string, unknown>): Promise<void>;\n}\n\n/**\n * A context store as used by a CDK app.\n *\n * Will source context from the following locations:\n *\n * - Any context values passed to the constructor (expected\n *   to come from the command line, treated as ephemeral).\n * - The `context` key in `<appDirectory>/cdk.json`.\n * - `<appDirectory>/cdk.context.json`.\n * - The `context` key in `~/.cdk.json`.\n *\n * Updates will be written to `<appDirectory>/cdk.context.json`.\n */\nexport class CdkAppMultiContext implements IContextStore {\n  private _context?: Context;\n  private configContextFile: string;\n  private projectContextFile: string;\n  private userConfigFile: string;\n\n  constructor(appDirectory: string, private readonly commandlineContext?: Record<string, unknown>) {\n    this.configContextFile = path.join(appDirectory, 'cdk.json');\n    this.projectContextFile = path.join(appDirectory, 'cdk.context.json');\n    this.userConfigFile = path.join(os.homedir() ?? '/tmp', '.cdk.json');\n  }\n\n  public async read(): Promise<Record<string, unknown>> {\n    const context = await this.asyncInitialize();\n    return context.all;\n  }\n\n  public async update(updates: Record<string, unknown>): Promise<void> {\n    const context = await this.asyncInitialize();\n    for (const [key, value] of Object.entries(updates)) {\n      context.set(key, value);\n    }\n\n    await context.save(this.projectContextFile);\n  }\n\n  /**\n   * Initialize the `Context` object\n   *\n   * This code all exists to reuse code that's already there, to minimize\n   * the chances of the new code behaving subtly differently than the\n   * old code.\n   *\n   * It might be most of this is unnecessary now...\n   */\n  private async asyncInitialize(): Promise<Context> {\n    if (this._context) {\n      return this._context;\n    }\n\n    const contextSources: ContextBag[] = [\n      { bag: new Settings(this.commandlineContext, true) },\n      {\n        fileName: this.configContextFile,\n        bag: (await settingsFromFile(this.configContextFile)).subSettings(['context']).makeReadOnly(),\n      },\n      {\n        fileName: this.projectContextFile,\n        bag: await settingsFromFile(this.projectContextFile),\n      },\n      {\n        fileName: this.userConfigFile,\n        bag: (await settingsFromFile(this.userConfigFile)).subSettings(['context']).makeReadOnly(),\n      },\n    ];\n\n    this._context = new Context(...contextSources);\n    return this._context;\n  }\n}\n\n/**\n * On-disk context stored in a single file\n */\nexport class FileContext implements IContextStore {\n  private _cache?: Record<string, unknown>;\n\n  constructor(private readonly fileName: string) {\n  }\n\n  public async read(): Promise<Record<string, unknown>> {\n    if (!this._cache) {\n      try {\n        this._cache = JSON.parse(await fs.readFile(this.fileName, 'utf-8'));\n      } catch (e: any) {\n        if (e.code === 'ENOENT') {\n          this._cache = {};\n        } else {\n          throw e;\n        }\n      }\n    }\n    if (!this._cache || typeof this._cache !== 'object') {\n      throw new ToolkitError(`${this.fileName} must contain an object, got: ${JSON.stringify(this._cache)}`);\n    }\n    return this._cache;\n  }\n\n  public async update(updates: Record<string, unknown>): Promise<void> {\n    this._cache = {\n      ...await this.read(),\n      ...updates,\n    };\n\n    const persistable = persistableContext(this._cache);\n    await fs.writeFile(this.fileName, JSON.stringify(persistable, undefined, 2), 'utf-8');\n  }\n}\n\n/**\n * An in-memory context store\n */\nexport class MemoryContext implements IContextStore {\n  private context: Record<string, unknown> = {};\n\n  constructor(initialContext?: Record<string, unknown>) {\n    this.context = { ...initialContext };\n  }\n\n  public read(): Promise<Record<string, unknown>> {\n    return Promise.resolve(this.context);\n  }\n\n  public update(updates: Record<string, unknown>): Promise<void> {\n    this.context = {\n      ...this.context,\n      ...updates,\n    };\n\n    return Promise.resolve();\n  }\n}\n\n/**\n * Filter the given context, leaving only entries that should be persisted\n */\nexport function persistableContext(context: Record<string, unknown>): Record<string, unknown> {\n  return Object.fromEntries(Object.entries(context)\n    .filter(([_, value]) => !isTransientValue(value)));\n}\n\nfunction isTransientValue(x: unknown) {\n  return x && typeof x === 'object' && (x as any)[TRANSIENT_CONTEXT_KEY];\n}\n\nasync function settingsFromFile(filename: string): Promise<Settings> {\n  try {\n    const data = JSON.parse(await fs.readFile(filename, 'utf-8'));\n    return new Settings(data);\n  } catch (e: any) {\n    if (e.code === 'ENOENT') {\n      return new Settings();\n    }\n    throw e;\n  }\n}\n"]}

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

@@ -1,5 +1,11 @@
 import type { SdkProvider } from '../aws-auth/private';
 import type { Settings } from '../settings';
+export type Env = {
+    [key: string]: string | undefined;
+};
+export type Context = {
+    [key: string]: unknown;
+};
 /**
  * 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
@@ -12,24 +18,21 @@ import type { Settings } from '../settings';
  *
  * @param context The context key/value bash.
  */
-export declare function prepareDefaultEnvironment(aws: SdkProvider, debugFn: (msg: string) => Promise<void>): Promise<{
-    [key: string]: string;
-}>;
+export declare function prepareDefaultEnvironment(aws: SdkProvider, debugFn: (msg: string) => Promise<void>): Promise<Env>;
 /**
- * Settings related to synthesis are read from context.
- * The merging of various configuration sources like cli args or cdk.json has already happened.
- * We now need to set the final values to the context.
+ * Create context from settings.
+ *
+ * Mutates the `context` object and returns it.
  */
-export declare function prepareContext(settings: Settings, context: {
-    [key: string]: any;
-}, env: {
-    [key: string]: string | undefined;
-}, debugFn: (msg: string) => Promise<void>): Promise<{
-    [key: string]: any;
-}>;
-export declare function spaceAvailableForContext(env: {
-    [key: string]: string;
-}, limit: number): number;
+export declare function contextFromSettings(settings: Settings): Record<string, unknown>;
+/**
+ * Convert settings to context/environment variables
+ */
+export declare function synthParametersFromSettings(settings: Settings): {
+    context: Context;
+    env: Env;
+};
+export declare function spaceAvailableForContext(env: Env, limit: number): number;
 /**
  * Guess the executable from the command-line argument
  *

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareDefaultEnvironment = prepareDefaultEnvironment;
-exports.prepareContext = prepareContext;
+exports.contextFromSettings = contextFromSettings;
+exports.synthParametersFromSettings = synthParametersFromSettings;
 exports.spaceAvailableForContext = spaceAvailableForContext;
 exports.guessExecutable = guessExecutable;
 const path = require("path");
-const util_1 = require("util");
 const cxapi = require("@aws-cdk/cx-api");
 const fs = require("fs-extra");
 /**
@@ -32,15 +32,12 @@ async function prepareDefaultEnvironment(aws, debugFn) {
     return env;
 }
 /**
- * Settings related to synthesis are read from context.
- * The merging of various configuration sources like cli args or cdk.json has already happened.
- * We now need to set the final values to the context.
+ * Create context from settings.
+ *
+ * Mutates the `context` object and returns it.
  */
-async function prepareContext(settings, context, env, debugFn) {
-    const debugMode = settings.get(['debug']) ?? true;
-    if (debugMode) {
-        env.CDK_DEBUG = 'true';
-    }
+function contextFromSettings(settings) {
+    const context = {};
     const pathMetadata = settings.get(['pathMetadata']) ?? true;
     if (pathMetadata) {
         context[cxapi.PATH_METADATA_ENABLE_CONTEXT] = true;
@@ -63,9 +60,21 @@ async function prepareContext(settings, context, env, debugFn) {
     }
     const bundlingStacks = settings.get(['bundlingStacks']) ?? ['**'];
     context[cxapi.BUNDLING_STACKS] = bundlingStacks;
-    await debugFn((0, util_1.format)('context:', context));
     return context;
 }
+/**
+ * Convert settings to context/environment variables
+ */
+function synthParametersFromSettings(settings) {
+    return {
+        context: contextFromSettings(settings),
+        env: {
+            // An environment variable instead of a context variable, so it can also
+            // be accessed in framework code where we don't have access to a construct tree.
+            ...settings.get(['debug']) ? { CDK_DEBUG: 'true' } : {},
+        },
+    };
+}
 function spaceAvailableForContext(env, limit) {
     const size = (value) => value != null ? Buffer.byteLength(value) : 0;
     const usedSpace = Object.entries(env)
@@ -124,4 +133,4 @@ function executeNode(scriptFile) {
 function appToArray(app) {
     return typeof app === 'string' ? app.split(' ') : app;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["environment.ts"],"names":[],"mappings":";;AAmBA,8DAgBC;AAOD,wCAyCC;AAED,4DAQC;AAYD,0CAsBC;AA/HD,6BAA6B;AAC7B,+BAA8B;AAC9B,yCAAyC;AACzC,+BAA+B;AAI/B;;;;;;;;;;;GAWG;AACI,KAAK,UAAU,yBAAyB,CAC7C,GAAgB,EAChB,OAAuC;IAEvC,MAAM,GAAG,GAA8B,EAAG,CAAC;IAE3C,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC;IAClD,MAAM,OAAO,CAAC,YAAY,KAAK,CAAC,kBAAkB,6BAA6B,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;IAEhH,MAAM,SAAS,GAAG,CAAC,MAAM,GAAG,CAAC,cAAc,EAAE,CAAC,EAAE,SAAS,CAAC;IAC1D,IAAI,SAAS,EAAE,CAAC;QACd,GAAG,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAC;QAC3C,MAAM,OAAO,CAAC,YAAY,KAAK,CAAC,mBAAmB,6BAA6B,GAAG,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;IACpH,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,cAAc,CAClC,QAAkB,EAClB,OAA+B,EAC/B,GAA0C,EAC1C,OAAuC;IAEvC,MAAM,SAAS,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC;IAC3D,IAAI,SAAS,EAAE,CAAC;QACd,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC;IACzB,CAAC;IAED,MAAM,YAAY,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC,IAAI,IAAI,CAAC;IACrE,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,CAAC,KAAK,CAAC,4BAA4B,CAAC,GAAG,IAAI,CAAC;IACrD,CAAC;IAED,MAAM,aAAa,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,eAAe,CAAC,CAAC,IAAI,IAAI,CAAC;IACvE,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,CAAC,KAAK,CAAC,uCAAuC,CAAC,GAAG,IAAI,CAAC;IAChE,CAAC;IAED,MAAM,gBAAgB,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,kBAAkB,CAAC,CAAC,IAAI,IAAI,CAAC;IAC7E,IAAI,gBAAgB,EAAE,CAAC;QACrB,OAAO,CAAC,KAAK,CAAC,mCAAmC,CAAC,GAAG,IAAI,CAAC;IAC5D,CAAC;IACD,4FAA4F;IAC5F,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,OAAO,CAAC,mCAAmC,CAAC,GAAG,IAAI,CAAC;IACtD,CAAC;IAED,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,CAAC;IACzD,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CAAC,6BAA6B,CAAC,GAAG,IAAI,CAAC;IACtD,CAAC;IAED,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClE,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,cAAc,CAAC;IAEhD,MAAM,OAAO,CAAC,IAAA,aAAM,EAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;IAE3C,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAgB,wBAAwB,CAAC,GAA8B,EAAE,KAAa;IACpF,MAAM,IAAI,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE7E,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;SACtE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAE9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;GASG;AACI,KAAK,UAAU,eAAe,CAAC,GAAW,EAAE,OAAuC;IACxF,MAAM,WAAW,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,IAAI,KAAK,CAAC;QAEV,IAAI,CAAC;YACH,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,OAAO,CAAC,gBAAgB,WAAW,CAAC,CAAC,CAAC,aAAa,WAAW,mBAAmB,CAAC,CAAC;YACzF,OAAO,WAAW,CAAC;QACrB,CAAC;QAED,sCAAsC;QACtC,MAAM,YAAY,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5D,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC;QAE/C,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChE,IAAI,OAAO,IAAI,CAAC,CAAC,YAAY,IAAI,SAAS,CAAC,EAAE,CAAC;YAC5C,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;GAEG;AACH,MAAM,aAAa,GAAG,IAAI,GAAG,CAA2B;IACtD,CAAC,KAAK,EAAE,WAAW,CAAC;CACrB,CAAC,CAAC;AAIH;;GAEG;AACH,SAAS,WAAW,CAAC,UAAkB;IACrC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,GAAQ;IAC1B,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACxD,CAAC","sourcesContent":["import * as path from 'path';\nimport { format } from 'util';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { SdkProvider } from '../aws-auth/private';\nimport type { Settings } from '../settings';\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(\n  aws: SdkProvider,\n  debugFn: (msg: string) => Promise<void>,\n): Promise<{ [key: string]: string }> {\n  const env: { [key: string]: string } = { };\n\n  env[cxapi.DEFAULT_REGION_ENV] = aws.defaultRegion;\n  await debugFn(`Setting \"${cxapi.DEFAULT_REGION_ENV}\" environment variable to ${env[cxapi.DEFAULT_REGION_ENV]}`);\n\n  const accountId = (await aws.defaultAccount())?.accountId;\n  if (accountId) {\n    env[cxapi.DEFAULT_ACCOUNT_ENV] = accountId;\n    await debugFn(`Setting \"${cxapi.DEFAULT_ACCOUNT_ENV}\" environment variable to ${env[cxapi.DEFAULT_ACCOUNT_ENV]}`);\n  }\n\n  return env;\n}\n\n/**\n * Settings related to synthesis are read from context.\n * The merging of various configuration sources like cli args or cdk.json has already happened.\n * We now need to set the final values to the context.\n */\nexport async function prepareContext(\n  settings: Settings,\n  context: { [key: string]: any },\n  env: { [key: string]: string | undefined },\n  debugFn: (msg: string) => Promise<void>,\n) {\n  const debugMode: boolean = settings.get(['debug']) ?? true;\n  if (debugMode) {\n    env.CDK_DEBUG = 'true';\n  }\n\n  const pathMetadata: boolean = settings.get(['pathMetadata']) ?? true;\n  if (pathMetadata) {\n    context[cxapi.PATH_METADATA_ENABLE_CONTEXT] = true;\n  }\n\n  const assetMetadata: boolean = settings.get(['assetMetadata']) ?? true;\n  if (assetMetadata) {\n    context[cxapi.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT] = true;\n  }\n\n  const versionReporting: boolean = settings.get(['versionReporting']) ?? true;\n  if (versionReporting) {\n    context[cxapi.ANALYTICS_REPORTING_ENABLED_CONTEXT] = true;\n  }\n  // We need to keep on doing this for framework version from before this flag was deprecated.\n  if (!versionReporting) {\n    context['aws:cdk:disable-version-reporting'] = true;\n  }\n\n  const stagingEnabled = settings.get(['staging']) ?? true;\n  if (!stagingEnabled) {\n    context[cxapi.DISABLE_ASSET_STAGING_CONTEXT] = true;\n  }\n\n  const bundlingStacks = settings.get(['bundlingStacks']) ?? ['**'];\n  context[cxapi.BUNDLING_STACKS] = bundlingStacks;\n\n  await debugFn(format('context:', context));\n\n  return context;\n}\n\nexport function spaceAvailableForContext(env: { [key: string]: string }, limit: number) {\n  const size = (value: string) => value != null ? Buffer.byteLength(value) : 0;\n\n  const usedSpace = Object.entries(env)\n    .map(([k, v]) => k === cxapi.CONTEXT_ENV ? size(k) : size(k) + size(v))\n    .reduce((a, b) => a + b, 0);\n\n  return Math.max(0, limit - usedSpace);\n}\n\n/**\n * Guess the executable from the command-line argument\n *\n * Only do this if the file is NOT marked as executable. If it is,\n * we'll defer to the shebang inside the file itself.\n *\n * If we're on Windows, we ALWAYS take the handler, since it's hard to\n * verify if registry associations have or have not been set up for this\n * file type, so we'll assume the worst and take control.\n */\nexport async function guessExecutable(app: string, debugFn: (msg: string) => Promise<void>) {\n  const commandLine = appToArray(app);\n  if (commandLine.length === 1) {\n    let fstat;\n\n    try {\n      fstat = await fs.stat(commandLine[0]);\n    } catch {\n      await debugFn(`Not a file: '${commandLine[0]}'. Using '${commandLine}' as command-line`);\n      return commandLine;\n    }\n\n    // eslint-disable-next-line no-bitwise\n    const isExecutable = (fstat.mode & fs.constants.X_OK) !== 0;\n    const isWindows = process.platform === 'win32';\n\n    const handler = EXTENSION_MAP.get(path.extname(commandLine[0]));\n    if (handler && (!isExecutable || isWindows)) {\n      return handler(commandLine[0]);\n    }\n  }\n  return commandLine;\n}\n\n/**\n * Mapping of extensions to command-line generators\n */\nconst EXTENSION_MAP = new Map<string, CommandGenerator>([\n  ['.js', executeNode],\n]);\n\ntype CommandGenerator = (file: string) => string[];\n\n/**\n * Execute the given file with the same 'node' process as is running the current process\n */\nfunction executeNode(scriptFile: string): string[] {\n  return [process.execPath, scriptFile];\n}\n\n/**\n * Make sure the 'app' is an array\n *\n * If it's a string, split on spaces as a trivial way of tokenizing the command line.\n */\nfunction appToArray(app: any) {\n  return typeof app === 'string' ? app.split(' ') : app;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["environment.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { SdkProvider } from '../aws-auth/private';\nimport type { Settings } from '../settings';\n\nexport type Env = { [key: string]: string | undefined };\nexport type Context = { [key: string]: unknown };\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(\n  aws: SdkProvider,\n  debugFn: (msg: string) => Promise<void>,\n): Promise<Env> {\n  const env: Env = {};\n\n  env[cxapi.DEFAULT_REGION_ENV] = aws.defaultRegion;\n  await debugFn(`Setting \"${cxapi.DEFAULT_REGION_ENV}\" environment variable to ${env[cxapi.DEFAULT_REGION_ENV]}`);\n\n  const accountId = (await aws.defaultAccount())?.accountId;\n  if (accountId) {\n    env[cxapi.DEFAULT_ACCOUNT_ENV] = accountId;\n    await debugFn(`Setting \"${cxapi.DEFAULT_ACCOUNT_ENV}\" environment variable to ${env[cxapi.DEFAULT_ACCOUNT_ENV]}`);\n  }\n\n  return env;\n}\n\n/**\n * Create context from settings.\n *\n * Mutates the `context` object and returns it.\n */\nexport function contextFromSettings(\n  settings: Settings,\n) {\n  const context: Record<string, unknown> = {};\n\n  const pathMetadata: boolean = settings.get(['pathMetadata']) ?? true;\n  if (pathMetadata) {\n    context[cxapi.PATH_METADATA_ENABLE_CONTEXT] = true;\n  }\n\n  const assetMetadata: boolean = settings.get(['assetMetadata']) ?? true;\n  if (assetMetadata) {\n    context[cxapi.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT] = true;\n  }\n\n  const versionReporting: boolean = settings.get(['versionReporting']) ?? true;\n  if (versionReporting) {\n    context[cxapi.ANALYTICS_REPORTING_ENABLED_CONTEXT] = true;\n  }\n  // We need to keep on doing this for framework version from before this flag was deprecated.\n  if (!versionReporting) {\n    context['aws:cdk:disable-version-reporting'] = true;\n  }\n\n  const stagingEnabled = settings.get(['staging']) ?? true;\n  if (!stagingEnabled) {\n    context[cxapi.DISABLE_ASSET_STAGING_CONTEXT] = true;\n  }\n\n  const bundlingStacks = settings.get(['bundlingStacks']) ?? ['**'];\n  context[cxapi.BUNDLING_STACKS] = bundlingStacks;\n\n  return context;\n}\n\n/**\n * Convert settings to context/environment variables\n */\nexport function synthParametersFromSettings(settings: Settings): {\n  context: Context;\n  env: Env;\n} {\n  return {\n    context: contextFromSettings(settings),\n    env: {\n      // An environment variable instead of a context variable, so it can also\n      // be accessed in framework code where we don't have access to a construct tree.\n      ...settings.get(['debug']) ? { CDK_DEBUG: 'true' } : {},\n    },\n  };\n}\n\nexport function spaceAvailableForContext(env: Env, limit: number) {\n  const size = (value?: string) => value != null ? Buffer.byteLength(value) : 0;\n\n  const usedSpace = Object.entries(env)\n    .map(([k, v]) => k === cxapi.CONTEXT_ENV ? size(k) : size(k) + size(v))\n    .reduce((a, b) => a + b, 0);\n\n  return Math.max(0, limit - usedSpace);\n}\n\n/**\n * Guess the executable from the command-line argument\n *\n * Only do this if the file is NOT marked as executable. If it is,\n * we'll defer to the shebang inside the file itself.\n *\n * If we're on Windows, we ALWAYS take the handler, since it's hard to\n * verify if registry associations have or have not been set up for this\n * file type, so we'll assume the worst and take control.\n */\nexport async function guessExecutable(app: string, debugFn: (msg: string) => Promise<void>) {\n  const commandLine = appToArray(app);\n  if (commandLine.length === 1) {\n    let fstat;\n\n    try {\n      fstat = await fs.stat(commandLine[0]);\n    } catch {\n      await debugFn(`Not a file: '${commandLine[0]}'. Using '${commandLine}' as command-line`);\n      return commandLine;\n    }\n\n    // eslint-disable-next-line no-bitwise\n    const isExecutable = (fstat.mode & fs.constants.X_OK) !== 0;\n    const isWindows = process.platform === 'win32';\n\n    const handler = EXTENSION_MAP.get(path.extname(commandLine[0]));\n    if (handler && (!isExecutable || isWindows)) {\n      return handler(commandLine[0]);\n    }\n  }\n  return commandLine;\n}\n\n/**\n * Mapping of extensions to command-line generators\n */\nconst EXTENSION_MAP = new Map<string, CommandGenerator>([\n  ['.js', executeNode],\n]);\n\ntype CommandGenerator = (file: string) => string[];\n\n/**\n * Execute the given file with the same 'node' process as is running the current process\n */\nfunction executeNode(scriptFile: string): string[] {\n  return [process.execPath, scriptFile];\n}\n\n/**\n * Make sure the 'app' is an array\n *\n * If it's a string, split on spaces as a trivial way of tokenizing the command line.\n */\nfunction appToArray(app: any) {\n  return typeof app === 'string' ? app.split(' ') : app;\n}\n"]}

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

@@ -3,3 +3,4 @@ export type { StackSelector } from './stack-selector';
 export * from './cached-source';
 export * from './source-builder';
 export * from './types';
+export * from './context-store';

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

@@ -21,4 +21,5 @@ Object.defineProperty(exports, "StackSelectionStrategy", { enumerable: true, get
 __exportStar(require("./cached-source"), exports);
 __exportStar(require("./source-builder"), exports);
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFnRjtBQUF2RSxzSEFBQSxvQkFBb0IsT0FBQTtBQUFFLHdIQUFBLHNCQUFzQixPQUFBO0FBRXJELGtEQUFnQztBQUNoQyxtREFBaUM7QUFDakMsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRXhwYW5kU3RhY2tTZWxlY3Rpb24sIFN0YWNrU2VsZWN0aW9uU3RyYXRlZ3kgfSBmcm9tICcuL3N0YWNrLXNlbGVjdG9yJztcbmV4cG9ydCB0eXBlIHsgU3RhY2tTZWxlY3RvciB9IGZyb20gJy4vc3RhY2stc2VsZWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9jYWNoZWQtc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vc291cmNlLWJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=
+__exportStar(require("./context-store"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFnRjtBQUF2RSxzSEFBQSxvQkFBb0IsT0FBQTtBQUFFLHdIQUFBLHNCQUFzQixPQUFBO0FBRXJELGtEQUFnQztBQUNoQyxtREFBaUM7QUFDakMsMENBQXdCO0FBQ3hCLGtEQUFnQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEV4cGFuZFN0YWNrU2VsZWN0aW9uLCBTdGFja1NlbGVjdGlvblN0cmF0ZWd5IH0gZnJvbSAnLi9zdGFjay1zZWxlY3Rvcic7XG5leHBvcnQgdHlwZSB7IFN0YWNrU2VsZWN0b3IgfSBmcm9tICcuL3N0YWNrLXNlbGVjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vY2FjaGVkLXNvdXJjZSc7XG5leHBvcnQgKiBmcm9tICcuL3NvdXJjZS1idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LXN0b3JlJztcbiJdfQ==

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

@@ -1,5 +1,5 @@
 import type { ToolkitServices } from '../../../toolkit/private';
-import { type Context } from '../../context';
+import type { IContextStore } from '../context-store';
 import type { ICloudAssemblySource, IReadableCloudAssembly } from '../types';
 export interface ContextAwareCloudAssemblyProps {
     /**
@@ -8,15 +8,9 @@ export interface ContextAwareCloudAssemblyProps {
      */
     readonly services: ToolkitServices;
     /**
-     * Application context
+     * Location to read and write context
      */
-    readonly context: Context;
-    /**
-     * The file used to store application context in (relative to cwd).
-     *
-     * @default "cdk.context.json"
-     */
-    readonly contextFile?: string;
+    readonly contextStore: IContextStore;
     /**
      * Enable context lookups.
      *
@@ -48,7 +42,6 @@ export declare class ContextAwareCloudAssemblySource implements ICloudAssemblySo
     private readonly props;
     private canLookup;
     private context;
-    private contextFile;
     private ioHelper;
     constructor(source: ICloudAssemblySource, props: ContextAwareCloudAssemblyProps);
     /**

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextAwareCloudAssemblySource = void 0;
 const contextproviders = require("../../../context-providers");
 const toolkit_error_1 = require("../../../toolkit/toolkit-error");
-const context_1 = require("../../context");
 const private_1 = require("../../io/private");
 /**
  * A CloudAssemblySource that wraps another CloudAssemblySource and runs a lookup loop on it
@@ -27,14 +26,12 @@ class ContextAwareCloudAssemblySource {
     props;
     canLookup;
     context;
-    contextFile;
     ioHelper;
     constructor(source, props) {
         this.source = source;
         this.props = props;
         this.canLookup = props.lookups ?? true;
-        this.context = props.context;
-        this.contextFile = props.contextFile ?? context_1.PROJECT_CONTEXT; // @todo new feature not needed right now
+        this.context = props.contextStore;
         this.ioHelper = props.services.ioHelper;
     }
     /**
@@ -65,13 +62,11 @@ class ContextAwareCloudAssemblySource {
                 previouslyMissingKeys = missingKeysSet;
                 if (tryLookup) {
                     await this.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));
-                    await contextproviders.provideContextValues(assembly.manifest.missing, this.context, this.props.services.sdkProvider, this.props.services.pluginHost, this.ioHelper);
-                    // Cache the new context to disk
-                    await this.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0042.msg(`Writing updated context to ${this.contextFile}...`, {
-                        contextFile: this.contextFile,
-                        context: this.context.all,
+                    const contextUpdates = await contextproviders.provideContextValues(assembly.manifest.missing, this.props.services.sdkProvider, this.props.services.pluginHost, this.ioHelper);
+                    await this.ioHelper.notify(private_1.IO.CDK_ASSEMBLY_I0042.msg('Writing context updates...', {
+                        context: contextUpdates,
                     }));
-                    await this.context.save(this.contextFile);
+                    await this.context.update(contextUpdates);
                     // Execute again. Unlock the assembly here so that the producer can acquire
                     // a read lock on the directory again.
                     await readableAsm._unlock();
@@ -103,4 +98,4 @@ function equalSets(a, b) {
     }
     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 contextproviders from '../../../context-providers';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport { ToolkitError } from '../../../toolkit/toolkit-error';\nimport { PROJECT_CONTEXT, type Context } from '../../context';\nimport type { IoHelper } from '../../io/private';\nimport { IO } from '../../io/private';\nimport type { ICloudAssemblySource, IReadableCloudAssembly } 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 * A CloudAssemblySource that wraps another CloudAssemblySource and runs a lookup loop on it\n *\n * This means that if the underlying CloudAssemblySource produces a manifest\n * with provider queries in it, the `ContextAwareCloudAssemblySource` will\n * perform the necessary context lookups and invoke the underlying\n * `CloudAssemblySource` again with thew missing context information.\n *\n * This is only useful if the underlying `CloudAssemblySource` can respond to\n * this new context information (it must be a CDK app source); if it is just a\n * static directory, then the contents of the assembly won't change in response\n * to context.\n *\n * The context is passed between `ContextAwareCloudAssemblySource` and the wrapped\n * cloud assembly source via a contex file on disk, so the wrapped assembly source\n * should re-read the context file on every invocation.\n */\nexport class ContextAwareCloudAssemblySource implements ICloudAssemblySource {\n  private canLookup: boolean;\n  private context: Context;\n  private contextFile: string;\n  private ioHelper: IoHelper;\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.ioHelper = props.services.ioHelper;\n  }\n\n  /**\n   * Produce a Cloud Assembly, i.e. a set of stacks\n   */\n  public async produce(): Promise<IReadableCloudAssembly> {\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 readableAsm = await this.source.produce();\n\n      const assembly = readableAsm.cloudAssembly;\n      if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n        const missingKeysSet = missingContextKeys(assembly.manifest.missing);\n        const missingKeys = Array.from(missingKeysSet);\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: '${missingKeys.join(', ')}'`);\n        }\n\n        let tryLookup = true;\n        if (previouslyMissingKeys && equalSets(missingKeysSet, previouslyMissingKeys)) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0240.msg('Not making progress trying to resolve environmental context. Giving up.', { missingKeys }));\n          tryLookup = false;\n        }\n\n        previouslyMissingKeys = missingKeysSet;\n\n        if (tryLookup) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));\n          await contextproviders.provideContextValues(\n            assembly.manifest.missing,\n            this.context,\n            this.props.services.sdkProvider,\n            this.props.services.pluginHost,\n            this.ioHelper,\n          );\n\n          // Cache the new context to disk\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0042.msg(`Writing updated context to ${this.contextFile}...`, {\n            contextFile: this.contextFile,\n            context: this.context.all,\n          }));\n          await this.context.save(this.contextFile);\n\n          // Execute again. Unlock the assembly here so that the producer can acquire\n          // a read lock on the directory again.\n          await readableAsm._unlock();\n          continue;\n        }\n      }\n\n      return readableAsm;\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"]}
+//# 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 contextproviders from '../../../context-providers';\nimport type { ToolkitServices } from '../../../toolkit/private';\nimport { ToolkitError } from '../../../toolkit/toolkit-error';\nimport type { IoHelper } from '../../io/private';\nimport { IO } from '../../io/private';\nimport type { IContextStore } from '../context-store';\nimport type { ICloudAssemblySource, IReadableCloudAssembly } 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   * Location to read and write context\n   */\n  readonly contextStore: IContextStore;\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 * A CloudAssemblySource that wraps another CloudAssemblySource and runs a lookup loop on it\n *\n * This means that if the underlying CloudAssemblySource produces a manifest\n * with provider queries in it, the `ContextAwareCloudAssemblySource` will\n * perform the necessary context lookups and invoke the underlying\n * `CloudAssemblySource` again with thew missing context information.\n *\n * This is only useful if the underlying `CloudAssemblySource` can respond to\n * this new context information (it must be a CDK app source); if it is just a\n * static directory, then the contents of the assembly won't change in response\n * to context.\n *\n * The context is passed between `ContextAwareCloudAssemblySource` and the wrapped\n * cloud assembly source via a contex file on disk, so the wrapped assembly source\n * should re-read the context file on every invocation.\n */\nexport class ContextAwareCloudAssemblySource implements ICloudAssemblySource {\n  private canLookup: boolean;\n  private context: IContextStore;\n  private ioHelper: IoHelper;\n\n  constructor(private readonly source: ICloudAssemblySource, private readonly props: ContextAwareCloudAssemblyProps) {\n    this.canLookup = props.lookups ?? true;\n    this.context = props.contextStore;\n    this.ioHelper = props.services.ioHelper;\n  }\n\n  /**\n   * Produce a Cloud Assembly, i.e. a set of stacks\n   */\n  public async produce(): Promise<IReadableCloudAssembly> {\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 readableAsm = await this.source.produce();\n\n      const assembly = readableAsm.cloudAssembly;\n      if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n        const missingKeysSet = missingContextKeys(assembly.manifest.missing);\n        const missingKeys = Array.from(missingKeysSet);\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: '${missingKeys.join(', ')}'`);\n        }\n\n        let tryLookup = true;\n        if (previouslyMissingKeys && equalSets(missingKeysSet, previouslyMissingKeys)) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0240.msg('Not making progress trying to resolve environmental context. Giving up.', { missingKeys }));\n          tryLookup = false;\n        }\n\n        previouslyMissingKeys = missingKeysSet;\n\n        if (tryLookup) {\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));\n          const contextUpdates = await contextproviders.provideContextValues(\n            assembly.manifest.missing,\n            this.props.services.sdkProvider,\n            this.props.services.pluginHost,\n            this.ioHelper,\n          );\n\n          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0042.msg('Writing context updates...', {\n            context: contextUpdates,\n          }));\n          await this.context.update(contextUpdates);\n\n          // Execute again. Unlock the assembly here so that the producer can acquire\n          // a read lock on the directory again.\n          await readableAsm._unlock();\n          continue;\n        }\n      }\n\n      return readableAsm;\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

@@ -1,7 +1,7 @@
 type EventPublisher = (event: 'open' | 'data_stdout' | 'data_stderr' | 'close', line: string) => void;
 interface ExecOptions {
     eventPublisher?: EventPublisher;
-    extraEnv?: {
+    env?: {
         [key: string]: string | undefined;
     };
     cwd?: string;

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

@@ -23,10 +23,7 @@ async function execInChildProcess(commandAndArgs, options = {}) {
             detached: false,
             shell: true,
             cwd: options.cwd,
-            env: {
-                ...process.env,
-                ...(options.extraEnv ?? {}),
-            },
+            env: options.env,
         });
         const eventPublisher = options.eventPublisher ?? ((type, line) => {
             switch (type) {
@@ -54,4 +51,4 @@ async function execInChildProcess(commandAndArgs, options = {}) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhlYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImV4ZWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFnQkEsZ0RBK0NDO0FBL0RELG9EQUFvRDtBQUNwRCxpRUFBaUU7QUFDakUsZ0NBQWlDO0FBQ2pDLGtFQUE4RDtBQVU5RDs7R0FFRztBQUNJLEtBQUssVUFBVSxrQkFBa0IsQ0FBQyxjQUFzQixFQUFFLFVBQXVCLEVBQUU7SUFDeEYsT0FBTyxJQUFJLE9BQU8sQ0FBTyxDQUFDLEVBQUUsRUFBRSxJQUFJLEVBQUUsRUFBRTtRQUNwQyw4Q0FBOEM7UUFDOUMsRUFBRTtRQUNGLG9FQUFvRTtRQUNwRSx3RUFBd0U7UUFDeEUsMERBQTBEO1FBQzFELEVBQUU7UUFDRiwwRkFBMEY7UUFDMUYsc0ZBQXNGO1FBQ3RGLE1BQU0sSUFBSSxHQUFHLGFBQWEsQ0FBQyxLQUFLLENBQUMsY0FBYyxFQUFFO1lBQy9DLEtBQUssRUFBRSxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDO1lBQ2pDLFFBQVEsRUFBRSxLQUFLO1lBQ2YsS0FBSyxFQUFFLElBQUk7WUFDWCxHQUFHLEVBQUUsT0FBTyxDQUFDLEdBQUc7WUFDaEIsR0FBRyxFQUFFO2dCQUNILEdBQUcsT0FBTyxDQUFDLEdBQUc7Z0JBQ2QsR0FBRyxDQUFDLE9BQU8sQ0FBQyxRQUFRLElBQUksRUFBRSxDQUFDO2FBQzVCO1NBQ0YsQ0FBQyxDQUFDO1FBRUgsTUFBTSxjQUFjLEdBQW1CLE9BQU8sQ0FBQyxjQUFjLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsRUFBRTtZQUMvRSxRQUFRLElBQUksRUFBRSxDQUFDO2dCQUNiLEtBQUssYUFBYTtvQkFDaEIsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7b0JBQzNCLE9BQU87Z0JBQ1QsS0FBSyxhQUFhO29CQUNoQixPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztvQkFDM0IsT0FBTztnQkFDVCxLQUFLLE1BQU0sQ0FBQztnQkFDWixLQUFLLE9BQU87b0JBQ1YsT0FBTztZQUNYLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsY0FBYyxDQUFDLGFBQWEsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQ3BGLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsY0FBYyxDQUFDLGFBQWEsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBRXBGLElBQUksQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBRXZCLElBQUksQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxFQUFFO1lBQ3JCLElBQUksSUFBSSxLQUFLLENBQUMsRUFBRSxDQUFDO2dCQUNmLE9BQU8sRUFBRSxFQUFFLENBQUM7WUFDZCxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sT0FBTyxJQUFJLENBQUMsSUFBSSw0QkFBWSxDQUFDLEdBQUcsY0FBYyxrQ0FBa0MsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQzNGLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGNoaWxkX3Byb2Nlc3MgZnJvbSAnbm9kZTpjaGlsZF9wcm9jZXNzJztcbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzXG5pbXBvcnQgc3BsaXQgPSByZXF1aXJlKCdzcGxpdDInKTtcbmltcG9ydCB7IFRvb2xraXRFcnJvciB9IGZyb20gJy4uLy4uLy4uL3Rvb2xraXQvdG9vbGtpdC1lcnJvcic7XG5cbnR5cGUgRXZlbnRQdWJsaXNoZXIgPSAoZXZlbnQ6ICdvcGVuJyB8ICdkYXRhX3N0ZG91dCcgfCAnZGF0YV9zdGRlcnInIHwgJ2Nsb3NlJywgbGluZTogc3RyaW5nKSA9PiB2b2lkO1xuXG5pbnRlcmZhY2UgRXhlY09wdGlvbnMge1xuICBldmVudFB1Ymxpc2hlcj86IEV2ZW50UHVibGlzaGVyO1xuICBleHRyYUVudj86IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIHwgdW5kZWZpbmVkIH07XG4gIGN3ZD86IHN0cmluZztcbn1cblxuLyoqXG4gKiBFeGVjdXRlIGEgY29tbWFuZCBhbmQgYXJncyBpbiBhIGNoaWxkIHByb2Nlc3NcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGV4ZWNJbkNoaWxkUHJvY2Vzcyhjb21tYW5kQW5kQXJnczogc3RyaW5nLCBvcHRpb25zOiBFeGVjT3B0aW9ucyA9IHt9KSB7XG4gIHJldHVybiBuZXcgUHJvbWlzZTx2b2lkPigob2ssIGZhaWwpID0+IHtcbiAgICAvLyBXZSB1c2UgYSBzbGlnaHRseSBsb3dlci1sZXZlbCBpbnRlcmZhY2UgdG86XG4gICAgLy9cbiAgICAvLyAtIFBhc3MgYXJndW1lbnRzIGluIGFuIGFycmF5IGluc3RlYWQgb2YgYSBzdHJpbmcsIHRvIGdldCBhcm91bmQgYVxuICAgIC8vICAgbnVtYmVyIG9mIHF1b3RpbmcgaXNzdWVzIGludHJvZHVjZWQgYnkgdGhlIGludGVybWVkaWF0ZSBzaGVsbCBsYXllclxuICAgIC8vICAgKHdoaWNoIHdvdWxkIGJlIGRpZmZlcmVudCBiZXR3ZWVuIExpbnV4IGFuZCBXaW5kb3dzKS5cbiAgICAvL1xuICAgIC8vIC0gV2UgaGF2ZSB0byBjYXB0dXJlIGFueSBvdXRwdXQgdG8gc3Rkb3V0IGFuZCBzdGRlcnIgc3Agd2UgY2FuIHBhc3MgaXQgb24gdG8gdGhlIElvSG9zdFxuICAgIC8vICAgVG8gZW5zdXJlIG1lc3NhZ2VzIGdldCB0byB0aGUgdXNlciBmYXN0LCB3ZSB3aWxsIGVtaXQgZXZlcnkgZnVsbCBsaW5lIHdlIHJlY2VpdmUuXG4gICAgY29uc3QgcHJvYyA9IGNoaWxkX3Byb2Nlc3Muc3Bhd24oY29tbWFuZEFuZEFyZ3MsIHtcbiAgICAgIHN0ZGlvOiBbJ2lnbm9yZScsICdwaXBlJywgJ3BpcGUnXSxcbiAgICAgIGRldGFjaGVkOiBmYWxzZSxcbiAgICAgIHNoZWxsOiB0cnVlLFxuICAgICAgY3dkOiBvcHRpb25zLmN3ZCxcbiAgICAgIGVudjoge1xuICAgICAgICAuLi5wcm9jZXNzLmVudixcbiAgICAgICAgLi4uKG9wdGlvbnMuZXh0cmFFbnYgPz8ge30pLFxuICAgICAgfSxcbiAgICB9KTtcblxuICAgIGNvbnN0IGV2ZW50UHVibGlzaGVyOiBFdmVudFB1Ymxpc2hlciA9IG9wdGlvbnMuZXZlbnRQdWJsaXNoZXIgPz8gKCh0eXBlLCBsaW5lKSA9PiB7XG4gICAgICBzd2l0Y2ggKHR5cGUpIHtcbiAgICAgICAgY2FzZSAnZGF0YV9zdGRvdXQnOlxuICAgICAgICAgIHByb2Nlc3Muc3Rkb3V0LndyaXRlKGxpbmUpO1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgY2FzZSAnZGF0YV9zdGRlcnInOlxuICAgICAgICAgIHByb2Nlc3Muc3RkZXJyLndyaXRlKGxpbmUpO1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgY2FzZSAnb3Blbic6XG4gICAgICAgIGNhc2UgJ2Nsb3NlJzpcbiAgICAgICAgICByZXR1cm47XG4gICAgICB9XG4gICAgfSk7XG4gICAgcHJvYy5zdGRvdXQucGlwZShzcGxpdCgpKS5vbignZGF0YScsIChsaW5lKSA9PiBldmVudFB1Ymxpc2hlcignZGF0YV9zdGRvdXQnLCBsaW5lKSk7XG4gICAgcHJvYy5zdGRlcnIucGlwZShzcGxpdCgpKS5vbignZGF0YScsIChsaW5lKSA9PiBldmVudFB1Ymxpc2hlcignZGF0YV9zdGRlcnInLCBsaW5lKSk7XG5cbiAgICBwcm9jLm9uKCdlcnJvcicsIGZhaWwpO1xuXG4gICAgcHJvYy5vbignZXhpdCcsIGNvZGUgPT4ge1xuICAgICAgaWYgKGNvZGUgPT09IDApIHtcbiAgICAgICAgcmV0dXJuIG9rKCk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICByZXR1cm4gZmFpbChuZXcgVG9vbGtpdEVycm9yKGAke2NvbW1hbmRBbmRBcmdzfTogU3VicHJvY2VzcyBleGl0ZWQgd2l0aCBlcnJvciAke2NvZGV9YCkpO1xuICAgICAgfVxuICAgIH0pO1xuICB9KTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+/**
+ * Temporarily overwrite the `process.env` with a new `env`
+ *
+ * We make the environment immutable in case there are accidental
+ * concurrent accesses.
+ */
+export declare function temporarilyWriteEnv(env: Record<string, string>): {
+    [Symbol.dispose](): void;
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.temporarilyWriteEnv = temporarilyWriteEnv;
+const toolkit_error_1 = require("../../../toolkit/toolkit-error");
+/**
+ * Temporarily overwrite the `process.env` with a new `env`
+ *
+ * We make the environment immutable in case there are accidental
+ * concurrent accesses.
+ */
+function temporarilyWriteEnv(env) {
+    const oldEnv = process.env;
+    process.env = detectSynthvarConflicts({
+        ...process.env,
+        ...env,
+    });
+    return {
+        [Symbol.dispose]() {
+            process.env = oldEnv;
+        },
+    };
+}
+/**
+ * Return an environment-like object that throws if certain keys are set
+ *
+ * We only throw on specific environment variables to catch the case of
+ * concurrent synths. We can't do all variables because there are some
+ * routines somewhere that modify things like `JSII_DEPRECATED` globally.
+ */
+function detectSynthvarConflicts(obj) {
+    return new Proxy(obj, {
+        get(target, prop) {
+            return target[prop];
+        },
+        set(target, prop, value) {
+            if (['CDK_CONTEXT', 'CDK_OUTDIR'].includes(String(prop))) {
+                throw new toolkit_error_1.ToolkitError('process.env is temporarily immutable. Set \'clobberEnv: false\' if you want to run multiple \'fromAssemblyBuilder\' synths concurrently');
+            }
+            target[prop] = value;
+            return true;
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -2,5 +2,4 @@ export * from './context-aware-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

@@ -18,6 +18,5 @@ __exportStar(require("./context-aware-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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseURBQXVDO0FBQ3ZDLG1EQUFpQztBQUNqQyx5Q0FBdUI7QUFDdkIsbURBQWlDO0FBQ2pDLG1EQUFpQztBQUNqQyxvREFBa0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRleHQtYXdhcmUtc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2stYXNzZW1ibHknO1xuZXhwb3J0ICogZnJvbSAnLi9leGVjJztcbmV4cG9ydCAqIGZyb20gJy4vcHJlcGFyZS1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb3VyY2UtYnVpbGRlcic7XG5leHBvcnQgKiBmcm9tICcuL3N0YWNrLXNlbGVjdG9ycyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseURBQXVDO0FBQ3ZDLG1EQUFpQztBQUNqQyx5Q0FBdUI7QUFDdkIsbURBQWlDO0FBQ2pDLG9EQUFrQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC1hd2FyZS1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFjay1hc3NlbWJseSc7XG5leHBvcnQgKiBmcm9tICcuL2V4ZWMnO1xuZXhwb3J0ICogZnJvbSAnLi9wcmVwYXJlLXNvdXJjZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0YWNrLXNlbGVjdG9ycyc7XG4iXX0=