@k8ts/instruments 0.5.3 → 0.6.2

package/src/api-kind/index.ts

@@ -1,142 +0,0 @@
-import { hash } from "immutable"
-import { displayers } from "../displayers"
-import { bind_own_methods } from "../displayers/bind"
-import { InstrumentsError } from "../error"
-
-export type Kind<
-    Name extends string = string,
-    Version extends Kind.Version = Kind.Version
-> = Kind.Kind<Name, Version>
-export namespace Kind {
-    export type InputVersion = `v${string}`
-
-    export interface IdentParent {
-        text: string
-        name: string
-        dns: string
-    }
-
-    @displayers({
-        simple: self => self.text
-    })
-    @bind_own_methods()
-    export abstract class Identifier<
-        Name extends string = string,
-        Parent extends IdentParent | null = IdentParent | null
-    > implements IdentParent
-    {
-        constructor(
-            readonly name: Name,
-            readonly parent: Parent
-        ) {}
-        get text(): string {
-            return [this.parent?.text, this.name].filter(Boolean).join("/")
-        }
-
-        get dns() {
-            return [this.name, this.parent?.dns].filter(Boolean).join(".")
-        }
-
-        abstract child<Name extends string>(name: Name): Identifier<Name, this>
-
-        equals(other: any) {
-            if (typeof other !== "object" || !other) {
-                return false
-            }
-            if (!(other instanceof Identifier)) {
-                return false
-            }
-            return this.text === other.text
-        }
-
-        private hashCode() {
-            return hash(this.text)
-        }
-    }
-    @bind_own_methods()
-    export class Group<const Name extends string = string> extends Identifier<Name, null> {
-        constructor(override name: Name) {
-            super(name, null)
-        }
-        version<Version extends InputVersion>(apiVersion: Version) {
-            return new Version(apiVersion, this)
-        }
-
-        child<Name extends string>(name: Name): Version<Name, this> {
-            if (!name.startsWith("v")) {
-                throw new InstrumentsError(
-                    `Invalid version name "${name}". Version name must start with "v".`
-                )
-            }
-            return this.version(name as any)
-        }
-    }
-    @bind_own_methods()
-    export class Version<
-        const _Version extends string = string,
-        const _Group extends Group = Group
-    > extends Identifier<_Version, _Group> {
-        kind<Kind extends string>(kind: Kind) {
-            return new Kind(kind, this)
-        }
-
-        get group() {
-            return this.parent
-        }
-
-        child<Name extends string>(name: Name): Kind<Name, this> {
-            return this.kind(name)
-        }
-    }
-    @bind_own_methods()
-    export class Kind<
-        const Name extends string = string,
-        const V extends Version = Version
-    > extends Identifier<Name, V> {
-        get version() {
-            return this.parent
-        }
-
-        get group() {
-            return this.parent?.parent
-        }
-
-        subkind<SubKind extends string>(subkind: SubKind) {
-            return new SubKind(subkind, this)
-        }
-
-        child<Name extends string>(name: Name): SubKind<Name, this> {
-            return this.subkind(name)
-        }
-    }
-    @bind_own_methods()
-    export class SubKind<
-        _SubKind extends string = string,
-        _Parent extends Identifier = Identifier
-    > extends Identifier<_SubKind, _Parent> {
-        constructor(name: _SubKind, parent: _Parent) {
-            super(name, parent)
-        }
-        subkind<_SubKind2 extends string>(subkind: _SubKind2): SubKind<_SubKind2, this> {
-            return new SubKind(subkind, this)
-        }
-
-        child<Name extends string>(name: Name) {
-            return this.subkind(name)
-        }
-    }
-
-    export function group<ApiGroup extends string>(apiGroup: ApiGroup) {
-        return new Group(apiGroup)
-    }
-
-    export function version<ApiVersion extends InputVersion>(apiVersion: ApiVersion) {
-        return new Version(apiVersion, group(""))
-    }
-}
-export function kinded(kind: Kind.Identifier) {
-    return <T extends abstract new (...args: any[]) => object>(ctor: T) => {
-        ctor.prototype.kind = kind
-        return ctor
-    }
-}

package/src/cmd/index.ts

@@ -1,2 +0,0 @@
-export { Cmd, CmdBuilder } from "./cli-command"
-export { CliArgsMapping, CliKey, CliValue } from "./types"

package/src/cmd/types.ts

@@ -1,4 +0,0 @@
-export type CliKey = `-${string}` | `--${string}`
-export type InputCliKey = `${CliKey}=` | `${CliKey} ` | CliKey
-export type CliValue = string | number | boolean | null | `${string}` | ` ${string}`
-export type CliArgsMapping = Record<InputCliKey, CliValue>

package/src/data-sources/index.ts

@@ -1,126 +0,0 @@
-import { doddle, DoddleAsync } from "doddle"
-import { readFile } from "fs/promises"
-import { Map } from "immutable"
-import { dirname, join, resolve } from "path"
-import StackTracey from "stacktracey"
-import { InstrumentsError } from "../error"
-export type LocalFileMode = "text" | "binary"
-
-export interface LocalFileSourceProps<Mode extends LocalFileMode = "text"> {
-    pointOfCall: StackTracey
-    path: string
-    cwd?: string
-    mode?: Mode
-}
-export class LocalFileSource<Mode extends LocalFileMode = "text"> {
-    constructor(private readonly _props: LocalFileSourceProps<Mode>) {}
-
-    get cwd() {
-        if (this._props.cwd) {
-            return this._props.cwd
-        }
-        const where = this._props.pointOfCall.at(0)
-        return dirname(where.file)
-    }
-
-    get path() {
-        const where = this._props.pointOfCall.at(0)
-        const joined = join(dirname(where.file), this._props.path)
-        return resolve(joined)
-    }
-
-    contents = doddle(async () => {
-        const mode = this._props.mode ?? "text"
-        if (mode === "binary") {
-            const data = await readFile(this.path, null)
-            return data
-        }
-        return readFile(this.path, "utf-8")
-    }) as DoddleAsync<Mode extends "text" ? string : Uint8Array>
-}
-
-export function localFile<Mode extends LocalFileMode = "text">(
-    path: string,
-    props?: Pick<LocalFileSourceProps<Mode>, "cwd" | "mode">
-): LocalFileSource<Mode>
-export function localFile(args: TemplateStringsArray, ...params: any[]): LocalFileSource<"text">
-export function localFile(args: any, ...params: any[]) {
-    if (typeof args === "string") {
-        const options = params[0] ?? {}
-        return new LocalFileSource({
-            pointOfCall: new StackTracey().slice(1),
-            path: args,
-            ...(options ?? {})
-        })
-    }
-    const path = String.raw(args, ...params)
-    return new LocalFileSource({
-        pointOfCall: new StackTracey().slice(1),
-        path
-    })
-}
-
-export interface TypedArrayLike {
-    buffer: ArrayBuffer
-    byteLength: number
-}
-export type DataSource_Text = LocalFileSource<"text"> | string
-export type DataSource_Binary = LocalFileSource<"binary"> | TypedArrayLike | ArrayBuffer
-export type DataSourceRecord_Text = Record<string, DataSource_Text>
-export type DataSourceRecord_Binary = Record<string, DataSource_Binary>
-export type DataSourceRecord = DataSourceRecord_Text | DataSourceRecord_Binary
-export function isTypedArray(data: DataSource_Binary): data is TypedArrayLike {
-    return (
-        typeof data === "object" &&
-        "buffer" in data &&
-        "byteSize" in data &&
-        typeof data.byteSize === "number"
-    )
-}
-export function isArrayBuffer(data: DataSource_Binary): data is ArrayBuffer {
-    return data instanceof ArrayBuffer
-}
-export interface DataSourceResolvedRecord {
-    data: Record<string, string>
-    binaryData: Record<string, Uint8Array>
-}
-type MaybePromise<T> = T | Promise<T>
-async function promiseAllMap<K, V>(m: Map<K, MaybePromise<V>>) {
-    const promises = m.toArray().map(async x => [x[0], await x[1]] as [K, V])
-    const res = await Promise.all(promises)
-    return Map(res)
-}
-export async function resolveText(record: DataSourceRecord_Text) {
-    const mp = Map(record).map(async (v, k) => {
-        let resolved = v
-        if (v instanceof LocalFileSource) {
-            resolved = await v.contents.pull()
-        }
-        if (typeof resolved !== "string") {
-            throw new InstrumentsError(
-                `Got an invalid data value ${v} for key ${k}. Must be a string.`
-            )
-        }
-        return resolved
-    })
-    return promiseAllMap(mp)
-}
-export async function resolveBinary(record: DataSourceRecord_Binary) {
-    const mp = Map(record).map(async (v, k) => {
-        let resolved = v
-        if (v instanceof LocalFileSource) {
-            resolved = await v.contents.pull()
-        }
-        if (isTypedArray(resolved)) {
-            return new Uint8Array(resolved.buffer)
-        } else if (isArrayBuffer(resolved)) {
-            return new Uint8Array(resolved)
-        } else {
-            throw new InstrumentsError(
-                `Got an invalid data value ${v} for key ${k}. Must be binary data.`
-            )
-        }
-    })
-
-    return promiseAllMap(mp)
-}

package/src/forward-exports/delayed-exports.ts

@@ -1,157 +0,0 @@
-import { seq } from "doddle"
-import { ProxyOperationError } from "../error"
-import { ResourceEntity } from "../graph"
-import { Origin } from "../graph/origin-node"
-import type { LiveRefable } from "../reference"
-import { ForwardRef } from "../reference"
-
-export type FutureExports<Exps extends LiveRefable> = FutureExports.FutureExports<Exps>
-export namespace FutureExports {
-    export type FutureExports<Exps extends LiveRefable> = _ExportsByKey<Exps>
-    type _ExportsByKey<Exports extends LiveRefable = LiveRefable> = {
-        [E in Exports as `${E["kind"]["name"]}/${E["name"]}`]: ForwardRef<E>
-    }
-    export interface Props<
-        Actual extends object = object,
-        Exports extends LiveRefable = LiveRefable
-    > {
-        readonly origin: Origin
-        readonly actual: Actual
-        readonly exports: Iterable<Exports>
-    }
-
-    export function make<T extends LiveRefable, Actual extends object>(
-        props: Props<Actual, T>
-    ): Actual & FutureExports<LiveRefable> {
-        const handler = new Handler(props)
-        return new Proxy(props.actual, handler) as any
-    }
-    class Handler implements ProxyHandler<object> {
-        constructor(private readonly _props: Props) {}
-
-        #createImmutableError(action: string) {
-            return new ProxyOperationError(
-                `Tried to ${action} an the exports constructs of ${this._props.origin}, but it is immutable.`
-            )
-        }
-
-        defineProperty(_: object, property: string | symbol, __: PropertyDescriptor): boolean {
-            throw this.#createImmutableError(`define property ${String(property)} on`)
-        }
-
-        deleteProperty(_: object, property: string | symbol): boolean {
-            throw this.#createImmutableError(`delete property ${String(property)} from`)
-        }
-
-        getPrototypeOf(_: Iterable<LiveRefable>): object | null {
-            return Reflect.getPrototypeOf(this._target)
-        }
-
-        get seq() {
-            return seq(this._props.exports)
-        }
-
-        #isValidReferant(prop: PropertyKey) {
-            return this._props.origin.resourceKinds.tryParse(prop as string) != null
-        }
-
-        get _target() {
-            return this._props.actual
-        }
-
-        get(target: any, property: string | symbol): any {
-            const key = property as string
-            if (Reflect.has(this._target, key)) {
-                const x = Reflect.get(this._target, property)
-                if (typeof x === "function") {
-                    return x.bind(this._target)
-                }
-                return x
-            }
-
-            const refKey = this._props.origin.resourceKinds.tryParse(key)
-            if (refKey == null) {
-                return undefined
-            }
-            const cls = this._props.origin.resourceKinds.getClass(refKey)
-            return ForwardRef.make({
-                class: cls,
-                key: refKey,
-                origin: this._props.origin,
-                namespace: this._props.origin.meta.tryGet("namespace"),
-                resolver: this.seq
-                    .as<ResourceEntity>()
-                    .first(exp => exp.node.key.equals(refKey))
-                    .map(x => {
-                        if (x == null) {
-                            throw new ProxyOperationError(
-                                `Failed to resolve forward reference to ${refKey} in ${this._props.origin}.`
-                            )
-                        }
-                        return x
-                    })
-            })
-        }
-
-        has(_: Iterable<LiveRefable>, p: string | symbol): boolean {
-            if (Reflect.has(this._target, p)) {
-                return true
-            }
-            if (!this.#isValidReferant(p)) {
-                return false
-            }
-            return true
-        }
-
-        isExtensible(target: Iterable<LiveRefable>): boolean {
-            return false
-        }
-
-        preventExtensions(target: Iterable<LiveRefable>): boolean {
-            return true
-        }
-
-        ownKeys(target: Iterable<LiveRefable>): ArrayLike<string | symbol> {
-            throw new ProxyOperationError(
-                `Cannot list all keys of a dynamic exports construct for ${this._props.origin}.`
-            )
-        }
-
-        set(
-            target: Iterable<LiveRefable>,
-            p: string | symbol,
-            newValue: any,
-            receiver: any
-        ): boolean {
-            throw this.#createImmutableError(`set property ${String(p)} on`)
-        }
-
-        setPrototypeOf(target: Iterable<LiveRefable>, v: any): boolean {
-            throw this.#createImmutableError(`set prototype of`)
-        }
-
-        _tryTargetDescriptor(p: PropertyKey) {
-            return Object.getOwnPropertyDescriptor(this._target, p)
-        }
-
-        getOwnPropertyDescriptor(
-            target: Iterable<LiveRefable>,
-            p: string | symbol
-        ): PropertyDescriptor | undefined {
-            const desc = this._tryTargetDescriptor(p)
-            if (desc) {
-                return desc
-            }
-            const value = this.get(this._target, p)
-            if (value == null) {
-                return undefined
-            }
-            return {
-                configurable: false,
-                enumerable: true,
-                value,
-                writable: false
-            }
-        }
-    }
-}

package/src/forward-exports/index.ts

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

package/src/graph/base-node.ts

@@ -1,135 +0,0 @@
-import { Seq, seq } from "doddle"
-import { hash, Set } from "immutable"
-import { Kind } from "../api-kind"
-import { RefKey } from "../ref-key"
-import { ForwardRef } from "../reference"
-import { Relation } from "./dependencies"
-
-export interface BaseEntity<Node extends BaseNode<Node>> {
-    readonly node: Node
-
-    readonly kind: Kind.Identifier
-    readonly name: string
-}
-
-export abstract class BaseNode<
-    Node extends BaseNode<Node, Entity>,
-    Entity extends BaseEntity<Node> = BaseEntity<Node>
-> {
-    private _eqProxy = {}
-    abstract readonly key: RefKey
-    get kind() {
-        return this.key.kind
-    }
-
-    abstract readonly kids: Seq<Node>
-    abstract readonly relations: Seq<Relation<Node>>
-    abstract readonly parent: Node | null
-    protected get _asNode() {
-        return this as any as Node
-    }
-
-    constructor(readonly _entity: Entity) {}
-
-    get shortFqn() {
-        return `${this.kind.name}/${this.name}`
-    }
-
-    get root(): Node {
-        return (this.ancestors.at(-1).pull() as any) ?? (this as any)
-    }
-    get name() {
-        return this.key.name
-    }
-    get isRoot() {
-        return this.parent === null && this._entity.kind.name !== "PodTemplate"
-    }
-
-    hashCode() {
-        return hash(this._eqProxy)
-    }
-    equals(other: any) {
-        if (ForwardRef.is(other)) {
-            return other.equals(this)
-        }
-        return this === other
-    }
-
-    readonly ancestors = seq(() => {
-        const seen = Set<Node>()
-        const recurse = function* (from: Node): Iterable<Node> {
-            const parent = from.parent
-            if (parent && !seen.has(parent)) {
-                seen.add(parent)
-                yield parent
-                yield* recurse(parent)
-            }
-        }
-        return seq(recurse.bind(null, this._asNode))
-    }).cache()
-
-    readonly descendants = seq(() => {
-        const self = this
-        let seen = Set<Node>()
-        const recurse = function* (from: Node): Iterable<Node> {
-            for (const kid of from.kids) {
-                if (seen.has(kid)) {
-                    continue
-                }
-                seen = seen.add(kid)
-                yield kid
-                yield* recurse(kid)
-            }
-        }
-        return seq(recurse.bind(null, self._asNode))
-    }).cache()
-
-    isParentOf(other: Node): boolean {
-        if (ForwardRef.is(other)) {
-            return other.isChildOf(this._asNode)
-        }
-        return Set(this.descendants).has(other)
-    }
-
-    isChildOf(other: Node): boolean {
-        if (ForwardRef.is(other)) {
-            return other.isParentOf(this._asNode)
-        }
-        return this.equals(other) || Set(this.ancestors).has(other._asNode)
-    }
-
-    hasRelationTo(other: Node): boolean {
-        return this.recursiveRelations.some(x => x.needed.equals(other)).pull()
-    }
-
-    readonly recursiveRelationsSubtree = seq((): Seq<Relation<Node>> => {
-        const self = this
-        return seq(function* () {
-            for (const child of [self, ...self.descendants] as Node[]) {
-                yield* child.recursiveRelations
-            }
-        }) as any
-    })
-
-    readonly recursiveRelations = seq(() => {
-        let resources = Set<Node>()
-        const recurseIntoDependency = function* (root: Relation<Node>): Iterable<Relation<Node>> {
-            yield root
-            if (resources.has(root.needed)) {
-                return
-            }
-            resources = resources.add(root.needed)
-
-            const ownDeps = root.needed.relations
-            for (const needsEdge of ownDeps) {
-                yield* recurseIntoDependency(needsEdge)
-            }
-        }
-        return seq(recurseIntoDependency.bind(null, new Relation<Node>("self", this._asNode)))
-            .after(() => {
-                resources = Set()
-            })
-            .cache()
-    })
-}
-export type Formats = "local" | "source" | undefined

package/src/graph/base-origin-entity.ts

@@ -1,44 +0,0 @@
-import { Meta } from "@k8ts/metadata"
-import chalk from "chalk"
-import { doddle, Doddle } from "doddle"
-import { Kind } from "../api-kind"
-import { displayers } from "../displayers"
-import { RefKey } from "../ref-key"
-import { Origin, OriginEntity } from "./origin-node"
-export interface OriginEntityProps {
-    meta?: Meta.Input
-    alias?: string
-}
-@displayers({
-    simple: x => `[${x.shortFqn}]`,
-    pretty(origin) {
-        const kindPart = chalk.greenBright.bold(origin.kind.name)
-        const originName = chalk.cyan(origin.name)
-        return `${kindPart}/${originName}`
-    }
-})
-export abstract class BaseOriginEntity<Props extends OriginEntityProps = OriginEntityProps>
-    implements OriginEntity
-{
-    abstract readonly kind: Kind.Kind
-    #node: Doddle<Origin>
-
-    meta: Meta
-    get alias() {
-        return this.props.alias ?? undefined
-    }
-    get node() {
-        return this.#node.pull()
-    }
-    constructor(
-        readonly name: string,
-        readonly props: Props,
-        parent: Origin | null
-    ) {
-        this.#node = doddle(() => new Origin(parent, this, RefKey.make(this.kind, name)))
-        this.meta = Meta.make(props.meta)
-    }
-    get shortFqn() {
-        return this.node.shortFqn
-    }
-}

package/src/graph/dependencies.ts

@@ -1,30 +0,0 @@
-import { pretty } from "../_string"
-import { displayers } from "../displayers"
-import { BaseNode } from "./base-node"
-import { ResourceEntity } from "./resource-node"
-
-export namespace Dependencies {
-    export type Input = Record<string, ResourceEntity | undefined>
-}
-export function dependencies(record: Dependencies.Input) {
-    return Object.entries(record)
-        .map(([key, value]) => {
-            if (value) {
-                return new Relation(key, value.node)
-            }
-        })
-        .filter(x => !!x)
-}
-@displayers({
-    simple: s => [s.why, "-->", s.needed],
-    pretty: (dep, format) => {
-        const neededFmt = pretty`${["lowkey", dep.needed]}`
-        return [dep.why, neededFmt].join("➜ ")
-    }
-})
-export class Relation<Node extends BaseNode<Node>> {
-    constructor(
-        readonly why: string,
-        readonly needed: Node
-    ) {}
-}

package/src/graph/index.ts

@@ -1,6 +0,0 @@
-export * from "./base-node"
-export * from "./base-origin-entity"
-export * from "./dependencies"
-export * from "./origin-node"
-export * from "./relations"
-export * from "./resource-node"