k8ts 0.7.3 → 0.9.1

package/src/node/sub-resource.ts

@@ -1,20 +0,0 @@
-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: SubResource | ManifestResource,
-        name: string,
-        props: Props
-    ) {
-        super(parent.node.origin, name, props)
-    }
-
-    get namespace(): string | undefined {
-        return this.parent.namespace
-    }
-}

package/src/node/top-resource.ts

@@ -1,7 +0,0 @@
-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/resources/persistent/volume/backend.ts

@@ -1,20 +0,0 @@
-export namespace Backend {
-    export interface HostPath {
-        type: "HostPath"
-        hostpathType: string
-        path: string
-    }
-    export interface Local {
-        type: "Local"
-        path: string
-    }
-    export interface NFS {
-        type: "NFS"
-        server: string
-        path: string
-    }
-
-    export type Backend = HostPath | Local | NFS
-}
-
-export type Backend = Backend.Backend

package/src/resources/service/frontend.ts

@@ -1,11 +0,0 @@
-export namespace Frontend {
-    export interface ClusterIp {
-        type: "ClusterIP"
-    }
-
-    export interface LoadBalancer {
-        type: "LoadBalancer"
-        loadBalancerIP?: string
-    }
-}
-export type Frontend = Frontend.ClusterIp | Frontend.LoadBalancer

package/src/world/index.ts

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

package/src/world/world.ts

@@ -1,90 +0,0 @@
-import { BaseOriginEntity, KindMap, LiveRefable, Origin, type Kind } from "@k8ts/instruments"
-import { Meta } from "@k8ts/metadata"
-import { assign } from "lodash"
-import { External } from "../external"
-import { File } from "../file"
-import { FileExports } from "../file/exports"
-import { FileOrigin } from "../file/origin"
-import { k8tsBuildKind } from "../k8ts-sys-kind"
-import { K8tsRootOrigin } from "../kind-map"
-export type ManifestFileName = `${string}.yaml`
-export namespace World {
-    export interface Props {
-        name: string
-        meta?: Meta.Input
-        kinds?: KindMap
-    }
-
-    const ident = k8tsBuildKind.kind("World")
-    export type DefineScopedFile<Scope extends FileOrigin.Scope> = {
-        metadata(input: Meta.Input): DefineScopedFile<Scope>
-        Resources<const Produced extends LiveRefable>(
-            producer: FileExports.Producer<Scope, Produced>
-        ): File<Produced>
-    }
-    export class Builder extends BaseOriginEntity<Props> {
-        readonly kind = ident
-        private readonly _ExternalOrigin: ExternalOriginEntity
-        constructor(props: Props) {
-            super("World", props, K8tsRootOrigin.node)
-            this._ExternalOrigin = new ExternalOriginEntity(this.node)
-        }
-
-        External<K extends Kind>(kind: K, name: string, namespace?: string) {
-            return new External(this._ExternalOrigin.node, kind, name, namespace)
-        }
-
-        Scope<const Scope extends FileOrigin.Scope>(scope: Scope) {
-            const builder = this
-            let meta = Meta.make()
-            return {
-                File(name: ManifestFileName, props?: FileOrigin.SmallerProps) {
-                    props ??= {}
-
-                    const self: DefineScopedFile<Scope> = {
-                        metadata(input: Meta.Input) {
-                            props = assign({}, props!, {
-                                meta: Meta.splat(props?.meta, input)
-                            })
-                            return self
-                        },
-                        Resources<const Produced extends LiveRefable>(
-                            producer: FileExports.Producer<Scope, Produced>
-                        ): File<Produced> {
-                            return builder._File(name, {
-                                ...props,
-                                scope,
-                                FILE: producer
-                            } as any)
-                        }
-                    }
-                    return self
-                }
-            }
-        }
-
-        private _File<T extends LiveRefable>(
-            name: ManifestFileName,
-            props: File.Props<any, T>
-        ): File<T> {
-            return File.make(name, props, this.node)
-        }
-    }
-
-    export function make(props: Props) {
-        return new Builder(props)
-    }
-}
-const ident = k8tsBuildKind.kind("External")
-export class ExternalOriginEntity extends BaseOriginEntity {
-    kind = ident
-    constructor(parent: Origin) {
-        super(
-            "EXTERNAL",
-            {
-                meta: {}
-            },
-            parent
-        )
-    }
-}