k8ts 0.4.23 → 0.5.0

package/src/resources/http-route/http-route.ts

@@ -11,16 +11,16 @@ export type HttpRoute<Ports extends string> = HttpRoute.HttpRoute<Ports>
 
 export namespace HttpRoute {
     export interface Props<Ports extends string> {
-        gateway: External<api.gateway_.v1_.Gateway>
-        hostname: string
-        backend: Service.Port<Ports>
+        $gateway: External<api.gateway_.v1_.Gateway>
+        $hostname: string
+        $backend: Service.Port<Ports>
     }
 
     @k8ts(api.gateway_.v1_.HttpRoute)
     @relations({
         needs: self => ({
-            gateway: self.props.gateway,
-            service: self.props.backend.service
+            gateway: self.props.$gateway,
+            service: self.props.$backend.service
         })
     })
     @equiv_cdk8s(CDK.HttpRoute)
@@ -28,11 +28,11 @@ export namespace HttpRoute {
         body(self): CDK.HttpRouteProps {
             return {
                 spec: {
-                    parentRefs: [self.props.gateway.ref()],
-                    hostnames: [self.props.hostname],
+                    parentRefs: [self.props.$gateway.ref()],
+                    hostnames: [self.props.$hostname],
                     rules: [
                         {
-                            backendRefs: [self.props.backend.ref()]
+                            backendRefs: [self.props.$backend.ref()]
                         }
                     ]
                 }

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

@@ -1,5 +1,6 @@
 import { manifest, relations, ResourcesSpec, Unit } from "@k8ts/instruments"
 import { CDK } from "../../../_imports"
+import { Prefix$ } from "../../../_type/prefix$"
 import { k8ts } from "../../../kind-map"
 import { api } from "../../../kinds"
 import { ManifestResource } from "../../../node"
@@ -14,11 +15,11 @@ export namespace Pvc {
         storage: Unit.Data
     })
     type PvcResourceSpec = typeof pvc_ResourcesSpec
-    type PvcResources = PvcResourceSpec["__INPUT__"]
+    type PvcResources = Prefix$<PvcResourceSpec["__INPUT__"]>
     export interface Props<Mode extends DataMode> extends PvcResources {
-        accessModes: Access
-        mode?: Mode
-        bind: Pv.AbsPv<Mode>
+        $accessModes: Access
+        $mode?: Mode
+        $bind: Pv.AbsPv<Mode>
     }
 
     @k8ts(api.v1_.PersistentVolumeClaim)
@@ -30,16 +31,16 @@ export namespace Pvc {
     })
     @manifest({
         body(self): CDK.KubePersistentVolumeClaimProps {
-            const { storage, accessModes, mode } = self.props
-            const nAccessModes = Access.parse(accessModes)
+            const { $storage, $accessModes, $mode } = self.props
+            const nAccessModes = Access.parse($accessModes)
             return {
                 spec: {
                     accessModes: nAccessModes,
-                    volumeName: self.props.bind!.name,
-                    volumeMode: mode,
+                    volumeName: self.props.$bind!.name,
+                    volumeMode: $mode,
                     resources: pvc_ResourcesSpec
                         .parse({
-                            storage
+                            storage: $storage
                         })
                         .toObject(),
                     storageClassName: "standard"
@@ -51,7 +52,7 @@ export namespace Pvc {
         kind = api.v1_.PersistentVolumeClaim
 
         get bound() {
-            return this.props.bind as Pv<Mode>
+            return this.props.$bind as Pv<Mode>
         }
     }
 }

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

@@ -14,12 +14,12 @@ 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
+        $accessModes: Access
         storageClassName?: string
-        mode?: Mode
+        $mode?: Mode
         reclaimPolicy?: Reclaim
-        capacity: Unit.Data
-        backend: Backend
+        $capacity: Unit.Data
+        $backend: Backend
         nodeAffinity?: CDK.VolumeNodeAffinity
     }
     export type Reclaim = "Retain" | "Delete" | "Recycle"
@@ -30,8 +30,8 @@ export namespace Pv {
     @manifest({
         body(self) {
             const pvProps = self.props
-            const accessModes = Access.parse(pvProps.accessModes)
-            if (self.props.backend.type === "Local") {
+            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.`
@@ -41,18 +41,18 @@ export namespace Pv {
             let base: CDK.PersistentVolumeSpec = {
                 accessModes,
                 storageClassName: pvProps.storageClassName ?? "standard",
-                capacity: pvProps.capacity
+                capacity: pvProps.$capacity
                     ? {
-                          storage: CDK.Quantity.fromString(pvProps.capacity)
+                          storage: CDK.Quantity.fromString(pvProps.$capacity)
                       }
                     : undefined,
-                volumeMode: pvProps.mode ?? "Filesystem",
+                volumeMode: pvProps.$mode ?? "Filesystem",
                 persistentVolumeReclaimPolicy: pvProps.reclaimPolicy ?? "Retain",
                 nodeAffinity: pvProps.nodeAffinity
             }
             base = {
                 ...base,
-                ...parseBackend(pvProps.backend)
+                ...parseBackend(pvProps.$backend)
             }
             return {
                 spec: base

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

@@ -16,7 +16,7 @@ import type { CDK } from "../../../_imports"
 import { toContainerPorts, toEnvVars } from "../../utils/adapters"
 
 import { seq } from "doddle"
-import { mapKeys, mapValues } from "lodash"
+import { mapKeys, mapValues, omitBy } from "lodash"
 import { k8ts } from "../../../kind-map"
 import { api } from "../../../kinds"
 import type { ManifestResource } from "../../../node"
@@ -36,17 +36,19 @@ export namespace Container {
         [key: string]: SomeMount
     }
 
-    export interface K8tsProps<Ports extends string = never> {
+    interface K8tsPropsClean<Ports extends string = never> {
         image: TaggedImage
         ports?: InputPortSetRecord<Ports>
         command?: CmdBuilder
         mounts?: Mounts
         env?: InputEnvMapping
-        securityContext?: CDK.SecurityContext
         resources?: Resources
     }
+    export type K8tsProps<Ports extends string = never> = {
+        [key in keyof K8tsPropsClean<Ports> as `$${key}`]: K8tsPropsClean<Ports>[key]
+    }
     export type Props<Ports extends string = never> = K8tsProps<Ports> &
-        WritableDeep<Omit<CDK.Container, keyof K8tsProps | "name">>
+        WritableDeep<Omit<CDK.Container, keyof K8tsPropsClean | "name">>
 
     @k8ts(api.v1_.Pod_.Container)
     @relations({
@@ -63,7 +65,7 @@ export namespace Container {
         readonly kind = api.v1_.Pod_.Container
 
         get mounts() {
-            return Map(this.props.mounts ?? {})
+            return Map(this.props.$mounts ?? {})
                 .mapEntries(([path, mount]) => {
                     return [
                         mount,
@@ -84,19 +86,20 @@ export namespace Container {
                 .pull()
         }
         get ports() {
-            return PortSet.make(this.props.ports)
+            return PortSet.make(this.props.$ports)
         }
         submanifest(): CDK.Container {
             const self = this
-            const { image, ports, command, env, securityContext } = self.props
+            const { $image, $ports, $command, $env } = self.props
+            const untaggedProps = omitBy(self.props, (_, k) => k.startsWith("$"))
             const container: CDK.Container = {
+                ...untaggedProps,
                 name: self.name,
-                image: image.toString(),
-                ports: ports && toContainerPorts(PortSet.make(ports)).valueSeq().toArray(),
+                image: $image.toString(),
+                ports: $ports && toContainerPorts(PortSet.make($ports)).valueSeq().toArray(),
                 resources: self._resources()?.toObject(),
-                command: command?.toArray(),
-                env: toEnvVars(Env(env)).valueSeq().toArray(),
-                securityContext,
+                command: $command?.toArray(),
+                env: toEnvVars(Env($env)).valueSeq().toArray(),
                 ...self._groupedMounts()
             }
             return container
@@ -105,7 +108,7 @@ export namespace Container {
             parent: ManifestResource,
             name: string,
             readonly subtype: "init" | "main",
-            override readonly props: K8tsProps<Ports>
+            override readonly props: Props<Ports>
         ) {
             super(parent, name, props)
         }
@@ -126,10 +129,10 @@ export namespace Container {
             return x
         }
         private _resources() {
-            if (!this.props.resources) {
+            if (!this.props.$resources) {
                 return undefined
             }
-            const { cpu, memory } = this.props.resources
+            const { cpu, memory } = this.props.$resources
             return container_ResourcesSpec.parse({
                 cpu: cpu,
                 memory: memory

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

@@ -1,6 +1,6 @@
 import { Kinded, manifest, Producer, relations } from "@k8ts/instruments"
 import { seq } from "doddle"
-import { omit } from "lodash"
+import { omitBy } from "lodash"
 import { CDK } from "../../_imports"
 import { k8ts } from "../../kind-map"
 import { api } from "../../kinds"
@@ -15,7 +15,7 @@ export namespace PodTemplate {
     }
     export type PodContainerProducer<Ports extends string> = Producer<PodScope, AbsContainer<Ports>>
     export type Props<Ports extends string> = PodProps & {
-        POD: PodContainerProducer<Ports>
+        $POD: PodContainerProducer<Ports>
     }
     export type HostPortSpec<Ports extends string> = {
         [port in Ports]?: {
@@ -23,10 +23,7 @@ export namespace PodTemplate {
             port?: number
         }
     }
-    export interface HostNetInput<Ports extends string> {
-        hostNetwork?: boolean
-        ports: HostPortSpec<Ports>
-    }
+
     @k8ts(api.v1_.PodTemplate)
     @relations({
         kids: s => [...s.containers, ...s.volumes]
@@ -47,7 +44,7 @@ export namespace PodTemplate {
             const volumes = self.volumes.map(x => x.submanifest()).toArray()
             return {
                 spec: {
-                    ...omit(props, "POD"),
+                    ...omitBy(props, (x, k) => k.startsWith("$")),
                     containers: mainContainers.pull(),
                     initContainers: initContainers.pull(),
                     volumes: volumes.pull()
@@ -57,7 +54,7 @@ export namespace PodTemplate {
     })
     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)))
+        readonly containers = seq(() => this.props.$POD(new PodScope(this)))
             .map(x => {
                 return x as Container<Ports>
             })

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

@@ -9,7 +9,7 @@ import { Mount } from "../container/mounts"
 export type Device = Device.PodDevice
 export namespace Device {
     interface PodDevice_Backend_Pvc {
-        backend: Pvc.Pvc<"Block">
+        $backend: Pvc.Pvc<"Block">
         readOnly?: boolean
     }
 
@@ -17,7 +17,7 @@ export namespace Device {
     @k8ts(api.v1_.Pod_.Device)
     @relations({
         needs: self => ({
-            backend: self.backend.backend
+            backend: self.backend.$backend
         })
     })
     export class PodDevice extends SubResource<PodDevice_Backend_Pvc> {
@@ -34,7 +34,7 @@ export namespace Device {
             return {
                 name: this.name,
                 persistentVolumeClaim: {
-                    claimName: this.backend.backend.name,
+                    claimName: this.backend.$backend.name,
                     readOnly: this.backend.readOnly
                 }
             }

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

@@ -12,15 +12,15 @@ 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">
+        $backend: Pvc.Pvc<"Filesystem">
         readOnly?: boolean
     }
 
     interface PodVolume_Backend_ConfigMap {
-        backend: ConfigMap
+        $backend: ConfigMap
     }
     interface PodVolume_Backend_Secret {
-        backend: Secret
+        $backend: Secret
     }
     export type Backend =
         | PodVolume_Backend_Pvc
@@ -30,7 +30,7 @@ export namespace Volume {
     @k8ts(api.v1_.Pod_.Volume)
     @relations({
         needs: self => ({
-            backend: self.props.backend
+            backend: self.props.$backend
         })
     })
     export abstract class PodVolume<Props extends Backend = Backend> extends SubResource<Props> {
@@ -51,7 +51,7 @@ export namespace Volume {
             return {
                 name: this.name,
                 persistentVolumeClaim: {
-                    claimName: this.props.backend.name,
+                    claimName: this.props.$backend.name,
                     readOnly: this.props.readOnly
                 }
             }
@@ -63,7 +63,7 @@ export namespace Volume {
             return {
                 name: this.name,
                 configMap: {
-                    name: this.props.backend.name
+                    name: this.props.$backend.name
                 }
             }
         }
@@ -74,15 +74,15 @@ export namespace Volume {
             return {
                 name: this.name,
                 secret: {
-                    secretName: this.props.backend.name
+                    secretName: this.props.$backend.name
                 }
             }
         }
     }
 
     export function make(parent: ManifestResource, name: string, input: Backend): PodVolume {
-        const { backend } = input
-        switch (backend.kind.name) {
+        const { $backend } = input
+        switch ($backend.kind.name) {
             case "PersistentVolumeClaim":
                 return new PvcPodVolume(parent, name, input as PodVolume_Backend_Pvc)
             case "ConfigMap":

package/src/resources/service/service.ts

@@ -20,9 +20,9 @@ export namespace Service {
     export import Port = Port_
     export import Frontend = Frontend_
     export interface Props<DeployPorts extends string, ExposedPorts extends DeployPorts> {
-        ports: InputPortMapping<ExposedPorts>
-        backend: Deployment.AbsDeployment<DeployPorts>
-        frontend: Frontend
+        $ports: InputPortMapping<ExposedPorts>
+        $backend: Deployment.AbsDeployment<DeployPorts>
+        $frontend: Frontend
     }
     export type AbsService<ExposedPorts extends string> = Refable<api.v1_.Service> & {
         __PORTS__: ExposedPorts
@@ -39,12 +39,12 @@ export namespace Service {
             const svcPorts = self.ports
             return {
                 spec: {
-                    ...self.props.frontend,
+                    ...self.props.$frontend,
                     ports: toServicePorts(svcPorts).toArray(),
                     selector: {
-                        app: self.props.backend.name
+                        app: self.props.$backend.name
                     },
-                    ...(self.props.frontend.type === "LoadBalancer"
+                    ...(self.props.$frontend.type === "LoadBalancer"
                         ? {
                               allocateLoadBalancerNodePorts: false,
                               externalTrafficPolicy: "Local"
@@ -61,15 +61,15 @@ export namespace Service {
         kind = api.v1_.Service
 
         private get backend() {
-            return this.props.backend as Deployment<ExposedPorts>
+            return this.props.$backend as Deployment<ExposedPorts>
         }
         get ports() {
             const srcPorts = this.backend.ports.pull()
-            const knownPorts = Map(this.props.ports)
+            const knownPorts = Map(this.props.$ports)
                 .filter(x => x !== undefined)
                 .keySeq()
                 .toArray() as ExposedPorts[]
-            const svcPorts = srcPorts.pick(...knownPorts).map(this.props.ports as any)
+            const svcPorts = srcPorts.pick(...knownPorts).map(this.props.$ports as any)
             return svcPorts
         }