k8ts 0.4.16 → 0.4.19

package/src/resources/namespace/namespace.ts

@@ -1,8 +1,9 @@
 import { manifest, relations, type Origin } from "@k8ts/instruments"
 import { Meta, MutableMeta } from "@k8ts/metadata"
-import type { CDK } from "../../_imports"
+import { CDK } from "../../_imports"
 import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 export type Namespace = Namespace.Namespace
 export namespace Namespace {
@@ -10,6 +11,7 @@ export namespace Namespace {
     const ident = v1.kind("Namespace")
     @k8ts(ident)
     @relations("none")
+    @equiv_cdk8s(CDK.KubeNamespace)
     @manifest({
         body(self): CDK.KubeNamespaceProps {
             return {

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

@@ -1,8 +1,9 @@
 import { manifest, relations, ResourcesSpec, Unit } from "@k8ts/instruments"
-import type { CDK } from "../../../_imports"
+import { CDK } from "../../../_imports"
 import { v1 } from "../../../api-versions"
 import { k8ts } from "../../../kind-map"
 import { ManifestResource } from "../../../node"
+import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
 import { Access } from "../access-mode"
 import type { DataMode } from "../block-mode"
 import { Pv } from "../volume"
@@ -22,6 +23,7 @@ export namespace Pvc {
 
     const ident = v1.kind("PersistentVolumeClaim")
     @k8ts(ident)
+    @equiv_cdk8s(CDK.KubePersistentVolumeClaim)
     @relations({
         needs: self => ({
             bind: self.props.bind

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

@@ -3,6 +3,7 @@ import { CDK } from "../../../_imports"
 import { v1 } from "../../../api-versions"
 import { MakeError } from "../../../error"
 import { k8ts } from "../../../kind-map"
+import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
 import { ManifestResource } from "../../../node/manifest-resource"
 import { Access } from "../access-mode"
 import type { DataMode } from "../block-mode"
@@ -25,6 +26,7 @@ export namespace Pv {
 
     const ident = v1.kind("PersistentVolume")
 
+    @equiv_cdk8s(CDK.KubePersistentVolume)
     @manifest({
         body(self) {
             const pvProps = self.props

package/src/resources/secret/secret.ts

@@ -2,6 +2,7 @@ import { manifest, relations } from "@k8ts/instruments"
 import { CDK } from "../../_imports"
 import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 
 export interface Props {
@@ -11,6 +12,7 @@ export interface Props {
 
 const ident = v1.kind("Secret")
 @k8ts(ident)
+@equiv_cdk8s(CDK.KubeSecret)
 @relations("none")
 @manifest({
     body(self): CDK.KubeSecretProps {

package/src/resources/service/service.ts

@@ -4,6 +4,7 @@ import { CDK } from "../../_imports"
 import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
 import { ManifestResource } from "../../node"
+import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import type { Deployment } from "../deployment/deployment"
 import { toServicePorts } from "../utils/adapters"
 import { Frontend as Frontend_ } from "./frontend"
@@ -28,6 +29,7 @@ export namespace Service {
             backend: self.props.backend
         })
     })
+    @equiv_cdk8s(CDK.KubeService)
     @manifest({
         body(self): CDK.KubeServiceProps {
             const svcPorts = self.ports

package/src/runner/exporter/assembler.ts

@@ -1,13 +1,14 @@
-import { BaseManifest, Origin, ResourceNode } from "@k8ts/instruments"
+import { Origin } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
 import { aseq } from "doddle"
 import Emittery from "emittery"
 import { cloneDeep } from "lodash"
 import type { File } from "../../file"
 import { ResourceLoader, type ResourceLoaderEventsTable } from "./loader"
-import { Manifester, type ManifesterEventsTable } from "./manifester"
+import { Manifester, NodeManifest, type ManifesterEventsTable } from "./manifester"
 import { ManifestSaver, type ManifestSaverEventsTable } from "./saver"
 import { YamlSerializer, type YamlSerializerEventsTable } from "./serializer"
+import { NodeGraphValidator, ValidatorEventsTable } from "./validator"
 
 export class Assembler extends Emittery<AssemblerEventsTable> {
     constructor(private readonly _options: AssemblerOptions) {
@@ -21,6 +22,7 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
         ) => {
             return await this.emit(event, payload)
         }
+        const validator = new NodeGraphValidator({})
         const loader = new ResourceLoader({})
         loader.onAny(_emit)
         const generator = new Manifester({
@@ -59,25 +61,29 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
             .map(async ({ file, resources }) => {
                 const manifests = await aseq(resources)
                     .map(async resource => {
-                        return {
-                            k8ts: resource,
-                            manifest: await generator.generate(resource)
-                        }
+                        return await generator.generate(resource)
                     })
                     .toArray()
                     .pull()
 
                 return {
-                    file,
-                    manifests
-                }
+                    file: file.node,
+                    resources: manifests
+                } satisfies FileNodes
+            })
+            .after(async () => {
+                await _emit("stage", { stage: "validating" })
+            })
+            .collect("array")
+            .concatMap(async x => {
+                validator.validate(x)
+                return x
             })
             .after(async () => {
                 await _emit("stage", { stage: "serializing" })
             })
-            .collect()
-            .map(async ({ file, manifests }) => {
-                const artifacts = await aseq(manifests)
+            .map(async ({ file, resources }) => {
+                const artifacts = await aseq(resources)
                     .map(async obj => {
                         return {
                             ...obj,
@@ -101,11 +107,11 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
             .collect()
             .map(async ({ file, artifacts }) => {
                 const { filename, bytes, path } = await saver.save(
-                    file.node,
+                    file,
                     artifacts.map(x => x.yaml)
                 )
                 return {
-                    file: file.node,
+                    file: file,
                     path,
                     filename,
                     bytes,
@@ -124,9 +130,11 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
         } as AssembledResult
     }
 }
-export interface Artifact {
-    k8ts: ResourceNode
-    manifest: BaseManifest
+export interface FileNodes {
+    file: Origin
+    resources: NodeManifest[]
+}
+export interface Artifact extends NodeManifest {
     yaml: string
 }
 export interface AssembledFile {
@@ -148,6 +156,7 @@ export interface AssemblerOptions {
 }
 export type AssemblyStage =
     | "loading"
+    | "validating"
     | "manifesting"
     | "serializing"
     | "saving"
@@ -159,7 +168,8 @@ export interface AssemblerEventsTable
     extends ManifestSaverEventsTable,
         YamlSerializerEventsTable,
         ManifesterEventsTable,
-        ResourceLoaderEventsTable {
+        ResourceLoaderEventsTable,
+        ValidatorEventsTable {
     ["received-file"]: { file: Origin }
     ["stage"]: { stage: AssemblyStage }
 }

package/src/runner/exporter/manifester.ts

@@ -59,13 +59,21 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
         })
     }
 
-    async generate(res: ResourceNode) {
+    async generate(res: ResourceNode): Promise<NodeManifest> {
         this._attachProductionAnnotations(res)
         await this.emit("manifest", { resource: res })
         const manifest = await this._generate(res.entity as ManifestResource)
-        return manifest
+        return {
+            node: res,
+            manifest: manifest
+        }
     }
 }
+
+export interface NodeManifest {
+    node: ResourceNode
+    manifest: BaseManifest
+}
 export interface ManifesterManifestEvent {
     resource: ResourceNode
 }

package/src/runner/exporter/validator.ts

@@ -0,0 +1,27 @@
+import { ResourceNode } from "@k8ts/instruments"
+import { App, Chart } from "cdk8s"
+import { ManifestResource } from "../../node"
+import { EquivCdk8s } from "../../node/equiv-cdk8s"
+import { FileNodes } from "./assembler"
+export interface ValidatingEvent {
+    node: ResourceNode
+}
+export interface ValidatorEventsTable {
+    validating: ValidatingEvent
+}
+export interface ValidatorOptions {}
+export class NodeGraphValidator {
+    constructor(readonly options: ValidatorOptions) {}
+    validate(collection: FileNodes[]) {
+        const app = new App()
+        const rootChart = new Chart(app, "root_chart")
+        for (const fileNode of collection) {
+            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(rootChart, fullFqn, nodeManifest.manifest)
+            }
+        }
+        app.synthYaml()
+    }
+}

package/src/runner/summarizer.ts

@@ -113,7 +113,7 @@ export class Summarizer {
             this.files(
                 result.files.map(x => ({
                     origin: x.file,
-                    resources: x.artifacts.map(x => x.k8ts)
+                    resources: x.artifacts.map(x => x.node)
                 }))
             )
         )