k8ts 0.4.18 → 0.4.20

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

@@ -1,27 +1,28 @@
 import type { CDK } from "../../../_imports"
+import { api } from "../../../kinds"
+import { Volume } from "../volume"
 import type { Device } from "../volume/devices"
-import type { Volume } from "../volume/volumes"
 export type Mount = Mount.ContainerVolumeMount | Mount.ContainerDeviceMount
 export namespace Mount {
     type Path_Rooted = `/${string}`
     export type Path = `${"" | "." | ".."}${Path_Rooted}`
 
-    export interface Options {
+    export interface Props {
         readOnly?: boolean
         subPath?: string
+        volume: Volume
     }
     export class ContainerVolumeMount {
-        get kind() {
-            return this.parent.kind.parent.subkind("ContainerVolumeMount")
-        }
-        constructor(
-            readonly parent: Volume.PodVolume,
-            readonly props: Options
-        ) {}
+        readonly kind = api.v1_.Pod_.VolumeMount
+
+        constructor(readonly props: Props) {}
 
+        get volume() {
+            return this.props.volume
+        }
         submanifest(mountPath: string): CDK.VolumeMount {
             return {
-                name: this.parent.name,
+                name: this.props.volume.name,
                 mountPath: mountPath,
                 readOnly: this.props.readOnly,
                 subPath: this.props.subPath
@@ -29,16 +30,20 @@ export namespace Mount {
         }
     }
 
+    export interface DeviceMountProps {
+        device: Device
+    }
+
     export class ContainerDeviceMount {
-        get kind() {
-            return this.parent.kind.parent.subkind("ContainerDeviceMount")
+        kind = api.v1_.Pod_.DeviceMount
+        get volume() {
+            return this.props.device
         }
-        constructor(readonly parent: Device.PodDevice) {}
-
+        constructor(readonly props: DeviceMountProps) {}
         submanifest(devicePath: string): CDK.VolumeDevice {
             return {
                 devicePath: devicePath,
-                name: this.parent.name
+                name: this.props.device.name
             }
         }
     }

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

@@ -1,24 +1,23 @@
-import { manifest, Producer, relations } from "@k8ts/instruments"
+import { Kinded, manifest, Producer, relations } from "@k8ts/instruments"
 import { seq } from "doddle"
 import { omit } from "lodash"
 import { CDK } from "../../_imports"
-import { apps_v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { ManifestResource } from "../../node/manifest-resource"
 import { Container } from "./container"
 import { Device, Volume } from "./volume"
-export type PodTemplate<Ports extends string> = PodTemplate.PodTemplate<Ports>
+export type PodTemplate<Ports extends string = string> = PodTemplate.PodTemplate<Ports>
 export namespace PodTemplate {
     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 & {
+    type AbsContainer<Ports extends string> = Kinded<api.v1_.Pod_.Container> & {
+        __PORTS__: Ports
+    }
+    export type PodContainerProducer<Ports extends string> = Producer<PodScope, AbsContainer<Ports>>
+    export type Props<Ports extends string> = PodProps & {
         POD: PodContainerProducer<Ports>
     }
-    const ident = apps_v1.kind("PodTemplate")
-    @k8ts(ident)
+    @k8ts(api.v1_.PodTemplate)
     @relations({
         kids: s => [...s.containers, ...s.volumes]
     })
@@ -47,8 +46,12 @@ export namespace PodTemplate {
         }
     })
     export class PodTemplate<Ports extends string = string> extends ManifestResource<Props<Ports>> {
-        kind = ident
-        readonly containers = seq(() => this.props.POD(new PodScope(this))).cache()
+        readonly kind = api.v1_.PodTemplate
+        readonly containers = seq(() => this.props.POD(new PodScope(this)))
+            .map(x => {
+                return x as Container<Ports>
+            })
+            .cache()
         readonly mounts = seq(() => this.containers.concatMap(x => x.mounts)).cache()
         readonly volumes = seq(() => this.containers.concatMap(x => x.volumes)).uniq()
         readonly ports = seq(() => this.containers.map(x => x.ports)).reduce((a, b) => a.union(b))
@@ -56,19 +59,16 @@ export namespace PodTemplate {
 
     export class PodScope {
         constructor(private readonly _parent: PodTemplate) {}
-        Container<Ports extends string>(
-            name: string,
-            options: Container.Props<Ports>
-        ): Container<Ports> {
-            return Container.make(this._parent, name, "main", options)
+        Container<Ports extends string>(name: string, options: Container.Props<Ports>) {
+            return new Container.Container(this._parent, name, "main", options)
         }
-        InitContainer(name: string, options: Container.Props<never>): Container<never> {
-            return Container.make(this._parent, name, "init", options)
+        InitContainer(name: string, options: Container.K8tsProps<never>) {
+            return new Container.Container(this._parent, name, "init", options)
         }
         Volume(name: string, options: Volume.Backend) {
             return Volume.make(this._parent, name, options)
         }
-        Device(name: string, options: Device.Backend): Device {
+        Device(name: string, options: Device.Backend) {
             return Device.make(this._parent, name, options)
         }
     }

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

@@ -1,5 +1,7 @@
 import { relations } from "@k8ts/instruments"
 import type { CDK } from "../../../_imports"
+import { k8ts } from "../../../kind-map"
+import { api } from "../../../kinds"
 import type { ManifestResource } from "../../../node"
 import { SubResource } from "../../../node/sub-resource"
 import { Pvc } from "../../persistent"
@@ -12,15 +14,14 @@ export namespace Device {
     }
 
     export type Backend = PodDevice_Backend_Pvc
+    @k8ts(api.v1_.Pod_.Device)
     @relations({
         needs: self => ({
             backend: self.backend.backend
         })
     })
     export class PodDevice extends SubResource<PodDevice_Backend_Pvc> {
-        get kind() {
-            return this.parent.kind.subkind("Device")
-        }
+        readonly kind = api.v1_.Pod_.Device
         constructor(
             parent: ManifestResource,
             name: string,
@@ -40,7 +41,9 @@ export namespace Device {
         }
 
         Mount() {
-            return new Mount.ContainerDeviceMount(this)
+            return new Mount.ContainerDeviceMount({
+                device: this
+            })
         }
     }
 

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

@@ -1,6 +1,8 @@
 import type { CDK } from "../../../_imports"
 
 import { relations } from "@k8ts/instruments"
+import { k8ts } from "../../../kind-map"
+import { api } from "../../../kinds"
 import type { ManifestResource } from "../../../node"
 import { SubResource } from "../../../node/sub-resource"
 import type { ConfigMap } from "../../configmap"
@@ -24,20 +26,23 @@ export namespace Volume {
         | PodVolume_Backend_Pvc
         | PodVolume_Backend_ConfigMap
         | PodVolume_Backend_Secret
+
+    @k8ts(api.v1_.Pod_.Volume)
     @relations({
         needs: self => ({
             backend: self.props.backend
         })
     })
     export abstract class PodVolume<Props extends Backend = Backend> extends SubResource<Props> {
-        get kind() {
-            return this.parent.kind.subkind("Volume")
-        }
+        readonly kind = api.v1_.Pod_.Volume
 
         abstract submanifest(): CDK.Volume
 
-        Mount(options?: Mount.Options) {
-            return new Mount.ContainerVolumeMount(this as any, options ?? {})
+        Mount(options?: Omit<Mount.Props, "volume">) {
+            return new Mount.ContainerVolumeMount({
+                volume: this,
+                ...options
+            })
         }
     }
 

package/src/resources/secret/secret.ts

@@ -1,7 +1,7 @@
 import { manifest, relations } from "@k8ts/instruments"
 import { CDK } from "../../_imports"
-import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 
@@ -10,8 +10,7 @@ export interface Props {
     stringData: Record<string, string>
 }
 
-const ident = v1.kind("Secret")
-@k8ts(ident)
+@k8ts(api.v1_.Secret)
 @equiv_cdk8s(CDK.KubeSecret)
 @relations("none")
 @manifest({
@@ -23,5 +22,5 @@ const ident = v1.kind("Secret")
     }
 })
 export class Secret extends ManifestResource<Props> {
-    kind = ident
+    readonly kind = api.v1_.Secret
 }

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

@@ -4,23 +4,27 @@ import type { Service } from "./service"
 export type Port<Port extends string> = Port.Port<Port>
 export namespace Port {
     export interface Props<Port extends string> {
-        service: Service<Port, Port>
-        port: Port
+        service: Service.AbsService<Port>
+        name: Port
     }
 
     export class Port<Port extends string> {
-        constructor(
-            readonly service: Service<Port, Port>,
-            readonly portName: Port,
-            readonly port: number
-        ) {}
+        constructor(readonly props: Props<Port>) {}
+
+        get service() {
+            return this.props.service as Service<Port>
+        }
+
+        get port() {
+            return this.props
+        }
 
         ref(): CDK.HttpRouteSpecRulesBackendRefs {
             return {
                 kind: "Service",
                 namespace: this.service.meta.tryGet("namespace"),
                 name: this.service.meta.get("name"),
-                port: this.port
+                port: this.service.ports.get(this.props.name).frontend
             }
         }
     }

package/src/resources/service/service.ts

@@ -1,32 +1,36 @@
-import { manifest, relations, type InputPortMapping } from "@k8ts/instruments"
+import {
+    manifest,
+    Refable,
+    relations,
+    ResourceEntity,
+    type InputPortMapping
+} from "@k8ts/instruments"
 import { Map } from "immutable"
 import { CDK } from "../../_imports"
-import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { ManifestResource } from "../../node"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import type { Deployment } from "../deployment/deployment"
+import { Deployment } from "../deployment"
 import { toServicePorts } from "../utils/adapters"
 import { Frontend as Frontend_ } from "./frontend"
 import { Port as Port_ } from "./service-port"
-export type Service<DeployPorts extends string, ExposedPorts extends DeployPorts> = Service.Service<
-    DeployPorts,
-    ExposedPorts
->
+export type Service<ExposedPorts extends string = string> = Service.Service<ExposedPorts>
 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.Deployment<DeployPorts>
+        backend: Deployment.AbsDeployment<DeployPorts>
         frontend: Frontend
     }
-
-    const ident = v1.kind("Service")
-    @k8ts(ident)
+    export type AbsService<ExposedPorts extends string> = Refable<api.v1_.Service> & {
+        __PORTS__: ExposedPorts
+    }
+    @k8ts(api.v1_.Service)
     @relations({
         needs: self => ({
-            backend: self.props.backend
+            backend: self.backend as ResourceEntity
         })
     })
     @equiv_cdk8s(CDK.KubeService)
@@ -50,14 +54,17 @@ export namespace Service {
             }
         }
     })
-    export class Service<
-        DeployPorts extends string = string,
-        ExposedPorts extends DeployPorts = DeployPorts
-    > extends ManifestResource<Props<DeployPorts, ExposedPorts>> {
-        kind = ident
+    export class Service<ExposedPorts extends string = string> extends ManifestResource<
+        Props<string, ExposedPorts>
+    > {
+        __PORTS__!: ExposedPorts
+        kind = api.v1_.Service
 
+        private get backend() {
+            return this.props.backend as Deployment<ExposedPorts>
+        }
         get ports() {
-            const srcPorts = this.props.backend.ports.pull()
+            const srcPorts = this.backend.ports.pull()
             const knownPorts = Map(this.props.ports)
                 .filter(x => x !== undefined)
                 .keySeq()
@@ -66,8 +73,11 @@ export namespace Service {
             return svcPorts
         }
 
-        portRef(port: ExposedPorts) {
-            return new Port.Port(this, port, this.ports.get(port).frontend)
+        portRef(name: ExposedPorts) {
+            return new Port.Port({
+                service: this,
+                name: name
+            })
         }
     }
 }

package/src/runner/exporter/serializer.ts

@@ -41,7 +41,7 @@ export class YamlSerializer extends Emittery<YamlSerializerEventsTable> {
             return result
         } catch (err) {
             const resource = ManifestSourceEmbedder.get(input)
-            throw new MakeError(`Failed to serialize manifest ${resource?.shortFqn ?? "???"}`, {
+            throw new MakeError(`Failed to serialize manifest ${resource}`, {
                 cause: err
             })
         }

package/src/runner/exporter/validator.ts

@@ -16,11 +16,10 @@ export class NodeGraphValidator {
         const app = new App()
         const rootChart = new Chart(app, "root_chart")
         for (const fileNode of collection) {
-            const fileChart = new Chart(rootChart, fileNode.file.name)
             for (const nodeManifest of fileNode.resources) {
                 const equiv = EquivCdk8s.get(nodeManifest.node._entity as ManifestResource)
                 const fullFqn = nodeManifest.node.fullFqn.replaceAll("/", "_").replaceAll(".", "-")
-                const cdk8sNode = new equiv(fileChart, fullFqn, nodeManifest.manifest)
+                const cdk8sNode = new equiv(rootChart, fullFqn, nodeManifest.manifest)
             }
         }
         app.synthYaml()

package/src/world/world.ts

@@ -1,4 +1,4 @@
-import { BaseOriginEntity, KindMap, Origin, type Kind } from "@k8ts/instruments"
+import { BaseOriginEntity, KindMap, LiveRefable, Origin, type Kind } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
 import { assign } from "lodash"
 import { External } from "../external"
@@ -7,7 +7,6 @@ import { FileExports } from "../file/exports"
 import { FileOrigin } from "../file/origin"
 import { k8tsBuildKind } from "../k8ts-sys-kind"
 import { K8tsRootOrigin } from "../kind-map"
-import type { ManifestResource } from "../node"
 export type ManifestFileName = `${string}.yaml`
 export namespace World {
     export interface Props {
@@ -19,7 +18,7 @@ export namespace World {
     const ident = k8tsBuildKind.kind("World")
     export type DefineScopedFile<Scope extends FileOrigin.Scope> = {
         metadata(input: Meta.Input): DefineScopedFile<Scope>
-        Resources<const Produced extends ManifestResource>(
+        Resources<const Produced extends LiveRefable>(
             producer: FileExports.Producer<Scope, Produced>
         ): File<Produced>
     }
@@ -49,7 +48,7 @@ export namespace World {
                             })
                             return self
                         },
-                        Resources<const Produced extends ManifestResource>(
+                        Resources<const Produced extends LiveRefable>(
                             producer: FileExports.Producer<Scope, Produced>
                         ): File<Produced> {
                             return builder._File(name, {
@@ -64,7 +63,7 @@ export namespace World {
             }
         }
 
-        private _File<T extends ManifestResource>(
+        private _File<T extends LiveRefable>(
             name: ManifestFileName,
             props: File.Props<any, T>
         ): File<T> {

package/dist/api-versions.d.ts

@@ -1,5 +0,0 @@
-import { Kind } from "@k8ts/instruments";
-export declare const v1: Kind.Version<"v1", Kind.Group<"">>;
-export declare const apps_v1: Kind.Version<"v1", Kind.Group<"apps">>;
-export declare const gateway_v1: Kind.Version<"v1", Kind.Group<"gateway.networking.k8s.io">>;
-//# sourceMappingURL=api-versions.d.ts.map

package/dist/api-versions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-versions.d.ts","sourceRoot":"","sources":["../src/api-versions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAExC,eAAO,MAAM,EAAE,oCAA+B,CAAA;AAC9C,eAAO,MAAM,OAAO,wCAAmC,CAAA;AACvD,eAAO,MAAM,UAAU,6DAAwD,CAAA"}

package/dist/api-versions.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gateway_v1 = exports.apps_v1 = exports.v1 = void 0;
-const instruments_1 = require("@k8ts/instruments");
-exports.v1 = instruments_1.Kind.group("").version("v1");
-exports.apps_v1 = instruments_1.Kind.group("apps").version("v1");
-exports.gateway_v1 = instruments_1.Kind.group("gateway.networking.k8s.io").version("v1");
-//# sourceMappingURL=api-versions.js.map

package/dist/api-versions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-versions.js","sourceRoot":"","sources":["../src/api-versions.ts"],"names":[],"mappings":";;;AAAA,mDAAwC;AAE3B,QAAA,EAAE,GAAG,kBAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AACjC,QAAA,OAAO,GAAG,kBAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AAC1C,QAAA,UAAU,GAAG,kBAAI,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/src/api-versions.ts

@@ -1,5 +0,0 @@
-import { Kind } from "@k8ts/instruments"
-
-export const v1 = Kind.group("").version("v1")
-export const apps_v1 = Kind.group("apps").version("v1")
-export const gateway_v1 = Kind.group("gateway.networking.k8s.io").version("v1")