timonel 2.9.1 → 2.10.0

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

@@ -1,7 +1,9 @@
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { Chart, ApiObject } from 'cdk8s';
-import YAML from 'yaml';
+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 { UmbrellaChart } from 'timonel';
@@ -91,7 +93,87 @@ export class UmbrellaChartTemplate extends Chart {
             },
         });
     }
-    _addSubchart(_subchart, _index) {
+    _addSubchart(subchart, index) {
+        try {
+            let _subchartInstance;
+            const { name: _name, version: _version, description: _description, ...subchartProps } = subchart;
+            const flexibleSubchart = createFlexibleSubchart(this, `${subchart.name}-${index}`, {
+                name: subchart.name,
+                version: subchart.version || '1.0.0',
+                description: subchart.description || `${subchart.name} subchart`,
+                ...subchartProps,
+            });
+            if (typeof subchart.chart === 'function') {
+                try {
+                    const subchartInstance = subchart.chart(this, `${subchart.name}-${index}`);
+                    if (subchartInstance.node.children) {
+                        subchartInstance.node.children.forEach((child) => {
+                            if (child instanceof Chart) {
+                                flexibleSubchart.addConstruct(child);
+                            }
+                        });
+                    }
+                }
+                catch {
+                    const subchartInstance = subchart.chart();
+                    if (subchartInstance.node.children) {
+                        subchartInstance.node.children.forEach((child) => {
+                            if (child instanceof Chart) {
+                                flexibleSubchart.addConstruct(child);
+                            }
+                        });
+                    }
+                }
+            }
+            else if (subchart.chart && typeof subchart.chart === 'object') {
+                if (subchart.chart.constructor && subchart.chart.constructor.name !== 'Object') {
+                    flexibleSubchart.addConstruct(subchart.chart);
+                }
+                else {
+                    flexibleSubchart.addManifest(subchart.chart);
+                }
+            }
+            console.log(`Added flexible subchart: ${subchart.name}`);
+        }
+        catch (_error) {
+            console.warn(`Failed to add subchart ${subchart.name}:`, _error);
+            const _fallbackSubchart = createFlexibleSubchart(this, `${subchart.name}-fallback-${index}`, {
+                name: subchart.name,
+                version: subchart.version || '1.0.0',
+                description: `${subchart.name} subchart (fallback)`,
+            });
+            console.log(`Created fallback subchart: ${subchart.name}`);
+        }
+    }
+    _createBasicSubchart(subchartName, subchartDir) {
+        const subchartYaml = {
+            apiVersion: 'v2',
+            name: subchartName,
+            description: `${subchartName} subchart`,
+            type: 'application',
+            version: '1.0.0',
+            appVersion: '1.0.0',
+        };
+        writeFileSync(join(subchartDir, 'Chart.yaml'), dumpHelmAwareYaml(subchartYaml));
+        const subchartValues = {
+            enabled: true,
+            replicas: 1,
+            image: {
+                repository: 'nginx',
+                tag: 'latest',
+            },
+        };
+        writeFileSync(join(subchartDir, 'values.yaml'), dumpHelmAwareYaml(subchartValues));
+        const templatesDir = join(subchartDir, 'templates');
+        if (!existsSync(templatesDir)) {
+            mkdirSync(templatesDir, { recursive: true });
+        }
+        const helpersTpl = generateHelpersTemplate('aws', undefined, {
+            includeKubernetes: true,
+            includeSprig: true,
+        });
+        writeFileSync(join(templatesDir, '_helpers.tpl'), helpersTpl);
+        console.log(`Created basic Helm chart structure for subchart: ${subchartName}`);
     }
     writeHelmChart(outputDir) {
         if (!existsSync(outputDir)) {
@@ -110,7 +192,7 @@ export class UmbrellaChartTemplate extends Chart {
                 repository: 'file://./charts/' + subchart.name,
             })) || [],
         };
-        writeFileSync(join(outputDir, 'Chart.yaml'), YAML.stringify(chartYaml));
+        writeFileSync(join(outputDir, 'Chart.yaml'), dumpHelmAwareYaml(chartYaml));
         const valuesYaml = {
             global: {
                 namespace: this.config.name,
@@ -122,7 +204,7 @@ export class UmbrellaChartTemplate extends Chart {
                 },
             ]) || []),
         };
-        writeFileSync(join(outputDir, 'values.yaml'), YAML.stringify(valuesYaml));
+        writeFileSync(join(outputDir, 'values.yaml'), dumpHelmAwareYaml(valuesYaml));
         const chartsDir = join(outputDir, 'charts');
         if (!existsSync(chartsDir)) {
             mkdirSync(chartsDir, { recursive: true });
@@ -132,21 +214,50 @@ export class UmbrellaChartTemplate extends Chart {
             if (!existsSync(subchartDir)) {
                 mkdirSync(subchartDir, { recursive: true });
             }
-            let subchartInstance = null;
+            const { name: _name, version: _version, description: _description, ...subchartProps } = subchart;
+            const flexibleSubchart = createFlexibleSubchart(this, `${subchart.name}-chart`, {
+                name: subchart.name,
+                version: subchart.version || '1.0.0',
+                description: subchart.description || `${subchart.name} subchart`,
+                ...subchartProps,
+            });
             if (typeof subchart.chart === 'function') {
                 try {
-                    subchartInstance = subchart.chart();
+                    const chartInstance = subchart.chart(this, `${subchart.name}-chart`);
+                    if (chartInstance && typeof chartInstance.writeHelmChart === 'function') {
+                        chartInstance.writeHelmChart(subchartDir);
+                    }
+                    else {
+                        flexibleSubchart.writeHelmChart(subchartDir);
+                    }
                 }
-                catch (error) {
-                    console.warn(`Failed to create subchart ${subchart.name}:`, error);
-                    return;
+                catch {
+                    try {
+                        const chartInstance = subchart.chart();
+                        if (chartInstance && typeof chartInstance.writeHelmChart === 'function') {
+                            chartInstance.writeHelmChart(subchartDir);
+                        }
+                        else {
+                            flexibleSubchart.writeHelmChart(subchartDir);
+                        }
+                    }
+                    catch (fallbackError) {
+                        console.warn(`Failed to create subchart ${subchart.name}:`, fallbackError);
+                        flexibleSubchart.writeHelmChart(subchartDir);
+                    }
                 }
             }
-            else {
-                subchartInstance = subchart.chart;
+            else if (subchart.chart && typeof subchart.chart === 'object') {
+                if (subchart.chart.constructor && subchart.chart.constructor.name !== 'Object') {
+                    flexibleSubchart.addConstruct(subchart.chart);
+                }
+                else {
+                    flexibleSubchart.addManifest(subchart.chart);
+                }
+                flexibleSubchart.writeHelmChart(subchartDir);
             }
-            if (subchartInstance && typeof subchartInstance.writeHelmChart === 'function') {
-                subchartInstance.writeHelmChart(subchartDir);
+            else {
+                flexibleSubchart.writeHelmChart(subchartDir);
             }
         });
         const templatesDir = join(outputDir, 'templates');
@@ -159,64 +270,18 @@ export class UmbrellaChartTemplate extends Chart {
             metadata: {
                 name: '{{ .Values.global.namespace | default .Release.Name }}',
                 labels: {
-                    'app.kubernetes.io/name': '{{ include "chart.name" . }}',
+                    'app.kubernetes.io/name': '{{ .Chart.Name }}',
                     'app.kubernetes.io/instance': '{{ .Release.Name }}',
                     'app.kubernetes.io/version': '{{ .Chart.AppVersion }}',
                     'app.kubernetes.io/managed-by': '{{ .Release.Service }}',
                 },
             },
         };
-        writeFileSync(join(templatesDir, 'namespace.yaml'), YAML.stringify(namespaceYaml));
-        const helpersTpl = `{{/*
-Expand the name of the chart.
-*/}}
-{{- define "chart.name" -}}
-{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
-{{- end }}
-
-{{/*
-Create a default fully qualified app name.
-*/}}
-{{- define "chart.fullname" -}}
-{{- if .Values.fullnameOverride }}
-{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
-{{- else }}
-{{- $name := default .Chart.Name .Values.nameOverride }}
-{{- if contains $name .Release.Name }}
-{{- .Release.Name | trunc 63 | trimSuffix "-" }}
-{{- else }}
-{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
-{{- end }}
-{{- end }}
-{{- end }}
-
-{{/*
-Create chart name and version as used by the chart label.
-*/}}
-{{- define "chart.chart" -}}
-{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" }}
-{{- end }}
-
-{{/*
-Common labels
-*/}}
-{{- define "chart.labels" -}}
-helm.sh/chart: {{ include "chart.chart" . }}
-{{ include "chart.selectorLabels" . }}
-{{- if .Chart.AppVersion }}
-app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
-{{- end }}
-app.kubernetes.io/managed-by: {{ .Release.Service }}
-{{- end }}
-
-{{/*
-Selector labels
-*/}}
-{{- define "chart.selectorLabels" -}}
-app.kubernetes.io/name: {{ include "chart.name" . }}
-app.kubernetes.io/instance: {{ .Release.Name }}
-{{- end }}
-`;
+        writeFileSync(join(templatesDir, 'namespace.yaml'), dumpHelmAwareYaml(namespaceYaml));
+        const helpersTpl = generateHelpersTemplate('aws', undefined, {
+            includeKubernetes: true,
+            includeSprig: true,
+        });
         writeFileSync(join(templatesDir, '_helpers.tpl'), helpersTpl);
     }
 }

package/dist/lib/types.d.ts

@@ -3,6 +3,9 @@ export interface ChartProps {
     name: string;
     version: string;
     description: string;
+    namespace?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
     services?: Array<{
         name: string;
         port: number;
@@ -10,8 +13,12 @@ export interface ChartProps {
     }>;
     subcharts?: Array<{
         name: string;
-        chart: Chart | (() => Chart);
+        chart: Chart | ((scope: Chart, id: string) => Chart) | unknown;
+        version?: string;
+        enabled?: boolean;
+        [key: string]: unknown;
     }>;
+    [key: string]: unknown;
 }
 export interface SubchartProps {
     name: string;

package/dist/lib/umbrellaRutter.js

@@ -1,7 +1,7 @@
 import { writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
-import YAML from 'yaml';
 import { SecurityUtils } from './security.js';
+import { dumpHelmAwareYaml } from './utils/helmYamlSerializer.js';
 export class UmbrellaRutter {
     constructor(props) {
         this.validateMetadata(props.meta);
@@ -54,7 +54,7 @@ export class UmbrellaRutter {
                 };
             }),
         };
-        writeFileSync(join(outDir, 'Chart.yaml'), YAML.stringify(chartYaml));
+        writeFileSync(join(outDir, 'Chart.yaml'), dumpHelmAwareYaml(chartYaml));
     }
     writeParentValues(outDir) {
         const values = {
@@ -68,12 +68,12 @@ export class UmbrellaRutter {
                 };
             }
         }
-        writeFileSync(join(outDir, 'values.yaml'), YAML.stringify(values));
+        writeFileSync(join(outDir, 'values.yaml'), dumpHelmAwareYaml(values));
         if (this.props.envValues) {
             for (const [env, envVals] of Object.entries(this.props.envValues)) {
                 const sanitizedEnv = SecurityUtils.sanitizeEnvironmentName(env);
                 const envValues = this.deepMerge(values, envVals);
-                writeFileSync(join(outDir, `values-${sanitizedEnv}.yaml`), YAML.stringify(envValues));
+                writeFileSync(join(outDir, `values-${sanitizedEnv}.yaml`), dumpHelmAwareYaml(envValues));
             }
         }
     }

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

@@ -0,0 +1,8 @@
+import * as jsYaml from 'js-yaml';
+export declare function dumpHelmAwareYaml(obj: unknown, options?: jsYaml.DumpOptions): string;
+export declare function stringify(obj: unknown, options?: {
+    lineWidth?: number;
+    doubleQuotedAsJSON?: boolean;
+    simpleKeys?: boolean;
+}): string;
+export declare function validateHelmExpressions(yaml: string): boolean;

package/dist/lib/utils/helmYamlSerializer.js

@@ -0,0 +1,88 @@
+import * as jsYaml from 'js-yaml';
+const HELM_EXPRESSION_PATTERNS = [
+    /\{\{\s*[^}]+\s*\}\}/g,
+    /\{\{\s*include\s+[^}]+\s*\}\}/g,
+    /\{\{\s*if\s+[^}]+\s*\}\}/g,
+    /\{\{\s*else\s*\}\}/g,
+    /\{\{\s*end\s*\}\}/g,
+    /\{\{\s*range\s+[^}]+\s*\}\}/g,
+    /\{\{\s*with\s+[^}]+\s*\}\}/g,
+    /\{\{\s*\$[^}]+\s*\}\}/g,
+    /\{\{\s*[^}]*\|\s*[^}]+\s*\}\}/g,
+];
+function createHelmExpression(value) {
+    return {
+        __helmExpression: true,
+        value,
+    };
+}
+function isHelmExpression(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '__helmExpression' in value &&
+        value.__helmExpression === true);
+}
+function containsHelmExpression(str) {
+    return HELM_EXPRESSION_PATTERNS.some((pattern) => pattern.test(str));
+}
+function preprocessHelmExpressions(obj) {
+    if (typeof obj === 'string') {
+        if (containsHelmExpression(obj)) {
+            return createHelmExpression(obj);
+        }
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(preprocessHelmExpressions);
+    }
+    if (obj && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            Object.defineProperty(result, key, {
+                value: preprocessHelmExpressions(value),
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+        return result;
+    }
+    return obj;
+}
+function helmAwareReplacer(key, value) {
+    if (isHelmExpression(value)) {
+        return value.value;
+    }
+    return value;
+}
+export function dumpHelmAwareYaml(obj, options = {}) {
+    const preprocessed = preprocessHelmExpressions(obj);
+    const helmOptions = {
+        forceQuotes: false,
+        lineWidth: options.lineWidth ?? 0,
+        flowLevel: options.flowLevel ?? -1,
+        replacer: helmAwareReplacer,
+        ...options,
+    };
+    let yamlOutput = jsYaml.dump(preprocessed, helmOptions);
+    yamlOutput = postProcessHelmExpressions(yamlOutput);
+    return yamlOutput;
+}
+function postProcessHelmExpressions(yaml) {
+    let processed = yaml;
+    processed = processed.replace(/'(\{\{[^}]*\}\})'/g, '$1');
+    processed = processed.replace(/"(\{\{[^}]*\}\})"/g, '$1');
+    processed = processed.replace(/\\(\{\{[^}]*\}\})/g, '$1');
+    return processed;
+}
+export function stringify(obj, options = {}) {
+    const jsYamlOptions = {
+        lineWidth: options.lineWidth ?? 0,
+        quotingType: options.doubleQuotedAsJSON ? '"' : "'",
+    };
+    return dumpHelmAwareYaml(obj, jsYamlOptions);
+}
+export function validateHelmExpressions(yaml) {
+    const quotedHelmExpressions = [/'(\{\{[^}]*\}\})'/g, /"(\{\{[^}]*\}\})"/g];
+    return !quotedHelmExpressions.some((pattern) => pattern.test(yaml));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "timonel",
   "type": "module",
-  "version": "2.9.1",
+  "version": "2.10.0",
   "description": "Timonel: programmatic Helm chart generator using cdk8s (TypeScript)",
   "bin": {
     "timonel": "dist/cli.js",
@@ -81,27 +81,29 @@
     ]
   },
   "dependencies": {
-    "cdk8s": "^2.70.11",
-    "cdk8s-plus-33": "^2.3.5",
+    "cdk8s": "^2.70.15",
+    "cdk8s-plus-33": "^2.3.6",
     "constructs": "^10.4.2",
     "handlebars": "^4.7.8",
-    "timonel": "^2.9.0",
+    "js-yaml": "^4.1.0",
+    "timonel": "^2.9.2",
     "ts-node": "^10.9.2",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
-    "@eslint/js": "^9.35.0",
+    "@eslint/js": "^9.36.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
-    "@types/node": "^24.3.0",
-    "@typescript-eslint/eslint-plugin": "^8.42.0",
-    "@typescript-eslint/parser": "^8.42.0",
-    "@vitest/coverage-v8": "^2.1.9",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.5.2",
+    "@typescript-eslint/eslint-plugin": "^8.44.0",
+    "@typescript-eslint/parser": "^8.44.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "conventional-changelog-cli": "^5.0.0",
-    "eslint": "^9.35.0",
+    "eslint": "^9.36.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
@@ -113,10 +115,10 @@
     "markdownlint": "^0.38.0",
     "markdownlint-cli": "^0.45.0",
     "prettier": "^3.6.2",
-    "semantic-release": "^24.2.7",
+    "semantic-release": "^24.2.9",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2",
-    "vitest": "^2.1.9"
+    "vitest": "^3.2.4"
   },
   "files": [
     "dist",