k8ts 0.13.2 → 0.14.0

package/src/resources/workload/pod/container/mounts/device.ts

@@ -0,0 +1,41 @@
+import {
+    ResourcePart,
+    type Gvk_SubKind,
+    type ResourceEntity,
+    type ResourceRef,
+    type Resource_Props
+} from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../../../../gvks"
+
+export interface ContainerDeviceMount_Input extends Resource_Props<K8S.VolumeDevice> {
+    $backend: ResourceRef<v1.Pod.Device._>
+}
+
+export interface ContainerMountDevice_Props extends ContainerDeviceMount_Input {
+    mountPath: string
+}
+
+export class ContainerDeviceMount extends ResourcePart<ContainerMountDevice_Props> {
+    constructor(parent: ResourceEntity, props: ContainerMountDevice_Props) {
+        super(parent, props.$backend.ident.name, props)
+    }
+    get kind() {
+        return v1.Pod.Container.DeviceMount._ satisfies Gvk_SubKind
+    }
+    get backend() {
+        return this.props.$backend
+    }
+
+    get path() {
+        return this.props.mountPath
+    }
+    protected __submanifest__(): K8S.VolumeDevice {
+        const body = {
+            devicePath: this.props.mountPath,
+            name: this.props.$backend.ident.name
+        }
+        return merge(body, this.props.$$manifest)
+    }
+}

package/src/resources/workload/pod/container/mounts/volume.ts

@@ -0,0 +1,46 @@
+import {
+    ResourcePart,
+    type Resource_Props,
+    type ResourceEntity,
+    type ResourceRef
+} from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../../../../kinds"
+
+export interface ContainerVolumeMount_Input<SubPaths extends string = string>
+    extends Resource_Props<K8S.VolumeMount> {
+    subPath?: SubPaths
+    readOnly?: boolean
+}
+export interface ContainerVolumeMount_Unbound extends ContainerVolumeMount_Input {
+    $backend: ResourceRef<v1.Pod.Volume._>
+}
+export interface ContainerVolumeMount_Props extends ContainerVolumeMount_Unbound {
+    mountPath: string
+}
+export class ContainerVolumeMount extends ResourcePart<ContainerVolumeMount_Props> {
+    constructor(parent: ResourceEntity, props: ContainerVolumeMount_Props) {
+        super(parent, props.$backend.ident.name, props)
+    }
+    get kind() {
+        return v1.Pod.Container.VolumeMount._
+    }
+
+    get path() {
+        return this.props.mountPath
+    }
+
+    get backend() {
+        return this.props.$backend
+    }
+    protected __submanifest__(): K8S.VolumeMount {
+        const body = {
+            name: this.props.$backend.ident.name,
+            mountPath: this.props.mountPath,
+            readOnly: this.props.readOnly,
+            subPath: this.props.subPath
+        }
+        return merge(body, this.props.$$manifest)
+    }
+}

package/src/resources/workload/pod/container/ref.ts

@@ -0,0 +1,6 @@
+import type { ResourceRef } from "@k8ts/instruments"
+import type { v1 } from "../../../../gvks"
+
+export type ContainerRef<Ports extends string> = ResourceRef<v1.Pod.Container._> & {
+    __PORTS__: Ports
+}

package/src/resources/workload/pod/container/scope.ts

@@ -0,0 +1,83 @@
+import type { ResourceRef, ResourceRef_HasKeys } from "@k8ts/instruments"
+import { PodContainer, PodContainer_Props } from "./container"
+
+import { PodDevice, PodDeviceBackend, PodVolume, PodVolume_Backend } from "../volume"
+
+import type { EnvValuePrimitive } from "../../../../env"
+import { v1 } from "../../../../gvks"
+import { K8tsResourceError } from "../../../errors"
+import type { Pod } from "../pod"
+import {
+    type PodVolume_Backend_ConfigMap,
+    type PodVolume_Backend_EmptyDir,
+    type PodVolume_Backend_HostPath,
+    type PodVolume_Backend_Pvc,
+    type PodVolume_Backend_Secret,
+    PodVolume_ConfigMap,
+    PodVolume_EmptyDir,
+    PodVolume_HostPath,
+    PodVolume_Pvc,
+    PodVolume_Secret
+} from "../volume/volumes"
+
+export class Pod_Scope {
+    constructor(protected readonly _parent: Pod) {}
+    Container<
+        Ports extends string,
+        Env extends {
+            [key in keyof Env]:
+                | {
+                      $backend: ResourceRef
+                      key: Env[key] extends object
+                          ? ResourceRef_HasKeys<Env[key]["$backend"], string>
+                          : never
+                  }
+                | EnvValuePrimitive
+        }
+    >(name: string, options: PodContainer_Props<Ports, Env>) {
+        return new PodContainer(this._parent, name, "main", options)
+    }
+    InitContainer(name: string, options: PodContainer_Props<never>) {
+        return new PodContainer(this._parent, name, "init", options)
+    }
+    Volume<const P extends PodVolume_Backend_EmptyDir>(name: string, options: P): PodVolume<P>
+    Volume<const P extends PodVolume_Backend_HostPath>(name: string, options: P): PodVolume<P>
+    Volume<const P extends PodVolume_Backend_ConfigMap<ResourceRef<v1.ConfigMap._>>>(
+        name: string,
+        options: P
+    ): PodVolume<P>
+    Volume<const P extends PodVolume_Backend_Secret<ResourceRef<v1.Secret._>>>(
+        name: string,
+        options: P
+    ): PodVolume<P>
+    Volume<const P extends PodVolume_Backend_Pvc<ResourceRef<v1.PersistentVolumeClaim._>>>(
+        name: string,
+        options: P
+    ): PodVolume<P>
+    Volume(name: string, options: PodVolume_Backend): PodVolume {
+        {
+            const backend = options.$backend
+            if ("kind" in backend) {
+                switch (backend.kind) {
+                    case "EmptyDir":
+                        return new PodVolume_EmptyDir(this._parent, name, options as any)
+                }
+            }
+            if ("kind" in backend && backend.kind === "HostPath") {
+                return new PodVolume_HostPath(this._parent, name, options as any)
+            }
+        }
+        const backend = options.$backend as ResourceRef
+        if (backend.is(v1.ConfigMap._)) {
+            return new PodVolume_ConfigMap(this._parent, name, options as any)
+        } else if (backend.is(v1.Secret._)) {
+            return new PodVolume_Secret(this._parent, name, options as any)
+        } else if (backend.is(v1.PersistentVolumeClaim._)) {
+            return new PodVolume_Pvc(this._parent, name, options as any)
+        }
+        throw new K8tsResourceError(`Unsupported volume backend kind: ${backend.kind}`)
+    }
+    Device(name: string, options: PodDeviceBackend) {
+        return new PodDevice(this._parent, name, options)
+    }
+}

package/src/resources/workload/pod/container/utils.ts

@@ -0,0 +1,16 @@
+import type { Port_Full, PortExports } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
+export function toContainerPort(entry: Port_Full): K8S.ContainerPort {
+    return {
+        containerPort: entry.port,
+        name: entry.name,
+        protocol: entry.protocol,
+        hostPort: entry.hostPort,
+        hostIp: entry.hostIp?.text
+    }
+}
+
+export function toContainerPorts(ports: PortExports<any>) {
+    return seq(ports.values).map(toContainerPort).toArray().pull()
+}

package/src/resources/workload/pod/pod.ts

@@ -0,0 +1,96 @@
+import { K8sResource, ResourcePart, type Resource_Props } from "@k8ts/instruments"
+import type { Metadata_Input } from "@k8ts/metadata"
+import { K8S } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
+import { merge } from "lodash"
+import type { Workload_Ref } from "../../.."
+import { v1 } from "../../../gvks"
+import { K8tsResourceError } from "../../errors"
+import { createSelectionMetadata } from "../util"
+import type { PodContainer } from "./container"
+import type { ContainerRef } from "./container/ref"
+import { Pod_Scope } from "./container/scope"
+export type Pod_Producer<Ports extends string> = ($pod: Pod_Scope) => Iterable<ContainerRef<Ports>>
+
+export interface Pod_Props<Ports extends string> extends Resource_Props<Partial<K8S.PodSpec>> {
+    metadata?: Metadata_Input
+    containers$: Pod_Producer<Ports>
+}
+
+export class Pod<Name extends string = string, Ports extends string = string>
+    extends K8sResource<Name, Pod_Props<Ports>>
+    implements Workload_Ref<Ports>
+{
+    get kind() {
+        return v1.Pod._
+    }
+    private readonly _containers = seq(() => {
+        return this.__scope__(this.props.containers$)(new Pod_Scope(this))
+    })
+        .as<PodContainer<Ports>>()
+        .cache()
+
+    private readonly _mounts = seq(() => this._containers.concatMap(x => x.mounts))
+        .uniq()
+        .cache()
+    private readonly _volumes = seq(() => this._containers.concatMap(x => x.volumes))
+        .uniq()
+        .cache()
+    private readonly _ports = this._containers.map(x => x.ports).reduce((a, b) => a.union(b))
+
+    get containers() {
+        return this._containers.toIterable()
+    }
+    get mounts() {
+        return this._mounts.toIterable()
+    }
+
+    get volumes() {
+        return this._volumes.toIterable()
+    }
+
+    get ports() {
+        return this._ports.pull()
+    }
+
+    protected __kids__() {
+        this._containers.toArray().pull()
+        return super.__kids__()
+    }
+
+    protected __body__(): K8S.PodTemplateSpec {
+        const self = this
+        const { props } = self
+        const containers = self._containers
+        const initContainers = containers
+            .filter(c => c.subtype === "init")
+            .map(x => x["__submanifest__"]())
+            .toArray()
+        const mainContainers = containers
+            .filter(c => c.subtype === "main")
+            .map(x => x["__submanifest__"]())
+            .toArray()
+
+        const volumes = self._volumes
+            .map(x => {
+                if (x.is(ResourcePart)) {
+                    return x["__submanifest__"]() as K8S.Volume
+                }
+                throw new K8tsResourceError(`Unsupported volume type: ${x}`)
+            })
+            .toArray()
+        const spec = {
+            containers: mainContainers.pull(),
+            initContainers: initContainers.pull(),
+            volumes: volumes.pull()
+        } satisfies K8S.PodSpec
+        const spec2 = merge(spec, props.$$manifest)
+        return {
+            spec: spec2
+        }
+    }
+
+    get selectorLabels() {
+        return createSelectionMetadata(this)
+    }
+}

package/src/resources/workload/pod/volume/devices.ts

@@ -0,0 +1,56 @@
+import type { Resource_Props, ResourceEntity, ResourceRef } from "@k8ts/instruments"
+import { ResourcePart } from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../../../gvks/default"
+import type { ContainerDeviceMount_Input } from "../container/mounts/device"
+interface PodDeviceBackendPvc extends Resource_Props<K8S.Volume> {
+    $backend: ResourceRef<v1.PersistentVolumeClaim._>
+    readOnly?: boolean
+}
+
+export type PodDeviceBackend = PodDeviceBackendPvc
+
+export class PodDevice extends ResourcePart<PodDeviceBackendPvc> {
+    get kind() {
+        return v1.Pod.Device._
+    }
+
+    constructor(
+        parent: ResourceEntity,
+        name: string,
+        readonly backend: PodDeviceBackendPvc
+    ) {
+        super(parent, name, backend)
+    }
+    get sourceNamespace() {
+        const backend = this.props.$backend as any as ResourceEntity
+        return backend.ident.namespace
+    }
+    protected __needs__() {
+        return {
+            backend: this.backend.$backend
+        }
+    }
+
+    protected __submanifest__(): K8S.Volume {
+        const body = {
+            name: this.ident.name,
+            persistentVolumeClaim: {
+                claimName: this.backend.$backend.ident.name,
+                readOnly: this.backend.readOnly
+            }
+        }
+        return merge(body, this.props.$$manifest)
+    }
+
+    Mount(): ContainerDeviceMount_Input {
+        return {
+            $backend: this
+        }
+    }
+}
+
+export function make(parent: ResourceEntity, name: string, input: PodDeviceBackend) {
+    return new PodDevice(parent, name, input)
+}

package/src/resources/workload/pod/volume/index.ts

@@ -0,0 +1,2 @@
+export { PodDevice, type PodDeviceBackend } from "./devices"
+export { PodVolume, type PodVolume_Backend } from "./volumes"

package/src/resources/workload/pod/volume/volumes.ts

@@ -0,0 +1,203 @@
+import { K8S } from "@k8ts/sample-interfaces"
+
+import {
+    ResourceEntity,
+    ResourcePart,
+    toCdkQuantity,
+    Units,
+    type Resource_Props,
+    type ResourceRef,
+    type ResourceRef_HasKeys
+} from "@k8ts/instruments"
+import { merge } from "lodash"
+import { v1 } from "../../../../gvks/default"
+import type { HostPath_Type } from "../../../hostpath"
+import {
+    type ContainerVolumeMount_Input,
+    type ContainerVolumeMount_Unbound
+} from "../container/mounts/volume"
+
+export interface PodVolume_Backend_Pvc<
+    A extends ResourceRef<v1.PersistentVolumeClaim._> = ResourceRef<v1.PersistentVolumeClaim._>
+> extends Resource_Props<K8S.Volume> {
+    $backend: A
+    readOnly?: boolean
+}
+
+export interface PodVolume_Backend_HostPath extends Resource_Props<K8S.Volume> {
+    $backend: {
+        kind: "HostPath"
+        $noEmit?: boolean
+        type?: HostPath_Type
+        path: string
+    }
+}
+export interface PodVolume_Backend_EmptyDir extends Resource_Props<K8S.Volume> {
+    $backend: {
+        kind: "EmptyDir"
+        medium?: "" | "Memory"
+        sizeLimit?: Units.Data
+    }
+}
+export interface PodVolume_Backend_ConfigMap<
+    A extends ResourceRef<v1.ConfigMap._> = ResourceRef<v1.ConfigMap._>
+> extends Resource_Props<K8S.Volume> {
+    $backend: A
+    optional?: boolean
+    mappings?: {
+        [K in ResourceRef_HasKeys<A>]?: string
+    }
+}
+
+export interface PodVolume_Backend_Secret<
+    A extends ResourceRef<v1.Secret._> = ResourceRef<v1.Secret._>
+> extends Resource_Props<K8S.Volume> {
+    $backend: A
+    optional?: boolean
+    mappings?: {
+        [K in ResourceRef_HasKeys<A>]?: string
+    }
+}
+
+export type PodVolume_Backend = (
+    | PodVolume_Backend_Pvc
+    | PodVolume_Backend_ConfigMap
+    | PodVolume_Backend_Secret
+    | PodVolume_Backend_HostPath
+    | PodVolume_Backend_EmptyDir
+) &
+    Resource_Props<K8S.Volume>
+
+type _KeysOf<T> = T extends {
+    $backend: {
+        keys: infer Ks extends string[]
+    }
+}
+    ? Ks[number]
+    : string
+
+type _Mapped<T> = T extends {
+    mappings: infer M
+}
+    ? {
+          [K in _KeysOf<T>]: K extends keyof M ? M[K] : K
+      }[_KeysOf<T>]
+    : _KeysOf<T>
+export type PodVolumeBackendKnownPaths<T extends PodVolume_Backend> = string & _Mapped<T>
+
+export abstract class PodVolume<
+    P extends PodVolume_Backend = PodVolume_Backend
+> extends ResourcePart<P> {
+    get kind() {
+        return v1.Pod.Volume._
+    }
+
+    get namespace() {
+        const backend = this.props.$backend
+        if (backend instanceof ResourceEntity) {
+            const x = backend.ident.namespace
+            return x
+        }
+        return this.__parent__.ident.namespace
+    }
+
+    protected __needs__(): Record<string, ResourceEntity | ResourceEntity[] | undefined> {
+        return {
+            backend: this.props.$backend instanceof ResourceEntity ? this.props.$backend : undefined
+        }
+    }
+    mount(
+        options?: ContainerVolumeMount_Input<PodVolumeBackendKnownPaths<P>>
+    ): ContainerVolumeMount_Unbound {
+        return {
+            ...options,
+            $backend: this
+        }
+    }
+
+    protected abstract __submanifest__(): K8S.Volume
+}
+
+export class PodVolume_Pvc extends PodVolume<PodVolume_Backend_Pvc> {
+    protected __submanifest__(): K8S.Volume {
+        const body = {
+            name: this.ident.name,
+            persistentVolumeClaim: {
+                claimName: this.props.$backend.ident.name,
+                readOnly: this.props.readOnly
+            }
+        }
+        return merge(body, this.props.$$manifest)
+    }
+}
+
+function mappingsToKeyPaths(input: Record<string, string>) {
+    const mappings = input
+    const arr = Object.entries(mappings).map(([key, value]) => {
+        return {
+            key: key,
+            path: value
+        } satisfies K8S.KeyToPath
+    })
+    if (arr.length === 0) {
+        return undefined
+    }
+    return arr
+}
+
+export class PodVolume_ConfigMap extends PodVolume<PodVolume_Backend_ConfigMap> {
+    protected __submanifest__(): K8S.Volume {
+        const mappings = mappingsToKeyPaths(this.props.mappings ?? {})
+
+        const body = {
+            name: this.ident.name,
+            configMap: {
+                name: this.props.$backend.ident.name,
+                optional: this.props.optional,
+                items: mappings
+            }
+        }
+        return merge(body, this.props.$$manifest)
+    }
+}
+
+export class PodVolume_Secret<
+    Source extends ResourceRef<v1.Secret._>
+> extends PodVolume<PodVolume_Backend_Secret> {
+    protected __submanifest__(): K8S.Volume {
+        const mappings = mappingsToKeyPaths(this.props.mappings ?? {})
+
+        const body = {
+            name: this.ident.name,
+            secret: {
+                secretName: this.props.$backend.ident.name,
+                optional: this.props.optional,
+                items: mappings
+            }
+        }
+        return merge(body, this.props.$$manifest)
+    }
+}
+
+export class PodVolume_HostPath extends PodVolume<PodVolume_Backend_HostPath> {
+    protected __submanifest__(): K8S.Volume {
+        const body = {
+            name: this.ident.name,
+            hostPath: {
+                path: this.props.$backend.path,
+                type: this.props.$backend.kind
+            }
+        }
+        return merge(body, this.props.$$manifest)
+    }
+}
+
+export class PodVolume_EmptyDir extends PodVolume<PodVolume_Backend_EmptyDir> {
+    protected __submanifest__(): K8S.Volume {
+        const body = {
+            medium: this.props.$backend.medium,
+            sizeLimit: toCdkQuantity(this.props.$backend.sizeLimit)
+        } satisfies K8S.EmptyDirVolumeSource
+        return merge(body, this.props.$$manifest)
+    }
+}

package/src/resources/workload/statefulset/index.ts

@@ -0,0 +1 @@
+export * from "./statefulset"

package/src/resources/workload/statefulset/props.ts

@@ -0,0 +1,34 @@
+import type { Resource_Props_Top } from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+import type { Pod_Props, Service_Props } from "../../.."
+import type { ContainerRef } from "../pod/container"
+import type { StatefulSet_Scope } from "./scope"
+
+export interface StatefulSet_UpdateStrategy_RollingUpdate
+    extends K8S.RollingUpdateStatefulSetStrategy {
+    type: "RollingUpdate"
+}
+export interface StatefulSet_UpdateStrategy_OnDelete {
+    type: "OnDelete"
+}
+export type StatefulSet_UpdateStrategy =
+    | StatefulSet_UpdateStrategy_RollingUpdate
+    | StatefulSet_UpdateStrategy_OnDelete
+
+export type StatefulSet_Producer<Ports extends string> = (
+    scope: StatefulSet_Scope
+) => Iterable<ContainerRef<Ports>>
+export interface StatefulSet_Props<
+    Ports extends string,
+    SvcPorts extends NoInfer<Ports>,
+    SvcName extends string
+> extends Resource_Props_Top<K8S.StatefulSetSpec> {
+    $replicas?: number
+    $template: Omit<Pod_Props<Ports>, "containers$"> & {
+        containers$: StatefulSet_Producer<Ports>
+    }
+    $service: {
+        name: SvcName
+    } & Omit<Service_Props<Ports, SvcPorts>, "$backend" | "$frontend">
+    $updateStrategy?: StatefulSet_UpdateStrategy
+}

package/src/resources/workload/statefulset/scope.ts

@@ -0,0 +1,25 @@
+import type { TemplateOrigin } from "@k8ts/instruments"
+import type { Pvc_Props, PvVolumeMode } from "../../persistent"
+import { Pvc } from "../../persistent"
+import { Pod_Scope } from "../pod/container/scope"
+export class StatefulSet_Scope extends Pod_Scope {
+    constructor(
+        podScope: Pod_Scope,
+        private readonly _template: TemplateOrigin
+    ) {
+        super(podScope["_parent"])
+    }
+
+    PvcTemplate<Mode extends PvVolumeMode>(name: string, props: Pvc_Props<Mode>) {
+        const pvc = new Pvc(name, props, {
+            origins: {
+                own: this._template,
+                subscope: this["_parent"]["__origin__"]
+            }
+        })
+        return this.Volume(pvc.ident.name, {
+            $backend: pvc,
+            $noEmit: true
+        })
+    }
+}