@intentius/chant-lexicon-helm 0.124.31 → 0.124.32

package/dist/composites/helm-microservice.js

@@ -0,0 +1,260 @@
+/**
+ * HelmMicroservice composite — Deployment + Service + Ingress + HPA + PDB + ServiceAccount + ConfigMap.
+ *
+ * Full microservice pattern with all common production resources.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Chart, Values, Deployment, Service, ServiceAccount, ConfigMap, Ingress, HPA, PDB } from "../resources.js";
+import { values, include, printf, toYaml, With } from "../intrinsics.js";
+export const HelmMicroservice = Composite((props) => {
+    const { name, imageRepository = "nginx", imageTag = "", port = 8080, replicas = 2, serviceType = "ClusterIP", ingress = true, autoscaling = true, pdb = true, configMap = true, appVersion = "1.0.0", defaults: defs, } = props;
+    const chart = new Chart(mergeDefaults({
+        apiVersion: "v2",
+        name,
+        version: "0.1.0",
+        appVersion,
+        type: "application",
+        description: `A Helm chart for ${name} microservice`,
+    }, defs?.chart));
+    const valuesObj = {
+        replicaCount: replicas,
+        image: {
+            repository: imageRepository,
+            tag: imageTag,
+            pullPolicy: "IfNotPresent",
+        },
+        service: {
+            type: serviceType,
+            port,
+        },
+        serviceAccount: {
+            create: true,
+            name: "",
+            annotations: {},
+        },
+        resources: {
+            limits: { cpu: "500m", memory: "256Mi" },
+            requests: { cpu: "100m", memory: "128Mi" },
+        },
+        livenessProbe: {
+            httpGet: { path: "/healthz", port: "http" },
+            initialDelaySeconds: 15,
+            periodSeconds: 20,
+        },
+        readinessProbe: {
+            httpGet: { path: "/readyz", port: "http" },
+            initialDelaySeconds: 5,
+            periodSeconds: 10,
+        },
+    };
+    if (props.podSecurityContext)
+        valuesObj.podSecurityContext = props.podSecurityContext;
+    if (props.securityContext)
+        valuesObj.securityContext = props.securityContext;
+    if (props.nodeSelector)
+        valuesObj.nodeSelector = props.nodeSelector;
+    if (props.tolerations)
+        valuesObj.tolerations = props.tolerations;
+    if (props.affinity)
+        valuesObj.affinity = props.affinity;
+    if (props.podAnnotations)
+        valuesObj.podAnnotations = props.podAnnotations;
+    if (props.strategy)
+        valuesObj.strategy = props.strategy;
+    if (configMap) {
+        valuesObj.config = {};
+    }
+    if (ingress) {
+        valuesObj.ingress = {
+            enabled: false,
+            className: "",
+            annotations: {},
+            hosts: [{ host: `${name}.local`, paths: [{ path: "/", pathType: "Prefix" }] }],
+            tls: [],
+        };
+    }
+    if (autoscaling) {
+        valuesObj.autoscaling = {
+            enabled: false,
+            minReplicas: replicas,
+            maxReplicas: 10,
+            targetCPUUtilizationPercentage: 80,
+            targetMemoryUtilizationPercentage: 80,
+        };
+    }
+    if (pdb) {
+        valuesObj.podDisruptionBudget = {
+            enabled: true,
+            minAvailable: 1,
+        };
+    }
+    const valuesRes = new Values(mergeDefaults(valuesObj, defs?.values));
+    const containerSpec = {
+        name,
+        image: printf("%s:%s", values.image.repository, values.image.tag),
+        imagePullPolicy: values.image.pullPolicy,
+        ports: [{ containerPort: values.service.port, name: "http" }],
+        resources: toYaml(values.resources),
+        livenessProbe: toYaml(values.livenessProbe),
+        readinessProbe: toYaml(values.readinessProbe),
+    };
+    if (props.securityContext)
+        containerSpec.securityContext = toYaml(values.securityContext);
+    const podSpec = {
+        serviceAccountName: include(`${name}.serviceAccountName`),
+        containers: [containerSpec],
+    };
+    if (props.podSecurityContext)
+        podSpec.securityContext = toYaml(values.podSecurityContext);
+    if (props.nodeSelector)
+        podSpec.nodeSelector = With(values.nodeSelector, toYaml(values.nodeSelector));
+    if (props.tolerations)
+        podSpec.tolerations = With(values.tolerations, toYaml(values.tolerations));
+    if (props.affinity)
+        podSpec.affinity = With(values.affinity, toYaml(values.affinity));
+    const templateMetadata = {
+        labels: include(`${name}.selectorLabels`),
+    };
+    if (props.podAnnotations)
+        templateMetadata.annotations = toYaml(values.podAnnotations);
+    const deploymentSpec = {
+        replicas: values.replicaCount,
+        selector: {
+            matchLabels: include(`${name}.selectorLabels`),
+        },
+        template: {
+            metadata: templateMetadata,
+            spec: podSpec,
+        },
+    };
+    if (props.strategy)
+        deploymentSpec.strategy = toYaml(values.strategy);
+    const deployment = new Deployment(mergeDefaults({
+        apiVersion: "apps/v1",
+        kind: "Deployment",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: deploymentSpec,
+    }, defs?.deployment));
+    const service = new Service(mergeDefaults({
+        apiVersion: "v1",
+        kind: "Service",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: {
+            type: values.service.type,
+            ports: [{
+                    port: values.service.port,
+                    targetPort: "http",
+                    protocol: "TCP",
+                    name: "http",
+                }],
+            selector: include(`${name}.selectorLabels`),
+        },
+    }, defs?.service));
+    const serviceAccount = new ServiceAccount(mergeDefaults({
+        apiVersion: "v1",
+        kind: "ServiceAccount",
+        metadata: {
+            name: include(`${name}.serviceAccountName`),
+            labels: include(`${name}.labels`),
+            annotations: toYaml(values.serviceAccount.annotations),
+        },
+    }, defs?.serviceAccount));
+    const result = {
+        chart,
+        values: valuesRes,
+        deployment,
+        service,
+        serviceAccount,
+    };
+    if (configMap) {
+        result.configMap = new ConfigMap(mergeDefaults({
+            apiVersion: "v1",
+            kind: "ConfigMap",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+            },
+            data: values.config,
+        }, defs?.configMap));
+    }
+    if (ingress) {
+        result.ingress = new Ingress(mergeDefaults({
+            apiVersion: "networking.k8s.io/v1",
+            kind: "Ingress",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+                annotations: toYaml(values.ingress.annotations),
+            },
+            spec: {
+                ingressClassName: values.ingress.className,
+                rules: values.ingress.hosts,
+                tls: values.ingress.tls,
+            },
+        }, defs?.ingress));
+    }
+    if (autoscaling) {
+        result.hpa = new HPA(mergeDefaults({
+            apiVersion: "autoscaling/v2",
+            kind: "HorizontalPodAutoscaler",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+            },
+            spec: {
+                scaleTargetRef: {
+                    apiVersion: "apps/v1",
+                    kind: "Deployment",
+                    name: include(`${name}.fullname`),
+                },
+                minReplicas: values.autoscaling.minReplicas,
+                maxReplicas: values.autoscaling.maxReplicas,
+                metrics: [
+                    {
+                        type: "Resource",
+                        resource: {
+                            name: "cpu",
+                            target: {
+                                type: "Utilization",
+                                averageUtilization: values.autoscaling.targetCPUUtilizationPercentage,
+                            },
+                        },
+                    },
+                    {
+                        type: "Resource",
+                        resource: {
+                            name: "memory",
+                            target: {
+                                type: "Utilization",
+                                averageUtilization: values.autoscaling.targetMemoryUtilizationPercentage,
+                            },
+                        },
+                    },
+                ],
+            },
+        }, defs?.hpa));
+    }
+    if (pdb) {
+        result.pdb = new PDB(mergeDefaults({
+            apiVersion: "policy/v1",
+            kind: "PodDisruptionBudget",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+            },
+            spec: {
+                minAvailable: values.podDisruptionBudget.minAvailable,
+                selector: {
+                    matchLabels: include(`${name}.selectorLabels`),
+                },
+            },
+        }, defs?.pdb));
+    }
+    return result;
+}, "HelmMicroservice");

package/dist/composites/helm-monitored-service.js

@@ -0,0 +1,188 @@
+/**
+ * HelmMonitoredService composite — Deployment + Service + ServiceMonitor + optional PrometheusRule.
+ *
+ * Full observability pattern for services monitored by Prometheus Operator.
+ * Uses fallback GVK for CRD resources (ServiceMonitor, PrometheusRule).
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Chart, Values, Deployment, Service, ServiceAccount, ServiceMonitor as ServiceMonitorRes, PrometheusRule as PrometheusRuleRes, } from "../resources.js";
+import { values, include, printf, toYaml, If, With } from "../intrinsics.js";
+export const HelmMonitoredService = Composite((props) => {
+    const { name, imageRepository = "nginx", imageTag = "", port = 8080, metricsPort = 9090, metricsPath = "/metrics", scrapeInterval = "30s", replicas = 2, serviceType = "ClusterIP", serviceAccount = true, alertRules = false, appVersion = "1.0.0", defaults: defs, } = props;
+    const chart = new Chart(mergeDefaults({
+        apiVersion: "v2",
+        name,
+        version: "0.1.0",
+        appVersion,
+        type: "application",
+        description: `A Helm chart for ${name} with monitoring`,
+    }, defs?.chart));
+    const valuesObj = {
+        replicaCount: replicas,
+        image: {
+            repository: imageRepository,
+            tag: imageTag,
+            pullPolicy: "IfNotPresent",
+        },
+        service: {
+            type: serviceType,
+            port,
+        },
+        resources: {},
+        monitoring: {
+            enabled: true,
+            metricsPort,
+            metricsPath,
+            scrapeInterval,
+        },
+    };
+    if (alertRules) {
+        valuesObj.alerting = {
+            enabled: false,
+            rules: [],
+        };
+    }
+    if (props.podSecurityContext)
+        valuesObj.podSecurityContext = props.podSecurityContext;
+    if (props.securityContext)
+        valuesObj.securityContext = props.securityContext;
+    if (props.nodeSelector)
+        valuesObj.nodeSelector = props.nodeSelector;
+    if (props.tolerations)
+        valuesObj.tolerations = props.tolerations;
+    if (props.affinity)
+        valuesObj.affinity = props.affinity;
+    if (serviceAccount) {
+        valuesObj.serviceAccount = {
+            create: true,
+            name: "",
+            annotations: {},
+        };
+    }
+    const valuesRes = new Values(mergeDefaults(valuesObj, defs?.values));
+    const containerSpec = {
+        name,
+        image: printf("%s:%s", values.image.repository, values.image.tag),
+        imagePullPolicy: values.image.pullPolicy,
+        ports: [
+            { containerPort: values.service.port, name: "http" },
+            { containerPort: values.monitoring.metricsPort, name: "metrics" },
+        ],
+        resources: toYaml(values.resources),
+    };
+    if (props.securityContext)
+        containerSpec.securityContext = toYaml(values.securityContext);
+    const podSpec = {
+        containers: [containerSpec],
+    };
+    if (props.podSecurityContext)
+        podSpec.securityContext = toYaml(values.podSecurityContext);
+    if (props.nodeSelector)
+        podSpec.nodeSelector = With(values.nodeSelector, toYaml(values.nodeSelector));
+    if (props.tolerations)
+        podSpec.tolerations = With(values.tolerations, toYaml(values.tolerations));
+    if (props.affinity)
+        podSpec.affinity = With(values.affinity, toYaml(values.affinity));
+    if (serviceAccount)
+        podSpec.serviceAccountName = include(`${name}.serviceAccountName`);
+    const deployment = new Deployment(mergeDefaults({
+        apiVersion: "apps/v1",
+        kind: "Deployment",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: {
+            replicas: values.replicaCount,
+            selector: {
+                matchLabels: include(`${name}.selectorLabels`),
+            },
+            template: {
+                metadata: {
+                    labels: include(`${name}.selectorLabels`),
+                },
+                spec: podSpec,
+            },
+        },
+    }, defs?.deployment));
+    const service = new Service(mergeDefaults({
+        apiVersion: "v1",
+        kind: "Service",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: {
+            type: values.service.type,
+            ports: [
+                {
+                    port: values.service.port,
+                    targetPort: "http",
+                    protocol: "TCP",
+                    name: "http",
+                },
+                {
+                    port: values.monitoring.metricsPort,
+                    targetPort: "metrics",
+                    protocol: "TCP",
+                    name: "metrics",
+                },
+            ],
+            selector: include(`${name}.selectorLabels`),
+        },
+    }, defs?.service));
+    // ServiceMonitor CRD (monitoring.coreos.com/v1) — gated on Capabilities check
+    const serviceMonitor = new ServiceMonitorRes(mergeDefaults(If(`and .Values.monitoring.enabled (.Capabilities.APIVersions.Has "monitoring.coreos.com/v1")`, {
+        apiVersion: "monitoring.coreos.com/v1",
+        kind: "ServiceMonitor",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: {
+            selector: {
+                matchLabels: include(`${name}.selectorLabels`),
+            },
+            endpoints: [{
+                    port: "metrics",
+                    path: values.monitoring.metricsPath,
+                    interval: values.monitoring.scrapeInterval,
+                }],
+        },
+    }), defs?.serviceMonitor));
+    const result = {
+        chart,
+        values: valuesRes,
+        deployment,
+        service,
+        serviceMonitor,
+    };
+    if (serviceAccount) {
+        result.serviceAccount = new ServiceAccount(mergeDefaults({
+            apiVersion: "v1",
+            kind: "ServiceAccount",
+            metadata: {
+                name: include(`${name}.serviceAccountName`),
+                labels: include(`${name}.labels`),
+                annotations: toYaml(values.serviceAccount.annotations),
+            },
+        }, defs?.serviceAccount));
+    }
+    if (alertRules) {
+        result.prometheusRule = new PrometheusRuleRes(mergeDefaults(If(`and .Values.alerting.enabled (.Capabilities.APIVersions.Has "monitoring.coreos.com/v1")`, {
+            apiVersion: "monitoring.coreos.com/v1",
+            kind: "PrometheusRule",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+            },
+            spec: {
+                groups: [{
+                        name: printf("%s.rules", name),
+                        rules: toYaml(values.alerting.rules),
+                    }],
+            },
+        }), defs?.prometheusRule));
+    }
+    return result;
+}, "HelmMonitoredService");

package/dist/composites/helm-namespace-env.js

@@ -0,0 +1,116 @@
+/**
+ * HelmNamespaceEnv composite — Namespace + ResourceQuota + LimitRange + NetworkPolicy.
+ *
+ * Environment namespace pattern with optional resource governance and
+ * network isolation.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Chart, Values, Namespace, ResourceQuota as ResourceQuotaRes, LimitRange as LimitRangeRes, NetworkPolicy as NetworkPolicyRes, } from "../resources.js";
+import { values, include, toYaml, If } from "../intrinsics.js";
+export const HelmNamespaceEnv = Composite((props) => {
+    const { name, resourceQuota = true, limitRange = true, networkPolicy = true, appVersion = "1.0.0", defaults: defs, } = props;
+    const chart = new Chart(mergeDefaults({
+        apiVersion: "v2",
+        name,
+        version: "0.1.0",
+        appVersion,
+        type: "application",
+        description: `A Helm chart for ${name} namespace environment`,
+    }, defs?.chart));
+    const valuesObj = {
+        namespace: {
+            labels: {},
+            annotations: {},
+        },
+    };
+    if (resourceQuota) {
+        valuesObj.resourceQuota = {
+            enabled: true,
+            hard: {
+                cpu: "10",
+                memory: "20Gi",
+                pods: "50",
+            },
+        };
+    }
+    if (limitRange) {
+        valuesObj.limitRange = {
+            enabled: true,
+            default: {
+                cpu: "500m",
+                memory: "256Mi",
+            },
+            defaultRequest: {
+                cpu: "100m",
+                memory: "128Mi",
+            },
+        };
+    }
+    if (networkPolicy) {
+        valuesObj.networkPolicy = {
+            enabled: true,
+            denyIngress: true,
+            denyEgress: false,
+        };
+    }
+    const valuesRes = new Values(mergeDefaults(valuesObj, defs?.values));
+    const ns = new Namespace(mergeDefaults({
+        apiVersion: "v1",
+        kind: "Namespace",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: toYaml(values.namespace.labels),
+            annotations: toYaml(values.namespace.annotations),
+        },
+    }, defs?.namespace));
+    const result = {
+        chart,
+        values: valuesRes,
+        namespace: ns,
+    };
+    if (resourceQuota) {
+        result.resourceQuota = new ResourceQuotaRes(mergeDefaults(If(values.resourceQuota.enabled, {
+            apiVersion: "v1",
+            kind: "ResourceQuota",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+            },
+            spec: {
+                hard: toYaml(values.resourceQuota.hard),
+            },
+        }), defs?.resourceQuota));
+    }
+    if (limitRange) {
+        result.limitRange = new LimitRangeRes(mergeDefaults(If(values.limitRange.enabled, {
+            apiVersion: "v1",
+            kind: "LimitRange",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+            },
+            spec: {
+                limits: [{
+                        type: "Container",
+                        default: toYaml(values.limitRange.default),
+                        defaultRequest: toYaml(values.limitRange.defaultRequest),
+                    }],
+            },
+        }), defs?.limitRange));
+    }
+    if (networkPolicy) {
+        result.networkPolicy = new NetworkPolicyRes(mergeDefaults(If(values.networkPolicy.enabled, {
+            apiVersion: "networking.k8s.io/v1",
+            kind: "NetworkPolicy",
+            metadata: {
+                name: include(`${name}.fullname`),
+                labels: include(`${name}.labels`),
+            },
+            spec: {
+                podSelector: {},
+                policyTypes: ["Ingress", "Egress"],
+            },
+        }), defs?.networkPolicy));
+    }
+    return result;
+}, "HelmNamespaceEnv");

package/dist/composites/helm-secure-ingress.js

@@ -0,0 +1,86 @@
+/**
+ * HelmSecureIngress composite — Ingress + optional cert-manager Certificate.
+ *
+ * TLS-enabled ingress pattern with optional cert-manager integration
+ * for automatic certificate provisioning.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Chart, Values, Ingress, Certificate } from "../resources.js";
+import { values, include, toYaml, If, Range } from "../intrinsics.js";
+export const HelmSecureIngress = Composite((props) => {
+    const { name, ingressClassName = "", clusterIssuer = "letsencrypt-prod", appVersion = "1.0.0", defaults: defs, } = props;
+    const chart = new Chart(mergeDefaults({
+        apiVersion: "v2",
+        name,
+        version: "0.1.0",
+        appVersion,
+        type: "application",
+        description: `A Helm chart for ${name} secure ingress`,
+    }, defs?.chart));
+    const valuesRes = new Values(mergeDefaults({
+        ingress: {
+            enabled: true,
+            className: ingressClassName,
+            annotations: {},
+            hosts: [
+                {
+                    host: `${name}.example.com`,
+                    paths: [{ path: "/", pathType: "Prefix" }],
+                },
+            ],
+            tls: {
+                enabled: true,
+                secretName: `${name}-tls`,
+            },
+        },
+        certManager: {
+            enabled: true,
+            clusterIssuer,
+        },
+    }, defs?.values));
+    const ingress = new Ingress(mergeDefaults(If(values.ingress.enabled, {
+        apiVersion: "networking.k8s.io/v1",
+        kind: "Ingress",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+            annotations: toYaml(values.ingress.annotations),
+        },
+        spec: {
+            ingressClassName: values.ingress.className,
+            tls: [{
+                    secretName: values.ingress.tls.secretName,
+                    hosts: Range(values.ingress.hosts, values.ingress.hosts),
+                }],
+            rules: Range(values.ingress.hosts, {
+                host: values.ingress.hosts,
+                http: {
+                    paths: values.ingress.hosts,
+                },
+            }),
+        },
+    }), defs?.ingress));
+    // cert-manager Certificate CRD (cert-manager.io/v1)
+    const certificate = new Certificate(mergeDefaults(If(values.certManager.enabled, {
+        apiVersion: "cert-manager.io/v1",
+        kind: "Certificate",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: {
+            secretName: values.ingress.tls.secretName,
+            issuerRef: {
+                name: values.certManager.clusterIssuer,
+                kind: "ClusterIssuer",
+            },
+            dnsNames: values.ingress.hosts,
+        },
+    }), defs?.certificate));
+    return {
+        chart,
+        values: valuesRes,
+        ingress,
+        certificate,
+    };
+}, "HelmSecureIngress");