@intentius/chant-lexicon-gcp 0.124.31 → 0.124.33

package/dist/serializer.js

@@ -0,0 +1,247 @@
+/**
+ * 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 { moduleSourceUrl } from "@intentius/chant/module-source";
+import { isPropertyDeclarable, isResourceDeclarable } from "@intentius/chant/declarable";
+import { ownershipEntries, LABEL_OWNERSHIP_KEYS } from "@intentius/chant/ownership";
+import { walkValue } from "@intentius/chant/serializer-walker";
+import { emitYAML } from "@intentius/chant/yaml";
+import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
+import { isDefaultLabels, isDefaultAnnotations } from "./default-labels.js";
+const require = createRequire(moduleSourceUrl(import.meta.url));
+let cachedGVKMap = null;
+function getGVKMap() {
+    if (cachedGVKMap)
+        return cachedGVKMap;
+    try {
+        cachedGVKMap = require("./generated/lexicon-gcp.json");
+    }
+    catch {
+        cachedGVKMap = {};
+    }
+    return cachedGVKMap;
+}
+/**
+ * Resolve entityType to apiVersion and kind.
+ *
+ * Exported for the read paths (./describe-resources.ts): the CNRM kind is the
+ * key into the applier's mapper table, and the packaged map is the only place
+ * that knows `GCP::Pubsub::Topic` is `PubSubTopic` rather than the naive
+ * `PubsubTopic` the fallback derivation would produce.
+ */
+export function resolveGVK(entityType) {
+    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) {
+    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) {
+    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 (!isResourceDeclarable(entity) || typeof entity.props !== "object" || entity.props === null) {
+                return undefined;
+            }
+            const props = entity.props;
+            const result = {};
+            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, entityNames) {
+    return walkValue(value, entityNames, gcpVisitor(entityNames));
+}
+/**
+ * A warning for each output of a gcp resource (#4181). Config Connector YAML
+ * has no outputs section, and a field such as `status.uri` exists only once
+ * the resource is applied, so the build cannot write the value anywhere. An
+ * output with no source lexicon (a literal or an intrinsic) is passed to
+ * every lexicon and is left to one that writes outputs.
+ */
+function unwritableOutputWarnings(outputs) {
+    return (outputs ?? [])
+        .filter((o) => o.sourceLexicon === "gcp")
+        .map((o) => `gcp: output "${o.outputName}" (${o.sourceEntity || "?"}.${o.sourceAttribute}) is not written: Config Connector YAML has no outputs, so the value exists only after apply. Read it from the live resource instead.`);
+}
+/**
+ * GCP Config Connector YAML serializer implementation.
+ */
+export const gcpSerializer = {
+    name: "gcp",
+    rulePrefix: "WGC",
+    serialize(entities, outputs, context) {
+        // Build reverse map: entity → name
+        const entityNames = new Map();
+        for (const [name, entity] of entities) {
+            entityNames.set(entity, name);
+        }
+        // Collect default labels and annotations. Ownership markers are stamped as
+        // labels (Config Connector resources carry them in metadata.labels).
+        let defaultLabelEntries = context?.ownership
+            ? { ...ownershipEntries(LABEL_OWNERSHIP_KEYS, context.ownership) }
+            : {};
+        let defaultAnnotationEntries = {};
+        for (const [, entity] of entities) {
+            if (isDefaultLabels(entity)) {
+                defaultLabelEntries = { ...defaultLabelEntries, ...entity.labels };
+            }
+            if (isDefaultAnnotations(entity)) {
+                defaultAnnotationEntries = { ...defaultAnnotationEntries, ...entity.annotations };
+            }
+        }
+        const documents = [];
+        for (const [name, entity] of entities) {
+            if (isPropertyDeclarable(entity))
+                continue;
+            if (isDefaultLabels(entity) || isDefaultAnnotations(entity))
+                continue;
+            const entityType = entity.entityType;
+            const gvk = resolveGVK(entityType);
+            if (!gvk)
+                continue;
+            const props = toYAMLValue(isResourceDeclarable(entity) ? entity.props : undefined, entityNames);
+            if (!props)
+                continue;
+            // Build the Config Connector manifest structure
+            const manifest = {
+                apiVersion: gvk.apiVersion,
+                kind: gvk.kind,
+            };
+            // Build metadata
+            const metadata = props.metadata ?? {};
+            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 ?? {});
+                metadata.labels = { ...defaultLabelEntries, ...existingLabels };
+            }
+            // Merge default annotations (resolve PseudoParameters to env-var strings)
+            if (Object.keys(defaultAnnotationEntries).length > 0) {
+                const resolvedAnnotations = {};
+                for (const [k, v] of Object.entries(defaultAnnotationEntries)) {
+                    resolvedAnnotations[k] = resolveAnnotationValue(v);
+                }
+                const existingAnnotations = (metadata.annotations ?? {});
+                metadata.annotations = { ...resolvedAnnotations, ...existingAnnotations };
+            }
+            manifest.metadata = metadata;
+            // All Config Connector resources use spec
+            const spec = {};
+            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);
+        }
+        const primary = documents.join("\n---\n");
+        const warnings = unwritableOutputWarnings(outputs);
+        return warnings.length > 0 ? { primary, warnings } : primary;
+    },
+};
+/**
+ * Pseudo-parameter → environment variable mapping.
+ * Config Connector annotations must be plain strings, so PseudoParameters
+ * are resolved from environment variables at build time.
+ */
+const PSEUDO_ENV_MAP = {
+    "GCP::ProjectId": { envVar: "GCP_PROJECT_ID", fallback: "PROJECT_ID" },
+    "GCP::Region": { envVar: "GCP_REGION", fallback: "us-central1" },
+    "GCP::Zone": { envVar: "GCP_ZONE", fallback: "us-central1-a" },
+};
+/**
+ * Resolve an annotation value to a plain string.
+ * PseudoParameter intrinsics are resolved from environment variables;
+ * other values pass through unchanged.
+ */
+function resolveAnnotationValue(value) {
+    if (typeof value === "object" && value !== null && INTRINSIC_MARKER in value) {
+        if ("toJSON" in value && typeof value.toJSON === "function") {
+            const json = value.toJSON();
+            if (json && typeof json === "object" && "Ref" in json && typeof json.Ref === "string") {
+                const mapping = PSEUDO_ENV_MAP[json.Ref];
+                if (mapping) {
+                    return process.env[mapping.envVar] ?? mapping.fallback;
+                }
+            }
+        }
+        return String(value);
+    }
+    return value;
+}
+/**
+ * Emit a key-value pair as YAML.
+ */
+function emitKeyValue(key, value) {
+    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) {
+    const orderedKeys = ["apiVersion", "kind", "metadata", "spec"];
+    const lines = [];
+    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";
+}

package/dist/spec/fetch.js

@@ -0,0 +1,107 @@
+/**
+ * Schema fetching — downloads Config Connector CRD bundle from GitHub releases.
+ *
+ * Uses the release bundle tar.gz, filtering for CRD YAML files.
+ */
+import { homedir } from "os";
+import { join } from "path";
+import { fetchWithCache, clearCacheFile } from "@intentius/chant/codegen/fetch";
+/** Per-attempt download timeout for a multi-megabyte archive. */
+const ARCHIVE_ATTEMPT_TIMEOUT_MS = 120000;
+/** A tagged archive never changes, so a cached copy stays good for a week. */
+const ARCHIVE_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Pinned Config Connector version for reproducible codegen.
+ */
+export const KCC_VERSION = "v1.152.0";
+const CACHE_DIR = join(homedir(), ".chant");
+function bundleUrl(version) {
+    // The release-bundle.tar.gz asset is no longer published.
+    // Use GitHub's auto-generated source tarball instead — CRDs are at config/crds/resources/.
+    return `https://github.com/GoogleCloudPlatform/k8s-config-connector/archive/refs/tags/${version}.tar.gz`;
+}
+function cacheFile(version) {
+    return join(CACHE_DIR, `kcc-crds-${version}.tar.gz`);
+}
+/**
+ * Fetch the Config Connector CRD bundle and extract CRD YAML files.
+ *
+ * Returns a Map keyed by CRD filename (e.g., "computeinstance.yaml") with
+ * the raw YAML content as a Buffer.
+ */
+export async function fetchCRDBundle(force = false, version = KCC_VERSION) {
+    const url = bundleUrl(version);
+    const cache = cacheFile(version);
+    // The archive is a whole source tree at a pinned tag: tens of megabytes,
+    // immutable, so it gets a long attempt and a week of cache.
+    const tarData = await fetchWithCache({ url, cacheFile: cache, attemptTimeoutMs: ARCHIVE_ATTEMPT_TIMEOUT_MS, cacheTtlMs: ARCHIVE_CACHE_TTL_MS }, force);
+    return extractCRDs(tarData);
+}
+/**
+ * Extract CRD YAML files from a tar.gz bundle.
+ *
+ * Filters for entries under a crds/ directory or standalone CRD YAML files.
+ */
+async function extractCRDs(tarData) {
+    const { gunzipSync } = await import("fflate");
+    const crds = new Map();
+    // Decompress gzip synchronously (avoids lingering event loop references)
+    const gunzipped = gunzipSync(new Uint8Array(tarData));
+    // Parse tar (512-byte header blocks) with PAX extended header support.
+    // GitHub source tarballs use PAX headers (type 'x') for long filenames.
+    let offset = 0;
+    const data = gunzipped;
+    let paxPath = null;
+    while (offset < data.length - 512) {
+        const header = data.slice(offset, offset + 512);
+        offset += 512;
+        if (header.every((b) => b === 0))
+            break;
+        // Extract filename: ustar prefix (bytes 345-499) + name (bytes 0-99)
+        const nameBytes = header.slice(0, 100);
+        const nameEnd = nameBytes.indexOf(0);
+        let name = new TextDecoder().decode(nameBytes.slice(0, nameEnd > 0 ? nameEnd : 100)).trim();
+        const prefixBytes = header.slice(345, 500);
+        const prefixEnd = prefixBytes.indexOf(0);
+        const ustarPrefix = new TextDecoder().decode(prefixBytes.slice(0, prefixEnd > 0 ? prefixEnd : 155)).trim();
+        if (ustarPrefix)
+            name = `${ustarPrefix}/${name}`;
+        const sizeStr = new TextDecoder().decode(header.slice(124, 136)).trim().replace(/\0/g, "");
+        const size = parseInt(sizeStr, 8) || 0;
+        const typeFlag = header[156];
+        const typeFlagChar = String.fromCharCode(typeFlag);
+        const blocks = Math.ceil(size / 512);
+        const fileData = data.slice(offset, offset + size);
+        offset += blocks * 512;
+        // PAX extended header — extract path= for the next entry
+        if (typeFlagChar === "x") {
+            const paxStr = new TextDecoder().decode(fileData);
+            const match = paxStr.match(/\bpath=([^\n]+)/);
+            if (match)
+                paxPath = match[1];
+            continue;
+        }
+        // Use PAX path if available, then reset
+        if (paxPath) {
+            name = paxPath;
+            paxPath = null;
+        }
+        // Only process regular files
+        if (typeFlag !== 48 && typeFlag !== 0)
+            continue;
+        if (size === 0)
+            continue;
+        // Match CRD YAML files — source tarball has them at config/crds/resources/
+        if (name.includes("config/crds/resources/") && name.endsWith(".yaml")) {
+            const basename = name.split("/").pop() || name;
+            crds.set(basename, Buffer.from(fileData));
+        }
+    }
+    return crds;
+}
+export function getCachePath(version = KCC_VERSION) {
+    return cacheFile(version);
+}
+export function clearCache(version = KCC_VERSION) {
+    clearCacheFile(cacheFile(version));
+}

package/dist/spec/parse.d.ts

@@ -4,7 +4,7 @@
  * Adapts the K8s CRD parser pattern for GCP-specific concerns:
  * - Type naming: GCP::{Service}::{Kind}
  * - resourceRef detection
- * - Status field skipping
+ * - Status fields skipped as props; scalar ones become attributes
  */
 import type { PropertyConstraints } from "@intentius/chant/codegen/json-schema";
 export interface ParsedProperty {