k8ts 0.8.1 → 0.9.2

package/src/external/index.ts

@@ -1,34 +0,0 @@
-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 = 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

@@ -1,66 +0,0 @@
-import { FutureExports, LiveRefable, Producer } from "@k8ts/instruments"
-import { seq, type Seq } from "doddle"
-import { 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 LiveRefable = LiveRefable
-    > {
-        origin: FileOrigin<Scope>
-        FILE: Producer<Scope, Produced>
-    }
-
-    export class Core {
-        #props: Props
-        #produced: Seq<LiveRefable>
-        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))
-                .as<ManifestResource>()
-                .each(x => {
-                    x.meta.add(k8ts_namespace, {
-                        "#is-exported": "true"
-                    })
-                })
-                .cache()
-        }
-
-        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 LiveRefable>(
-        props: Props<Scope, Produced>
-    ): Core & FutureExports<Produced> {
-        const core = new Core(props as any)
-        return FutureExports.make({
-            actual: core,
-            origin: props.origin.node,
-            exports: core
-        }) as any
-    }
-}

package/src/file/factory.ts

@@ -1,199 +0,0 @@
-import {
-    Cron,
-    Origin,
-    Trace,
-    TraceEmbedder,
-    auto_register,
-    displayers,
-    type LiveRefable
-} from "@k8ts/instruments"
-import chalk from "chalk"
-import StackTracey from "stacktracey"
-import {
-    ConfigMap,
-    DataMode,
-    Deployment,
-    HttpRoute,
-    Namespace,
-    PodTemplate,
-    Pv,
-    Pvc,
-    Secret,
-    Service
-} from "../resources"
-import { K8tsCronJob, K8tsCronJobProps } from "../resources/cronjob"
-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 DataMode = "Filesystem">(
-            name: Name,
-            props: Pv.Props<Mode>
-        ) {
-            return new Pv.Pv(this.origin, this._metaWithName(name), props) as LiveRefable<
-                Pv.Pv<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<Name extends string, Mode extends DataMode = "Filesystem">(
-            name: Name,
-            mode: Pvc.Props<Mode>
-        ) {
-            return new Pvc.Pvc(this.origin, this._metaWithName(name), mode) as LiveRefable<
-                Pvc.Pvc<Mode>,
-                Name
-            >
-        }
-        CronJob<Name extends string, Cr extends Cron.Record>(
-            name: Name,
-            props: K8tsCronJobProps<Cr>
-        ) {
-            return new K8tsCronJob(this.origin, this._metaWithName(name), props) as LiveRefable<
-                K8tsCronJob<Cr>,
-                Name
-            >
-        }
-
-        ConfigMap<Name extends string>(name: Name, props: ConfigMap.Props) {
-            return new ConfigMap.ConfigMap(
-                this.origin,
-                this._metaWithName(name),
-                props
-            ) as LiveRefable<ConfigMap, Name>
-        }
-        HttpRoute<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>
-        }
-        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, DeployPorts extends string, ExposedPorts extends DeployPorts>(
-            name: Name,
-            props: Service.Props<DeployPorts, ExposedPorts>
-        ) {
-            return new Service.Service(this.origin, this._metaWithName(name), props) as LiveRefable<
-                Service<ExposedPorts>,
-                Name
-            >
-        }
-
-        Deployment<Name extends string>(name: Name, props: Deployment.NormalProps) {
-            const builder = this
-            const traceHere = new Trace(new StackTracey().slice(2))
-
-            return {
-                Template(templateProps?: PodTemplate.PodProps) {
-                    return {
-                        POD<Ports extends string>(
-                            producer: PodTemplate.PodContainerProducer<Ports>
-                        ) {
-                            const dep = new Deployment.Deployment(
-                                builder.origin,
-                                builder._metaWithName(name),
-                                {
-                                    ...props,
-                                    $template: {
-                                        ...templateProps,
-                                        $POD: producer
-                                    }
-                                }
-                            ) as LiveRefable<Deployment<Ports>, Name>
-                            TraceEmbedder.set(dep.node, traceHere)
-                            dep.node.origin["__attach_resource__"]([dep.node])
-                            return dep
-                        }
-                    }
-                }
-            }
-        }
-
-        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

@@ -1,33 +0,0 @@
-import type { FutureExports, LiveRefable, Origin } from "@k8ts/instruments"
-import { FileExports as Exports_ } from "./exports"
-import { Factory as Factory_ } from "./factory"
-import { FileOrigin } from "./origin"
-export type File<T extends LiveRefable = LiveRefable> = 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 LiveRefable = LiveRefable
-    > extends FileOrigin.Props<Scope> {
-        FILE: Exports.Producer<Scope, Produced>
-    }
-
-    export type Input = Exports.Core & Iterable<LiveRefable>
-    export type File<T extends LiveRefable> = Exports.Core & FutureExports<T>
-
-    export function make<Scope extends FileOrigin.Scope, Produced extends LiveRefable>(
-        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

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

package/src/file/origin.ts

@@ -1,41 +0,0 @@
-import { BaseOriginEntity, Origin, OriginEntityProps, Refable } from "@k8ts/instruments"
-import { Meta } from "@k8ts/metadata"
-import { k8tsBuildKind } from "../k8ts-sys-kind"
-import { api } from "../kinds"
-export type FileOrigin<FScope extends FileOrigin.Scope = FileOrigin.Scope> =
-    FileOrigin.FileEntity<FScope>
-export namespace FileOrigin {
-    export type Scope = Refable<api.v1_.Namespace> | "cluster"
-
-    export interface SmallerProps extends OriginEntityProps {
-        meta?: Meta.Input
-    }
-    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/k8ts-sys-kind.ts

@@ -1,4 +0,0 @@
-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

@@ -1,42 +0,0 @@
-import {
-    BaseOriginEntity,
-    Kind,
-    kinded,
-    OriginEntityProps,
-    ResourceEntity
-} 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 abstract new (...args: any[]) => ResourceEntity>(
-            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
-export const REF_TYPE = Symbol.for("k8ts:ref")

package/src/kinds.ts

@@ -1,158 +0,0 @@
-import { Kind } from "@k8ts/instruments"
-export namespace api {
-    export const v1 = Kind.version("v1")
-    export type v1 = typeof v1
-
-    export const batch = Kind.group("batch")
-    export type batch = typeof batch
-    export namespace batch_ {
-        export const v1 = batch.version("v1")
-        export namespace v1_ {
-            export function kind_<Name extends string>(name: Name): Kind<Name, typeof v1> {
-                return v1.kind(name)
-            }
-
-            export const Job = v1.kind("Job")
-            export type Job = typeof Job
-
-            export const CronJob = v1.kind("CronJob")
-            export type CronJob = typeof CronJob
-        }
-    }
-    export namespace v1_ {
-        export function kind_<Name extends string>(name: Name): Kind<Name, typeof v1> {
-            return v1.kind(name)
-        }
-
-        export const ConfigMap = v1.kind("ConfigMap")
-        export type ConfigMap = typeof ConfigMap
-
-        export const Secret = v1.kind("Secret")
-        export type Secret = typeof Secret
-
-        export const Service = v1.kind("Service")
-        export type Service = typeof Service
-
-        export const Pod = v1.kind("Pod")
-        export type Pod = typeof Pod
-
-        export namespace Pod_ {
-            export const Container = Pod.subkind("Container")
-            export type Container = typeof Container
-
-            export const Port = Container.subkind("Port")
-            export type Port = typeof Port
-
-            export const EnvVar = Container.subkind("EnvVar")
-            export type EnvVar = typeof EnvVar
-
-            export const VolumeMount = Container.subkind("VolumeMount")
-            export type VolumeMount = typeof VolumeMount
-
-            export const DeviceMount = Container.subkind("DeviceMount")
-            export type DeviceMount = typeof DeviceMount
-
-            export const Volume = Pod.subkind("Volume")
-            export type Volume = typeof Volume
-
-            export const Device = Volume.subkind("Device")
-            export type Device = typeof Device
-        }
-
-        export const Node = v1.kind("Node")
-        export type Node = typeof Node
-
-        export const Namespace = v1.kind("Namespace")
-        export type Namespace = typeof Namespace
-
-        export const ServiceAccount = v1.kind("ServiceAccount")
-        export type ServiceAccount = typeof ServiceAccount
-
-        export const PersistentVolume = v1.kind("PersistentVolume")
-        export type PersistentVolume = typeof PersistentVolume
-
-        export const PersistentVolumeClaim = v1.kind("PersistentVolumeClaim")
-        export type PersistentVolumeClaim = typeof PersistentVolumeClaim
-
-        export const PodTemplate = v1.kind("PodTemplate")
-        export type PodTemplate = typeof PodTemplate
-    }
-
-    export const apps = Kind.group("apps")
-    export type apps = typeof apps
-
-    export namespace apps_ {
-        export const v1 = apps.version("v1")
-        export type v1 = typeof v1
-
-        export namespace v1_ {
-            export const Deployment = v1.kind("Deployment")
-            export type Deployment = typeof Deployment
-
-            export const StatefulSet = v1.kind("StatefulSet")
-            export type StatefulSet = typeof StatefulSet
-
-            export const DaemonSet = v1.kind("DaemonSet")
-            export type DaemonSet = typeof DaemonSet
-
-            export const ReplicaSet = v1.kind("ReplicaSet")
-            export type ReplicaSet = typeof ReplicaSet
-
-            export const ControllerRevision = v1.kind("ControllerRevision")
-            export type ControllerRevision = typeof ControllerRevision
-        }
-    }
-
-    export const networking = Kind.group("networking.k8s.io")
-    export type networking = typeof networking
-
-    export namespace networking_ {
-        export const v1 = networking.version("v1")
-        export type v1 = typeof v1
-
-        export namespace v1_ {
-            export const NetworkPolicy = v1.kind("NetworkPolicy")
-            export type NetworkPolicy = typeof NetworkPolicy
-        }
-    }
-
-    export const gateway = Kind.group("gateway.networking.k8s.io")
-    export type gateway = typeof gateway
-
-    export namespace gateway_ {
-        export const v1 = gateway.version("v1")
-        export type v1 = typeof v1
-
-        export namespace v1_ {
-            export const Gateway = v1.kind("Gateway")
-            export type Gateway = typeof Gateway
-
-            export const GatewayClass = v1.kind("GatewayClass")
-            export type GatewayClass = typeof GatewayClass
-
-            export const HttpRoute = v1.kind("HTTPRoute")
-            export type HttpRoute = typeof HttpRoute
-
-            export const TcpRoute = v1.kind("TCPRoute")
-            export type TcpRoute = typeof TcpRoute
-
-            export const TlsRoute = v1.kind("TLSRoute")
-            export type TlsRoute = typeof TlsRoute
-        }
-    }
-
-    export const storage = Kind.group("storage.k8s.io")
-    export type storage = typeof storage
-    export namespace storage_ {
-        export const v1 = storage.version("v1")
-        export type v1 = typeof v1
-
-        export namespace v1_ {
-            export const StorageClass = v1.kind("StorageClass")
-            export type StorageClass = typeof StorageClass
-
-            export const VolumeAttachment = v1.kind("VolumeAttachment")
-            export type VolumeAttachment = typeof VolumeAttachment
-        }
-    }
-}

package/src/meta/k8ts-section.ts

@@ -1,6 +0,0 @@
-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

@@ -1,37 +0,0 @@
-import { displayers, Kind, Origin, RefKey, ResourceEntity, ResourceNode } from "@k8ts/instruments"
-import { Doddle, doddle } from "doddle"
-
-export interface ResourceIdentBlock {
-    kind: Kind.IdentParent
-    name: string
-}
-@displayers({
-    simple: s => s.node,
-    pretty: s => s.node
-})
-export abstract class AbsResource<Props extends object = object> implements ResourceEntity {
-    abstract readonly kind: Kind.Identifier<string, Kind.Identifier>
-
-    private _node: Doddle<ResourceNode>
-
-    with(callback: (self: this) => void) {
-        callback(this)
-        return this
-    }
-    get node() {
-        return this._node.pull()
-    }
-    protected constructor(
-        origin: Origin,
-        public 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/equiv-cdk8s.ts

@@ -1,19 +0,0 @@
-import { Embedder, Kinded, LiveRefable } from "@k8ts/instruments"
-import { Construct } from "constructs"
-
-export type Cdk8sCtor = {
-    new (parent: Construct, id: string, props: any): Construct
-}
-export type KindedCtor = new (...args: any[]) => Kinded
-export const EquivCdk8s = new Embedder<LiveRefable, Cdk8sCtor>("CDK8S_RESOURCE")
-
-export function equiv_cdk8s(ctor: Cdk8sCtor) {
-    return <F extends KindedCtor>(target: F) => {
-        const cdk8s = EquivCdk8s.tryGet(target.prototype)
-        if (cdk8s) {
-            throw new Error(`Target ${target} already has a cdk8s equivalent! ${cdk8s}`)
-        }
-        EquivCdk8s.set(target.prototype, ctor)
-        return target
-    }
-}

package/src/node/index.ts

@@ -1,4 +0,0 @@
-export { AbsResource } from "./abs-resource"
-export { ManifestResource } from "./manifest-resource"
-export { SubResource } from "./sub-resource"
-export { TopResource } from "./top-resource"

package/src/node/manifest-resource.ts

@@ -1,23 +0,0 @@
-import { Builder, Kind, type Origin } from "@k8ts/instruments"
-import type { Meta, MutableMeta } from "@k8ts/metadata"
-import { ResourceIdentBlock } from "./abs-resource"
-import { TopResource } from "./top-resource"
-
-export interface ManifestResourceIdent extends ResourceIdentBlock {
-    name: string
-}
-export abstract class ManifestResource<Props extends object = object> extends TopResource<Props> {
-    protected async 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")
-    }
-}