@intentius/chant-lexicon-gcp 0.0.15

package/src/codegen/generate-cli.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+/**
+ * CLI entry point for GCP lexicon generation.
+ */
+
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { generate, writeGeneratedFiles } from "./generate";
+
+// src/codegen/generate-cli.ts → dirname x3 → package root
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+
+const verbose = process.argv.includes("--verbose") || !process.argv.includes("--quiet");
+const force = process.argv.includes("--force");
+
+const result = await generate({ verbose, force });
+writeGeneratedFiles(result, pkgDir);
+
+console.error(
+  `Generated ${result.resources} resources, ${result.properties} property types, ${result.enums} enums`,
+);
+if (result.warnings.length > 0) {
+  console.error(`${result.warnings.length} warnings`);
+}

package/src/codegen/generate.ts

@@ -0,0 +1,252 @@
+/**
+ * GCP Config Connector generation pipeline — uses core generatePipeline
+ * with GCP-specific fetch, parse, naming, and generation callbacks.
+ */
+
+import {
+  generatePipeline,
+  writeGeneratedArtifacts,
+  type GenerateOptions,
+  type GenerateResult,
+  type GeneratePipelineConfig,
+} from "@intentius/chant/codegen/generate";
+import { fetchCRDBundle } from "../spec/fetch";
+import { parseGcpCRD, type GcpParseResult } from "../spec/parse";
+import { NamingStrategy, propertyTypeName } from "./naming";
+import {
+  generateRuntimeIndex as coreGenerateRuntimeIndex,
+  type RuntimeIndexEntry,
+  type RuntimeIndexPropertyEntry,
+} from "@intentius/chant/codegen/generate-runtime-index";
+
+export type { GenerateOptions, GenerateResult };
+
+const gcpPipelineConfig: GeneratePipelineConfig<GcpParseResult> = {
+  fetchSchemas: async (opts) => {
+    return fetchCRDBundle(opts.force);
+  },
+
+  parseSchema: (_typeName, data) => {
+    const results = parseGcpCRD(data);
+    // Each CRD file may contain one or more resources
+    // We return the first one; additional ones get collected in augmentResults
+    if (results.length === 0) return null;
+    return results[0];
+  },
+
+  createNaming: (results) => new NamingStrategy(results),
+
+  augmentResults: (results, _opts, log) => {
+    const warnings: Array<{ file: string; error: string }> = [];
+    log(`Total: ${results.length} GCP Config Connector resource schemas`);
+    return { results, warnings };
+  },
+
+  generateRegistry: (results, naming) => {
+    return generateLexiconJSON(results, naming as NamingStrategy);
+  },
+
+  generateTypes: (results, naming) => {
+    return generateTypeScriptDeclarations(results, naming as NamingStrategy);
+  },
+
+  generateRuntimeIndex: (results, naming) => {
+    return generateRuntimeIndex(results, naming as NamingStrategy);
+  },
+};
+
+/**
+ * Run the full GCP generation pipeline.
+ */
+export async function generate(opts: GenerateOptions = {}): Promise<GenerateResult> {
+  return generatePipeline(gcpPipelineConfig, opts);
+}
+
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result: GenerateResult, baseDir: string): void {
+  writeGeneratedArtifacts({
+    baseDir,
+    files: {
+      "lexicon-gcp.json": result.lexiconJSON,
+      "index.d.ts": result.typesDTS,
+      "index.ts": result.indexTS,
+      "runtime.ts": [
+        "/**",
+        " * Runtime factory constructors — re-exported from core.",
+        " */",
+        'export { createResource, createProperty } from "@intentius/chant/runtime";',
+        "",
+      ].join("\n"),
+    },
+  });
+}
+
+/**
+ * Extract the property-type suffix from a GCP `::` name and flatten to valid TS identifier.
+ * "GCP::Alloydb::Backup::EncryptionConfig", "GCP::Alloydb::Backup" → "EncryptionConfig"
+ * "GCP::Acm::AccessLevel::Custom::Expr", "GCP::Acm::AccessLevel" → "Custom_Expr"
+ */
+function gcpDefName(ptName: string, resourceType: string): string {
+  const prefix = `${resourceType}::`;
+  const raw = ptName.startsWith(prefix) ? ptName.slice(prefix.length) : ptName.split("::").pop()!;
+  return raw.replace(/::/g, "_");
+}
+
+// ── Lexicon JSON generation ─────────────────────────────────────────
+
+function generateLexiconJSON(results: GcpParseResult[], naming: NamingStrategy): string {
+  const entries: Record<string, unknown> = {};
+
+  for (const r of results) {
+    const cfnType = r.resource.typeName;
+    const tsName = naming.resolve(cfnType);
+    if (!tsName) continue;
+
+    const apiVersion = `${r.gvk.group}/${r.gvk.version}`;
+
+    entries[tsName] = {
+      resourceType: cfnType,
+      kind: "resource",
+      apiVersion,
+      gvkKind: r.gvk.kind,
+      group: r.gvk.group,
+      properties: r.resource.properties.length,
+      attrs: Object.fromEntries(
+        r.resource.attributes.map((a) => [a.name, a.tsType]),
+      ),
+    };
+
+    // Add property types
+    for (const pt of r.propertyTypes) {
+      const defName = gcpDefName(pt.name, cfnType);
+      const ptName = propertyTypeName(tsName, defName);
+      entries[ptName] = {
+        resourceType: `${cfnType}.${pt.specType}`,
+        kind: "property",
+      };
+    }
+  }
+
+  return JSON.stringify(entries, null, 2);
+}
+
+// ── TypeScript declarations generation ──────────────────────────────
+
+function generateTypeScriptDeclarations(results: GcpParseResult[], naming: NamingStrategy): string {
+  const lines: string[] = [
+    "/**",
+    " * GCP Config Connector resource type declarations.",
+    " *",
+    " * Auto-generated — do not edit.",
+    " */",
+    "",
+  ];
+
+  const emittedTypes = new Set<string>();
+
+  for (const r of results) {
+    const cfnType = r.resource.typeName;
+    const tsName = naming.resolve(cfnType);
+    if (!tsName) continue;
+
+    // Resource class interface
+    const desc = (r.resource.description ?? cfnType).replace(/\*\//g, "*\\/");
+    lines.push(`/** ${desc} */`);
+    lines.push(`export declare class ${tsName} {`);
+    lines.push(`  constructor(props: ${tsName}Props);`);
+
+    // Attributes
+    for (const attr of r.resource.attributes) {
+      lines.push(`  readonly ${attr.name}: ${attr.tsType};`);
+    }
+
+    lines.push(`}`);
+    lines.push("");
+
+    // Props interface
+    lines.push(`export interface ${tsName}Props {`);
+    for (const prop of r.resource.properties) {
+      const optional = prop.required ? "" : "?";
+      const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(prop.name) ? prop.name : JSON.stringify(prop.name);
+      const propDesc = prop.description ? `  /** ${prop.description.replace(/\*\//g, "*\\/")} */\n` : "";
+      lines.push(`${propDesc}  ${safeName}${optional}: ${prop.tsType};`);
+    }
+    lines.push(`}`);
+    lines.push("");
+
+    // Aliases
+    for (const alias of naming.aliases(cfnType)) {
+      lines.push(`/** Alias for ${tsName} */`);
+      lines.push(`export declare const ${alias}: typeof ${tsName};`);
+      lines.push("");
+    }
+
+    // Property types (skip duplicates from singularization collisions)
+    for (const pt of r.propertyTypes) {
+      const defName = gcpDefName(pt.name, cfnType);
+      const ptName = propertyTypeName(tsName, defName);
+      if (emittedTypes.has(ptName)) continue;
+      emittedTypes.add(ptName);
+
+      lines.push(`export declare class ${ptName} {`);
+      lines.push(`  constructor(props: ${ptName}Props);`);
+      lines.push(`}`);
+      lines.push("");
+
+      lines.push(`export interface ${ptName}Props {`);
+      for (const prop of pt.properties) {
+        const optional = prop.required ? "" : "?";
+        const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(prop.name) ? prop.name : JSON.stringify(prop.name);
+        lines.push(`  ${safeName}${optional}: ${prop.tsType};`);
+      }
+      lines.push(`}`);
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ── Runtime index generation ────────────────────────────────────────
+
+function generateRuntimeIndex(results: GcpParseResult[], naming: NamingStrategy): string {
+  const resourceEntries: RuntimeIndexEntry[] = [];
+  const propertyEntries: RuntimeIndexPropertyEntry[] = [];
+  const emittedProperties = new Set<string>();
+
+  for (const r of results) {
+    const cfnType = r.resource.typeName;
+    const tsName = naming.resolve(cfnType);
+    if (!tsName) continue;
+
+    const attrs: Record<string, string> = {};
+    for (const a of r.resource.attributes) {
+      attrs[a.name] = a.name;
+    }
+
+    resourceEntries.push({ tsName, resourceType: cfnType, attrs });
+
+    for (const alias of naming.aliases(cfnType)) {
+      resourceEntries.push({ tsName: alias, resourceType: cfnType, attrs });
+    }
+
+    for (const pt of r.propertyTypes) {
+      const defName = gcpDefName(pt.name, cfnType);
+      const ptName = propertyTypeName(tsName, defName);
+      if (emittedProperties.has(ptName)) continue;
+      emittedProperties.add(ptName);
+      const ptCfnType = `${cfnType}.${pt.specType}`;
+      propertyEntries.push({ tsName: ptName, resourceType: ptCfnType });
+    }
+  }
+
+  return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+    lexiconName: "gcp",
+    pseudoReExports: {
+      names: ["GCP", "ProjectId", "Region", "Zone"],
+      from: "../pseudo",
+    },
+  });
+}

package/src/codegen/naming.test.ts

@@ -0,0 +1,49 @@
+import { describe, test, expect } from "bun:test";
+import { NamingStrategy } from "./naming";
+import type { GcpParseResult } from "../spec/parse";
+
+function makeResult(typeName: string): GcpParseResult {
+  return {
+    resource: {
+      typeName,
+      properties: [],
+      attributes: [],
+      deprecatedProperties: [],
+    },
+    propertyTypes: [],
+    enums: [],
+    gvk: { group: "", version: "v1beta1", kind: typeName.split("::").pop()! },
+  };
+}
+
+describe("NamingStrategy", () => {
+  test("resolves priority names", () => {
+    const results = [
+      makeResult("GCP::Compute::Instance"),
+      makeResult("GCP::Storage::Bucket"),
+      makeResult("GCP::Container::Cluster"),
+    ];
+    const naming = new NamingStrategy(results);
+
+    expect(naming.resolve("GCP::Compute::Instance")).toBe("ComputeInstance");
+    expect(naming.resolve("GCP::Storage::Bucket")).toBe("StorageBucket");
+    expect(naming.resolve("GCP::Container::Cluster")).toBe("GKECluster");
+  });
+
+  test("provides aliases", () => {
+    const results = [makeResult("GCP::Container::Cluster")];
+    const naming = new NamingStrategy(results);
+
+    const aliases = naming.aliases("GCP::Container::Cluster");
+    expect(aliases).toContain("GKE");
+  });
+
+  test("resolves non-priority types by short name", () => {
+    const results = [makeResult("GCP::Accesscontextmanager::AccessLevel")];
+    const naming = new NamingStrategy(results);
+
+    const name = naming.resolve("GCP::Accesscontextmanager::AccessLevel");
+    expect(name).toBeDefined();
+    expect(name!.length).toBeGreaterThan(0);
+  });
+});

package/src/codegen/naming.ts

@@ -0,0 +1,132 @@
+/**
+ * GCP-specific naming configuration for the core NamingStrategy.
+ *
+ * Maps Config Connector resource types to concise TypeScript class names.
+ */
+
+import {
+  NamingStrategy as CoreNamingStrategy,
+  type NamingConfig,
+  type NamingInput,
+} from "@intentius/chant/codegen/naming";
+
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+
+import type { GcpParseResult } from "../spec/parse";
+import { gcpShortName, gcpServiceName } from "../spec/parse";
+
+/**
+ * Fixed TypeScript class names for key GCP resources.
+ */
+const priorityNames: Record<string, string> = {
+  "GCP::Compute::Instance": "ComputeInstance",
+  "GCP::Compute::Network": "VPCNetwork",
+  "GCP::Compute::Subnetwork": "Subnetwork",
+  "GCP::Compute::Firewall": "Firewall",
+  "GCP::Compute::Address": "ComputeAddress",
+  "GCP::Compute::Disk": "ComputeDisk",
+  "GCP::Compute::ForwardingRule": "ForwardingRule",
+  "GCP::Compute::HealthCheck": "ComputeHealthCheck",
+  "GCP::Compute::Router": "Router",
+  "GCP::Compute::RouterNAT": "RouterNAT",
+  "GCP::Compute::BackendService": "BackendService",
+  "GCP::Compute::TargetHTTPProxy": "TargetHTTPProxy",
+  "GCP::Compute::URLMap": "URLMap",
+  "GCP::Compute::SSLCertificate": "SSLCertificate",
+  "GCP::Storage::Bucket": "StorageBucket",
+  "GCP::Sql::Instance": "SQLInstance",
+  "GCP::Sql::Database": "SQLDatabase",
+  "GCP::Sql::User": "SQLUser",
+  "GCP::Container::Cluster": "GKECluster",
+  "GCP::Container::NodePool": "NodePool",
+  "GCP::Iam::ServiceAccount": "GCPServiceAccount",
+  "GCP::Iam::PolicyMember": "IAMPolicyMember",
+  "GCP::Iam::Policy": "IAMPolicy",
+  "GCP::Iam::AuditConfig": "IAMAuditConfig",
+  "GCP::Run::Service": "CloudRunService",
+  "GCP::Run::Job": "CloudRunJob",
+  "GCP::Pubsub::Topic": "PubSubTopic",
+  "GCP::Pubsub::Subscription": "PubSubSubscription",
+  "GCP::Bigquery::Dataset": "BigQueryDataset",
+  "GCP::Bigquery::Table": "BigQueryTable",
+  "GCP::Dns::ManagedZone": "DNSManagedZone",
+  "GCP::Dns::RecordSet": "DNSRecordSet",
+  "GCP::Logging::Metric": "LoggingMetric",
+  "GCP::Monitoring::AlertPolicy": "AlertPolicy",
+  "GCP::Secretmanager::Secret": "SecretManagerSecret",
+  "GCP::Secretmanager::SecretVersion": "SecretManagerSecretVersion",
+  "GCP::Artifactregistry::Repository": "ArtifactRegistryRepository",
+  "GCP::Cloudfunctions::Function": "CloudFunction",
+  "GCP::Kms::KeyRing": "KMSKeyRing",
+  "GCP::Kms::CryptoKey": "KMSCryptoKey",
+  "GCP::Redis::Instance": "RedisInstance",
+  "GCP::Memcache::Instance": "MemcacheInstance",
+  "GCP::Spanner::Instance": "SpannerInstance",
+  "GCP::Spanner::Database": "SpannerDatabase",
+  "GCP::Dataflow::Job": "DataflowJob",
+  "GCP::Bigtable::Instance": "BigtableInstance",
+  "GCP::Bigtable::Table": "BigtableTable",
+};
+
+/**
+ * Additional TypeScript names beyond the primary priority name.
+ */
+const priorityAliases: Record<string, string[]> = {
+  "GCP::Compute::Network": ["VPC"],
+  "GCP::Container::Cluster": ["GKE"],
+  "GCP::Storage::Bucket": ["GCSBucket"],
+  "GCP::Sql::Instance": ["CloudSQL"],
+  "GCP::Iam::ServiceAccount": ["GSA"],
+  "GCP::Run::Service": ["CloudRun"],
+};
+
+/**
+ * Service name abbreviations for collision-resolved names.
+ */
+const serviceAbbreviations: Record<string, string> = {
+  Compute: "Compute",
+  Storage: "Gcs",
+  Container: "Gke",
+  Sql: "Sql",
+  Iam: "Iam",
+  Bigquery: "BQ",
+  Pubsub: "PubSub",
+  Dns: "Dns",
+  Logging: "Log",
+  Monitoring: "Mon",
+  Secretmanager: "Sm",
+  Artifactregistry: "Ar",
+  Cloudfunctions: "Gcf",
+  Kms: "Kms",
+  Redis: "Redis",
+  Run: "Run",
+  Spanner: "Spanner",
+  Dataflow: "Df",
+  Bigtable: "Bt",
+  Memcache: "Mc",
+};
+
+const gcpNamingConfig: NamingConfig = {
+  priorityNames,
+  priorityAliases,
+  priorityPropertyAliases: {},
+  serviceAbbreviations,
+  shortName: gcpShortName,
+  serviceName: (typeName: string) => {
+    const parts = typeName.split("::");
+    return parts.length >= 2 ? parts[1] : "Other";
+  },
+};
+
+/**
+ * GCP-specific NamingStrategy — wraps the core algorithm with GCP data tables.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+  constructor(results: GcpParseResult[]) {
+    const inputs: NamingInput[] = results.map((r) => ({
+      typeName: r.resource.typeName,
+      propertyTypes: r.propertyTypes,
+    }));
+    super(inputs, gcpNamingConfig);
+  }
+}

package/src/codegen/package.ts

@@ -0,0 +1,66 @@
+/**
+ * GCP lexicon packaging — delegates to core packagePipeline
+ * with GCP-specific manifest building and skill collection.
+ */
+
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+const require = createRequire(import.meta.url);
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  packagePipeline,
+  collectSkills,
+  type PackageOptions,
+  type PackageResult,
+} from "@intentius/chant/codegen/package";
+import { generate } from "./generate";
+
+export type { PackageOptions, PackageResult };
+
+// src/codegen/package.ts → dirname x2 → src/ (srcDir for rule collection)
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+
+/**
+ * Package the GCP lexicon into a distributable BundleSpec.
+ */
+export async function packageLexicon(opts: PackageOptions = {}): Promise<PackageResult> {
+  const pkgJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+
+  return packagePipeline(
+    {
+      generate: (genOpts) => generate({ verbose: genOpts.verbose, force: genOpts.force }),
+
+      buildManifest: (_genResult) => {
+        const { gcpPlugin } = require("../plugin");
+
+        const pseudoParams: string[] = gcpPlugin.pseudoParameters?.() ?? [];
+        const pseudoParameters: Record<string, string> = {};
+        for (const p of pseudoParams) {
+          const shortName = p.split("::").pop()!;
+          pseudoParameters[shortName] = p;
+        }
+
+        return {
+          name: "gcp",
+          version: pkgJson.version ?? "0.0.0",
+          chantVersion: ">=0.1.0",
+          namespace: "GCP",
+          intrinsics: [],
+          pseudoParameters,
+        };
+      },
+
+      srcDir: pkgDir,
+
+      collectSkills: () => {
+        const { gcpPlugin } = require("../plugin");
+        const skillDefs = gcpPlugin.skills?.() ?? [];
+        return collectSkills(skillDefs);
+      },
+
+      version: pkgJson.version ?? "0.0.0",
+    },
+    opts,
+  );
+}

package/src/composites/cloud-function.ts

@@ -0,0 +1,117 @@
+/**
+ * CloudFunctionWithTrigger composite — CloudFunction + source bucket + optional PubSub/HTTP trigger + invoker IAM.
+ */
+
+export interface CloudFunctionWithTriggerProps {
+  /** Function name. */
+  name: string;
+  /** Runtime (e.g., "nodejs20", "python312"). */
+  runtime: string;
+  /** Entry point function name. */
+  entryPoint: string;
+  /** GCP region. */
+  region?: string;
+  /** Available memory (default: "256M"). */
+  availableMemoryMb?: string;
+  /** Timeout in seconds (default: 60). */
+  timeout?: number;
+  /** Trigger type (default: "http"). */
+  triggerType?: "http" | "pubsub";
+  /** PubSub topic name (required if triggerType is "pubsub"). */
+  triggerTopic?: string;
+  /** Allow unauthenticated HTTP invocations (default: false). */
+  publicAccess?: boolean;
+  /** Environment variables. */
+  environmentVariables?: Record<string, string>;
+  /** Additional labels. */
+  labels?: Record<string, string>;
+  /** Namespace for all resources. */
+  namespace?: string;
+}
+
+export interface CloudFunctionWithTriggerResult {
+  function: Record<string, unknown>;
+  sourceBucket: Record<string, unknown>;
+  invokerIam?: Record<string, unknown>;
+}
+
+export function CloudFunctionWithTrigger(props: CloudFunctionWithTriggerProps): CloudFunctionWithTriggerResult {
+  const {
+    name,
+    runtime,
+    entryPoint,
+    region,
+    availableMemoryMb = "256M",
+    timeout = 60,
+    triggerType = "http",
+    triggerTopic,
+    publicAccess = false,
+    environmentVariables,
+    labels: extraLabels = {},
+    namespace,
+  } = props;
+
+  const commonLabels: Record<string, string> = {
+    "app.kubernetes.io/name": name,
+    "app.kubernetes.io/managed-by": "chant",
+    ...extraLabels,
+  };
+
+  const sourceBucket: Record<string, unknown> = {
+    metadata: {
+      name: `${name}-source`,
+      ...(namespace && { namespace }),
+      labels: { ...commonLabels, "app.kubernetes.io/component": "source" },
+    },
+    location: region ?? "US",
+    uniformBucketLevelAccess: true,
+  };
+
+  const eventTrigger = triggerType === "pubsub" && triggerTopic
+    ? { eventType: "google.cloud.pubsub.topic.v1.messagePublished", pubsubTopic: triggerTopic }
+    : undefined;
+
+  const fn: Record<string, unknown> = {
+    metadata: {
+      name,
+      ...(namespace && { namespace }),
+      labels: { ...commonLabels, "app.kubernetes.io/component": "function" },
+    },
+    ...(region && { location: region }),
+    runtime,
+    entryPoint,
+    availableMemoryMb,
+    timeout: `${timeout}s`,
+    buildConfig: {
+      sourceRef: {
+        storageBucketRef: { name: `${name}-source` },
+      },
+    },
+    ...(eventTrigger && { eventTrigger }),
+    ...(environmentVariables && { environmentVariables }),
+  };
+
+  const result: CloudFunctionWithTriggerResult = {
+    function: fn,
+    sourceBucket,
+  };
+
+  if (publicAccess && triggerType === "http") {
+    result.invokerIam = {
+      metadata: {
+        name: `${name}-invoker`,
+        ...(namespace && { namespace }),
+        labels: { ...commonLabels, "app.kubernetes.io/component": "iam" },
+      },
+      member: "allUsers",
+      role: "roles/cloudfunctions.invoker",
+      resourceRef: {
+        apiVersion: "cloudfunctions.cnrm.cloud.google.com/v1beta1",
+        kind: "CloudFunctionsFunction",
+        name,
+      },
+    };
+  }
+
+  return result;
+}