@k8ts/instruments 0.6.0 → 0.6.2

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"

package/src/graph/origin-node.ts

@@ -1,122 +0,0 @@
-import { Meta } from "@k8ts/metadata"
-import chalk from "chalk"
-import { doddle, seq, Seq } from "doddle"
-import StackTracey from "stacktracey"
-import { getMarkerForExternal, getMarkerForIndex } from "../_string"
-import { displayers } from "../displayers"
-import { KindMap } from "../kind-map"
-import { RefKey } from "../ref-key"
-import { TraceEmbedder } from "../tracing"
-import { Trace } from "../tracing/trace"
-import { BaseEntity, BaseNode } from "./base-node"
-import { ResourceNode } from "./resource-node"
-@displayers({
-    simple: s => `[${s.shortFqn}]`,
-    prefix: s => {
-        if (s.name === "EXTERNAL") {
-            return getMarkerForExternal()
-        }
-        return getMarkerForIndex(s.index)
-    },
-    pretty(origin, format) {
-        const kindName = chalk.greenBright.bold(origin.kind.name)
-        const resourceName = chalk.cyan(origin.name)
-        const pref = this.prefix!()
-
-        return chalk.underline(`${pref}${kindName}:${resourceName}`)
-    }
-})
-export class Origin extends BaseNode<Origin, OriginEntity> implements Iterable<ResourceNode> {
-    private _kids = [] as Origin[]
-    get kids() {
-        return seq(this._kids)
-    }
-    get meta() {
-        return this._entity.meta
-    }
-    readonly index: number
-    private readonly _getIndex = doddle(() => {
-        let index = 1
-        return () => index++
-    }).pull()
-    constructor(
-        readonly parent: Origin | null,
-        entity: OriginEntity,
-        readonly key: RefKey
-    ) {
-        super(entity)
-        this.index = parent?._getIndex() ?? 0
-        this._kindMap = new KindMap(undefined, parent?._kindMap)
-    }
-    get resourceKinds() {
-        return this._kindMap
-    }
-    private _kindMap: KindMap
-    private _attached = [] as ResourceNode[]
-
-    get relations() {
-        return seq.empty()
-    }
-    [Symbol.iterator]() {
-        return this.resources[Symbol.iterator]()
-    }
-    readonly attachedTree: Seq<ResourceNode> = seq(() => {
-        const self = this
-        const desc = self.descendants
-            .concatFirst([this])
-            .map(x => x)
-            .concatMap(function* (x) {
-                yield* self.resources
-                for (const kid of self.kids) {
-                    yield* kid.resources
-                }
-            })
-        return desc
-    }).cache()
-
-    get resources() {
-        return this._attached
-    }
-
-    static registerWithOrigin<F extends Function>(ctor: F) {
-        const prototype = ctor.prototype
-        for (const key of Object.getOwnPropertyNames(prototype)) {
-            const value = prototype[key]
-            if (!key.match(/^[A-Z]/) || typeof value !== "function") {
-                continue
-            }
-            const orig = prototype[key]
-            prototype[key] = {
-                [key](this: any, ...args: any[]) {
-                    const result = orig.apply(this, args) as BaseEntity<any>
-                    if (
-                        typeof result === "object" &&
-                        "node" in result &&
-                        result.node instanceof ResourceNode
-                    ) {
-                        result.node.origin.__attach_resource__([result.node])
-                        TraceEmbedder.set(result.node, new Trace(new StackTracey().slice(1)))
-                    }
-                    return result
-                }
-            }[key]
-        }
-    }
-
-    private __attach_child__(child: Origin) {
-        this._kids.push(child)
-    }
-
-    private __attach_resource__(resources: ResourceNode | Iterable<ResourceNode>) {
-        resources = Symbol.iterator in resources ? resources : [resources]
-        for (const resource of resources) {
-            this._attached.push(resource)
-        }
-    }
-}
-export interface OriginEntity extends BaseEntity<Origin> {
-    alias?: string
-    meta: Meta
-}
-
-export const auto_register = Origin.registerWithOrigin

package/src/graph/relations.ts

@@ -1,62 +0,0 @@
-import { Embedder } from "../_embedder/base"
-import { Dependencies, dependencies, Relation } from "./dependencies"
-import { ResourceEntity, ResourceNode } from "./resource-node"
-
-export namespace Relations {
-    export interface Out {
-        needs: () => Iterable<Relation<ResourceNode>>
-        parent: () => ResourceNode | null
-        kids: () => ResourceNode[]
-    }
-
-    export type In<Target extends ResourceEntity = ResourceEntity> = {
-        needs: (self: Target) => Dependencies.Input
-        parent: (self: Target) => ResourceEntity | null
-        kids: (self: Target) => ResourceEntity[]
-    } & {
-        [key: string]: (self: Target, ...args: any[]) => any
-    }
-}
-
-class RelationsService {
-    private _system = new Embedder<ResourceEntity, Relations.In>("relations")
-
-    implement(
-        ctor: abstract new (...args: any[]) => ResourceEntity,
-        input: Relations.In<ResourceEntity>
-    ) {
-        const existing = this._system.tryGet(ctor.prototype)
-        if (existing) {
-            input = Object.assign({}, existing, input)
-        }
-        this._system.set(ctor.prototype, input)
-    }
-
-    get(target: ResourceEntity): Relations.Out {
-        const input = this._system.get(target)
-        const o = {
-            kids: () => input.kids?.call(o, target).map(x => x.node) ?? [],
-            parent: () => input.parent?.call(o, target)?.node ?? null,
-            needs: () => dependencies(input.needs?.call(o, target) ?? {})
-        }
-        return o
-    }
-
-    get decorator() {
-        return <
-            Target extends abstract new (...args: any[]) => ResourceEntity,
-            Impl extends Partial<Relations.In<InstanceType<Target>>> | "none"
-        >(
-            input: Impl
-        ) => {
-            return (ctor: Target) => {
-                this.implement(ctor, input === "none" ? {} : (input as any))
-                return ctor
-            }
-        }
-    }
-}
-export const Relations = new RelationsService()
-export const relations = Relations.decorator
-
-// writing the decorator itself