@k8ts/instruments 0.6.2 → 0.9.0

package/src/core/graph/resource/node.ts

@@ -20,8 +20,12 @@ import { RefKey } from "./ref-key"
         if (format !== "lowkey") {
             kindName = chalk.bold(kindName)
         }
-        const resourceName = chalk.blueBright(resource.name)
-        const mainPart = `${kindName}/${resourceName}`
+        const parts = [kindName]
+        if (resource.namespace) {
+            parts.push(chalk.yellowBright(resource.namespace))
+        }
+        parts.push(chalk.blueBright(resource.name))
+        const mainPart = parts.join("/")
         let originPart = `${Displayers.get(resource.origin).prefix!()}`
         let text = ""
 
@@ -40,7 +44,10 @@ export class Resource_Node extends Node<Resource_Node, Resource_Entity> {
         return [this.kind.dns, this.namespace, this.name].filter(Boolean).join("/")
     }
     get key(): RefKey {
-        return new RefKey(this.kind, this.name)
+        return new RefKey(this.kind, {
+            name: this.name,
+            namespace: this.namespace
+        })
     }
     get kind() {
         return this.entity.kind
@@ -63,7 +70,7 @@ export class Resource_Node extends Node<Resource_Node, Resource_Entity> {
     }
 
     get isExternal() {
-        return this.origins.some(x => x.name === "EXTERNAL").pull()
+        return this.meta?.tryGet("#k8ts.org/is-external") ?? false
     }
 
     when<EntityType extends Resource_Entity>(
@@ -97,6 +104,10 @@ export class Resource_Node extends Node<Resource_Node, Resource_Entity> {
         })
     }
 
+    get disabled() {
+        return "disabled" in this.entity ? !!this.entity.disabled : false
+    }
+
     get shortFqn() {
         return `${this.origin.name}:${this.key}`
     }

package/src/core/graph/resource/ref-key/ref-key.ts

@@ -1,5 +1,7 @@
+import type { Ref2_Of } from ".."
 import { InstrumentsError } from "../../../../error"
 import type { Kind } from "../api-kind"
+import { External_Base, type External_Props, type External_WithFeatures } from "../external"
 
 export type RefKey_Input = RefKey | RefKey["string"]
 export type RefKey_sFormat<Kind extends string, Name extends string> = `${Kind}/${Name}`
@@ -36,14 +38,30 @@ export function tryParse(ref: string): RefKey_Parsed | undefined {
         name
     }
 }
+
+type nsKind = Kind<"", "v1", "Namespace">
+
+export interface RefKey_Options<Name extends string = string> {
+    name: Name
+    namespace?: RefKey<nsKind> | string | Ref2_Of<nsKind>
+}
+
 export class RefKey<K extends Kind.IdentParent = Kind.IdentParent, Name extends string = string> {
+    readonly name: string
+    readonly namespace: string | undefined
     constructor(
         readonly kind: K,
-        readonly name: Name
-    ) {}
+        options: RefKey_Options<Name>
+    ) {
+        this.name = options.name
+        this.namespace =
+            typeof options.namespace === "string" ? options.namespace : options.namespace?.name
+    }
 
     get string(): RefKey_sFormat<K["name"], Name> {
-        return [this.kind.name, this.name].join(separator) as RefKey_sFormat<K["name"], Name>
+        return [this.kind.name, this.namespace, this.name]
+            .filter(x => !!x)
+            .join(separator) as RefKey_sFormat<K["name"], Name>
     }
 
     equals(other: RefKey): boolean {
@@ -53,10 +71,20 @@ export class RefKey<K extends Kind.IdentParent = Kind.IdentParent, Name extends
         if (typeof other !== "object") {
             return false
         }
-        return this.kind.equals(other.kind) && this.name === other.name
+        return (
+            this.kind.equals(other.kind) &&
+            this.name === other.name &&
+            this.namespace === other.namespace
+        )
     }
 
     toString() {
         return this.string
     }
+
+    External<const P extends External_Props<K> = External_Props<K>>(
+        options?: P
+    ): External_WithFeatures<K, P> {
+        return new External_Base(this, options ?? {}) as any
+    }
 }

package/src/core/graph/resource/reference/fw-ref-exports.ts

@@ -1,19 +1,19 @@
 import { seq } from "doddle"
-import type { Resource_Core_Ref } from "."
+import type { Ref2_Of } from "."
 import { FwReference } from "."
 import type { Origin_Exporter } from "../../origin"
 import { ProxyOperationError } from "./error"
 
-export type FwRef_Exports_ByKey<Exports extends Resource_Core_Ref = Resource_Core_Ref> = {
+export type FwRef_Exports_ByKey<Exports extends Ref2_Of = Ref2_Of> = {
     [E in Exports as `${E["kind"]["name"]}/${E["name"]}`]: FwReference<E>
 }
 
-export type FwRef_Exports<Exported extends Resource_Core_Ref = Resource_Core_Ref> =
-    FxRef_Exports_Proxied & FwRef_Exports_ByKey<Exported>
+export type FwRef_Exports<Exported extends Ref2_Of = Ref2_Of> = FxRef_Exports_Proxied &
+    FwRef_Exports_ByKey<Exported>
 
 export type FwRef_Exports_Brand = FxRef_Exports_Proxied
 
-export function FwRef_Exports<Exported extends Resource_Core_Ref>(
+export function FwRef_Exports<Exported extends Ref2_Of>(
     entity: Origin_Exporter
 ): FwRef_Exports<Exported> {
     const proxied = new FxRef_Exports_Proxied(entity)

package/src/core/graph/resource/reference/fw-ref.ts

@@ -2,11 +2,10 @@ import type { Doddle } from "doddle"
 import type { AnyCtor } from "what-are-you"
 import type { RefKey } from "../ref-key"
 import { ProxyOperationError } from "./error"
-import type { Resource_Core_Ref } from "./refable"
+import type { Ref2_Of } from "./refable"
 
-export type FwReference<T extends Resource_Core_Ref = Resource_Core_Ref> = FwReference_Proxied<T> &
-    T
-export function FwReference<Referenced extends Resource_Core_Ref>(
+export type FwReference<T extends Ref2_Of = Ref2_Of> = FwReference_Proxied<T> & T
+export function FwReference<Referenced extends Ref2_Of>(
     props: FwReference_Props<Referenced>
 ): FwReference<Referenced> {
     const core = new FwReference_Proxied(props)
@@ -17,7 +16,7 @@ export namespace FwReference {
         return FwReference_Proxied.is(obj)
     }
 }
-export interface FwReference_Props<Referenced extends Resource_Core_Ref> {
+export interface FwReference_Props<Referenced extends Ref2_Of> {
     readonly class?: AnyCtor<Referenced>
     readonly key: RefKey
     readonly namespace?: string
@@ -25,7 +24,7 @@ export interface FwReference_Props<Referenced extends Resource_Core_Ref> {
     readonly resolver: Doddle<Referenced>
 }
 
-class FwReference_Proxied<To extends Resource_Core_Ref> {
+class FwReference_Proxied<To extends Ref2_Of> {
     readonly #props: FwReference_Props<To>
     constructor(props: FwReference_Props<To>) {
         this.#props = props
@@ -44,7 +43,7 @@ class FwReference_Proxied<To extends Resource_Core_Ref> {
     }
 }
 
-class FwRef_Handler<T extends Resource_Core_Ref> implements ProxyHandler<T> {
+class FwRef_Handler<T extends Ref2_Of> implements ProxyHandler<T> {
     get _props() {
         return this._subject["__reference_props__"]()
     }

package/src/core/graph/resource/reference/index.ts

@@ -1,8 +1,3 @@
 export { FwReference } from "./fw-ref"
 export { FwRef_Exports, type FwRef_Exports_Brand } from "./fw-ref-exports"
-export type {
-    Resource_Core_Ref,
-    Resource_Ctor_Of,
-    Resource_Full_Ref,
-    Resource_Min_Ref
-} from "./refable"
+export type * from "./refable"

package/src/core/graph/resource/reference/refable.ts

@@ -3,22 +3,29 @@ import type { Kind } from "../api-kind"
 import type { Resource_Entity } from "../entity"
 import type { Resource_Node } from "../node"
 
-export type Resource_Min_Ref<K extends Kind.IdentParent = Kind.IdentParent> = { kind: K }
+export type Resource_Ref_Min<K extends Kind.IdentParent = Kind.IdentParent> = { kind: K }
 export type Resource_Ctor_Of<K extends Kind.IdentParent = Kind.IdentParent> = AnyCtor<
-    Resource_Core_Ref<K>
+    Ref2_Of<K>
 > & {
-    prototype: Resource_Core_Ref<K>
+    prototype: Ref2_Of<K>
 }
-export type Resource_Core_Ref<
+export type Ref2_Of<
     Kind extends Kind.IdentParent = Kind.IdentParent,
     Name extends string = string
-> = Resource_Min_Ref<Kind> & {
+> = Resource_Ref_Min<Kind> & {
     name: Name
     equals(other: any): boolean
     node: Resource_Node
 }
-
-export type Resource_Full_Ref<
+export type Resource_Ref_Full<
     _Kind extends Kind.IdentParent = Kind.IdentParent,
     _Name extends string = string
-> = Resource_Core_Ref<_Kind, _Name> & Resource_Entity<_Name>
+> = Ref2_Of<_Kind, _Name> & Resource_Entity<_Name>
+
+export type Resource_Ref_Keys_Of<X extends Resource_Ref_Min, Else = never> = [X] extends [
+    {
+        keys: (infer K extends string)[]
+    }
+]
+    ? K
+    : Else

package/src/core/graph/resource/top.ts

@@ -10,10 +10,20 @@ export abstract class Resource_Top<
     Name extends string = string,
     Props extends object = object
 > extends Resource_Entity<Name, Props> {
-    readonly _origin: Origin_Entity
+    private readonly _origin: Origin_Entity
     readonly meta: Meta
     abstract readonly kind: Kind.IdentParent
 
+    get disabled() {
+        return this.meta.tryGet("#k8ts.org/disabled", "") !== ""
+    }
+    set disabled(v: boolean) {
+        if (!v) {
+            this.meta.delete("#k8ts.org/disabled")
+        } else {
+            this.meta.add("#k8ts.org/disabled", "true")
+        }
+    }
     constructor(name: Name, props: Props) {
         super(name, props)
         this.meta = Meta.make({

package/src/expressions/data-sources/base.ts

@@ -0,0 +1,14 @@
+import { doddle, type DoddleAsync } from "doddle"
+
+export declare const DATA_SOURCE: unique symbol
+
+export class DataSource_Lazy<T = any> {
+    private readonly _data: DoddleAsync<T>
+    constructor(getter: () => T | Promise<T>) {
+        this._data = doddle(async () => getter())
+    }
+
+    get() {
+        return this._data.pull()
+    }
+}

package/src/expressions/data-sources/env-var.ts

@@ -0,0 +1,17 @@
+import { DataSource_Lazy } from "./base"
+
+export class DataSource_EnvVar extends DataSource_Lazy<string> {
+    constructor(public readonly name: string) {
+        super(async () => {
+            const value = process.env[this.name]
+            if (value === undefined) {
+                throw new Error(`Environment variable "${this.name}" is not set`)
+            }
+            return value
+        })
+    }
+}
+
+export function localRefEnvVar(name: string) {
+    return new DataSource_EnvVar(name)
+}

package/src/expressions/data-sources/index.ts

@@ -1,147 +1,4 @@
-import { doddle, DoddleAsync, seq, type Doddle } from "doddle"
-import { readFile } from "fs/promises"
-import { dirname, join, resolve } from "path"
-import StackTracey from "stacktracey"
-import { InstrumentsError } from "../../error"
-export type DataSource_LocalFile_Mode = "text" | "binary"
-
-export interface DataSource_LocalFile_Props<Mode extends DataSource_LocalFile_Mode = "text"> {
-    pointOfCall: StackTracey
-    path: string
-    cwd?: string
-    mode?: Mode
-}
-export class DataSource_LocalFile<Mode extends DataSource_LocalFile_Mode = "text"> {
-    constructor(private readonly _props: DataSource_LocalFile_Props<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 DataSource_LocalFile_Mode = "text">(
-    path: string,
-    props?: Pick<DataSource_LocalFile_Props<Mode>, "cwd" | "mode">
-): DataSource_LocalFile<Mode>
-export function localFile(
-    args: TemplateStringsArray,
-    ...params: any[]
-): DataSource_LocalFile<"text">
-export function localFile(args: any, ...params: any[]) {
-    if (typeof args === "string") {
-        const options = params[0] ?? {}
-        return new DataSource_LocalFile({
-            pointOfCall: new StackTracey().slice(1),
-            path: args,
-            ...(options ?? {})
-        })
-    }
-    const path = String.raw(args, ...params)
-    return new DataSource_LocalFile({
-        pointOfCall: new StackTracey().slice(1),
-        path
-    })
-}
-
-export interface TypedArrayLike {
-    buffer: ArrayBuffer
-    byteLength: number
-}
-export type DataSource_Text = DataSource_LocalFile<"text"> | string
-export type DataSource_Binary = DataSource_LocalFile<"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, Doddle<MaybePromise<V>>>): Promise<Map<K, V>> {
-    const promises = seq(m)
-        .map(async x => [x[0], await x[1].pull()] as [K, V])
-        .toArray()
-        .pull()
-    const res = await Promise.all(promises)
-    return new Map(res)
-}
-export async function resolveText(record: DataSourceRecord_Text) {
-    const mp = seq(Object.entries(record))
-        .map(([k, v]) => {
-            return [
-                k,
-                doddle(async () => {
-                    let resolved = v
-                    if (v instanceof DataSource_LocalFile) {
-                        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
-                })
-            ] as const
-        })
-        .toMap(x => x)
-        .pull()
-    return promiseAllMap(mp)
-}
-export async function resolveBinary(record: DataSourceRecord_Binary) {
-    const mp = seq(Object.entries(record))
-        .map(([k, v]) => {
-            return [
-                k,
-                doddle(async () => {
-                    let resolved = v as any
-                    if (v instanceof DataSource_LocalFile) {
-                        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.`
-                        )
-                    }
-                })
-            ] as const
-        })
-        .toMap(x => x)
-        .pull()
-
-    return promiseAllMap(mp)
-}
+export * from "./base"
+export * from "./env-var"
+export * from "./interface"
+export * from "./local-file"

package/src/expressions/data-sources/interface.ts

@@ -0,0 +1,13 @@
+export type DataSource_Type_Name = "string" | "binary"
+export type DataSource_Value<Name extends DataSource_Type_Name> = Name extends "string"
+    ? string
+    : Name extends "binary"
+      ? Uint8Array
+      : DataSource_Type_Name
+export interface DataSource_Object<TypeName extends DataSource_Type_Name = DataSource_Type_Name> {
+    get(): DataSource_Value<TypeName> | Promise<DataSource_Value<TypeName>>
+}
+
+export type DataSource<Only extends DataSource_Type_Name = DataSource_Type_Name> =
+    | DataSource_Object<Only>
+    | DataSource_Value<Only>

package/src/expressions/data-sources/local-file.ts

@@ -0,0 +1,49 @@
+import Path from "pathlib-js"
+import StackTracey from "stacktracey"
+import type { TypedArray } from "what-are-you"
+import { DataSource_Lazy } from "./base"
+export type DataSource_Allowed = string | Uint8Array | TypedArray
+export class DataSource_LocalFile_Path {
+    readonly path: Path
+    constructor(
+        private readonly _cwd: Path,
+        relPath: string
+    ) {
+        this.path = this._cwd.join(relPath)
+    }
+
+    as(mode: "text", encoding?: BufferEncoding): DataSource_Lazy<string>
+    as(mode: "binary"): DataSource_Lazy<Uint8Array>
+    as(mode: "text" | "binary", encoding?: BufferEncoding): DataSource_Lazy {
+        if (mode === "text") {
+            return new DataSource_LocalFile_Text(this, encoding)
+        } else {
+            return new DataSource_LocalFile_Binary(this)
+        }
+    }
+}
+class DataSource_LocalFile_Text extends DataSource_Lazy<string> {
+    constructor(
+        private readonly _parent: DataSource_LocalFile_Path,
+        readonly encoding: BufferEncoding = "utf-8"
+    ) {
+        super(async () => {
+            return this._parent.path.readFile(this.encoding)
+        })
+    }
+}
+
+class DataSource_LocalFile_Binary extends DataSource_Lazy<Uint8Array> {
+    constructor(private readonly _parent: DataSource_LocalFile_Path) {
+        super(async () => {
+            const x = await this._parent.path.readFile()
+            return new Uint8Array(x)
+        })
+    }
+}
+
+export function localRefFile(path: string) {
+    const trace = new StackTracey().slice(1)
+    const callerFile = trace.at(0).file
+    return new DataSource_LocalFile_Path(new Path(callerFile).parent(), path)
+}

package/src/utils/tagged-template.ts

@@ -0,0 +1,6 @@
+export function createTaggedTemplate<DataSource_T>(f: (joined: string) => DataSource_T) {
+    return (tArgs: TemplateStringsArray, ...params: any[]) => {
+        const joined = String.raw(tArgs, ...params)
+        return f(joined)
+    }
+}