@highstate/library 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/library",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "type": "module",
   "highstate": {
     "type": "library"
@@ -19,14 +19,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@highstate/contract": "^0.10.0",
-    "remeda": "^2.21.0"
+    "remeda": "^2.21.0",
+    "@highstate/contract": "0.13.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.0",
-    "@highstate/cli": "^0.10.0",
     "@typescript/native-preview": "^7.0.0-dev.20250920.1",
-    "type-fest": "^4.41.0"
+    "type-fest": "^4.41.0",
+    "@highstate/cli": "0.13.0"
   },
   "repository": {
     "url": "https://github.com/highstate-io/highstate"

package/src/databases/index.ts

@@ -1,4 +1,6 @@
 export * from "./mariadb"
 export * from "./mongodb"
 export * from "./postgresql"
+export * from "./redis"
+export * from "./s3"
 export * from "./shared"

package/src/databases/redis.ts

@@ -0,0 +1,48 @@
+import { defineEntity, defineUnit, z } from "@highstate/contract"
+import { sharedArgs, sharedInputs, sharedSchema } from "./shared"
+
+/**
+ * Represents the Redis database or virtual database behind it.
+ */
+export const redisEntity = defineEntity({
+  type: "databases.redis.v1",
+
+  schema: sharedSchema.pick({ endpoints: true }).extend({
+    /**
+     * The number of the database to use.
+     */
+    database: z.number().default(0),
+  }),
+
+  meta: {
+    color: "#dc382d",
+  },
+})
+
+/**
+ * The existing Redis database or virtual database behind it.
+ */
+export const existingRedis = defineUnit({
+  type: "databases.redis.existing.v1",
+
+  args: sharedArgs,
+  inputs: sharedInputs,
+
+  outputs: {
+    redis: redisEntity,
+  },
+
+  source: {
+    package: "@highstate/common",
+    path: "units/databases/existing-redis",
+  },
+
+  meta: {
+    title: "Existing Redis Database",
+    icon: "simple-icons:redis",
+    secondaryIcon: "mdi:database",
+    category: "Databases",
+  },
+})
+
+export type Redis = z.infer<typeof redisEntity.schema>

package/src/databases/s3.ts

@@ -0,0 +1,123 @@
+import { $args, $inputs, $secrets, defineEntity, defineUnit, z } from "@highstate/contract"
+import { l4EndpointEntity } from "../network"
+
+export const s3BucketPolicySchema = z.enum(["none", "download", "upload", "public"])
+
+export const s3BucketSchema = z.object({
+  /**
+   * The name of the bucket.
+   */
+  name: z.string(),
+
+  /**
+   * The optional policy applied to the bucket.
+   */
+  policy: s3BucketPolicySchema.optional(),
+})
+
+const s3Args = $args({
+  /**
+   * The endpoints to connect to the S3-compatible API in form of `host:port`.
+   */
+  endpoints: z.string().array().min(1),
+
+  /**
+   * The access key used to authenticate against the S3-compatible API.
+   */
+  accessKey: z.string(),
+
+  /**
+   * The region associated with the S3-compatible deployment.
+   */
+  region: z.string().optional(),
+
+  /**
+   * The buckets that must exist on the instance.
+   */
+  buckets: s3BucketSchema.array().default([]),
+})
+
+const s3Secrets = $secrets({
+  /**
+   * The secret key used to authenticate against the S3-compatible API.
+   */
+  secretKey: z.string(),
+})
+
+const s3Inputs = $inputs({
+  /**
+   * The endpoints to connect to the S3-compatible API.
+   */
+  endpoints: {
+    entity: l4EndpointEntity,
+    multiple: true,
+    required: false,
+  },
+})
+
+/**
+ * Represents an S3-compatible object storage endpoint.
+ */
+export const s3Entity = defineEntity({
+  type: "databases.s3.v1",
+
+  schema: z.object({
+    /**
+     * The endpoints that expose the S3-compatible API.
+     */
+    endpoints: l4EndpointEntity.schema.array(),
+
+    /**
+     * The region associated with the object storage instance.
+     */
+    region: z.string().optional(),
+
+    /**
+     * The access key used to authenticate against the API.
+     */
+    accessKey: z.string(),
+
+    /**
+     * The secret key used to authenticate against the API.
+     */
+    secretKey: z.string(),
+
+    /**
+     * The buckets that must exist on the instance.
+     */
+    buckets: s3BucketSchema.array(),
+  }),
+
+  meta: {
+    color: "#ff9900",
+  },
+})
+
+/**
+ * The existing S3-compatible object storage instance.
+ */
+export const existingS3 = defineUnit({
+  type: "databases.s3.existing.v1",
+
+  args: s3Args,
+  secrets: s3Secrets,
+  inputs: s3Inputs,
+
+  outputs: {
+    s3: s3Entity,
+  },
+
+  source: {
+    package: "@highstate/common",
+    path: "units/databases/existing-s3",
+  },
+
+  meta: {
+    title: "Existing S3-Compatible Storage",
+    icon: "simple-icons:amazons3",
+    secondaryIcon: "mdi:bucket",
+    category: "Databases",
+  },
+})
+
+export type S3 = z.infer<typeof s3Entity.schema>

package/src/k8s/apps/index.ts

@@ -4,8 +4,10 @@ export * from "./hubble"
 export * from "./kubernetes-dashboard"
 export * from "./mariadb"
 export * from "./maybe"
+export * from "./minio"
 export * from "./mongodb"
 export * from "./postgresql"
+export * from "./remnawave"
 export {
   appName,
   optionalSharedArgs,
@@ -18,5 +20,6 @@ export * from "./syncthing"
 // export * from "./zitadel"
 // export * from "./gitea"
 export * from "./traefik"
+export * from "./valkey"
 export * from "./vaultwarden"
 export * from "./workload"

package/src/k8s/apps/maybe.ts

@@ -24,7 +24,7 @@ export const maybe = defineUnit({
   },
 
   inputs: {
-    ...pick(sharedInputs, ["k8sCluster", "accessPoint", "postgresql"]),
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint", "postgresql", "redis"]),
     ...pick(optionalSharedInputs, ["resticRepo"]),
   },
 

package/src/k8s/apps/minio.ts

@@ -0,0 +1,81 @@
+import { $secrets, defineUnit, text, z } from "@highstate/contract"
+import { pick } from "remeda"
+import * as databases from "../../databases"
+import { l4EndpointEntity } from "../../network"
+import { serviceEntity } from "../service"
+import { appName, optionalSharedInputs, sharedArgs, sharedInputs, source } from "./shared"
+
+const minioSecrets = $secrets({
+  /**
+   * The secret key used to authenticate with MinIO.
+   */
+  secretKey: z.string().optional(),
+
+  /**
+   * The key that protects Restic backups.
+   */
+  backupKey: z.string().optional(),
+})
+
+/**
+ * The MinIO object storage deployed on Kubernetes.
+ */
+export const minio = defineUnit({
+  type: "k8s.apps.minio.v1",
+  args: {
+    ...appName("minio"),
+    ...pick(sharedArgs, ["external"]),
+
+    accessKey: {
+      schema: z.string().default("admin"),
+      meta: {
+        description: text`
+          The access key used to authenticate with MinIO.
+          If not provided, defaults to "admin".
+        `,
+      },
+    },
+
+    region: {
+      schema: z.string().optional(),
+      meta: {
+        description: text`The region associated with the MinIO deployment.`,
+      },
+    },
+
+    buckets: {
+      schema: databases.s3BucketSchema.array().default([]),
+      meta: {
+        description: text`
+          The buckets that must exist on the MinIO instance.
+          Each entry can optionally include a bucket policy: none, download, upload, or public.
+        `,
+      },
+    },
+  },
+
+  secrets: minioSecrets,
+
+  inputs: {
+    ...pick(sharedInputs, ["k8sCluster"]),
+    ...pick(optionalSharedInputs, ["resticRepo"]),
+  },
+
+  outputs: {
+    s3: databases.s3Entity,
+    service: serviceEntity,
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true,
+    },
+  },
+
+  meta: {
+    title: "MinIO",
+    icon: "simple-icons:minio",
+    secondaryIcon: "mdi:bucket",
+    category: "Databases",
+  },
+
+  source: source("minio/app"),
+})

package/src/k8s/apps/remnawave.ts

@@ -0,0 +1,66 @@
+import { defineEntity, defineUnit, z } from "@highstate/contract"
+import { pick } from "remeda"
+import { optionalSharedInputs, sharedInputs, source } from "./shared"
+
+export const remnawaveEntity = defineEntity({
+  type: "k8s.apps.remnawave.v1",
+
+  schema: z.object({
+    /**
+     * The ID of the Remnawave instance.
+     */
+    instanceId: z.string(),
+  }),
+})
+
+/**
+ * The Remnawave backend deployed on Kubernetes.
+ */
+export const remnawave = defineUnit({
+  type: "k8s.apps.remnawave.backend.v1",
+
+  secrets: {
+    jwtAuthSecret: z.string(),
+    jwtApiTokensSecret: z.string(),
+  },
+
+  inputs: {
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint", "postgresql", "redis"]),
+    ...pick(optionalSharedInputs, ["resticRepo"]),
+  },
+
+  outputs: {
+    remnawave: remnawaveEntity,
+  },
+
+  meta: {
+    title: "Remnawave Backend",
+    icon: "mdi:waveform",
+    iconColor: "#0066cc",
+    category: "VPN",
+  },
+
+  source: source("remnawave/backend"),
+})
+
+/**
+ * The Remnawave node deployed on Kubernetes.
+ */
+export const node = defineUnit({
+  type: "k8s.apps.remnawave.node.v1",
+
+  inputs: {
+    remnawave: remnawaveEntity,
+    ...pick(sharedInputs, ["k8sCluster"]),
+  },
+
+  meta: {
+    title: "Remnawave Node",
+    icon: "mdi:waveform",
+    iconColor: "#0066cc",
+    secondaryIcon: "mdi:server-network",
+    category: "VPN",
+  },
+
+  source: source("remnawave/node"),
+})

package/src/k8s/apps/shared.ts

@@ -12,7 +12,7 @@ import {
 } from "@highstate/contract"
 import { mapValues } from "remeda"
 import { accessPointEntity } from "../../common"
-import { mariadbEntity, mongodbEntity, postgresqlEntity } from "../../databases"
+import { mariadbEntity, mongodbEntity, postgresqlEntity, redisEntity } from "../../databases"
 import { providerEntity } from "../../dns"
 import { repositoryEntity } from "../../restic"
 import { namespaceEntity, persistentVolumeClaimEntity } from "../resources"
@@ -138,6 +138,9 @@ export const sharedInputs = $inputs({
   mongodb: {
     entity: mongodbEntity,
   },
+  redis: {
+    entity: redisEntity,
+  },
 })
 
 type ToOptionalInputs<T extends Record<string, FullComponentInputOptions>> = Simplify<{

package/src/k8s/apps/traefik.ts

@@ -14,7 +14,13 @@ export const traefik = defineUnit({
   args: {
     ...appName("traefik"),
     ...pick(sharedArgs, ["external", "replicas", "endpoints"]),
-    className: z.string().optional(),
+
+    /**
+     * The name of the class to configure for ingress and gateway resources.
+     *
+     * Defaults to "traefik".
+     */
+    className: z.string().default("traefik"),
   },
 
   inputs: {

package/src/k8s/apps/valkey.ts

@@ -0,0 +1,52 @@
+import { defineUnit } from "@highstate/contract"
+import { pick } from "remeda"
+import { databases } from "../.."
+import { l4EndpointEntity } from "../../network"
+import { serviceEntity } from "../service"
+import {
+  appName,
+  optionalSharedInputs,
+  sharedArgs,
+  sharedInputs,
+  sharedSecrets,
+  source,
+} from "./shared"
+
+/**
+ * The Valkey instance deployed on Kubernetes.
+ */
+export const valkey = defineUnit({
+  type: "k8s.apps.valkey.v1",
+
+  args: {
+    ...appName("valkey"),
+    ...pick(sharedArgs, ["external"]),
+  },
+
+  secrets: {
+    ...pick(sharedSecrets, ["backupKey"]),
+  },
+
+  inputs: {
+    ...pick(sharedInputs, ["k8sCluster"]),
+    ...pick(optionalSharedInputs, ["resticRepo"]),
+  },
+
+  outputs: {
+    redis: databases.redisEntity,
+    service: serviceEntity,
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true,
+    },
+  },
+
+  meta: {
+    title: "Valkey (Redis)",
+    icon: "simple-icons:redis",
+    secondaryIcon: "mdi:database",
+    category: "Databases",
+  },
+
+  source: source("valkey/app"),
+})

package/src/proxmox.ts

@@ -260,6 +260,13 @@ export const virtualMachine = defineUnit({
   type: "proxmox.virtual-machine.v1",
 
   args: {
+    /**
+     * The name of the virtual machine.
+     *
+     * If not specified, the unit name will be used.
+     */
+    vmName: z.string().optional(),
+
     /**
      * The name of the node to create the virtual machine on.
      *

package/src/third-party/timeweb.ts

@@ -46,6 +46,13 @@ export const virtualMachine = defineUnit({
   type: "timeweb.virtual-machine.v1",
 
   args: {
+    /**
+     * The name of the virtual machine.
+     *
+     * If not provided, the name of the unit will be used.
+     */
+    vmName: z.string().optional(),
+
     /**
      * The ID of the preset to use for the virtual machine.
      *
@@ -97,3 +104,5 @@ export const virtualMachine = defineUnit({
     path: "virtual-machine",
   },
 })
+
+export type Connection = z.infer<typeof connectionEntity.schema>

package/src/third-party/yandex.ts

@@ -342,6 +342,15 @@ export const virtualMachine = defineUnit({
          * Whether to assign a public IP.
          */
         assignPublicIp: z.boolean().default(true),
+
+        /**
+         * Whether to reserve the public IP permanently.
+         *
+         * If not set, the public IP can be changed when the VM is stopped and started again.
+         *
+         * Makes no sense if `assignPublicIp` is false.
+         */
+        reservePublicIp: z.boolean().default(true),
       })
       .prefault({}),