k8ts 0.13.2 → 0.14.0

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

@@ -1,34 +1,13 @@
-import { Ident_Kind, Rsc_Top, type Ident_Group } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
+import { K8sResource } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
 import { seq } from "doddle"
-import { rbac } from "../../kinds/rbac"
-export interface ClusterRole_Rule<
-    Groups extends Ident_Group[] = Ident_Group[],
-    Resources extends Ident_Kind<Groups[number]["name"], string, string>[] = Ident_Kind[]
+import { merge } from "lodash"
+import { rbac } from "../../gvks/rbac"
+import { type ClusterRole_Props, type ClusterRole_Rule, ClusterRole_Scope } from "./role-props"
+export class ClusterRole<Name extends string = string> extends K8sResource<
+    Name,
+    ClusterRole_Props
 > {
-    resources: Resources
-    verbs: Verbs[]
-}
-export type ClusterRole_RuleProducer<Rules extends ClusterRole_Rule> = (
-    scope: ClusterRole_Scope
-) => Iterable<Rules>
-class ClusterRole_Scope {
-    Rule<const R extends Ident_Kind[]>(...resources: R) {
-        return {
-            verbs(...verbs: Verbs[]) {
-                return {
-                    resources: resources,
-                    verbs: verbs
-                }
-            }
-        }
-    }
-}
-export interface ClusterRole_Props<Rules extends ClusterRole_Rule = ClusterRole_Rule> {
-    rules: ClusterRole_RuleProducer<Rules>
-}
-
-export class ClusterRole<Name extends string = string> extends Rsc_Top<Name, ClusterRole_Props> {
     get kind() {
         return rbac.v1.ClusterRole._
     }
@@ -38,21 +17,22 @@ export class ClusterRole<Name extends string = string> extends Rsc_Top<Name, Clu
 
     private _fromObject(rule: ClusterRole_Rule) {
         return {
-            apiGroups: Array.from(new Set(rule.resources.map(x => x.parent.parent.name))),
+            apiGroups: Array.from(new Set(rule.resources.map(x => x.parent.parent.value))),
             resources: rule.resources.map(r => r.plural),
             verbs: rule.verbs
         }
     }
-    protected body(): CDK.KubeClusterRoleProps {
-        const rules = seq(this.props.rules(new ClusterRole_Scope()))
+    protected __body__(): K8S.KubeClusterRoleProps {
+        const rules = seq(this.props.rules$(new ClusterRole_Scope()))
             .map(rule => {
                 return this._fromObject(rule)
             })
             .toArray()
             .pull()
-        return {
+        const body = {
             rules: rules
         }
+        return merge(body, this.props.$$manifest)
     }
 }
 
@@ -65,32 +45,3 @@ export type Verbs =
     | "patch"
     | "delete"
     | "deletecollection"
-
-export type ApiGroup =
-    | "namespaces"
-    | "pods"
-    | "services"
-    | "endpoints"
-    | "persistentvolumeclaims"
-    | "events"
-    | "configmaps"
-    | "secrets"
-    | "httproutes"
-    | "gateways"
-    | "jobs"
-    | "cronjobs"
-    | "deployments"
-    | "replicasets"
-    | "statefulsets"
-    | "daemonsets"
-    | "podtemplates"
-    | "clusterroles"
-    | "roles"
-    | "rolebindings"
-    | "clusterrolebindings"
-    | "serviceaccounts"
-    | "nodes"
-    | "persistentvolumes"
-    | "storageclasses"
-    | "volumeattachments"
-    | "persistentvolumeclaims"

package/src/resources/rbac/role-props.ts

@@ -0,0 +1,26 @@
+import type { Gvk, Resource_Props_Top } from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+import type { Verbs } from "./cluster-role"
+export interface ClusterRole_Rule<Resources extends Gvk[] = Gvk[]> {
+    resources: Resources
+    verbs: Verbs[]
+}
+export type ClusterRole_RuleProducer<Rules extends ClusterRole_Rule> = (
+    Role: ClusterRole_Scope
+) => Iterable<Rules>
+export class ClusterRole_Scope {
+    Rule<const R extends Gvk[]>(...resources: R) {
+        return {
+            verbs(...verbs: Verbs[]) {
+                return {
+                    resources: resources,
+                    verbs: verbs
+                }
+            }
+        }
+    }
+}
+export interface ClusterRole_Props<Rules extends ClusterRole_Rule = ClusterRole_Rule>
+    extends Resource_Props_Top<K8S.KubeClusterRoleProps> {
+    rules$: ClusterRole_RuleProducer<Rules>
+}

package/src/resources/rbac/service-account.ts

@@ -1,25 +1,27 @@
-import { Rsc_Top } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
-import { v1 } from "../../kinds/default"
-export interface ServiceAccount_Props {
-    automountToken?: boolean
-    imagePullSecrets?: string[]
+import { K8sResource, type Resource_Props_Top } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../gvks/default"
+export interface ServiceAccount_Props extends Resource_Props_Top<K8S.KubeServiceAccountProps> {
+    $automountToken?: boolean
+    $imagePullSecrets?: string[]
 }
 
-export class ServiceAccount<Name extends string = string> extends Rsc_Top<
+export class ServiceAccount<Name extends string = string> extends K8sResource<
     Name,
     ServiceAccount_Props
 > {
     get kind() {
         return v1.ServiceAccount._
     }
-    protected body(): CDK.KubeServiceAccountProps {
+    protected __body__(): K8S.KubeServiceAccountProps {
         const self = this
-        return {
-            automountServiceAccountToken: self.props.automountToken,
-            imagePullSecrets: self.props.imagePullSecrets?.map(name => ({
+        const body = {
+            automountServiceAccountToken: self.props.$automountToken,
+            imagePullSecrets: self.props.$imagePullSecrets?.map(name => ({
                 name
             }))
-        }
+        } satisfies K8S.KubeServiceAccountProps
+        return merge(body, self.props.$$manifest)
     }
 }

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

@@ -0,0 +1,74 @@
+import {
+    CronStanza,
+    K8sResource,
+    TemplateOrigin,
+    type Cron_Record,
+    type Resource_Props_Top,
+    type ResourceRef,
+    type Timezone
+} from "@k8ts/instruments"
+import { type Metadata_Input } from "@k8ts/metadata"
+import { K8S } from "@k8ts/sample-interfaces"
+import { doddlify } from "doddle"
+import { merge, omitBy } from "lodash"
+import { batch } from "../../../gvks/batch"
+import { Pod, Pod_Props } from "../pod/pod"
+import { createSelectionMetadata } from "../util"
+export interface CronJob_Props<CronSpec extends Cron_Record>
+    extends Resource_Props_Top<K8S.KubeCronJobProps> {
+    $schedule: CronStanza<CronSpec>
+    $template: Pod_Props<never> & {
+        restartPolicy: "Always" | "OnFailure" | "Never"
+    }
+    $metadata?: Metadata_Input
+    timeZone: Timezone
+}
+
+export class CronJob<
+    Name extends string = string,
+    Cron extends Cron_Record = Cron_Record
+> extends K8sResource<Name, CronJob_Props<Cron>> {
+    private _template = new TemplateOrigin("CronJobTemplate", {
+        owner: this
+    })
+    get kind() {
+        return batch.v1.CronJob._
+    }
+    get selectorLabels() {
+        return createSelectionMetadata(this)
+    }
+    @doddlify
+    get PodTemplate() {
+        const p = new Pod(this.ident.name, this.props.$template, {
+            origins: {
+                own: this._template,
+                subscope: this.__origin__
+            },
+            metadata: this.selectorLabels
+        })
+        return p
+    }
+
+    protected __kids__(): Iterable<ResourceRef> {
+        this.PodTemplate
+        return super.__kids__()
+    }
+
+    protected async __body__(): Promise<K8S.KubeCronJobProps> {
+        const self = this
+        const template = await self.PodTemplate["__manifest__"]()
+        const object = {
+            spec: {
+                ...omitBy(self.props, (x, k) => k.startsWith("$") || k === "timeZone"),
+                schedule: self.props.$schedule.toString(),
+                timeZone: self.props.timeZone,
+                jobTemplate: {
+                    spec: {
+                        template: template
+                    }
+                }
+            }
+        }
+        return merge(object, self.props.$$manifest)
+    }
+}

package/src/resources/workload/daemonset/daemonset.ts

@@ -0,0 +1,82 @@
+import { K8sResource, ResourceRef, TemplateOrigin } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { doddlify } from "doddle"
+import { merge, omit } from "lodash"
+import { apps } from "../../../gvks/apps"
+import { K8tsResourceError } from "../../errors"
+import { Pod } from "../pod/pod"
+import { createSelectionMetadata } from "../util"
+import type { Workload_Ref } from "../workload-ref"
+import type { DaemonSet_Props } from "./props"
+
+export class DaemonSet<Name extends string, Ports extends string = string>
+    extends K8sResource<Name, DaemonSet_Props<Ports>>
+    implements Workload_Ref<Ports>
+{
+    private _template = new TemplateOrigin("DaemonSetTemplate", {
+        owner: this
+    })
+    get kind() {
+        return apps.v1.DaemonSet._
+    }
+
+    get selectorLabels() {
+        return createSelectionMetadata(this)
+    }
+
+    protected __kids__(): Iterable<ResourceRef> {
+        return [this.PodTemplate]
+    }
+
+    protected async __body__(): Promise<K8S.KubeDaemonSetProps> {
+        const self = this
+        const template = await self.PodTemplate["__manifest__"]()
+        const noKindFields = omit(template, ["kind", "apiVersion"])
+        const spec = {
+            selector: {
+                matchLabels: this.selectorLabels.labels
+            },
+            template: noKindFields,
+            updateStrategy: self._updateStrategy
+        } satisfies K8S.DaemonSetSpec
+        const spec2 = merge(spec, self.props.$$manifest)
+        return {
+            spec: spec2
+        }
+    }
+
+    private get _updateStrategy() {
+        const strategy = this.props.$updateStrategy
+        if (!strategy) {
+            return undefined
+        }
+        if (strategy.type === "OnDelete") {
+            return { type: "OnDelete" }
+        }
+        if (strategy.type === "RollingUpdate") {
+            return {
+                type: "RollingUpdate",
+                rollingUpdate: omit(strategy, "type")
+            }
+        }
+        throw new K8tsResourceError(`Invalid update strategy type: ${strategy}`)
+    }
+
+    @doddlify
+    get PodTemplate() {
+        const self = this
+        const resource = new Pod(`${self.ident.name}`, self.props.$template, {
+            origins: {
+                subscope: self.__origin__,
+                own: self._template
+            },
+            metadata: this.selectorLabels
+        })
+
+        return resource
+    }
+
+    get ports() {
+        return this.PodTemplate.ports
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+import type { Resource_Props_Top } from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+import type { Pod_Props } from "../../.."
+
+export interface DaemonSet_UpdateStrategy_RollingUpdate extends K8S.RollingUpdateDaemonSet {
+    type: "RollingUpdate"
+}
+export interface DaemonSet_UpdateStrategy_OnDelete {
+    type: "OnDelete"
+}
+export type DaemonSet_UpdateStrategy =
+    | DaemonSet_UpdateStrategy_RollingUpdate
+    | DaemonSet_UpdateStrategy_OnDelete
+
+export interface DaemonSet_Props<Ports extends string>
+    extends Resource_Props_Top<K8S.DaemonSetSpec> {
+    $template: Pod_Props<Ports>
+    $updateStrategy?: DaemonSet_UpdateStrategy
+}

package/src/resources/workload/deployment/deployment.ts

@@ -0,0 +1,79 @@
+import { K8sResource, ResourceRef, TemplateOrigin } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { doddlify } from "doddle"
+import { merge, omit } from "lodash"
+import { apps } from "../../../gvks/apps"
+import { K8tsResourceError } from "../../errors"
+import { Pod } from "../pod/pod"
+import { createSelectionMetadata } from "../util"
+import type { Workload_Ref } from "../workload-ref"
+import type { Deployment_Props } from "./props"
+export class Deployment<Name extends string, Ports extends string = string>
+    extends K8sResource<Name, Deployment_Props<Ports>>
+    implements Workload_Ref<Ports>
+{
+    private _template = new TemplateOrigin("DeploymentTemplate", {
+        owner: this
+    })
+    get kind() {
+        return apps.v1.Deployment._
+    }
+
+    get selectorLabels() {
+        return createSelectionMetadata(this)
+    }
+
+    protected __kids__(): Iterable<ResourceRef> {
+        return [this.PodTemplate]
+    }
+    protected async __body__(): Promise<K8S.KubeDeploymentProps> {
+        const self = this
+        const template = await self.PodTemplate["__manifest__"]()
+        const noKindFields = omit(template, ["kind", "apiVersion"])
+        const spec = {
+            replicas: self.props.$replicas,
+            selector: {
+                matchLabels: this.selectorLabels.labels
+            },
+            template: noKindFields,
+            strategy: self._strategy
+        } satisfies K8S.DeploymentSpec
+        const spec2 = merge(spec, self.props.$$manifest)
+        return {
+            spec: spec2
+        }
+    }
+    private get _strategy() {
+        const strat = this.props.$strategy
+        if (!strat) {
+            return undefined
+        }
+        if (strat.type === "Recreate") {
+            return strat
+        }
+        if (strat.type === "RollingUpdate") {
+            return {
+                type: "RollingUpdate",
+                rollingUpdate: omit(strat, "type")
+            }
+        }
+        throw new K8tsResourceError(`Invalid strategy type: ${strat}`)
+    }
+
+    @doddlify
+    get PodTemplate() {
+        const self = this
+        const resource = new Pod(`${self.ident.name}`, self.props.$template, {
+            origins: {
+                own: self._template,
+                subscope: self.__origin__
+            },
+            metadata: this.selectorLabels
+        })
+        return resource
+    }
+
+    get ports() {
+        return this.PodTemplate.ports
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { Resource_Props_Top } from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+import type { Pod_Props } from "../../.."
+
+export interface Deployment_Strategy_RollingUpdate extends K8S.RollingUpdateDeployment {
+    type: "RollingUpdate"
+    options?: K8S.RollingUpdateDeployment
+}
+export interface Deployment_Strategy_Recreate {
+    type: "Recreate"
+}
+export type Deployment_Strategy = Deployment_Strategy_RollingUpdate | Deployment_Strategy_Recreate
+
+export interface Deployment_Props<Ports extends string>
+    extends Resource_Props_Top<K8S.DeploymentSpec> {
+    $replicas?: number
+    $template: Pod_Props<Ports>
+    $strategy?: Deployment_Strategy
+}

package/src/resources/workload/index.ts

@@ -0,0 +1,6 @@
+export * from "./cronjob"
+export * from "./daemonset"
+export * from "./deployment"
+export * from "./pod/pod"
+export * from "./statefulset"
+export * from "./workload-ref"

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

@@ -0,0 +1,227 @@
+import {
+    PortExports,
+    Reqs,
+    Units,
+    type Cmd,
+    type Image,
+    type PortExports_Input,
+    type Resource_Props,
+    type ResourceRef
+} from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
+
+import { K8sResource, ResourceEntity, ResourcePart } from "@k8ts/instruments"
+import { seq } from "doddle"
+import { mapKeys, mapValues, merge } from "lodash"
+import { Env } from "../../../../env"
+import type { EnvValue } from "../../../../env/types"
+import { v1 } from "../../../../gvks/default"
+import { K8tsResourceError } from "../../../errors"
+import { PodDevice, PodVolume } from "../volume"
+import { ContainerDeviceMount, type ContainerDeviceMount_Input } from "./mounts/device"
+import { ContainerVolumeMount, type ContainerVolumeMount_Unbound } from "./mounts/volume"
+import { toContainerPorts } from "./utils"
+const container_ResourcesSpec = new Reqs({
+    cpu: Units.Cpu,
+    memory: Units.Data
+})
+
+type PodContainerResources = (typeof container_ResourcesSpec)["__INPUT__"]
+type PodContainerMountAny =
+    | ContainerVolumeMount_Unbound
+    | ContainerDeviceMount_Input
+    | ResourceRef<v1.Pod.Device._>
+    | ResourceRef<v1.Pod.Volume._>
+export type PodContainer_Mounts = {
+    [key: string]: PodContainerMountAny
+}
+
+export interface PodContainer_EnvFromItem {
+    source: ResourceRef<v1.ConfigMap._> | ResourceRef<v1.Secret._>
+    prefix?: string
+    optional?: boolean
+}
+export interface PodContainer_Props<
+    Ports extends string = never,
+    _Env extends Record<string, EnvValue> = Record<string, EnvValue>
+> extends Resource_Props<Partial<K8S.Container>> {
+    $image: Image
+    $ports?: PortExports_Input<Ports>
+    $command?: Cmd
+    $mounts?: PodContainer_Mounts
+    $env?: _Env
+    $envFrom?: PodContainer_EnvFromItem[]
+    $resources?: PodContainerResources
+}
+
+export class PodContainer<Ports extends string = string> extends ResourcePart<
+    PodContainer_Props<Ports>
+> {
+    __PORTS__!: Ports
+    get kind() {
+        return v1.Pod.Container._
+    }
+
+    protected __needs__(): Record<string, ResourceRef | ResourceRef[]> {
+        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, PodContainerMountAny]) => {
+                if ("kind" in mount) {
+                    var backend = mount
+                } else {
+                    var backend = mount.$backend
+                }
+                if (backend.is(PodDevice)) {
+                    return new ContainerDeviceMount(this, {
+                        $backend: backend,
+                        mountPath: path
+                    })
+                } else if (backend.is(PodVolume)) {
+                    const x = mount as any
+                    return new ContainerVolumeMount(this, {
+                        $backend: backend,
+                        mountPath: path,
+                        readOnly: x.readOnly,
+                        subPath: x.subPath
+                    })
+                }
+                throw new K8tsResourceError(`Unsupported mount backend type: ${backend}`)
+            })
+            .filter(x => !x.props.$noEmit)
+            .toArray()
+            .pull()
+    }
+
+    get volumes() {
+        return seq(this.mounts.map(x => x.backend))
+            .filter(x => {
+                const a = 1
+                return !x.noEmit
+            })
+
+            .uniq()
+            .toArray()
+            .pull()
+    }
+    get ports() {
+        return PortExports(this.props.$ports)
+    }
+    protected __submanifest__(): K8S.Container {
+        const self = this
+        const { $image, $ports, $command, $env } = self.props
+        let resourcesObject = self._resources()?.toObject()
+        const pex = PortExports($ports)
+        const containerPorts = $ports && toContainerPorts(pex)
+
+        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 ResourceEntity) {
+                if (backend.ident.namespace !== self.ident.namespace) {
+                    throw new K8tsResourceError(
+                        `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.ident.namespace !== self.ident.namespace) {
+                throw new K8tsResourceError(
+                    `Volume reference "${vol}" had an inherited namespace ${vol.ident.namespace}, which is different from the container "${self}"`
+                )
+            }
+        }
+        const envFroms = (self.props.$envFrom ?? []).map(ef => {
+            const source = ef.source as any as ResourceEntity
+            if (source.ident.namespace !== self.ident.namespace) {
+                throw new K8tsResourceError(
+                    `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.ident.name
+                    }
+                } as K8S.EnvFromSource
+            } else if (source.is(v1.ConfigMap._)) {
+                return {
+                    configMapRef: {
+                        optional: ef.optional,
+                        name: source.ident.name
+                    }
+                } as K8S.EnvFromSource
+            } else {
+                throw new K8tsResourceError(
+                    `EnvFrom source reference "${source}" must be a ConfigMap or Secret, but was ${source.kind}`
+                )
+            }
+        })
+        const container: K8S.Container = {
+            name: self.ident.name,
+            image: $image.toString(),
+            ports: containerPorts,
+            resources: resourcesObject,
+            command: $command?.toArray(),
+            env: Env($env).toEnvVars(),
+            envFrom: envFroms,
+            ...self._groupedMounts()
+        }
+        return merge(container, self.props.$$manifest)
+    }
+    constructor(
+        parent: ResourceEntity,
+        name: string,
+        readonly subtype: "init" | "main",
+        override readonly props: PodContainer_Props<Ports>
+    ) {
+        super(parent, name, props)
+    }
+
+    private _groupedMounts() {
+        const volumeMounts = [] as K8S.VolumeMount[]
+        const volumeDevices = [] as K8S.VolumeDevice[]
+        for (const mnt of this.mounts) {
+            if (mnt.backend.is(PodDevice)) {
+                const deviceMount = mnt as ContainerDeviceMount
+                volumeDevices!.push(deviceMount["__submanifest__"]())
+            } else if (mnt.backend.is(PodVolume)) {
+                const volumeMount = mnt as ContainerVolumeMount
+                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: K8sResource,
+    name: string,
+    subtype: "init" | "main",
+    props: PodContainer_Props<Ports>
+) {
+    return new PodContainer(parent, name, subtype, props)
+}

package/src/resources/{pod → workload/pod}/container/index.ts

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