@azure/provisioning-core 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/commonjs/serialization/ast/expression-builder.js

@@ -0,0 +1,316 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expression_builder_exports = {};
+__export(expression_builder_exports, {
+  buildExpression: () => buildExpression,
+  buildExpressionProperties: () => buildExpressionProperties,
+  moduleOutputExpression: () => moduleOutputExpression
+});
+module.exports = __toCommonJS(expression_builder_exports);
+var import_ast_nodes = require("../../expression/ast-nodes.js");
+var import_expressions = require("../../expression/expressions.js");
+function expandArmPropertyPaths(node) {
+  if (node.kind !== "property-access") return node;
+  const expandedBase = expandArmPropertyPaths(node.base);
+  if (node.armPath !== void 0) {
+    const path = node.armPath.length > 0 ? node.armPath : [node.property];
+    let current = expandedBase;
+    for (const segment of path) {
+      current = (0, import_ast_nodes.accessExpressionNode)(current, segment, {
+        nullish: node.nullish
+      });
+    }
+    return current;
+  }
+  if (expandedBase === node.base) return node;
+  return { ...node, base: expandedBase };
+}
+function splitSymbolicPath(path) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (const character of path) {
+    if (character === "." && depth === 0) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    if (character === "(") {
+      depth += 1;
+    } else if (character === ")") {
+      depth -= 1;
+    }
+    current += character;
+  }
+  if (current.length > 0) {
+    parts.push(current);
+  }
+  return parts;
+}
+function buildSymbolicPath(path) {
+  const parts = splitSymbolicPath(path);
+  let current;
+  for (const part of parts) {
+    if (part.endsWith("()")) {
+      const target = part.slice(0, -2);
+      const callNode = {
+        kind: "function-call",
+        target,
+        args: []
+      };
+      current = current === void 0 ? callNode : {
+        kind: "instance-function-call",
+        base: current,
+        name: target,
+        args: []
+      };
+      continue;
+    }
+    current = current === void 0 ? {
+      kind: "identifier",
+      id: part
+    } : {
+      kind: "property-access",
+      base: current,
+      property: part,
+      nullish: false
+    };
+  }
+  if (current === void 0) {
+    throw new Error(`Cannot serialize empty symbolic path.`);
+  }
+  return current;
+}
+function buildPlainObject(value, symbolMap) {
+  return {
+    kind: "object",
+    value: buildExpressionProperties(value, symbolMap)
+  };
+}
+function buildExpressionProperties(value, symbolMap) {
+  return Object.fromEntries(
+    Object.entries(value).flatMap(
+      ([key, propertyValue]) => propertyValue === void 0 ? [] : [[key, buildExpression(propertyValue, symbolMap)]]
+    )
+  );
+}
+function buildArray(value, symbolMap) {
+  return {
+    kind: "array",
+    items: value.map((item) => buildExpression(item, symbolMap))
+  };
+}
+function isSerializableObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildIdentifierExpression(value, symbolMap) {
+  if (typeof value.id === "string") {
+    return {
+      kind: "identifier",
+      id: value.id
+    };
+  }
+  const identifier = symbolMap.get(value.id);
+  if (identifier === void 0) {
+    throw new Error(`Missing synthesized symbol for referenced resource type ${value.id.type}.`);
+  }
+  return {
+    kind: "identifier",
+    id: identifier
+  };
+}
+function isBicepIdentifierSegment(segment) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(segment);
+}
+function buildMemberAccessExpression(value, symbolMap) {
+  const base = buildExpression(value.base, symbolMap);
+  if (value.kind === "property-access") {
+    return {
+      kind: "property-access",
+      base,
+      property: value.property,
+      nullish: value.nullish
+    };
+  }
+  if (typeof value.index === "number") {
+    return {
+      kind: "array-access",
+      base,
+      index: {
+        kind: "integer",
+        value: String(value.index)
+      },
+      nullish: value.nullish,
+      fromEnd: value.fromEnd
+    };
+  }
+  if (typeof value.index === "string") {
+    if (value.fromEnd) {
+      throw new Error("Reverse indexing requires an integer index, not a string.");
+    }
+    return isBicepIdentifierSegment(value.index) ? {
+      kind: "property-access",
+      base,
+      property: value.index,
+      nullish: value.nullish
+    } : {
+      kind: "array-access",
+      base,
+      index: {
+        kind: "string",
+        value: value.index
+      },
+      nullish: value.nullish,
+      fromEnd: value.fromEnd
+    };
+  }
+  return {
+    kind: "array-access",
+    base,
+    index: buildExpression(value.index, symbolMap),
+    nullish: value.nullish,
+    fromEnd: value.fromEnd
+  };
+}
+function moduleOutputExpression(moduleName, outputName) {
+  return {
+    kind: "property-access",
+    base: {
+      kind: "property-access",
+      base: { kind: "identifier", id: moduleName },
+      property: "outputs",
+      nullish: false
+    },
+    property: outputName,
+    nullish: false
+  };
+}
+function buildExpression(value, symbolMap = /* @__PURE__ */ new Map()) {
+  if ((0, import_expressions.isExpression)(value)) {
+    return buildExpression((0, import_expressions.unwrapExpression)(value), symbolMap);
+  }
+  if (value !== null && typeof value === "object" && (0, import_ast_nodes.isExpressionNode)(value)) {
+    const expanded = expandArmPropertyPaths(value);
+    if (expanded !== value) {
+      return buildExpression(expanded, symbolMap);
+    }
+  }
+  if (typeof value === "string") {
+    return {
+      kind: "string",
+      value
+    };
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new Error(`Bicep serialization currently only supports integer numbers.`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new Error(`Bicep serialization currently only supports safe integer numbers.`);
+    }
+    return {
+      kind: "integer",
+      value: String(value)
+    };
+  }
+  if (typeof value === "boolean") {
+    return {
+      kind: "boolean",
+      value
+    };
+  }
+  if (value === null) {
+    return {
+      kind: "null",
+      value: null
+    };
+  }
+  if (Array.isArray(value)) {
+    return buildArray(value, symbolMap);
+  }
+  if ((0, import_ast_nodes.isExpressionNode)(value)) {
+    switch (value.kind) {
+      case "binary":
+        return {
+          kind: "binary-operation",
+          operator: value.operator,
+          left: buildExpression(value.left, symbolMap),
+          right: buildExpression(value.right, symbolMap)
+        };
+      case "unary":
+        return {
+          kind: "unary-operation",
+          operator: value.operator,
+          argument: buildExpression(value.argument, symbolMap)
+        };
+      case "ternary":
+        return {
+          kind: "ternary-operation",
+          condition: buildExpression(value.condition, symbolMap),
+          trueValue: buildExpression(value.trueValue, symbolMap),
+          falseValue: buildExpression(value.falseValue, symbolMap)
+        };
+      case "fn-call":
+        return {
+          kind: "function-call",
+          target: value.operator,
+          args: value.args.map(
+            (argument) => buildExpression(argument, symbolMap)
+          )
+        };
+      case "instance-function-call":
+        return {
+          kind: "instance-function-call",
+          base: buildExpression(value.base, symbolMap),
+          name: value.name,
+          args: value.args.map(
+            (argument) => buildExpression(argument, symbolMap)
+          )
+        };
+      case "interpolated-string":
+        return {
+          kind: "interpolated-string",
+          segments: value.segments.map(
+            (segment) => buildExpression(segment, symbolMap)
+          )
+        };
+      case "identifier":
+        return buildIdentifierExpression(value, symbolMap);
+      case "property-access":
+      case "array-access":
+        return buildMemberAccessExpression(value, symbolMap);
+      case "symbolic-value": {
+        const identifier = symbolMap.get(value);
+        return identifier === void 0 ? buildSymbolicPath(value.path) : { kind: "identifier", id: identifier };
+      }
+    }
+  }
+  if (isSerializableObject(value)) {
+    return buildPlainObject(value, symbolMap);
+  }
+  throw new Error(`Unsupported serialization input.`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildExpression,
+  buildExpressionProperties,
+  moduleOutputExpression
+});
+//# sourceMappingURL=expression-builder.js.map

package/dist/commonjs/serialization/ast/expression-builder.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/serialization/ast/expression-builder.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport {\n  accessExpressionNode,\n  isExpressionNode,\n  type ArrayAccessExpressionNode,\n  type ExpressionNode as CoreExpressionNode,\n  type IdentifierExpressionNode,\n  type PropertyAccessExpressionNode,\n} from \"../../expression/ast-nodes.js\";\nimport { isExpression, unwrapExpression, type Expression } from \"../../expression/expressions.js\";\nimport type { DeclarationSymbolMap } from \"../symbol-map.js\";\nimport type { ArrayValue, ExpressionNode, FunctionCallExpression, ObjectValue } from \"./index.js\";\n\nexport type ExpressionNodeInput =\n  | CoreExpressionNode\n  | Expression<unknown>\n  | string\n  | number\n  | boolean\n  | null\n  | readonly ExpressionNodeInput[]\n  | {\n      readonly [key: string]: ExpressionNodeInput | undefined;\n    };\n\n// ---------------------------------------------------------------------------\n// ARM property path expansion\n// ---------------------------------------------------------------------------\n\n/**\n * Expands armPath stamps along a core property-access chain, replacing each\n * stamped property with its ARM path relative to the expanded base. Empty\n * paths fall back to the original property name. Generated accesses carry\n * no stamps; unchanged nodes retain their identity.\n *\n * Recursion stops at non-property-access nodes and leaves their children\n * untouched. buildExpression traverses those children and invokes this\n * helper as it reaches them.\n */\nfunction expandArmPropertyPaths(node: CoreExpressionNode): CoreExpressionNode {\n  if (node.kind !== \"property-access\") return node;\n\n  const expandedBase = expandArmPropertyPaths(node.base);\n  if (node.armPath !== undefined) {\n    const path = node.armPath.length > 0 ? node.armPath : [node.property];\n    let current: CoreExpressionNode = expandedBase;\n    for (const segment of path) {\n      // A flattened optional property may be absent at any wire-path segment.\n      current = accessExpressionNode(current, segment, {\n        nullish: node.nullish,\n      });\n    }\n    return current;\n  }\n  if (expandedBase === node.base) return node;\n  return { ...node, base: expandedBase };\n}\n\n// ---------------------------------------------------------------------------\n// Expression building: CDK value -> AST\n// ---------------------------------------------------------------------------\n\nfunction splitSymbolicPath(path: string): string[] {\n  const parts: string[] = [];\n  let current = \"\";\n  let depth = 0;\n\n  for (const character of path) {\n    if (character === \".\" && depth === 0) {\n      if (current.length > 0) {\n        parts.push(current);\n        current = \"\";\n      }\n      continue;\n    }\n\n    if (character === \"(\") {\n      depth += 1;\n    } else if (character === \")\") {\n      depth -= 1;\n    }\n\n    current += character;\n  }\n\n  if (current.length > 0) {\n    parts.push(current);\n  }\n\n  return parts;\n}\n\nfunction buildSymbolicPath(path: string): ExpressionNode {\n  const parts = splitSymbolicPath(path);\n  let current: ExpressionNode | undefined;\n\n  for (const part of parts) {\n    if (part.endsWith(\"()\")) {\n      const target = part.slice(0, -2);\n      const callNode: FunctionCallExpression = {\n        kind: \"function-call\",\n        target,\n        args: [],\n      };\n\n      current =\n        current === undefined\n          ? callNode\n          : {\n              kind: \"instance-function-call\",\n              base: current,\n              name: target,\n              args: [],\n            };\n      continue;\n    }\n\n    current =\n      current === undefined\n        ? {\n            kind: \"identifier\",\n            id: part,\n          }\n        : {\n            kind: \"property-access\",\n            base: current,\n            property: part,\n            nullish: false,\n          };\n  }\n\n  if (current === undefined) {\n    throw new Error(`Cannot serialize empty symbolic path.`);\n  }\n\n  return current;\n}\n\nfunction buildPlainObject(\n  value: { readonly [key: string]: ExpressionNodeInput | undefined },\n  symbolMap: DeclarationSymbolMap,\n): ObjectValue {\n  return {\n    kind: \"object\",\n    value: buildExpressionProperties(value, symbolMap),\n  };\n}\n\n/** Builds a property map of expression nodes, omitting undefined values. */\nexport function buildExpressionProperties(\n  value: { readonly [key: string]: ExpressionNodeInput | undefined },\n  symbolMap: DeclarationSymbolMap,\n): Record<string, ExpressionNode> {\n  return Object.fromEntries(\n    Object.entries(value).flatMap(([key, propertyValue]) =>\n      propertyValue === undefined ? [] : [[key, buildExpression(propertyValue, symbolMap)]],\n    ),\n  );\n}\n\nfunction buildArray(\n  value: readonly ExpressionNodeInput[],\n  symbolMap: DeclarationSymbolMap,\n): ArrayValue {\n  return {\n    kind: \"array\",\n    items: value.map((item) => buildExpression(item, symbolMap)),\n  };\n}\n\nfunction isSerializableObject(\n  value: ExpressionNodeInput,\n): value is { readonly [key: string]: ExpressionNodeInput | undefined } {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction buildIdentifierExpression(\n  value: IdentifierExpressionNode,\n  symbolMap: DeclarationSymbolMap,\n): ExpressionNode {\n  if (typeof value.id === \"string\") {\n    return {\n      kind: \"identifier\",\n      id: value.id,\n    };\n  }\n\n  const identifier = symbolMap.get(value.id);\n\n  if (identifier === undefined) {\n    throw new Error(`Missing synthesized symbol for referenced resource type ${value.id.type}.`);\n  }\n\n  return {\n    kind: \"identifier\",\n    id: identifier,\n  };\n}\n\nfunction isBicepIdentifierSegment(segment: string): boolean {\n  return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(segment);\n}\n\nfunction buildMemberAccessExpression(\n  value: PropertyAccessExpressionNode | ArrayAccessExpressionNode,\n  symbolMap: DeclarationSymbolMap,\n): ExpressionNode {\n  const base = buildExpression(value.base, symbolMap);\n\n  if (value.kind === \"property-access\") {\n    return {\n      kind: \"property-access\",\n      base,\n      property: value.property,\n      nullish: value.nullish,\n    };\n  }\n\n  if (typeof value.index === \"number\") {\n    return {\n      kind: \"array-access\",\n      base,\n      index: {\n        kind: \"integer\",\n        value: String(value.index),\n      },\n      nullish: value.nullish,\n      fromEnd: value.fromEnd,\n    };\n  }\n\n  if (typeof value.index === \"string\") {\n    if (value.fromEnd) {\n      throw new Error(\"Reverse indexing requires an integer index, not a string.\");\n    }\n    return isBicepIdentifierSegment(value.index)\n      ? {\n          kind: \"property-access\",\n          base,\n          property: value.index,\n          nullish: value.nullish,\n        }\n      : {\n          kind: \"array-access\",\n          base,\n          index: {\n            kind: \"string\",\n            value: value.index,\n          },\n          nullish: value.nullish,\n          fromEnd: value.fromEnd,\n        };\n  }\n\n  // Expression-shaped index (e.g. a loop's `.index` symbolic value or any\n  // `Expression<number>` proxy). Recursively serialize into the wire\n  // array-access's `index` slot.\n  return {\n    kind: \"array-access\",\n    base,\n    index: buildExpression(value.index as ExpressionNodeInput, symbolMap),\n    nullish: value.nullish,\n    fromEnd: value.fromEnd,\n  };\n}\n\nexport function moduleOutputExpression(moduleName: string, outputName: string): ExpressionNode {\n  return {\n    kind: \"property-access\",\n    base: {\n      kind: \"property-access\",\n      base: { kind: \"identifier\", id: moduleName },\n      property: \"outputs\",\n      nullish: false,\n    },\n    property: outputName,\n    nullish: false,\n  };\n}\n\nexport function buildExpression(\n  value: ExpressionNodeInput,\n  symbolMap: DeclarationSymbolMap = new Map(),\n): ExpressionNode {\n  if (isExpression(value)) {\n    return buildExpression(unwrapExpression(value) as ExpressionNodeInput, symbolMap);\n  }\n\n  // Expand the current property paths; recursion below visits other expressions.\n  if (value !== null && typeof value === \"object\" && isExpressionNode(value)) {\n    const expanded = expandArmPropertyPaths(value as CoreExpressionNode);\n    if (expanded !== value) {\n      return buildExpression(expanded as ExpressionNodeInput, symbolMap);\n    }\n  }\n\n  if (typeof value === \"string\") {\n    return {\n      kind: \"string\",\n      value,\n    };\n  }\n\n  if (typeof value === \"number\") {\n    if (!Number.isInteger(value)) {\n      throw new Error(`Bicep serialization currently only supports integer numbers.`);\n    }\n    if (!Number.isSafeInteger(value)) {\n      throw new Error(`Bicep serialization currently only supports safe integer numbers.`);\n    }\n\n    return {\n      kind: \"integer\",\n      value: String(value),\n    };\n  }\n\n  if (typeof value === \"boolean\") {\n    return {\n      kind: \"boolean\",\n      value,\n    };\n  }\n\n  if (value === null) {\n    return {\n      kind: \"null\",\n      value: null,\n    };\n  }\n\n  if (Array.isArray(value)) {\n    return buildArray(value, symbolMap);\n  }\n\n  if (isExpressionNode(value)) {\n    switch (value.kind) {\n      case \"binary\":\n        return {\n          kind: \"binary-operation\",\n          operator: value.operator,\n          left: buildExpression(value.left as ExpressionNodeInput, symbolMap),\n          right: buildExpression(value.right as ExpressionNodeInput, symbolMap),\n        };\n\n      case \"unary\":\n        return {\n          kind: \"unary-operation\",\n          operator: value.operator,\n          argument: buildExpression(value.argument as ExpressionNodeInput, symbolMap),\n        };\n\n      case \"ternary\":\n        return {\n          kind: \"ternary-operation\",\n          condition: buildExpression(value.condition as ExpressionNodeInput, symbolMap),\n          trueValue: buildExpression(value.trueValue as ExpressionNodeInput, symbolMap),\n          falseValue: buildExpression(value.falseValue as ExpressionNodeInput, symbolMap),\n        };\n\n      case \"fn-call\":\n        return {\n          kind: \"function-call\",\n          target: value.operator,\n          args: value.args.map((argument) =>\n            buildExpression(argument as ExpressionNodeInput, symbolMap),\n          ),\n        };\n\n      case \"instance-function-call\":\n        return {\n          kind: \"instance-function-call\",\n          base: buildExpression(value.base as ExpressionNodeInput, symbolMap),\n          name: value.name,\n          args: value.args.map((argument) =>\n            buildExpression(argument as ExpressionNodeInput, symbolMap),\n          ),\n        };\n\n      case \"interpolated-string\":\n        return {\n          kind: \"interpolated-string\",\n          segments: value.segments.map((segment) =>\n            buildExpression(segment as ExpressionNodeInput, symbolMap),\n          ),\n        };\n\n      case \"identifier\":\n        return buildIdentifierExpression(value, symbolMap);\n\n      case \"property-access\":\n      case \"array-access\":\n        return buildMemberAccessExpression(value, symbolMap);\n\n      case \"symbolic-value\": {\n        const identifier = symbolMap.get(value);\n        return identifier === undefined\n          ? buildSymbolicPath(value.path)\n          : { kind: \"identifier\", id: identifier };\n      }\n    }\n  }\n\n  if (isSerializableObject(value)) {\n    return buildPlainObject(value, symbolMap);\n  }\n\n  throw new Error(`Unsupported serialization input.`);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/commonjs/serialization/ast/expression-restorer.d.ts

@@ -0,0 +1,8 @@
+import { type Expression } from "../../expression/expressions.js";
+import type { LoopedResource, Resource } from "../../constructs/resource/resource.js";
+import type { ExpressionNode } from "./index.js";
+type SymbolValue = Expression<unknown> | Resource | LoopedResource<Resource>;
+export type DeclarationReferenceMap = Map<string, SymbolValue>;
+export declare function restoreExpression(node: ExpressionNode, symbols: DeclarationReferenceMap): unknown;
+export {};
+//# sourceMappingURL=expression-restorer.d.ts.map

package/dist/commonjs/serialization/ast/expression-restorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-restorer.d.ts","sourceRoot":"","sources":["../../../../src/serialization/ast/expression-restorer.ts"],"names":[],"mappings":"AAeA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,uCAAuC,CAAC;AACtF,OAAO,KAAK,EAEV,cAAc,EAGf,MAAM,YAAY,CAAC;AAEpB,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;AAC7E,MAAM,MAAM,uBAAuB,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAM/D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,uBAAuB,GAAG,OAAO,CA0LjG"}

package/dist/commonjs/serialization/ast/expression-restorer.js

@@ -0,0 +1,193 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expression_restorer_exports = {};
+__export(expression_restorer_exports, {
+  restoreExpression: () => restoreExpression
+});
+module.exports = __toCommonJS(expression_restorer_exports);
+var import_ast_nodes = require("../../expression/ast-nodes.js");
+var import_expressions = require("../../expression/expressions.js");
+var import_resource_utils = require("../../constructs/resource/resource-utils.js");
+function restoreExpression(node, symbols) {
+  switch (node.kind) {
+    case "string":
+      return node.value;
+    case "integer": {
+      const value = parseInt(node.value, 10);
+      if (!Number.isSafeInteger(value)) {
+        throw new Error(`Cannot deserialize unsafe integer literal "${node.value}".`);
+      }
+      return value;
+    }
+    case "boolean":
+      return node.value;
+    case "null":
+      return null;
+    case "identifier": {
+      const sym = symbols.get(node.id);
+      if (sym !== void 0) return sym;
+      return (0, import_expressions.wrapExpression)((0, import_ast_nodes.identifierExpressionNode)(node.id));
+    }
+    case "function-call":
+      if (typeof node.target !== "string") {
+        throw new Error("Cannot deserialize function call with an expression target.");
+      }
+      return (0, import_expressions.wrapExpression)(
+        (0, import_ast_nodes.functionCallExpressionNode)(
+          node.target,
+          node.args.map((a) => restoreExpression(a, symbols))
+        )
+      );
+    case "instance-function-call": {
+      const base = restoreExpression(node.base, symbols);
+      const baseNode = (0, import_expressions.isExpression)(base) ? (0, import_expressions.unwrapExpression)(base) : (0, import_ast_nodes.identifierExpressionNode)((0, import_resource_utils.isResource)(base) ? base : String(base));
+      return (0, import_expressions.wrapExpression)(
+        (0, import_ast_nodes.instanceFunctionCallExpressionNode)(
+          baseNode,
+          node.name,
+          node.args.map((a) => restoreExpression(a, symbols))
+        )
+      );
+    }
+    case "property-access": {
+      const base = restoreExpression(node.base, symbols);
+      if ((0, import_resource_utils.isResource)(base)) {
+        if (node.nullish) {
+          return (0, import_expressions.wrapExpression)(
+            (0, import_ast_nodes.propertyAccessExpressionNode)((0, import_ast_nodes.identifierExpressionNode)(base), node.property, {
+              nullish: node.nullish
+            })
+          );
+        }
+        return base[node.property];
+      }
+      if ((0, import_expressions.isExpression)(base)) {
+        const inner = (0, import_expressions.unwrapExpression)(base);
+        return (0, import_expressions.wrapExpression)(
+          (0, import_ast_nodes.propertyAccessExpressionNode)(inner, node.property, {
+            nullish: node.nullish
+          })
+        );
+      }
+      return (0, import_expressions.wrapExpression)(
+        (0, import_ast_nodes.propertyAccessExpressionNode)((0, import_ast_nodes.identifierExpressionNode)(String(base)), node.property, {
+          nullish: node.nullish
+        })
+      );
+    }
+    case "array-access": {
+      const base = restoreExpression(node.base, symbols);
+      let idx;
+      if (node.index.kind === "integer") {
+        idx = parseInt(node.index.value, 10);
+      } else if (node.index.kind === "string") {
+        idx = node.index.value;
+      } else {
+        const deserializedIndex = restoreExpression(node.index, symbols);
+        idx = (0, import_expressions.isExpression)(deserializedIndex) ? (0, import_expressions.unwrapExpression)(deserializedIndex) : deserializedIndex;
+      }
+      if ((0, import_resource_utils.isResource)(base)) {
+        if (node.nullish || node.fromEnd) {
+          return (0, import_expressions.wrapExpression)(
+            (0, import_ast_nodes.arrayAccessExpressionNode)((0, import_ast_nodes.identifierExpressionNode)(base), idx, {
+              nullish: node.nullish,
+              fromEnd: node.fromEnd
+            })
+          );
+        }
+        return base[String(idx)];
+      }
+      if ((0, import_resource_utils.isLoopedResource)(base)) {
+        return (0, import_expressions.wrapExpression)(
+          (0, import_ast_nodes.arrayAccessExpressionNode)((0, import_ast_nodes.identifierExpressionNode)(base), idx, {
+            nullish: node.nullish,
+            fromEnd: node.fromEnd
+          })
+        );
+      }
+      if ((0, import_expressions.isExpression)(base)) {
+        const inner = (0, import_expressions.unwrapExpression)(base);
+        return (0, import_expressions.wrapExpression)(
+          (0, import_ast_nodes.arrayAccessExpressionNode)(inner, idx, {
+            nullish: node.nullish,
+            fromEnd: node.fromEnd
+          })
+        );
+      }
+      return (0, import_expressions.wrapExpression)(
+        (0, import_ast_nodes.arrayAccessExpressionNode)((0, import_ast_nodes.identifierExpressionNode)(String(base)), idx, {
+          nullish: node.nullish,
+          fromEnd: node.fromEnd
+        })
+      );
+    }
+    case "object": {
+      const obj = /* @__PURE__ */ Object.create(null);
+      for (const [key, value] of Object.entries(node.value)) {
+        Object.defineProperty(obj, key, {
+          value: restoreExpression(value, symbols),
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+      }
+      return obj;
+    }
+    case "array":
+      return node.items.map((item) => restoreExpression(item, symbols));
+    case "binary-operation": {
+      const operation = node;
+      return (0, import_expressions.wrapExpression)({
+        kind: "binary",
+        operator: operation.operator,
+        left: restoreExpression(operation.left, symbols),
+        right: restoreExpression(operation.right, symbols)
+      });
+    }
+    case "unary-operation": {
+      const operation = node;
+      return (0, import_expressions.wrapExpression)({
+        kind: "unary",
+        operator: operation.operator,
+        argument: restoreExpression(operation.argument, symbols)
+      });
+    }
+    case "ternary-operation": {
+      const operation = node;
+      return (0, import_expressions.wrapExpression)({
+        kind: "ternary",
+        condition: restoreExpression(operation.condition, symbols),
+        trueValue: restoreExpression(operation.trueValue, symbols),
+        falseValue: restoreExpression(operation.falseValue, symbols)
+      });
+    }
+    case "interpolated-string": {
+      return (0, import_expressions.wrapExpression)({
+        kind: "interpolated-string",
+        segments: node.segments.map((segment) => restoreExpression(segment, symbols))
+      });
+    }
+    default:
+      throw new Error(`Unsupported expression node kind: ${node.kind}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  restoreExpression
+});
+//# sourceMappingURL=expression-restorer.js.map

package/dist/commonjs/serialization/ast/expression-restorer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/serialization/ast/expression-restorer.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport {\n  arrayAccessExpressionNode,\n  functionCallExpressionNode,\n  identifierExpressionNode,\n  instanceFunctionCallExpressionNode,\n  propertyAccessExpressionNode,\n  type ArrayAccessIndex,\n  type BinaryExpressionNode,\n  type ExpressionNode as CoreExpressionNode,\n  type TernaryExpressionNode,\n  type UnaryExpressionNode,\n} from \"../../expression/ast-nodes.js\";\nimport {\n  isExpression,\n  unwrapExpression,\n  wrapExpression,\n  type Expression,\n} from \"../../expression/expressions.js\";\nimport { isResource, isLoopedResource } from \"../../constructs/resource/resource-utils.js\";\nimport type { LoopedResource, Resource } from \"../../constructs/resource/resource.js\";\nimport type {\n  BinaryOperationExpression,\n  ExpressionNode,\n  TernaryOperationExpression,\n  UnaryOperationExpression,\n} from \"./index.js\";\n\ntype SymbolValue = Expression<unknown> | Resource | LoopedResource<Resource>;\nexport type DeclarationReferenceMap = Map<string, SymbolValue>;\n\n// ---------------------------------------------------------------------------\n// Expression restoration: AST -> CDK value\n// ---------------------------------------------------------------------------\n\nexport function restoreExpression(node: ExpressionNode, symbols: DeclarationReferenceMap): unknown {\n  switch (node.kind) {\n    case \"string\":\n      return node.value;\n    case \"integer\": {\n      const value = parseInt(node.value, 10);\n      if (!Number.isSafeInteger(value)) {\n        throw new Error(`Cannot deserialize unsafe integer literal \"${node.value}\".`);\n      }\n      return value;\n    }\n    case \"boolean\":\n      return node.value;\n    case \"null\":\n      return null;\n\n    case \"identifier\": {\n      const sym = symbols.get(node.id);\n      if (sym !== undefined) return sym;\n      return wrapExpression(identifierExpressionNode(node.id));\n    }\n\n    case \"function-call\":\n      if (typeof node.target !== \"string\") {\n        throw new Error(\"Cannot deserialize function call with an expression target.\");\n      }\n      return wrapExpression(\n        functionCallExpressionNode(\n          node.target,\n          node.args.map((a) => restoreExpression(a, symbols)),\n        ),\n      );\n\n    case \"instance-function-call\": {\n      const base = restoreExpression(node.base, symbols);\n      const baseNode = isExpression(base)\n        ? unwrapExpression(base as Expression<unknown>)\n        : identifierExpressionNode(isResource(base) ? base : String(base));\n      return wrapExpression(\n        instanceFunctionCallExpressionNode(\n          baseNode,\n          node.name,\n          node.args.map((a) => restoreExpression(a, symbols)),\n        ),\n      );\n    }\n\n    case \"property-access\": {\n      const base = restoreExpression(node.base, symbols);\n      if (isResource(base)) {\n        if (node.nullish) {\n          return wrapExpression(\n            propertyAccessExpressionNode(identifierExpressionNode(base), node.property, {\n              nullish: node.nullish,\n            }),\n          );\n        }\n        return (base as unknown as Record<string, unknown>)[node.property];\n      }\n      if (isExpression(base)) {\n        const inner = unwrapExpression(base as Expression<unknown>);\n        return wrapExpression(\n          propertyAccessExpressionNode(inner, node.property, {\n            nullish: node.nullish,\n          }),\n        );\n      }\n      return wrapExpression(\n        propertyAccessExpressionNode(identifierExpressionNode(String(base)), node.property, {\n          nullish: node.nullish,\n        }),\n      );\n    }\n\n    case \"array-access\": {\n      const base = restoreExpression(node.base, symbols);\n      // Preserve non-literal indexes as expressions so `sym[<expr>]` round-\n      // trips faithfully. Literal integer/string indexes lower to native\n      // JS number/string values as before.\n      let idx: ArrayAccessIndex;\n      if (node.index.kind === \"integer\") {\n        idx = parseInt(node.index.value, 10);\n      } else if (node.index.kind === \"string\") {\n        idx = node.index.value;\n      } else {\n        const deserializedIndex = restoreExpression(node.index, symbols);\n        idx = isExpression(deserializedIndex)\n          ? unwrapExpression(deserializedIndex as Expression<unknown>)\n          : (deserializedIndex as ArrayAccessIndex);\n      }\n      if (isResource(base)) {\n        if (node.nullish || node.fromEnd) {\n          return wrapExpression(\n            arrayAccessExpressionNode(identifierExpressionNode(base), idx, {\n              nullish: node.nullish,\n              fromEnd: node.fromEnd,\n            }),\n          );\n        }\n        return (base as unknown as Record<string, unknown>)[String(idx)];\n      }\n      if (isLoopedResource(base)) {\n        // `sym[idx]` on a looped declaration. Carry the handle itself as the\n        // identifier id (not `String(base)`, which would stringify to\n        // \"[object Object]\") so re-serialize maps it back to the resource's\n        // symbol. The resulting expression proxy lets an outer `.prop` chain\n        // (e.g. `looped.at(0).id`) render as `sym[idx].prop`.\n        return wrapExpression(\n          arrayAccessExpressionNode(identifierExpressionNode(base as unknown as Resource), idx, {\n            nullish: node.nullish,\n            fromEnd: node.fromEnd,\n          }),\n        );\n      }\n      if (isExpression(base)) {\n        const inner = unwrapExpression(base as Expression<unknown>);\n        return wrapExpression(\n          arrayAccessExpressionNode(inner, idx, {\n            nullish: node.nullish,\n            fromEnd: node.fromEnd,\n          }),\n        );\n      }\n      return wrapExpression(\n        arrayAccessExpressionNode(identifierExpressionNode(String(base)), idx, {\n          nullish: node.nullish,\n          fromEnd: node.fromEnd,\n        }),\n      );\n    }\n\n    case \"object\": {\n      const obj: Record<string, unknown> = Object.create(null);\n      for (const [key, value] of Object.entries(node.value)) {\n        Object.defineProperty(obj, key, {\n          value: restoreExpression(value, symbols),\n          enumerable: true,\n          configurable: true,\n          writable: true,\n        });\n      }\n      return obj;\n    }\n\n    case \"array\":\n      return node.items.map((item) => restoreExpression(item, symbols));\n\n    case \"binary-operation\": {\n      const operation = node as BinaryOperationExpression;\n      return wrapExpression({\n        kind: \"binary\",\n        operator: operation.operator,\n        left: restoreExpression(operation.left, symbols),\n        right: restoreExpression(operation.right, symbols),\n      } as BinaryExpressionNode as CoreExpressionNode);\n    }\n\n    case \"unary-operation\": {\n      const operation = node as UnaryOperationExpression;\n      return wrapExpression({\n        kind: \"unary\",\n        operator: operation.operator,\n        argument: restoreExpression(operation.argument, symbols),\n      } as UnaryExpressionNode as CoreExpressionNode);\n    }\n\n    case \"ternary-operation\": {\n      const operation = node as TernaryOperationExpression;\n      return wrapExpression({\n        kind: \"ternary\",\n        condition: restoreExpression(operation.condition, symbols),\n        trueValue: restoreExpression(operation.trueValue, symbols),\n        falseValue: restoreExpression(operation.falseValue, symbols),\n      } as TernaryExpressionNode as CoreExpressionNode);\n    }\n\n    case \"interpolated-string\": {\n      return wrapExpression({\n        kind: \"interpolated-string\",\n        segments: node.segments.map((segment) => restoreExpression(segment, symbols)),\n      } as CoreExpressionNode);\n    }\n\n    default:\n      throw new Error(`Unsupported expression node kind: ${node.kind}`);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/commonjs/serialization/ast/expression-rewriter.d.ts

@@ -0,0 +1,29 @@
+import type { DeclarableBodyNode, DeclarationNode, ExpressionNode, ModuleDeclarationNode, OutputDeclarationNode, ParameterDeclarationNode, ResourceDeclarationNode, VariableDeclarationNode } from "./index.js";
+/** An identifier-rooted access chain with its static path and original AST node. */
+export interface ExpressionReference {
+    readonly identifier: string;
+    readonly path: readonly (string | number)[];
+    readonly expression: ExpressionNode;
+}
+export type ExpressionReferenceResolver = (reference: ExpressionReference) => ExpressionNode | undefined;
+/**
+ * Replaces identifier access chains, preserving unchanged branches and ignoring
+ * loop-local references. The resolver receives the original expression.
+ */
+export declare function rewriteExpressionReferences(expression: DeclarableBodyNode, resolve: ExpressionReferenceResolver): DeclarableBodyNode;
+export declare function rewriteExpressionReferences(expression: ExpressionNode, resolve: ExpressionReferenceResolver): ExpressionNode;
+type ExpressionRewriter = (expression: ExpressionNode) => ExpressionNode;
+/**
+ * Applies an expression transformation to a declaration's value, default,
+ * decorators, and nested type decorators. The callback rewrites each complete
+ * expression subtree; recursive expression traversal is its responsibility.
+ * Unchanged branches are shared, and the input declaration is not mutated.
+ */
+export declare function rewriteDeclarationExpressions(node: ResourceDeclarationNode, rewriteExpression: ExpressionRewriter): ResourceDeclarationNode;
+export declare function rewriteDeclarationExpressions(node: ModuleDeclarationNode, rewriteExpression: ExpressionRewriter): ModuleDeclarationNode;
+export declare function rewriteDeclarationExpressions(node: OutputDeclarationNode, rewriteExpression: ExpressionRewriter): OutputDeclarationNode;
+export declare function rewriteDeclarationExpressions(node: ParameterDeclarationNode, rewriteExpression: ExpressionRewriter): ParameterDeclarationNode;
+export declare function rewriteDeclarationExpressions(node: VariableDeclarationNode, rewriteExpression: ExpressionRewriter): VariableDeclarationNode;
+export declare function rewriteDeclarationExpressions(node: DeclarationNode, rewriteExpression: ExpressionRewriter): DeclarationNode;
+export {};
+//# sourceMappingURL=expression-rewriter.d.ts.map

package/dist/commonjs/serialization/ast/expression-rewriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-rewriter.d.ts","sourceRoot":"","sources":["../../../../src/serialization/ast/expression-rewriter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EAEf,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EAEvB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;CACrC;AAED,MAAM,MAAM,2BAA2B,GAAG,CACxC,SAAS,EAAE,mBAAmB,KAC3B,cAAc,GAAG,SAAS,CAAC;AA2BhC;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE,2BAA2B,GACnC,kBAAkB,CAAC;AACtB,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,2BAA2B,GACnC,cAAc,CAAC;AAgHlB,KAAK,kBAAkB,GAAG,CAAC,UAAU,EAAE,cAAc,KAAK,cAAc,CAAC;AA+GzE;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,uBAAuB,EAC7B,iBAAiB,EAAE,kBAAkB,GACpC,uBAAuB,CAAC;AAC3B,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,qBAAqB,EAC3B,iBAAiB,EAAE,kBAAkB,GACpC,qBAAqB,CAAC;AACzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,qBAAqB,EAC3B,iBAAiB,EAAE,kBAAkB,GACpC,qBAAqB,CAAC;AACzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,wBAAwB,EAC9B,iBAAiB,EAAE,kBAAkB,GACpC,wBAAwB,CAAC;AAC5B,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,uBAAuB,EAC7B,iBAAiB,EAAE,kBAAkB,GACpC,uBAAuB,CAAC;AAC3B,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,eAAe,EACrB,iBAAiB,EAAE,kBAAkB,GACpC,eAAe,CAAC"}