@highstate/k8s 0.6.2 → 0.7.1

package/assets/charts.json

@@ -0,0 +1,8 @@
+{
+  "cert-manager": {
+    "repo": "https://charts.jetstack.io",
+    "name": "cert-manager",
+    "version": "v1.17.1",
+    "sha256": "48707f6e8937290da96065dc7de8b4f5a95d9707798d4b5a0d560f78c12996f7"
+  }
+}

package/dist/helm-wPTgVV1N.js

@@ -0,0 +1,413 @@
+import { resolve } from 'path';
+import { mkdir, unlink, readFile } from 'node:fs/promises';
+import { ComponentResource, output, interpolate, normalize, toPromise } from '@highstate/pulumi';
+import { core, helm } from '@pulumi/kubernetes';
+import { ComponentResource as ComponentResource$1, output as output$1 } from '@pulumi/pulumi';
+import spawn from 'nano-spawn';
+import { sha256 } from 'crypto-hash';
+import { omit, pipe, map } from 'remeda';
+import { local } from '@pulumi/command';
+import { glob } from 'glob';
+import { deepmerge } from 'deepmerge-ts';
+import { v as verifyProvider, m as mapMetadata, c as commonExtraArgs, r as resourceIdToString, d as mapNamespaceLikeToNamespaceName } from './shared-Clzbl5K-.js';
+import { gateway } from '@highstate/gateway-api';
+
+const serviceExtraArgs = [...commonExtraArgs, "port", "ports", "patch"];
+class Service extends ComponentResource {
+  constructor(type, name, args, opts, clusterInfo, metadata, spec, status, resources) {
+    super(type, name, args, opts);
+    this.clusterInfo = clusterInfo;
+    this.metadata = metadata;
+    this.spec = spec;
+    this.status = status;
+    this.resources = resources;
+  }
+  /**
+   * The Highstate service entity.
+   */
+  get entity() {
+    return output({
+      type: "k8s.service",
+      clusterInfo: this.clusterInfo,
+      metadata: this.metadata,
+      spec: this.spec
+    });
+  }
+  static create(name, args, opts) {
+    return new CreatedService(name, args, opts);
+  }
+  static wrap(name, service, clusterInfo, opts) {
+    return new WrappedService(name, service, clusterInfo, opts);
+  }
+  static external(name, id, clusterInfo, opts) {
+    return new ExternalService(name, id, clusterInfo, opts);
+  }
+  static of(name, entity, opts) {
+    return new ExternalService(name, output(entity).metadata, output(entity).clusterInfo, opts);
+  }
+  /**
+   * Returns the host of the service accessible from the cluster.
+   *
+   * The format is `name.namespace.svc`.
+   */
+  get clusterHost() {
+    return interpolate`${this.metadata.name}.${this.metadata.namespace}.svc`;
+  }
+  /**
+   * Returns the external IP of the service.
+   *
+   * If the load balancer is available, the external IP is returned, otherwise the IP of the node.
+   *
+   * If the service has no external IP, `undefined` is returned.
+   */
+  get externalIp() {
+    return output({ spec: this.spec, status: this.status }).apply(({ spec, status }) => {
+      const loadBalancerIp = status.loadBalancer?.ingress?.[0]?.ip;
+      if (loadBalancerIp) {
+        return loadBalancerIp;
+      }
+      const nodeIp = spec.externalIPs?.[0];
+      if (nodeIp) {
+        return nodeIp;
+      }
+      return void 0;
+    });
+  }
+  /**
+   * The "most public" IP of the service.
+   *
+   * Resolves to the external IP if available, otherwise the cluster IP.
+   *
+   * If the service is headless, an error is thrown.
+   */
+  get ip() {
+    return output({ spec: this.spec, externalIp: this.externalIp }).apply(
+      ({ spec, externalIp }) => {
+        if (externalIp) {
+          return externalIp;
+        }
+        const clusterIp = spec.clusterIP;
+        if (clusterIp && clusterIp !== "None") {
+          return clusterIp;
+        }
+        throw new Error("The service does not have neither an external IP nor a cluster IP.");
+      }
+    );
+  }
+}
+class CreatedService extends Service {
+  constructor(name, args, opts) {
+    const service = output(args).apply(async (args2) => {
+      await verifyProvider(opts.provider, args2.cluster.info);
+      return new (args2.patch ? core.v1.ServicePatch : core.v1.Service)(
+        name,
+        {
+          metadata: mapMetadata(args2.patch?.metadata ?? args2, name),
+          spec: deepmerge(
+            {
+              ports: normalize(args2.port, args2.ports)
+            },
+            omit(args2, serviceExtraArgs)
+          )
+        },
+        { parent: this, ...opts }
+      );
+    });
+    super(
+      "highstate:k8s:Service",
+      name,
+      args,
+      opts,
+      output(args.cluster).info,
+      service.metadata,
+      service.spec,
+      service.status,
+      [service]
+    );
+  }
+}
+class WrappedService extends Service {
+  constructor(name, service, clusterInfo, opts) {
+    super(
+      "highstate:k8s:WrappedService",
+      name,
+      { service, clusterInfo },
+      opts,
+      output(clusterInfo),
+      output(service).metadata,
+      output(service).spec,
+      output(service).status,
+      [service]
+    );
+  }
+}
+class ExternalService extends Service {
+  constructor(name, id, clusterInfo, opts) {
+    const service = output(id).apply(async (id2) => {
+      await verifyProvider(opts.provider, this.clusterInfo);
+      return core.v1.Service.get(
+        //
+        name,
+        resourceIdToString(id2),
+        { parent: this, provider: opts.provider }
+      );
+    });
+    super(
+      "highstate:k8s:ExternalService",
+      name,
+      { id, clusterInfo },
+      opts,
+      output(clusterInfo),
+      service.metadata,
+      service.spec,
+      service.status,
+      [service]
+    );
+  }
+}
+function mapContainerPortToServicePort(port) {
+  return {
+    name: port.name,
+    port: port.containerPort,
+    targetPort: port.containerPort,
+    protocol: port.protocol
+  };
+}
+function mapServiceToLabelSelector(service) {
+  return {
+    matchLabels: service.spec.selector
+  };
+}
+
+function resolveBackendRef(ref) {
+  if (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: ref.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) => ({
+              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;
+}
+
+class Chart extends ComponentResource$1 {
+  constructor(name, args, opts) {
+    super("highstate:k8s:Chart", name, args, opts);
+    this.name = name;
+    this.args = args;
+    this.opts = opts;
+    this.chart = output$1(args).apply((args2) => {
+      return new helm.v4.Chart(
+        name,
+        omit(
+          {
+            ...args2,
+            chart: resolveHelmChart(args2.chart),
+            namespace: args2.namespace ? mapNamespaceLikeToNamespaceName(args2.namespace) : void 0
+          },
+          ["httpRoute"]
+        ),
+        { parent: this, ...opts }
+      );
+    });
+    this.httpRoute = output$1(args.httpRoute).apply((httpRoute) => {
+      if (!httpRoute) {
+        return void 0;
+      }
+      return new HttpRoute(
+        name,
+        {
+          ...httpRoute,
+          rule: {
+            backend: this.service
+          }
+        },
+        { ...opts, parent: this }
+      );
+    });
+    this.registerOutputs({ chart: this.chart });
+  }
+  /**
+   * The underlying Helm chart.
+   */
+  chart;
+  /**
+   * The HTTP route associated with the deployment.
+   */
+  httpRoute;
+  get service() {
+    return this.getServiceOutput(void 0);
+  }
+  services = /* @__PURE__ */ new Map();
+  getServiceOutput(name) {
+    return output$1({ args: this.args, chart: this.chart }).apply(({ args, chart }) => {
+      const resolvedName = name ?? args.serviceName ?? this.name;
+      const existingService = this.services.get(resolvedName);
+      if (existingService) {
+        return existingService;
+      }
+      const service = getChartServiceOutput(chart, resolvedName);
+      const wrappedService = Service.wrap(
+        //
+        resolvedName,
+        service,
+        args.cluster.info,
+        { parent: this, ...this.opts }
+      );
+      this.services.set(resolvedName, wrappedService);
+      return wrappedService;
+    });
+  }
+  getService(name) {
+    return toPromise(this.getServiceOutput(name));
+  }
+}
+class RenderedChart extends ComponentResource$1 {
+  /**
+   * The rendered manifest of the Helm chart.
+   */
+  manifest;
+  /**
+   * The underlying command used to render the chart.
+   */
+  command;
+  constructor(name, args, opts) {
+    super("highstate:k8s:RenderedChart", name, args, opts);
+    this.command = output$1(args).apply((args2) => {
+      const values = args2.values ? Object.entries(args2.values).flatMap(([key, value]) => ["--set", `${key}="${value}"`]) : [];
+      return new local.Command(
+        name,
+        {
+          create: output$1([
+            "helm",
+            "template",
+            resolveHelmChart(args2.chart),
+            ...args2.namespace ? ["--namespace", mapNamespaceLikeToNamespaceName(args2.namespace)] : [],
+            ...values
+          ]).apply((command) => command.join(" ")),
+          logging: "stderr"
+        },
+        { parent: this, ...opts }
+      );
+    });
+    this.manifest = this.command.stdout;
+    this.registerOutputs({ manifest: this.manifest, command: this.command });
+  }
+}
+async function resolveHelmChart(manifest) {
+  if (!process.env.HIGHSTATE_CACHE_DIR) {
+    throw new Error("Environment variable HIGHSTATE_CACHE_DIR is not set");
+  }
+  const chartsDir = resolve(process.env.HIGHSTATE_CACHE_DIR, "charts");
+  await mkdir(chartsDir, { recursive: true });
+  const globPattern = `${manifest.name}-*.tgz`;
+  const targetFileName = `${manifest.name}-${manifest.version}.tgz`;
+  const files = await glob(globPattern, { cwd: chartsDir });
+  if (files.includes(targetFileName)) {
+    return resolve(chartsDir, targetFileName);
+  }
+  for (const file of files) {
+    await unlink(resolve(chartsDir, file));
+  }
+  await spawn("helm", [
+    "pull",
+    manifest.name,
+    "--version",
+    manifest.version,
+    "--repo",
+    manifest.repo,
+    "--destination",
+    chartsDir
+  ]);
+  const content = await readFile(resolve(chartsDir, targetFileName));
+  const actualSha256 = await sha256(content);
+  if (actualSha256 !== manifest.sha256) {
+    throw new Error(`SHA256 mismatch for chart '${manifest.name}'`);
+  }
+  return resolve(chartsDir, targetFileName);
+}
+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 { Chart as C, HttpRoute as H, RenderedChart as R, Service as S, mapServiceToLabelSelector as a, getChartService as b, getChartServiceOutput as g, mapContainerPortToServicePort as m, resolveHelmChart as r };