@highstate/library 0.9.16 → 0.9.19

package/src/apps/shared.ts

@@ -1,290 +0,0 @@
-import type { TString } from "@sinclair/typebox"
-import type { mariadbEntity } from "./mariadb"
-import type { postgresqlEntity } from "./postgresql"
-import type { mongodbEntity } from "./mongodb"
-import { Type } from "@highstate/contract"
-import {
-  accessPointEntity,
-  clusterEntity,
-  persistentVolumeClaimEntity,
-  serviceEntity,
-} from "../k8s"
-import { repositoryEntity } from "../restic"
-import { providerEntity } from "../dns"
-import { l4EndpointEntity } from "../network"
-
-const extraArgsDefinitions = {
-  fqdn: {
-    schema: Type.String(),
-  },
-  endpoints: {
-    schema: Type.Array(Type.String()),
-    required: false,
-  },
-  external: {
-    schema: Type.Boolean(),
-    required: false,
-  },
-} as const
-
-const extraSecretsDefinitions = {
-  rootPassword: {
-    schema: Type.String(),
-    required: false,
-  },
-  backupPassword: {
-    schema: Type.String(),
-    required: false,
-  },
-}
-
-type LazyExtraInputDefinitions = {
-  mariadb: {
-    entity: typeof mariadbEntity
-    displayName: "MariaDB"
-  }
-  postgresql: {
-    entity: typeof postgresqlEntity
-    displayName: "PostgreSQL"
-  }
-  mongodb: {
-    entity: typeof mongodbEntity
-    displayName: "MongoDB"
-  }
-}
-
-const eagerExtraInputDefinitions = {
-  accessPoint: {
-    entity: accessPointEntity,
-  },
-  resticRepo: {
-    entity: repositoryEntity,
-    required: false,
-  },
-  dnsProviders: {
-    entity: providerEntity,
-    required: false,
-    multiple: true,
-  },
-  volume: {
-    entity: persistentVolumeClaimEntity,
-    required: false,
-  },
-} as const
-
-export const extraInputDefinitions = {
-  ...eagerExtraInputDefinitions,
-} as typeof eagerExtraInputDefinitions & LazyExtraInputDefinitions
-
-type ExtraArgsDefinitions = typeof extraArgsDefinitions
-type ExtraSecretsDefinitions = typeof extraSecretsDefinitions
-type ExtraArgsName = keyof ExtraArgsDefinitions
-type ExtraSecretsName = keyof ExtraSecretsDefinitions
-
-type CreateArgsOptions<R extends readonly ExtraArgsName[], O extends readonly ExtraArgsName[]> = {
-  required?: R
-  optional?: O
-}
-
-type CreateSecretsOptions<
-  R extends readonly ExtraSecretsName[],
-  O extends readonly ExtraSecretsName[],
-> = {
-  required?: R
-  optional?: O
-}
-
-export function createArgs<T extends readonly ExtraArgsName[] = []>(
-  defaultAppName: string,
-  extraArgs?: T,
-): {
-  appName: TString & { default: string }
-} & {
-  [K in T[number]]: ExtraArgsDefinitions[K]
-}
-
-export function createArgs<
-  R extends readonly ExtraArgsName[] = [],
-  O extends readonly ExtraArgsName[] = [],
->(
-  defaultAppName: string,
-  extraArgs?: CreateArgsOptions<R, O>,
-): {
-  appName: TString & { default: string }
-} & {
-  [K in R[number]]: ExtraArgsDefinitions[K] & { required: true }
-} & {
-  [K in O[number]]: ExtraArgsDefinitions[K] & { required: false }
-}
-
-export function createArgs<
-  R extends readonly ExtraArgsName[] = [],
-  O extends readonly ExtraArgsName[] = [],
->(defaultAppName: string, extraArgs?: readonly ExtraArgsName[] | CreateArgsOptions<R, O>) {
-  const base = {
-    appName: Type.Default(Type.String(), defaultAppName),
-  }
-
-  const dynamicArgs: Partial<Record<ExtraArgsName, object>> = {}
-
-  if (Array.isArray(extraArgs)) {
-    for (const name of extraArgs as readonly ExtraArgsName[]) {
-      dynamicArgs[name] = extraArgsDefinitions[name]
-    }
-  } else {
-    const { required, optional } = (extraArgs as CreateArgsOptions<R, O>) ?? {}
-
-    for (const name of required ?? []) {
-      dynamicArgs[name] = {
-        ...extraArgsDefinitions[name],
-        required: true,
-      }
-    }
-
-    for (const name of optional ?? []) {
-      dynamicArgs[name] = {
-        ...extraArgsDefinitions[name],
-        required: false,
-      }
-    }
-  }
-
-  return {
-    ...base,
-    ...dynamicArgs,
-  }
-}
-
-export function createSecrets<T extends readonly ExtraSecretsName[] = []>(
-  extraSecrets?: T,
-): {
-  [K in T[number]]: ExtraSecretsDefinitions[K]
-}
-
-export function createSecrets<
-  R extends readonly ExtraSecretsName[] = [],
-  O extends readonly ExtraSecretsName[] = [],
->(
-  extraSecrets?: CreateSecretsOptions<R, O>,
-): {
-  [K in R[number]]: ExtraSecretsDefinitions[K] & { required: true }
-} & {
-  [K in O[number]]: ExtraSecretsDefinitions[K] & { required: false }
-}
-
-export function createSecrets<
-  R extends readonly ExtraSecretsName[] = [],
-  O extends readonly ExtraSecretsName[] = [],
->(extraSecrets?: readonly ExtraSecretsName[] | CreateSecretsOptions<R, O>) {
-  const dynamicSecrets: Partial<Record<ExtraSecretsName, object>> = {}
-
-  if (Array.isArray(extraSecrets)) {
-    for (const name of extraSecrets as readonly ExtraSecretsName[]) {
-      dynamicSecrets[name] = extraSecretsDefinitions[name]
-    }
-  } else {
-    const { required, optional } = (extraSecrets as CreateSecretsOptions<R, O>) ?? {}
-
-    for (const name of required ?? []) {
-      dynamicSecrets[name] = {
-        ...extraSecretsDefinitions[name],
-        required: true,
-      }
-    }
-
-    for (const name of optional ?? []) {
-      dynamicSecrets[name] = {
-        ...extraSecretsDefinitions[name],
-        required: false,
-      }
-    }
-  }
-
-  return dynamicSecrets as {
-    [K in R[number]]: ExtraSecretsDefinitions[K] & { required: true }
-  } & {
-    [K in O[number]]: ExtraSecretsDefinitions[K] & { required: false }
-  }
-}
-
-type ExtraInputDefinitions = typeof extraInputDefinitions
-type ExtraInputName = keyof ExtraInputDefinitions
-
-type CreateInputsOptions<
-  R extends readonly ExtraInputName[],
-  O extends readonly ExtraInputName[],
-> = {
-  required?: R
-  optional?: O
-}
-
-export function createInputs<T extends readonly ExtraInputName[] = []>(
-  inputs?: T,
-): {
-  k8sCluster: typeof clusterEntity
-} & {
-  [K in T[number]]: ExtraInputDefinitions[K]
-}
-
-export function createInputs<
-  R extends readonly ExtraInputName[] = [],
-  O extends readonly ExtraInputName[] = [],
->(
-  inputs?: CreateInputsOptions<R, O>,
-): {
-  k8sCluster: typeof clusterEntity
-} & {
-  [K in R[number]]: ExtraInputDefinitions[K] & { required: true }
-} & {
-  [K in O[number]]: ExtraInputDefinitions[K] & { required: false }
-}
-
-export function createInputs<
-  R extends readonly ExtraInputName[] = [],
-  O extends readonly ExtraInputName[] = [],
->(inputs?: readonly ExtraInputName[] | CreateInputsOptions<R, O>) {
-  const base = {
-    k8sCluster: clusterEntity,
-  }
-
-  const dynamicInputs: Partial<Record<ExtraInputName, object>> = {}
-
-  if (Array.isArray(inputs)) {
-    for (const name of inputs as readonly ExtraInputName[]) {
-      dynamicInputs[name] = extraInputDefinitions[name]
-    }
-  } else {
-    const { required, optional } = (inputs as CreateInputsOptions<R, O>) ?? {}
-
-    for (const name of required ?? []) {
-      dynamicInputs[name] = {
-        ...extraInputDefinitions[name],
-        required: true,
-      }
-    }
-    for (const name of optional ?? []) {
-      dynamicInputs[name] = {
-        ...extraInputDefinitions[name],
-        required: false,
-      }
-    }
-  }
-
-  return {
-    ...base,
-    ...dynamicInputs,
-  }
-}
-
-export function createSource(path: string) {
-  return {
-    package: "@highstate/apps",
-    path,
-  }
-}
-
-export const databaseSchema = Type.Object({
-  endpoints: Type.Array(l4EndpointEntity.schema),
-  service: Type.Optional(serviceEntity.schema),
-  rootPassword: Type.String(),
-})

package/src/apps/syncthing.ts

@@ -1,54 +0,0 @@
-import { defineUnit, Type } from "@highstate/contract"
-import { persistentVolumeClaimEntity, serviceEntity } from "../k8s"
-import { l4EndpointEntity } from "../network"
-import { createArgs, createInputs, createSecrets, createSource } from "./shared"
-
-export const backupModeSchema = Type.StringEnum(["state", "full"])
-
-export const syncthing = defineUnit({
-  type: "apps.syncthing",
-
-  args: {
-    ...createArgs("syncthing", ["fqdn", "external"]),
-
-    /**
-     * The FQDN of the Syncthing instance used to sync with other devices.
-     *
-     * The `fqdn` argument unlike this one points to the gateway and used to
-     * access the Syncthing Web UI.
-     */
-    deviceFqdn: Type.Optional(Type.String()),
-
-    /**
-     * The backup mode to use for the Syncthing instance.
-     *
-     * - `state`: Only the state is backed up. When the instance is restored, it will
-     * sync files from the other devices automatically.
-     * - `full`: A full backup is created including all files.
-     *
-     * The default is `state`.
-     */
-    backupMode: Type.Default(backupModeSchema, "state"),
-  },
-
-  secrets: createSecrets(["backupPassword"]),
-  inputs: createInputs(["accessPoint", "resticRepo", "volume"]),
-
-  outputs: {
-    volume: persistentVolumeClaimEntity,
-    service: serviceEntity,
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true,
-    },
-  },
-
-  meta: {
-    displayName: "Syncthing",
-    description: "The Syncthing instance deployed on Kubernetes.",
-    primaryIcon: "simple-icons:syncthing",
-    category: "File Sync",
-  },
-
-  source: createSource("syncthing"),
-})

package/src/apps/test.ts

@@ -1,19 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import * as apps from "./mariadb"
-
-import type { InstanceInput } from "@highstate/contract"
-
-declare const cluster: InstanceInput<"k8s.cluster">
-
-const { mariadb, service } = apps.mariadb({
-  name: "test",
-  args: {
-    external: true,
-  },
-  inputs: {
-    k8sCluster: cluster,
-  },
-})
-
-void mariadb
-void service

package/src/apps/traefik.ts

@@ -1,36 +0,0 @@
-import { defineUnit, Type } from "@highstate/contract"
-import { gatewayEntity, serviceEntity } from "../k8s"
-import { l4EndpointEntity } from "../network"
-import { createArgs, createInputs } from "./shared"
-
-export const traefikGateway = defineUnit({
-  type: "apps.traefik-gateway",
-
-  args: {
-    ...createArgs("traefik", ["external"]),
-    className: Type.Optional(Type.String()),
-  },
-
-  inputs: createInputs(),
-
-  outputs: {
-    gateway: gatewayEntity,
-    service: serviceEntity,
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true,
-    },
-  },
-
-  meta: {
-    displayName: "Traefik Gateway",
-    description: "A Traefik gateway for routing traffic to services.",
-    primaryIcon: "simple-icons:traefikproxy",
-    category: "Network",
-  },
-
-  source: {
-    package: "@highstate/apps",
-    path: "traefik",
-  },
-})

package/src/apps/vaultwarden.ts

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

package/src/apps/zitadel.ts

@@ -1,21 +0,0 @@
-import { defineUnit } from "@highstate/contract"
-import { createArgs, createInputs } from "./shared"
-
-export const zitadel = defineUnit({
-  type: "apps.zitadel",
-
-  args: createArgs("zitadel", ["fqdn"]),
-
-  inputs: createInputs(["accessPoint", "postgresql"]),
-
-  meta: {
-    displayName: "Zitadel",
-    description: "The Zitadel IAM deployed on Kubernetes.",
-    primaryIcon: "hugeicons:access",
-  },
-
-  source: {
-    package: "@highstate/apps",
-    path: "zitadel",
-  },
-})

package/src/cloudflare.ts

@@ -1,26 +0,0 @@
-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",
-    category: "Cloudflare",
-  },
-
-  source: {
-    package: "@highstate/cloudflare",
-    path: "connection",
-  },
-})

package/src/common.ts

@@ -1,200 +0,0 @@
-import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
-import { credentialsSchema, keyPairEntity } from "./ssh"
-import { l3EndpointEntity } from "./network"
-import * as dns from "./dns"
-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),
-  }),
-
-  meta: {
-    color: "#009688",
-  },
-})
-
-export const serverOutputs = {
-  server: serverEntity,
-  endpoints: {
-    entity: l3EndpointEntity,
-    multiple: true,
-  },
-} as const
-
-export const existingServer = defineUnit({
-  type: "common.existing-server",
-
-  args: {
-    /**
-     * The endpoint of the server.
-     *
-     * Takes precedence over the `endpoint` input.
-     */
-    endpoint: Type.Optional(Type.String()),
-
-    /**
-     * The SSH user to use for connecting to the server.
-     */
-    sshUser: Type.Default(Type.String(), "root"),
-
-    /**
-     * The SSH port to use for connecting to the server.
-     */
-    sshPort: Type.Default(Type.Number(), 22),
-  },
-
-  secrets: {
-    sshPassword: Type.Optional(Type.String()),
-    sshPrivateKey: Type.Optional(Type.String()),
-  },
-
-  inputs: {
-    sshKeyPair: {
-      entity: keyPairEntity,
-      required: false,
-    },
-    endpoint: {
-      entity: l3EndpointEntity,
-      required: false,
-    },
-  },
-
-  outputs: serverOutputs,
-
-  meta: {
-    displayName: "Existing Server",
-    description: "An existing server that can be used in the configuration.",
-    primaryIcon: "mdi:server",
-    defaultNamePrefix: "server",
-    category: "Infrastructure",
-  },
-
-  source: {
-    package: "@highstate/common",
-    path: "units/existing-server",
-  },
-})
-
-export const serverPatch = defineUnit({
-  type: "common.server-patch",
-
-  args: {
-    /**
-     * The endpoints of the server.
-     *
-     * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
-     *
-     * 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()), []),
-
-    /**
-     * The mode to use for patching the endpoints.
-     *
-     * - `prepend`: prepend the new endpoints to the existing ones (default);
-     * - `replace`: replace the existing endpoints with the new ones.
-     */
-    endpointsPatchMode: Type.Default(arrayPatchModeSchema, "prepend"),
-  },
-
-  inputs: {
-    server: serverEntity,
-    endpoints: {
-      entity: l3EndpointEntity,
-      required: false,
-      multiple: true,
-    },
-  },
-
-  outputs: {
-    server: serverEntity,
-    endpoints: {
-      entity: l3EndpointEntity,
-      multiple: true,
-    },
-  },
-
-  meta: {
-    displayName: "Server Patch",
-    description: "Patches some properties of the server.",
-    primaryIcon: "mdi:server",
-    secondaryIcon: "fluent:patch-20-filled",
-    category: "Infrastructure",
-  },
-
-  source: {
-    package: "@highstate/common",
-    path: "units/server-patch",
-  },
-})
-
-export const serverDns = defineUnit({
-  type: "common.server-dns",
-
-  args: dns.createArgs(),
-
-  inputs: {
-    server: serverEntity,
-    ...dns.inputs,
-  },
-
-  outputs: {
-    server: serverEntity,
-    endpoints: {
-      entity: l3EndpointEntity,
-      multiple: true,
-    },
-  },
-
-  meta: {
-    displayName: "Server DNS",
-    description: "Creates DNS records for the server and updates endpoints.",
-    primaryIcon: "mdi:server",
-    secondaryIcon: "mdi:dns",
-    category: "Infrastructure",
-  },
-
-  source: {
-    package: "@highstate/common",
-    path: "units/server-dns",
-  },
-})
-
-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" })),
-  },
-
-  inputs: {
-    server: serverEntity,
-  },
-
-  outputs: {
-    server: serverEntity,
-  },
-
-  meta: {
-    displayName: "Shell Script",
-    description: "Run a shell script on the server.",
-    primaryIcon: "mdi:bash",
-    category: "Infrastructure",
-  },
-
-  source: {
-    package: "@highstate/common",
-    path: "units/script",
-  },
-})
-
-export type Server = Static<typeof serverEntity.schema>
-
-export * from "./files"