k8ts 0.7.3 → 0.9.1

package/src/runner/exporter/manifester.ts

@@ -1,17 +1,16 @@
-import { BaseManifest, ResourceNode } from "@k8ts/instruments"
+import { Manifest, ManifestSourceEmbedder, Resource_Node, Resource_Top } from "@k8ts/instruments"
 import Emittery from "emittery"
 import { cloneDeep, cloneDeepWith, isEmpty, unset } from "lodash"
-import { ManifestResource } from "../../node"
 import { version } from "../../version"
-import { k8ts_namespace } from "./meta"
 export interface ManifesterOptions {
     cwd?: string
 }
+
 export class Manifester extends Emittery<ManifesterEventsTable> {
     constructor(private readonly _options: ManifesterOptions) {
         super()
     }
-    private _cleanSpecificEmptyObjects(manifest: BaseManifest) {
+    private _cleanSpecificEmptyObjects(manifest: Manifest) {
         const clone = cloneDeepWith(manifest, (value, key) => {
             if (key !== "metadata") {
                 return
@@ -26,7 +25,7 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
         })
         return clone
     }
-    private _cleanNullishValues(manifest: BaseManifest) {
+    private _cleanNullishValues(manifest: Manifest) {
         const _cleanKeys = (obj: any) => {
             if (typeof obj !== "object") {
                 return obj
@@ -42,27 +41,38 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
 
         return cloneDeepWith(clone, _cleanKeys)
     }
-    private async _generate(resource: ManifestResource): Promise<BaseManifest> {
-        const manifest = await resource["manifest"]()
+
+    private async _generate(resource: Resource_Top): Promise<Manifest> {
+        const manifest = await resource["__manifest__"]()
+
         const noNullish = this._cleanNullishValues(manifest)
         const noEmpty = this._cleanSpecificEmptyObjects(noNullish)
         return noEmpty
     }
 
-    private _attachProductionAnnotations(resource: ResourceNode) {
+    private _attachProductionAnnotations(resource: Resource_Node) {
         const loc = resource.trace.format({
             cwd: this._options.cwd
         })
-        resource.meta!.add(k8ts_namespace, {
+        resource.meta!.add(`build.k8ts.org/`, {
             "^constructed-at": loc,
             "^produced-by": `k8ts@${version}`
         })
+        const resourceOriginMetas = resource.origin.inheritedMeta
+
+        resource.meta!.add(resourceOriginMetas)
     }
 
-    async generate(res: ResourceNode): Promise<NodeManifest> {
+    async generate(res: Resource_Node): Promise<NodeManifest> {
         this._attachProductionAnnotations(res)
         await this.emit("manifest", { resource: res })
-        const manifest = await this._generate(res.entity as ManifestResource)
+        const manifest = await this._generate(res.entity as Resource_Top)
+        ManifestSourceEmbedder.add(manifest, res.entity)
+        res.origin.entity["__emit__"]("resource/manifested", {
+            origin: res.origin.entity,
+            manifest,
+            resource: res.entity as Resource_Top
+        })
         return {
             node: res,
             manifest: manifest
@@ -71,11 +81,11 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
 }
 
 export interface NodeManifest {
-    node: ResourceNode
-    manifest: BaseManifest
+    node: Resource_Node
+    manifest: Manifest
 }
 export interface ManifesterManifestEvent {
-    resource: ResourceNode
+    resource: Resource_Node
 }
 
 export interface ManifesterEventsTable {

package/src/runner/exporter/meta.ts

@@ -1 +0,0 @@
-export const k8ts_namespace = "k8ts.org/" as const

package/src/runner/exporter/saver.ts

@@ -1,4 +1,4 @@
-import type { Origin } from "@k8ts/instruments"
+import type { OriginNode } from "@k8ts/instruments"
 import Emittery from "emittery"
 import { mkdir, rm, writeFile } from "fs/promises"
 import { join, resolve } from "path"
@@ -26,7 +26,7 @@ export class ManifestSaver extends Emittery<ManifestSaverEventsTable> {
         await mkdir(this._options.outdir, { recursive: true })
     }
 
-    async save(origin: Origin, manifests: string[]) {
+    async save(origin: OriginNode, manifests: string[]) {
         const content = this._splat(manifests)
         const filename = `${origin.name}`
         const encoded = this._encoder.encode(content)
@@ -37,6 +37,7 @@ export class ManifestSaver extends Emittery<ManifestSaverEventsTable> {
             content: content,
             bytes: encoded.byteLength
         }
+
         await this.emit("save", e)
         await mkdir(this._options.outdir, { recursive: true })
         await writeFile(join(this._options.outdir, filename), encoded)

package/src/runner/exporter/serializer.ts

@@ -1,15 +1,20 @@
-import { BaseManifest, ManifestSourceEmbedder, type ResourceNode } from "@k8ts/instruments"
+import {
+    Manifest,
+    ManifestSourceEmbedder,
+    type Resource_Node,
+    type Resource_Top
+} from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
 import Emittery from "emittery"
 import { dump, type DumpOptions } from "js-yaml"
-import { CDK } from "../../_imports"
 import { MakeError } from "../../error"
 
 export interface YamlSerializerOptions {
     jsYamlOptions: DumpOptions
 }
 export interface SerializingEvent {
-    manifest: BaseManifest
-    resource: ResourceNode
+    manifest: Manifest
+    resource: Resource_Node
 }
 export interface SerializerEventsTable {
     serialize: SerializingEvent
@@ -19,10 +24,11 @@ export class YamlSerializer extends Emittery<SerializerEventsTable> {
         super()
     }
 
-    async serialize(input: BaseManifest) {
+    async serialize(input: Manifest) {
+        const node = ManifestSourceEmbedder.get(input).node
         await this.emit("serialize", {
             manifest: input,
-            resource: ManifestSourceEmbedder.get(input).node
+            resource: node
         })
 
         try {
@@ -42,7 +48,14 @@ export class YamlSerializer extends Emittery<SerializerEventsTable> {
                 ...this._options.jsYamlOptions,
                 noRefs: true
             })
-            return result
+            const e = {
+                origin: node.origin.entity,
+                resource: node.entity as Resource_Top,
+                manifest: input,
+                content: result
+            }
+            node.origin.entity["__emit__"]("resource/serialized", e)
+            return e.content
         } catch (err) {
             const resource = ManifestSourceEmbedder.get(input)
             throw new MakeError(`Failed to serialize manifest ${resource}`, {

package/src/runner/exporter/validator.ts

@@ -1,10 +1,7 @@
-import { ResourceNode } from "@k8ts/instruments"
-import { App, Chart } from "cdk8s"
-import { ManifestResource } from "../../node"
-import { EquivCdk8s } from "../../node/equiv-cdk8s"
+import { Resource_Node } from "@k8ts/instruments"
 import { FileNodes } from "./assembler"
 export interface ValidatingEvent {
-    node: ResourceNode
+    node: Resource_Node
 }
 export interface ValidatorEventsTable {
     validating: ValidatingEvent
@@ -12,16 +9,5 @@ export interface ValidatorEventsTable {
 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()
-    }
+    validate(collection: FileNodes[]) {}
 }

package/src/runner/runner.ts

@@ -1,10 +1,9 @@
-import { GitTrace, Trace } from "@k8ts/instruments"
+import { GitTrace, Trace, type FwRef_Exports_Brand } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
 import chalk from "chalk"
+import { seq } from "doddle"
 import Emittery from "emittery"
 import StackTracey from "stacktracey"
-import { File } from "../file"
-import { proverbsPath } from "../paths"
 import {
     Assembler,
     AssemblerEventsTable,
@@ -12,7 +11,7 @@ import {
     ProgressOptions,
     ProgressShower
 } from "./exporter"
-import { k8ts_namespace } from "./exporter/meta"
+import { proverbsPath } from "./paths"
 import { Proverbs } from "./silly/proverbs"
 import { Summarizer } from "./summarizer"
 
@@ -27,20 +26,26 @@ export class Runner extends Emittery<AssemblerEventsTable> {
         super()
     }
 
-    async run(input: Iterable<File.Input>) {
+    async run(input: Iterable<FwRef_Exports_Brand>) {
+        const results = seq(input)
+            .map(e => e.__entity__())
+            .toArray()
+            .pull()
         const gitInfo = await GitTrace.make({
             cwd: this._options.cwd
         })
+
         const runTrace = new Trace(new StackTracey().slice(1))
         const options = {
             cwd: ".",
             ...this._options,
-            meta: Meta.make(this._options.meta).add(k8ts_namespace, {
-                "^emitted-at": runTrace.format({
-                    cwd: this._options.cwd
-                }),
-                "^source-git": gitInfo?.text
-            })
+            meta: Meta.make(this._options.meta)
+                .add(`source.k8ts.org/`, {
+                    "^emitted-at": runTrace.format({
+                        cwd: this._options.cwd
+                    })
+                })
+                .add(gitInfo?.metaFields)
         }
 
         const progressShower = new ProgressShower(options.progress)
@@ -52,7 +57,7 @@ export class Runner extends Emittery<AssemblerEventsTable> {
             printOptions: this._options.printOptions
         })
         const visualizer = progressShower.visualize(assembler)
-        const result = await assembler.assemble(input)
+        const result = await assembler.assemble(results)
 
         const viz = summarizer.result(result)
 

package/src/runner/summarizer.ts

@@ -1,13 +1,13 @@
 import {
     Displayers,
-    Origin,
+    OriginNode,
     pretty,
     Relation,
-    ResourceNode,
+    Resource_Node,
     TextPostProcessor
 } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
-import { List, Map } from "immutable"
+import { mapToObject } from "@k8ts/metadata/util"
 import { dump } from "js-yaml"
 import { AssembledResult } from "./exporter"
 export interface SummarizerOptions {
@@ -16,7 +16,7 @@ export interface SummarizerOptions {
 export class Summarizer {
     private _post = new TextPostProcessor()
     constructor(private readonly _options: SummarizerOptions) {}
-    _formatRefFromTo(node: ResourceNode, edge: Relation<ResourceNode>) {
+    _formatRefFromTo(node: Resource_Node, edge: Relation<Resource_Node>) {
         return this._token(pretty`${edge}`)
     }
 
@@ -28,7 +28,7 @@ export class Summarizer {
         return token
     }
 
-    private _resource(resource: ResourceNode): any[] | null {
+    private _resource(resource: Resource_Node): any[] | null {
         const subs = resource.kids
             .map(sub => {
                 const heading = Displayers.get(sub).pretty("local")
@@ -47,8 +47,8 @@ export class Summarizer {
         return [...subs, ...depends]
     }
 
-    private _resources(resources: ResourceNode[]): object {
-        const resourceContainer = List(resources)
+    private _resources(resources: Resource_Node[]): object {
+        const resourceContainer = resources
             .map(resource => {
                 const text = pretty`${resource}`
                 const token = this._token(text)
@@ -120,14 +120,14 @@ export class Summarizer {
         return outputs.join("\n")
     }
 
-    files(obj: { origin: Origin; resources: ResourceNode[] }[]) {
+    files(obj: { origin: OriginNode; resources: Resource_Node[] }[]) {
         let pairs = obj.flatMap(({ origin, resources }) => {
             return [
                 [this._token(pretty`\n${origin}`), this._resources(resources)] as [string, object]
             ]
         })
 
-        const x = Map(pairs).toJS()
+        const x = mapToObject(new Map(pairs))
         return this._serialize(x)
     }
 }

package/src/version.ts

@@ -1 +1,2 @@
-export const version = "0.0.1"
+import { version } from "../package.json"
+export { version }

package/dist/_imports/_mix.d.ts

@@ -1,4 +0,0 @@
-export * from "./acme.cert-manager.io";
-export * from "./gateway.networking.k8s.io";
-export * from "./k8s";
-//# sourceMappingURL=_mix.d.ts.map

package/dist/_imports/_mix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_mix.d.ts","sourceRoot":"","sources":["../../src/_imports/_mix.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,OAAO,CAAA"}

package/dist/_imports/_mix.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_mix.js","sourceRoot":"","sources":["../../src/_imports/_mix.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAsC;AACtC,8DAA2C;AAC3C,wCAAqB"}