k8ts 0.8.1 → 0.9.2

package/src/origins/file/file.ts

@@ -0,0 +1,72 @@
+import {
+    FwRef_Exports,
+    Origin_Exporter,
+    type Origin_Entity,
+    type Origin_Props,
+    type Resource_Core_Ref,
+    type Resource_Ctor_Of
+} from "@k8ts/instruments"
+import { doddlify, seq } from "doddle"
+import type { v1 } from "../../kinds"
+import { Origin_Section, type File_Section_Props } from "./section"
+export type File_sName = `${string}.yaml`
+export interface File_Props<
+    Kinds extends Resource_Ctor_Of[] = Resource_Ctor_Of[],
+    Exports extends Kinds[number]["prototype"] = Kinds[number]["prototype"]
+> extends Origin_Props<Kinds[number]> {
+    kinds?: Kinds
+    namespace?: Resource_Core_Ref<v1.Namespace._>
+    FILE(FILE: Origin_File_Scope<Kinds>): Iterable<Exports | FwRef_Exports<Exports>>
+}
+export class Origin_File extends Origin_Exporter<File_Props> {
+    #_ = (() => {
+        this.meta.add("source.k8ts.org/", {
+            "^file": this.name
+        })
+        this.meta.overwrite("namespace", this._props.namespace?.name)
+    })()
+    get kind() {
+        return "k8ts:File"
+    }
+
+    @doddlify
+    protected __exports__() {
+        return seq(
+            this._props.FILE.call(
+                this,
+                new Origin_File_Scope(this) as any
+            ) as Iterable<Resource_Core_Ref>
+        ).cache()
+    }
+}
+export function File<
+    Kinds extends Resource_Ctor_Of[] = Resource_Ctor_Of[],
+    Exports extends Kinds[number]["prototype"] = Kinds[number]["prototype"]
+>(parent: Origin_Entity, name: File_sName, props: File_Props<Kinds, Exports>) {
+    const file = new Origin_File(parent, name, props as any)
+
+    return FwRef_Exports<Exports>(file)
+}
+
+export class Origin_File_Scope<Kinds extends Resource_Ctor_Of[]> {
+    constructor(private readonly _file: Origin_File) {
+        this.on = this._file.on
+    }
+    get __entity__() {
+        return this._file
+    }
+    on: Origin_File["on"]
+
+    Section<Exported extends Kinds[number]["prototype"] = Kinds[number]["prototype"]>(
+        name: string,
+        props: File_Section_Props<Exported>
+    ) {
+        const section: Origin_Section = new Origin_Section(this._file, name, props)
+        return FwRef_Exports<Exported>(section)
+    }
+}
+
+export type File<
+    Kinds extends Resource_Ctor_Of[] = Resource_Ctor_Of[],
+    T extends Kinds[number]["prototype"] = Kinds[number]["prototype"]
+> = FwRef_Exports<T>

package/src/origins/file/index.ts

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

package/src/origins/file/modifier.ts

@@ -0,0 +1,21 @@
+import { Origin_Entity, OriginContextTracker } from "@k8ts/instruments"
+
+export interface ModifierOrigin_Props {}
+
+export class Origin_Modifier extends Origin_Entity<ModifierOrigin_Props> {
+    get kind() {
+        return "Modifier"
+    }
+
+    #currentRunnerState = (() => {
+        return OriginContextTracker.disposableOriginModifier(this)
+    })();
+
+    [Symbol.dispose]() {
+        this.#currentRunnerState[Symbol.dispose]()
+    }
+}
+
+export function Modifier(name: string, props: ModifierOrigin_Props = {}) {
+    return new Origin_Modifier(name, props)
+}

package/src/origins/file/section.ts

@@ -0,0 +1,43 @@
+import {
+    type Origin_Exporter_Props,
+    type Resource_Core_Ref,
+    Origin_Exporter
+} from "@k8ts/instruments"
+import { doddle, doddlify, seq } from "doddle"
+import type { v1 } from "../../kinds"
+
+export class File_Section_Scope {
+    on: Origin_Section["on"]
+    get __entity__() {
+        return this._section
+    }
+    constructor(private readonly _section: Origin_Section) {
+        this.on = this._section.on
+    }
+}
+export interface File_Section_Props<Exported extends Resource_Core_Ref = Resource_Core_Ref>
+    extends Origin_Exporter_Props {
+    namespace?: Resource_Core_Ref<v1.Namespace._>
+    SECTION(SCOPE: File_Section_Scope): Iterable<Exported>
+}
+
+export class Origin_Section extends Origin_Exporter<File_Section_Props> {
+    get kind() {
+        return "k8ts:File/Section"
+    }
+    #_ = doddle(() => {
+        this.meta.overwrite({
+            namespace: this._props.namespace?.name
+        })
+    }).pull()
+
+    @doddlify
+    protected __exports__() {
+        return seq(
+            this._props.SECTION.call(
+                this,
+                new File_Section_Scope(this)
+            ) as Iterable<Resource_Core_Ref>
+        ).cache()
+    }
+}

package/src/origins/index.ts

@@ -0,0 +1,3 @@
+export * from "../resources/external"
+export * from "./file"
+export * from "./world"

package/src/origins/world.ts

@@ -0,0 +1,40 @@
+import {
+    Origin_Entity,
+    type FwRef_Exports,
+    type Kind,
+    type Origin_Props,
+    type Resource_Ctor_Of
+} from "@k8ts/instruments"
+
+import { External } from "../resources/external"
+import { Origin_External } from "./external"
+import { File, type File_Props, type File_sName } from "./file"
+
+export type World_Props<Kinds extends Resource_Ctor_Of[]> = Origin_Props<Kinds[number]>
+
+export class World<Kinds extends Resource_Ctor_Of[] = Resource_Ctor_Of[]> extends Origin_Entity<
+    World_Props<Kinds>
+> {
+    get kind() {
+        return "k8ts:World"
+    }
+    private readonly _ExternalOrigin = new Origin_External(this)
+    #_ = (() => {
+        this.meta.add("source.k8ts.org/", {
+            "^world": this.name
+        })
+    })()
+
+    External<K extends Kind, Name extends string>(kind: K, name: Name, namespace?: string) {
+        return new External(this._ExternalOrigin, kind.refKey(name), namespace)
+    }
+
+    File<Exports extends Resource_Ctor_Of["prototype"]>(
+        name: File_sName,
+        props: File_Props<Kinds, Exports>
+    ) {
+        return File(this, name, props) as FwRef_Exports<Exports>
+    }
+}
+
+export const k8ts_namespace = "k8ts.org/" as const

package/src/resources/configmap/configmap.ts

@@ -1,41 +1,36 @@
 import {
     DataSourceRecord_Binary,
     DataSourceRecord_Text,
-    LocalFileSource,
-    manifest,
-    relations,
+    DataSource_LocalFile,
+    Resource_Top,
     resolveBinary,
     resolveText
 } from "@k8ts/instruments"
-import { CDK } from "../../_imports"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import { ManifestResource } from "../../node/manifest-resource"
-export type ConfigMap = ConfigMap.ConfigMap
-export namespace ConfigMap {
-    export type ConfigMapEntrySource = LocalFileSource | string
-    export interface Props {
-        data: DataSourceRecord_Text
-        binaryData?: DataSourceRecord_Binary
-    }
+import { toObject } from "@k8ts/metadata/util"
+import { CDK } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
+import { v1 } from "../../kinds/default"
+export type ConfigMap_Entry_Source = DataSource_LocalFile | string
+export interface ConfigMap_Props {
+    data: DataSourceRecord_Text
+    binaryData?: DataSourceRecord_Binary
+}
 
-    @k8ts(api.v1_.ConfigMap)
-    @relations("none")
-    @equiv_cdk8s(CDK.KubeConfigMap)
-    @manifest({
-        async body(self): Promise<CDK.KubeConfigMapProps> {
-            const binaryData = await resolveBinary(self.props.binaryData ?? {})
-            const data = await resolveText(self.props.data)
-            return {
-                data: data.isEmpty() ? undefined : data.toObject(),
-                binaryData: binaryData.isEmpty()
-                    ? undefined
-                    : binaryData.map(x => Buffer.from(x).toString("base64")).toObject()
-            }
+export class ConfigMap<Name extends string = string> extends Resource_Top<Name, ConfigMap_Props> {
+    get kind() {
+        return v1.ConfigMap._
+    }
+    protected async body(): Promise<CDK.KubeConfigMapProps> {
+        const self = this
+        const binaryData = await resolveBinary(self.props.binaryData ?? {})
+        const data = await resolveText(self.props.data)
+        const encodedBinaryData = seq(binaryData)
+            .map(([k, x]) => [k, Buffer.from(x).toString("base64")] as const)
+            .toRecord(x => x)
+            .pull()
+        return {
+            data: data.size === 0 ? undefined : toObject(data),
+            binaryData: binaryData.size === 0 ? undefined : encodedBinaryData
         }
-    })
-    export class ConfigMap extends ManifestResource<Props> {
-        override kind = api.v1_.ConfigMap
     }
 }

package/src/resources/cronjob/index.ts

@@ -1,60 +1,50 @@
-import { Cron, CronStanza, manifest, Origin, relations } from "@k8ts/instruments"
-import { Timezone } from "@k8ts/instruments/src/timezone"
-import { Meta, MutableMeta } from "@k8ts/metadata"
-import { omit, omitBy } from "lodash"
-import { CDK } from "../../_imports"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import { ManifestResource } from "../../node/manifest-resource"
-import { PodTemplate } from "../pod/pod-template"
-export interface K8tsCronJobProps<CronSpec extends Cron.Record>
+import { Cron, CronStanza, Resource_Top, type Resource_Entity } from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import { CDK } from "@k8ts/sample-interfaces"
+import { doddle } from "doddle"
+import { omitBy } from "lodash"
+import { Timezone } from "../../../../instruments/dist/expressions/timezone"
+import { batch } from "../../kinds/batch"
+import { Pod_Template, type Pod_Props } from "../pod"
+export interface CronJob_Props<CronSpec extends Cron.Record>
     extends Omit<CDK.CronJobSpec, "jobTemplate" | "schedule" | "timeZone"> {
     $schedule: CronStanza<CronSpec>
-    $template: PodTemplate.Props<never> & {
+    $template: Pod_Props<never> & {
         restartPolicy: "Always" | "OnFailure" | "Never"
     }
     $meta?: Meta.Input
     timeZone: Timezone
 }
 
-@k8ts(api.batch_.v1_.CronJob)
-@equiv_cdk8s(CDK.KubeCronJob)
-@relations({
-    kids: s => [s.template]
-})
-@manifest({
-    async body(self): Promise<CDK.KubeCronJobProps> {
-        const template = await self.template["manifest"]()
-        const noKindFields = omit(template, ["kind", "apiVersion"])
+export class CronJob<
+    Name extends string = string,
+    Cron extends Cron.Record = Cron.Record
+> extends Resource_Top<Name, CronJob_Props<Cron>> {
+    get kind() {
+        return batch.v1.CronJob._
+    }
+    private _template = doddle(() => {
+        return new Pod_Template<never>(this, this.name, this.props.$template)
+    })
+
+    protected __kids__(): Resource_Entity[] {
+        return [this._template.pull()]
+    }
+
+    protected body(): CDK.KubeCronJobProps {
+        const self = this
+        const template = self._template.pull()["__submanifest__"]()
         return {
             spec: {
-                ...omitBy(self.props, (x, k) => k.startsWith("$")),
-                schedule: self.props.$schedule.string,
+                ...omitBy(self.props, (x, k) => k.startsWith("$") || k === "timeZone"),
+                schedule: self.props.$schedule.toString(),
+                timeZone: self.props.timeZone,
                 jobTemplate: {
                     spec: {
-                        template: noKindFields
+                        template: template
                     }
-                },
-                timeZone: self.props.timeZone
+                }
             }
         }
     }
-})
-export class K8tsCronJob<Cron extends Cron.Record> extends ManifestResource<
-    K8tsCronJobProps<Cron>
-> {
-    kind = api.batch_.v1_.CronJob
-    template: PodTemplate.PodTemplate<never>
-    constructor(origin: Origin, meta: Meta | MutableMeta, props: K8tsCronJobProps<Cron>) {
-        super(origin, meta, props)
-        this.template = new PodTemplate.PodTemplate(
-            origin,
-            Meta.make({
-                name: this.name
-            }),
-            props.$template
-        )
-        this.template.meta.add(props.$meta)
-    }
 }

package/src/resources/deployment/deployment.ts

@@ -1,89 +1,98 @@
-import { manifest, Origin, Refable, relations, WritableDeep } from "@k8ts/instruments"
-import { Meta, MutableMeta } from "@k8ts/metadata"
+import {
+    OriginContextTracker,
+    Resource_Core_Ref,
+    Resource_Top,
+    type Resource_Entity
+} from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
+import { doddle } from "doddle"
 import { omit, omitBy } from "lodash"
-import { CDK } from "../../_imports"
 import { MakeError } from "../../error"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import { ManifestResource } from "../../node/manifest-resource"
-import { PodTemplate } from "../pod/pod-template"
+import { apps } from "../../kinds/apps"
+import { Pod_Template, type Pod_Props } from "../pod"
 
-export type Deployment<Ports extends string> = Deployment.Deployment<Ports>
-export namespace Deployment {
-    export type DeploymentStrategy =
-        | { type: "Recreate" }
-        | ({
-              type: "RollingUpdate"
-          } & CDK.RollingUpdateDeployment)
-    export type NormalProps = WritableDeep<
-        Omit<CDK.DeploymentSpec, "selector" | "template" | "strategy">
-    >
-    export type Props<Ports extends string> = NormalProps & {
-        $template: PodTemplate.Props<Ports>
-        $strategy?: DeploymentStrategy
-    }
-    export type AbsDeployment<Ports extends string> = Refable<api.apps_.v1_.Deployment> & {
-        __PORTS__: Ports
+export interface Deployment_Strategy_RollingUpdate extends CDK.RollingUpdateDeployment {
+    type: "RollingUpdate"
+}
+export interface Deployment_Strategy_Recreate {
+    type: "Recreate"
+}
+export type Deployment_Strategy = Deployment_Strategy_RollingUpdate | Deployment_Strategy_Recreate
+export type Deployment_Props_Original = Omit<
+    CDK.DeploymentSpec,
+    "selector" | "template" | "strategy"
+>
+
+export type Deployment_Props<Ports extends string> = Deployment_Props_Original & {
+    $template: Pod_Props<Ports>
+    $strategy?: Deployment_Strategy
+}
+export type Deployment_Ref<Ports extends string> = Resource_Core_Ref<apps.v1.Deployment._> & {
+    __PORTS__: Ports
+}
+
+export class Deployment<Name extends string, Ports extends string = string> extends Resource_Top<
+    Name,
+    Deployment_Props<Ports>
+> {
+    __PORTS__!: Ports
+    get kind() {
+        return apps.v1.Deployment._
     }
 
-    @k8ts(api.apps_.v1_.Deployment)
-    @equiv_cdk8s(CDK.KubeDeployment)
-    @relations({
-        kids: s => [s.template]
-    })
-    @manifest({
-        async body(self): Promise<CDK.KubeDeploymentProps> {
-            const template = await self.template["manifest"]()
-            const noKindFields = omit(template, ["kind", "apiVersion"])
-            return {
-                spec: {
-                    ...omitBy(self.props, (x, k) => k.startsWith("$")),
-                    selector: {
-                        matchLabels: {
-                            app: self.name
-                        }
-                    },
-                    template: noKindFields,
-                    strategy: self._strategy
-                }
-            }
+    #_ = (() => {
+        const origin = OriginContextTracker.current
+        if (!origin) {
+            throw new MakeError(
+                `Deployment ${this.name} must be created within an OriginEntity context`
+            )
         }
-    })
-    export class Deployment<Ports extends string = string> extends ManifestResource<Props<Ports>> {
-        __PORTS__!: Ports
-        kind = api.apps_.v1_.Deployment
-        template: PodTemplate<Ports>
+        this.props.$template.$POD = origin["__binder__"]().bind(this.props.$template.$POD)
+    })()
 
-        private get _strategy() {
-            const strat = this.props.$strategy
-            if (!strat) {
-                return undefined
-            }
-            if (strat.type === "Recreate") {
-                return strat
-            }
-            if (strat.type === "RollingUpdate") {
-                return {
-                    type: "RollingUpdate",
-                    rollingUpdate: omit(strat, "type")
-                }
+    protected __kids__(): Resource_Entity[] {
+        return [this._template.pull()]
+    }
+    protected body(): CDK.KubeDeploymentProps {
+        const self = this
+        const template = self._template.pull()["__submanifest__"]()
+        const noKindFields = omit(template, ["kind", "apiVersion"])
+        return {
+            spec: {
+                ...omitBy(self.props, (x, k) => k.startsWith("$")),
+                selector: {
+                    matchLabels: {
+                        app: self.name
+                    }
+                },
+                template: noKindFields,
+                strategy: self._strategy
             }
-            throw new MakeError(`Invalid strategy type: ${strat}`)
         }
-        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
-            )
+    }
+    private get _strategy() {
+        const strat = this.props.$strategy
+        if (!strat) {
+            return undefined
         }
-        get ports() {
-            return this.template.ports
+        if (strat.type === "Recreate") {
+            return strat
         }
+        if (strat.type === "RollingUpdate") {
+            return {
+                type: "RollingUpdate",
+                rollingUpdate: omit(strat, "type")
+            }
+        }
+        throw new MakeError(`Invalid strategy type: ${strat}`)
+    }
+    private readonly _template = doddle(() => {
+        const podTemplate = new Pod_Template(this, this.name, this.props.$template)
+        podTemplate.meta.add("%app", this.name)
+        return podTemplate
+    })
+
+    get ports() {
+        return this._template.pull().ports
     }
 }

package/src/resources/external/index.ts

@@ -0,0 +1,49 @@
+import { Kind, Resource_Entity, type Origin_Entity, type RefKey } from "@k8ts/instruments"
+import { Meta } from "@k8ts/metadata"
+import { MakeError } from "../../error"
+
+export class External<
+    K extends Kind.IdentParent = Kind.IdentParent,
+    Name extends string = string
+> extends Resource_Entity<Name> {
+    meta = Meta.make()
+    constructor(
+        private readonly _origin: Origin_Entity,
+        readonly key: RefKey<K, Name>,
+        namespace: string | undefined = undefined
+    ) {
+        super(key.name, {})
+        this.meta.overwrite("name", key.name)
+        if (namespace) {
+            this.meta.overwrite("namespace", namespace)
+        }
+    }
+
+    get namespace() {
+        return this.meta.tryGet("namespace")
+    }
+
+    get kind() {
+        return this.key.kind
+    }
+
+    protected __origin__(): Origin_Entity {
+        return this._origin
+    }
+
+    protected __parent__() {
+        return undefined
+    }
+
+    protected body(): never {
+        throw new MakeError("Cannot get body of External resource")
+    }
+
+    ref() {
+        return {
+            kind: this.kind.name,
+            name: this.name,
+            namespace: this.namespace
+        }
+    }
+}

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

@@ -1,47 +1,48 @@
-import { manifest, relations } from "@k8ts/instruments"
-import { CDK } from "../../_imports"
-import type { External } from "../../external"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { ManifestResource } from "../../node"
-import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import type { Service } from "../service"
+import { Resource_Top, type Resource_Full_Ref } from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
+import { gateway } from "../../kinds/gateway"
+import type { Port } from "../service/service-port"
 
-export type HttpRoute<Ports extends string> = HttpRoute.HttpRoute<Ports>
+const GatewayKind = gateway.v1.Gateway._
+const HttpRouteKind = gateway.v1.HttpRoute._
 
-export namespace HttpRoute {
-    export interface Props<Ports extends string> {
-        $gateway: External<api.gateway_.v1_.Gateway>
-        $hostname: string
-        $backend: Service.Port<Ports>
-        _filters?: CDK.HttpRouteSpecRulesFilters[]
+export interface HttpRoute_Props<Ports extends string> {
+    $gateway: Resource_Full_Ref<gateway.v1.Gateway._>
+    $hostname: string
+    $backend: Port<Ports>
+    _filters?: CDK.HttpRouteSpecRulesFilters[]
+}
+
+export class HttpRoute<Name extends string, Ports extends string> extends Resource_Top<
+    Name,
+    HttpRoute_Props<Ports>
+> {
+    declare name: Name
+
+    get kind() {
+        return HttpRouteKind
     }
 
-    @k8ts(api.gateway_.v1_.HttpRoute)
-    @relations({
-        needs: self => ({
-            gateway: self.props.$gateway,
-            service: self.props.$backend.service
-        })
-    })
-    @equiv_cdk8s(CDK.HttpRoute)
-    @manifest({
-        body(self): CDK.HttpRouteProps {
-            return {
-                spec: {
-                    parentRefs: [self.props.$gateway.ref()],
-                    hostnames: [self.props.$hostname],
-                    rules: [
-                        {
-                            backendRefs: [self.props.$backend.ref()],
-                            filters: self.props._filters
-                        }
-                    ]
-                }
+    protected body() {
+        const self = this
+        return {
+            spec: {
+                parentRefs: [self.props.$gateway.ref()],
+                hostnames: [self.props.$hostname],
+                rules: [
+                    {
+                        backendRefs: [self.props.$backend.ref()],
+                        filters: self.props._filters
+                    }
+                ]
             }
         }
-    })
-    export class HttpRoute<Ports extends string> extends ManifestResource<Props<Ports>> {
-        kind = api.gateway_.v1_.HttpRoute
+    }
+
+    protected __needs__() {
+        return {
+            gateway: this.props.$gateway,
+            service: this.props.$backend.service
+        }
     }
 }