@intentius/chant-lexicon-gcp 0.124.31 → 0.124.33

package/dist/spec/parse.js

@@ -0,0 +1,339 @@
+/**
+ * CRD parser for GCP Config Connector resources.
+ *
+ * Adapts the K8s CRD parser pattern for GCP-specific concerns:
+ * - Type naming: GCP::{Service}::{Kind}
+ * - resourceRef detection
+ * - Status fields skipped as props; scalar ones become attributes
+ */
+import yaml from "js-yaml";
+// ── Naming helpers ──────────────────────────────────────────────────
+/**
+ * Extract GCP service name from a CNRM group.
+ * "compute.cnrm.cloud.google.com" → "Compute"
+ */
+export function gcpServiceName(group) {
+    const firstSegment = group.split(".")[0];
+    return firstSegment.charAt(0).toUpperCase() + firstSegment.slice(1);
+}
+/**
+ * Strip the service prefix from a CRD kind.
+ * "ComputeInstance", "Compute" → "Instance"
+ * "IAMPolicyMember", "Iam" → "PolicyMember"
+ */
+export function stripServicePrefix(kind, service) {
+    // Direct match (e.g., "Compute" prefix in "ComputeInstance")
+    if (kind.startsWith(service)) {
+        const rest = kind.slice(service.length);
+        if (rest.length > 0 && rest[0] === rest[0].toUpperCase()) {
+            return rest;
+        }
+    }
+    // Case-insensitive match (e.g., "IAM" prefix when service is "Iam")
+    const kindLower = kind.toLowerCase();
+    const serviceLower = service.toLowerCase();
+    if (kindLower.startsWith(serviceLower)) {
+        const rest = kind.slice(service.length);
+        if (rest.length > 0 && rest[0] === rest[0].toUpperCase()) {
+            return rest;
+        }
+    }
+    return kind;
+}
+/**
+ * Build full GCP type name.
+ * "compute.cnrm.cloud.google.com", "ComputeInstance" → "GCP::Compute::Instance"
+ */
+export function gcpTypeName(group, kind) {
+    const service = gcpServiceName(group);
+    const shortKind = stripServicePrefix(kind, service);
+    return `GCP::${service}::${shortKind}`;
+}
+/**
+ * Extract short name from a GCP type.
+ * "GCP::Compute::Instance" → "Instance"
+ */
+export function gcpShortName(typeName) {
+    const parts = typeName.split("::");
+    return parts[parts.length - 1];
+}
+// ── CRD Parsing ─────────────────────────────────────────────────────
+/**
+ * Parse a CRD YAML document string into GcpParseResult entries.
+ * Supports multi-document YAML for CRD bundles.
+ */
+export function parseGcpCRD(content) {
+    const text = typeof content === "string" ? content : content.toString("utf-8");
+    const results = [];
+    const documents = text
+        .split(/^---\s*$/m)
+        .map((d) => d.trim())
+        .filter((d) => d.length > 0);
+    for (const docStr of documents) {
+        const doc = yaml.load(docStr);
+        if (!doc || doc.kind !== "CustomResourceDefinition")
+            continue;
+        const spec = doc.spec;
+        if (!spec?.group || !spec?.names?.kind || !spec?.versions)
+            continue;
+        // Only process groups that are Config Connector CRDs
+        if (!spec.group.includes("cnrm.cloud.google.com"))
+            continue;
+        const crdResults = parseCRDSpec(spec);
+        results.push(...crdResults);
+    }
+    return results;
+}
+/**
+ * Parse a CRD spec into GcpParseResult entries.
+ */
+function parseCRDSpec(spec) {
+    const results = [];
+    // Find the storage version (canonical)
+    const storageVersion = spec.versions.find((v) => v.storage && v.served);
+    const targetVersion = storageVersion ?? spec.versions.find((v) => v.served);
+    if (!targetVersion)
+        return results;
+    const typeName = gcpTypeName(spec.group, spec.names.kind);
+    const gvk = {
+        group: spec.group,
+        version: targetVersion.name,
+        kind: spec.names.kind,
+    };
+    const schema = targetVersion.schema?.openAPIV3Schema;
+    const specSchema = schema?.properties?.spec;
+    const properties = specSchema ? extractSpecProperties(specSchema) : [];
+    const propertyTypes = specSchema ? extractPropertyTypes(specSchema, typeName) : [];
+    const enums = specSchema ? extractEnums(specSchema, typeName) : [];
+    results.push({
+        resource: {
+            typeName,
+            description: `Config Connector resource: ${spec.names.kind} (${spec.group})`,
+            properties,
+            attributes: [
+                { name: "name", tsType: "string" },
+                { name: "namespace", tsType: "string" },
+                { name: "uid", tsType: "string" },
+                ...statusAttributes(schema?.properties?.status),
+            ],
+            deprecatedProperties: [],
+        },
+        propertyTypes,
+        enums,
+        gvk,
+    });
+    return results;
+}
+/**
+ * The scalar top-level fields of a CRD's `status`, such as RunService's
+ * `status.uri` (#4179), as dotted attribute names. Config Connector fills them
+ * once the resource is ready, so they can't appear in the resource's own
+ * YAML, but another lexicon or an output can reference them.
+ */
+function statusAttributes(statusSchema) {
+    const out = [];
+    for (const [name, prop] of Object.entries(statusSchema?.properties ?? {})) {
+        if (prop.type !== "string" && prop.type !== "integer" && prop.type !== "number" && prop.type !== "boolean")
+            continue;
+        out.push({ name: `status.${name}`, tsType: resolveSchemaType(prop) });
+    }
+    return out;
+}
+// ── Property extraction ─────────────────────────────────────────────
+/**
+ * Extract properties from the spec sub-object of a CRD schema.
+ */
+function extractSpecProperties(specSchema) {
+    const result = [];
+    const props = specSchema.properties ?? {};
+    const requiredSet = new Set(specSchema.required ?? []);
+    for (const [name, prop] of Object.entries(props)) {
+        const isRef = isResourceRef(prop);
+        result.push({
+            name,
+            tsType: resolveSchemaType(prop),
+            required: requiredSet.has(name),
+            description: prop.description,
+            enum: prop.enum,
+            constraints: extractConstraints(prop),
+            ...(isRef && { isResourceRef: true }),
+        });
+    }
+    return result;
+}
+/**
+ * Detect Config Connector resourceRef fields.
+ * These typically have `name` and `external` sub-properties,
+ * optionally with `namespace`, `kind`, and `apiVersion`.
+ */
+function isResourceRef(schema) {
+    if (schema.type !== "object" || !schema.properties)
+        return false;
+    const keys = new Set(Object.keys(schema.properties));
+    // Must have either `name` or `external`
+    if (!keys.has("name") && !keys.has("external"))
+        return false;
+    // Must be a small object with only ref-like keys
+    const refKeys = new Set(["name", "external", "namespace", "kind", "apiVersion"]);
+    for (const key of keys) {
+        if (!refKeys.has(key))
+            return false;
+    }
+    return keys.size >= 2;
+}
+/**
+ * Extract nested object types as ParsedPropertyType entries.
+ */
+function extractPropertyTypes(specSchema, parentTypeName) {
+    const results = [];
+    const props = specSchema.properties ?? {};
+    for (const [name, prop] of Object.entries(props)) {
+        // Skip resourceRef fields — they are treated as references, not nested types
+        if (isResourceRef(prop))
+            continue;
+        // Inline object definitions
+        if (prop.type === "object" && prop.properties) {
+            const ptName = `${parentTypeName}::${pascalCase(name)}`;
+            const requiredSet = new Set(prop.required ?? []);
+            results.push({
+                name: ptName,
+                specType: name,
+                properties: Object.entries(prop.properties).map(([pName, pSchema]) => ({
+                    name: pName,
+                    tsType: resolveSchemaType(pSchema),
+                    required: requiredSet.has(pName),
+                    description: pSchema.description,
+                    enum: pSchema.enum,
+                    constraints: extractConstraints(pSchema),
+                    ...(isResourceRef(pSchema) && { isResourceRef: true }),
+                })),
+            });
+            // Recurse into nested objects
+            for (const [subName, subProp] of Object.entries(prop.properties)) {
+                if (subProp.type === "object" && subProp.properties && !isResourceRef(subProp)) {
+                    const subPtName = `${ptName}::${pascalCase(subName)}`;
+                    const subRequiredSet = new Set(subProp.required ?? []);
+                    results.push({
+                        name: subPtName,
+                        specType: subName,
+                        properties: Object.entries(subProp.properties).map(([spName, spSchema]) => ({
+                            name: spName,
+                            tsType: resolveSchemaType(spSchema),
+                            required: subRequiredSet.has(spName),
+                            description: spSchema.description,
+                            enum: spSchema.enum,
+                            constraints: extractConstraints(spSchema),
+                        })),
+                    });
+                }
+            }
+        }
+        // Array of objects
+        if (prop.type === "array" && prop.items?.type === "object" && prop.items.properties) {
+            if (isResourceRef(prop.items))
+                continue;
+            const itemSchema = prop.items;
+            const ptName = `${parentTypeName}::${pascalCase(singularize(name))}`;
+            const requiredSet = new Set(itemSchema.required ?? []);
+            results.push({
+                name: ptName,
+                specType: name,
+                properties: Object.entries(itemSchema.properties).map(([pName, pSchema]) => ({
+                    name: pName,
+                    tsType: resolveSchemaType(pSchema),
+                    required: requiredSet.has(pName),
+                    description: pSchema.description,
+                    enum: pSchema.enum,
+                    constraints: extractConstraints(pSchema),
+                    ...(isResourceRef(pSchema) && { isResourceRef: true }),
+                })),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Extract enum types from the spec schema.
+ */
+function extractEnums(specSchema, parentTypeName) {
+    const results = [];
+    const props = specSchema.properties ?? {};
+    for (const [name, prop] of Object.entries(props)) {
+        if (prop.enum && prop.enum.length > 0) {
+            results.push({
+                name: `${parentTypeName}::${pascalCase(name)}`,
+                values: prop.enum,
+            });
+        }
+    }
+    return results;
+}
+// ── Schema type resolution ──────────────────────────────────────────
+function resolveSchemaType(schema) {
+    if (!schema)
+        return "any";
+    if (schema["x-kubernetes-int-or-string"])
+        return "string | number";
+    if (schema["x-kubernetes-preserve-unknown-fields"])
+        return "Record<string, any>";
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    switch (schema.type) {
+        case "string":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "array":
+            if (schema.items) {
+                const itemType = resolveSchemaType(schema.items);
+                if (itemType.includes(" | "))
+                    return `(${itemType})[]`;
+                return `${itemType}[]`;
+            }
+            return "any[]";
+        case "object":
+            if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+                const valueType = resolveSchemaType(schema.additionalProperties);
+                return `Record<string, ${valueType}>`;
+            }
+            if (schema.properties)
+                return "Record<string, any>"; // will be a property type
+            return "Record<string, any>";
+        default:
+            return "any";
+    }
+}
+function extractConstraints(schema) {
+    const constraints = {};
+    if (schema.minimum !== undefined)
+        constraints.minimum = schema.minimum;
+    if (schema.maximum !== undefined)
+        constraints.maximum = schema.maximum;
+    if (schema.minLength !== undefined)
+        constraints.minLength = schema.minLength;
+    if (schema.maxLength !== undefined)
+        constraints.maxLength = schema.maxLength;
+    if (schema.pattern !== undefined)
+        constraints.pattern = schema.pattern;
+    return constraints;
+}
+// ── Utilities ───────────────────────────────────────────────────────
+function pascalCase(str) {
+    return str
+        .split(/[-_.]/)
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join("");
+}
+function singularize(str) {
+    if (str.endsWith("ies"))
+        return str.slice(0, -3) + "y";
+    if (str.endsWith("ses"))
+        return str.slice(0, -2);
+    if (str.endsWith("s") && !str.endsWith("ss"))
+        return str.slice(0, -1);
+    return str;
+}