@highstate/k8s 0.7.0 → 0.7.1

package/dist/{helm-BV9UE-B8.js → helm-wPTgVV1N.js}

@@ -1,46 +1,173 @@
 import { resolve } from 'path';
 import { mkdir, unlink, readFile } from 'node:fs/promises';
-import { ComponentResource, output, normalize, interpolate, all, toPromise } from '@highstate/pulumi';
+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 { mergeDeep, omit, pipe, map } from 'remeda';
+import { omit, pipe, map } from 'remeda';
 import { local } from '@pulumi/command';
 import { glob } from 'glob';
-import { m as mapMetadata, c as commonExtraArgs, d as mapNamespaceLikeToNamespaceName } from './shared-r5jBysdR.js';
+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"];
+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);
+  }
   /**
-   * The underlying Kubernetes service.
+   * Returns the host of the service accessible from the cluster.
+   *
+   * The format is `name.namespace.svc`.
    */
-  service;
+  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) {
-    super("highstate:k8s:Service", name, args, opts);
-    this.service = output(args).apply((args2) => {
-      return new core.v1.Service(
+    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, name),
-          spec: mergeDeep(
+          metadata: mapMetadata(args2.patch?.metadata ?? args2, name),
+          spec: deepmerge(
             {
               ports: normalize(args2.port, args2.ports)
             },
             omit(args2, serviceExtraArgs)
           )
         },
-        { ...opts, parent: this }
+        { parent: this, ...opts }
       );
     });
-    this.registerOutputs({
-      service: this.service
+    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
@@ -51,21 +178,9 @@ function mapServiceToLabelSelector(service) {
     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)) {
+  if (Service.isInstance(ref)) {
     return output({
       name: ref.metadata.name,
       namespace: ref.metadata.namespace,
@@ -77,9 +192,7 @@ function resolveBackendRef(ref) {
     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);
-      })
+      port: ref.port
     });
   }
   return output({
@@ -149,16 +262,18 @@ 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.charts, args2.chart),
+            chart: resolveHelmChart(args2.chart),
             namespace: args2.namespace ? mapNamespaceLikeToNamespaceName(args2.namespace) : void 0
           },
-          ["charts", "httpRoute"]
+          ["httpRoute"]
         ),
         { parent: this, ...opts }
       );
@@ -172,7 +287,7 @@ class Chart extends ComponentResource$1 {
         {
           ...httpRoute,
           rule: {
-            backend: this.getServiceOutput(args.serviceName)
+            backend: this.service
           }
         },
         { ...opts, parent: this }
@@ -188,8 +303,28 @@ class Chart extends ComponentResource$1 {
    * The HTTP route associated with the deployment.
    */
   httpRoute;
+  get service() {
+    return this.getServiceOutput(void 0);
+  }
+  services = /* @__PURE__ */ new Map();
   getServiceOutput(name) {
-    return this.chart.apply((chart) => getChartServiceOutput(chart, name ?? this.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));
@@ -214,7 +349,7 @@ class RenderedChart extends ComponentResource$1 {
           create: output$1([
             "helm",
             "template",
-            resolveHelmChart(args2.charts, args2.chart),
+            resolveHelmChart(args2.chart),
             ...args2.namespace ? ["--namespace", mapNamespaceLikeToNamespaceName(args2.namespace)] : [],
             ...values
           ]).apply((command) => command.join(" ")),
@@ -227,18 +362,14 @@ class RenderedChart extends ComponentResource$1 {
     this.registerOutputs({ manifest: this.manifest, command: this.command });
   }
 }
-async function resolveHelmChart(charts, name) {
-  const entry = charts[name];
-  if (!entry) {
-    throw new Error(`Chart '${name}' not found in the charts.json`);
-  }
+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 = `${name}-*.tgz`;
-  const targetFileName = `${name}-${entry.version}.tgz`;
+  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);
@@ -248,18 +379,18 @@ async function resolveHelmChart(charts, name) {
   }
   await spawn("helm", [
     "pull",
-    entry.name,
+    manifest.name,
     "--version",
-    entry.version,
+    manifest.version,
     "--repo",
-    entry.repo,
+    manifest.repo,
     "--destination",
     chartsDir
   ]);
   const content = await readFile(resolve(chartsDir, targetFileName));
   const actualSha256 = await sha256(content);
-  if (actualSha256 !== entry.sha256) {
-    throw new Error(`SHA256 mismatch for chart '${name}'`);
+  if (actualSha256 !== manifest.sha256) {
+    throw new Error(`SHA256 mismatch for chart '${manifest.name}'`);
   }
   return resolve(chartsDir, targetFileName);
 }
@@ -279,4 +410,4 @@ 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, getChartServiceOutput as b, getChartService as c, getServiceHost as g, mapContainerPortToServicePort as m, resolveHelmChart as r };
+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 };