@k8ts/instruments 0.5.3 → 0.6.2

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

package/src/kind-map/index.ts

@@ -1,150 +0,0 @@
-import { Map, type Set } from "immutable"
-import { Kind } from "../api-kind"
-import { InstrumentsError } from "../error"
-import { RefKey } from "../ref-key"
-const separator = "/"
-export type LookupKey = NodeEntry[keyof NodeEntry]
-interface NodeEntry {
-    kind: string
-    class: Function
-    ident: Kind.Identifier
-}
-export class KindMap {
-    constructor(
-        private _entryMap: Map<LookupKey, NodeEntry> = Map([]) as any,
-        private _parent: KindMap | undefined = undefined
-    ) {}
-
-    refKey<Kind extends string, Name extends string>(
-        kind: Kind | Kind.Identifier<Kind>,
-        name: Name
-    ): RefKey<Kind, Name> {
-        const trueKind = this.getKind(kind)
-        return new RefKey.RefKey(trueKind, name) as any
-    }
-
-    private _bindEntry(entry: NodeEntry) {
-        for (const key of [entry.kind, entry.class, entry.ident]) {
-            this._entryMap = this._entryMap.set(key, entry)
-        }
-    }
-
-    add(kind: Kind.Identifier, klass: Function) {
-        this._bindEntry({
-            kind: kind.name,
-            class: klass,
-            ident: kind
-        })
-    }
-
-    parse(ref: string | RefKey) {
-        const result = this.tryParse(ref)
-        if (!result) {
-            throw new InstrumentsError(`Could not parse reference key: ${ref}`)
-        }
-        return result
-    }
-
-    tryParse(ref: unknown): RefKey.RefKey | undefined {
-        if (typeof ref !== "string" && typeof ref !== "object") {
-            return undefined
-        }
-        if (ref == null) {
-            return undefined
-        }
-        if (ref instanceof RefKey.RefKey) {
-            return ref
-        }
-        if (typeof ref === "object") {
-            return undefined
-        }
-        const [kind, name] = ref.split(separator).map(s => s.trim())
-        if (!kind || !name) {
-            return undefined
-        }
-        return this.refKey(kind, name)
-    }
-
-    get kinds(): Set<string> {
-        return this._entryMap
-            .keySeq()
-            .filter(k => typeof k === "string")
-            .toSet()
-    }
-
-    private _unknownNameError(kind: string) {
-        return new InstrumentsError(`The shorthand name ${kind} is not registered`)
-    }
-    private _unknownIdentError(ident: Kind.Identifier) {
-        return new InstrumentsError(`The kind identifier ${ident} is not registered`)
-    }
-    private _unknownClassError(klass: Function) {
-        return new InstrumentsError(`The class ${klass.name} is not registered`)
-    }
-    private _convert(something: LookupKey | RefKey.RefKey) {
-        if (typeof something === "string") {
-            if (something.includes("/")) {
-                return this.parse(something).kind
-            }
-            return something
-        } else if (typeof something === "function" || something instanceof Kind.Identifier) {
-            return something
-        } else if (something instanceof RefKey.RefKey) {
-            return something.kind
-        }
-        throw new InstrumentsError(`Invalid argument ${something}`)
-    }
-    private _getEntry(key: LookupKey | RefKey.RefKey) {
-        const converted = this._convert(key)
-        const entry = this._tryGetEntry(key)
-        if (!entry) {
-            if (typeof converted === "string") {
-                throw this._unknownNameError(converted)
-            } else if (converted instanceof Kind.Identifier) {
-                throw this._unknownIdentError(converted)
-            } else if (typeof converted === "function") {
-                throw this._unknownClassError(converted)
-            }
-        }
-        return entry!
-    }
-    private _tryGetEntry(key: LookupKey | RefKey.RefKey): NodeEntry | undefined {
-        const converted = this._convert(key)
-        return this._entryMap.get(converted) ?? this._parent?._tryGetEntry(converted) ?? undefined
-    }
-
-    tryGetKind<Name extends string>(refKey: RefKey.RefKey<Name>): Kind.Identifier<Name> | undefined
-    tryGetKind<F extends Kind.Identifier>(klass: F): F
-    tryGetKind<Name extends string>(kind: Name): Kind.Identifier<Name> | undefined
-    tryGetKind(key: LookupKey): Kind.Identifier | undefined
-    tryGetKind(kindOrIdent: LookupKey | RefKey.RefKey): Kind.Identifier | undefined {
-        return this._tryGetEntry(kindOrIdent)?.ident
-    }
-
-    getKind<K extends Kind.Identifier>(kind: K): K
-    getKind<Name extends string>(kind: Name): Kind.Identifier<Name>
-    getKind(kindOrClass: LookupKey): Kind.Identifier
-    getKind(kindOrClass: string | Function): Kind.Identifier {
-        return this._getEntry(kindOrClass).ident
-    }
-
-    tryGetClass(refKey: RefKey.RefKey): Function | undefined
-    tryGetClass<F extends Function>(klass: F): F
-    tryGetClass(kind: string): Function | undefined
-    tryGetClass(ident: Kind.Identifier): Function | undefined
-    tryGetClass(kindOrIdent: LookupKey | RefKey.RefKey): Function | undefined {
-        return this._tryGetEntry(kindOrIdent)?.class
-    }
-
-    getClass(refKey: RefKey.RefKey): Function
-    getClass<F extends Function>(klass: F): F
-    getClass(kind: string): Function
-    getClass<T extends Function | string>(kindOrClass: T): T extends Function ? string : Function
-    getClass(kindOrClass: string | Function | RefKey.RefKey): Function | string {
-        return this._getEntry(kindOrClass).class
-    }
-
-    has(kindOrClass: LookupKey): boolean {
-        return this._entryMap.has(kindOrClass as any)
-    }
-}

package/src/manifest/manifest-builder.ts

@@ -1,99 +0,0 @@
-import {
-    BaseManifest,
-    ManifestIdentFields,
-    ManifestMetadata,
-    ManifestSourceEmbedder,
-    PreManifest
-} from "."
-import { Embedder } from "../_embedder/base"
-import { MetadataEntity } from "../graph/resource-node"
-
-type MaybePromise<T> = T | Promise<T>
-export namespace ManifestBuilder {
-    export interface Out {
-        body: () => MaybePromise<PreManifest>
-        metadata: () => Partial<ManifestMetadata>
-        ident: () => ManifestIdentFields
-        manifest: () => MaybePromise<BaseManifest>
-    }
-
-    export type In<Target extends MetadataEntity = MetadataEntity> = Partial<{
-        [K in keyof Out]: (self: Target) => ReturnType<Out[K]>
-    }> & {
-        body: (self: Target) => PreManifest
-    } & {
-        [key: string]: (self: Target, ...args: any[]) => any
-    }
-}
-
-class BuilderDecorator {
-    private _system = new Embedder<MetadataEntity, ManifestBuilder.In>("builder")
-
-    implement(
-        ctor: { new (...args: any[]): MetadataEntity },
-        input: ManifestBuilder.In<MetadataEntity>
-    ) {
-        this._system.set(ctor.prototype, {
-            ...input
-        })
-    }
-    private _metadata(self: MetadataEntity) {
-        return {
-            name: self.meta.get("name"),
-            namespace: self.meta.tryGet("namespace"),
-            labels: self.meta.labels,
-            annotations: self.meta.annotations
-        }
-    }
-
-    private _idents(self: MetadataEntity) {
-        return {
-            apiVersion: self.kind.parent!.text,
-            kind: self.kind.name
-        }
-    }
-
-    async manifest(trait: ManifestBuilder.Out, self: MetadataEntity) {
-        const mani = {
-            ...trait.ident(),
-            metadata: trait.metadata(),
-            ...(await trait.body())
-        }
-        ManifestSourceEmbedder.set(mani, self)
-        return mani
-    }
-
-    idents(self: MetadataEntity) {
-        return {
-            kind: self.kind.name,
-            apiVersion: self.kind.parent!.text
-        }
-    }
-    get(target: MetadataEntity): ManifestBuilder.Out {
-        const input = this._system.get(target)
-        const o: ManifestBuilder.Out = {
-            ident: () => input.ident?.call(o, target) ?? this._idents(target),
-            metadata: () => input.metadata?.call(o, target) ?? this._metadata(target),
-            body: () => input.body.call(o, target),
-            manifest: () => this.manifest(o, target) as any
-        }
-        return o
-    }
-
-    get decorator() {
-        return <Target extends new (...args: any[]) => MetadataEntity>(
-            input: ManifestBuilder.In<InstanceType<Target>>
-        ) => {
-            return (ctor: Target) => {
-                this.implement(ctor, input as any)
-                return ctor
-            }
-        }
-    }
-}
-
-export const Builder = new BuilderDecorator()
-
-export const manifest = Builder.decorator
-
-// writing the decorator itself

package/src/producer/index.ts

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

package/src/producer/producer.ts

@@ -1,18 +0,0 @@
-export type Producer<Factory extends object, Thing extends object> = Producer.Producer<
-    Factory,
-    Thing
->
-export namespace Producer {
-    export type Producer<Factory extends object, Produced extends object> = (
-        factory: Factory
-    ) => Iterable<Produced>
-
-    export function map<Factory extends object, Produced extends object, NewInput extends object>(
-        producer: Producer<Factory, Produced>,
-        projection: (input: NewInput) => Factory
-    ) {
-        return function bound_producer(input: NewInput) {
-            return producer(projection(input))
-        }
-    }
-}

package/src/ref-key/ref-key.ts

@@ -1,76 +0,0 @@
-import { hash } from "immutable"
-import { Kind } from "../api-kind"
-import { InstrumentsError } from "../error"
-export type RefKey<Kind extends string = string, Name extends string = string> = RefKey.RefKey<
-    Kind,
-    Name
->
-export namespace RefKey {
-    export function make<K extends string, Name extends string>(
-        kind: Kind.Identifier<K>,
-        name: Name
-    ): RefKey<K, Name> {
-        return new RefKey(kind, name)
-    }
-    export type Input = RefKey | RefKey["string"]
-    export type Format<Kind extends string, Name extends string> = `${Kind}/${Name}`
-    const separator = "/"
-    export interface Parsed {
-        kind: string
-        name: string
-    }
-
-    export function parse(ref: string) {
-        const result = tryParse(ref)
-        if (!result) {
-            throw new InstrumentsError(`Could not parse reference key: ${ref}`)
-        }
-        return result
-    }
-
-    export function tryParse(ref: string): 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
-        }
-    }
-    export class RefKey<K extends string = string, Name extends string = string> {
-        constructor(
-            readonly kind: Kind.Identifier<K>,
-            readonly name: Name
-        ) {}
-
-        get string(): Format<K, Name> {
-            return [this.kind.name, this.name].join(separator) as Format<K, Name>
-        }
-
-        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
-        }
-        hashCode() {
-            return hash(this.string)
-        }
-        toString() {
-            return this.string
-        }
-    }
-}

package/src/reference/forward-ref.ts

@@ -1,122 +0,0 @@
-import type { Doddle } from "doddle"
-import { hash, List } from "immutable"
-import { ProxyOperationError } from "../error"
-import { RefKey } from "../ref-key/ref-key"
-
-export type ForwardRef<T extends object> = ForwardRef.Core<T> & T
-export namespace ForwardRef {
-    export function is(x: any): boolean {
-        return "__reference_props__" in x
-    }
-    export function make<T extends object>(props: Props<T>): ForwardRef<T> {
-        const core = new Core(props)
-        return new Proxy(core, new Handler(core)) as ForwardRef<T>
-    }
-    export interface Props<Referenced extends object> {
-        readonly key: RefKey
-        readonly namespace?: string
-        readonly origin: object
-        readonly resolver: Doddle<Referenced>
-        readonly class: Function
-    }
-
-    export class Core<T extends object> {
-        #props: Props<T>
-        constructor(props: Props<T>) {
-            this.#props = props
-        }
-
-        equals(other: any) {
-            const resolved = this.#props.resolver.pull() as any
-            if (ForwardRef.is(other)) {
-                return other.equals(resolved)
-            }
-            if ("equals" in resolved) {
-                return resolved.equals(other)
-            }
-            return resolved === other
-        }
-
-        hashCode() {
-            return hash(List.of(this.#props.key, this.#props.origin))
-        }
-
-        get __reference_props__() {
-            return this.#props
-        }
-    }
-
-    class Handler<T extends object> implements ProxyHandler<T> {
-        get _props() {
-            return this._core.__reference_props__
-        }
-        constructor(private readonly _core: Core<T>) {}
-
-        get(target: T, prop: PropertyKey) {
-            const { _props, _core } = this
-            if (Reflect.has(_core, prop)) {
-                return Reflect.get(_core, prop)
-            }
-            const resource = _props.resolver.pull() as any
-            const result = Reflect.get(resource, prop)
-            if (typeof result === "function") {
-                return result.bind(resource)
-            }
-            return result
-        }
-        getPrototypeOf(target: T) {
-            const { _props } = this
-            return _props.class.prototype
-        }
-        has(target: T, prop: PropertyKey) {
-            const { _props, _core } = this
-            if (Reflect.has(_core, prop)) {
-                return true
-            }
-            const resource = _props.resolver.pull() as any
-            return Reflect.has(resource, prop)
-        }
-        getOwnPropertyDescriptor(_: T, p: string | symbol): PropertyDescriptor | undefined {
-            const { _core, _props } = this
-            const desc = Object.getOwnPropertyDescriptor(_core, p)
-            if (desc) {
-                desc.configurable = false
-                return desc
-            }
-            const resource = _props.resolver.pull() as any
-            const resourceDesc = Object.getOwnPropertyDescriptor(resource, p)
-            return resourceDesc
-        }
-        get referant() {
-            return this._core.__reference_props__.key.string
-        }
-        #createImmutableError(action: string) {
-            return new ProxyOperationError(
-                `Tried to ${action} a forward reference to ${this.referant}, but it cannot be modified.`
-            )
-        }
-
-        defineProperty(_: any, property: string | symbol, desc: PropertyDescriptor): boolean {
-            throw this.#createImmutableError(`define property ${String(property)} on`)
-        }
-        deleteProperty(_: T, p: string | symbol): boolean {
-            throw this.#createImmutableError(`delete property ${String(p)} from`)
-        }
-        preventExtensions(): boolean {
-            return true
-        }
-        isExtensible(): boolean {
-            return false
-        }
-        set(_: T, p: string | symbol): boolean {
-            throw this.#createImmutableError(`set property ${String(p)} on`)
-        }
-        ownKeys(): ArrayLike<string | symbol> {
-            const pulled = this._props.resolver.pull() as any
-            return [...Reflect.ownKeys(this._core), ...Reflect.ownKeys(pulled)]
-        }
-        setPrototypeOf(): boolean {
-            throw this.#createImmutableError(`set the prototype of`)
-        }
-    }
-}

package/src/reference/index.ts

@@ -1,3 +0,0 @@
-export { RefKey } from "../ref-key"
-export { ForwardRef } from "./forward-ref"
-export { Kinded, LiveRefable, Refable } from "./refable"

package/src/reference/refable.ts

@@ -1,12 +0,0 @@
-import type { Kind } from "../api-kind"
-
-export type Kinded<K extends Kind.IdentParent = Kind.IdentParent> = { kind: K }
-
-export type Refable<
-    Kind extends Kind.IdentParent = Kind.IdentParent,
-    Name extends string = string
-> = Kinded<Kind> & {
-    name: Name
-}
-export type LiveRefable<Object extends Kinded = Kinded, Name extends string = string> = Object &
-    Refable<Object["kind"], Name>