@intentius/chant-lexicon-azure 0.124.32 → 0.124.33

package/src/serializer.ts

@@ -170,20 +170,52 @@ export function getApiVersion(resourceType: string): string {
   return "2023-01-01";
 }
 
+/**
+ * The ARM name of a chant export, as the arguments an ARM function takes
+ * (#4183). A resource's `name` prop is its ARM name, and the export name is
+ * used only when it has none. A literal name is quoted, one argument per
+ * segment of a child's `parent/child` name; a bracket expression such as
+ * `[parameters('n')]` is passed unwrapped.
+ */
+function armNameArgs(entity: Declarable | undefined, exportName: string): { args: string; literal: string | null } {
+  const props = entity && isResourceDeclarable(entity) && typeof entity.props === "object" && entity.props !== null
+    ? entity.props as Record<string, unknown>
+    : undefined;
+  const name = typeof props?.name === "string" ? props.name : exportName;
+  if (name.startsWith("[") && name.endsWith("]")) return { args: name.slice(1, -1), literal: null };
+  return { args: name.split("/").map((seg) => `'${seg}'`).join(", "), literal: name };
+}
+
+function entityNamed(entityNames: Map<Declarable, string>, name: string): Declarable | undefined {
+  return [...entityNames.entries()].find(([, n]) => n === name)?.[0];
+}
+
+/** `resourceId(...)` for an export: the type and its ARM name. */
+function armResourceId(entityNames: Map<Declarable, string>, name: string): string {
+  const entity = entityNamed(entityNames, name);
+  const { args } = armNameArgs(entity, name);
+  return entity ? `resourceId('${entity.entityType}', ${args})` : `resourceId(${args})`;
+}
+
+/**
+ * An attribute of an export. `id` is `resourceId()`, since `reference()`
+ * returns the resource's properties and they have no `id`; anything else
+ * reads `reference()` by the ARM name.
+ */
+export function armAttrExpression(entityNames: Map<Declarable, string>, name: string, attr: string): string {
+  if (attr === "id") return `[${armResourceId(entityNames, name)}]`;
+  const { args, literal } = armNameArgs(entityNamed(entityNames, name), name);
+  const target = literal !== null && !literal.includes("/") ? args : armResourceId(entityNames, name);
+  return `[reference(${target}).${attr}]`;
+}
+
 /**
  * ARM-specific visitor for the generic serializer walker.
  */
 function armVisitor(entityNames: Map<Declarable, string>): SerializerVisitor {
   return {
-    attrRef: (name, attr) => `[reference('${name}').${attr}]`,
-    resourceRef: (name) => {
-      // Look up the resource type from entityNames
-      const entity = [...entityNames.entries()].find(([, n]) => n === name)?.[0];
-      if (entity) {
-        return `[resourceId('${entity.entityType}', '${name}')]`;
-      }
-      return `[resourceId('${name}')]`;
-    },
+    attrRef: (name, attr) => armAttrExpression(entityNames, name, attr),
+    resourceRef: (name) => `[${armResourceId(entityNames, name)}]`,
     propertyDeclarable: (entity, walk) => {
       if (!isResourceDeclarable(entity) || typeof entity.props !== "object" || entity.props === null) {
         return undefined;
@@ -203,6 +235,30 @@ function armVisitor(entityNames: Map<Declarable, string>): SerializerVisitor {
 /**
  * Convert a value to ARM-compatible JSON using the generic walker.
  */
+/** An ARM output for a literal, or for an azure intrinsic's `[...]` expression. */
+function armOutputValue(value: unknown): { type: string; value: unknown } | undefined {
+  if (typeof value === "string") return { type: "string", value };
+  if (typeof value === "number" && Number.isInteger(value)) return { type: "int", value };
+  if (typeof value === "boolean") return { type: "bool", value };
+  return undefined;
+}
+
+function isIntrinsicLike(value: unknown): value is { toJSON(): unknown } {
+  return typeof value === "object" && value !== null && typeof (value as { toJSON?: unknown }).toJSON === "function";
+}
+
+function isCloudFormationShaped(value: unknown): boolean {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 1 && (keys[0] === "Ref" || keys[0].startsWith("Fn::"));
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
 function toArmValue(value: unknown, entityNames: Map<Declarable, string>): unknown {
   return walkValue(value, entityNames, armVisitor(entityNames));
 }
@@ -214,6 +270,7 @@ function serializeToTemplate(
   entities: Map<string, Declarable>,
   outputs?: LexiconOutput[],
   ownership?: OwnershipMarker,
+  warnings: string[] = [],
 ): ArmTemplate {
   // Resolve the deployment scope from the resource types being emitted
   // (#1545): a template of tenant-only resources (management groups, policy
@@ -330,6 +387,12 @@ function serializeToTemplate(
             (resource as unknown as Record<string, unknown>)[key] = toArmValue(value, entityNames);
           } else if (key === "name") {
             resource.name = toArmValue(value, entityNames) as string;
+          } else if (key === "properties" && isPlainObject(value)) {
+            // The generated types take ARM's own `properties` object, so
+            // merge it, not nest it (#4183).
+            for (const [inner, innerValue] of Object.entries(value)) {
+              if (innerValue !== undefined) armProperties[inner] = toArmValue(innerValue, entityNames);
+            }
           } else {
             armProperties[key] = toArmValue(value, entityNames);
           }
@@ -356,14 +419,9 @@ function serializeToTemplate(
       if (attrs?.DependsOn !== undefined) {
         const resolved = resolveDependsOn(attrs.DependsOn, entityNames, name);
         if (resolved.length > 0) {
-          resource.dependsOn = resolved.map((dep) => {
-            // Convert to resourceId expression
-            const depEntity = [...entityNames.entries()].find(([, n]) => n === dep)?.[0];
-            if (depEntity) {
-              return `[resourceId('${depEntity.entityType}', '${dep}')]`;
-            }
-            return dep;
-          });
+          resource.dependsOn = resolved.map((dep) =>
+            entityNamed(entityNames, dep) ? `[${armResourceId(entityNames, dep)}]` : dep,
+          );
         }
       }
 
@@ -424,7 +482,7 @@ function serializeToTemplate(
         // Find the resource to build the resourceId expression
         const depResource = template.resources.find((r) => r.name === refName);
         if (depResource) {
-          const depExpr = `[resourceId('${depResource.type}', '${refName}')]`;
+          const depExpr = `[resourceId('${depResource.type}', ${refName.split("/").map((seg) => `'${seg}'`).join(", ")})]`;
           if (!existing.has(depExpr)) {
             existing.add(depExpr);
           }
@@ -442,17 +500,20 @@ function serializeToTemplate(
       if (!template.outputs) template.outputs = {};
       const stackOutput = entity as StackOutput;
       // `unknown` so isAttrRefLike narrows cleanly across the workspace/published
-      // type boundary. An intrinsic-wrapped output (#517) has no bare ARM
-      // reference form, so skip it here (only aws/CFN emits those).
+      // type boundary.
       const ref: unknown = stackOutput.sourceRef;
       if (isAttrRefLike(ref)) {
         const logicalName = ref.getLogicalName();
         if (logicalName) {
           template.outputs[name] = {
             type: "string",
-            value: `[reference('${logicalName}').${ref.attribute}]`,
+            value: armAttrExpression(entityNames, logicalName, ref.attribute),
           };
         }
+      } else {
+        const value = armOutputValue(isIntrinsicLike(ref) ? ref.toJSON() : ref);
+        if (value) template.outputs[name] = value;
+        else warnings.push(`azure: stack output "${name}" is not written: its value has no ARM form.`);
       }
     }
   }
@@ -461,11 +522,27 @@ function serializeToTemplate(
   if (outputs && outputs.length > 0) {
     template.outputs = template.outputs ?? {};
     for (const output of outputs) {
-      template.outputs[output.outputName] = {
-        type: "string",
-        value: `[reference('${output.sourceEntity}').${output.sourceAttribute}]`,
-      };
+      if (output.sourceAttribute !== null) {
+        if (output.sourceEntity) {
+          template.outputs[output.outputName] = {
+            type: "string",
+            value: armAttrExpression(entityNames, output.sourceEntity, output.sourceAttribute),
+          };
+        } else {
+          warnings.push(`azure: output "${output.outputName}" is not written: its resource has no name in this build.`);
+        }
+        continue;
+      }
+      // A literal or an intrinsic (#4181). It has no source lexicon, so every
+      // lexicon receives it; a CloudFormation-shaped value is aws's to write.
+      const raw = output.getOutputValue();
+      const value = armOutputValue(raw);
+      if (value) template.outputs[output.outputName] = value;
+      else if (!isCloudFormationShaped(raw)) {
+        warnings.push(`azure: output "${output.outputName}" is not written: its value has no ARM form.`);
+      }
     }
+    if (Object.keys(template.outputs).length === 0) delete template.outputs;
   }
 
   return template;
@@ -519,13 +596,18 @@ export const azureSerializer: Serializer = {
       }
     }
 
-    const template = serializeToTemplate(entities, outputs, context?.ownership);
+    const warnings: string[] = [];
+    const template = serializeToTemplate(entities, outputs, context?.ownership, warnings);
     const primary = JSON.stringify(template, null, 2);
 
-    if (!hasChildProjects) {
+    if (!hasChildProjects && warnings.length === 0) {
       return primary;
     }
 
-    return { primary, files: allFiles };
+    return {
+      primary,
+      ...(hasChildProjects ? { files: allFiles } : {}),
+      ...(warnings.length > 0 ? { warnings } : {}),
+    };
   },
 };

package/src/spec/parse.test.ts

@@ -68,6 +68,21 @@ describe("parseArmSchema", () => {
     expect(result.resource.attributes.find((a) => a.name === "id")).toBeTruthy();
   });
 
+  it("gives a Container App its hostname attributes (#4179)", () => {
+    const schema = {
+      resourceType: "Microsoft.App/containerApps",
+      apiVersion: "2024-03-01",
+      provider: "Microsoft.App",
+      resourceName: "containerApps",
+      resourceDefinition: { properties: {} },
+      definitions: {},
+    };
+
+    const names = parseArmSchema(JSON.stringify(schema)).resource.attributes.map((a) => a.name);
+    expect(names).toContain("configuration.ingress.fqdn");
+    expect(names).toContain("latestRevisionFqdn");
+  });
+
   it("parses definitions into property types and enums", () => {
     const schema = {
       resourceType: "Microsoft.Test/resources",

package/src/spec/parse.ts

@@ -168,6 +168,16 @@ const CURATED_ATTRIBUTES: Record<string, Array<{ name: string; tsType: string }>
     { name: "id", tsType: "string" },
     { name: "provisioningState", tsType: "string" },
   ],
+  // The app's hostname, for DNS in front of it (#4179). Dotted names read a
+  // nested field of reference()'s properties, as AWS's Endpoint.Address does.
+  "Microsoft.App/containerApps": [
+    { name: "id", tsType: "string" },
+    { name: "configuration.ingress.fqdn", tsType: "string" },
+    { name: "latestRevisionFqdn", tsType: "string" },
+    { name: "latestRevisionName", tsType: "string" },
+    { name: "outboundIpAddresses", tsType: "string[]" },
+    { name: "provisioningState", tsType: "string" },
+  ],
 };
 
 /**