@intentius/chant-lexicon-helm 0.124.30 → 0.124.32

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

@@ -0,0 +1,160 @@
+/**
+ * HelmStatefulService composite — StatefulSet + headless Service + PVC templates.
+ *
+ * Produces a Helm chart for stateful workloads with persistent storage.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Chart, Values, StatefulSet, Service, ServiceAccount } from "../resources.js";
+import { values, include, printf, toYaml, With } from "../intrinsics.js";
+export const HelmStatefulService = Composite((props) => {
+    const { name, imageRepository = "postgres", imageTag = "16", replicas = 1, port = 5432, storageSize = "10Gi", storageClass = "", appVersion = "1.0.0", serviceAccount = false, defaults: defs, } = props;
+    const chart = new Chart(mergeDefaults({
+        apiVersion: "v2",
+        name,
+        version: "0.1.0",
+        appVersion,
+        type: "application",
+        description: `A Helm chart for ${name} (stateful)`,
+    }, defs?.chart));
+    const valuesObj = {
+        replicaCount: replicas,
+        image: {
+            repository: imageRepository,
+            tag: imageTag,
+            pullPolicy: "IfNotPresent",
+        },
+        service: {
+            port,
+        },
+        persistence: {
+            size: storageSize,
+            storageClass,
+            accessModes: ["ReadWriteOnce"],
+        },
+        resources: {},
+    };
+    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.livenessProbe)
+        valuesObj.livenessProbe = props.livenessProbe;
+    if (props.readinessProbe)
+        valuesObj.readinessProbe = props.readinessProbe;
+    if (props.updateStrategy)
+        valuesObj.updateStrategy = props.updateStrategy;
+    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: "tcp" }],
+        resources: toYaml(values.resources),
+        volumeMounts: [{
+                name: "data",
+                mountPath: "/data",
+            }],
+    };
+    if (props.securityContext)
+        containerSpec.securityContext = toYaml(values.securityContext);
+    if (props.livenessProbe)
+        containerSpec.livenessProbe = toYaml(values.livenessProbe);
+    if (props.readinessProbe)
+        containerSpec.readinessProbe = toYaml(values.readinessProbe);
+    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 templateMetadata = {
+        labels: include(`${name}.selectorLabels`),
+    };
+    if (props.podAnnotations)
+        templateMetadata.annotations = toYaml(values.podAnnotations);
+    const statefulSetSpec = {
+        serviceName: include(`${name}.fullname`),
+        replicas: values.replicaCount,
+        selector: {
+            matchLabels: include(`${name}.selectorLabels`),
+        },
+        template: {
+            metadata: templateMetadata,
+            spec: podSpec,
+        },
+        volumeClaimTemplates: [{
+                metadata: { name: "data" },
+                spec: {
+                    accessModes: values.persistence.accessModes,
+                    storageClassName: values.persistence.storageClass,
+                    resources: {
+                        requests: { storage: values.persistence.size },
+                    },
+                },
+            }],
+    };
+    if (props.updateStrategy)
+        statefulSetSpec.updateStrategy = toYaml(values.updateStrategy);
+    const statefulSet = new StatefulSet(mergeDefaults({
+        apiVersion: "apps/v1",
+        kind: "StatefulSet",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: statefulSetSpec,
+    }, defs?.statefulSet));
+    const service = new Service(mergeDefaults({
+        apiVersion: "v1",
+        kind: "Service",
+        metadata: {
+            name: include(`${name}.fullname`),
+            labels: include(`${name}.labels`),
+        },
+        spec: {
+            clusterIP: "None",
+            ports: [{
+                    port: values.service.port,
+                    targetPort: "tcp",
+                    protocol: "TCP",
+                    name: "tcp",
+                }],
+            selector: include(`${name}.selectorLabels`),
+        },
+    }, defs?.service));
+    const result = { chart, values: valuesRes, statefulSet, service };
+    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));
+    }
+    return result;
+}, "HelmStatefulService");

package/dist/composites/helm-web-app.js

@@ -0,0 +1,201 @@
+/**
+ * HelmWebApp composite — Deployment + Service + Ingress (conditional) + HPA (conditional) + ServiceAccount.
+ *
+ * Produces a full set of Helm chart entities with parameterized values references.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Chart, Values, Deployment, Service, ServiceAccount, Ingress, HPA } from "../resources.js";
+import { values, include, printf, toYaml, With } from "../intrinsics.js";
+export const HelmWebApp = Composite((props) => {
+    const { name, imageRepository = "nginx", imageTag = "", port = 80, replicas = 1, serviceType = "ClusterIP", ingress = true, autoscaling = true, serviceAccount = 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}`,
+    }, defs?.chart));
+    const valuesObj = {
+        replicaCount: replicas,
+        image: {
+            repository: imageRepository,
+            tag: imageTag,
+            pullPolicy: "IfNotPresent",
+        },
+        service: {
+            type: serviceType,
+            port,
+        },
+        resources: {},
+    };
+    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.livenessProbe)
+        valuesObj.livenessProbe = props.livenessProbe;
+    if (props.readinessProbe)
+        valuesObj.readinessProbe = props.readinessProbe;
+    if (props.strategy)
+        valuesObj.strategy = props.strategy;
+    if (serviceAccount) {
+        valuesObj.serviceAccount = {
+            create: true,
+            name: "",
+            annotations: {},
+        };
+    }
+    if (ingress) {
+        valuesObj.ingress = {
+            enabled: false,
+            className: "",
+            annotations: {},
+            hosts: [{ host: `${name}.local`, paths: [{ path: "/", pathType: "ImplementationSpecific" }] }],
+            tls: [],
+        };
+    }
+    if (autoscaling) {
+        valuesObj.autoscaling = {
+            enabled: false,
+            minReplicas: 1,
+            maxReplicas: 100,
+            targetCPUUtilizationPercentage: 80,
+        };
+    }
+    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),
+    };
+    if (props.securityContext)
+        containerSpec.securityContext = toYaml(values.securityContext);
+    if (props.livenessProbe)
+        containerSpec.livenessProbe = toYaml(values.livenessProbe);
+    if (props.readinessProbe)
+        containerSpec.readinessProbe = toYaml(values.readinessProbe);
+    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));
+    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 result = { chart, values: valuesRes, deployment, service };
+    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 (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,
+                            },
+                        },
+                    }],
+            },
+        }, defs?.hpa));
+    }
+    return result;
+}, "HelmWebApp");

package/dist/composites/helm-worker.js

@@ -0,0 +1,164 @@
+/**
+ * HelmWorker composite — Deployment (no Service) + ServiceAccount + optional HPA + PDB.
+ *
+ * Worker pattern for background processors, queue consumers, and async tasks
+ * that don't serve HTTP traffic.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Chart, Values, Deployment, ServiceAccount, HPA, PDB } from "../resources.js";
+import { values, include, printf, toYaml } from "../intrinsics.js";
+export const HelmWorker = Composite((props) => {
+    const { name, imageRepository = "worker", imageTag = "", replicas = 2, autoscaling = false, pdb = 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} worker`,
+    }, defs?.chart));
+    const valuesObj = {
+        replicaCount: replicas,
+        image: {
+            repository: imageRepository,
+            tag: imageTag,
+            pullPolicy: "IfNotPresent",
+        },
+        serviceAccount: {
+            create: true,
+            name: "",
+            annotations: {},
+        },
+        resources: {
+            limits: { cpu: "500m", memory: "256Mi" },
+            requests: { cpu: "100m", memory: "128Mi" },
+        },
+        queue: {
+            concurrency: 5,
+            pollInterval: "5s",
+        },
+        livenessProbe: {
+            exec: { command: ["/bin/sh", "-c", "pgrep -f worker"] },
+            initialDelaySeconds: 15,
+            periodSeconds: 20,
+        },
+        readinessProbe: {
+            exec: { command: ["/bin/sh", "-c", "pgrep -f worker"] },
+            initialDelaySeconds: 5,
+            periodSeconds: 10,
+        },
+    };
+    if (autoscaling) {
+        valuesObj.autoscaling = {
+            enabled: false,
+            minReplicas: replicas,
+            maxReplicas: 10,
+            targetCPUUtilizationPercentage: 80,
+        };
+    }
+    if (pdb) {
+        valuesObj.podDisruptionBudget = {
+            enabled: true,
+            minAvailable: 1,
+        };
+    }
+    const valuesRes = new Values(mergeDefaults(valuesObj, defs?.values));
+    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: {
+                    serviceAccountName: include(`${name}.serviceAccountName`),
+                    securityContext: {
+                        runAsNonRoot: true,
+                    },
+                    containers: [{
+                            name,
+                            image: printf("%s:%s", values.image.repository, values.image.tag),
+                            imagePullPolicy: values.image.pullPolicy,
+                            resources: toYaml(values.resources),
+                            livenessProbe: toYaml(values.livenessProbe),
+                            readinessProbe: toYaml(values.readinessProbe),
+                            env: [
+                                { name: "QUEUE_CONCURRENCY", value: values.queue.concurrency },
+                                { name: "QUEUE_POLL_INTERVAL", value: values.queue.pollInterval },
+                            ],
+                        }],
+                },
+            },
+        },
+    }, defs?.deployment));
+    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,
+        serviceAccount,
+    };
+    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,
+                            },
+                        },
+                    }],
+            },
+        }, 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;
+}, "HelmWorker");

package/dist/composites/index.js

@@ -0,0 +1,13 @@
+export { HelmWebApp } from "./helm-web-app.js";
+export { HelmStatefulService } from "./helm-stateful-service.js";
+export { HelmCronJob } from "./helm-cron-job.js";
+export { HelmMicroservice } from "./helm-microservice.js";
+export { HelmLibrary } from "./helm-library.js";
+export { HelmCRDLifecycle } from "./helm-crd-lifecycle.js";
+export { HelmDaemonSet } from "./helm-daemon-set.js";
+export { HelmWorker } from "./helm-worker.js";
+export { HelmExternalSecret } from "./helm-external-secret.js";
+export { HelmBatchJob } from "./helm-batch-job.js";
+export { HelmMonitoredService } from "./helm-monitored-service.js";
+export { HelmSecureIngress } from "./helm-secure-ingress.js";
+export { HelmNamespaceEnv } from "./helm-namespace-env.js";