@intentius/chant-lexicon-gcp 0.0.15

package/src/pseudo.ts

@@ -0,0 +1,19 @@
+import { PseudoParameter, createPseudoParameters } from "@intentius/chant/pseudo-parameter";
+
+export { PseudoParameter };
+
+export const { ProjectId, Region, Zone } =
+  createPseudoParameters({
+    ProjectId: "GCP::ProjectId",
+    Region: "GCP::Region",
+    Zone: "GCP::Zone",
+  });
+
+/**
+ * GCP namespace containing all pseudo-parameters.
+ */
+export const GCP = {
+  ProjectId,
+  Region,
+  Zone,
+} as const;

package/src/serializer.test.ts

@@ -0,0 +1,250 @@
+import { describe, test, expect } from "bun:test";
+import { gcpSerializer } from "./serializer";
+import { DECLARABLE_MARKER } from "@intentius/chant/declarable";
+import {
+  defaultLabels,
+  defaultAnnotations,
+  DEFAULT_LABELS_MARKER,
+  DEFAULT_ANNOTATIONS_MARKER,
+} from "./default-labels";
+
+// ── Mock helpers ────────────────────────────────────────────────────
+
+function mockResource(
+  entityType: string,
+  props: Record<string, unknown>,
+): any {
+  return {
+    [DECLARABLE_MARKER]: true,
+    lexicon: "gcp",
+    entityType,
+    kind: "resource",
+    props,
+  };
+}
+
+function mockProperty(
+  entityType: string,
+  props: Record<string, unknown>,
+): any {
+  return {
+    [DECLARABLE_MARKER]: true,
+    lexicon: "gcp",
+    entityType,
+    kind: "property",
+    props,
+  };
+}
+
+// ── Tests ───────────────────────────────────────────────────────────
+
+describe("gcpSerializer", () => {
+  test("name is gcp", () => {
+    expect(gcpSerializer.name).toBe("gcp");
+  });
+
+  test("rulePrefix is WGC", () => {
+    expect(gcpSerializer.rulePrefix).toBe("WGC");
+  });
+
+  test("empty entities produce empty string", () => {
+    const result = gcpSerializer.serialize(new Map());
+    expect(result).toBe("");
+  });
+
+  test("single resource produces valid YAML with apiVersion/kind/metadata/spec", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "myBucket",
+      mockResource("GCP::Storage::Bucket", {
+        location: "US",
+        storageClass: "STANDARD",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("apiVersion:");
+    expect(result).toContain("kind:");
+    expect(result).toContain("metadata:");
+    expect(result).toContain("spec:");
+    expect(result).toContain("location: US");
+    expect(result).toContain("storageClass: STANDARD");
+  });
+
+  test("metadata.name auto-generated from logical name (camelCase→kebab-case)", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "myDataBucket",
+      mockResource("GCP::Storage::Bucket", {
+        location: "US",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("name: my-data-bucket");
+  });
+
+  test("explicit metadata.name preserved", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "myBucket",
+      mockResource("GCP::Storage::Bucket", {
+        metadata: { name: "custom-bucket-name" },
+        location: "US",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("name: custom-bucket-name");
+  });
+
+  test("all GCP resources use spec (no specless types)", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "instance",
+      mockResource("GCP::Compute::Instance", {
+        machineType: "e2-medium",
+        zone: "us-central1-a",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("spec:");
+    expect(result).toContain("machineType: e2-medium");
+  });
+
+  test("multi-resource entities joined by ---", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "bucket",
+      mockResource("GCP::Storage::Bucket", {
+        location: "US",
+      }),
+    );
+    entities.set(
+      "instance",
+      mockResource("GCP::Compute::Instance", {
+        machineType: "e2-medium",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("---");
+  });
+
+  test("default labels merged into metadata.labels", () => {
+    const entities = new Map<string, any>();
+    entities.set("labels", defaultLabels({ env: "prod" }));
+    entities.set(
+      "bucket",
+      mockResource("GCP::Storage::Bucket", {
+        location: "US",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("env: prod");
+  });
+
+  test("default annotations merged into metadata.annotations", () => {
+    const entities = new Map<string, any>();
+    entities.set("annot", defaultAnnotations({ "cnrm.cloud.google.com/project-id": "my-project" }));
+    entities.set(
+      "bucket",
+      mockResource("GCP::Storage::Bucket", {
+        location: "US",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("cnrm.cloud.google.com/project-id: my-project");
+  });
+
+  test("explicit labels override default labels", () => {
+    const entities = new Map<string, any>();
+    entities.set("labels", defaultLabels({ env: "dev" }));
+    entities.set(
+      "bucket",
+      mockResource("GCP::Storage::Bucket", {
+        metadata: { labels: { env: "prod" } },
+        location: "US",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("env: prod");
+    // Should not contain "dev" since explicit overrides
+    const envLines = result.split("\n").filter((l: string) => l.includes("env:"));
+    expect(envLines.every((l: string) => !l.includes("dev"))).toBe(true);
+  });
+
+  test("property entities skipped in output", () => {
+    const entities = new Map<string, any>();
+    entities.set("netConfig", mockProperty("GCP::Compute::NetworkConfig", { name: "config" }));
+    entities.set(
+      "instance",
+      mockResource("GCP::Compute::Instance", {
+        machineType: "e2-medium",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    // Only one document — property entities should not appear as separate docs
+    expect(result.split("---").length).toBeLessThanOrEqual(2);
+  });
+
+  test("DefaultLabels entities skipped in output", () => {
+    const entities = new Map<string, any>();
+    entities.set("labels", defaultLabels({ env: "prod" }));
+
+    const result = gcpSerializer.serialize(entities);
+    // defaultLabels alone should not produce any output
+    expect(result).toBe("");
+  });
+
+  test("DefaultAnnotations entities skipped in output", () => {
+    const entities = new Map<string, any>();
+    entities.set("annotations", defaultAnnotations({ note: "hi" }));
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toBe("");
+  });
+
+  test("key ordering: apiVersion, kind, metadata, spec", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "bucket",
+      mockResource("GCP::Storage::Bucket", {
+        location: "US",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    const lines = result.split("\n");
+    const keyLines = lines.filter((l: string) => /^\w+:/.test(l));
+    const keys = keyLines.map((l: string) => l.split(":")[0]);
+
+    const apiIdx = keys.indexOf("apiVersion");
+    const kindIdx = keys.indexOf("kind");
+    const metaIdx = keys.indexOf("metadata");
+    const specIdx = keys.indexOf("spec");
+
+    expect(apiIdx).toBeLessThan(kindIdx);
+    expect(kindIdx).toBeLessThan(metaIdx);
+    expect(metaIdx).toBeLessThan(specIdx);
+  });
+
+  test("fallback GVK derivation (GCP::Compute::Instance → compute.cnrm.cloud.google.com/v1beta1)", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "myInstance",
+      mockResource("GCP::Compute::Instance", {
+        machineType: "e2-medium",
+      }),
+    );
+
+    const result = gcpSerializer.serialize(entities);
+    expect(result).toContain("compute.cnrm.cloud.google.com/v1beta1");
+    expect(result).toContain("ComputeInstance");
+  });
+});

package/src/serializer.ts

@@ -0,0 +1,232 @@
+/**
+ * GCP Config Connector YAML serializer.
+ *
+ * Converts Chant declarables to multi-document K8s YAML output
+ * for Config Connector resources with apiVersion, kind, metadata, and spec.
+ */
+
+import { createRequire } from "module";
+import type { Declarable } from "@intentius/chant/declarable";
+import { isPropertyDeclarable } from "@intentius/chant/declarable";
+import type { Serializer, SerializerResult } from "@intentius/chant/serializer";
+import type { LexiconOutput } from "@intentius/chant/lexicon-output";
+import { walkValue, type SerializerVisitor } from "@intentius/chant/serializer-walker";
+import { emitYAML } from "@intentius/chant/yaml";
+import { isDefaultLabels, isDefaultAnnotations, type DefaultLabels, type DefaultAnnotations } from "./default-labels";
+
+const require = createRequire(import.meta.url);
+
+/**
+ * GVK mapping entry — loaded from generated lexicon-gcp.json.
+ */
+interface GVKEntry {
+  resourceType: string;
+  kind: "resource" | "property";
+  apiVersion?: string;
+  gvkKind?: string;
+  group?: string;
+}
+
+let cachedGVKMap: Record<string, GVKEntry> | null = null;
+
+function getGVKMap(): Record<string, GVKEntry> {
+  if (cachedGVKMap) return cachedGVKMap;
+  try {
+    cachedGVKMap = require("./generated/lexicon-gcp.json") as Record<string, GVKEntry>;
+  } catch {
+    cachedGVKMap = {};
+  }
+  return cachedGVKMap!;
+}
+
+/**
+ * Resolve entityType to apiVersion and kind.
+ */
+function resolveGVK(entityType: string): { apiVersion: string; kind: string } | null {
+  const gvkMap = getGVKMap();
+
+  for (const entry of Object.values(gvkMap)) {
+    if (entry.resourceType === entityType && entry.apiVersion && entry.gvkKind) {
+      return { apiVersion: entry.apiVersion, kind: entry.gvkKind };
+    }
+  }
+
+  // Fallback: derive from entity type string (GCP::Service::Kind → service.cnrm.cloud.google.com/v1beta1, Kind)
+  return deriveGVKFromType(entityType);
+}
+
+/**
+ * Derive GVK from a GCP type name.
+ * "GCP::Compute::Instance" → { apiVersion: "compute.cnrm.cloud.google.com/v1beta1", kind: "ComputeInstance" }
+ */
+function deriveGVKFromType(entityType: string): { apiVersion: string; kind: string } | null {
+  const parts = entityType.split("::");
+  if (parts.length !== 3 || parts[0] !== "GCP") return null;
+
+  const service = parts[1].toLowerCase();
+  const shortKind = parts[2];
+  const group = `${service}.cnrm.cloud.google.com`;
+  const apiVersion = `${group}/v1beta1`;
+  const kind = `${parts[1]}${shortKind}`;
+
+  return { apiVersion, kind };
+}
+
+/**
+ * GCP visitor for the generic serializer walker.
+ */
+function gcpVisitor(entityNames: Map<Declarable, string>): SerializerVisitor {
+  return {
+    attrRef: (name, _attr) => {
+      // For Config Connector, references resolve to metadata.name
+      return name;
+    },
+    resourceRef: (name) => {
+      // Config Connector uses resourceRef pattern: { name: "resource-name" }
+      return { name };
+    },
+    propertyDeclarable: (entity, walk) => {
+      if (!("props" in entity) || typeof entity.props !== "object" || entity.props === null) {
+        return undefined;
+      }
+      const props = entity.props as Record<string, unknown>;
+      const result: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(props)) {
+        if (value !== undefined) {
+          result[key] = walk(value);
+        }
+      }
+      return Object.keys(result).length > 0 ? result : undefined;
+    },
+  };
+}
+
+/**
+ * Convert a value to YAML-compatible form using the walker.
+ */
+function toYAMLValue(value: unknown, entityNames: Map<Declarable, string>): unknown {
+  return walkValue(value, entityNames, gcpVisitor(entityNames));
+}
+
+/**
+ * GCP Config Connector YAML serializer implementation.
+ */
+export const gcpSerializer: Serializer = {
+  name: "gcp",
+  rulePrefix: "WGC",
+
+  serialize(entities: Map<string, Declarable>, _outputs?: LexiconOutput[]): string {
+    // Build reverse map: entity → name
+    const entityNames = new Map<Declarable, string>();
+    for (const [name, entity] of entities) {
+      entityNames.set(entity, name);
+    }
+
+    // Collect default labels and annotations
+    let defaultLabelEntries: Record<string, unknown> = {};
+    let defaultAnnotationEntries: Record<string, unknown> = {};
+
+    for (const [, entity] of entities) {
+      if (isDefaultLabels(entity)) {
+        defaultLabelEntries = { ...defaultLabelEntries, ...(entity as DefaultLabels).labels };
+      }
+      if (isDefaultAnnotations(entity)) {
+        defaultAnnotationEntries = { ...defaultAnnotationEntries, ...(entity as DefaultAnnotations).annotations };
+      }
+    }
+
+    const documents: string[] = [];
+
+    for (const [name, entity] of entities) {
+      if (isPropertyDeclarable(entity)) continue;
+      if (isDefaultLabels(entity) || isDefaultAnnotations(entity)) continue;
+
+      const entityType = (entity as unknown as Record<string, unknown>).entityType as string;
+      const gvk = resolveGVK(entityType);
+      if (!gvk) continue;
+
+      const props = toYAMLValue(
+        (entity as unknown as Record<string, unknown>).props,
+        entityNames,
+      ) as Record<string, unknown> | undefined;
+
+      if (!props) continue;
+
+      // Build the Config Connector manifest structure
+      const manifest: Record<string, unknown> = {
+        apiVersion: gvk.apiVersion,
+        kind: gvk.kind,
+      };
+
+      // Build metadata
+      const metadata: Record<string, unknown> = props.metadata as Record<string, unknown> ?? {};
+      if (!metadata.name) {
+        metadata.name = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      }
+
+      // Merge default labels
+      if (Object.keys(defaultLabelEntries).length > 0) {
+        const existingLabels = (metadata.labels ?? {}) as Record<string, unknown>;
+        metadata.labels = { ...defaultLabelEntries, ...existingLabels };
+      }
+
+      // Merge default annotations
+      if (Object.keys(defaultAnnotationEntries).length > 0) {
+        const existingAnnotations = (metadata.annotations ?? {}) as Record<string, unknown>;
+        metadata.annotations = { ...defaultAnnotationEntries, ...existingAnnotations };
+      }
+
+      manifest.metadata = metadata;
+
+      // All Config Connector resources use spec
+      const spec: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(props)) {
+        if (key !== "metadata") {
+          spec[key] = value;
+        }
+      }
+      if (Object.keys(spec).length > 0) {
+        manifest.spec = spec;
+      }
+
+      const yamlDoc = emitK8sManifest(manifest);
+      documents.push(yamlDoc);
+    }
+
+    return documents.join("\n---\n");
+  },
+};
+
+/**
+ * Emit a key-value pair as YAML.
+ */
+function emitKeyValue(key: string, value: unknown): string {
+  const yamlStr = emitYAML(value, 1);
+  if (yamlStr.startsWith("\n")) {
+    return `${key}:${yamlStr}`;
+  }
+  return `${key}: ${yamlStr}`;
+}
+
+/**
+ * Emit a Config Connector manifest object as YAML.
+ * Preserves key ordering: apiVersion, kind, metadata, spec.
+ */
+function emitK8sManifest(manifest: Record<string, unknown>): string {
+  const orderedKeys = ["apiVersion", "kind", "metadata", "spec"];
+  const lines: string[] = [];
+
+  for (const key of orderedKeys) {
+    if (manifest[key] !== undefined) {
+      lines.push(emitKeyValue(key, manifest[key]));
+    }
+  }
+
+  for (const [key, value] of Object.entries(manifest)) {
+    if (!orderedKeys.includes(key) && value !== undefined) {
+      lines.push(emitKeyValue(key, value));
+    }
+  }
+
+  return lines.join("\n") + "\n";
+}