@highstate/k8s 0.9.4 → 0.9.5

package/src/deployment.ts

@@ -1,62 +1,49 @@
 import type { k8s } from "@highstate/library"
 import type { HttpRoute } from "./gateway"
 import type { Service } from "./service"
-import {
-  output,
-  type ComponentResourceOptions,
-  Output,
-  type Inputs,
-  ComponentResource,
-  type InputArray,
-  Resource,
-  type Input,
-  type InstanceTerminal,
-  interpolate,
-} from "@highstate/pulumi"
+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 { trimIndentation } from "@highstate/contract"
-import { mapMetadata, verifyProvider } from "./shared"
-import { mapContainerToRaw } from "./container"
 import {
-  getPublicWorkloadComponents,
-  publicWorkloadExtraArgs,
-  type PublicWorkloadArgs,
+  getProvider,
+  mapMetadata,
+  resourceIdToString,
+  withPatchName,
+  type ResourceId,
+} from "./shared"
+import {
+  exposableWorkloadExtraArgs,
+  ExposableWorkload,
+  type ExposableWorkloadArgs,
+  getExposableWorkloadComponents,
 } from "./workload"
 
-export type DeploymentArgs = Omit<PublicWorkloadArgs, "patch"> & {
-  patch?: Input<k8s.Deployment>
-
-  /**
-   * The shell to use in the terminal.
-   *
-   * By default, `bash` is used.
-   */
-  terminalShell?: string
-} & Omit<Partial<types.input.apps.v1.DeploymentSpec>, "template"> & {
+export type DeploymentArgs = Omit<ExposableWorkloadArgs, "existing"> &
+  Omit<Partial<types.input.apps.v1.DeploymentSpec>, "template"> & {
     template?: {
       metadata?: types.input.meta.v1.ObjectMeta
       spec?: Partial<types.input.core.v1.PodSpec>
     }
   }
 
-export abstract class Deployment extends ComponentResource {
+export type CreateOrGetDeploymentArgs = DeploymentArgs & {
+  /**
+   * The entity to use to determine the deployment to patch.
+   */
+  existing: Input<k8s.Deployment> | undefined
+}
+
+export abstract class Deployment extends ExposableWorkload {
   protected constructor(
     type: string,
     name: string,
-    private readonly args: Inputs,
-    opts: ComponentResourceOptions,
-
-    /**
-     * The cluster where the deployment is created.
-     */
-    readonly cluster: Output<k8s.Cluster>,
+    args: ExposableWorkloadArgs,
+    opts: ComponentResourceOptions | undefined,
 
-    /**
-     * The metadata of the underlying Kubernetes deployment.
-     */
-    readonly metadata: Output<types.output.meta.v1.ObjectMeta>,
+    cluster: Output<k8s.Cluster>,
+    metadata: Output<types.output.meta.v1.ObjectMeta>,
 
     /**
      * The spec of the underlying Kubernetes deployment.
@@ -68,15 +55,23 @@ export abstract class Deployment extends ComponentResource {
      */
     readonly status: Output<types.output.apps.v1.DeploymentStatus>,
 
-    private readonly _service: Output<Service | undefined>,
-    private readonly _httpRoute: Output<HttpRoute | undefined>,
+    networkPolicy: Output<NetworkPolicy | undefined>,
 
-    /**
-     * The resources associated with the deployment.
-     */
-    readonly resources: InputArray<Resource>,
+    service: Output<Service | undefined>,
+    httpRoute: Output<HttpRoute | undefined>,
   ) {
-    super(type, name, args, opts)
+    super(
+      type,
+      name,
+      args,
+      opts,
+      "deployment",
+      cluster,
+      metadata,
+      networkPolicy,
+      service,
+      httpRoute,
+    )
   }
 
   /**
@@ -85,113 +80,130 @@ export abstract class Deployment extends ComponentResource {
   get entity(): Output<k8s.Deployment> {
     return output({
       type: "k8s.deployment",
-      clusterInfo: this.cluster.info,
+      clusterId: this.cluster.id,
       metadata: this.metadata,
-      spec: this.spec,
       service: this._service.apply(service => service?.entity),
     })
   }
 
-  get optionalService(): Output<Service | undefined> {
-    return this._service
+  static create(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions): Deployment {
+    return new CreatedDeployment(name, args, opts)
   }
 
-  /**
-   * The service associated with the deployment.
-   */
-  get service(): Output<Service> {
-    return this._service.apply(service => {
-      if (!service) {
-        throw new Error("The service is not available.")
-      }
+  static createOrPatch(
+    name: string,
+    args: CreateOrGetDeploymentArgs,
+    opts?: ComponentResourceOptions,
+  ): Deployment {
+    if (!args.existing) {
+      return new CreatedDeployment(name, args, opts)
+    }
 
-      return service
-    })
+    return new DeploymentPatch(
+      name,
+      {
+        ...args,
+        name: withPatchName("deployment", args.existing, args.cluster),
+        namespace: output(args.existing).metadata.namespace,
+      },
+      opts,
+    )
   }
 
-  /**
-   * The HTTP route associated with the deployment.
-   */
-  get httpRoute(): Output<HttpRoute> {
-    return this._httpRoute.apply(httpRoute => {
-      if (!httpRoute) {
-        throw new Error("The HTTP route is not available.")
-      }
+  static patch(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions): Deployment {
+    return new DeploymentPatch(name, args, opts)
+  }
 
-      return httpRoute
-    })
+  static createOrGet(
+    name: string,
+    args: CreateOrGetDeploymentArgs,
+    opts?: ComponentResourceOptions,
+  ): Deployment {
+    if (!args.existing) {
+      return new CreatedDeployment(name, args, opts)
+    }
+
+    return new ExternalDeployment(name, output(args.existing).metadata, args.cluster, opts)
   }
+}
 
-  /**
-   * The instance terminal to interact with the deployment.
-   */
-  get terminal(): Output<InstanceTerminal> {
-    return output({
-      name: this.metadata.name,
-      title: this.metadata.name,
-      image: "ghcr.io/exeteres/highstate/terminal-kubectl",
-      command: ["script", "-q", "-c", "/enter-container.sh", "/dev/null"],
-      files: {
-        "/kubeconfig": this.cluster.kubeconfig,
-
-        "/enter-container.sh": {
-          mode: 0o755,
-          content: interpolate`
-            #!/bin/bash
-
-            exec kubectl exec -it -n ${this.metadata.namespace} deployment/${this.metadata.name} -- ${this.args.terminalShell ?? "bash"}
-          `.apply(trimIndentation),
+class CreatedDeployment extends Deployment {
+  constructor(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions) {
+    const { labels, podTemplate, networkPolicy, service, httpRoute } =
+      getExposableWorkloadComponents(name, args, () => this, opts)
+
+    const deployment = output({ args, podTemplate }).apply(async ({ args, podTemplate }) => {
+      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,
         },
-      },
-      env: {
-        KUBECONFIG: "/kubeconfig",
-      },
+        {
+          ...opts,
+          parent: this,
+          provider: await getProvider(args.cluster),
+        },
+      )
     })
-  }
 
-  static create(name: string, args: DeploymentArgs, opts: ComponentResourceOptions): Deployment {
-    return new CreatedDeployment(name, args, opts)
+    super(
+      "highstate:k8s:Deployment",
+      name,
+      args,
+      opts,
+
+      output(args.cluster),
+      deployment.metadata,
+      deployment.spec,
+      deployment.status,
+
+      networkPolicy,
+      service,
+      httpRoute,
+    )
   }
 }
 
-class CreatedDeployment extends Deployment {
-  constructor(name: string, args: DeploymentArgs, opts: ComponentResourceOptions) {
-    const { labels, containers, volumes, service, httpRoute } = getPublicWorkloadComponents(
+class DeploymentPatch extends Deployment {
+  constructor(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions) {
+    const { podSpec, networkPolicy, service, httpRoute } = getExposableWorkloadComponents(
       name,
       args,
       () => this,
       opts,
     )
 
-    const deployment = output({ args, containers, volumes }).apply(
-      async ({ args, containers, volumes }) => {
-        await verifyProvider(opts.provider, args.cluster.info)
-
-        return new (args.patch ? apps.v1.DeploymentPatch : apps.v1.Deployment)(
-          name,
-          {
-            metadata: mapMetadata(args.patch?.metadata ?? args, name),
-            spec: deepmerge(
-              {
-                template: {
-                  metadata: !args.patch ? { labels } : undefined,
-                  spec: {
-                    containers: containers.map(container => mapContainerToRaw(container, name)),
-                    volumes,
-                  },
-                },
-                selector: !args.patch ? { matchLabels: labels } : undefined,
+    const deployment = output({ args, podSpec }).apply(async ({ args, podSpec }) => {
+      return new apps.v1.DeploymentPatch(
+        name,
+        {
+          metadata: mapMetadata(args, name),
+          spec: deepmerge(
+            {
+              template: {
+                spec: podSpec,
               },
-              omit(args, publicWorkloadExtraArgs),
-            ),
-          },
-          { parent: this, ...opts },
-        )
-      },
-    )
+            },
+            omit(args, exposableWorkloadExtraArgs),
+          ) as types.input.apps.v1.DeploymentSpec,
+        },
+        {
+          ...opts,
+          parent: this,
+          provider: await getProvider(args.cluster),
+        },
+      )
+    })
 
     super(
-      "highstate:k8s:Deployment",
+      "highstate:k8s:DeploymentPatch",
       name,
       args,
       opts,
@@ -201,10 +213,41 @@ class CreatedDeployment extends Deployment {
       deployment.spec,
       deployment.status,
 
+      networkPolicy,
       service,
       httpRoute,
+    )
+  }
+}
+
+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),
+      })
+    })
+
+    super(
+      "highstate:k8s:ExternalDeployment",
+      name,
+      { namespace: output(id).namespace, cluster },
+      opts,
+      output(cluster),
+      deployment.metadata,
+      deployment.spec,
+      deployment.status,
 
-      [deployment],
+      output(undefined),
+      output(undefined),
+      output(undefined),
     )
   }
 }

package/src/gateway/http-route.ts

@@ -9,7 +9,7 @@ import {
 } from "@highstate/pulumi"
 import { gateway, types } from "@highstate/gateway-api"
 import { map, pipe } from "remeda"
-import { mapMetadata, type CommonArgs } from "../shared"
+import { getProvider, mapMetadata, type CommonArgs } from "../shared"
 import { resolveBackendRef, type BackendRef } from "./backend"
 
 export type HttpRouteArgs = Omit<CommonArgs, "namespace"> & {
@@ -80,7 +80,7 @@ export class HttpRoute extends ComponentResource {
     this.route = output({
       args,
       gatewayNamespace: output(args.gateway).metadata.namespace,
-    }).apply(({ args, gatewayNamespace }) => {
+    }).apply(async ({ args, gatewayNamespace }) => {
       return new gateway.v1.HTTPRoute(
         name,
         {
@@ -114,11 +114,13 @@ export class HttpRoute extends ComponentResource {
             })),
           } satisfies types.input.gateway.v1.HTTPRouteSpec,
         },
-        { parent: this, ...opts },
+        {
+          ...opts,
+          parent: this,
+          provider: await getProvider(args.cluster),
+        },
       )
     })
-
-    this.registerOutputs({ route: this.route })
   }
 }
 

package/src/helm.ts

@@ -2,7 +2,7 @@ import type { k8s } from "@highstate/library"
 import { resolve } from "node:path"
 import { mkdir, readFile, unlink } from "node:fs/promises"
 import { toPromise, type InputMap } from "@highstate/pulumi"
-import { core, helm } from "@pulumi/kubernetes"
+import { core, helm, types } from "@pulumi/kubernetes"
 import {
   ComponentResource,
   output,
@@ -16,8 +16,8 @@ import { omit } from "remeda"
 import { local } from "@pulumi/command"
 import { glob } from "glob"
 import { HttpRoute, type HttpRouteArgs } from "./gateway"
-import { mapNamespaceLikeToNamespaceName, type NamespaceLike } from "./shared"
-import { Service } from "./service"
+import { getProvider, mapNamespaceLikeToNamespaceName, type NamespaceLike } from "./shared"
+import { getServiceType, Service, type ServiceArgs } from "./service"
 
 export type ChartArgs = Omit<
   helm.v4.ChartArgs,
@@ -35,6 +35,13 @@ export type ChartArgs = Omit<
    */
   serviceName?: string
 
+  /**
+   * The extra args to pass to the main service of the chart.
+   *
+   * Will be patched via transformations.
+   */
+  service?: Partial<ServiceArgs>
+
   /**
    * The manifest of the chart to resolve.
    */
@@ -69,18 +76,60 @@ export class Chart extends ComponentResource {
   ) {
     super("highstate:k8s:Chart", name, args, opts)
 
-    this.chart = output(args).apply(args => {
+    const namespace = output(args.namespace).apply(namespace =>
+      output(namespace ? mapNamespaceLikeToNamespaceName(namespace) : "default"),
+    )
+
+    this.chart = output({ args, namespace }).apply(async ({ args, namespace }) => {
       return new helm.v4.Chart(
         name,
         omit(
           {
             ...args,
             chart: resolveHelmChart(args.chart),
-            namespace: args.namespace ? mapNamespaceLikeToNamespaceName(args.namespace) : undefined,
+            namespace,
           },
           ["httpRoute"],
         ),
-        { parent: this, ...opts },
+        {
+          ...opts,
+          parent: this,
+          provider: await getProvider(args.cluster),
+
+          transforms: [
+            ...(opts?.transforms ?? []),
+
+            resourceArgs => {
+              const serviceName = args.serviceName ?? name
+              const expectedName = `${name}:${namespace}/${serviceName}`
+
+              if (
+                resourceArgs.type === "kubernetes:core/v1:Service" &&
+                resourceArgs.name === expectedName
+              ) {
+                const spec = resourceArgs.props.spec as types.input.core.v1.ServiceSpec
+
+                return {
+                  props: {
+                    ...resourceArgs.props,
+                    spec: {
+                      ...spec,
+                      ...(args.service ?? {}),
+
+                      type: getServiceType(args.service, args.cluster),
+
+                      externalIPs:
+                        args.service?.externalIPs ?? args.cluster.externalIps ?? spec.externalIPs,
+                    },
+                  },
+                  opts: resourceArgs.opts,
+                }
+              }
+
+              return undefined
+            },
+          ],
+        },
       )
     })
 
@@ -125,8 +174,8 @@ export class Chart extends ComponentResource {
         //
         resolvedName,
         service,
-        args.cluster.info,
-        { parent: this, ...this.opts },
+        args.cluster,
+        { ...this.opts, parent: this },
       )
 
       this.services.set(resolvedName, wrappedService)

package/src/index.ts

@@ -1,7 +1,5 @@
 export {
-  getProvider as createProvider,
-  createNamespace,
-  getNamespace,
+  getProvider,
   mapMetadata,
   mapNamespaceLikeToNamespaceName,
   mapNamespaceNameToSelector,
@@ -14,11 +12,17 @@ export {
 } from "./shared"
 export { type DeploymentArgs, Deployment } from "./deployment"
 export {
-  type ServiceArgs as ServiceArgs,
+  type ServiceArgs,
+  type ServiceEndpointMetadata,
   Service,
   mapContainerPortToServicePort,
   mapServiceToLabelSelector,
+  hasServiceMetadata,
+  getServiceMetadata,
+  withServiceMetadata,
+  isFromCluster,
 } from "./service"
+export { type SecretArgs, type CreateOrPatchSecretArgs, Secret } from "./secret"
 export { type StatefulSetArgs, StatefulSet } from "./stateful-set"
 export {
   type NetworkPolicyArgs,
@@ -59,3 +63,6 @@ export {
 export { type HttpRouteArgs, HttpRoute } from "./gateway"
 export { type PersistentVolumeClaimArgs, PersistentVolumeClaim } from "./pvc"
 export { detectExternalIps, createK8sTerminal } from "./cluster"
+export { getBestEndpoint, requireBestEndpoint } from "./network"
+export { Workload, ExposableWorkload } from "./workload"
+export { type NamespaceArgs, type CreateOrPatchNamespaceArgs, Namespace } from "./namespace"

package/src/job.ts

@@ -1,21 +1,11 @@
 import { batch, type types } from "@pulumi/kubernetes"
-import {
-  ComponentResource,
-  normalize,
-  Output,
-  output,
-  type ComponentResourceOptions,
-  type Input,
-  type InputArray,
-} from "@highstate/pulumi"
+import { ComponentResource, Output, output, type ComponentResourceOptions } from "@highstate/pulumi"
 import { mergeDeep, omit } from "remeda"
-import { mapContainerToRaw, mapWorkloadVolume, type Container } from "./container"
-import { commonExtraArgs, mapMetadata, type CommonArgs } from "./shared"
+import { commonExtraArgs, getProvider, mapMetadata } from "./shared"
+import { getWorkloadComponents, type WorkloadArgs } from "./workload"
 
-export type JobArgs = CommonArgs & {
-  container?: Input<Container>
-  containers?: InputArray<Container>
-} & Omit<Partial<types.input.batch.v1.JobSpec>, "template"> & {
+export type JobArgs = WorkloadArgs &
+  Omit<Partial<types.input.batch.v1.JobSpec>, "template"> & {
     template?: {
       metadata?: types.input.meta.v1.ObjectMeta
       spec?: Partial<types.input.core.v1.PodSpec>
@@ -30,37 +20,29 @@ export class Job extends ComponentResource {
    */
   public readonly job: Output<batch.v1.Job>
 
-  constructor(name: string, args: JobArgs, opts?: ComponentResourceOptions) {
+  constructor(name: string, args: JobArgs, opts: ComponentResourceOptions) {
     super("highstate:k8s:Job", name, args, opts)
 
-    this.job = output(args).apply(args => {
-      const containers = normalize(args.container, args.containers)
+    const { podTemplate } = getWorkloadComponents(name, args, () => this, opts)
 
+    this.job = output({ args, podTemplate }).apply(async ({ args, podTemplate }) => {
       return new batch.v1.Job(
         name,
         {
           metadata: mapMetadata(args, name),
           spec: mergeDeep(
             {
-              template: {
-                spec: {
-                  containers: containers.map(container => mapContainerToRaw(container, name)),
-
-                  volumes: containers
-                    .flatMap(container => normalize(container.volume, container.volumes))
-                    .map(mapWorkloadVolume),
-
-                  restartPolicy: "Never",
-                },
-              },
+              template: podTemplate,
             } satisfies types.input.batch.v1.JobSpec,
             omit(args, jobExtraArgs) as types.input.batch.v1.JobSpec,
           ),
         },
-        { parent: this, ...opts },
+        {
+          ...opts,
+          parent: this,
+          provider: await getProvider(args.cluster),
+        },
       )
     })
-
-    this.registerOutputs({ job: this.job })
   }
 }