k8ts 0.8.1 → 0.9.2

package/src/resources/rbac/cluster-role.ts

@@ -0,0 +1,99 @@
+import { Kind, Resource_Top } from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
+import { rbac } from "../../kinds/rbac"
+export interface ClusterRole_Rule<
+    Groups extends Kind.Group[] = Kind.Group[],
+    Resources extends Kind.Kind<Groups[number]["name"], string, string>[] = Kind.Kind[]
+> {
+    resources: Resources
+    verbs: Verbs[]
+}
+export type ClusterRole_RuleProducer<Rules extends ClusterRole_Rule> = (
+    scope: ClusterRole_Scope
+) => Iterable<Rules>
+class ClusterRole_Scope {
+    Resources<const R extends Kind[]>(...resources: R) {
+        return {
+            verbs(...verbs: Verbs[]) {
+                return {
+                    resources: resources,
+                    verbs: verbs
+                }
+            }
+        }
+    }
+}
+export interface ClusterRole_Props<Rules extends ClusterRole_Rule = ClusterRole_Rule> {
+    rules: ClusterRole_RuleProducer<Rules>
+}
+
+export class ClusterRole<Name extends string = string> extends Resource_Top<
+    Name,
+    ClusterRole_Props
+> {
+    get kind() {
+        return rbac.v1.ClusterRole._
+    }
+    constructor(name: Name, props: ClusterRole_Props) {
+        super(name, props)
+    }
+
+    private _fromObject(rule: ClusterRole_Rule) {
+        return {
+            apiGroups: rule.resources.map(x => x.parent.parent.name),
+            resources: rule.resources.map(r => r.plural),
+            verbs: rule.verbs
+        }
+    }
+    protected body(): CDK.KubeClusterRoleProps {
+        const rules = seq(this.props.rules(new ClusterRole_Scope()))
+            .map(rule => {
+                return this._fromObject(rule)
+            })
+            .toArray()
+            .pull()
+        return {
+            rules: rules
+        }
+    }
+}
+
+export type Verbs =
+    | "get"
+    | "list"
+    | "watch"
+    | "create"
+    | "update"
+    | "patch"
+    | "delete"
+    | "deletecollection"
+
+export type ApiGroup =
+    | "namespaces"
+    | "pods"
+    | "services"
+    | "endpoints"
+    | "persistentvolumeclaims"
+    | "events"
+    | "configmaps"
+    | "secrets"
+    | "httproutes"
+    | "gateways"
+    | "jobs"
+    | "cronjobs"
+    | "deployments"
+    | "replicasets"
+    | "statefulsets"
+    | "daemonsets"
+    | "podtemplates"
+    | "clusterroles"
+    | "roles"
+    | "rolebindings"
+    | "clusterrolebindings"
+    | "serviceaccounts"
+    | "nodes"
+    | "persistentvolumes"
+    | "storageclasses"
+    | "volumeattachments"
+    | "persistentvolumeclaims"

package/src/resources/rbac/service-account.ts

@@ -0,0 +1,25 @@
+import { Resource_Top } from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
+import { v1 } from "../../kinds/default"
+export interface ServiceAccount_Props {
+    automountToken?: boolean
+    imagePullSecrets?: string[]
+}
+
+export class ServiceAccount<Name extends string = string> extends Resource_Top<
+    Name,
+    ServiceAccount_Props
+> {
+    get kind() {
+        return v1.ServiceAccount._
+    }
+    protected body(): CDK.KubeServiceAccountProps {
+        const self = this
+        return {
+            automountServiceAccountToken: self.props.automountToken,
+            imagePullSecrets: self.props.imagePullSecrets?.map(name => ({
+                name
+            }))
+        }
+    }
+}

package/src/resources/secret/index.ts

@@ -1,3 +1 @@
-import * as Secret from "./secret"
-type Secret = Secret.Secret
-export { Secret }
+export * from "./secret"

package/src/resources/secret/secret.ts

@@ -1,26 +1,20 @@
-import { manifest, relations } from "@k8ts/instruments"
-import { CDK } from "../../_imports"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import { ManifestResource } from "../../node/manifest-resource"
+import { Resource_Top } from "@k8ts/instruments"
+import { v1 } from "../../kinds/default"
 
-export interface Props {
+export interface Secret_Props {
     data?: Record<string, string>
     stringData?: Record<string, string>
 }
 
-@k8ts(api.v1_.Secret)
-@equiv_cdk8s(CDK.KubeSecret)
-@relations("none")
-@manifest({
-    body(self): CDK.KubeSecretProps {
+export class Secret<Name extends string = string> extends Resource_Top<Name, Secret_Props> {
+    get kind() {
+        return v1.Secret._
+    }
+
+    protected body() {
         return {
-            data: self.props.data,
-            stringData: self.props.stringData
+            data: this.props.data,
+            stringData: this.props.stringData
         }
     }
-})
-export class Secret extends ManifestResource<Props> {
-    readonly kind = api.v1_.Secret
 }

package/src/resources/service/service-port.ts

@@ -1,32 +1,28 @@
-import { CDK } from "../../_imports"
-import type { Service } from "./service"
+import { CDK } from "@k8ts/sample-interfaces"
+import type { Service, Service_Ref } from "./service"
 
-export type Port<Port extends string> = Port.Port<Port>
-export namespace Port {
-    export interface Props<Port extends string> {
-        service: Service.AbsService<Port>
-        name: Port
-    }
-
-    export class Port<Port extends string> {
-        constructor(readonly props: Props<Port>) {}
+export interface Service_Port_Props<Port extends string> {
+    service: Service_Ref<Port>
+    name: Port
+}
 
-        get service() {
-            return this.props.service as Service<Port>
-        }
+export class Port<Port extends string> {
+    constructor(readonly props: Service_Port_Props<Port>) {}
+    get service() {
+        return this.props.service as any as Service<Port>
+    }
 
-        get port() {
-            return this.props
-        }
+    get port() {
+        return this.props
+    }
 
-        // TODO: Does this need to resolve ports?
-        ref(): CDK.HttpRouteSpecRulesBackendRefs {
-            return {
-                kind: "Service",
-                namespace: this.service.meta.tryGet("namespace"),
-                name: this.service.meta.get("name"),
-                port: this.service.ports.get(this.props.name).frontend
-            }
+    // TODO: Does this need to resolve ports?
+    ref(): CDK.HttpRouteSpecRulesBackendRefs {
+        return {
+            kind: "Service",
+            namespace: this.service.meta.tryGet("namespace"),
+            name: this.service.meta.get("name"),
+            port: this.service.ports.get(this.props.name).frontend
         }
     }
 }

package/src/resources/service/service.ts

@@ -1,107 +1,99 @@
-import {
-    manifest,
-    Refable,
-    relations,
-    ResourceEntity,
-    type InputPortMapping
-} from "@k8ts/instruments"
-import { Map } from "immutable"
-import { CDK } from "../../_imports"
+import { Resource_Core_Ref, Resource_Top, type InputPortMapping } from "@k8ts/instruments"
+import { CDK } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
 import { MakeError } from "../../error"
-import { k8ts } from "../../kind-map"
-import { api } from "../../kinds"
-import { ManifestResource } from "../../node"
-import { equiv_cdk8s } from "../../node/equiv-cdk8s"
-import { Deployment } from "../deployment"
+import { v1 } from "../../kinds/index"
+import { Deployment, type Deployment_Ref } from "../deployment"
 import { toServicePorts } from "../utils/adapters"
-import { Frontend as Frontend_ } from "./frontend"
-import { Port as Port_ } from "./service-port"
-export type Service<ExposedPorts extends string = string> = Service.Service<ExposedPorts>
-export namespace Service {
-    export import Port = Port_
-    export import Frontend = Frontend_
-    export interface Props<DeployPorts extends string, ExposedPorts extends DeployPorts> {
-        $ports: InputPortMapping<ExposedPorts>
-        $backend: Deployment.AbsDeployment<DeployPorts>
-        $frontend: Frontend
+import { Port } from "./service-port"
+export interface Service_Frontend_ClusterIp {
+    type: "ClusterIP"
+}
+
+export interface Service_Frontend_LoadBalancer {
+    type: "LoadBalancer"
+    loadBalancerIP?: string
+}
+export type Service_Frontend = Service_Frontend_ClusterIp | Service_Frontend_LoadBalancer
+export interface Service_Props<DeployPorts extends string, ExposedPorts extends DeployPorts> {
+    $ports: InputPortMapping<ExposedPorts>
+    $backend: Deployment_Ref<DeployPorts>
+    $frontend: Service_Frontend
+}
+export interface Service_Ref<ExposedPorts extends string> extends Resource_Core_Ref<v1.Service._> {
+    __PORTS__: ExposedPorts
+}
+
+export class Service<
+    Name extends string = string,
+    ExposedPorts extends string = string
+> extends Resource_Top<Name, Service_Props<string, ExposedPorts>> {
+    __PORTS__!: ExposedPorts
+    get kind() {
+        return v1.Service._
+    }
+
+    private get backend() {
+        return this.props.$backend as Deployment<ExposedPorts>
     }
-    export type AbsService<ExposedPorts extends string> = Refable<api.v1_.Service> & {
-        __PORTS__: ExposedPorts
+    // TODO: Ports force evaluates the backend which is not needed
+    get ports() {
+        const srcPorts = this.backend.ports.pull()
+        const knownPorts = seq(Object.entries(this.props.$ports))
+            .filter(([, v]) => v !== undefined)
+            .map(([k]) => k)
+            .toArray()
+            .pull() as ExposedPorts[]
+        const svcPorts = srcPorts.pick(...knownPorts).map(this.props.$ports as any)
+        return svcPorts
     }
-    @k8ts(api.v1_.Service)
-    @relations({
-        needs: self => ({
-            backend: self.backend as ResourceEntity
-        })
-    })
-    @equiv_cdk8s(CDK.KubeService)
-    @manifest({
-        body(self): CDK.KubeServiceProps {
-            const svcPorts = self.ports
-            return {
-                spec: {
-                    ...self.props.$frontend,
-                    ports: toServicePorts(svcPorts).toArray(),
-                    selector: {
-                        app: self.props.$backend.name
-                    },
-                    ...(self.props.$frontend.type === "LoadBalancer"
-                        ? {
-                              allocateLoadBalancerNodePorts: false,
-                              externalTrafficPolicy: "Local"
-                          }
-                        : {})
-                }
-            }
-        }
-    })
-    export class Service<ExposedPorts extends string = string> extends ManifestResource<
-        Props<string, ExposedPorts>
-    > {
-        __PORTS__!: ExposedPorts
-        kind = api.v1_.Service
 
-        private get backend() {
-            return this.props.$backend as Deployment<ExposedPorts>
-        }
-        // TODO: Ports force evaluates the backend which is not needed
-        get ports() {
-            const srcPorts = this.backend.ports.pull()
-            const knownPorts = Map(this.props.$ports)
-                .filter(x => x !== undefined)
-                .keySeq()
-                .toArray() as ExposedPorts[]
-            const svcPorts = srcPorts.pick(...knownPorts).map(this.props.$ports as any)
-            return svcPorts
+    protected override __needs__() {
+        return {
+            backend: this.backend
         }
+    }
 
-        portRef(name: ExposedPorts) {
-            return new Port.Port({
-                service: this,
-                name: name
-            })
-        }
+    portRef(name: ExposedPorts) {
+        return new Port({
+            service: this,
+            name: name
+        })
+    }
 
-        get hostname() {
-            return `${this.name}.${this.namespace}.svc.cluster.local`
+    get hostname() {
+        return `${this.name}.${this.namespace}.svc.cluster.local`
+    }
+
+    private _getPortoPart(port: ExposedPorts, protocol: "http" | "https") {
+        const portNumber = this.props.$ports[port]
+        if (portNumber === 80 && protocol === "http") {
+            return ""
+        }
+        if (portNumber === 443 && protocol === "https") {
+            return ""
+        }
+        if (portNumber === undefined) {
+            throw new MakeError(`Port ${port} is not defined in service ${this.name}`)
         }
+        return `:${portNumber}`
+    }
 
-        private _getPortoPart(port: ExposedPorts, protocol: "http" | "https") {
-            const portNumber = this.props.$ports[port]
-            if (portNumber === 80 && protocol === "http") {
-                return ""
-            }
-            if (portNumber === 443 && protocol === "https") {
-                return ""
-            }
-            if (portNumber === undefined) {
-                throw new MakeError(`Port ${port} is not defined in service ${this.name}`)
+    protected body(): CDK.KubeServiceProps {
+        const self = this
+        const svcPorts = self.ports
+        return {
+            spec: {
+                ...self.props.$frontend,
+                ports: toServicePorts(svcPorts),
+                selector: {
+                    app: self.props.$backend.name
+                }
             }
-            return `:${portNumber}`
         }
+    }
 
-        address(protocol: "http" | "https", port: ExposedPorts) {
-            return `${protocol}://${this.hostname}${this._getPortoPart(port, protocol)}`
-        }
+    address(protocol: "http" | "https", port: ExposedPorts) {
+        return `${protocol}://${this.hostname}${this._getPortoPart(port, protocol)}`
     }
 }

package/src/resources/utils/adapters.ts

@@ -1,5 +1,6 @@
 import type { PortMap, PortMapEntry, PortSet, PortSetEntry } from "@k8ts/instruments"
-import { CDK } from "../../_imports"
+import { CDK } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
 export function toContainerPort(entry: PortSetEntry): CDK.ContainerPort {
     return {
         containerPort: entry.port,
@@ -11,7 +12,7 @@ export function toContainerPort(entry: PortSetEntry): CDK.ContainerPort {
 }
 
 export function toContainerPorts(ports: PortSet<any>) {
-    return ports.values.map(toContainerPort)
+    return seq(ports.values.values()).map(toContainerPort).toArray().pull()
 }
 
 export function toServicePort(entry: PortMapEntry): CDK.ServicePort {
@@ -24,5 +25,5 @@ export function toServicePort(entry: PortMapEntry): CDK.ServicePort {
 }
 
 export function toServicePorts(ports: PortMap<any>) {
-    return ports.values.map(toServicePort).toList()
+    return seq(ports.values.values()).map(toServicePort).toArray().pull()
 }

package/src/runner/exporter/assembler.ts

@@ -1,9 +1,8 @@
-import { Origin } from "@k8ts/instruments"
+import { OriginNode, type Origin_Exporter } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
 import { aseq } from "doddle"
 import Emittery from "emittery"
 import { cloneDeep } from "lodash"
-import type { File } from "../../file"
 import { ResourceLoader, type ResourceLoaderEventsTable } from "./loader"
 import { Manifester, NodeManifest, type ManifesterEventsTable } from "./manifester"
 import { ManifestSaver, type ManifestSaverEventsTable } from "./saver"
@@ -15,7 +14,7 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
         super()
     }
 
-    async assemble(inFiles: Iterable<File.Input>) {
+    async assemble(inFiles: Iterable<Origin_Exporter>) {
         const _emit = async <Name extends keyof AssemblerEventsTable>(
             event: Name,
             payload: AssemblerEventsTable[Name]
@@ -36,11 +35,12 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
         })
         saver.onAny(_emit)
         const reports = aseq(inFiles)
+            .map(x => x.node)
             .before(async () => {
                 await _emit("stage", { stage: "gathering" })
             })
             .each(async file => {
-                await _emit("received-file", { file: file.__node__ })
+                await _emit("received-file", { file: file })
             })
             .after(async () => {
                 await _emit("stage", { stage: "loading" })
@@ -50,7 +50,7 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
                 const loaded = await loader.load(file)
                 loaded.forEach(r => r.meta!.add(this._options.meta))
                 return {
-                    file: file.__entity__,
+                    file: file,
                     resources: loaded.filter(x => !x.isExternal)
                 }
             })
@@ -67,7 +67,7 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
                     .pull()
 
                 return {
-                    file: file.node,
+                    file: file,
                     resources: manifests
                 } satisfies FileNodes
             })
@@ -131,14 +131,14 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
     }
 }
 export interface FileNodes {
-    file: Origin
+    file: OriginNode
     resources: NodeManifest[]
 }
 export interface Artifact extends NodeManifest {
     yaml: string
 }
 export interface AssembledFile {
-    file: Origin
+    file: OriginNode
     path: string
     filename: string
     bytes: number
@@ -170,7 +170,7 @@ export interface AssemblerEventsTable
         ManifesterEventsTable,
         ResourceLoaderEventsTable,
         ValidatorEventsTable {
-    ["received-file"]: { file: Origin }
+    ["received-file"]: { file: OriginNode }
     ["stage"]: { stage: AssemblyStage }
 }
 export type AnyAssemblerEvent = {

package/src/runner/exporter/loader.ts

@@ -1,25 +1,13 @@
-import { ForwardRef, ResourceNode } from "@k8ts/instruments"
-import { seq } from "doddle"
+import { OriginNode, Resource_Node, type Node, type Resource_Top } from "@k8ts/instruments"
 import Emittery from "emittery"
-import { Map, Set } from "immutable"
 import { MakeError } from "../../error"
-import type { File } from "../../file"
-import { k8ts_namespace } from "./meta"
 export class ResourceLoader extends Emittery<ResourceLoaderEventsTable> {
     constructor(private readonly _options: ResourceLoaderOptions) {
         super()
     }
 
-    private _attachSourceAnnotations(loadEvent: ResourceLoadedEvent) {
-        const { resource } = loadEvent
-
-        resource.meta!.add(k8ts_namespace, {
-            "^declared-in": `(${resource.origin.root.name}) ${resource.origin.name}`
-        })
-    }
-
-    private _checkNames(resources: Set<ResourceNode>) {
-        let names = Map<string, ResourceNode>()
+    private _checkNames(resources: Resource_Node[]) {
+        let names = new Map<string, Resource_Node>()
         const nameRegexp = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/
         for (const resource of resources) {
             const name = [resource.kind.name, resource.namespace, resource.name]
@@ -36,16 +24,19 @@ export class ResourceLoader extends Emittery<ResourceLoaderEventsTable> {
                     `Invalid resource name ${resource.name}. Must match ${nameRegexp}`
                 )
             }
-            names = names.set(name, resource)
+            names.set(name, resource)
         }
     }
 
-    async load(input: File.Input) {
+    async load(input: OriginNode) {
         // TODO: Handle ORIGINS that are referenced but not passed to the runner
-        const parentOrigin = input.__node__
+        let resources = [] as Resource_Node[]
 
-        const addResource = async (res: ResourceNode) => {
-            if (resources.has(res)) {
+        const addResource = async (res: Node) => {
+            if (!(res instanceof Resource_Node)) {
+                throw new Error(`Expected ResourceNode, got ${res.constructor.name}`)
+            }
+            if (resources.some(r => r.equals(res))) {
                 return
             }
             if (!res.isRoot) {
@@ -53,48 +44,41 @@ export class ResourceLoader extends Emittery<ResourceLoaderEventsTable> {
             }
             const origin = res.origin
 
-            if (!origin.isChildOf(parentOrigin)) {
+            if (!origin.isChildOf(input)) {
                 return
             }
             const event = {
-                isExported: res.meta!.has(`#${k8ts_namespace}is-exported`),
+                isExported: res.meta!.has(`#k8ts.org/is-exported`),
                 resource: res
             } as const
 
-            this._attachSourceAnnotations(event)
             await this.emit("load", event)
-            resources = resources.add(res)
+            origin.entity["__emit__"]("resource/loaded", {
+                origin: origin.entity,
+                resource: res.entity as Resource_Top
+            })
+            resources.push(res)
         }
 
-        let resources = Set<ResourceNode>()
-        // We execute the main FILE iterable to load all the resources attached to the origin
-        seq(input).toArray().pull()
-        for (let res of input.__node__.resources) {
-            if (ForwardRef.is(res)) {
-                throw new MakeError(`Resource ${res} is a forward reference`)
-            }
-            await addResource(res)
+        for (const resource of input.resources) {
+            await addResource(resource.node)
         }
+
         // Some resources might appear as dependencies to sub-resources that
         // haven't loaded. We can acquire them by getting all the needed resources
-        for (const resource of resources.toArray()) {
+        for (const resource of resources) {
             for (const relation of resource.recursiveRelationsSubtree) {
                 await addResource(relation.needed)
             }
         }
 
-        // The lazy sections might have attached more resources to the origin
-        for (const resource of parentOrigin.resources) {
-            await addResource(resource)
-        }
-
         this._checkNames(resources)
-        return resources.toArray()
+        return [...resources]
     }
 }
 export interface ResourceLoadedEvent {
     isExported: boolean
-    resource: ResourceNode
+    resource: Resource_Node
 }
 
 export interface ResourceLoaderEventsTable {