k8ts 0.13.2 → 0.14.0

package/src/resources/namespace/namespace.ts

@@ -1,19 +1,22 @@
-import { Rsc_Top } from "@k8ts/instruments"
-import { v1 } from "../../kinds/default"
-export interface Namespace_Props {}
+import { K8sResource, type Resource_Props_Top } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../gvks/default"
+export interface NamespaceProps extends Resource_Props_Top<K8S.NamespaceSpec> {}
 
-export class Namespace<Name extends string = string> extends Rsc_Top<Name, Namespace_Props> {
-    constructor(name: Name, props: Namespace_Props = {}) {
+export class Namespace<Name extends string = string> extends K8sResource<Name, NamespaceProps> {
+    constructor(name: Name, props: NamespaceProps = {}) {
         super(name, props)
     }
-    declare name: Name
     get kind() {
         return v1.Namespace._
     }
 
-    protected body() {
+    protected __body__(): K8S.KubeNamespaceProps {
+        const spec = {} satisfies K8S.NamespaceSpec
+        const spec2 = merge(spec, this.props.$$manifest)
         return {
-            spec: {}
+            spec: spec2
         }
     }
 }

package/src/resources/network/http-route/http-route.ts

@@ -0,0 +1,62 @@
+import { K8sResource, type ResourceRef, type Resource_Props_Top } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { gateway } from "../../../gvks/gateway"
+import type { Service_PortRef } from "../service/service-port"
+
+export interface HttpRoute_Props<Ports extends string>
+    extends Resource_Props_Top<K8S.HttpRouteSpec> {
+    $gateway: ResourceRef<gateway.v1.Gateway._>
+    $hostname: string
+    $backend: Service_PortRef<Ports>
+}
+
+export class HttpRoute<Name extends string, Ports extends string> extends K8sResource<
+    Name,
+    HttpRoute_Props<Ports>
+> {
+    get kind() {
+        return gateway.v1.HttpRoute._
+    }
+
+    private _getBackendRef() {
+        const backendRef: K8S.HttpRouteSpecRulesBackendRefs = {
+            kind: "Service",
+            namespace: this.props.$backend.service.ident.namespace,
+            name: this.props.$backend.service.ident.name,
+            port: this.props.$backend.number()
+        }
+        return backendRef
+    }
+
+    protected __body__(): K8S.HttpRouteProps {
+        const self = this
+        const backendRef = this._getBackendRef()
+        const spec = {
+            parentRefs: [
+                {
+                    kind: "Gateway",
+                    name: self.props.$gateway.ident.name,
+                    namespace: self.props.$gateway.ident.namespace
+                }
+            ],
+            hostnames: [self.props.$hostname],
+            rules: [
+                {
+                    backendRefs: [backendRef]
+                }
+            ]
+        } satisfies K8S.HttpRouteSpec
+        const spec2 = merge(spec, self.props.$$manifest)
+        return {
+            spec: spec2
+        }
+    }
+
+    protected __needs__() {
+        return {
+            gateway: this.props.$gateway,
+            service: this.props.$backend.service
+        }
+    }
+}

package/src/resources/network/index.ts

@@ -0,0 +1,2 @@
+export * from "./http-route"
+export * from "./service"

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

@@ -0,0 +1,17 @@
+import { Service, type Service_Ref } from "./service"
+
+export interface Service_PortRef_Props<Port extends string> {
+    service: Service_Ref<Port>
+    name: Port
+}
+
+export class Service_PortRef<Port extends string> {
+    constructor(readonly props: Service_PortRef_Props<Port>) {}
+    get service() {
+        return this.props.service
+    }
+
+    number() {
+        return this.props.service.cast(Service).ports.get(this.props.name).frontend
+    }
+}

package/src/resources/network/service/service.ts

@@ -0,0 +1,135 @@
+import {
+    K8sResource,
+    ResourceRef,
+    type Ip4_Input_String,
+    type PortMap,
+    type PortMapping_Input,
+    type Resource_Props_Top
+} from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
+import { merge } from "lodash"
+import { v1 } from "../../../gvks/index"
+import { K8tsResourceError } from "../../errors"
+import type { Workload_Ref } from "../../workload/workload-ref"
+import { Service_PortRef } from "./service-port"
+import { toServicePorts } from "./utils"
+
+/** Short for ClusterIp with ClusterIp: None */
+export interface Service_Frontend_Headless {
+    type: "Headless"
+}
+export interface Sevice_Frontend_ClusterIp {
+    type: "ClusterIP"
+    clusterIp?: Ip4_Input_String | "None"
+}
+
+export interface Service_Frontend_LoadBalancer {
+    type: "LoadBalancer"
+    loadBalancerIP?: Ip4_Input_String
+    loadBalancerSourceRanges?: string[]
+    loadBalancerClass?: string
+    allocateLoadBalancerNodePorts?: boolean
+    clusterIp?: Ip4_Input_String
+}
+export type Service_Frontend =
+    | Sevice_Frontend_ClusterIp
+    | Service_Frontend_LoadBalancer
+    | Service_Frontend_Headless
+export interface Service_Props<DeployPorts extends string, ExposedPorts extends DeployPorts>
+    extends Resource_Props_Top<K8S.ServiceSpec> {
+    $ports: PortMapping_Input<ExposedPorts>
+    $backend: Workload_Ref<DeployPorts>
+    $frontend: Service_Frontend
+}
+export interface Service_Ref<PortsExposed extends string> extends ResourceRef<v1.Service._> {
+    ports: PortMap<PortsExposed>
+}
+
+export class Service<
+    Name extends string = string,
+    PortsExposed extends string = string
+> extends K8sResource<Name, Service_Props<string, PortsExposed>> {
+    __PORTS__!: PortsExposed
+    get kind() {
+        return v1.Service._
+    }
+
+    private get _backend() {
+        return this.props.$backend
+    }
+    get ports() {
+        const srcPorts = this._backend.ports
+        const knownPorts = seq(Object.entries(this.props.$ports))
+            .filter(([, v]) => v !== undefined)
+            .map(([k]) => k)
+            .toArray()
+            .pull() as PortsExposed[]
+        const svcPorts = srcPorts.pick(...knownPorts).map(this.props.$ports as any)
+        return svcPorts
+    }
+
+    protected override __needs__() {
+        return {
+            backend: this._backend
+        }
+    }
+
+    portRef(name: PortsExposed) {
+        return new Service_PortRef({
+            service: this,
+            name: name
+        })
+    }
+
+    get hostname() {
+        return `${this.ident.name}.${this.ident.namespace}.svc.cluster.local`
+    }
+
+    private _getProtoPort(port: PortsExposed, 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 K8tsResourceError(`Port ${port} is not defined in service ${this.ident.name}`)
+        }
+        return `:${portNumber}`
+    }
+
+    private _frontend() {
+        if (this.props.$frontend.type === "Headless") {
+            return {
+                type: "ClusterIP",
+                clusterIp: "None"
+            } satisfies K8S.ServiceSpec
+        }
+        return this.props.$frontend satisfies K8S.ServiceSpec
+    }
+
+    protected __body__(): K8S.KubeServiceProps {
+        const self = this
+        const svcPorts = self.ports
+        const spec = {
+            ...self._frontend(),
+
+            ports: toServicePorts(svcPorts),
+            selector: {
+                app: self.props.$backend.ident.name
+            }
+        } satisfies K8S.ServiceSpec
+        const spec2 = merge(spec, self.props.$$manifest)
+        const body = {
+            spec: spec2
+        }
+
+        return body
+    }
+
+    address(protocol: "http" | "https", port: PortsExposed) {
+        return `${protocol}://${this.hostname}${this._getProtoPort(port, protocol)}`
+    }
+}

package/src/resources/network/service/utils.ts

@@ -0,0 +1,20 @@
+import type { PortMap, PortMap_Item } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { seq } from "doddle"
+
+export function toServicePort(entry: PortMap_Item): K8S.ServicePort {
+    return {
+        port: entry.frontend,
+        targetPort: K8S.IntOrString.fromString(entry.name),
+        protocol: entry.protocol,
+        name: entry.name
+    }
+}
+
+export function toServicePorts(ports: PortMap<any>) {
+    return seq
+        .fromObject(ports.values)
+        .map(([, entry]) => toServicePort(entry))
+        .toArray()
+        .pull()
+}

package/src/resources/persistent/access-mode.ts

@@ -1,29 +1,25 @@
-export type Access = Access.Pv_AccessMode_Inputs
+export type PvAccessMode_Explicit = "ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany"
+export type PvAccessMode = PvAccessMode_Explicit | "RWX" | "ROX" | "RWO"
+export type PvAccessMode_Many = PvAccessMode | PvAccessMode[]
 
-export namespace Access {
-    export type Pv_AccessMode = "ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany"
-    export type Pv_AccessMode_Input = Pv_AccessMode | "RWX" | "ROX" | "RWO"
-    export type Pv_AccessMode_Inputs = Pv_AccessMode_Input | Pv_AccessMode_Input[]
-
-    function parseOne(mode: Pv_AccessMode_Input): Pv_AccessMode {
-        switch (mode) {
-            case "RWX":
-            case "ReadWriteMany":
-                return "ReadWriteMany"
-            case "ROX":
-            case "ReadOnlyMany":
-                return "ReadOnlyMany"
-            case "RWO":
-            case "ReadWriteOnce":
-                return "ReadWriteOnce"
-        }
+function parseOne(mode: PvAccessMode): PvAccessMode_Explicit {
+    switch (mode) {
+        case "RWX":
+        case "ReadWriteMany":
+            return "ReadWriteMany"
+        case "ROX":
+        case "ReadOnlyMany":
+            return "ReadOnlyMany"
+        case "RWO":
+        case "ReadWriteOnce":
+            return "ReadWriteOnce"
     }
+}
 
-    export function pv_parseAccessMode(modes: Pv_AccessMode_Inputs): Pv_AccessMode[] {
-        if (Array.isArray(modes)) {
-            return modes.map(parseOne)
-        } else {
-            return [parseOne(modes)]
-        }
+export function parsePvAccessMode(modes: PvAccessMode_Many): PvAccessMode_Explicit[] {
+    if (Array.isArray(modes)) {
+        return modes.map(parseOne)
+    } else {
+        return [parseOne(modes)]
     }
 }

package/src/resources/persistent/claim/pvc.ts

@@ -1,31 +1,34 @@
-import { ResourcesSpec, Rsc_Top, Unit, type Rsc_Ref } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
-import { Prefix$ } from "../../../_type/prefix$"
-import { MakeError } from "../../../error"
-import { v1 } from "../../../kinds/default"
-import { storage } from "../../../kinds/storage"
-import { Access } from "../access-mode"
-import type { Pv_VolumeMode } from "../block-mode"
-import type { Pv, Pv_Ref } from "../volume"
+import {
+    K8sResource,
+    Reqs,
+    Units,
+    type ResourceRef,
+    type Resource_Props_Top
+} from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../../gvks/default"
+import { storage } from "../../../gvks/storage"
+import { parsePvAccessMode, type PvAccessMode_Many } from "../access-mode"
+import type { Pv_Ref } from "../volume"
+import type { PvVolumeMode } from "../volume-mode"
 
-const StorageClassKind = storage.v1.StorageClass._
-
-const pvc_ResourcesSpec = ResourcesSpec.make({
-    storage: Unit.Data
+const pvcReqs = new Reqs({
+    storage: Units.Data
 })
-type Pvc_Resources = Prefix$<(typeof pvc_ResourcesSpec)["__INPUT__"]>
-export interface Pvc_Props<Mode extends Pv_VolumeMode> extends Pvc_Resources {
-    $accessModes: Access
+export interface Pvc_Props<Mode extends PvVolumeMode>
+    extends Resource_Props_Top<K8S.KubePersistentVolumeClaimProps> {
+    $accessModes: PvAccessMode_Many
     $mode?: Mode
-    $storageClass?: Rsc_Ref<typeof StorageClassKind>
-    $bind?: Pv_Ref<Mode>
+    $storageClass?: ResourceRef<storage.v1.StorageClass._>
+    $volume?: Pv_Ref<Mode>
+    $resources: typeof pvcReqs.__INPUT__
 }
 
-export class Pvc<Mode extends Pv_VolumeMode, Name extends string = string> extends Rsc_Top<
+export class Pvc<Mode extends PvVolumeMode, Name extends string = string> extends K8sResource<
     Name,
     Pvc_Props<Mode>
 > {
-    declare name: Name
     get kind() {
         return v1.PersistentVolumeClaim._
     }
@@ -33,34 +36,29 @@ export class Pvc<Mode extends Pv_VolumeMode, Name extends string = string> exten
     protected __needs__() {
         const self = this
         return {
-            bind: self.bound,
+            bind: self.props.$volume,
             storageClass: self.props.$storageClass
         }
     }
-    protected body(): CDK.KubePersistentVolumeClaimProps {
+    protected __body__(): K8S.KubePersistentVolumeClaimProps {
         const self = this
-        const { $storage, $accessModes, $mode, $storageClass, $bind } = self.props
-        const nAccessModes = Access.pv_parseAccessMode($accessModes)
-        if (!$bind && !$storageClass) {
-            throw new MakeError(
-                `While manifesting ${self.node.format("source")}, PVC that doesn't have a $bind must have a $storageClass.`
-            )
-        }
+        const { $resources, $accessModes, $mode, $storageClass, $volume } = self.props
+        const nAccessModes = parsePvAccessMode($accessModes)
+
+        const spec = {
+            accessModes: nAccessModes,
+            volumeName: self.props.$volume?.ident.name,
+            volumeMode: $mode,
+            resources: pvcReqs
+                .parse({
+                    storage: $resources.storage
+                })
+                .toObject(),
+            storageClassName: self.props.$storageClass?.ident.name ?? "standard"
+        } satisfies K8S.PersistentVolumeClaimSpec
+        const spec2 = merge(spec, self.props.$$manifest)
         return {
-            spec: {
-                accessModes: nAccessModes,
-                volumeName: self.props.$bind?.name,
-                volumeMode: $mode,
-                resources: pvc_ResourcesSpec
-                    .parse({
-                        storage: $storage
-                    })
-                    .toObject(),
-                storageClassName: self.props.$storageClass?.name ?? "standard"
-            }
+            spec: spec2
         }
     }
-    get bound() {
-        return this.props.$bind as Pv<Mode> | undefined
-    }
 }

package/src/resources/persistent/index.ts

@@ -1,4 +1,4 @@
 export * from "./access-mode"
-export * from "./block-mode"
 export * from "./claim"
 export * from "./volume"
+export * from "./volume-mode"

package/src/resources/persistent/volume/parse-backend.ts

@@ -1,4 +1,4 @@
-import { MakeError } from "../../../error"
+import { K8tsResourceError } from "../../errors"
 import type { Pv_Backend } from "./pv"
 export function parseBackend(backend?: Pv_Backend) {
     switch (backend?.kind) {
@@ -9,7 +9,7 @@ export function parseBackend(backend?: Pv_Backend) {
             return {
                 hostPath: {
                     path: backend.path,
-                    type: backend.hostpathType
+                    type: backend.type
                 }
             }
         case "Local":
@@ -26,7 +26,7 @@ export function parseBackend(backend?: Pv_Backend) {
                 }
             }
         default:
-            throw new MakeError(`Unknown backend kind!`, {
+            throw new K8tsResourceError(`Unknown backend kind!`, {
                 backend
             })
     }

package/src/resources/persistent/volume/pv.ts

@@ -1,50 +1,59 @@
-import { Rsc_Ref, Rsc_Top, type Unit } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
-import { MakeError } from "../../../error"
-import { v1 } from "../../../kinds/default"
-import { storage } from "../../../kinds/storage"
-import type { HostPathType } from "../../hostpath"
-import { Access } from "../access-mode"
-import type { Pv_VolumeMode } from "../block-mode"
+import {
+    K8sResource,
+    ResourceRef,
+    toCdkQuantityRecord,
+    Units,
+    type Resource_Props_Top
+} from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import { v1 } from "../../../gvks/default"
+import { storage } from "../../../gvks/storage"
+import { K8tsResourceError } from "../../errors"
+import type { HostPath_Type } from "../../hostpath"
+import { parsePvAccessMode, type PvAccessMode_Many } from "../access-mode"
+import type { PvVolumeMode } from "../volume-mode"
 import { parseBackend } from "./parse-backend"
 
 const StorageClassKind = storage.v1.StorageClass._
 
 export interface Pv_Backend_HostPath {
     kind: "HostPath"
-    hostpathType: HostPathType
+    type: HostPath_Type
     path: string
 }
 export interface Pv_Backend_Local {
     kind: "Local"
     path: string
 }
-export interface Pv_Backend_Nfs {
+export interface Pv_Backend_NFS {
     kind: "NFS"
     server: string
     path: string
 }
 
-export type Pv_Backend = Pv_Backend_HostPath | Pv_Backend_Local | Pv_Backend_Nfs
-export interface Pv_Props_K8ts<Mode extends Pv_VolumeMode = Pv_VolumeMode> {
-    $accessModes: Access
-    $storageClass?: Rsc_Ref<storage.v1.StorageClass._>
+export type Pv_Backend = Pv_Backend_HostPath | Pv_Backend_Local | Pv_Backend_NFS
+export interface Pv_Props<Mode extends PvVolumeMode = PvVolumeMode>
+    extends Resource_Props_Top<K8S.PersistentVolumeSpec> {
+    $accessModes: PvAccessMode_Many
+    $storageClass?: ResourceRef<storage.v1.StorageClass._>
     $mode?: Mode
-    reclaimPolicy?: Reclaim
-    $capacity: Unit.Data
+    $reclaimPolicy?: Pv_ReclaimMode
+    $capacity: {
+        storage: Units.Data
+    }
     $backend?: Pv_Backend
-    mountOptions?: string[]
-    nodeAffinity?: CDK.VolumeNodeAffinity
-}
-export type Reclaim = "Retain" | "Delete" | "Recycle"
-export type Pv_Ref<Mode extends Pv_VolumeMode = Pv_VolumeMode> = Rsc_Ref<v1.PersistentVolume._> & {
-    __MODE__: Mode
 }
+export type Pv_ReclaimMode = "Retain" | "Delete" | "Recycle"
+export type Pv_Ref<Mode extends PvVolumeMode = PvVolumeMode> =
+    ResourceRef<v1.PersistentVolume._> & {
+        __MODE__: Mode
+    }
 
 export class Pv<
-    Mode extends Pv_VolumeMode = "Filesystem",
+    Mode extends PvVolumeMode = "Filesystem",
     Name extends string = string
-> extends Rsc_Top<Name, Pv_Props_K8ts<Mode>> {
+> extends K8sResource<Name, Pv_Props<Mode>> {
     __MODE__!: Mode
     get kind() {
         return v1.PersistentVolume._
@@ -55,41 +64,36 @@ export class Pv<
             storageClass: this.props.$storageClass
         }
     }
-    protected body() {
+    protected __body__(): K8S.KubePersistentVolumeProps {
         const self = this
-        const pvProps = self.props
-        const accessModes = Access.pv_parseAccessMode(pvProps.$accessModes)
-        if (self.props.$backend?.kind === "Local") {
-            if (!pvProps.nodeAffinity) {
-                throw new MakeError(
-                    `While manifesting ${self.node.format("source")}, PV with Local backend must have nodeAffinity.`
-                )
-            }
-        }
+        const accessModes = parsePvAccessMode(self.props.$accessModes)
+        // Make sure it parses correctly
+        Units.Data.parse(self.props.$capacity.storage)
+
         if (!self.props.$backend && !self.props.$storageClass) {
-            throw new MakeError(
-                `While manifesting ${self.node.format("source")}, PV that doesn't have a $backend must have a $storageClass.`
+            throw new K8tsResourceError(
+                `While manifesting ${self.__vertex__.format("source")}, PV that doesn't have a $backend must have a $storageClass.`
             )
         }
-        let base: CDK.PersistentVolumeSpec = {
+        let spec: K8S.PersistentVolumeSpec = {
             accessModes,
-            storageClassName: pvProps.$storageClass?.name ?? "standard",
-            capacity: pvProps.$capacity
-                ? {
-                      storage: CDK.Quantity.fromString(pvProps.$capacity)
-                  }
-                : undefined,
-            volumeMode: pvProps.$mode ?? "Filesystem",
-            mountOptions: pvProps.mountOptions,
-            persistentVolumeReclaimPolicy: pvProps.reclaimPolicy ?? "Retain",
-            nodeAffinity: pvProps.nodeAffinity
+            storageClassName: self.props.$storageClass?.ident.name ?? "standard",
+            capacity: toCdkQuantityRecord(self.props.$capacity),
+            volumeMode: self.props.$mode ?? "Filesystem",
+            persistentVolumeReclaimPolicy: self.props.$reclaimPolicy ?? "Retain"
+        }
+        spec = {
+            ...spec,
+            ...parseBackend(self.props.$backend)
         }
-        base = {
-            ...base,
-            ...parseBackend(pvProps.$backend)
+        spec = merge(spec, self.props.$$manifest)
+        if (!spec.nodeAffinity) {
+            throw new K8tsResourceError(
+                `While manifesting ${self.__vertex__.format("source")}, PV with Local backend must have nodeAffinity.`
+            )
         }
         return {
-            spec: base
+            spec
         }
     }
 }

package/src/resources/persistent/volume-mode.ts

@@ -0,0 +1 @@
+export type PvVolumeMode = "Block" | "Filesystem"

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

@@ -1,15 +1,16 @@
-import { Rsc_Top } from "@k8ts/instruments"
-import { CDK } from "@k8ts/sample-interfaces"
-import { rbac } from "../../kinds/rbac"
-import type { ClusterRole } from "./cluster-role"
-import type { ServiceAccount } from "./service-account"
+import { K8sResource, type Resource_Props_Top, type ResourceRef } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { merge } from "lodash"
+import type { v1 } from "../../gvks"
+import { rbac } from "../../gvks/rbac"
 
-export interface ClusterRoleBoding_Props {
-    $role: ClusterRole
-    $subjects: ServiceAccount[]
+export interface ClusterRoleBoding_Props
+    extends Resource_Props_Top<K8S.KubeClusterRoleBindingProps> {
+    $role: ResourceRef<rbac.v1.ClusterRole._>
+    $subjects: ResourceRef<v1.ServiceAccount._>[]
 }
 
-export class ClusterRoleBinding<Name extends string = string> extends Rsc_Top<
+export class ClusterRoleBinding<Name extends string = string> extends K8sResource<
     Name,
     ClusterRoleBoding_Props
 > {
@@ -23,18 +24,19 @@ export class ClusterRoleBinding<Name extends string = string> extends Rsc_Top<
             subjects: this.props.$subjects
         }
     }
-    protected body(): CDK.KubeClusterRoleBindingProps {
-        return {
+    protected __body__(): K8S.KubeClusterRoleBindingProps {
+        const body = {
             roleRef: {
-                apiGroup: this.props.$role.kind.parent!.parent!.text,
-                kind: this.props.$role.kind.name,
-                name: this.props.$role.name
+                apiGroup: this.props.$role.kind.parent!.parent!.url,
+                kind: this.props.$role.kind.value,
+                name: this.props.$role.ident.name
             },
             subjects: this.props.$subjects.map(sa => ({
-                kind: sa.kind.name,
-                name: sa.name,
-                namespace: sa.namespace!
+                kind: sa.kind.value,
+                name: sa.ident.name,
+                namespace: sa.ident.namespace!
             }))
         }
+        return merge(body, this.props.$$manifest)
     }
 }