@intentius/chant-lexicon-helm 0.0.18 → 0.0.24

package/src/composites/helm-microservice.ts

@@ -4,6 +4,8 @@
  * 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";
 import { values, include, printf, toYaml, If, With } from "../intrinsics";
 
 export interface HelmMicroserviceProps {
@@ -43,21 +45,33 @@ export interface HelmMicroserviceProps {
   podAnnotations?: Record<string, string>;
   /** Deployment strategy defaults. */
   strategy?: Record<string, unknown>;
+  /** Per-member defaults. */
+  defaults?: {
+    chart?: Partial<Record<string, unknown>>;
+    values?: Partial<Record<string, unknown>>;
+    deployment?: Partial<Record<string, unknown>>;
+    service?: Partial<Record<string, unknown>>;
+    serviceAccount?: Partial<Record<string, unknown>>;
+    configMap?: Partial<Record<string, unknown>>;
+    ingress?: Partial<Record<string, unknown>>;
+    hpa?: Partial<Record<string, unknown>>;
+    pdb?: Partial<Record<string, unknown>>;
+  };
 }
 
 export interface HelmMicroserviceResult {
-  chart: Record<string, unknown>;
-  values: Record<string, unknown>;
-  deployment: Record<string, unknown>;
-  service: Record<string, unknown>;
-  serviceAccount: Record<string, unknown>;
-  configMap?: Record<string, unknown>;
-  ingress?: Record<string, unknown>;
-  hpa?: Record<string, unknown>;
-  pdb?: Record<string, unknown>;
+  chart: InstanceType<typeof Chart>;
+  values: InstanceType<typeof Values>;
+  deployment: InstanceType<typeof Deployment>;
+  service: InstanceType<typeof Service>;
+  serviceAccount: InstanceType<typeof ServiceAccount>;
+  configMap?: InstanceType<typeof ConfigMap>;
+  ingress?: InstanceType<typeof Ingress>;
+  hpa?: InstanceType<typeof HPA>;
+  pdb?: InstanceType<typeof PDB>;
 }
 
-export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroserviceResult {
+export const HelmMicroservice = Composite<HelmMicroserviceProps>((props) => {
   const {
     name,
     imageRepository = "nginx",
@@ -70,16 +84,17 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
     pdb = true,
     configMap = true,
     appVersion = "1.0.0",
+    defaults: defs,
   } = props;
 
-  const chart = {
+  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: Record<string, unknown> = {
     replicaCount: replicas,
@@ -152,6 +167,8 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
     };
   }
 
+  const valuesRes = new Values(mergeDefaults(valuesObj, defs?.values));
+
   const containerSpec: Record<string, unknown> = {
     name,
     image: printf("%s:%s", values.image.repository, values.image.tag),
@@ -192,7 +209,7 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
 
   if (props.strategy) deploymentSpec.strategy = toYaml(values.strategy);
 
-  const deployment = {
+  const deployment = new Deployment(mergeDefaults({
     apiVersion: "apps/v1",
     kind: "Deployment",
     metadata: {
@@ -200,9 +217,9 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
       labels: include(`${name}.labels`),
     },
     spec: deploymentSpec,
-  };
+  }, defs?.deployment));
 
-  const service = {
+  const service = new Service(mergeDefaults({
     apiVersion: "v1",
     kind: "Service",
     metadata: {
@@ -219,9 +236,9 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
       }],
       selector: include(`${name}.selectorLabels`),
     },
-  };
+  }, defs?.service));
 
-  const serviceAccount = {
+  const serviceAccount = new ServiceAccount(mergeDefaults({
     apiVersion: "v1",
     kind: "ServiceAccount",
     metadata: {
@@ -229,18 +246,18 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
       labels: include(`${name}.labels`),
       annotations: toYaml(values.serviceAccount.annotations),
     },
-  };
+  }, defs?.serviceAccount));
 
-  const result: HelmMicroserviceResult = {
+  const result: Record<string, any> = {
     chart,
-    values: valuesObj,
+    values: valuesRes,
     deployment,
     service,
     serviceAccount,
   };
 
   if (configMap) {
-    result.configMap = {
+    result.configMap = new ConfigMap(mergeDefaults({
       apiVersion: "v1",
       kind: "ConfigMap",
       metadata: {
@@ -248,11 +265,11 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
         labels: include(`${name}.labels`),
       },
       data: values.config,
-    };
+    }, defs?.configMap));
   }
 
   if (ingress) {
-    result.ingress = {
+    result.ingress = new Ingress(mergeDefaults({
       apiVersion: "networking.k8s.io/v1",
       kind: "Ingress",
       metadata: {
@@ -265,11 +282,11 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
         rules: values.ingress.hosts,
         tls: values.ingress.tls,
       },
-    };
+    }, defs?.ingress));
   }
 
   if (autoscaling) {
-    result.hpa = {
+    result.hpa = new HPA(mergeDefaults({
       apiVersion: "autoscaling/v2",
       kind: "HorizontalPodAutoscaler",
       metadata: {
@@ -307,11 +324,11 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
           },
         ],
       },
-    };
+    }, defs?.hpa));
   }
 
   if (pdb) {
-    result.pdb = {
+    result.pdb = new PDB(mergeDefaults({
       apiVersion: "policy/v1",
       kind: "PodDisruptionBudget",
       metadata: {
@@ -324,8 +341,8 @@ export function HelmMicroservice(props: HelmMicroserviceProps): HelmMicroservice
           matchLabels: include(`${name}.selectorLabels`),
         },
       },
-    };
+    }, defs?.pdb));
   }
 
   return result;
-}
+}, "HelmMicroservice");

package/src/composites/helm-monitored-service.ts

@@ -5,6 +5,11 @@
  * 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";
 import { values, include, printf, toYaml, If, With, Capabilities } from "../intrinsics";
 
 export interface HelmMonitoredServiceProps {
@@ -42,19 +47,29 @@ export interface HelmMonitoredServiceProps {
   affinity?: Record<string, unknown>;
   /** Chart appVersion. */
   appVersion?: string;
+  /** Per-member defaults. */
+  defaults?: {
+    chart?: Partial<Record<string, unknown>>;
+    values?: Partial<Record<string, unknown>>;
+    deployment?: Partial<Record<string, unknown>>;
+    service?: Partial<Record<string, unknown>>;
+    serviceAccount?: Partial<Record<string, unknown>>;
+    serviceMonitor?: Partial<Record<string, unknown>>;
+    prometheusRule?: Partial<Record<string, unknown>>;
+  };
 }
 
 export interface HelmMonitoredServiceResult {
-  chart: Record<string, unknown>;
-  values: Record<string, unknown>;
-  deployment: Record<string, unknown>;
-  service: Record<string, unknown>;
-  serviceAccount?: Record<string, unknown>;
-  serviceMonitor: Record<string, unknown>;
-  prometheusRule?: Record<string, unknown>;
+  chart: InstanceType<typeof Chart>;
+  values: InstanceType<typeof Values>;
+  deployment: InstanceType<typeof Deployment>;
+  service: InstanceType<typeof Service>;
+  serviceAccount?: InstanceType<typeof ServiceAccount>;
+  serviceMonitor: InstanceType<typeof ServiceMonitorRes>;
+  prometheusRule?: InstanceType<typeof PrometheusRuleRes>;
 }
 
-export function HelmMonitoredService(props: HelmMonitoredServiceProps): HelmMonitoredServiceResult {
+export const HelmMonitoredService = Composite<HelmMonitoredServiceProps>((props) => {
   const {
     name,
     imageRepository = "nginx",
@@ -68,16 +83,17 @@ export function HelmMonitoredService(props: HelmMonitoredServiceProps): HelmMoni
     serviceAccount = true,
     alertRules = false,
     appVersion = "1.0.0",
+    defaults: defs,
   } = props;
 
-  const chart = {
+  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: Record<string, unknown> = {
     replicaCount: replicas,
@@ -120,6 +136,8 @@ export function HelmMonitoredService(props: HelmMonitoredServiceProps): HelmMoni
     };
   }
 
+  const valuesRes = new Values(mergeDefaults(valuesObj, defs?.values));
+
   const containerSpec: Record<string, unknown> = {
     name,
     image: printf("%s:%s", values.image.repository, values.image.tag),
@@ -143,7 +161,7 @@ export function HelmMonitoredService(props: HelmMonitoredServiceProps): HelmMoni
   if (props.affinity) podSpec.affinity = With(values.affinity, toYaml(values.affinity));
   if (serviceAccount) podSpec.serviceAccountName = include(`${name}.serviceAccountName`);
 
-  const deployment = {
+  const deployment = new Deployment(mergeDefaults({
     apiVersion: "apps/v1",
     kind: "Deployment",
     metadata: {
@@ -162,9 +180,9 @@ export function HelmMonitoredService(props: HelmMonitoredServiceProps): HelmMoni
         spec: podSpec,
       },
     },
-  };
+  }, defs?.deployment));
 
-  const service = {
+  const service = new Service(mergeDefaults({
     apiVersion: "v1",
     kind: "Service",
     metadata: {
@@ -189,38 +207,41 @@ export function HelmMonitoredService(props: HelmMonitoredServiceProps): HelmMoni
       ],
       selector: include(`${name}.selectorLabels`),
     },
-  };
+  }, defs?.service));
 
   // ServiceMonitor CRD (monitoring.coreos.com/v1) — gated on Capabilities check
-  const serviceMonitor = 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`),
+  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`),
       },
-      endpoints: [{
-        port: "metrics",
-        path: values.monitoring.metricsPath,
-        interval: values.monitoring.scrapeInterval,
-      }],
-    },
-  });
+      spec: {
+        selector: {
+          matchLabels: include(`${name}.selectorLabels`),
+        },
+        endpoints: [{
+          port: "metrics",
+          path: values.monitoring.metricsPath,
+          interval: values.monitoring.scrapeInterval,
+        }],
+      },
+    }) as Record<string, unknown>,
+    defs?.serviceMonitor,
+  ));
 
-  const result: HelmMonitoredServiceResult = {
+  const result: Record<string, any> = {
     chart,
-    values: valuesObj,
+    values: valuesRes,
     deployment,
     service,
-    serviceMonitor: serviceMonitor as unknown as Record<string, unknown>,
+    serviceMonitor,
   };
 
   if (serviceAccount) {
-    result.serviceAccount = {
+    result.serviceAccount = new ServiceAccount(mergeDefaults({
       apiVersion: "v1",
       kind: "ServiceAccount",
       metadata: {
@@ -228,25 +249,28 @@ export function HelmMonitoredService(props: HelmMonitoredServiceProps): HelmMoni
         labels: include(`${name}.labels`),
         annotations: toYaml(values.serviceAccount.annotations),
       },
-    };
+    }, defs?.serviceAccount));
   }
 
   if (alertRules) {
-    result.prometheusRule = 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),
-        }],
-      },
-    }) as unknown as Record<string, unknown>;
+    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),
+          }],
+        },
+      }) as Record<string, unknown>,
+      defs?.prometheusRule,
+    ));
   }
 
   return result;
-}
+}, "HelmMonitoredService");

package/src/composites/helm-namespace-env.ts

@@ -5,6 +5,13 @@
  * network isolation.
  */
 
+import { Composite, mergeDefaults } from "@intentius/chant";
+import {
+  Chart, Values, Namespace,
+  ResourceQuota as ResourceQuotaRes,
+  LimitRange as LimitRangeRes,
+  NetworkPolicy as NetworkPolicyRes,
+} from "../resources";
 import { values, include, toYaml, If } from "../intrinsics";
 
 export interface HelmNamespaceEnvProps {
@@ -18,34 +25,44 @@ export interface HelmNamespaceEnvProps {
   networkPolicy?: boolean;
   /** Chart appVersion. */
   appVersion?: string;
+  /** Per-member defaults. */
+  defaults?: {
+    chart?: Partial<Record<string, unknown>>;
+    values?: Partial<Record<string, unknown>>;
+    namespace?: Partial<Record<string, unknown>>;
+    resourceQuota?: Partial<Record<string, unknown>>;
+    limitRange?: Partial<Record<string, unknown>>;
+    networkPolicy?: Partial<Record<string, unknown>>;
+  };
 }
 
 export interface HelmNamespaceEnvResult {
-  chart: Record<string, unknown>;
-  values: Record<string, unknown>;
-  namespace: Record<string, unknown>;
-  resourceQuota?: Record<string, unknown>;
-  limitRange?: Record<string, unknown>;
-  networkPolicy?: Record<string, unknown>;
+  chart: InstanceType<typeof Chart>;
+  values: InstanceType<typeof Values>;
+  namespace: InstanceType<typeof Namespace>;
+  resourceQuota?: InstanceType<typeof ResourceQuotaRes>;
+  limitRange?: InstanceType<typeof LimitRangeRes>;
+  networkPolicy?: InstanceType<typeof NetworkPolicyRes>;
 }
 
-export function HelmNamespaceEnv(props: HelmNamespaceEnvProps): HelmNamespaceEnvResult {
+export const HelmNamespaceEnv = Composite<HelmNamespaceEnvProps>((props) => {
   const {
     name,
     resourceQuota = true,
     limitRange = true,
     networkPolicy = true,
     appVersion = "1.0.0",
+    defaults: defs,
   } = props;
 
-  const chart = {
+  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: Record<string, unknown> = {
     namespace: {
@@ -87,7 +104,9 @@ export function HelmNamespaceEnv(props: HelmNamespaceEnvProps): HelmNamespaceEnv
     };
   }
 
-  const ns = {
+  const valuesRes = new Values(mergeDefaults(valuesObj, defs?.values));
+
+  const ns = new Namespace(mergeDefaults({
     apiVersion: "v1",
     kind: "Namespace",
     metadata: {
@@ -95,60 +114,69 @@ export function HelmNamespaceEnv(props: HelmNamespaceEnvProps): HelmNamespaceEnv
       labels: toYaml(values.namespace.labels),
       annotations: toYaml(values.namespace.annotations),
     },
-  };
+  }, defs?.namespace));
 
-  const result: HelmNamespaceEnvResult = {
+  const result: Record<string, any> = {
     chart,
-    values: valuesObj,
+    values: valuesRes,
     namespace: ns,
   };
 
   if (resourceQuota) {
-    result.resourceQuota = If(values.resourceQuota.enabled, {
-      apiVersion: "v1",
-      kind: "ResourceQuota",
-      metadata: {
-        name: include(`${name}.fullname`),
-        labels: include(`${name}.labels`),
-      },
-      spec: {
-        hard: toYaml(values.resourceQuota.hard),
-      },
-    }) as unknown as Record<string, unknown>;
+    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),
+        },
+      }) as Record<string, unknown>,
+      defs?.resourceQuota,
+    ));
   }
 
   if (limitRange) {
-    result.limitRange = 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),
-        }],
-      },
-    }) as unknown as Record<string, unknown>;
+    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),
+          }],
+        },
+      }) as Record<string, unknown>,
+      defs?.limitRange,
+    ));
   }
 
   if (networkPolicy) {
-    result.networkPolicy = 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"],
-      },
-    }) as unknown as Record<string, unknown>;
+    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"],
+        },
+      }) as Record<string, unknown>,
+      defs?.networkPolicy,
+    ));
   }
 
   return result;
-}
+}, "HelmNamespaceEnv");