k8ts 0.9.1 → 0.11.2

package/src/env/env.ts

@@ -1,21 +1,15 @@
-import { merge } from "@k8ts/metadata/util"
+import type { Ref2_Of } from "@k8ts/instruments"
 import type { CDK } from "@k8ts/sample-interfaces"
 import { seq } from "doddle"
 import { isObject } from "what-are-you"
 import { MakeError } from "../error"
 import { v1 } from "../kinds/index"
-import {
-    toInputEnv,
-    type EnvVarFrom,
-    type InputEnv,
-    type InputEnvMap,
-    type InputEnvMapping,
-    type InputEnvValue
-} from "./types"
+import { type Env_From, type Env_Leaf, type Env_Value } from "./types"
 import { isValidEnvVarName } from "./validate-name"
-export class EnvBuilder {
-    constructor(private readonly _env: InputEnvMap) {
-        for (const key of _env.keys()) {
+
+export class EnvBuilder<M extends Record<keyof M, Env_Leaf>> {
+    constructor(private readonly _env: M) {
+        for (const key of Object.keys(_env)) {
             if (!isValidEnvVarName(key)) {
                 throw new MakeError("Invalid environment variable name", {
                     key: key
@@ -28,29 +22,31 @@ export class EnvBuilder {
         return this._env
     }
 
-    private _envFromSecret(value: EnvVarFrom<v1.Secret._>): CDK.EnvVarSource {
+    private _envFromSecret(value: Env_From): CDK.EnvVarSource {
         return {
             secretKeyRef: {
-                name: value.$ref.name,
+                name: value.$backend.name,
                 key: value.key,
                 optional: value.optional
             }
         }
     }
 
-    private _envFromConfigMap(value: EnvVarFrom<v1.ConfigMap._>): CDK.EnvVarSource {
+    private _envFromConfigMap<S extends Ref2_Of<v1.ConfigMap._>>(
+        value: Env_From
+    ): CDK.EnvVarSource {
         return {
             configMapKeyRef: {
-                name: value.$ref.name,
+                name: value.$backend.name,
                 key: value.key,
                 optional: value.optional
             }
         }
     }
 
-    *[Symbol.iterator](): IterableIterator<[string, InputEnvValue]> {
-        for (const entry of this._env.entries()) {
-            yield entry
+    *[Symbol.iterator](): IterableIterator<[string, Env_Value]> {
+        for (const entry of Object.entries(this._env)) {
+            yield entry as any
         }
     }
 
@@ -63,18 +59,18 @@ export class EnvBuilder {
                         value: `${value}`
                     }
                 }
-                const resourceValue = value as EnvVarFrom<v1.Secret._ | v1.ConfigMap._>
-                switch (resourceValue.$ref.kind) {
+                const resourceValue = value as any
+                switch (resourceValue.$backend.kind) {
                     case v1.Secret._:
                         return {
                             name: key,
                             valueFrom: this._envFromSecret(resourceValue as any)
-                        }
+                        } satisfies CDK.EnvVar
                     case v1.ConfigMap._:
                         return {
                             name: key,
                             valueFrom: this._envFromConfigMap(resourceValue as any)
-                        }
+                        } satisfies CDK.EnvVar
                     default:
                         throw new MakeError("Invalid environment variable reference", {
                             key: key,
@@ -85,37 +81,6 @@ export class EnvBuilder {
             .toArray()
             .pull()
     }
-    private _withEnv(f: (env: InputEnvMap) => InputEnvMap) {
-        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 = new Map(pairs)
-        const existingKeys = seq(map.keys())
-            .filter(k => this._env.has(k))
-            .toArray()
-            .pull()
-        if (existingKeys.length > 0) {
-            throw new MakeError("Cannot overwrite existing keys using add", {
-                keys: existingKeys
-            })
-        }
-        return this._withEnv(env => merge(env, map))
-    }
-
-    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 = toInputEnv(a)
-            return this._withEnv(env => merge(env, map))
-        }
-    }
 
     toObject() {
         return seq(this)
@@ -124,11 +89,19 @@ export class EnvBuilder {
             .pull()
     }
 
-    static make(env?: InputEnv) {
-        return new EnvBuilder(toInputEnv(env ?? {}))
+    get entries() {
+        return Object.entries(this._env) as [string, Env_Leaf][]
+    }
+
+    static make<M>(env?: M) {
+        return new EnvBuilder(env ?? {})
     }
 }
 
-export function Env(env?: InputEnvMapping) {
+export function Env<
+    M extends {
+        [key in keyof M]: Env_Leaf
+    }
+>(env?: M) {
     return EnvBuilder.make(env)
 }

package/src/env/index.ts

@@ -1,2 +1,2 @@
 export { Env, EnvBuilder } from "./env"
-export type { InputEnvMapping } from "./types"
+export type { Env_From, Env_Leaf, Env_Value } from "./types"

package/src/env/types.ts

@@ -1,27 +1,10 @@
-import type { Kind, Resource_Core_Ref } from "@k8ts/instruments"
-import { EnvBuilder } from "./env"
+import type { Ref2_Of } from "@k8ts/instruments"
 
-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: Resource_Core_Ref<_Kind>
+export type Env_Value = string | null | number | boolean | bigint | undefined
+export interface Env_From {
+    $backend: Ref2_Of
     key: string
     optional?: boolean
 }
 
-export type InputEnv = EnvBuilder | InputEnvMapping | InputEnvMap
-
-export function toInputEnv(env: InputEnv): InputEnvMap {
-    if (env instanceof EnvBuilder) {
-        return new Map(env["_env"])
-    }
-    if (env instanceof Map) {
-        return new Map(env)
-    }
-    return new Map(Object.entries(env))
-}
-export type EnvFrom<_Kind extends Kind = Kind> = {
-    $ref: Resource_Core_Ref<_Kind>
-    prefix?: string
-}
-export type InputEnvMap = Map<string, InputEnvValue>
+export type Env_Leaf = string | null | number | boolean | bigint | undefined | Env_From

package/src/index.ts

@@ -1,6 +1,5 @@
 export type { CDK } from "@k8ts/sample-interfaces"
-export { K8ts } from "./default-world"
+export { World } from "./common-world"
 export * from "./origins"
-export * from "./origins/file"
 export * from "./resources"
 export * from "./runner"

package/src/origins/file/file.ts

@@ -3,7 +3,7 @@ import {
     Origin_Exporter,
     type Origin_Entity,
     type Origin_Props,
-    type Resource_Core_Ref,
+    type Ref2_Of,
     type Resource_Ctor_Of
 } from "@k8ts/instruments"
 import { doddlify, seq } from "doddle"
@@ -15,7 +15,7 @@ export interface File_Props<
     Exports extends Kinds[number]["prototype"] = Kinds[number]["prototype"]
 > extends Origin_Props<Kinds[number]> {
     kinds?: Kinds
-    namespace?: Resource_Core_Ref<v1.Namespace._>
+    namespace?: Ref2_Of<v1.Namespace._>
     FILE(FILE: Origin_File_Scope<Kinds>): Iterable<Exports | FwRef_Exports<Exports>>
 }
 export class Origin_File extends Origin_Exporter<File_Props> {
@@ -26,16 +26,13 @@ export class Origin_File extends Origin_Exporter<File_Props> {
         this.meta.overwrite("namespace", this._props.namespace?.name)
     })()
     get kind() {
-        return "k8ts:File"
+        return "[k8ts] File"
     }
 
     @doddlify
     protected __exports__() {
         return seq(
-            this._props.FILE.call(
-                this,
-                new Origin_File_Scope(this) as any
-            ) as Iterable<Resource_Core_Ref>
+            this._props.FILE.call(this, new Origin_File_Scope(this) as any) as Iterable<Ref2_Of>
         ).cache()
     }
 }

package/src/origins/file/modifier.ts

@@ -4,7 +4,7 @@ export interface ModifierOrigin_Props {}
 
 export class Origin_Modifier extends Origin_Entity<ModifierOrigin_Props> {
     get kind() {
-        return "Modifier"
+        return "[k8ts] Modifier"
     }
 
     #currentRunnerState = (() => {

package/src/origins/file/section.ts

@@ -1,8 +1,4 @@
-import {
-    type Origin_Exporter_Props,
-    type Resource_Core_Ref,
-    Origin_Exporter
-} from "@k8ts/instruments"
+import { type Origin_Exporter_Props, type Ref2_Of, Origin_Exporter } from "@k8ts/instruments"
 import { doddle, doddlify, seq } from "doddle"
 import type { v1 } from "../../kinds"
 
@@ -15,15 +11,15 @@ export class File_Section_Scope {
         this.on = this._section.on
     }
 }
-export interface File_Section_Props<Exported extends Resource_Core_Ref = Resource_Core_Ref>
+export interface File_Section_Props<Exported extends Ref2_Of = Ref2_Of>
     extends Origin_Exporter_Props {
-    namespace?: Resource_Core_Ref<v1.Namespace._>
+    namespace?: Ref2_Of<v1.Namespace._>
     SECTION(SCOPE: File_Section_Scope): Iterable<Exported>
 }
 
 export class Origin_Section extends Origin_Exporter<File_Section_Props> {
     get kind() {
-        return "k8ts:File/Section"
+        return "[k8ts] File/Section"
     }
     #_ = doddle(() => {
         this.meta.overwrite({
@@ -34,10 +30,7 @@ export class Origin_Section extends Origin_Exporter<File_Section_Props> {
     @doddlify
     protected __exports__() {
         return seq(
-            this._props.SECTION.call(
-                this,
-                new File_Section_Scope(this)
-            ) as Iterable<Resource_Core_Ref>
+            this._props.SECTION.call(this, new File_Section_Scope(this)) as Iterable<Ref2_Of>
         ).cache()
     }
 }

package/src/origins/index.ts

@@ -1,3 +1,2 @@
-export * from "../resources/external"
 export * from "./file"
 export * from "./world"

package/src/origins/world.ts

@@ -1,34 +1,26 @@
 import {
     Origin_Entity,
     type FwRef_Exports,
-    type Kind,
     type Origin_Props,
     type Resource_Ctor_Of
 } from "@k8ts/instruments"
 
-import { External } from "../resources/external"
-import { Origin_External } from "./external"
 import { File, type File_Props, type File_sName } from "./file"
 
 export type World_Props<Kinds extends Resource_Ctor_Of[]> = Origin_Props<Kinds[number]>
 
-export class World<Kinds extends Resource_Ctor_Of[] = Resource_Ctor_Of[]> extends Origin_Entity<
-    World_Props<Kinds>
-> {
+export class World_Entity<
+    Kinds extends Resource_Ctor_Of[] = Resource_Ctor_Of[]
+> extends Origin_Entity<World_Props<Kinds>> {
     get kind() {
-        return "k8ts:World"
+        return "[k8ts] World"
     }
-    private readonly _ExternalOrigin = new Origin_External(this)
     #_ = (() => {
         this.meta.add("source.k8ts.org/", {
             "^world": this.name
         })
     })()
 
-    External<K extends Kind, Name extends string>(kind: K, name: Name, namespace?: string) {
-        return new External(this._ExternalOrigin, kind.refKey(name), namespace)
-    }
-
     File<Exports extends Resource_Ctor_Of["prototype"]>(
         name: File_sName,
         props: File_Props<Kinds, Exports>

package/src/resources/config/configmap.ts

@@ -0,0 +1,24 @@
+import { Resource_Top, type DataSource } from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
+import { v1 } from "../../kinds/default"
+import { resolveDataSourceRecord } from "./resolver"
+export interface ConfigMap_Props<Keys extends string = string> {
+    $data: Record<Keys, DataSource>
+}
+
+export class ConfigMap<
+    Name extends string = string,
+    Keys extends string = string
+> extends Resource_Top<Name, ConfigMap_Props<Keys>> {
+    get keys(): Keys[] {
+        return Object.keys(this.props.$data) as Keys[]
+    }
+    get kind() {
+        return v1.ConfigMap._
+    }
+
+    protected async body(): Promise<CDK.KubeConfigMapProps> {
+        const resolvedRecord = await resolveDataSourceRecord(this, this.props.$data)
+        return resolvedRecord
+    }
+}

package/src/resources/config/index.ts

@@ -0,0 +1,3 @@
+export * from "./configmap"
+export * from "./key-ref"
+export * from "./secret"

package/src/resources/config/key-ref.ts

@@ -0,0 +1,8 @@
+import type { Ref2_Of } from "@k8ts/instruments"
+
+export class ConfigKeyRef<Backend extends Ref2_Of = Ref2_Of, K extends string = string> {
+    constructor(
+        readonly backend: Backend,
+        public readonly key: K
+    ) {}
+}

package/src/resources/config/resolver.ts

@@ -0,0 +1,29 @@
+import { DataSource_Lazy, type DataSource, type Resource_Ref_Min } from "@k8ts/instruments"
+import { isArrayBufferLike, isTypedArray } from "what-are-you"
+
+export async function resolveDataSourceRecord(
+    resource: Resource_Ref_Min,
+    input: Record<string, DataSource>
+) {
+    const binaryData: [string, string][] = []
+    const data: [string, string][] = []
+    const entries = Object.entries(input ?? {}) as [string, DataSource][]
+    for (const [k, v] of entries) {
+        let current = v
+        if (current instanceof DataSource_Lazy) {
+            current = await current.get()
+        }
+        if (isTypedArray(current) || isArrayBufferLike(current)) {
+            const encoded = Buffer.from(current).toString("base64")
+            binaryData.push([k, encoded])
+        } else if (typeof current === "string") {
+            data.push([k, current])
+        } else {
+            throw new Error(`Unsupported DataSource for ConfigMap ${resource} key "${k}"`)
+        }
+    }
+    return {
+        data: Object.fromEntries(data),
+        binaryData: Object.fromEntries(binaryData)
+    }
+}

package/src/resources/config/secret.ts

@@ -0,0 +1,43 @@
+import { Resource_Top, type DataSource } from "@k8ts/instruments"
+import { v1 } from "../../kinds/default"
+import { resolveDataSourceRecord } from "./resolver"
+
+export interface Secret_Data_Entry {
+    as: "base64" | "plain"
+    value: DataSource
+}
+
+export type Secret_Types =
+    | `kubernetes.io/${
+          | "service-account-token"
+          | "dockercfg"
+          | "dockerconfigjson"
+          | "basic-auth"
+          | "ssh-auth"
+          | "tls"}`
+    | "bootstrap.kubernetes.io/token"
+export interface Secret_Props<Keys extends string = string> {
+    $type?: Secret_Types
+    $data?: Record<Keys, DataSource>
+}
+
+export class Secret<
+    Name extends string = string,
+    Keys extends string = string
+> extends Resource_Top<Name, Secret_Props<Keys>> {
+    get keys() {
+        return Object.keys(this.props.$data ?? {}) as Keys[]
+    }
+    get kind() {
+        return v1.Secret._
+    }
+
+    protected async body() {
+        const resolved = await resolveDataSourceRecord(this, this.props.$data ?? {})
+        return {
+            type: this.props.$type ?? "Opaque",
+            data: resolved.binaryData,
+            stringData: resolved.data
+        }
+    }
+}

package/src/resources/deployment/deployment.ts

@@ -1,6 +1,6 @@
 import {
     OriginContextTracker,
-    Resource_Core_Ref,
+    Ref2_Of,
     Resource_Top,
     type Resource_Entity
 } from "@k8ts/instruments"
@@ -27,7 +27,7 @@ export type Deployment_Props<Ports extends string> = Deployment_Props_Original &
     $template: Pod_Props<Ports>
     $strategy?: Deployment_Strategy
 }
-export type Deployment_Ref<Ports extends string> = Resource_Core_Ref<apps.v1.Deployment._> & {
+export type Deployment_Ref<Ports extends string> = Ref2_Of<apps.v1.Deployment._> & {
     __PORTS__: Ports
 }
 

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

@@ -1,4 +1,4 @@
-import { Resource_Top, type Resource_Full_Ref } from "@k8ts/instruments"
+import { Resource_Top, type Resource_Ref_Full } from "@k8ts/instruments"
 import { CDK } from "@k8ts/sample-interfaces"
 import { gateway } from "../../kinds/gateway"
 import type { Port } from "../service/service-port"
@@ -7,7 +7,7 @@ const GatewayKind = gateway.v1.Gateway._
 const HttpRouteKind = gateway.v1.HttpRoute._
 
 export interface HttpRoute_Props<Ports extends string> {
-    $gateway: Resource_Full_Ref<gateway.v1.Gateway._>
+    $gateway: Resource_Ref_Full<gateway.v1.Gateway._>
     $hostname: string
     $backend: Port<Ports>
     _filters?: CDK.HttpRouteSpecRulesFilters[]

package/src/resources/index.ts

@@ -1,13 +1,9 @@
-export * from "./configmap"
+export * from "./config"
 export * from "./cronjob"
 export * from "./deployment"
-export * from "./external"
-export * from "./http-route/http-route"
+export * from "./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 "./rbac"
 export * from "./service"

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

@@ -1,4 +1,4 @@
-import { Resource_Top, ResourcesSpec, Unit, type Resource_Full_Ref } from "@k8ts/instruments"
+import { Resource_Top, ResourcesSpec, Unit, type Resource_Ref_Full } from "@k8ts/instruments"
 import { CDK } from "@k8ts/sample-interfaces"
 import { Prefix$ } from "../../../_type/prefix$"
 import { MakeError } from "../../../error"
@@ -17,7 +17,7 @@ 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>
+    $storageClass?: Resource_Ref_Full<typeof StorageClassKind>
     $bind?: Pv_Ref<Mode>
 }
 

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

@@ -1,9 +1,4 @@
-import {
-    Resource_Core_Ref,
-    Resource_Top,
-    type Resource_Full_Ref,
-    type Unit
-} from "@k8ts/instruments"
+import { Ref2_Of, Resource_Top, type Resource_Ref_Full, type Unit } from "@k8ts/instruments"
 import { CDK } from "@k8ts/sample-interfaces"
 import { MakeError } from "../../../error"
 import { v1 } from "../../../kinds/default"
@@ -32,7 +27,7 @@ export interface Pv_Backend_Nfs {
 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._>
+    $storageClass?: Resource_Ref_Full<storage.v1.StorageClass._>
     $mode?: Mode
     reclaimPolicy?: Reclaim
     $capacity: Unit.Data
@@ -41,10 +36,9 @@ export interface Pv_Props_K8ts<Mode extends Pv_VolumeMode = Pv_VolumeMode> {
     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
-    }
+export type Pv_Ref<Mode extends Pv_VolumeMode = Pv_VolumeMode> = Ref2_Of<v1.PersistentVolume._> & {
+    __MODE__: Mode
+}
 
 export class Pv<
     Mode extends Pv_VolumeMode = "Filesystem",