@highstate/library 0.7.1 → 0.7.3

package/src/apps/mongodb.ts

@@ -0,0 +1,96 @@
+import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { clusterEntity, serviceEntity, serviceTypeSchema } from "../k8s"
+import { repoEntity } from "../restic"
+import { providerEntity } from "../dns"
+
+export const mongodbEntity = defineEntity({
+  type: "apps.mongodb",
+
+  schema: Type.Object({
+    service: Type.Optional(serviceEntity.schema),
+
+    host: Type.String(),
+    port: Type.Number(),
+    rootPassword: Type.String(),
+  }),
+
+  meta: {
+    color: "#13aa52",
+  },
+})
+
+export const mongodb = defineUnit({
+  type: "apps.mongodb",
+
+  args: {
+    fqdn: Type.Optional(Type.String()),
+    appName: Type.Optional(Type.String()),
+    serviceType: Type.Optional(serviceTypeSchema),
+  },
+
+  secrets: {
+    rootPassword: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    k8sCluster: clusterEntity,
+    resticRepo: {
+      entity: repoEntity,
+      required: false,
+    },
+    dnsProvider: {
+      entity: providerEntity,
+      required: false,
+    },
+  },
+
+  outputs: {
+    mongodb: mongodbEntity,
+    service: serviceEntity,
+  },
+
+  meta: {
+    displayName: "MongoDB",
+    description: "The MongoDB instance deployed on Kubernetes.",
+    primaryIcon: "simple-icons:mongodb",
+    secondaryIcon: "mdi:database",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "mongodb/app",
+  },
+})
+
+export const mongodbDatabase = defineUnit({
+  type: "apps.mongodb.database",
+
+  args: {
+    database: Type.Optional(Type.String()),
+    username: Type.Optional(Type.String()),
+  },
+
+  secrets: {
+    password: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    k8sCluster: clusterEntity,
+    mongodb: mongodbEntity,
+  },
+
+  meta: {
+    displayName: "MongoDB Database",
+    description:
+      "The virtual MongoDB database created on the MongoDB instance. Works only for MongoDB instances deployed on Kubernetes.",
+    primaryIcon: "simple-icons:mongodb",
+    secondaryIcon: "mdi:database-plus",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "mongodb/database",
+  },
+})
+
+export type MongoDB = Static<typeof mongodbEntity.schema>

package/src/apps/postgresql.ts

@@ -0,0 +1,95 @@
+import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { clusterEntity, serviceEntity } from "../k8s"
+import { repoEntity } from "../restic"
+import { providerEntity } from "../dns"
+
+export const postgresqlEntity = defineEntity({
+  type: "apps.postgresql",
+
+  schema: Type.Object({
+    service: Type.Optional(serviceEntity.schema),
+
+    host: Type.String(),
+    port: Type.Number(),
+    rootPassword: Type.String(),
+  }),
+
+  meta: {
+    color: "#336791",
+  },
+})
+
+export const postgresql = defineUnit({
+  type: "apps.postgresql",
+
+  args: {
+    fqdn: Type.Optional(Type.String()),
+    appName: Type.Optional(Type.String()),
+  },
+
+  secrets: {
+    rootPassword: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    k8sCluster: clusterEntity,
+    resticRepo: {
+      entity: repoEntity,
+      required: false,
+    },
+    dnsProvider: {
+      entity: providerEntity,
+      required: false,
+    },
+  },
+
+  outputs: {
+    postgresql: postgresqlEntity,
+    service: serviceEntity,
+  },
+
+  meta: {
+    displayName: "PostgreSQL",
+    description: "The PostgreSQL database deployed on Kubernetes.",
+    primaryIcon: "simple-icons:postgresql",
+    secondaryIcon: "mdi:database",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "postgresql/app",
+  },
+})
+
+export const postgresqlDatabase = defineUnit({
+  type: "apps.postgresql.database",
+
+  args: {
+    database: Type.Optional(Type.String()),
+    username: Type.Optional(Type.String()),
+  },
+
+  secrets: {
+    password: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    k8sCluster: clusterEntity,
+    postgresql: postgresqlEntity,
+  },
+
+  meta: {
+    displayName: "PostgreSQL Database",
+    description:
+      "The virtual PostgreSQL database created on the PostgreSQL instance. Works only for PostgreSQL instances deployed on Kubernetes.",
+    primaryIcon: "simple-icons:postgresql",
+    secondaryIcon: "mdi:database-plus",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "postgresql/database",
+  },
+})
+
+export type PostgreSQL = Static<typeof postgresqlEntity.schema>

package/src/apps/syncthing.ts

@@ -0,0 +1,50 @@
+import { defineUnit, Type } from "@highstate/contract"
+import {
+  accessPointEntity,
+  clusterEntity,
+  persistentVolumeClaimEntity,
+  serviceEntity,
+} from "../k8s"
+import { repoEntity } from "../restic"
+
+export const backupModeSchema = Type.Union([Type.Literal("metadata"), Type.Literal("full")])
+
+export const syncthing = defineUnit({
+  type: "apps.syncthing",
+
+  args: {
+    fqdn: Type.String(),
+    deviceFqdn: Type.Optional(Type.String()),
+    appName: Type.Optional(Type.String()),
+    backupMode: Type.Optional({ ...backupModeSchema, default: "metadata" }),
+  },
+
+  inputs: {
+    accessPoint: accessPointEntity,
+    k8sCluster: clusterEntity,
+    resticRepo: {
+      entity: repoEntity,
+      required: false,
+    },
+    volume: {
+      entity: persistentVolumeClaimEntity,
+      required: false,
+    },
+  },
+
+  outputs: {
+    service: serviceEntity,
+    volume: persistentVolumeClaimEntity,
+  },
+
+  meta: {
+    displayName: "Syncthing",
+    description: "The Syncthing instance deployed on Kubernetes.",
+    primaryIcon: "simple-icons:syncthing",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "syncthing",
+  },
+})

package/src/apps/traefik.ts

@@ -0,0 +1,32 @@
+import { defineUnit, Type } from "@highstate/contract"
+import { clusterEntity, gatewayEntity, serviceEntity, serviceTypeSchema } from "../k8s"
+
+export const traefikGateway = defineUnit({
+  type: "apps.traefik-gateway",
+
+  args: {
+    appName: Type.Optional(Type.String()),
+    className: Type.Optional(Type.String()),
+    serviceType: Type.Optional(serviceTypeSchema),
+  },
+
+  inputs: {
+    k8sCluster: clusterEntity,
+  },
+
+  outputs: {
+    gateway: gatewayEntity,
+    service: serviceEntity,
+  },
+
+  meta: {
+    displayName: "Traefik Gateway",
+    description: "A Traefik gateway for routing traffic to services.",
+    primaryIcon: "simple-icons:traefikproxy",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "traefik",
+  },
+})

package/src/apps/vaultwarden.ts

@@ -0,0 +1,33 @@
+import { defineUnit, Type } from "@highstate/contract"
+import { accessPointEntity, clusterEntity } from "../k8s"
+import { mariadbEntity } from "./mariadb"
+
+export const vaultwarden = defineUnit({
+  type: "apps.vaultwarden",
+
+  args: {
+    fqdn: Type.String(),
+    appName: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    mariadb: mariadbEntity,
+    accessPoint: accessPointEntity,
+    k8sCluster: clusterEntity,
+  },
+
+  secrets: {
+    mariadbPassword: Type.Optional(Type.String()),
+  },
+
+  meta: {
+    displayName: "Vaultwarden",
+    description: "The Vaultwarden password manager deployed on Kubernetes.",
+    primaryIcon: "simple-icons:vaultwarden",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "vaultwarden",
+  },
+})

package/src/apps/zitadel.ts

@@ -0,0 +1,31 @@
+import { defineUnit, Type } from "@highstate/contract"
+import { accessPointEntity, clusterEntity } from "../k8s"
+import { postgresqlEntity } from "./postgresql"
+
+export const zitadel = defineUnit({
+  type: "apps.zitadel",
+
+  args: {
+    domain: Type.String(),
+  },
+
+  inputs: {
+    postgresql: {
+      entity: postgresqlEntity,
+      displayName: "PostgreSQL",
+    },
+    accessPoint: accessPointEntity,
+    k8sCluster: clusterEntity,
+  },
+
+  meta: {
+    displayName: "Zitadel",
+    description: "The Zitadel IAM deployed on Kubernetes.",
+    primaryIcon: "hugeicons:access",
+  },
+
+  source: {
+    package: "@highstate/apps",
+    path: "zitadel",
+  },
+})

package/src/cloudflare.ts

@@ -0,0 +1,25 @@
+import { defineUnit, Type } from "@highstate/contract"
+import { providerEntity } from "./dns"
+
+export const connection = defineUnit({
+  type: "cloudflare.connection",
+
+  secrets: {
+    apiToken: Type.String(),
+  },
+
+  outputs: {
+    dnsProvider: providerEntity,
+  },
+
+  meta: {
+    displayName: "Cloudflare Connection",
+    description: "Creates a new Cloudflare connection for one zone.",
+    primaryIcon: "simple-icons:cloudflare",
+  },
+
+  source: {
+    package: "@highstate/cloudflare",
+    path: "connection",
+  },
+})

package/src/common.ts

@@ -0,0 +1,70 @@
+import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { credentialsSchema, keyPairEntity } from "./ssh"
+
+export const serverEntity = defineEntity({
+  type: "common.server",
+
+  schema: Type.Object({
+    endpoint: Type.String(),
+    hostname: Type.String(),
+    sshCredentials: Type.Optional(credentialsSchema),
+  }),
+
+  meta: {
+    color: "#009688",
+  },
+})
+
+export const endpointEntity = defineEntity({
+  type: "common.endpoint",
+
+  schema: Type.Object({
+    endpoint: Type.String(),
+  }),
+
+  meta: {
+    color: "#FFC107",
+    description: "The L3-L4 endpoint for some network service.",
+  },
+})
+
+export const existingServer = defineUnit({
+  type: "common.existing-server",
+
+  args: {
+    endpoint: Type.String(),
+    sshUser: Type.Optional(Type.String({ default: "root" })),
+    sshPort: Type.Optional(Type.Number({ default: 22 })),
+  },
+
+  secrets: {
+    sshPassword: Type.Optional(Type.String()),
+    sshPrivateKey: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    sshKeyPair: {
+      entity: keyPairEntity,
+      required: false,
+    },
+  },
+
+  outputs: {
+    server: serverEntity,
+  },
+
+  meta: {
+    displayName: "Existing Server",
+    description: "An existing server that can be used in the configuration.",
+    primaryIcon: "mdi:server",
+    defaultNamePrefix: "server",
+  },
+
+  source: {
+    package: "@highstate/common",
+    path: "existing-server",
+  },
+})
+
+export type Server = Static<typeof serverEntity.schema>
+export type Endpoint = Static<typeof endpointEntity.schema>

package/src/dns.ts

@@ -0,0 +1,45 @@
+import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+
+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(),
+  }),
+
+  meta: {
+    color: "#FF5722",
+  },
+})
+
+export const record = defineUnit({
+  type: "common.dns-record",
+
+  args: {
+    name: Type.String(),
+    type: Type.String(),
+    value: Type.String(),
+    ttl: Type.Optional(Type.Number()),
+  },
+
+  inputs: {
+    dnsProvider: providerEntity,
+  },
+
+  meta: {
+    displayName: "DNS Record",
+    description: "A DNS record to create.",
+    primaryIcon: "mdi:server",
+    defaultNamePrefix: "record",
+  },
+
+  source: {
+    package: "@highstate/common",
+    path: "dns/record",
+  },
+})
+
+export type Provider = Static<typeof providerEntity.schema>

package/src/index.ts

@@ -0,0 +1,13 @@
+export * as common from "./common"
+export * as proxmox from "./proxmox"
+export * as ssh from "./ssh"
+export * as k8s from "./k8s"
+export * as talos from "./talos"
+export * as wireguard from "./wireguard"
+export * as apps from "./apps"
+export * as cloudflare from "./cloudflare"
+export * as k3s from "./k3s"
+// export * as xtWgobfs from "./xt-wgobfs"
+export * as restic from "./restic"
+export * as mullvad from "./mullvad"
+export * as dns from "./dns"

package/src/k3s.ts

@@ -0,0 +1,28 @@
+import { defineUnit } from "@highstate/contract"
+import { serverEntity } from "./common"
+import { clusterEntity } from "./k8s"
+
+export const cluster = defineUnit({
+  type: "k3s.cluster",
+
+  inputs: {
+    server: serverEntity,
+  },
+
+  outputs: {
+    k8sCluster: clusterEntity,
+  },
+
+  meta: {
+    displayName: "K3s Cluster",
+    description: "The K3s cluster created on top of the server.",
+    category: "k3s",
+    primaryIcon: "devicon:k3s",
+    secondaryIcon: "devicon:kubernetes",
+  },
+
+  source: {
+    package: "@highstate/k3s",
+    path: "cluster",
+  },
+})