@aws-cdk/cloud-assembly-api 2.2.6 → 2.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,277 @@
1
+ "use strict";
2
+ var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
3
+ if (k2 === undefined) k2 = k;
4
+ var desc = Object.getOwnPropertyDescriptor(m, k);
5
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
6
+ desc = { enumerable: true, get: function() { return m[k]; } };
7
+ }
8
+ Object.defineProperty(o, k2, desc);
9
+ }) : (function(o, m, k, k2) {
10
+ if (k2 === undefined) k2 = k;
11
+ o[k2] = m[k];
12
+ }));
13
+ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
14
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
15
+ }) : function(o, v) {
16
+ o["default"] = v;
17
+ });
18
+ var __importStar = (this && this.__importStar) || (function () {
19
+ var ownKeys = function(o) {
20
+ ownKeys = Object.getOwnPropertyNames || function (o) {
21
+ var ar = [];
22
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
23
+ return ar;
24
+ };
25
+ return ownKeys(o);
26
+ };
27
+ return function (mod) {
28
+ if (mod && mod.__esModule) return mod;
29
+ var result = {};
30
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
31
+ __setModuleDefault(result, mod);
32
+ return result;
33
+ };
34
+ })();
35
+ Object.defineProperty(exports, "__esModule", { value: true });
36
+ exports.ConstructIndex = void 0;
37
+ exports.buildConstructTree = buildConstructTree;
38
+ exports.buildConstructTreeAsync = buildConstructTreeAsync;
39
+ const fs = __importStar(require("fs"));
40
+ const path = __importStar(require("path"));
41
+ const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
42
+ const assets_1 = require("./assets");
43
+ /** Construct ids that aws-cdk-lib injects into the tree but aren't user constructs. */
44
+ const CDK_INTERNAL_IDS = new Set(['Tree', 'CDKMetadata', 'BootstrapVersion', 'CheckBootstrapVersion']);
45
+ /**
46
+ * A pre-built index over a construct tree. Walks the tree once and exposes
47
+ * O(1) path lookup plus pre-order iteration over every node, so callers never
48
+ * re-implement the recursive descent over `children`.
49
+ *
50
+ * Generic over the concrete node type, so callers that store richer nodes get
51
+ * those richer nodes back from `byPath()` and iteration.
52
+ */
53
+ class ConstructIndex {
54
+ byPathMap;
55
+ /** Build an index from the roots of a construct tree. */
56
+ static fromTree(tree) {
57
+ const byPath = new Map();
58
+ // Pre-order insertion: iteration order below relies on the Map preserving it.
59
+ visit(tree, (node) => byPath.set(node.path, node));
60
+ return new ConstructIndex(byPath);
61
+ }
62
+ constructor(byPathMap) {
63
+ this.byPathMap = byPathMap;
64
+ }
65
+ /** The node at a given construct path, or undefined if absent. */
66
+ byPath(constructPath) {
67
+ return this.byPathMap.get(constructPath);
68
+ }
69
+ /** Number of nodes in the tree. */
70
+ get size() {
71
+ return this.byPathMap.size;
72
+ }
73
+ /** Pre-order iteration over every node in the tree. */
74
+ [Symbol.iterator]() {
75
+ return this.byPathMap.values();
76
+ }
77
+ }
78
+ exports.ConstructIndex = ConstructIndex;
79
+ /** The single recursive descent over a construct tree. */
80
+ function visit(nodes, fn) {
81
+ for (const node of nodes) {
82
+ fn(node);
83
+ // In a homogeneous tree the children are the same concrete node type.
84
+ if (node.children.length > 0)
85
+ visit(node.children, fn);
86
+ }
87
+ }
88
+ /**
89
+ * Read a cloud assembly's tree.json and join it with each stack's manifest
90
+ * metadata to produce a construct tree where every CFN resource carries its
91
+ * logicalId and CFN type.
92
+ *
93
+ * Supports:
94
+ * - Flat assemblies (stacks directly under App).
95
+ * - Stage-based apps: each Stage produces a nested cloud-assembly artifact
96
+ * under assembly-STAGE/. stacksRecursively descends into them.
97
+ * - NestedStack contents: aws-cdk-lib emits the per-resource metadata for
98
+ * nested-stack constructs into the PARENT stack's artifact metadata,
99
+ * keyed by full construct path.
100
+ *
101
+ * The `decorate` callback turns each node's generic fields and its metadata
102
+ * entries into the concrete node type (e.g. attaching a resolved source location).
103
+ *
104
+ * This is the synchronous variant: `decorate` must return `T`. Callers whose
105
+ * decoration needs non-blocking I/O should use {@link buildConstructTreeAsync}.
106
+ */
107
+ function buildConstructTree(assembly, decorate) {
108
+ const roots = readRoots(assembly);
109
+ if (!roots)
110
+ return [];
111
+ const { rawRoots, ctx } = roots;
112
+ return rawRoots.map((child) => buildNodeSync(child, ctx, undefined, NO_TEMPLATE, decorate));
113
+ }
114
+ /**
115
+ * Async counterpart of {@link buildConstructTree}: the `decorate` callback may
116
+ * return a `Promise<T>`, letting it do non-blocking I/O per node (for example
117
+ * tracing source locations with `fs.promises`) without blocking the calling
118
+ * thread. Behaves identically otherwise; the tree is walked in pre-order and
119
+ * each node's children are resolved before the node is decorated.
120
+ */
121
+ async function buildConstructTreeAsync(assembly, decorate) {
122
+ const roots = readRoots(assembly);
123
+ if (!roots)
124
+ return [];
125
+ const { rawRoots, ctx } = roots;
126
+ const out = [];
127
+ for (const child of rawRoots) {
128
+ out.push(await buildNodeAsync(child, ctx, undefined, NO_TEMPLATE, decorate));
129
+ }
130
+ return out;
131
+ }
132
+ /**
133
+ * Load tree.json and build the walk context shared by both tree builders.
134
+ * Returns the user-facing root raw nodes (cdk-internal ids filtered out) plus
135
+ * the context, or undefined when there's no tree to walk.
136
+ */
137
+ function readRoots(assembly) {
138
+ const treeArtifact = assembly.tree();
139
+ if (!treeArtifact)
140
+ return undefined;
141
+ const rawTree = loadTree(path.join(assembly.directory, treeArtifact.file));
142
+ if (!rawTree)
143
+ return undefined;
144
+ const ctx = {
145
+ stackIndex: buildStackIndex(assembly.stacksRecursively),
146
+ templateCache: new Map(),
147
+ };
148
+ const rawRoots = Object.values(rawTree.children ?? {}).filter((child) => !isCdkInternal(child.id));
149
+ return { rawRoots, ctx };
150
+ }
151
+ /** Scope for nodes with no resolvable template: the root seed and unresolvable nested stacks. */
152
+ const NO_TEMPLATE = { file: undefined, template: undefined };
153
+ /** Reads and parses tree.json. Kept synchronous on purpose; see {@link loadTemplate}. */
154
+ function loadTree(treePath) {
155
+ if (!fs.existsSync(treePath))
156
+ return undefined;
157
+ const content = JSON.parse(fs.readFileSync(treePath, 'utf-8'));
158
+ return content.tree;
159
+ }
160
+ /**
161
+ * Index a stack's metadata by its tree-path key. Uses hierarchicalId, which
162
+ * resolves to stack.node.path for everything aws-cdk-lib emits. Caches the
163
+ * metadata Map because stack.metadata re-reads from disk on each access.
164
+ */
165
+ function buildStackIndex(stacks) {
166
+ const index = new Map();
167
+ for (const stack of stacks) {
168
+ index.set(stack.hierarchicalId, { stack, metadata: new Map(Object.entries(stack.metadata)) });
169
+ }
170
+ return index;
171
+ }
172
+ /**
173
+ * Compute the generic fields, owning stack, and per-child template scopes for a
174
+ * single node. Owns all of the tree/metadata/template join logic; the sync and
175
+ * async builders share it so the substantive walk lives in exactly one place.
176
+ */
177
+ function prepareNode(raw, ctx, inheritedStack, inherited) {
178
+ const stackHere = ctx.stackIndex.get(raw.path);
179
+ const owner = stackHere ?? inheritedStack;
180
+ // A stack node switches to its own template via the artifact's cached getter,
181
+ // which throws on a missing/corrupt top-level template -- a real assembly error
182
+ // we surface rather than swallow. Other nodes inherit the active scope.
183
+ const scope = stackHere
184
+ ? { file: stackHere.stack.templateFullPath, template: stackHere.stack.template }
185
+ : inherited;
186
+ // Metadata keys carry a leading "/", construct paths in tree.json don't.
187
+ const entries = owner?.metadata.get('/' + raw.path) ?? [];
188
+ const logicalId = logicalIdFromEntries(entries);
189
+ const cfnTypeRaw = raw.attributes?.[cloud_assembly_schema_1.CFN_RESOURCE_TYPE_ATTRIBUTE];
190
+ const cfnType = typeof cfnTypeRaw === 'string' ? cfnTypeRaw : undefined;
191
+ const cfnPropsRaw = raw.attributes?.[cloud_assembly_schema_1.CFN_RESOURCE_PROPS_ATTRIBUTE];
192
+ const cfnProperties = typeof cfnPropsRaw === 'object' && cfnPropsRaw !== null ? cfnPropsRaw : undefined;
193
+ // A NestedStack switches its subtree to the nested scope; other nodes inherit.
194
+ const childInputs = Object.values(raw.children ?? {})
195
+ .filter((child) => !isCdkInternal(child.id))
196
+ .map((child) => ({ raw: child, scope: nestedBoundary(child, raw, owner, scope.template, ctx) ?? scope }));
197
+ // Only CFN resources (those with a logical ID) carry a templateFile.
198
+ const nodeTemplateFile = logicalId !== undefined ? scope.file : undefined;
199
+ return {
200
+ base: { path: raw.path, id: raw.id, type: cfnType, logicalId, templateFile: nodeTemplateFile, cfnProperties },
201
+ owner,
202
+ constructPath: raw.path,
203
+ childInputs,
204
+ };
205
+ }
206
+ function buildNodeSync(raw, ctx, inheritedStack, inherited, decorate) {
207
+ const prepared = prepareNode(raw, ctx, inheritedStack, inherited);
208
+ const children = prepared.childInputs.map((ci) => buildNodeSync(ci.raw, ctx, prepared.owner, ci.scope, decorate));
209
+ return decorate({ ...prepared.base, children }, prepared.owner?.stack, prepared.constructPath);
210
+ }
211
+ async function buildNodeAsync(raw, ctx, inheritedStack, inherited, decorate) {
212
+ const prepared = prepareNode(raw, ctx, inheritedStack, inherited);
213
+ const children = [];
214
+ for (const ci of prepared.childInputs) {
215
+ children.push(await buildNodeAsync(ci.raw, ctx, prepared.owner, ci.scope, decorate));
216
+ }
217
+ return decorate({ ...prepared.base, children }, prepared.owner?.stack, prepared.constructPath);
218
+ }
219
+ function logicalIdFromEntries(entries) {
220
+ const entry = entries.find((e) => e.type === cloud_assembly_schema_1.ArtifactMetadataEntryType.LOGICAL_ID);
221
+ return typeof entry?.data === 'string' ? entry.data : undefined;
222
+ }
223
+ /**
224
+ * Parses a template file (cached by absolute path); undefined when missing/unparseable.
225
+ *
226
+ * Synchronous by design: {@link prepareNode} is shared by the sync `buildConstructTree`
227
+ * and the async `buildConstructTreeAsync`, so it cannot await. These reads are O(stacks)
228
+ * (one tree.json plus a handful of nested templates), not the per-construct hot path, so
229
+ * blocking here is acceptable. Do not switch to `fs.promises` without splitting the shared walk.
230
+ */
231
+ function loadTemplate(absPath, cache) {
232
+ if (cache.has(absPath))
233
+ return cache.get(absPath);
234
+ let template;
235
+ try {
236
+ template = JSON.parse(fs.readFileSync(absPath, 'utf-8'));
237
+ }
238
+ catch {
239
+ template = undefined; // missing/unparseable: that subtree just won't resolve a templateFile
240
+ }
241
+ cache.set(absPath, template);
242
+ return template;
243
+ }
244
+ /**
245
+ * If `child` is a NestedStack, resolves the template scope for its subtree;
246
+ * otherwise returns `undefined` (caller keeps the active scope).
247
+ *
248
+ * Detection keys off the sibling `AWS::CloudFormation::Stack` that aws-cdk-lib
249
+ * emits at `<parent>/<id>.NestedStack/<id>.NestedStackResource` (whose
250
+ * `aws:asset:path` points at the nested template), NOT the construct's fqn -- a
251
+ * jsii-published NestedStack subclass has an fqn that doesn't end in
252
+ * ".NestedStack", but the sibling is named the same regardless. Returns
253
+ * NO_TEMPLATE (not the parent's) when unresolvable, since the nested stack's
254
+ * resources don't live in the parent template.
255
+ */
256
+ function nestedBoundary(child, parent, owner, currentTemplate, ctx) {
257
+ const resourceNode = parent.children?.[`${child.id}.NestedStack`]?.children?.[`${child.id}.NestedStackResource`];
258
+ // No sibling -> not a nested stack. A real nested stack always lives under a
259
+ // stack, so `owner` is defined here; the check also narrows it.
260
+ if (!resourceNode || !owner)
261
+ return undefined;
262
+ const logicalId = logicalIdFromEntries(owner.metadata.get('/' + resourceNode.path) ?? []);
263
+ const assetPath = logicalId !== undefined
264
+ ? currentTemplate?.Resources?.[logicalId]?.Metadata?.[assets_1.ASSET_RESOURCE_METADATA_PATH_KEY]
265
+ : undefined;
266
+ if (typeof assetPath !== 'string')
267
+ return NO_TEMPLATE;
268
+ // Asset path is relative to the OWNER stack's assembly dir (the Stage
269
+ // sub-assembly for staged stacks), not necessarily the root assembly.
270
+ const file = path.join(path.dirname(owner.stack.templateFullPath), assetPath);
271
+ const template = loadTemplate(file, ctx.templateCache);
272
+ return template ? { file, template } : NO_TEMPLATE;
273
+ }
274
+ function isCdkInternal(id) {
275
+ return CDK_INTERNAL_IDS.has(id);
276
+ }
277
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"construct-tree.js","sourceRoot":"","sources":["construct-tree.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { ArtifactMetadataEntryType, CFN_RESOURCE_PROPS_ATTRIBUTE, CFN_RESOURCE_TYPE_ATTRIBUTE, type MetadataEntry } from '@aws-cdk/cloud-assembly-schema';\nimport type { CloudFormationStackArtifact } from './artifacts/cloudformation-artifact';\nimport { ASSET_RESOURCE_METADATA_PATH_KEY } from './assets';\nimport type { CloudAssembly } from './cloud-assembly';\n\n/** Construct ids that aws-cdk-lib injects into the tree but aren't user constructs. */\nconst CDK_INTERNAL_IDS = new Set(['Tree', 'CDKMetadata', 'BootstrapVersion', 'CheckBootstrapVersion']);\n\n/**\n * A construct from tree.json joined with the CloudFormation metadata of the\n * stack it belongs to: the construct path/id plus, for CFN resources, the\n * logical ID and resource type. Readers that need more (for example a source\n * location) extend this and build the richer tree via {@link buildConstructTree}.\n */\nexport interface ConstructTreeNode {\n  readonly path: string;\n  readonly id: string;\n  /** CFN resource type (e.g. \"AWS::S3::Bucket\"), if this construct is a CFN resource. */\n  readonly type?: string;\n  /** CFN logical ID, if this construct maps to a CFN resource. */\n  readonly logicalId?: string;\n  /**\n   * Absolute path to the `*.template.json` that declares this construct's CFN\n   * resource -- the nested template for resources inside a NestedStack. Set\n   * only for CFN resources whose template is resolvable.\n   */\n  readonly templateFile?: string;\n  /**\n   * Resolved CloudFormation resource properties (the synthesized values from\n   * the `aws:cdk:cloudformation:props` attribute), if this is a CFN resource.\n   */\n  readonly cfnProperties?: Record<string, unknown>;\n  readonly children: readonly ConstructTreeNode[];\n}\n\n/**\n * The generic fields {@link buildConstructTree} computes for each node before a\n * consumer decorates it. `children` are already the decorated node type.\n */\nexport interface ConstructTreeNodeFields<T extends ConstructTreeNode> {\n  readonly path: string;\n  readonly id: string;\n  readonly type?: string;\n  readonly logicalId?: string;\n  readonly templateFile?: string;\n  readonly cfnProperties?: Record<string, unknown>;\n  readonly children: readonly T[];\n}\n\n/**\n * Produces a node of type `T` from the generic fields, the owning stack\n * artifact (if any), and the construct path. Readers use the stack + path to\n * attach extra data (for example a source location traced from the stack).\n */\nexport type ConstructNodeDecorator<T extends ConstructTreeNode> = (\n  fields: ConstructTreeNodeFields<T>,\n  stack: CloudFormationStackArtifact | undefined,\n  constructPath: string,\n) => T;\n\n/**\n * Async variant of {@link ConstructNodeDecorator}: the decorator may return a\n * `Promise<T>`, so it can do non-blocking I/O (for example reading source maps\n * off disk with `fs.promises`) while building each node. Used by\n * {@link buildConstructTreeAsync}.\n */\nexport type AsyncConstructNodeDecorator<T extends ConstructTreeNode> = (\n  fields: ConstructTreeNodeFields<T>,\n  stack: CloudFormationStackArtifact | undefined,\n  constructPath: string,\n) => T | Promise<T>;\n\n/**\n * A pre-built index over a construct tree. Walks the tree once and exposes\n * O(1) path lookup plus pre-order iteration over every node, so callers never\n * re-implement the recursive descent over `children`.\n *\n * Generic over the concrete node type, so callers that store richer nodes get\n * those richer nodes back from `byPath()` and iteration.\n */\nexport class ConstructIndex<T extends ConstructTreeNode = ConstructTreeNode> implements Iterable<T> {\n  /** Build an index from the roots of a construct tree. */\n  public static fromTree<T extends ConstructTreeNode>(tree: readonly T[]): ConstructIndex<T> {\n    const byPath = new Map<string, T>();\n    // Pre-order insertion: iteration order below relies on the Map preserving it.\n    visit(tree, (node) => byPath.set(node.path, node));\n    return new ConstructIndex(byPath);\n  }\n\n  private constructor(private readonly byPathMap: Map<string, T>) {\n  }\n\n  /** The node at a given construct path, or undefined if absent. */\n  public byPath(constructPath: string): T | undefined {\n    return this.byPathMap.get(constructPath);\n  }\n\n  /** Number of nodes in the tree. */\n  public get size(): number {\n    return this.byPathMap.size;\n  }\n\n  /** Pre-order iteration over every node in the tree. */\n  public [Symbol.iterator](): Iterator<T> {\n    return this.byPathMap.values();\n  }\n}\n\n/** The single recursive descent over a construct tree. */\nfunction visit<T extends ConstructTreeNode>(nodes: readonly T[], fn: (node: T) => void): void {\n  for (const node of nodes) {\n    fn(node);\n    // In a homogeneous tree the children are the same concrete node type.\n    if (node.children.length > 0) visit(node.children as readonly T[], fn);\n  }\n}\n\n/**\n * Read a cloud assembly's tree.json and join it with each stack's manifest\n * metadata to produce a construct tree where every CFN resource carries its\n * logicalId and CFN type.\n *\n * Supports:\n *  - Flat assemblies (stacks directly under App).\n *  - Stage-based apps: each Stage produces a nested cloud-assembly artifact\n *    under assembly-STAGE/. stacksRecursively descends into them.\n *  - NestedStack contents: aws-cdk-lib emits the per-resource metadata for\n *    nested-stack constructs into the PARENT stack's artifact metadata,\n *    keyed by full construct path.\n *\n * The `decorate` callback turns each node's generic fields and its metadata\n * entries into the concrete node type (e.g. attaching a resolved source location).\n *\n * This is the synchronous variant: `decorate` must return `T`. Callers whose\n * decoration needs non-blocking I/O should use {@link buildConstructTreeAsync}.\n */\nexport function buildConstructTree<T extends ConstructTreeNode>(\n  assembly: CloudAssembly,\n  decorate: ConstructNodeDecorator<T>,\n): T[] {\n  const roots = readRoots(assembly);\n  if (!roots) return [];\n  const { rawRoots, ctx } = roots;\n  return rawRoots.map((child) => buildNodeSync(child, ctx, undefined, NO_TEMPLATE, decorate));\n}\n\n/**\n * Async counterpart of {@link buildConstructTree}: the `decorate` callback may\n * return a `Promise<T>`, letting it do non-blocking I/O per node (for example\n * tracing source locations with `fs.promises`) without blocking the calling\n * thread. Behaves identically otherwise; the tree is walked in pre-order and\n * each node's children are resolved before the node is decorated.\n */\nexport async function buildConstructTreeAsync<T extends ConstructTreeNode>(\n  assembly: CloudAssembly,\n  decorate: AsyncConstructNodeDecorator<T>,\n): Promise<T[]> {\n  const roots = readRoots(assembly);\n  if (!roots) return [];\n  const { rawRoots, ctx } = roots;\n  const out: T[] = [];\n  for (const child of rawRoots) {\n    out.push(await buildNodeAsync(child, ctx, undefined, NO_TEMPLATE, decorate));\n  }\n  return out;\n}\n\n/**\n * Load tree.json and build the walk context shared by both tree builders.\n * Returns the user-facing root raw nodes (cdk-internal ids filtered out) plus\n * the context, or undefined when there's no tree to walk.\n */\nfunction readRoots(assembly: CloudAssembly): WalkRoots | undefined {\n  const treeArtifact = assembly.tree();\n  if (!treeArtifact) return undefined;\n\n  const rawTree = loadTree(path.join(assembly.directory, treeArtifact.file));\n  if (!rawTree) return undefined;\n\n  const ctx: WalkContext = {\n    stackIndex: buildStackIndex(assembly.stacksRecursively),\n    templateCache: new Map(),\n  };\n  const rawRoots = Object.values(rawTree.children ?? {}).filter((child) => !isCdkInternal(child.id));\n  return { rawRoots, ctx };\n}\n\n/** The user-facing root raw nodes plus the shared walk context. */\ninterface WalkRoots {\n  readonly rawRoots: RawTreeNode[];\n  readonly ctx: WalkContext;\n}\n\n/** Shared state for a single tree walk (decorator-independent). */\ninterface WalkContext {\n  readonly stackIndex: StackMetadataIndex;\n  /** Parsed nested templates, cached by absolute path. */\n  readonly templateCache: Map<string, CfnTemplate | undefined>;\n}\n\n/** The slice of a CloudFormation template the tree walk reads. */\ninterface CfnTemplate {\n  readonly Resources?: Record<string, CfnResource>;\n}\ninterface CfnResource {\n  readonly Type?: string;\n  readonly Metadata?: Record<string, unknown>;\n}\n\n/**\n * The active CloudFormation template threaded down the tree walk: a resolved\n * `{ file, template }` pair, or both `undefined` when there's no resolvable\n * template (the root, or a nested stack that isn't CDK-resolvable). Never a\n * partial mix.\n */\ntype TemplateScope =\n  | { readonly file: string; readonly template: CfnTemplate }\n  | { readonly file: undefined; readonly template: undefined };\n\n/** Scope for nodes with no resolvable template: the root seed and unresolvable nested stacks. */\nconst NO_TEMPLATE: TemplateScope = { file: undefined, template: undefined };\n\n/**\n * Raw tree.json node. The root tree.json holds the FULL hierarchy including\n * Stage children; nested-assembly subdirs don't shard tree.json.\n */\ninterface RawTreeNode {\n  readonly id: string;\n  readonly path: string;\n  readonly children?: { [key: string]: RawTreeNode };\n  readonly attributes?: { [key: string]: unknown };\n}\n\n/** A stack artifact plus its metadata Map, keyed (in the index) by construct path. */\ninterface StackMetadata {\n  readonly stack: CloudFormationStackArtifact;\n  readonly metadata: Map<string, MetadataEntry[]>;\n}\ntype StackMetadataIndex = Map<string, StackMetadata>;\n\n/** The generic fields for one node, minus its (decorated) children. */\ntype NodeFieldsBase = Omit<ConstructTreeNodeFields<ConstructTreeNode>, 'children'>;\n\n/** A child to recurse into, paired with the template scope it inherits. */\ninterface ChildInput {\n  readonly raw: RawTreeNode;\n  readonly scope: TemplateScope;\n}\n\n/**\n * Everything {@link buildNodeSync}/{@link buildNodeAsync} need for one node,\n * computed once (no I/O beyond the cached template reads), so the two builders\n * differ only in how they recurse and invoke `decorate`.\n */\ninterface PreparedNode {\n  readonly base: NodeFieldsBase;\n  /** Owning stack metadata: its `stack` is the decorate arg and the children's inheritedStack. */\n  readonly owner: StackMetadata | undefined;\n  readonly constructPath: string;\n  readonly childInputs: readonly ChildInput[];\n}\n\n/** Reads and parses tree.json. Kept synchronous on purpose; see {@link loadTemplate}. */\nfunction loadTree(treePath: string): RawTreeNode | undefined {\n  if (!fs.existsSync(treePath)) return undefined;\n  const content = JSON.parse(fs.readFileSync(treePath, 'utf-8'));\n  return content.tree;\n}\n\n/**\n * Index a stack's metadata by its tree-path key. Uses hierarchicalId, which\n * resolves to stack.node.path for everything aws-cdk-lib emits. Caches the\n * metadata Map because stack.metadata re-reads from disk on each access.\n */\nfunction buildStackIndex(stacks: CloudFormationStackArtifact[]): StackMetadataIndex {\n  const index: StackMetadataIndex = new Map();\n  for (const stack of stacks) {\n    index.set(stack.hierarchicalId, { stack, metadata: new Map(Object.entries(stack.metadata)) });\n  }\n  return index;\n}\n\n/**\n * Compute the generic fields, owning stack, and per-child template scopes for a\n * single node. Owns all of the tree/metadata/template join logic; the sync and\n * async builders share it so the substantive walk lives in exactly one place.\n */\nfunction prepareNode(\n  raw: RawTreeNode,\n  ctx: WalkContext,\n  inheritedStack: StackMetadata | undefined,\n  inherited: TemplateScope,\n): PreparedNode {\n  const stackHere = ctx.stackIndex.get(raw.path);\n  const owner = stackHere ?? inheritedStack;\n  // A stack node switches to its own template via the artifact's cached getter,\n  // which throws on a missing/corrupt top-level template -- a real assembly error\n  // we surface rather than swallow. Other nodes inherit the active scope.\n  const scope: TemplateScope = stackHere\n    ? { file: stackHere.stack.templateFullPath, template: stackHere.stack.template as CfnTemplate }\n    : inherited;\n\n  // Metadata keys carry a leading \"/\", construct paths in tree.json don't.\n  const entries = owner?.metadata.get('/' + raw.path) ?? [];\n  const logicalId = logicalIdFromEntries(entries);\n\n  const cfnTypeRaw = raw.attributes?.[CFN_RESOURCE_TYPE_ATTRIBUTE];\n  const cfnType = typeof cfnTypeRaw === 'string' ? cfnTypeRaw : undefined;\n  const cfnPropsRaw = raw.attributes?.[CFN_RESOURCE_PROPS_ATTRIBUTE];\n  const cfnProperties =\n    typeof cfnPropsRaw === 'object' && cfnPropsRaw !== null ? (cfnPropsRaw as Record<string, unknown>) : undefined;\n\n  // A NestedStack switches its subtree to the nested scope; other nodes inherit.\n  const childInputs: ChildInput[] = Object.values(raw.children ?? {})\n    .filter((child) => !isCdkInternal(child.id))\n    .map((child) => ({ raw: child, scope: nestedBoundary(child, raw, owner, scope.template, ctx) ?? scope }));\n\n  // Only CFN resources (those with a logical ID) carry a templateFile.\n  const nodeTemplateFile = logicalId !== undefined ? scope.file : undefined;\n  return {\n    base: { path: raw.path, id: raw.id, type: cfnType, logicalId, templateFile: nodeTemplateFile, cfnProperties },\n    owner,\n    constructPath: raw.path,\n    childInputs,\n  };\n}\n\nfunction buildNodeSync<T extends ConstructTreeNode>(\n  raw: RawTreeNode,\n  ctx: WalkContext,\n  inheritedStack: StackMetadata | undefined,\n  inherited: TemplateScope,\n  decorate: ConstructNodeDecorator<T>,\n): T {\n  const prepared = prepareNode(raw, ctx, inheritedStack, inherited);\n  const children = prepared.childInputs.map(\n    (ci) => buildNodeSync(ci.raw, ctx, prepared.owner, ci.scope, decorate),\n  );\n  return decorate({ ...prepared.base, children }, prepared.owner?.stack, prepared.constructPath);\n}\n\nasync function buildNodeAsync<T extends ConstructTreeNode>(\n  raw: RawTreeNode,\n  ctx: WalkContext,\n  inheritedStack: StackMetadata | undefined,\n  inherited: TemplateScope,\n  decorate: AsyncConstructNodeDecorator<T>,\n): Promise<T> {\n  const prepared = prepareNode(raw, ctx, inheritedStack, inherited);\n  const children: T[] = [];\n  for (const ci of prepared.childInputs) {\n    children.push(await buildNodeAsync(ci.raw, ctx, prepared.owner, ci.scope, decorate));\n  }\n  return decorate({ ...prepared.base, children }, prepared.owner?.stack, prepared.constructPath);\n}\n\nfunction logicalIdFromEntries(entries: MetadataEntry[]): string | undefined {\n  const entry = entries.find((e) => e.type === ArtifactMetadataEntryType.LOGICAL_ID);\n  return typeof entry?.data === 'string' ? entry.data : undefined;\n}\n\n/**\n * Parses a template file (cached by absolute path); undefined when missing/unparseable.\n *\n * Synchronous by design: {@link prepareNode} is shared by the sync `buildConstructTree`\n * and the async `buildConstructTreeAsync`, so it cannot await. These reads are O(stacks)\n * (one tree.json plus a handful of nested templates), not the per-construct hot path, so\n * blocking here is acceptable. Do not switch to `fs.promises` without splitting the shared walk.\n */\nfunction loadTemplate(absPath: string, cache: Map<string, CfnTemplate | undefined>): CfnTemplate | undefined {\n  if (cache.has(absPath)) return cache.get(absPath);\n  let template: CfnTemplate | undefined;\n  try {\n    template = JSON.parse(fs.readFileSync(absPath, 'utf-8')) as CfnTemplate;\n  } catch {\n    template = undefined; // missing/unparseable: that subtree just won't resolve a templateFile\n  }\n  cache.set(absPath, template);\n  return template;\n}\n\n/**\n * If `child` is a NestedStack, resolves the template scope for its subtree;\n * otherwise returns `undefined` (caller keeps the active scope).\n *\n * Detection keys off the sibling `AWS::CloudFormation::Stack` that aws-cdk-lib\n * emits at `<parent>/<id>.NestedStack/<id>.NestedStackResource` (whose\n * `aws:asset:path` points at the nested template), NOT the construct's fqn -- a\n * jsii-published NestedStack subclass has an fqn that doesn't end in\n * \".NestedStack\", but the sibling is named the same regardless. Returns\n * NO_TEMPLATE (not the parent's) when unresolvable, since the nested stack's\n * resources don't live in the parent template.\n */\nfunction nestedBoundary(\n  child: RawTreeNode,\n  parent: RawTreeNode,\n  owner: StackMetadata | undefined,\n  currentTemplate: CfnTemplate | undefined,\n  ctx: WalkContext,\n): TemplateScope | undefined {\n  const resourceNode = parent.children?.[`${child.id}.NestedStack`]?.children?.[`${child.id}.NestedStackResource`];\n  // No sibling -> not a nested stack. A real nested stack always lives under a\n  // stack, so `owner` is defined here; the check also narrows it.\n  if (!resourceNode || !owner) return undefined;\n\n  const logicalId = logicalIdFromEntries(owner.metadata.get('/' + resourceNode.path) ?? []);\n  const assetPath = logicalId !== undefined\n    ? currentTemplate?.Resources?.[logicalId]?.Metadata?.[ASSET_RESOURCE_METADATA_PATH_KEY]\n    : undefined;\n  if (typeof assetPath !== 'string') return NO_TEMPLATE;\n  // Asset path is relative to the OWNER stack's assembly dir (the Stage\n  // sub-assembly for staged stacks), not necessarily the root assembly.\n  const file = path.join(path.dirname(owner.stack.templateFullPath), assetPath);\n  const template = loadTemplate(file, ctx.templateCache);\n  return template ? { file, template } : NO_TEMPLATE;\n}\n\nfunction isCdkInternal(id: string): boolean {\n  return CDK_INTERNAL_IDS.has(id);\n}\n"]}
@@ -2,7 +2,17 @@
2
2
  * Models an AWS execution environment, for use within the CDK toolkit.
3
3
  */
4
4
  export interface Environment {
5
- /** The arbitrary name of this environment (user-set, or at least user-meaningful) */
5
+ /**
6
+ * The display name of this environment, in the form `aws://<account>/<region>`
7
+ *
8
+ * This is always machine-generated, never user-set: it is either the
9
+ * artifact's `environment` field (which has this shape) or formatted from
10
+ * the account and region by `EnvironmentUtils.format`.
11
+ *
12
+ * Note that until the environment has been resolved, the account and region
13
+ * may still be the `UNKNOWN_ACCOUNT`/`UNKNOWN_REGION` placeholders, so this
14
+ * value is not necessarily usable as a `cdk` command line argument.
15
+ */
6
16
  readonly name: string;
7
17
  /** The AWS account this environment deploys into */
8
18
  readonly account: string;
@@ -37,4 +37,4 @@ class EnvironmentUtils {
37
37
  }
38
38
  }
39
39
  exports.EnvironmentUtils = EnvironmentUtils;
40
- //# sourceMappingURL=data:application/json;base64,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
40
+ //# sourceMappingURL=data:application/json;base64,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
package/lib/index.d.ts CHANGED
@@ -19,3 +19,5 @@ export * from './metadata';
19
19
  export * from './placeholders';
20
20
  export * from './environment';
21
21
  export * from './bootstrap';
22
+ export * from './construct-tree';
23
+ export * from './template-ranges';
package/lib/index.js CHANGED
@@ -35,4 +35,6 @@ __exportStar(require("./metadata"), exports);
35
35
  __exportStar(require("./placeholders"), exports);
36
36
  __exportStar(require("./environment"), exports);
37
37
  __exportStar(require("./bootstrap"), exports);
38
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCO0FBQzlCLGdEQUE4QjtBQUM5QiwwREFBd0M7QUFDeEMsK0RBQTZDO0FBQzdDLGdGQUE4RDtBQUM5RCwyREFBeUM7QUFDekMsZ0RBQThCO0FBQzlCLG9EQUFrQztBQUNsQyxtREFBaUM7QUFDakMsZ0NBQThCO0FBQzlCLHNFQUFvRDtBQUNwRCxzRUFBb0Q7QUFDcEQsa0VBQWdEO0FBQ2hELDZFQUEyRDtBQUMzRCwwREFBd0Q7QUFDeEQsbURBQWlDO0FBQ2pDLDJDQUF5QjtBQUN6Qiw2Q0FBMkI7QUFDM0IsaURBQStCO0FBQy9CLGdEQUE4QjtBQUM5Qiw4Q0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRleHQvdnBjJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGV4dC9hbWknO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0L2xvYWQtYmFsYW5jZXInO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0L2F2YWlsYWJpbGl0eS16b25lcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQvZW5kcG9pbnQtc2VydmljZS1hdmFpbGFiaWxpdHktem9uZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0L3NlY3VyaXR5LWdyb3VwJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGV4dC9rZXknO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0L2dlbmVyaWMnO1xuZXhwb3J0ICogZnJvbSAnLi9jbG91ZC1hcnRpZmFjdCc7XG5pbXBvcnQgJy4vY2xvdWQtYXJ0aWZhY3QtYXVnJztcbmV4cG9ydCAqIGZyb20gJy4vYXJ0aWZhY3RzL2Fzc2V0LW1hbmlmZXN0LWFydGlmYWN0JztcbmV4cG9ydCAqIGZyb20gJy4vYXJ0aWZhY3RzL2Nsb3VkZm9ybWF0aW9uLWFydGlmYWN0JztcbmV4cG9ydCAqIGZyb20gJy4vYXJ0aWZhY3RzL3RyZWUtY2xvdWQtYXJ0aWZhY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9hcnRpZmFjdHMvbmVzdGVkLWNsb3VkLWFzc2VtYmx5LWFydGlmYWN0JztcbmltcG9ydCAnLi9hcnRpZmFjdHMvbmVzdGVkLWNsb3VkLWFzc2VtYmx5LWFydGlmYWN0LWF1Zyc7XG5leHBvcnQgKiBmcm9tICcuL2Nsb3VkLWFzc2VtYmx5JztcbmV4cG9ydCAqIGZyb20gJy4vYXNzZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0YWRhdGEnO1xuZXhwb3J0ICogZnJvbSAnLi9wbGFjZWhvbGRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnZpcm9ubWVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Jvb3RzdHJhcCc7XG4iXX0=
38
+ __exportStar(require("./construct-tree"), exports);
39
+ __exportStar(require("./template-ranges"), exports);
40
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCO0FBQzlCLGdEQUE4QjtBQUM5QiwwREFBd0M7QUFDeEMsK0RBQTZDO0FBQzdDLGdGQUE4RDtBQUM5RCwyREFBeUM7QUFDekMsZ0RBQThCO0FBQzlCLG9EQUFrQztBQUNsQyxtREFBaUM7QUFDakMsZ0NBQThCO0FBQzlCLHNFQUFvRDtBQUNwRCxzRUFBb0Q7QUFDcEQsa0VBQWdEO0FBQ2hELDZFQUEyRDtBQUMzRCwwREFBd0Q7QUFDeEQsbURBQWlDO0FBQ2pDLDJDQUF5QjtBQUN6Qiw2Q0FBMkI7QUFDM0IsaURBQStCO0FBQy9CLGdEQUE4QjtBQUM5Qiw4Q0FBNEI7QUFDNUIsbURBQWlDO0FBQ2pDLG9EQUFrQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC92cGMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0L2FtaSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQvbG9hZC1iYWxhbmNlcic7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQvYXZhaWxhYmlsaXR5LXpvbmVzJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGV4dC9lbmRwb2ludC1zZXJ2aWNlLWF2YWlsYWJpbGl0eS16b25lcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQvc2VjdXJpdHktZ3JvdXAnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0L2tleSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQvZ2VuZXJpYyc7XG5leHBvcnQgKiBmcm9tICcuL2Nsb3VkLWFydGlmYWN0JztcbmltcG9ydCAnLi9jbG91ZC1hcnRpZmFjdC1hdWcnO1xuZXhwb3J0ICogZnJvbSAnLi9hcnRpZmFjdHMvYXNzZXQtbWFuaWZlc3QtYXJ0aWZhY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9hcnRpZmFjdHMvY2xvdWRmb3JtYXRpb24tYXJ0aWZhY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9hcnRpZmFjdHMvdHJlZS1jbG91ZC1hcnRpZmFjdCc7XG5leHBvcnQgKiBmcm9tICcuL2FydGlmYWN0cy9uZXN0ZWQtY2xvdWQtYXNzZW1ibHktYXJ0aWZhY3QnO1xuaW1wb3J0ICcuL2FydGlmYWN0cy9uZXN0ZWQtY2xvdWQtYXNzZW1ibHktYXJ0aWZhY3QtYXVnJztcbmV4cG9ydCAqIGZyb20gJy4vY2xvdWQtYXNzZW1ibHknO1xuZXhwb3J0ICogZnJvbSAnLi9hc3NldHMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXRhZGF0YSc7XG5leHBvcnQgKiBmcm9tICcuL3BsYWNlaG9sZGVycyc7XG5leHBvcnQgKiBmcm9tICcuL2Vudmlyb25tZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0LXRyZWUnO1xuZXhwb3J0ICogZnJvbSAnLi90ZW1wbGF0ZS1yYW5nZXMnO1xuIl19
@@ -8,6 +8,18 @@ exports.EnvironmentPlaceholders = void 0;
8
8
  * Cloud Assembly manifest.
9
9
  */
10
10
  class EnvironmentPlaceholders {
11
+ /**
12
+ * Insert this into the destination fields to be replaced with the current region
13
+ */
14
+ static CURRENT_REGION = '${AWS::Region}';
15
+ /**
16
+ * Insert this into the destination fields to be replaced with the current account
17
+ */
18
+ static CURRENT_ACCOUNT = '${AWS::AccountId}';
19
+ /**
20
+ * Insert this into the destination fields to be replaced with the current partition
21
+ */
22
+ static CURRENT_PARTITION = '${AWS::Partition}';
11
23
  /**
12
24
  * Replace the environment placeholders in all strings found in a complex object.
13
25
  *
@@ -69,22 +81,10 @@ class EnvironmentPlaceholders {
69
81
  }
70
82
  }
71
83
  exports.EnvironmentPlaceholders = EnvironmentPlaceholders;
72
- /**
73
- * Insert this into the destination fields to be replaced with the current region
74
- */
75
- EnvironmentPlaceholders.CURRENT_REGION = '${AWS::Region}';
76
- /**
77
- * Insert this into the destination fields to be replaced with the current account
78
- */
79
- EnvironmentPlaceholders.CURRENT_ACCOUNT = '${AWS::AccountId}';
80
- /**
81
- * Insert this into the destination fields to be replaced with the current partition
82
- */
83
- EnvironmentPlaceholders.CURRENT_PARTITION = '${AWS::Partition}';
84
84
  /**
85
85
  * A "replace-all" function that doesn't require us escaping a literal string to a regex
86
86
  */
87
87
  function replaceAll(s, search, replace) {
88
88
  return s.split(search).join(replace);
89
89
  }
90
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"placeholders.js","sourceRoot":"","sources":["placeholders.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Placeholders which can be used manifests\n *\n * These can occur both in the Asset Manifest as well as the general\n * Cloud Assembly manifest.\n */\nexport class EnvironmentPlaceholders {\n  /**\n   * Insert this into the destination fields to be replaced with the current region\n   */\n  public static readonly CURRENT_REGION = '${AWS::Region}';\n\n  /**\n   * Insert this into the destination fields to be replaced with the current account\n   */\n  public static readonly CURRENT_ACCOUNT = '${AWS::AccountId}';\n\n  /**\n   * Insert this into the destination fields to be replaced with the current partition\n   */\n  public static readonly CURRENT_PARTITION = '${AWS::Partition}';\n\n  /**\n   * Replace the environment placeholders in all strings found in a complex object.\n   *\n   * Duplicated between cdk-assets and aws-cdk CLI because we don't have a good single place to put it\n   * (they're nominally independent tools).\n   */\n  public static replace(object: any, values: EnvironmentPlaceholderValues): any {\n    return this.recurse(object, value => {\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_REGION, values.region);\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_ACCOUNT, values.accountId);\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_PARTITION, values.partition);\n      return value;\n    });\n  }\n\n  /**\n   * Like 'replace', but asynchronous\n   */\n  public static async replaceAsync(object: any, provider: IEnvironmentPlaceholderProvider): Promise<any> {\n    let needRegion = false;\n    let needAccountId = false;\n    let needPartition = false;\n\n    this.recurse(object, value => {\n      if (value.indexOf(EnvironmentPlaceholders.CURRENT_REGION) > 1) {\n        needRegion = true;\n      }\n      if (value.indexOf(EnvironmentPlaceholders.CURRENT_ACCOUNT) > 1) {\n        needAccountId = true;\n      }\n      if (value.indexOf(EnvironmentPlaceholders.CURRENT_PARTITION) > 1) {\n        needPartition = true;\n      }\n      return value;\n    });\n\n    const region = needRegion ? await provider.region() : undefined;\n    const accountId = needAccountId ? await provider.accountId() : undefined;\n    const partition = needPartition ? await provider.partition() : undefined;\n\n    return this.recurse(object, value => {\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_REGION, region ?? 'WONTHAPPEN');\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_ACCOUNT, accountId ?? 'WONTHAPPEN');\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_PARTITION, partition ?? 'WONTHAPPEN');\n      return value;\n    });\n  }\n\n  private static recurse(value: any, cb: (x: string) => string): any {\n    if (typeof value === 'string') {\n      return cb(value);\n    }\n    if (typeof value !== 'object' || value === null) {\n      return value;\n    }\n    if (Array.isArray(value)) {\n      return value.map(x => this.recurse(x, cb));\n    }\n\n    const ret: Record<string, any> = {};\n    for (const [key, inner] of Object.entries(value)) {\n      ret[key] = this.recurse(inner, cb);\n    }\n    return ret;\n  }\n}\n\n/**\n * Return the appropriate values for the environment placeholders\n */\nexport interface EnvironmentPlaceholderValues {\n  /**\n   * Return the region\n   */\n  readonly region: string;\n\n  /**\n   * Return the account\n   */\n  readonly accountId: string;\n\n  /**\n   * Return the partition\n   */\n  readonly partition: string;\n}\n\n/**\n * Return the appropriate values for the environment placeholders\n */\nexport interface IEnvironmentPlaceholderProvider {\n  /**\n   * Return the region\n   */\n  region(): Promise<string>;\n\n  /**\n   * Return the account\n   */\n  accountId(): Promise<string>;\n\n  /**\n   * Return the partition\n   */\n  partition(): Promise<string>;\n}\n\n/**\n * A \"replace-all\" function that doesn't require us escaping a literal string to a regex\n */\nfunction replaceAll(s: string, search: string, replace: string) {\n  return s.split(search).join(replace);\n}\n"]}
90
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"placeholders.js","sourceRoot":"","sources":["placeholders.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Placeholders which can be used manifests\n *\n * These can occur both in the Asset Manifest as well as the general\n * Cloud Assembly manifest.\n */\nexport class EnvironmentPlaceholders {\n  /**\n   * Insert this into the destination fields to be replaced with the current region\n   */\n  public static readonly CURRENT_REGION = '${AWS::Region}';\n\n  /**\n   * Insert this into the destination fields to be replaced with the current account\n   */\n  public static readonly CURRENT_ACCOUNT = '${AWS::AccountId}';\n\n  /**\n   * Insert this into the destination fields to be replaced with the current partition\n   */\n  public static readonly CURRENT_PARTITION = '${AWS::Partition}';\n\n  /**\n   * Replace the environment placeholders in all strings found in a complex object.\n   *\n   * Duplicated between cdk-assets and aws-cdk CLI because we don't have a good single place to put it\n   * (they're nominally independent tools).\n   */\n  public static replace(object: any, values: EnvironmentPlaceholderValues): any {\n    return this.recurse(object, value => {\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_REGION, values.region);\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_ACCOUNT, values.accountId);\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_PARTITION, values.partition);\n      return value;\n    });\n  }\n\n  /**\n   * Like 'replace', but asynchronous\n   */\n  public static async replaceAsync(object: any, provider: IEnvironmentPlaceholderProvider): Promise<any> {\n    let needRegion = false;\n    let needAccountId = false;\n    let needPartition = false;\n\n    this.recurse(object, value => {\n      if (value.indexOf(EnvironmentPlaceholders.CURRENT_REGION) > 1) {\n        needRegion = true;\n      }\n      if (value.indexOf(EnvironmentPlaceholders.CURRENT_ACCOUNT) > 1) {\n        needAccountId = true;\n      }\n      if (value.indexOf(EnvironmentPlaceholders.CURRENT_PARTITION) > 1) {\n        needPartition = true;\n      }\n      return value;\n    });\n\n    const region = needRegion ? await provider.region() : undefined;\n    const accountId = needAccountId ? await provider.accountId() : undefined;\n    const partition = needPartition ? await provider.partition() : undefined;\n\n    return this.recurse(object, value => {\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_REGION, region ?? 'WONTHAPPEN');\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_ACCOUNT, accountId ?? 'WONTHAPPEN');\n      value = replaceAll(value, EnvironmentPlaceholders.CURRENT_PARTITION, partition ?? 'WONTHAPPEN');\n      return value;\n    });\n  }\n\n  private static recurse(value: any, cb: (x: string) => string): any {\n    if (typeof value === 'string') {\n      return cb(value);\n    }\n    if (typeof value !== 'object' || value === null) {\n      return value;\n    }\n    if (Array.isArray(value)) {\n      return value.map(x => this.recurse(x, cb));\n    }\n\n    const ret: Record<string, any> = {};\n    for (const [key, inner] of Object.entries(value)) {\n      ret[key] = this.recurse(inner, cb);\n    }\n    return ret;\n  }\n}\n\n/**\n * Return the appropriate values for the environment placeholders\n */\nexport interface EnvironmentPlaceholderValues {\n  /**\n   * Return the region\n   */\n  readonly region: string;\n\n  /**\n   * Return the account\n   */\n  readonly accountId: string;\n\n  /**\n   * Return the partition\n   */\n  readonly partition: string;\n}\n\n/**\n * Return the appropriate values for the environment placeholders\n */\nexport interface IEnvironmentPlaceholderProvider {\n  /**\n   * Return the region\n   */\n  region(): Promise<string>;\n\n  /**\n   * Return the account\n   */\n  accountId(): Promise<string>;\n\n  /**\n   * Return the partition\n   */\n  partition(): Promise<string>;\n}\n\n/**\n * A \"replace-all\" function that doesn't require us escaping a literal string to a regex\n */\nfunction replaceAll(s: string, search: string, replace: string) {\n  return s.split(search).join(replace);\n}\n"]}
@@ -1,16 +1,4 @@
1
1
  "use strict";
2
- var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
3
- if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
4
- if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
5
- return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
6
- };
7
- var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
8
- if (kind === "m") throw new TypeError("Private method is not writable");
9
- if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
10
- if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
11
- return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
12
- };
13
- var _CloudAssemblyError_time;
14
2
  Object.defineProperty(exports, "__esModule", { value: true });
15
3
  exports.CloudAssemblyError = void 0;
16
4
  const ASSEMBLY_ERROR_SYMBOL = Symbol.for('@aws-cdk/cx-api.CloudAssemblyError');
@@ -24,24 +12,23 @@ const ASSEMBLY_ERROR_SYMBOL = Symbol.for('@aws-cdk/cx-api.CloudAssemblyError');
24
12
  * @internal
25
13
  */
26
14
  class CloudAssemblyError extends Error {
15
+ #time;
27
16
  /**
28
17
  * The time the error was thrown.
29
18
  */
30
19
  get time() {
31
- return __classPrivateFieldGet(this, _CloudAssemblyError_time, "f");
20
+ return this.#time;
32
21
  }
33
22
  get type() {
34
23
  return 'assembly';
35
24
  }
36
25
  constructor(msg) {
37
26
  super(msg);
38
- _CloudAssemblyError_time.set(this, void 0);
39
27
  Object.setPrototypeOf(this, CloudAssemblyError.prototype);
40
28
  Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });
41
29
  this.name = new.target.name;
42
- __classPrivateFieldSet(this, _CloudAssemblyError_time, new Date().toISOString(), "f");
30
+ this.#time = new Date().toISOString();
43
31
  }
44
32
  }
45
33
  exports.CloudAssemblyError = CloudAssemblyError;
46
- _CloudAssemblyError_time = new WeakMap();
47
- //# sourceMappingURL=data:application/json;base64,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
34
+ //# sourceMappingURL=data:application/json;base64,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
@@ -0,0 +1,64 @@
1
+ /**
2
+ * A character-offset range into a template's text, as a half-open interval
3
+ * `[start, end)`. Framework-neutral on purpose: consumers map offsets to their
4
+ * own position model (for example the LSP via `TextDocument.positionAt`), which
5
+ * keeps this package free of editor types and of the UTF-16 column subtlety.
6
+ */
7
+ export interface OffsetRange {
8
+ /** Start offset, a 0-based character index, inclusive. */
9
+ readonly start: number;
10
+ /** End offset, a 0-based character index, exclusive. */
11
+ readonly end: number;
12
+ }
13
+ /**
14
+ * Resolves the character range of a resource's value block inside a synthesized
15
+ * CloudFormation template. The range covers the value `{ ... }` under
16
+ * `Resources/<logicalId>`, so `JSON.parse(text.slice(start, end))` returns the
17
+ * resource object.
18
+ *
19
+ * Returns `undefined` when the text is not valid JSON, or when there is no such
20
+ * resource.
21
+ */
22
+ export declare function resolveResourceRange(templateText: string, logicalId: string): OffsetRange | undefined;
23
+ /** A resource's block range plus the range of each of its top-level properties. */
24
+ export interface ResourceRanges {
25
+ /** The resource's value block `{ ... }` (value-only, like {@link resolveResourceRange}). */
26
+ readonly block: OffsetRange;
27
+ /** Each top-level property keyed by name, covering the whole `"Key": value` entry. */
28
+ readonly properties: Record<string, OffsetRange>;
29
+ }
30
+ /**
31
+ * Resolves, in a single parse, a resource's block range and the range of each
32
+ * of its top-level properties. Property ranges span `"Key": value` so a
33
+ * navigation lands on the named property.
34
+ *
35
+ * Returns `undefined` when the text is not valid JSON or there is no such resource.
36
+ */
37
+ export declare function resolveResourceRanges(templateText: string, logicalId: string): ResourceRanges | undefined;
38
+ /**
39
+ * A template parsed once into a queryable range index, so a caller resolving
40
+ * several resources (for example a hover over a multi-resource construct) pays
41
+ * the parse cost once instead of per resource.
42
+ */
43
+ export interface TemplateRanges {
44
+ /** The resource's value-block range, or `undefined` if there is no such resource. */
45
+ block(logicalId: string): OffsetRange | undefined;
46
+ /** The resource's block plus its top-level property ranges, or `undefined` if absent. */
47
+ resource(logicalId: string): ResourceRanges | undefined;
48
+ }
49
+ /**
50
+ * Parse a template once into a {@link TemplateRanges} index. Returns `undefined`
51
+ * when the text is not valid JSON. The single-resource {@link resolveResourceRange}
52
+ * and {@link resolveResourceRanges} are thin wrappers over this.
53
+ */
54
+ export declare function indexTemplateRanges(templateText: string): TemplateRanges | undefined;
55
+ /**
56
+ * The inverse of `resolveResourceRange`: given a character offset into a
57
+ * template's text, returns the logical id of the resource whose block contains
58
+ * that offset, for linking a position in the template back to its construct.
59
+ *
60
+ * Returns `undefined` when the text is not valid JSON, or when the offset is not
61
+ * inside any `Resources/<logicalId>` block (for example whitespace, the
62
+ * `Resources` key, or another top-level section).
63
+ */
64
+ export declare function resolveLogicalIdAtOffset(templateText: string, offset: number): string | undefined;