k8ts 0.6.0 → 0.7.0

package/src/env/env.ts

@@ -0,0 +1,128 @@
+import { Map, type MapOf } from "immutable"
+import { isObject } from "what-are-you"
+import type { CDK } from "../_imports"
+import { MakeError } from "../error"
+import { api } from "../kinds"
+import type { EnvVarFrom, InputEnv, InputEnvMapping } from "./types"
+import { isValidEnvVarName } from "./validate-name"
+
+type _EnvBuilderMap = MapOf<InputEnvMapping>
+export class EnvBuilder {
+    constructor(private readonly _env: _EnvBuilderMap) {
+        for (const key of _env.keys()) {
+            if (!isValidEnvVarName(key)) {
+                throw new MakeError("Invalid environment variable name", {
+                    key: key
+                })
+            }
+        }
+    }
+
+    get values() {
+        return this._env
+    }
+
+    private _envFromSecret(value: EnvVarFrom<api.v1_.Secret>): CDK.EnvVarSource {
+        return {
+            secretKeyRef: {
+                name: value.$ref.name,
+                key: value.key,
+                optional: value.optional
+            }
+        }
+    }
+
+    private _envFromConfigMap(value: EnvVarFrom<api.v1_.ConfigMap>): CDK.EnvVarSource {
+        return {
+            configMapKeyRef: {
+                name: value.$ref.name,
+                key: value.key,
+                optional: value.optional
+            }
+        }
+    }
+
+    toEnvVars() {
+        return this.values
+            .map((value, key) => {
+                if (!isObject(value)) {
+                    return {
+                        name: key,
+                        value: `${value}`
+                    }
+                }
+                const resourceValue = value as EnvVarFrom<api.v1_.Secret | api.v1_.ConfigMap>
+                switch (resourceValue.$ref.kind) {
+                    case api.v1_.Secret:
+                        return {
+                            name: key,
+                            valueFrom: this._envFromSecret(resourceValue as any)
+                        }
+                    case api.v1_.ConfigMap:
+                        return {
+                            name: key,
+                            valueFrom: this._envFromConfigMap(resourceValue as any)
+                        }
+                    default:
+                        throw new MakeError("Invalid environment variable reference", {
+                            key: key,
+                            value: value
+                        })
+                }
+            })
+            .valueSeq()
+            .toArray()
+    }
+    private _withEnv(f: (env: _EnvBuilderMap) => _EnvBuilderMap) {
+        return new EnvBuilder(f(this._env))
+    }
+
+    add(name: string, value: InputEnvMapping[string]): EnvBuilder
+    add(input: InputEnvMapping): EnvBuilder
+    add(a: any, b?: any) {
+        const pairs: [string, string][] = typeof a === "string" ? [[a, b]] : Object.entries(a)
+        const map = Map(pairs)
+        const existingKeys = map
+            .keySeq()
+            .filter(k => this._env.has(k))
+            .toList()
+        if (existingKeys.size > 0) {
+            throw new MakeError("Cannot overwrite existing keys using add", {
+                keys: existingKeys.toArray()
+            })
+        }
+        return this._withEnv(env => env.merge(map) as any)
+    }
+
+    overwrite(name: string, value: string): EnvBuilder
+    overwrite(input: InputEnvMapping): EnvBuilder
+    overwrite(a: any, b?: any) {
+        if (typeof a === "string") {
+            return this._withEnv(env => env.set(a, b))
+        } else {
+            const map = Map(a as InputEnvMapping) as _EnvBuilderMap
+            return this._withEnv(env => env.merge(map) as any)
+        }
+    }
+
+    toObject() {
+        return this._env
+            .filter(v => v != null)
+            .map(x => `${x}`)
+            .toObject()
+    }
+
+    static make(env?: InputEnv) {
+        if (!env) {
+            return new EnvBuilder(Map({}))
+        }
+        if (env instanceof EnvBuilder) {
+            return env
+        }
+        return new EnvBuilder(Map(env ?? {}).filter(v => v != null) as _EnvBuilderMap)
+    }
+}
+
+export function Env(env?: InputEnvMapping) {
+    return EnvBuilder.make(env)
+}

package/src/env/index.ts

@@ -0,0 +1,2 @@
+export { Env, EnvBuilder } from "./env"
+export { InputEnvMapping } from "./types"

package/src/env/types.ts

@@ -0,0 +1,17 @@
+import type { Kind, Refable } from "@k8ts/instruments"
+import type { EnvBuilder } from "./env"
+
+export type InputEnvValue = string | null | number | boolean | bigint | undefined | EnvVarFrom
+export type InputEnvMapping = Partial<Record<string, InputEnvValue>>
+export interface EnvVarFrom<_Kind extends Kind = Kind> {
+    $ref: Refable<_Kind>
+    key: string
+    optional?: boolean
+}
+
+export type InputEnv = EnvBuilder | InputEnvMapping
+
+export type EnvFrom<_Kind extends Kind = Kind> = {
+    $ref: Refable<_Kind>
+    prefix?: string
+}

package/src/env/validate-name.ts

@@ -0,0 +1,10 @@
+import { anyCharOf, digit, letter } from "parjs"
+import { many, or, stringify, then } from "parjs/combinators"
+
+const pEnvVarStartChar = letter().pipe(or(anyCharOf("_")))
+const pEnvVarChar = pEnvVarStartChar.pipe(or(digit()))
+const pEnvVarName = pEnvVarStartChar.pipe(then(pEnvVarChar.pipe(many())), stringify())
+
+export function isValidEnvVarName(x: string) {
+    return pEnvVarName.parse(x).isOk
+}

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

@@ -1,5 +1,4 @@
 import {
-    Env,
     Kinded,
     PortSet,
     relations,
@@ -7,16 +6,16 @@ import {
     Unit,
     WritableDeep,
     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 { toContainerPorts } from "../../utils/adapters"
 
 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"
@@ -35,7 +34,6 @@ export namespace Container {
     export type Mounts = {
         [key: string]: SomeMount
     }
-
     interface K8tsPropsClean<Ports extends string = never> {
         image: TaggedImage
         ports?: InputPortSetRecord<Ports>
@@ -99,7 +97,7 @@ export namespace Container {
                 ports: $ports && toContainerPorts(PortSet.make($ports)).valueSeq().toArray(),
                 resources: self._resources()?.toObject(),
                 command: $command?.toArray(),
-                env: toEnvVars(Env($env)).valueSeq().toArray(),
+                env: Env($env).toEnvVars(),
                 ...self._groupedMounts()
             }
             return container

package/src/resources/service/service-port.ts

@@ -19,6 +19,7 @@ export namespace Port {
             return this.props
         }
 
+        // TODO: Does this need to resolve ports?
         ref(): CDK.HttpRouteSpecRulesBackendRefs {
             return {
                 kind: "Service",

package/src/resources/service/service.ts

@@ -64,6 +64,7 @@ export namespace Service {
         private get backend() {
             return this.props.$backend as Deployment<ExposedPorts>
         }
+        // TODO: Ports force evaluates the backend which is not needed
         get ports() {
             const srcPorts = this.backend.ports.pull()
             const knownPorts = Map(this.props.$ports)
@@ -86,7 +87,7 @@ export namespace Service {
         }
 
         private _getPortoPart(port: ExposedPorts, protocol: "http" | "https") {
-            const portNumber = this.ports.get(port)?.frontend
+            const portNumber = this.props.$ports[port]
             if (portNumber === 80 && protocol === "http") {
                 return ""
             }

package/src/resources/utils/adapters.ts

@@ -1,6 +1,5 @@
-import type { EnvBuilder, PortMap, PortMapEntry, PortSet, PortSetEntry } from "@k8ts/instruments"
+import type { PortMap, PortMapEntry, PortSet, PortSetEntry } from "@k8ts/instruments"
 import { CDK } from "../../_imports"
-
 export function toContainerPort(entry: PortSetEntry): CDK.ContainerPort {
     return {
         containerPort: entry.port,
@@ -27,12 +26,3 @@ export function toServicePort(entry: PortMapEntry): CDK.ServicePort {
 export function toServicePorts(ports: PortMap<any>) {
     return ports.values.map(toServicePort).toList()
 }
-
-export function toEnvVars(env: EnvBuilder) {
-    return env.values.map((x, key) => {
-        return {
-            name: key,
-            value: `${x}`
-        } as CDK.EnvVar
-    })
-}

package/src/tsconfig.json

@@ -17,6 +17,6 @@
     "outDir": "../dist",
     "tsBuildInfoFile": "../dist/src.tsbuildinfo"
   },
-  "include": ["**/*.ts", "../../instruments/src/timezone.ts"],
+  "include": ["**/*.ts"],
   "exclude": ["_imports/**/*.ts"]
 }