@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/plugin/context-provider-plugin.d.ts

@@ -0,0 +1,6 @@
+export interface ContextProviderPlugin {
+    getValue(args: {
+        [key: string]: any;
+    }): Promise<any>;
+}
+export declare function isContextProviderPlugin(x: unknown): x is ContextProviderPlugin;

package/lib/api/plugin/context-provider-plugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContextProviderPlugin = isContextProviderPlugin;
+function isContextProviderPlugin(x) {
+    return typeof x === 'object' && !!x && !!x.getValue;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC1wcm92aWRlci1wbHVnaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb250ZXh0LXByb3ZpZGVyLXBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLDBEQUVDO0FBRkQsU0FBZ0IsdUJBQXVCLENBQUMsQ0FBVTtJQUNoRCxPQUFPLE9BQU8sQ0FBQyxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBRSxDQUFTLENBQUMsUUFBUSxDQUFDO0FBQy9ELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENvbnRleHRQcm92aWRlclBsdWdpbiB7XG4gIGdldFZhbHVlKGFyZ3M6IHsgW2tleTogc3RyaW5nXTogYW55IH0pOiBQcm9taXNlPGFueT47XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0NvbnRleHRQcm92aWRlclBsdWdpbih4OiB1bmtub3duKTogeCBpcyBDb250ZXh0UHJvdmlkZXJQbHVnaW4ge1xuICByZXR1cm4gdHlwZW9mIHggPT09ICdvYmplY3QnICYmICEheCAmJiAhISh4IGFzIGFueSkuZ2V0VmFsdWU7XG59XG4iXX0=

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

@@ -0,0 +1,3 @@
+export * from './plugin';
+export * from './mode';
+export * from './context-provider-plugin';

package/lib/api/plugin/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("./plugin"), exports);
+__exportStar(require("./mode"), exports);
+__exportStar(require("./context-provider-plugin"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMkNBQXlCO0FBQ3pCLHlDQUF1QjtBQUN2Qiw0REFBMEMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BsdWdpbic7XG5leHBvcnQgKiBmcm9tICcuL21vZGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LXByb3ZpZGVyLXBsdWdpbic7XG4iXX0=

package/lib/api/plugin/mode.d.ts

@@ -0,0 +1,4 @@
+export declare enum Mode {
+    ForReading,
+    ForWriting
+}

package/lib/api/plugin/mode.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mode = void 0;
+var Mode;
+(function (Mode) {
+    Mode[Mode["ForReading"] = 0] = "ForReading";
+    Mode[Mode["ForWriting"] = 1] = "ForWriting";
+})(Mode || (exports.Mode = Mode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm1vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsSUFBWSxJQUdYO0FBSEQsV0FBWSxJQUFJO0lBQ2QsMEJBQWEsQ0FBNEIsZ0JBQUEsQ0FBQTtJQUN6QywwQkFBYSxDQUE0QixnQkFBQSxDQUFBO0FBQzNDLENBQUMsRUFIVyxJQUFJLG9CQUFKLElBQUksUUFHZiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRm9yUmVhZGluZyBhcyBQbHVnaW5Gb3JSZWFkaW5nLCBGb3JXcml0aW5nIGFzIFBsdWdpbkZvcldyaXRpbmcgfSBmcm9tICdAYXdzLWNkay9jbGktcGx1Z2luLWNvbnRyYWN0JztcblxuZXhwb3J0IGVudW0gTW9kZSB7XG4gIEZvclJlYWRpbmcgPSAwIHNhdGlzZmllcyBQbHVnaW5Gb3JSZWFkaW5nLFxuICBGb3JXcml0aW5nID0gMSBzYXRpc2ZpZXMgUGx1Z2luRm9yV3JpdGluZyxcbn1cbiJdfQ==

package/lib/api/plugin/plugin.d.ts

@@ -0,0 +1,70 @@
+import type { CredentialProviderSource, IPluginHost } from '@aws-cdk/cli-plugin-contract';
+import { type ContextProviderPlugin } from './context-provider-plugin';
+import type { IIoHost } from '../io';
+/**
+ * Class to manage a plugin collection
+ *
+ * It provides a `load()` function that loads a JavaScript
+ * module from disk, and gives it access to the `IPluginHost` interface
+ * to register itself.
+ */
+export declare class PluginHost implements IPluginHost {
+    /**
+     * Access the currently registered CredentialProviderSources. New sources can
+     * be registered using the +registerCredentialProviderSource+ method.
+     */
+    readonly credentialProviderSources: CredentialProviderSource[];
+    readonly contextProviderPlugins: Record<string, ContextProviderPlugin>;
+    ioHost?: IIoHost;
+    private readonly alreadyLoaded;
+    /**
+     * Loads a plug-in into this PluginHost.
+     *
+     * Will use `require.resolve()` to get the most accurate representation of what
+     * code will get loaded in error messages. As such, it will not work in
+     * unit tests with Jest virtual modules becauase of <https://github.com/jestjs/jest/issues/9543>.
+     *
+     * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.
+     * @param ioHost the I/O host to use for printing progress information
+     */
+    load(moduleSpec: string, ioHost?: IIoHost): void;
+    /**
+     * Allows plug-ins to register new CredentialProviderSources.
+     *
+     * @param source a new CredentialProviderSource to register.
+     */
+    registerCredentialProviderSource(source: CredentialProviderSource): void;
+    /**
+     * (EXPERIMENTAL) Allow plugins to register context providers
+     *
+     * Context providers are objects with the following method:
+     *
+     * ```ts
+     *   getValue(args: {[key: string]: any}): Promise<any>;
+     * ```
+     *
+     * Currently, they cannot reuse the CDK's authentication mechanisms, so they
+     * must be prepared to either not make AWS calls or use their own source of
+     * AWS credentials.
+     *
+     * This feature is experimental, and only intended to be used internally at Amazon
+     * as a trial.
+     *
+     * After registering with 'my-plugin-name', the provider must be addressed as follows:
+     *
+     * ```ts
+     * const value = ContextProvider.getValue(this, {
+     *   providerName: 'plugin',
+     *   props: {
+     *     pluginName: 'my-plugin-name',
+     *     myParameter1: 'xyz',
+     *   },
+     *   includeEnvironment: true | false,
+     *   dummyValue: 'what-to-return-on-the-first-pass',
+     * })
+     * ```
+     *
+     * @experimental
+     */
+    registerContextProviderAlpha(pluginProviderName: string, provider: ContextProviderPlugin): void;
+}

package/lib/api/plugin/plugin.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginHost = void 0;
+const util_1 = require("util");
+const context_provider_plugin_1 = require("./context-provider-plugin");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const private_1 = require("../io/private");
+/**
+ * Class to manage a plugin collection
+ *
+ * It provides a `load()` function that loads a JavaScript
+ * module from disk, and gives it access to the `IPluginHost` interface
+ * to register itself.
+ */
+class PluginHost {
+    /**
+     * Access the currently registered CredentialProviderSources. New sources can
+     * be registered using the +registerCredentialProviderSource+ method.
+     */
+    credentialProviderSources = new Array();
+    contextProviderPlugins = {};
+    ioHost;
+    alreadyLoaded = new Set();
+    /**
+     * Loads a plug-in into this PluginHost.
+     *
+     * Will use `require.resolve()` to get the most accurate representation of what
+     * code will get loaded in error messages. As such, it will not work in
+     * unit tests with Jest virtual modules becauase of <https://github.com/jestjs/jest/issues/9543>.
+     *
+     * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.
+     * @param ioHost the I/O host to use for printing progress information
+     */
+    load(moduleSpec, ioHost) {
+        try {
+            const resolved = require.resolve(moduleSpec);
+            if (ioHost) {
+                new private_1.IoDefaultMessages(private_1.IoHelper.fromIoHost(ioHost, 'init')).debug(`Loading plug-in: ${resolved} from ${moduleSpec}`);
+            }
+            return this._doLoad(resolved);
+        }
+        catch (e) {
+            // according to Node.js docs `MODULE_NOT_FOUND` is the only possible error here
+            // @see https://nodejs.org/api/modules.html#requireresolverequest-options
+            // Not using `withCause()` here, since the node error contains a "Require Stack"
+            // as part of the error message that is inherently useless to our users.
+            throw new toolkit_error_1.ToolkitError(`Unable to resolve plug-in: Cannot find module '${moduleSpec}': ${e}`);
+        }
+    }
+    /**
+     * Do the loading given an already-resolved module name
+     *
+     * @internal
+     */
+    _doLoad(resolved) {
+        try {
+            if (this.alreadyLoaded.has(resolved)) {
+                return;
+            }
+            /* eslint-disable @typescript-eslint/no-require-imports */
+            const plugin = require(resolved);
+            /* eslint-enable */
+            if (!isPlugin(plugin)) {
+                throw new toolkit_error_1.ToolkitError(`Module ${resolved} is not a valid plug-in, or has an unsupported version.`);
+            }
+            if (plugin.init) {
+                plugin.init(this);
+            }
+            this.alreadyLoaded.add(resolved);
+        }
+        catch (e) {
+            throw toolkit_error_1.ToolkitError.withCause(`Unable to load plug-in '${resolved}'`, e);
+        }
+        function isPlugin(x) {
+            return x != null && x.version === '1';
+        }
+    }
+    /**
+     * Allows plug-ins to register new CredentialProviderSources.
+     *
+     * @param source a new CredentialProviderSource to register.
+     */
+    registerCredentialProviderSource(source) {
+        // Forward to the right credentials-related plugin host
+        this.credentialProviderSources.push(source);
+    }
+    /**
+     * (EXPERIMENTAL) Allow plugins to register context providers
+     *
+     * Context providers are objects with the following method:
+     *
+     * ```ts
+     *   getValue(args: {[key: string]: any}): Promise<any>;
+     * ```
+     *
+     * Currently, they cannot reuse the CDK's authentication mechanisms, so they
+     * must be prepared to either not make AWS calls or use their own source of
+     * AWS credentials.
+     *
+     * This feature is experimental, and only intended to be used internally at Amazon
+     * as a trial.
+     *
+     * After registering with 'my-plugin-name', the provider must be addressed as follows:
+     *
+     * ```ts
+     * const value = ContextProvider.getValue(this, {
+     *   providerName: 'plugin',
+     *   props: {
+     *     pluginName: 'my-plugin-name',
+     *     myParameter1: 'xyz',
+     *   },
+     *   includeEnvironment: true | false,
+     *   dummyValue: 'what-to-return-on-the-first-pass',
+     * })
+     * ```
+     *
+     * @experimental
+     */
+    registerContextProviderAlpha(pluginProviderName, provider) {
+        if (!(0, context_provider_plugin_1.isContextProviderPlugin)(provider)) {
+            throw new toolkit_error_1.ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${(0, util_1.inspect)(provider)}`);
+        }
+        this.contextProviderPlugins[pluginProviderName] = provider;
+    }
+}
+exports.PluginHost = PluginHost;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["plugin.ts"],"names":[],"mappings":";;;AAAA,+BAA+B;AAE/B,uEAAgG;AAChG,+DAA2D;AAE3D,2CAA4D;AAE5D;;;;;;GAMG;AACH,MAAa,UAAU;IACrB;;;OAGG;IACa,yBAAyB,GAAG,IAAI,KAAK,EAA4B,CAAC;IAElE,sBAAsB,GAA0C,EAAE,CAAC;IAE5E,MAAM,CAAW;IAEP,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IAEnD;;;;;;;;;OASG;IACI,IAAI,CAAC,UAAkB,EAAE,MAAgB;QAC9C,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAC7C,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,2BAAiB,CAAC,kBAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,oBAAoB,QAAQ,SAAS,UAAU,EAAE,CAAC,CAAC;YACtH,CAAC;YACD,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,+EAA+E;YAC/E,yEAAyE;YACzE,gFAAgF;YAChF,wEAAwE;YACxE,MAAM,IAAI,4BAAY,CAAC,kDAAkD,UAAU,MAAM,CAAC,EAAE,CAAC,CAAC;QAChG,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,OAAO,CAAC,QAAgB;QAC7B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACrC,OAAO;YACT,CAAC;YAED,0DAA0D;YAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;YACjC,mBAAmB;YACnB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBACtB,MAAM,IAAI,4BAAY,CAAC,UAAU,QAAQ,yDAAyD,CAAC,CAAC;YACtG,CAAC;YACD,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;YAED,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,4BAAY,CAAC,SAAS,CAAC,2BAA2B,QAAQ,GAAG,EAAE,CAAC,CAAC,CAAC;QAC1E,CAAC;QAED,SAAS,QAAQ,CAAC,CAAM;YACtB,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC;QACxC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,gCAAgC,CAAC,MAAgC;QACtE,uDAAuD;QACvD,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACI,4BAA4B,CAAC,kBAA0B,EAAE,QAA+B;QAC7F,IAAI,CAAC,IAAA,iDAAuB,EAAC,QAAQ,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,4BAAY,CAAC,kEAAkE,IAAA,cAAO,EAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAChH,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,kBAAkB,CAAC,GAAG,QAAQ,CAAC;IAC7D,CAAC;CACF;AAtHD,gCAsHC","sourcesContent":["import { inspect } from 'util';\nimport type { CredentialProviderSource, IPluginHost, Plugin } from '@aws-cdk/cli-plugin-contract';\nimport { type ContextProviderPlugin, isContextProviderPlugin } from './context-provider-plugin';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport type { IIoHost } from '../io';\nimport { IoDefaultMessages, IoHelper } from '../io/private';\n\n/**\n * Class to manage a plugin collection\n *\n * It provides a `load()` function that loads a JavaScript\n * module from disk, and gives it access to the `IPluginHost` interface\n * to register itself.\n */\nexport class PluginHost implements IPluginHost {\n  /**\n   * Access the currently registered CredentialProviderSources. New sources can\n   * be registered using the +registerCredentialProviderSource+ method.\n   */\n  public readonly credentialProviderSources = new Array<CredentialProviderSource>();\n\n  public readonly contextProviderPlugins: Record<string, ContextProviderPlugin> = {};\n\n  public ioHost?: IIoHost;\n\n  private readonly alreadyLoaded = new Set<string>();\n\n  /**\n   * Loads a plug-in into this PluginHost.\n   *\n   * Will use `require.resolve()` to get the most accurate representation of what\n   * code will get loaded in error messages. As such, it will not work in\n   * unit tests with Jest virtual modules becauase of <https://github.com/jestjs/jest/issues/9543>.\n   *\n   * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.\n   * @param ioHost the I/O host to use for printing progress information\n   */\n  public load(moduleSpec: string, ioHost?: IIoHost) {\n    try {\n      const resolved = require.resolve(moduleSpec);\n      if (ioHost) {\n        new IoDefaultMessages(IoHelper.fromIoHost(ioHost, 'init')).debug(`Loading plug-in: ${resolved} from ${moduleSpec}`);\n      }\n      return this._doLoad(resolved);\n    } catch (e: any) {\n      // according to Node.js docs `MODULE_NOT_FOUND` is the only possible error here\n      // @see https://nodejs.org/api/modules.html#requireresolverequest-options\n      // Not using `withCause()` here, since the node error contains a \"Require Stack\"\n      // as part of the error message that is inherently useless to our users.\n      throw new ToolkitError(`Unable to resolve plug-in: Cannot find module '${moduleSpec}': ${e}`);\n    }\n  }\n\n  /**\n   * Do the loading given an already-resolved module name\n   *\n   * @internal\n   */\n  public _doLoad(resolved: string) {\n    try {\n      if (this.alreadyLoaded.has(resolved)) {\n        return;\n      }\n\n      /* eslint-disable @typescript-eslint/no-require-imports */\n      const plugin = require(resolved);\n      /* eslint-enable */\n      if (!isPlugin(plugin)) {\n        throw new ToolkitError(`Module ${resolved} is not a valid plug-in, or has an unsupported version.`);\n      }\n      if (plugin.init) {\n        plugin.init(this);\n      }\n\n      this.alreadyLoaded.add(resolved);\n    } catch (e: any) {\n      throw ToolkitError.withCause(`Unable to load plug-in '${resolved}'`, e);\n    }\n\n    function isPlugin(x: any): x is Plugin {\n      return x != null && x.version === '1';\n    }\n  }\n\n  /**\n   * Allows plug-ins to register new CredentialProviderSources.\n   *\n   * @param source a new CredentialProviderSource to register.\n   */\n  public registerCredentialProviderSource(source: CredentialProviderSource) {\n    // Forward to the right credentials-related plugin host\n    this.credentialProviderSources.push(source);\n  }\n\n  /**\n   * (EXPERIMENTAL) Allow plugins to register context providers\n   *\n   * Context providers are objects with the following method:\n   *\n   * ```ts\n   *   getValue(args: {[key: string]: any}): Promise<any>;\n   * ```\n   *\n   * Currently, they cannot reuse the CDK's authentication mechanisms, so they\n   * must be prepared to either not make AWS calls or use their own source of\n   * AWS credentials.\n   *\n   * This feature is experimental, and only intended to be used internally at Amazon\n   * as a trial.\n   *\n   * After registering with 'my-plugin-name', the provider must be addressed as follows:\n   *\n   * ```ts\n   * const value = ContextProvider.getValue(this, {\n   *   providerName: 'plugin',\n   *   props: {\n   *     pluginName: 'my-plugin-name',\n   *     myParameter1: 'xyz',\n   *   },\n   *   includeEnvironment: true | false,\n   *   dummyValue: 'what-to-return-on-the-first-pass',\n   * })\n   * ```\n   *\n   * @experimental\n   */\n  public registerContextProviderAlpha(pluginProviderName: string, provider: ContextProviderPlugin) {\n    if (!isContextProviderPlugin(provider)) {\n      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${inspect(provider)}`);\n    }\n    this.contextProviderPlugins[pluginProviderName] = provider;\n  }\n}\n"]}

package/lib/api/private.d.ts

@@ -0,0 +1 @@
+export * from './io/private';

package/lib/api/private.js

@@ -0,0 +1,18 @@
+"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("./io/private"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInByaXZhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW8vcHJpdmF0ZSc7XG4iXX0=

package/lib/api/refactoring/cloudformation.d.ts

@@ -0,0 +1,38 @@
+import type { TypedMapping } from '@aws-cdk/cloudformation-diff';
+import type * as cxapi from '@aws-cdk/cx-api';
+export interface CloudFormationTemplate {
+    Resources?: {
+        [logicalId: string]: {
+            Type: string;
+            Properties?: any;
+            Metadata?: Record<string, any>;
+        };
+    };
+}
+export interface CloudFormationStack {
+    readonly environment: cxapi.Environment;
+    readonly stackName: string;
+    readonly template: CloudFormationTemplate;
+}
+/**
+ * This class mirrors the `ResourceLocation` interface from CloudFormation,
+ * but is richer, since it has a reference to the stack object, rather than
+ * merely the stack name.
+ */
+export declare class ResourceLocation {
+    readonly stack: CloudFormationStack;
+    readonly logicalResourceId: string;
+    constructor(stack: CloudFormationStack, logicalResourceId: string);
+    toPath(): string;
+    getType(): string;
+    equalTo(other: ResourceLocation): boolean;
+}
+/**
+ * A mapping between a source and a destination location.
+ */
+export declare class ResourceMapping {
+    readonly source: ResourceLocation;
+    readonly destination: ResourceLocation;
+    constructor(source: ResourceLocation, destination: ResourceLocation);
+    toTypedMapping(): TypedMapping;
+}

package/lib/api/refactoring/cloudformation.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceMapping = exports.ResourceLocation = void 0;
+/**
+ * This class mirrors the `ResourceLocation` interface from CloudFormation,
+ * but is richer, since it has a reference to the stack object, rather than
+ * merely the stack name.
+ */
+class ResourceLocation {
+    stack;
+    logicalResourceId;
+    constructor(stack, logicalResourceId) {
+        this.stack = stack;
+        this.logicalResourceId = logicalResourceId;
+    }
+    toPath() {
+        const stack = this.stack;
+        const resource = stack.template.Resources?.[this.logicalResourceId];
+        const result = resource?.Metadata?.['aws:cdk:path'];
+        if (result != null) {
+            return result;
+        }
+        // If the path is not available, we can use stack name and logical ID
+        return `${stack.stackName}.${this.logicalResourceId}`;
+    }
+    getType() {
+        const resource = this.stack.template.Resources?.[this.logicalResourceId ?? ''];
+        return resource?.Type ?? 'Unknown';
+    }
+    equalTo(other) {
+        return this.logicalResourceId === other.logicalResourceId && this.stack.stackName === other.stack.stackName;
+    }
+}
+exports.ResourceLocation = ResourceLocation;
+/**
+ * A mapping between a source and a destination location.
+ */
+class ResourceMapping {
+    source;
+    destination;
+    constructor(source, destination) {
+        this.source = source;
+        this.destination = destination;
+    }
+    toTypedMapping() {
+        return {
+            // the type is the same in both source and destination,
+            // so we can use either one
+            type: this.source.getType(),
+            sourcePath: this.source.toPath(),
+            destinationPath: this.destination.toPath(),
+        };
+    }
+}
+exports.ResourceMapping = ResourceMapping;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/refactoring/digest.d.ts

@@ -0,0 +1,26 @@
+import type { CloudFormationTemplate } from './cloudformation';
+/**
+ * Computes the digest for each resource in the template.
+ *
+ * Conceptually, the digest is computed as:
+ *
+ *     d(resource) = hash(type + physicalId)                       , if physicalId is defined
+ *                 = hash(type + properties + dependencies.map(d)) , otherwise
+ *
+ * where `hash` is a cryptographic hash function. In other words, if a resource has
+ * a physical ID, we use the physical ID plus its type to uniquely identify
+ * that resource. In this case, the digest can be computed from these two fields
+ * alone. A corollary is that such resources can be renamed and have their
+ * properties updated at the same time, and still be considered equivalent.
+ *
+ * Otherwise, the digest is computed from its type, its own properties (that is,
+ * excluding properties that refer to other resources), and the digests of each of
+ * its dependencies.
+ *
+ * The digest of a resource, defined recursively this way, remains stable even if
+ * one or more of its dependencies gets renamed. Since the resources in a
+ * CloudFormation template form a directed acyclic graph, this function is
+ * well-defined.
+ */
+export declare function computeResourceDigests(template: CloudFormationTemplate): Record<string, string>;
+export declare function hashObject(obj: any): string;

package/lib/api/refactoring/digest.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeResourceDigests = computeResourceDigests;
+exports.hashObject = hashObject;
+const crypto = require("node:crypto");
+const util_1 = require("@aws-cdk/cloudformation-diff/lib/diff/util");
+/**
+ * Computes the digest for each resource in the template.
+ *
+ * Conceptually, the digest is computed as:
+ *
+ *     d(resource) = hash(type + physicalId)                       , if physicalId is defined
+ *                 = hash(type + properties + dependencies.map(d)) , otherwise
+ *
+ * where `hash` is a cryptographic hash function. In other words, if a resource has
+ * a physical ID, we use the physical ID plus its type to uniquely identify
+ * that resource. In this case, the digest can be computed from these two fields
+ * alone. A corollary is that such resources can be renamed and have their
+ * properties updated at the same time, and still be considered equivalent.
+ *
+ * Otherwise, the digest is computed from its type, its own properties (that is,
+ * excluding properties that refer to other resources), and the digests of each of
+ * its dependencies.
+ *
+ * The digest of a resource, defined recursively this way, remains stable even if
+ * one or more of its dependencies gets renamed. Since the resources in a
+ * CloudFormation template form a directed acyclic graph, this function is
+ * well-defined.
+ */
+function computeResourceDigests(template) {
+    const resources = template.Resources || {};
+    const graph = {};
+    const reverseGraph = {};
+    // 1. Build adjacency lists
+    for (const id of Object.keys(resources)) {
+        graph[id] = new Set();
+        reverseGraph[id] = new Set();
+    }
+    // 2. Detect dependencies by searching for Ref/Fn::GetAtt
+    const findDependencies = (value) => {
+        if (!value || typeof value !== 'object')
+            return [];
+        if (Array.isArray(value)) {
+            return value.flatMap(findDependencies);
+        }
+        if ('Ref' in value) {
+            return [value.Ref];
+        }
+        if ('Fn::GetAtt' in value) {
+            const refTarget = Array.isArray(value['Fn::GetAtt']) ? value['Fn::GetAtt'][0] : value['Fn::GetAtt'].split('.')[0];
+            return [refTarget];
+        }
+        if ('DependsOn' in value) {
+            return [value.DependsOn];
+        }
+        return Object.values(value).flatMap(findDependencies);
+    };
+    for (const [id, res] of Object.entries(resources)) {
+        const deps = findDependencies(res || {});
+        for (const dep of deps) {
+            if (dep in resources && dep !== id) {
+                graph[id].add(dep);
+                reverseGraph[dep].add(id);
+            }
+        }
+    }
+    // 3. Topological sort
+    const outDegree = Object.keys(graph).reduce((acc, k) => {
+        acc[k] = graph[k].size;
+        return acc;
+    }, {});
+    const queue = Object.keys(outDegree).filter((k) => outDegree[k] === 0);
+    const order = [];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        order.push(node);
+        for (const nxt of reverseGraph[node]) {
+            outDegree[nxt]--;
+            if (outDegree[nxt] === 0) {
+                queue.push(nxt);
+            }
+        }
+    }
+    // 4. Compute digests in sorted order
+    const result = {};
+    for (const id of order) {
+        const resource = resources[id];
+        const resourceProperties = resource.Properties ?? {};
+        const model = (0, util_1.loadResourceModel)(resource.Type);
+        const identifier = intersection(Object.keys(resourceProperties), model?.primaryIdentifier ?? []);
+        let toHash;
+        if (identifier.length === model?.primaryIdentifier?.length) {
+            // The resource has a physical ID defined, so we can
+            // use the ID and the type as the identity of the resource.
+            toHash =
+                resource.Type +
+                    identifier
+                        .sort()
+                        .map((attr) => JSON.stringify(resourceProperties[attr]))
+                        .join('');
+        }
+        else {
+            // The resource does not have a physical ID defined, so we need to
+            // compute the digest based on its properties and dependencies.
+            const depDigests = Array.from(graph[id]).map((d) => result[d]);
+            const propertiesHash = hashObject(stripReferences(stripConstructPath(resource)));
+            toHash = resource.Type + propertiesHash + depDigests.join('');
+        }
+        result[id] = crypto.createHash('sha256').update(toHash).digest('hex');
+    }
+    return result;
+}
+function hashObject(obj) {
+    const hash = crypto.createHash('sha256');
+    function addToHash(value) {
+        if (value == null) {
+            addToHash('null');
+        }
+        else if (typeof value === 'object') {
+            if (Array.isArray(value)) {
+                value.forEach(addToHash);
+            }
+            else {
+                Object.keys(value)
+                    .sort()
+                    .forEach((key) => {
+                    hash.update(key);
+                    addToHash(value[key]);
+                });
+            }
+        }
+        else {
+            hash.update(typeof value + value.toString());
+        }
+    }
+    addToHash(obj);
+    return hash.digest('hex');
+}
+/**
+ * Removes sub-properties containing Ref or Fn::GetAtt to avoid hashing
+ * references themselves but keeps the property structure.
+ */
+function stripReferences(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(stripReferences);
+    }
+    if ('Ref' in value) {
+        return { __cloud_ref__: 'Ref' };
+    }
+    if ('Fn::GetAtt' in value) {
+        return { __cloud_ref__: 'Fn::GetAtt' };
+    }
+    if ('DependsOn' in value) {
+        return { __cloud_ref__: 'DependsOn' };
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+        result[k] = stripReferences(v);
+    }
+    return result;
+}
+function stripConstructPath(resource) {
+    if (resource?.Metadata?.['aws:cdk:path'] == null) {
+        return resource;
+    }
+    const copy = JSON.parse(JSON.stringify(resource));
+    delete copy.Metadata['aws:cdk:path'];
+    return copy;
+}
+function intersection(a, b) {
+    return a.filter((value) => b.includes(value));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"digest.js","sourceRoot":"","sources":["digest.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'node:crypto';\nimport { loadResourceModel } from '@aws-cdk/cloudformation-diff/lib/diff/util';\nimport type { CloudFormationTemplate } from './cloudformation';\n\n/**\n * Computes the digest for each resource in the template.\n *\n * Conceptually, the digest is computed as:\n *\n *     d(resource) = hash(type + physicalId)                       , if physicalId is defined\n *                 = hash(type + properties + dependencies.map(d)) , otherwise\n *\n * where `hash` is a cryptographic hash function. In other words, if a resource has\n * a physical ID, we use the physical ID plus its type to uniquely identify\n * that resource. In this case, the digest can be computed from these two fields\n * alone. A corollary is that such resources can be renamed and have their\n * properties updated at the same time, and still be considered equivalent.\n *\n * Otherwise, the digest is computed from its type, its own properties (that is,\n * excluding properties that refer to other resources), and the digests of each of\n * its dependencies.\n *\n * The digest of a resource, defined recursively this way, remains stable even if\n * one or more of its dependencies gets renamed. Since the resources in a\n * CloudFormation template form a directed acyclic graph, this function is\n * well-defined.\n */\nexport function computeResourceDigests(template: CloudFormationTemplate): Record<string, string> {\n  const resources = template.Resources || {};\n  const graph: Record<string, Set<string>> = {};\n  const reverseGraph: Record<string, Set<string>> = {};\n\n  // 1. Build adjacency lists\n  for (const id of Object.keys(resources)) {\n    graph[id] = new Set();\n    reverseGraph[id] = new Set();\n  }\n\n  // 2. Detect dependencies by searching for Ref/Fn::GetAtt\n  const findDependencies = (value: any): string[] => {\n    if (!value || typeof value !== 'object') return [];\n    if (Array.isArray(value)) {\n      return value.flatMap(findDependencies);\n    }\n    if ('Ref' in value) {\n      return [value.Ref];\n    }\n    if ('Fn::GetAtt' in value) {\n      const refTarget = Array.isArray(value['Fn::GetAtt']) ? value['Fn::GetAtt'][0] : value['Fn::GetAtt'].split('.')[0];\n      return [refTarget];\n    }\n    if ('DependsOn' in value) {\n      return [value.DependsOn];\n    }\n    return Object.values(value).flatMap(findDependencies);\n  };\n\n  for (const [id, res] of Object.entries(resources)) {\n    const deps = findDependencies(res || {});\n    for (const dep of deps) {\n      if (dep in resources && dep !== id) {\n        graph[id].add(dep);\n        reverseGraph[dep].add(id);\n      }\n    }\n  }\n\n  // 3. Topological sort\n  const outDegree = Object.keys(graph).reduce((acc, k) => {\n    acc[k] = graph[k].size;\n    return acc;\n  }, {} as Record<string, number>);\n\n  const queue = Object.keys(outDegree).filter((k) => outDegree[k] === 0);\n  const order: string[] = [];\n\n  while (queue.length > 0) {\n    const node = queue.shift()!;\n    order.push(node);\n    for (const nxt of reverseGraph[node]) {\n      outDegree[nxt]--;\n      if (outDegree[nxt] === 0) {\n        queue.push(nxt);\n      }\n    }\n  }\n\n  // 4. Compute digests in sorted order\n  const result: Record<string, string> = {};\n  for (const id of order) {\n    const resource = resources[id];\n    const resourceProperties = resource.Properties ?? {};\n    const model = loadResourceModel(resource.Type);\n    const identifier = intersection(Object.keys(resourceProperties), model?.primaryIdentifier ?? []);\n    let toHash: string;\n\n    if (identifier.length === model?.primaryIdentifier?.length) {\n      // The resource has a physical ID defined, so we can\n      // use the ID and the type as the identity of the resource.\n      toHash =\n        resource.Type +\n        identifier\n          .sort()\n          .map((attr) => JSON.stringify(resourceProperties[attr]))\n          .join('');\n    } else {\n      // The resource does not have a physical ID defined, so we need to\n      // compute the digest based on its properties and dependencies.\n      const depDigests = Array.from(graph[id]).map((d) => result[d]);\n      const propertiesHash = hashObject(stripReferences(stripConstructPath(resource)));\n      toHash = resource.Type + propertiesHash + depDigests.join('');\n    }\n\n    result[id] = crypto.createHash('sha256').update(toHash).digest('hex');\n  }\n\n  return result;\n}\n\nexport function hashObject(obj: any): string {\n  const hash = crypto.createHash('sha256');\n\n  function addToHash(value: any) {\n    if (value == null) {\n      addToHash('null');\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        value.forEach(addToHash);\n      } else {\n        Object.keys(value)\n          .sort()\n          .forEach((key) => {\n            hash.update(key);\n            addToHash(value[key]);\n          });\n      }\n    } else {\n      hash.update(typeof value + value.toString());\n    }\n  }\n\n  addToHash(obj);\n  return hash.digest('hex');\n}\n\n/**\n * Removes sub-properties containing Ref or Fn::GetAtt to avoid hashing\n * references themselves but keeps the property structure.\n */\nfunction stripReferences(value: any): any {\n  if (!value || typeof value !== 'object') return value;\n  if (Array.isArray(value)) {\n    return value.map(stripReferences);\n  }\n  if ('Ref' in value) {\n    return { __cloud_ref__: 'Ref' };\n  }\n  if ('Fn::GetAtt' in value) {\n    return { __cloud_ref__: 'Fn::GetAtt' };\n  }\n  if ('DependsOn' in value) {\n    return { __cloud_ref__: 'DependsOn' };\n  }\n  const result: any = {};\n  for (const [k, v] of Object.entries(value)) {\n    result[k] = stripReferences(v);\n  }\n  return result;\n}\n\nfunction stripConstructPath(resource: any): any {\n  if (resource?.Metadata?.['aws:cdk:path'] == null) {\n    return resource;\n  }\n\n  const copy = JSON.parse(JSON.stringify(resource));\n  delete copy.Metadata['aws:cdk:path'];\n  return copy;\n}\n\nfunction intersection<T>(a: T[], b: T[]): T[] {\n  return a.filter((value) => b.includes(value));\n}\n"]}