@highstate/library 0.9.15 → 0.9.18

package/src/proxmox.ts

@@ -1,22 +1,23 @@
-import { defineEntity, defineUnit, Type } from "@highstate/contract"
-import { serverOutputs } from "./common"
-import { keyPairEntity } from "./ssh"
+import { defineEntity, defineUnit, z } from "@highstate/contract"
+import { checksumSchema, fileEntity, serverOutputs } from "./common"
+import { credentialsSchema, keyPairEntity } from "./ssh"
+import { l7EndpointEntity } from "./network"
 
 export const clusterEntity = defineEntity({
   type: "proxmox.cluster",
 
-  schema: Type.Object({
-    endpoint: Type.String(),
-    insecure: Type.Optional(Type.Boolean()),
-    username: Type.Optional(Type.String()),
+  schema: z.object({
+    endpoint: l7EndpointEntity.schema,
+    insecure: z.boolean().optional(),
+    username: z.string().optional(),
 
-    defaultNodeName: Type.String(),
-    defaultDatastoreId: Type.String(),
+    defaultNodeName: z.string(),
+    defaultDatastoreId: z.string(),
 
-    password: Type.Optional(Type.String()),
-    apiToken: Type.Optional(Type.String()),
+    password: z.string().optional(),
+    apiToken: z.string().optional(),
 
-    sshKeyPair: Type.Optional(keyPairEntity.schema),
+    ssh: credentialsSchema.optional(),
   }),
 
   meta: {
@@ -27,8 +28,8 @@ export const clusterEntity = defineEntity({
 export const imageEntity = defineEntity({
   type: "proxmox.image",
 
-  schema: Type.Object({
-    id: Type.String(),
+  schema: z.object({
+    id: z.string(),
   }),
 
   meta: {
@@ -40,20 +41,85 @@ export const connection = defineUnit({
   type: "proxmox.connection",
 
   args: {
-    endpoint: Type.String(),
-    insecure: Type.Optional(Type.Boolean()),
-    username: Type.Optional(Type.String()),
-
-    defaultNodeName: Type.Optional(Type.String()),
-    defaultDatastoreId: Type.Optional(Type.String()),
+    /**
+     * The endpoint of the Proxmox API.
+     */
+    endpoint: z.string(),
+
+    /**
+     * Whether to allow insecure connections to the Proxmox API.
+     */
+    insecure: z.boolean().optional(),
+
+    /**
+     * The username to use for the Proxmox API.
+     *
+     * Only required for password token authentication.
+     */
+    username: z.string().optional(),
+
+    /**
+     * The name of the default Proxmox node to use for operations.
+     *
+     * If not specified, the first node in the cluster will be used.
+     */
+    defaultNodeName: z.string().optional(),
+
+    /**
+     * The ID of the default Proxmox datastore to use for operations.
+     *
+     * If not specified, the first datastore in the cluster will be used.
+     */
+    defaultDatastoreId: z.string().optional(),
+
+    /**
+     * The username to use for SSH connections to the Proxmox nodes.
+     *
+     * By default, this is set to "root".
+     */
+    sshUser: z.string().default("root"),
+
+    /**
+     * The port to use for SSH connections to the Proxmox nodes.
+     *
+     * By default, this is set to 22.
+     */
+    sshPort: z.number().default(22),
   },
 
   secrets: {
-    password: Type.Optional(Type.String()),
-    apiToken: Type.Optional(Type.String()),
+    /**
+     * The password to use for the Proxmox API.
+     *
+     * Requires `username` to be set.
+     */
+    password: {
+      schema: z.string().optional(),
+      meta: {
+        title: "Proxmox Password",
+      },
+    },
+
+    /**
+     * The Proxmox API token to use for authentication.
+     */
+    apiToken: {
+      schema: z.string().optional(),
+      meta: {
+        title: "Proxmox API Token",
+      },
+    },
+
+    /**
+     * The SSH password to use for connecting to the Proxmox nodes.
+     */
+    sshPassword: z.string().optional(),
   },
 
   inputs: {
+    /**
+     * The key pair to use for SSH connections to the Proxmox nodes.
+     */
     sshKeyPair: {
       entity: keyPairEntity,
       required: false,
@@ -65,11 +131,11 @@ export const connection = defineUnit({
   },
 
   meta: {
-    displayName: "Proxmox Connection",
+    title: "Proxmox Connection",
     description: "The connection to an existing Proxmox cluster.",
     category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
+    icon: "simple-icons:proxmox",
+    iconColor: "#e56901",
   },
 
   source: {
@@ -82,14 +148,54 @@ export const image = defineUnit({
   type: "proxmox.image",
 
   args: {
-    url: Type.String(),
-    nodeName: Type.Optional(Type.String()),
-    sha256: Type.Optional(Type.String()),
-    datastoreId: Type.Optional(Type.String()),
+    /**
+     * The name of the image to upload.
+     *
+     * If not specified, the default name is `<unitName>-<sha256>.<extension>`
+     * or `<unitName>.<extension>` if `sha256` is not provided.
+     */
+    fileName: z.string().optional(),
+
+    /**
+     * The URL of the image to upload.
+     */
+    url: z.string().optional(),
+
+    /**
+     * The checksum of the image file to verify.
+     */
+    checksum: checksumSchema.optional(),
+
+    /**
+     * The name of the Proxmox node to upload the image to.
+     *
+     * If not specified, the default node name from the cluster will be used.
+     */
+    nodeName: z.string().optional(),
+
+    /**
+     * The ID of the Proxmox datastore to upload the image to.
+     *
+     * If not specified, the default datastore ID from the cluster will be used.
+     */
+    datastoreId: z.string().optional(),
   },
 
   inputs: {
+    /**
+     * The Proxmox cluster to upload the image to.
+     */
     proxmoxCluster: clusterEntity,
+
+    /**
+     * The file to upload as an image.
+     *
+     * If `url` is not specified, this file will be used.
+     */
+    file: {
+      entity: fileEntity,
+      required: false,
+    },
   },
 
   outputs: {
@@ -97,11 +203,11 @@ export const image = defineUnit({
   },
 
   meta: {
-    displayName: "Proxmox Image",
+    title: "Proxmox Image",
     description: "The image to upload to a Proxmox cluster.",
     category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
+    icon: "simple-icons:proxmox",
+    iconColor: "#e56901",
     secondaryIcon: "mage:compact-disk-fill",
   },
 
@@ -115,7 +221,7 @@ export const existingImage = defineUnit({
   type: "proxmox.existing-image",
 
   args: {
-    id: Type.String(),
+    id: z.string(),
   },
 
   inputs: {
@@ -127,11 +233,11 @@ export const existingImage = defineUnit({
   },
 
   meta: {
-    displayName: "Proxmox Existing Image",
+    title: "Proxmox Existing Image",
     description: "The existing image on a Proxmox cluster.",
     category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
+    icon: "simple-icons:proxmox",
+    iconColor: "#e56901",
     secondaryIcon: "mage:compact-disk-fill",
   },
 
@@ -145,30 +251,155 @@ export const virtualMachine = defineUnit({
   type: "proxmox.virtual-machine",
 
   args: {
-    nodeName: Type.Optional(Type.String()),
-
-    cpuType: Type.Default(Type.String(), "host"),
-    cores: Type.Default(Type.Number(), 1),
-    sockets: Type.Default(Type.Number(), 1),
-    memory: Type.Default(Type.Number(), 512),
-
-    ipv4: Type.Optional(Type.String()),
-    ipv4Gateway: Type.Optional(Type.String()),
-    dns: Type.Optional(Type.Array(Type.String())),
-
-    datastoreId: Type.Optional(Type.String()),
-    diskSize: Type.Default(Type.Number(), 8),
-    bridge: Type.Default(Type.String(), "vmbr0"),
-
-    sshPort: Type.Default(Type.Number(), 22),
-    sshUser: Type.Default(Type.String(), "root"),
-
-    waitForAgent: Type.Default(Type.Boolean(), true),
-    vendorData: Type.Optional(Type.String({ language: "yaml" })),
+    /**
+     * The name of the node to create the virtual machine on.
+     *
+     * If not specified, the default node name from the cluster will be used.
+     */
+    nodeName: z.string().optional(),
+
+    /**
+     * The ID of the Proxmox datastore to create the virtual machine on.
+     *
+     * If not specified, the default datastore ID from the cluster will be used.
+     */
+    datastoreId: z.string().optional(),
+
+    /**
+     * The type of CPU to use for the virtual machine.
+     *
+     * By default, this is set to "host" which offers the best performance.
+     */
+    cpuType: z.string().default("host"),
+
+    /**
+     * The resources to allocate to the virtual machine.
+     */
+    resources: z
+      .object({
+        /**
+         * The number of CPU cores to allocate to the virtual machine.
+         *
+         * By default, this is set to 1.
+         */
+        cores: z.number(),
+
+        /**
+         * The number of CPU sockets to allocate to the virtual machine.
+         *
+         * By default, this is set to 1.
+         */
+        sockets: z.number(),
+
+        /**
+         * The amount of dedicated memory to allocate to the virtual machine, in MB.
+         *
+         * By default, this is set to 512 MB.
+         */
+        memory: z.number(),
+
+        /**
+         * The size of the disk to create for the virtual machine, in GB.
+         *
+         * By default, this is set to 8 GB.
+         */
+        diskSize: z.number(),
+      })
+      .default({
+        cores: 1,
+        sockets: 1,
+        memory: 512,
+        diskSize: 8,
+      }),
+
+    /**
+     * The IPv4 address configuration for the virtual machine.
+     */
+    ipv4: z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("dhcp"),
+        }),
+        z.object({
+          type: z.literal("static"),
+
+          /**
+           * The IPv4 address to assign to the virtual machine.
+           */
+          address: z.string(),
+
+          /**
+           * The CIDR prefix for the IPv4 address.
+           *
+           * By default, this is set to 24.
+           */
+          prefix: z.number().default(24),
+
+          /**
+           * The IPv4 gateway for the virtual machine.
+           *
+           * If not specified, will be set to the first address in the subnet.
+           */
+          gateway: z.string().optional(),
+        }),
+      ])
+      .default({ type: "dhcp" }),
+
+    /**
+     * The network configuration for the virtual machine.
+     */
+    network: z
+      .object({
+        /**
+         * The list of DNS servers to use for the virtual machine.
+         */
+        dns: z.string().array(),
+
+        /**
+         * The name of the network bridge to connect the virtual machine to.
+         *
+         * By default, this is set to "vmbr0".
+         */
+        bridge: z.string(),
+      })
+      .default({ dns: [], bridge: "vmbr0" }),
+
+    /**
+     * The SSH configuration for the virtual machine.
+     */
+    ssh: z
+      .object({
+        /**
+         * The port to use for SSH connections to the virtual machine.
+         *
+         * By default, this is set to 22.
+         */
+        port: z.number(),
+
+        /**
+         * The user to use for SSH connections to the virtual machine.
+         *
+         * By default, this is set to "root".
+         */
+        user: z.string(),
+      })
+      .default({ port: 22, user: "root" }),
+
+    /**
+     * Whether to wait for the Proxmox agent to be ready before returning.
+     */
+    waitForAgent: z.boolean().default(true),
+
+    /**
+     * The cloud-init vendor data to use for the virtual machine.
+     *
+     * Will take precedence over the `vendorData` input.
+     */
+    vendorData: z.string().optional().meta({ multiline: true }),
   },
 
   secrets: {
-    sshPassword: Type.Optional(Type.String()),
+    sshPassword: z.string().optional(),
   },
 
   inputs: {
@@ -179,16 +410,26 @@ export const virtualMachine = defineUnit({
       entity: keyPairEntity,
       required: false,
     },
+
+    /**
+     * The cloud-init vendor data to use for the virtual machine.
+     *
+     * You can provide a cloud-config from the distribution component.
+     */
+    vendorData: {
+      entity: fileEntity,
+      required: false,
+    },
   },
 
   outputs: serverOutputs,
 
   meta: {
-    displayName: "Proxmox Virtual Machine",
+    title: "Proxmox Virtual Machine",
     description: "The virtual machine on a Proxmox cluster.",
     category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
+    icon: "simple-icons:proxmox",
+    iconColor: "#e56901",
     secondaryIcon: "codicon:vm",
   },
 

package/src/restic.ts

@@ -1,16 +1,16 @@
-import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { defineEntity, defineUnit, z } from "@highstate/contract"
 import { l3EndpointEntity, l4EndpointEntity } from "./network"
 
-export const repoEntity = defineEntity({
-  type: "restic.repo",
+export const repositoryEntity = defineEntity({
+  type: "restic.repository",
 
-  schema: Type.Object({
-    remoteEndpoints: Type.Array(Type.Union([l3EndpointEntity.schema, l4EndpointEntity.schema])),
+  schema: z.object({
+    remoteEndpoints: z.union([l3EndpointEntity.schema, l4EndpointEntity.schema]).array(),
 
-    type: Type.Literal("rclone"),
-    rcloneConfig: Type.String(),
-    remoteName: Type.String(),
-    pathPattern: Type.String(),
+    type: z.literal("rclone"),
+    rcloneConfig: z.string(),
+    remoteName: z.string(),
+    pathPattern: z.string(),
   }),
 
   meta: {
@@ -22,7 +22,7 @@ export const repo = defineUnit({
   type: "restic.repo",
 
   args: {
-    remoteEndpoints: Type.Default(Type.Array(Type.String()), []),
+    remoteEndpoints: z.string().array().default([]),
 
     /**
      * The pattern for the path where backups will be stored for the specific application.
@@ -34,14 +34,12 @@ export const repo = defineUnit({
      * - `$unitName`: The name of the unit, which deploys the application, provided by the user.
      *
      * By default, the path pattern is `backups/$clusterName/$appName`.
-     *
-     * @schema
      */
-    pathPattern: Type.Default(Type.String(), "backups/$clusterName/$appName"),
+    pathPattern: z.string().default("backups/$clusterName/$appName"),
   },
 
   secrets: {
-    rcloneConfig: Type.String({ language: "ini" }),
+    rcloneConfig: z.string(),
   },
 
   inputs: {
@@ -58,14 +56,14 @@ export const repo = defineUnit({
   },
 
   outputs: {
-    repo: repoEntity,
+    repo: repositoryEntity,
   },
 
   meta: {
-    displayName: "Restic Repo",
+    title: "Restic Repo",
     description: "Holds the configuration for a Restic repository and its remote storage.",
-    primaryIconColor: "#e56901",
-    primaryIcon: "material-symbols:backup",
+    iconColor: "#e56901",
+    icon: "material-symbols:backup",
     category: "Infrastructure",
   },
 
@@ -75,4 +73,4 @@ export const repo = defineUnit({
   },
 })
 
-export type Repo = Static<typeof repoEntity.schema>
+export type Repository = z.infer<typeof repositoryEntity.schema>

package/src/sops.ts

@@ -1,11 +1,12 @@
-import { defineUnit, Type } from "@highstate/contract"
-import { fileEntity, serverEntity } from "./common"
+import { defineUnit, z } from "@highstate/contract"
+import { fileEntity } from "./files"
+import { serverEntity } from "./common"
 
 export const secrets = defineUnit({
   type: "sops.secrets",
 
-  args: {
-    secrets: Type.Record(Type.String(), Type.Any()),
+  secrets: {
+    data: z.record(z.string(), z.any()),
   },
 
   inputs: {
@@ -21,9 +22,9 @@ export const secrets = defineUnit({
   },
 
   meta: {
-    displayName: "SOPS Secrets",
+    title: "SOPS Secrets",
     description: "Encrypts secrets using SOPS for the specified servers.",
-    primaryIcon: "mdi:file-lock",
+    icon: "mdi:file-lock",
     category: "Secrets",
   },
 

package/src/ssh.ts

@@ -1,16 +1,17 @@
-import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { defineEntity, defineUnit, z } from "@highstate/contract"
 import { l4EndpointEntity } from "./network"
+import { fileEntity } from "./files"
 
-export const keyTypeSchema = Type.StringEnum(["ed25519"])
+export const keyTypeSchema = z.enum(["ed25519"])
 
 export const keyPairEntity = defineEntity({
   type: "ssh.key-pair",
 
-  schema: Type.Object({
+  schema: z.object({
     type: keyTypeSchema,
-    fingerprint: Type.String(),
-    publicKey: Type.String(),
-    privateKey: Type.String(),
+    fingerprint: z.string(),
+    publicKey: z.string(),
+    privateKey: z.string(),
   }),
 
   meta: {
@@ -18,31 +19,32 @@ export const keyPairEntity = defineEntity({
   },
 })
 
-export const credentialsSchema = Type.Object({
-  endpoints: Type.Array(l4EndpointEntity.schema),
-  hostKey: Type.String(),
-  user: Type.String(),
-  password: Type.Optional(Type.String()),
-  keyPair: Type.Optional(keyPairEntity.schema),
+export const credentialsSchema = z.object({
+  endpoints: l4EndpointEntity.schema.array(),
+  hostKey: z.string(),
+  user: z.string(),
+  password: z.string().optional(),
+  keyPair: keyPairEntity.schema.optional(),
 })
 
 export const keyPair = defineUnit({
   type: "ssh.key-pair",
 
   secrets: {
-    privateKey: Type.Optional(Type.String()),
+    privateKey: z.string().optional(),
   },
 
   outputs: {
     keyPair: keyPairEntity,
+    publicKeyFile: fileEntity,
   },
 
   meta: {
-    displayName: "SSH Key Pair",
+    title: "SSH Key Pair",
     description: "Holds the ED25519 SSH key pair and generates the private key if not provided.",
     category: "ssh",
-    primaryIcon: "charm:key",
-    primaryIconColor: "#ffffff",
+    icon: "charm:key",
+    iconColor: "#ffffff",
     secondaryIcon: "mdi:lock",
     secondaryIconColor: "#ffffff",
   },
@@ -53,6 +55,6 @@ export const keyPair = defineUnit({
   },
 })
 
-export type KeyType = Static<typeof keyTypeSchema>
-export type Credentials = Static<typeof credentialsSchema>
-export type KeyPair = Static<typeof keyPairEntity.schema>
+export type KeyType = z.infer<typeof keyTypeSchema>
+export type Credentials = z.infer<typeof credentialsSchema>
+export type KeyPair = z.infer<typeof keyPairEntity.schema>