@highstate/k8s 0.9.16 → 0.9.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/k8s",
-  "version": "0.9.16",
+  "version": "0.9.19",
   "type": "module",
   "files": [
     "dist",
@@ -11,6 +11,30 @@
       ".": {
         "mode": "manual",
         "version": "1"
+      },
+      "./units/cert-manager": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/cluster-patch": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/cluster-dns": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/dns01-issuer": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/existing-cluster": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/gateway-api": {
+        "mode": "manual",
+        "version": "1"
       }
     }
   },
@@ -19,34 +43,35 @@
       "types": "./src/index.ts",
       "default": "./dist/index.js"
     },
-    "./units/access-point": "./dist/units/access-point/index.js",
     "./units/cert-manager": "./dist/units/cert-manager/index.js",
     "./units/cluster-patch": "./dist/units/cluster-patch/index.js",
     "./units/cluster-dns": "./dist/units/cluster-dns/index.js",
     "./units/dns01-issuer": "./dist/units/dns01-issuer/index.js",
     "./units/existing-cluster": "./dist/units/existing-cluster/index.js",
-    "./units/gateway-api": "./dist/units/gateway-api/index.js"
+    "./units/gateway-api": "./dist/units/gateway-api/index.js",
+    "./impl/gateway-route": "./dist/impl/gateway-route.js",
+    "./impl/tls-certificate": "./dist/impl/tls-certificate.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "highstate build",
-    "update-charts": "../../scripts/update-charts.sh ./assets/charts.json",
-    "update-images": "../../scripts/update-images.sh ./assets/images.json",
+    "update-charts": "../../../scripts/update-charts.sh ./assets/charts.json",
+    "update-images": "../../../scripts/update-images.sh ./assets/images.json",
     "generate-crds": "./scripts/generate-crds.sh"
   },
   "dependencies": {
-    "@highstate/cert-manager": "^0.9.16",
-    "@highstate/common": "^0.9.16",
-    "@highstate/contract": "^0.9.16",
-    "@highstate/gateway-api": "^0.9.16",
-    "@highstate/library": "^0.9.16",
-    "@highstate/pulumi": "^0.9.16",
+    "@highstate/cert-manager": "^0.9.19",
+    "@highstate/common": "^0.9.19",
+    "@highstate/contract": "^0.9.19",
+    "@highstate/gateway-api": "^0.9.19",
+    "@highstate/library": "^0.9.19",
+    "@highstate/pulumi": "^0.9.19",
     "@kubernetes/client-node": "^1.1.0",
     "@pulumi/command": "^1.0.2",
     "@pulumi/kubernetes": "^4.18.0",
-    "@pulumi/pulumi": "^3.181.0",
+    "@pulumi/pulumi": "^3.184.0",
     "crypto-hash": "^3.1.0",
     "deepmerge-ts": "^7.1.5",
     "glob": "^11.0.1",
@@ -55,7 +80,8 @@
     "remeda": "^2.21.0"
   },
   "devDependencies": {
-    "@highstate/cli": "^0.9.16"
+    "@highstate/cli": "^0.9.19",
+    "type-fest": "^4.41.0"
   },
-  "gitHead": "458d6f1f9f6d4aec0ba75a2b2c4c01408cb9c8df"
+  "gitHead": "e77d292335556c6e5b6275acda1a3d1609d786a1"
 }

package/src/cluster.ts

@@ -1,6 +1,6 @@
 import type { k8s } from "@highstate/library"
-import { text } from "@highstate/contract"
-import { secret, type Input, type InstanceTerminal } from "@highstate/pulumi"
+import { text, type UnitTerminal } from "@highstate/contract"
+import { fileFromString, output, type Output, type Input } from "@highstate/pulumi"
 import { CoreV1Api, type KubeConfig } from "@kubernetes/client-node"
 import { images } from "./shared"
 
@@ -39,32 +39,40 @@ export async function detectExternalIps(
   })
 }
 
-export function createK8sTerminal(kubeconfig: Input<string>): InstanceTerminal {
-  return {
+export function createK8sTerminal(kubeconfig: Input<string>): Output<UnitTerminal> {
+  return output({
     name: "management",
-    title: "Cluster Management",
-    description: "Manage the cluster using kubectl and helm",
-    icon: "devicon:kubernetes",
 
-    image: images["terminal-kubectl"].image,
-    command: ["bash", "/welcome.sh"],
+    meta: {
+      title: "Cluster Management",
+      description: "Manage the cluster using kubectl and helm",
+      icon: "devicon:kubernetes",
+    },
 
-    files: {
-      "/kubeconfig": secret(kubeconfig),
+    spec: {
+      image: images["terminal-kubectl"].image,
+      command: ["bash", "/welcome.sh"],
 
-      "/welcome.sh": text`
-        echo "Connecting to the cluster..."
-        kubectl cluster-info
+      files: {
+        "/kubeconfig": fileFromString("kubeconfig", kubeconfig, { isSecret: true }),
 
-        echo "Use 'kubectl' and 'helm' to manage the cluster."
-        echo
+        "/welcome.sh": fileFromString(
+          "welcome.sh",
+          text`
+            echo "Connecting to the cluster..."
+            kubectl cluster-info
 
-        exec bash
-      `,
-    },
+            echo "Use 'kubectl' and 'helm' to manage the cluster."
+            echo
 
-    env: {
-      KUBECONFIG: "/kubeconfig",
+            exec bash
+          `,
+        ),
+      },
+
+      env: {
+        KUBECONFIG: "/kubeconfig",
+      },
     },
-  }
+  })
 }

package/src/config-map.ts

@@ -1,50 +1,61 @@
 import type { k8s } from "@highstate/library"
+import { getOrCreate } from "@highstate/contract"
+import { toPromise } from "@highstate/pulumi"
 import { core, type types } from "@pulumi/kubernetes"
 import {
-  ComponentResource,
-  output,
-  Output,
   type ComponentResourceOptions,
   type Input,
   type Inputs,
+  interpolate,
+  type Output,
+  output,
 } from "@pulumi/pulumi"
-import { getProvider, mapMetadata, withPatchName, type CommonArgs } from "./shared"
+import { Namespace } from "./namespace"
+import { getProvider, mapMetadata, ScopedResource, type ScopedResourceArgs } from "./shared"
 
-export type ConfigMapArgs = CommonArgs &
+export type ConfigMapArgs = ScopedResourceArgs &
   Omit<types.input.core.v1.ConfigMap, "kind" | "metadata" | "apiVersion">
 
-export type CreateOrPatchConfigMapArgs = ConfigMapArgs & {
+export type CreateOrGetConfigMapArgs = ConfigMapArgs & {
   /**
-   * The resource to use to determine the name of the config map.
-   *
-   * If not provided, the config map will be created, otherwise it will be retrieved/patched.
+   * The config map entity to patch/retrieve.
    */
-  existing: Input<k8s.Resource> | undefined
+  existing: Input<k8s.ScopedResource> | undefined
 }
 
-export abstract class ConfigMap extends ComponentResource {
+/**
+ * Represents a Kubernetes ConfigMap resource with metadata and data.
+ */
+export abstract class ConfigMap extends ScopedResource {
   protected constructor(
     type: string,
     name: string,
     args: Inputs,
     opts: ComponentResourceOptions | undefined,
 
-    /**
-     * The cluster where the config map is created.
-     */
-    readonly cluster: Output<k8s.Cluster>,
-
-    /**
-     * The metadata of the underlying Kubernetes config map.
-     */
-    readonly metadata: Output<types.output.meta.v1.ObjectMeta>,
+    apiVersion: Output<string>,
+    kind: Output<string>,
+    namespace: Output<Namespace>,
+    metadata: Output<types.output.meta.v1.ObjectMeta>,
 
     /**
      * The data of the underlying Kubernetes config map.
      */
     readonly data: Output<Record<string, string>>,
   ) {
-    super(type, name, args, opts)
+    super(type, name, args, opts, apiVersion, kind, namespace, metadata)
+  }
+
+  /**
+   * The Highstate config map entity.
+   */
+  get entity(): Output<k8s.ScopedResource> {
+    return output({
+      type: "config-map",
+      clusterId: this.cluster.id,
+      clusterName: this.cluster.name,
+      metadata: this.metadata,
+    })
   }
 
   /**
@@ -57,26 +68,66 @@ export abstract class ConfigMap extends ComponentResource {
   /**
    * Creates a new config map or patches an existing one.
    *
-   * Will throw an error if the config map does not exist when `args.resource` is provided.
+   * @param name The name of the resource. May not be the same as the config map name.
+   * @param args The arguments to create or patch the config map with.
+   * @param opts Optional resource options.
    */
   static createOrPatch(
     name: string,
-    args: CreateOrPatchConfigMapArgs,
+    args: CreateOrGetConfigMapArgs,
     opts?: ComponentResourceOptions,
   ): ConfigMap {
-    if (!args.existing) {
-      return new CreatedConfigMap(name, args, opts)
+    if (args.existing) {
+      return new ConfigMapPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+      })
     }
 
-    return new ConfigMapPatch(
-      name,
-      {
-        ...args,
-        name: withPatchName("configmap", args.existing, args.cluster),
-        namespace: output(args.existing).metadata.namespace,
-      },
-      opts,
-    )
+    return new CreatedConfigMap(name, args, opts)
+  }
+
+  /**
+   * Creates a new config map or gets an existing one.
+   *
+   * @param name The name of the resource. May not be the same as the config map name. Will not be used when existing config map is retrieved.
+   * @param args The arguments to create or get the config map with.
+   * @param opts Optional resource options.
+   */
+  static async createOrGet(
+    name: string,
+    args: CreateOrGetConfigMapArgs,
+    opts?: ComponentResourceOptions,
+  ): Promise<ConfigMap> {
+    if (args.existing) {
+      return await ConfigMap.forAsync(args.existing, output(args.namespace).cluster)
+    }
+
+    return new CreatedConfigMap(name, args, opts)
+  }
+
+  /**
+   * Patches an existing config map.
+   *
+   * Will throw an error if the config map does not exist.
+   *
+   * @param name The name of the resource. May not be the same as the config map name.
+   * @param args The arguments to patch the config map with.
+   * @param opts Optional resource options.
+   */
+  static patch(name: string, args: ConfigMapArgs, opts?: ComponentResourceOptions): ConfigMap {
+    return new ConfigMapPatch(name, args, opts)
+  }
+
+  /**
+   * Wraps an existing Kubernetes config map.
+   */
+  static wrap(
+    name: string,
+    args: WrappedConfigMapArgs,
+    opts?: ComponentResourceOptions,
+  ): ConfigMap {
+    return new WrappedConfigMap(name, args, opts)
   }
 
   /**
@@ -86,17 +137,61 @@ export abstract class ConfigMap extends ComponentResource {
    */
   static get(
     name: string,
-    id: Input<string>,
-    cluster: Input<k8s.Cluster>,
+    args: ExternalConfigMapArgs,
     opts?: ComponentResourceOptions,
   ): ConfigMap {
-    return new ExternalConfigMap(name, id, cluster, opts)
+    return new ExternalConfigMap(name, args, opts)
+  }
+
+  private static readonly configMapCache = new Map<string, ConfigMap>()
+
+  /**
+   * Gets an existing config map for a given entity.
+   * Prefer this method over `get` when possible.
+   *
+   * It automatically names the resource with the following format: `{clusterName}.{namespace}.{name}.{clusterId}`.
+   *
+   * This method is idempotent and will return the same instance for the same entity.
+   *
+   * @param entity The entity to get the config map for.
+   * @param cluster The cluster where the config map is located.
+   */
+  static for(entity: k8s.ScopedResource, cluster: Input<k8s.Cluster>): ConfigMap {
+    return getOrCreate(
+      ConfigMap.configMapCache,
+      `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`,
+      name => {
+        return ConfigMap.get(name, {
+          name: entity.metadata.name,
+          namespace: Namespace.forResource(entity, cluster),
+        })
+      },
+    )
+  }
+
+  /**
+   * Gets an existing config map for a given entity.
+   * Prefer this method over `get` when possible.
+   *
+   * It automatically names the resource with the following format: `{clusterName}.{namespace}.{name}.{clusterId}`.
+   *
+   * This method is idempotent and will return the same instance for the same entity.
+   *
+   * @param entity The entity to get the config map for.
+   * @param cluster The cluster where the config map is located.
+   */
+  static async forAsync(
+    entity: Input<k8s.ScopedResource>,
+    cluster: Input<k8s.Cluster>,
+  ): Promise<ConfigMap> {
+    const resolvedEntity = await toPromise(entity)
+    return ConfigMap.for(resolvedEntity, cluster)
   }
 }
 
 class CreatedConfigMap extends ConfigMap {
   constructor(name: string, args: ConfigMapArgs, opts?: ComponentResourceOptions) {
-    const configMap = output(args).apply(async args => {
+    const configMap = output(args.namespace).cluster.apply(cluster => {
       return new core.v1.ConfigMap(
         name,
         {
@@ -106,7 +201,7 @@ class CreatedConfigMap extends ConfigMap {
         {
           ...opts,
           parent: this,
-          provider: await getProvider(args.cluster),
+          provider: getProvider(cluster),
         },
       )
     })
@@ -116,7 +211,9 @@ class CreatedConfigMap extends ConfigMap {
       name,
       args,
       opts,
-      output(args.cluster),
+      configMap.apiVersion,
+      configMap.kind,
+      output(args.namespace),
       configMap.metadata,
       configMap.data,
     )
@@ -125,7 +222,7 @@ class CreatedConfigMap extends ConfigMap {
 
 class ConfigMapPatch extends ConfigMap {
   constructor(name: string, args: ConfigMapArgs, opts?: ComponentResourceOptions) {
-    const configMap = output(args).apply(async args => {
+    const configMap = output(args.namespace).cluster.apply(cluster => {
       return new core.v1.ConfigMapPatch(
         name,
         {
@@ -135,7 +232,7 @@ class ConfigMapPatch extends ConfigMap {
         {
           ...opts,
           parent: this,
-          provider: await getProvider(args.cluster),
+          provider: getProvider(cluster),
         },
       )
     })
@@ -145,34 +242,75 @@ class ConfigMapPatch extends ConfigMap {
       name,
       args,
       opts,
-      output(args.cluster),
+      configMap.apiVersion,
+      configMap.kind,
+      output(args.namespace),
       configMap.metadata,
       configMap.data,
     )
   }
 }
 
+export type WrappedConfigMapArgs = {
+  /**
+   * The underlying Kubernetes config map to wrap.
+   */
+  configMap: Input<core.v1.ConfigMap>
+
+  /**
+   * The namespace where the config map is located.
+   */
+  namespace: Input<Namespace>
+}
+
+class WrappedConfigMap extends ConfigMap {
+  constructor(name: string, args: WrappedConfigMapArgs, opts?: ComponentResourceOptions) {
+    super(
+      "highstate:k8s:WrappedConfigMap",
+      name,
+      args,
+      opts,
+
+      output(args.configMap).apiVersion,
+      output(args.configMap).kind,
+      output(args.namespace),
+      output(args.configMap).metadata,
+      output(args.configMap).data,
+    )
+  }
+}
+
+export type ExternalConfigMapArgs = {
+  /**
+   * The name of the config map to get.
+   */
+  name: Input<string>
+
+  /**
+   * The namespace where the config map is located.
+   */
+  namespace: Input<Namespace>
+}
+
 class ExternalConfigMap extends ConfigMap {
-  constructor(
-    name: string,
-    id: Input<string>,
-    cluster: Input<k8s.Cluster>,
-    opts?: ComponentResourceOptions,
-  ) {
-    const configMap = output(id).apply(async realName => {
-      return core.v1.ConfigMap.get(name, realName, {
-        ...opts,
-        parent: this,
-        provider: await getProvider(cluster),
-      })
+  constructor(name: string, args: ExternalConfigMapArgs, opts?: ComponentResourceOptions) {
+    const configMap = output(args.namespace).cluster.apply(cluster => {
+      return core.v1.ConfigMap.get(
+        name,
+        interpolate`${output(args.namespace).metadata.name}/${args.name}`,
+        { ...opts, parent: this, provider: getProvider(cluster) },
+      )
     })
 
     super(
       "highstate:k8s:ExternalConfigMap",
       name,
-      { id, cluster },
+      args,
       opts,
-      output(cluster),
+
+      configMap.apiVersion,
+      configMap.kind,
+      output(args.namespace),
       configMap.metadata,
       configMap.data,
     )

package/src/container.ts

@@ -1,18 +1,18 @@
 import type { PartialKeys } from "@highstate/contract"
 import type { k8s, network } from "@highstate/library"
-import { core, type types } from "@pulumi/kubernetes"
 import {
-  normalize,
-  Output,
-  output,
   type Input,
   type InputArray,
+  normalize,
+  type Output,
+  output,
   type Unwrap,
 } from "@highstate/pulumi"
+import { core, type types } from "@pulumi/kubernetes"
 import { concat, map, omit } from "remeda"
+import { ConfigMap } from "./config-map"
 import { PersistentVolumeClaim } from "./pvc"
 import { Secret } from "./secret"
-import { ConfigMap } from "./config-map"
 
 export type Container = Omit<PartialKeys<types.input.core.v1.Container, "name">, "volumeMounts"> & {
   /**