timonel 2.8.3 → 2.9.1

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

@@ -0,0 +1,189 @@
+import { Chart, ApiObject } from 'cdk8s';
+import { Rutter } from '../rutter.js';
+export class BasicChart extends Chart {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.props = props;
+        this.initializeRutter();
+        this.generateKubernetesManifests();
+    }
+    initializeRutter() {
+        const { appName = 'my-app', image = 'nginx:latest', port = 80, replicas = 1, createNamespace = false, } = this.props;
+        const meta = {
+            name: appName,
+            version: '1.0.0',
+            description: `Helm chart for ${appName}`,
+        };
+        this.rutter = new Rutter({
+            meta,
+            scope: this,
+            defaultValues: {
+                appName,
+                image,
+                port,
+                replicas,
+                createNamespace,
+            },
+        });
+        if (createNamespace) {
+            this.rutter.addConditionalManifest({
+                apiVersion: 'v1',
+                kind: 'Namespace',
+                metadata: {
+                    name: `{{ .Values.appName }}`,
+                },
+            }, 'createNamespace', 'namespace');
+        }
+        this.rutter.addManifest({
+            apiVersion: 'apps/v1',
+            kind: 'Deployment',
+            metadata: {
+                name: `{{ .Values.appName }}`,
+                labels: {
+                    app: `{{ .Values.appName }}`,
+                },
+            },
+            spec: {
+                replicas: `{{ .Values.replicas }}`,
+                selector: {
+                    matchLabels: {
+                        app: `{{ .Values.appName }}`,
+                    },
+                },
+                template: {
+                    metadata: {
+                        labels: {
+                            app: `{{ .Values.appName }}`,
+                        },
+                    },
+                    spec: {
+                        containers: [
+                            {
+                                name: 'app',
+                                image: `{{ .Values.image }}`,
+                                ports: [
+                                    {
+                                        containerPort: `{{ .Values.port }}`,
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        }, 'deployment');
+        this.rutter.addManifest({
+            apiVersion: 'v1',
+            kind: 'Service',
+            metadata: {
+                name: `{{ .Values.appName }}`,
+                labels: {
+                    app: `{{ .Values.appName }}`,
+                },
+            },
+            spec: {
+                ports: [
+                    {
+                        port: `{{ .Values.port }}`,
+                        targetPort: `{{ .Values.port }}`,
+                    },
+                ],
+                selector: {
+                    app: `{{ .Values.appName }}`,
+                },
+            },
+        }, 'service');
+    }
+    writeHelmChart(outDir) {
+        this.rutter.write(outDir);
+    }
+    generateKubernetesManifests() {
+        const { appName = 'my-app', image = 'nginx:latest', port = 80, replicas = 1, createNamespace = false, } = this.props;
+        if (createNamespace) {
+            new ApiObject(this, 'namespace', {
+                apiVersion: 'v1',
+                kind: 'Namespace',
+                metadata: {
+                    name: appName,
+                },
+            });
+        }
+        new ApiObject(this, 'deployment', {
+            apiVersion: 'apps/v1',
+            kind: 'Deployment',
+            metadata: {
+                name: appName,
+                labels: {
+                    app: appName,
+                },
+            },
+            spec: {
+                replicas,
+                selector: {
+                    matchLabels: {
+                        app: appName,
+                    },
+                },
+                template: {
+                    metadata: {
+                        labels: {
+                            app: appName,
+                        },
+                    },
+                    spec: {
+                        containers: [
+                            {
+                                name: 'app',
+                                image,
+                                ports: [
+                                    {
+                                        containerPort: port,
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        });
+        new ApiObject(this, 'service', {
+            apiVersion: 'v1',
+            kind: 'Service',
+            metadata: {
+                name: appName,
+                labels: {
+                    app: appName,
+                },
+            },
+            spec: {
+                ports: [
+                    {
+                        port,
+                        targetPort: port,
+                    },
+                ],
+                selector: {
+                    app: appName,
+                },
+            },
+        });
+    }
+}
+export function generateBasicChart(appName = 'my-app') {
+    return `import { App } from 'cdk8s';
+import { BasicChart } from 'timonel';
+
+const app = new App();
+
+const chart = new BasicChart(app, '${appName}', {
+  appName: '${appName}',
+  image: 'nginx:latest',
+  port: 80,
+  replicas: 1,
+  createNamespace: true // Set to true to create namespace, false to skip
+});
+
+// Generate complete Helm chart structure (Chart.yaml, values.yaml, templates/, _helpers.tpl)
+chart.writeHelmChart('dist');
+`;
+}

package/dist/lib/templates/subchart.d.ts

@@ -0,0 +1,27 @@
+import { Chart } from 'cdk8s';
+import type { ChartProps } from 'cdk8s';
+import type { Construct } from 'constructs';
+import { Rutter } from '../rutter.js';
+export interface SubchartProps extends ChartProps {
+    appName?: string;
+    image?: string;
+    port?: number;
+    replicas?: number;
+    serviceType?: string;
+    enableIngress?: boolean;
+    ingressHost?: string;
+    env?: Record<string, string>;
+    persistentVolume?: {
+        enabled: boolean;
+        size: string;
+        storageClass?: string;
+    };
+}
+export declare class Subchart extends Chart {
+    private rutter;
+    constructor(scope: Construct, id: string, props?: SubchartProps);
+    get rutterInstance(): Rutter;
+    writeHelmChart(outDir: string): void;
+}
+export declare function generateSubchart(props?: SubchartProps, outDir?: string): void;
+export declare function generateSubchartTemplate(name: string): string;

package/dist/lib/templates/subchart.js

@@ -0,0 +1,221 @@
+import { App, Chart } from 'cdk8s';
+import { Rutter } from '../rutter.js';
+export class Subchart extends Chart {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        const { appName = 'subchart-app', image = 'nginx:latest', port = 80, replicas = 1, serviceType = 'ClusterIP', enableIngress = false, ingressHost = 'example.com', env = {}, persistentVolume = { enabled: false, size: '1Gi' }, } = props;
+        const meta = {
+            name: appName,
+            version: '1.0.0',
+            description: `Helm chart for ${appName}`,
+        };
+        this.rutter = new Rutter({
+            meta,
+            scope: this,
+            defaultValues: {
+                appName,
+                image,
+                port,
+                replicas,
+                serviceType,
+                enableIngress,
+                ingressHost,
+                env,
+                persistentVolume,
+                ingress: {
+                    annotations: {},
+                    className: '',
+                    hosts: [
+                        {
+                            host: ingressHost,
+                            paths: [
+                                {
+                                    path: '/',
+                                    pathType: 'Prefix',
+                                },
+                            ],
+                        },
+                    ],
+                    tls: [],
+                },
+            },
+        });
+        this.rutter.addManifest({
+            apiVersion: 'v1',
+            kind: 'ConfigMap',
+            metadata: {
+                name: `{{ .Values.appName }}-config`,
+                labels: {
+                    app: `{{ .Values.appName }}`,
+                    component: 'config',
+                },
+            },
+            data: {
+                'app.name': `{{ .Values.appName }}`,
+                'app.port': `{{ .Values.port }}`,
+                'app.environment': 'production',
+            },
+        }, 'configmap');
+        this.rutter.addManifest({
+            apiVersion: 'v1',
+            kind: 'Secret',
+            metadata: {
+                name: `{{ .Values.appName }}-secret`,
+                labels: {
+                    app: `{{ .Values.appName }}`,
+                    component: 'secret',
+                },
+            },
+            stringData: {
+                'database.password': 'changeme',
+                'api.key': 'your-api-key-here',
+            },
+        }, 'secret');
+        this.rutter.addManifest({
+            apiVersion: 'apps/v1',
+            kind: 'Deployment',
+            metadata: {
+                name: `{{ .Values.appName }}`,
+                labels: {
+                    app: `{{ .Values.appName }}`,
+                },
+            },
+            spec: {
+                replicas: `{{ .Values.replicas }}`,
+                selector: {
+                    matchLabels: {
+                        app: `{{ .Values.appName }}`,
+                    },
+                },
+                template: {
+                    metadata: {
+                        labels: {
+                            app: `{{ .Values.appName }}`,
+                        },
+                    },
+                    spec: {
+                        containers: [
+                            {
+                                name: 'app',
+                                image: `{{ .Values.image }}`,
+                                ports: [
+                                    {
+                                        containerPort: `{{ .Values.port }}`,
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        }, 'deployment');
+        this.rutter.addManifest({
+            apiVersion: 'v1',
+            kind: 'Service',
+            metadata: {
+                name: `{{ .Values.appName }}`,
+                labels: {
+                    app: `{{ .Values.appName }}`,
+                },
+            },
+            spec: {
+                type: `{{ .Values.serviceType }}`,
+                ports: [
+                    {
+                        port: `{{ .Values.port }}`,
+                        targetPort: `{{ .Values.port }}`,
+                    },
+                ],
+                selector: {
+                    app: `{{ .Values.appName }}`,
+                },
+            },
+        }, 'service');
+        this.rutter.addTemplateManifest(`{{- if .Values.enableIngress }}
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: {{ include "chart.fullname" . }}
+  labels:
+    {{- include "chart.labels" . | nindent 4 }}
+  {{- with .Values.ingress.annotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+spec:
+  {{- if and .Values.ingress.className (not (hasKey .Values.ingress.annotations "kubernetes.io/ingress.class")) }}
+  ingressClassName: {{ .Values.ingress.className }}
+  {{- end }}
+  {{- if .Values.ingress.tls }}
+  tls:
+    {{- range .Values.ingress.tls }}
+    - hosts:
+        {{- range .hosts }}
+        - {{ . | quote }}
+        {{- end }}
+      secretName: {{ .secretName }}
+    {{- end }}
+  {{- end }}
+  rules:
+    {{- range .Values.ingress.hosts }}
+    - host: {{ .host | quote }}
+      http:
+        paths:
+          {{- range .paths }}
+          - path: {{ .path }}
+            {{- if and .pathType (semverCompare ">=1.18-0" $.Capabilities.KubeVersion.GitVersion) }}
+            pathType: {{ .pathType }}
+            {{- end }}
+            backend:
+              {{- if semverCompare ">=1.19-0" $.Capabilities.KubeVersion.GitVersion }}
+              service:
+                name: {{ include "chart.fullname" $ }}
+                port:
+                  number: {{ $.Values.port | int }}
+              {{- else }}
+              serviceName: {{ include "chart.fullname" $ }}
+              servicePort: {{ $.Values.port | int }}
+              {{- end }}
+          {{- end }}
+    {{- end }}
+{{- end }}`, 'ingress');
+    }
+    get rutterInstance() {
+        return this.rutter;
+    }
+    writeHelmChart(outDir) {
+        this.rutter.write(outDir);
+    }
+}
+export function generateSubchart(props = {}, outDir = 'dist') {
+    const app = new App();
+    const subchart = new Subchart(app, 'subchart', props);
+    subchart.writeHelmChart(outDir);
+}
+export function generateSubchartTemplate(name) {
+    return `import { App } from 'cdk8s';
+import { Subchart } from 'timonel';
+
+export default function createChart() {
+  const app = new App({
+    outdir: 'dist'
+  });
+
+  return new Subchart(app, '${name}', {
+    appName: '${name}',
+    image: 'nginx:latest',
+    port: 80,
+    replicas: 1,
+    serviceType: 'ClusterIP',
+    enableIngress: false,
+    ingressHost: 'example.com'
+  });
+}
+
+// Auto-execute when run directly
+if (import.meta.url === new URL(import.meta.url).href) {
+  const chart = createChart();
+  chart.node.root.synth();
+}
+`;
+}

package/dist/lib/templates/umbrella-chart.d.ts

@@ -0,0 +1,13 @@
+import type { App } from 'cdk8s';
+import { Chart } from 'cdk8s';
+import type { ChartProps } from '../types.js';
+export declare function generateUmbrellaChart(name: string): string;
+export declare class UmbrellaChartTemplate extends Chart {
+    private readonly config;
+    private _umbrellaRutter?;
+    constructor(scope: App, id: string, config: ChartProps);
+    private configure;
+    private _addService;
+    private _addSubchart;
+    writeHelmChart(outputDir: string): void;
+}

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

@@ -0,0 +1,222 @@
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { Chart, ApiObject } from 'cdk8s';
+import YAML from 'yaml';
+export function generateUmbrellaChart(name) {
+    return `import { App } from 'cdk8s';
+import { UmbrellaChart } from 'timonel';
+
+export function synth(outDir: string) {
+  const app = new App({
+    outdir: outDir,
+    outputFileExtension: '.yaml',
+    yamlOutputType: 'FILE_PER_RESOURCE'
+  });
+
+  const chart = new UmbrellaChart(app, '${name}', {
+    name: '${name}',
+    version: '0.1.0',
+    description: '${name} umbrella chart',
+    services: [],
+    subcharts: []
+  });
+
+  // Generate Helm chart files
+  chart.writeHelmChart(outDir);
+  
+  // Also generate CDK8s YAML files
+  app.synth();
+}
+
+// Auto-execute when run directly
+if (import.meta.url === new URL(import.meta.url).href) {
+  synth(process.argv[2] || 'dist');
+}
+
+export default synth;`;
+}
+export class UmbrellaChartTemplate extends Chart {
+    constructor(scope, id, config) {
+        super(scope, id);
+        this.config = config;
+        this.configure();
+    }
+    configure() {
+        new ApiObject(this, 'umbrella-info', {
+            apiVersion: 'v1',
+            kind: 'ConfigMap',
+            metadata: {
+                name: `${this.config.name}-info`,
+                labels: {
+                    'app.kubernetes.io/name': this.config.name,
+                    'app.kubernetes.io/component': 'umbrella-chart',
+                    'app.kubernetes.io/version': this.config.version,
+                },
+            },
+            data: {
+                'chart.name': this.config.name,
+                'chart.version': this.config.version,
+                'chart.description': this.config.description || '',
+                'subcharts.count': String(this.config.subcharts?.length || 0),
+            },
+        });
+        this.config.services?.forEach((svc, index) => {
+            this._addService(svc, index);
+        });
+        this.config.subcharts?.forEach((subchart, index) => {
+            this._addSubchart(subchart, index);
+        });
+    }
+    _addService(svc, index) {
+        new ApiObject(this, `service-${index}`, {
+            apiVersion: 'v1',
+            kind: 'Service',
+            metadata: {
+                name: svc.name,
+                labels: {
+                    'app.kubernetes.io/name': this.config.name,
+                    'app.kubernetes.io/component': 'service',
+                },
+            },
+            spec: {
+                ports: [
+                    {
+                        port: svc.port,
+                        targetPort: svc.targetPort,
+                    },
+                ],
+                selector: {
+                    'app.kubernetes.io/name': svc.name,
+                },
+            },
+        });
+    }
+    _addSubchart(_subchart, _index) {
+    }
+    writeHelmChart(outputDir) {
+        if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+        }
+        const chartYaml = {
+            apiVersion: 'v2',
+            name: this.config.name,
+            description: this.config.description || 'A Helm umbrella chart',
+            type: 'application',
+            version: this.config.version,
+            appVersion: this.config.version,
+            dependencies: this.config.subcharts?.map((subchart) => ({
+                name: subchart.name,
+                version: '1.0.0',
+                repository: 'file://./charts/' + subchart.name,
+            })) || [],
+        };
+        writeFileSync(join(outputDir, 'Chart.yaml'), YAML.stringify(chartYaml));
+        const valuesYaml = {
+            global: {
+                namespace: this.config.name,
+            },
+            ...Object.fromEntries(this.config.subcharts?.map((subchart) => [
+                subchart.name,
+                {
+                    enabled: true,
+                },
+            ]) || []),
+        };
+        writeFileSync(join(outputDir, 'values.yaml'), YAML.stringify(valuesYaml));
+        const chartsDir = join(outputDir, 'charts');
+        if (!existsSync(chartsDir)) {
+            mkdirSync(chartsDir, { recursive: true });
+        }
+        this.config.subcharts?.forEach((subchart) => {
+            const subchartDir = join(chartsDir, subchart.name);
+            if (!existsSync(subchartDir)) {
+                mkdirSync(subchartDir, { recursive: true });
+            }
+            let subchartInstance = null;
+            if (typeof subchart.chart === 'function') {
+                try {
+                    subchartInstance = subchart.chart();
+                }
+                catch (error) {
+                    console.warn(`Failed to create subchart ${subchart.name}:`, error);
+                    return;
+                }
+            }
+            else {
+                subchartInstance = subchart.chart;
+            }
+            if (subchartInstance && typeof subchartInstance.writeHelmChart === 'function') {
+                subchartInstance.writeHelmChart(subchartDir);
+            }
+        });
+        const templatesDir = join(outputDir, 'templates');
+        if (!existsSync(templatesDir)) {
+            mkdirSync(templatesDir, { recursive: true });
+        }
+        const namespaceYaml = {
+            apiVersion: 'v1',
+            kind: 'Namespace',
+            metadata: {
+                name: '{{ .Values.global.namespace | default .Release.Name }}',
+                labels: {
+                    'app.kubernetes.io/name': '{{ include "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, '_helpers.tpl'), helpersTpl);
+    }
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,20 @@
+import type { Chart } from 'cdk8s';
+export interface ChartProps {
+    name: string;
+    version: string;
+    description: string;
+    services?: Array<{
+        name: string;
+        port: number;
+        targetPort: number;
+    }>;
+    subcharts?: Array<{
+        name: string;
+        chart: Chart | (() => Chart);
+    }>;
+}
+export interface SubchartProps {
+    name: string;
+    version: string;
+    path: string;
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};