k8ts 0.1.0

package/src/_imports/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "CommonJS",
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "moduleResolution": "Node",
+    "resolveJsonModule": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "tsBuildInfoFile": "../../dist/.imports.tsbuildinfo",
+    "rootDir": ".",
+    "noEmit": false,
+    "declaration": true,
+    "outDir": "../../dist/_imports",
+    "strict": false
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["**/node_modules"]
+}

package/src/api-versions.ts

@@ -0,0 +1,5 @@
+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("networking.k8s.io").version("v1")

package/src/error.ts

@@ -0,0 +1,7 @@
+export class MakeError extends Error {
+    override name = "MakeError"
+    constructor(message: string, details: Record<string, any> = {}) {
+        super(message)
+        Object.assign(this, details)
+    }
+}

package/src/external/index.ts

@@ -0,0 +1,34 @@
+import { Kind, Origin, relations } from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import { ManifestResource } from "../node"
+
+@relations("none")
+export class External<K extends Kind> extends ManifestResource {
+    constructor(
+        origin: Origin,
+        readonly kind: K,
+        name: string,
+        namespace: string | undefined
+    ) {
+        super(
+            origin,
+            Meta.make({
+                name,
+                namespace
+            }),
+            {}
+        )
+    }
+
+    manifestBody(): never {
+        throw new Error("External resources cannot be manifested")
+    }
+
+    ref() {
+        return {
+            kind: this.kind.name,
+            name: this.name,
+            namespace: this.namespace
+        }
+    }
+}

package/src/file/exports.ts

@@ -0,0 +1,63 @@
+import { FutureExports, Producer } from "@k8ts/instruments"
+import { seq, type Seq } from "doddle"
+import type { ManifestResource } from "../node"
+import { k8ts_namespace } from "../runner/exporter/meta"
+import { Factory } from "./factory"
+import type { FileOrigin } from "./origin"
+
+export namespace FileExports {
+    export type Producer<
+        Scope extends FileOrigin.Scope,
+        Produced extends object
+    > = Producer.Producer<Factory.FromScope<Scope>, Produced>
+    export interface Props<
+        Scope extends FileOrigin.Scope = FileOrigin.Scope,
+        Produced extends ManifestResource = ManifestResource
+    > {
+        origin: FileOrigin<Scope>
+        FILE: Producer<Scope, Produced>
+    }
+
+    export class Core {
+        #props: Props
+        #produced: Seq<ManifestResource>
+        constructor(props: Props) {
+            this.#props = props
+            const producer = Producer.map(props.FILE, () => {
+                if (props.origin.scope === "cluster") {
+                    return new Factory.Cluster(props.origin.node)
+                } else {
+                    return new Factory.Namespaced(props.origin.node)
+                }
+            })
+            this.#produced = seq(() => producer(props.origin)).each(x => {
+                x.meta.add(k8ts_namespace, {
+                    "#is-exported": "true"
+                })
+            })
+        }
+
+        get __entity__() {
+            return this.#props.origin
+        }
+
+        get __node__() {
+            return this.#props.origin.node
+        }
+
+        [Symbol.iterator]() {
+            return this.#produced[Symbol.iterator]()
+        }
+    }
+
+    export function make<Scope extends FileOrigin.Scope, Produced extends ManifestResource>(
+        props: Props<Scope, Produced>
+    ): Core & FutureExports<Produced> {
+        const core = new Core(props)
+        return FutureExports.make({
+            actual: core,
+            origin: props.origin.node,
+            exports: core
+        }) as any
+    }
+}

package/src/file/factory.ts

@@ -0,0 +1,150 @@
+import { Origin, auto_register, displayers, type LiveRefable } from "@k8ts/instruments"
+import chalk from "chalk"
+import {
+    ConfigMap,
+    Deployment,
+    HttpRoute,
+    Namespace,
+    Persistent,
+    PodTemplate,
+    Secret,
+    Service
+} from "../resources"
+import { AssemblyStage } from "../runner/exporter"
+import type { FileOrigin } from "./origin"
+
+export type Factory = Factory.Factory
+export namespace Factory {
+    export type Factory = Cluster | Namespaced
+    export type FromScope<FScope extends FileOrigin.Scope> = FScope extends "cluster"
+        ? Cluster
+        : Namespaced
+
+    export class Base {
+        constructor(readonly origin: Origin) {}
+
+        protected _metaWithName(name: string) {
+            return this.origin.meta.add({
+                name
+            })
+        }
+    }
+    @auto_register
+    export class Cluster extends Base {
+        PersistentVolume<Name extends string, Mode extends Persistent.DataMode = "Filesystem">(
+            name: Name,
+            props: Persistent.Volume.Props<Mode>
+        ) {
+            return new Persistent.Volume.Volume(
+                this.origin,
+                this._metaWithName(name),
+                props
+            ) as LiveRefable<Persistent.Volume<Mode>, Name>
+        }
+        Namespace<Name extends string>(name: Name, props?: Namespace.Props) {
+            return new Namespace.Namespace(
+                this.origin,
+                this._metaWithName(name),
+                props
+            ) as LiveRefable<Namespace, Name>
+        }
+    }
+
+    @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>
+        }
+        ConfigMap<Name extends string>(name: Name, props: ConfigMap.Props) {
+            return new ConfigMap.ConfigMap(
+                this.origin,
+                this._metaWithName(name),
+                props
+            ) as LiveRefable<ConfigMap, Name>
+        }
+        Secret<Name extends string>(name: Name, props: Secret.Props) {
+            return new Secret.Secret(this.origin, this._metaWithName(name), props) as LiveRefable<
+                Secret,
+                Name
+            >
+        }
+        Service<Name extends string, Ports extends string>(
+            name: Name,
+            props: Service.Props<Ports>
+        ) {
+            return new Service.Service(this.origin, this._metaWithName(name), props) as LiveRefable<
+                Service<Ports>,
+                Name
+            >
+        }
+
+        Deployment<Name extends string, Ports extends string>(
+            name: Name,
+            props: Deployment.Props<Ports>
+        ) {
+            return new Deployment.Deployment(
+                this.origin,
+                this._metaWithName(name),
+                props
+            ) as LiveRefable<Deployment<Ports>, Name>
+        }
+
+        DomainRoute<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>
+        }
+        PodTemplate<Name extends string, Ports extends string>(
+            name: Name,
+            props: PodTemplate.Props<Ports> | PodTemplate.Props<Ports>["POD"]
+        ) {
+            const props_ = typeof props === "function" ? { POD: props } : props
+            return new PodTemplate.PodTemplate(
+                this.origin,
+                this._metaWithName(name),
+                props_
+            ) as LiveRefable<PodTemplate<Ports>, Name>
+        }
+    }
+}
+@displayers({
+    simple: s => s.text,
+    pretty: stage => chalk.bgGreenBright.bold.black(` ${stage.text} `)
+})
+export class Stage {
+    text: string
+    constructor(private stage: AssemblyStage) {
+        this.text = `${stage.toUpperCase()}`
+    }
+
+    private get _emoji() {
+        switch (this.stage) {
+            case "gathering":
+                return "🛒"
+            case "loading":
+                return "🚚"
+            case "manifesting":
+                return "👻"
+            case "start":
+                return "🚀"
+            case "saving":
+                return "💾"
+            case "serializing":
+                return "🖨️"
+            case "done":
+                return "✅"
+        }
+    }
+}

package/src/file/file.ts

@@ -0,0 +1,34 @@
+import type { FutureExports, Origin } from "@k8ts/instruments"
+import type { ManifestResource } from "../node"
+import { FileExports as Exports_ } from "./exports"
+import { Factory as Factory_ } from "./factory"
+import { FileOrigin } from "./origin"
+export type File<T extends ManifestResource = ManifestResource> = File.File<T>
+export namespace File {
+    export import Factory = Factory_
+
+    export import Exports = Exports_
+
+    export interface Props<
+        Scope extends FileOrigin.Scope = FileOrigin.Scope,
+        Produced extends ManifestResource = ManifestResource
+    > extends FileOrigin.Props<Scope> {
+        FILE: Exports.Producer<Scope, Produced>
+    }
+
+    export type Input = Exports.Core & Iterable<ManifestResource>
+    export type File<T extends ManifestResource> = Exports.Core & FutureExports<T>
+
+    export function make<Scope extends FileOrigin.Scope, Produced extends ManifestResource>(
+        name: string,
+        props: Props<Scope, Produced>,
+        parent: Origin
+    ) {
+        const origin = FileOrigin.make(name, props, parent)
+        const exports = Exports.make({
+            origin,
+            FILE: props.FILE
+        })
+        return exports as File<Produced>
+    }
+}

package/src/file/index.ts

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

package/src/file/origin.ts

@@ -0,0 +1,38 @@
+import { BaseOriginEntity, Origin, OriginEntityProps } from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import { k8tsBuildKind } from "../k8ts-sys-kind"
+import type { Namespace } from "../resources"
+export type FileOrigin<FScope extends FileOrigin.Scope = FileOrigin.Scope> =
+    FileOrigin.FileEntity<FScope>
+export namespace FileOrigin {
+    export type Scope = Namespace | "cluster"
+
+    export interface Props<FScope extends Scope = Scope> extends OriginEntityProps {
+        meta?: Meta.Input
+        scope: FScope
+    }
+
+    const ident = k8tsBuildKind.kind("File")
+    export class FileEntity<FScope extends Scope> extends BaseOriginEntity<Props<FScope>> {
+        kind = k8tsBuildKind.kind("File")
+
+        constructor(name: string, props: Props<FScope>, parent: Origin) {
+            super(name, props, parent)
+            this.meta = this.meta.add({
+                namespace: props.scope === "cluster" ? undefined : props.scope.name
+            })
+        }
+
+        get scope() {
+            return this.props.scope
+        }
+    }
+
+    export function make<FScope extends Scope>(
+        name: string,
+        props: Props<FScope>,
+        parent: Origin
+    ): FileEntity<FScope> {
+        return new FileEntity(name, props, parent)
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { CDK } from "./_imports"
+export * from "./external"
+export * from "./file"
+export * as ScopedFactory from "./file/factory"
+export * from "./resources"
+export * from "./runner"
+export * from "./runner/exporter"
+export * from "./world"

package/src/k8ts-sys-kind.ts

@@ -0,0 +1,4 @@
+import { Kind } from "@k8ts/instruments"
+import { version } from "./version"
+const major = version.split(".")[0]
+export const k8tsBuildKind = Kind.group("build.k8ts.org").version(`v${major}`)

package/src/kind-map.ts

@@ -0,0 +1,39 @@
+import {
+    BaseOriginEntity,
+    Kind,
+    kinded,
+    MetadataEntity,
+    OriginEntityProps
+} from "@k8ts/instruments"
+import { k8tsBuildKind } from "./k8ts-sys-kind"
+const ident = k8tsBuildKind.kind("World")
+
+class K8tsRootOriginEntity extends BaseOriginEntity<OriginEntityProps> {
+    override kind = ident
+    constructor() {
+        super(
+            "K8ts",
+            {
+                meta: {
+                    "^produced-by": `k8ts@${k8tsBuildKind.name.slice(1)}`
+                }
+            },
+            null
+        )
+    }
+
+    get decorator() {
+        return <Target extends new (...args: any[]) => MetadataEntity>(kind: Kind.Identifier) => {
+            return (ctor: Target) => {
+                this.node.resourceKinds.add(kind, ctor)
+                kinded(kind)(ctor)
+                return ctor
+            }
+        }
+    }
+}
+
+export const K8tsRootOrigin = new K8tsRootOriginEntity()
+export const K8tsResources = K8tsRootOrigin.node.resourceKinds
+
+export const k8ts = K8tsRootOrigin.decorator

package/src/meta/k8ts-section.ts

@@ -0,0 +1,6 @@
+import { Meta } from "@k8ts/metadata"
+import { k8ts_namespace } from "../runner/exporter/meta"
+export function k8tsSectionMeta(meta: Meta.Input) {
+    const m = Meta.make(meta)
+    return m.section(k8ts_namespace)
+}

package/src/node/abs-resource.ts

@@ -0,0 +1,32 @@
+import { displayers, Kind, Origin, RefKey, ResourceNode } from "@k8ts/instruments"
+import { Doddle, doddle } from "doddle"
+export interface DependsOn {
+    resource: AbsResource
+    text: string
+}
+@displayers({
+    simple: s => s.node,
+    pretty: s => s.node
+})
+export abstract class AbsResource<Props extends object = object> {
+    abstract readonly kind: Kind.Identifier<string, Kind.Identifier>
+
+    private _node: Doddle<ResourceNode>
+
+    get node() {
+        return this._node.pull()
+    }
+    constructor(
+        origin: Origin,
+        readonly name: string,
+        readonly props: Props
+    ) {
+        this._node = doddle(() => new ResourceNode(origin, this, RefKey.make(this.kind, this.name)))
+    }
+
+    get shortFqn() {
+        return [this.node.origin.name, [this.kind.name, this.name].filter(Boolean).join("/")].join(
+            ":"
+        )
+    }
+}

package/src/node/index.ts

@@ -0,0 +1 @@
+export { ManifestResource } from "./manifest-resource"

package/src/node/manifest-resource.ts

@@ -0,0 +1,19 @@
+import { Builder, Kind, type Origin } from "@k8ts/instruments"
+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() {
+        return Builder.get(this).manifest()
+    }
+    abstract override readonly kind: Kind.Kind
+    readonly meta: MutableMeta
+    constructor(origin: Origin, meta: Meta | MutableMeta, props: Props) {
+        super(origin, meta.get("name"), props)
+        this.meta = meta.toMutable()
+    }
+
+    get namespace() {
+        return this.meta.tryGet("namespace")
+    }
+}

package/src/node/sub-resource.ts

@@ -0,0 +1,20 @@
+import { relations } from "@k8ts/instruments"
+import { AbsResource } from "./abs-resource"
+import type { ManifestResource } from "./manifest-resource"
+
+@relations({
+    parent: self => self.parent
+})
+export abstract class SubResource<Props extends object = object> extends AbsResource<Props> {
+    constructor(
+        readonly parent: ManifestResource,
+        name: string,
+        props: Props
+    ) {
+        super(parent.node.origin, name, props)
+    }
+
+    get namespace() {
+        return this.parent.namespace
+    }
+}

package/src/node/top-resource.ts

@@ -0,0 +1,7 @@
+import type { Kind } from "@k8ts/instruments"
+import { AbsResource } from "./abs-resource"
+
+export abstract class TopResource<Props extends object = object> extends AbsResource<Props> {
+    abstract override readonly kind: Kind.Kind
+    abstract readonly namespace: string | undefined
+}

package/src/paths.ts

@@ -0,0 +1 @@
+export const proverbsPath = `${__dirname}/../proverbs.txt`

package/src/resources/configmap/configmap.ts

@@ -0,0 +1,26 @@
+import { manifest, relations } 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 interface Props {
+        data: Record<string, string>
+        name: string
+    }
+
+    const ident = v1.kind("ConfigMap")
+    @k8ts(ident)
+    @relations("none")
+    @manifest({
+        body(self): CDK.KubeConfigMapProps {
+            return {
+                data: self.props.data
+            }
+        }
+    })
+    export class ConfigMap extends ManifestResource<Props> {
+        override kind = ident
+    }
+}

package/src/resources/configmap/index.ts

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

package/src/resources/deployment/deployment.ts

@@ -0,0 +1,54 @@
+import { manifest, Origin, relations } from "@k8ts/instruments"
+import { Meta, MutableMeta } from "@k8ts/metadata"
+import { omit } from "lodash"
+import { CDK } from "../../_imports"
+import { apps_v1 } from "../../api-versions"
+import { k8ts } from "../../kind-map"
+import { ManifestResource } from "../../node/manifest-resource"
+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"> & {
+        template: PodTemplate.Props<Ports>
+    }
+
+    const ident = apps_v1.kind("Deployment")
+    @k8ts(ident)
+    @relations({
+        kids: s => [s.template]
+    })
+    @manifest({
+        body(self): CDK.KubeDeploymentProps {
+            return {
+                spec: {
+                    ...omit(self.props, "template"),
+                    selector: {
+                        matchLabels: {
+                            app: self.name
+                        }
+                    },
+                    template: self.template["manifest"]()
+                }
+            }
+        }
+    })
+    export class Deployment<Ports extends string = string> extends ManifestResource<Props<Ports>> {
+        kind = ident
+        template: PodTemplate<Ports>
+        constructor(origin: Origin, meta: Meta | MutableMeta, props: Props<Ports>) {
+            super(origin, meta, props)
+            this.template = new PodTemplate.PodTemplate(
+                origin,
+                Meta.make({
+                    name: this.name,
+                    "%app": this.name
+                }),
+                props.template
+            )
+        }
+        get ports() {
+            return this.template.ports
+        }
+    }
+}

package/src/resources/deployment/index.ts

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

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

@@ -0,0 +1,45 @@
+import { manifest, relations } from "@k8ts/instruments"
+import type { CDK } from "../../_imports"
+import { gateway_v1 } from "../../api-versions"
+import type { External } from "../../external"
+import { k8ts } from "../../kind-map"
+import { ManifestResource } from "../../node"
+import type { Service } from "../service"
+
+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>
+        hostname: string
+        backend: Service.Port<Ports>
+    }
+
+    const kind = gateway_v1.kind("HttpRoute")
+    @k8ts(kind)
+    @relations({
+        needs: self => ({
+            gateway: self.props.parent,
+            service: self.props.backend.service
+        })
+    })
+    @manifest({
+        body(self): CDK.HttpRouteProps {
+            return {
+                spec: {
+                    parentRefs: [self.props.parent.ref()],
+                    hostnames: [self.props.hostname],
+                    rules: [
+                        {
+                            backendRefs: [self.props.backend.ref()]
+                        }
+                    ]
+                }
+            }
+        }
+    })
+    export class HttpRoute<Ports extends string> extends ManifestResource<Props<Ports>> {
+        kind = gateway_v1.kind("HttpRoute")
+    }
+}

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

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

package/src/resources/index.ts

@@ -0,0 +1,8 @@
+export * from "./configmap"
+export * from "./deployment"
+export * from "./http-route/http-route"
+export * from "./namespace"
+export * from "./persistent"
+export * from "./pod"
+export * from "./secret"
+export * from "./service"

package/src/resources/namespace/index.ts

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