@intentius/chant-lexicon-k8s 0.97.0 → 0.99.0

package/src/import/generator.ts

@@ -7,6 +7,18 @@
 
 import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
 import type { TemplateIR, ResourceIR } from "@intentius/chant/import/parser";
+import {
+  EmbeddedImportScope,
+  isEmbeddedReference,
+  renderEmbeddedReference,
+} from "@intentius/chant/import/embedded";
+
+const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+/** An object key as TypeScript: bare when it is an identifier, quoted otherwise (`"config.yaml"`, `"app.kubernetes.io/name"`). */
+function propertyKey(key: string): string {
+  return IDENT.test(key) ? key : JSON.stringify(key);
+}
 
 /**
  * Map K8s entity types to their constructor class names.
@@ -99,6 +111,9 @@ const SERVICE_PORT_TYPES = new Set([
  * Generate TypeScript source code from a Kubernetes IR.
  */
 export class K8sGenerator implements TypeScriptGenerator {
+  /** The imports for embedded content the current `generate()` call references (#2962). */
+  private scope = new EmbeddedImportScope("");
+
   generate(ir: TemplateIR): GeneratedFile[] {
     const lines: string[] = [];
 
@@ -112,10 +127,13 @@ export class K8sGenerator implements TypeScriptGenerator {
       this.collectNestedConstructors(resource.properties, usedConstructors, resource.type);
     }
 
-    // Import statement
-    const imports = [...usedConstructors].sort().join(", ");
-    lines.push(`import { ${imports} } from "@intentius/chant-lexicon-k8s";`);
-    lines.push("");
+    // Names the embedded content's imports must not take: every constructor this file may use, and its exports.
+    this.scope = new EmbeddedImportScope("", [
+      ...usedConstructors,
+      ...Object.values(PROPERTY_CONSTRUCTORS),
+      "ServicePort",
+      ...ir.resources.map((r) => r.logicalId),
+    ]);
 
     // Emit namespaces as comments
     if (ir.metadata?.namespaces && Array.isArray(ir.metadata.namespaces)) {
@@ -139,7 +157,16 @@ export class K8sGenerator implements TypeScriptGenerator {
       lines.push("");
     }
 
-    return [{ path: "main.ts", content: lines.join("\n") }];
+    // Import statements: the k8s constructors, then what embedded content references.
+    // The constructors are read back from what was emitted (string literals
+    // taken out), so a nested one the walk above does not reach (a
+    // container's env) is imported too.
+    const code = lines.join("\n").replace(/"(?:[^"\\\n]|\\.)*"/g, '""');
+    for (const m of code.matchAll(/\bnew ([A-Z][A-Za-z0-9_]*)\(/g)) usedConstructors.add(m[1]);
+    const imports = [...usedConstructors].sort().join(", ");
+    const head = [`import { ${imports} } from "@intentius/chant-lexicon-k8s";`, ...this.scope.lines(), ""];
+
+    return [{ path: "main.ts", content: [...head, ...lines].join("\n") }];
   }
 
   /**
@@ -199,7 +226,7 @@ export class K8sGenerator implements TypeScriptGenerator {
     for (const [key, value] of Object.entries(props)) {
       if (value === undefined || value === null) continue;
       const emitted = this.emitValue(key, value, depth + 1, parentType);
-      entries.push(`${innerIndent}${key}: ${emitted},`);
+      entries.push(`${innerIndent}${propertyKey(key)}: ${emitted},`);
     }
 
     if (entries.length === 0) return "{}";
@@ -208,6 +235,7 @@ export class K8sGenerator implements TypeScriptGenerator {
 
   private emitValue(key: string, value: unknown, depth: number, parentType: string): string {
     if (value === null || value === undefined) return "undefined";
+    if (isEmbeddedReference(value)) return renderEmbeddedReference(value, this.scope, depth * 2);
 
     // Special case: "ports" on Service → ServicePort constructor
     if (key === "ports" && SERVICE_PORT_TYPES.has(parentType) && Array.isArray(value)) {
@@ -256,6 +284,7 @@ export class K8sGenerator implements TypeScriptGenerator {
 
   private emitLiteral(value: unknown, depth: number, parentType: string): string {
     if (value === null || value === undefined) return "undefined";
+    if (isEmbeddedReference(value)) return renderEmbeddedReference(value, this.scope, depth * 2);
     if (typeof value === "string") return JSON.stringify(value);
     if (typeof value === "number" || typeof value === "boolean") return String(value);
 
@@ -275,7 +304,7 @@ export class K8sGenerator implements TypeScriptGenerator {
       const indent = "  ".repeat(depth);
       const innerIndent = "  ".repeat(depth + 1);
       const items = entries.map(
-        ([k, v]) => `${innerIndent}${k}: ${this.emitLiteral(v, depth + 1, parentType)},`,
+        ([k, v]) => `${innerIndent}${propertyKey(k)}: ${this.emitLiteral(v, depth + 1, parentType)},`,
       );
       return `{\n${items.join("\n")}\n${indent}}`;
     }

package/src/import/parser.test.ts

@@ -43,6 +43,24 @@ metadata:
     expect(ir.resources.length).toBe(2);
   });
 
+  test("multi-doc YAML splits on commented separators and document ends (#2965)", () => {
+    const yaml = `--- # the app
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: app
+...
+--- # its service
+apiVersion: v1
+kind: Service
+metadata:
+  name: svc
+...
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources.map((r) => r.type)).toEqual(["K8s::Apps::Deployment", "K8s::Core::Service"]);
+  });
+
   test("apiVersion: apps/v1, kind: Deployment → K8s::Apps::Deployment", () => {
     const yaml = `
 apiVersion: apps/v1

package/src/import/parser.ts

@@ -6,9 +6,11 @@
  * convention.
  */
 
-import type { TemplateParser, TemplateIR, ResourceIR } from "@intentius/chant/import/parser";
-import { parseYAML } from "@intentius/chant/yaml";
+import type { TemplateParser, TemplateIR, ResourceIR, ParseContext } from "@intentius/chant/import/parser";
+import type { EmbeddedContentResolver } from "@intentius/chant/import/embedded";
+import { parseYAML, splitYAMLDocuments } from "@intentius/chant/yaml";
 import { namespaceSegmentForGroup } from "../group-namespace";
+import { delegateEmbedded } from "./embedded";
 
 // ── GVK to type name mapping ───────────────────────────────────────
 
@@ -130,25 +132,29 @@ function toLogicalId(kind: string, name: string | undefined): string {
 /**
  * Kubernetes YAML parser implementation.
  *
- * Supports multi-document YAML (split on `---`). Each document is expected
+ * Supports multi-document YAML (split on `---`, see `splitYAMLDocuments`). Each document is expected
  * to be a standard Kubernetes object with apiVersion, kind, and metadata.
  */
 export class K8sParser implements TemplateParser {
-  parse(content: string): TemplateIR {
+  /**
+   * With `context.embedded` (`chant import`), content another lexicon owns
+   * is offered to it: every ConfigMap `data` value and a PrometheusRule's
+   * `spec.groups` (see ./embedded.ts). Without it, everything is kept as
+   * written.
+   */
+  parse(content: string, context?: ParseContext): TemplateIR {
     const resources: ResourceIR[] = [];
     const namespaces = new Set<string>();
 
-    // Split on YAML document separator, filter blanks
-    const documents = content
-      .split(/^---\s*$/m)
-      .map((d) => d.trim())
-      .filter((d) => d.length > 0 && !/^[\s#]*$/.test(d.replace(/#[^\n]*/g, "")));
+    // Split into documents on `---` / `...` markers (a trailing `# comment`
+    // allowed); empty and comment-only documents are dropped (#2965).
+    const documents = splitYAMLDocuments(content);
 
     for (const docStr of documents) {
       const doc = parseYAML(docStr);
       if (!doc || typeof doc !== "object") continue;
 
-      const resource = this.parseDocument(doc as Record<string, unknown>);
+      const resource = this.parseDocument(doc as Record<string, unknown>, context?.embedded);
       if (resource) {
         resources.push(resource);
 
@@ -172,7 +178,7 @@ export class K8sParser implements TemplateParser {
     };
   }
 
-  private parseDocument(doc: Record<string, unknown>): ResourceIR | null {
+  private parseDocument(doc: Record<string, unknown>, embedded?: EmbeddedContentResolver): ResourceIR | null {
     const apiVersion = doc.apiVersion as string | undefined;
     const kind = doc.kind as string | undefined;
 
@@ -190,6 +196,8 @@ export class K8sParser implements TemplateParser {
       properties[key] = value;
     }
 
+    if (embedded) delegateEmbedded(type, kind, properties, embedded);
+
     return {
       logicalId,
       type,

package/src/import/testdata/embedded/README.md

@@ -0,0 +1,11 @@
+# Embedded-content import fixtures
+
+Manifests that hold another lexicon's content, for `embedded-roundtrip.test.ts`
+and `embedded-types.e2e.test.ts` (#2962).
+
+| File | Source |
+|---|---|
+| `otel-collector-daemonset.yaml` | open-telemetry/opentelemetry-helm-charts at `b0bce1305083b574c63d6d537431f0b08d36e17f`, chart opentelemetry-collector 0.173.1 (collector 0.160.0): `charts/opentelemetry-collector/examples/daemonset-only/rendered/configmap-agent.yaml` followed by `daemonset.yaml` from the same directory, unchanged. The config is under the chart's `relay` key. |
+| `node-exporter-prometheusrule.yaml` | prometheus-operator/kube-prometheus `v0.19.0`, `manifests/nodeExporter-prometheusRule.yaml`, unchanged. |
+| `grafana-dashboard-configmap.yaml` | prometheus-operator/kube-prometheus `v0.19.0`, `manifests/grafana-dashboardDefinitions.yaml`: the `grafana-dashboard-alertmanager-overview` item of that ConfigMapList, written as a ConfigMap of its own with the Grafana sidecar's `grafana_dashboard: "1"` label added, re-serialized by js-yaml. The dashboard JSON is unchanged. |
+| `agent-observability.yaml` | `chant build src --lexicon k8s` of `examples/agent-observability` as of #2954: collector ConfigMaps from the k8s collector composites, Prometheus's `rules.yml` from `ruleFileYaml`, and the Grafana dashboard, datasource and provider ConfigMaps from `GrafanaConfigMaps` (`@intentius/chant-lexicon-grafana/k8s`). |