Feat dock stacks and dock node

apps/api/package.json

@@ -11,12 +11,15 @@
     "@dockstat/db": "workspace:*",
     "@dockstat/docker-client": "workspace:*",
     "@dockstat/logger": "workspace:*",
+    "@dockstat/theme-handler": "workspace:*",
+    "@dockstat/docknode": "workspace:*",
     "@dockstat/plugin-handler": "workspace:*",
     "@dockstat/sqlite-wrapper": "workspace:*",
     "@dockstat/typings": "workspace:*",
     "@dockstat/repo-cli": "workspace:*",
     "@dockstat/ui": "workspace:*",
     "@dockstat/utils": "workspace:*",
+    "@elysiajs/eden": "catalog:",
     "@elysiajs/cors": "^1.4.0",
     "@elysiajs/openapi": "^1.4.11",
     "@elysiajs/server-timing": "^1.4.0",

apps/api/src/docknode/index.ts

@@ -0,0 +1,108 @@
+import type { DockNodeTreaty } from "@dockstat/docknode/treaty"
+import type Logger from "@dockstat/logger"
+import { column, type DB, type QueryBuilder } from "@dockstat/sqlite-wrapper"
+import type { DockStatConfigTableType } from "@dockstat/typings/types"
+import { treaty } from "@elysiajs/eden"
+import type { DockNodeTable } from "./type"
+
+class DockNodeHandler {
+  private table: QueryBuilder<DockNodeTable>
+  private logger: Logger
+  private loadedNodes = new Map<number, ReturnType<typeof treaty<DockNodeTreaty>>["api"]>()
+
+  constructor(DB: DB, logger: Logger) {
+    this.logger = logger.spawn("DNH")
+    this.table = DB.createTable<DockNodeTable>(
+      "docknode-register",
+      {
+        id: column.id(),
+        name: column.text(),
+        host: column.text(),
+        port: column.integer(),
+        useSSL: column.boolean(),
+        keys: column.foreignKey<DockStatConfigTableType>("config", "keys", {
+          references: {
+            onDelete: "NO ACTION",
+            onUpdate: "CASCADE",
+            column: "keys",
+            table: "config",
+          },
+          type: "JSON",
+        }),
+        timeout: column.integer({ default: 60 }),
+      },
+      { ifNotExists: true }
+    )
+
+    this.logger.info("DockNode-Hanlder initialising")
+
+    const allDockNodeClients = this.table.select(["*"]).all()
+
+    for (const node of allDockNodeClients) {
+      this.loadedNodes.set(
+        Number(node.id),
+        treaty<DockNodeTreaty>(`${node.useSSL ? "https://" : "http://"}${node.host}:${node.port}`)
+          .api
+      )
+    }
+
+    this.logger.info("DockNode-Hanlder initialized.")
+  }
+
+  private setLoadedNode(node: DockNodeTable) {
+    return this.loadedNodes.set(
+      Number(node.id),
+      treaty<DockNodeTreaty>(`${node.useSSL ? "https://" : "http://"}${node.host}:${node.port}`).api
+    )
+  }
+
+  async getAllNodes() {
+    this.logger.info("Getting all nodes")
+    const allNodes = this.table.select(["*"]).all()
+
+    this.logger.debug(`Got ${allNodes.length} node(s)`)
+
+    const res = await Promise.all(
+      allNodes.map(async (n) => {
+        this.logger.debug(`Getting online state for ${n.id}`)
+        const dnc = this.loadedNodes.get(Number(n.id))
+
+        if (!dnc) {
+          return {
+            ...n,
+            isReachable: "DockNode not initialised",
+          }
+        }
+
+        const state = (await dnc?.status.get())?.data ?? "NO"
+
+        this.logger.info(`State for ${n.id}: ${state}`)
+
+        return {
+          ...n,
+          isReachable: state,
+        }
+      })
+    )
+
+    return res
+  }
+
+  createNode(cfg: Omit<DockNodeTable, "keys">) {
+    const insertRes = this.table.insert(cfg)
+
+    const node = this.table.select(["*"]).where({ id: insertRes.insertId }).first()
+
+    if (node !== null) {
+      this.setLoadedNode(node)
+    }
+
+    return insertRes
+  }
+
+  delteNode(id: number) {
+    return this.table.where({ id: id }).delete()
+  }
+}
+
+export default DockNodeHandler

apps/api/src/docknode/type.ts

@@ -0,0 +1,11 @@
+import type { DockStatConfigTableType } from "@dockstat/typings/types"
+
+export type DockNodeTable = {
+  id?: number
+  name: string
+  host: string
+  port: number
+  useSSL: boolean
+  timeout: number
+  keys: DockStatConfigTableType["keys"]
+}

apps/api/src/index.ts

@@ -7,9 +7,11 @@ import MetricsMiddleware from "./middleware/metrics"
 import DBRoutes from "./routes/db"
 import DockerRoutes from "./routes/docker"
 import DockStatMiscRoutes from "./routes/misc"
+import { DockNodeElyisa } from "./routes/node"
 import PluginRoutes from "./routes/plugins"
 import RepositoryRoutes from "./routes/repositories"
 import StatusRoutes from "./routes/status"
+import ThemeRoutes from "./routes/themes"
 import DockStatWebsockets from "./websockets"
 
 const PORT = Bun.env.DOCKSTATAPI_PORT || 3030
@@ -25,7 +27,9 @@ export const DockStatAPI = new Elysia({ prefix: "/api/v2" })
   .use(PluginRoutes)
   .use(DockStatMiscRoutes)
   .use(RepositoryRoutes)
+  .use(ThemeRoutes)
   .use(DockStatWebsockets)
+  .use(DockNodeElyisa)
   .listen(PORT)
 
 const hostnameAndPort = `${DockStatAPI.server?.hostname}:${DockStatAPI.server?.port}`

apps/api/src/middleware/metrics/helper.ts

@@ -214,8 +214,10 @@ const MetricsMiddleware = (app: Elysia) => {
           savePersistedMetrics()
         }
 
-        logger.debug("Tracked metrics", headers["x-dockstatapi-reqid"] ?? undefined)
-        logger.info("Request finished", headers["x-dockstatapi-reqid"] ?? undefined)
+        logger.info(
+          `Request on ${new URL(request.url).pathname} finished`,
+          headers["x-dockstatapi-reqid"] ?? undefined
+        )
       }
     )
     .onError(

apps/api/src/models/database.ts

@@ -33,6 +33,26 @@ export namespace DatabaseModel {
     200: configRes,
     400: error,
   })
+
+  export const hotkeyRes = t.Object({
+    success: t.Literal(true),
+    message: t.String(),
+    data: t.Array(
+      t.Object({
+        action: t.String(),
+        key: t.String(),
+      })
+    ),
+  })
+
+  export const hotkeyBody = t.Pick(updateBody, t.Literal("hotkeys"))
+
+  export const additionalSettingsBody = t.Pick(updateBody, t.Literal("additionalSettings"))
+
+  export const additionalSettingsRes = t.Object({
+    success: t.Boolean(),
+    message: t.String(),
+  })
 }
 
 export namespace RepositoryModel {

apps/api/src/models/docknode.ts

@@ -0,0 +1,22 @@
+import { t } from "elysia"
+
+export namespace DockNodeModel {
+  export const dockNode_registryTable = t.Object({
+    id: t.Integer(),
+    name: t.String({ minLength: 5 }),
+    host: t.String({ minLength: 5 }),
+    port: t.Number(),
+    useSSL: t.Boolean(),
+    timeout: t.Number(),
+    keys: t.Unknown(),
+  })
+
+  export const createBody = t.Omit(
+    t.Omit(dockNode_registryTable, t.Literal("keys")),
+    t.Literal("id")
+  )
+
+  export const deleteBody = t.Object({
+    id: t.Number(),
+  })
+}

apps/api/src/routes/db.ts

@@ -1,3 +1,4 @@
+import type { SQLQueryBindings } from "bun:sqlite"
 import type { RepoFile } from "@dockstat/repo-cli/types"
 import type { DockStatConfigTableType } from "@dockstat/typings/types"
 import { extractErrorMessage, repo } from "@dockstat/utils"
@@ -13,6 +14,51 @@ const DBRoutes = new Elysia({
     tags: ["DB"],
   },
 })
+  .get("/details", () => {
+    const schema = DockStatDB._sqliteWrapper.getSchema()
+    const integrity = DockStatDB._sqliteWrapper.integrityCheck()
+    const backups = DockStatDB._sqliteWrapper.listBackups()
+    const path = DockStatDB._dbPath
+
+    const info: Record<
+      string,
+      {
+        table: {
+          name: string
+          type: string
+          sql: string
+        }
+        info: {
+          cid: number
+          name: string
+          type: string
+          notnull: number
+          dflt_value: SQLQueryBindings
+          pk: number
+        }[]
+      }
+    > = {}
+
+    for (const table of schema) {
+      const i = DockStatDB._sqliteWrapper.getTableInfo(table.name)
+      info[table.name] = { table, info: i }
+    }
+
+    return {
+      info,
+      integrity,
+      path,
+      backups,
+    }
+  })
+  .get(
+    "/details/:tableName/all",
+    ({ params }) => DockStatDB._sqliteWrapper.table(params.tableName).select(["*"]).all(),
+    {
+      params: t.Object({ tableName: t.String() }),
+    }
+  )
+
   // ==================== Config Routes ====================
   .post(
     "config",
@@ -114,6 +160,44 @@ const DBRoutes = new Elysia({
     }
   )
 
+  .post(
+    "/config/hotkey",
+    ({ body }) => DockStatDB.configTable.where({ id: 0 }).update({ hotkeys: body.hotkeys }),
+    {
+      body: DatabaseModel.hotkeyBody,
+    }
+  )
+
+  .post(
+    "/config/additionalSettings",
+    ({ body, status }) => {
+      try {
+        DockStatDB.configTable
+          .where({ id: 0 })
+          .update({ additionalSettings: body.additionalSettings })
+
+        return status(200, {
+          success: true,
+          message: "Additional settings updated successfully",
+          data: body.additionalSettings,
+        })
+      } catch (error) {
+        const errorMessage = extractErrorMessage(error, "Error while updating additional settings")
+        return status(400, {
+          success: false,
+          message: errorMessage,
+        })
+      }
+    },
+    {
+      body: DatabaseModel.additionalSettingsBody,
+      response: {
+        200: DatabaseModel.additionalSettingsRes,
+        400: DatabaseModel.additionalSettingsRes,
+      },
+    }
+  )
+
   // ==================== Repository Routes ====================
   .get(
     "repositories",

apps/api/src/routes/docker/container.ts

@@ -8,7 +8,7 @@ export const DockerContainerElysia = new Elysia({
   },
 })
   .get("/all-containers", async ({ status }) => {
-    const CC = await DCM.getContainerCount()
+    const CC = await DCM.getAllContainerStats()
     return status(200, CC)
   })
   .get("/all/:clientId", async ({ params: { clientId } }) => await DCM.getAllContainers(clientId), {

apps/api/src/routes/node/index.ts

@@ -0,0 +1,20 @@
+import Elysia from "elysia"
+import { DockStatDB } from "../../database"
+import DockNodeHandler from "../../docknode"
+import BaseLogger from "../../logger"
+import { DockNodeModel } from "../../models/docknode"
+
+const DNH = new DockNodeHandler(DockStatDB._sqliteWrapper, BaseLogger)
+
+export const DockNodeElyisa = new Elysia({ prefix: "/node", detail: { tags: ["DockNode"] } })
+  .get("/", async ({ status }) => {
+    return status(200, await DNH.getAllNodes())
+  })
+  .post(
+    "/",
+    ({ body }) => {
+      DNH.createNode(body)
+    },
+    { body: DockNodeModel.createBody }
+  )
+  .delete("/", ({ body }) => DNH.delteNode(body.id), { body: DockNodeModel.deleteBody })

apps/api/src/routes/repositories/index.ts

@@ -1,5 +1,5 @@
 import type { RepoManifestType, RepoType } from "@dockstat/typings/types"
-import { parseFromDBToRepoLink } from "@dockstat/utils/src/repo"
+import { repo } from "@dockstat/utils"
 import Elysia from "elysia"
 import { DockStatDB } from "../../database"
 
@@ -20,8 +20,8 @@ const RepositoryRoutes = new Elysia({
       }
     > = {}
 
-    for (const repo of allRepos) {
-      const link = parseFromDBToRepoLink(repo.type, repo.source)
+    for (const repoElement of allRepos) {
+      const link = repo.parseFromDBToRepoLink(repoElement.type, repoElement.source)
 
       try {
         const response = await fetch(link)
@@ -53,10 +53,10 @@ const RepositoryRoutes = new Elysia({
           }
         }
 
-        result[repo.name] = {
+        result[repoElement.name] = {
           data: data as RepoManifestType,
-          type: repo.type,
-          repoSource: repo.source,
+          type: repoElement.type,
+          repoSource: repoElement.source,
         }
       } catch (error) {
         console.error(`Error processing ${link}:`, error)