refactor: replace configuration imports with ConfigService for better dependency management

- Updated various guards, strategies, services, and controllers to use ConfigService instead of direct configuration imports.
- Introduced a private `config` getter in multiple classes to access application configuration.
- Ensured that testing flags and other configuration values are accessed through the ConfigService for improved testability and maintainability.

Author: Alfagun74

package.json

@@ -27,6 +27,7 @@
   },
   "dependencies": {
     "@nestjs/common": "^11.1.13",
+    "@nestjs/config": "^4.0.3",
     "@nestjs/core": "^11.1.13",
     "@nestjs/event-emitter": "^3.0.1",
     "@nestjs/jwt": "^11.0.2",
@@ -80,7 +81,8 @@
     "unidecode": "^1.1.0",
     "winston": "^3.19.0",
     "winston-console-format": "^1.0.8",
-    "winston-daily-rotate-file": "^5.0.0"
+    "winston-daily-rotate-file": "^5.0.0",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@eslint/compat": "^2.0.2",

pnpm-lock.yaml

@@ -1,13 +1,18 @@
 import { Module } from "@nestjs/common";
+import {
+  ConfigService,
+  ConfigModule as NestConfigModule,
+} from "@nestjs/config";
 import { APP_INTERCEPTOR } from "@nestjs/core";
 import { EventEmitterModule } from "@nestjs/event-emitter";
 import { ScheduleModule } from "@nestjs/schedule";
-import configuration from "./configuration";
+import configuration, { gamevaultConfiguration } from "./configuration";
+import { GAMEVAULT_CONFIG, getGamevaultConfig } from "./gamevault-config";
 import { DisableApiIfInterceptor } from "./interceptors/disable-api-if.interceptor";
 import { HttpLoggingInterceptor } from "./interceptors/http-logging.interceptor";
 import { AdminModule } from "./modules/admin/admin.module";
 import { AuthModule } from "./modules/auth/auth.module";
-import { ConfigModule } from "./modules/config/config.module";
+import { ConfigModule as ApiConfigModule } from "./modules/config/config.module";
 import { DatabaseModule } from "./modules/database/database.module";
 import { GamesModule } from "./modules/games/games.module";
 import { GarbageCollectionModule } from "./modules/garbage-collection/garbage-collection.module";
@@ -22,8 +27,12 @@ import { WebUIModule } from "./modules/web-ui/web-ui.module";
 
 @Module({
   imports: [
+    NestConfigModule.forRoot({
+      isGlobal: true,
+      load: [gamevaultConfiguration],
+    }),
     OtpModule,
-    ConfigModule,
+    ApiConfigModule,
     AuthModule,
     DatabaseModule,
     MediaModule,
@@ -40,6 +49,11 @@ import { WebUIModule } from "./modules/web-ui/web-ui.module";
     ...(configuration.WEB_UI.ENABLED ? [WebUIModule] : []),
   ],
   providers: [
+    {
+      provide: GAMEVAULT_CONFIG,
+      inject: [ConfigService],
+      useFactory: getGamevaultConfig,
+    },
     {
       provide: APP_INTERCEPTOR,
       useClass: DisableApiIfInterceptor,

src/app.module.ts

@@ -4,6 +4,10 @@
  * their effects on the configuration object and exported utilities.
  */
 
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
 import { getCensoredConfiguration } from "./configuration";
 
 describe("Configuration", () => {
@@ -136,4 +140,44 @@ describe("Configuration", () => {
       expect(Array.isArray(config.MEDIA.SUPPORTED_FORMATS)).toBe(true);
     });
   });
+
+  describe("YAML configuration fallback", () => {
+    let tempConfigDir: string;
+
+    beforeEach(() => {
+      tempConfigDir = mkdtempSync(join(tmpdir(), "gamevault-config-"));
+      process.env.VOLUMES_CONFIG = tempConfigDir;
+      delete process.env.SERVER_PORT;
+      jest.resetModules();
+    });
+
+    afterEach(() => {
+      delete process.env.VOLUMES_CONFIG;
+      delete process.env.SERVER_PORT;
+      rmSync(tempConfigDir, { recursive: true, force: true });
+    });
+
+    it("should use YAML values when corresponding env vars are unset", async () => {
+      writeFileSync(
+        join(tempConfigDir, "config.yaml"),
+        "server:\n  port: 9191\n",
+      );
+
+      const { default: config } = await import("./configuration");
+
+      expect(config.SERVER.PORT).toBe(9191);
+    });
+
+    it("should prioritize env vars over YAML values", async () => {
+      writeFileSync(
+        join(tempConfigDir, "config.yaml"),
+        "server:\n  port: 9191\n",
+      );
+      process.env.SERVER_PORT = "8089";
+
+      const { default: config } = await import("./configuration");
+
+      expect(config.SERVER.PORT).toBe(8089);
+    });
+  });
 });

src/configuration.spec.ts

@@ -1,10 +1,114 @@
+import { registerAs } from "@nestjs/config";
 import bytes from "bytes";
 import { createHash, randomBytes } from "crypto";
+import * as dotenv from "dotenv";
+import { existsSync } from "fs";
 import { readFileSync } from "fs-extra";
 import { toLower } from "lodash";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
 import packageJson from "../package.json";
 import globals from "./globals";
 
+dotenv.config();
+
+let yamlConfigurationCache: Record<string, unknown> | null | undefined;
+
+function getConfigVolumePath(): string {
+  return process.env.VOLUMES_CONFIG?.replace(/\/$/, "") || "/config";
+}
+
+function getYamlConfiguration(): Record<string, unknown> | null {
+  if (yamlConfigurationCache !== undefined) {
+    return yamlConfigurationCache;
+  }
+
+  const configVolumePath = getConfigVolumePath();
+  const candidates = ["config.yaml", "config.yml"];
+
+  for (const candidate of candidates) {
+    const yamlPath = join(configVolumePath, candidate);
+    if (!existsSync(yamlPath)) {
+      continue;
+    }
+
+    try {
+      const parsed = parseYaml(readFileSync(yamlPath, "utf-8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        yamlConfigurationCache = parsed as Record<string, unknown>;
+        return yamlConfigurationCache;
+      }
+
+      throw new Error("Configuration root must be a YAML mapping/object.");
+    } catch (error) {
+      throw new Error(
+        `Failed to parse YAML configuration at \"${yamlPath}\": ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  yamlConfigurationCache = null;
+  return yamlConfigurationCache;
+}
+
+function getYamlValueByPath(
+  source: Record<string, unknown>,
+  pathSegments: string[],
+): unknown {
+  let current: unknown = source;
+
+  for (const segment of pathSegments) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+      return undefined;
+    }
+
+    const record = current as Record<string, unknown>;
+    const matchedKey = Object.keys(record).find(
+      (key) => key.toLowerCase() === segment.toLowerCase(),
+    );
+
+    if (!matchedKey) {
+      return undefined;
+    }
+
+    current = record[matchedKey];
+  }
+
+  return current;
+}
+
+function toEnvironmentString(value: unknown): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    return value.map(String).join(",");
+  }
+  if (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  ) {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+
+function resolveYamlEnvFallback(name: string): string | undefined {
+  const yamlConfiguration = getYamlConfiguration();
+  if (!yamlConfiguration) {
+    return undefined;
+  }
+
+  const directValue = getYamlValueByPath(yamlConfiguration, [name]);
+  if (directValue !== undefined) {
+    return toEnvironmentString(directValue);
+  }
+
+  const nestedValue = getYamlValueByPath(yamlConfiguration, name.split("_"));
+  return toEnvironmentString(nestedValue);
+}
+
 /**
  * Resolves an environment variable with Docker Secrets support.
  * If `<name>_FILE` is set, reads the file at that path and returns its
@@ -23,7 +127,12 @@ function resolveEnv(name: string): string | undefined {
       );
     }
   }
-  return process.env[name];
+
+  if (process.env[name] !== undefined) {
+    return process.env[name];
+  }
+
+  return resolveYamlEnvFallback(name);
 }
 
 function parseBooleanEnvVariable(
@@ -324,6 +433,15 @@ const configuration = {
   } as const,
 } as const;
 
+export const CONFIG_NAMESPACE = "gamevault";
+
+export const gamevaultConfiguration = registerAs(
+  CONFIG_NAMESPACE,
+  () => configuration,
+);
+
+export type AppConfiguration = typeof configuration;
+
 export function getCensoredConfiguration() {
   const censoredConfig = JSON.parse(
     JSON.stringify(configuration, (_k, v) => (v === undefined ? null : v)),

src/configuration.ts

@@ -0,0 +1,10 @@
+import { ConfigService } from "@nestjs/config";
+import { AppConfiguration, CONFIG_NAMESPACE } from "./configuration";
+
+export const GAMEVAULT_CONFIG = Symbol("GAMEVAULT_CONFIG");
+
+export function getGamevaultConfig(
+  configService: ConfigService,
+): AppConfiguration {
+  return configService.getOrThrow<AppConfiguration>(CONFIG_NAMESPACE);
+}

src/gamevault-config.ts

@@ -16,7 +16,9 @@ describe("HttpLoggingInterceptor", () => {
   let mockCallHandler: any;
 
   beforeEach(() => {
-    interceptor = new HttpLoggingInterceptor();
+    interceptor = new HttpLoggingInterceptor(
+      jest.requireMock("../configuration").default,
+    );
     mockCallHandler = {
       handle: jest.fn().mockReturnValue(of({ data: "response" })),
     };
@@ -140,7 +142,7 @@ describe("HttpLoggingInterceptor (disabled)", () => {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const config = require("../configuration").default;
     config.TESTING.LOG_HTTP_TRAFFIC_ENABLED = false;
-    interceptor = new HttpLoggingInterceptor();
+    interceptor = new HttpLoggingInterceptor(config);
     mockCallHandler = {
       handle: jest.fn().mockReturnValue(of("result")),
     };