construct.js
1 "use strict"; 2 var _a, _b; 3 Object.defineProperty(exports, "__esModule", { value: true }); 4 exports.ConstructOrder = exports.Construct = exports.Node = void 0; 5 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti"); 6 const metadata_1 = require("./metadata"); 7 const dependency_1 = require("./private/dependency"); 8 const stack_trace_1 = require("./private/stack-trace"); 9 const uniqueid_1 = require("./private/uniqueid"); 10 const CONSTRUCT_NODE_PROPERTY_SYMBOL = Symbol.for('constructs.Construct.node'); 11 /** 12 * Represents the construct node in the scope tree. 13 * 14 * @stability stable 15 */ 16 class Node { 17 /** 18 * @stability stable 19 */ 20 constructor(host, scope, id) { 21 this.host = host; 22 this._locked = false; // if this is "true", addChild will fail 23 this._aspects = []; 24 this._children = {}; 25 this._context = {}; 26 this._metadata = new Array(); 27 this._dependencies = new Set(); 28 this.invokedAspects = []; 29 this._validations = new Array(); 30 id = id || ''; // if undefined, convert to empty string 31 this.id = sanitizeId(id); 32 this.scope = scope; 33 // We say that scope is required, but root scopes will bypass the type 34 // checks and actually pass in 'undefined'. 35 if (scope != null) { 36 if (id === '') { 37 throw new Error('Only root constructs may have an empty name'); 38 } 39 // Has side effect so must be very last thing in constructor 40 Node.of(scope).addChild(host, this.id); 41 } 42 else { 43 // This is a root construct. 44 this.id = id; 45 } 46 } 47 /** 48 * Returns the node associated with a construct. 49 * 50 * @param construct the construct. 51 * @stability stable 52 */ 53 static of(construct) { 54 const node = construct[CONSTRUCT_NODE_PROPERTY_SYMBOL]; 55 if (!node) { 56 throw new Error('construct does not have an associated node. All constructs must extend the "Construct" base class'); 57 } 58 return node; 59 } 60 /** 61 * The full, absolute path of this construct in the tree. 62 * 63 * Components are separated by '/'. 64 * 65 * @stability stable 66 */ 67 get path() { 68 const components = this.scopes.slice(1).map(c => Node.of(c).id); 69 return components.join(Node.PATH_SEP); 70 } 71 /** 72 * Returns an opaque tree-unique address for this construct. 73 * 74 * Addresses are 42 characters hexadecimal strings. They begin with "c8" 75 * followed by 40 lowercase hexadecimal characters (0-9a-f). 76 * 77 * Addresses are calculated using a SHA-1 of the components of the construct 78 * path. 79 * 80 * To enable refactorings of construct trees, constructs with the ID `Default` 81 * will be excluded from the calculation. In those cases constructs in the 82 * same tree may have the same addreess. 83 * 84 * @stability stable 85 * @example 86 * 87 * c83a2846e506bcc5f10682b564084bca2d275709ee 88 */ 89 get addr() { 90 if (!this._addr) { 91 this._addr = uniqueid_1.addressOf(this.scopes.map(c => Node.of(c).id)); 92 } 93 return this._addr; 94 } 95 /** 96 * (deprecated) A tree-global unique alphanumeric identifier for this construct. 97 * 98 * Includes 99 * all components of the tree. 100 * 101 * @deprecated please avoid using this property and use `addr` to form unique names. 102 * This algorithm uses MD5, which is not FIPS-complient and also excludes the 103 * identity of the root construct from the calculation. 104 */ 105 get uniqueId() { 106 const components = this.scopes.slice(1).map(c => Node.of(c).id); 107 return components.length > 0 ? uniqueid_1.makeLegacyUniqueId(components) : ''; 108 } 109 /** 110 * Return a direct child by id, or undefined. 111 * 112 * @param id Identifier of direct child. 113 * @returns the child if found, or undefined 114 * @stability stable 115 */ 116 tryFindChild(id) { 117 return this._children[sanitizeId(id)]; 118 } 119 /** 120 * Return a direct child by id. 121 * 122 * Throws an error if the child is not found. 123 * 124 * @param id Identifier of direct child. 125 * @returns Child with the given id. 126 * @stability stable 127 */ 128 findChild(id) { 129 const ret = this.tryFindChild(id); 130 if (!ret) { 131 throw new Error(`No child with id: '${id}'`); 132 } 133 return ret; 134 } 135 /** 136 * Returns the child construct that has the id `Default` or `Resource"`. 137 * 138 * This is usually the construct that provides the bulk of the underlying functionality. 139 * Useful for modifications of the underlying construct that are not available at the higher levels. 140 * Override the defaultChild property. 141 * 142 * This should only be used in the cases where the correct 143 * default child is not named 'Resource' or 'Default' as it 144 * should be. 145 * 146 * If you set this to undefined, the default behavior of finding 147 * the child named 'Resource' or 'Default' will be used. 148 * 149 * @returns a construct or undefined if there is no default child 150 * @stability stable 151 * @throws if there is more than one child 152 */ 153 get defaultChild() { 154 if (this._defaultChild !== undefined) { 155 return this._defaultChild; 156 } 157 const resourceChild = this.tryFindChild('Resource'); 158 const defaultChild = this.tryFindChild('Default'); 159 if (resourceChild && defaultChild) { 160 throw new Error(`Cannot determine default child for ${this.path}. There is both a child with id "Resource" and id "Default"`); 161 } 162 return defaultChild || resourceChild; 163 } 164 /** 165 * Returns the child construct that has the id `Default` or `Resource"`. 166 * 167 * This is usually the construct that provides the bulk of the underlying functionality. 168 * Useful for modifications of the underlying construct that are not available at the higher levels. 169 * Override the defaultChild property. 170 * 171 * This should only be used in the cases where the correct 172 * default child is not named 'Resource' or 'Default' as it 173 * should be. 174 * 175 * If you set this to undefined, the default behavior of finding 176 * the child named 'Resource' or 'Default' will be used. 177 * 178 * @returns a construct or undefined if there is no default child 179 * @stability stable 180 * @throws if there is more than one child 181 */ 182 set defaultChild(value) { 183 this._defaultChild = value; 184 } 185 /** 186 * All direct children of this construct. 187 * 188 * @stability stable 189 */ 190 get children() { 191 return Object.values(this._children); 192 } 193 /** 194 * Return this construct and all of its children in the given order. 195 * 196 * @stability stable 197 */ 198 findAll(order = ConstructOrder.PREORDER) { 199 const ret = new Array(); 200 visit(this.host); 201 return ret; 202 function visit(c) { 203 if (order === ConstructOrder.PREORDER) { 204 ret.push(c); 205 } 206 for (const child of Node.of(c).children) { 207 visit(child); 208 } 209 if (order === ConstructOrder.POSTORDER) { 210 ret.push(c); 211 } 212 } 213 } 214 /** 215 * This can be used to set contextual values. 216 * 217 * Context must be set before any children are added, since children may consult context info during construction. 218 * If the key already exists, it will be overridden. 219 * 220 * @param key The context key. 221 * @param value The context value. 222 * @stability stable 223 */ 224 setContext(key, value) { 225 if (this.children.length > 0) { 226 const names = this.children.map(c => Node.of(c).id); 227 throw new Error('Cannot set context after children have been added: ' + names.join(',')); 228 } 229 this._context[key] = value; 230 } 231 /** 232 * Retrieves a value from tree context. 233 * 234 * Context is usually initialized at the root, but can be overridden at any point in the tree. 235 * 236 * @param key The context key. 237 * @returns The context value or `undefined` if there is no context value for thie key. 238 * @stability stable 239 */ 240 tryGetContext(key) { 241 const value = this._context[key]; 242 if (value !== undefined) { 243 return value; 244 } 245 return this.scope && Node.of(this.scope).tryGetContext(key); 246 } 247 /** 248 * An immutable array of metadata objects associated with this construct. 249 * 250 * This can be used, for example, to implement support for deprecation notices, source mapping, etc. 251 * 252 * @stability stable 253 */ 254 get metadata() { 255 return [...this._metadata]; 256 } 257 /** 258 * Adds a metadata entry to this construct. 259 * 260 * Entries are arbitrary values and will also include a stack trace to allow tracing back to 261 * the code location for when the entry was added. It can be used, for example, to include source 262 * mapping in CloudFormation templates to improve diagnostics. 263 * 264 * @param type a string denoting the type of metadata. 265 * @param data the value of the metadata (can be a Token). 266 * @param fromFunction a function under which to restrict the metadata entry's stack trace (defaults to this.addMetadata). 267 * @stability stable 268 */ 269 addMetadata(type, data, fromFunction) { 270 if (data == null) { 271 return; 272 } 273 const trace = this.tryGetContext(metadata_1.ConstructMetadata.DISABLE_STACK_TRACE_IN_METADATA) 274 ? undefined 275 : stack_trace_1.captureStackTrace(fromFunction || this.addMetadata); 276 this._metadata.push({ type, data, trace }); 277 } 278 /** 279 * Adds a { "info": <message> } metadata entry to this construct. 280 * 281 * The toolkit will display the info message when apps are synthesized. 282 * 283 * @param message The info message. 284 * @stability stable 285 */ 286 addInfo(message) { 287 this.addMetadata(metadata_1.ConstructMetadata.INFO_METADATA_KEY, message); 288 } 289 /** 290 * Adds a { "warning": <message> } metadata entry to this construct. 291 * 292 * The toolkit will display the warning when an app is synthesized, or fail 293 * if run in --strict mode. 294 * 295 * @param message The warning message. 296 * @stability stable 297 */ 298 addWarning(message) { 299 this.addMetadata(metadata_1.ConstructMetadata.WARNING_METADATA_KEY, message); 300 } 301 /** 302 * Adds an { "error": <message> } metadata entry to this construct. 303 * 304 * The toolkit will fail synthesis when errors are reported. 305 * 306 * @param message The error message. 307 * @stability stable 308 */ 309 addError(message) { 310 this.addMetadata(metadata_1.ConstructMetadata.ERROR_METADATA_KEY, message); 311 } 312 /** 313 * Applies the aspect to this Constructs node. 314 * 315 * @stability stable 316 */ 317 applyAspect(aspect) { 318 this._aspects.push(aspect); 319 return; 320 } 321 /** 322 * All parent scopes of this construct. 323 * 324 * @returns a list of parent scopes. The last element in the list will always 325 * be the current construct and the first element will be the root of the 326 * tree. 327 * @stability stable 328 */ 329 get scopes() { 330 const ret = new Array(); 331 let curr = this.host; 332 while (curr) { 333 ret.unshift(curr); 334 curr = Node.of(curr).scope; 335 } 336 return ret; 337 } 338 /** 339 * Returns the root of the construct tree. 340 * 341 * @returns The root of the construct tree. 342 * @stability stable 343 */ 344 get root() { 345 return this.scopes[0]; 346 } 347 /** 348 * Returns true if this construct or the scopes in which it is defined are locked. 349 * 350 * @stability stable 351 */ 352 get locked() { 353 if (this._locked) { 354 return true; 355 } 356 if (this.scope && Node.of(this.scope).locked) { 357 return true; 358 } 359 return false; 360 } 361 /** 362 * Add an ordering dependency on another Construct. 363 * 364 * All constructs in the dependency's scope will be deployed before any 365 * construct in this construct's scope. 366 * 367 * @stability stable 368 */ 369 addDependency(...dependencies) { 370 for (const dependency of dependencies) { 371 this._dependencies.add(dependency); 372 } 373 } 374 /** 375 * Return all dependencies registered on this node or any of its children. 376 * 377 * @stability stable 378 */ 379 get dependencies() { 380 const found = new Map(); // Deduplication map 381 const ret = new Array(); 382 for (const source of this.findAll()) { 383 for (const dependable of Node.of(source)._dependencies) { 384 for (const target of dependency_1.DependableTrait.get(dependable).dependencyRoots) { 385 let foundTargets = found.get(source); 386 if (!foundTargets) { 387 found.set(source, foundTargets = new Set()); 388 } 389 if (!foundTargets.has(target)) { 390 ret.push({ source, target }); 391 foundTargets.add(target); 392 } 393 } 394 } 395 } 396 return ret; 397 } 398 /** 399 * (experimental) Remove the child with the given name, if present. 400 * 401 * @returns Whether a child with the given name was deleted. 402 * @experimental 403 */ 404 tryRemoveChild(childName) { 405 if (!(childName in this._children)) { 406 return false; 407 } 408 delete this._children[childName]; 409 return true; 410 } 411 /** 412 * Adds a validation to this construct. 413 * 414 * When `node.validate()` is called, the `validate()` method will be called on 415 * all validations and all errors will be returned. 416 * 417 * @stability stable 418 */ 419 addValidation(validation) { 420 this._validations.push(validation); 421 } 422 /** 423 * Synthesizes a CloudAssembly from a construct tree. 424 * 425 * @param options Synthesis options. 426 * @stability stable 427 */ 428 synthesize(options) { 429 // the three holy phases of synthesis: prepare, validate and synthesize 430 // prepare 431 this.prepare(); 432 // validate 433 const validate = options.skipValidation === undefined ? true : !options.skipValidation; 434 if (validate) { 435 const errors = this.validate(); 436 if (errors.length > 0) { 437 const errorList = errors.map(e => `[${Node.of(e.source).path}] ${e.message}`).join('\n '); 438 throw new Error(`Validation failed with the following errors:\n ${errorList}`); 439 } 440 } 441 // synthesize (leaves first) 442 for (const construct of this.findAll(ConstructOrder.POSTORDER)) { 443 const node = Node.of(construct); 444 try { 445 node._lock(); 446 const ctx = { 447 ...options.sessionContext, 448 outdir: options.outdir, 449 }; 450 construct.onSynthesize(ctx); // "as any" is needed because we want to keep "synthesize" protected 451 } 452 finally { 453 node._unlock(); 454 } 455 } 456 } 457 /** 458 * Invokes "prepare" on all constructs (depth-first, post-order) in the tree under `node`. 459 * 460 * @stability stable 461 */ 462 prepare() { 463 // Aspects are applied root to leaf 464 for (const construct of this.findAll(ConstructOrder.PREORDER)) { 465 Node.of(construct).invokeAspects(); 466 } 467 // since constructs can be added to the tree during invokeAspects, call findAll() to recreate the list. 468 // use PREORDER.reverse() for backward compatability 469 for (const construct of this.findAll(ConstructOrder.PREORDER).reverse()) { 470 const cn = construct; 471 if ('onPrepare' in cn) { 472 if (typeof (cn.onPrepare) !== 'function') { 473 throw new Error('expecting "onPrepare" to be a function'); 474 } 475 cn.onPrepare(); 476 } 477 } 478 } 479 /** 480 * Validates tree (depth-first, pre-order) and returns the list of all errors. 481 * 482 * An empty list indicates that there are no errors. 483 * 484 * @stability stable 485 */ 486 validate() { 487 let errors = new Array(); 488 for (const child of this.children) { 489 errors = errors.concat(Node.of(child).validate()); 490 } 491 const localErrors = this.host.onValidate(); // "as any" is needed because we want to keep "validate" protected 492 // invoke validations 493 for (const v of this._validations) { 494 localErrors.push(...v.validate()); 495 } 496 return errors.concat(localErrors.map(msg => ({ source: this.host, message: msg }))); 497 } 498 /** 499 * Locks this construct from allowing more children to be added. After this 500 * call, no more children can be added to this construct or to any children. 501 * @internal 502 */ 503 _lock() { 504 this._locked = true; 505 } 506 /** 507 * Unlocks this costruct and allows mutations (adding children). 508 * @internal 509 */ 510 _unlock() { 511 this._locked = false; 512 } 513 /** 514 * Adds a child construct to this node. 515 * 516 * @param child The child construct 517 * @param childName The type name of the child construct. 518 * @returns The resolved path part name of the child 519 */ 520 addChild(child, childName) { 521 if (this.locked) { 522 // special error if root is locked 523 if (!this.path) { 524 throw new Error('Cannot add children during synthesis'); 525 } 526 throw new Error(`Cannot add children to "${this.path}" during synthesis`); 527 } 528 if (childName in this._children) { 529 const name = this.id || ''; 530 const typeName = this.host.constructor.name; 531 throw new Error(`There is already a Construct with name '${childName}' in ${typeName}${name.length > 0 ? ' [' + name + ']' : ''}`); 532 } 533 this._children[childName] = child; 534 } 535 /** 536 * Triggers each aspect to invoke visit 537 */ 538 invokeAspects() { 539 const descendants = this.findAll(); 540 for (const aspect of this._aspects) { 541 if (this.invokedAspects.includes(aspect)) { 542 continue; 543 } 544 descendants.forEach(member => aspect.visit(member)); 545 this.invokedAspects.push(aspect); 546 } 547 } 548 } 549 exports.Node = Node; 550 _a = JSII_RTTI_SYMBOL_1; 551 Node[_a] = { fqn: "constructs.Node", version: "3.3.161" }; 552 /** 553 * Separator used to delimit construct path components. 554 * 555 * @stability stable 556 */ 557 Node.PATH_SEP = '/'; 558 /** 559 * Represents the building block of the construct graph. 560 * 561 * All constructs besides the root construct must be created within the scope of 562 * another construct. 563 * 564 * @stability stable 565 */ 566 class Construct { 567 /** 568 * Creates a new construct node. 569 * 570 * @param scope The scope in which to define this construct. 571 * @param id The scoped construct ID. 572 * @param options Options. 573 * @stability stable 574 */ 575 constructor(scope, id, options = {}) { 576 var _c; 577 // attach the construct to the construct tree by creating a node 578 const nodeFactory = (_c = options.nodeFactory) !== null && _c !== void 0 ? _c : { createNode: (host, nodeScope, nodeId) => new Node(host, nodeScope, nodeId) }; 579 Object.defineProperty(this, CONSTRUCT_NODE_PROPERTY_SYMBOL, { 580 value: nodeFactory.createNode(this, scope, id), 581 enumerable: false, 582 configurable: false, 583 }); 584 // implement IDependable privately 585 dependency_1.DependableTrait.implement(this, { 586 dependencyRoots: [this], 587 }); 588 } 589 /** 590 * Returns a string representation of this construct. 591 * 592 * @stability stable 593 */ 594 toString() { 595 return Node.of(this).path || '<root>'; 596 } 597 /** 598 * (deprecated) Validate the current construct. 599 * 600 * This method can be implemented by derived constructs in order to perform 601 * validation logic. It is called on all constructs before synthesis. 602 * 603 * @returns An array of validation error messages, or an empty array if there the construct is valid. 604 * @deprecated use `Node.addValidation()` to subscribe validation functions on this construct 605 * instead of overriding this method. 606 */ 607 onValidate() { 608 return []; 609 } 610 /** 611 * Perform final modifications before synthesis. 612 * 613 * This method can be implemented by derived constructs in order to perform 614 * final changes before synthesis. prepare() will be called after child 615 * constructs have been prepared. 616 * 617 * This is an advanced framework feature. Only use this if you 618 * understand the implications. 619 * 620 * @stability stable 621 */ 622 onPrepare() { 623 return; 624 } 625 /** 626 * Allows this construct to emit artifacts into the cloud assembly during synthesis. 627 * 628 * This method is usually implemented by framework-level constructs such as `Stack` and `Asset` 629 * as they participate in synthesizing the cloud assembly. 630 * 631 * @param session The synthesis session. 632 * @stability stable 633 */ 634 onSynthesize(session) { 635 ignore(session); 636 } 637 } 638 exports.Construct = Construct; 639 _b = JSII_RTTI_SYMBOL_1; 640 Construct[_b] = { fqn: "constructs.Construct", version: "3.3.161" }; 641 /** 642 * In what order to return constructs. 643 * 644 * @stability stable 645 */ 646 var ConstructOrder; 647 (function (ConstructOrder) { 648 ConstructOrder[ConstructOrder["PREORDER"] = 0] = "PREORDER"; 649 ConstructOrder[ConstructOrder["POSTORDER"] = 1] = "POSTORDER"; 650 })(ConstructOrder = exports.ConstructOrder || (exports.ConstructOrder = {})); 651 function ignore(_x) { 652 return; 653 } 654 // Import this _after_ everything else to help node work the classes out in the correct order... 655 const PATH_SEP_REGEX = new RegExp(`${Node.PATH_SEP}`, 'g'); 656 /** 657 * Return a sanitized version of an arbitrary string, so it can be used as an ID 658 */ 659 function sanitizeId(id) { 660 // Escape path seps as double dashes 661 return id.replace(PATH_SEP_REGEX, '--'); 662 } 663 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"construct.js","sourceRoot":"","sources":["../src/construct.ts"],"names":[],"mappings":";;;;;AACA,yCAA8D;AAC9D,qDAAuD;AACvD,uDAA0D;AAC1D,iDAAmE;AAEnE,MAAM,8BAA8B,GAAG,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAC;;;;;;AAM/E,MAAa,IAAI;;;;IA+Bf,YAA6B,IAAe,EAAE,KAAiB,EAAE,EAAU;QAA9C,SAAI,GAAJ,IAAI,CAAW;QAXpC,YAAO,GAAG,KAAK,CAAC,CAAC,wCAAwC;QAChD,aAAQ,GAAc,EAAE,CAAC;QACzB,cAAS,GAAiC,EAAG,CAAC;QAC9C,aAAQ,GAA2B,EAAG,CAAC;QACvC,cAAS,GAAG,IAAI,KAAK,EAAiB,CAAC;QACvC,kBAAa,GAAG,IAAI,GAAG,EAAc,CAAC;QACtC,mBAAc,GAAc,EAAE,CAAC;QAE/B,iBAAY,GAAG,IAAI,KAAK,EAAe,CAAC;QAIvD,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,wCAAwC;QAEvD,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,sEAAsE;QACtE,2CAA2C;QAC3C,IAAI,KAAK,IAAI,IAAI,EAAE;YACjB,IAAI,EAAE,KAAK,EAAE,EAAE;gBACb,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;aAChE;YAED,4DAA4D;YAC5D,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;SACxC;aAAM;YACL,4BAA4B;YAC5B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;SACd;IACH,CAAC;;;;;;;IA7CM,MAAM,CAAC,EAAE,CAAC,SAAqB;QACpC,MAAM,IAAI,GAAI,SAAiB,CAAC,8BAA8B,CAAS,CAAC;QACxE,IAAI,CAAC,IAAI,EAAE;YACT,MAAM,IAAI,KAAK,CAAC,mGAAmG,CAAC,CAAC;SACtH;QAED,OAAO,IAAI,CAAC;IACd,CAAC;;;;;;;;IAyCD,IAAW,IAAI;QACb,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAChE,OAAO,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACxC,CAAC;;;;;;;;;;;;;;;;;;;IAGD,IAAW,IAAI;QACb,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACf,IAAI,CAAC,KAAK,GAAG,oBAAS,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;SAC7D;QAED,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;;;;;;;;;;;IAGD,IAAW,QAAQ;QACjB,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAChE,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,6BAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACrE,CAAC;;;;;;;;IAGM,YAAY,CAAC,EAAU;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;IACxC,CAAC;;;;;;;;;;IAGM,SAAS,CAAC,EAAU;QACzB,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,GAAG,EAAE;YACR,MAAM,IAAI,KAAK,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAC;SAC9C;QACD,OAAO,GAAG,CAAC;IACb,CAAC;;;;;;;;;;;;;;;;;;;IAGD,IAAW,YAAY;QACrB,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE;YACpC,OAAO,IAAI,CAAC,aAAa,CAAC;SAC3B;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QACpD,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAClD,IAAI,aAAa,IAAI,YAAY,EAAE;YACjC,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,CAAC,IAAI,6DAA6D,CAAC,CAAC;SAC/H;QAED,OAAO,YAAY,IAAI,aAAa,CAAC;IACvC,CAAC;;;;;;;;;;;;;;;;;;;IAGD,IAAW,YAAY,CAAC,KAA6B;QACnD,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;;;;;;IAGD,IAAW,QAAQ;QACjB,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;;;;;;IAGM,OAAO,CAAC,QAAwB,cAAc,CAAC,QAAQ;QAC5D,MAAM,GAAG,GAAG,IAAI,KAAK,EAAc,CAAC;QACpC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,OAAO,GAAG,CAAC;QAEX,SAAS,KAAK,CAAC,CAAa;YAC1B,IAAI,KAAK,KAAK,cAAc,CAAC,QAAQ,EAAE;gBACrC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb;YAED,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;gBACvC,KAAK,CAAC,KAAK,CAAC,CAAC;aACd;YAED,IAAI,KAAK,KAAK,cAAc,CAAC,SAAS,EAAE;gBACtC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb;QACH,CAAC;IACH,CAAC;;;;;;;;;;;IAGM,UAAU,CAAC,GAAW,EAAE,KAAU;QACvC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACpD,MAAM,IAAI,KAAK,CAAC,qDAAqD,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;SAC1F;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC7B,CAAC;;;;;;;;;;IAGM,aAAa,CAAC,GAAW;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,KAAK,KAAK,SAAS,EAAE;YAAE,OAAO,KAAK,CAAC;SAAE;QAE1C,OAAO,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAC9D,CAAC;;;;;;;;IAGD,IAAW,QAAQ;QACjB,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC;;;;;;;;;;;;;IAGM,WAAW,CAAC,IAAY,EAAE,IAAS,EAAE,YAAkB;QAC5D,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,OAAO;SACR;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,4BAAiB,CAAC,+BAA+B,CAAC;YACjF,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,+BAAiB,CAAC,YAAY,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC;QAExD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7C,CAAC;;;;;;;;;IAGM,OAAO,CAAC,OAAe;QAC5B,IAAI,CAAC,WAAW,CAAC,4BAAiB,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;;;;;;;;;;IAGM,UAAU,CAAC,OAAe;QAC/B,IAAI,CAAC,WAAW,CAAC,4BAAiB,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;;;;;;;;;IAGM,QAAQ,CAAC,OAAe;QAC7B,IAAI,CAAC,WAAW,CAAC,4BAAiB,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;;;;;;IAGM,WAAW,CAAC,MAAe;QAChC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO;IACT,CAAC;;;;;;;;;IAGD,IAAW,MAAM;QACf,MAAM,GAAG,GAAG,IAAI,KAAK,EAAc,CAAC;QAEpC,IAAI,IAAI,GAA2B,IAAI,CAAC,IAAI,CAAC;QAC7C,OAAO,IAAI,EAAE;YACX,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAClB,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC;SAC5B;QAED,OAAO,GAAG,CAAC;IACb,CAAC;;;;;;;IAGD,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;;;;;;IAGD,IAAW,MAAM;QACf,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,OAAO,IAAI,CAAC;SACb;QAED,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE;YAC5C,OAAO,IAAI,CAAC;SACb;QAED,OAAO,KAAK,CAAC;IACf,CAAC;;;;;;;;;IAGM,aAAa,CAAC,GAAG,YAA0B;QAChD,KAAK,MAAM,UAAU,IAAI,YAAY,EAAE;YACrC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;SACpC;IACH,CAAC;;;;;;IAGD,IAAW,YAAY;QACrB,MAAM,KAAK,GAAG,IAAI,GAAG,EAA+B,CAAC,CAAC,oBAAoB;QAC1E,MAAM,GAAG,GAAG,IAAI,KAAK,EAAc,CAAC;QAEpC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE;YACnC,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE;gBACtD,KAAK,MAAM,MAAM,IAAI,4BAAe,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,eAAe,EAAE;oBACpE,IAAI,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBACrC,IAAI,CAAC,YAAY,EAAE;wBAAE,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,EAAE,CAAC,CAAC;qBAAE;oBAEnE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;wBAC7B,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;wBAC7B,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;qBAC1B;iBACF;aACF;SACF;QAED,OAAO,GAAG,CAAC;IACb,CAAC;;;;;;;IAGM,cAAc,CAAC,SAAiB;QACrC,IAAI,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,EAAE;YAAE,OAAO,KAAK,CAAC;SAAE;QACrD,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;;;;;;;;;IAGM,aAAa,CAAC,UAAuB;QAC1C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACrC,CAAC;;;;;;;IAGM,UAAU,CAAC,OAAyB;QACzC,uEAAuE;QAEvE,UAAU;QACV,IAAI,CAAC,OAAO,EAAE,CAAC;QAEf,WAAW;QACX,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;QACvF,IAAI,QAAQ,EAAE;YACZ,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC/B,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;gBACrB,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAC3F,MAAM,IAAI,KAAK,CAAC,mDAAmD,SAAS,EAAE,CAAC,CAAC;aACjF;SACF;QAED,4BAA4B;QAC5B,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE;YAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;YAChC,IAAI;gBACF,IAAI,CAAC,KAAK,EAAE,CAAC;gBACb,MAAM,GAAG,GAAG;oBACV,GAAG,OAAO,CAAC,cAAc;oBACzB,MAAM,EAAE,OAAO,CAAC,MAAM;iBACvB,CAAC;gBACD,SAAiB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,oEAAoE;aAC3G;oBAAS;gBACR,IAAI,CAAC,OAAO,EAAE,CAAC;aAChB;SACF;IACH,CAAC;;;;;;IAGM,OAAO;QACZ,mCAAmC;QACnC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;YAC7D,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,aAAa,EAAE,CAAC;SACpC;QAED,uGAAuG;QACvG,oDAAoD;QACpD,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,EAAE;YACvE,MAAM,EAAE,GAAG,SAAgB,CAAC;YAC5B,IAAI,WAAW,IAAI,EAAE,EAAE;gBACrB,IAAI,OAAM,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,UAAU,EAAE;oBAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;iBAAE;gBACvG,EAAE,CAAC,SAAS,EAAE,CAAC;aAChB;SACF;IACH,CAAC;;;;;;;;IAGM,QAAQ;QACb,IAAI,MAAM,GAAG,IAAI,KAAK,EAAmB,CAAC;QAE1C,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;SACnD;QAED,MAAM,WAAW,GAAc,IAAI,CAAC,IAAY,CAAC,UAAU,EAAE,CAAC,CAAC,kEAAkE;QAEjI,qBAAqB;QACrB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE;YACjC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;SACnC;QAED,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACtF,CAAC;IAED;;;;OAIG;IACK,KAAK;QACX,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;OAGG;IACK,OAAO;QACb,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACK,QAAQ,CAAC,KAAgB,EAAE,SAAiB;QAClD,IAAI,IAAI,CAAC,MAAM,EAAE;YAEf,kCAAkC;YAClC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;gBACd,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;aACzD;YAED,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,CAAC,IAAI,oBAAoB,CAAC,CAAC;SAC3E;QAED,IAAI,SAAS,IAAI,IAAI,CAAC,SAAS,EAAE;YAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;YAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,2CAA2C,SAAS,QAAQ,QAAQ,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SACpI;QAED,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;IACpC,CAAC;IAED;;OAEG;IACK,aAAa;QACnB,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QACnC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,QAAQ,EAAE;YAClC,IAAI,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;gBACxC,SAAS;aACV;YACD,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;YACpD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClC;IACH,CAAC;;AAlYH,oBAmYC;;;;;;;;AAjYwB,aAAQ,GAAG,GAAG,CAAC;;;;;;;;;AAoYxC,MAAa,SAAS;;;;;;;;;IAEpB,YAAY,KAAgB,EAAE,EAAU,EAAE,UAA4B,EAAG;;QACvE,gEAAgE;QAChE,MAAM,WAAW,SAAG,OAAO,CAAC,WAAW,mCAAI,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,CAAC;QAC1H,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,8BAA8B,EAAE;YAC1D,KAAK,EAAE,WAAW,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC9C,UAAU,EAAE,KAAK;YACjB,YAAY,EAAE,KAAK;SACpB,CAAC,CAAC;QAEH,kCAAkC;QAClC,4BAAe,CAAC,SAAS,CAAC,IAAI,EAAE;YAC9B,eAAe,EAAE,CAAC,IAAI,CAAC;SACxB,CAAC,CAAC;IACL,CAAC;;;;;;IAGM,QAAQ;QACb,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,QAAQ,CAAC;IACxC,CAAC;;;;;;;;;;;IAGS,UAAU;QAClB,OAAO,EAAE,CAAC;IACZ,CAAC;;;;;;;;;;;;;IAGS,SAAS;QACjB,OAAO;IACT,CAAC;;;;;;;;;;IAGS,YAAY,CAAC,OAA0B;QAC/C,MAAM,CAAC,OAAO,CAAC,CAAC;IAClB,CAAC;;AAnCH,8BAoCC;;;;;;;;AAkBD,IAAY,cAMX;AAND,WAAY,cAAc;IAExB,2DAAQ,CAAA;IAGR,6DAAS,CAAA;AACX,CAAC,EANW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAMzB;AAkCD,SAAS,MAAM,CAAC,EAAO;IACrB,OAAO;AACT,CAAC;AAED,gGAAgG;AAChG,MAAM,cAAc,GAAG,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,EAAE,GAAG,CAAC,CAAC;AAE3D;;GAEG;AACH,SAAS,UAAU,CAAC,EAAU;IAC5B,oCAAoC;IACpC,OAAO,EAAE,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["import { IAspect } from './aspect';\nimport { ConstructMetadata, MetadataEntry } from './metadata';\nimport { DependableTrait } from './private/dependency';\nimport { captureStackTrace } from './private/stack-trace';\nimport { makeLegacyUniqueId, addressOf } from './private/uniqueid';\n\nconst CONSTRUCT_NODE_PROPERTY_SYMBOL = Symbol.for('constructs.Construct.node');\n\n                                  \nexport interface IConstruct { }\n\n                                                           \nexport class Node {\n                                                                     \n  public static readonly PATH_SEP = '/';\n\n                                                                                                  \n  public static of(construct: IConstruct): Node {\n    const node = (construct as any)[CONSTRUCT_NODE_PROPERTY_SYMBOL] as Node;\n    if (!node) {\n      throw new Error('construct does not have an associated node. All constructs must extend the \"Construct\" base class');\n    }\n\n    return node;\n  }\n\n                                                                                                                                                  \n  public readonly scope?: IConstruct;\n\n                                                                                                                                                                         \n  public readonly id: string;\n\n  private _locked = false; // if this is \"true\", addChild will fail\n  private readonly _aspects: IAspect[] = [];\n  private readonly _children: { [id: string]: IConstruct } = { };\n  private readonly _context: { [key: string]: any } = { };\n  private readonly _metadata = new Array<MetadataEntry>();\n  private readonly _dependencies = new Set<IConstruct>();\n  private readonly invokedAspects: IAspect[] = [];\n  private _defaultChild: IConstruct | undefined;\n  private readonly _validations = new Array<IValidation>();\n  private _addr?: string; // cache\n\n  constructor(private readonly host: Construct, scope: IConstruct, id: string) {\n    id = id || ''; // if undefined, convert to empty string\n\n    this.id = sanitizeId(id);\n    this.scope = scope;\n\n    // We say that scope is required, but root scopes will bypass the type\n    // checks and actually pass in 'undefined'.\n    if (scope != null) {\n      if (id === '') {\n        throw new Error('Only root constructs may have an empty name');\n      }\n\n      // Has side effect so must be very last thing in constructor\n      Node.of(scope).addChild(host, this.id);\n    } else {\n      // This is a root construct.\n      this.id = id;\n    }\n  }\n\n                                                                                                                  \n  public get path(): string {\n    const components = this.scopes.slice(1).map(c => Node.of(c).id);\n    return components.join(Node.PATH_SEP);\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \n  public get addr(): string {\n    if (!this._addr) {\n      this._addr = addressOf(this.scopes.map(c => Node.of(c).id));\n    }\n\n    return this._addr;\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                 \n  public get uniqueId(): string {\n    const components = this.scopes.slice(1).map(c => Node.of(c).id);\n    return components.length > 0 ? makeLegacyUniqueId(components) : '';\n  }\n\n                                                                                                                                                        \n  public tryFindChild(id: string): IConstruct | undefined {\n    return this._children[sanitizeId(id)];\n  }\n\n                                                                                                                                                                                       \n  public findChild(id: string): IConstruct {\n    const ret = this.tryFindChild(id);\n    if (!ret) {\n      throw new Error(`No child with id: '${id}'`);\n    }\n    return ret;\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                              \n  public get defaultChild(): IConstruct | undefined {\n    if (this._defaultChild !== undefined) {\n      return this._defaultChild;\n    }\n\n    const resourceChild = this.tryFindChild('Resource');\n    const defaultChild = this.tryFindChild('Default');\n    if (resourceChild && defaultChild) {\n      throw new Error(`Cannot determine default child for ${this.path}. There is both a child with id \"Resource\" and id \"Default\"`);\n    }\n\n    return defaultChild || resourceChild;\n  }\n\n                                                                                                                                                                                                                                                                                                                                       \n  public set defaultChild(value: IConstruct | undefined) {\n    this._defaultChild = value;\n  }\n\n                                                       \n  public get children() {\n    return Object.values(this._children);\n  }\n\n                                                                                 \n  public findAll(order: ConstructOrder = ConstructOrder.PREORDER): IConstruct[] {\n    const ret = new Array<IConstruct>();\n    visit(this.host);\n    return ret;\n\n    function visit(c: IConstruct) {\n      if (order === ConstructOrder.PREORDER) {\n        ret.push(c);\n      }\n\n      for (const child of Node.of(c).children) {\n        visit(child);\n      }\n\n      if (order === ConstructOrder.POSTORDER) {\n        ret.push(c);\n      }\n    }\n  }\n\n                                                                                                                                                                                                                                                                                                           \n  public setContext(key: string, value: any) {\n    if (this.children.length > 0) {\n      const names = this.children.map(c => Node.of(c).id);\n      throw new Error('Cannot set context after children have been added: ' + names.join(','));\n    }\n    this._context[key] = value;\n  }\n\n                                                                                                                                                                                                                                                                                          \n  public tryGetContext(key: string): any {\n    const value = this._context[key];\n    if (value !== undefined) { return value; }\n\n    return this.scope && Node.of(this.scope).tryGetContext(key);\n  }\n\n                                                                                                                                                                                              \n  public get metadata() {\n    return [...this._metadata];\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \n  public addMetadata(type: string, data: any, fromFunction?: any): void {\n    if (data == null) {\n      return;\n    }\n\n    const trace = this.tryGetContext(ConstructMetadata.DISABLE_STACK_TRACE_IN_METADATA)\n      ? undefined\n      : captureStackTrace(fromFunction || this.addMetadata);\n\n    this._metadata.push({ type, data, trace });\n  }\n\n                                                                                                                                                                                               \n  public addInfo(message: string): void {\n    this.addMetadata(ConstructMetadata.INFO_METADATA_KEY, message);\n  }\n\n                                                                                                                                                                                                                                       \n  public addWarning(message: string): void {\n    this.addMetadata(ConstructMetadata.WARNING_METADATA_KEY, message);\n  }\n\n                                                                                                                                                                                       \n  public addError(message: string) {\n    this.addMetadata(ConstructMetadata.ERROR_METADATA_KEY, message);\n  }\n\n                                                           \n  public applyAspect(aspect: IAspect): void {\n    this._aspects.push(aspect);\n    return;\n  }\n\n                                                                                                                                                                                                                                 \n  public get scopes(): IConstruct[] {\n    const ret = new Array<IConstruct>();\n\n    let curr: IConstruct | undefined = this.host;\n    while (curr) {\n      ret.unshift(curr);\n      curr = Node.of(curr).scope;\n    }\n\n    return ret;\n  }\n\n                                                                                                      \n  public get root() {\n    return this.scopes[0];\n  }\n\n                                                                                                     \n  public get locked() {\n    if (this._locked) {\n      return true;\n    }\n\n    if (this.scope && Node.of(this.scope).locked) {\n      return true;\n    }\n\n    return false;\n  }\n\n                                                                                                                                                                                          \n  public addDependency(...dependencies: IConstruct[]) {\n    for (const dependency of dependencies) {\n      this._dependencies.add(dependency);\n    }\n  }\n\n                                                                                       \n  public get dependencies(): Dependency[] {\n    const found = new Map<IConstruct, Set<IConstruct>>(); // Deduplication map\n    const ret = new Array<Dependency>();\n\n    for (const source of this.findAll()) {\n      for (const dependable of Node.of(source)._dependencies) {\n        for (const target of DependableTrait.get(dependable).dependencyRoots) {\n          let foundTargets = found.get(source);\n          if (!foundTargets) { found.set(source, foundTargets = new Set()); }\n\n          if (!foundTargets.has(target)) {\n            ret.push({ source, target });\n            foundTargets.add(target);\n          }\n        }\n      }\n    }\n\n    return ret;\n  }\n\n                                                                                                                                                         \n  public tryRemoveChild(childName: string): boolean {\n    if (!(childName in this._children)) { return false; }\n    delete this._children[childName];\n    return true;\n  }\n\n                                                                                                                                                                                                                             \n  public addValidation(validation: IValidation) {\n    this._validations.push(validation);\n  }\n\n                                                                                                          \n  public synthesize(options: SynthesisOptions): void {\n    // the three holy phases of synthesis: prepare, validate and synthesize\n\n    // prepare\n    this.prepare();\n\n    // validate\n    const validate = options.skipValidation === undefined ? true : !options.skipValidation;\n    if (validate) {\n      const errors = this.validate();\n      if (errors.length > 0) {\n        const errorList = errors.map(e => `[${Node.of(e.source).path}] ${e.message}`).join('\\n  ');\n        throw new Error(`Validation failed with the following errors:\\n  ${errorList}`);\n      }\n    }\n\n    // synthesize (leaves first)\n    for (const construct of this.findAll(ConstructOrder.POSTORDER)) {\n      const node = Node.of(construct);\n      try {\n        node._lock();\n        const ctx = {\n          ...options.sessionContext,\n          outdir: options.outdir,\n        };\n        (construct as any).onSynthesize(ctx); // \"as any\" is needed because we want to keep \"synthesize\" protected\n      } finally {\n        node._unlock();\n      }\n    }\n  }\n\n                                                                                                        \n  public prepare() {\n    // Aspects are applied root to leaf\n    for (const construct of this.findAll(ConstructOrder.PREORDER)) {\n      Node.of(construct).invokeAspects();\n    }\n\n    // since constructs can be added to the tree during invokeAspects, call findAll() to recreate the list.\n    // use PREORDER.reverse() for backward compatability\n    for (const construct of this.findAll(ConstructOrder.PREORDER).reverse()) {\n      const cn = construct as any;\n      if ('onPrepare' in cn) {\n        if (typeof(cn.onPrepare) !== 'function') { throw new Error('expecting \"onPrepare\" to be a function'); }\n        cn.onPrepare();\n      }\n    }\n  }\n\n                                                                                                                                                   \n  public validate() {\n    let errors = new Array<ValidationError>();\n\n    for (const child of this.children) {\n      errors = errors.concat(Node.of(child).validate());\n    }\n\n    const localErrors: string[] = (this.host as any).onValidate(); // \"as any\" is needed because we want to keep \"validate\" protected\n\n    // invoke validations\n    for (const v of this._validations) {\n      localErrors.push(...v.validate());\n    }\n\n    return errors.concat(localErrors.map(msg => ({ source: this.host, message: msg })));\n  }\n\n  /**\n   * Locks this construct from allowing more children to be added. After this\n   * call, no more children can be added to this construct or to any children.\n   * @internal\n   */\n  private _lock() {\n    this._locked = true;\n  }\n\n  /**\n   * Unlocks this costruct and allows mutations (adding children).\n   * @internal\n   */\n  private _unlock() {\n    this._locked = false;\n  }\n\n  /**\n   * Adds a child construct to this node.\n   *\n   * @param child The child construct\n   * @param childName The type name of the child construct.\n   * @returns The resolved path part name of the child\n   */\n  private addChild(child: Construct, childName: string) {\n    if (this.locked) {\n\n      // special error if root is locked\n      if (!this.path) {\n        throw new Error('Cannot add children during synthesis');\n      }\n\n      throw new Error(`Cannot add children to \"${this.path}\" during synthesis`);\n    }\n\n    if (childName in this._children) {\n      const name = this.id || '';\n      const typeName = this.host.constructor.name;\n      throw new Error(`There is already a Construct with name '${childName}' in ${typeName}${name.length > 0 ? ' [' + name + ']' : ''}`);\n    }\n\n    this._children[childName] = child;\n  }\n\n  /**\n   * Triggers each aspect to invoke visit\n   */\n  private invokeAspects(): void {\n    const descendants = this.findAll();\n    for (const aspect of this._aspects) {\n      if (this.invokedAspects.includes(aspect)) {\n        continue;\n      }\n      descendants.forEach(member => aspect.visit(member));\n      this.invokedAspects.push(aspect);\n    }\n  }\n}\n\n                                                                                                                                                                          \nexport class Construct implements IConstruct {\n                                                                                                                                                                                                                                                                                                                         \n  constructor(scope: Construct, id: string, options: ConstructOptions = { }) {\n    // attach the construct to the construct tree by creating a node\n    const nodeFactory = options.nodeFactory ?? { createNode: (host, nodeScope, nodeId) => new Node(host, nodeScope, nodeId) };\n    Object.defineProperty(this, CONSTRUCT_NODE_PROPERTY_SYMBOL, {\n      value: nodeFactory.createNode(this, scope, id),\n      enumerable: false,\n      configurable: false,\n    });\n\n    // implement IDependable privately\n    DependableTrait.implement(this, {\n      dependencyRoots: [this],\n    });\n  }\n\n                                                                   \n  public toString() {\n    return Node.of(this).path || '<root>';\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                \n  protected onValidate(): string[] {\n    return [];\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                      \n  protected onPrepare(): void {\n    return;\n  }\n\n                                                                                                                                                                                                                                                                                                                      \n  protected onSynthesize(session: ISynthesisSession): void {\n    ignore(session);\n  }\n}\n\n                                                         \nexport interface ValidationError {\n                                                       \n  readonly source: Construct;\n\n                                   \n  readonly message: string;\n}\n\n                                                                                             \nexport interface IValidation {\n                                                                                                                                                                                                                                                                                                                        \n  validate(): string[];\n}\n\n                                             \nexport enum ConstructOrder {\n                                       \n  PREORDER,\n\n                                                           \n  POSTORDER\n}\n\n                              \nexport interface Dependency {\n                                      \n  readonly source: IConstruct;\n\n                                         \n  readonly target: IConstruct;\n}\n\n                                                                                                    \nexport interface ISynthesisSession {\n                                                                 \n  readonly outdir: string;\n\n  /**\n   * Additional context passed to synthesizeNode through `sessionContext`.\n   */\n  [key: string]: any;\n}\n\n                                 \nexport interface SynthesisOptions {\n                                                                                                                                \n  readonly outdir: string;\n\n                                                                                        \n  readonly skipValidation?: boolean;\n\n                                                                                                                                                                                \n  readonly sessionContext?: { [key: string]: any };\n}\n\nfunction ignore(_x: any) {\n  return;\n}\n\n// Import this _after_ everything else to help node work the classes out in the correct order...\nconst PATH_SEP_REGEX = new RegExp(`${Node.PATH_SEP}`, 'g');\n\n/**\n * Return a sanitized version of an arbitrary string, so it can be used as an ID\n */\nfunction sanitizeId(id: string) {\n  // Escape path seps as double dashes\n  return id.replace(PATH_SEP_REGEX, '--');\n}\n\n                                           \nexport interface ConstructOptions {\n                                                                                                                   \n  readonly nodeFactory?: INodeFactory;\n}\n\n                                                            \nexport interface INodeFactory {\n                                                                                                                                                                                        \n  createNode(host: Construct, scope: IConstruct, id: string): Node;\n}\n"]}