@k8ts/instruments 0.11.4 → 0.12.0

package/src/core/graph/resource/api-kind/index.ts

@@ -1,171 +0,0 @@
-import { InstrumentsError } from "../../../../error"
-import { bind_own_methods } from "../../../../utils"
-import { displayers } from "../../../../utils/displayers"
-import { RefKey, type RefKey_Options } from "../ref-key"
-import { pluralize } from "./pluralize"
-
-export interface Ident_Like {
-    text: string
-    name: string
-    dns: string
-    parent: Ident_Like | null
-    equals(other: any): boolean
-}
-type _alphabeta = "alpha" | "beta" | ""
-type _subversion = `${_alphabeta}${number}` | ""
-type _version = `v${number}${_subversion | ""}`
-
-@displayers({
-    simple: self => self.text
-})
-@bind_own_methods()
-export abstract class Ident<
-    Name extends string = string,
-    Parent extends Ident_Like | null = Ident_Like | null
-> implements Ident_Like
-{
-    constructor(
-        readonly name: Name,
-        readonly parent: Parent
-    ) {}
-
-    get full(): Ident_Like[] {
-        const parts: Ident_Like[] = []
-        let curr: Ident_Like | null = this
-        while (curr) {
-            parts.unshift(curr)
-            curr = curr.parent
-        }
-        return parts.filter(x => x.name)
-    }
-
-    get text(): string {
-        return this.full.map(p => p.name).join("/") as any
-    }
-
-    get dns(): string {
-        return this.full
-            .map(x => x.name)
-            .filter(Boolean)
-            .join(".")
-    }
-
-    abstract child(name: string): Ident<
-        string,
-        {
-            name: Name
-        } & Ident_Like
-    >
-
-    equals(other: any) {
-        if (!other) {
-            return false
-        }
-        if (typeof other !== "object" || !other) {
-            return false
-        }
-        if (!(other instanceof Ident)) {
-            return false
-        }
-        return this.text === other.text
-    }
-}
-@bind_own_methods()
-export class Ident_Group<const _Group extends string = string> extends Ident<_Group, null> {
-    constructor(override name: _Group) {
-        super(name, null)
-    }
-    version<Version extends _version>(apiVersion: Version) {
-        return new Ident_Version(apiVersion, this)
-    }
-
-    child(name: string): Ident_Version<_Group, string> {
-        if (!name.startsWith("v")) {
-            throw new InstrumentsError(
-                `Invalid version name "${name}". Version name must start with "v".`
-            )
-        }
-        return this.version(name as any) as any
-    }
-}
-@bind_own_methods()
-export class Ident_Version<
-    const _Group extends string = string,
-    const _Version extends string = string
-> extends Ident<_Version, Ident_Group<_Group>> {
-    kind<_Kind extends string>(kind: _Kind, specialPlural?: string) {
-        return new Ident_Kind(kind, this as Ident_Version<_Group, _Version>, specialPlural)
-    }
-
-    __FORMAT__!: _Version
-
-    get group() {
-        return this.parent
-    }
-
-    child(name: string): Ident_Kind<_Group, _Version, string> {
-        return this.kind(name)
-    }
-}
-@bind_own_methods()
-export class Ident_Kind<
-    const _Group extends string = string,
-    const _Version extends string = string,
-    const _Kind extends string = string
-> extends Ident<_Kind, Ident_Version<_Group, _Version>> {
-    constructor(
-        name: _Kind,
-        parent: Ident_Version<_Group, _Version>,
-        private readonly _specialPlural?: string
-    ) {
-        super(name, parent)
-    }
-
-    refKey<Name extends string>(options: RefKey_Options<Name>) {
-        return new RefKey<this, Name>(this as any, options)
-    }
-
-    get plural() {
-        return this._specialPlural ?? pluralize(this.name.toLowerCase())
-    }
-    get version() {
-        return this.parent
-    }
-
-    get group() {
-        return this.parent.parent
-    }
-
-    subkind<SubKind extends string>(subkind: SubKind) {
-        return new Ident_Rsc_Part(subkind, this)
-    }
-
-    child<Name extends string>(name: Name): Ident_Rsc_Part<Name, this> {
-        return this.subkind(name)
-    }
-}
-
-@bind_own_methods()
-export class Ident_Rsc_Part<
-    Name extends string = string,
-    Parent extends Ident_Like = Ident_Like
-> extends Ident<Name, Parent> {
-    constructor(name: Name, parent: Parent) {
-        super(name, parent)
-    }
-    subkind<_SubKind2 extends string>(subkind: _SubKind2): Ident_Rsc_Part<_SubKind2, this> {
-        return new Ident_Rsc_Part(subkind, this)
-    }
-
-    child<Name extends string>(name: Name) {
-        return this.subkind(name)
-    }
-}
-
-export function group<ApiGroup extends string>(apiGroup: ApiGroup) {
-    return new Ident_Group(apiGroup)
-}
-
-export function version<ApiVersion extends _version>(apiVersion: ApiVersion) {
-    return new Ident_Version(apiVersion, group(""))
-}

package/src/core/graph/resource/api-kind/pluralize.ts

@@ -1,40 +0,0 @@
-type _Alpha_Beta = "alpha" | "beta"
-type _Sub_Version = `${_Alpha_Beta}${number}`
-type Version = `v${number}${_Sub_Version | ""}`
-
-export type _Group = string
-export type _Slash<A extends string, B extends string> = `${A}/${B}`
-export type _Group_Version<Group extends string = string, Vers extends string = string> =
-    | _Slash<Group, Vers>
-    | Version
-
-type _Word_Plural_Map = {
-    y: "ies"
-    s: "es"
-    ch: "ches"
-    sh: "es"
-    z: "zes"
-    ro: "es"
-    x: "es"
-    ay: "ays"
-    ey: "eys"
-    iy: "iys"
-    oy: "oys"
-    uy: "uys"
-}
-
-export type Pluralize<S extends string> = S extends `${infer K extends keyof _Word_Plural_Map}`
-    ? `${K}${_Word_Plural_Map[K]}`
-    : `${S}s`
-export function pluralize<S extends string>(word: S): Pluralize<S> {
-    if (["s", "sh", "ch", "x", "z", "ro"].some(suffix => word.endsWith(suffix))) {
-        return `${word}es` as Pluralize<S>
-    }
-    if (["ay", "ey", "iy", "oy", "uy"].some(suffix => word.endsWith(suffix))) {
-        return `${word}s` as Pluralize<S>
-    }
-    if (word.endsWith("y")) {
-        return `${word.slice(0, -1)}ies` as Pluralize<S>
-    }
-    return `${word}s` as Pluralize<S>
-}

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

@@ -1,23 +0,0 @@
-import type { Ident_Rsc_Part } from "./api-kind"
-import { Rsc_Entity } from "./entity"
-
-export abstract class Rsc_Part<Props extends object = object> extends Rsc_Entity<string, Props> {
-    abstract get kind(): Ident_Rsc_Part
-    #parent: Rsc_Entity
-    constructor(parent: Rsc_Entity, name: string, props: Props) {
-        super(name, props)
-        this.#parent = parent
-    }
-
-    protected __parent__(): Rsc_Entity {
-        return this.#parent
-    }
-
-    protected __origin__() {
-        return this.__parent__()["__origin__"]()
-    }
-
-    get namespace(): string | undefined {
-        return this.__parent__().namespace
-    }
-}

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

@@ -1,73 +0,0 @@
-import { getDeepPropertyDescriptor } from "@k8ts/metadata/util"
-import { getNiceClassName } from "what-are-you"
-import { displayers } from "../../../utils"
-import { Entity } from "../entity"
-import type { Origin_Entity } from "../origin"
-import type { Ident } from "./api-kind"
-import { Rsc_Node } from "./node"
-import { FwRef, type Rsc_Ref } from "./reference"
-
-@displayers({
-    simple: s => s.node,
-    pretty: s => s.node
-})
-export abstract class Rsc_Entity<
-    Name extends string = string,
-    Props extends object = object
-> extends Entity<Rsc_Node, Rsc_Entity, Rsc_Ref> {
-    abstract get kind(): Ident
-
-    with(callback: (self: this) => void) {
-        callback(this)
-        return this
-    }
-
-    abstract readonly namespace: string | undefined
-
-    get ref() {
-        return {
-            kind: this.kind.name,
-            name: this.name,
-            namespace: this.namespace
-        }
-    }
-
-    constructor(
-        readonly name: Name,
-        readonly props: Props
-    ) {
-        super()
-
-        this.name = name
-        const desc = getDeepPropertyDescriptor(this, "kind")
-        if (!desc || !desc.get) {
-            throw new Error(
-                `ResourceEntity subclass ${getNiceClassName(this)} must implement the 'kind' property as a getter, but it's missing or not a getter.`
-            )
-        }
-    }
-
-    equals(other: any): boolean {
-        if (!other) {
-            return false
-        }
-        if (FwRef.is(other)) {
-            return other.equals(this)
-        }
-        if (other instanceof Rsc_Entity) {
-            return Object.is(this, other)
-        }
-        return false
-    }
-
-    protected abstract __origin__(): Origin_Entity
-    get node(): Rsc_Node {
-        return new Rsc_Node(this.__origin__().node, this)
-    }
-
-    get shortFqn() {
-        return [this.node.origin.name, [this.kind.name, this.name].filter(Boolean).join("/")].join(
-            ":"
-        )
-    }
-}

package/src/core/graph/resource/external/base.ts

@@ -1,39 +0,0 @@
-import { Meta } from "@k8ts/metadata"
-import { Origin_External } from "../../origin/external"
-import type { Ident_Kind } from "../api-kind"
-import { Rsc_Entity } from "../entity"
-import type { RefKey } from "../ref-key"
-export class External<K extends Ident_Kind> extends Rsc_Entity<string, any> {
-    readonly meta = Meta.make()
-    constructor(
-        readonly key: RefKey<K>,
-        props: any
-    ) {
-        super(key.name, props)
-
-        this.meta.add({
-            name: key.name,
-            namespace: key.namespace,
-            "#k8ts.org/is-external": "true"
-        })
-
-        if (props.keys) {
-            Object.defineProperties(this, {
-                keys: {
-                    get: () => props.keys
-                }
-            })
-        }
-    }
-
-    protected __origin__() {
-        return Origin_External.instance
-    }
-    get namespace() {
-        return this.meta.tryGet("namespace")
-    }
-
-    get kind() {
-        return this.key.kind
-    }
-}

package/src/core/graph/resource/external/index.ts

@@ -1,3 +0,0 @@
-export * from "./base"
-export * from "./features"
-export * from "./props"

package/src/core/graph/resource/external/props.ts

@@ -1,16 +0,0 @@
-import type { Ident_Kind } from "../api-kind"
-
-export interface External_Features {
-    keys?: string[]
-}
-export interface External_KindToFeatures {
-    ConfigMap: {
-        keys?: string[]
-    }
-    Secret: {
-        keys?: string[]
-    }
-    [s: string]: {}
-}
-
-export type External_Props<K extends Ident_Kind> = External_KindToFeatures[K["name"]]

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

@@ -1,132 +0,0 @@
-import { Meta } from "@k8ts/metadata"
-import chalk from "chalk"
-import { seq } from "doddle"
-import { type AnyCtor } from "what-are-you"
-import { Displayers, displayers } from "../../../utils/displayers"
-import { TraceEmbedder } from "../../tracing"
-import { Formats } from "../entity"
-import { Node } from "../node"
-import { OriginNode } from "../origin/node"
-import type { Ident_Kind, Ident_Like } from "./api-kind"
-import type { Rsc_Entity } from "./entity"
-import { RefKey } from "./ref-key"
-
-@displayers({
-    simple: s => `[${s.shortFqn}]`,
-    pretty(resource, format) {
-        format ??= "global"
-
-        let kindName = chalk.greenBright(resource.kind.name)
-        if (format !== "lowkey") {
-            kindName = chalk.bold(kindName)
-        }
-        const parts = [kindName]
-        if (resource.namespace) {
-            parts.push(chalk.yellowBright(resource.namespace))
-        }
-        parts.push(chalk.blueBright(resource.name))
-        const mainPart = parts.join("/")
-        let originPart = `${Displayers.get(resource.origin).prefix!()}`
-        let text = ""
-
-        text += mainPart
-        if (format !== "local") {
-            text = `${originPart}${text}`
-        }
-        if (format === "source") {
-            text += ` (at ${resource.trace.format()})`
-        }
-        return text
-    }
-})
-export class Rsc_Node extends Node<Rsc_Node, Rsc_Entity> {
-    get fullFqn() {
-        return [this.kind.dns, this.namespace, this.name].filter(Boolean).join("/")
-    }
-    get key(): RefKey {
-        return new RefKey(this.kind, {
-            name: this.name,
-            namespace: this.namespace
-        })
-    }
-    get kind() {
-        return this.entity.kind as Ident_Kind
-    }
-
-    get namespace() {
-        return this.meta?.tryGet("namespace")
-    }
-
-    get trace() {
-        return TraceEmbedder.get(this.entity)
-    }
-
-    get isExported() {
-        return this.meta?.tryGet("#k8ts.org/is-exported") ?? false
-    }
-
-    get meta() {
-        return "meta" in this.entity ? (this.entity.meta as Meta) : undefined
-    }
-
-    get isExternal() {
-        return this.meta?.tryGet("#k8ts.org/is-external") ?? false
-    }
-
-    when<EntityType extends Rsc_Entity>(
-        type: AnyCtor<EntityType>,
-        fn: (entity: EntityType) => void
-    ) {
-        const entity = this.entity as EntityType
-        if (entity instanceof type) {
-            fn(entity)
-        }
-    }
-
-    as<EntityType extends Rsc_Entity>(type: AnyCtor<EntityType>) {
-        const entity = this.entity as EntityType
-        if (entity instanceof type) {
-            return entity
-        }
-        throw new Error(
-            `This node is for an entity of type ${entity.constructor.name}, not ${type.name}`
-        )
-    }
-
-    get origins() {
-        const self = this
-        return seq(function* () {
-            let current: OriginNode | null = self.origin
-            while (current) {
-                yield current
-                current = current.parent
-            }
-        })
-    }
-
-    get disabled() {
-        return "disabled" in this.entity ? !!this.entity.disabled : false
-    }
-
-    get shortFqn() {
-        return `${this.origin.name}:${this.key}`
-    }
-
-    get localName() {
-        return this.key.string
-    }
-
-    format(format: Formats) {
-        return Displayers.get(this).pretty(format)
-    }
-
-    hasKind(kind: Ident_Like) {
-        return this.kind.equals(kind)
-    }
-    constructor(
-        readonly origin: OriginNode,
-        readonly entity: Rsc_Entity
-    ) {
-        super(entity)
-    }
-}

package/src/core/graph/resource/ref-key/index.ts

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

package/src/core/graph/resource/ref-key/ref-key.ts

@@ -1,156 +0,0 @@
-import { InstrumentsError } from "../../../../error"
-import type { Ident_Kind } from "../api-kind"
-import type { External } from "../external"
-import { type External_Props } from "../external"
-import type { Rsc_Ref } from "../reference"
-/** Input type for reference keys. Accepts either a RefKey instance or its string representation. */
-export type RefKey_Input = RefKey | RefKey["string"]
-
-/**
- * String format template for reference keys.
- *
- * @template Kind - The Kubernetes resource kind
- * @template Name - The resource name
- */
-export type RefKey_sFormat<Kind extends string, Name extends string> = `${Kind}/${Name}`
-
-const separator = "/"
-
-/** Parsed representation of a reference key string. */
-export interface RefKey_Parsed {
-    /** The Kubernetes resource kind */
-    kind: string
-    /** The resource name */
-    name: string
-}
-
-export function parse(ref: string) {
-    const result = tryParse(ref)
-    if (!result) {
-        throw new InstrumentsError(`Could not parse reference key: ${ref}`)
-    }
-    return result
-}
-
-/**
- * Attempts to parse a reference key string into its kind and name components. Returns undefined if
- * the string cannot be parsed.
- *
- * @param ref - The reference key string to parse (format: "Kind/Name")
- * @returns The parsed reference key, or undefined if parsing fails
- */
-export function tryParse(ref: string): RefKey_Parsed | undefined {
-    if (typeof ref !== "string") {
-        return undefined
-    }
-    if (ref == null) {
-        return undefined
-    }
-    if (typeof ref === "object") {
-        return undefined
-    }
-    const [kind, name] = ref.split(separator).map(s => s.trim())
-    if (!kind || !name) {
-        return undefined
-    }
-    return {
-        kind,
-        name
-    }
-}
-
-type nsKind = Ident_Kind<"", "v1", "Namespace">
-
-/**
- * Options for creating a RefKey instance.
- *
- * @template Name - The resource name type
- */
-export interface RefKey_Options<Name extends string = string> {
-    /** The resource name */
-    name: Name
-    /** Optional namespace for namespaced resources. Can be a RefKey, string, or Ref2 */
-    namespace?: RefKey<nsKind> | string | Rsc_Ref<nsKind>
-}
-
-/**
- * A unique identifier for a k8s resource consisting of a Kind, name, and namespace. Used by
- * resources to reference other resources. Serves as the basis for the {@link External} resource
- * type.
- *
- * Important: This class is ambiguous because it can represent keys for namespaced resources but
- * ignore the namespace. Needs some kind of refactor.
- */
-export class RefKey<K extends Ident_Kind = Ident_Kind, Name extends string = string> {
-    /** The resource name */
-    readonly name: string
-    /** The optional namespace for namespaced resources */
-    readonly namespace: string | undefined
-
-    /**
-     * Creates a new RefKey instance.
-     *
-     * @param kind - The Kubernetes resource kind
-     * @param options - Configuration options including name and optional namespace
-     */
-    constructor(
-        readonly kind: K,
-        options: RefKey_Options<Name>
-    ) {
-        this.name = options.name
-        this.namespace =
-            typeof options.namespace === "string" ? options.namespace : options.namespace?.name
-    }
-
-    /**
-     * Returns the string representation of this reference key. Format: "Kind/Namespace/Name" or
-     * "Kind/Name" for cluster-scoped resources.
-     */
-    get string(): RefKey_sFormat<K["name"], Name> {
-        return [this.kind.name, this.namespace, this.name]
-            .filter(x => !!x)
-            .join(separator) as RefKey_sFormat<K["name"], Name>
-    }
-
-    /**
-     * Checks if this RefKey is equal to another RefKey by comparing kind, name, and namespace.
-     *
-     * @param other - The RefKey to compare with
-     * @returns True if both RefKeys have the same kind, name, and namespace
-     */
-    equals(other: RefKey): boolean {
-        if (other == null) {
-            return false
-        }
-        if (typeof other !== "object") {
-            return false
-        }
-        return (
-            this.kind.equals(other.kind) &&
-            this.name === other.name &&
-            this.namespace === other.namespace
-        )
-    }
-
-    /**
-     * Returns the string representation of this reference key.
-     *
-     * @returns The reference key in string format
-     */
-    toString() {
-        return this.string
-    }
-
-    /**
-     * Creates an External reference to this resource.
-     *
-     * @template P - The external properties type
-     * @param options - Optional external properties configuration
-     * @returns An External instance with the specified features
-     */
-    External(options?: External_Props<K>): External<K> {
-        const External = require("../external").External
-
-        return new External(this, options ?? {}) as any
-    }
-}

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

@@ -1,7 +0,0 @@
-import { InstrumentsError } from "../../../../error"
-
-export class ProxyOperationError extends InstrumentsError {
-    constructor(message: string, details: Record<string, any> = {}) {
-        super(message, details)
-    }
-}

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

@@ -1,3 +0,0 @@
-export { FwRef } from "./fw-ref"
-export { Rsc_FwRef_Exports } from "./fw-ref-exports"
-export type * from "./refable"