@k8ts/instruments 0.1.0

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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,122 @@
+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

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

package/src/reference/refable.ts

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

package/src/resources/index.ts

@@ -0,0 +1,2 @@
+export * from "./objects"
+export * from "./types"

package/src/resources/objects.ts

@@ -0,0 +1,99 @@
+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 { 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.str
+                }
+            }
+            if (value.limit) {
+                result.limits = {
+                    [key]: value.limit.str
+                }
+            }
+            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>>
+    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) {
+            throw new InstrumentsError(`No parser found for ${resource}`)
+        }
+        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)
+            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/parser.ts

@@ -0,0 +1,24 @@
+import { manySepBy, map, must } from "parjs/combinators"
+import type { UnitParser } from "../units/unit-parser"
+import type { ReqLimit } from "./types"
+
+export function createResourceParser(pUnitValue: UnitParser) {
+    return pUnitValue.parser.pipe(
+        manySepBy("--->", 2),
+        must(x => {
+            if (x.length !== 2) {
+                return {
+                    kind: "Hard",
+                    reason: "Expected exactly 2 values"
+                }
+            }
+            return true
+        }),
+        map(([a, b]) => {
+            return {
+                request: a,
+                limit: b
+            } as ReqLimit
+        })
+    )
+}

package/src/resources/types.ts

@@ -0,0 +1,23 @@
+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>
+
+export type InputReqLimitString<U extends string> = `${_limit_term<U>}--->${_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>
+    | InputReqLimitObject<Unit>
+    | InputReqLimitArray<Unit>
+export type mt_Resource_Input_Map<ResourceUnit extends mt_Resource_Unit_Map<ResourceUnit>> = {
+    [K in keyof ResourceUnit]: InputReqLimit<ResourceUnit[K]>
+}

package/src/tracing/git.ts

@@ -0,0 +1,51 @@
+import dayjs from "dayjs"
+import simpleGit from "simple-git"
+
+export interface GitTraceOptions {
+    cwd: string
+    absolute: boolean
+}
+
+export interface GitTraceProps {
+    commit: {
+        sha: string
+        message: string
+        author: string
+        date: string
+    }
+}
+export class GitTrace {
+    private constructor(readonly props: GitTraceProps) {}
+
+    get text() {
+        const hashPart = this.props.commit.sha.slice(0, 7)
+        const shortDate = dayjs(this.props.commit.date).format("YYYY-MM-DD")
+        const shortMessage = this.props.commit.message.split("\n")[0].slice(0, 20)
+        const author = this.props.commit.author
+        return `${hashPart} '${shortMessage}⋯' (${author}@${shortDate})`
+    }
+
+    static async make(options?: Partial<GitTraceOptions>) {
+        options = {
+            cwd: ".",
+            absolute: false,
+            ...options
+        }
+        const sg = simpleGit(options.cwd)
+        const isRepo = await sg.checkIsRepo()
+        if (!isRepo) {
+            return undefined
+        }
+        const l = await sg.log({
+            maxCount: 1
+        })
+        return new GitTrace({
+            commit: {
+                sha: l.latest!.hash,
+                message: l.latest!.message,
+                author: l.latest!.author_name,
+                date: l.latest!.date
+            }
+        })
+    }
+}

package/src/tracing/index.ts

@@ -0,0 +1,3 @@
+export * from "./git"
+export * from "./trace"
+export * from "./traced"

package/src/tracing/trace.ts

@@ -0,0 +1,31 @@
+import { defaults } from "lodash"
+import { relative, resolve } from "path"
+import StackTracey from "stacktracey"
+
+export interface TraceFormatOptions {
+    cwd: string
+    absolute: boolean
+}
+
+export class Trace {
+    readonly trace: StackTracey.Entry
+    constructor(trace: StackTracey) {
+        const findGoodFrame = (e: StackTracey.Entry) => {
+            return !e.native && e.file && !e.file.includes("node:")
+        }
+        this.trace = trace.filter(x => !!findGoodFrame(x)).at(0)
+    }
+
+    format(inOptions?: Partial<TraceFormatOptions>) {
+        const e = this.trace
+        const options = defaults(inOptions, {
+            cwd: ".",
+            absolute: false
+        }) as TraceFormatOptions
+        options.cwd = resolve(options.cwd)
+        const sourcePath = options.absolute ? e.file : relative(options.cwd, e.file)
+        const relativeToCwd = relative(options.cwd, sourcePath)
+        const sourceLocation = `${relativeToCwd}:${e.line}:${e.column}`
+        return sourceLocation
+    }
+}

package/src/tracing/traced.ts

@@ -0,0 +1,4 @@
+import { Embedder } from "../_embedder"
+import { Trace } from "./trace"
+
+export const TraceEmbedder = new Embedder<object, Trace>("TRACED")

package/src/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": false,
+    "outDir": "../dist",
+    "tsBuildInfoFile": "../dist/src.tsbuildinfo"
+  },
+  "include": ["**/*.ts"]
+}

package/src/units/index.ts

@@ -0,0 +1,2 @@
+export { UnitParser, UnitValue } from "./unit-parser"
+export * from "./units"

package/src/units/unit-parser.ts

@@ -0,0 +1,63 @@
+import { Set } from "immutable"
+import { int, letter, type Parjser } from "parjs"
+import { many1, map, stringify, then } from "parjs/combinators"
+import { InstrumentsError } from "../error"
+const pUnit = letter().pipe(many1(2), stringify())
+
+const pValueUnit = int().pipe(
+    then(pUnit),
+    map(arr => {
+        const [value, unit] = arr
+        return { value, unit }
+    })
+)
+export class UnitValue<Unit extends string = string> {
+    constructor(
+        readonly unit: Unit,
+        readonly value: number,
+        readonly type: string
+    ) {}
+
+    get str() {
+        return `${this.value}${this.unit}`
+    }
+
+    toString() {
+        return this.str
+    }
+}
+
+export class UnitParser<const Unit extends string = string> {
+    readonly parser: Parjser<UnitValue<Unit>>
+    constructor(
+        private readonly unitType: string,
+        private readonly _units: Set<Unit>
+    ) {
+        this.parser = pValueUnit.pipe(
+            map(({ value, unit }) => {
+                const gotType = this._units.has(unit as any)
+                if (!gotType) {
+                    throw new InstrumentsError(
+                        `Unit ${unit} is not a valid unit of type ${this.unitType}`
+                    )
+                }
+                return new UnitValue<Unit>(unit as any, value, this.unitType)
+            })
+        )
+    }
+
+    parse = (input: `${number}${Unit}`) => {
+        const pUnitValue = this.parser
+        const result = pUnitValue.parse(input)
+        if (result.kind !== "OK") {
+            throw new InstrumentsError(`Failed to parse ${this.unitType}`, {
+                more: result.trace.toString()
+            })
+        }
+        return result.value
+    }
+
+    static make<const Unit extends string>(unitType: string, units: Set<Unit>) {
+        return new UnitParser<Unit>(unitType, units)
+    }
+}

package/src/units/units.ts

@@ -0,0 +1,53 @@
+import { Set } from "immutable"
+import { UnitParser } from "./unit-parser"
+
+export type G = `${number}G`
+export const G = (n: number) => `${n}G` as G
+
+export type M = `${number}M`
+export const M = (n: number) => `${n}M` as M
+
+export type K = `${number}K`
+export const K = (n: number) => `${n}K` as K
+
+export type T = `${number}T`
+export const T = (n: number) => `${n}T` as T
+
+export type Gi = `${number}Gi`
+export const Gi = (n: number) => `${n}Gi` as Gi
+
+export type Mi = `${number}Mi`
+export const Mi = (n: number) => `${n}Mi` as Mi
+
+export type Ki = `${number}Ki`
+export const Ki = (n: number) => `${n}Ki` as Ki
+
+export type m = `${number}m`
+export const m = (n: number) => `${n}m` as m
+
+export type h = `${number}h`
+export const h = (n: number) => `${n}h` as h
+
+export type d = `${number}d`
+export const d = (n: number) => `${n * 24}h` as d
+
+export type s = `${number}s`
+export const s = (n: number) => `${n}s` as s
+
+export type ms = `${number}ms`
+export const ms = (n: number) => `${n}ms` as ms
+
+export interface UnitDefinition<Unit extends string> {}
+
+export namespace Unit {
+    export type Data = M | G | T | K | Mi | Gi | Ki
+    export type Cpu = m
+    export type Time = m | h | d | s | ms
+    export type Any = Data | Cpu | Time
+
+    export const Cpu = UnitParser.make("cpu", Set(["m"]))
+
+    export const Data = UnitParser.make("data", Set(["M", "G", "T", "K", "Mi", "Gi", "Ki"]))
+
+    export const Time = UnitParser.make("time", Set(["m", "h", "d", "s", "ms"]))
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "references": [
+    {
+      "path": "./src/tsconfig.json"
+    },
+    {
+      "path": "./test/tsconfig.json"
+    }
+  ],
+  "compilerOptions": {
+    "composite": true,
+    "noEmit": true
+  },
+  "files": []
+}