k8ts 0.8.1 → 0.9.2

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

@@ -1,50 +1,53 @@
-import type { CDK } from "../../../_imports"
-import { api } from "../../../kinds"
-import { Volume } from "../volume"
-import type { Device } from "../volume/devices"
-export type Mount = Mount.ContainerVolumeMount | Mount.ContainerDeviceMount
-export namespace Mount {
-    type Path_Rooted = `/${string}`
-    export type Path = `${"" | "." | ".."}${Path_Rooted}`
+import { Kind } from "@k8ts/instruments"
+import type { CDK } from "@k8ts/sample-interfaces"
+import { v1 } from "../../../kinds/default"
+import type { Pod_Volume } from "../volume"
+import type { Pod_Device } from "../volume/devices"
+type Path_Rooted = `/${string}`
+export type Container_Mount_Path = `${"" | "." | ".."}${Path_Rooted}`
 
-    export interface Props {
-        readOnly?: boolean
-        subPath?: string
-        volume: Volume
+export type Container_Mount = Container_Mount_Volume | Container_Mount_Device
+export interface Container_Mount_Props {
+    readOnly?: boolean
+    subPath?: string
+    volume: Pod_Volume
+}
+export class Container_Mount_Volume {
+    get kind() {
+        return v1.Pod.Container.VolumeMount._
     }
-    export class ContainerVolumeMount {
-        readonly kind = api.v1_.Pod_.VolumeMount
 
-        constructor(readonly props: Props) {}
+    constructor(readonly props: Container_Mount_Props) {}
 
-        get volume() {
-            return this.props.volume
-        }
-        submanifest(mountPath: string): CDK.VolumeMount {
-            return {
-                name: this.props.volume.name,
-                mountPath: mountPath,
-                readOnly: this.props.readOnly,
-                subPath: this.props.subPath
-            }
+    get volume() {
+        return this.props.volume
+    }
+    protected __submanifest__(mountPath: string): CDK.VolumeMount {
+        return {
+            name: this.props.volume.name,
+            mountPath: mountPath,
+            readOnly: this.props.readOnly,
+            subPath: this.props.subPath
         }
     }
+}
 
-    export interface DeviceMountProps {
-        device: Device
-    }
+export interface Container_Mount_Device_Props {
+    device: Pod_Device
+}
 
-    export class ContainerDeviceMount {
-        kind = api.v1_.Pod_.DeviceMount
-        get volume() {
-            return this.props.device
-        }
-        constructor(readonly props: DeviceMountProps) {}
-        submanifest(devicePath: string): CDK.VolumeDevice {
-            return {
-                devicePath: devicePath,
-                name: this.props.device.name
-            }
+export class Container_Mount_Device {
+    get kind() {
+        return v1.Pod.Container.DeviceMount._ satisfies Kind.SubKind
+    }
+    get volume() {
+        return this.props.device
+    }
+    constructor(readonly props: Container_Mount_Device_Props) {}
+    protected __submanifest__(devicePath: string): CDK.VolumeDevice {
+        return {
+            devicePath: devicePath,
+            name: this.props.device.name
         }
     }
 }

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

@@ -1,82 +1,95 @@
-import { Kinded, manifest, Producer, relations } from "@k8ts/instruments"
+import { Resource_Child, Resource_Min_Ref } from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import { CDK } from "@k8ts/sample-interfaces"
 import { seq } from "doddle"
 import { omitBy } from "lodash"
-import { CDK } from "../../_imports"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { ManifestResource } from "../../node/manifest-resource"
-import { Container } from "./container"
-import { Device, Volume } from "./volume"
-export type PodTemplate<Ports extends string = string> = PodTemplate.PodTemplate<Ports>
-export namespace PodTemplate {
-    export type PodProps = Omit<CDK.PodSpec, "containers" | "initContainers" | "volumes">
-    type AbsContainer<Ports extends string> = Kinded<api.v1_.Pod_.Container> & {
-        __PORTS__: Ports
+import { v1 } from "../../kinds/default"
+import { Container, type Container_Props } from "./container"
+import { Pod_Device, type Pod_Device_Backend } from "./volume/devices"
+import { Pod_Volume, type Pod_Volume_Backend } from "./volume/volumes"
+export type Pod_Props_Original = Omit<CDK.PodSpec, "containers" | "initContainers" | "volumes">
+type Container_Ref<Ports extends string> = Resource_Min_Ref<v1.Pod.Container._> & {
+    __PORTS__: Ports
+}
+export type Pod_Container_Producer<Ports extends string> = (
+    scope: PodScope
+) => 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 Resource_Child<Pod_Props<Ports>> {
+    get kind() {
+        return v1.PodTemplate._
     }
-    export type PodContainerProducer<Ports extends string> = Producer<PodScope, AbsContainer<Ports>>
-    export type Props<Ports extends string> = PodProps & {
-        $POD: PodContainerProducer<Ports>
+    readonly containers = seq(() => this.props.$POD(new PodScope(this)))
+        .map(x => {
+            return x as Container<Ports>
+        })
+        .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))
+
+    protected __kids__() {
+        return [...this.containers, ...this.volumes]
     }
-    export type HostPortSpec<Ports extends string> = {
-        [port in Ports]?: {
-            ip?: string
-            port?: number
+    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)
 
-    @k8ts(api.v1_.PodTemplate)
-    @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()
+    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 => x.submanifest()).toArray()
-            return {
-                spec: {
-                    ...omitBy(props, (x, k) => k.startsWith("$")),
-                    containers: mainContainers.pull(),
-                    initContainers: initContainers.pull(),
-                    volumes: volumes.pull()
+        const volumes = self.volumes
+            .map(x => {
+                if (x instanceof Pod_Volume) {
+                    return x["__submanifest__"]()
                 }
+                return x["__submanifest__"]()
+            })
+            .toArray()
+        return {
+            metadata: self.__metadata__(),
+            spec: {
+                ...omitBy(props, (x, k) => k.startsWith("$")),
+                containers: mainContainers.pull(),
+                initContainers: initContainers.pull(),
+                volumes: volumes.pull()
             }
         }
-    })
-    export class PodTemplate<Ports extends string = string> extends ManifestResource<Props<Ports>> {
-        readonly kind = api.v1_.PodTemplate
-        readonly containers = seq(() => this.props.$POD(new PodScope(this)))
-            .map(x => {
-                return x as Container<Ports>
-            })
-            .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>) {
-            return new Container.Container(this._parent, name, "main", options)
-        }
-        InitContainer(name: string, options: Container.K8tsProps<never>) {
-            return new Container.Container(this._parent, name, "init", options)
-        }
-        Volume(name: string, options: Volume.Backend) {
-            return Volume.make(this._parent, name, options)
-        }
-        Device(name: string, options: Device.Backend) {
-            return Device.make(this._parent, name, options)
-        }
+export class PodScope {
+    constructor(private readonly _parent: Pod_Template) {}
+    Container<Ports extends string>(name: string, options: Container_Props<Ports>) {
+        return new Container(this._parent, name, "main", options)
+    }
+    InitContainer(name: string, options: Container_Props<never>) {
+        return new Container(this._parent, name, "init", options)
+    }
+    Volume(name: string, options: Pod_Volume_Backend) {
+        return Pod_Volume.make(this._parent, name, options)
+    }
+    Device(name: string, options: Pod_Device_Backend) {
+        return new Pod_Device(this._parent, name, options)
     }
 }

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

@@ -1,53 +1,52 @@
-import { relations } from "@k8ts/instruments"
-import type { CDK } from "../../../_imports"
-import { k8ts } from "../../../kind-map"
-import { api } from "../../../kinds"
-import type { ManifestResource } from "../../../node"
-import { SubResource } from "../../../node/sub-resource"
+import type { Resource_Entity } from "@k8ts/instruments"
+import { Resource_Child } from "@k8ts/instruments"
+import type { CDK } from "@k8ts/sample-interfaces"
+import { v1 } from "../../../kinds/default"
 import { Pvc } from "../../persistent"
-import { Mount } from "../container/mounts"
-export type Device = Device.PodDevice
-export namespace Device {
-    interface PodDevice_Backend_Pvc {
-        $backend: Pvc.Pvc<"Block">
-        readOnly?: boolean
+import { Container_Mount_Device } from "../container/mounts"
+interface Pod_Device_Backend_Pvc {
+    $backend: Pvc<"Block">
+    readOnly?: boolean
+}
+
+export type Pod_Device_Backend = Pod_Device_Backend_Pvc
+
+export class Pod_Device extends Resource_Child<Pod_Device_Backend_Pvc> {
+    get kind() {
+        return v1.Pod.Device._
     }
 
-    export type Backend = PodDevice_Backend_Pvc
-    @k8ts(api.v1_.Pod_.Device)
-    @relations({
-        needs: self => ({
-            backend: self.backend.$backend
-        })
-    })
-    export class PodDevice extends SubResource<PodDevice_Backend_Pvc> {
-        readonly kind = api.v1_.Pod_.Device
-        constructor(
-            parent: ManifestResource,
-            name: string,
-            readonly backend: PodDevice_Backend_Pvc
-        ) {
-            super(parent, name, backend)
-        }
+    constructor(
+        parent: Resource_Entity,
+        name: string,
+        readonly backend: Pod_Device_Backend_Pvc
+    ) {
+        super(parent, name, backend)
+    }
 
-        submanifest(): CDK.Volume {
-            return {
-                name: this.name,
-                persistentVolumeClaim: {
-                    claimName: this.backend.$backend.name,
-                    readOnly: this.backend.readOnly
-                }
-            }
+    protected __needs__(): Record<string, Resource_Entity | Resource_Entity[] | undefined> {
+        return {
+            backend: this.backend.$backend
         }
+    }
 
-        Mount() {
-            return new Mount.ContainerDeviceMount({
-                device: this
-            })
+    protected __submanifest__(): CDK.Volume {
+        return {
+            name: this.name,
+            persistentVolumeClaim: {
+                claimName: this.backend.$backend.name,
+                readOnly: this.backend.readOnly
+            }
         }
     }
 
-    export function make(parent: ManifestResource, name: string, input: Backend) {
-        return new PodDevice(parent, name, input)
+    Mount() {
+        return new Container_Mount_Device({
+            device: this
+        })
     }
 }
+
+export function make(parent: Resource_Entity, name: string, input: Pod_Device_Backend) {
+    return new Pod_Device(parent, name, input)
+}

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

@@ -1,3 +1,2 @@
-export { Mount } from "../container/mounts"
-export { Device } from "./devices"
-export { Volume } from "./volumes"
+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,94 +1,116 @@
-import type { CDK } from "../../../_imports"
+import type { CDK } from "@k8ts/sample-interfaces"
 
-import { relations } from "@k8ts/instruments"
-import { k8ts } from "../../../kind-map"
-import { api } from "../../../kinds"
-import type { ManifestResource } from "../../../node"
-import { SubResource } from "../../../node/sub-resource"
+import type { Resource_Entity } from "@k8ts/instruments"
+import { Resource_Child } from "@k8ts/instruments"
+import { v1 } from "../../../kinds/default"
 import type { ConfigMap } from "../../configmap"
-import { Pvc } from "../../persistent"
+import { Pvc, type Pv_VolumeMode } 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: Pvc.Pvc<"Filesystem">
-        readOnly?: boolean
-    }
+import { Container_Mount_Volume, type Container_Mount_Props } from "../container/mounts"
 
-    interface PodVolume_Backend_ConfigMap {
-        $backend: ConfigMap
-    }
-    interface PodVolume_Backend_Secret {
-        $backend: Secret
-    }
-    export type Backend =
-        | PodVolume_Backend_Pvc
-        | PodVolume_Backend_ConfigMap
-        | PodVolume_Backend_Secret
+interface Pod_Volume_Backend_Pvc<Mode extends Pv_VolumeMode = Pv_VolumeMode> {
+    $backend: Pvc<Mode>
+    readOnly?: boolean
+}
 
-    @k8ts(api.v1_.Pod_.Volume)
-    @relations({
-        needs: self => ({
-            backend: self.props.$backend
-        })
-    })
-    export abstract class PodVolume<Props extends Backend = Backend> extends SubResource<Props> {
-        readonly kind = api.v1_.Pod_.Volume
+interface Pod_Volume_Backend_ConfigMap {
+    $backend: ConfigMap
+}
+interface Pod_Volume_Backend_Secret {
+    $backend: Secret
+}
+export type Pod_Volume_Backend<Mode extends Pv_VolumeMode = Pv_VolumeMode> =
+    | Pod_Volume_Backend_Pvc<Mode>
+    | Pod_Volume_Backend_ConfigMap
+    | Pod_Volume_Backend_Secret
 
-        abstract submanifest(): CDK.Volume
+export abstract class Pod_Volume<
+    Props extends Pod_Volume_Backend = Pod_Volume_Backend
+> extends Resource_Child<Props> {
+    get kind() {
+        return v1.Pod.Volume._
+    }
 
-        Mount(options?: Omit<Mount.Props, "volume">) {
-            return new Mount.ContainerVolumeMount({
-                volume: this,
-                ...options
-            })
+    static make<Mode extends Pv_VolumeMode>(
+        parent: Resource_Entity,
+        name: string,
+        backend: Pod_Volume_Backend<Mode>
+    ): Pod_Volume<Pod_Volume_Backend<Mode>> {
+        switch (backend.$backend.kind.name) {
+            case "PersistentVolumeClaim":
+                return new Pod_Volume_Pvc<Mode>(
+                    parent,
+                    name,
+                    backend as Pod_Volume_Backend_Pvc<Mode>
+                )
+            case "ConfigMap":
+                return new Pod_Volume_ConfigMap(
+                    parent,
+                    name,
+                    backend as Pod_Volume_Backend_ConfigMap
+                )
+            case "Secret":
+                return new Pod_Volume_Secret(parent, name, backend as Pod_Volume_Backend_Secret)
         }
     }
 
-    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
-                }
-            }
+    protected __needs__(): Record<string, Resource_Entity | Resource_Entity[] | undefined> {
+        return {
+            backend: this.props.$backend
         }
     }
+    Mount(options?: Omit<Container_Mount_Props, "volume">) {
+        return new Container_Mount_Volume({
+            volume: this,
+            ...options
+        })
+    }
+
+    protected abstract __submanifest__(): CDK.Volume
+}
 
-    class ConfigMapPodVolume extends PodVolume<PodVolume_Backend_ConfigMap> {
-        override submanifest(): CDK.Volume {
-            return {
-                name: this.name,
-                configMap: {
-                    name: this.props.$backend.name
-                }
+class Pod_Volume_Pvc<Mode extends Pv_VolumeMode> extends Pod_Volume<Pod_Volume_Backend_Pvc<Mode>> {
+    protected __submanifest__(): CDK.Volume {
+        return {
+            name: this.name,
+            persistentVolumeClaim: {
+                claimName: this.props.$backend.name,
+                readOnly: this.props.readOnly
             }
         }
     }
+}
 
-    class SecretPodVolume extends PodVolume<PodVolume_Backend_Secret> {
-        override submanifest(): CDK.Volume {
-            return {
-                name: this.name,
-                secret: {
-                    secretName: this.props.$backend.name
-                }
+class Pod_Volume_ConfigMap extends Pod_Volume<Pod_Volume_Backend_ConfigMap> {
+    protected __submanifest__(): CDK.Volume {
+        return {
+            name: this.name,
+            configMap: {
+                name: 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)
+class Pod_Volume_Secret extends Pod_Volume<Pod_Volume_Backend_Secret> {
+    protected __submanifest__(): CDK.Volume {
+        return {
+            name: this.name,
+            secret: {
+                secretName: this.props.$backend.name
+            }
         }
     }
 }
+
+export function make(parent: Resource_Entity, name: string, input: Pod_Volume_Backend): Pod_Volume {
+    const { $backend } = input
+    switch ($backend.kind.name) {
+        case "PersistentVolumeClaim":
+            return new Pod_Volume_Pvc(parent, name, input as Pod_Volume_Backend_Pvc)
+        case "ConfigMap":
+            return new Pod_Volume_ConfigMap(parent, name, input as Pod_Volume_Backend_ConfigMap)
+        case "Secret":
+            return new Pod_Volume_Secret(parent, name, input as Pod_Volume_Backend_Secret)
+    }
+}

package/src/resources/rbac/cluster-role-binding.ts

@@ -0,0 +1,40 @@
+import { Resource_Top } from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
+import { rbac } from "../../kinds/rbac"
+import type { ClusterRole } from "./cluster-role"
+import type { ServiceAccount } from "./service-account"
+
+export interface ClusterRoleBoding_Props {
+    $role: ClusterRole
+    $subjects: ServiceAccount[]
+}
+
+export class ClusterRoleBinding<Name extends string = string> extends Resource_Top<
+    Name,
+    ClusterRoleBoding_Props
+> {
+    get kind() {
+        return rbac.v1.ClusterRoleBinding._
+    }
+
+    protected __needs__() {
+        return {
+            role: this.props.$role,
+            subjects: this.props.$subjects
+        }
+    }
+    protected body(): CDK.KubeClusterRoleBindingProps {
+        return {
+            roleRef: {
+                apiGroup: this.props.$role.kind.parent!.text,
+                kind: this.props.$role.kind.name,
+                name: this.props.$role.name
+            },
+            subjects: this.props.$subjects.map(sa => ({
+                kind: sa.kind.name,
+                name: sa.name,
+                namespace: sa.namespace!
+            }))
+        }
+    }
+}