@k8ts/instruments 0.11.4 → 0.12.0

package/src/core/graph/resource/reference/refable.ts

@@ -1,26 +0,0 @@
-import type { AnyCtor } from "what-are-you"
-import type { RefLike } from "../../entity"
-import type { Ident_Like } from "../api-kind"
-import type { Rsc_Node } from "../node"
-export type Rsc_Ctor_Of<K extends Ident_Like = Ident_Like> = AnyCtor<Rsc_Ref<K>> & {
-    prototype: Rsc_Ref<K>
-}
-export type Rsc_Ref<
-    _Kind extends Ident_Like = Ident_Like,
-    Name extends string = string
-> = RefLike & {
-    kind: _Kind
-    name: Name
-    namespace?: string
-    is<_Kind2 extends Ident_Like>(kind: _Kind2): this is Rsc_Ref<_Kind2>
-    equals(other: any): boolean
-    node: Rsc_Node
-}
-
-export type Rsc_Ref_Keys_Of<X extends Rsc_Ref, Else = never> = [X] extends [
-    {
-        keys: (infer K extends string)[]
-    }
-]
-    ? K
-    : Else

package/src/core/graph/resource/top.ts

@@ -1,82 +0,0 @@
-import { Meta } from "@k8ts/metadata"
-import StackTracey from "stacktracey"
-import { type Manifest, type Manifest_Ident, type Manifest_Metadata } from "../../manifest"
-import { Trace, TraceEmbedder } from "../../tracing"
-import type { Origin_Entity } from "../origin/entity"
-import { OriginContextTracker } from "../origin/tracker"
-import type { Ident_Kind } from "./api-kind"
-import { Rsc_Entity } from "./entity"
-export abstract class Rsc_Top<
-    Name extends string = string,
-    Props extends object = object
-> extends Rsc_Entity<Name, Props> {
-    private readonly _origin: Origin_Entity
-    readonly meta: Meta
-    abstract readonly kind: Ident_Kind
-
-    get key() {
-        return this.kind.refKey({ name: this.name, namespace: this.namespace })
-    }
-    get disabled() {
-        return this.meta.tryGet("#k8ts.org/disabled", "") !== ""
-    }
-    set disabled(v: boolean) {
-        if (!v) {
-            this.meta.delete("#k8ts.org/disabled")
-        } else {
-            this.meta.add("#k8ts.org/disabled", "true")
-        }
-    }
-    constructor(name: Name, props: Props) {
-        super(name, props)
-        this.meta = Meta.make({
-            name
-        })
-        const lastOrigin = OriginContextTracker.current
-        if (!lastOrigin) {
-            throw new Error(
-                `ManifestResource ${this.name} must be created within an OriginEntity context`
-            )
-        }
-        this._origin = lastOrigin
-        this._origin["__attach_resource__"](this)
-        TraceEmbedder.add(this, new Trace(new StackTracey().slice(2)))
-    }
-
-    protected __origin__() {
-        return this._origin
-    }
-
-    protected __metadata__(): Manifest_Metadata {
-        const self = this
-        return {
-            name: self.meta.get("name"),
-            namespace: self.meta.tryGet("namespace"),
-            labels: self.meta.labels,
-            annotations: self.meta.annotations
-        }
-    }
-
-    protected __idents__(): Manifest_Ident {
-        return {
-            apiVersion: this.kind.parent!.text,
-            kind: this.kind.name
-        }
-    }
-
-    protected abstract body(): Promise<object> | object
-
-    protected async __manifest__(): Promise<Manifest> {
-        const a = {
-            ...this.__idents__(),
-            metadata: this.__metadata__(),
-            ...(await this.body())
-        }
-
-        return a
-    }
-
-    get namespace() {
-        return this.meta.tryGet("namespace")
-    }
-}

package/src/core/tracing/traced.ts

@@ -1,4 +0,0 @@
-import { Embedder } from "../../utils/embedder"
-import { Trace } from "./trace"
-
-export const TraceEmbedder = new Embedder<object, Trace>("TRACED")

package/src/expressions/data-sources/base.ts

@@ -1,38 +0,0 @@
-import { doddle, type DoddleAsync } from "doddle"
-
-/** Unique symbol used to identify data source objects. */
-export declare const DATA_SOURCE: unique symbol
-
-/**
- * Lazy-loading data source that caches the result of a getter function. The getter is executed only
- * once, and the result is memoized for subsequent calls.
- *
- * @example
- *     const lazy = new DataSource_Lazy(() => expensiveComputation())
- *     const value1 = await lazy.get() // Computes value
- *     const value2 = await lazy.get() // Returns cached value
- *
- * @typeParam T - The type of data this source provides
- */
-export class DataSource_Lazy<T = any> {
-    private readonly _data: DoddleAsync<T>
-
-    /**
-     * Creates a new lazy data source.
-     *
-     * @param getter - Function that computes or retrieves the value (can be async)
-     */
-    constructor(getter: () => T | Promise<T>) {
-        this._data = doddle(async () => getter())
-    }
-
-    /**
-     * Retrieves the value, computing it on first call and returning cached value on subsequent
-     * calls.
-     *
-     * @returns Promise resolving to the data value
-     */
-    get() {
-        return this._data.pull()
-    }
-}

package/src/expressions/network/ip/index.ts

@@ -1,17 +0,0 @@
-import { Address4 } from "ip-address"
-
-export type Ip4_String = `${number}.${number}.${number}.${number}`
-
-export class Ip4<Text extends Ip4_String = Ip4_String> {
-    readonly _addr4: Address4 | undefined
-    constructor(readonly text: Text) {
-        this._addr4 = new Address4(text)
-    }
-}
-export type Subnet4_String = `${number}.${number}.${number}.${number}/${number}`
-export class Subnet4<Text extends Subnet4_String = Subnet4_String> {
-    readonly _addr4: Address4 | undefined
-    constructor(readonly text: Text) {
-        this._addr4 = new Address4(text)
-    }
-}

package/src/expressions/network/ports/index.ts

@@ -1,8 +0,0 @@
-import type { Port_Exports_Input } from "./set"
-import { Port_Exports } from "./set"
-export { Port_Map, type PortMapping_Input } from "./map"
-export { Port_Exports, type Port_Exports_Input } from "./set"
-export type { Port_Full, Port_Mapping_Entry } from "./types"
-export function ports<Names extends string>(input: Port_Exports_Input<Names>): Port_Exports<Names> {
-    return Port_Exports.make(input)
-}

package/src/expressions/network/ports/map.ts

@@ -1,88 +0,0 @@
-import { filterMap, mapValues } from "@k8ts/metadata/util"
-import { PortError } from "./error"
-import type { Port_Mapping_Entry } from "./types"
-
-/**
- * Represents an immutable mapping of named ports to their frontend/backend configuration.
- *
- * Used to define how container ports are exposed through services, mapping backend container ports
- * to frontend service ports.
- *
- * @template Names The union type of all port names in the map.
- */
-export class Port_Map<Names extends string> {
-    constructor(private readonly _map: Map<string, Port_Mapping_Entry>) {}
-
-    private _apply(
-        f: (map: Map<string, Port_Mapping_Entry>) => Map<string, Port_Mapping_Entry>
-    ): Port_Map<any> {
-        return new Port_Map(f(this._map))
-    }
-
-    /**
-     * Creates a new Port_Map containing only the specified port names.
-     *
-     * @param name The port names to include in the new map.
-     * @returns A new Port_Map with only the selected ports.
-     */
-    pick<InNames extends Names>(...name: InNames[]): Port_Map<InNames> {
-        return this._apply(map => filterMap(map, (_, key) => name.includes(key as InNames)))
-    }
-
-    /** The underlying map of port names to their mapping entries. */
-    get values() {
-        return this._map
-    }
-
-    /**
-     * Remaps the frontend ports to new values.
-     *
-     * @param mapping A record mapping port names to their new frontend port numbers.
-     * @returns A new Port_Map with updated frontend ports.
-     */
-    map(mapping: Record<Names, number>): Port_Map<Names> {
-        return new Port_Map(
-            mapValues(this._map, entry => {
-                return {
-                    ...entry,
-                    frontend: mapping[entry.name as keyof typeof mapping]
-                }
-            })
-        )
-    }
-
-    /**
-     * Retrieves a port mapping entry by name.
-     *
-     * @param name The name of the port to retrieve.
-     * @returns The port mapping entry.
-     * @throws {PortError} If the port name is not found in the map.
-     */
-    get(name: Names): Port_Mapping_Entry {
-        if (!this._map.has(name)) {
-            throw new PortError(`Port ${name} not found`)
-        }
-        return this._map.get(name) as Port_Mapping_Entry
-    }
-
-    /** Converts this Port_Map to a standard Map. */
-    toMap() {
-        return this._map
-    }
-}
-
-/**
- * Input type for creating port mappings.
- *
- * Each port name maps to either:
- *
- * - A number specifying the frontend port
- * - `true` to use the same port number as the backend
- *
- * @template Names The union type of port names.
- */
-export type PortMapping_Input<Names extends string = string> = [Names] extends [never]
-    ? never
-    : {
-          [K in Names]: number | true
-      }

package/src/expressions/network/ports/set.ts

@@ -1,178 +0,0 @@
-import { Meta } from "@k8ts/metadata"
-import { filterMap, mapValues, merge } from "@k8ts/metadata/util"
-import { seq } from "doddle"
-import { PortError } from "./error"
-import { Port_Map, PortMapping_Input } from "./map"
-import { parsePortInput, portRecordInput } from "./tools/entry"
-import type {
-    Port_Basic_Input,
-    Port_Full,
-    Port_Full_Input,
-    Port_Input,
-    Port_Protocol_Input
-} from "./types"
-
-/**
- * An immutable dictionary of named network ports exported by a container. Each port also has an
- * attached configuration.
- *
- * @template Names All exported port names.
- */
-export class Port_Exports<Names extends string = never> {
-    constructor(private readonly _map: Map<Names, Port_Full> = new Map()) {
-        for (const entry of _map.values()) {
-            Meta._checkNameValue(`container port '${entry.name}' (${entry.port})`, entry.name)
-        }
-    }
-
-    private _apply(f: (map: Map<string, Port_Full>) => Map<string, Port_Full>) {
-        return new Port_Exports(f(this._map))
-    }
-
-    /**
-     * Creates a new Port_Exports that is the union of this and another Port_Exports.
-     *
-     * @param other The other Port_Exports to merge with.
-     * @returns A new Port_Exports containing ports from both dictionaries. The 2nd dictionary's
-     *   ports will overwrite any with the same name from the first.
-     */
-    union<InNames extends string>(other: Port_Exports<InNames>): Port_Exports<Names | InNames> {
-        return new Port_Exports(merge(this._map, other._map))
-    }
-
-    /**
-     * Adds a port with explicit name, port number, and protocol.
-     *
-     * @param name The unique name for the port.
-     * @param port The port number.
-     * @param protocol The protocol (TCP or UDP).
-     */
-    add<Name extends string>(
-        name: Name,
-        port: Port_Basic_Input,
-        protocol: Port_Protocol_Input
-    ): Port_Exports<Names | Name>
-    /**
-     * Adds a port with a name and full port configuration.
-     *
-     * @param name The unique name for the port.
-     * @param entry The port configuration including number and protocol, and optional host
-     *   settings.
-     */
-    add<Name extends string>(name: Name, entry: Port_Full_Input): Port_Exports<Names | Name>
-    /**
-     * Adds multiple ports from a record of port configurations.
-     *
-     * @param input A record mapping port names to their configurations.
-     */
-    add<InNames extends string>(input?: Port_Exports_Input<InNames>): Port_Exports<Names | InNames>
-    add(a: any, b?: any, c?: any): any {
-        if (!a) {
-            return this
-        }
-        if (c) {
-            return this._apply(map => map.set(a, { name: a, port: +b, protocol: c.toUpperCase() }))
-        }
-        if (b) {
-            return this._apply(map => map.set(a, parsePortInput(a, b)))
-        }
-        return this._apply(map => {
-            const processed = portRecordInput(a)
-            return merge(map, processed)
-        })
-    }
-
-    /**
-     * Creates a new Port_Exports containing only the specified port names.
-     *
-     * @param name The port names to include.
-     * @returns A new Port_Exports with only the selected ports.
-     */
-    pick<InNames extends Names>(...name: InNames[]): Port_Exports<InNames> {
-        return this._apply(map => filterMap(map, (_, key) => name.includes(key as InNames))) as any
-    }
-
-    /** An array of all port names in this set. */
-    get names() {
-        return seq(this._map.keys()).toArray().pull() as Names[]
-    }
-
-    /**
-     * Retrieves a port by name.
-     *
-     * @param name The name of the port to retrieve.
-     * @returns The full port configuration.
-     * @throws {PortError} If the port name is not found.
-     */
-    get(name: Names): Port_Full {
-        if (!this._map.has(name)) {
-            throw new PortError(`Port ${name} not found`)
-        }
-        return this._map.get(name)!
-    }
-
-    /** The underlying map of port names to their full configurations. */
-    get values() {
-        return this._map
-    }
-
-    /**
-     * Creates a Port_Map by mapping each port to a frontend port number.
-     *
-     * @param mapping A record where each port name maps to either a frontend port number or `true`
-     *   to use the backend port.
-     * @returns A new Port_Map with the specified frontend mappings.
-     * @throws {PortError} If a port name is missing from the mapping or has an invalid value.
-     */
-    map(mapping: PortMapping_Input<Names>): Port_Map<Names> {
-        return new Port_Map(
-            mapValues(this._map, entry => {
-                if (!(entry.name in mapping)) {
-                    throw new PortError(`Port ${entry.name} not found in mapping`)
-                }
-                const portIn = mapping[entry.name as keyof typeof mapping]
-                let portVal: number
-                if (typeof portIn === "boolean") {
-                    portVal = entry.port
-                } else if (typeof portIn === "number") {
-                    portVal = portIn
-                } else {
-                    throw new PortError(
-                        `Port ${entry.name} mapping value must be a number or boolean`
-                    )
-                }
-                return {
-                    name: entry.name,
-                    protocol: entry.protocol,
-                    backend: entry.name,
-                    frontend: portVal as any
-                }
-            })
-        )
-    }
-
-    /**
-     * Creates a new Port_Exports from a record of port configurations.
-     *
-     * @param input A record mapping port names to their configurations.
-     * @returns A new Port_Exports containing the specified ports.
-     */
-    static make<Names extends string>(input?: Port_Exports_Input<Names>) {
-        return new Port_Exports().add(input)
-    }
-}
-
-/**
- * Input type for creating Port_Exports.
- *
- * A record mapping port names to their configurations, which can be:
- *
- * - A port number (uses TCP by default)
- * - A tuple of `[port, protocol]`
- * - A full port configuration object
- *
- * @template Names The union type of port names.
- */
-export type Port_Exports_Input<Names extends string = string> = {
-    [K in Names]: Port_Input
-}

package/src/expressions/quantities/reqlem/index.ts

@@ -1,2 +0,0 @@
-export * from "./objects"
-export * from "./types"

package/src/expressions/quantities/reqlem/objects.ts

@@ -1,107 +0,0 @@
-import { mapFromObject, mapValues } from "@k8ts/metadata/util"
-import { seq } from "doddle"
-import { isEmpty, merge } from "lodash"
-import { string, type Parjser } from "parjs"
-import { mapConst, or } from "parjs/combinators"
-import { InstrumentsError } from "../../../error"
-import type { UnitParser, UnitValue } from "../units"
-import { AnyUnitParser } from "../units/unit-parser"
-import { createResourceParser } from "./parser"
-import type { ReqLimit, Resources_ReqLimits_Trait, Resources_UnitMap_Trait } from "./types"
-
-export class Resources_UnitMap<const RM extends Resources_UnitMap_Trait<RM>> {
-    constructor(private _map: Map<string, ReqLimit>) {}
-
-    toObject() {
-        const kubernetesForm = mapValues(this._map, (value, key) => {
-            const result = {} as any
-            if (value.request) {
-                result.requests = {
-                    [key]: value.request.val
-                }
-            }
-            if (value.limit) {
-                result.limits = {
-                    [key]: value.limit.val
-                }
-            }
-            if (!isEmpty(result)) {
-                return result
-            }
-            return undefined
-        })
-
-        return merge({}, ...kubernetesForm.values())
-    }
-}
-
-export class ResourcesSpec<const RM extends Resources_UnitMap_Trait<RM>> {
-    readonly _unitParsers: Map<string, Parjser<UnitValue | undefined>>
-    readonly _reqLimitParsers: Map<string, Parjser<ReqLimit>>
-    readonly _anyUnitParser = AnyUnitParser.make()
-    readonly _anyReqLimitParser = createResourceParser(this._anyUnitParser)
-    constructor(_unitMap: Map<string, UnitParser>) {
-        const questionMarkParser = string("?").pipe(mapConst(undefined))
-        this._unitParsers = mapValues(_unitMap, parser =>
-            parser.parser.pipe(or(questionMarkParser))
-        )
-        this._reqLimitParsers = mapValues(_unitMap, parser => createResourceParser(parser))
-    }
-
-    private _parseUnitValue(resource: string, input: string): UnitValue | undefined {
-        const pUnitValue = this._unitParsers.get(input)
-        if (!pUnitValue) {
-            throw new InstrumentsError(`No parser found for ${input}`)
-        }
-        return pUnitValue.parse(input).value
-    }
-
-    private _parseReqLimit(resource: string, input: string): ReqLimit {
-        const pReqLimit = this._reqLimitParsers.get(resource)
-        if (!pReqLimit) {
-            return this._anyReqLimitParser.parse(input).value
-        }
-        return pReqLimit.parse(input).value
-    }
-    __INPUT__!: Resources_ReqLimits_Trait<RM>
-
-    parse<const R extends Resources_ReqLimits_Trait<RM>>(input: R): Resources_UnitMap<RM> {
-        const allKeys = new Set([...Object.keys(input), ...this._unitParsers.keys()])
-        const map = seq(allKeys)
-            .toMap(key => {
-                const getVal = () => {
-                    const value = input[key as keyof R]
-                    const pUnitValue = this._unitParsers.get(key) ?? this._anyUnitParser.parser
-                    if (!pUnitValue) {
-                        throw new InstrumentsError(`No parser found for ${String(key)}`)
-                    }
-                    if (!value) {
-                        throw new InstrumentsError(`No value found for ${String(key)}`)
-                    }
-
-                    if (Array.isArray(value)) {
-                        const [req, limit] = value.map(v => {
-                            return pUnitValue.parse(v as any).value
-                        })
-                        return {
-                            request: req,
-                            limit: limit
-                        }
-                    } else if (typeof value === "string") {
-                        return this._parseReqLimit(key as string, value)
-                    } else {
-                        throw new InstrumentsError(`Invalid value for resource ${String(key)}`)
-                    }
-                }
-                return [key, getVal()] as const
-            })
-            .pull()
-        return new Resources_UnitMap(map as Map<string, ReqLimit>)
-    }
-
-    static make<const RM extends Resources_UnitMap_Trait<RM>>(unitMap: {
-        [K in keyof RM]: UnitParser<RM[K]>
-    }) {
-        return new ResourcesSpec<RM>(mapFromObject(unitMap as any) as Map<string, UnitParser>)
-    }
-}

package/src/expressions/quantities/reqlem/types.ts

@@ -1,28 +0,0 @@
-import type { UnitValue } from "../units/unit-parser"
-export type Resources_sUnitTerm<Unit extends string> = `${number}${Unit}` | "?"
-
-export type ReqLim_Array<Unit extends string> = [
-    Resources_sUnitTerm<Unit>,
-    Resources_sUnitTerm<Unit>
-]
-export type Resources_UnitMap_Trait<T> = Record<keyof T, string>
-type _Spaces = "" | " " | "  "
-export type Resources_sToFrom<Unit extends string> =
-    `${Resources_sUnitTerm<Unit>}${_Spaces}->${_Spaces}${Resources_sUnitTerm<Unit>}`
-export type Resources_sExactly<U extends string> = `=${Resources_sUnitTerm<U>}`
-export interface ReqLimit<Unit extends string = string> {
-    readonly request?: UnitValue<Unit>
-    readonly limit?: UnitValue<Unit>
-}
-export type ReqLim_Input_Of<Unit extends string> =
-    | Resources_sToFrom<Unit>
-    | Resources_sExactly<Unit>
-    | ReqLim_Array<Unit>
-type CustomResource = `${string}/${string}`
-
-export type Resources_ReqLimits_Trait<ResourceUnit extends Resources_UnitMap_Trait<ResourceUnit>> =
-    {
-        [K in keyof ResourceUnit]: ReqLim_Input_Of<ResourceUnit[K]>
-    } & {
-        [K in CustomResource]?: ReqLim_Input_Of<string>
-    }

package/src/expressions/quantities/units/index.ts

@@ -1,2 +0,0 @@
-export { UnitParser, UnitValue } from "./unit-parser"
-export * from "./units"

package/src/expressions/quantities/units/unit-parser.ts

@@ -1,92 +0,0 @@
-import { int, letter, type Parjser } from "parjs"
-import { many, map, stringify, then } from "parjs/combinators"
-import { InstrumentsError } from "../../../error"
-const pUnit = letter().pipe(many(), stringify())
-
-const pValueUnit = int().pipe(
-    then(pUnit),
-    map(arr => {
-        const [value, unit] = arr
-        return { value, unit }
-    })
-)
-export class UnitValue<Unit extends string = string> {
-    constructor(
-        readonly unit: Unit,
-        readonly value: number,
-        readonly type: string
-    ) {}
-
-    get str() {
-        return `${this.value}${this.unit}`
-    }
-
-    get val() {
-        if (!this.unit) {
-            return +this.value
-        }
-        return this.str
-    }
-
-    toString() {
-        return this.str
-    }
-}
-
-export abstract class UnitParser<const Unit extends string = string> {
-    readonly parser: Parjser<UnitValue<Unit>>
-    protected abstract _validate(unit: string): asserts unit is Unit
-    constructor(protected readonly _unitType: string) {
-        this.parser = pValueUnit.pipe(
-            map(({ value, unit }) => {
-                this._validate(unit)
-
-                return new UnitValue<Unit>(unit as any, value, this._unitType)
-            })
-        )
-    }
-
-    parse = (input: `${number}${Unit}`) => {
-        const pUnitValue = this.parser
-        const result = pUnitValue.parse(input)
-        if (result.kind !== "OK") {
-            throw new InstrumentsError(`Failed to parse ${this._unitType}`, {
-                more: result.trace.toString()
-            })
-        }
-        return result.value
-    }
-}
-
-export class AnyUnitParser extends UnitParser<string> {
-    constructor() {
-        super("any")
-    }
-
-    _validate(_unit: string): void {
-        // Accept any unit
-    }
-
-    static make() {
-        return new AnyUnitParser()
-    }
-}
-
-export class SetUnitParser<const Unit extends string = string> extends UnitParser<Unit> {
-    constructor(
-        unitType: string,
-        private readonly _units: Set<Unit>
-    ) {
-        super(unitType)
-    }
-
-    _validate(unit: string): asserts unit is Unit {
-        if (!this._units.has(unit as Unit)) {
-            throw new InstrumentsError(`Unit ${unit} is not a valid unit of type ${this._unitType}`)
-        }
-    }
-
-    static make<const Unit extends string>(unitType: string, units: Set<Unit>) {
-        return new SetUnitParser<Unit>(unitType, units)
-    }
-}