@highstate/library 0.9.15 → 0.9.18

package/src/k3s.ts

@@ -1,4 +1,4 @@
-import { defineUnit, Type } from "@highstate/contract"
+import { defineUnit, z } from "@highstate/contract"
 import { clusterInputs, clusterOutputs } from "./k8s"
 
 export const packagedComponents = [
@@ -18,9 +18,9 @@ export const internalComponents = [
   "helm-controller",
 ] as const
 
-export const componentSchema = Type.StringEnum([...packagedComponents, ...internalComponents])
+export const componentSchema = z.enum([...packagedComponents, ...internalComponents])
 
-export const cniSchema = Type.StringEnum(["none", "flannel"])
+export const cniSchema = z.enum(["none", "flannel"])
 
 export const cluster = defineUnit({
   type: "k3s.cluster",
@@ -28,48 +28,40 @@ export const cluster = defineUnit({
   args: {
     /**
      * The components to disable in the K3S cluster.
-     *
-     * @schema
      */
-    disabledComponents: Type.Default(Type.Array(componentSchema), []),
+    disabledComponents: componentSchema.array().default([]),
 
     /**
      * The CNI to use in the K3S cluster.
      *
      * Setting this to "none" will disable default Flannel CNI, but will not disable network policy controller and kube-proxy.
      * If needed, you can disable them using `disabledComponents` argument.
-     *
-     * @schema
      */
-    cni: Type.Default(cniSchema, "flannel"),
+    cni: cniSchema.default("flannel"),
 
     /**
      * The K3S configuration to pass to each server or agent in the cluster.
      *
      * See: https://docs.k3s.io/installation/configuration
-     *
-     * @schema
      */
-    config: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    config: z.record(z.string(), z.any()).optional(),
 
     /**
      * The configuration of the registries to use for the K3S cluster.
      *
      * See: https://docs.k3s.io/installation/private-registry
-     *
-     * @schema
      */
-    registries: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    registries: z.record(z.string(), z.any()).optional(),
   },
 
   inputs: clusterInputs,
   outputs: clusterOutputs,
 
   meta: {
-    displayName: "K3s Cluster",
+    title: "K3s Cluster",
     description: "The K3s cluster created on top of the server.",
     category: "k3s",
-    primaryIcon: "devicon:k3s",
+    icon: "devicon:k3s",
     secondaryIcon: "devicon:kubernetes",
   },
 

package/src/k8s.ts

@@ -1,39 +1,36 @@
-import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
-import { Literal } from "@sinclair/typebox"
+import { $args, defineEntity, defineUnit, z } from "@highstate/contract"
 import * as dns from "./dns"
 import { l3EndpointEntity, l4EndpointEntity } from "./network"
 import { serverEntity } from "./common"
 import { arrayPatchModeSchema } from "./utils"
 
-export const fallbackKubeApiAccessSchema = Type.Object({
-  serverIp: Type.String(),
-  serverPort: Type.Number(),
+export const fallbackKubeApiAccessSchema = z.object({
+  serverIp: z.string(),
+  serverPort: z.number(),
 })
 
-export const tunDevicePolicySchema = Type.Union([
-  Type.Object({
-    type: Literal("host"),
+export const tunDevicePolicySchema = z.union([
+  z.object({
+    type: z.literal("host"),
   }),
-  Type.Object({
-    type: Literal("plugin"),
-    resourceName: Type.String(),
-    resourceValue: Type.String(),
+  z.object({
+    type: z.literal("plugin"),
+    resourceName: z.string(),
+    resourceValue: z.string(),
   }),
 ])
 
-export const externalServiceTypeSchema = Type.StringEnum(["NodePort", "LoadBalancer"])
-export const scheduleOnMastersPolicySchema = Type.StringEnum(["always", "when-no-workers", "never"])
-export const cniSchema = Type.StringEnum(["cilium", "other"])
+export const externalServiceTypeSchema = z.enum(["NodePort", "LoadBalancer"])
+export const scheduleOnMastersPolicySchema = z.enum(["always", "when-no-workers", "never"])
+export const cniSchema = z.enum(["cilium", "other"])
 
-export const clusterQuirksSchema = Type.Object({
+export const clusterQuirksSchema = z.object({
   /**
    * The IP and port of the kube-apiserver available from the cluster.
    *
    * Will be used to create fallback network policy in CNIs which does not support allowing access to the kube-apiserver.
-   *
-   * @schema
    */
-  fallbackKubeApiAccess: Type.Optional(fallbackKubeApiAccessSchema),
+  fallbackKubeApiAccess: fallbackKubeApiAccessSchema.optional(),
 
   /**
    * Specifies the policy for using the tun device inside containers.
@@ -41,19 +38,15 @@ export const clusterQuirksSchema = Type.Object({
    * If not provided, the default policy is `host` which assumes just mounting /dev/net/tun from the host.
    *
    * For some runtimes, like Talos's one, the /dev/net/tun device is not available in the host, so the plugin policy should be used.
-   *
-   * @schema
    */
-  tunDevicePolicy: Type.Optional(tunDevicePolicySchema),
+  tunDevicePolicy: tunDevicePolicySchema.optional(),
 
   /**
    * The service type to use for external services.
    *
    * If not provided, the default service type is `NodePort` since `LoadBalancer` may not be available.
-   *
-   * @schema
    */
-  externalServiceType: Type.Optional(externalServiceTypeSchema),
+  externalServiceType: externalServiceTypeSchema.optional(),
 })
 
 export const clusterInfoProperties = {
@@ -61,17 +54,13 @@ export const clusterInfoProperties = {
    * The unique identifier of the cluster.
    *
    * Should be defined as a UUID of the `kube-system` namespace which is always present in the cluster.
-   *
-   * @schema
    */
-  id: Type.String(),
+  id: z.string(),
 
   /**
    * The name of the cluster.
-   *
-   * @schema
    */
-  name: Type.String(),
+  name: z.string(),
 
   /**
    * The name of the CNI plugin used by the cluster.
@@ -79,8 +68,6 @@ export const clusterInfoProperties = {
    * Supported values are:
    * - `cilium`
    * - `other`
-   *
-   * @schema
    */
   cni: cniSchema,
 
@@ -90,10 +77,8 @@ export const clusterInfoProperties = {
    * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
    *
    * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-   *
-   * @schema
    */
-  endpoints: Type.Array(l3EndpointEntity.schema),
+  endpoints: l3EndpointEntity.schema.array(),
 
   /**
    * The endpoints of the API server.
@@ -102,51 +87,45 @@ export const clusterInfoProperties = {
    *
    * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
    */
-  apiEndpoints: Type.Array(l4EndpointEntity.schema),
+  apiEndpoints: l4EndpointEntity.schema.array(),
 
   /**
    * The external IPs of the cluster nodes allowed to be used for external access.
-   *
-   * @schema
    */
-  externalIps: Type.Array(Type.String()),
+  externalIps: z.string().array(),
 
   /**
    * The extra quirks of the cluster to improve compatibility.
-   *
-   * @schema
    */
-  quirks: Type.Optional(clusterQuirksSchema),
+  quirks: clusterQuirksSchema.optional(),
 
   /**
    * The extra metadata to attach to the cluster.
-   *
-   * @schema
    */
-  metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+  metadata: z.record(z.string(), z.unknown()).optional(),
 } as const
 
-export const serviceTypeSchema = Type.StringEnum(["NodePort", "LoadBalancer", "ClusterIP"])
+export const serviceTypeSchema = z.enum(["NodePort", "LoadBalancer", "ClusterIP"])
 
-export const metadataSchema = Type.Object({
-  name: Type.String(),
-  namespace: Type.String(),
-  labels: Type.Optional(Type.Record(Type.String(), Type.String())),
-  annotations: Type.Optional(Type.Record(Type.String(), Type.String())),
+export const metadataSchema = z.object({
+  name: z.string(),
+  namespace: z.string(),
+  labels: z.record(z.string(), z.string()).optional(),
+  annotations: z.record(z.string(), z.string()).optional(),
 })
 
-export const resourceSchema = Type.Object({
-  clusterId: Type.String(),
+export const resourceSchema = z.object({
+  clusterId: z.string(),
   metadata: metadataSchema,
 })
 
 export const serviceEntity = defineEntity({
   type: "k8s.service",
 
-  schema: Type.Object({
-    type: Type.Literal("k8s.service"),
-    ...resourceSchema.properties,
-    endpoints: Type.Array(l4EndpointEntity.schema),
+  schema: z.object({
+    type: z.literal("k8s.service"),
+    ...resourceSchema.shape,
+    endpoints: l4EndpointEntity.schema.array(),
   }),
 
   meta: {
@@ -157,9 +136,9 @@ export const serviceEntity = defineEntity({
 export const clusterEntity = defineEntity({
   type: "k8s.cluster",
 
-  schema: Type.Object({
+  schema: z.object({
     ...clusterInfoProperties,
-    kubeconfig: Type.String(),
+    kubeconfig: z.string(),
   }),
 
   meta: {
@@ -167,20 +146,18 @@ export const clusterEntity = defineEntity({
   },
 })
 
-export const internalIpsPolicySchema = Type.StringEnum(["always", "public", "never"])
+export const internalIpsPolicySchema = z.enum(["always", "public", "never"])
 
-export const scheduleOnMastersPolicyArgs = {
+export const scheduleOnMastersPolicyArgs = $args({
   /**
    * The policy for scheduling workloads on master nodes.
    *
    * - `always`: always schedule workloads on master nodes regardless of the number of workers;
    * - `when-no-workers`: schedule workloads on master nodes only if there are no workers (default);
    * - `never`: never schedule workloads on master nodes.
-   *
-   * @schema
    */
-  scheduleOnMastersPolicy: Type.Default(scheduleOnMastersPolicySchema, "when-no-workers"),
-}
+  scheduleOnMastersPolicy: scheduleOnMastersPolicySchema.default("when-no-workers"),
+})
 
 export const clusterInputs = {
   masters: {
@@ -214,10 +191,8 @@ export const existingCluster = defineUnit({
      * The list of external IPs of the cluster nodes allowed to be used for external access.
      *
      * If not provided, will be automatically detected by querying the cluster nodes.
-     *
-     * @schema
      */
-    externalIps: Type.Optional(Type.Array(Type.String())),
+    externalIps: z.string().array().optional(),
 
     /**
      * The policy for using internal IPs of the nodes as external IPs.
@@ -225,17 +200,13 @@ export const existingCluster = defineUnit({
      * - `always`: always use internal IPs as external IPs;
      * - `public`: use internal IPs as external IPs only if they are (theoretically) routable from the public internet **(default)**;
      * - `never`: never use internal IPs as external IPs.
-     *
-     * @schema
      */
-    internalIpsPolicy: Type.Default(internalIpsPolicySchema, "public"),
+    internalIpsPolicy: internalIpsPolicySchema.default("public"),
 
     /**
      * The extra quirks of the cluster to improve compatibility.
-     *
-     * @schema
      */
-    quirks: Type.Optional(clusterQuirksSchema),
+    quirks: clusterQuirksSchema.optional(),
   },
 
   secrets: {
@@ -243,18 +214,16 @@ export const existingCluster = defineUnit({
      * The kubeconfig of the cluster to use for connecting to the cluster.
      *
      * Will be available for all components using `cluster` output of this unit.
-     *
-     * @schema
      */
-    kubeconfig: Type.Record(Type.String(), Type.Any()),
+    kubeconfig: z.record(z.string(), z.unknown()),
   },
 
   outputs: clusterOutputs,
 
   meta: {
-    displayName: "Existing Cluster",
+    title: "Existing Cluster",
     description: "An existing Kubernetes cluster.",
-    primaryIcon: "devicon:kubernetes",
+    icon: "devicon:kubernetes",
     category: "Kubernetes",
   },
 
@@ -274,10 +243,8 @@ export const clusterPatch = defineUnit({
      * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
      *
      * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-     *
-     * @schema
      */
-    apiEndpoints: Type.Default(Type.Array(Type.String()), []),
+    apiEndpoints: z.string().array().default([]),
 
     /**
      * The mode to use for patching the API endpoints.
@@ -285,7 +252,7 @@ export const clusterPatch = defineUnit({
      * - `prepend`: prepend the new endpoints to the existing ones (default);
      * - `replace`: replace the existing endpoints with the new ones.
      */
-    apiEndpointsPatchMode: Type.Default(arrayPatchModeSchema, "prepend"),
+    apiEndpointsPatchMode: arrayPatchModeSchema.default("prepend"),
 
     /**
      * The endpoints of the cluster nodes.
@@ -293,10 +260,8 @@ export const clusterPatch = defineUnit({
      * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
      *
      * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-     *
-     * @schema
      */
-    endpoints: Type.Default(Type.Array(Type.String()), []),
+    endpoints: z.string().array().default([]),
 
     /**
      * The mode to use for patching the endpoints.
@@ -304,7 +269,7 @@ export const clusterPatch = defineUnit({
      * - `prepend`: prepend the new endpoints to the existing ones (default);
      * - `replace`: replace the existing endpoints with the new ones.
      */
-    endpointsPatchMode: Type.Default(arrayPatchModeSchema, "prepend"),
+    endpointsPatchMode: arrayPatchModeSchema.default("prepend"),
   },
 
   inputs: {
@@ -324,9 +289,9 @@ export const clusterPatch = defineUnit({
   outputs: clusterOutputs,
 
   meta: {
-    displayName: "Cluster Patch",
+    title: "Cluster Patch",
     description: "Patches some properties of the cluster.",
-    primaryIcon: "devicon:kubernetes",
+    icon: "devicon:kubernetes",
     secondaryIcon: "fluent:patch-20-filled",
     category: "Kubernetes",
   },
@@ -353,9 +318,9 @@ export const clusterDns = defineUnit({
   outputs: clusterOutputs,
 
   meta: {
-    displayName: "Cluster DNS",
+    title: "Cluster DNS",
     description: "Creates DNS records for the cluster and updates endpoints.",
-    primaryIcon: "devicon:kubernetes",
+    icon: "devicon:kubernetes",
     secondaryIcon: "mdi:dns",
     category: "Kubernetes",
   },
@@ -369,12 +334,12 @@ export const clusterDns = defineUnit({
 export const gatewayEntity = defineEntity({
   type: "k8s.gateway",
 
-  schema: Type.Object({
-    clusterId: Type.String(),
-    gatewayClassName: Type.String(),
-    httpListenerPort: Type.Number(),
-    httpsListenerPort: Type.Number(),
-    endpoints: Type.Array(l3EndpointEntity.schema),
+  schema: z.object({
+    clusterId: z.string(),
+    gatewayClassName: z.string(),
+    httpListenerPort: z.number(),
+    httpsListenerPort: z.number(),
+    endpoints: l3EndpointEntity.schema.array(),
   }),
 
   meta: {
@@ -385,9 +350,9 @@ export const gatewayEntity = defineEntity({
 export const tlsIssuerEntity = defineEntity({
   type: "k8s.tls-issuer",
 
-  schema: Type.Object({
-    clusterId: Type.String(),
-    clusterIssuerName: Type.String(),
+  schema: z.object({
+    clusterId: z.string(),
+    clusterIssuerName: z.string(),
   }),
 
   meta: {
@@ -398,11 +363,11 @@ export const tlsIssuerEntity = defineEntity({
 export const accessPointEntity = defineEntity({
   type: "k8s.access-point",
 
-  schema: Type.Object({
-    clusterId: Type.String(),
+  schema: z.object({
+    clusterId: z.string(),
     gateway: gatewayEntity.schema,
     tlsIssuer: tlsIssuerEntity.schema,
-    dnsProviders: Type.Array(dns.providerEntity.schema),
+    dnsProviders: dns.providerEntity.schema.array(),
   }),
 
   meta: {
@@ -427,9 +392,9 @@ export const accessPoint = defineUnit({
   },
 
   meta: {
-    displayName: "Access Point",
+    title: "Access Point",
     description: "An access point which can be used to connect to services.",
-    primaryIcon: "mdi:access-point",
+    icon: "mdi:access-point",
     category: "Kubernetes",
   },
 
@@ -451,9 +416,9 @@ export const certManager = defineUnit({
   },
 
   meta: {
-    displayName: "Cert Manager",
+    title: "Cert Manager",
     description: "A certificate manager for managing TLS certificates.",
-    primaryIcon: "simple-icons:letsencrypt",
+    icon: "simple-icons:letsencrypt",
     category: "Kubernetes",
   },
 
@@ -471,10 +436,8 @@ export const dns01TlsIssuer = defineUnit({
      * The top-level domains to filter the DNS01 challenge for.
      *
      * If not provided, will use all domains passed to the DNS providers.
-     *
-     * @schema
      */
-    domains: Type.Optional(Type.Array(Type.String())),
+    domains: z.string().array().optional(),
   },
 
   inputs: {
@@ -490,9 +453,9 @@ export const dns01TlsIssuer = defineUnit({
   },
 
   meta: {
-    displayName: "DNS01 Issuer",
+    title: "DNS01 Issuer",
     description: "A TLS issuer for issuing certificate using DNS01 challenge.",
-    primaryIcon: "mdi:certificate",
+    icon: "mdi:certificate",
     category: "Kubernetes",
   },
 
@@ -505,10 +468,10 @@ export const dns01TlsIssuer = defineUnit({
 export const deploymentEntity = defineEntity({
   type: "k8s.deployment",
 
-  schema: Type.Object({
-    type: Type.Literal("k8s.deployment"),
-    ...resourceSchema.properties,
-    service: Type.Optional(serviceEntity.schema),
+  schema: z.object({
+    type: z.literal("k8s.deployment"),
+    ...resourceSchema.shape,
+    service: serviceEntity.schema.optional(),
   }),
 
   meta: {
@@ -519,9 +482,9 @@ export const deploymentEntity = defineEntity({
 export const statefulSetEntity = defineEntity({
   type: "k8s.stateful-set",
 
-  schema: Type.Object({
-    type: Type.Literal("k8s.stateful-set"),
-    ...resourceSchema.properties,
+  schema: z.object({
+    type: z.literal("k8s.stateful-set"),
+    ...resourceSchema.shape,
     service: serviceEntity.schema,
   }),
 
@@ -533,7 +496,7 @@ export const statefulSetEntity = defineEntity({
 export const exposableWorkloadEntity = defineEntity({
   type: "k8s.exposable-workload",
 
-  schema: Type.Union([deploymentEntity.schema, statefulSetEntity.schema]),
+  schema: z.union([deploymentEntity.schema, statefulSetEntity.schema]),
 
   meta: {
     color: "#4CAF50",
@@ -543,9 +506,9 @@ export const exposableWorkloadEntity = defineEntity({
 export const persistentVolumeClaimEntity = defineEntity({
   type: "k8s.persistent-volume-claim",
 
-  schema: Type.Object({
-    type: Type.Literal("k8s.persistent-volume-claim"),
-    ...resourceSchema.properties,
+  schema: z.object({
+    type: z.literal("k8s.persistent-volume-claim"),
+    ...resourceSchema.shape,
   }),
 
   meta: {
@@ -556,8 +519,8 @@ export const persistentVolumeClaimEntity = defineEntity({
 export const interfaceEntity = defineEntity({
   type: "k8s.interface",
 
-  schema: Type.Object({
-    name: Type.String(),
+  schema: z.object({
+    name: z.string(),
     workload: exposableWorkloadEntity.schema,
   }),
 
@@ -580,9 +543,9 @@ export const gatewayApi = defineUnit({
   },
 
   meta: {
-    displayName: "Gateway API",
+    title: "Gateway API",
     description: "Installs the Gateway API CRDs to the cluster.",
-    primaryIcon: "devicon:kubernetes",
+    icon: "devicon:kubernetes",
     secondaryIcon: "mdi:api",
     secondaryIconColor: "#4CAF50",
     category: "Kubernetes",
@@ -605,7 +568,7 @@ export const cilium = defineUnit({
      *
      * By default, is `false`.
      */
-    allowForbiddenFqdnResolution: Type.Default(Type.Boolean(), false),
+    allowForbiddenFqdnResolution: z.boolean().default(false),
   },
 
   inputs: {
@@ -617,9 +580,9 @@ export const cilium = defineUnit({
   },
 
   meta: {
-    displayName: "Cilium",
+    title: "Cilium",
     description: "The Cilium CNI deployed on Kubernetes.",
-    primaryIcon: "simple-icons:cilium",
+    icon: "simple-icons:cilium",
     secondaryIcon: "devicon:kubernetes",
     category: "Kubernetes",
   },
@@ -630,24 +593,45 @@ export const cilium = defineUnit({
   },
 })
 
-export type CNI = Static<typeof cniSchema>
-export type Cluster = Static<typeof clusterEntity.schema>
+export const monitorWorkerResourceGroupSchema = z.object({
+  type: z.enum(["deployment", "statefulset", "pod", "service"]),
+  namespace: z.string(),
+  names: z.string().array().optional(),
+})
+
+export const monitorWorkerParamsSchema = z.object({
+  /**
+   * The ID of the secret containing the kubeconfig of the cluster.
+   */
+  kubeconfigSecretId: z.string(),
+
+  /**
+   * The resources to monitor in the cluster.
+   */
+  resourceGroups: monitorWorkerResourceGroupSchema.array(),
+})
+
+export type CNI = z.infer<typeof cniSchema>
+export type Cluster = z.infer<typeof clusterEntity.schema>
+
+export type Gateway = z.infer<typeof gatewayEntity.schema>
+export type TlsIssuer = z.infer<typeof tlsIssuerEntity.schema>
+export type AccessPoint = z.infer<typeof accessPointEntity.schema>
 
-export type Gateway = Static<typeof gatewayEntity.schema>
-export type TlsIssuer = Static<typeof tlsIssuerEntity.schema>
-export type AccessPoint = Static<typeof accessPointEntity.schema>
+export type Metadata = z.infer<typeof metadataSchema>
+export type Resource = z.infer<typeof resourceSchema>
 
-export type Metadata = Static<typeof metadataSchema>
-export type Resource = Static<typeof resourceSchema>
+export type ServiceType = z.infer<typeof serviceTypeSchema>
+export type Service = z.infer<typeof serviceEntity.schema>
 
-export type ServiceType = Static<typeof serviceTypeSchema>
-export type Service = Static<typeof serviceEntity.schema>
+export type Deployment = z.infer<typeof deploymentEntity.schema>
+export type ExposableWorkload = z.infer<typeof exposableWorkloadEntity.schema>
 
-export type Deployment = Static<typeof deploymentEntity.schema>
-export type ExposableWorkload = Static<typeof exposableWorkloadEntity.schema>
+export type PersistentVolumeClaim = z.infer<typeof persistentVolumeClaimEntity.schema>
+export type StatefulSet = z.infer<typeof statefulSetEntity.schema>
 
-export type PersistentVolumeClaim = Static<typeof persistentVolumeClaimEntity.schema>
-export type StatefulSet = Static<typeof statefulSetEntity.schema>
+export type Interface = z.infer<typeof interfaceEntity.schema>
+export type InternalIpsPolicy = z.infer<typeof internalIpsPolicySchema>
 
-export type Interface = Static<typeof interfaceEntity.schema>
-export type InternalIpsPolicy = Static<typeof internalIpsPolicySchema>
+export type MonitorWorkerParams = z.infer<typeof monitorWorkerParamsSchema>
+export type MonitorWorkerResourceGroup = z.infer<typeof monitorWorkerResourceGroupSchema>