@highstate/k8s 0.9.16 → 0.9.19

package/src/gateway/gateway.ts

@@ -0,0 +1,383 @@
+import type { k8s, network } from "@highstate/library"
+import type { types } from "@pulumi/kubernetes"
+import type { SetRequired } from "type-fest"
+import { parseL3Endpoint } from "@highstate/common"
+import { getOrCreate } from "@highstate/contract"
+import { gateway, type types as gwTypes } from "@highstate/gateway-api"
+import {
+  ComponentResource,
+  type ComponentResourceOptions,
+  type Input,
+  type InputArray,
+  type Inputs,
+  interpolate,
+  type Output,
+  output,
+  toPromise,
+} from "@highstate/pulumi"
+import { deepmerge } from "deepmerge-ts"
+import { omit } from "remeda"
+import { Namespace } from "../namespace"
+import { commonExtraArgs, getProvider, mapMetadata, type ScopedResourceArgs } from "../shared"
+
+export type GatewayArgs = ScopedResourceArgs & {
+  /**
+   * The FQDN to configure the listeners for.
+   */
+  fqdn?: Input<string>
+
+  /**
+   * The FQDNs to configure the listeners for.
+   */
+  fqdns?: InputArray<string>
+} & gwTypes.input.gateway.v1.GatewaySpec
+
+export type CreateOrGetGatewayArgs = GatewayArgs & {
+  /**
+   * The gateway entity to patch/retrieve.
+   */
+  existing: Input<k8s.Gateway> | undefined
+}
+
+const gatewayExtraArgs = [...commonExtraArgs, "fqdn", "fqdns"] as const
+
+/**
+ * Represents a Kubernetes Gateway resource.
+ */
+export abstract class Gateway extends ComponentResource {
+  protected constructor(
+    type: string,
+    name: string,
+    args: Inputs,
+    opts: ComponentResourceOptions | undefined,
+
+    /**
+     * The namespace where the gateway is located.
+     */
+    readonly namespace: Output<Namespace>,
+
+    /**
+     * The metadata of the underlying Kubernetes gateway.
+     */
+    readonly metadata: Output<types.output.meta.v1.ObjectMeta>,
+
+    /**
+     * The spec of the underlying Gateway resource.
+     */
+    readonly spec: Output<gwTypes.output.gateway.v1.GatewaySpec>,
+
+    /**
+     * The status of the underlying Gateway resource.
+     */
+    readonly status: Output<gwTypes.output.gateway.v1.GatewayStatus>,
+  ) {
+    super(type, name, args, opts)
+  }
+
+  /**
+   * The cluster where the gateway is located.
+   */
+  get cluster(): Output<k8s.Cluster> {
+    return this.namespace.cluster
+  }
+
+  /**
+   * The Highstate gateway entity.
+   */
+  get entity(): Output<k8s.Gateway> {
+    return output({
+      type: "gateway",
+      clusterId: this.cluster.id,
+      clusterName: this.cluster.name,
+      metadata: this.metadata,
+    })
+  }
+
+  /**
+   * Returns the endpoints L3 endpoints on which the gateway is exposed.
+   */
+  get endpoints(): Output<network.L3Endpoint[]> {
+    return this.status.addresses.apply(addresses => {
+      if (!addresses) {
+        return []
+      }
+
+      return addresses.map(address => parseL3Endpoint(address.value))
+    })
+  }
+
+  /**
+   * Creates a new gateway.
+   */
+  static create(name: string, args: GatewayArgs, opts?: ComponentResourceOptions): Gateway {
+    return new CreatedGateway(name, args, opts)
+  }
+
+  /**
+   * Creates a new gateway or patches an existing one.
+   *
+   * @param name The name of the resource. May not be the same as the gateway name.
+   * @param args The arguments to create or patch the gateway with.
+   * @param opts Optional resource options.
+   */
+  static createOrPatch(
+    name: string,
+    args: CreateOrGetGatewayArgs,
+    opts?: ComponentResourceOptions,
+  ): Gateway {
+    if (args.existing) {
+      return new GatewayPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster),
+      })
+    }
+
+    return new CreatedGateway(name, args, opts)
+  }
+
+  /**
+   * Creates a new gateway or gets an existing one.
+   *
+   * @param name The name of the resource. May not be the same as the gateway name. Will not be used when existing gateway is retrieved.
+   * @param args The arguments to create or get the gateway with.
+   * @param opts Optional resource options.
+   */
+  static async createOrGet(
+    name: string,
+    args: CreateOrGetGatewayArgs,
+    opts?: ComponentResourceOptions,
+  ): Promise<Gateway> {
+    if (args.existing) {
+      return await Gateway.forAsync(args.existing, output(args.namespace).cluster)
+    }
+
+    return new CreatedGateway(name, args, opts)
+  }
+
+  /**
+   * Patches an existing gateway.
+   *
+   * Will throw an error if the gateway does not exist.
+   *
+   * @param name The name of the resource. May not be the same as the gateway name.
+   * @param args The arguments to patch the gateway with.
+   * @param opts Optional resource options.
+   */
+  static patch(name: string, args: GatewayArgs, opts?: ComponentResourceOptions): Gateway {
+    return new GatewayPatch(name, args, opts)
+  }
+
+  /**
+   * Wraps an existing Kubernetes gateway.
+   */
+  static wrap(name: string, args: WrappedGatewayArgs, opts?: ComponentResourceOptions): Gateway {
+    return new WrappedGateway(name, args, opts)
+  }
+
+  /**
+   * Gets an existing gateway.
+   *
+   * Will throw an error if the gateway does not exist.
+   */
+  static get(name: string, args: ExternalGatewayArgs, opts?: ComponentResourceOptions): Gateway {
+    return new ExternalGateway(name, args, opts)
+  }
+
+  private static readonly gatewayCache = new Map<string, Gateway>()
+
+  /**
+   * Gets an existing gateway for a given entity.
+   * Prefer this method over `get` when possible.
+   *
+   * It automatically names the resource with the following format: `{clusterName}.{namespace}.{gatewayName}.{clusterId}`.
+   *
+   * This method is idempotent and will return the same instance for the same entity.
+   *
+   * @param entity The entity to get the gateway for.
+   * @param cluster The cluster where the gateway is located.
+   */
+  static for(entity: k8s.Gateway, cluster: Input<k8s.Cluster>): Gateway {
+    return getOrCreate(
+      Gateway.gatewayCache,
+      `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`,
+      name => {
+        return Gateway.get(name, {
+          name: entity.metadata.name,
+          namespace: Namespace.forResourceAsync(entity, cluster),
+        })
+      },
+    )
+  }
+
+  /**
+   * Gets an existing gateway for a given entity.
+   * Prefer this method over `get` when possible.
+   *
+   * It automatically names the resource with the following format: `{clusterName}.{namespace}.{gatewayName}.{clusterId}`.
+   *
+   * This method is idempotent and will return the same instance for the same entity.
+   *
+   * @param entity The entity to get the gateway for.
+   * @param cluster The cluster where the gateway is located.
+   */
+  static async forAsync(entity: Input<k8s.Gateway>, cluster: Input<k8s.Cluster>): Promise<Gateway> {
+    const resolvedEntity = await toPromise(entity)
+
+    return Gateway.for(resolvedEntity, output(cluster))
+  }
+
+  /**
+   * Creates a gateway with the provided name/namespace/cluster only once.
+   *
+   * It automatically names the resource with the following format: `{name}.{namespace}.{clusterName}.{clusterId}`.
+   *
+   * This method is idempotent and will return the same instance for the same name/namespace/cluster.
+   *
+   * @param name The name of the gateway to create.
+   * @param args The arguments to create the gateway with.
+   * @param opts Optional resource options.
+   */
+  static async createOnce(
+    args: SetRequired<GatewayArgs, "name">,
+    opts?: ComponentResourceOptions,
+  ): Promise<Gateway> {
+    const { name, namespace, cluster } = await toPromise({
+      name: args.name,
+      namespace: output(args.namespace).metadata.name,
+      cluster: output(args.namespace).cluster,
+    })
+
+    const fullName = `${name}.${namespace}.${cluster.name}.${cluster.id}`
+
+    return getOrCreate(Gateway.gatewayCache, name, () =>
+      Gateway.create(
+        fullName,
+        {
+          ...args,
+          name,
+          namespace: args.namespace,
+        },
+        opts,
+      ),
+    )
+  }
+}
+
+class CreatedGateway extends Gateway {
+  constructor(name: string, args: GatewayArgs, opts?: ComponentResourceOptions) {
+    const gatewayResource = output(args.namespace).cluster.apply(cluster => {
+      return new gateway.v1.Gateway(
+        name,
+        {
+          metadata: mapMetadata(args, name),
+          spec: deepmerge({}, omit(args, gatewayExtraArgs)),
+        },
+        { ...opts, parent: this, provider: getProvider(cluster) },
+      )
+    })
+
+    super(
+      "highstate:k8s:Gateway",
+      name,
+      args,
+      opts,
+
+      output(args.namespace),
+      gatewayResource.metadata as Output<types.output.meta.v1.ObjectMeta>,
+      gatewayResource.spec,
+      gatewayResource.status,
+    )
+  }
+}
+
+class GatewayPatch extends Gateway {
+  constructor(name: string, args: GatewayArgs, opts?: ComponentResourceOptions) {
+    const gatewayResource = output(args.namespace).cluster.apply(cluster => {
+      return new gateway.v1.GatewayPatch(
+        name,
+        {
+          metadata: mapMetadata(args, name),
+          spec: deepmerge({}, omit(args, gatewayExtraArgs)),
+        },
+        { ...opts, parent: this, provider: getProvider(cluster) },
+      )
+    })
+
+    super(
+      "highstate:k8s:GatewayPatch",
+      name,
+      args,
+      opts,
+
+      output(args.namespace),
+      gatewayResource.metadata as Output<types.output.meta.v1.ObjectMeta>,
+      gatewayResource.spec,
+      gatewayResource.status,
+    )
+  }
+}
+
+export type WrappedGatewayArgs = {
+  /**
+   * The underlying Kubernetes gateway to wrap.
+   */
+  gateway: Input<gateway.v1.Gateway>
+
+  /**
+   * The namespace where the gateway is located.
+   */
+  namespace: Input<Namespace>
+}
+
+class WrappedGateway extends Gateway {
+  constructor(name: string, args: WrappedGatewayArgs, opts?: ComponentResourceOptions) {
+    super(
+      "highstate:k8s:WrappedGateway",
+      name,
+      args,
+      opts,
+
+      output(args.namespace),
+      output(args.gateway).metadata as Output<types.output.meta.v1.ObjectMeta>,
+      output(args.gateway).spec,
+      output(args.gateway).status,
+    )
+  }
+}
+
+export type ExternalGatewayArgs = {
+  /**
+   * The name of the gateway to get.
+   */
+  name: Input<string>
+
+  /**
+   * The namespace of the gateway to get.
+   */
+  namespace: Input<Namespace>
+}
+
+class ExternalGateway extends Gateway {
+  constructor(name: string, args: ExternalGatewayArgs, opts?: ComponentResourceOptions) {
+    const gatewayResource = output(args.namespace).cluster.apply(cluster => {
+      return gateway.v1.Gateway.get(
+        name,
+        interpolate`${output(args.namespace).metadata.name}/${args.name}`,
+        { ...opts, parent: this, provider: getProvider(cluster) },
+      )
+    })
+
+    super(
+      "highstate:k8s:ExternalGateway",
+      name,
+      args,
+      opts,
+
+      output(args.namespace),
+      gatewayResource.metadata as Output<types.output.meta.v1.ObjectMeta>,
+      gatewayResource.spec,
+      gatewayResource.status,
+    )
+  }
+}

package/src/gateway/http-route.ts

@@ -1,22 +1,25 @@
+import type { Gateway } from "./gateway"
 import {
   ComponentResource,
   normalize,
+  normalizeInputs,
+  normalizeInputsAndMap,
   output,
-  Output,
+  type Output,
   type ComponentResourceOptions,
   type Input,
   type InputArray,
 } from "@highstate/pulumi"
-import { gateway, types } from "@highstate/gateway-api"
+import { gateway, type types } from "@highstate/gateway-api"
 import { map, pipe } from "remeda"
-import { getProvider, mapMetadata, type CommonArgs } from "../shared"
+import { getProvider, mapMetadata, type ScopedResourceArgs } from "../shared"
 import { resolveBackendRef, type BackendRef } from "./backend"
 
-export type HttpRouteArgs = Omit<CommonArgs, "namespace"> & {
+export type HttpRouteArgs = Omit<ScopedResourceArgs, "namespace"> & {
   /**
    * The gateway to associate with the route.
    */
-  gateway: Input<gateway.v1.Gateway>
+  gateway: Input<Gateway>
 
   /**
    * The alias for `hostnames: [hostname]`.
@@ -77,30 +80,24 @@ export class HttpRoute extends ComponentResource {
   constructor(name: string, args: HttpRouteArgs, opts?: ComponentResourceOptions) {
     super("highstate:k8s:HttpRoute", name, args, opts)
 
-    this.route = output({
-      args,
-      gatewayNamespace: output(args.gateway).metadata.namespace,
-    }).apply(async ({ args, gatewayNamespace }) => {
+    this.route = output(args.gateway).cluster.apply(cluster => {
       return new gateway.v1.HTTPRoute(
         name,
         {
-          metadata: mapMetadata(
-            {
-              ...args,
-              namespace: gatewayNamespace as string,
-            },
-            name,
-          ),
+          metadata: mapMetadata(args, name).apply(metadata => ({
+            ...metadata,
+            namespace: output(args.gateway).namespace.metadata.name,
+          })),
           spec: {
-            hostnames: normalize(args.hostname, args.hostnames),
+            hostnames: normalizeInputs(args.hostname, args.hostnames),
 
             parentRefs: [
               {
-                name: args.gateway.metadata.name as Output<string>,
+                name: output(args.gateway).metadata.name,
               },
             ],
 
-            rules: normalize(args.rule, args.rules).map(rule => ({
+            rules: normalizeInputsAndMap(args.rule, args.rules, rule => ({
               timeouts: rule.timeouts,
 
               matches: pipe(
@@ -114,11 +111,7 @@ export class HttpRoute extends ComponentResource {
             })),
           } satisfies types.input.gateway.v1.HTTPRouteSpec,
         },
-        {
-          ...opts,
-          parent: this,
-          provider: await getProvider(args.cluster),
-        },
+        { ...opts, parent: this, provider: getProvider(cluster) },
       )
     })
   }

package/src/gateway/index.ts

@@ -1,2 +1,3 @@
 export * from "./backend"
 export * from "./http-route"
+export * from "./gateway"