k8ts 0.1.0

package/src/resources/namespace/namespace.ts

@@ -0,0 +1,26 @@
+import { manifest, relations, type Origin } from "@k8ts/instruments"
+import { Meta, MutableMeta } from "@k8ts/metadata"
+import type { CDK } from "../../_imports"
+import { v1 } from "../../api-versions"
+import { k8ts } from "../../kind-map"
+import { ManifestResource } from "../../node/manifest-resource"
+export type Namespace = Namespace.Namespace
+export namespace Namespace {
+    export interface Props {}
+    const ident = v1.kind("Namespace")
+    @k8ts(ident)
+    @relations("none")
+    @manifest({
+        body(self): CDK.KubeNamespaceProps {
+            return {
+                spec: {}
+            }
+        }
+    })
+    export class Namespace extends ManifestResource<Props> {
+        override kind = ident
+        constructor(origin: Origin, meta: Meta | MutableMeta, props?: Props) {
+            super(origin, meta.toMutable(), props ?? {})
+        }
+    }
+}

package/src/resources/persistent/access-mode.ts

@@ -0,0 +1,29 @@
+export type Access = Access.Inputs
+
+export namespace Access {
+    export type Mode = "ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany"
+    export type Input = Mode | "RWX" | "ROX" | "RWO"
+    export type Inputs = Input | Input[]
+
+    function parseOne(mode: Input): Mode {
+        switch (mode) {
+            case "RWX":
+            case "ReadWriteMany":
+                return "ReadWriteMany"
+            case "ROX":
+            case "ReadOnlyMany":
+                return "ReadOnlyMany"
+            case "RWO":
+            case "ReadWriteOnce":
+                return "ReadWriteOnce"
+        }
+    }
+
+    export function parse(modes: Inputs): Mode[] {
+        if (Array.isArray(modes)) {
+            return modes.map(parseOne)
+        } else {
+            return [parseOne(modes)]
+        }
+    }
+}

package/src/resources/persistent/block-mode.ts

@@ -0,0 +1 @@
+export type DataMode = "Block" | "Filesystem"

package/src/resources/persistent/claim/index.ts

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

package/src/resources/persistent/claim/pvc.ts

@@ -0,0 +1,52 @@
+import { manifest, relations, ResourcesSpec, Unit } from "@k8ts/instruments"
+import type { CDK } from "../../../_imports"
+import { v1 } from "../../../api-versions"
+import { k8ts } from "../../../kind-map"
+import { ManifestResource } from "../../../node"
+import { Access } from "../access-mode"
+import type { DataMode } from "../block-mode"
+import type { Volume } from "../volume"
+
+export type Claim<T extends DataMode = DataMode> = Claim.Claim<T>
+export namespace Claim {
+    const pvc_ResourcesSpec = ResourcesSpec.make({
+        storage: Unit.Data
+    })
+    type PvcResourceSpec = typeof pvc_ResourcesSpec
+    type PvcResources = PvcResourceSpec["__INPUT__"]
+    export interface Props<Mode extends DataMode> extends PvcResources {
+        accessModes: Access
+        mode?: Mode
+        bind: Volume.Volume<Mode>
+    }
+
+    const ident = v1.kind("PersistentVolumeClaim")
+    @k8ts(ident)
+    @relations({
+        needs: self => ({
+            bind: self.props.bind
+        })
+    })
+    @manifest({
+        body(self): CDK.KubePersistentVolumeClaimProps {
+            const { storage, accessModes, mode } = self.props
+            const nAccessModes = Access.parse(accessModes)
+            return {
+                spec: {
+                    accessModes: nAccessModes,
+                    volumeName: self.props.bind!.name,
+                    volumeMode: mode,
+                    resources: pvc_ResourcesSpec
+                        .parse({
+                            storage
+                        })
+                        .toObject(),
+                    storageClassName: "standard"
+                }
+            }
+        }
+    })
+    export class Claim<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
+        kind = ident
+    }
+}

package/src/resources/persistent/index.ts

@@ -0,0 +1,10 @@
+import { Access as Access_ } from "./access-mode"
+import { DataMode as DataMode_ } from "./block-mode"
+import { Claim as Claim_ } from "./claim"
+import { Volume as Volume_ } from "./volume"
+export namespace Persistent {
+    export import Claim = Claim_
+    export import Volume = Volume_
+    export import Access = Access_
+    export type DataMode = DataMode_
+}

package/src/resources/persistent/volume/backend.ts

@@ -0,0 +1,14 @@
+export namespace Backend {
+    export interface HostPath {
+        type: "HostPath"
+        path: string
+    }
+    export interface Local {
+        type: "Local"
+        path: string
+    }
+
+    export type Backend = HostPath | Local
+}
+
+export type Backend = Backend.Backend

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

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

package/src/resources/persistent/volume/parse-backend.ts

@@ -0,0 +1,23 @@
+import { MakeError } from "../../../error"
+import { Backend } from "./backend"
+export function parseBackend(backend: Backend) {
+    switch (backend.type) {
+        case "HostPath":
+            return {
+                hostPath: {
+                    path: backend.path,
+                    type: backend.type
+                }
+            }
+        case "Local":
+            return {
+                local: {
+                    path: backend.path
+                }
+            }
+        default:
+            throw new MakeError(`Unknown backend kind!`, {
+                backend
+            })
+    }
+}

package/src/resources/persistent/volume/pv.ts

@@ -0,0 +1,56 @@
+import { manifest, relations, type Unit } from "@k8ts/instruments"
+import { CDK } from "../../../_imports"
+import { v1 } from "../../../api-versions"
+import { k8ts } from "../../../kind-map"
+import { ManifestResource } from "../../../node/manifest-resource"
+import { Access } from "../access-mode"
+import type { DataMode } from "../block-mode"
+import { Backend as Backend_ } from "./backend"
+import { parseBackend } from "./parse-backend"
+
+export type Volume<T extends DataMode = DataMode> = Volume.Volume<T>
+export namespace Volume {
+    export import Backend = Backend_
+    export interface Props<Mode extends DataMode = DataMode> {
+        accessModes: Access
+        storageClassName?: string
+        mode?: Mode
+        reclaimPolicy?: Reclaim
+        capacity?: Unit.Data
+        backend: Backend
+        nodeAffinity?: CDK.VolumeNodeAffinity
+    }
+    export type Reclaim = "Retain" | "Delete" | "Recycle"
+
+    const ident = v1.kind("PersistentVolume")
+
+    @manifest({
+        body(self) {
+            const pvProps = self.props
+            const accessModes = Access.parse(pvProps.accessModes)
+            let base: CDK.PersistentVolumeSpec = {
+                accessModes,
+                storageClassName: pvProps.storageClassName,
+                capacity: pvProps.capacity
+                    ? {
+                          storage: CDK.Quantity.fromString(pvProps.capacity)
+                      }
+                    : undefined,
+                volumeMode: pvProps.mode ?? "Filesystem",
+                persistentVolumeReclaimPolicy: pvProps.reclaimPolicy ?? "Retain"
+            }
+            base = {
+                ...base,
+                ...parseBackend(pvProps.backend)
+            }
+            return {
+                spec: base
+            }
+        }
+    })
+    @k8ts(ident)
+    @relations("none")
+    export class Volume<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
+        declare readonly kind: typeof ident
+    }
+}

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

@@ -0,0 +1,137 @@
+import {
+    Env,
+    PortSet,
+    relations,
+    ResourcesSpec,
+    Unit,
+    type CmdBuilder,
+    type InputEnvMapping,
+    type InputPortSetRecord,
+    type TaggedImage
+} from "@k8ts/instruments"
+import { Map } from "immutable"
+import type { CDK } from "../../../_imports"
+import { toContainerPorts, toEnvVars } from "../../utils/adapters"
+
+import { seq } from "doddle"
+import { mapKeys, mapValues } from "lodash"
+import type { ManifestResource } from "../../../node"
+import { SubResource } from "../../../node/sub-resource"
+import { Mount as Mount_ } from "./mounts"
+export type Container<Ports extends string> = Container.Container<Ports>
+export namespace Container {
+    export import Mount = Mount_
+    const container_ResourcesSpec = ResourcesSpec.make({
+        cpu: Unit.Cpu,
+        memory: Unit.Data
+    })
+
+    type Resources = (typeof container_ResourcesSpec)["__INPUT__"]
+    export type Mounts = {
+        [key: string]: Mount.ContainerDeviceMount | Mount.ContainerVolumeMount
+    }
+    export interface Props<Ports extends string> {
+        image: TaggedImage
+        ports: InputPortSetRecord<Ports>
+        command?: CmdBuilder
+        mounts?: Mounts
+        env?: InputEnvMapping
+        securityContext?: CDK.SecurityContext
+        resources?: Resources
+    }
+    @relations({
+        needs: self => {
+            const a = self.mounts
+            return mapValues(
+                mapKeys(a, x => x.path),
+                x => x.mount.parent
+            )
+        }
+    })
+    export class Container<Ports extends string> extends SubResource<Props<Ports>> {
+        get kind() {
+            return this.parent.kind.subkind("Container")
+        }
+        get mounts() {
+            return Map(this.props.mounts ?? {})
+                .mapEntries(([path, mount]) => {
+                    return [
+                        mount,
+                        {
+                            mount,
+                            path: path as string
+                        }
+                    ]
+                })
+                .valueSeq()
+                .toArray()
+        }
+
+        get volumes() {
+            return seq(this.mounts.map(x => x.mount.parent))
+                .uniq()
+                .toArray()
+                .pull()
+        }
+        get ports() {
+            return PortSet.make(this.props.ports)
+        }
+        submanifest(): CDK.Container {
+            const self = this
+            const { image, ports, command, env, securityContext } = self.props
+            const container: CDK.Container = {
+                name: self.name,
+                image: image.text,
+                ports: toContainerPorts(PortSet.make(ports)).valueSeq().toArray(),
+                resources: self._resources()?.toObject(),
+                command: command?.toArray(),
+                env: toEnvVars(Env(env)).valueSeq().toArray(),
+                securityContext,
+                ...self._groupedMounts()
+            }
+            return container
+        }
+        constructor(
+            parent: ManifestResource,
+            name: string,
+            readonly subtype: "init" | "main",
+            override readonly props: Props<Ports>
+        ) {
+            super(parent, name, props)
+        }
+
+        private _groupedMounts() {
+            const x = {
+                volumeMounts: [],
+                volumeDevices: []
+            } as Pick<CDK.Container, "volumeMounts" | "volumeDevices">
+            for (const [path, mount] of Object.entries(this.props.mounts ?? {})) {
+                if (mount instanceof Mount.ContainerDeviceMount) {
+                    x.volumeDevices!.push(mount.submanifest(path))
+                } else {
+                    x.volumeMounts!.push(mount.submanifest(path))
+                }
+            }
+            return x
+        }
+        private _resources() {
+            if (!this.props.resources) {
+                return undefined
+            }
+            const { cpu, memory } = this.props.resources
+            return container_ResourcesSpec.parse({
+                cpu: cpu,
+                memory: memory
+            })
+        }
+    }
+
+    export function make<Ports extends string>(
+        parent: ManifestResource,
+        name: string,
+        subtype: "init" | "main",
+        props: Props<Ports>
+    ) {
+        return new Container(parent, name, subtype, props)
+    }
+}

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

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

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

@@ -0,0 +1,45 @@
+import type { CDK } from "../../../_imports"
+import type { Device } from "../volume/devices"
+import type { Volume } from "../volume/volumes"
+export type Mount = Mount.ContainerVolumeMount | Mount.ContainerDeviceMount
+export namespace Mount {
+    type Path_Rooted = `/${string}`
+    export type Path = `${"" | "." | ".."}${Path_Rooted}`
+
+    export interface Options {
+        readOnly?: boolean
+        subPath?: string
+    }
+    export class ContainerVolumeMount {
+        get kind() {
+            return this.parent.kind.parent.subkind("ContainerVolumeMount")
+        }
+        constructor(
+            readonly parent: Volume.PodVolume,
+            readonly props: Options
+        ) {}
+
+        submanifest(mountPath: string): CDK.VolumeMount {
+            return {
+                name: this.parent.name,
+                mountPath: mountPath,
+                readOnly: this.props.readOnly,
+                subPath: this.props.subPath
+            }
+        }
+    }
+
+    export class ContainerDeviceMount {
+        get kind() {
+            return this.parent.kind.parent.subkind("ContainerDeviceMount")
+        }
+        constructor(readonly parent: Device.PodDevice) {}
+
+        submanifest(devicePath: string): CDK.VolumeDevice {
+            return {
+                devicePath: devicePath,
+                name: this.parent.name
+            }
+        }
+    }
+}

package/src/resources/pod/index.ts

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

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

@@ -0,0 +1,73 @@
+import { manifest, relations } from "@k8ts/instruments"
+import { seq } from "doddle"
+import { omit } from "lodash"
+import { CDK } from "../../_imports"
+import { apps_v1 } from "../../api-versions"
+import { k8ts } from "../../kind-map"
+import { ManifestResource } from "../../node/manifest-resource"
+import { Container } from "./container"
+import { Device, Volume } from "./volume"
+export type PodTemplate<Ports extends string> = PodTemplate.PodTemplate<Ports>
+export namespace PodTemplate {
+    export type Props<Ports extends string> = Omit<
+        CDK.PodSpec,
+        "containers" | "initContainers" | "volumes"
+    > & {
+        POD(scope: PodScope): Iterable<Container.Container<Ports>>
+    }
+    const ident = apps_v1.kind("PodTemplate")
+    @k8ts(ident)
+    @relations({
+        kids: s => [...s.containers, ...s.volumes]
+    })
+    @manifest({
+        body(self): CDK.PodTemplateSpec {
+            const { meta, 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 => x.submanifest()).toArray()
+            return {
+                spec: {
+                    ...omit(props, "POD"),
+                    containers: mainContainers.pull(),
+                    initContainers: initContainers.pull(),
+                    volumes: volumes.pull()
+                }
+            }
+        }
+    })
+    export class PodTemplate<Ports extends string = string> extends ManifestResource<Props<Ports>> {
+        kind = ident
+        readonly containers = seq(() => this.props.POD(new PodScope(this))).cache()
+        readonly mounts = seq(() => this.containers.concatMap(x => x.mounts)).cache()
+        readonly volumes = seq(() => this.containers.concatMap(x => x.volumes)).uniq()
+        readonly ports = seq(() => this.containers.map(x => x.ports)).reduce((a, b) => a.union(b))
+    }
+
+    export class PodScope {
+        constructor(private readonly _parent: PodTemplate) {}
+        Container<Ports extends string>(
+            name: string,
+            options: Container.Props<Ports>
+        ): Container<Ports> {
+            return Container.make(this._parent, name, "main", options)
+        }
+        InitContainer(name: string, options: Container.Props<never>): Container<never> {
+            return Container.make(this._parent, name, "init", options)
+        }
+        Volume(name: string, options: Volume.Backend) {
+            return Volume.make(this._parent, name, options)
+        }
+        Device(name: string, options: Device.Backend): Device {
+            return Device.make(this._parent, name, options)
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+import { relations } from "@k8ts/instruments"
+import type { CDK } from "../../../_imports"
+import type { ManifestResource } from "../../../node"
+import { SubResource } from "../../../node/sub-resource"
+import { Persistent } from "../../persistent"
+import { Mount } from "../container/mounts"
+export type Device = Device.PodDevice
+export namespace Device {
+    interface PodDevice_Backend_Pvc {
+        backend: Persistent.Claim<"Block">
+        readOnly?: boolean
+    }
+
+    export type Backend = PodDevice_Backend_Pvc
+    @relations({
+        needs: self => ({
+            backend: self.backend.backend
+        })
+    })
+    export class PodDevice extends SubResource<PodDevice_Backend_Pvc> {
+        get kind() {
+            return this.parent.kind.subkind("Device")
+        }
+        constructor(
+            parent: ManifestResource,
+            name: string,
+            readonly backend: PodDevice_Backend_Pvc
+        ) {
+            super(parent, name, backend)
+        }
+
+        submanifest(): CDK.Volume {
+            return {
+                name: this.name,
+                persistentVolumeClaim: {
+                    claimName: this.backend.backend.name,
+                    readOnly: this.backend.readOnly
+                }
+            }
+        }
+
+        mount() {
+            return new Mount.ContainerDeviceMount(this)
+        }
+    }
+
+    export function make(parent: ManifestResource, name: string, input: Backend) {
+        return new PodDevice(parent, name, input)
+    }
+}

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

@@ -0,0 +1,3 @@
+export { Mount } from "../container/mounts"
+export { Device } from "./devices"
+export { Volume } from "./volumes"

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

@@ -0,0 +1,90 @@
+import type { CDK } from "../../../_imports"
+
+import { relations } from "@k8ts/instruments"
+import type { ManifestResource } from "../../../node"
+import { SubResource } from "../../../node/sub-resource"
+import type { ConfigMap } from "../../configmap"
+import type { Persistent } from "../../persistent"
+import type { Secret } from "../../secret"
+import { Mount } from "../container/mounts"
+export type Volume<Props extends Volume.Backend = Volume.Backend> = Volume.PodVolume<Props>
+export namespace Volume {
+    interface PodVolume_Backend_Pvc {
+        backend: Persistent.Claim<"Filesystem">
+        readOnly?: boolean
+    }
+
+    interface PodVolume_Backend_ConfigMap {
+        backend: ConfigMap
+    }
+    interface PodVolume_Backend_Secret {
+        backend: Secret
+    }
+    export type Backend =
+        | PodVolume_Backend_Pvc
+        | PodVolume_Backend_ConfigMap
+        | PodVolume_Backend_Secret
+    @relations({
+        needs: self => ({
+            backend: self.props.backend
+        })
+    })
+    export abstract class PodVolume<Props extends Backend = Backend> extends SubResource<Props> {
+        private KIND = "Volume" as const
+        get kind() {
+            return this.parent.kind.subkind("Volume")
+        }
+
+        abstract submanifest(): CDK.Volume
+
+        Mount(options?: Mount.Options) {
+            return new Mount.ContainerVolumeMount(this as any, options ?? {})
+        }
+    }
+
+    class PvcPodVolume extends PodVolume<PodVolume_Backend_Pvc> {
+        override submanifest(): CDK.Volume {
+            return {
+                name: this.name,
+                persistentVolumeClaim: {
+                    claimName: this.props.backend.name,
+                    readOnly: this.props.readOnly
+                }
+            }
+        }
+    }
+
+    class ConfigMapPodVolume extends PodVolume<PodVolume_Backend_ConfigMap> {
+        override submanifest(): CDK.Volume {
+            return {
+                name: this.name,
+                configMap: {
+                    name: this.props.backend.name
+                }
+            }
+        }
+    }
+
+    class SecretPodVolume extends PodVolume<PodVolume_Backend_Secret> {
+        override submanifest(): CDK.Volume {
+            return {
+                name: this.name,
+                secret: {
+                    secretName: this.props.backend.name
+                }
+            }
+        }
+    }
+
+    export function make(parent: ManifestResource, name: string, input: Backend): PodVolume {
+        const { backend } = input
+        switch (backend.kind.name) {
+            case "PersistentVolumeClaim":
+                return new PvcPodVolume(parent, name, input as PodVolume_Backend_Pvc)
+            case "ConfigMap":
+                return new ConfigMapPodVolume(parent, name, input as PodVolume_Backend_ConfigMap)
+            case "Secret":
+                return new SecretPodVolume(parent, name, input as PodVolume_Backend_Secret)
+        }
+    }
+}

package/src/resources/secret/index.ts

@@ -0,0 +1,3 @@
+import * as Secret from "./secret"
+type Secret = Secret.Secret
+export { Secret }

package/src/resources/secret/secret.ts

@@ -0,0 +1,25 @@
+import { manifest, relations } from "@k8ts/instruments"
+import { CDK } from "../../_imports"
+import { v1 } from "../../api-versions"
+import { k8ts } from "../../kind-map"
+import { ManifestResource } from "../../node/manifest-resource"
+
+export interface Props {
+    data: Record<string, string>
+    stringData: Record<string, string>
+}
+
+const ident = v1.kind("Secret")
+@k8ts(ident)
+@relations("none")
+@manifest({
+    body(self): CDK.KubeSecretProps {
+        return {
+            data: self.props.data,
+            stringData: self.props.stringData
+        }
+    }
+})
+export class Secret extends ManifestResource<Props> {
+    kind = ident
+}

package/src/resources/service/frontend.ts

@@ -0,0 +1,11 @@
+export namespace Frontend {
+    export interface ClusterIp {
+        type: "ClusterIP"
+    }
+
+    export interface LoadBalancer {
+        type: "LoadBalancer"
+        loadBalancerIP?: string
+    }
+}
+export type Frontend = Frontend.ClusterIp | Frontend.LoadBalancer