k8ts 0.8.1 → 0.9.2

package/src/resources/index.ts

@@ -1,9 +1,13 @@
 export * from "./configmap"
 export * from "./cronjob"
 export * from "./deployment"
+export * from "./external"
 export * from "./http-route/http-route"
 export * from "./namespace"
 export * from "./persistent"
 export * from "./pod"
+export * from "./rbac/cluster-role"
+export * from "./rbac/cluster-role-binding"
+export * from "./rbac/service-account"
 export * from "./secret"
 export * from "./service"

package/src/resources/namespace/namespace.ts

@@ -1,27 +1,19 @@
-import { manifest, relations, type Origin } from "@k8ts/instruments"
-import { Meta, MutableMeta } from "@k8ts/metadata"
-import { CDK } from "../../_imports"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import { ManifestResource } from "../../node/manifest-resource"
-export type Namespace = Namespace.Namespace
-export namespace Namespace {
-    export interface Props {}
-    @k8ts(api.v1_.Namespace)
-    @relations("none")
-    @equiv_cdk8s(CDK.KubeNamespace)
-    @manifest({
-        body(self): CDK.KubeNamespaceProps {
-            return {
-                spec: {}
-            }
-        }
-    })
-    export class Namespace extends ManifestResource<Props> {
-        override kind = api.v1_.Namespace
-        constructor(origin: Origin, meta: Meta | MutableMeta, props?: Props) {
-            super(origin, meta.toMutable(), props ?? {})
+import { Resource_Top } from "@k8ts/instruments"
+import { v1 } from "../../kinds/default"
+export interface Namespace_Props {}
+
+export class Namespace<Name extends string = string> extends Resource_Top<Name, Namespace_Props> {
+    constructor(name: Name, props: Namespace_Props = {}) {
+        super(name, props)
+    }
+    declare name: Name
+    get kind() {
+        return v1.Namespace._
+    }
+
+    protected body() {
+        return {
+            spec: {}
         }
     }
 }

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

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

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

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

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

@@ -1,67 +1,66 @@
-import { manifest, relations, ResourcesSpec, Unit } from "@k8ts/instruments"
-import { CDK } from "../../../_imports"
+import { Resource_Top, ResourcesSpec, Unit, type Resource_Full_Ref } from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
 import { Prefix$ } from "../../../_type/prefix$"
 import { MakeError } from "../../../error"
-import { External } from "../../../external"
-import { k8ts } from "../../../kind-map"
-import { api } from "../../../kinds"
-import { ManifestResource } from "../../../node"
-import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
+import { v1 } from "../../../kinds/default"
+import { storage } from "../../../kinds/storage"
 import { Access } from "../access-mode"
-import type { DataMode } from "../block-mode"
-import { Pv } from "../volume"
+import type { Pv_VolumeMode } from "../block-mode"
+import type { Pv, Pv_Ref } from "../volume"
 
-export type Pvc<T extends DataMode = DataMode> = Pvc.Pvc<T>
-export namespace Pvc {
-    const pvc_ResourcesSpec = ResourcesSpec.make({
-        storage: Unit.Data
-    })
-    type PvcResourceSpec = typeof pvc_ResourcesSpec
-    type PvcResources = Prefix$<PvcResourceSpec["__INPUT__"]>
-    export interface Props<Mode extends DataMode> extends PvcResources {
-        $accessModes: Access
-        $mode?: Mode
-        $storageClass?: External<api.storage_.v1_.StorageClass>
-        $bind?: Pv.AbsPv<Mode>
+const StorageClassKind = storage.v1.StorageClass._
+
+const pvc_ResourcesSpec = ResourcesSpec.make({
+    storage: Unit.Data
+})
+type Pvc_Resources = Prefix$<(typeof pvc_ResourcesSpec)["__INPUT__"]>
+export interface Pvc_Props<Mode extends Pv_VolumeMode> extends Pvc_Resources {
+    $accessModes: Access
+    $mode?: Mode
+    $storageClass?: Resource_Full_Ref<typeof StorageClassKind>
+    $bind?: Pv_Ref<Mode>
+}
+
+export class Pvc<Mode extends Pv_VolumeMode, Name extends string = string> extends Resource_Top<
+    Name,
+    Pvc_Props<Mode>
+> {
+    declare name: Name
+    get kind() {
+        return v1.PersistentVolumeClaim._
     }
 
-    @k8ts(api.v1_.PersistentVolumeClaim)
-    @equiv_cdk8s(CDK.KubePersistentVolumeClaim)
-    @relations({
-        needs: self => ({
+    protected __needs__() {
+        const self = this
+        return {
             bind: self.bound,
             storageClass: self.props.$storageClass
-        })
-    })
-    @manifest({
-        body(self): CDK.KubePersistentVolumeClaimProps {
-            const { $storage, $accessModes, $mode, $storageClass, $bind } = self.props
-            const nAccessModes = Access.parse($accessModes)
-            if (!$bind && !$storageClass) {
-                throw new MakeError(
-                    `While manifesting ${self.node.format("source")}, PVC that doesn't have a $bind must have a $storageClass.`
-                )
-            }
-            return {
-                spec: {
-                    accessModes: nAccessModes,
-                    volumeName: self.props.$bind?.name,
-                    volumeMode: $mode,
-                    resources: pvc_ResourcesSpec
-                        .parse({
-                            storage: $storage
-                        })
-                        .toObject(),
-                    storageClassName: self.props.$storageClass?.name ?? "standard"
-                }
-            }
         }
-    })
-    export class Pvc<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
-        kind = api.v1_.PersistentVolumeClaim
-
-        get bound() {
-            return this.props.$bind as Pv<Mode>
+    }
+    protected body(): CDK.KubePersistentVolumeClaimProps {
+        const self = this
+        const { $storage, $accessModes, $mode, $storageClass, $bind } = self.props
+        const nAccessModes = Access.pv_parseAccessMode($accessModes)
+        if (!$bind && !$storageClass) {
+            throw new MakeError(
+                `While manifesting ${self.node.format("source")}, PVC that doesn't have a $bind must have a $storageClass.`
+            )
         }
+        return {
+            spec: {
+                accessModes: nAccessModes,
+                volumeName: self.props.$bind?.name,
+                volumeMode: $mode,
+                resources: pvc_ResourcesSpec
+                    .parse({
+                        storage: $storage
+                    })
+                    .toObject(),
+                storageClassName: self.props.$storageClass?.name ?? "standard"
+            }
+        }
+    }
+    get bound() {
+        return this.props.$bind as Pv<Mode> | undefined
     }
 }

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

@@ -1,6 +1,6 @@
 import { MakeError } from "../../../error"
-import { Backend } from "./backend"
-export function parseBackend(backend?: Backend) {
+import type { Pv_Backend } from "./pv"
+export function parseBackend(backend?: Pv_Backend) {
     switch (backend?.type) {
         case undefined:
         case null:

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

@@ -1,82 +1,100 @@
-import { manifest, Refable, relations, type Unit } from "@k8ts/instruments"
-import { CDK } from "../../../_imports"
+import {
+    Resource_Core_Ref,
+    Resource_Top,
+    type Resource_Full_Ref,
+    type Unit
+} from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
 import { MakeError } from "../../../error"
-import { External } from "../../../external"
-import { k8ts } from "../../../kind-map"
-import { api } from "../../../kinds"
-import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
-import { ManifestResource } from "../../../node/manifest-resource"
+import { v1 } from "../../../kinds/default"
+import { storage } from "../../../kinds/storage"
 import { Access } from "../access-mode"
-import type { DataMode } from "../block-mode"
-import { Backend as Backend_ } from "./backend"
+import type { Pv_VolumeMode } from "../block-mode"
 import { parseBackend } from "./parse-backend"
 
-export type Pv<T extends DataMode = DataMode> = Pv.Pv<T>
-export namespace Pv {
-    export import Backend = Backend_
-    export interface Props<Mode extends DataMode = DataMode> {
-        $accessModes: Access
-        $storageClass?: External<api.storage_.v1_.StorageClass>
-        $mode?: Mode
-        reclaimPolicy?: Reclaim
-        $capacity: Unit.Data
-        $backend?: Backend
-        mountOptions?: string[]
-        nodeAffinity?: CDK.VolumeNodeAffinity
-    }
-    export type Reclaim = "Retain" | "Delete" | "Recycle"
-    export type AbsPv<Mode extends DataMode = DataMode> = Refable<api.v1_.PersistentVolume> & {
+const StorageClassKind = storage.v1.StorageClass._
+
+export interface Pv_Backend_HostPath {
+    type: "HostPath"
+    hostpathType: string
+    path: string
+}
+export interface Pv_Backend_Local {
+    type: "Local"
+    path: string
+}
+export interface Pv_Backend_Nfs {
+    type: "NFS"
+    server: string
+    path: string
+}
+
+export type Pv_Backend = Pv_Backend_HostPath | Pv_Backend_Local | Pv_Backend_Nfs
+export interface Pv_Props_K8ts<Mode extends Pv_VolumeMode = Pv_VolumeMode> {
+    $accessModes: Access
+    $storageClass?: Resource_Full_Ref<storage.v1.StorageClass._>
+    $mode?: Mode
+    reclaimPolicy?: Reclaim
+    $capacity: Unit.Data
+    $backend?: Pv_Backend
+    mountOptions?: string[]
+    nodeAffinity?: CDK.VolumeNodeAffinity
+}
+export type Reclaim = "Retain" | "Delete" | "Recycle"
+export type Pv_Ref<Mode extends Pv_VolumeMode = Pv_VolumeMode> =
+    Resource_Core_Ref<v1.PersistentVolume._> & {
         __MODE__: Mode
     }
-    @equiv_cdk8s(CDK.KubePersistentVolume)
-    @manifest({
-        body(self) {
-            const pvProps = self.props
-            const accessModes = Access.parse(pvProps.$accessModes)
-            if (self.props.$backend?.type === "Local") {
-                if (!pvProps.nodeAffinity) {
-                    throw new MakeError(
-                        `While manifesting ${self.node.format("source")}, PV with Local backend must have nodeAffinity.`
-                    )
-                }
-            }
-            if (!self.props.$backend && !self.props.$storageClass) {
+
+export class Pv<
+    Mode extends Pv_VolumeMode = "Filesystem",
+    Name extends string = string
+> extends Resource_Top<Name, Pv_Props_K8ts<Mode>> {
+    __MODE__!: Mode
+    get kind() {
+        return v1.PersistentVolume._
+    }
+
+    protected __needs__() {
+        return {
+            storageClass: this.props.$storageClass
+        }
+    }
+    protected body() {
+        const self = this
+        const pvProps = self.props
+        const accessModes = Access.pv_parseAccessMode(pvProps.$accessModes)
+        if (self.props.$backend?.type === "Local") {
+            if (!pvProps.nodeAffinity) {
                 throw new MakeError(
-                    `While manifesting ${self.node.format("source")}, PV that doesn't have a $backend must have a $storageClass.`
+                    `While manifesting ${self.node.format("source")}, PV with Local backend must have nodeAffinity.`
                 )
             }
-            let base: CDK.PersistentVolumeSpec = {
-                accessModes,
-                storageClassName: pvProps.$storageClass?.name ?? "standard",
-                capacity: pvProps.$capacity
-                    ? {
-                          storage: CDK.Quantity.fromString(pvProps.$capacity)
-                      }
-                    : undefined,
-                volumeMode: pvProps.$mode ?? "Filesystem",
-                mountOptions: pvProps.mountOptions,
-                persistentVolumeReclaimPolicy: pvProps.reclaimPolicy ?? "Retain",
-                nodeAffinity: pvProps.nodeAffinity
-            }
-            base = {
-                ...base,
-                ...parseBackend(pvProps.$backend)
-            }
-            return {
-                spec: base
-            }
         }
-    })
-    @k8ts(api.v1_.PersistentVolume)
-    @relations({
-        needs(self) {
-            return {
-                storageClass: self.props.$storageClass
-            }
+        if (!self.props.$backend && !self.props.$storageClass) {
+            throw new MakeError(
+                `While manifesting ${self.node.format("source")}, PV that doesn't have a $backend must have a $storageClass.`
+            )
+        }
+        let base: CDK.PersistentVolumeSpec = {
+            accessModes,
+            storageClassName: pvProps.$storageClass?.name ?? "standard",
+            capacity: pvProps.$capacity
+                ? {
+                      storage: CDK.Quantity.fromString(pvProps.$capacity)
+                  }
+                : undefined,
+            volumeMode: pvProps.$mode ?? "Filesystem",
+            mountOptions: pvProps.mountOptions,
+            persistentVolumeReclaimPolicy: pvProps.reclaimPolicy ?? "Retain",
+            nodeAffinity: pvProps.nodeAffinity
+        }
+        base = {
+            ...base,
+            ...parseBackend(pvProps.$backend)
+        }
+        return {
+            spec: base
         }
-    })
-    export class Pv<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
-        __MODE__!: Mode
-        readonly kind = api.v1_.PersistentVolume
     }
 }

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

@@ -1,148 +1,141 @@
 import {
-    Kinded,
     PortSet,
-    relations,
     ResourcesSpec,
     Unit,
-    WritableDeep,
     type CmdBuilder,
     type InputPortSetRecord,
     type TaggedImage
 } from "@k8ts/instruments"
-import { Map } from "immutable"
-import type { CDK } from "../../../_imports"
+import type { CDK } from "@k8ts/sample-interfaces"
 import { toContainerPorts } from "../../utils/adapters"
 
+import type { Resource_Entity, Resource_Min_Ref, Resource_Top } from "@k8ts/instruments"
+import { Resource_Child } from "@k8ts/instruments"
 import { seq } from "doddle"
 import { mapKeys, mapValues, omitBy } from "lodash"
 import { Env, type InputEnvMapping } from "../../../env"
-import { k8ts } from "../../../kind-map"
-import { api } from "../../../kinds"
-import type { ManifestResource } from "../../../node"
-import { SubResource } from "../../../node/sub-resource"
-import { Mount as Mount_ } from "./mounts"
-export type Container<Ports extends string = string> = Container.Container<Ports>
-export namespace Container {
-    export import Mount = Mount_
-    const container_ResourcesSpec = ResourcesSpec.make({
-        cpu: Unit.Cpu,
-        memory: Unit.Data
-    })
+import { v1 } from "../../../kinds/default"
+import { Container_Mount_Device, type Container_Mount } from "./mounts"
+const container_ResourcesSpec = ResourcesSpec.make({
+    cpu: Unit.Cpu,
+    memory: Unit.Data
+})
 
-    type Resources = (typeof container_ResourcesSpec)["__INPUT__"]
-    type SomeMount = Kinded<api.v1_.Pod_.DeviceMount | api.v1_.Pod_.VolumeMount>
-    export type Mounts = {
-        [key: string]: SomeMount
+type Container_Resources = (typeof container_ResourcesSpec)["__INPUT__"]
+type Container_Mount_Some = Resource_Min_Ref<
+    v1.Pod.Container.DeviceMount._ | v1.Pod.Container.VolumeMount._
+>
+export type Container_Mounts = {
+    [key: string]: Container_Mount_Some
+}
+interface Container_Props_K8ts<Ports extends string = never> {
+    $image: TaggedImage
+    $ports?: InputPortSetRecord<Ports>
+    $command?: CmdBuilder
+    $mounts?: Container_Mounts
+    $env?: InputEnvMapping
+    $resources?: Container_Resources
+}
+
+export type Container_Props<Ports extends string = never> = Container_Props_K8ts<Ports> &
+    Omit<CDK.Container, keyof Container_Props_K8ts | "name">
+
+export class Container<Ports extends string = string> extends Resource_Child<
+    Container_Props<Ports>
+> {
+    __PORTS__!: Ports
+    get kind() {
+        return v1.Pod.Container._
     }
-    interface K8tsPropsClean<Ports extends string = never> {
-        image: TaggedImage
-        ports?: InputPortSetRecord<Ports>
-        command?: CmdBuilder
-        mounts?: Mounts
-        env?: InputEnvMapping
-        resources?: Resources
+
+    protected __needs__(): Record<string, Resource_Entity | Resource_Entity[] | undefined> {
+        const a = this.mounts
+        return mapValues(
+            mapKeys(a, x => x.path),
+            x => x.mount.volume
+        )
     }
-    export type K8tsProps<Ports extends string = never> = {
-        [key in keyof K8tsPropsClean<Ports> as `$${key}`]: K8tsPropsClean<Ports>[key]
+    get mounts() {
+        return seq(Object.entries(this.props.$mounts ?? {}))
+            .map(([path, mount]) => {
+                return {
+                    mount: mount as Container_Mount,
+                    path: path as string
+                }
+            })
+            .toArray()
+            .pull()
     }
-    export type Props<Ports extends string = never> = K8tsProps<Ports> &
-        WritableDeep<Omit<CDK.Container, keyof K8tsPropsClean | "name">>
-
-    @k8ts(api.v1_.Pod_.Container)
-    @relations({
-        needs: self => {
-            const a = self.mounts
-            return mapValues(
-                mapKeys(a, x => x.path),
-                x => x.mount.volume
-            )
-        }
-    })
-    export class Container<Ports extends string = string> extends SubResource<Props<Ports>> {
-        __PORTS__!: Ports
-        readonly kind = api.v1_.Pod_.Container
 
-        get mounts() {
-            return Map(this.props.$mounts ?? {})
-                .mapEntries(([path, mount]) => {
-                    return [
-                        mount,
-                        {
-                            mount: mount as Mount.ContainerVolumeMount | Mount.ContainerDeviceMount,
-                            path: path as string
-                        }
-                    ]
-                })
-                .valueSeq()
-                .toArray()
-        }
-
-        get volumes() {
-            return seq(this.mounts.map(x => x.mount.volume))
-                .uniq()
+    get volumes() {
+        return seq(this.mounts.map(x => x.mount.volume))
+            .uniq()
+            .toArray()
+            .pull()
+    }
+    get ports() {
+        return PortSet.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(PortSet.make($ports)).values())
                 .toArray()
                 .pull()
+        const container: CDK.Container = {
+            ...untaggedProps,
+            name: self.name,
+            image: $image.toString(),
+            ports: containerPorts,
+            resources: resourcesObject,
+            command: $command?.toArray(),
+            env: Env($env).toEnvVars(),
+            ...self._groupedMounts()
         }
-        get ports() {
-            return PortSet.make(this.props.$ports)
-        }
-        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 container: CDK.Container = {
-                ...untaggedProps,
-                name: self.name,
-                image: $image.toString(),
-                ports: $ports && toContainerPorts(PortSet.make($ports)).valueSeq().toArray(),
-                resources: resourcesObject,
-                command: $command?.toArray(),
-                env: Env($env).toEnvVars(),
-                ...self._groupedMounts()
-            }
-            return container
-        }
-        constructor(
-            parent: ManifestResource,
-            name: string,
-            readonly subtype: "init" | "main",
-            override readonly props: Props<Ports>
-        ) {
-            super(parent, name, props)
-        }
+        return container
+    }
+    constructor(
+        parent: Resource_Entity,
+        name: string,
+        readonly subtype: "init" | "main",
+        override readonly props: Container_Props<Ports>
+    ) {
+        super(parent, name, props)
+    }
 
-        private _groupedMounts() {
-            const x = {
-                volumeMounts: [],
-                volumeDevices: []
-            } as Pick<CDK.Container, "volumeMounts" | "volumeDevices">
-            for (const mnt of this.mounts) {
-                const { mount, path } = mnt
-                if (mount instanceof Mount.ContainerDeviceMount) {
-                    x.volumeDevices!.push(mount.submanifest(path))
-                } else {
-                    x.volumeMounts!.push(mount.submanifest(path))
-                }
+    private _groupedMounts() {
+        const x = {
+            volumeMounts: [],
+            volumeDevices: []
+        } as Pick<CDK.Container, "volumeMounts" | "volumeDevices">
+        for (const mnt of this.mounts) {
+            const { mount, path } = mnt
+            if (mount instanceof Container_Mount_Device) {
+                x.volumeDevices!.push(mount["__submanifest__"](path))
+            } else {
+                x.volumeMounts!.push(mount["__submanifest__"](path))
             }
-            return x
         }
-        private _resources() {
-            if (!this.props.$resources) {
-                return undefined
-            }
-            const result = container_ResourcesSpec.parse(this.props.$resources)
-            return result
+        return x
+    }
+    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: ManifestResource,
-        name: string,
-        subtype: "init" | "main",
-        props: Props<Ports>
-    ) {
-        return new Container(parent, name, subtype, props)
-    }
+export function make<Ports extends string>(
+    parent: Resource_Top,
+    name: string,
+    subtype: "init" | "main",
+    props: Container_Props<Ports>
+) {
+    return new Container(parent, name, subtype, props)
 }