k8ts 0.13.2 → 0.14.0

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

@@ -1,17 +0,0 @@
-import { Service, type Service_Ref } from "./service"
-
-export interface Service_Port_Props<Port extends string> {
-    service: Service_Ref<Port>
-    name: Port
-}
-
-export class Port<Port extends string> {
-    constructor(readonly props: Service_Port_Props<Port>) {}
-    get service() {
-        return this.props.service
-    }
-
-    port() {
-        return this.props.service.assert(Service).ports.get(this.props.name).frontend
-    }
-}

package/src/resources/service/service.ts

@@ -1,101 +0,0 @@
-import { Rsc_Ref, Rsc_Top, type PortMapping_Input } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
-import { seq } from "doddle"
-import { MakeError } from "../../error"
-import { v1 } from "../../kinds/index"
-import { Deployment, type Deployment_Ref } from "../deployment"
-import { toServicePorts } from "../utils/adapters"
-import { Port } from "./service-port"
-export interface Service_Frontend_ClusterIp {
-    type: "ClusterIP"
-}
-
-export interface Service_Frontend_LoadBalancer {
-    type: "LoadBalancer"
-    loadBalancerIP?: string
-    loadBalancerSourceRanges?: string[]
-    loadBalancerClass?: string
-    allocateLoadBalancerNodePorts?: boolean
-}
-export type Service_Frontend = Service_Frontend_ClusterIp | Service_Frontend_LoadBalancer
-export interface Service_Props<DeployPorts extends string, ExposedPorts extends DeployPorts> {
-    $ports: PortMapping_Input<ExposedPorts>
-    $backend: Deployment_Ref<DeployPorts>
-    $frontend: Service_Frontend
-}
-export interface Service_Ref<ExposedPorts extends string> extends Rsc_Ref<v1.Service._> {
-    __PORTS__: ExposedPorts
-}
-
-export class Service<
-    Name extends string = string,
-    Ports_Exposed extends string = string
-> extends Rsc_Top<Name, Service_Props<string, Ports_Exposed>> {
-    __PORTS__!: Ports_Exposed
-    get kind() {
-        return v1.Service._
-    }
-
-    private get backend() {
-        return this.props.$backend.assert(Deployment<Ports_Exposed>)
-    }
-    get ports() {
-        const srcPorts = this.backend.ports
-        const knownPorts = seq(Object.entries(this.props.$ports))
-            .filter(([, v]) => v !== undefined)
-            .map(([k]) => k)
-            .toArray()
-            .pull() as Ports_Exposed[]
-        const svcPorts = srcPorts.pick(...knownPorts).map(this.props.$ports as any)
-        return svcPorts
-    }
-
-    protected override __needs__() {
-        return {
-            backend: this.backend
-        }
-    }
-
-    portRef(name: Ports_Exposed) {
-        return new Port({
-            service: this,
-            name: name
-        })
-    }
-
-    get hostname() {
-        return `${this.name}.${this.namespace}.svc.cluster.local`
-    }
-
-    private _getPortoPart(port: Ports_Exposed, protocol: "http" | "https") {
-        const portNumber = this.props.$ports[port]
-        if (portNumber === 80 && protocol === "http") {
-            return ""
-        }
-        if (portNumber === 443 && protocol === "https") {
-            return ""
-        }
-        if (portNumber === undefined) {
-            throw new MakeError(`Port ${port} is not defined in service ${this.name}`)
-        }
-        return `:${portNumber}`
-    }
-
-    protected body(): CDK.KubeServiceProps {
-        const self = this
-        const svcPorts = self.ports
-        return {
-            spec: {
-                ...self.props.$frontend,
-                ports: toServicePorts(svcPorts),
-                selector: {
-                    app: self.props.$backend.name
-                }
-            }
-        }
-    }
-
-    address(protocol: "http" | "https", port: Ports_Exposed) {
-        return `${protocol}://${this.hostname}${this._getPortoPart(port, protocol)}`
-    }
-}

package/src/resources/utils/adapters.ts

@@ -1,29 +0,0 @@
-import type { Port_Exports, Port_Full, Port_Map, Port_Mapping_Entry } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
-import { seq } from "doddle"
-export function toContainerPort(entry: Port_Full): CDK.ContainerPort {
-    return {
-        containerPort: entry.port,
-        name: entry.name,
-        protocol: entry.protocol,
-        hostPort: entry.hostPort,
-        hostIp: entry.hostIp?.text
-    }
-}
-
-export function toContainerPorts(ports: Port_Exports<any>) {
-    return seq(ports.values.values()).map(toContainerPort).toArray().pull()
-}
-
-export function toServicePort(entry: Port_Mapping_Entry): CDK.ServicePort {
-    return {
-        port: entry.frontend,
-        targetPort: CDK.IntOrString.fromString(entry.name),
-        protocol: entry.protocol,
-        name: entry.name
-    }
-}
-
-export function toServicePorts(ports: Port_Map<any>) {
-    return seq(ports.values.values()).map(toServicePort).toArray().pull()
-}

package/src/runner/exporter/index.ts

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

package/src/runner/exporter/validator.ts

@@ -1,13 +0,0 @@
-import { Rsc_Node } from "@k8ts/instruments"
-import { FileNodes } from "./assembler"
-export interface ValidatingEvent {
-    node: Rsc_Node
-}
-export interface ValidatorEventsTable {
-    validating: ValidatingEvent
-}
-export interface ValidatorOptions {}
-export class NodeGraphValidator {
-    constructor(readonly options: ValidatorOptions) {}
-    validate(collection: FileNodes[]) {}
-}

package/src/runner/paths.ts

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

package/src/runner/silly/proverbs.ts

@@ -1,14 +0,0 @@
-import { readFile } from "fs/promises"
-export class Proverbs {
-    constructor(private _proverbs: string[]) {}
-    static async make(file: string) {
-        const loaded = await readFile(file, "utf-8")
-        const lines = loaded.split("\n")
-        return new Proverbs(lines)
-    }
-
-    get random() {
-        const idx = Math.floor(Math.random() * this._proverbs.length)
-        return this._proverbs[idx]
-    }
-}