feat: add server settings (#487)

* feat: add server settings

* feat: remove old migration

* feat: add new migrations

* refactor: format

* fix: build error

* refactor: format

* fix: lint

packages/api/src/root.ts

@@ -7,6 +7,7 @@ import { integrationRouter } from "./router/integration";
 import { inviteRouter } from "./router/invite";
 import { locationRouter } from "./router/location";
 import { logRouter } from "./router/log";
+import { serverSettingsRouter } from "./router/serverSettings";
 import { userRouter } from "./router/user";
 import { widgetRouter } from "./router/widgets";
 import { createTRPCRouter } from "./trpc";
@@ -23,6 +24,7 @@ export const appRouter = createTRPCRouter({
   log: logRouter,
   icon: iconsRouter,
   home: homeRouter,
+  serverSettings: serverSettingsRouter,
 });
 
 // export type definition of API

packages/api/src/router/serverSettings.ts

@@ -0,0 +1,43 @@
+import SuperJSON from "superjson";
+
+import { eq } from "@homarr/db";
+import { serverSettings } from "@homarr/db/schema/sqlite";
+import type { ServerSettings } from "@homarr/server-settings";
+import { defaultServerSettingsKeys } from "@homarr/server-settings";
+import { z } from "@homarr/validation";
+
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+
+export const serverSettingsRouter = createTRPCRouter({
+  getAll: protectedProcedure.query(async ({ ctx }) => {
+    const settings = await ctx.db.query.serverSettings.findMany();
+
+    const data = {} as ServerSettings;
+    defaultServerSettingsKeys.forEach((key) => {
+      const settingValue = settings.find(
+        (setting) => setting.settingKey === key,
+      )?.value;
+      if (!settingValue) {
+        return;
+      }
+      data[key] = SuperJSON.parse(settingValue);
+    });
+    return data;
+  }),
+  saveSettings: protectedProcedure
+    .input(
+      z.object({
+        settingsKey: z.enum(defaultServerSettingsKeys),
+        value: z.record(z.string(), z.unknown()),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const databaseRunResult = await ctx.db
+        .update(serverSettings)
+        .set({
+          value: SuperJSON.stringify(input.value),
+        })
+        .where(eq(serverSettings.settingKey, input.settingsKey));
+      return databaseRunResult.changes === 1;
+    }),
+});

packages/api/src/router/test/serverSettings.spec.ts

@@ -0,0 +1,134 @@
+import SuperJSON from "superjson";
+import { describe, expect, test, vi } from "vitest";
+
+import type { Session } from "@homarr/auth";
+import { createId } from "@homarr/db";
+import { serverSettings } from "@homarr/db/schema/sqlite";
+import { createDb } from "@homarr/db/test";
+import {
+  defaultServerSettings,
+  defaultServerSettingsKeys,
+} from "@homarr/server-settings";
+
+import { serverSettingsRouter } from "../serverSettings";
+
+// Mock the auth module to return an empty session
+vi.mock("@homarr/auth", () => ({ auth: () => ({}) as Session }));
+
+const defaultSession = {
+  user: {
+    id: createId(),
+    permissions: [],
+  },
+  expires: new Date().toISOString(),
+} satisfies Session;
+
+describe("getAll server settings", () => {
+  test("getAll should throw error when unauthorized", async () => {
+    const db = createDb();
+    const caller = serverSettingsRouter.createCaller({
+      db,
+      session: null,
+    });
+
+    await db.insert(serverSettings).values([
+      {
+        settingKey: defaultServerSettingsKeys[0],
+        value: SuperJSON.stringify(defaultServerSettings.analytics),
+      },
+    ]);
+
+    const actAsync = async () => await caller.getAll();
+
+    await expect(actAsync()).rejects.toThrow();
+  });
+  test("getAll should return server", async () => {
+    const db = createDb();
+    const caller = serverSettingsRouter.createCaller({
+      db,
+      session: defaultSession,
+    });
+
+    await db.insert(serverSettings).values([
+      {
+        settingKey: defaultServerSettingsKeys[0],
+        value: SuperJSON.stringify(defaultServerSettings.analytics),
+      },
+    ]);
+
+    const result = await caller.getAll();
+
+    expect(result).toStrictEqual({
+      analytics: {
+        enableGeneral: true,
+        enableWidgetData: false,
+        enableIntegrationData: false,
+        enableUserData: false,
+      },
+    });
+  });
+});
+
+describe("saveSettings", () => {
+  test("saveSettings should return false when it did not update one", async () => {
+    const db = createDb();
+    const caller = serverSettingsRouter.createCaller({
+      db,
+      session: defaultSession,
+    });
+
+    const result = await caller.saveSettings({
+      settingsKey: "analytics",
+      value: {
+        enableGeneral: true,
+        enableWidgetData: true,
+        enableIntegrationData: true,
+        enableUserData: true,
+      },
+    });
+
+    expect(result).toBe(false);
+
+    const dbSettings = await db.select().from(serverSettings);
+    expect(dbSettings.length).toBe(0);
+  });
+  test("saveSettings should update settings and return true when it updated only one", async () => {
+    const db = createDb();
+    const caller = serverSettingsRouter.createCaller({
+      db,
+      session: defaultSession,
+    });
+
+    await db.insert(serverSettings).values([
+      {
+        settingKey: defaultServerSettingsKeys[0],
+        value: SuperJSON.stringify(defaultServerSettings.analytics),
+      },
+    ]);
+
+    const result = await caller.saveSettings({
+      settingsKey: "analytics",
+      value: {
+        enableGeneral: true,
+        enableWidgetData: true,
+        enableIntegrationData: true,
+        enableUserData: true,
+      },
+    });
+
+    expect(result).toBe(true);
+
+    const dbSettings = await db.select().from(serverSettings);
+    expect(dbSettings).toStrictEqual([
+      {
+        settingKey: "analytics",
+        value: SuperJSON.stringify({
+          enableGeneral: true,
+          enableWidgetData: true,
+          enableIntegrationData: true,
+          enableUserData: true,
+        }),
+      },
+    ]);
+  });
+});