@k8ts/instruments 0.2.1 → 0.4.1

package/dist/tracing/git.js

@@ -7,6 +7,7 @@ exports.GitTrace = void 0;
 const dayjs_1 = __importDefault(require("dayjs"));
 const simple_git_1 = __importDefault(require("simple-git"));
 class GitTrace {
+    props;
     constructor(props) {
         this.props = props;
     }
@@ -42,4 +43,3 @@ class GitTrace {
     }
 }
 exports.GitTrace = GitTrace;
-//# sourceMappingURL=git.js.map

package/dist/tracing/index.js

@@ -17,4 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./git"), exports);
 __exportStar(require("./trace"), exports);
 __exportStar(require("./traced"), exports);
-//# sourceMappingURL=index.js.map

package/dist/tracing/trace.js

@@ -4,6 +4,7 @@ exports.Trace = void 0;
 const lodash_1 = require("lodash");
 const path_1 = require("path");
 class Trace {
+    trace;
     constructor(trace) {
         const findGoodFrame = (e) => {
             return !e.native && e.file && !e.file.includes("node:");
@@ -24,4 +25,3 @@ class Trace {
     }
 }
 exports.Trace = Trace;
-//# sourceMappingURL=trace.js.map

package/dist/tracing/traced.js

@@ -3,4 +3,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraceEmbedder = void 0;
 const _embedder_1 = require("../_embedder");
 exports.TraceEmbedder = new _embedder_1.Embedder("TRACED");
-//# sourceMappingURL=traced.js.map

package/dist/units/index.js

@@ -19,4 +19,3 @@ var unit_parser_1 = require("./unit-parser");
 Object.defineProperty(exports, "UnitParser", { enumerable: true, get: function () { return unit_parser_1.UnitParser; } });
 Object.defineProperty(exports, "UnitValue", { enumerable: true, get: function () { return unit_parser_1.UnitValue; } });
 __exportStar(require("./units"), exports);
-//# sourceMappingURL=index.js.map

package/dist/units/unit-parser.js

@@ -10,6 +10,9 @@ const pValueUnit = (0, parjs_1.int)().pipe((0, combinators_1.then)(pUnit), (0, c
     return { value, unit };
 }));
 class UnitValue {
+    unit;
+    value;
+    type;
     constructor(unit, value, type) {
         this.unit = unit;
         this.value = value;
@@ -24,19 +27,12 @@ class UnitValue {
 }
 exports.UnitValue = UnitValue;
 class UnitParser {
+    unitType;
+    _units;
+    parser;
     constructor(unitType, _units) {
         this.unitType = unitType;
         this._units = _units;
-        this.parse = (input) => {
-            const pUnitValue = this.parser;
-            const result = pUnitValue.parse(input);
-            if (result.kind !== "OK") {
-                throw new error_1.InstrumentsError(`Failed to parse ${this.unitType}`, {
-                    more: result.trace.toString()
-                });
-            }
-            return result.value;
-        };
         this.parser = pValueUnit.pipe((0, combinators_1.map)(({ value, unit }) => {
             const gotType = this._units.has(unit);
             if (!gotType) {
@@ -45,9 +41,18 @@ class UnitParser {
             return new UnitValue(unit, value, this.unitType);
         }));
     }
+    parse = (input) => {
+        const pUnitValue = this.parser;
+        const result = pUnitValue.parse(input);
+        if (result.kind !== "OK") {
+            throw new error_1.InstrumentsError(`Failed to parse ${this.unitType}`, {
+                more: result.trace.toString()
+            });
+        }
+        return result.value;
+    };
     static make(unitType, units) {
         return new UnitParser(unitType, units);
     }
 }
 exports.UnitParser = UnitParser;
-//# sourceMappingURL=unit-parser.js.map

package/dist/units/units.js

@@ -33,4 +33,3 @@ var Unit;
     Unit.Data = unit_parser_1.UnitParser.make("data", (0, immutable_1.Set)(["M", "G", "T", "K", "Mi", "Gi", "Ki"]));
     Unit.Time = unit_parser_1.UnitParser.make("time", (0, immutable_1.Set)(["m", "h", "d", "s", "ms"]));
 })(Unit || (exports.Unit = Unit = {}));
-//# sourceMappingURL=units.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k8ts/instruments",
-  "version": "0.2.1",
+  "version": "0.4.1",
   "description": "A collection of utilities and core components for k8ts.",
   "keywords": [
     "kubernetes",
@@ -54,7 +54,6 @@
     "test:coverage": "jest --coverage"
   },
   "dependencies": {
-    "@k8ts/metadata": "^0.2.1",
     "chalk": "4.1.2",
     "dayjs": "^1.11.13",
     "doddle": "^5.0.0-beta.16",
@@ -65,6 +64,7 @@
     "stacktracey": "^2.1.8"
   },
   "devDependencies": {
+    "@k8ts/metadata": "^0.4.1",
     "@swc/core": "^1.11.11",
     "@swc/jest": "^0.2.37",
     "@types/jest": "^29.5.12",
@@ -80,7 +80,7 @@
     "yamprint": "^0.8.4"
   },
   "peerDependencies": {
-    "@k8ts/metadata": "^0.1.0"
+    "@k8ts/metadata": "^0.4.1"
   },
   "packageManager": "yarn@4.1.1",
   "engines": {

package/src/_embedder/base.ts

@@ -34,7 +34,7 @@ export class Embedder<Target extends object, Value> {
         const input = this.tryGet(target)
         if (!input) {
             throw new Error(
-                `Target of type ${target.constructor.name} doesn't have any embedded data for ${this.name}!`
+                `Target of type ${target} doesn't have any embedded data for ${this.name}!`
             )
         }
         return input

package/src/_string/markers.ts

@@ -30,18 +30,37 @@ const interchangeable = {
     mac_char: "⌘ "
 }
 
-const colors = [chalk.red, chalk.green, chalk.yellow, chalk.blue, chalk.magenta, chalk.cyan]
+const colors = [
+    chalk.redBright,
+    chalk.yellowBright,
+    chalk.blue,
+    chalk.magenta,
+    chalk.cyan,
+    chalk.blueBright
+]
 
 const numbered = Object.values(interchangeable)
 
-export function getMarkerForIndex(index: number, alias: string) {
-    const clamedIndex = index % numbered.length
+// We want to have symbols be as distinct as possible
+// that means we use each symbol with a different color
+
+// Instead of using all symbols of a single color, then all symbols of another color
+// We mix it up, so we only get repeat colors after all symbols have been used
+
+// we can get combinations of color + symbol like this:
+// symbol = i % symbols.length
+// color = (Math.floor(i / colors.length) + i)
+
+export function getMarkerForIndex(index: number) {
+    const clampedIndex = index % numbered.length
     const multiplier = Math.floor(index / numbered.length)
-    const char = numbered[clamedIndex]
-    const color = colors[multiplier % colors.length]
-    const marker = [char, alias].join(" ")
-    const colored = color(marker)
-    return colored
+    const char = numbered[clampedIndex]
+    const color = colors[(multiplier + clampedIndex) % colors.length]
+    const colored = color(char)
+    return `${colored} `
 }
 
-export const external = "∃"
+export function getMarkerForExternal() {
+    const external = "∃"
+    return chalk.yellowBright(external)
+}

package/src/data-sources/index.ts

@@ -0,0 +1,126 @@
+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/graph/base-node.ts

@@ -3,7 +3,7 @@ import { hash, Set } from "immutable"
 import { Kind } from "../api-kind"
 import { RefKey } from "../ref-key"
 import { ForwardRef } from "../reference"
-import { NeedsEdge } from "./dependencies"
+import { Relation } from "./dependencies"
 
 export interface BaseEntity<Node extends BaseNode<Node>> {
     readonly node: Node
@@ -17,13 +17,14 @@ 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 needs: Seq<NeedsEdge<Node>>
+    abstract readonly relations: Seq<Relation<Node>>
     abstract readonly parent: Node | null
     protected get _asNode() {
         return this as any as Node
@@ -41,11 +42,11 @@ export abstract class BaseNode<
         return this.key.name
     }
     get isRoot() {
-        return this.parent === null
+        return this.parent === null && this._entity.kind.name !== "PodTemplate"
     }
 
     hashCode() {
-        return hash(this)
+        return hash(this._eqProxy)
     }
     equals(other: any) {
         if (ForwardRef.is(other)) {
@@ -97,25 +98,34 @@ export abstract class BaseNode<
         return this.equals(other) || Set(this.ancestors).has(other._asNode)
     }
 
-    isNeeding(other: Node): boolean {
-        return this.needsGraph.some(x => x.needed.equals(other)).pull()
+    hasRelationTo(other: Node): boolean {
+        return this.recursiveRelations.some(x => x.needed.equals(other)).pull()
     }
 
-    readonly needsGraph = seq(() => {
+    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: NeedsEdge<Node>): Iterable<NeedsEdge<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.needs
+            const ownDeps = root.needed.relations
             for (const needsEdge of ownDeps) {
                 yield* recurseIntoDependency(needsEdge)
             }
         }
-        return seq(recurseIntoDependency.bind(null, new NeedsEdge<Node>("self", this._asNode)))
+        return seq(recurseIntoDependency.bind(null, new Relation<Node>("self", this._asNode)))
             .after(() => {
                 resources = Set()
             })

package/src/graph/dependencies.ts

@@ -9,7 +9,7 @@ export namespace Dependencies {
 }
 export function dependencies(record: Dependencies.Input) {
     return Object.entries(record).map(([key, value]) => {
-        return new NeedsEdge(key, value.node)
+        return new Relation(key, value.node)
     })
 }
 @displayers({
@@ -19,7 +19,7 @@ export function dependencies(record: Dependencies.Input) {
         return [`${chalk.gray.italic.white(`${dep.why}`)}`, "➜ ", chalk.italic(`${neededFmt}`)]
     }
 })
-export class NeedsEdge<Node extends BaseNode<Node>> {
+export class Relation<Node extends BaseNode<Node>> {
     constructor(
         readonly why: string,
         readonly needed: Node

package/src/graph/origin-node.ts

@@ -2,7 +2,7 @@ import { Meta } from "@k8ts/metadata"
 import chalk from "chalk"
 import { doddle, seq, Seq } from "doddle"
 import StackTracey from "stacktracey"
-import { getMarkerForIndex, toSuperScript } from "../_string"
+import { getMarkerForExternal, getMarkerForIndex } from "../_string"
 import { displayers } from "../displayers"
 import { KindMap } from "../kind-map"
 import { RefKey } from "../ref-key"
@@ -14,16 +14,16 @@ import { ResourceNode } from "./resource-node"
     simple: s => `[${s.shortFqn}]`,
     prefix: s => {
         if (s.name === "EXTERNAL") {
-            return "🌐"
+            return getMarkerForExternal()
         }
-        return getMarkerForIndex(s.index, s._entity.alias ?? toSuperScript(s.index))
+        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 `${kindName}:${resourceName} (${pref})`
+        return chalk.underline(`${pref}${kindName}:${resourceName}`)
     }
 })
 export class Origin extends BaseNode<Origin, OriginEntity> implements Iterable<ResourceNode> {
@@ -54,7 +54,7 @@ export class Origin extends BaseNode<Origin, OriginEntity> implements Iterable<R
     private _kindMap: KindMap
     private _attached = [] as ResourceNode[]
 
-    get needs() {
+    get relations() {
         return seq.empty()
     }
     [Symbol.iterator]() {

package/src/graph/relations.ts

@@ -1,10 +1,10 @@
 import { Embedder } from "../_embedder/base"
-import { Dependencies, dependencies, NeedsEdge } from "./dependencies"
+import { Dependencies, dependencies, Relation } from "./dependencies"
 import { ResourceEntity, ResourceNode } from "./resource-node"
 
 export namespace Relations {
     export interface Out {
-        needs: () => Iterable<NeedsEdge<ResourceNode>>
+        needs: () => Iterable<Relation<ResourceNode>>
         parent: () => ResourceNode | null
         kids: () => ResourceNode[]
     }

package/src/graph/resource-node.ts

@@ -19,18 +19,18 @@ import { Relations } from "./relations"
         }
         const resourceName = chalk.blueBright(resource.name)
         const mainPart = `${kindName}/${resourceName}`
-        let originPart = ` (${displayers.get(resource.origin).prefix!()})`
+        let originPart = `${displayers.get(resource.origin).prefix!()}`
         let text = ""
 
         text += mainPart
         if (format !== "local") {
-            text += originPart
+            text = `${originPart}${text}`
         }
         return text
     }
 })
 export class ResourceNode extends BaseNode<ResourceNode, ResourceEntity> {
-    get needs() {
+    get relations() {
         return seq(this._relations.needs)
     }
 

package/src/image/family.ts

@@ -1,67 +1,83 @@
+import { displayers } from "../displayers"
+
 export type JoinIfNotEmpty<A extends string, J extends string, B extends string> = A extends ""
     ? B
     : B extends ""
       ? A
       : `${A}${J}${B}`
+@displayers({
+    simple: s => s._url
+})
 export class ImageHost<Text extends string = string> {
     private readonly _url: Text
     constructor(source: Text) {
         this._url = source
-        this.toString = () => this[Symbol.toStringTag]
+    }
+
+    author<Author extends string>(name: Author) {
+        return new ImageAuthor<JoinIfNotEmpty<Text, "/", Author>>(this.toString(), name)
     }
 
     image<Image extends string>(name: Image) {
-        return new BaseImage<JoinIfNotEmpty<Text, "/", Image>>(this, name)
+        return new BaseImage<JoinIfNotEmpty<Text, "/", Image>>(this.toString(), name)
     }
 
     get [Symbol.toStringTag]() {
         return this._url
     }
 }
+@displayers({
+    simple: s => s._url
+})
+export class ImageAuthor<Text extends string = string> {
+    private readonly _url: Text
+    constructor(base: string, name: string) {
+        this._url = base === "" ? (name as Text) : ([base, name].join("/") as Text)
+    }
 
+    image<Image extends string>(name: Image) {
+        return new BaseImage<JoinIfNotEmpty<Text, "/", Image>>(this.toString(), name)
+    }
+}
+@displayers({
+    simple: s => {
+        if (!s._base) {
+            return s._name
+        }
+        return [s._base, s._name].join("/")
+    }
+})
 export class BaseImage<Text extends string = string> {
     constructor(
-        private readonly _source: ImageHost,
+        private readonly _base: string,
         private readonly _name: string
-    ) {
-        this.toString = () => this[Symbol.toStringTag]
-    }
+    ) {}
 
     tag<Tag extends string>(tag: Tag) {
         return new TaggedImage<JoinIfNotEmpty<Text, ":", Tag>>(this, tag)
     }
-
-    get [Symbol.toStringTag]() {
-        if (this._source[Symbol.toStringTag] === "") {
-            return this._name
+}
+@displayers({
+    simple: s => {
+        const fam = s._family.toString()
+        if (s._tag === "") {
+            return fam
         }
-        return [this._source, this._name].join("/")
+        return [fam, s._tag].join(":")
     }
-}
-
+})
 export class TaggedImage<Text extends string = string> {
     constructor(
         private readonly _family: BaseImage<string>,
         private readonly _tag: string
-    ) {
-        this.toString = () => this.text
-    }
-
-    get text() {
-        const fam = this._family[Symbol.toStringTag]
-        if (this._tag === "") {
-            return fam
-        }
-        return [fam, this._tag].join(":")
-    }
-
-    get [Symbol.toStringTag]() {
-        return this.text
-    }
+    ) {}
 }
 
 export namespace Image {
-    export function name<Name extends string>(name: Name) {
+    export function author<Author extends string>(name: Author) {
+        return new ImageHost("").author(name)
+    }
+    export function name<Name extends `${string}/${string}`>(name: Name) {
         return new ImageHost("").image(name)
     }
 

package/src/index.ts

@@ -2,6 +2,7 @@ export * from "./_embedder"
 export * from "./_string"
 export * from "./api-kind"
 export * from "./cmd"
+export * from "./data-sources"
 export * from "./displayers"
 export * from "./env"
 export * from "./forward-exports"

package/src/manifest/manifest-builder.ts

@@ -8,12 +8,13 @@ import {
 import { Embedder } from "../_embedder/base"
 import { MetadataEntity } from "../graph/resource-node"
 
+type MaybePromise<T> = T | Promise<T>
 export namespace ManifestBuilder {
     export interface Out {
-        body: () => PreManifest
-        metadata: () => ManifestMetadata
+        body: () => MaybePromise<PreManifest>
+        metadata: () => Partial<ManifestMetadata>
         ident: () => ManifestIdentFields
-        manifest: () => BaseManifest
+        manifest: () => MaybePromise<BaseManifest>
     }
 
     export type In<Target extends MetadataEntity = MetadataEntity> = Partial<{
@@ -52,11 +53,11 @@ class BuilderDecorator {
         }
     }
 
-    manifest(trait: ManifestBuilder.Out, self: MetadataEntity) {
+    async manifest(trait: ManifestBuilder.Out, self: MetadataEntity) {
         const mani = {
             ...trait.ident(),
             metadata: trait.metadata(),
-            ...trait.body()
+            ...(await trait.body())
         }
         ManifestSourceEmbedder.set(mani, self)
         return mani