k8ts 0.2.1 → 0.4.1

package/dist/world/world.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExternalOriginEntity = exports.World = void 0;
 const instruments_1 = require("@k8ts/instruments");
+const metadata_1 = require("@k8ts/metadata");
+const lodash_1 = require("lodash");
 const external_1 = require("../external");
 const file_1 = require("../file");
 const k8ts_sys_kind_1 = require("../k8ts-sys-kind");
@@ -10,15 +12,41 @@ var World;
 (function (World) {
     const ident = k8ts_sys_kind_1.k8tsBuildKind.kind("World");
     class Builder extends instruments_1.BaseOriginEntity {
+        kind = ident;
+        _ExternalOrigin;
         constructor(props) {
             super("World", props, kind_map_1.K8tsRootOrigin.node);
-            this.kind = ident;
-            this.ExternalOrigin = new ExternalOriginEntity(this.node);
+            this._ExternalOrigin = new ExternalOriginEntity(this.node);
         }
         External(kind, name, namespace) {
-            return new external_1.External(this.ExternalOrigin.node, kind, name, namespace);
+            return new external_1.External(this._ExternalOrigin.node, kind, name, namespace);
         }
-        File(name, props) {
+        Scope(scope) {
+            const builder = this;
+            let meta = metadata_1.Meta.make();
+            return {
+                File(name, props) {
+                    props ??= {};
+                    const self = {
+                        metadata(input) {
+                            props = (0, lodash_1.assign)({}, props, {
+                                meta: metadata_1.Meta.splat(props?.meta, input)
+                            });
+                            return self;
+                        },
+                        Resources(producer) {
+                            return builder._File(name, {
+                                ...props,
+                                scope,
+                                FILE: producer
+                            });
+                        }
+                    };
+                    return self;
+                }
+            };
+        }
+        _File(name, props) {
             return file_1.File.make(name, props, this.node);
         }
     }
@@ -30,12 +58,11 @@ var World;
 })(World || (exports.World = World = {}));
 const ident = k8ts_sys_kind_1.k8tsBuildKind.kind("External");
 class ExternalOriginEntity extends instruments_1.BaseOriginEntity {
+    kind = ident;
     constructor(parent) {
         super("EXTERNAL", {
             meta: {}
         }, parent);
-        this.kind = ident;
     }
 }
 exports.ExternalOriginEntity = ExternalOriginEntity;
-//# sourceMappingURL=world.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k8ts",
-  "version": "0.2.1",
+  "version": "0.4.1",
   "description": "Powerful framwork for building Kubernetes manifests in TypeScript.",
   "keywords": [
     "kubernetes",
@@ -60,8 +60,6 @@
     "test:coverage": "jest --coverage"
   },
   "dependencies": {
-    "@k8ts/instruments": "^0.2.1",
-    "@k8ts/metadata": "^0.2.1",
     "chalk": "4.1.2",
     "constructs": "^10.4.2",
     "dayjs": "^1.11.13",
@@ -77,6 +75,8 @@
   },
   "devDependencies": {
     "@datreeio/datree-cdk8s": "^1.3.5",
+    "@k8ts/instruments": "^0.4.1",
+    "@k8ts/metadata": "^0.4.1",
     "@swc/core": "^1.11.11",
     "@swc/jest": "^0.2.37",
     "@types/chalk": "^2.2.4",
@@ -97,8 +97,8 @@
     "yamprint": "^0.8.4"
   },
   "peerDependencies": {
-    "@k8ts/instruments": "^0.1.0",
-    "@k8ts/metadata": "^0.1.0"
+    "@k8ts/instruments": "^0.4.1",
+    "@k8ts/metadata": "^0.4.1"
   },
   "packageManager": "yarn@4.1.1",
   "engines": {

package/src/file/exports.ts

@@ -30,11 +30,13 @@ export namespace FileExports {
                     return new Factory.Namespaced(props.origin.node)
                 }
             })
-            this.#produced = seq(() => producer(props.origin)).each(x => {
-                x.meta.add(k8ts_namespace, {
-                    "#is-exported": "true"
+            this.#produced = seq(() => producer(props.origin))
+                .each(x => {
+                    x.meta.add(k8ts_namespace, {
+                        "#is-exported": "true"
+                    })
                 })
-            })
+                .cache()
         }
 
         get __entity__() {
@@ -53,7 +55,7 @@ export namespace FileExports {
     export function make<Scope extends FileOrigin.Scope, Produced extends ManifestResource>(
         props: Props<Scope, Produced>
     ): Core & FutureExports<Produced> {
-        const core = new Core(props)
+        const core = new Core(props as any)
         return FutureExports.make({
             actual: core,
             origin: props.origin.node,

package/src/file/factory.ts

@@ -2,11 +2,13 @@ import { Origin, auto_register, displayers, type LiveRefable } from "@k8ts/instr
 import chalk from "chalk"
 import {
     ConfigMap,
+    DataMode,
     Deployment,
     HttpRoute,
     Namespace,
-    Persistent,
     PodTemplate,
+    Pv,
+    Pvc,
     Secret,
     Service
 } from "../resources"
@@ -31,15 +33,14 @@ export namespace Factory {
     }
     @auto_register
     export class Cluster extends Base {
-        PersistentVolume<Name extends string, Mode extends Persistent.DataMode = "Filesystem">(
+        PersistentVolume<Name extends string, Mode extends DataMode = "Filesystem">(
             name: Name,
-            props: Persistent.Volume.Props<Mode>
+            props: Pv.Props<Mode>
         ) {
-            return new Persistent.Volume.Volume(
-                this.origin,
-                this._metaWithName(name),
-                props
-            ) as LiveRefable<Persistent.Volume<Mode>, Name>
+            return new Pv.Pv(this.origin, this._metaWithName(name), props) as LiveRefable<
+                Pv.Pv<Mode>,
+                Name
+            >
         }
         Namespace<Name extends string>(name: Name, props?: Namespace.Props) {
             return new Namespace.Namespace(
@@ -52,15 +53,11 @@ export namespace Factory {
 
     @auto_register
     export class Namespaced extends Base {
-        Claim<Mode extends Persistent.DataMode, Name extends string>(
-            name: Name,
-            mode: Persistent.Claim.Props<Mode>
-        ) {
-            return new Persistent.Claim.Claim(
-                this.origin,
-                this._metaWithName(name),
-                mode
-            ) as LiveRefable<Persistent.Claim<Mode>, Name>
+        Claim<Mode extends DataMode, Name extends string>(name: Name, mode: Pvc.Props<Mode>) {
+            return new Pvc.Pvc(this.origin, this._metaWithName(name), mode) as LiveRefable<
+                Pvc.Pvc<Mode>,
+                Name
+            >
         }
         ConfigMap<Name extends string>(name: Name, props: ConfigMap.Props) {
             return new ConfigMap.ConfigMap(
@@ -69,6 +66,16 @@ export namespace Factory {
                 props
             ) as LiveRefable<ConfigMap, Name>
         }
+        HttpRoute<Name extends string, Ports extends string>(
+            name: Name,
+            props: HttpRoute.Props<Ports>
+        ) {
+            return new HttpRoute.HttpRoute(
+                this.origin,
+                this._metaWithName(name),
+                props
+            ) as LiveRefable<HttpRoute<Ports>, Name>
+        }
         Secret<Name extends string>(name: Name, props: Secret.Props) {
             return new Secret.Secret(this.origin, this._metaWithName(name), props) as LiveRefable<
                 Secret,
@@ -85,7 +92,7 @@ export namespace Factory {
             >
         }
 
-        Deployment<Name extends string, Ports extends string>(
+        private PrvDeployment<Name extends string, Ports extends string = never>(
             name: Name,
             props: Deployment.Props<Ports>
         ) {
@@ -96,6 +103,27 @@ export namespace Factory {
             ) as LiveRefable<Deployment<Ports>, Name>
         }
 
+        Deployment<Name extends string>(name: Name, props: Deployment.SmallerProps) {
+            const builder = this
+            return {
+                Template(templateProps?: PodTemplate.PodProps) {
+                    return {
+                        POD<Ports extends string>(
+                            producer: PodTemplate.PodContainerProducer<Ports>
+                        ) {
+                            return builder.PrvDeployment(name, {
+                                ...props,
+                                template: {
+                                    ...templateProps,
+                                    POD: producer
+                                }
+                            })
+                        }
+                    }
+                }
+            }
+        }
+
         DomainRoute<Name extends string, Ports extends string>(
             name: Name,
             props: HttpRoute.Props<Ports>

package/src/file/origin.ts

@@ -7,6 +7,9 @@ export type FileOrigin<FScope extends FileOrigin.Scope = FileOrigin.Scope> =
 export namespace FileOrigin {
     export type Scope = Namespace | "cluster"
 
+    export interface SmallerProps extends OriginEntityProps {
+        meta?: Meta.Input
+    }
     export interface Props<FScope extends Scope = Scope> extends OriginEntityProps {
         meta?: Meta.Input
         scope: FScope

package/src/index.ts

@@ -2,6 +2,7 @@ export { CDK } from "./_imports"
 export * from "./external"
 export * from "./file"
 export * as ScopedFactory from "./file/factory"
+export * from "./node"
 export * from "./resources"
 export * from "./runner"
 export * from "./runner/exporter"

package/src/node/index.ts

@@ -1 +1,4 @@
+export { AbsResource } from "./abs-resource"
 export { ManifestResource } from "./manifest-resource"
+export { SubResource } from "./sub-resource"
+export { TopResource } from "./top-resource"

package/src/node/manifest-resource.ts

@@ -3,7 +3,7 @@ import type { Meta, MutableMeta } from "@k8ts/metadata"
 import { TopResource } from "./top-resource"
 
 export abstract class ManifestResource<Props extends object = object> extends TopResource<Props> {
-    protected manifest() {
+    protected async manifest() {
         return Builder.get(this).manifest()
     }
     abstract override readonly kind: Kind.Kind

package/src/resources/configmap/configmap.ts

@@ -1,21 +1,36 @@
-import { manifest, relations } from "@k8ts/instruments"
+import {
+    DataSourceRecord_Binary,
+    DataSourceRecord_Text,
+    LocalFileSource,
+    manifest,
+    relations,
+    resolveBinary,
+    resolveText
+} from "@k8ts/instruments"
 import type { CDK } from "../../_imports"
 import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
 import { ManifestResource } from "../../node/manifest-resource"
 export type ConfigMap = ConfigMap.ConfigMap
 export namespace ConfigMap {
+    export type ConfigMapEntrySource = LocalFileSource | string
     export interface Props {
-        data: Record<string, string>
+        data: DataSourceRecord_Text
+        binaryData?: DataSourceRecord_Binary
     }
 
     const ident = v1.kind("ConfigMap")
     @k8ts(ident)
     @relations("none")
     @manifest({
-        body(self): CDK.KubeConfigMapProps {
+        async body(self): Promise<CDK.KubeConfigMapProps> {
+            const binaryData = await resolveBinary(self.props.binaryData ?? {})
+            const data = await resolveText(self.props.data)
             return {
-                data: self.props.data
+                data: data.isEmpty() ? undefined : data.toObject(),
+                binaryData: binaryData.isEmpty()
+                    ? undefined
+                    : binaryData.map(x => Buffer.from(x).toString("base64")).toObject()
             }
         }
     })

package/src/resources/deployment/deployment.ts

@@ -9,7 +9,8 @@ import { PodTemplate } from "../pod/pod-template"
 
 export type Deployment<Ports extends string> = Deployment.Deployment<Ports>
 export namespace Deployment {
-    export type Props<Ports extends string> = Omit<CDK.DeploymentSpec, "selector" | "template"> & {
+    export type SmallerProps = Omit<CDK.DeploymentSpec, "selector" | "template">
+    export type Props<Ports extends string> = SmallerProps & {
         template: PodTemplate.Props<Ports>
     }
 
@@ -19,7 +20,7 @@ export namespace Deployment {
         kids: s => [s.template]
     })
     @manifest({
-        body(self): CDK.KubeDeploymentProps {
+        async body(self): Promise<CDK.KubeDeploymentProps> {
             return {
                 spec: {
                     ...omit(self.props, "template"),
@@ -28,7 +29,7 @@ export namespace Deployment {
                             app: self.name
                         }
                     },
-                    template: self.template["manifest"]()
+                    template: await self.template["manifest"]()
                 }
             }
         }

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

@@ -11,7 +11,7 @@ export type HttpRoute<Ports extends string> = HttpRoute.HttpRoute<Ports>
 export namespace HttpRoute {
     const gwKind = gateway_v1.kind("Gateway")
     export interface Props<Ports extends string> {
-        parent: External<typeof gwKind>
+        gateway: External<typeof gwKind>
         hostname: string
         backend: Service.Port<Ports>
     }
@@ -20,7 +20,7 @@ export namespace HttpRoute {
     @k8ts(kind)
     @relations({
         needs: self => ({
-            gateway: self.props.parent,
+            gateway: self.props.gateway,
             service: self.props.backend.service
         })
     })
@@ -28,7 +28,7 @@ export namespace HttpRoute {
         body(self): CDK.HttpRouteProps {
             return {
                 spec: {
-                    parentRefs: [self.props.parent.ref()],
+                    parentRefs: [self.props.gateway.ref()],
                     hostnames: [self.props.hostname],
                     rules: [
                         {

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

@@ -5,10 +5,10 @@ import { k8ts } from "../../../kind-map"
 import { ManifestResource } from "../../../node"
 import { Access } from "../access-mode"
 import type { DataMode } from "../block-mode"
-import type { Volume } from "../volume"
+import { Pv } from "../volume"
 
-export type Claim<T extends DataMode = DataMode> = Claim.Claim<T>
-export namespace Claim {
+export type Pvc<T extends DataMode = DataMode> = Pvc.Pvc<T>
+export namespace Pvc {
     const pvc_ResourcesSpec = ResourcesSpec.make({
         storage: Unit.Data
     })
@@ -17,7 +17,7 @@ export namespace Claim {
     export interface Props<Mode extends DataMode> extends PvcResources {
         accessModes: Access
         mode?: Mode
-        bind: Volume.Volume<Mode>
+        bind: Pv<Mode>
     }
 
     const ident = v1.kind("PersistentVolumeClaim")
@@ -46,7 +46,7 @@ export namespace Claim {
             }
         }
     })
-    export class Claim<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
+    export class Pvc<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
         kind = ident
     }
 }

package/src/resources/persistent/index.ts

@@ -1,10 +1,4 @@
-import { Access as Access_ } from "./access-mode"
-import { DataMode as DataMode_ } from "./block-mode"
-import { Claim as Claim_ } from "./claim"
-import { Volume as Volume_ } from "./volume"
-export namespace Persistent {
-    export import Claim = Claim_
-    export import Volume = Volume_
-    export import Access = Access_
-    export type DataMode = DataMode_
-}
+export * from "./access-mode"
+export * from "./block-mode"
+export * from "./claim"
+export * from "./volume"

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

@@ -8,8 +8,8 @@ import type { DataMode } from "../block-mode"
 import { Backend as Backend_ } from "./backend"
 import { parseBackend } from "./parse-backend"
 
-export type Volume<T extends DataMode = DataMode> = Volume.Volume<T>
-export namespace Volume {
+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
@@ -50,7 +50,7 @@ export namespace Volume {
     })
     @k8ts(ident)
     @relations("none")
-    export class Volume<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
+    export class Pv<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
         declare readonly kind: typeof ident
     }
 }

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

@@ -30,9 +30,9 @@ export namespace Container {
     export type Mounts = {
         [key: string]: Mount.ContainerDeviceMount | Mount.ContainerVolumeMount
     }
-    export interface Props<Ports extends string> {
+    export interface Props<Ports extends string = never> {
         image: TaggedImage
-        ports: InputPortSetRecord<Ports>
+        ports?: InputPortSetRecord<Ports>
         command?: CmdBuilder
         mounts?: Mounts
         env?: InputEnvMapping
@@ -52,6 +52,7 @@ export namespace Container {
         get kind() {
             return this.parent.kind.subkind("Container")
         }
+
         get mounts() {
             return Map(this.props.mounts ?? {})
                 .mapEntries(([path, mount]) => {
@@ -81,8 +82,8 @@ export namespace Container {
             const { image, ports, command, env, securityContext } = self.props
             const container: CDK.Container = {
                 name: self.name,
-                image: image.text,
-                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(),

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

@@ -1,4 +1,4 @@
-import { manifest, relations } from "@k8ts/instruments"
+import { manifest, Producer, relations } from "@k8ts/instruments"
 import { seq } from "doddle"
 import { omit } from "lodash"
 import { CDK } from "../../_imports"
@@ -9,11 +9,13 @@ import { Container } from "./container"
 import { Device, Volume } from "./volume"
 export type PodTemplate<Ports extends string> = PodTemplate.PodTemplate<Ports>
 export namespace PodTemplate {
-    export type Props<Ports extends string> = Omit<
-        CDK.PodSpec,
-        "containers" | "initContainers" | "volumes"
-    > & {
-        POD(scope: PodScope): Iterable<Container.Container<Ports>>
+    export type PodProps = Omit<CDK.PodSpec, "containers" | "initContainers" | "volumes">
+    export type PodContainerProducer<Ports extends string> = Producer<
+        PodScope,
+        Container.Container<Ports>
+    >
+    export type Props<Ports extends string = never> = PodProps & {
+        POD: PodContainerProducer<Ports>
     }
     const ident = apps_v1.kind("PodTemplate")
     @k8ts(ident)

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

@@ -2,12 +2,12 @@ import { relations } from "@k8ts/instruments"
 import type { CDK } from "../../../_imports"
 import type { ManifestResource } from "../../../node"
 import { SubResource } from "../../../node/sub-resource"
-import { Persistent } from "../../persistent"
+import { Pvc } from "../../persistent"
 import { Mount } from "../container/mounts"
 export type Device = Device.PodDevice
 export namespace Device {
     interface PodDevice_Backend_Pvc {
-        backend: Persistent.Claim<"Block">
+        backend: Pvc.Pvc<"Block">
         readOnly?: boolean
     }
 
@@ -39,7 +39,7 @@ export namespace Device {
             }
         }
 
-        mount() {
+        Mount() {
             return new Mount.ContainerDeviceMount(this)
         }
     }

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

@@ -4,13 +4,13 @@ import { relations } from "@k8ts/instruments"
 import type { ManifestResource } from "../../../node"
 import { SubResource } from "../../../node/sub-resource"
 import type { ConfigMap } from "../../configmap"
-import type { Persistent } from "../../persistent"
+import { Pvc } from "../../persistent"
 import type { Secret } from "../../secret"
 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: Persistent.Claim<"Filesystem">
+        backend: Pvc.Pvc<"Filesystem">
         readOnly?: boolean
     }
 
@@ -30,7 +30,6 @@ export namespace Volume {
         })
     })
     export abstract class PodVolume<Props extends Backend = Backend> extends SubResource<Props> {
-        private KIND = "Volume" as const
         get kind() {
             return this.parent.kind.subkind("Volume")
         }

package/src/resources/service/service.ts

@@ -1,11 +1,11 @@
 import { manifest, relations, type InputPortMapping } from "@k8ts/instruments"
+import { Map } from "immutable"
 import { CDK } from "../../_imports"
 import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
 import { ManifestResource } from "../../node"
 import type { Deployment } from "../deployment/deployment"
 import { toServicePorts } from "../utils/adapters"
-
 import { Frontend as Frontend_ } from "./frontend"
 import { Port as Port_ } from "./service-port"
 export type Service<Ports extends string> = Service.Service<Ports>
@@ -13,7 +13,7 @@ export namespace Service {
     export import Port = Port_
     export import Frontend = Frontend_
     export interface Props<Ports extends string> {
-        ports: InputPortMapping<Ports>
+        ports: Partial<InputPortMapping<Ports>>
         backend: Deployment.Deployment<Ports>
         frontend: Frontend
     }
@@ -31,7 +31,9 @@ export namespace Service {
             return {
                 spec: {
                     ports: toServicePorts(svcPorts).toArray(),
-                    selector: self.props.backend.meta.pick("%app").labels,
+                    selector: {
+                        app: self.props.backend.name
+                    },
                     ...self.props.frontend
                 }
             }
@@ -42,11 +44,15 @@ export namespace Service {
 
         get ports() {
             const srcPorts = this.props.backend.ports.pull()
-            const svcPorts = srcPorts.map(this.props.ports)
+            const knownPorts = Map(this.props.ports)
+                .filter(x => x !== undefined)
+                .keySeq()
+                .toArray() as Ports[]
+            const svcPorts = srcPorts.pick(...knownPorts).map(this.props.ports as any)
             return svcPorts
         }
 
-        getPortRef(port: Ports) {
+        portRef(port: Ports) {
             return new Port.Port(this, port)
         }
     }