@aws-cdk/toolkit-lib 1.24.0 → 1.25.1

package/lib/api/orphan/orphaner.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceOrphaner = void 0;
+const private_1 = require("./private");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+/**
+ * Orphans all resources under construct path(s) from a CloudFormation stack.
+ *
+ * Usage:
+ *   const plan = await orphaner.makePlan(stack, constructPaths);
+ *   // inspect plan.orphanedResources
+ *   const result = await plan.execute();
+ */
+class ResourceOrphaner {
+    deployments;
+    ioHelper;
+    roleArn;
+    toolkitStackName;
+    constructor(props) {
+        this.deployments = props.deployments;
+        this.ioHelper = props.ioHelper;
+        this.roleArn = props.roleArn;
+        this.toolkitStackName = props.toolkitStackName;
+    }
+    /**
+     * Analyze the stack and build a plan of what will be orphaned.
+     * This is read-only — no changes are made until `plan.execute()` is called.
+     */
+    async makePlan(stack, constructPaths) {
+        const currentTemplate = await this.deployments.readCurrentTemplate(stack);
+        const resources = currentTemplate.Resources ?? {};
+        // Build a map of construct path -> logical ID from the local assembly
+        const pathToLogicalId = new Map();
+        for (const md of stack.findMetadataByType('aws:cdk:logicalId')) {
+            pathToLogicalId.set(md.path, md.data);
+        }
+        // Find logical IDs matching the given construct paths (prefix match)
+        const matched = [];
+        for (const constructPath of constructPaths) {
+            const prefix = `/${stack.hierarchicalId}/${constructPath}/`;
+            for (const [path, logicalId] of pathToLogicalId) {
+                if (path.startsWith(prefix) && resources[logicalId]) {
+                    matched.push({ logicalId, path });
+                }
+            }
+        }
+        if (matched.length === 0) {
+            throw new toolkit_error_1.ToolkitError('OrphanNoResources', `No resources found under construct path '${constructPaths.join(', ')}' in stack '${stack.stackName}'`);
+        }
+        const logicalIds = matched.map(m => m.logicalId);
+        const orphanedResources = matched.map(m => ({
+            logicalId: m.logicalId,
+            resourceType: resources[m.logicalId].Type ?? 'Unknown',
+            cdkPath: m.path,
+        }));
+        return {
+            stackName: stack.stackName,
+            orphanedResources,
+            execute: () => this.execute(stack, logicalIds, currentTemplate),
+        };
+    }
+    async execute(stack, logicalIds, currentTemplate) {
+        const env = await this.deployments.envs.accessStackForReadOnlyStackOperations(stack);
+        const cfn = env.sdk.cloudFormation();
+        // Get physical resource IDs (Ref values)
+        const stackResources = await cfn.listStackResources({ StackName: stack.stackName });
+        const physicalIds = new Map();
+        for (const res of stackResources) {
+            if (res.LogicalResourceId && res.PhysicalResourceId) {
+                physicalIds.set(res.LogicalResourceId, res.PhysicalResourceId);
+            }
+        }
+        // Step 1/3: Resolve GetAtt attribute values via temporary stack outputs
+        await this.ioHelper.defaults.info('Step 1/3: Resolving attribute values...');
+        const resolvedValues = await this.resolveGetAttValues(stack, cfn, logicalIds, currentTemplate, physicalIds);
+        // Step 2/3: Decouple — set RETAIN, replace all Ref/GetAtt with literals, remove DependsOn
+        await this.ioHelper.defaults.info('Step 2/3: Decoupling resources...');
+        const decoupledTemplate = JSON.parse(JSON.stringify(currentTemplate));
+        for (const id of logicalIds) {
+            (0, private_1.replaceReferences)(decoupledTemplate, id, resolvedValues.get(id));
+            (0, private_1.removeDependsOn)(decoupledTemplate, id);
+            decoupledTemplate.Resources[id].DeletionPolicy = 'Retain';
+            decoupledTemplate.Resources[id].UpdateReplacePolicy = 'Retain';
+        }
+        const step2Result = await this.deployStack(stack, decoupledTemplate, 'cdk-orphan-step2');
+        (0, private_1.assertDeploySucceeded)(step2Result, 'Step 2');
+        // Step 3/3: Remove orphaned resources from the template
+        await this.ioHelper.defaults.info('Step 3/3: Removing resources from stack...');
+        const removalTemplate = JSON.parse(JSON.stringify(decoupledTemplate));
+        for (const id of logicalIds) {
+            delete removalTemplate.Resources[id];
+        }
+        (0, private_1.ensureNonEmptyResources)(removalTemplate);
+        const step3Result = await this.deployStack(stack, removalTemplate, 'cdk-orphan-step3');
+        (0, private_1.assertDeploySucceeded)(step3Result, 'Step 3');
+        if (step3Result.noOp) {
+            throw new toolkit_error_1.ToolkitError('OrphanNoOp', 'Orphan step 3 was unexpectedly a no-op — the resources were not removed from the stack. ' +
+                'If this issue persists, please open an issue at https://github.com/aws/aws-cdk-cli/issues ' +
+                'with your stack template attached.');
+        }
+        const resourceMapping = await this.getResourceIdentifiers(stack, logicalIds, physicalIds, currentTemplate);
+        return { resourceMapping };
+    }
+    /**
+     * Deploy a template override to the stack.
+     */
+    async deployStack(stack, template, changeSetName) {
+        return this.deployments.deployStack({
+            stack,
+            roleArn: this.roleArn,
+            toolkitStackName: this.toolkitStackName,
+            deploymentMethod: { method: 'change-set', changeSetName },
+            overrideTemplate: template,
+            usePreviousParameters: true,
+            forceDeployment: true,
+        });
+    }
+    /**
+     * Resolve GetAtt attribute values for orphaned resources.
+     *
+     * Current strategy: inject temporary Outputs into the stack that reference
+     * each GetAtt, deploy, then read the resolved values from DescribeStacks.
+     *
+     * This function is intentionally decoupled from the rest of the orphan flow
+     * so it can be replaced with a Cloud Control API-based approach later.
+     *
+     * Returns a complete map of resolved values (Ref + attrs) for each logical ID.
+     */
+    async resolveGetAttValues(stack, cfn, logicalIds, currentTemplate, physicalIds) {
+        // Build Ref values from physical IDs
+        const values = new Map();
+        for (const id of logicalIds) {
+            const physicalId = physicalIds.get(id);
+            if (!physicalId) {
+                throw new toolkit_error_1.ToolkitError('OrphanMissingPhysicalId', `Could not resolve physical resource ID for '${id}'`);
+            }
+            values.set(id, { ref: physicalId, attrs: {} });
+        }
+        const getAttRefs = this.findGetAttReferences(currentTemplate, logicalIds);
+        // If there are no GetAtt references, skip the deploy
+        if (getAttRefs.size === 0) {
+            return values;
+        }
+        // Inject temporary outputs so CloudFormation resolves the GetAtt values
+        const resolveTemplate = JSON.parse(JSON.stringify(currentTemplate));
+        if (!resolveTemplate.Outputs) {
+            resolveTemplate.Outputs = {};
+        }
+        for (const [outputKey, ref] of getAttRefs) {
+            resolveTemplate.Outputs[outputKey] = {
+                Value: { 'Fn::GetAtt': [ref.logicalId, ref.attr] },
+            };
+        }
+        const step1Result = await this.deployStack(stack, resolveTemplate, 'cdk-orphan-step1');
+        (0, private_1.assertDeploySucceeded)(step1Result, 'Step 1');
+        // Read resolved values from stack outputs
+        const stackDesc = await cfn.describeStacks({ StackName: stack.stackName });
+        for (const output of stackDesc.Stacks?.[0]?.Outputs ?? []) {
+            if (!output.OutputKey || !output.OutputValue)
+                continue;
+            const ref = getAttRefs.get(output.OutputKey);
+            if (ref) {
+                values.get(ref.logicalId).attrs[ref.attr] = output.OutputValue;
+            }
+        }
+        return values;
+    }
+    findGetAttReferences(template, logicalIds) {
+        const refs = new Map();
+        const addRef = (id, attr) => {
+            const outputKey = `CdkOrphan${id}${attr}`.replace(/[^a-zA-Z0-9]/g, '');
+            if (!refs.has(outputKey)) {
+                refs.set(outputKey, { logicalId: id, attr });
+            }
+        };
+        const scanSubString = (str) => {
+            // Match ${LogicalId.Attr} patterns in Fn::Sub format strings
+            const pattern = /\$\{([^}.]+)\.([^}]+)\}/g;
+            let match;
+            while ((match = pattern.exec(str)) !== null) {
+                const [, id, attr] = match;
+                if (logicalIds.includes(id)) {
+                    addRef(id, attr);
+                }
+            }
+        };
+        (0, private_1.walkObject)(template, (value) => {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                // Explicit Fn::GetAtt
+                const getAtt = value['Fn::GetAtt'];
+                if (Array.isArray(getAtt) && logicalIds.includes(getAtt[0])) {
+                    addRef(getAtt[0], getAtt[1]);
+                }
+                // Implicit GetAtt inside Fn::Sub
+                const sub = value['Fn::Sub'];
+                if (typeof sub === 'string') {
+                    scanSubString(sub);
+                }
+                else if (Array.isArray(sub) && typeof sub[0] === 'string') {
+                    scanSubString(sub[0]);
+                }
+            }
+        });
+        return refs;
+    }
+    async getResourceIdentifiers(stack, logicalIds, physicalIds, template) {
+        const result = {};
+        try {
+            const summaries = await this.deployments.resourceIdentifierSummaries(stack);
+            const identifiersByType = new Map();
+            for (const summary of summaries) {
+                if (summary.ResourceType && summary.ResourceIdentifiers) {
+                    identifiersByType.set(summary.ResourceType, summary.ResourceIdentifiers);
+                }
+            }
+            const resources = template.Resources ?? {};
+            for (const id of logicalIds) {
+                const resource = resources[id];
+                if (!resource)
+                    continue;
+                const identifierProps = identifiersByType.get(resource.Type);
+                if (!identifierProps || identifierProps.length === 0)
+                    continue;
+                const identifier = {};
+                const props = resource.Properties ?? {};
+                for (const prop of identifierProps) {
+                    if (props[prop] && typeof props[prop] === 'string') {
+                        identifier[prop] = props[prop];
+                    }
+                    else if (identifierProps.length === 1 && physicalIds.has(id)) {
+                        identifier[prop] = physicalIds.get(id);
+                    }
+                }
+                if (Object.keys(identifier).length > 0) {
+                    result[id] = identifier;
+                }
+            }
+        }
+        catch (e) {
+            await this.ioHelper.defaults.warn(`Could not retrieve resource identifiers for import: ${e.message}`);
+        }
+        return result;
+    }
+}
+exports.ResourceOrphaner = ResourceOrphaner;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orphaner.js","sourceRoot":"","sources":["orphaner.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cloud-assembly-api';\nimport {\n  replaceReferences,\n  removeDependsOn,\n  walkObject,\n  assertDeploySucceeded,\n  ensureNonEmptyResources,\n} from './private';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport type { ICloudFormationClient } from '../aws-auth/sdk';\nimport type { Deployments } from '../deployments';\nimport type { IoHelper } from '../io/private';\n\ninterface ResolvedValues {\n  ref: string;\n  attrs: Record<string, string>;\n}\n\nexport interface ResourceOrphanerProps {\n  readonly deployments: Deployments;\n  readonly ioHelper: IoHelper;\n  readonly roleArn?: string;\n  readonly toolkitStackName?: string;\n}\n\n/**\n * A resource that will be orphaned.\n */\nexport interface OrphanedResource {\n  readonly logicalId: string;\n  readonly resourceType: string;\n  readonly cdkPath: string;\n}\n\n/**\n * The result of planning an orphan operation.\n */\nexport interface OrphanPlan {\n  /** The stack being modified */\n  readonly stackName: string;\n  /** Resources that will be detached from the stack */\n  readonly orphanedResources: OrphanedResource[];\n  /** Execute the orphan operation (3 CloudFormation deployments) */\n  execute(): Promise<OrphanResult>;\n}\n\n/**\n * The result of executing an orphan operation.\n */\nexport interface OrphanResult {\n  /** Resource mapping JSON for use with `cdk import --resource-mapping` */\n  readonly resourceMapping: Record<string, Record<string, string>>;\n}\n\n/**\n * Orphans all resources under construct path(s) from a CloudFormation stack.\n *\n * Usage:\n *   const plan = await orphaner.makePlan(stack, constructPaths);\n *   // inspect plan.orphanedResources\n *   const result = await plan.execute();\n */\nexport class ResourceOrphaner {\n  private readonly deployments: Deployments;\n  private readonly ioHelper: IoHelper;\n  private readonly roleArn?: string;\n  private readonly toolkitStackName?: string;\n\n  constructor(props: ResourceOrphanerProps) {\n    this.deployments = props.deployments;\n    this.ioHelper = props.ioHelper;\n    this.roleArn = props.roleArn;\n    this.toolkitStackName = props.toolkitStackName;\n  }\n\n  /**\n   * Analyze the stack and build a plan of what will be orphaned.\n   * This is read-only — no changes are made until `plan.execute()` is called.\n   */\n  public async makePlan(stack: cxapi.CloudFormationStackArtifact, constructPaths: string[]): Promise<OrphanPlan> {\n    const currentTemplate = await this.deployments.readCurrentTemplate(stack);\n    const resources = currentTemplate.Resources ?? {};\n\n    // Build a map of construct path -> logical ID from the local assembly\n    const pathToLogicalId = new Map<string, string>();\n    for (const md of stack.findMetadataByType('aws:cdk:logicalId' as any)) {\n      pathToLogicalId.set(md.path, md.data as string);\n    }\n\n    // Find logical IDs matching the given construct paths (prefix match)\n    const matched: { logicalId: string; path: string }[] = [];\n    for (const constructPath of constructPaths) {\n      const prefix = `/${stack.hierarchicalId}/${constructPath}/`;\n      for (const [path, logicalId] of pathToLogicalId) {\n        if (path.startsWith(prefix) && resources[logicalId]) {\n          matched.push({ logicalId, path });\n        }\n      }\n    }\n\n    if (matched.length === 0) {\n      throw new ToolkitError('OrphanNoResources', `No resources found under construct path '${constructPaths.join(', ')}' in stack '${stack.stackName}'`);\n    }\n\n    const logicalIds = matched.map(m => m.logicalId);\n    const orphanedResources: OrphanedResource[] = matched.map(m => ({\n      logicalId: m.logicalId,\n      resourceType: resources[m.logicalId].Type ?? 'Unknown',\n      cdkPath: m.path,\n    }));\n\n    return {\n      stackName: stack.stackName,\n      orphanedResources,\n      execute: () => this.execute(stack, logicalIds, currentTemplate),\n    };\n  }\n\n  private async execute(\n    stack: cxapi.CloudFormationStackArtifact,\n    logicalIds: string[],\n    currentTemplate: any,\n  ): Promise<OrphanResult> {\n    const env = await this.deployments.envs.accessStackForReadOnlyStackOperations(stack);\n    const cfn = env.sdk.cloudFormation();\n\n    // Get physical resource IDs (Ref values)\n    const stackResources = await cfn.listStackResources({ StackName: stack.stackName });\n    const physicalIds = new Map<string, string>();\n    for (const res of stackResources) {\n      if (res.LogicalResourceId && res.PhysicalResourceId) {\n        physicalIds.set(res.LogicalResourceId, res.PhysicalResourceId);\n      }\n    }\n\n    // Step 1/3: Resolve GetAtt attribute values via temporary stack outputs\n    await this.ioHelper.defaults.info('Step 1/3: Resolving attribute values...');\n    const resolvedValues = await this.resolveGetAttValues(stack, cfn, logicalIds, currentTemplate, physicalIds);\n\n    // Step 2/3: Decouple — set RETAIN, replace all Ref/GetAtt with literals, remove DependsOn\n    await this.ioHelper.defaults.info('Step 2/3: Decoupling resources...');\n    const decoupledTemplate = JSON.parse(JSON.stringify(currentTemplate));\n    for (const id of logicalIds) {\n      replaceReferences(decoupledTemplate, id, resolvedValues.get(id)!);\n      removeDependsOn(decoupledTemplate, id);\n      decoupledTemplate.Resources[id].DeletionPolicy = 'Retain';\n      decoupledTemplate.Resources[id].UpdateReplacePolicy = 'Retain';\n    }\n    const step2Result = await this.deployStack(stack, decoupledTemplate, 'cdk-orphan-step2');\n    assertDeploySucceeded(step2Result, 'Step 2');\n\n    // Step 3/3: Remove orphaned resources from the template\n    await this.ioHelper.defaults.info('Step 3/3: Removing resources from stack...');\n    const removalTemplate = JSON.parse(JSON.stringify(decoupledTemplate));\n    for (const id of logicalIds) {\n      delete removalTemplate.Resources[id];\n    }\n    ensureNonEmptyResources(removalTemplate);\n    const step3Result = await this.deployStack(stack, removalTemplate, 'cdk-orphan-step3');\n    assertDeploySucceeded(step3Result, 'Step 3');\n    if (step3Result.noOp) {\n      throw new ToolkitError(\n        'OrphanNoOp',\n        'Orphan step 3 was unexpectedly a no-op — the resources were not removed from the stack. ' +\n        'If this issue persists, please open an issue at https://github.com/aws/aws-cdk-cli/issues ' +\n        'with your stack template attached.',\n      );\n    }\n\n    const resourceMapping = await this.getResourceIdentifiers(stack, logicalIds, physicalIds, currentTemplate);\n    return { resourceMapping };\n  }\n\n  /**\n   * Deploy a template override to the stack.\n   */\n  private async deployStack(stack: cxapi.CloudFormationStackArtifact, template: any, changeSetName: string) {\n    return this.deployments.deployStack({\n      stack,\n      roleArn: this.roleArn,\n      toolkitStackName: this.toolkitStackName,\n      deploymentMethod: { method: 'change-set', changeSetName },\n      overrideTemplate: template,\n      usePreviousParameters: true,\n      forceDeployment: true,\n    });\n  }\n\n  /**\n   * Resolve GetAtt attribute values for orphaned resources.\n   *\n   * Current strategy: inject temporary Outputs into the stack that reference\n   * each GetAtt, deploy, then read the resolved values from DescribeStacks.\n   *\n   * This function is intentionally decoupled from the rest of the orphan flow\n   * so it can be replaced with a Cloud Control API-based approach later.\n   *\n   * Returns a complete map of resolved values (Ref + attrs) for each logical ID.\n   */\n  private async resolveGetAttValues(\n    stack: cxapi.CloudFormationStackArtifact,\n    cfn: ICloudFormationClient,\n    logicalIds: string[],\n    currentTemplate: any,\n    physicalIds: Map<string, string>,\n  ): Promise<Map<string, ResolvedValues>> {\n    // Build Ref values from physical IDs\n    const values = new Map<string, ResolvedValues>();\n    for (const id of logicalIds) {\n      const physicalId = physicalIds.get(id);\n      if (!physicalId) {\n        throw new ToolkitError('OrphanMissingPhysicalId', `Could not resolve physical resource ID for '${id}'`);\n      }\n      values.set(id, { ref: physicalId, attrs: {} });\n    }\n\n    const getAttRefs = this.findGetAttReferences(currentTemplate, logicalIds);\n\n    // If there are no GetAtt references, skip the deploy\n    if (getAttRefs.size === 0) {\n      return values;\n    }\n\n    // Inject temporary outputs so CloudFormation resolves the GetAtt values\n    const resolveTemplate = JSON.parse(JSON.stringify(currentTemplate));\n    if (!resolveTemplate.Outputs) {\n      resolveTemplate.Outputs = {};\n    }\n    for (const [outputKey, ref] of getAttRefs) {\n      resolveTemplate.Outputs[outputKey] = {\n        Value: { 'Fn::GetAtt': [ref.logicalId, ref.attr] },\n      };\n    }\n\n    const step1Result = await this.deployStack(stack, resolveTemplate, 'cdk-orphan-step1');\n    assertDeploySucceeded(step1Result, 'Step 1');\n\n    // Read resolved values from stack outputs\n    const stackDesc = await cfn.describeStacks({ StackName: stack.stackName });\n    for (const output of stackDesc.Stacks?.[0]?.Outputs ?? []) {\n      if (!output.OutputKey || !output.OutputValue) continue;\n      const ref = getAttRefs.get(output.OutputKey);\n      if (ref) {\n        values.get(ref.logicalId)!.attrs[ref.attr] = output.OutputValue;\n      }\n    }\n\n    return values;\n  }\n\n  private findGetAttReferences(template: any, logicalIds: string[]): Map<string, { logicalId: string; attr: string }> {\n    const refs = new Map<string, { logicalId: string; attr: string }>();\n\n    const addRef = (id: string, attr: string) => {\n      const outputKey = `CdkOrphan${id}${attr}`.replace(/[^a-zA-Z0-9]/g, '');\n      if (!refs.has(outputKey)) {\n        refs.set(outputKey, { logicalId: id, attr });\n      }\n    };\n\n    const scanSubString = (str: string) => {\n      // Match ${LogicalId.Attr} patterns in Fn::Sub format strings\n      const pattern = /\\$\\{([^}.]+)\\.([^}]+)\\}/g;\n      let match;\n      while ((match = pattern.exec(str)) !== null) {\n        const [, id, attr] = match;\n        if (logicalIds.includes(id)) {\n          addRef(id, attr);\n        }\n      }\n    };\n\n    walkObject(template, (value) => {\n      if (value && typeof value === 'object' && !Array.isArray(value)) {\n        // Explicit Fn::GetAtt\n        const getAtt = value['Fn::GetAtt'];\n        if (Array.isArray(getAtt) && logicalIds.includes(getAtt[0])) {\n          addRef(getAtt[0], getAtt[1]);\n        }\n\n        // Implicit GetAtt inside Fn::Sub\n        const sub = value['Fn::Sub'];\n        if (typeof sub === 'string') {\n          scanSubString(sub);\n        } else if (Array.isArray(sub) && typeof sub[0] === 'string') {\n          scanSubString(sub[0]);\n        }\n      }\n    });\n\n    return refs;\n  }\n\n  private async getResourceIdentifiers(\n    stack: cxapi.CloudFormationStackArtifact,\n    logicalIds: string[],\n    physicalIds: Map<string, string>,\n    template: any,\n  ): Promise<Record<string, Record<string, string>>> {\n    const result: Record<string, Record<string, string>> = {};\n\n    try {\n      const summaries = await this.deployments.resourceIdentifierSummaries(stack);\n\n      const identifiersByType = new Map<string, string[]>();\n      for (const summary of summaries) {\n        if (summary.ResourceType && summary.ResourceIdentifiers) {\n          identifiersByType.set(summary.ResourceType, summary.ResourceIdentifiers);\n        }\n      }\n\n      const resources = template.Resources ?? {};\n\n      for (const id of logicalIds) {\n        const resource = resources[id];\n        if (!resource) continue;\n\n        const identifierProps = identifiersByType.get(resource.Type);\n        if (!identifierProps || identifierProps.length === 0) continue;\n\n        const identifier: Record<string, string> = {};\n        const props = resource.Properties ?? {};\n\n        for (const prop of identifierProps) {\n          if (props[prop] && typeof props[prop] === 'string') {\n            identifier[prop] = props[prop];\n          } else if (identifierProps.length === 1 && physicalIds.has(id)) {\n            identifier[prop] = physicalIds.get(id)!;\n          }\n        }\n\n        if (Object.keys(identifier).length > 0) {\n          result[id] = identifier;\n        }\n      }\n    } catch (e) {\n      await this.ioHelper.defaults.warn(`Could not retrieve resource identifiers for import: ${(e as Error).message}`);\n    }\n\n    return result;\n  }\n}\n"]}

package/lib/api/orphan/private/helpers.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Walk an object tree depth-first, calling visitor on every node.
+ */
+export declare function walkObject(obj: any, visitor: (value: any) => void): void;
+/**
+ * Replace all {Ref}, {Fn::GetAtt}, and {Fn::Sub} references to a logical ID with literal values.
+ */
+export declare function replaceInObject(obj: any, logicalId: string, values: {
+    ref: string;
+    attrs: Record<string, string>;
+}): any;
+/**
+ * Replace all references to a logical ID across Resources, Outputs, and Conditions.
+ */
+export declare function replaceReferences(template: any, logicalId: string, values: {
+    ref: string;
+    attrs: Record<string, string>;
+}): void;
+/**
+ * Remove all DependsOn references to a logical ID from the template.
+ */
+export declare function removeDependsOn(template: any, logicalId: string): void;
+/**
+ * Find all resources whose aws:cdk:path starts with `<stackName>/<constructPath>/`.
+ */
+export declare function findResourcesByPath(resources: Record<string, any>, stackName: string, constructPath: string): string[];
+/**
+ * Find resources in the remaining template that still reference any of the orphaned logical IDs.
+ */
+export declare function findBlockingResources(remainingTemplate: any, orphanedIds: string[], fullTemplate: any): string[];
+/**
+ * Check if any resources in the template have aws:cdk:path metadata at all.
+ * Used to detect if metadata has been disabled.
+ */
+export declare function hasAnyCdkPathMetadata(resources: Record<string, any>): boolean;
+import type { DeployStackResult, SuccessfulDeployStackResult } from '../../deployments/deployment-result';
+/**
+ * Verify a deploy result completed successfully.
+ */
+export declare function assertDeploySucceeded(result: DeployStackResult, step: string): asserts result is SuccessfulDeployStackResult;
+/**
+ * CloudFormation requires at least one resource in the template.
+ * Add a placeholder if all resources were removed.
+ */
+export declare function ensureNonEmptyResources(template: any): void;
+/**
+ * Parse construct paths like `/MyStack/MyTable` or `MyStack/MyTable` into
+ * a stack construct ID and construct-level paths.
+ *
+ * All paths must reference the same stack.
+ */
+export declare function parseAndValidateConstructPaths(paths: string[]): {
+    stackId: string;
+    constructPaths: string[];
+};
+//# sourceMappingURL=helpers.d.ts.map

package/lib/api/orphan/private/helpers.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkObject = walkObject;
+exports.replaceInObject = replaceInObject;
+exports.replaceReferences = replaceReferences;
+exports.removeDependsOn = removeDependsOn;
+exports.findResourcesByPath = findResourcesByPath;
+exports.findBlockingResources = findBlockingResources;
+exports.hasAnyCdkPathMetadata = hasAnyCdkPathMetadata;
+exports.assertDeploySucceeded = assertDeploySucceeded;
+exports.ensureNonEmptyResources = ensureNonEmptyResources;
+exports.parseAndValidateConstructPaths = parseAndValidateConstructPaths;
+const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api");
+/**
+ * Walk an object tree depth-first, calling visitor on every node.
+ */
+function walkObject(obj, visitor) {
+    if (obj === null || obj === undefined)
+        return;
+    visitor(obj);
+    if (typeof obj === 'object') {
+        for (const value of Object.values(obj)) {
+            walkObject(value, visitor);
+        }
+    }
+}
+/**
+ * Replace all {Ref}, {Fn::GetAtt}, and {Fn::Sub} references to a logical ID with literal values.
+ */
+function replaceInObject(obj, logicalId, values) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map((item) => replaceInObject(item, logicalId, values));
+    }
+    if (Object.keys(obj).length === 1 && obj.Ref === logicalId) {
+        return values.ref;
+    }
+    if (Object.keys(obj).length === 1 && Array.isArray(obj['Fn::GetAtt']) && obj['Fn::GetAtt'][0] === logicalId) {
+        const attr = obj['Fn::GetAtt'][1];
+        if (values.attrs[attr]) {
+            return values.attrs[attr];
+        }
+    }
+    // Handle Fn::Sub implicit references: ${LogicalId} and ${LogicalId.Attr}
+    if (obj['Fn::Sub'] !== undefined) {
+        const sub = obj['Fn::Sub'];
+        const replaceSubString = (str) => {
+            // Replace ${LogicalId.Attr} with the resolved attribute value
+            for (const [attr, val] of Object.entries(values.attrs)) {
+                str = str.replace(new RegExp(`\\$\\{${logicalId}\\.${attr}\\}`, 'g'), val);
+            }
+            // Replace ${LogicalId} with the resolved Ref value
+            str = str.replace(new RegExp(`\\$\\{${logicalId}\\}`, 'g'), values.ref);
+            return str;
+        };
+        if (typeof sub === 'string') {
+            return { 'Fn::Sub': replaceSubString(sub) };
+        }
+        if (Array.isArray(sub) && typeof sub[0] === 'string') {
+            return {
+                'Fn::Sub': [
+                    replaceSubString(sub[0]),
+                    sub[1] ? replaceInObject(sub[1], logicalId, values) : sub[1],
+                ],
+            };
+        }
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[key] = replaceInObject(value, logicalId, values);
+    }
+    return result;
+}
+/**
+ * Replace all references to a logical ID across Resources, Outputs, and Conditions.
+ */
+function replaceReferences(template, logicalId, values) {
+    for (const section of ['Resources', 'Outputs', 'Conditions']) {
+        if (!template[section])
+            continue;
+        for (const [key, value] of Object.entries(template[section])) {
+            if (section === 'Resources' && key === logicalId)
+                continue;
+            template[section][key] = replaceInObject(value, logicalId, values);
+        }
+    }
+}
+/**
+ * Remove all DependsOn references to a logical ID from the template.
+ */
+function removeDependsOn(template, logicalId) {
+    for (const resource of Object.values(template.Resources ?? {})) {
+        const res = resource;
+        if (Array.isArray(res.DependsOn)) {
+            res.DependsOn = res.DependsOn.filter((dep) => dep !== logicalId);
+            if (res.DependsOn.length === 0)
+                delete res.DependsOn;
+        }
+        else if (res.DependsOn === logicalId) {
+            delete res.DependsOn;
+        }
+    }
+}
+/**
+ * Find all resources whose aws:cdk:path starts with `<stackName>/<constructPath>/`.
+ */
+function findResourcesByPath(resources, stackName, constructPath) {
+    const prefix = `${stackName}/${constructPath}/`;
+    const ids = [];
+    for (const [id, resource] of Object.entries(resources)) {
+        const cdkPath = resource.Metadata?.[cloud_assembly_api_1.PATH_METADATA_KEY] ?? '';
+        if (cdkPath.startsWith(prefix)) {
+            ids.push(id);
+        }
+    }
+    return ids;
+}
+/**
+ * Find resources in the remaining template that still reference any of the orphaned logical IDs.
+ */
+function findBlockingResources(remainingTemplate, orphanedIds, fullTemplate) {
+    const blockers = [];
+    const remaining = remainingTemplate.Resources ?? {};
+    const full = fullTemplate.Resources ?? {};
+    for (const [id, resource] of Object.entries(full)) {
+        if (orphanedIds.includes(id))
+            continue;
+        if (!remaining[id])
+            continue;
+        let references = false;
+        walkObject(resource, (value) => {
+            if (references)
+                return;
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                if (value.Ref && orphanedIds.includes(value.Ref))
+                    references = true;
+                const getAtt = value['Fn::GetAtt'];
+                if (Array.isArray(getAtt) && orphanedIds.includes(getAtt[0]))
+                    references = true;
+            }
+        });
+        const deps = resource.DependsOn;
+        if (typeof deps === 'string' && orphanedIds.includes(deps))
+            references = true;
+        if (Array.isArray(deps) && deps.some((d) => orphanedIds.includes(d)))
+            references = true;
+        if (references) {
+            const path = resource.Metadata?.[cloud_assembly_api_1.PATH_METADATA_KEY] ?? id;
+            blockers.push(path);
+        }
+    }
+    return blockers;
+}
+/**
+ * Check if any resources in the template have aws:cdk:path metadata at all.
+ * Used to detect if metadata has been disabled.
+ */
+function hasAnyCdkPathMetadata(resources) {
+    for (const resource of Object.values(resources)) {
+        if (resource.Metadata?.[cloud_assembly_api_1.PATH_METADATA_KEY]) {
+            return true;
+        }
+    }
+    return false;
+}
+const toolkit_error_1 = require("../../../toolkit/toolkit-error");
+/**
+ * Verify a deploy result completed successfully.
+ */
+function assertDeploySucceeded(result, step) {
+    if (result.type !== 'did-deploy-stack') {
+        throw new toolkit_error_1.ToolkitError('OrphanDeployFailed', `${step}: unexpected deployment result '${result.type}'`);
+    }
+}
+/**
+ * CloudFormation requires at least one resource in the template.
+ * Add a placeholder if all resources were removed.
+ */
+function ensureNonEmptyResources(template) {
+    if (Object.keys(template.Resources ?? {}).length === 0) {
+        template.Resources = {
+            CDKOrphanPlaceholder: {
+                Type: 'AWS::CloudFormation::WaitConditionHandle',
+            },
+        };
+    }
+}
+/**
+ * Parse construct paths like `/MyStack/MyTable` or `MyStack/MyTable` into
+ * a stack construct ID and construct-level paths.
+ *
+ * All paths must reference the same stack.
+ */
+function parseAndValidateConstructPaths(paths) {
+    if (paths.length === 0) {
+        throw new toolkit_error_1.ToolkitError('MissingConstructPath', 'At least one construct path is required (e.g. cdk orphan MyStack/MyTable)');
+    }
+    const constructPaths = [];
+    let stackId;
+    for (const raw of paths) {
+        const p = raw.replace(/^\//, ''); // strip leading slash
+        const slashIdx = p.indexOf('/');
+        if (slashIdx < 0) {
+            throw new toolkit_error_1.ToolkitError('InvalidConstructPath', `Construct path '${raw}' must include both a stack name and a construct path separated by '/' (e.g. MyStack/MyTable)`);
+        }
+        const thisStack = p.substring(0, slashIdx);
+        const constructPath = p.substring(slashIdx + 1);
+        if (stackId && thisStack !== stackId) {
+            throw new toolkit_error_1.ToolkitError('MultipleStacks', `All construct paths must reference the same stack, but got '${stackId}' and '${thisStack}'`);
+        }
+        stackId = thisStack;
+        constructPaths.push(constructPath);
+    }
+    return { stackId: stackId, constructPaths };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { PATH_METADATA_KEY } from '@aws-cdk/cloud-assembly-api';\n\n/**\n * Walk an object tree depth-first, calling visitor on every node.\n */\nexport function walkObject(obj: any, visitor: (value: any) => void): void {\n  if (obj === null || obj === undefined) return;\n  visitor(obj);\n  if (typeof obj === 'object') {\n    for (const value of Object.values(obj)) {\n      walkObject(value, visitor);\n    }\n  }\n}\n\n/**\n * Replace all {Ref}, {Fn::GetAtt}, and {Fn::Sub} references to a logical ID with literal values.\n */\nexport function replaceInObject(obj: any, logicalId: string, values: { ref: string; attrs: Record<string, string> }): any {\n  if (obj === null || obj === undefined) return obj;\n  if (typeof obj !== 'object') return obj;\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => replaceInObject(item, logicalId, values));\n  }\n\n  if (Object.keys(obj).length === 1 && obj.Ref === logicalId) {\n    return values.ref;\n  }\n\n  if (Object.keys(obj).length === 1 && Array.isArray(obj['Fn::GetAtt']) && obj['Fn::GetAtt'][0] === logicalId) {\n    const attr = obj['Fn::GetAtt'][1];\n    if (values.attrs[attr]) {\n      return values.attrs[attr];\n    }\n  }\n\n  // Handle Fn::Sub implicit references: ${LogicalId} and ${LogicalId.Attr}\n  if (obj['Fn::Sub'] !== undefined) {\n    const sub = obj['Fn::Sub'];\n    const replaceSubString = (str: string): string => {\n      // Replace ${LogicalId.Attr} with the resolved attribute value\n      for (const [attr, val] of Object.entries(values.attrs)) {\n        str = str.replace(new RegExp(`\\\\$\\\\{${logicalId}\\\\.${attr}\\\\}`, 'g'), val);\n      }\n      // Replace ${LogicalId} with the resolved Ref value\n      str = str.replace(new RegExp(`\\\\$\\\\{${logicalId}\\\\}`, 'g'), values.ref);\n      return str;\n    };\n\n    if (typeof sub === 'string') {\n      return { 'Fn::Sub': replaceSubString(sub) };\n    }\n    if (Array.isArray(sub) && typeof sub[0] === 'string') {\n      return {\n        'Fn::Sub': [\n          replaceSubString(sub[0]),\n          sub[1] ? replaceInObject(sub[1], logicalId, values) : sub[1],\n        ],\n      };\n    }\n  }\n\n  const result: any = {};\n  for (const [key, value] of Object.entries(obj)) {\n    result[key] = replaceInObject(value, logicalId, values);\n  }\n  return result;\n}\n\n/**\n * Replace all references to a logical ID across Resources, Outputs, and Conditions.\n */\nexport function replaceReferences(\n  template: any,\n  logicalId: string,\n  values: { ref: string; attrs: Record<string, string> },\n): void {\n  for (const section of ['Resources', 'Outputs', 'Conditions']) {\n    if (!template[section]) continue;\n    for (const [key, value] of Object.entries(template[section])) {\n      if (section === 'Resources' && key === logicalId) continue;\n      template[section][key] = replaceInObject(value, logicalId, values);\n    }\n  }\n}\n\n/**\n * Remove all DependsOn references to a logical ID from the template.\n */\nexport function removeDependsOn(template: any, logicalId: string): void {\n  for (const resource of Object.values(template.Resources ?? {})) {\n    const res = resource as any;\n    if (Array.isArray(res.DependsOn)) {\n      res.DependsOn = res.DependsOn.filter((dep: string) => dep !== logicalId);\n      if (res.DependsOn.length === 0) delete res.DependsOn;\n    } else if (res.DependsOn === logicalId) {\n      delete res.DependsOn;\n    }\n  }\n}\n\n/**\n * Find all resources whose aws:cdk:path starts with `<stackName>/<constructPath>/`.\n */\nexport function findResourcesByPath(resources: Record<string, any>, stackName: string, constructPath: string): string[] {\n  const prefix = `${stackName}/${constructPath}/`;\n  const ids: string[] = [];\n  for (const [id, resource] of Object.entries(resources)) {\n    const cdkPath = resource.Metadata?.[PATH_METADATA_KEY] ?? '';\n    if (cdkPath.startsWith(prefix)) {\n      ids.push(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Find resources in the remaining template that still reference any of the orphaned logical IDs.\n */\nexport function findBlockingResources(remainingTemplate: any, orphanedIds: string[], fullTemplate: any): string[] {\n  const blockers: string[] = [];\n  const remaining = remainingTemplate.Resources ?? {};\n  const full = fullTemplate.Resources ?? {};\n\n  for (const [id, resource] of Object.entries(full) as [string, any][]) {\n    if (orphanedIds.includes(id)) continue;\n    if (!remaining[id]) continue;\n\n    let references = false;\n    walkObject(resource, (value) => {\n      if (references) return;\n      if (value && typeof value === 'object' && !Array.isArray(value)) {\n        if (value.Ref && orphanedIds.includes(value.Ref)) references = true;\n        const getAtt = value['Fn::GetAtt'];\n        if (Array.isArray(getAtt) && orphanedIds.includes(getAtt[0])) references = true;\n      }\n    });\n\n    const deps = resource.DependsOn;\n    if (typeof deps === 'string' && orphanedIds.includes(deps)) references = true;\n    if (Array.isArray(deps) && deps.some((d: string) => orphanedIds.includes(d))) references = true;\n\n    if (references) {\n      const path = (resource as any).Metadata?.[PATH_METADATA_KEY] ?? id;\n      blockers.push(path);\n    }\n  }\n\n  return blockers;\n}\n\n/**\n * Check if any resources in the template have aws:cdk:path metadata at all.\n * Used to detect if metadata has been disabled.\n */\nexport function hasAnyCdkPathMetadata(resources: Record<string, any>): boolean {\n  for (const resource of Object.values(resources)) {\n    if ((resource as any).Metadata?.[PATH_METADATA_KEY]) {\n      return true;\n    }\n  }\n  return false;\n}\n\nimport { ToolkitError } from '../../../toolkit/toolkit-error';\nimport type { DeployStackResult, SuccessfulDeployStackResult } from '../../deployments/deployment-result';\n\n/**\n * Verify a deploy result completed successfully.\n */\nexport function assertDeploySucceeded(result: DeployStackResult, step: string): asserts result is SuccessfulDeployStackResult {\n  if (result.type !== 'did-deploy-stack') {\n    throw new ToolkitError('OrphanDeployFailed', `${step}: unexpected deployment result '${result.type}'`);\n  }\n}\n\n/**\n * CloudFormation requires at least one resource in the template.\n * Add a placeholder if all resources were removed.\n */\nexport function ensureNonEmptyResources(template: any): void {\n  if (Object.keys(template.Resources ?? {}).length === 0) {\n    template.Resources = {\n      CDKOrphanPlaceholder: {\n        Type: 'AWS::CloudFormation::WaitConditionHandle',\n      },\n    };\n  }\n}\n\n/**\n * Parse construct paths like `/MyStack/MyTable` or `MyStack/MyTable` into\n * a stack construct ID and construct-level paths.\n *\n * All paths must reference the same stack.\n */\nexport function parseAndValidateConstructPaths(paths: string[]): { stackId: string; constructPaths: string[] } {\n  if (paths.length === 0) {\n    throw new ToolkitError('MissingConstructPath', 'At least one construct path is required (e.g. cdk orphan MyStack/MyTable)');\n  }\n\n  const constructPaths: string[] = [];\n  let stackId: string | undefined;\n\n  for (const raw of paths) {\n    const p = raw.replace(/^\\//, ''); // strip leading slash\n    const slashIdx = p.indexOf('/');\n    if (slashIdx < 0) {\n      throw new ToolkitError('InvalidConstructPath', `Construct path '${raw}' must include both a stack name and a construct path separated by '/' (e.g. MyStack/MyTable)`);\n    }\n\n    const thisStack = p.substring(0, slashIdx);\n    const constructPath = p.substring(slashIdx + 1);\n\n    if (stackId && thisStack !== stackId) {\n      throw new ToolkitError('MultipleStacks', `All construct paths must reference the same stack, but got '${stackId}' and '${thisStack}'`);\n    }\n    stackId = thisStack;\n    constructPaths.push(constructPath);\n  }\n\n  return { stackId: stackId!, constructPaths };\n}\n"]}

package/lib/api/orphan/private/index.d.ts

@@ -0,0 +1,2 @@
+export * from './helpers';
+//# sourceMappingURL=index.d.ts.map

package/lib/api/orphan/private/index.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("./helpers"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNENBQTBCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9oZWxwZXJzJztcbiJdfQ==

package/lib/api/resource-import/importer.d.ts

@@ -103,7 +103,11 @@ export declare class ResourceImporter {
     /**
      * Load the resources to import from a file
      */
-    loadResourceIdentifiers(available: ImportableResource[], filename: string): Promise<ImportMap>;
+    loadResourceIdentifiersFromFile(available: ImportableResource[], fileName: string): Promise<ImportMap>;
+    /**
+     * Load the resources to import from a mapping (JSON string or pre-parsed object)
+     */
+    loadResourceIdentifiers(available: ImportableResource[], identifiers: string | Record<string, ResourceIdentifierProperties>): Promise<ImportMap>;
     /**
      * Based on the provided resource mapping, prepare CFN structures for import (template,
      * ResourcesToImport structure) and perform the import operation (CloudFormation deployment)