@aws-cdk/toolkit-lib 0.3.2 → 0.3.3

package/lib/api/plugin/plugin.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginHost = exports.TESTING = void 0;
+exports.markTesting = markTesting;
+const util_1 = require("util");
+const context_provider_plugin_1 = require("./context-provider-plugin");
+const private_1 = require("../private");
+const toolkit_error_1 = require("../toolkit-error");
+exports.TESTING = false;
+function markTesting() {
+    exports.TESTING = true;
+}
+/**
+ * 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":";;;AASA,kCAEC;AAXD,+BAA+B;AAE/B,uEAAgG;AAEhG,wCAAyD;AACzD,oDAAgD;AAErC,QAAA,OAAO,GAAG,KAAK,CAAC;AAE3B,SAAgB,WAAW;IACzB,eAAO,GAAG,IAAI,CAAC;AACjB,CAAC;AAED;;;;;;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 type { IIoHost } from '../io';\nimport { IoDefaultMessages, IoHelper } from '../private';\nimport { ToolkitError } from '../toolkit-error';\n\nexport let TESTING = false;\n\nexport function markTesting() {\n  TESTING = true;\n}\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,15 @@
+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;
+}

package/lib/api/refactoring/cloudformation.js

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

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"]}

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

@@ -0,0 +1,51 @@
+import type { TypedMapping } from '@aws-cdk/cloudformation-diff';
+import type { SdkProvider } from '../aws-auth/private';
+import type { CloudFormationStack } from './cloudformation';
+/**
+ * Represents a set of possible movements of a resource from one location
+ * to another. In the ideal case, there is only one source and only one
+ * destination.
+ */
+export type ResourceMovement = [ResourceLocation[], ResourceLocation[]];
+export declare class AmbiguityError extends Error {
+    readonly movements: ResourceMovement[];
+    constructor(movements: ResourceMovement[]);
+    paths(): [string[], string[]][];
+}
+/**
+ * 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;
+}
+export declare function resourceMovements(before: CloudFormationStack[], after: CloudFormationStack[]): ResourceMovement[];
+export declare function ambiguousMovements(movements: ResourceMovement[]): ResourceMovement[];
+/**
+ * Converts a list of unambiguous resource movements into a list of resource mappings.
+ *
+ */
+export declare function resourceMappings(movements: ResourceMovement[], stacks?: CloudFormationStack[]): ResourceMapping[];
+/**
+ * Compares the deployed state to the cloud assembly state, and finds all resources
+ * that were moved from one location (stack + logical ID) to another. The comparison
+ * is done per environment.
+ */
+export declare function findResourceMovements(stacks: CloudFormationStack[], sdkProvider: SdkProvider): Promise<ResourceMovement[]>;
+export declare function formatTypedMappings(mappings: TypedMapping[]): string;
+export declare function formatAmbiguousMappings(paths: [string[], string[]][]): string;