timonel 2.13.0 → 3.0.0-beta.1

package/dist/lib/rutter.js

@@ -1,11 +1,12 @@
 import { ApiObject, App, Chart, Testing } from 'cdk8s';
-import * as jsYaml from 'js-yaml';
+import { parse } from 'yaml';
 import { include } from './helm.js';
 import { HelmChartWriter } from './helmChartWriter.js';
 import { AWSResources } from './resources/cloud/aws/awsResources.js';
 import { createLogger } from './utils/logger.js';
 import { KarpenterResources } from './resources/cloud/aws/karpenterResources.js';
-import { dumpHelmAwareYaml, isHelmExpression } from './utils/helmYamlSerializer.js';
+import { isHelmExpression, isHelmConstruct } from './utils/helmControlStructures.js';
+import { dumpHelmAwareYaml, preprocessHelmConstructs } from './utils/helmYamlSerializer.js';
 import { generateHelpersTemplate } from './utils/helmHelpers.js';
 export class Rutter {
     constructor(props) {
@@ -63,7 +64,7 @@ export class Rutter {
         let manifestObject;
         if (typeof yamlOrObject === 'string') {
             try {
-                manifestObject = jsYaml.load(yamlOrObject);
+                manifestObject = parse(yamlOrObject);
             }
             catch (error) {
                 throw new Error(`Invalid YAML provided to addManifest(): ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -76,12 +77,14 @@ export class Rutter {
             throw new Error('addManifest() requires either a YAML string or an object');
         }
         this.validateManifestStructure(manifestObject);
-        return new ApiObject(this.chart, id, {
-            apiVersion: manifestObject['apiVersion'],
-            kind: manifestObject['kind'],
-            metadata: manifestObject['metadata'],
-            spec: manifestObject['spec'],
-        });
+        const preprocessedManifest = preprocessHelmConstructs(manifestObject);
+        const apiObjectProps = {
+            apiVersion: preprocessedManifest.apiVersion,
+            kind: preprocessedManifest.kind,
+            metadata: preprocessedManifest.metadata,
+            ...preprocessedManifest,
+        };
+        return new ApiObject(this.chart, id, apiObjectProps);
     }
     addTemplateManifest(yamlTemplate, id) {
         const templateAsset = {
@@ -169,13 +172,10 @@ ${yamlContent.trim()}
             });
             throw new Error('Manifest metadata must have a name');
         }
-        if (typeof metadata.name !== 'string' && !isHelmExpression(metadata.name)) {
-            this.logger.error('Validation failed: metadata.name must be a string or HelmExpression', {
-                operation: 'manifest_validation',
-                issue: 'invalid_metadata_name_type',
-                actual_type: typeof metadata.name,
-            });
-            throw new Error('Manifest metadata.name must be a string or HelmExpression');
+        const name = manifest['metadata']?.['name'];
+        if (typeof name !== 'string' && !isHelmExpression(name) && !isHelmConstruct(name)) {
+            const actualType = Array.isArray(name) ? 'array' : name === null ? 'null' : typeof name;
+            throw new Error(`Manifest metadata.name must be a string, HelmExpression, or HelmConstruct. Got ${actualType}`);
         }
     }
     getMeta() {
@@ -218,8 +218,9 @@ ${yamlContent.trim()}
             operation: 'manifest_processing',
         });
         const enriched = manifestObjs.map((obj) => {
-            if (obj && typeof obj === 'object') {
-                const o = obj;
+            const preprocessed = preprocessHelmConstructs(obj);
+            if (preprocessed && typeof preprocessed === 'object') {
+                const o = preprocessed;
                 o.metadata = o.metadata ?? {};
                 o.metadata.labels = o.metadata.labels ?? {};
                 const labels = o.metadata.labels;
@@ -237,12 +238,12 @@ ${yamlContent.trim()}
                     }
                 }
             }
-            return obj;
+            return preprocessed;
         });
         const synthAssets = [];
         if (this.props.singleManifestFile) {
             const combinedYaml = enriched
-                .map((obj) => this.processHelmTemplates(dumpHelmAwareYaml(obj).trim()))
+                .map((obj) => dumpHelmAwareYaml(obj).trim())
                 .filter(Boolean)
                 .join('\n---\n');
             const manifestId = this.props.manifestPrefix ?? 'manifests';
@@ -252,7 +253,7 @@ ${yamlContent.trim()}
             enriched.forEach((obj, index) => {
                 const apiObjectId = apiObjectIds[index];
                 const manifestId = apiObjectId || `manifest-${index + 1}`;
-                const yaml = this.processHelmTemplates(dumpHelmAwareYaml(obj).trim());
+                const yaml = dumpHelmAwareYaml(obj).trim();
                 if (yaml) {
                     synthAssets.push({ id: manifestId, yaml });
                 }
@@ -270,173 +271,6 @@ ${yamlContent.trim()}
         timer();
         return synthAssets;
     }
-    processHelmTemplates(yaml) {
-        let processed = this.fixCharacterMappingIssues(yaml);
-        processed = this.applyHelmTemplateReplacements(processed);
-        return processed;
-    }
-    fixCharacterMappingIssues(yaml) {
-        const lines = yaml.split('\n');
-        const fixedLines = [];
-        let i = 0;
-        while (i < lines.length) {
-            const line = lines[i];
-            if (!line) {
-                i++;
-                continue;
-            }
-            const charKeyMatch = line.match(/^(\s*)"(\d+)":\s*(.+)$/);
-            if (charKeyMatch && charKeyMatch[2] && parseInt(charKeyMatch[2]) === 0) {
-                const indent = charKeyMatch[1] || '';
-                const result = this.processCharacterMapping(lines, i, indent);
-                if (result.reconstructed) {
-                    fixedLines.push(result.reconstructed);
-                    i = result.nextIndex;
-                    continue;
-                }
-            }
-            if (line) {
-                fixedLines.push(line);
-            }
-            i++;
-        }
-        return fixedLines.join('\n');
-    }
-    processCharacterMapping(lines, startIndex, indent) {
-        const charMappings = [];
-        let j = startIndex;
-        while (j < lines.length) {
-            const currentLine = lines[j];
-            if (!currentLine) {
-                break;
-            }
-            const currentMatch = currentLine.match(/^(\s*)"(\d+)":\s*(.+)$/);
-            if (currentMatch && currentMatch[1] === indent && currentMatch[2] && currentMatch[3]) {
-                const index = parseInt(currentMatch[2]);
-                let char = currentMatch[3];
-                if (char && char.startsWith('"') && char.endsWith('"')) {
-                    char = char.slice(1, -1);
-                }
-                charMappings.push({ index, char });
-                j++;
-            }
-            else {
-                break;
-            }
-        }
-        if (charMappings.length > 3) {
-            charMappings.sort((a, b) => a.index - b.index);
-            const reconstructed = charMappings.map((m) => m.char).join('');
-            if (reconstructed.includes('{{') && reconstructed.includes('}}')) {
-                return { reconstructed: `${indent}${reconstructed}`, nextIndex: j };
-            }
-        }
-        return { nextIndex: j };
-    }
-    applyHelmTemplateReplacements(processed) {
-        processed = this.fixConditionalBlocks(processed);
-        processed = this.fixPipeExpressions(processed);
-        processed = this.fixNestedQuotes(processed);
-        processed = this.cleanupArtifacts(processed);
-        processed = this.removeHelmExpressionQuotes(processed);
-        return processed;
-    }
-    fixIncludeStatements(processed) {
-        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \| nindent (\d+) \}\}/g, '{{ include "$1" . | nindent $2 }}');
-        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \}\}/g, '{{ include "$1" . }}');
-        return processed;
-    }
-    fixFunctionCalls(processed) {
-        return processed.replace(/\{\{ (\w+) \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ $1 "$2" $3 }}');
-    }
-    fixChartReferences(processed) {
-        return processed.replace(/\{\{ \.Chart\.(\w+) \| replace \\"([^"]*)\\" \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ .Chart.$1 | replace "$2" "$3" $4 }}');
-    }
-    removeHelmExpressionQuotes(processed) {
-        const HELM_EXPRESSION_REPLACEMENT = '$1$2: {{$3}}';
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\|\s*(?:int|float|bool|number)[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(service\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(backend\.service\.port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(spec\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]*\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(replicas):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(targetPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(nodePort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(containerPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(hostPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(weight):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(priority):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(timeoutSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(periodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(successThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(failureThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(initialDelaySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(terminationGracePeriodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(activeDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(backoffLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(parallelism):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(completions):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(revisionHistoryLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(progressDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(minReadySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(maxUnavailable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(maxSurge):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(cpu):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(memory):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(enabled):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(create):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(allow):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(disable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(force):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(required):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(optional):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(readOnly):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(runAsNonRoot):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(privileged):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(allowPrivilegeEscalation):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)(readOnlyRootFilesystem):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*true[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*false[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\d+[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\beq\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bne\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\blt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\ble\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bgt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bge\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\band\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bor\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bnot\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[+][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[-][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[*][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/:\s*"([^"]*\{\{[^}]+\}\}[^"]*)"/g, ': $1');
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(true|false)"$/gm, '$1$2: $3');
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+)"$/gm, '$1$2: $3');
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.\d+)"$/gm, '$1$2: $3');
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.?\d*[eE][+-]?\d+)"$/gm, '$1$2: $3');
-        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
-        processed = processed.replace(/"\{\{([^}]*)\}\}"/g, '{{$1}}');
-        processed = processed.replace(/^(\s*)-\s*"\{\{([^}]*)\}\}"/gm, '$1- {{$2}}');
-        return processed;
-    }
-    fixConditionalBlocks(processed) {
-        return processed.replace(/"\{\{-\s*(if|with|range)([^}]*)\}\}([^"]*)\{\{-\s*end\s*\}\}"/g, '{{- $1$2}}$3{{- end }}');
-    }
-    fixPipeExpressions(processed) {
-        return processed.replace(/"\{\{([^}]*\|[^}]*)\}\}"/g, '{{$1}}');
-    }
-    fixNestedQuotes(processed) {
-        return processed.replace(/\{\{([^}]*)\\"([^"]*)\\"([^}]*)\}\}/g, '{{$1"$2"$3}}');
-    }
-    cleanupArtifacts(processed) {
-        processed = processed.replace(/": "\.nan"/g, ': .nan');
-        processed = processed.replace(/: \{\{([^}]+)\}\}$/gm, ': {{$1}}');
-        return processed;
-    }
     write(outDir) {
         const timer = this.logger.time('chart_write');
         this.logger.info('Starting chart write operation', {

package/dist/lib/templates/flexible-subchart.js

@@ -107,10 +107,10 @@ export function createFlexibleSubchart(scope, id, config) {
 }
 export function generateFlexibleSubchartTemplate(name) {
     return `import { App } from 'cdk8s';
-import { Rutter } from 'timonel';
+import { Rutter, helmInclude, helmIf, helmWith, createHelmExpression as helm } from 'timonel';
 
 /**
- * Creates a new chart with simple Rutter implementation
+ * Creates a new chart with type-safe Helm helpers
  * @returns Rutter instance for Helm chart generation
  * @since 2.11.0
  */
@@ -126,45 +126,43 @@ export default function createChart() {
     scope: app,
     defaultValues: {
       appName: '${name}',
-      image: 'nginx:latest',
+      image: {
+        repository: 'nginx',
+        tag: 'latest'
+      },
       port: 80,
       replicas: 1,
     },
   });
 
-  // Add simple deployment
+  // Add Deployment with type-safe helpers
   rutter.addManifest({
     apiVersion: 'apps/v1',
     kind: 'Deployment',
     metadata: { 
-      name: '${name}',
-      labels: {
-        'app.kubernetes.io/name': '${name}'
-      }
+      name: helmInclude('chart.fullname', '.'),
+      labels: helmInclude('chart.labels', '.', { pipe: 'nindent 4' })
     },
     spec: {
-      replicas: 1,
+      replicas: helmIf('.Values.autoscaling.enabled', '{{ .Values.replicas }}', '1'),
       selector: {
-        matchLabels: {
-          'app.kubernetes.io/name': '${name}'
-        }
+        matchLabels: helmInclude('chart.selectorLabels', '.', { pipe: 'nindent 6' })
       },
       template: {
         metadata: {
-          labels: {
-            'app.kubernetes.io/name': '${name}'
-          }
+          labels: helmInclude('chart.selectorLabels', '.', { pipe: 'nindent 8' }),
+          annotations: helmWith('.Values.podAnnotations', helm('{{- toYaml . | nindent 8 }}'))
         },
         spec: {
           containers: [{
             name: '${name}',
-            image: 'nginx:latest',
+            image: helm('{{ .Values.image.repository }}:{{ .Values.image.tag }}'),
             ports: [{
-              containerPort: 80
+              containerPort: helm('{{ .Values.port }}')
             }],
             env: [
-              { name: 'APP_NAME', value: '${name}' },
-              { name: 'PORT', value: '80' }
+              { name: 'APP_NAME', value: helm('{{ .Values.appName }}') },
+              { name: 'PORT', value: helm('{{ .Values.port | toString }}') }
             ]
           }]
         }
@@ -172,27 +170,23 @@ export default function createChart() {
     }
   }, 'deployment');
 
-  // Add Service
+  // Add Service with type-safe helpers
   rutter.addManifest({
     apiVersion: 'v1',
     kind: 'Service',
     metadata: {
-      name: '${name}',
-      labels: {
-        'app.kubernetes.io/name': '${name}'
-      }
+      name: helmInclude('chart.fullname', '.'),
+      labels: helmInclude('chart.labels', '.', { pipe: 'nindent 4' })
     },
     spec: {
       type: 'ClusterIP',
       ports: [{
-        port: 80,
-        targetPort: 80,
+        port: helm('{{ .Values.port }}'),
+        targetPort: helm('{{ .Values.port }}'),
         protocol: 'TCP',
         name: 'http'
       }],
-      selector: {
-        'app.kubernetes.io/name': '${name}'
-      }
+      selector: helmInclude('chart.selectorLabels', '.', { pipe: 'nindent 4' })
     }
   }, 'service');
 

package/dist/lib/templates/umbrella-chart.js

@@ -1,16 +1,16 @@
 import { writeFileSync, mkdirSync, existsSync, copyFileSync, readdirSync, rmSync } from 'fs';
 import { join } from 'path';
-import * as jsYaml from 'js-yaml';
+import { parse } from 'yaml';
 import { App, Chart, ApiObject } from 'cdk8s';
 import { dumpHelmAwareYaml } from '../utils/helmYamlSerializer.js';
 import { generateHelpersTemplate } from '../utils/helmHelpers.js';
 import { createFlexibleSubchart } from './flexible-subchart.js';
 export function generateUmbrellaChart(name) {
     return `import { App } from 'cdk8s';
-import { Rutter } from 'timonel';
+import { Rutter, helmInclude, helmIf, helmWith, createHelmExpression as helm } from 'timonel';
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import * as jsYaml from 'js-yaml';
+import { parse, stringify } from 'yaml';
 // Import subcharts - add your subchart imports here
 
 type SynthMode = 'dependencies' | 'inline';
@@ -42,7 +42,7 @@ function readYamlFile(filePath: string): Record<string, unknown> {
   if (!existsSync(filePath)) {
     return {};
   }
-  const content = jsYaml.load(readFileSync(filePath, 'utf8'));
+  const content = parse(readFileSync(filePath, 'utf8'));
   return content && typeof content === 'object' ? (content as Record<string, unknown>) : {};
 }
 
@@ -147,8 +147,8 @@ export function synth(outDir: string, options?: SynthOptions) {
     });
   }
 
-  writeFileSync(chartPath, jsYaml.dump(chartDoc));
-  writeFileSync(valuesPath, jsYaml.dump(valuesDoc));
+  writeFileSync(chartPath, stringify(chartDoc));
+  writeFileSync(valuesPath, stringify(valuesDoc));
 
   app.synth();
 
@@ -327,7 +327,7 @@ export class UmbrellaChartTemplate extends Chart {
         const assets = getAssets?.() || [];
         assets.forEach((asset, assetIndex) => {
             try {
-                const manifest = jsYaml.load(asset.yaml);
+                const manifest = parse(asset.yaml);
                 if (manifest?.apiVersion && manifest?.kind) {
                     new ApiObject(flexibleSubchart, `${String(manifest.kind).toLowerCase()}-${assetIndex}`, {
                         apiVersion: String(manifest.apiVersion),

package/dist/lib/utils/envVarsLoader.d.ts

@@ -0,0 +1,19 @@
+export interface EnvVarConfig {
+    name: string;
+    type: 'value' | 'secret';
+    scope?: string;
+    defaultValue?: string;
+    secretName?: string;
+}
+export interface LoadEnvVarsOptions {
+    configPath?: string;
+    defaultScope?: string;
+    fallbackConfig?: EnvVarConfig[];
+}
+export declare function loadEnvVarsConfig(options?: LoadEnvVarsOptions): EnvVarConfig[];
+export declare function generateEnvVars(config: EnvVarConfig[], options?: {
+    defaultScope?: string;
+}): Array<Record<string, unknown>>;
+export declare function loadAndGenerateEnvVars(options?: LoadEnvVarsOptions & {
+    defaultScope?: string;
+}): Array<Record<string, unknown>>;

package/dist/lib/utils/envVarsLoader.js

@@ -0,0 +1,57 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { createHelmExpression } from './helmControlStructures.js';
+export function loadEnvVarsConfig(options = {}) {
+    const { configPath, fallbackConfig = [] } = options;
+    try {
+        if (configPath && existsSync(configPath)) {
+            const data = readFileSync(configPath, 'utf-8');
+            return configPath.endsWith('.yaml') || configPath.endsWith('.yml')
+                ? parseYaml(data)
+                : JSON.parse(data);
+        }
+        const yamlPath = join(process.cwd(), 'env-config.yaml');
+        if (existsSync(yamlPath)) {
+            const data = readFileSync(yamlPath, 'utf-8');
+            return parseYaml(data);
+        }
+        const jsonPath = join(process.cwd(), 'env-config.json');
+        if (existsSync(jsonPath)) {
+            const data = readFileSync(jsonPath, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch {
+    }
+    return fallbackConfig;
+}
+export function generateEnvVars(config, options = {}) {
+    const { defaultScope = 'global.env' } = options;
+    return config.map((item) => {
+        const scope = item.scope || defaultScope;
+        if (item.type === 'value') {
+            return {
+                name: item.name,
+                value: createHelmExpression(`{{ .Values.${scope}.${item.name} | default "${item.defaultValue || ''}" }}`),
+            };
+        }
+        else {
+            return {
+                name: item.name,
+                valueFrom: {
+                    secretKeyRef: {
+                        name: item.secretName || createHelmExpression('{{ .Values.secretName }}'),
+                        key: item.name,
+                        optional: true,
+                    },
+                },
+            };
+        }
+    });
+}
+export function loadAndGenerateEnvVars(options = {}) {
+    const config = loadEnvVarsConfig(options);
+    const genOptions = options.defaultScope ? { defaultScope: options.defaultScope } : {};
+    return generateEnvVars(config, genOptions);
+}

package/dist/lib/utils/helmConstructSerializer.d.ts

@@ -0,0 +1,3 @@
+import type { HelmConstruct, HelmContent } from './helmControlStructures.js';
+export declare function serializeHelmConstruct(construct: HelmConstruct, indent?: number): string;
+export declare function serializeHelmContent(content: HelmContent, indent?: number): string;

package/dist/lib/utils/helmConstructSerializer.js

@@ -0,0 +1,61 @@
+import { isHelmConstruct } from './helmControlStructures.js';
+export function serializeHelmConstruct(construct, indent = 0) {
+    const trimLeft = construct.options?.trimLeft ?? true;
+    const trimRight = construct.options?.trimRight ?? true;
+    const openTag = `{{${trimLeft ? '-' : ''} `;
+    const closeTag = ` ${trimRight ? '-' : ''}}}`;
+    switch (construct.type) {
+        case 'if': {
+            const data = construct.data;
+            let result = `${openTag}if ${data.condition}${closeTag}\n`;
+            result += serializeHelmContent(data.then, indent);
+            if (data.else !== undefined) {
+                result += `\n${openTag}else${closeTag}\n`;
+                result += serializeHelmContent(data.else, indent);
+            }
+            result += `\n${openTag}end${closeTag}`;
+            return result;
+        }
+        default:
+            throw new Error(`Unknown Helm construct type: ${construct.type}`);
+    }
+}
+export function serializeHelmContent(content, indent = 0) {
+    const indentStr = '  '.repeat(indent);
+    if (isHelmConstruct(content)) {
+        return serializeHelmConstruct(content, indent);
+    }
+    if (content === null || content === undefined) {
+        return '';
+    }
+    if (typeof content === 'string' || typeof content === 'number' || typeof content === 'boolean') {
+        return String(content);
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((item) => {
+            if (isHelmConstruct(item)) {
+                return serializeHelmConstruct(item, indent);
+            }
+            return serializeHelmContent(item, indent);
+        })
+            .join('\n');
+    }
+    if (typeof content === 'object') {
+        const lines = [];
+        for (const [key, value] of Object.entries(content)) {
+            if (isHelmConstruct(value)) {
+                lines.push(`${indentStr}${key}: ${serializeHelmConstruct(value, indent + 1)}`);
+            }
+            else if (typeof value === 'object' && value !== null) {
+                lines.push(`${indentStr}${key}:`);
+                lines.push(serializeHelmContent(value, indent + 1));
+            }
+            else {
+                lines.push(`${indentStr}${key}: ${value}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    return '';
+}

package/dist/lib/utils/helmControlStructures.d.ts

@@ -0,0 +1,33 @@
+export interface HelmConstruct {
+    __helmConstruct: true;
+    type: 'if' | 'range' | 'with' | 'include' | 'define' | 'var' | 'block' | 'comment' | 'fragment' | 'fieldConditional';
+    data: unknown;
+    options?: HelmWhitespaceOptions;
+}
+export declare function helmFragment(...contents: HelmContent[]): HelmConstruct;
+export interface HelmExpression {
+    __helmExpression: true;
+    value: string;
+}
+export declare function createHelmExpression(value: string): HelmExpression;
+export declare function isHelmExpression(value: unknown): value is HelmExpression;
+export declare function helmRange(vars: string, collection: string, content: HelmContent, options?: HelmWhitespaceOptions): HelmConstruct;
+export declare function helmWith(scope: string, content: HelmContent, options?: HelmWhitespaceOptions): HelmConstruct;
+export declare function helmInclude(templateName: string, scope?: string, options?: {
+    pipe?: string;
+} & HelmWhitespaceOptions): HelmConstruct;
+export declare function helmDefine(name: string, content: HelmContent, options?: HelmWhitespaceOptions): HelmConstruct;
+export declare function helmVar(name: string, value: string, options?: HelmWhitespaceOptions): HelmConstruct;
+export declare function helmBlock(name: string, content: HelmContent, options?: HelmWhitespaceOptions): HelmConstruct;
+export declare function helmComment(text: string): HelmConstruct;
+export type HelmContent = string | number | boolean | null | undefined | HelmConstruct | HelmExpression | {
+    [key: string]: HelmContent;
+} | HelmContent[];
+export interface HelmWhitespaceOptions {
+    trimLeft?: boolean;
+    trimRight?: boolean;
+    inline?: boolean;
+}
+export declare function helmIf(condition: string, thenContent: HelmContent, elseContent?: HelmContent, options?: HelmWhitespaceOptions): HelmConstruct;
+export declare function helmIfSimple(condition: string, thenContent: HelmContent, options?: HelmWhitespaceOptions): HelmConstruct;
+export declare function isHelmConstruct(value: unknown): value is HelmConstruct;