k8ts 0.13.2 → 0.14.0

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

@@ -1,215 +0,0 @@
-import {
-    Port_Exports,
-    ResourcesSpec,
-    Unit,
-    type CmdBuilder,
-    type Port_Exports_Input,
-    type Rsc_Ref,
-    type TaggedImage
-} from "@k8ts/instruments"
-import type { CDK } from "@k8ts/sample-interfaces"
-import { toContainerPorts } from "../../utils/adapters"
-
-import { Rsc_Entity, Rsc_Part, Rsc_Top } from "@k8ts/instruments"
-import { seq } from "doddle"
-import { mapKeys, mapValues, omitBy } from "lodash"
-import { Env } from "../../../env"
-import type { Env_Leaf } from "../../../env/types"
-import { v1 } from "../../../kinds/default"
-import { Pod_Device, Pod_Volume } from "../volume"
-import { Container_Device_Mount, type Container_Device_Mount_Source } from "./mounts/device"
-import { Container_Volume_Mount, type Container_Volume_Mount_Source } from "./mounts/volume"
-const container_ResourcesSpec = ResourcesSpec.make({
-    cpu: Unit.Cpu,
-    memory: Unit.Data
-})
-
-type Pod_Container_Resources = (typeof container_ResourcesSpec)["__INPUT__"]
-type Pod_Container_Mount_Any = Container_Volume_Mount_Source | Container_Device_Mount_Source
-export type Pod_Container_Mounts = {
-    [key: string]: Pod_Container_Mount_Any
-}
-
-export interface Pod_Container_Env_From {
-    source: Rsc_Ref<v1.ConfigMap._> | Rsc_Ref<v1.Secret._>
-    prefix?: string
-    optional?: boolean
-}
-export interface Pod_Container_Props<
-    Ports extends string = never,
-    _Env extends Record<string, Env_Leaf> = Record<string, Env_Leaf>
-> extends Omit<CDK.Container, "name"> {
-    $image: TaggedImage
-    $ports?: Port_Exports_Input<Ports>
-    $command?: CmdBuilder
-    $mounts?: Pod_Container_Mounts
-    $env?: _Env
-    $envFrom?: Pod_Container_Env_From[]
-    $resources?: Pod_Container_Resources
-}
-
-export class Pod_Container<Ports extends string = string> extends Rsc_Part<
-    Pod_Container_Props<Ports>
-> {
-    __PORTS__!: Ports
-    get kind() {
-        return v1.Pod.Container._
-    }
-
-    protected __needs__(): Record<string, Rsc_Ref | Rsc_Ref[]> {
-        const a = this.mounts
-        return mapValues(
-            mapKeys(a, x => x.path),
-            x => x.backend
-        )
-    }
-    get mounts() {
-        return seq(Object.entries(this.props.$mounts ?? {}))
-            .map(([path, mount]: [string, Pod_Container_Mount_Any]) => {
-                if (mount.$backend.is(Pod_Device)) {
-                    return new Container_Device_Mount(this, {
-                        $backend: mount.$backend,
-                        mountPath: path
-                    })
-                } else if (mount.$backend.is(Pod_Volume)) {
-                    const x = mount as any
-                    return new Container_Volume_Mount(this, {
-                        $backend: mount.$backend,
-                        mountPath: path,
-                        readOnly: x.readOnly,
-                        subPath: x.subPath
-                    })
-                }
-                throw new Error(`Unsupported mount backend type: ${mount.$backend}`)
-            })
-            .toArray()
-            .pull()
-    }
-
-    get volumes() {
-        return seq(this.mounts.map(x => x.backend))
-            .uniq()
-            .toArray()
-            .pull()
-    }
-    get ports() {
-        return Port_Exports.make(this.props.$ports)
-    }
-    protected __submanifest__(): CDK.Container {
-        const self = this
-        const { $image, $ports, $command, $env } = self.props
-        const untaggedProps = omitBy(self.props, (_, k) => k.startsWith("$"))
-        let resourcesObject = self._resources()?.toObject()
-        const containerPorts =
-            $ports &&
-            seq(toContainerPorts(Port_Exports.make($ports)).values())
-                .toArray()
-                .pull()
-
-        const env = Env($env)
-        for (const [key, value] of env.entries) {
-            if (typeof value !== "object") {
-                continue
-            }
-            if (!value) {
-                continue
-            }
-            const backend = value.$backend
-            if (backend instanceof Rsc_Entity) {
-                if (backend.namespace !== self.namespace) {
-                    throw new Error(
-                        `Environment variable reference "${key}" must be in the same namespace as the container "${self}", but was ${backend}"`
-                    )
-                }
-            }
-        }
-        for (const vol of self.volumes) {
-            if (vol.namespace !== self.namespace) {
-                throw new Error(
-                    `Volume reference "${vol}" had an inherited namespace ${vol.namespace}, which is different from the container "${self}"`
-                )
-            }
-        }
-        const envFroms = (self.props.$envFrom ?? []).map(ef => {
-            const source = ef.source as any as Rsc_Entity
-            if (source.namespace !== self.namespace) {
-                throw new Error(
-                    `EnvFrom source reference "${source}" must be in the same namespace as the container "${self}"`
-                )
-            }
-            if (source.is(v1.Secret._)) {
-                return {
-                    secretRef: {
-                        optional: ef.optional,
-                        name: source.name
-                    }
-                } as CDK.EnvFromSource
-            } else if (source.is(v1.ConfigMap._)) {
-                return {
-                    configMapRef: {
-                        optional: ef.optional,
-                        name: source.name
-                    }
-                } as CDK.EnvFromSource
-            } else {
-                throw new Error(
-                    `EnvFrom source reference "${source}" must be a ConfigMap or Secret, but was ${source.kind}`
-                )
-            }
-        })
-        const container: CDK.Container = {
-            ...untaggedProps,
-            name: self.name,
-            image: $image.toString(),
-            ports: containerPorts,
-            resources: resourcesObject,
-            command: $command?.toArray(),
-            env: Env($env).toEnvVars(),
-            envFrom: envFroms,
-            ...self._groupedMounts()
-        }
-        return container
-    }
-    constructor(
-        parent: Rsc_Entity,
-        name: string,
-        readonly subtype: "init" | "main",
-        override readonly props: Pod_Container_Props<Ports>
-    ) {
-        super(parent, name, props)
-    }
-
-    private _groupedMounts() {
-        const volumeMounts = [] as CDK.VolumeMount[]
-        const volumeDevices = [] as CDK.VolumeDevice[]
-        for (const mnt of this.mounts) {
-            if (mnt.backend.is(Pod_Device)) {
-                const deviceMount = mnt as Container_Device_Mount
-                volumeDevices!.push(deviceMount["__submanifest__"]())
-            } else if (mnt.backend.is(Pod_Volume)) {
-                const volumeMount = mnt as Container_Volume_Mount
-                volumeMounts!.push(volumeMount["__submanifest__"]())
-            }
-        }
-        return {
-            volumeMounts: volumeMounts.length > 0 ? volumeMounts : undefined,
-            volumeDevices: volumeDevices.length > 0 ? volumeDevices : undefined
-        }
-    }
-    private _resources() {
-        if (!this.props.$resources) {
-            return undefined
-        }
-        const result = container_ResourcesSpec.parse(this.props.$resources)
-        return result
-    }
-}
-
-export function make<Ports extends string>(
-    parent: Rsc_Top,
-    name: string,
-    subtype: "init" | "main",
-    props: Pod_Container_Props<Ports>
-) {
-    return new Pod_Container(parent, name, subtype, props)
-}

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

@@ -1,33 +0,0 @@
-import { Rsc_Part, type Ident_Rsc_Part, type Rsc_Entity, type Rsc_Ref } from "@k8ts/instruments"
-import type { CDK } from "@k8ts/sample-interfaces"
-import { v1 } from "../../../../kinds"
-
-export interface Container_Device_Mount_Source {
-    $backend: Rsc_Ref<v1.Pod.Device._>
-}
-
-export interface Container_Mount_Device_Props extends Container_Device_Mount_Source {
-    mountPath: string
-}
-
-export class Container_Device_Mount extends Rsc_Part<Container_Mount_Device_Props> {
-    constructor(parent: Rsc_Entity, props: Container_Mount_Device_Props) {
-        super(parent, props.$backend.name, props)
-    }
-    get kind() {
-        return v1.Pod.Container.DeviceMount._ satisfies Ident_Rsc_Part
-    }
-    get backend() {
-        return this.props.$backend
-    }
-
-    get path() {
-        return this.props.mountPath
-    }
-    protected __submanifest__(): CDK.VolumeDevice {
-        return {
-            devicePath: this.props.mountPath,
-            name: this.props.$backend.name
-        }
-    }
-}

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

@@ -1,38 +0,0 @@
-import { Rsc_Part, type Rsc_Entity, type Rsc_Ref } from "@k8ts/instruments"
-import type { CDK } from "@k8ts/sample-interfaces"
-import { v1 } from "../../../../kinds"
-
-export interface Container_Volume_Mount_Attrs<SubPaths extends string = string> {
-    subPath?: SubPaths
-    readOnly?: boolean
-}
-export interface Container_Volume_Mount_Source extends Container_Volume_Mount_Attrs {
-    $backend: Rsc_Ref<v1.Pod.Volume._>
-}
-export interface Container_Volume_Mount_Props extends Container_Volume_Mount_Source {
-    mountPath: string
-}
-export class Container_Volume_Mount extends Rsc_Part<Container_Volume_Mount_Props> {
-    constructor(parent: Rsc_Entity, props: Container_Volume_Mount_Props) {
-        super(parent, props.$backend.name, props)
-    }
-    get kind() {
-        return v1.Pod.Container.VolumeMount._
-    }
-
-    get path() {
-        return this.props.mountPath
-    }
-
-    get backend() {
-        return this.props.$backend
-    }
-    protected __submanifest__(): CDK.VolumeMount {
-        return {
-            name: this.props.$backend.name,
-            mountPath: this.props.mountPath,
-            readOnly: this.props.readOnly,
-            subPath: this.props.subPath
-        }
-    }
-}

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

@@ -1,2 +0,0 @@
-export type Path_Rooted = `/${string}`
-export type Container_Mount_Path = `${"" | "." | ".."}${Path_Rooted}`

package/src/resources/pod/index.ts

@@ -1,3 +0,0 @@
-export * from "./container"
-export * from "./pod-template"
-export * from "./volume"

package/src/resources/pod/pod-template.ts

@@ -1,166 +0,0 @@
-import { Rsc_Part, Rsc_Ref, type Rsc_Ref_Keys_Of } from "@k8ts/instruments"
-import { Meta } from "@k8ts/metadata"
-import { CDK } from "@k8ts/sample-interfaces"
-import { seq } from "doddle"
-import { omitBy } from "lodash"
-import type { Env_Value } from "../../env/types"
-import { v1 } from "../../kinds/default"
-import { Pod_Container, type Pod_Container_Props } from "./container"
-import { Pod_Device, type Pod_Device_Backend } from "./volume/devices"
-import {
-    Pod_Volume,
-    Pod_Volume_ConfigMap,
-    Pod_Volume_HostPath,
-    Pod_Volume_Pvc,
-    Pod_Volume_Secret,
-    type Pod_Volume_Backend,
-    type Pod_Volume_Backend_ConfigMap,
-    type Pod_Volume_Backend_HostPath,
-    type Pod_Volume_Backend_Pvc,
-    type Pod_Volume_Backend_Secret
-} from "./volume/volumes"
-export type Pod_Props_Original = Omit<CDK.PodSpec, "containers" | "initContainers" | "volumes">
-type Container_Ref<Ports extends string> = Rsc_Ref<v1.Pod.Container._> & {
-    __PORTS__: Ports
-}
-export type Pod_Container_Producer<Ports extends string> = (
-    scope: Pod_Scope
-) => Iterable<Container_Ref<Ports>>
-
-export interface Pod_Props<Ports extends string> extends Pod_Props_Original {
-    meta?: Meta.Input
-    $POD: Pod_Container_Producer<Ports>
-}
-
-export class Pod_Template<Ports extends string = string> extends Rsc_Part<Pod_Props<Ports>> {
-    get kind() {
-        return v1.PodTemplate._
-    }
-    private readonly _containers = seq(() => this.props.$POD(new Pod_Scope(this)))
-        .as<Pod_Container<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__() {
-        return [...this._containers, ...this.volumes]
-    }
-    protected __metadata__() {
-        return {
-            name: this.name,
-            labels: this.meta.labels,
-            annotations: this.meta.annotations
-        }
-    }
-    readonly meta = Meta.make(this.props.meta ?? {}).add("name", this.name)
-
-    protected __submanifest__(): CDK.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(Pod_Volume)) {
-                    return x["__submanifest__"]()
-                } else if (x.is(Pod_Device)) {
-                    return x["__submanifest__"]()
-                }
-                throw new Error(`Unsupported volume type: ${x}`)
-            })
-            .toArray()
-        return {
-            metadata: self.__metadata__(),
-            spec: {
-                ...omitBy(props, (x, k) => k.startsWith("$")),
-                containers: mainContainers.pull(),
-                initContainers: initContainers.pull(),
-                volumes: volumes.pull()
-            }
-        }
-    }
-}
-
-export class Pod_Scope {
-    constructor(private readonly _parent: Pod_Template) {}
-    Container<
-        Ports extends string,
-        Env extends {
-            [key in keyof Env]:
-                | {
-                      $backend: Rsc_Ref
-                      key: Env[key] extends object
-                          ? Rsc_Ref_Keys_Of<Env[key]["$backend"], string>
-                          : never
-                  }
-                | Env_Value
-        }
-    >(name: string, options: Pod_Container_Props<Ports, Env>) {
-        return new Pod_Container(this._parent, name, "main", options)
-    }
-    InitContainer(name: string, options: Pod_Container_Props<never>) {
-        return new Pod_Container(this._parent, name, "init", options)
-    }
-    Volume<const P extends Pod_Volume_Backend_HostPath>(name: string, options: P): Pod_Volume<P>
-    Volume<const P extends Pod_Volume_Backend_ConfigMap<Rsc_Ref<v1.ConfigMap._>>>(
-        name: string,
-        options: P
-    ): Pod_Volume<P>
-    Volume<const P extends Pod_Volume_Backend_Secret<Rsc_Ref<v1.Secret._>>>(
-        name: string,
-        options: P
-    ): Pod_Volume<P>
-    Volume<const P extends Pod_Volume_Backend_Pvc<Rsc_Ref<v1.PersistentVolumeClaim._>>>(
-        name: string,
-        options: P
-    ): Pod_Volume<P>
-    Volume(name: string, options: Pod_Volume_Backend): Pod_Volume {
-        {
-            const backend = options.$backend
-            if (backend.kind === "HostPath") {
-                return new Pod_Volume_HostPath(this._parent, name, options as any)
-            }
-        }
-        const backend = options.$backend as Rsc_Ref
-        if (backend.is(v1.ConfigMap._)) {
-            return new Pod_Volume_ConfigMap(this._parent, name, options as any)
-        } else if (backend.is(v1.Secret._)) {
-            return new Pod_Volume_Secret(this._parent, name, options as any)
-        } else if (backend.is(v1.PersistentVolumeClaim._)) {
-            return new Pod_Volume_Pvc(this._parent, name, options as any)
-        }
-        throw new Error(`Unsupported volume backend kind: ${backend.kind}`)
-    }
-    Device(name: string, options: Pod_Device_Backend) {
-        return new Pod_Device(this._parent, name, options)
-    }
-}

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

@@ -1,55 +0,0 @@
-import type { Rsc_Entity } from "@k8ts/instruments"
-import { Rsc_Part } from "@k8ts/instruments"
-import type { CDK } from "@k8ts/sample-interfaces"
-import { v1 } from "../../../kinds/default"
-import { Pvc } from "../../persistent"
-import type { Container_Device_Mount_Source } from "../container/mounts/device"
-interface Pod_Device_Backend_Pvc {
-    $backend: Pvc<"Block">
-    readOnly?: boolean
-}
-
-export type Pod_Device_Backend = Pod_Device_Backend_Pvc
-
-export class Pod_Device extends Rsc_Part<Pod_Device_Backend_Pvc> {
-    get kind() {
-        return v1.Pod.Device._
-    }
-
-    constructor(
-        parent: Rsc_Entity,
-        name: string,
-        readonly backend: Pod_Device_Backend_Pvc
-    ) {
-        super(parent, name, backend)
-    }
-    get sourceNamespace() {
-        const backend = this.props.$backend as any as Rsc_Entity
-        return backend.namespace
-    }
-    protected __needs__() {
-        return {
-            backend: this.backend.$backend
-        }
-    }
-
-    protected __submanifest__(): CDK.Volume {
-        return {
-            name: this.name,
-            persistentVolumeClaim: {
-                claimName: this.backend.$backend.name,
-                readOnly: this.backend.readOnly
-            }
-        }
-    }
-
-    Mount(): Container_Device_Mount_Source {
-        return {
-            $backend: this
-        }
-    }
-}
-
-export function make(parent: Rsc_Entity, name: string, input: Pod_Device_Backend) {
-    return new Pod_Device(parent, name, input)
-}

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

@@ -1,2 +0,0 @@
-export { Pod_Device, type Pod_Device_Backend } from "./devices"
-export { Pod_Volume, type Pod_Volume_Backend } from "./volumes"

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

@@ -1,170 +0,0 @@
-import type { CDK } from "@k8ts/sample-interfaces"
-
-import { Rsc_Entity, Rsc_Part, type Rsc_Ref, type Rsc_Ref_Keys_Of } from "@k8ts/instruments"
-import { v1 } from "../../../kinds/default"
-import type { HostPathType } from "../../hostpath"
-import {
-    type Container_Volume_Mount_Attrs,
-    type Container_Volume_Mount_Source
-} from "../container/mounts/volume"
-
-export interface Pod_Volume_Backend_Pvc<
-    A extends Rsc_Ref<v1.PersistentVolumeClaim._> = Rsc_Ref<v1.PersistentVolumeClaim._>
-> {
-    $backend: A
-    readOnly?: boolean
-}
-const allowedVolumeResourceKinds = [v1.ConfigMap._, v1.Secret._] as const
-type VolumeResourceKind = (typeof allowedVolumeResourceKinds)[number]
-export type AllowedResources = Rsc_Ref<VolumeResourceKind>
-
-export interface Pod_Volume_Backend_HostPath {
-    $backend: {
-        kind: "HostPath"
-        type?: HostPathType
-        path: string
-    }
-}
-export interface Pod_Volume_Backend_ConfigMap<
-    A extends Rsc_Ref<v1.ConfigMap._> = Rsc_Ref<v1.ConfigMap._>
-> {
-    $backend: A
-    optional?: boolean
-    mappings?: {
-        [K in Rsc_Ref_Keys_Of<A>]?: string
-    }
-}
-
-export interface Pod_Volume_Backend_Secret<A extends Rsc_Ref<v1.Secret._> = Rsc_Ref<v1.Secret._>> {
-    $backend: A
-    optional?: boolean
-    mappings?: {
-        [K in Rsc_Ref_Keys_Of<A>]?: string
-    }
-}
-
-export type Pod_Volume_Backend =
-    | Pod_Volume_Backend_Pvc
-    | Pod_Volume_Backend_ConfigMap
-    | Pod_Volume_Backend_Secret
-    | Pod_Volume_Backend_HostPath
-
-type _KeysOf<T> = T extends {
-    $backend: {
-        keys: infer Ks extends string[]
-    }
-}
-    ? Ks[number]
-    : never
-
-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 Pod_Volume_Backend_Known_Paths<T extends Pod_Volume_Backend> = string & _Mapped<T>
-
-export abstract class Pod_Volume<
-    P extends Pod_Volume_Backend = Pod_Volume_Backend
-> extends Rsc_Part<P> {
-    get kind() {
-        return v1.Pod.Volume._
-    }
-
-    get namespace() {
-        const backend = this.props.$backend
-        if (backend instanceof Rsc_Entity) {
-            const x = backend.namespace
-            return x
-        }
-        return undefined
-    }
-
-    protected __needs__(): Record<string, Rsc_Entity | Rsc_Entity[] | undefined> {
-        return {
-            backend: this.props.$backend instanceof Rsc_Entity ? this.props.$backend : undefined
-        }
-    }
-    Mount(
-        options?: Container_Volume_Mount_Attrs<Pod_Volume_Backend_Known_Paths<P>>
-    ): Container_Volume_Mount_Source {
-        return {
-            ...options,
-            $backend: this
-        }
-    }
-
-    protected abstract __submanifest__(): CDK.Volume
-}
-
-export class Pod_Volume_Pvc extends Pod_Volume<Pod_Volume_Backend_Pvc> {
-    protected __submanifest__(): CDK.Volume {
-        return {
-            name: this.name,
-            persistentVolumeClaim: {
-                claimName: this.props.$backend.name,
-                readOnly: this.props.readOnly
-            }
-        }
-    }
-}
-
-function mappingsToKeyPaths(input: Record<string, string>) {
-    const mappings = input
-    const arr = Object.entries(mappings).map(([key, value]) => {
-        return {
-            key: key,
-            path: value
-        } satisfies CDK.KeyToPath
-    })
-    if (arr.length === 0) {
-        return undefined
-    }
-    return arr
-}
-
-export class Pod_Volume_ConfigMap extends Pod_Volume<Pod_Volume_Backend_ConfigMap> {
-    protected __submanifest__(): CDK.Volume {
-        const mappings = mappingsToKeyPaths(this.props.mappings ?? {})
-
-        return {
-            name: this.name,
-            configMap: {
-                name: this.props.$backend.name,
-                optional: this.props.optional,
-                items: mappings
-            }
-        }
-    }
-}
-
-export class Pod_Volume_Secret<
-    Source extends Rsc_Ref<v1.Secret._>
-> extends Pod_Volume<Pod_Volume_Backend_Secret> {
-    protected __submanifest__(): CDK.Volume {
-        const mappings = mappingsToKeyPaths(this.props.mappings ?? {})
-
-        return {
-            name: this.name,
-            secret: {
-                secretName: this.props.$backend.name,
-                optional: this.props.optional,
-                items: mappings
-            }
-        }
-    }
-}
-
-export class Pod_Volume_HostPath extends Pod_Volume<Pod_Volume_Backend_HostPath> {
-    protected __submanifest__(): CDK.Volume {
-        return {
-            name: this.name,
-            hostPath: {
-                path: this.props.$backend.path,
-                type: this.props.$backend.type
-            }
-        }
-    }
-}