k8ts 0.1.0

package/src/resources/service/index.ts

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

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

@@ -0,0 +1,24 @@
+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
+    }
+
+    export class Port<Port extends string> {
+        constructor(
+            readonly service: Service<Port>,
+            readonly port: Port
+        ) {}
+
+        ref() {
+            return {
+                kind: "Service",
+                namespace: this.service.meta.tryGet("namespace"),
+                name: this.service.meta.get("name")
+            }
+        }
+    }
+}

package/src/resources/service/service.ts

@@ -0,0 +1,53 @@
+import { manifest, relations, type InputPortMapping } from "@k8ts/instruments"
+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>
+export namespace Service {
+    export import Port = Port_
+    export import Frontend = Frontend_
+    export interface Props<Ports extends string> {
+        ports: InputPortMapping<Ports>
+        backend: Deployment.Deployment<Ports>
+        frontend: Frontend
+    }
+
+    const ident = v1.kind("Service")
+    @k8ts(ident)
+    @relations({
+        needs: self => ({
+            backend: self.props.backend
+        })
+    })
+    @manifest({
+        body(self): CDK.KubeServiceProps {
+            const svcPorts = self.ports
+            return {
+                spec: {
+                    ports: toServicePorts(svcPorts).toArray(),
+                    selector: self.props.backend.meta.pick("%app").labels,
+                    ...self.props.frontend
+                }
+            }
+        }
+    })
+    export class Service<Ports extends string = string> extends ManifestResource<Props<Ports>> {
+        kind = ident
+
+        get ports() {
+            const srcPorts = this.props.backend.ports.pull()
+            const svcPorts = srcPorts.map(this.props.ports)
+            return svcPorts
+        }
+
+        getPortRef(port: Ports) {
+            return new Port.Port(this, port)
+        }
+    }
+}

package/src/resources/utils/adapters.ts

@@ -0,0 +1,36 @@
+import type { EnvBuilder, PortMap, PortMapEntry, PortSet, PortSetEntry } from "@k8ts/instruments"
+import { CDK } from "../../_imports"
+
+export function toContainerPort(entry: PortSetEntry): CDK.ContainerPort {
+    return {
+        containerPort: entry.port,
+        name: entry.name,
+        protocol: entry.protocol
+    }
+}
+
+export function toContainerPorts(ports: PortSet<any>) {
+    return ports.values.map(toContainerPort)
+}
+
+export function toServicePort(entry: PortMapEntry): CDK.ServicePort {
+    return {
+        port: entry.source,
+        targetPort: CDK.IntOrString.fromNumber(entry.target),
+        protocol: entry.protocol,
+        name: entry.name
+    }
+}
+
+export function toServicePorts(ports: PortMap<any>) {
+    return ports.values.map(toServicePort).toList()
+}
+
+export function toEnvVars(env: EnvBuilder) {
+    return env.values.map((x, key) => {
+        return {
+            name: key,
+            value: x
+        } as CDK.EnvVar
+    })
+}

package/src/runner/exporter/FILE xyz.md

@@ -0,0 +1,47 @@
+FILE xyz.yaml
+
+Service _ ZZ
+HttpRoute _ OtherThing
+Gateway --> Gateway
+Deployment _ ABC
+PodTemplate _ (no name)
+Volume _ Xyz
+PVC --> AAA
+Container _ z
+Volume --> ABC : /mnt/data
+Container \* y
+Volume --> ABC : /mnt/data
+
+Service/X: - @Deployment/AAA
+HttpRoute/X: - @Service/X
+Deployment/X:
+PodTemplate:
+Container/XYZ: - Own/Thing: 222 - /mnt/data --> Volume/ABC -
+
+        Container/
+          - /mnt/b: @Volume/ABC
+        Volume:
+          - A:
+            - @Claim/AAA
+          - B:
+            - @Claim/XYZ
+
+Claim/AAA:
+
+- @Deployment/ABC
+
+---> BackThing/Hello (backend) \* ABC/AYZ
+---> OtherThing/Goodbye (service)
+
+- Deployment/ ABC [app=x]
+-   - PodTemplate [app=x]
+-       * Container/ XYZ
+          --> Volume/ Xyz : /mnt/data
+
+        * Volume A
+        --> AAA [PersistentVolumeClaim]
+
+- @ N
+- @ Name 3/
+-      * xtz
+-      *  abc

package/src/runner/exporter/assembler.ts

@@ -0,0 +1,170 @@
+import { BaseManifest, Origin, ResourceNode } 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 { ManifestSaver, type ManifestSaverEventsTable } from "./saver"
+import { YamlSerializer, type YamlSerializerEventsTable } from "./serializer"
+
+export class Assembler extends Emittery<AssemblerEventsTable> {
+    constructor(private readonly _options: AssemblerOptions) {
+        super()
+    }
+
+    async assemble(inFiles: Iterable<File.Input>) {
+        const _emit = async <Name extends keyof AssemblerEventsTable>(
+            event: Name,
+            payload: AssemblerEventsTable[Name]
+        ) => {
+            return await this.emit(event, payload)
+        }
+        const loader = new ResourceLoader({})
+        loader.onAny(_emit)
+        const generator = new Manifester({
+            cwd: this._options.cwd
+        })
+        generator.onAny(_emit)
+        const serializer = new YamlSerializer({})
+        serializer.onAny(_emit)
+        const saver = new ManifestSaver({
+            outdir: this._options.outdir
+        })
+        saver.onAny(_emit)
+        const reports = aseq(inFiles)
+            .before(async () => {
+                await _emit("stage", { stage: "gathering" })
+            })
+            .each(async file => {
+                await _emit("received-file", { file: file.__node__ })
+            })
+            .after(async () => {
+                await _emit("stage", { stage: "loading" })
+            })
+            .collect()
+            .map(async file => {
+                const loaded = await loader.load(file)
+                loaded.forEach(r => r.meta!.add(this._options.meta))
+                return {
+                    file: file.__entity__,
+                    resources: loaded.filter(x => !x.isExternal)
+                }
+            })
+            .after(async () => {
+                await _emit("stage", { stage: "manifesting" })
+            })
+            .collect()
+            .map(async ({ file, resources }) => {
+                const manifests = await aseq(resources)
+                    .map(async resource => {
+                        return {
+                            k8ts: resource,
+                            manifest: await generator.generate(resource)
+                        }
+                    })
+                    .toArray()
+                    .pull()
+
+                return {
+                    file,
+                    manifests
+                }
+            })
+            .after(async () => {
+                await _emit("stage", { stage: "serializing" })
+            })
+            .collect()
+            .map(async ({ file, manifests }) => {
+                const artifacts = await aseq(manifests)
+                    .map(async obj => {
+                        return {
+                            ...obj,
+                            yaml: await serializer.serialize(obj.manifest)
+                        }
+                    })
+                    .toArray()
+                    .pull()
+
+                return {
+                    file,
+                    artifacts
+                }
+            })
+            .after(async () => {
+                await _emit("stage", { stage: "saving" })
+            })
+            .after(async () => {
+                await saver.prepareOnce()
+            })
+            .collect()
+            .map(async ({ file, artifacts }) => {
+                const { filename, bytes, path } = await saver.save(
+                    file.node,
+                    artifacts.map(x => x.yaml)
+                )
+                return {
+                    file: file.node,
+                    path,
+                    filename,
+                    bytes,
+                    artifacts
+                }
+            })
+            .after(async () => {
+                await _emit("stage", { stage: "done" })
+            })
+            .collect()
+            .toArray()
+        const files = (await reports.pull()) satisfies AssembledFile[]
+        return {
+            files,
+            options: cloneDeep(this._options)
+        } as AssembledResult
+    }
+}
+export interface Artifact {
+    k8ts: ResourceNode
+    manifest: BaseManifest
+    yaml: string
+}
+export interface AssembledFile {
+    file: Origin
+    path: string
+    filename: string
+    bytes: number
+    artifacts: Artifact[]
+}
+export interface AssembledResult {
+    files: AssembledFile[]
+    options: AssemblerOptions
+}
+export interface AssemblerOptions {
+    cwd?: string
+    printOptions?: boolean
+    outdir: string
+    meta?: Omit<Meta.Input, "name" | "namespace"> | Meta
+}
+export type AssemblyStage =
+    | "loading"
+    | "manifesting"
+    | "serializing"
+    | "saving"
+    | "start"
+    | "reporting"
+    | "done"
+    | "gathering"
+export interface AssemblerEventsTable
+    extends ManifestSaverEventsTable,
+        YamlSerializerEventsTable,
+        ManifesterEventsTable,
+        ResourceLoaderEventsTable {
+    ["received-file"]: { file: Origin }
+    ["stage"]: { stage: AssemblyStage }
+}
+export type AnyAssemblerEvent = {
+    [K in keyof AssemblerEventsTable]: AssemblerEventsTable[K] & {
+        type: K
+    }
+}[keyof AssemblerEventsTable]

package/src/runner/exporter/index.ts

@@ -0,0 +1,2 @@
+export * from "./assembler"
+export * from "./progress-shower"

package/src/runner/exporter/loader.ts

@@ -0,0 +1,54 @@
+import { ForwardRef, ResourceNode } from "@k8ts/instruments"
+import { seq } from "doddle"
+import Emittery from "emittery"
+import { List } from "immutable"
+import { MakeError } from "../../error"
+import type { File } from "../../file"
+import { k8ts_namespace } from "./meta"
+export class ResourceLoader extends Emittery<ResourceLoaderEventsTable> {
+    constructor(private readonly _options: ResourceLoaderOptions) {
+        super()
+    }
+
+    private _attachSourceAnnotations(loadEvent: ResourceLoadedEvent) {
+        const { resource } = loadEvent
+
+        resource.meta!.add(k8ts_namespace, {
+            "^declared-in": `(${resource.origin.root.name}) ${resource.origin.name}`
+        })
+    }
+
+    async load(input: File.Input) {
+        let resources = List<ResourceNode>()
+        seq(input).drain().pull()
+        for (let res of input.__node__.resources) {
+            const origin = res.origin
+            if (!origin.isChildOf(origin)) {
+                throw new MakeError(`Resource ${res} is not a child of the input file ${input}`)
+            }
+            if (ForwardRef.is(res)) {
+                throw new MakeError(`Resource ${res} is a forward reference`)
+            }
+            const event = {
+                isExported: res.meta!.has(`#${k8ts_namespace}is-exported`),
+                resource: res
+            } as const
+
+            this._attachSourceAnnotations(event)
+            await this.emit("load", event)
+            resources = resources.push(res)
+        }
+
+        return resources.toArray()
+    }
+}
+export interface ResourceLoadedEvent {
+    isExported: boolean
+    resource: ResourceNode
+}
+
+export interface ResourceLoaderEventsTable {
+    load: ResourceLoadedEvent
+}
+
+export interface ResourceLoaderOptions {}

package/src/runner/exporter/manifester.ts

@@ -0,0 +1,77 @@
+import { BaseManifest, ResourceNode, TraceEmbedder } 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) {
+        const clone = cloneDeepWith(manifest, (value, key) => {
+            if (key !== "metadata") {
+                return
+            }
+            for (const k in value) {
+                if (["labels", "annotations"].includes(k)) {
+                    if (isEmpty(value[k])) {
+                        unset(value, k)
+                    }
+                }
+            }
+        })
+        return clone
+    }
+    private _cleanNullishValues(manifest: BaseManifest) {
+        const _cleanKeys = (obj: any) => {
+            if (typeof obj !== "object") {
+                return obj
+            }
+            for (const [k, v] of Object.entries(obj)) {
+                if (v == null) {
+                    delete obj[k]
+                }
+            }
+            return undefined
+        }
+        const clone = cloneDeep(manifest)
+
+        return cloneDeepWith(clone, _cleanKeys)
+    }
+    private _generate(resource: ManifestResource): BaseManifest {
+        const manifest = resource["manifest"]()
+        const noNullish = this._cleanNullishValues(manifest)
+        const noEmpty = this._cleanSpecificEmptyObjects(noNullish)
+        return noEmpty
+    }
+
+    private _attachProductionAnnotations(resource: ResourceNode) {
+        const origin = resource.origin
+        const entry = TraceEmbedder.get(resource)
+        const loc = resource.trace.format({
+            cwd: this._options.cwd
+        })
+        resource.meta!.add(k8ts_namespace, {
+            "^constructed-at": loc,
+            "^produced-by": `k8ts@${version}`
+        })
+    }
+
+    async generate(res: ResourceNode) {
+        this._attachProductionAnnotations(res)
+        await this.emit("manifest", { resource: res })
+        const manifest = this._generate(res.entity as ManifestResource)
+        return manifest
+    }
+}
+export interface ManifesterManifestEvent {
+    resource: ResourceNode
+}
+
+export interface ManifesterEventsTable {
+    manifest: ManifesterManifestEvent
+}

package/src/runner/exporter/meta.ts

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

package/src/runner/exporter/progress-shower.ts

@@ -0,0 +1,77 @@
+import { attr, dest, ManifestSourceEmbedder, pretty, quantity, verb } from "@k8ts/instruments"
+import ora from "ora"
+import { setTimeout } from "timers/promises"
+import type { Assembler, AssemblerEventsTable, AssemblyStage } from "./assembler"
+import { stage } from "./stage"
+export interface ProgressOptions {
+    waitTransition?: number
+    debug?: boolean
+}
+
+function typedOnAny(
+    target: Assembler,
+    handler: (
+        typedEvent: {
+            [K in keyof AssemblerEventsTable]: AssemblerEventsTable[K] & { type: K }
+        }[keyof AssemblerEventsTable]
+    ) => void | Promise<void>
+) {
+    return target.onAny((name, ev) => {
+        return handler({ ...ev, type: name } as any)
+    })
+}
+
+export class ProgressShower {
+    constructor(private readonly _options: ProgressOptions) {}
+    async visualize(events: Assembler) {
+        const spinner = ora({
+            spinner: "dots",
+            text: "K8ts is getting ready..."
+        })
+        spinner.text = "abc"
+        let filesWritten = 0
+        let lastStage: AssemblyStage = "start"
+        const unsub = typedOnAny(events, async event => {
+            switch (event.type) {
+                case "load":
+                    spinner.text = pretty`${verb("Load")} ${attr(
+                        event.isExported ? "exported" : ""
+                    )} ${event.resource} `
+                    break
+                case "stage":
+                    if (event.stage !== "done") {
+                        return
+                    }
+                    spinner.text = pretty`${stage(event.stage)}`
+                    break
+                case "received-file":
+                    spinner.text = pretty`${verb("Receive")} ${event.file}`
+                    break
+                case "serialize":
+                    const rsc = ManifestSourceEmbedder.get(event.manifest)
+                    spinner.text = pretty`${verb("Serialize")} ${rsc}`
+                    break
+                case "save":
+                    spinner.text = pretty`${verb("Save")} ${dest(event.filename)} (${quantity(event.bytes, "byte")})`
+                    break
+
+                case "manifest":
+                    spinner.text = pretty`${verb("Manifest")} ${event.resource}`
+                    break
+                case "purge":
+                    spinner.text = pretty`${verb("Purge")} ${dest(event.outdir)}`
+                    break
+            }
+            if (this._options.waitTransition) {
+                await setTimeout(this._options.waitTransition)
+            }
+            spinner.render()
+
+            if (this._options.debug) {
+                console.log()
+            }
+        })
+
+        spinner.render()
+    }
+}

package/src/runner/exporter/saver.ts

@@ -0,0 +1,62 @@
+import type { Origin } from "@k8ts/instruments"
+import Emittery from "emittery"
+import { mkdir, rm, writeFile } from "fs/promises"
+import { join, resolve } from "path"
+
+export class ManifestSaver extends Emittery<ManifestSaverEventsTable> {
+    private _encoder = new TextEncoder()
+    constructor(private readonly _options: ManifestSaverOptions) {
+        super()
+    }
+
+    _splat(manifests: string[]) {
+        return manifests.join("\n---\n")
+    }
+
+    async prepareOnce() {
+        await this.emit("purge", {
+            outdir: this._options.outdir
+        })
+        await rm(this._options.outdir, {
+            force: true,
+            maxRetries: 2,
+            retryDelay: 500,
+            recursive: true
+        })
+        await mkdir(this._options.outdir, { recursive: true })
+    }
+
+    async save(origin: Origin, manifests: string[]) {
+        const content = this._splat(manifests)
+        const filename = `${origin.name}`
+        const encoded = this._encoder.encode(content)
+        const outPath = resolve(this._options.outdir, filename)
+        const e: SavingManifestEvent = {
+            filename,
+            path: outPath,
+            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)
+        return e
+    }
+}
+export interface SavingManifestEvent {
+    path: string
+    filename: string
+    content: string
+    bytes: number
+}
+export interface PurgingDirEvent {
+    outdir: string
+}
+export interface ManifestSaverEventsTable {
+    save: SavingManifestEvent
+    purge: PurgingDirEvent
+}
+
+export interface ManifestSaverOptions {
+    outdir: string
+}

package/src/runner/exporter/serializer.ts

@@ -0,0 +1,49 @@
+import { BaseManifest, ManifestSourceEmbedder } from "@k8ts/instruments"
+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
+}
+export interface YamlSerializerEventsTable {
+    serialize: SerializingEvent
+}
+export class YamlSerializer extends Emittery<YamlSerializerEventsTable> {
+    constructor(private readonly _options: Partial<YamlSerializerOptions>) {
+        super()
+    }
+
+    async serialize(input: BaseManifest) {
+        await this.emit("serialize", { manifest: input })
+
+        try {
+            const result = dump(input, {
+                lineWidth: 800,
+                noArrayIndent: true,
+                indent: 2,
+                replacer(key, value) {
+                    if (value instanceof CDK.IntOrString) {
+                        return value.value
+                    }
+                    if (value instanceof CDK.Quantity) {
+                        return value.value
+                    }
+                    return value
+                },
+                ...this._options.jsYamlOptions,
+                noRefs: true
+            })
+            return result
+        } catch (err) {
+            const resource = ManifestSourceEmbedder.get(input)
+            throw new MakeError(`Failed to serialize manifest ${resource?.shortFqn ?? "???"}`, {
+                cause: err
+            })
+        }
+    }
+}