@shepherdjerred/helm-types 0.0.0-dev.706

package/dist/index.js

@@ -0,0 +1,23 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+var HELM_TYPES_PACKAGE_VERSION = "1.1.0";
+export {
+  HELM_TYPES_PACKAGE_VERSION
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@shepherdjerred/helm-types",
+  "version": "0.0.0-dev.706",
+  "description": "Generate TypeScript types from Helm chart values.yaml and values.schema.json",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "helm-types": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/__snapshots__"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts src/cli.ts --outdir dist --target node",
+    "generate": "bun run src/cli.ts",
+    "test": "bun test",
+    "test:helm-types": "bun test src/helm-types.test.ts",
+    "test:cli": "bun test src/cli.test.ts",
+    "lint": "bunx eslint .",
+    "lint:fix": "bunx eslint . --fix",
+    "typecheck": "bunx tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "helm",
+    "kubernetes",
+    "typescript",
+    "types",
+    "codegen",
+    "k8s"
+  ],
+  "author": "Jerred Shepherd",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shepherdjerred/homelab.git",
+    "directory": "src/helm-types"
+  },
+  "bugs": {
+    "url": "https://github.com/shepherdjerred/homelab/issues"
+  },
+  "homepage": "https://github.com/shepherdjerred/homelab/tree/main/src/helm-types#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "yaml": "^2.8.1",
+    "zod": "^4.1.11"
+  },
+  "devDependencies": {
+    "jiti": "^2.6.1"
+  }
+}

package/src/chart-fetcher.ts

@@ -0,0 +1,171 @@
+// Using Bun.$ for path operations instead of node:path
+import { parse as yamlParse } from "yaml";
+import type { ChartInfo, JSONSchemaProperty } from "./types.ts";
+import { HelmValueSchema, RecordSchema, ErrorSchema } from "./schemas.ts";
+import type { HelmValue } from "./schemas.ts";
+import { parseYAMLComments } from "./yaml-comments.ts";
+
+/**
+ * Load JSON schema if it exists in the chart
+ */
+async function loadJSONSchema(
+  chartPath: string,
+): Promise<JSONSchemaProperty | null> {
+  try {
+    const schemaPath = `${chartPath}/values.schema.json`;
+    const schemaContent = await Bun.file(schemaPath).text();
+    const parsed: unknown = JSON.parse(schemaContent);
+    // Validate that parsed is an object
+    const recordCheck = RecordSchema.safeParse(parsed);
+    if (!recordCheck.success) {
+      return null;
+    }
+    // Note: JSONSchemaProperty is a structural type
+    const schema: JSONSchemaProperty = recordCheck.data;
+    console.log(`  📋 Loaded values.schema.json`);
+    return schema;
+  } catch {
+    // Schema doesn't exist or couldn't be parsed - that's okay
+    return null;
+  }
+}
+
+/**
+ * Run a command and return its output using Bun
+ */
+async function runCommand(command: string, args: string[]): Promise<string> {
+  try {
+    const proc = Bun.spawn([command, ...args], {
+      stdout: "pipe",
+      stderr: "inherit",
+    });
+
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    if (exitCode === 0) {
+      return output;
+    } else {
+      throw new Error(
+        `Command "${command} ${args.join(" ")}" failed with code ${exitCode.toString()}`,
+      );
+    }
+  } catch (error) {
+    const parseResult = ErrorSchema.safeParse(error);
+    const errorMessage = parseResult.success
+      ? parseResult.data.message
+      : String(error);
+    throw new Error(
+      `Failed to spawn command "${command} ${args.join(" ")}": ${errorMessage}`,
+    );
+  }
+}
+
+/**
+ * Fetch a Helm chart and extract its values.yaml and optional schema
+ */
+export async function fetchHelmChart(chart: ChartInfo): Promise<{
+  values: HelmValue;
+  schema: JSONSchemaProperty | null;
+  yamlComments: Map<string, string>;
+}> {
+  const pwd = Bun.env["PWD"] ?? process.cwd();
+  const tempDir = `${pwd}/temp/helm-${chart.name}`;
+  const repoName = `temp-repo-${chart.name}-${String(Date.now())}`;
+
+  try {
+    // Ensure temp directory exists
+    await Bun.$`mkdir -p ${tempDir}`.quiet();
+
+    console.log(`  📦 Adding Helm repo: ${chart.repoUrl}`);
+    // Add the helm repo
+    await runCommand("helm", ["repo", "add", repoName, chart.repoUrl]);
+
+    console.log(`  🔄 Updating Helm repos...`);
+    // Update repo
+    await runCommand("helm", ["repo", "update"]);
+
+    console.log(`  ⬇️  Pulling chart ${chart.chartName}:${chart.version}...`);
+    // Pull the chart
+    await runCommand("helm", [
+      "pull",
+      `${repoName}/${chart.chartName}`,
+      "--version",
+      chart.version,
+      "--destination",
+      tempDir,
+      "--untar",
+    ]);
+
+    // Read values.yaml
+    const valuesPath = `${tempDir}/${chart.chartName}/values.yaml`;
+    console.log(`  📖 Reading values.yaml from ${valuesPath}`);
+
+    try {
+      const valuesContent = await Bun.file(valuesPath).text();
+
+      // Parse YAML comments
+      const yamlComments = parseYAMLComments(valuesContent);
+      console.log(
+        `  💬 Extracted ${String(yamlComments.size)} comments from values.yaml`,
+      );
+
+      // Parse YAML using yaml package
+      const parsedValues = yamlParse(valuesContent) as unknown;
+      console.log(`  ✅ Successfully parsed values.yaml`);
+      const recordParseResult = RecordSchema.safeParse(parsedValues);
+      if (recordParseResult.success) {
+        console.log(
+          `  🔍 Parsed values keys: ${Object.keys(recordParseResult.data)
+            .slice(0, 10)
+            .join(
+              ", ",
+            )}${Object.keys(recordParseResult.data).length > 10 ? "..." : ""}`,
+        );
+      }
+
+      // Check if parsedValues is a valid object using Zod before validation
+      if (!recordParseResult.success) {
+        console.warn(
+          `  ⚠️  Parsed values is not a valid record object: ${String(parsedValues)}`,
+        );
+        return { values: {}, schema: null, yamlComments: new Map() };
+      }
+
+      // Validate and parse with Zod for runtime type safety
+      const parseResult = HelmValueSchema.safeParse(recordParseResult.data);
+
+      // Try to load JSON schema
+      const chartPath = `${tempDir}/${chart.chartName}`;
+      const schema = await loadJSONSchema(chartPath);
+
+      if (parseResult.success) {
+        console.log(`  ✅ Zod validation successful`);
+        return { values: parseResult.data, schema, yamlComments };
+      } else {
+        console.warn(`  ⚠️  Zod validation failed for ${chart.name}:`);
+        console.warn(
+          `    First few errors:`,
+          parseResult.error.issues.slice(0, 3),
+        );
+        console.warn(
+          `  ⚠️  Falling back to unvalidated object for type generation`,
+        );
+        // Return the validated record data from the successful parse result
+        return { values: recordParseResult.data, schema, yamlComments };
+      }
+    } catch (error) {
+      console.warn(`  ⚠️  Failed to read/parse values.yaml: ${String(error)}`);
+      return { values: {}, schema: null, yamlComments: new Map() };
+    }
+  } finally {
+    // Cleanup
+    try {
+      console.log(`  🧹 Cleaning up...`);
+      await runCommand("helm", ["repo", "remove", repoName]);
+      await Bun.$`rm -rf ${tempDir}`.quiet();
+    } catch (cleanupError) {
+      console.warn(`Cleanup failed for ${chart.name}:`, String(cleanupError));
+    }
+  }
+}

package/src/chart-info-parser.ts

@@ -0,0 +1,72 @@
+import type { ChartInfo } from "./types.ts";
+
+/**
+ * Parse chart information from versions.ts comments and values
+ */
+export async function parseChartInfoFromVersions(
+  versionsPath = "src/versions.ts",
+): Promise<ChartInfo[]> {
+  const content = await Bun.file(versionsPath).text();
+  const lines = content.split("\n");
+  const charts: ChartInfo[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const nextLine = lines[i + 1];
+
+    // Look for renovate comments that indicate Helm charts
+    if (
+      line == null ||
+      !line.includes("renovate: datasource=helm") ||
+      nextLine == null ||
+      nextLine === ""
+    ) {
+      continue;
+    }
+
+    const repoUrlMatch = /registryUrl=(\S+)/.exec(line);
+    const versionKeyMatch = /^\s*"?([^":\s]+)"?:/.exec(nextLine);
+    if (!repoUrlMatch || !versionKeyMatch) {
+      continue;
+    }
+
+    const repoUrl = repoUrlMatch[1];
+    const versionKey = versionKeyMatch[1];
+    if (
+      repoUrl == null ||
+      repoUrl === "" ||
+      versionKey == null ||
+      versionKey === ""
+    ) {
+      continue;
+    }
+
+    // Extract version value
+    const versionMatch = /:\s*"([^"]+)"/.exec(nextLine);
+    if (!versionMatch) {
+      continue;
+    }
+
+    const version = versionMatch[1];
+    if (version == null || version === "") {
+      continue;
+    }
+
+    // Try to determine chart name from the version key or URL
+    let chartName = versionKey;
+
+    // Handle special cases like "argo-cd" vs "argocd"
+    if (versionKey === "argo-cd") {
+      chartName = "argo-cd";
+    }
+
+    charts.push({
+      name: versionKey,
+      repoUrl: repoUrl.replace(/\/$/, ""), // Remove trailing slash
+      version,
+      chartName,
+    });
+  }
+
+  return charts;
+}

package/src/cli.ts

@@ -0,0 +1,215 @@
+#!/usr/bin/env bun
+/**
+ * CLI for @homelab/helm-types
+ *
+ * Generate TypeScript types from Helm charts
+ */
+import { z } from "zod";
+import { fetchHelmChart } from "./chart-fetcher.ts";
+import { convertToTypeScriptInterface } from "./type-converter.ts";
+import { generateTypeScriptCode } from "./interface-generator.ts";
+import type { ChartInfo } from "./types.ts";
+
+const ErrorSchema = z.object({
+  message: z.string(),
+});
+
+const HELP_TEXT = String.raw`
+helm-types - Generate TypeScript types from Helm charts
+
+USAGE:
+  bunx @homelab/helm-types [options]
+
+OPTIONS:
+  --name, -n          Unique identifier for the chart (required)
+  --chart, -c         Chart name in the repository (defaults to --name)
+  --repo, -r          Helm repository URL (required)
+  --version, -v       Chart version (required)
+  --output, -o        Output file path (defaults to stdout)
+  --interface, -i     Interface name (auto-generated from chart name if not provided)
+  --help, -h          Show this help message
+
+EXAMPLES:
+  # Generate types for ArgoCD and print to stdout
+  bunx @homelab/helm-types \
+    --name argo-cd \
+    --repo https://argoproj.github.io/argo-helm \
+    --version 8.3.1
+
+  # Generate types with custom output file
+  bunx @homelab/helm-types \
+    --name argo-cd \
+    --repo https://argoproj.github.io/argo-helm \
+    --version 8.3.1 \
+    --output argo-cd.types.ts
+
+  # Generate types with custom chart name and interface name
+  bunx @homelab/helm-types \
+    --name argocd \
+    --chart argo-cd \
+    --repo https://argoproj.github.io/argo-helm \
+    --version 8.3.1 \
+    --interface ArgocdHelmValues \
+    --output argocd.types.ts
+`;
+
+type CliArgs = {
+  name?: string;
+  chart?: string;
+  repo?: string;
+  version?: string;
+  output?: string;
+  interface?: string;
+  help?: boolean;
+};
+
+/** String-valued flag names (excludes boolean 'help') */
+type StringCliArgsKey = Exclude<keyof CliArgs, "help">;
+
+/** Map from flag name to CliArgs key */
+const FLAG_MAP: Record<string, StringCliArgsKey> = {
+  "--name": "name",
+  "-n": "name",
+  "--chart": "chart",
+  "-c": "chart",
+  "--repo": "repo",
+  "-r": "repo",
+  "--version": "version",
+  "-v": "version",
+  "--output": "output",
+  "-o": "output",
+  "--interface": "interface",
+  "-i": "interface",
+};
+
+const HELP_FLAGS = new Set(["--help", "-h"]);
+
+/**
+ * Simple argument parser for Bun CLI
+ */
+function parseCliArgs(args: string[]): CliArgs {
+  const result: CliArgs = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg == null || arg === "") {
+      continue;
+    }
+
+    if (HELP_FLAGS.has(arg)) {
+      result.help = true;
+      continue;
+    }
+
+    const key = FLAG_MAP[arg];
+    if (key != null) {
+      const value = args[i + 1];
+      if (value != null && value !== "") {
+        result[key] = value;
+        i += 1;
+      }
+      continue;
+    }
+
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return result;
+}
+
+async function main() {
+  try {
+    const args = parseCliArgs(Bun.argv.slice(2));
+
+    // Show help
+    if (args.help === true) {
+      console.log(HELP_TEXT);
+      process.exit(0);
+    }
+
+    // Validate required arguments
+    if (
+      args.name == null ||
+      args.name === "" ||
+      args.repo == null ||
+      args.repo === "" ||
+      args.version == null ||
+      args.version === ""
+    ) {
+      console.error("Error: Missing required arguments");
+      console.error("Required: --name, --repo, --version");
+      console.error("\nRun with --help for usage information");
+      process.exit(1);
+    }
+
+    // Build chart info
+    const chartInfo: ChartInfo = {
+      name: args.name,
+      chartName: args.chart ?? args.name,
+      repoUrl: args.repo,
+      version: args.version,
+    };
+
+    // Generate interface name from chart name if not provided
+    const interfaceName =
+      args.interface ?? `${toPascalCase(args.name)}HelmValues`;
+
+    console.error(
+      `Fetching chart: ${chartInfo.chartName}@${chartInfo.version}`,
+    );
+    console.error(`Repository: ${chartInfo.repoUrl}`);
+    console.error("");
+
+    // Fetch chart
+    const { values, schema, yamlComments } = await fetchHelmChart(chartInfo);
+
+    console.error("");
+    console.error(`Converting to TypeScript interface: ${interfaceName}`);
+
+    // Convert to TypeScript interface
+    const tsInterface = convertToTypeScriptInterface({
+      values,
+      interfaceName,
+      schema,
+      yamlComments,
+      chartName: args.name,
+    });
+
+    // Generate TypeScript code
+    const code = generateTypeScriptCode(tsInterface, args.name);
+
+    // Write to file or stdout
+    if (args.output != null && args.output !== "") {
+      await Bun.write(args.output, code);
+      console.error("");
+      console.error(`✅ Types written to: ${args.output}`);
+    } else {
+      // Write to stdout (so it can be piped)
+      console.log(code);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    const parseResult = ErrorSchema.safeParse(error);
+    if (parseResult.success) {
+      console.error(`Error: ${parseResult.data.message}`);
+    } else {
+      console.error(`Error: ${String(error)}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Convert a string to PascalCase
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join("");
+}
+
+void main();