timonel 2.8.0-beta.4 → 2.8.0

package/dist/lib/rutter.js

@@ -1,19 +1,10 @@
-import { Chart, App, Testing } from 'cdk8s';
+import { ApiObject, App, Chart, Testing } from 'cdk8s';
 import YAML from 'yaml';
-// Import resource providers
-import { CoreResources } from './resources/core/coreResources.js';
-import { StorageResources } from './resources/core/storageResources.js';
+import { helm, include } from './helm.js';
+import { HelmChartWriter } from './helmChartWriter.js';
 import { AWSResources } from './resources/cloud/aws/awsResources.js';
-import { AzureResources } from './resources/cloud/azure/azureResources.js';
-import { GCPResources } from './resources/cloud/gcp/gcpResources.js';
-import { AutoscalingResources } from './resources/autoscaling/autoscalingResources.js';
-import { NetworkResources } from './resources/network/networkResources.js';
 import { KarpenterResources } from './resources/cloud/aws/karpenterResources.js';
-// Import HelmChartWriter for write functionality
-import { HelmChartWriter } from './helmChartWriter.js';
-import { include, helm } from './helm.js';
 import { generateHelpersTemplate } from './utils/helmHelpers.js';
-import { generateManifestName } from './utils/resourceNaming.js';
 /**
  * Rutter class with modular architecture
  * Provides a clean API while delegating to specialized resource providers
@@ -35,346 +26,9 @@ export class Rutter {
             ...(props.namespace ? { namespace: props.namespace } : {}),
         });
         // Initialize resource providers
-        this.coreResources = new CoreResources(this.chart);
-        this.storageResources = new StorageResources(this.chart);
         this.awsResources = new AWSResources(this.chart);
-        this.azureResources = new AzureResources(this.chart);
-        this.gcpResources = new GCPResources(this.chart);
-        this.autoscalingResources = new AutoscalingResources(this.chart);
-        this.networkResources = new NetworkResources(this.chart);
         this.karpenterResources = new KarpenterResources(this.chart);
     }
-    // Core Kubernetes Resources
-    /**
-     * Creates a Deployment resource
-     * @param spec - Deployment specification
-     * @returns Created Deployment ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addDeployment({
-     *   name: 'web-app',
-     *   image: 'nginx:1.21',
-     *   replicas: 3,
-     *   containerPort: 80
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addDeployment(spec) {
-        return this.coreResources.addDeployment(spec);
-    }
-    /**
-     * Creates a DaemonSet resource
-     * @param spec - DaemonSet specification
-     * @returns Created DaemonSet ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addDaemonSet({
-     *   name: 'log-collector',
-     *   image: 'fluentd:v1.14',
-     *   containerPort: 24224,
-     *   hostNetwork: true
-     * });
-     * ```
-     *
-     * @since 2.4.0
-     */
-    addDaemonSet(spec) {
-        return this.coreResources.addDaemonSet(spec);
-    }
-    /**
-     * Creates a StatefulSet resource
-     * @param spec - StatefulSet specification
-     * @returns Created StatefulSet ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addStatefulSet({
-     *   name: 'database',
-     *   image: 'postgres:13',
-     *   replicas: 3,
-     *   serviceName: 'database-headless',
-     *   containerPort: 5432
-     * });
-     * ```
-     *
-     * @since 2.4.0
-     */
-    addStatefulSet(spec) {
-        return this.coreResources.addStatefulSet(spec);
-    }
-    /**
-     * Creates a Role resource for RBAC
-     * @param spec - Role specification
-     * @returns Created Role ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addRole({
-     *   name: 'pod-reader',
-     *   rules: [
-     *     {
-     *       apiGroups: [''],
-     *       resources: ['pods'],
-     *       verbs: ['get', 'list', 'watch']
-     *     }
-     *   ]
-     * });
-     * ```
-     *
-     * @since 2.4.0
-     */
-    addRole(spec) {
-        return this.coreResources.addRole(spec);
-    }
-    /**
-     * Creates a ClusterRole resource for cluster-wide RBAC
-     * @param spec - ClusterRole specification
-     * @returns Created ClusterRole ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addClusterRole({
-     *   name: 'cluster-reader',
-     *   rules: [
-     *     {
-     *       apiGroups: [''],
-     *       resources: ['nodes', 'namespaces'],
-     *       verbs: ['get', 'list', 'watch']
-     *     }
-     *   ]
-     * });
-     * ```
-     *
-     * @since 2.4.0
-     */
-    addClusterRole(spec) {
-        return this.coreResources.addClusterRole(spec);
-    }
-    /**
-     * Creates a RoleBinding resource for RBAC
-     * @param spec - RoleBinding specification
-     * @returns Created RoleBinding ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addRoleBinding({
-     *   name: 'pod-reader-binding',
-     *   roleRef: {
-     *     kind: 'Role',
-     *     name: 'pod-reader',
-     *     apiGroup: 'rbac.authorization.k8s.io'
-     *   },
-     *   subjects: [
-     *     {
-     *       kind: 'ServiceAccount',
-     *       name: 'my-service-account'
-     *     }
-     *   ]
-     * });
-     * ```
-     *
-     * @since 2.4.0
-     */
-    addRoleBinding(spec) {
-        return this.coreResources.addRoleBinding(spec);
-    }
-    /**
-     * Creates a ClusterRoleBinding resource for cluster-wide RBAC
-     * @param spec - ClusterRoleBinding specification
-     * @returns Created ClusterRoleBinding ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addClusterRoleBinding({
-     *   name: 'cluster-reader-binding',
-     *   roleRef: {
-     *     kind: 'ClusterRole',
-     *     name: 'cluster-reader',
-     *     apiGroup: 'rbac.authorization.k8s.io'
-     *   },
-     *   subjects: [
-     *     {
-     *       kind: 'ServiceAccount',
-     *       name: 'monitoring-agent',
-     *       namespace: 'monitoring'
-     *     }
-     *   ]
-     * });
-     * ```
-     *
-     * @since 2.4.0
-     */
-    addClusterRoleBinding(spec) {
-        return this.coreResources.addClusterRoleBinding(spec);
-    }
-    /**
-     * Creates a Job resource for batch workloads
-     * @param spec - Job specification
-     * @returns Created Job ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addJob({
-     *   name: 'data-processor',
-     *   image: 'busybox:1.35',
-     *   command: ['sh', '-c', 'echo "Processing..." && sleep 30'],
-     *   completions: 1
-     * });
-     * ```
-     *
-     * @since 2.4.0
-     */
-    addJob(spec) {
-        return this.coreResources.addJob(spec);
-    }
-    /**
-     * Creates a Service resource
-     * @param spec - Service specification
-     * @returns Created Service ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addService({
-     *   name: 'web-service',
-     *   port: 80,
-     *   targetPort: 8080,
-     *   type: 'ClusterIP'
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addService(spec) {
-        return this.coreResources.addService(spec);
-    }
-    /**
-     * Creates a ConfigMap resource
-     * @param spec - ConfigMap specification
-     * @returns Created ConfigMap ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addConfigMap({
-     *   name: 'app-config',
-     *   data: {
-     *     'config.yaml': 'key: value',
-     *     'app.properties': 'debug=true'
-     *   }
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addConfigMap(spec) {
-        return this.coreResources.addConfigMap(spec);
-    }
-    /**
-     * Creates a Secret resource
-     * @param spec - Secret specification
-     * @returns Created Secret ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addSecret({
-     *   name: 'app-secrets',
-     *   type: 'Opaque',
-     *   data: {
-     *     username: 'YWRtaW4=',
-     *     password: 'MWYyZDFlMmU2N2Rm'
-     *   }
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addSecret(spec) {
-        return this.coreResources.addSecret(spec);
-    }
-    /**
-     * Creates a ServiceAccount resource
-     * @param spec - ServiceAccount specification
-     * @returns Created ServiceAccount ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addServiceAccount({
-     *   name: 'app-service-account',
-     *   automountServiceAccountToken: false
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addServiceAccount(spec) {
-        return this.coreResources.addServiceAccount(spec);
-    }
-    // Storage Resources
-    /**
-     * Creates a PersistentVolume resource
-     * @param spec - PersistentVolume specification
-     * @returns Created PersistentVolume ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addPersistentVolume({
-     *   name: 'data-pv',
-     *   capacity: '10Gi',
-     *   accessModes: ['ReadWriteOnce'],
-     *   storageClassName: 'fast-ssd'
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addPersistentVolume(spec) {
-        return this.storageResources.addPersistentVolume(spec);
-    }
-    /**
-     * Creates a PersistentVolumeClaim resource
-     * @param spec - PersistentVolumeClaim specification
-     * @returns Created PersistentVolumeClaim ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addPersistentVolumeClaim({
-     *   name: 'data-pvc',
-     *   size: '10Gi',
-     *   accessModes: ['ReadWriteOnce'],
-     *   storageClassName: 'fast-ssd'
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addPersistentVolumeClaim(spec) {
-        return this.storageResources.addPersistentVolumeClaim(spec);
-    }
-    /**
-     * Creates a StorageClass resource
-     * @param spec - StorageClass specification
-     * @returns Created StorageClass ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addStorageClass({
-     *   name: 'fast-ssd',
-     *   provisioner: 'kubernetes.io/aws-ebs',
-     *   parameters: {
-     *     type: 'gp3',
-     *     encrypted: 'true'
-     *   }
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
-    addStorageClass(spec) {
-        return this.storageResources.addStorageClass(spec);
-    }
     // AWS Resources
     /**
      * Creates an AWS EBS StorageClass
@@ -423,8 +77,8 @@ export class Rutter {
      * @example
      * ```typescript
      * rutter.addAWSIRSAServiceAccount({
-     *   name: 'aws-service-account',
-     *   roleArn: 'arn:aws:iam::123456789012:role/MyRole'
+     *   name: 'my-service-account',
+     *   roleArn: 'arn:aws:iam::ACCOUNT_ID:role/MyRole'
      * });
      * ```
      *
@@ -458,116 +112,6 @@ export class Rutter {
     addAWSALBIngress(spec) {
         return this.awsResources.addALBIngress(spec);
     }
-    // Azure Cloud Resources
-    /**
-     * Creates an Azure Disk StorageClass
-     * @param spec - Azure Disk StorageClass specification
-     * @returns Created StorageClass ApiObject
-     *
-     * @since 2.4.0
-     */
-    addAzureDiskStorageClass(spec) {
-        return this.azureResources.addAzureDiskStorageClass(spec);
-    }
-    /**
-     * Creates an Azure File StorageClass
-     * @param spec - Azure File StorageClass specification
-     * @returns Created StorageClass ApiObject
-     *
-     * @since 2.4.0
-     */
-    addAzureFileStorageClass(spec) {
-        return this.azureResources.addAzureFileStorageClass(spec);
-    }
-    /**
-     * Creates an Azure Application Gateway Ingress
-     * @param spec - AGIC Ingress specification
-     * @returns Created Ingress ApiObject
-     *
-     * @since 2.4.0
-     */
-    addAzureApplicationGatewayIngress(spec) {
-        return this.azureResources.addApplicationGatewayIngress(spec);
-    }
-    /**
-     * Creates an Azure Key Vault SecretProviderClass
-     * @param spec - Azure Key Vault SecretProviderClass specification
-     * @returns Created SecretProviderClass ApiObject
-     *
-     * @since 2.4.0
-     */
-    addAzureKeyVaultSecretProviderClass(spec) {
-        return this.azureResources.addAzureKeyVaultSecretProviderClass(spec);
-    }
-    /**
-     * Creates an Azure Container Registry ServiceAccount
-     * @param spec - Azure ACR ServiceAccount specification
-     * @returns Created ServiceAccount ApiObject
-     *
-     * @since 2.4.0
-     */
-    addAzureACRServiceAccount(spec) {
-        return this.azureResources.addAzureACRServiceAccount(spec);
-    }
-    // GCP Cloud Resources
-    /**
-     * Creates a GCP Persistent Disk StorageClass
-     * @param spec - GCP PD StorageClass specification
-     * @returns Created StorageClass ApiObject
-     *
-     * @since 2.4.0
-     */
-    addGCPPersistentDiskStorageClass(spec) {
-        return this.gcpResources.addPersistentDiskStorageClass(spec);
-    }
-    /**
-     * Creates a GCP Filestore StorageClass
-     * @param spec - GCP Filestore StorageClass specification
-     * @returns Created StorageClass ApiObject
-     *
-     * @since 2.4.0
-     */
-    addGCPFilestoreStorageClass(spec) {
-        return this.gcpResources.addFilestoreStorageClass(spec);
-    }
-    /**
-     * Creates a GCE Ingress with Google Cloud Load Balancer
-     * @param spec - GCE Ingress specification
-     * @returns Created Ingress ApiObject
-     *
-     * @since 2.4.0
-     */
-    addGCPGCEIngress(spec) {
-        return this.gcpResources.addGCEIngress(spec);
-    }
-    /**
-     * Creates a ServiceAccount with Workload Identity annotations
-     * @param spec - Workload Identity ServiceAccount specification
-     * @returns Created ServiceAccount ApiObject
-     *
-     * @since 2.4.0
-     */
-    addGCPWorkloadIdentityServiceAccount(spec) {
-        return this.gcpResources.addWorkloadIdentityServiceAccount(spec);
-    }
-    /**
-     * Creates a ServiceAccount with GCP Artifact Registry access
-     * @param spec - Artifact Registry ServiceAccount specification
-     * @returns Created ServiceAccount ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addGCPArtifactRegistryServiceAccount({
-     *   name: 'artifact-registry-sa',
-     *   googleServiceAccount: 'my-gsa@project.iam.gserviceaccount.com'
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
-    addGCPArtifactRegistryServiceAccount(spec) {
-        return this.gcpResources.addArtifactRegistryServiceAccount(spec);
-    }
     // AWS Karpenter Resources
     /**
      * Creates a Karpenter NodePool resource
@@ -696,235 +240,6 @@ export class Rutter {
     addKarpenterNodePoolWithScheduling(spec) {
         return this.karpenterResources.addKarpenterNodePoolWithScheduling(spec);
     }
-    // Network Resources
-    /**
-     * Creates a NetworkPolicy resource
-     * @param spec - NetworkPolicy specification
-     * @returns Created NetworkPolicy ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addNetworkPolicy({
-     *   name: 'deny-all',
-     *   podSelector: {},
-     *   policyTypes: ['Ingress', 'Egress']
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
-    addNetworkPolicy(spec) {
-        return this.networkResources.addNetworkPolicy(spec);
-    }
-    /**
-     * Creates a deny-all NetworkPolicy that blocks all traffic
-     * @param name - Policy name
-     * @param podSelector - Pod selector to apply policy to
-     * @param labels - Optional labels
-     * @param annotations - Optional annotations
-     * @returns Created NetworkPolicy ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addDenyAllNetworkPolicy('deny-all', { matchLabels: { app: 'web' } });
-     * ```
-     *
-     * @since 2.7.0
-     */
-    addDenyAllNetworkPolicy(name, podSelector = {}, labels, annotations) {
-        return this.networkResources.addDenyAllNetworkPolicy(name, podSelector, labels, annotations);
-    }
-    /**
-     * Creates a NetworkPolicy that allows traffic from specific pods
-     * @param name - Policy name
-     * @param podSelector - Pod selector to apply policy to
-     * @param fromPodSelector - Pod selector for allowed source pods
-     * @param ports - Optional ports to allow
-     * @param labels - Optional labels
-     * @param annotations - Optional annotations
-     * @returns Created NetworkPolicy ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addAllowFromPodsNetworkPolicy(
-     *   'allow-from-frontend',
-     *   { matchLabels: { app: 'backend' } },
-     *   { matchLabels: { app: 'frontend' } },
-     *   [{ port: 8080, protocol: 'TCP' }]
-     * );
-     * ```
-     *
-     * @since 2.7.0
-     */
-    addAllowFromPodsNetworkPolicy(name, podSelector, fromPodSelector, ports, labels, annotations) {
-        return this.networkResources.addAllowFromPodsNetworkPolicy(name, podSelector, fromPodSelector, ports, labels, annotations);
-    }
-    /**
-     * Creates a NetworkPolicy that allows traffic from specific namespaces
-     * @param name - Policy name
-     * @param podSelector - Pod selector to apply policy to
-     * @param fromNamespaceSelector - Namespace selector for allowed source namespaces
-     * @param ports - Optional ports to allow
-     * @param labels - Optional labels
-     * @param annotations - Optional annotations
-     * @returns Created NetworkPolicy ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addAllowFromNamespaceNetworkPolicy(
-     *   'allow-from-monitoring',
-     *   { matchLabels: { app: 'web' } },
-     *   { matchLabels: { name: 'monitoring' } },
-     *   [{ port: 9090, protocol: 'TCP' }]
-     * );
-     * ```
-     *
-     * @since 2.7.0
-     */
-    addAllowFromNamespaceNetworkPolicy(name, podSelector, fromNamespaceSelector, ports, labels, annotations) {
-        return this.networkResources.addAllowFromNamespaceNetworkPolicy(name, podSelector, fromNamespaceSelector, ports, labels, annotations);
-    }
-    addIngress(specOrName, host, serviceName, servicePort, options) {
-        if (typeof specOrName === 'string') {
-            return this.createSimpleIngress(specOrName, host, serviceName, servicePort, options);
-        }
-        // Original spec-based overload
-        return this.networkResources.addIngress(specOrName);
-    }
-    /**
-     * Creates a simple Ingress with enhanced options
-     * @private
-     */
-    createSimpleIngress(name, host, serviceName, servicePort, options) {
-        const tlsSecretName = typeof options?.tls === 'string' ? options.tls : `${name}-tls`;
-        const annotations = this.buildIngressAnnotations(options);
-        const spec = {
-            name,
-            rules: [
-                {
-                    host,
-                    http: {
-                        paths: [
-                            {
-                                path: options?.path || '/',
-                                pathType: options?.pathType || 'Prefix',
-                                backend: {
-                                    service: {
-                                        name: serviceName,
-                                        port: { number: servicePort },
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-            ],
-            ...(options?.className && { ingressClassName: options.className }),
-            ...(Object.keys(annotations).length > 0 && { annotations }),
-            ...(options?.tls && {
-                tls: [
-                    {
-                        hosts: [host],
-                        secretName: tlsSecretName,
-                    },
-                ],
-            }),
-        };
-        return this.networkResources.addIngress(spec);
-    }
-    /**
-     * Builds annotations for Ingress based on options
-     * @private
-     */
-    buildIngressAnnotations(options) {
-        const annotations = { ...options?.annotations };
-        this.addSSLRedirectAnnotation(annotations, options);
-        this.addCertManagerAnnotation(annotations, options);
-        this.addNginxAnnotations(annotations, options);
-        return annotations;
-    }
-    /**
-     * Adds SSL redirect annotation based on class and options
-     * @private
-     */
-    addSSLRedirectAnnotation(annotations, options) {
-        if (!options?.tls || options.sslRedirect === false)
-            return;
-        if (options.className === 'nginx' || !options.className) {
-            annotations['nginx.ingress.kubernetes.io/ssl-redirect'] = 'true';
-        }
-        else if (options.className === 'alb') {
-            annotations['alb.ingress.kubernetes.io/ssl-redirect'] = '443';
-        }
-    }
-    /**
-     * Adds cert-manager annotation if specified
-     * @private
-     */
-    addCertManagerAnnotation(annotations, options) {
-        if (options?.certManager) {
-            annotations['cert-manager.io/cluster-issuer'] = options.certManager;
-        }
-    }
-    /**
-     * Adds NGINX-specific annotations
-     * @private
-     */
-    addNginxAnnotations(annotations, options) {
-        if (options?.className !== 'nginx' && options?.className)
-            return;
-        if (options?.cors) {
-            annotations['nginx.ingress.kubernetes.io/enable-cors'] = 'true';
-        }
-        if (options?.bodySize) {
-            annotations['nginx.ingress.kubernetes.io/proxy-body-size'] = options.bodySize;
-        }
-        if (options?.timeout) {
-            annotations['nginx.ingress.kubernetes.io/proxy-read-timeout'] = options.timeout.toString();
-        }
-        if (options?.backendProtocol && options.backendProtocol !== 'HTTP') {
-            annotations['nginx.ingress.kubernetes.io/backend-protocol'] = options.backendProtocol;
-        }
-        if (options?.rewriteTarget) {
-            annotations['nginx.ingress.kubernetes.io/rewrite-target'] = options.rewriteTarget;
-        }
-    }
-    /**
-     * Creates a secure Ingress resource with TLS validation and environment-aware security defaults
-     * @param spec - Enhanced Ingress specification with security options
-     * @returns Created Ingress ApiObject
-     *
-     * @example
-     * ```typescript
-     * // Production Ingress with mandatory TLS
-     * rutter.addSecureIngress({
-     *   name: 'secure-web-ingress',
-     *   environment: 'production',
-     *   tls: [{
-     *     hosts: ['secure.example.com'],
-     *     secretName: 'secure-example-tls'
-     *   }],
-     *   forceSSLRedirect: true,
-     *   rules: [{
-     *     host: 'secure.example.com',
-     *     http: {
-     *       paths: [{
-     *         path: '/',
-     *         pathType: 'Prefix',
-     *         backend: {
-     *           service: { name: 'web-service', port: { number: 80 } }
-     *         }
-     *       }]
-     *     }
-     *   }]
-     * });
-     * ```
-     *
-     * @since 2.8.0
-     */
-    addSecureIngress(spec) {
-        return this.networkResources.addSecureIngress(spec);
-    }
     // AWS ECR ServiceAccount
     /**
      * Creates a ServiceAccount with ECR access annotations
@@ -935,7 +250,7 @@ export class Rutter {
      * ```typescript
      * rutter.addAWSECRServiceAccount({
      *   name: 'ecr-service-account',
-     *   roleArn: 'arn:aws:iam::123456789012:role/ECRAccessRole'
+     *   roleArn: 'arn:aws:iam::ACCOUNT_ID:role/ECRAccessRole'
      * });
      * ```
      *
@@ -944,103 +259,21 @@ export class Rutter {
     addAWSECRServiceAccount(spec) {
         return this.awsResources.addECRServiceAccount(spec);
     }
-    // Autoscaling Resources
-    /**
-     * Creates a Horizontal Pod Autoscaler (HPA) resource
-     * @param spec - HPA specification
-     * @returns Created HPA ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addHorizontalPodAutoscaler({
-     *   name: 'web-hpa',
-     *   scaleTargetRef: {
-     *     apiVersion: 'apps/v1',
-     *     kind: 'Deployment',
-     *     name: 'web-app'
-     *   },
-     *   minReplicas: 2,
-     *   maxReplicas: 10,
-     *   metrics: [{
-     *     type: 'Resource',
-     *     resource: {
-     *       name: 'cpu',
-     *       target: { type: 'Utilization', averageUtilization: 70 }
-     *     }
-     *   }]
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
-    addHorizontalPodAutoscaler(spec) {
-        return this.autoscalingResources.addHorizontalPodAutoscaler(spec);
-    }
-    /**
-     * Creates a Vertical Pod Autoscaler (VPA) resource
-     * @param spec - VPA specification
-     * @returns Created VPA ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addVerticalPodAutoscaler({
-     *   name: 'web-vpa',
-     *   targetRef: {
-     *     apiVersion: 'apps/v1',
-     *     kind: 'Deployment',
-     *     name: 'web-app'
-     *   },
-     *   updatePolicy: { updateMode: 'Auto' }
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
-    addVerticalPodAutoscaler(spec) {
-        return this.autoscalingResources.addVerticalPodAutoscaler(spec);
-    }
+    // Utility methods
     /**
-     * Creates a CronJob resource
-     * @param spec - CronJob specification
-     * @returns Created CronJob ApiObject
+     * Adds a Kubernetes manifest to the chart using CDK8S
      *
-     * @example
-     * ```typescript
-     * rutter.addCronJob({
-     *   name: 'backup-job',
-     *   schedule: '0 2 * * *',
-     *   jobTemplate: {
-     *     spec: {
-     *       template: {
-     *         spec: {
-     *           containers: [{
-     *             name: 'backup',
-     *             image: 'backup:latest',
-     *             command: ['backup.sh']
-     *           }],
-     *           restartPolicy: 'OnFailure'
-     *         }
-     *       }
-     *     }
-     *   }
-     * });
-     * ```
+     * This method allows you to add any Kubernetes manifest (CRDs, custom resources, etc.)
+     * either as YAML strings or as objects. The manifest will be processed using CDK8S
+     * for better type safety and validation.
      *
-     * @since 2.7.0
-     */
-    addCronJob(spec) {
-        return this.autoscalingResources.addCronJob(spec);
-    }
-    // Utility methods
-    /**
-     * Adds a custom resource definition (CRD) YAML or object
-     * @param yamlOrObject - CRD YAML content string or object
-     * @param id - Unique identifier for the CRD
+     * @param yamlOrObject - Kubernetes manifest as YAML string or object
+     * @param id - Unique identifier for the manifest (required for multiple manifests)
      *
      * @example
      * ```typescript
-     * // Using YAML string
-     * rutter.addCrd(`
+     * // Using YAML string for CRD
+     * rutter.addManifest(`
      * apiVersion: apiextensions.k8s.io/v1
      * kind: CustomResourceDefinition
      * metadata:
@@ -1048,82 +281,144 @@ export class Rutter {
      * spec:
      *   group: example.com
      *   versions: []
-     * `);
+     * `, 'my-crd');
      *
-     * // Using object
-     * rutter.addCrd({
-     *   apiVersion: 'apiextensions.k8s.io/v1',
-     *   kind: 'CustomResourceDefinition',
-     *   metadata: { name: 'example.com' },
-     *   spec: { group: 'example.com', versions: [] }
-     * });
+     * // Using object for any Kubernetes resource
+     * rutter.addManifest({
+     *   apiVersion: 'v1',
+     *   kind: 'ConfigMap',
+     *   metadata: { name: 'my-config' },
+     *   data: { key: 'value' }
+     * }, 'my-configmap');
      * ```
      *
-     * @since 1.0.0
+     * @since 3.0.0
+     * @note Consider using cdk8s-plus constructs for better type safety when available
      */
-    addCrd(yamlOrObject, id = 'crd') {
-        let yaml;
-        let crdObject;
+    addManifest(yamlOrObject, id) {
+        let manifestObject;
         if (typeof yamlOrObject === 'string') {
-            // Validate YAML string
+            // Parse YAML string to object
             try {
-                crdObject = YAML.parse(yamlOrObject);
-                yaml = yamlOrObject.trim();
+                manifestObject = YAML.parse(yamlOrObject);
             }
             catch (error) {
-                throw new Error(`Invalid YAML provided to addCrd(): ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw new Error(`Invalid YAML provided to addManifest(): ${error instanceof Error ? error.message : 'Unknown error'}`);
             }
         }
         else if (typeof yamlOrObject === 'object' && yamlOrObject !== null) {
-            // Use object directly and convert to YAML
-            crdObject = yamlOrObject;
-            try {
-                yaml = YAML.stringify(yamlOrObject).trim();
-            }
-            catch (error) {
-                throw new Error(`Failed to convert object to YAML in addCrd(): ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
+            // Use object directly
+            manifestObject = yamlOrObject;
         }
         else {
-            throw new Error('addCrd() requires either a YAML string or an object');
+            throw new Error('addManifest() requires either a YAML string or an object');
         }
-        // Ensure we have valid content
-        if (!yaml) {
-            throw new Error('addCrd() received empty or invalid content');
+        // Validate basic Kubernetes manifest structure
+        this.validateManifestStructure(manifestObject);
+        // Create CDK8S ApiObject from the manifest
+        return new ApiObject(this.chart, id, {
+            apiVersion: manifestObject['apiVersion'],
+            kind: manifestObject['kind'],
+            metadata: manifestObject['metadata'],
+            spec: manifestObject['spec'],
+        });
+    }
+    /**
+     * Adds a Kubernetes manifest wrapped in a Helm conditional
+     *
+     * This method creates a manifest that will only be rendered if the specified
+     * condition evaluates to true. The condition is checked against .Values in Helm.
+     *
+     * @param manifestObject - JavaScript object representing the Kubernetes manifest
+     * @param condition - Path to the condition value in .Values (e.g., 'createNamespace')
+     * @param id - Unique identifier for this manifest within the chart
+     * @returns The created ApiObject instance
+     * @throws {Error} If the manifest structure is incorrect or condition path is invalid
+     *
+     * @example
+     * ```typescript
+     * // Add a namespace that's only created if .Values.createNamespace is true
+     * rutter.addConditionalManifest(
+     *   {
+     *     apiVersion: 'v1',
+     *     kind: 'Namespace',
+     *     metadata: {
+     *       name: valuesRef('namespace'),
+     *       labels: {
+     *         environment: conditionalRef('environment', 'environment')
+     *       }
+     *     }
+     *   },
+     *   'createNamespace',
+     *   'namespace'
+     * );
+     * ```
+     *
+     * @since 2.7.4
+     */
+    addConditionalManifest(manifestObject, condition, id) {
+        // Validate condition path
+        if (!condition || typeof condition !== 'string') {
+            throw new Error('Condition must be a non-empty string');
         }
-        // Validate CRD structure
-        this.validateCrdStructure(crdObject);
-        this.assets.push({ id, yaml, target: 'crds' });
+        // Validate basic Kubernetes manifest structure
+        this.validateManifestStructure(manifestObject);
+        // Store the manifest as a conditional asset that will be processed during write
+        const conditionalAsset = {
+            id,
+            yaml: `{{- if .Values.${condition} }}\n${YAML.stringify(manifestObject)}{{- end }}`,
+            target: 'templates',
+        };
+        this.assets.push(conditionalAsset);
+        // Create a placeholder CDK8S ApiObject for consistency
+        return new ApiObject(this.chart, id, {
+            apiVersion: manifestObject['apiVersion'],
+            kind: manifestObject['kind'],
+            metadata: {
+                ...(manifestObject['metadata'] || {}),
+                annotations: {
+                    ...(manifestObject['metadata']?.['annotations'] || {}),
+                    'timonel.sh/conditional': condition,
+                },
+            },
+            spec: manifestObject['spec'],
+        });
     }
     /**
-     * Validates CRD structure according to Kubernetes specification
-     * @param crd - CRD object to validate
+     * Validates the structure of a Kubernetes manifest object
+     * @param manifest - The manifest object to validate
      * @private
-     * @since 2.5.0
+     * @since 3.0.0
      */
-    validateCrdStructure(crd) {
-        if (crd['apiVersion'] !== 'apiextensions.k8s.io/v1') {
-            throw new Error('CRD must use apiVersion: apiextensions.k8s.io/v1');
+    validateManifestStructure(manifest) {
+        if (!manifest['apiVersion'] || typeof manifest['apiVersion'] !== 'string') {
+            throw new Error('Kubernetes manifest must have a valid apiVersion');
         }
-        if (crd['kind'] !== 'CustomResourceDefinition') {
-            throw new Error('CRD must have kind: CustomResourceDefinition');
+        if (!manifest['kind'] || typeof manifest['kind'] !== 'string') {
+            throw new Error('Kubernetes manifest must have a valid kind');
         }
-        if (!crd['metadata'] || typeof crd['metadata'] !== 'object' || crd['metadata'] === null) {
-            throw new Error('CRD must have a metadata object');
+        if (!manifest['metadata'] ||
+            typeof manifest['metadata'] !== 'object' ||
+            manifest['metadata'] === null) {
+            throw new Error('Kubernetes manifest must have valid metadata');
         }
-        const metadata = crd['metadata'];
+        const metadata = manifest['metadata'];
         if (!metadata['name'] || typeof metadata['name'] !== 'string') {
-            throw new Error('CRD must have a valid metadata.name');
-        }
-        if (!crd['spec'] || typeof crd['spec'] !== 'object' || crd['spec'] === null) {
-            throw new Error('CRD must have a spec object');
+            throw new Error('Kubernetes manifest metadata must have a valid name');
         }
-        const spec = crd['spec'];
-        if (!spec['group'] || typeof spec['group'] !== 'string') {
-            throw new Error('CRD must have a valid spec.group');
-        }
-        if (!Array.isArray(spec['versions']) || spec['versions'].length === 0) {
-            throw new Error('CRD must have at least one version in spec.versions');
+        // Additional validation for specific resource types
+        const kind = manifest['kind'];
+        if (kind === 'CustomResourceDefinition') {
+            if (!manifest['spec'] || typeof manifest['spec'] !== 'object' || manifest['spec'] === null) {
+                throw new Error('CustomResourceDefinition must have a valid spec');
+            }
+            const spec = manifest['spec'];
+            if (!spec['group'] || typeof spec['group'] !== 'string') {
+                throw new Error('CustomResourceDefinition spec must have a valid group');
+            }
+            if (!Array.isArray(spec['versions']) || spec['versions'].length === 0) {
+                throw new Error('CustomResourceDefinition must have at least one version in spec.versions');
+            }
         }
     }
     /**
@@ -1169,6 +464,13 @@ export class Rutter {
      * @since 2.4.0
      */
     toSynthArray() {
+        // Get ApiObject IDs before synthesis
+        const apiObjectIds = [];
+        for (const child of this.chart.node.children) {
+            if (child instanceof ApiObject) {
+                apiObjectIds.push(child.node.id);
+            }
+        }
         // Use cdk8s Testing.synth to obtain manifest objects
         const manifestObjs = Testing.synth(this.chart);
         // Enforce common labels best-practice on all rendered objects
@@ -1200,7 +502,7 @@ export class Rutter {
         if (this.props.singleManifestFile) {
             // Combine all resources into single manifest
             const combinedYaml = enriched
-                .map((obj) => YAML.stringify(obj).trim())
+                .map((obj) => this.processHelmTemplates(YAML.stringify(obj).trim()))
                 .filter(Boolean)
                 .join('\n---\n');
             const manifestId = this.props.manifestPrefix ?? 'manifests';
@@ -1209,9 +511,12 @@ export class Rutter {
         else {
             // Create separate files for each resource (default behavior)
             enriched.forEach((obj, index) => {
-                const yaml = YAML.stringify(obj).trim();
+                const yaml = this.processHelmTemplates(YAML.stringify(obj).trim());
                 if (yaml) {
-                    const manifestId = generateManifestName(obj, this.props.namingStrategy ?? 'descriptive', index + 1, this.props.manifestPrefix);
+                    // Use descriptive name from ApiObject ID if available, otherwise fallback to generic name
+                    // eslint-disable-next-line security/detect-object-injection
+                    const apiObjectId = apiObjectIds[index];
+                    const manifestId = apiObjectId || `manifest-${index + 1}`;
                     synthAssets.push({ id: manifestId, yaml });
                 }
             });
@@ -1222,6 +527,21 @@ export class Rutter {
         });
         return synthAssets;
     }
+    /**
+     * Process YAML content to remove quotes from Helm templates
+     * This fixes the issue where YAML.stringify adds quotes around Helm template expressions
+     * Removes quotes from all Helm template expressions
+     */
+    processHelmTemplates(yaml) {
+        // Remove quotes from Helm template expressions
+        // Match patterns like "{{ .Values.replicas | int }}", "{{ .Release.Name }}", etc.
+        // Handle both key-value pairs and standalone values
+        return yaml
+            .replace(/": "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
+            .replace(/: "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
+            .replace(/"\{\{([^}]+)\}\}"/g, '{{ $1 }}')
+            .replace(/": "\.nan"/g, ': .nan');
+    }
     /**
      * Writes the Helm chart to the specified output directory
      * @param outDir - Output directory path