@k8ts/instruments 0.2.1 → 0.4.0

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

@@ -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

@@ -30,7 +30,7 @@ import { Relations } from "./relations"
     }
 })
 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

package/src/ports/set.ts

@@ -28,8 +28,11 @@ export class PortSet<Names extends string = never> {
         protocol: InputProtocol
     ): PortSet<Names | Name>
     add<Name extends string>(name: Name, entry: InputPortSetEntry): PortSet<Names | Name>
-    add<InNames extends string>(input: InputPortSetRecord<InNames>): PortSet<Names | InNames>
+    add<InNames extends string>(input?: InputPortSetRecord<InNames>): PortSet<Names | InNames>
     add(a: any, b?: any, c?: any): any {
+        if (!a) {
+            return this
+        }
         if (c) {
             return this._apply(map => map.set(a, { name: a, port: +b, protocol: c.toUpperCase() }))
         }
@@ -63,17 +66,28 @@ export class PortSet<Names extends string = never> {
                 if (!(entry.name in mapping)) {
                     throw new PortError(`Port ${entry.name} not found in mapping`)
                 }
+                const portIn = mapping[entry.name as keyof typeof mapping]
+                let portVal: number
+                if (typeof portIn === "boolean") {
+                    portVal = entry.port
+                } else if (typeof portIn === "number") {
+                    portVal = portIn
+                } else {
+                    throw new PortError(
+                        `Port ${entry.name} mapping value must be a number or boolean`
+                    )
+                }
                 return {
                     name: entry.name,
                     protocol: entry.protocol,
                     source: entry.port,
-                    target: mapping[entry.name as keyof typeof mapping]
+                    target: portVal as any
                 }
             })
         )
     }
 
-    static make<Names extends string>(input: InputPortSetRecord<Names>) {
+    static make<Names extends string>(input?: InputPortSetRecord<Names>) {
         return new PortSet().add(input)
     }
 }

package/src/ports/types.ts

@@ -37,6 +37,8 @@ export interface InputPortMapEntry {
 export type InputPortSetRecord<Names extends string = string> = {
     [K in Names]: InputPortSetSpec
 }
-export type InputPortMapping<Names extends string = string> = {
-    [K in Names]: number
-}
+export type InputPortMapping<Names extends string = string> = [Names] extends [never]
+    ? never
+    : {
+          [K in Names]: number | true
+      }