@k8ts/instruments 0.6.0 → 0.6.2

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>

package/src/resources/objects.ts

@@ -1,102 +0,0 @@
-import { Map, Set } from "immutable"
-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 { mt_Resource_Input_Map, mt_Resource_Unit_Map, ReqLimit } from "./types"
-
-export class ResourcesMap<const RM extends mt_Resource_Unit_Map<RM>> {
-    constructor(private _map: Map<string, ReqLimit>) {}
-
-    toObject() {
-        const kubernetesForm = this._map.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 mt_Resource_Unit_Map<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 = _unitMap.map(parser => parser.parser.pipe(or(questionMarkParser)))
-        this._reqLimitParsers = _unitMap.map(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__!: mt_Resource_Input_Map<RM>
-
-    parse<const R extends mt_Resource_Input_Map<RM>>(input: R): ResourcesMap<RM> {
-        const allKeys = Set([...Object.keys(input), ...this._unitParsers.keys()]).toMap()
-        const map = allKeys.map((_, key) => {
-            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 {
-                return {
-                    request: this._parseUnitValue(key as string, value.request),
-                    limit: this._parseUnitValue(key as string, value.limit)
-                }
-            }
-        })
-        return new ResourcesMap(map as Map<string, ReqLimit>)
-    }
-
-    static make<const RM extends mt_Resource_Unit_Map<RM>>(unitMap: {
-        [K in keyof RM]: UnitParser<RM[K]>
-    }) {
-        return new ResourcesSpec<RM>(Map(unitMap) as Map<string, UnitParser>)
-    }
-}

package/src/resources/types.ts

@@ -1,30 +0,0 @@
-import type { UnitValue } from "../units/unit-parser"
-export type _limit_term<Unit extends string> = `${number}${Unit}` | "?"
-
-export interface InputReqLimitObject<Unit extends string> {
-    readonly request: _limit_term<Unit>
-    readonly limit: _limit_term<Unit>
-}
-export type InputReqLimitArray<Unit extends string> = [_limit_term<Unit>, _limit_term<Unit>]
-export type mt_Resource_Unit_Map<T> = Record<keyof T, string>
-
-type spaces = "" | " " | "  "
-export type InputReqLimitString<U extends string> =
-    `${_limit_term<U>}${spaces}->${spaces}${_limit_term<U>}`
-export type InputIdenticalReqLimitString<U extends string> = `=${_limit_term<U>}`
-export interface ReqLimit<Unit extends string = string> {
-    readonly request?: UnitValue<Unit>
-    readonly limit?: UnitValue<Unit>
-}
-export type InputReqLimit<Unit extends string> =
-    | InputReqLimitString<Unit>
-    | InputIdenticalReqLimitString<Unit>
-    | InputReqLimitObject<Unit>
-    | InputReqLimitArray<Unit>
-type CustomResource = `${string}/${string}`
-
-export type mt_Resource_Input_Map<ResourceUnit extends mt_Resource_Unit_Map<ResourceUnit>> = {
-    [K in keyof ResourceUnit]: InputReqLimit<ResourceUnit[K]>
-} & {
-    [K in CustomResource]?: InputReqLimit<string>
-}

package/src/types.ts

@@ -1,13 +0,0 @@
-export type BuiltIn =
-    | Function
-    | Error
-    | Date
-    | {
-          readonly [Symbol.toStringTag]: string
-      }
-    | RegExp
-    | Generator
-
-export type WritableDeep<O> = {
-    -readonly [K in keyof O]: O[K] extends BuiltIn ? O[K] : WritableDeep<O[K]>
-}