k8ts 0.13.2 → 0.14.0

package/dist/util/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/util/merge.ts"],"names":[],"mappings":""}

package/dist/util/merge.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=merge.js.map

package/dist/util/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../src/util/merge.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k8ts",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "Powerful framework for building Kubernetes manifests in TypeScript.",
   "keywords": [
     "k8ts",
@@ -36,10 +36,10 @@
       "types": "./dist/index.d.ts"
     },
     "./kinds": {
-      "require": "./dist/kinds/index.js",
-      "import": "./dist/kinds/index.js",
-      "default": "./dist/kinds/index.js",
-      "types": "./dist/kinds/index.d.ts"
+      "require": "./dist/kinds.js",
+      "import": "./dist/kinds.js",
+      "default": "./dist/kinds.js",
+      "types": "./dist/kinds.d.ts"
     }
   },
   "main": "dist/index.js",
@@ -62,11 +62,11 @@
     "test": "tsx --tsconfig ./example/tsconfig.json ./example/run.ts"
   },
   "dependencies": {
-    "@k8ts/sample-interfaces": "^0.6.2",
+    "@k8ts/sample-interfaces": "^0.6.3",
     "chalk": "4.1.2",
     "dayjs": "^1.11.13",
     "doddle": "^7.3.1",
-    "emittery": "0.13.1",
+    "eventemitter3": "^5.0.1",
     "ip-address": "^10.0.1",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
@@ -74,11 +74,11 @@
     "parjs": "^1.3.9",
     "simple-git": "^3.27.0",
     "stacktracey": "^2.1.8",
-    "what-are-you": "^0.2.0"
+    "what-are-you": "^0.3.0"
   },
   "devDependencies": {
-    "@k8ts/instruments": "^0.11.2",
-    "@k8ts/metadata": "^0.10.2",
+    "@k8ts/instruments": "^0.12.0",
+    "@k8ts/metadata": "^0.11.0",
     "@types/chalk": "^2.2.4",
     "@types/jest": "^29.5.12",
     "@types/js-yaml": "^4",
@@ -95,8 +95,8 @@
     "yamprint": "^0.8.4"
   },
   "peerDependencies": {
-    "@k8ts/instruments": "^0.11.2",
-    "@k8ts/metadata": "^0.10.2"
+    "@k8ts/instruments": "^0.12.0",
+    "@k8ts/metadata": "^0.11.0"
   },
   "engines": {
     "node": ">=16.0.0"

package/src/common-world.ts

@@ -1,5 +1,5 @@
-import type { Rsc_Ctor_Of } from "@k8ts/instruments"
-import { World_Entity, type World_Props } from "./origins"
+import type { ResourceRef_Constructor } from "@k8ts/instruments"
+import { K8tsWorld_Base, type K8tsWorld_Base_Props } from "./origins"
 import {
     ClusterRole,
     ClusterRoleBinding,
@@ -61,13 +61,12 @@ const defaultKindPairs = [
     ClusterRoleBinding
 ] as const
 
-export class World<MoreKinds extends Rsc_Ctor_Of[] = []> extends World_Entity<
-    [...typeof defaultKindPairs, ...MoreKinds]
-> {
-    constructor(name: string, props?: World_Props<[...typeof defaultKindPairs, ...MoreKinds]>) {
-        props ??= {}
-        props.kinds ??= []
-        props.kinds.push(...(defaultKindPairs as any))
-        super(name, props)
-    }
+export function K8tsWorld<MoreKinds extends ResourceRef_Constructor[] = []>(
+    name: string,
+    props?: K8tsWorld_Base_Props<[...typeof defaultKindPairs, ...MoreKinds]>
+) {
+    props ??= {}
+    props.kinds ??= []
+    props.kinds.push(...(defaultKindPairs as any))
+    return new K8tsWorld_Base<[...typeof defaultKindPairs, ...MoreKinds]>(name, props)
 }

package/src/env/env.ts

@@ -1,17 +1,17 @@
-import type { Rsc_Ref } from "@k8ts/instruments"
-import type { CDK } from "@k8ts/sample-interfaces"
+import type { ResourceRef } from "@k8ts/instruments"
+import type { K8S } from "@k8ts/sample-interfaces"
 import { seq } from "doddle"
-import { isObject } from "what-are-you"
-import { MakeError } from "../error"
-import { v1 } from "../kinds/index"
-import { type Env_From, type Env_Leaf, type Env_Value } from "./types"
+import { isPrimitive } from "what-are-you"
+import { v1 } from "../kinds"
+import { K8tsEnvError } from "./error"
+import { type EnvValue, type EnvValueSource } from "./types"
 import { isValidEnvVarName } from "./validate-name"
 
-export class EnvBuilder<M extends Record<keyof M, Env_Leaf>> {
+export class EnvBuilder<M extends Record<keyof M, EnvValue>> {
     constructor(private readonly _env: M) {
         for (const key of Object.keys(_env)) {
             if (!isValidEnvVarName(key)) {
-                throw new MakeError("Invalid environment variable name", {
+                throw new K8tsEnvError("Invalid environment variable name", {
                     key: key
                 })
             }
@@ -22,29 +22,29 @@ export class EnvBuilder<M extends Record<keyof M, Env_Leaf>> {
         return this._env
     }
 
-    private _envFromSecret(value: Env_From): CDK.EnvVarSource {
+    private _envFromSecret(value: EnvValueSource): K8S.EnvVarSource {
         return {
             secretKeyRef: {
-                name: value.$backend.name,
+                name: value.$backend.ident.name,
                 key: value.key,
                 optional: value.optional
             }
         }
     }
 
-    private _envFromConfigMap<S extends Rsc_Ref<v1.ConfigMap._>>(
-        value: Env_From
-    ): CDK.EnvVarSource {
+    private _envFromConfigMap<S extends ResourceRef<v1.ConfigMap._>>(
+        value: EnvValueSource
+    ): K8S.EnvVarSource {
         return {
             configMapKeyRef: {
-                name: value.$backend.name,
+                name: value.$backend.ident.name,
                 key: value.key,
                 optional: value.optional
             }
         }
     }
 
-    *[Symbol.iterator](): IterableIterator<[string, Env_Value]> {
+    *[Symbol.iterator](): IterableIterator<[string, EnvValue]> {
         for (const entry of Object.entries(this._env)) {
             yield entry as any
         }
@@ -53,30 +53,28 @@ export class EnvBuilder<M extends Record<keyof M, Env_Leaf>> {
     toEnvVars() {
         return seq(this)
             .map(([key, value]) => {
-                if (!isObject(value)) {
+                if (isPrimitive(value)) {
                     return {
                         name: key,
                         value: `${value}`
                     }
                 }
-                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,
-                            value: value
-                        })
+                if (value.$backend.is(v1.Secret._)) {
+                    return {
+                        name: key,
+                        valueFrom: this._envFromSecret(value as any)
+                    } satisfies K8S.EnvVar
+                }
+                if (value.$backend.is(v1.ConfigMap._)) {
+                    return {
+                        name: key,
+                        valueFrom: this._envFromConfigMap(value as any)
+                    } satisfies K8S.EnvVar
                 }
+                throw new K8tsEnvError("Invalid environment variable reference", {
+                    key: key,
+                    value: value
+                })
             })
             .toArray()
             .pull()
@@ -90,7 +88,7 @@ export class EnvBuilder<M extends Record<keyof M, Env_Leaf>> {
     }
 
     get entries() {
-        return Object.entries(this._env) as [string, Env_Leaf][]
+        return Object.entries(this._env) as [string, EnvValue][]
     }
 
     static make<M>(env?: M) {
@@ -100,7 +98,7 @@ export class EnvBuilder<M extends Record<keyof M, Env_Leaf>> {
 
 export function Env<
     M extends {
-        [key in keyof M]: Env_Leaf
+        [key in keyof M]: EnvValue
     }
 >(env?: M) {
     return EnvBuilder.make(env)

package/src/env/error.ts

@@ -0,0 +1,7 @@
+export class K8tsEnvError extends Error {
+    override name = "EnvError" as const
+    constructor(message: string, details: Record<string, any> = {}) {
+        super(message)
+        Object.assign(this, details)
+    }
+}

package/src/env/index.ts

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

package/src/env/types.ts

@@ -1,10 +1,10 @@
-import type { Rsc_Ref } from "@k8ts/instruments"
+import type { ResourceRef } from "@k8ts/instruments"
 
-export type Env_Value = string | null | number | boolean | bigint | undefined
-export interface Env_From {
-    $backend: Rsc_Ref
+export type EnvValuePrimitive = string | null | number | boolean | bigint | undefined
+export interface EnvValueSource {
+    $backend: ResourceRef
     key: string
     optional?: boolean
 }
 
-export type Env_Leaf = string | null | number | boolean | bigint | undefined | Env_From
+export type EnvValue = EnvValuePrimitive | EnvValueSource

package/src/index.ts

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

package/src/kinds.ts

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

package/src/origins/file/file.ts

@@ -1,69 +1,61 @@
 import {
-    Origin_Exporter,
-    Rsc_FwRef_Exports,
-    type Origin_Entity,
+    ExporterOrigin,
+    ForwardExports,
     type Origin_Props,
-    type Rsc_Ctor_Of,
-    type Rsc_Ref
+    type ResourceRef,
+    type ResourceRef_Constructor
 } from "@k8ts/instruments"
 import { doddlify, seq } from "doddle"
 import type { v1 } from "../../kinds"
-import { Origin_Section, type File_Section_Props } from "./section"
+import { K8tsFile_Section, type K8tsFile_Section_Props } from "./section"
 export type File_sName = `${string}.yaml`
-export interface File_Props<
-    Kinds extends Rsc_Ctor_Of[] = Rsc_Ctor_Of[],
+export interface K8tsFile_Props<
+    Kinds extends ResourceRef_Constructor[] = ResourceRef_Constructor[],
     Exports extends Kinds[number]["prototype"] = Kinds[number]["prototype"]
 > extends Origin_Props<Kinds[number]> {
     kinds?: Kinds
-    namespace?: Rsc_Ref<v1.Namespace._>
-    FILE(FILE: Origin_File_Scope<Kinds>): Iterable<Exports | Rsc_FwRef_Exports<Exports>>
+    namespace?: ResourceRef<v1.Namespace._>
+    resources$($file: K8tsFile_Scope<Kinds>): Iterable<Exports | ForwardExports<Exports>>
 }
-export class Origin_File extends Origin_Exporter<File_Props> {
+export class K8tsFile extends ExporterOrigin<K8tsFile_Props> {
     #_ = (() => {
-        this.meta.add("source.k8ts.org/", {
+        this.metadata.add("source.k8ts.org/", {
             "^file": this.name
         })
-        this.meta.overwrite("namespace", this._props.namespace?.name)
     })()
     get kind() {
         return "[k8ts] File"
     }
 
+    get namespace() {
+        return this._props.namespace?.ident.name
+    }
+
     @doddlify
     protected __exports__() {
         return seq(
-            this._props.FILE.call(this, new Origin_File_Scope(this) as any) as Iterable<Rsc_Ref>
+            this._props.resources$.call(
+                this,
+                new K8tsFile_Scope(this) as any
+            ) as Iterable<ResourceRef>
         ).cache()
     }
 }
-export function File<
-    Kinds extends Rsc_Ctor_Of[] = Rsc_Ctor_Of[],
-    Exports extends Kinds[number]["prototype"] = Kinds[number]["prototype"]
->(parent: Origin_Entity, name: File_sName, props: File_Props<Kinds, Exports>) {
-    const file = new Origin_File(parent, name, props as any)
-
-    return Rsc_FwRef_Exports<Exports>(file)
-}
 
-export class Origin_File_Scope<Kinds extends Rsc_Ctor_Of[]> {
-    constructor(private readonly _file: Origin_File) {
+export class K8tsFile_Scope<Kinds extends ResourceRef_Constructor[]> {
+    constructor(private readonly _file: K8tsFile) {
         this.on = this._file.on
     }
     get __entity__() {
         return this._file
     }
-    on: Origin_File["on"]
+    on: K8tsFile["on"]
 
     Section<Exported extends Kinds[number]["prototype"] = Kinds[number]["prototype"]>(
         name: string,
-        props: File_Section_Props<Exported>
+        props: K8tsFile_Section_Props<Exported>
     ) {
-        const section: Origin_Section = new Origin_Section(this._file, name, props)
-        return Rsc_FwRef_Exports<Exported>(section)
+        const section: K8tsFile_Section = new K8tsFile_Section(this._file, name, props)
+        return ForwardExports<Exported>(section)
     }
 }
-
-export type File<
-    Kinds extends Rsc_Ctor_Of[] = Rsc_Ctor_Of[],
-    T extends Kinds[number]["prototype"] = Kinds[number]["prototype"]
-> = Rsc_FwRef_Exports<T>

package/src/origins/file/index.ts

@@ -1,3 +1,2 @@
 export * from "./file"
-export * from "./modifier"
 export * from "./section"

package/src/origins/file/section.ts

@@ -1,36 +1,37 @@
-import { type Origin_Exporter_Props, type Rsc_Ref, Origin_Exporter } from "@k8ts/instruments"
-import { doddle, doddlify, seq } from "doddle"
+import { type OriginExporter_Props, type ResourceRef, ExporterOrigin } from "@k8ts/instruments"
+import { doddlify, seq } from "doddle"
 import type { v1 } from "../../kinds"
 
-export class File_Section_Scope {
-    on: Origin_Section["on"]
+export class K8tsFile_Section_Scope {
+    on: K8tsFile_Section["on"]
     get __entity__() {
         return this._section
     }
-    constructor(private readonly _section: Origin_Section) {
+    constructor(private readonly _section: K8tsFile_Section) {
         this.on = this._section.on
     }
 }
-export interface File_Section_Props<Exported extends Rsc_Ref = Rsc_Ref>
-    extends Origin_Exporter_Props {
-    namespace?: Rsc_Ref<v1.Namespace._>
-    SECTION(SCOPE: File_Section_Scope): Iterable<Exported>
+export interface K8tsFile_Section_Props<Exported extends ResourceRef = ResourceRef>
+    extends OriginExporter_Props {
+    namespace?: ResourceRef<v1.Namespace._>
+    resources$(Section: K8tsFile_Section_Scope): Iterable<Exported>
 }
 
-export class Origin_Section extends Origin_Exporter<File_Section_Props> {
+export class K8tsFile_Section extends ExporterOrigin<K8tsFile_Section_Props> {
     get kind() {
         return "[k8ts] File/Section"
     }
-    #_ = doddle(() => {
-        this.meta.overwrite({
-            namespace: this._props.namespace?.name
-        })
-    }).pull()
 
+    get namespace() {
+        return this.__parent__.cast(ExporterOrigin).namespace
+    }
     @doddlify
     protected __exports__() {
         return seq(
-            this._props.SECTION.call(this, new File_Section_Scope(this)) as Iterable<Rsc_Ref>
+            this._props.resources$.call(
+                this,
+                new K8tsFile_Section_Scope(this)
+            ) as Iterable<ResourceRef>
         ).cache()
     }
 }

package/src/origins/world.ts

@@ -1,31 +1,37 @@
 import {
-    Origin_Entity,
+    ForwardExports,
+    OriginEntity,
     type Origin_Props,
-    type Rsc_Ctor_Of,
-    type Rsc_FwRef_Exports
+    type ResourceRef_Constructor
 } from "@k8ts/instruments"
 
-import { File, type File_Props, type File_sName } from "./file"
+import { K8tsFile, type File_sName, type K8tsFile_Props } from "./file"
 
-export type World_Props<Kinds extends Rsc_Ctor_Of[]> = Origin_Props<Kinds[number]>
+export type K8tsWorld_Base_Props<Kinds extends ResourceRef_Constructor[]> = Origin_Props<
+    Kinds[number]
+>
 
-export class World_Entity<Kinds extends Rsc_Ctor_Of[] = Rsc_Ctor_Of[]> extends Origin_Entity<
-    World_Props<Kinds>
-> {
+export class K8tsWorld_Base<
+    Kinds extends ResourceRef_Constructor[] = ResourceRef_Constructor[]
+> extends OriginEntity<K8tsWorld_Base_Props<Kinds>> {
     get kind() {
         return "[k8ts] World"
     }
     #_ = (() => {
-        this.meta.add("source.k8ts.org/", {
+        this.metadata.add("source.k8ts.org/", {
             "^world": this.name
         })
     })()
-
-    File<Exports extends Rsc_Ctor_Of["prototype"]>(
+    get namespace() {
+        return undefined
+    }
+    File<Exports extends ResourceRef_Constructor["prototype"]>(
         name: File_sName,
-        props: File_Props<Kinds, Exports>
+        props: K8tsFile_Props<Kinds, Exports>
     ) {
-        return File(this, name, props) as Rsc_FwRef_Exports<Exports>
+        const file = new K8tsFile(this, name, props as any)
+
+        return ForwardExports<Exports>(file)
     }
 }
 

package/src/resources/config/configmap.ts

@@ -1,24 +1,25 @@
-import { Rsc_Top, type DataSource } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
-import { v1 } from "../../kinds/default"
+import { K8sResource, type DataSource, type Resource_Props_Top } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../gvks/default"
 import { resolveDataSourceRecord } from "./resolver"
-export interface ConfigMap_Props<Keys extends string = string> {
-    $data: Record<Keys, DataSource>
+export interface ConfigMap_Props<Keys extends string = string> extends Resource_Props_Top {
+    $data?: Record<Keys, DataSource>
 }
 
-export class ConfigMap<Name extends string = string, Keys extends string = string> extends Rsc_Top<
-    Name,
-    ConfigMap_Props<Keys>
-> {
+export class ConfigMap<
+    Name extends string = string,
+    Keys extends string = string
+> extends K8sResource<Name, ConfigMap_Props<Keys>> {
     get keys(): Keys[] {
-        return Object.keys(this.props.$data) as 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
+    protected async __body__(): Promise<K8S.KubeConfigMapProps> {
+        const resolvedRecord = await resolveDataSourceRecord(this, this.props.$data ?? {})
+        return merge(resolvedRecord, this.props.$$manifest)
     }
 }

package/src/resources/config/index.ts

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

package/src/resources/config/resolver.ts

@@ -1,8 +1,9 @@
-import { DataSource_Lazy, type DataSource, type Rsc_Ref } from "@k8ts/instruments"
+import { isDataSource, type DataSource, type ResourceRef } from "@k8ts/instruments"
 import { isArrayBufferLike, isTypedArray } from "what-are-you"
+import { K8tsResourceError } from "../errors"
 
 export async function resolveDataSourceRecord(
-    resource: Rsc_Ref,
+    resource: ResourceRef,
     input: Record<string, DataSource>
 ) {
     const binaryData: [string, string][] = []
@@ -10,8 +11,8 @@ export async function resolveDataSourceRecord(
     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 (isDataSource(current)) {
+            current = await current.pull()
         }
         if (isTypedArray(current) || isArrayBufferLike(current)) {
             const encoded = Buffer.from(current).toString("base64")
@@ -19,7 +20,9 @@ export async function resolveDataSourceRecord(
         } else if (typeof current === "string") {
             data.push([k, current])
         } else {
-            throw new Error(`Unsupported DataSource for ConfigMap ${resource} key "${k}"`)
+            throw new K8tsResourceError(
+                `Unsupported DataSource for ConfigMap ${resource} key "${k}"`
+            )
         }
     }
     return {

package/src/resources/config/secret.ts

@@ -1,8 +1,10 @@
-import { Rsc_Top, type DataSource } from "@k8ts/instruments"
-import { v1 } from "../../kinds/default"
+import { K8sResource, type DataSource, type Resource_Props_Top } from "@k8ts/instruments"
+import { merge } from "lodash"
+import type { K8S } from "../.."
+import { v1 } from "../../gvks/default"
 import { resolveDataSourceRecord } from "./resolver"
 
-export interface Secret_Data_Entry {
+export interface Secret_Entry {
     as: "base64" | "plain"
     value: DataSource
 }
@@ -16,12 +18,13 @@ export type Secret_Types =
           | "ssh-auth"
           | "tls"}`
     | "bootstrap.kubernetes.io/token"
-export interface Secret_Props<Keys extends string = string> {
+export interface Secret_Props<Keys extends string = string>
+    extends Resource_Props_Top<K8S.KubeSecretProps> {
     $type?: Secret_Types
     $data?: Record<Keys, DataSource>
 }
 
-export class Secret<Name extends string = string, Keys extends string = string> extends Rsc_Top<
+export class Secret<Name extends string = string, Keys extends string = string> extends K8sResource<
     Name,
     Secret_Props<Keys>
 > {
@@ -32,12 +35,13 @@ export class Secret<Name extends string = string, Keys extends string = string>
         return v1.Secret._
     }
 
-    protected async body() {
+    protected async __body__(): Promise<K8S.KubeSecretProps> {
         const resolved = await resolveDataSourceRecord(this, this.props.$data ?? {})
-        return {
+        const body = {
             type: this.props.$type ?? "Opaque",
             data: resolved.binaryData,
             stringData: resolved.data
         }
+        return merge(body, this.props.$$manifest)
     }
 }

package/src/resources/errors.ts

@@ -0,0 +1,7 @@
+export class K8tsResourceError extends Error {
+    name = "K8tsResourceError" as const
+    constructor(message: string, fields: Record<string, any> & { cause?: Error } = {}) {
+        super(message)
+        Object.assign(this, fields)
+    }
+}

package/src/resources/hostpath.ts

@@ -1,4 +1,4 @@
-export type HostPathType =
+export type HostPath_Type =
     | "DirectoryOrCreate"
     | "Directory"
     | "FileOrCreate"

package/src/resources/index.ts

@@ -1,9 +1,6 @@
 export * from "./config"
-export * from "./cronjob"
-export * from "./deployment"
-export * from "./http-route"
 export * from "./namespace"
+export * from "./network"
 export * from "./persistent"
-export * from "./pod"
 export * from "./rbac"
-export * from "./service"
+export * from "./workload"