@highstate/k8s 0.9.18 → 0.9.19

package/src/deployment.ts

@@ -1,23 +1,30 @@
+import type { AccessPointRoute } from "@highstate/common"
 import type { k8s } from "@highstate/library"
-import type { HttpRoute } from "./gateway"
-import type { Service } from "./service"
+import type { Container } from "./container"
 import type { NetworkPolicy } from "./network-policy"
-import { output, type ComponentResourceOptions, Output, type Input } from "@highstate/pulumi"
-import { apps, types } from "@pulumi/kubernetes"
-import { omit } from "remeda"
-import { deepmerge } from "deepmerge-ts"
+import type { Service } from "./service"
+import { getOrCreate, type UnitTerminal } from "@highstate/contract"
 import {
-  getProvider,
-  mapMetadata,
-  resourceIdToString,
-  withPatchName,
-  type ResourceId,
-} from "./shared"
+  type ComponentResourceOptions,
+  type Input,
+  type Inputs,
+  interpolate,
+  type Output,
+  output,
+  toPromise,
+  type Unwrap,
+} from "@highstate/pulumi"
+import { apps, type types } from "@pulumi/kubernetes"
+import { deepmerge } from "deepmerge-ts"
+import { omit } from "remeda"
+import { Namespace } from "./namespace"
+import { getProvider, mapMetadata } from "./shared"
 import {
-  exposableWorkloadExtraArgs,
   ExposableWorkload,
   type ExposableWorkloadArgs,
+  exposableWorkloadExtraArgs,
   getExposableWorkloadComponents,
+  type WorkloadTerminalArgs,
 } from "./workload"
 
 export type DeploymentArgs = Omit<ExposableWorkloadArgs, "existing"> &
@@ -39,11 +46,19 @@ export abstract class Deployment extends ExposableWorkload {
   protected constructor(
     type: string,
     name: string,
-    args: ExposableWorkloadArgs,
+    args: Inputs,
     opts: ComponentResourceOptions | undefined,
 
-    cluster: Output<k8s.Cluster>,
+    apiVersion: Output<string>,
+    kind: Output<string>,
+    terminalArgs: Output<Unwrap<WorkloadTerminalArgs>>,
+    containers: Output<Container[]>,
+    namespace: Output<Namespace>,
     metadata: Output<types.output.meta.v1.ObjectMeta>,
+    networkPolicy: Output<NetworkPolicy | undefined>,
+
+    service: Output<Service | undefined>,
+    routes: Output<AccessPointRoute[]>,
 
     /**
      * The spec of the underlying Kubernetes deployment.
@@ -54,111 +69,199 @@ export abstract class Deployment extends ExposableWorkload {
      * The status of the underlying Kubernetes deployment.
      */
     readonly status: Output<types.output.apps.v1.DeploymentStatus>,
-
-    networkPolicy: Output<NetworkPolicy | undefined>,
-
-    service: Output<Service | undefined>,
-    httpRoute: Output<HttpRoute | undefined>,
   ) {
     super(
       type,
       name,
       args,
       opts,
-      "deployment",
-      cluster,
+      apiVersion,
+      kind,
+      terminalArgs,
+      containers,
+      namespace,
       metadata,
       networkPolicy,
       service,
-      httpRoute,
+      routes,
     )
   }
 
+  protected override getTerminalMeta(): Output<UnitTerminal["meta"]> {
+    return output({
+      title: "Deployment",
+      globalTitle: interpolate`Deployment | ${this.metadata.name}`,
+      description: "The shell inside the deployment.",
+      icon: "devicon:kubernetes",
+    })
+  }
+
   /**
    * The Highstate deployment entity.
    */
   get entity(): Output<k8s.Deployment> {
     return output({
-      type: "k8s.deployment",
+      type: "deployment",
       clusterId: this.cluster.id,
+      clusterName: this.cluster.name,
       metadata: this.metadata,
       service: this._service.apply(service => service?.entity),
     })
   }
 
+  /**
+   * Creates a new deployment.
+   */
   static create(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions): Deployment {
     return new CreatedDeployment(name, args, opts)
   }
 
+  /**
+   * Creates a new deployment or patches an existing one.
+   *
+   * @param name The name of the resource. May not be the same as the deployment name.
+   * @param args The arguments to create or patch the deployment with.
+   * @param opts Optional resource options.
+   */
   static createOrPatch(
     name: string,
     args: CreateOrGetDeploymentArgs,
     opts?: ComponentResourceOptions,
   ): Deployment {
-    if (!args.existing) {
-      return new CreatedDeployment(name, args, opts)
+    if (args.existing) {
+      return new DeploymentPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster),
+      })
     }
 
-    return new DeploymentPatch(
-      name,
-      {
-        ...args,
-        name: withPatchName("deployment", args.existing, args.cluster),
-        namespace: output(args.existing).metadata.namespace,
-      },
-      opts,
-    )
+    return new CreatedDeployment(name, args, opts)
+  }
+
+  /**
+   * Creates a new deployment or gets an existing one.
+   *
+   * @param name The name of the resource. May not be the same as the deployment name. Will not be used when existing deployment is retrieved.
+   * @param args The arguments to create or get the deployment with.
+   * @param opts Optional resource options.
+   */
+  static async createOrGet(
+    name: string,
+    args: CreateOrGetDeploymentArgs,
+    opts?: ComponentResourceOptions,
+  ): Promise<Deployment> {
+    if (args.existing) {
+      return await Deployment.forAsync(args.existing, output(args.namespace).cluster)
+    }
+
+    return new CreatedDeployment(name, args, opts)
   }
 
+  /**
+   * Patches an existing deployment.
+   *
+   * Will throw an error if the deployment does not exist.
+   *
+   * @param name The name of the resource. May not be the same as the deployment name.
+   * @param args The arguments to patch the deployment with.
+   * @param opts Optional resource options.
+   */
   static patch(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions): Deployment {
     return new DeploymentPatch(name, args, opts)
   }
 
-  static createOrGet(
+  /**
+   * Wraps an existing Kubernetes deployment.
+   */
+  static wrap(
     name: string,
-    args: CreateOrGetDeploymentArgs,
+    args: WrappedDeploymentArgs,
     opts?: ComponentResourceOptions,
   ): Deployment {
-    if (!args.existing) {
-      return new CreatedDeployment(name, args, opts)
-    }
-
-    return new ExternalDeployment(name, output(args.existing).metadata, args.cluster, opts)
+    return new WrappedDeployment(name, args, opts)
   }
 
-  static wrap(
+  /**
+   * Gets an existing deployment.
+   *
+   * Will throw an error if the deployment does not exist.
+   */
+  static get(
     name: string,
-    deployment: Input<apps.v1.Deployment>,
-    cluster: Input<k8s.Cluster>,
+    args: ExternalDeploymentArgs,
     opts?: ComponentResourceOptions,
   ): Deployment {
-    return new WrappedDeployment(name, deployment, cluster, opts)
+    return new ExternalDeployment(name, args, opts)
+  }
+
+  private static readonly deploymentCache = new Map<string, Deployment>()
+
+  /**
+   * Gets an existing deployment 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 deployment for.
+   * @param cluster The cluster where the deployment is located.
+   */
+  static for(entity: k8s.Deployment, cluster: Input<k8s.Cluster>): Deployment {
+    return getOrCreate(
+      Deployment.deploymentCache,
+      `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`,
+      name => {
+        return Deployment.get(name, {
+          name: entity.metadata.name,
+          namespace: Namespace.forResource(entity, cluster),
+        })
+      },
+    )
+  }
+
+  /**
+   * Gets an existing deployment 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 deployment for.
+   * @param cluster The cluster where the deployment is located.
+   */
+  static async forAsync(
+    entity: Input<k8s.Deployment>,
+    cluster: Input<k8s.Cluster>,
+  ): Promise<Deployment> {
+    const resolvedEntity = await toPromise(entity)
+    return Deployment.for(resolvedEntity, cluster)
   }
 }
 
 class CreatedDeployment extends Deployment {
   constructor(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions) {
-    const { labels, podTemplate, networkPolicy, service, httpRoute } =
+    const { labels, podTemplate, networkPolicy, containers, service, routes } =
       getExposableWorkloadComponents(name, args, () => this, opts)
 
-    const deployment = output({ args, podTemplate }).apply(async ({ args, podTemplate }) => {
+    const deployment = output(args.namespace).cluster.apply(cluster => {
       return new apps.v1.Deployment(
         name,
         {
           metadata: mapMetadata(args, name),
-          spec: deepmerge(
-            {
-              template: podTemplate,
-              selector: { matchLabels: labels },
-            },
-            omit(args, exposableWorkloadExtraArgs),
-          ) as types.input.apps.v1.DeploymentSpec,
-        },
-        {
-          ...opts,
-          parent: this,
-          provider: await getProvider(args.cluster),
+          spec: output({ args, podTemplate, labels }).apply(({ args, podTemplate, labels }) => {
+            return deepmerge(
+              {
+                template: podTemplate,
+                selector: { matchLabels: labels },
+              },
+              omit(args, exposableWorkloadExtraArgs),
+            ) as types.input.apps.v1.DeploymentSpec
+          }),
         },
+        { ...opts, parent: this, provider: getProvider(cluster) },
       )
     })
 
@@ -168,45 +271,47 @@ class CreatedDeployment extends Deployment {
       args,
       opts,
 
-      output(args.cluster),
+      deployment.apiVersion,
+      deployment.kind,
+      output(args.terminal ?? {}),
+      containers,
+      output(args.namespace),
       deployment.metadata,
-      deployment.spec,
-      deployment.status,
-
       networkPolicy,
+
       service,
-      httpRoute,
+      routes,
+
+      deployment.spec,
+      deployment.status,
     )
   }
 }
 
 class DeploymentPatch extends Deployment {
   constructor(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions) {
-    const { podSpec, networkPolicy, service, httpRoute } = getExposableWorkloadComponents(
-      name,
-      args,
-      () => this,
-      opts,
-    )
+    const { labels, podTemplate, networkPolicy, containers, service, routes } =
+      getExposableWorkloadComponents(name, args, () => this, opts)
 
-    const deployment = output({ args, podSpec }).apply(async ({ args, podSpec }) => {
+    const deployment = output(args.namespace).cluster.apply(cluster => {
       return new apps.v1.DeploymentPatch(
         name,
         {
           metadata: mapMetadata(args, name),
-          spec: deepmerge(
-            {
-              template: {
-                spec: podSpec,
+          spec: output({ args, podTemplate, labels }).apply(({ args, podTemplate, labels }) => {
+            return deepmerge(
+              {
+                template: podTemplate,
+                selector: { matchLabels: labels },
               },
-            },
-            omit(args, exposableWorkloadExtraArgs),
-          ) as types.input.apps.v1.DeploymentSpec,
+              omit(args, exposableWorkloadExtraArgs),
+            ) as types.input.apps.v1.DeploymentSpec
+          }),
         },
         {
           ...opts,
           parent: this,
-          provider: await getProvider(args.cluster),
+          provider: getProvider(cluster),
         },
       )
     })
@@ -217,71 +322,106 @@ class DeploymentPatch extends Deployment {
       args,
       opts,
 
-      output(args.cluster),
+      deployment.apiVersion,
+      deployment.kind,
+      output(args.terminal ?? {}),
+      containers,
+      output(args.namespace),
       deployment.metadata,
-      deployment.spec,
-      deployment.status,
-
       networkPolicy,
+
       service,
-      httpRoute,
+      routes,
+
+      deployment.spec,
+      deployment.status,
     )
   }
 }
 
-class ExternalDeployment extends Deployment {
-  constructor(
-    name: string,
-    id: Input<ResourceId>,
-    cluster: Input<k8s.Cluster>,
-    opts?: ComponentResourceOptions,
-  ) {
-    const deployment = output(id).apply(async id => {
-      return apps.v1.Deployment.get(name, resourceIdToString(id), {
-        ...opts,
-        parent: this,
-        provider: await getProvider(cluster),
-      })
-    })
+export type WrappedDeploymentArgs = {
+  /**
+   * The underlying Kubernetes deployment to wrap.
+   */
+  deployment: Input<apps.v1.Deployment>
+
+  /**
+   * The namespace where the deployment is located.
+   */
+  namespace: Input<Namespace>
+
+  /**
+   * The args for the terminal to use.
+   */
+  terminal?: Input<WorkloadTerminalArgs>
+}
 
+class WrappedDeployment extends Deployment {
+  constructor(name: string, args: WrappedDeploymentArgs, opts?: ComponentResourceOptions) {
     super(
-      "highstate:k8s:ExternalDeployment",
+      "highstate:k8s:WrappedDeployment",
       name,
-      { namespace: output(id).namespace, cluster },
+      args,
       opts,
-      output(cluster),
-      deployment.metadata,
-      deployment.spec,
-      deployment.status,
+
+      output(args.deployment).apiVersion,
+      output(args.deployment).kind,
+      output(args.terminal ?? {}),
+      output([]),
+      output(args.namespace),
+      output(args.deployment).metadata,
 
       output(undefined),
       output(undefined),
-      output(undefined),
+      output([]),
+
+      output(args.deployment).spec,
+      output(args.deployment).status,
     )
   }
 }
 
-class WrappedDeployment extends Deployment {
-  constructor(
-    name: string,
-    deployment: Input<apps.v1.Deployment>,
-    cluster: Input<k8s.Cluster>,
-    opts?: ComponentResourceOptions,
-  ) {
+export type ExternalDeploymentArgs = {
+  /**
+   * The name of the deployment to get.
+   */
+  name: Input<string>
+
+  /**
+   * The namespace where the deployment is located.
+   */
+  namespace: Input<Namespace>
+}
+
+class ExternalDeployment extends Deployment {
+  constructor(name: string, args: ExternalDeploymentArgs, opts?: ComponentResourceOptions) {
+    const deployment = output(args.namespace).cluster.apply(cluster => {
+      return apps.v1.Deployment.get(
+        name,
+        interpolate`${output(args.namespace).metadata.name}/${args.name}`,
+        { ...opts, parent: this, provider: getProvider(cluster) },
+      )
+    })
+
     super(
-      "highstate:k8s:WrappedDeployment",
+      "highstate:k8s:ExternalDeployment",
       name,
-      { namespace: output(deployment).metadata.namespace, cluster },
+      args,
       opts,
 
-      output(cluster),
-      output(deployment).metadata,
-      output(deployment).spec,
-      output(deployment).status,
+      deployment.apiVersion,
+      deployment.kind,
+      output({}),
+      output([]),
+      output(args.namespace),
+      deployment.metadata,
 
       output(undefined),
       output(undefined),
-      output(undefined),
+      output([]),
+
+      deployment.spec,
+      deployment.status,
     )
   }
 }

package/src/dns01-solver.ts

@@ -0,0 +1,10 @@
+import type { types } from "@highstate/cert-manager"
+import { ImplementationMediator } from "@highstate/common"
+import { z } from "@highstate/contract"
+import type { Namespace } from "./namespace"
+
+export const dns01SolverMediator = new ImplementationMediator(
+  "dns01-solver",
+  z.object({ namespace: z.custom<Namespace>() }),
+  z.custom<types.input.cert_manager.v1.ClusterIssuerSpecAcmeSolversDns01>(),
+)

package/src/gateway/backend.ts

@@ -1,5 +1,5 @@
-import { core } from "@pulumi/kubernetes"
-import { type Input, output, Output, type Unwrap } from "@highstate/pulumi"
+import type { core } from "@pulumi/kubernetes"
+import { type Input, output, type Output, type Unwrap } from "@highstate/pulumi"
 import { Service } from "../service"
 
 export interface FullBackendRef {