@highstate/k8s 0.4.5

package/dist/index.js

@@ -0,0 +1,950 @@
+import { m as mapMetadata, c as commonExtraArgs, a as mapSelectorLikeToSelector, b as mapNamespaceNameToSelector, d as mapNamespaceLikeToNamespaceName } from './shared-hajqPzR4.js';
+export { f as createNamespace, e as createProvider, r as resolveChartPath } from './shared-hajqPzR4.js';
+import { ComponentResource, output, normalize, interpolate, all, toPromise, apply } from '@highstate/pulumi';
+import { core, apps, networking, batch } from '@pulumi/kubernetes';
+import { gateway } from '@highstate/gateway-api';
+import { mergeDeep, omit, pipe, map, concat, capitalize, flat, merge } from 'remeda';
+import { DnsRecord } from '@highstate/common';
+import { ComponentResource as ComponentResource$1, output as output$1 } from '@pulumi/pulumi';
+import { deepmerge } from 'deepmerge-ts';
+import { trimIndentation, text } from '@highstate/contract';
+import 'node:fs';
+import 'node:path';
+
+const serviceExtraArgs = [...commonExtraArgs, "port", "ports"];
+class Service extends ComponentResource {
+  /**
+   * The underlying Kubernetes service.
+   */
+  service;
+  constructor(name, args, opts) {
+    super("highstate:k8s:Service", name, args, opts);
+    this.service = output(args).apply((args2) => {
+      return new core.v1.Service(
+        name,
+        {
+          metadata: mapMetadata(args2, name),
+          spec: mergeDeep(
+            {
+              ports: normalize(args2.port, args2.ports)
+            },
+            omit(args2, serviceExtraArgs)
+          )
+        },
+        { ...opts, parent: this }
+      );
+    });
+    this.registerOutputs({
+      service: this.service
+    });
+  }
+}
+function mapContainerPortToServicePort(port) {
+  return {
+    port: port.containerPort,
+    targetPort: port.containerPort,
+    protocol: port.protocol
+  };
+}
+function mapServiceToLabelSelector(service) {
+  return {
+    matchLabels: service.spec.selector
+  };
+}
+function getServiceHost(service) {
+  return interpolate`${service.metadata.name}.${service.metadata.namespace}.svc`;
+}
+function getRequiredServicePortByName(service, name) {
+  return service.spec.ports.apply((ports) => {
+    const port = ports.find((p) => p.name === name);
+    if (!port) {
+      throw new Error(`Service does not have a port with name ${name}`);
+    }
+    return port.port;
+  });
+}
+
+function resolveBackendRef(ref) {
+  if (core.v1.Service.isInstance(ref)) {
+    return output({
+      name: ref.metadata.name,
+      namespace: ref.metadata.namespace,
+      port: ref.spec.ports[0].port
+    });
+  }
+  if ("service" in ref) {
+    const service = output(ref.service);
+    return output({
+      name: service.metadata.name,
+      namespace: service.metadata.namespace,
+      port: all([ref.service, ref.port]).apply(([service2, port]) => {
+        return typeof port === "number" ? output(port) : getRequiredServicePortByName(service2, port);
+      })
+    });
+  }
+  return output({
+    name: ref.name,
+    namespace: ref.namespace,
+    port: ref.port
+  });
+}
+
+class HttpRoute extends ComponentResource {
+  /**
+   * The underlying Kubernetes resource.
+   */
+  route;
+  constructor(name, args, opts) {
+    super("highstate:k8s:HttpRoute", name, args, opts);
+    this.route = output({
+      args,
+      gatewayNamespace: output(args.gateway).metadata.namespace
+    }).apply(({ args: args2, gatewayNamespace }) => {
+      return new gateway.v1.HTTPRoute(
+        name,
+        {
+          metadata: mapMetadata(
+            {
+              ...args2,
+              namespace: gatewayNamespace
+            },
+            name
+          ),
+          spec: {
+            hostnames: normalize(args2.hostname, args2.hostnames),
+            parentRefs: [
+              {
+                name: args2.gateway.metadata.name
+              }
+            ],
+            rules: normalize(args2.rule, args2.rules).map((rule) => ({
+              sessionPersistence: rule.sessionPersistence,
+              timeouts: rule.timeouts,
+              matches: pipe(
+                normalize(rule.match, rule.matches),
+                map(mapHttpRouteRuleMatch),
+                addDefaultPathMatch
+              ),
+              filters: normalize(rule.filter, rule.filters),
+              backendRefs: rule.backend ? [resolveBackendRef(rule.backend)] : void 0
+            }))
+          }
+        },
+        { parent: this, ...opts }
+      );
+    });
+    this.registerOutputs({ route: this.route });
+  }
+}
+function addDefaultPathMatch(matches) {
+  return matches.length ? matches : [{ path: { type: "PathPrefix", value: "/" } }];
+}
+function mapHttpRouteRuleMatch(match) {
+  if (typeof match === "string") {
+    return { path: { type: "PathPrefix", value: match } };
+  }
+  return match;
+}
+
+const containerExtraArgs = [
+  "port",
+  "volumeMount",
+  "volume",
+  "environment",
+  "environmentSource",
+  "environmentSources"
+];
+function mapContainerToRaw(fallbackName, container) {
+  return {
+    ...omit(container, containerExtraArgs),
+    name: container.name ?? fallbackName,
+    ports: normalize(container.port, container.ports),
+    volumeMounts: map(normalize(container.volumeMount, container.volumeMounts), mapVolumeMount),
+    env: concat(
+      container.environment ? mapContainerEnvironment(container.environment) : [],
+      container.env ?? []
+    ),
+    envFrom: concat(
+      map(
+        normalize(container.environmentSource, container.environmentSources),
+        mapEnvironmentSource
+      ),
+      container.envFrom ?? []
+    )
+  };
+}
+function mapContainerEnvironment(environment) {
+  const envVars = [];
+  for (const [name, value] of Object.entries(environment)) {
+    if (!value) {
+      continue;
+    }
+    if (typeof value === "string") {
+      envVars.push({ name, value });
+      continue;
+    }
+    if ("secret" in value) {
+      envVars.push({
+        name,
+        valueFrom: {
+          secretKeyRef: {
+            name: value.secret.metadata.name,
+            key: value.key
+          }
+        }
+      });
+      continue;
+    }
+    if ("configMap" in value) {
+      envVars.push({
+        name,
+        valueFrom: {
+          configMapKeyRef: {
+            name: value.configMap.metadata.name,
+            key: value.key
+          }
+        }
+      });
+      continue;
+    }
+    envVars.push({ name, valueFrom: value });
+  }
+  return envVars;
+}
+function mapVolumeMount(volumeMount) {
+  if ("volume" in volumeMount) {
+    return {
+      ...volumeMount,
+      name: output(volumeMount.volume).apply(mapWorkloadVolume).apply((volume) => output(volume.name))
+    };
+  }
+  return volumeMount;
+}
+function mapEnvironmentSource(envFrom) {
+  if (envFrom instanceof core.v1.ConfigMap) {
+    return {
+      configMapRef: {
+        name: envFrom.metadata.name
+      }
+    };
+  }
+  if (envFrom instanceof core.v1.Secret) {
+    return {
+      secretRef: {
+        name: envFrom.metadata.name
+      }
+    };
+  }
+  return envFrom;
+}
+function mapWorkloadVolume(volume) {
+  if (volume instanceof core.v1.PersistentVolumeClaim) {
+    return {
+      name: volume.metadata.name,
+      persistentVolumeClaim: {
+        claimName: volume.metadata.name
+      }
+    };
+  }
+  if (volume instanceof core.v1.ConfigMap) {
+    return {
+      name: volume.metadata.name,
+      configMap: {
+        name: volume.metadata.name
+      }
+    };
+  }
+  if (volume instanceof core.v1.Secret) {
+    return {
+      name: volume.metadata.name,
+      secret: {
+        secretName: volume.metadata.name
+      }
+    };
+  }
+  return volume;
+}
+
+const deploymentExtraArgs = [
+  ...commonExtraArgs,
+  "container",
+  "containers",
+  "gateway",
+  "service",
+  "httpRoute"
+];
+class Deployment extends ComponentResource {
+  /**
+   * The underlying Kubernetes deployment.
+   */
+  deployment;
+  /**
+   * The service associated with the deployment.
+   */
+  service;
+  /**
+   * The HTTP route associated with the deployment.
+   */
+  httpRoute;
+  constructor(name, args, opts) {
+    super("highstate:k8s:Deployment", name, args, opts);
+    const labels = {
+      "app.kubernetes.io/name": name
+    };
+    this.deployment = output(args).apply((args2) => {
+      const containers = normalize(args2.container, args2.containers);
+      return new apps.v1.Deployment(
+        name,
+        {
+          metadata: mapMetadata(args2, name),
+          spec: mergeDeep(
+            {
+              template: {
+                metadata: {
+                  labels
+                },
+                spec: {
+                  containers: containers.map((container) => mapContainerToRaw(name, container)),
+                  volumes: containers.flatMap((container) => normalize(container.volume, container.volumes)).map(mapWorkloadVolume)
+                }
+              },
+              selector: {
+                matchLabels: labels
+              }
+            },
+            omit(args2, deploymentExtraArgs)
+          )
+        },
+        {
+          ...opts,
+          parent: this
+        }
+      );
+    });
+    this.service = output({
+      args: args.service,
+      httpRouteArgs: args.httpRoute,
+      namespace: this.deployment.metadata.namespace,
+      containers: this.deployment.spec.template.spec.containers
+    }).apply(({ args: args2, httpRouteArgs, namespace, containers }) => {
+      if (!args2 && !httpRouteArgs) {
+        return void 0;
+      }
+      const ports = containers.flatMap((container) => container.ports ?? []);
+      return new Service(
+        args2?.name ?? name,
+        {
+          ...args2,
+          namespace,
+          ports: (
+            // allow to completely override the ports
+            !args2?.port && !args2?.ports ? ports.map(mapContainerPortToServicePort) : args2?.ports
+          ),
+          selector: labels
+        },
+        {
+          ...opts,
+          parent: this
+        }
+      );
+    });
+    this.httpRoute = output({
+      args: args.httpRoute,
+      service: this.service
+    }).apply(({ args: args2, service }) => {
+      if (!args2 || !service) {
+        return void 0;
+      }
+      return new HttpRoute(
+        name,
+        {
+          ...args2,
+          gateway: args2.gateway,
+          rule: {
+            backend: service.service
+          }
+        },
+        {
+          ...opts,
+          parent: this
+        }
+      );
+    });
+    this.registerOutputs({
+      deployment: this.deployment,
+      service: this.service
+    });
+  }
+  getRequiredService() {
+    return this.service.apply((service) => {
+      if (!service) {
+        throw new Error("The service is not available for this deployment.");
+      }
+      return service;
+    });
+  }
+}
+
+function mapPersistentVolumeClaimToRaw(args) {
+  return {
+    metadata: mapMetadata(args),
+    spec: args
+  };
+}
+
+class StatefulSet extends ComponentResource {
+  /**
+   * The underlying Kubernetes stateful set.
+   */
+  statefulSet;
+  /**
+   * The service associated with the stateful set.
+   */
+  service;
+  constructor(name, args, opts) {
+    super("highstate:k8s:StatefulSet", name, args, opts);
+    const labels = {
+      "app.kubernetes.io/name": name
+    };
+    this.service = output(args.service).apply((service) => {
+      return new Service(
+        service?.name ?? name,
+        {
+          ...service,
+          clusterIP: "None"
+        },
+        { ...opts, parent: this }
+      );
+    });
+    this.statefulSet = output(args).apply((args2) => {
+      return new apps.v1.StatefulSet(name, {
+        metadata: mapMetadata(args2),
+        spec: mergeDeep(args2, {
+          serviceName: this.service.service.metadata.name,
+          template: {
+            metadata: {
+              labels
+            },
+            spec: {
+              containers: normalize(args2.container, args2.containers).map((container) => mapContainerToRaw(name, container))
+            }
+          },
+          selector: {
+            matchLabels: labels
+          },
+          volumeClaimTemplates: normalize(args2.volumeClaim, args2.volumeClaims).map(mapPersistentVolumeClaimToRaw)
+        })
+      });
+    });
+    this.registerOutputs({
+      statefulSet: this.statefulSet,
+      service: this.service
+    });
+  }
+}
+
+class NetworkPolicy extends ComponentResource {
+  /**
+   * The underlying network policy resource.
+   */
+  networkPolicy;
+  constructor(name, args, opts) {
+    super("k8s:network-policy", name, args, opts);
+    const normalizedArgs = output(args).apply((args2) => {
+      const ingressRules = normalize(args2.ingressRule, args2.ingressRules);
+      const egressRules = normalize(args2.egressRule, args2.egressRules);
+      return {
+        ...args2,
+        podSelector: args2.selector ? mapSelectorLikeToSelector(args2.selector) : {},
+        isolateEgress: args2.isolateEgress ?? false,
+        isolateIngress: args2.isolateIngress ?? false,
+        ingressRules: ingressRules.map((rule) => ({
+          all: rule.fromAll ?? false,
+          cidrs: normalize(rule.fromCidr, rule.fromCidrs),
+          fqdns: [],
+          services: normalize(rule.fromService, rule.fromServices),
+          namespaces: normalize(rule.fromNamespace, rule.fromNamespaces),
+          selectors: normalize(rule.fromSelector, rule.fromSelectors),
+          ports: normalize(rule.toPort, rule.toPorts)
+        })),
+        egressRules: egressRules.map((rule) => ({
+          all: rule.toAll ?? false,
+          cidrs: normalize(rule.toCidr, rule.toCidrs),
+          fqdns: normalize(rule.toFqdn, rule.toFqdns),
+          services: normalize(rule.toService, rule.toServices),
+          namespaces: normalize(rule.toNamespace, rule.toNamespaces),
+          selectors: normalize(rule.toSelector, rule.toSelectors),
+          ports: normalize(rule.toPort, rule.toPorts)
+        }))
+      };
+    });
+    this.networkPolicy = normalizedArgs.apply((args2) => {
+      return output(
+        this.create(name, args2, { ...opts, parent: this })
+      );
+    });
+    this.registerOutputs({ networkPolicy: this.networkPolicy });
+  }
+  static create(name, args, opts) {
+    return output(args).apply(async (args2) => {
+      if (!args2.cni || args2.cni === "unknown") {
+        return new NativeNetworkPolicy(name, args2, opts);
+      }
+      const implName = `${capitalize(args2.cni)}NetworkPolicy`;
+      const implModule = await import(`@highstate/${args2.cni}`);
+      const implClass = implModule[implName];
+      if (!implClass) {
+        throw new Error(`No implementation found for ${args2.cni}`);
+      }
+      return new implClass(name, args2, opts);
+    });
+  }
+}
+class NativeNetworkPolicy extends NetworkPolicy {
+  create(name, args, opts) {
+    const ingress = NativeNetworkPolicy.createIngressRules(args);
+    const egress = NativeNetworkPolicy.createEgressRules(args);
+    const policyTypes = [];
+    if (ingress.length > 0 || args.isolateIngress) {
+      policyTypes.push("Ingress");
+    }
+    if (egress.length > 0 || args.isolateEgress) {
+      policyTypes.push("Egress");
+    }
+    return new networking.v1.NetworkPolicy(
+      name,
+      {
+        metadata: mergeDeep(mapMetadata(args, name), {
+          annotations: args.description ? { "kubernetes.io/description": args.description } : void 0
+        }),
+        spec: {
+          podSelector: args.podSelector,
+          ingress,
+          egress,
+          policyTypes
+        }
+      },
+      opts
+    );
+  }
+  static fallbackIpBlock = {
+    cidr: "0.0.0.0/0",
+    except: ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]
+  };
+  static createIngressRules(args) {
+    return args.ingressRules.map((rule) => ({
+      from: rule.all ? void 0 : NativeNetworkPolicy.createRulePeers(rule),
+      ports: NativeNetworkPolicy.mapPorts(rule.ports)
+    }));
+  }
+  static createEgressRules(args) {
+    const needFallback = args.egressRules.some((rule) => rule.fqdns.length > 0);
+    if (needFallback) {
+      return [{ to: [{ ipBlock: NativeNetworkPolicy.fallbackIpBlock }] }];
+    }
+    return args.egressRules.map((rule) => ({
+      to: rule.all ? void 0 : NativeNetworkPolicy.createRulePeers(rule),
+      ports: NativeNetworkPolicy.mapPorts(rule.ports)
+    }));
+  }
+  static createRulePeers(args) {
+    return [
+      ...NativeNetworkPolicy.createCidrPeers(args),
+      ...NativeNetworkPolicy.createServicePeers(args),
+      ...NativeNetworkPolicy.createSelectorPeers(args)
+    ];
+  }
+  static createCidrPeers(args) {
+    return args.cidrs.map((cidr) => ({ ipBlock: { cidr } }));
+  }
+  static createServicePeers(args) {
+    return args.services.map((service) => {
+      const selector = mapServiceToLabelSelector(service);
+      return {
+        namespaceSelector: mapNamespaceNameToSelector(service.metadata.namespace),
+        podSelector: selector
+      };
+    });
+  }
+  static createSelectorPeers(args) {
+    const selectorPeers = args.selectors.map((selector) => ({
+      podSelector: mapSelectorLikeToSelector(selector)
+    }));
+    const namespacePeers = args.namespaces.map(NativeNetworkPolicy.createNamespacePeer);
+    if (namespacePeers.length === 0) {
+      return selectorPeers;
+    }
+    if (selectorPeers.length === 0) {
+      return namespacePeers;
+    }
+    return flat(
+      selectorPeers.map((selectorPeer) => {
+        return namespacePeers.map((namespacePeer) => merge(selectorPeer, namespacePeer));
+      })
+    );
+  }
+  static createNamespacePeer(namespace) {
+    const namespaceName = mapNamespaceLikeToNamespaceName(namespace);
+    const namespaceSelector = mapNamespaceNameToSelector(namespaceName);
+    return { namespaceSelector };
+  }
+  static mapPorts(ports) {
+    return ports.map((port) => {
+      if ("port" in port) {
+        return {
+          port: port.port,
+          protocol: port.protocol ?? "TCP"
+        };
+      }
+      return {
+        port: port.range[0],
+        endPort: port.range[1],
+        protocol: port.protocol ?? "TCP"
+      };
+    });
+  }
+}
+
+function useAccessPoint(args) {
+  const result = output(args).apply((args2) => {
+    const gateway2 = createGateway({
+      ...args2,
+      annotations: {
+        "cert-manager.io/cluster-issuer": args2.accessPoint.tlsIssuer.clusterIssuerName
+      },
+      gateway: args2.accessPoint.gateway
+    });
+    const dnsRecord = DnsRecord.create(args2.fqdn, {
+      provider: args2.accessPoint.dnsProvider,
+      type: "A",
+      value: args2.accessPoint.gateway.ip
+    });
+    return output({
+      gateway: gateway2,
+      dnsRecord
+    });
+  });
+  return toPromise(result);
+}
+function createGateway(args) {
+  return new gateway.v1.Gateway(
+    args.name,
+    {
+      metadata: {
+        name: args.name,
+        namespace: output(args.namespace).apply(mapNamespaceLikeToNamespaceName),
+        annotations: args.annotations
+      },
+      spec: {
+        gatewayClassName: output(args.gateway).gatewayClassName,
+        listeners: [
+          {
+            name: "https",
+            port: output(args.gateway).httpsListenerPort,
+            protocol: "HTTPS",
+            hostname: args.fqdn,
+            tls: {
+              mode: "Terminate",
+              certificateRefs: [{ name: args.fqdn }]
+            }
+          }
+        ]
+      }
+    },
+    { provider: args.provider }
+  );
+}
+
+const emptyDistributionEnvironment = {
+  preInstallPackages: [],
+  preInstallScripts: {},
+  packages: []
+};
+const emptyScriptEnvironment = {
+  alpine: emptyDistributionEnvironment,
+  ubuntu: emptyDistributionEnvironment,
+  setupScripts: {},
+  cleanupScripts: {},
+  scripts: {},
+  volumes: [],
+  volumeMounts: [],
+  environment: {}
+};
+
+class ScriptBundle extends ComponentResource$1 {
+  /**
+   * The config map containing the scripts.
+   */
+  configMap;
+  /**
+   * The volumes that should be included in the workload.
+   */
+  volumes;
+  /**
+   * The volume mounts that should be defined in the container.
+   */
+  volumeMounts;
+  /**
+   * The environment variables that should be defined in the container.
+   */
+  environment;
+  /**
+   * The distribution to use for the scripts.
+   */
+  distribution;
+  constructor(name, args, opts) {
+    super("highstate:k8s:ScriptBundle", name, args, opts);
+    const scriptEnvironment = pipe(
+      output$1(args),
+      apply((args2) => normalize(args2.environment, args2.environments)),
+      apply((args2) => deepmerge(emptyScriptEnvironment, ...args2))
+    );
+    this.distribution = args.distribution;
+    this.environment = scriptEnvironment.environment;
+    this.configMap = output$1({ scriptEnvironment, args }).apply(({ scriptEnvironment: scriptEnvironment2, args: args2 }) => {
+      return new core.v1.ConfigMap(
+        name,
+        {
+          metadata: mapMetadata(args2, name),
+          data: createScriptData(this.distribution, scriptEnvironment2)
+        },
+        { ...opts, parent: this }
+      );
+    });
+    this.volumes = scriptEnvironment.volumes.apply((volumes) => {
+      return [
+        ...volumes,
+        {
+          name: this.configMap.metadata.name,
+          configMap: {
+            name: this.configMap.metadata.name,
+            defaultMode: 360
+            // read and execute permissions
+          }
+        }
+      ];
+    });
+    this.volumeMounts = scriptEnvironment.volumeMounts.apply((volumeMounts) => {
+      return [
+        ...volumeMounts,
+        {
+          volume: this.configMap,
+          mountPath: "/scripts"
+        }
+      ];
+    });
+    this.registerOutputs({
+      configMap: this.configMap,
+      volumes: this.volumes,
+      volumeMounts: this.volumeMounts,
+      environment: this.environment
+    });
+  }
+}
+function createScriptData(distribution, environment) {
+  const scriptData = {};
+  const actions = [];
+  const distributionEnvironment = environment[distribution];
+  if (distributionEnvironment.preInstallPackages.length > 0) {
+    scriptData["pre-install-packages.sh"] = getInstallPackagesScript(
+      distribution,
+      distributionEnvironment.preInstallPackages
+    );
+    actions.push(`
+      echo "+ Installing pre-install packages..."
+      /scripts/pre-install-packages.sh
+      echo "+ Pre-install packages installed successfully"
+    `);
+  }
+  if (Object.keys(distributionEnvironment.preInstallScripts).length > 0) {
+    for (const key in distributionEnvironment.preInstallScripts) {
+      scriptData[`pre-install-${key}`] = distributionEnvironment.preInstallScripts[key];
+      actions.push(`
+        echo "+ Running pre-install script '${key}'..."
+        /scripts/pre-install-${key}
+        echo "+ Pre-install script '${key}'... Done"
+      `);
+    }
+  }
+  if (distributionEnvironment.packages.length > 0) {
+    scriptData["install-packages.sh"] = getInstallPackagesScript(
+      distribution,
+      distributionEnvironment.packages
+    );
+    actions.push(`
+      echo "+ Installing packages..."
+      /scripts/install-packages.sh
+      echo "+ Packages installed successfully"
+    `);
+  }
+  if (Object.keys(environment.setupScripts).length > 0) {
+    for (const key in environment.setupScripts) {
+      scriptData[`setup-${key}`] = environment.setupScripts[key];
+      actions.push(`
+        echo "+ Running setup script '${key}'..."
+        /scripts/setup-${key}
+        echo "+ Setup script '${key}'... Done"
+      `);
+    }
+  }
+  if (Object.keys(environment.cleanupScripts).length > 0) {
+    const cleanupActions = [];
+    for (const key in environment.cleanupScripts) {
+      scriptData[`cleanup-${key}`] = environment.cleanupScripts[key];
+      cleanupActions.push(`
+        echo "+ Running cleanup script '${key}'..."
+        /scripts/cleanup-${key}
+        echo "+ Cleanup script '${key}'... Done"
+      `);
+    }
+    actions.push(`
+      function cleanup() {
+      ${cleanupActions.map((s) => s.trim()).join("\n\n")}
+      }
+
+      trap cleanup EXIT
+      trap cleanup SIGTERM
+    `);
+  }
+  for (const key in environment.scripts) {
+    scriptData[key] = environment.scripts[key];
+  }
+  scriptData["entrypoint.sh"] = trimIndentation(`
+    #!/bin/sh
+    set -e
+
+    if [ -z "$1" ]; then
+      echo "Usage: entrypoint.sh <main script> [args...]"
+      exit 1
+    fi
+
+  ${actions.map((s) => s.trim()).join("\n\n")}
+
+    echo "+ Running main script..."
+    $@
+    echo "+ Main script completed"
+  `);
+  return scriptData;
+}
+function getInstallPackagesScript(distribution, packages) {
+  if (distribution === "alpine") {
+    return text`
+      #!/bin/sh
+      set -e
+
+      apk add --no-cache ${packages.join(" ")}
+    `;
+  } else {
+    return text`
+      #!/bin/sh
+      set -e
+
+      apt-get update
+      apt-get install -y ${packages.join(" ")}
+    `;
+  }
+}
+
+function createScriptContainer(options) {
+  return output$1(options).apply((options2) => {
+    const image = options2.bundle.distribution === "alpine" ? "alpine@sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c" : "ubuntu@sha256:72297848456d5d37d1262630108ab308d3e9ec7ed1c3286a32fe09856619a782";
+    return {
+      image,
+      command: ["/scripts/entrypoint.sh", `/scripts/${options2.main}`],
+      ...options2,
+      volumeMounts: merge(options2.bundle.volumeMounts, options2.volumeMounts),
+      volumes: merge(options2.bundle.volumes, options2.volumes),
+      environment: merge(options2.bundle.environment, options2.environment)
+    };
+  });
+}
+
+const jobExtraArgs = [...commonExtraArgs, "container", "containers"];
+class Job extends ComponentResource {
+  /**
+   * The underlying Kubernetes job.
+   */
+  job;
+  constructor(name, args, opts) {
+    super("highstate:k8s:Job", name, args, opts);
+    this.job = output(args).apply((args2) => {
+      const containers = normalize(args2.container, args2.containers);
+      return new batch.v1.Job(
+        name,
+        {
+          metadata: mapMetadata(args2, name),
+          spec: mergeDeep(
+            {
+              template: {
+                spec: {
+                  containers: containers.map((container) => mapContainerToRaw(name, container)),
+                  volumes: containers.flatMap((container) => normalize(container.volume, container.volumes)).map(mapWorkloadVolume),
+                  restartPolicy: "Never"
+                }
+              }
+            },
+            omit(args2, jobExtraArgs)
+          )
+        },
+        { parent: this, ...opts }
+      );
+    });
+    this.registerOutputs({ job: this.job });
+  }
+}
+
+const cronJobExtraArgs = [...commonExtraArgs, "container", "containers"];
+class CronJob extends ComponentResource {
+  /**
+   * The underlying Kubernetes job.
+   */
+  cronJob;
+  constructor(name, args, opts) {
+    super("highstate:k8s:CronJob", name, args, opts);
+    this.cronJob = output(args).apply((args2) => {
+      const containers = normalize(args2.container, args2.containers);
+      return new batch.v1.CronJob(
+        name,
+        {
+          metadata: mapMetadata(args2, name),
+          spec: mergeDeep(
+            {
+              jobTemplate: {
+                spec: {
+                  template: {
+                    spec: {
+                      containers: containers.map((container) => mapContainerToRaw(name, container)),
+                      volumes: containers.flatMap((container) => normalize(container.volume, container.volumes)).map(mapWorkloadVolume)
+                    }
+                  }
+                }
+              },
+              schedule: args2.schedule
+            },
+            omit(args2, cronJobExtraArgs)
+          )
+        },
+        { parent: this, ...opts }
+      );
+    });
+    this.registerOutputs({ cronJob: this.cronJob });
+  }
+}
+
+function getChartServiceOutput(chart, name) {
+  const services = chart.resources.apply((resources) => {
+    return resources.filter((r) => core.v1.Service.isInstance(r)).map((service) => ({ name: service.metadata.name, service }));
+  });
+  return output$1(services).apply((services2) => {
+    const service = services2.find((s) => s.name === name)?.service;
+    if (!service) {
+      throw new Error(`Service with name '${name}' not found in the chart resources`);
+    }
+    return service;
+  });
+}
+function getChartService(chart, name) {
+  return toPromise(getChartServiceOutput(chart, name));
+}
+
+export { CronJob, Deployment, HttpRoute, Job, NetworkPolicy, ScriptBundle, Service, StatefulSet, createScriptContainer, getChartService, getChartServiceOutput, getServiceHost, mapContainerPortToServicePort, mapMetadata, mapNamespaceLikeToNamespaceName, mapNamespaceNameToSelector, mapSelectorLikeToSelector, mapServiceToLabelSelector, useAccessPoint };