@intentius/chant-lexicon-gcp 0.124.31 → 0.124.32

package/dist/serializer.js

@@ -0,0 +1,233 @@
+/**
+ * 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));
+}
+/**
+ * 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);
+        }
+        return documents.join("\n---\n");
+    },
+};
+/**
+ * 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.js

@@ -0,0 +1,323 @@
+/**
+ * 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 field skipping
+ */
+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" },
+            ],
+            deprecatedProperties: [],
+        },
+        propertyTypes,
+        enums,
+        gvk,
+    });
+    return results;
+}
+// ── 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;
+}

package/dist/validate-cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env tsx
+import { validate } from "./validate.js";
+import { printValidationResult } from "@intentius/chant/codegen/validate";
+async function main() {
+    const result = await validate();
+    printValidationResult(result);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});