@highstate/library 0.9.16 → 0.9.18

package/src/apps/vaultwarden.ts

@@ -1,4 +1,4 @@
-import { defineUnit, Type } from "@highstate/contract"
+import { defineUnit, z } from "@highstate/contract"
 import { createArgs, createInputs, createSource } from "./shared"
 
 export const vaultwarden = defineUnit({
@@ -7,15 +7,15 @@ export const vaultwarden = defineUnit({
   args: createArgs("vaultwarden", ["fqdn"]),
 
   secrets: {
-    mariadbPassword: Type.Optional(Type.String()),
+    mariadbPassword: z.string().optional(),
   },
 
   inputs: createInputs(["accessPoint", "mariadb"]),
 
   meta: {
-    displayName: "Vaultwarden",
+    title: "Vaultwarden",
     description: "The Vaultwarden password manager deployed on Kubernetes.",
-    primaryIcon: "simple-icons:vaultwarden",
+    icon: "simple-icons:vaultwarden",
     category: "Security",
   },
 

package/src/apps/zitadel.ts

@@ -9,9 +9,9 @@ export const zitadel = defineUnit({
   inputs: createInputs(["accessPoint", "postgresql"]),
 
   meta: {
-    displayName: "Zitadel",
+    title: "Zitadel",
     description: "The Zitadel IAM deployed on Kubernetes.",
-    primaryIcon: "hugeicons:access",
+    icon: "hugeicons:access",
   },
 
   source: {

package/src/cloudflare.ts

@@ -1,11 +1,11 @@
-import { defineUnit, Type } from "@highstate/contract"
+import { defineUnit, z } from "@highstate/contract"
 import { providerEntity } from "./dns"
 
 export const connection = defineUnit({
   type: "cloudflare.connection",
 
   secrets: {
-    apiToken: Type.String(),
+    apiToken: z.string(),
   },
 
   outputs: {
@@ -13,9 +13,9 @@ export const connection = defineUnit({
   },
 
   meta: {
-    displayName: "Cloudflare Connection",
+    title: "Cloudflare Connection",
     description: "Creates a new Cloudflare connection for one zone.",
-    primaryIcon: "simple-icons:cloudflare",
+    icon: "simple-icons:cloudflare",
     category: "Cloudflare",
   },
 

package/src/common.ts

@@ -1,4 +1,4 @@
-import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { defineEntity, defineUnit, z } from "@highstate/contract"
 import { credentialsSchema, keyPairEntity } from "./ssh"
 import { l3EndpointEntity } from "./network"
 import * as dns from "./dns"
@@ -7,10 +7,10 @@ import { arrayPatchModeSchema } from "./utils"
 export const serverEntity = defineEntity({
   type: "common.server",
 
-  schema: Type.Object({
-    hostname: Type.String(),
-    endpoints: Type.Array(l3EndpointEntity.schema),
-    ssh: Type.Optional(credentialsSchema),
+  schema: z.object({
+    hostname: z.string(),
+    endpoints: l3EndpointEntity.schema.array(),
+    ssh: credentialsSchema.optional(),
   }),
 
   meta: {
@@ -35,22 +35,22 @@ export const existingServer = defineUnit({
      *
      * Takes precedence over the `endpoint` input.
      */
-    endpoint: Type.Optional(Type.String()),
+    endpoint: z.string().optional(),
 
     /**
      * The SSH user to use for connecting to the server.
      */
-    sshUser: Type.Default(Type.String(), "root"),
+    sshUser: z.string().default("root"),
 
     /**
      * The SSH port to use for connecting to the server.
      */
-    sshPort: Type.Default(Type.Number(), 22),
+    sshPort: z.number().default(22),
   },
 
   secrets: {
-    sshPassword: Type.Optional(Type.String()),
-    sshPrivateKey: Type.Optional(Type.String()),
+    sshPassword: z.string().optional(),
+    sshPrivateKey: z.string().optional(),
   },
 
   inputs: {
@@ -67,9 +67,9 @@ export const existingServer = defineUnit({
   outputs: serverOutputs,
 
   meta: {
-    displayName: "Existing Server",
+    title: "Existing Server",
     description: "An existing server that can be used in the configuration.",
-    primaryIcon: "mdi:server",
+    icon: "mdi:server",
     defaultNamePrefix: "server",
     category: "Infrastructure",
   },
@@ -91,7 +91,7 @@ export const serverPatch = defineUnit({
      *
      * The same server may also be represented by multiple entries (e.g. a node with private and public IP).
      */
-    endpoints: Type.Default(Type.Array(Type.String()), []),
+    endpoints: z.string().array().default([]),
 
     /**
      * The mode to use for patching the endpoints.
@@ -99,7 +99,7 @@ export const serverPatch = 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: {
@@ -120,9 +120,9 @@ export const serverPatch = defineUnit({
   },
 
   meta: {
-    displayName: "Server Patch",
+    title: "Server Patch",
     description: "Patches some properties of the server.",
-    primaryIcon: "mdi:server",
+    icon: "mdi:server",
     secondaryIcon: "fluent:patch-20-filled",
     category: "Infrastructure",
   },
@@ -152,9 +152,9 @@ export const serverDns = defineUnit({
   },
 
   meta: {
-    displayName: "Server DNS",
+    title: "Server DNS",
     description: "Creates DNS records for the server and updates endpoints.",
-    primaryIcon: "mdi:server",
+    icon: "mdi:server",
     secondaryIcon: "mdi:dns",
     category: "Infrastructure",
   },
@@ -169,9 +169,9 @@ export const script = defineUnit({
   type: "common.script",
 
   args: {
-    script: Type.String({ language: "shell" }),
-    updateScript: Type.Optional(Type.String({ language: "shell" })),
-    deleteScript: Type.Optional(Type.String({ language: "shell" })),
+    script: z.string().meta({ language: "shell" }),
+    updateScript: z.string().optional().meta({ language: "shell" }),
+    deleteScript: z.string().optional().meta({ language: "shell" }),
   },
 
   inputs: {
@@ -183,9 +183,9 @@ export const script = defineUnit({
   },
 
   meta: {
-    displayName: "Shell Script",
+    title: "Shell Script",
     description: "Run a shell script on the server.",
-    primaryIcon: "mdi:bash",
+    icon: "mdi:bash",
     category: "Infrastructure",
   },
 
@@ -195,6 +195,6 @@ export const script = defineUnit({
   },
 })
 
-export type Server = Static<typeof serverEntity.schema>
+export type Server = z.infer<typeof serverEntity.schema>
 
 export * from "./files"

package/src/distributions/ubuntu.ts

@@ -1,15 +1,15 @@
-import { defineUnit, Type } from "@highstate/contract"
+import { defineUnit, z } from "@highstate/contract"
 import { fileEntity } from "../files"
 
-export const ubuntuVersionSchema = Type.StringEnum(["22.04", "24.04", "24.10", "25.04", "25.10"])
-export const ubuntuArchitectureSchema = Type.StringEnum(["amd64", "arm64"])
+export const ubuntuVersionSchema = z.enum(["22.04", "24.04", "24.10", "25.04", "25.10"])
+export const ubuntuArchitectureSchema = z.enum(["amd64", "arm64"])
 
 export const ubuntu = defineUnit({
   type: "distributions.ubuntu",
 
   args: {
-    version: Type.Default(ubuntuVersionSchema, "24.04"),
-    architecture: Type.Default(ubuntuArchitectureSchema, "amd64"),
+    version: ubuntuVersionSchema.default("24.04"),
+    architecture: ubuntuArchitectureSchema.default("amd64"),
   },
 
   outputs: {
@@ -18,10 +18,10 @@ export const ubuntu = defineUnit({
   },
 
   meta: {
-    displayName: "Ubuntu",
+    title: "Ubuntu",
     description: "Ubuntu distribution with image and cloud-config.",
-    primaryIcon: "mdi:ubuntu",
-    primaryIconColor: "#E95420",
+    icon: "mdi:ubuntu",
+    iconColor: "#E95420",
     category: "Distributions",
   },
 

package/src/dns.ts

@@ -1,15 +1,15 @@
-import { defineEntity, Type, type Static } from "@highstate/contract"
+import { defineEntity, z } from "@highstate/contract"
 import { endpointFilterSchema } from "./network"
 import { arrayPatchModeSchema, prefixKeysWith } from "./utils"
 
 export const providerEntity = defineEntity({
   type: "dns.provider",
 
-  schema: Type.Object({
-    name: Type.String(),
-    type: Type.String(),
-    data: Type.Record(Type.String(), Type.Unknown()),
-    domain: Type.String(),
+  schema: z.object({
+    name: z.string(),
+    type: z.string(),
+    data: z.record(z.string(), z.unknown()),
+    domain: z.string(),
   }),
 
   meta: {
@@ -26,7 +26,7 @@ export function createArgs<TPrefix extends string = "">(prefix?: TPrefix) {
      *
      * Will throw an error if no matching provider is found.
      */
-    fqdn: Type.Optional(Type.String()),
+    fqdn: z.string().optional(),
 
     /**
      * The endpoint filter to filter the endpoints before creating the DNS records.
@@ -45,7 +45,7 @@ export function createArgs<TPrefix extends string = "">(prefix?: TPrefix) {
      * - Otherwise, if any external endpoints exist, all external endpoints are selected;
      * - If neither exist, all internal endpoints are selected.
      */
-    endpointFilter: Type.Default(endpointFilterSchema, []),
+    endpointFilter: endpointFilterSchema.default([]),
 
     /**
      * The mode to use for patching the existing endpoints.
@@ -55,7 +55,7 @@ export function createArgs<TPrefix extends string = "">(prefix?: TPrefix) {
      *
      * The default is `prepend`.
      */
-    patchMode: Type.Default(arrayPatchModeSchema, "prepend"),
+    patchMode: arrayPatchModeSchema.default("prepend"),
   })
 }
 
@@ -71,4 +71,4 @@ export const inputs = {
   },
 } as const
 
-export type Provider = Static<typeof providerEntity.schema>
+export type Provider = z.infer<typeof providerEntity.schema>

package/src/files.ts

@@ -1,45 +1,37 @@
-import type { Static } from "@sinclair/typebox"
 import {
   defineEntity,
   defineUnit,
-  HighstateSignature,
-  Type,
+  z,
   fileContentSchema as baseFileContentSchema,
   fileMetaSchema as baseFileMetaSchema,
   unitArtifactSchema,
 } from "@highstate/contract"
 import { l7EndpointEntity } from "./network"
 
-export const checksumAlgorithmSchema = Type.StringEnum([
-  "md5",
-  "sha1",
-  "sha256",
-  "sha384",
-  "sha512",
-])
+export const checksumAlgorithmSchema = z.enum(["md5", "sha1", "sha256", "sha384", "sha512"])
 
-export const checksumSchema = Type.Object({
+export const checksumSchema = z.object({
   algorithm: checksumAlgorithmSchema,
-  value: Type.String(),
+  value: z.string(),
 })
 
-export const fileContentSchema = Type.Union([
+export const fileContentSchema = z.union([
   baseFileContentSchema,
-  Type.Object({
-    type: Type.Literal("local"),
-    path: Type.String(),
+  z.object({
+    type: z.literal("local"),
+    path: z.string(),
   }),
-  Type.Object({
-    type: Type.Literal("remote"),
+  z.object({
+    type: z.literal("remote"),
     endpoint: l7EndpointEntity.schema,
-    checksum: Type.Optional(checksumSchema),
+    checksum: checksumSchema.optional(),
   }),
 ])
 
 export const fileEntity = defineEntity({
   type: "common.file",
 
-  schema: Type.Object({
+  schema: z.object({
     meta: baseFileMetaSchema,
     content: fileContentSchema,
   }),
@@ -49,45 +41,42 @@ export const fileEntity = defineEntity({
   },
 })
 
-export const folderMetaSchema = Type.Object({
-  name: Type.String(),
-  mode: Type.Optional(Type.Number()),
+export const folderMetaSchema = z.object({
+  name: z.string(),
+  mode: z.number().optional(),
 })
 
-export const folderContentSchema = Type.Recursive(
-  TSelf => {
-    return Type.Union([
-      Type.Object({
-        type: Type.Literal("embedded"),
-        files: Type.Array(fileEntity.schema),
-        folders: Type.Array(
-          Type.Object({
-            meta: folderMetaSchema,
-            content: TSelf,
-          }),
-        ),
-      }),
-      Type.Object({
-        type: Type.Literal("artifact"),
-        [HighstateSignature.Artifact]: unitArtifactSchema,
-      }),
-      Type.Object({
-        type: Type.Literal("local"),
-        path: Type.String(),
-      }),
-      Type.Object({
-        type: Type.Literal("remote"),
-        endpoint: l7EndpointEntity.schema,
-      }),
-    ])
-  },
-  { $id: "common.folder.content" },
-)
+export const folderContentSchema = z.union([
+  z.object({
+    type: z.literal("embedded"),
+    files: fileEntity.schema.array(),
+    folders: z
+      .object({
+        meta: folderMetaSchema,
+        get content() {
+          return folderContentSchema
+        },
+      })
+      .array(),
+  }),
+  z.object({
+    type: z.literal("artifact"),
+    ...unitArtifactSchema.shape,
+  }),
+  z.object({
+    type: z.literal("local"),
+    path: z.string(),
+  }),
+  z.object({
+    type: z.literal("remote"),
+    endpoint: l7EndpointEntity.schema,
+  }),
+])
 
 export const folderEntity = defineEntity({
   type: "common.folder",
 
-  schema: Type.Object({
+  schema: z.object({
     meta: folderMetaSchema,
     content: folderContentSchema,
   }),
@@ -104,7 +93,7 @@ export const remoteFile = defineUnit({
     /**
      * The URL of the remote file.
      */
-    url: Type.Optional(Type.String()),
+    url: z.string().optional(),
   },
 
   inputs: {
@@ -122,9 +111,9 @@ export const remoteFile = defineUnit({
   },
 
   meta: {
-    displayName: "Remote File",
+    title: "Remote File",
     description: "References a file from a remote URL.",
-    primaryIcon: "mdi:file-download",
+    icon: "mdi:file-download",
     category: "Files",
   },
 
@@ -134,13 +123,13 @@ export const remoteFile = defineUnit({
   },
 })
 
-export type File = Static<typeof fileEntity.schema>
-export type FileMeta = Static<typeof baseFileMetaSchema>
-export type FileContent = Static<typeof fileContentSchema>
+export type File = z.infer<typeof fileEntity.schema>
+export type FileMeta = z.infer<typeof baseFileMetaSchema>
+export type FileContent = z.infer<typeof fileContentSchema>
 
-export type Folder = Static<typeof folderEntity.schema>
-export type FolderMeta = Static<typeof folderMetaSchema>
-export type FolderContent = Static<typeof folderContentSchema>
+export type Folder = z.infer<typeof folderEntity.schema>
+export type FolderMeta = z.infer<typeof folderMetaSchema>
+export type FolderContent = z.infer<typeof folderContentSchema>
 
-export type Checksum = Static<typeof checksumSchema>
-export type ChecksumAlgorithm = Static<typeof checksumAlgorithmSchema>
+export type Checksum = z.infer<typeof checksumSchema>
+export type ChecksumAlgorithm = z.infer<typeof checksumAlgorithmSchema>

package/src/git.ts

@@ -1,4 +1,4 @@
-import { defineUnit, Type } from "@highstate/contract"
+import { defineUnit, z } from "@highstate/contract"
 import { l7EndpointEntity } from "./network"
 import { folderEntity } from "./files"
 
@@ -9,21 +9,21 @@ export const remoteRepository = defineUnit({
     /**
      * The URL of the remote repository.
      */
-    url: Type.Optional(Type.String()),
+    url: z.string().optional(),
 
     /**
      * The ref of the remote repository to checkout.
      *
      * If not specified, the default branch will be used.
      */
-    ref: Type.Optional(Type.String()),
+    ref: z.string().optional(),
 
     /**
      * Whether to include the .git directory in the packed artifact.
      *
      * Do not enable this unless you need the full git history.
      */
-    includeGit: Type.Default(Type.Boolean(), false),
+    includeGit: z.boolean().default(false),
   },
 
   inputs: {
@@ -44,10 +44,10 @@ export const remoteRepository = defineUnit({
   },
 
   meta: {
-    displayName: "Git Remote Repository",
+    title: "Git Remote Repository",
     description: "References a remote Git repository.",
-    primaryIcon: "simple-icons:git",
-    primaryIconColor: "#f1502f",
+    icon: "simple-icons:git",
+    iconColor: "#f1502f",
     category: "Git",
   },
 

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",
@@ -29,7 +29,7 @@ export const cluster = defineUnit({
     /**
      * The components to disable in the K3S cluster.
      */
-    disabledComponents: Type.Default(Type.Array(componentSchema), []),
+    disabledComponents: componentSchema.array().default([]),
 
     /**
      * The CNI to use in the K3S cluster.
@@ -37,31 +37,31 @@ export const cluster = defineUnit({
      * 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.
      */
-    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
      */
-    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
      */
-    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",
   },