@intentius/chant-lexicon-gcp 0.0.15

package/src/generated/runtime.ts

@@ -0,0 +1,4 @@
+/**
+ * Runtime factory constructors — re-exported from core.
+ */
+export { createResource, createProperty } from "@intentius/chant/runtime";

package/src/import/generator.test.ts

@@ -0,0 +1,125 @@
+import { describe, test, expect } from "bun:test";
+import { GcpGenerator } from "./generator";
+
+const generator = new GcpGenerator();
+
+function makeIR(resources: any[]) {
+  return { resources, parameters: [], outputs: [] };
+}
+
+describe("GcpGenerator", () => {
+  test("generates valid TypeScript from IR", () => {
+    const ir = makeIR([
+      {
+        logicalName: "my-bucket",
+        type: "GCP::Storage::Bucket",
+        properties: {
+          metadata: { name: "my-bucket" },
+          location: "US",
+        },
+      },
+    ]);
+    const result = generator.generate(ir);
+    expect(result).toContain("import");
+    expect(result).toContain("Bucket");
+  });
+
+  test("correct import source (@intentius/chant-lexicon-gcp)", () => {
+    const ir = makeIR([
+      {
+        logicalName: "my-bucket",
+        type: "GCP::Storage::Bucket",
+        properties: { location: "US" },
+      },
+    ]);
+    const result = generator.generate(ir);
+    expect(result).toContain('from "@intentius/chant-lexicon-gcp"');
+  });
+
+  test("multiple resources produce multiple exports", () => {
+    const ir = makeIR([
+      {
+        logicalName: "my-bucket",
+        type: "GCP::Storage::Bucket",
+        properties: { location: "US" },
+      },
+      {
+        logicalName: "my-vm",
+        type: "GCP::Compute::Instance",
+        properties: { machineType: "e2-medium" },
+      },
+    ]);
+    const result = generator.generate(ir);
+    expect(result).toContain("export const myBucket");
+    expect(result).toContain("export const myVm");
+  });
+
+  test("camelCase variable names from kebab-case logical names", () => {
+    const ir = makeIR([
+      {
+        logicalName: "my-data-bucket",
+        type: "GCP::Storage::Bucket",
+        properties: { location: "US" },
+      },
+    ]);
+    const result = generator.generate(ir);
+    expect(result).toContain("export const myDataBucket");
+  });
+
+  test("empty IR produces minimal output", () => {
+    const ir = makeIR([]);
+    const result = generator.generate(ir);
+    // Should still produce valid TypeScript, even if no resources
+    expect(typeof result).toBe("string");
+  });
+
+  test("nested object formatting", () => {
+    const ir = makeIR([
+      {
+        logicalName: "my-bucket",
+        type: "GCP::Storage::Bucket",
+        properties: {
+          location: "US",
+          versioning: { enabled: true },
+        },
+      },
+    ]);
+    const result = generator.generate(ir);
+    expect(result).toContain("versioning:");
+    expect(result).toContain("enabled: true");
+  });
+
+  test("uses new Constructor() syntax", () => {
+    const ir = makeIR([
+      {
+        logicalName: "my-bucket",
+        type: "GCP::Storage::Bucket",
+        properties: { location: "US" },
+      },
+    ]);
+    const result = generator.generate(ir);
+    expect(result).toContain("new Bucket(");
+  });
+
+  test("sorts imports alphabetically", () => {
+    const ir = makeIR([
+      {
+        logicalName: "vm",
+        type: "GCP::Compute::Instance",
+        properties: { machineType: "e2-medium" },
+      },
+      {
+        logicalName: "bucket",
+        type: "GCP::Storage::Bucket",
+        properties: { location: "US" },
+      },
+    ]);
+    const result = generator.generate(ir);
+    const importLine = result.split("\n").find((l: string) => l.startsWith("import"));
+    expect(importLine).toBeDefined();
+    // Bucket should come before Instance alphabetically
+    const bucketIdx = importLine!.indexOf("Bucket");
+    const instanceIdx = importLine!.indexOf("Instance");
+    expect(bucketIdx).toBeLessThan(instanceIdx);
+  });
+});

package/src/import/generator.ts

@@ -0,0 +1,82 @@
+/**
+ * Config Connector TypeScript generator.
+ *
+ * Converts import IR from the parser into typed chant TypeScript code.
+ */
+
+import type { TypeScriptGenerator, TemplateIR } from "@intentius/chant/import/generator";
+
+export class GcpGenerator implements TypeScriptGenerator {
+  generate(ir: TemplateIR): string {
+    const lines: string[] = [];
+    const imports = new Set<string>();
+
+    // Collect imports
+    for (const resource of ir.resources) {
+      const parts = resource.type.split("::");
+      if (parts.length >= 3) {
+        // Use the short name for the import
+        imports.add(parts[2]);
+      }
+    }
+
+    if (imports.size > 0) {
+      lines.push(
+        `import { ${[...imports].sort().join(", ")} } from "@intentius/chant-lexicon-gcp";`,
+      );
+      lines.push("");
+    }
+
+    // Generate resource declarations
+    for (const resource of ir.resources) {
+      const parts = resource.type.split("::");
+      const className = parts.length >= 3 ? parts[2] : resource.type;
+      const varName = camelCase(resource.logicalName);
+
+      lines.push(`export const ${varName} = new ${className}(${formatProps(resource.properties, 0)});`);
+      lines.push("");
+    }
+
+    return lines.join("\n");
+  }
+}
+
+function camelCase(str: string): string {
+  return str
+    .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+    .replace(/^(.)/, (_, c) => c.toLowerCase());
+}
+
+function formatProps(props: Record<string, unknown>, indent: number): string {
+  const entries = Object.entries(props);
+  if (entries.length === 0) return "{}";
+
+  const pad = "  ".repeat(indent + 1);
+  const closePad = "  ".repeat(indent);
+
+  const lines = entries.map(([key, value]) => {
+    return `${pad}${key}: ${formatValue(value, indent + 1)},`;
+  });
+
+  return `{\n${lines.join("\n")}\n${closePad}}`;
+}
+
+function formatValue(value: unknown, indent: number): string {
+  if (value === null || value === undefined) return "undefined";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const pad = "  ".repeat(indent + 1);
+    const closePad = "  ".repeat(indent);
+    const items = value.map((v) => `${pad}${formatValue(v, indent + 1)},`);
+    return `[\n${items.join("\n")}\n${closePad}]`;
+  }
+
+  if (typeof value === "object") {
+    return formatProps(value as Record<string, unknown>, indent);
+  }
+
+  return String(value);
+}

package/src/import/parser.test.ts

@@ -0,0 +1,167 @@
+import { describe, test, expect } from "bun:test";
+import { GcpParser } from "./parser";
+
+const parser = new GcpParser();
+
+describe("GcpParser", () => {
+  test("empty YAML returns empty resources", () => {
+    const ir = parser.parse("");
+    expect(ir.resources).toEqual([]);
+    expect(ir.parameters).toEqual([]);
+  });
+
+  test("single ComputeInstance parses correctly", () => {
+    const yaml = `
+apiVersion: compute.cnrm.cloud.google.com/v1beta1
+kind: ComputeInstance
+metadata:
+  name: my-vm
+spec:
+  machineType: e2-medium
+  zone: us-central1-a
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources.length).toBe(1);
+    const r = ir.resources[0];
+    expect(r.type).toBe("GCP::Compute::Instance");
+    expect(r.properties.machineType).toBe("e2-medium");
+    expect(r.properties.zone).toBe("us-central1-a");
+  });
+
+  test("multi-doc YAML produces multiple resources", () => {
+    const yaml = `
+apiVersion: storage.cnrm.cloud.google.com/v1beta1
+kind: StorageBucket
+metadata:
+  name: bucket
+spec:
+  location: US
+---
+apiVersion: compute.cnrm.cloud.google.com/v1beta1
+kind: ComputeInstance
+metadata:
+  name: vm
+spec:
+  machineType: e2-medium
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources.length).toBe(2);
+  });
+
+  test("apiVersion+kind maps to GCP type name", () => {
+    const yaml = `
+apiVersion: storage.cnrm.cloud.google.com/v1beta1
+kind: StorageBucket
+metadata:
+  name: test
+spec:
+  location: US
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources[0].type).toBe("GCP::Storage::Bucket");
+  });
+
+  test("IAM resource maps correctly", () => {
+    const yaml = `
+apiVersion: iam.cnrm.cloud.google.com/v1beta1
+kind: IAMPolicyMember
+metadata:
+  name: binding
+spec:
+  member: user:test@example.com
+  role: roles/viewer
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources[0].type).toBe("GCP::Iam::PolicyMember");
+  });
+
+  test("non-Config Connector resources ignored", () => {
+    const yaml = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: my-app
+spec:
+  replicas: 1
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources).toEqual([]);
+  });
+
+  test("metadata.name extracted as logicalName", () => {
+    const yaml = `
+apiVersion: compute.cnrm.cloud.google.com/v1beta1
+kind: ComputeNetwork
+metadata:
+  name: my-network
+spec:
+  autoCreateSubnetworks: false
+`;
+    const ir = parser.parse(yaml);
+    expect((ir.resources[0] as any).logicalName).toBe("my-network");
+  });
+
+  test("properties include metadata and spec fields, exclude apiVersion/kind", () => {
+    const yaml = `
+apiVersion: storage.cnrm.cloud.google.com/v1beta1
+kind: StorageBucket
+metadata:
+  name: test
+  annotations:
+    cnrm.cloud.google.com/project-id: my-project
+spec:
+  location: US
+  storageClass: STANDARD
+`;
+    const ir = parser.parse(yaml);
+    const props = ir.resources[0].properties;
+    expect((props as any).apiVersion).toBeUndefined();
+    expect((props as any).kind).toBeUndefined();
+    expect(props.metadata).toBeDefined();
+    expect(props.location).toBe("US");
+    expect(props.storageClass).toBe("STANDARD");
+  });
+
+  test("parameters are always empty (GCP has no template parameters)", () => {
+    const yaml = `
+apiVersion: compute.cnrm.cloud.google.com/v1beta1
+kind: ComputeInstance
+metadata:
+  name: test
+spec:
+  machineType: e2-medium
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.parameters).toEqual([]);
+  });
+
+  test("mixed Config Connector and non-CC resources filters correctly", () => {
+    const yaml = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: app
+spec:
+  replicas: 1
+---
+apiVersion: storage.cnrm.cloud.google.com/v1beta1
+kind: StorageBucket
+metadata:
+  name: bucket
+spec:
+  location: US
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: svc
+spec:
+  ports:
+    - port: 80
+`;
+    const ir = parser.parse(yaml);
+    // Only the StorageBucket should be parsed
+    expect(ir.resources.length).toBe(1);
+    expect(ir.resources[0].type).toBe("GCP::Storage::Bucket");
+  });
+});

package/src/import/parser.ts

@@ -0,0 +1,80 @@
+/**
+ * Config Connector YAML template parser.
+ *
+ * Parses Config Connector YAML manifests into the import IR
+ * for conversion to chant TypeScript.
+ */
+
+import type {
+  TemplateParser,
+  TemplateIR,
+  ResourceIR,
+} from "@intentius/chant/import/parser";
+import { BaseValueParser } from "@intentius/chant/import/base-parser";
+import { parseYAML } from "@intentius/chant/yaml";
+import { gcpTypeName } from "../spec/parse";
+
+/**
+ * Parser for Config Connector YAML manifests.
+ */
+export class GcpParser extends BaseValueParser implements TemplateParser {
+  protected dispatchIntrinsic(
+    _key: string,
+    _value: unknown,
+    _obj: Record<string, unknown>,
+  ): unknown | null {
+    // Config Connector YAML has no intrinsic functions
+    return null;
+  }
+
+  parse(input: string): TemplateIR {
+    const resources: ResourceIR[] = [];
+    const documents = input
+      .split(/^---\s*$/m)
+      .map((d) => d.trim())
+      .filter((d) => d.length > 0);
+
+    for (const docStr of documents) {
+      const doc = parseYAML(docStr) as Record<string, unknown>;
+      if (!doc) continue;
+
+      const apiVersion = doc.apiVersion as string | undefined;
+      const kind = doc.kind as string | undefined;
+      if (!apiVersion || !kind) continue;
+
+      // Only handle Config Connector resources
+      if (!apiVersion.includes("cnrm.cloud.google.com")) continue;
+
+      const group = apiVersion.split("/")[0];
+      const typeName = gcpTypeName(group, kind);
+
+      const metadata = doc.metadata as Record<string, unknown> | undefined;
+      const spec = doc.spec as Record<string, unknown> | undefined;
+
+      const logicalName = (metadata?.name as string) ?? kind;
+
+      // Build properties from spec
+      const properties: Record<string, unknown> = {};
+      if (metadata) {
+        properties.metadata = this.parseValue(metadata);
+      }
+      if (spec) {
+        for (const [key, value] of Object.entries(spec)) {
+          properties[key] = this.parseValue(value);
+        }
+      }
+
+      resources.push({
+        logicalName,
+        type: typeName,
+        properties,
+      });
+    }
+
+    return {
+      resources,
+      parameters: [],
+      outputs: [],
+    };
+  }
+}

package/src/import/roundtrip.test.ts

@@ -0,0 +1,66 @@
+import { describe, test, expect } from "bun:test";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { GcpParser } from "./parser";
+import { GcpGenerator } from "./generator";
+
+const testdataDir = join(
+  dirname(dirname(fileURLToPath(import.meta.url))),
+  "testdata",
+  "manifests",
+);
+
+const parser = new GcpParser();
+const generator = new GcpGenerator();
+
+describe("roundtrip: parse YAML → generate TypeScript", () => {
+  test("StorageBucket roundtrip", () => {
+    const yaml = readFileSync(join(testdataDir, "storage-bucket.yaml"), "utf-8");
+    const ir = parser.parse(yaml);
+    const ts = generator.generate(ir);
+
+    expect(ir.resources.length).toBe(1);
+    expect(ts).toContain("new Bucket");
+    expect(ts).toContain("export const");
+  });
+
+  test("ComputeInstance roundtrip", () => {
+    const yaml = readFileSync(join(testdataDir, "compute-instance.yaml"), "utf-8");
+    const ir = parser.parse(yaml);
+    const ts = generator.generate(ir);
+
+    expect(ir.resources.length).toBe(1);
+    expect(ts).toContain("new Instance");
+    expect(ts).toContain("export const");
+    expect(ts).toContain("e2-medium");
+  });
+
+  test("multi-doc full-app roundtrip", () => {
+    const yaml = readFileSync(join(testdataDir, "full-app.yaml"), "utf-8");
+    const ir = parser.parse(yaml);
+    expect(ir.resources.length).toBe(3); // StorageBucket + IAMPolicyMember + ComputeNetwork
+
+    const ts = generator.generate(ir);
+    expect(ts).toContain("Bucket");
+    expect(ts).toContain("PolicyMember");
+    expect(ts).toContain("Network");
+  });
+
+  test("inline YAML roundtrip", () => {
+    const yaml = `
+apiVersion: storage.cnrm.cloud.google.com/v1beta1
+kind: StorageBucket
+metadata:
+  name: inline-test
+spec:
+  location: EU
+  storageClass: NEARLINE
+`;
+    const ir = parser.parse(yaml);
+    const ts = generator.generate(ir);
+
+    expect(ts).toContain("new Bucket");
+    expect(ts).toContain("export const");
+  });
+});

package/src/index.ts

@@ -0,0 +1,54 @@
+// Serializer
+export { gcpSerializer } from "./serializer";
+
+// Plugin
+export { gcpPlugin } from "./plugin";
+
+// Default labels & annotations
+export { defaultLabels, defaultAnnotations, isDefaultLabels, isDefaultAnnotations } from "./default-labels";
+export { DEFAULT_LABELS_MARKER, DEFAULT_ANNOTATIONS_MARKER } from "./default-labels";
+
+// Pseudo-parameters
+export { GCP, ProjectId, Region, Zone } from "./pseudo";
+
+// Variables / annotation constants
+export { GcpAnnotations } from "./variables";
+
+// Generated entities — export everything from generated index
+// After running `bun run generate`, this re-exports all Config Connector resource classes
+export * from "./generated/index";
+
+// Composites
+export {
+  GkeCluster, CloudRunService, CloudSqlInstance, GcsBucket, VpcNetwork,
+  PubSubPipeline, CloudFunctionWithTrigger, PrivateService, ManagedCertificate, SecureProject,
+} from "./composites/index";
+export type {
+  GkeClusterProps, GkeClusterResult,
+  CloudRunServiceProps, CloudRunServiceResult,
+  CloudSqlInstanceProps, CloudSqlInstanceResult,
+  GcsBucketProps, GcsBucketResult,
+  VpcNetworkProps, VpcNetworkResult, VpcSubnet,
+  PubSubPipelineProps, PubSubPipelineResult,
+  CloudFunctionWithTriggerProps, CloudFunctionWithTriggerResult,
+  PrivateServiceProps, PrivateServiceResult,
+  ManagedCertificateProps, ManagedCertificateResult,
+  SecureProjectProps, SecureProjectResult,
+} from "./composites/index";
+
+// IAM role constants
+export { StorageRoles, ComputeRoles, ContainerRoles, IAMRoles, SQLRoles, RunRoles, PubSubRoles } from "./actions/index";
+
+// Spec utilities (for tooling)
+export { fetchCRDBundle, getCachePath, clearCache, KCC_VERSION } from "./spec/fetch";
+export { parseGcpCRD, gcpServiceName, gcpShortName, gcpTypeName, stripServicePrefix } from "./spec/parse";
+export type { GcpParseResult, ParsedResource, ParsedProperty, ParsedPropertyType, ParsedEnum, GroupVersionKind } from "./spec/parse";
+
+// Code generation pipeline
+export { generate, writeGeneratedFiles } from "./codegen/generate";
+export { packageLexicon } from "./codegen/package";
+export type { PackageOptions, PackageResult } from "./codegen/package";
+
+// LSP providers
+export { gcpCompletions } from "./lsp/completions";
+export { gcpHover } from "./lsp/hover";

package/src/lint/post-synth/gcp-helpers.ts

@@ -0,0 +1,117 @@
+/**
+ * Shared helpers for GCP Config Connector post-synthesis lint rules.
+ *
+ * Provides YAML parsing for multi-document Config Connector manifests
+ * and accessor utilities for common manifest fields.
+ */
+
+import { parseYAML } from "@intentius/chant/yaml";
+export { getPrimaryOutput } from "@intentius/chant/lint/post-synth";
+
+/**
+ * A parsed Config Connector manifest (loosely typed).
+ */
+export interface GcpManifest {
+  apiVersion?: string;
+  kind?: string;
+  metadata?: {
+    name?: string;
+    namespace?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    [key: string]: unknown;
+  };
+  spec?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+/**
+ * Split a multi-document YAML string on `---` boundaries and parse each
+ * document into a GcpManifest.
+ */
+export function parseGcpManifests(yaml: string): GcpManifest[] {
+  const documents = yaml.split(/^---\s*$/m);
+  const manifests: GcpManifest[] = [];
+
+  for (const doc of documents) {
+    const trimmed = doc.trim();
+    if (trimmed === "" || trimmed === "---") continue;
+    try {
+      const parsed = parseYAML(trimmed);
+      if (typeof parsed === "object" && parsed !== null) {
+        manifests.push(parsed as GcpManifest);
+      }
+    } catch {
+      // Skip unparseable documents
+    }
+  }
+
+  return manifests;
+}
+
+/**
+ * Check if a manifest is a Config Connector resource
+ * (apiVersion contains cnrm.cloud.google.com).
+ */
+export function isConfigConnectorResource(manifest: GcpManifest): boolean {
+  return typeof manifest.apiVersion === "string" &&
+    manifest.apiVersion.includes("cnrm.cloud.google.com");
+}
+
+/**
+ * Safely extract the spec from a manifest.
+ */
+export function getSpec(manifest: GcpManifest): Record<string, unknown> | undefined {
+  return manifest.spec ?? undefined;
+}
+
+/**
+ * Safely extract annotations from a manifest's metadata.
+ */
+export function getAnnotations(manifest: GcpManifest): Record<string, string> | undefined {
+  return manifest.metadata?.annotations ?? undefined;
+}
+
+/**
+ * Get the resource name from metadata.
+ */
+export function getResourceName(manifest: GcpManifest): string {
+  return manifest.metadata?.name ?? "unknown";
+}
+
+/**
+ * Recursively walk a spec object looking for keys ending in `Ref`
+ * (e.g. `networkRef`, `topicRef`, `clusterRef`) that have a `name`
+ * sub-field. Returns the set of referenced names.
+ *
+ * Skips `external` refs (cross-project references outside the template).
+ */
+export function findResourceRefs(obj: unknown): Set<string> {
+  const refs = new Set<string>();
+  walkForRefs(obj, refs);
+  return refs;
+}
+
+function walkForRefs(value: unknown, refs: Set<string>): void {
+  if (value === null || value === undefined) return;
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkForRefs(item, refs);
+    }
+    return;
+  }
+
+  if (typeof value === "object") {
+    const obj = value as Record<string, unknown>;
+    for (const [key, val] of Object.entries(obj)) {
+      if (key.endsWith("Ref") && typeof val === "object" && val !== null) {
+        const refObj = val as Record<string, unknown>;
+        if (typeof refObj.name === "string" && !refObj.external) {
+          refs.add(refObj.name);
+        }
+      }
+      walkForRefs(val, refs);
+    }
+  }
+}