@shepherdjerred/helm-types 0.0.0-dev.706

package/src/interface-generator.ts

@@ -0,0 +1,238 @@
+import type { TypeScriptInterface } from "./types.ts";
+import {
+  ArraySchema,
+  RecordSchema,
+  StringSchema,
+  ActualNumberSchema,
+  ActualBooleanSchema,
+} from "./schemas.ts";
+
+/**
+ * Generate TypeScript code from interface definition
+ */
+export function generateTypeScriptCode(
+  mainInterface: TypeScriptInterface,
+  chartName: string,
+): string {
+  const interfaces: TypeScriptInterface[] = [];
+
+  // Collect all nested interfaces
+  collectNestedInterfaces(mainInterface, interfaces);
+
+  let code = `// Generated TypeScript types for ${chartName} Helm chart\n\n`;
+
+  // Generate all interfaces
+  for (const iface of interfaces) {
+    code += generateInterfaceCode(iface);
+    code += "\n";
+  }
+
+  // Generate parameter type (flattened dot notation)
+  code += generateParameterType(mainInterface, chartName);
+
+  // Add header comment for generated files
+  if (code.includes(": any")) {
+    code = `// Generated TypeScript types for ${chartName} Helm chart
+
+${code.slice(Math.max(0, code.indexOf("\n\n") + 2))}`;
+  }
+
+  return code;
+}
+
+function collectNestedInterfaces(
+  iface: TypeScriptInterface,
+  collected: TypeScriptInterface[],
+): void {
+  for (const prop of Object.values(iface.properties)) {
+    if (prop.nested) {
+      collected.push(prop.nested);
+      collectNestedInterfaces(prop.nested, collected);
+    }
+  }
+
+  // Add main interface last so dependencies come first
+  if (!collected.some((i) => i.name === iface.name)) {
+    collected.push(iface);
+  }
+}
+
+function generateInterfaceCode(iface: TypeScriptInterface): string {
+  const hasProperties = Object.keys(iface.properties).length > 0;
+
+  if (!hasProperties && iface.allowArbitraryProps !== true) {
+    // Use 'object' for empty interfaces instead of '{}'
+    return `export type ${iface.name} = object;\n`;
+  }
+
+  let code = `export type ${iface.name} = {\n`;
+
+  // Add index signature if this type allows arbitrary properties
+  if (iface.allowArbitraryProps === true) {
+    code += `  /**\n`;
+    code += `   * This type allows arbitrary additional properties beyond those defined below.\n`;
+    code += `   * This is common for config maps, custom settings, and extensible configurations.\n`;
+    code += `   */\n`;
+    code += `  [key: string]: unknown;\n`;
+  }
+
+  for (const [key, prop] of Object.entries(iface.properties)) {
+    const optional = prop.optional ? "?" : "";
+
+    // Generate JSDoc comment if we have description or default
+    if (
+      (prop.description != null && prop.description !== "") ||
+      prop.default !== undefined
+    ) {
+      code += `  /**\n`;
+
+      if (prop.description != null && prop.description !== "") {
+        // Format multi-line descriptions properly with " * " prefix
+        // Escape */ sequences to prevent premature comment closure
+        const escapedDescription = prop.description.replaceAll(
+          "*/",
+          String.raw`*\/`,
+        );
+        const descLines = escapedDescription.split("\n");
+        for (const line of descLines) {
+          code += `   * ${line}\n`;
+        }
+      }
+
+      if (prop.default !== undefined) {
+        const defaultStr = formatDefaultValue(prop.default);
+        const hasDescription =
+          prop.description != null && prop.description !== "";
+        if (defaultStr != null && defaultStr !== "" && hasDescription) {
+          code += `   *\n`;
+        }
+        if (defaultStr != null && defaultStr !== "") {
+          code += `   * @default ${defaultStr}\n`;
+        }
+      }
+
+      code += `   */\n`;
+    }
+
+    code += `  ${key}${optional}: ${prop.type};\n`;
+  }
+
+  code += "};\n";
+  return code;
+}
+
+/**
+ * Format a default value for display in JSDoc
+ */
+function formatDefaultValue(value: unknown): string | null {
+  if (value === null) {
+    return "null";
+  }
+  if (value === undefined) {
+    return null;
+  }
+
+  // Handle arrays
+  const arrayCheck = ArraySchema.safeParse(value);
+  if (arrayCheck.success) {
+    if (arrayCheck.data.length === 0) {
+      return "[]";
+    }
+    if (arrayCheck.data.length <= 3) {
+      try {
+        return JSON.stringify(arrayCheck.data);
+      } catch {
+        return "[...]";
+      }
+    }
+    return `[...] (${String(arrayCheck.data.length)} items)`;
+  }
+
+  // Handle objects
+  const recordCheck = RecordSchema.safeParse(value);
+  if (recordCheck.success) {
+    const keys = Object.keys(recordCheck.data);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    if (keys.length <= 3) {
+      try {
+        return JSON.stringify(recordCheck.data);
+      } catch {
+        return "{...}";
+      }
+    }
+    return `{...} (${String(keys.length)} keys)`;
+  }
+
+  // Primitives
+  const stringCheck = StringSchema.safeParse(value);
+  if (stringCheck.success) {
+    // Truncate long strings
+    if (stringCheck.data.length > 50) {
+      return `"${stringCheck.data.slice(0, 47)}..."`;
+    }
+    return `"${stringCheck.data}"`;
+  }
+
+  // Handle other primitives (numbers, booleans, etc.)
+  const numberCheck = ActualNumberSchema.safeParse(value);
+  if (numberCheck.success) {
+    return String(numberCheck.data);
+  }
+
+  const booleanCheck = ActualBooleanSchema.safeParse(value);
+  if (booleanCheck.success) {
+    return String(booleanCheck.data);
+  }
+
+  // Fallback for unknown types - try JSON.stringify
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "unknown";
+  }
+}
+
+function generateParameterType(
+  iface: TypeScriptInterface,
+  chartName: string,
+): string {
+  const parameterKeys = flattenInterfaceKeys(iface);
+
+  const normalizedChartName = capitalizeFirst(chartName).replaceAll("-", "");
+  let code = `export type ${normalizedChartName}HelmParameters = {\n`;
+
+  for (const key of parameterKeys) {
+    code += `  "${key}"?: string;\n`;
+  }
+
+  code += "};\n";
+
+  return code;
+}
+
+function flattenInterfaceKeys(
+  iface: TypeScriptInterface,
+  prefix = "",
+): string[] {
+  const keys: string[] = [];
+
+  for (const [key, prop] of Object.entries(iface.properties)) {
+    // Remove quotes from key for parameter names
+    const cleanKey = key.replaceAll('"', "");
+    const fullKey = prefix ? `${prefix}.${cleanKey}` : cleanKey;
+
+    if (prop.nested) {
+      keys.push(...flattenInterfaceKeys(prop.nested, fullKey));
+    } else {
+      keys.push(fullKey);
+    }
+  }
+
+  return keys;
+}
+
+function capitalizeFirst(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/reset.d.ts

@@ -0,0 +1 @@
+import "@total-typescript/ts-reset";

package/src/schemas.ts

@@ -0,0 +1,39 @@
+// Zod schemas for runtime validation
+import { z } from "zod";
+
+// Individual Zod schemas for type detection
+export const StringSchema = z.string();
+export const ActualNumberSchema = z.number(); // Runtime number
+export const ActualBooleanSchema = z.boolean(); // Runtime boolean
+export const NullSchema = z.null();
+export const UndefinedSchema = z.undefined();
+export const ArraySchema = z.array(z.unknown());
+export const RecordSchema = z.record(z.string(), z.unknown());
+export const ErrorSchema = z.instanceof(Error);
+
+// Custom boolean string parser - only matches actual boolean-like strings
+export const StringBooleanSchema = z.string().refine((val) => {
+  const lower = val.toLowerCase();
+  return (
+    lower === "true" || lower === "false" || lower === "yes" || lower === "no"
+  );
+}, "Not a boolean string");
+
+// Zod schema for validating YAML values - recursive definition with more flexibility
+export const HelmValueSchema: z.ZodType<Record<string, unknown>> = z.lazy(() =>
+  z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      z.number(),
+      z.boolean(),
+      z.null(),
+      z.undefined(),
+      z.array(z.unknown()), // Allow arrays of any type
+      HelmValueSchema,
+      z.unknown(), // Allow any other values as fallback
+    ]),
+  ),
+);
+
+export type HelmValue = z.infer<typeof HelmValueSchema>;

package/src/type-converter-helpers.ts

@@ -0,0 +1,180 @@
+import type {
+  JSONSchemaProperty,
+  TypeScriptInterface,
+  TypeProperty,
+} from "./types.ts";
+import {
+  StringSchema,
+  ActualNumberSchema,
+  ActualBooleanSchema,
+  StringBooleanSchema,
+} from "./schemas.ts";
+
+export type PropertyConversionContext = {
+  value: unknown;
+  nestedTypeName: string;
+  schema?: JSONSchemaProperty;
+  propertyName?: string;
+  yamlComment?: string;
+  yamlComments?: Map<string, string>;
+  fullKey?: string;
+  chartName?: string;
+};
+
+/**
+ * Merge description from schema and YAML comments
+ */
+export function mergeDescriptions(
+  schemaDescription: string | undefined,
+  yamlComment: string | undefined,
+): string | undefined {
+  if (yamlComment == null || yamlComment === "") {
+    return schemaDescription;
+  }
+  return schemaDescription != null && schemaDescription !== ""
+    ? `${yamlComment}\n\n${schemaDescription}`
+    : yamlComment;
+}
+
+/**
+ * Infer a primitive TypeProperty from a runtime value (no schema)
+ */
+export function inferPrimitiveType(
+  value: unknown,
+  yamlComment?: string,
+): TypeProperty {
+  if (ActualBooleanSchema.safeParse(value).success) {
+    return {
+      type: "boolean",
+      optional: true,
+      description: yamlComment,
+      default: value,
+    };
+  }
+
+  if (ActualNumberSchema.safeParse(value).success) {
+    return {
+      type: "number",
+      optional: true,
+      description: yamlComment,
+      default: value,
+    };
+  }
+
+  if (StringBooleanSchema.safeParse(value).success) {
+    return {
+      type: "boolean",
+      optional: true,
+      description: yamlComment,
+      default: value,
+    };
+  }
+
+  const stringCheckForNumber = StringSchema.safeParse(value);
+  if (stringCheckForNumber.success) {
+    const trimmed = stringCheckForNumber.data.trim();
+    if (
+      trimmed !== "" &&
+      !Number.isNaN(Number(trimmed)) &&
+      Number.isFinite(Number(trimmed))
+    ) {
+      return {
+        type: "number",
+        optional: true,
+        description: yamlComment,
+        default: value,
+      };
+    }
+  }
+
+  const stringCheckForPlain = StringSchema.safeParse(value);
+  if (stringCheckForPlain.success) {
+    if (stringCheckForPlain.data === "default") {
+      return {
+        type: "string | number | boolean",
+        optional: true,
+        description: yamlComment,
+        default: value,
+      };
+    }
+    return {
+      type: "string",
+      optional: true,
+      description: yamlComment,
+      default: value,
+    };
+  }
+
+  console.warn(
+    `Unrecognized value type for: ${String(value)}, using 'unknown'`,
+  );
+  return { type: "unknown", optional: true, description: yamlComment };
+}
+
+/**
+ * Augment a Kubernetes resource spec interface with both requests and limits.
+ * If only one is present, copy its type structure to the other.
+ */
+export function augmentK8sResourceSpec(iface: TypeScriptInterface): void {
+  const hasRequests = "requests" in iface.properties;
+  const hasLimits = "limits" in iface.properties;
+
+  // If we have requests but not limits, add limits with the same structure
+  if (hasRequests && !hasLimits) {
+    const requestsProp = iface.properties["requests"];
+    if (requestsProp) {
+      // Create limits property with the same type but different name for the nested interface
+      const limitsTypeName = requestsProp.type.replace("Requests", "Limits");
+
+      // If there's a nested interface, create a copy for limits
+      if (requestsProp.nested) {
+        const limitsNested: TypeScriptInterface = {
+          name: limitsTypeName,
+          properties: { ...requestsProp.nested.properties },
+          allowArbitraryProps: requestsProp.nested.allowArbitraryProps,
+        };
+        iface.properties["limits"] = {
+          type: limitsTypeName,
+          optional: true,
+          nested: limitsNested,
+          description: "Kubernetes resource limits (memory, cpu, etc.)",
+        };
+      } else {
+        // No nested interface, just copy the type
+        iface.properties["limits"] = {
+          type: requestsProp.type,
+          optional: true,
+          description: "Kubernetes resource limits (memory, cpu, etc.)",
+        };
+      }
+    }
+  }
+
+  // If we have limits but not requests, add requests with the same structure
+  if (hasLimits && !hasRequests) {
+    const limitsProp = iface.properties["limits"];
+    if (limitsProp) {
+      const requestsTypeName = limitsProp.type.replace("Limits", "Requests");
+
+      if (limitsProp.nested) {
+        const requestsNested: TypeScriptInterface = {
+          name: requestsTypeName,
+          properties: { ...limitsProp.nested.properties },
+          allowArbitraryProps: limitsProp.nested.allowArbitraryProps,
+        };
+        iface.properties["requests"] = {
+          type: requestsTypeName,
+          optional: true,
+          nested: requestsNested,
+          description: "Kubernetes resource requests (memory, cpu, etc.)",
+        };
+      } else {
+        iface.properties["requests"] = {
+          type: limitsProp.type,
+          optional: true,
+          description: "Kubernetes resource requests (memory, cpu, etc.)",
+        };
+      }
+    }
+  }
+}