Cleaned up using in project. Improved prohect structure and refactored page names. Upgraded dependencies

Reviewed-on: #21

.gitea/workflows/publish-nuget.yml

@@ -34,7 +34,7 @@ jobs:
       # Publish frontend
       # We need to build it first so the class list files generate
       - name: Build project
-        run: dotnet build Moonlight.Frontend --configuration Debug
+        run: dotnet build Hosts/Moonlight.Frontend.Host --configuration Debug
       
       - name: Build tailwind styles and extract class list
         working-directory: Hosts/Moonlight.Frontend.Host/Styles

.gitignore

@@ -400,8 +400,10 @@ FodyWeavers.xsd
 # Style builds
 **/style.min.css
 **/package-lock.json
+**/bun.lock
 
 # Secrets
 **/.env
 **/appsettings.json
 **/appsettings.Development.json
+**/storage

Hosts/Moonlight.Api.Host/Api.props

@@ -0,0 +1,6 @@
+<Project>
+    <ItemGroup>
+        <!-- Put your plugin references here -->
+        <!-- E.g. <PackageReference Include="MoonlightServers.Api" Version="2.1.0" /> -->
+    </ItemGroup>
+</Project>

Hosts/Moonlight.Api.Host/AppStartupLoader.cs

@@ -1,10 +0,0 @@
-using MoonCore.PluginFramework;
-using Moonlight.Api.Startup;
-
-namespace Moonlight.Api.Host;
-
-[PluginLoader]
-public partial class AppStartupLoader : IAppStartup
-{
-    
-}

Hosts/Moonlight.Api.Host/Dockerfile

@@ -1,11 +1,13 @@
 # Base image
-FROM cgr.dev/chainguard/aspnet-runtime:latest AS base
+FROM git.battlestati.one/moonlight-panel/app_base:moonlight AS base
 WORKDIR /app
 
 FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
 
-# Build dependencies
+# Install required packages
-RUN apt-get update; apt-get install nodejs npm -y; apt-get clean
+RUN apt-get update; apt-get install unzip -y; apt-get clean
+RUN curl -fsSL https://bun.sh/install | bash
+ENV PATH="/root/.bun/bin:${PATH}"
 
 # Build options
 ARG BUILD_CONFIGURATION=Release
@@ -15,7 +17,7 @@ WORKDIR /src/Hosts/Moonlight.Frontend.Host/Styles
 
 COPY ["Hosts/Moonlight.Frontend.Host/Styles/package.json", "package.json"]
 
-RUN npm install
+RUN bun install
 
 # Restore nuget packages
 WORKDIR /src
@@ -27,6 +29,9 @@ COPY ["Moonlight.Shared/Moonlight.Shared.csproj", "Moonlight.Shared/"]
 COPY ["Hosts/Moonlight.Frontend.Host/Moonlight.Frontend.Host.csproj", "Hosts/Moonlight.Frontend.Host/"]
 COPY ["Hosts/Moonlight.Api.Host/Moonlight.Api.Host.csproj", "Hosts/Moonlight.Api.Host/"]
 
+COPY ["Hosts/Moonlight.Frontend.Host/Frontend.props", "Hosts/Moonlight.Frontend.Host/"]
+COPY ["Hosts/Moonlight.Api.Host/Api.props", "Hosts/Moonlight.Api.Host/"]
+
 RUN dotnet restore "Hosts/Moonlight.Api.Host/Moonlight.Api.Host.csproj"
 RUN dotnet restore "Hosts/Moonlight.Frontend.Host/Moonlight.Frontend.Host.csproj"
 
@@ -39,7 +44,7 @@ WORKDIR "/src/Hosts/Moonlight.Frontend.Host"
 RUN dotnet build "./Moonlight.Frontend.Host.csproj" -c $BUILD_CONFIGURATION -o /app/build-frontend
 
 WORKDIR "/src/Hosts/Moonlight.Frontend.Host/Styles"
-RUN npm run build
+RUN bun run build
 
 # Build projects
 WORKDIR "/src/Hosts/Moonlight.Api.Host"
@@ -67,4 +72,6 @@ WORKDIR /app
 COPY --from=publish /app/publish-api .
 COPY --from=publish /app/publish-frontend/wwwroot ./wwwroot
 
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 CMD ["/usr/bin/curl", "-sf", "-o", "/dev/null", "http://localhost:8080/"]
+
 ENTRYPOINT ["dotnet", "Moonlight.Api.Host.dll"]

Hosts/Moonlight.Api.Host/Moonlight.Api.Host.csproj

@@ -7,15 +7,13 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="MoonCore.PluginFramework" Version="1.0.9"/>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.5">
-        <PackageReference Include="MoonCore.PluginFramework.Generator" Version="1.0.3"/>
-
-        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="10.0.1"/>
-
-        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.1">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
+
+        <PackageReference Include="SimplePlugin" Version="1.0.2"/>
+        <PackageReference Include="SimplePlugin.Abstractions" Version="1.0.2"/>
     </ItemGroup>
 
     <ItemGroup>
@@ -29,4 +27,5 @@
         </Content>
     </ItemGroup>
 
+    <Import Project="Api.props"/>
 </Project>

Hosts/Moonlight.Api.Host/Program.cs

@@ -1,22 +1,9 @@
-using Moonlight.Api.Host;
+using Moonlight.Api;
+using SimplePlugin.Generated;
 
-var appLoader = new AppStartupLoader();
+var plugins = PluginRegistry
-appLoader.Initialize();
+    .Modules
+    .OfType<MoonlightPlugin>()
+    .ToArray();
 
-var builder = WebApplication.CreateBuilder(args);
+await StartupHandler.RunAsync(args, plugins);
-
-appLoader.PreBuild(builder);
-
-var app = builder.Build();
-
-appLoader.PostBuild(app);
-
-appLoader.PostMiddleware(app);
-
-if (app.Environment.IsDevelopment())
-    app.UseWebAssemblyDebugging();
-
-app.UseBlazorFrameworkFiles();
-app.UseStaticFiles();
-
-await app.RunAsync();

Hosts/Moonlight.Frontend.Host/AppStartupLoader.cs

@@ -1,10 +0,0 @@
-using MoonCore.PluginFramework;
-using Moonlight.Frontend.Startup;
-
-namespace Moonlight.Frontend.Host;
-
-[PluginLoader]
-public partial class AppStartupLoader : IAppStartup
-{
-    
-}

Hosts/Moonlight.Frontend.Host/Frontend.props

@@ -0,0 +1,6 @@
+<Project>
+    <ItemGroup>
+        <!-- Put your plugin references here -->
+        <!-- E.g. <PackageReference Include="MoonlightServers.Frontend" Version="2.1.0" /> -->
+    </ItemGroup>
+</Project>

Hosts/Moonlight.Frontend.Host/Moonlight.Frontend.Host.csproj

@@ -12,13 +12,17 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.1"/>
+        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.5" />
-        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="10.0.1" PrivateAssets="all"/>
+        <PackageReference Include="Microsoft.DotNet.HotReload.WebAssembly.Browser" Version="10.0.201" />
-        <PackageReference Include="MoonCore.PluginFramework" Version="1.0.9"/>
+        <PackageReference Include="Microsoft.NET.ILLink.Tasks" Version="10.0.5" />
-        <PackageReference Include="MoonCore.PluginFramework.Generator" Version="1.0.3"/>
+        <PackageReference Include="Microsoft.NET.Sdk.WebAssembly.Pack" Version="10.0.5" />
+        <PackageReference Include="SimplePlugin" Version="1.0.2"/>
+        <PackageReference Include="SimplePlugin.Abstractions" Version="1.0.2"/>
     </ItemGroup>
 
     <ItemGroup>
         <ProjectReference Include="..\..\Moonlight.Frontend\Moonlight.Frontend.csproj"/>
     </ItemGroup>
+
+    <Import Project="Frontend.props"/>
 </Project>

Hosts/Moonlight.Frontend.Host/Program.cs

@@ -1,15 +1,9 @@
-using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
+using Moonlight.Frontend;
-using Moonlight.Frontend.Host;
+using SimplePlugin.Generated;
 
-var appLoader = new AppStartupLoader();
+var plugins = PluginRegistry
-appLoader.Initialize();
+    .Modules
+    .OfType<MoonlightPlugin>()
+    .ToArray();
 
-var builder = WebAssemblyHostBuilder.CreateDefault(args);
+await StartupHandler.RunAsync(args, plugins);
-
-appLoader.PreBuild(builder);
-
-var app = builder.Build();
-
-appLoader.PostBuild(app);
-
-await app.RunAsync();

Hosts/Moonlight.Frontend.Host/Styles/styles.css

@@ -1,11 +1,11 @@
 @import "tailwindcss";
 @import "tw-animate-css";
 
-@import "../../../Moonlight.Frontend/bin/ShadcnBlazor/scrollbar.css";
+@import "../bin/ShadcnBlazor/scrollbar.css";
-@import "../../../Moonlight.Frontend/bin/ShadcnBlazor/default-theme.css";
+@import "../bin/ShadcnBlazor/default-theme.css";
 @import "./theme.css";
 
-@source "../../../Moonlight.Frontend/bin/ShadcnBlazor/ShadcnBlazor.map";
+@source "../bin/ShadcnBlazor/ShadcnBlazor.map";
 
 @source "../../../Moonlight.Api/**/*.razor";
 @source "../../../Moonlight.Api/**/*.cs";
@@ -25,6 +25,7 @@
     * {
         @apply border-border outline-ring/50;
     }
+
     body {
         @apply bg-background text-foreground;
     }

Hosts/Moonlight.Frontend.Host/wwwroot/index.html

@@ -1,14 +1,14 @@
 <!DOCTYPE html>
-<html lang="en" class="dark">
+<html class="dark" lang="en">
 
 <head>
     <meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta content="width=device-width, initial-scale=1.0" name="viewport"/>
     <title>Moonlight</title>
     <base href="/"/>
-    <link rel="preload" id="webassembly" />
+    <link id="webassembly" rel="preload"/>
-    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=fallback" />
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=fallback" rel="stylesheet"/>
-    <link rel="stylesheet" href="style.min.css" />
+    <link href="style.min.css" rel="stylesheet"/>
     <script type="importmap"></script>
 
     <script>
@@ -68,9 +68,9 @@
             <div class="flex max-w-sm flex-col items-center gap-2 text-center">
                 <div class="flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:shrink-0 bg-muted text-foreground size-10 rounded-lg [&_svg:not([class*='size-'])]:size-6">
 
-                        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none"
+                    <svg class="lucide lucide-zap-icon lucide-zap size-6" fill="none" height="24" stroke="currentColor" stroke-linecap="round"
-                             stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"
+                         stroke-linejoin="round" stroke-width="2" viewBox="0 0 24 24" width="24"
-                             class="lucide lucide-zap-icon lucide-zap size-6">
+                         xmlns="http://www.w3.org/2000/svg">
                         <path d="M4 14a1 1 0 0 1-.78-1.63l9.9-10.2a.5.5 0 0 1 .86.46l-1.92 6.02A1 1 0 0 0 13 10h7a1 1 0 0 1 .78 1.63l-9.9 10.2a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14z"/>
                     </svg>
 
@@ -95,13 +95,13 @@
 
 <div id="blazor-error-ui">
     An unhandled error has occurred.
-        <a href="." class="reload">Reload</a>
+    <a class="reload" href=".">Reload</a>
     <span class="dismiss">🗙</span>
 </div>
 
-    <script src="/_content/ShadcnBlazor/interop.js" defer></script>
+<script defer src="/_content/ShadcnBlazor/interop.js"></script>
-    <script src="/_content/ShadcnBlazor.Extras/interop.js" defer></script>
+<script defer src="/_content/ShadcnBlazor.Extras/interop.js"></script>
-    <script src="/_content/ShadcnBlazor.Extras/codemirror-bundle.js" defer></script>
+<script defer src="/_content/ShadcnBlazor.Extras/codemirror-bundle.js"></script>
 <script src="_framework/blazor.webassembly#[.{fingerprint}].js"></script>
 </body>
 

Moonlight.Api/Admin/Setup/SetupController.cs

@@ -0,0 +1,128 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Moonlight.Api.Admin.Sys.Settings;
+using Moonlight.Api.Infrastructure.Database;
+using Moonlight.Api.Infrastructure.Database.Entities;
+using Moonlight.Shared;
+using Moonlight.Shared.Admin.Setup;
+
+namespace Moonlight.Api.Admin.Setup;
+
+[ApiController]
+[Route("api/admin/setup")]
+public class SetupController : Controller
+{
+    private const string StateSettingsKey = "Moonlight.Api.Setup.State";
+    private readonly DatabaseRepository<Role> RolesRepository;
+    private readonly SettingsService SettingsService;
+    private readonly DatabaseRepository<User> UsersRepository;
+
+    public SetupController(
+        SettingsService settingsService,
+        DatabaseRepository<User> usersRepository,
+        DatabaseRepository<Role> rolesRepository
+    )
+    {
+        SettingsService = settingsService;
+        UsersRepository = usersRepository;
+        RolesRepository = rolesRepository;
+    }
+
+    [HttpGet]
+    [AllowAnonymous]
+    public async Task<ActionResult> GetSetupAsync()
+    {
+        var hasBeenSetup = await SettingsService.GetValueAsync<bool>(StateSettingsKey);
+
+        if (hasBeenSetup)
+            return Problem("This instance is already configured", statusCode: 405);
+
+        return NoContent();
+    }
+
+    [HttpPost]
+    [AllowAnonymous]
+    public async Task<ActionResult> ApplySetupAsync([FromBody] ApplySetupDto dto)
+    {
+        var adminRole = await RolesRepository
+            .Query()
+            .FirstOrDefaultAsync(x => x.Name == "Administrators");
+
+        if (adminRole == null)
+            adminRole = await RolesRepository.AddAsync(new Role
+            {
+                Name = "Administrators",
+                Description = "Automatically generated group for full administrator permissions",
+                Permissions =
+                [
+                    Permissions.ApiKeys.View,
+                    Permissions.ApiKeys.Create,
+                    Permissions.ApiKeys.Edit,
+                    Permissions.ApiKeys.Delete,
+
+                    Permissions.Roles.View,
+                    Permissions.Roles.Create,
+                    Permissions.Roles.Edit,
+                    Permissions.Roles.Delete,
+                    Permissions.Roles.Members,
+
+                    Permissions.Users.View,
+                    Permissions.Users.Create,
+                    Permissions.Users.Edit,
+                    Permissions.Users.Delete,
+                    Permissions.Users.Logout,
+
+                    Permissions.Themes.View,
+                    Permissions.Themes.Create,
+                    Permissions.Themes.Edit,
+                    Permissions.Themes.Delete,
+
+                    Permissions.System.Info,
+                    Permissions.System.Diagnose,
+                    Permissions.System.Versions,
+                    Permissions.System.Instance
+                ]
+            });
+
+
+        var user = await UsersRepository
+            .Query()
+            .FirstOrDefaultAsync(u => u.Email == dto.AdminEmail);
+
+        if (user == null)
+        {
+            await UsersRepository.AddAsync(new User
+            {
+                Email = dto.AdminEmail,
+                Username = dto.AdminUsername,
+                RoleMemberships =
+                [
+                    new RoleMember
+                    {
+                        Role = adminRole,
+                        CreatedAt = DateTimeOffset.UtcNow,
+                        UpdatedAt = DateTimeOffset.UtcNow
+                    }
+                ],
+                CreatedAt = DateTimeOffset.UtcNow,
+                UpdatedAt = DateTimeOffset.UtcNow
+            });
+        }
+        else
+        {
+            user.RoleMemberships.Add(new RoleMember
+            {
+                Role = adminRole,
+                CreatedAt = DateTimeOffset.UtcNow,
+                UpdatedAt = DateTimeOffset.UtcNow
+            });
+
+            await UsersRepository.UpdateAsync(user);
+        }
+
+        await SettingsService.SetValueAsync(StateSettingsKey, true);
+
+        return NoContent();
+    }
+}

Moonlight.Api/Admin/Sys/ApiKeys/ApiKeyController.cs

@@ -1,27 +1,28 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database;
+using Microsoft.Extensions.Caching.Hybrid;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Admin.Sys.ApiKeys.Scheme;
-using Moonlight.Api.Mappers;
+using Moonlight.Api.Infrastructure.Database;
+using Moonlight.Api.Infrastructure.Database.Entities;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Requests;
+using Moonlight.Shared.Admin.Sys.ApiKeys;
-using Moonlight.Shared.Http.Requests.ApiKeys;
+using Moonlight.Shared.Shared;
-using Moonlight.Shared.Http.Responses;
-using Moonlight.Shared.Http.Responses.ApiKeys;
 
-namespace Moonlight.Api.Http.Controllers.Admin;
+namespace Moonlight.Api.Admin.Sys.ApiKeys;
 
 [Authorize]
 [ApiController]
 [Route("api/admin/apiKeys")]
 public class ApiKeyController : Controller
 {
+    private readonly HybridCache HybridCache;
     private readonly DatabaseRepository<ApiKey> KeyRepository;
 
-    public ApiKeyController(DatabaseRepository<ApiKey> keyRepository)
+    public ApiKeyController(DatabaseRepository<ApiKey> keyRepository, HybridCache hybridCache)
     {
         KeyRepository = keyRepository;
+        HybridCache = hybridCache;
     }
 
     [HttpGet]
@@ -44,9 +45,7 @@ public class ApiKeyController : Controller
 
         // Filters
         if (filterOptions != null)
-        {
             foreach (var filterOption in filterOptions.Filters)
-            {
                 query = filterOption.Key switch
                 {
                     nameof(ApiKey.Name) =>
@@ -57,8 +56,6 @@ public class ApiKeyController : Controller
 
                     _ => query
                 };
-            }
-        }
 
         // Pagination
         var data = await query
@@ -114,6 +111,8 @@ public class ApiKeyController : Controller
         ApiKeyMapper.Merge(apiKey, request);
         await KeyRepository.UpdateAsync(apiKey);
 
+        await HybridCache.RemoveAsync(string.Format(ApiKeySchemeHandler.CacheKeyFormat, apiKey.Key));
+
         return ApiKeyMapper.ToDto(apiKey);
     }
 
@@ -129,6 +128,9 @@ public class ApiKeyController : Controller
             return Problem("No API key with this id found", statusCode: 404);
 
         await KeyRepository.RemoveAsync(apiKey);
+
+        await HybridCache.RemoveAsync(string.Format(ApiKeySchemeHandler.CacheKeyFormat, apiKey.Key));
+
         return NoContent();
     }
 }

Moonlight.Api/Admin/Sys/ApiKeys/ApiKeyMapper.cs

@@ -1,10 +1,9 @@
 using System.Diagnostics.CodeAnalysis;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Shared.Http.Requests.ApiKeys;
+using Moonlight.Shared.Admin.Sys.ApiKeys;
-using Moonlight.Shared.Http.Responses.ApiKeys;
 using Riok.Mapperly.Abstractions;
 
-namespace Moonlight.Api.Mappers;
+namespace Moonlight.Api.Admin.Sys.ApiKeys;
 
 [Mapper]
 [SuppressMessage("Mapper", "RMG020:No members are mapped in an object mapping")]

Moonlight.Api/Admin/Sys/ApiKeys/ApiOptions.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.Api.Admin.Sys.ApiKeys;
+
+public class ApiOptions
+{
+    public TimeSpan LookupCacheL1Expiry { get; set; } = TimeSpan.FromSeconds(30);
+    public TimeSpan LookupCacheL2Expiry { get; set; } = TimeSpan.FromMinutes(3);
+}

Moonlight.Api/Admin/Sys/ApiKeys/Scheme/ApiKeySchemeHandler.cs

@@ -2,30 +2,31 @@ using System.Security.Claims;
 using System.Text.Encodings.Web;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Caching.Hybrid;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
 using Moonlight.Shared;
 
-namespace Moonlight.Api.Implementations.ApiKeyScheme;
+namespace Moonlight.Api.Admin.Sys.ApiKeys.Scheme;
 
 public class ApiKeySchemeHandler : AuthenticationHandler<ApiKeySchemeOptions>
 {
+    public const string CacheKeyFormat = $"Moonlight.Api.{nameof(ApiKeySchemeHandler)}.{{0}}";
     private readonly DatabaseRepository<ApiKey> ApiKeyRepository;
-    private readonly IMemoryCache MemoryCache;
+    private readonly HybridCache HybridCache;
 
     public ApiKeySchemeHandler(
         IOptionsMonitor<ApiKeySchemeOptions> options,
         ILoggerFactory logger,
         UrlEncoder encoder,
         DatabaseRepository<ApiKey> apiKeyRepository,
-        IMemoryCache memoryCache
+        HybridCache hybridCache
     ) : base(options, logger, encoder)
     {
         ApiKeyRepository = apiKeyRepository;
-        MemoryCache = memoryCache;
+        HybridCache = hybridCache;
     }
 
     protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
@@ -38,24 +39,30 @@ public class ApiKeySchemeHandler : AuthenticationHandler<ApiKeySchemeOptions>
         if (authHeaderValue.Length > 32)
             return AuthenticateResult.Fail("Invalid api key specified");
 
-        if (!MemoryCache.TryGetValue<ApiKeySession>(authHeaderValue, out var apiKey))
+        var cacheKey = string.Format(CacheKeyFormat, authHeaderValue);
+
+        var apiKey = await HybridCache.GetOrCreateAsync<ApiKeySession?>(
+            cacheKey,
+            async ct =>
             {
-            apiKey = await ApiKeyRepository
+                return await ApiKeyRepository
                     .Query()
                     .Where(x => x.Key == authHeaderValue)
-                .Select(x => new ApiKeySession(x.Permissions))
+                    .Select(x => new ApiKeySession(x.Permissions, x.ValidUntil))
-                .FirstOrDefaultAsync();
+                    .FirstOrDefaultAsync(ct);
-
+            },
-            if (apiKey == null)
+            new HybridCacheEntryOptions
-                return AuthenticateResult.Fail("Invalid api key specified");
-
-            MemoryCache.Set(authHeaderValue, apiKey, Options.LookupCacheTime);
-        }
-        else
             {
+                LocalCacheExpiration = Options.LookupL1CacheTime,
+                Expiration = Options.LookupL2CacheTime
+            }
+        );
+
         if (apiKey == null)
             return AuthenticateResult.Fail("Invalid api key specified");
-        }
+
+        if (DateTimeOffset.UtcNow > apiKey.ValidUntil)
+            return AuthenticateResult.Fail("Api key expired");
 
         return AuthenticateResult.Success(new AuthenticationTicket(
             new ClaimsPrincipal(
@@ -67,5 +74,5 @@ public class ApiKeySchemeHandler : AuthenticationHandler<ApiKeySchemeOptions>
         ));
     }
 
-    private record ApiKeySession(string[] Permissions);
+    private record ApiKeySession(string[] Permissions, DateTimeOffset ValidUntil);
 }

Moonlight.Api/Admin/Sys/ApiKeys/Scheme/ApiKeySchemeOptions.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Authentication;
+
+namespace Moonlight.Api.Admin.Sys.ApiKeys.Scheme;
+
+public class ApiKeySchemeOptions : AuthenticationSchemeOptions
+{
+    public TimeSpan LookupL1CacheTime { get; set; }
+    public TimeSpan LookupL2CacheTime { get; set; }
+}

Moonlight.Api/Admin/Sys/ApplicationService.cs

@@ -1,24 +1,61 @@
 using System.Diagnostics;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
-using Moonlight.Api.Helpers;
+using VersionService = Moonlight.Api.Admin.Sys.Versions.VersionService;
 
-namespace Moonlight.Api.Services;
+namespace Moonlight.Api.Admin.Sys;
 
 public class ApplicationService : IHostedService
 {
-    private readonly VersionService VersionService;
     private readonly ILogger<ApplicationService> Logger;
+    private readonly VersionService VersionService;
+
+    public ApplicationService(VersionService versionService, ILogger<ApplicationService> logger)
+    {
+        VersionService = versionService;
+        Logger = logger;
+    }
 
     public DateTimeOffset StartedAt { get; private set; }
     public string VersionName { get; private set; } = "N/A";
     public bool IsUpToDate { get; set; } = true;
     public string OperatingSystem { get; private set; } = "N/A";
 
-    public ApplicationService(VersionService versionService, ILogger<ApplicationService> logger)
+    public async Task StartAsync(CancellationToken cancellationToken)
     {
-        VersionService = versionService;
+        StartedAt = DateTimeOffset.UtcNow;
-        Logger = logger;
+
+        OperatingSystem = OsHelper.GetName();
+
+        try
+        {
+            var currentVersion = await VersionService.GetInstanceVersionAsync();
+            var latestVersion = await VersionService.GetLatestVersionAsync();
+
+            VersionName = currentVersion.Identifier;
+            IsUpToDate = latestVersion == null || currentVersion.Identifier == latestVersion.Identifier;
+
+            Logger.LogInformation("Running Moonlight Panel {version} on {operatingSystem}", VersionName,
+                OperatingSystem);
+
+            if (!IsUpToDate)
+                Logger.LogWarning("Your instance is not up-to-date");
+
+            if (currentVersion.IsDevelopment)
+                Logger.LogWarning("Your instance is running a development version");
+
+            if (currentVersion.IsPreRelease)
+                Logger.LogWarning("Your instance is running a pre-release version");
+        }
+        catch (Exception e)
+        {
+            Logger.LogError(e, "An unhandled exception occurred while fetching version details");
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
     }
 
     public Task<long> GetMemoryUsageAsync()
@@ -45,41 +82,8 @@ public class ApplicationService : IHostedService
         // Calculate CPU usage
         var cpuUsedMs = (endCpuTime - startCpuTime).TotalMilliseconds;
         var totalMsPassed = (endTime - startTime).TotalMilliseconds;
-        var cpuUsagePercent = (cpuUsedMs / (Environment.ProcessorCount * totalMsPassed)) * 100;
+        var cpuUsagePercent = cpuUsedMs / (Environment.ProcessorCount * totalMsPassed) * 100;
 
         return Math.Round(cpuUsagePercent, 2);
     }
-
-    public async Task StartAsync(CancellationToken cancellationToken)
-    {
-        StartedAt = DateTimeOffset.UtcNow;
-        
-        OperatingSystem = OsHelper.GetName();
-
-        try
-        {
-            var currentVersion = await VersionService.GetInstanceVersionAsync();
-            var latestVersion = await VersionService.GetLatestVersionAsync();
-
-            VersionName = currentVersion.Identifier;
-            IsUpToDate = latestVersion == null || currentVersion.Identifier == latestVersion.Identifier;
-            
-            Logger.LogInformation("Running Moonlight Panel {version} on {operatingSystem}", VersionName, OperatingSystem);
-
-            if (!IsUpToDate)
-                Logger.LogWarning("Your instance is not up-to-date");
-
-            if (currentVersion.IsDevelopment)
-                Logger.LogWarning("Your instance is running a development version");
-
-            if (currentVersion.IsPreRelease)
-                Logger.LogWarning("Your instance is running a pre-release version");
-        }
-        catch (Exception e)
-        {
-            Logger.LogError(e, "An unhandled exception occurred while fetching version details");
-        }
-    }
-
-    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 }

Moonlight.Api/Admin/Sys/ContainerHelper/ContainerHelperController.cs

@@ -0,0 +1,53 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Moonlight.Shared;
+using Moonlight.Shared.Admin.Sys.ContainerHelper;
+
+namespace Moonlight.Api.Admin.Sys.ContainerHelper;
+
+[ApiController]
+[Route("api/admin/ch")]
+[Authorize(Policy = Permissions.System.Instance)]
+public class ContainerHelperController : Controller
+{
+    private readonly ContainerHelperService ContainerHelperService;
+    private readonly IOptions<ContainerHelperOptions> Options;
+
+    public ContainerHelperController(ContainerHelperService containerHelperService,
+        IOptions<ContainerHelperOptions> options)
+    {
+        ContainerHelperService = containerHelperService;
+        Options = options;
+    }
+
+    [HttpGet("status")]
+    public async Task<ActionResult<ContainerHelperStatusDto>> GetStatusAsync()
+    {
+        if (!Options.Value.IsEnabled)
+            return new ContainerHelperStatusDto(false, false);
+
+        var status = await ContainerHelperService.CheckConnectionAsync();
+
+        return new ContainerHelperStatusDto(true, status);
+    }
+
+    [HttpPost("rebuild")]
+    public Task<IResult> RebuildAsync([FromBody] RequestRebuildDto request)
+    {
+        var result = ContainerHelperService.RebuildAsync(request.NoBuildCache);
+        var mappedResult = result.Select(ContainerHelperMapper.ToDto);
+
+        return Task.FromResult<IResult>(
+            TypedResults.ServerSentEvents(mappedResult)
+        );
+    }
+
+    [HttpPost("version")]
+    public async Task<ActionResult> SetVersionAsync([FromBody] SetVersionDto request)
+    {
+        await ContainerHelperService.SetVersionAsync(request.Version);
+        return NoContent();
+    }
+}

Moonlight.Api/Admin/Sys/ContainerHelper/ContainerHelperMapper.cs

@@ -0,0 +1,13 @@
+using System.Diagnostics.CodeAnalysis;
+using Moonlight.Shared.Admin.Sys.ContainerHelper;
+using Riok.Mapperly.Abstractions;
+
+namespace Moonlight.Api.Admin.Sys.ContainerHelper;
+
+[Mapper]
+[SuppressMessage("Mapper", "RMG020:No members are mapped in an object mapping")]
+[SuppressMessage("Mapper", "RMG012:No members are mapped in an object mapping")]
+public static partial class ContainerHelperMapper
+{
+    public static partial RebuildEventDto ToDto(Models.Events.RebuildEventDto rebuildEventDto);
+}

Moonlight.Api/Admin/Sys/ContainerHelper/ContainerHelperOptions.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.Api.Admin.Sys.ContainerHelper;
+
+public class ContainerHelperOptions
+{
+    public bool IsEnabled { get; set; }
+    public string Url { get; set; } = "http://helper:8080";
+}

Moonlight.Api/Admin/Sys/ContainerHelper/ContainerHelperService.cs

@@ -0,0 +1,117 @@
+using System.Net.Http.Json;
+using System.Text.Json;
+using Moonlight.Api.Admin.Sys.ContainerHelper.Models;
+using Moonlight.Api.Admin.Sys.ContainerHelper.Models.Events;
+using Moonlight.Api.Admin.Sys.ContainerHelper.Models.Requests;
+
+namespace Moonlight.Api.Admin.Sys.ContainerHelper;
+
+public class ContainerHelperService
+{
+    private readonly IHttpClientFactory HttpClientFactory;
+
+    public ContainerHelperService(IHttpClientFactory httpClientFactory)
+    {
+        HttpClientFactory = httpClientFactory;
+    }
+
+    public async Task<bool> CheckConnectionAsync()
+    {
+        var client = HttpClientFactory.CreateClient("ContainerHelper");
+
+        try
+        {
+            var response = await client.GetAsync("api/ping");
+            response.EnsureSuccessStatusCode();
+
+            return true;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
+    public async IAsyncEnumerable<RebuildEventDto> RebuildAsync(bool noBuildCache)
+    {
+        var client = HttpClientFactory.CreateClient("ContainerHelper");
+
+        var request = new HttpRequestMessage(HttpMethod.Post, "api/rebuild");
+
+        request.Content = JsonContent.Create(
+            new RequestRebuildDto(noBuildCache),
+            null,
+            SerializationContext.Default.Options
+        );
+
+        var response = await client.SendAsync(
+            request,
+            HttpCompletionOption.ResponseHeadersRead
+        );
+
+        if (!response.IsSuccessStatusCode)
+        {
+            var responseText = await response.Content.ReadAsStringAsync();
+
+            yield return new RebuildEventDto
+            {
+                Type = RebuildEventType.Failed,
+                Data = responseText
+            };
+
+            yield break;
+        }
+
+        await using var responseStream = await response.Content.ReadAsStreamAsync();
+        using var streamReader = new StreamReader(responseStream);
+
+        do
+        {
+            var line = await streamReader.ReadLineAsync();
+
+            if (line == null)
+                break;
+
+            if (string.IsNullOrWhiteSpace(line))
+                continue;
+
+            var data = line.Trim("data: ");
+            var deserializedData =
+                JsonSerializer.Deserialize<RebuildEventDto>(data, SerializationContext.Default.Options);
+
+            yield return deserializedData;
+
+            // Exit if service will go down for a clean exit
+            if (deserializedData is { Type: RebuildEventType.Step, Data: "ServiceDown" })
+                yield break;
+        } while (true);
+
+        yield return new RebuildEventDto
+        {
+            Type = RebuildEventType.Succeeded,
+            Data = string.Empty
+        };
+    }
+
+    public async Task SetVersionAsync(string version)
+    {
+        var client = HttpClientFactory.CreateClient("ContainerHelper");
+
+        var response = await client.PostAsJsonAsync(
+            "api/configuration/version",
+            new SetVersionDto(version),
+            SerializationContext.Default.Options
+        );
+
+        if (response.IsSuccessStatusCode)
+            return;
+
+        var problemDetails =
+            await response.Content.ReadFromJsonAsync<ProblemDetails>(SerializationContext.Default.Options);
+
+        if (problemDetails == null)
+            throw new HttpRequestException($"Failed to set version: {response.ReasonPhrase}");
+
+        throw new HttpRequestException($"Failed to set version: {problemDetails.Detail ?? problemDetails.Title}");
+    }
+}

Moonlight.Api/Admin/Sys/ContainerHelper/Models/Events/RebuildEventDto.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace Moonlight.Api.Admin.Sys.ContainerHelper.Models.Events;
+
+public struct RebuildEventDto
+{
+    [JsonPropertyName("type")] public RebuildEventType Type { get; set; }
+
+    [JsonPropertyName("data")] public string Data { get; set; }
+}
+
+public enum RebuildEventType
+{
+    Log = 0,
+    Failed = 1,
+    Succeeded = 2,
+    Step = 3
+}

Moonlight.Api/Admin/Sys/ContainerHelper/Models/ProblemDetails.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.Api.Admin.Sys.ContainerHelper.Models;
+
+public class ProblemDetails
+{
+    public string Type { get; set; }
+    public string Title { get; set; }
+    public int Status { get; set; }
+    public string? Detail { get; set; }
+    public Dictionary<string, string[]>? Errors { get; set; }
+}

Moonlight.Api/Admin/Sys/ContainerHelper/Models/Requests/RequestRebuildDto.cs

@@ -0,0 +1,3 @@
+namespace Moonlight.Api.Admin.Sys.ContainerHelper.Models.Requests;
+
+public record RequestRebuildDto(bool NoBuildCache);

Moonlight.Api/Admin/Sys/ContainerHelper/Models/Requests/SetVersionDto.cs

@@ -0,0 +1,3 @@
+namespace Moonlight.Api.Admin.Sys.ContainerHelper.Models.Requests;
+
+public record SetVersionDto(string Version);

Moonlight.Api/Admin/Sys/ContainerHelper/Models/SerializationContext.cs

@@ -0,0 +1,15 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Moonlight.Api.Admin.Sys.ContainerHelper.Models.Events;
+using Moonlight.Api.Admin.Sys.ContainerHelper.Models.Requests;
+
+namespace Moonlight.Api.Admin.Sys.ContainerHelper.Models;
+
+[JsonSerializable(typeof(SetVersionDto))]
+[JsonSerializable(typeof(ProblemDetails))]
+[JsonSerializable(typeof(RebuildEventDto))]
+[JsonSerializable(typeof(RequestRebuildDto))]
+[JsonSourceGenerationOptions(JsonSerializerDefaults.Web)]
+public partial class SerializationContext : JsonSerializerContext
+{
+}

Moonlight.Api/Admin/Sys/Diagnose/DiagnoseController.cs

@@ -1,11 +1,9 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Moonlight.Api.Mappers;
-using Moonlight.Api.Services;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Responses.Admin;
+using Moonlight.Shared.Admin.Sys.Diagnose;
 
-namespace Moonlight.Api.Http.Controllers.Admin;
+namespace Moonlight.Api.Admin.Sys.Diagnose;
 
 [ApiController]
 [Authorize(Policy = Permissions.System.Diagnose)]

Moonlight.Api/Admin/Sys/Diagnose/DiagnoseResult.cs

@@ -0,0 +1,17 @@
+namespace Moonlight.Api.Admin.Sys.Diagnose;
+
+public record DiagnoseResult(
+    DiagnoseLevel Level,
+    string Title,
+    string[] Tags,
+    string? Message,
+    string? StackStrace,
+    string? SolutionUrl,
+    string? ReportUrl);
+
+public enum DiagnoseLevel
+{
+    Error = 0,
+    Warning = 1,
+    Healthy = 2
+}

Moonlight.Api/Admin/Sys/Diagnose/DiagnoseResultMapper.cs

@@ -1,9 +1,8 @@
 using System.Diagnostics.CodeAnalysis;
-using Moonlight.Api.Models;
+using Moonlight.Shared.Admin.Sys.Diagnose;
-using Moonlight.Shared.Http.Responses.Admin;
 using Riok.Mapperly.Abstractions;
 
-namespace Moonlight.Api.Mappers;
+namespace Moonlight.Api.Admin.Sys.Diagnose;
 
 [Mapper]
 [SuppressMessage("Mapper", "RMG020:No members are mapped in an object mapping")]

Moonlight.Api/Admin/Sys/Diagnose/DiagnoseService.cs

@@ -1,13 +1,12 @@
 using Microsoft.Extensions.Logging;
-using Moonlight.Api.Interfaces;
+using Moonlight.Api.Infrastructure.Hooks;
-using Moonlight.Api.Models;
 
-namespace Moonlight.Api.Services;
+namespace Moonlight.Api.Admin.Sys.Diagnose;
 
 public class DiagnoseService
 {
-    private readonly IEnumerable<IDiagnoseProvider> Providers;
     private readonly ILogger<DiagnoseService> Logger;
+    private readonly IEnumerable<IDiagnoseProvider> Providers;
 
     public DiagnoseService(IEnumerable<IDiagnoseProvider> providers, ILogger<DiagnoseService> logger)
     {
@@ -20,7 +19,6 @@ public class DiagnoseService
         var results = new List<DiagnoseResult>();
 
         foreach (var provider in Providers)
-        {
             try
             {
                 results.AddRange(
@@ -31,7 +29,6 @@ public class DiagnoseService
             {
                 Logger.LogError(e, "An unhandled error occured while processing provider");
             }
-        }
 
         return results.ToArray();
     }

Moonlight.Api/Admin/Sys/OsHelper.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace Moonlight.Api.Helpers;
+namespace Moonlight.Api.Admin.Sys;
 
 public class OsHelper
 {
@@ -53,17 +53,12 @@ public class OsHelper
                 string? version = null;
 
                 foreach (var line in lines)
-                {
                     if (line.StartsWith("NAME="))
                         name = line.Substring(5).Trim('"');
                     else if (line.StartsWith("VERSION_ID="))
                         version = line.Substring(11).Trim('"');
-                }
 
-                if (!string.IsNullOrEmpty(name))
+                if (!string.IsNullOrEmpty(name)) return string.IsNullOrEmpty(version) ? name : $"{name} {version}";
-                {
-                    return string.IsNullOrEmpty(version) ? name : $"{name} {version}";
-                }
             }
 
             //If for some weird reason it still uses lsb release
@@ -74,17 +69,12 @@ public class OsHelper
                 string? version = null;
 
                 foreach (var line in lines)
-                {
                     if (line.StartsWith("DISTRIB_ID="))
                         name = line.Substring(11);
                     else if (line.StartsWith("DISTRIB_RELEASE="))
                         version = line.Substring(16);
-                }
 
-                if (!string.IsNullOrEmpty(name))
+                if (!string.IsNullOrEmpty(name)) return string.IsNullOrEmpty(version) ? name : $"{name} {version}";
-                {
-                    return string.IsNullOrEmpty(version) ? name : $"{name} {version}";
-                }
             }
         }
         catch

Moonlight.Api/Admin/Sys/Settings/SettingsOptions.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.Api.Admin.Sys.Settings;
+
+public class SettingsOptions
+{
+    public TimeSpan LookupL1CacheTime { get; set; } = TimeSpan.FromMinutes(1);
+    public TimeSpan LookupL2CacheTime { get; set; } = TimeSpan.FromMinutes(5);
+}

Moonlight.Api/Admin/Sys/Settings/SettingsService.cs

@@ -0,0 +1,83 @@
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Hybrid;
+using Microsoft.Extensions.Options;
+using Moonlight.Api.Infrastructure.Database;
+using Moonlight.Api.Infrastructure.Database.Entities;
+
+namespace Moonlight.Api.Admin.Sys.Settings;
+
+public class SettingsService
+{
+    private const string CacheKey = "Moonlight.Api.SettingsService.{0}";
+    private readonly HybridCache HybridCache;
+    private readonly IOptions<SettingsOptions> Options;
+    private readonly DatabaseRepository<SettingsOption> Repository;
+
+    public SettingsService(
+        DatabaseRepository<SettingsOption> repository,
+        IOptions<SettingsOptions> options,
+        HybridCache hybridCache
+    )
+    {
+        Repository = repository;
+        HybridCache = hybridCache;
+        Options = options;
+    }
+
+    public async Task<T?> GetValueAsync<T>(string key)
+    {
+        var cacheKey = string.Format(CacheKey, key);
+
+        var value = await HybridCache.GetOrCreateAsync<string?>(
+            cacheKey,
+            async ct =>
+            {
+                return await Repository
+                    .Query()
+                    .Where(x => x.Key == key)
+                    .Select(o => o.ValueJson)
+                    .FirstOrDefaultAsync(ct);
+            },
+            new HybridCacheEntryOptions
+            {
+                LocalCacheExpiration = Options.Value.LookupL1CacheTime,
+                Expiration = Options.Value.LookupL2CacheTime
+            }
+        );
+
+        if (string.IsNullOrWhiteSpace(value))
+            return default;
+
+        return JsonSerializer.Deserialize<T>(value);
+    }
+
+    public async Task SetValueAsync<T>(string key, T value)
+    {
+        var cacheKey = string.Format(CacheKey, key);
+
+        var option = await Repository
+            .Query()
+            .FirstOrDefaultAsync(x => x.Key == key);
+
+        var json = JsonSerializer.Serialize(value);
+
+        if (option != null)
+        {
+            option.ValueJson = json;
+            await Repository.UpdateAsync(option);
+        }
+        else
+        {
+            option = new SettingsOption
+            {
+                Key = key,
+                ValueJson = json
+            };
+
+            await Repository.AddAsync(option);
+        }
+
+        await HybridCache.RemoveAsync(cacheKey);
+    }
+}

Moonlight.Api/Admin/Sys/Settings/WhiteLabelingController.cs

@@ -0,0 +1,47 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Moonlight.Api.Shared.Frontend;
+using Moonlight.Shared;
+using Moonlight.Shared.Admin.Sys.Settings;
+
+namespace Moonlight.Api.Admin.Sys.Settings;
+
+[ApiController]
+[Authorize(Policy = Permissions.System.Settings)]
+[Route("api/admin/system/settings/whiteLabeling")]
+public class WhiteLabelingController : Controller
+{
+    private readonly FrontendService FrontendService;
+    private readonly SettingsService SettingsService;
+
+    public WhiteLabelingController(SettingsService settingsService, FrontendService frontendService)
+    {
+        SettingsService = settingsService;
+        FrontendService = frontendService;
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<WhiteLabelingDto>> GetAsync()
+    {
+        var dto = new WhiteLabelingDto
+        {
+            Name = await SettingsService.GetValueAsync<string>(FrontendSettingConstants.Name) ?? "Moonlight"
+        };
+
+        return dto;
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<WhiteLabelingDto>> PostAsync([FromBody] SetWhiteLabelingDto request)
+    {
+        await SettingsService.SetValueAsync(FrontendSettingConstants.Name, request.Name);
+        await FrontendService.ResetCacheAsync();
+
+        var dto = new WhiteLabelingDto
+        {
+            Name = await SettingsService.GetValueAsync<string>(FrontendSettingConstants.Name) ?? "Moonlight"
+        };
+
+        return dto;
+    }
+}

Moonlight.Api/Admin/Sys/SystemController.cs

@@ -1,10 +1,9 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Moonlight.Api.Services;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Responses.Admin;
+using Moonlight.Shared.Admin.Sys;
 
-namespace Moonlight.Api.Http.Controllers.Admin;
+namespace Moonlight.Api.Admin.Sys;
 
 [ApiController]
 [Route("api/admin/system")]

Moonlight.Api/Admin/Sys/Themes/ThemeMapper.cs

@@ -1,10 +1,9 @@
 using System.Diagnostics.CodeAnalysis;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Shared.Http.Requests.Themes;
+using Moonlight.Shared.Admin.Sys.Themes;
-using Moonlight.Shared.Http.Responses.Themes;
 using Riok.Mapperly.Abstractions;
 
-namespace Moonlight.Api.Mappers;
+namespace Moonlight.Api.Admin.Sys.Themes;
 
 [Mapper]
 [SuppressMessage("Mapper", "RMG020:No members are mapped in an object mapping")]

Moonlight.Api/Admin/Sys/Themes/ThemeTransferModel.cs

@@ -0,0 +1,12 @@
+using VYaml.Annotations;
+
+namespace Moonlight.Api.Admin.Sys.Themes;
+
+[YamlObject]
+public partial class ThemeTransferModel
+{
+    public string Name { get; set; }
+    public string Version { get; set; }
+    public string Author { get; set; }
+    public string CssContent { get; set; }
+}

Moonlight.Api/Admin/Sys/Themes/ThemesController.cs

@@ -1,24 +1,21 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Mappers;
+using Moonlight.Api.Shared.Frontend;
-using Moonlight.Api.Services;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Requests;
+using Moonlight.Shared.Admin.Sys.Themes;
-using Moonlight.Shared.Http.Requests.Themes;
+using Moonlight.Shared.Shared;
-using Moonlight.Shared.Http.Responses;
-using Moonlight.Shared.Http.Responses.Themes;
 
-namespace Moonlight.Api.Http.Controllers.Admin;
+namespace Moonlight.Api.Admin.Sys.Themes;
 
 [ApiController]
 [Route("api/admin/themes")]
 public class ThemesController : Controller
 {
-    private readonly DatabaseRepository<Theme> ThemeRepository;
     private readonly FrontendService FrontendService;
+    private readonly DatabaseRepository<Theme> ThemeRepository;
 
     public ThemesController(DatabaseRepository<Theme> themeRepository, FrontendService frontendService)
     {
@@ -48,9 +45,7 @@ public class ThemesController : Controller
 
         // Filters
         if (filterOptions != null)
-        {
             foreach (var filterOption in filterOptions.Filters)
-            {
                 query = filterOption.Key switch
                 {
                     nameof(Theme.Name) =>
@@ -64,8 +59,6 @@ public class ThemesController : Controller
 
                     _ => query
                 };
-            }
-        }
 
         // Pagination
         var data = await query

Moonlight.Api/Admin/Sys/Themes/TransferController.cs

@@ -0,0 +1,74 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Moonlight.Api.Infrastructure.Database;
+using Moonlight.Api.Infrastructure.Database.Entities;
+using Moonlight.Shared;
+using Moonlight.Shared.Admin.Sys.Themes;
+using VYaml.Serialization;
+
+namespace Moonlight.Api.Admin.Sys.Themes;
+
+[ApiController]
+[Route("api/admin/themes")]
+[Authorize(Policy = Permissions.Themes.View)]
+public class TransferController : Controller
+{
+    private readonly DatabaseRepository<Theme> ThemeRepository;
+
+    public TransferController(DatabaseRepository<Theme> themeRepository)
+    {
+        ThemeRepository = themeRepository;
+    }
+
+    [HttpGet("{id:int}/export")]
+    public async Task<ActionResult> ExportAsync([FromRoute] int id)
+    {
+        var theme = await ThemeRepository
+            .Query()
+            .FirstOrDefaultAsync(x => x.Id == id);
+
+        if (theme == null)
+            return Problem("No theme with that id found", statusCode: 404);
+
+        var yml = YamlSerializer.Serialize(new ThemeTransferModel
+        {
+            Name = theme.Name,
+            Author = theme.Author,
+            CssContent = theme.CssContent,
+            Version = theme.Version
+        });
+
+        return File(yml.ToArray(), "text/yaml", $"{theme.Name}.yml");
+    }
+
+    [HttpPost("import")]
+    public async Task<ActionResult<ThemeDto>> ImportAsync()
+    {
+        var themeToImport = await YamlSerializer.DeserializeAsync<ThemeTransferModel>(Request.Body);
+
+        var existingTheme = await ThemeRepository
+            .Query()
+            .FirstOrDefaultAsync(x => x.Name == themeToImport.Name && x.Author == themeToImport.Author);
+
+        if (existingTheme == null)
+        {
+            var finalTheme = await ThemeRepository.AddAsync(new Theme
+            {
+                Name = themeToImport.Name,
+                Author = themeToImport.Author,
+                CssContent = themeToImport.CssContent,
+                Version = themeToImport.Version
+            });
+
+            return ThemeMapper.ToDto(finalTheme);
+        }
+
+        existingTheme.CssContent = themeToImport.CssContent;
+        existingTheme.Version = themeToImport.Version;
+
+        await ThemeRepository.UpdateAsync(existingTheme);
+
+        return ThemeMapper.ToDto(existingTheme);
+    }
+}

Moonlight.Api/Admin/Sys/Versions/FrontendOptions.cs

@@ -1,4 +1,4 @@
-namespace Moonlight.Api.Configuration;
+namespace Moonlight.Api.Admin.Sys.Versions;
 
 public class FrontendOptions
 {

Moonlight.Api/Admin/Sys/Versions/MoonlightVersion.cs

@@ -1,4 +1,4 @@
-namespace Moonlight.Api.Models;
+namespace Moonlight.Api.Admin.Sys.Versions;
 
 // Notes:
 // Identifier - This needs to be the branch to clone to build this version if

Moonlight.Api/Admin/Sys/Versions/VersionMapper.cs

@@ -1,9 +1,8 @@
 using System.Diagnostics.CodeAnalysis;
-using Moonlight.Api.Models;
+using Moonlight.Shared.Admin.Sys.Versions;
-using Moonlight.Shared.Http.Responses.Admin;
 using Riok.Mapperly.Abstractions;
 
-namespace Moonlight.Api.Mappers;
+namespace Moonlight.Api.Admin.Sys.Versions;
 
 [Mapper]
 [SuppressMessage("Mapper", "RMG020:Source member is not mapped to any target member")]

Moonlight.Api/Admin/Sys/Versions/VersionOptions.cs

@@ -1,4 +1,4 @@
-namespace Moonlight.Api.Configuration;
+namespace Moonlight.Api.Admin.Sys.Versions;
 
 public class VersionOptions
 {

Moonlight.Api/Admin/Sys/Versions/VersionService.cs

@@ -1,22 +1,16 @@
 using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
 using Microsoft.Extensions.Options;
-using Moonlight.Api.Configuration;
-using Moonlight.Api.Models;
 
-namespace Moonlight.Api.Services;
+namespace Moonlight.Api.Admin.Sys.Versions;
 
 public partial class VersionService
 {
-    private readonly IOptions<VersionOptions> Options;
-    private readonly IHttpClientFactory HttpClientFactory;
-
     private const string VersionPath = "/app/version";
     private const string GiteaServer = "https://git.battlestati.one";
     private const string GiteaRepository = "Moonlight-Panel/Moonlight";
-
+    private readonly IHttpClientFactory HttpClientFactory;
-    [GeneratedRegex(@"^v(?!1(\.|$))\d+\.[A-Za-z0-9]+(\.[A-Za-z0-9]+)*$")]
+    private readonly IOptions<VersionOptions> Options;
-    private static partial Regex RegexFilter();
 
     public VersionService(
         IOptions<VersionOptions> options,
@@ -27,6 +21,9 @@ public partial class VersionService
         HttpClientFactory = httpClientFactory;
     }
 
+    [GeneratedRegex(@"^v(?!1(\.|$))\d+\.[A-Za-z0-9]+(\.[A-Za-z0-9]+)*$")]
+    private static partial Regex RegexFilter();
+
     public async Task<MoonlightVersion[]> GetVersionsAsync()
     {
         if (Options.Value.OfflineMode)
@@ -42,7 +39,6 @@ public partial class VersionService
         var tagsJson = await JsonNode.ParseAsync(tagsJsonStream);
 
         if (tagsJson != null)
-        {
             foreach (var node in tagsJson.AsArray())
             {
                 if (node == null)
@@ -61,7 +57,6 @@ public partial class VersionService
                     createdAt
                 ));
             }
-        }
 
         // Branches
         const string branchesPath = $"{GiteaServer}/api/v1/repos/{GiteaRepository}/branches";
@@ -70,7 +65,6 @@ public partial class VersionService
         var branchesJson = await JsonNode.ParseAsync(branchesJsonStream);
 
         if (branchesJson != null)
-        {
             foreach (var node in branchesJson.AsArray())
             {
                 if (node == null)
@@ -94,7 +88,6 @@ public partial class VersionService
                     createdAt
                 ));
             }
-        }
 
         return versions.ToArray();
     }
@@ -106,7 +99,9 @@ public partial class VersionService
         string versionIdentifier;
 
         if (!string.IsNullOrWhiteSpace(Options.Value.CurrentOverride))
+        {
             versionIdentifier = Options.Value.CurrentOverride;
+        }
         else
         {
             if (File.Exists(VersionPath))

Moonlight.Api/Admin/Sys/Versions/VersionsController.cs

@@ -1,11 +1,9 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Moonlight.Api.Mappers;
-using Moonlight.Api.Services;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Responses.Admin;
+using Moonlight.Shared.Admin.Sys.Versions;
 
-namespace Moonlight.Api.Http.Controllers.Admin;
+namespace Moonlight.Api.Admin.Sys.Versions;
 
 [ApiController]
 [Route("api/admin/versions")]

Moonlight.Api/Admin/Users/Roles/RoleMapper.cs

@@ -1,10 +1,9 @@
 using System.Diagnostics.CodeAnalysis;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Shared.Http.Requests.Roles;
+using Moonlight.Shared.Admin.Users.Roles;
-using Moonlight.Shared.Http.Responses.Admin;
 using Riok.Mapperly.Abstractions;
 
-namespace Moonlight.Api.Mappers;
+namespace Moonlight.Api.Admin.Users.Roles;
 
 [Mapper]
 [SuppressMessage("Mapper", "RMG020:Source member is not mapped to any target member")]
@@ -13,6 +12,7 @@ public static partial class RoleMapper
 {
     [MapProperty([nameof(Role.Members), nameof(Role.Members.Count)], nameof(RoleDto.MemberCount))]
     public static partial RoleDto ToDto(Role role);
+
     public static partial Role ToEntity(CreateRoleDto request);
     public static partial void Merge([MappingTarget] Role role, UpdateRoleDto request);
 

Moonlight.Api/Admin/Users/Roles/RoleMembersController.cs

@@ -1,23 +1,23 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database;
+using Moonlight.Api.Admin.Users.Users;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Mappers;
+using Moonlight.Api.Infrastructure.Database.Entities;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Responses;
+using Moonlight.Shared.Admin.Users.Users;
-using Moonlight.Shared.Http.Responses.Users;
+using Moonlight.Shared.Shared;
 
-namespace Moonlight.Api.Http.Controllers.Admin;
+namespace Moonlight.Api.Admin.Users.Roles;
 
 [ApiController]
 [Authorize(Policy = Permissions.Roles.Members)]
 [Route("api/admin/roles/{roleId:int}/members")]
 public class RoleMembersController : Controller
 {
-    private readonly DatabaseRepository<User> UsersRepository;
-    private readonly DatabaseRepository<Role> RolesRepository;
     private readonly DatabaseRepository<RoleMember> RoleMembersRepository;
+    private readonly DatabaseRepository<Role> RolesRepository;
+    private readonly DatabaseRepository<User> UsersRepository;
 
     public RoleMembersController(
         DatabaseRepository<User> usersRepository,
@@ -53,19 +53,16 @@ public class RoleMembersController : Controller
 
         // Filtering
         if (!string.IsNullOrWhiteSpace(searchTerm))
-        {
             query = query.Where(x =>
                 EF.Functions.ILike(x.Username, $"%{searchTerm}%") ||
                 EF.Functions.ILike(x.Email, $"%{searchTerm}%")
             );
-        }
 
         // Pagination
-        var items = query
+        var items = UserMapper.ProjectToDto(query
                 .OrderBy(x => x.Id)
                 .Skip(startIndex)
-            .Take(length)
+                .Take(length))
-            .ProjectToDto()
             .ToArray();
 
         var totalCount = await query.CountAsync();
@@ -95,19 +92,16 @@ public class RoleMembersController : Controller
 
         // Filtering
         if (!string.IsNullOrWhiteSpace(searchTerm))
-        {
             query = query.Where(x =>
                 EF.Functions.ILike(x.Username, $"%{searchTerm}%") ||
                 EF.Functions.ILike(x.Email, $"%{searchTerm}%")
             );
-        }
 
         // Pagination
-        var items = query
+        var items = UserMapper.ProjectToDto(query
                 .OrderBy(x => x.Id)
                 .Skip(startIndex)
-            .Take(length)
+                .Take(length))
-            .ProjectToDto()
             .ToArray();
 
         var totalCount = await query.CountAsync();

Moonlight.Api/Admin/Users/Roles/RolesController.cs

@@ -1,16 +1,13 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Mappers;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Requests;
+using Moonlight.Shared.Admin.Users.Roles;
-using Moonlight.Shared.Http.Requests.Roles;
+using Moonlight.Shared.Shared;
-using Moonlight.Shared.Http.Responses;
-using Moonlight.Shared.Http.Responses.Admin;
 
-namespace Moonlight.Api.Http.Controllers.Admin;
+namespace Moonlight.Api.Admin.Users.Roles;
 
 [ApiController]
 [Route("api/admin/roles")]
@@ -45,9 +42,7 @@ public class RolesController : Controller
 
         // Filters
         if (filterOptions != null)
-        {
             foreach (var filterOption in filterOptions.Filters)
-            {
                 query = filterOption.Key switch
                 {
                     nameof(Role.Name) =>
@@ -55,8 +50,6 @@ public class RolesController : Controller
 
                     _ => query
                 };
-            }
-        }
 
         // Pagination
         var data = await query

Moonlight.Api/Admin/Users/Users/UserAuthService.cs

@@ -1,41 +1,41 @@
 using System.Security.Claims;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Caching.Hybrid;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
-using Moonlight.Api.Configuration;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Hooks;
-using Moonlight.Api.Interfaces;
 using Moonlight.Shared;
 
-namespace Moonlight.Api.Services;
+namespace Moonlight.Api.Admin.Users.Users;
 
 public class UserAuthService
 {
-    private readonly DatabaseRepository<User> UserRepository;
+    public const string CacheKeyPattern = $"Moonlight.{nameof(UserAuthService)}.{nameof(ValidateAsync)}-{{0}}";
-    private readonly IMemoryCache Cache;
-    private readonly ILogger<UserAuthService> Logger;
-    private readonly IOptions<SessionOptions> Options;
-    private readonly IEnumerable<IUserAuthHook> Hooks;
 
     private const string UserIdClaim = "UserId";
     private const string IssuedAtClaim = "IssuedAt";
     
-    public const string CacheKeyPattern = $"Moonlight.{nameof(UserAuthService)}.{nameof(ValidateAsync)}-{{0}}";
+    private readonly IEnumerable<IUserAuthHook> Hooks;
+    private readonly HybridCache HybridCache;
+    private readonly ILogger<UserAuthService> Logger;
+    private readonly IOptions<UserOptions> Options;
+    private readonly DatabaseRepository<User> UserRepository;
 
     public UserAuthService(
         DatabaseRepository<User> userRepository,
         ILogger<UserAuthService> logger,
-        IMemoryCache cache, IOptions<SessionOptions> options,
+        IOptions<UserOptions> options,
-        IEnumerable<IUserAuthHook> hooks
+        IEnumerable<IUserAuthHook> hooks,
+        HybridCache hybridCache
     )
     {
         UserRepository = userRepository;
         Logger = logger;
-        Cache = cache;
         Options = options;
         Hooks = hooks;
+        HybridCache = hybridCache;
     }
 
     public async Task<bool> SyncAsync(ClaimsPrincipal? principal)
@@ -59,7 +59,7 @@ public class UserAuthService
 
         if (user == null) // Sync user if not already existing in the database
         {
-            user = await UserRepository.AddAsync(new User()
+            user = await UserRepository.AddAsync(new User
             {
                 Username = username,
                 Email = email,
@@ -79,11 +79,9 @@ public class UserAuthService
         ]);
 
         foreach (var hook in Hooks)
-        {
+            // Run every hook, and if any returns false, we return false as well
-            // Run every hook and if any returns false we return false as well
             if (!await hook.SyncAsync(principal, user))
                 return false;
-        }
 
         return true;
     }
@@ -101,9 +99,11 @@ public class UserAuthService
 
         var cacheKey = string.Format(CacheKeyPattern, userId);
 
-        if (!Cache.TryGetValue<UserSession>(cacheKey, out var user))
+        var user = await HybridCache.GetOrCreateAsync<UserSession?>(
+            cacheKey,
+            async ct =>
             {
-            user = await UserRepository
+                return await UserRepository
                     .Query()
                     .AsNoTracking()
                     .Where(u => u.Id == userId)
@@ -111,22 +111,17 @@ public class UserAuthService
                         u.InvalidateTimestamp,
                         u.RoleMemberships.SelectMany(x => x.Role.Permissions).ToArray())
                     )
-                .FirstOrDefaultAsync();
+                    .FirstOrDefaultAsync(ct);
-
+            },
-            if (user == null)
+            new HybridCacheEntryOptions
-                return false;
-
-            Cache.Set(
-                cacheKey,
-                user,
-                TimeSpan.FromMinutes(Options.Value.ValidationCacheMinutes)
-            );
-        }
-        else
             {
+                LocalCacheExpiration = Options.Value.ValidationCacheL1Expiry,
+                Expiration = Options.Value.ValidationCacheL2Expiry
+            }
+        );
+
         if (user == null)
             return false;
-        }
 
         var issuedAtString = principal.FindFirstValue(IssuedAtClaim);
 
@@ -148,11 +143,9 @@ public class UserAuthService
         );
 
         foreach (var hook in Hooks)
-        {
+            // Run every hook, and if any returns false we return false as well
-            // Run every hook and if any returns false we return false as well
             if (!await hook.ValidateAsync(principal, userId))
                 return false;
-        }
 
         return true;
     }

Moonlight.Api/Admin/Users/Users/UserDeletionController.cs

@@ -1,21 +1,19 @@
-using System.Collections.Frozen;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Services;
 using Moonlight.Shared;
 
-namespace Moonlight.Api.Http.Controllers.Admin.Users;
+namespace Moonlight.Api.Admin.Users.Users;
 
 [ApiController]
 [Route("api/admin/users")]
 [Authorize(Policy = Permissions.Users.Delete)]
 public class UserDeletionController : Controller
 {
-    private readonly UserDeletionService UserDeletionService;
     private readonly DatabaseRepository<User> Repository;
+    private readonly UserDeletionService UserDeletionService;
 
     public UserDeletionController(UserDeletionService userDeletionService, DatabaseRepository<User> repository)
     {
@@ -39,7 +37,7 @@ public class UserDeletionController : Controller
         {
             return ValidationProblem(
                 new ValidationProblemDetails(
-                    new Dictionary<string, string[]>()
+                    new Dictionary<string, string[]>
                     {
                         {
                             string.Empty,

Moonlight.Api/Admin/Users/Users/UserDeletionService.cs

@@ -1,22 +1,26 @@
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Caching.Hybrid;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Interfaces;
+using Moonlight.Api.Infrastructure.Hooks;
 
-namespace Moonlight.Api.Services;
+namespace Moonlight.Api.Admin.Users.Users;
 
 public class UserDeletionService
 {
-    private readonly DatabaseRepository<User> Repository;
     private readonly IEnumerable<IUserDeletionHook> Hooks;
-    private readonly IMemoryCache Cache;
+    private readonly HybridCache HybridCache;
+    private readonly DatabaseRepository<User> Repository;
 
-    public UserDeletionService(DatabaseRepository<User> repository, IEnumerable<IUserDeletionHook> hooks, IMemoryCache cache)
+    public UserDeletionService(
+        DatabaseRepository<User> repository,
+        IEnumerable<IUserDeletionHook> hooks,
+        HybridCache hybridCache
+    )
     {
         Repository = repository;
         Hooks = hooks;
-        Cache = cache;
+        HybridCache = hybridCache;
     }
 
     public async Task<UserDeletionValidationResult> ValidateAsync(int userId)
@@ -54,7 +58,8 @@ public class UserDeletionService
             await hook.ExecuteAsync(user);
 
         await Repository.RemoveAsync(user);
-        Cache.Remove(string.Format(UserAuthService.CacheKeyPattern, userId));
+
+        await HybridCache.RemoveAsync(string.Format(UserAuthService.CacheKeyPattern, user.Id));
     }
 }
 

Moonlight.Api/Admin/Users/Users/UserLogoutController.cs

@@ -1,12 +1,11 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Services;
 using Moonlight.Shared;
 
-namespace Moonlight.Api.Http.Controllers.Admin.Users;
+namespace Moonlight.Api.Admin.Users.Users;
 
 [ApiController]
 [Route("api/admin/users/{id:int}/logout")]

Moonlight.Api/Admin/Users/Users/UserLogoutService.cs

@@ -1,26 +1,26 @@
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Caching.Hybrid;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Interfaces;
+using Moonlight.Api.Infrastructure.Hooks;
 
-namespace Moonlight.Api.Services;
+namespace Moonlight.Api.Admin.Users.Users;
 
 public class UserLogoutService
 {
-    private readonly DatabaseRepository<User> Repository;
     private readonly IEnumerable<IUserLogoutHook> Hooks;
-    private readonly IMemoryCache Cache;
+    private readonly HybridCache HybridCache;
+    private readonly DatabaseRepository<User> Repository;
 
     public UserLogoutService(
         DatabaseRepository<User> repository,
         IEnumerable<IUserLogoutHook> hooks,
-        IMemoryCache cache
+        HybridCache hybridCache
     )
     {
         Repository = repository;
         Hooks = hooks;
-        Cache = cache;
+        HybridCache = hybridCache;
     }
 
     public async Task LogoutAsync(int userId)
@@ -38,6 +38,6 @@ public class UserLogoutService
         user.InvalidateTimestamp = DateTimeOffset.UtcNow;
         await Repository.UpdateAsync(user);
 
-        Cache.Remove(string.Format(UserAuthService.CacheKeyPattern, userId));
+        await HybridCache.RemoveAsync(string.Format(UserAuthService.CacheKeyPattern, user.Id));
     }
 }

Moonlight.Api/Admin/Users/Users/UserMapper.cs

@@ -1,10 +1,9 @@
 using System.Diagnostics.CodeAnalysis;
+using Moonlight.Api.Infrastructure.Database.Entities;
+using Moonlight.Shared.Admin.Users.Users;
 using Riok.Mapperly.Abstractions;
-using Moonlight.Shared.Http.Requests.Users;
-using Moonlight.Shared.Http.Responses.Users;
-using Moonlight.Api.Database.Entities;
 
-namespace Moonlight.Api.Mappers;
+namespace Moonlight.Api.Admin.Users.Users;
 
 [Mapper]
 [SuppressMessage("Mapper", "RMG020:No members are mapped in an object mapping")]

Moonlight.Api/Admin/Users/Users/UserOptions.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.Api.Admin.Users.Users;
+
+public class UserOptions
+{
+    public TimeSpan ValidationCacheL1Expiry { get; set; } = TimeSpan.FromSeconds(30);
+    public TimeSpan ValidationCacheL2Expiry { get; set; } = TimeSpan.FromMinutes(3);
+}

Moonlight.Api/Admin/Users/Users/UsersController.cs

@@ -1,16 +1,13 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Mappers;
 using Moonlight.Shared;
-using Moonlight.Shared.Http.Requests;
+using Moonlight.Shared.Admin.Users.Users;
-using Moonlight.Shared.Http.Requests.Users;
+using Moonlight.Shared.Shared;
-using Moonlight.Shared.Http.Responses;
-using Moonlight.Shared.Http.Responses.Users;
 
-namespace Moonlight.Api.Http.Controllers.Admin.Users;
+namespace Moonlight.Api.Admin.Users.Users;
 
 [Authorize]
 [ApiController]
@@ -51,10 +48,10 @@ public class UsersController : Controller
             {
                 query = filterOption.Key switch
                 {
-                    nameof(Database.Entities.User.Email) =>
+                    nameof(Infrastructure.Database.Entities.User.Email) =>
                         query.Where(user => EF.Functions.ILike(user.Email, $"%{filterOption.Value}%")),
 
-                    nameof(Database.Entities.User.Username) =>
+                    nameof(Infrastructure.Database.Entities.User.Username) =>
                         query.Where(user => EF.Functions.ILike(user.Username, $"%{filterOption.Value}%")),
 
                     _ => query

Moonlight.Api/Configuration/ApiOptions.cs

@@ -1,6 +0,0 @@
-namespace Moonlight.Api.Configuration;
-
-public class ApiOptions
-{
-    public int LookupCacheMinutes { get; set; } = 3;
-}

Moonlight.Api/Configuration/SessionOptions.cs

@@ -1,6 +0,0 @@
-namespace Moonlight.Api.Configuration;
-
-public class SessionOptions
-{
-    public int ValidationCacheMinutes { get; set; } = 3;
-}

Moonlight.Api/Database/Entities/ApiKey.cs

@@ -1,24 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Moonlight.Api.Database.Interfaces;
-
-namespace Moonlight.Api.Database.Entities;
-
-public class ApiKey : IActionTimestamps
-{
-    public int Id { get; set; }
-
-    [MaxLength(30)]
-    public required string Name { get; set; }
-    
-    [MaxLength(300)]
-    public required string Description { get; set; }
-    
-    public string[] Permissions { get; set; } = [];
-    
-    [MaxLength(32)]
-    public string Key { get; set; }
-    
-    // Action timestamps
-    public DateTimeOffset CreatedAt { get; set; }
-    public DateTimeOffset UpdatedAt { get; set; }
-}

Moonlight.Api/Database/Entities/SettingsOption.cs

@@ -1,14 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Moonlight.Api.Database.Entities;
-
-public class SettingsOption
-{
-    public int Id { get; set; }
-
-    [MaxLength(256)]
-    public required string Key { get; set; }
-    
-    [MaxLength(4096)]
-    public required string Value { get; set; }
-}

Moonlight.Api/Database/Entities/Theme.cs

@@ -1,21 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Moonlight.Api.Database.Entities;
-
-public class Theme
-{
-    public int Id { get; set; }
-
-    [MaxLength(30)]
-    public required string Name { get; set; }
-    
-    [MaxLength(30)]
-    public required string Version { get; set; }
-    
-    [MaxLength(30)]
-    public required string Author { get; set; }
-    public bool IsEnabled { get; set; }
-    
-    [MaxLength(20_000)]
-    public required string CssContent { get; set; }
-}

Moonlight.Api/Implementations/ApiKeyScheme/ApiKeySchemeOptions.cs

@@ -1,8 +0,0 @@
-using Microsoft.AspNetCore.Authentication;
-
-namespace Moonlight.Api.Implementations.ApiKeyScheme;
-
-public class ApiKeySchemeOptions : AuthenticationSchemeOptions
-{
-    public TimeSpan LookupCacheTime { get; set; }
-}

Moonlight.Api/Infrastructure/Configuration/CacheOptions.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.Api.Infrastructure.Configuration;
+
+public class CacheOptions
+{
+    public bool EnableLayer2 { get; set; }
+}

Moonlight.Api/Infrastructure/Configuration/OidcOptions.cs

@@ -1,9 +1,10 @@
-namespace Moonlight.Api.Configuration;
+namespace Moonlight.Api.Infrastructure.Configuration;
 
 public class OidcOptions
 {
     public string Authority { get; set; }
     public bool RequireHttpsMetadata { get; set; } = true;
+    public bool DisableHttpsOnlyCookies { get; set; }
     public string ResponseType { get; set; } = "code";
     public string[]? Scopes { get; set; }
     public string ClientId { get; set; }

Moonlight.Api/Infrastructure/Configuration/RedisOptions.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.Api.Infrastructure.Configuration;
+
+public class RedisOptions
+{
+    public bool Enable { get; set; }
+    public string ConnectionString { get; set; }
+}

Moonlight.Api/Infrastructure/Database/DataContext.cs

@@ -1,19 +1,11 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
-using Moonlight.Api.Configuration;
+using Moonlight.Api.Infrastructure.Database.Entities;
-using Moonlight.Api.Database.Entities;
 
-namespace Moonlight.Api.Database;
+namespace Moonlight.Api.Infrastructure.Database;
 
 public class DataContext : DbContext
 {
-    public DbSet<User> Users { get; set; }
-    public DbSet<SettingsOption> SettingsOptions { get; set; }
-    public DbSet<Role> Roles { get; set; }
-    public DbSet<RoleMember> RoleMembers { get; set; }
-    public DbSet<ApiKey> ApiKeys { get; set; }
-    public DbSet<Theme> Themes { get; set; }
-
     private readonly IOptions<DatabaseOptions> Options;
 
     public DataContext(IOptions<DatabaseOptions> options)
@@ -21,6 +13,13 @@ public class DataContext : DbContext
         Options = options;
     }
 
+    public DbSet<User> Users { get; set; }
+    public DbSet<SettingsOption> SettingsOptions { get; set; }
+    public DbSet<Role> Roles { get; set; }
+    public DbSet<RoleMember> RoleMembers { get; set; }
+    public DbSet<ApiKey> ApiKeys { get; set; }
+    public DbSet<Theme> Themes { get; set; }
+
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
     {
         if (optionsBuilder.IsConfigured)
@@ -31,7 +30,12 @@ public class DataContext : DbContext
             $"Port={Options.Value.Port};" +
             $"Username={Options.Value.Username};" +
             $"Password={Options.Value.Password};" +
-            $"Database={Options.Value.Database}"
+            $"Database={Options.Value.Database}",
+            builder =>
+            {
+                builder.MigrationsAssembly(typeof(DataContext).Assembly);
+                builder.MigrationsHistoryTable("MigrationsHistory", "core");
+            }
         );
     }
 

Moonlight.Api/Infrastructure/Database/DatabaseOptions.cs

@@ -1,4 +1,4 @@
-namespace Moonlight.Api.Configuration;
+namespace Moonlight.Api.Infrastructure.Database;
 
 public class DatabaseOptions
 {

Moonlight.Api/Infrastructure/Database/DatabaseRepository.cs

@@ -1,7 +1,7 @@
 using Microsoft.EntityFrameworkCore;
-using Moonlight.Api.Database.Interfaces;
+using Moonlight.Api.Infrastructure.Database.Interfaces;
 
-namespace Moonlight.Api.Database;
+namespace Moonlight.Api.Infrastructure.Database;
 
 public class DatabaseRepository<T> where T : class
 {
@@ -14,7 +14,10 @@ public class DatabaseRepository<T> where T : class
         Set = DataContext.Set<T>();
     }
 
-    public IQueryable<T> Query() => Set;
+    public IQueryable<T> Query()
+    {
+        return Set;
+    }
 
     public async Task<T> AddAsync(T entity)
     {

Moonlight.Api/Infrastructure/Database/DbMigrationService.cs

@@ -2,9 +2,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
-using Moonlight.Api.Database;
 
-namespace Moonlight.Api.Services;
+namespace Moonlight.Api.Infrastructure.Database;
 
 public class DbMigrationService : IHostedLifecycleService
 {
@@ -29,7 +28,7 @@ public class DbMigrationService : IHostedLifecycleService
 
         if (migrationNames.Length == 0)
         {
-            Logger.LogDebug("No pending migrations found");
+            Logger.LogTrace("No pending migrations found");
             return;
         }
 
@@ -41,9 +40,28 @@ public class DbMigrationService : IHostedLifecycleService
         Logger.LogInformation("Migration complete");
     }
 
-    public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    public Task StartAsync(CancellationToken cancellationToken)
-    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    {
-    public Task StartedAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        return Task.CompletedTask;
-    public Task StoppedAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    }
-    public Task StoppingAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+
+    public Task StartedAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+
+    public Task StoppedAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+
+    public Task StoppingAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
 }

Moonlight.Api/Infrastructure/Database/Entities/ApiKey.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel.DataAnnotations;
+using Moonlight.Api.Infrastructure.Database.Interfaces;
+
+namespace Moonlight.Api.Infrastructure.Database.Entities;
+
+public class ApiKey : IActionTimestamps
+{
+    public int Id { get; set; }
+
+    [MaxLength(30)] public required string Name { get; set; }
+
+    [MaxLength(300)] public required string Description { get; set; }
+
+    public string[] Permissions { get; set; } = [];
+    public DateTimeOffset ValidUntil { get; set; }
+
+    [MaxLength(32)] public string Key { get; set; }
+
+    // Action timestamps
+    public DateTimeOffset CreatedAt { get; set; }
+    public DateTimeOffset UpdatedAt { get; set; }
+}

Moonlight.Api/Infrastructure/Database/Entities/Role.cs

@@ -1,17 +1,15 @@
 using System.ComponentModel.DataAnnotations;
-using Moonlight.Api.Database.Interfaces;
+using Moonlight.Api.Infrastructure.Database.Interfaces;
 
-namespace Moonlight.Api.Database.Entities;
+namespace Moonlight.Api.Infrastructure.Database.Entities;
 
 public class Role : IActionTimestamps
 {
     public int Id { get; set; }
 
-    [MaxLength(30)]
+    [MaxLength(30)] public required string Name { get; set; }
-    public required string Name { get; set; }
 
-    [MaxLength(300)]
+    [MaxLength(300)] public required string Description { get; set; }
-    public required string Description { get; set; }
 
     public string[] Permissions { get; set; } = [];
 

Moonlight.Api/Infrastructure/Database/Entities/RoleMember.cs

@@ -1,6 +1,6 @@
-using Moonlight.Api.Database.Interfaces;
+using Moonlight.Api.Infrastructure.Database.Interfaces;
 
-namespace Moonlight.Api.Database.Entities;
+namespace Moonlight.Api.Infrastructure.Database.Entities;
 
 public class RoleMember : IActionTimestamps
 {

Moonlight.Api/Infrastructure/Database/Entities/SettingsOption.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Moonlight.Api.Infrastructure.Database.Entities;
+
+public class SettingsOption
+{
+    public int Id { get; set; }
+
+    [MaxLength(256)] public required string Key { get; set; }
+
+    [MaxLength(4096)]
+    [Column(TypeName = "jsonb")]
+    public required string ValueJson { get; set; }
+}

Moonlight.Api/Infrastructure/Database/Entities/Theme.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Moonlight.Api.Infrastructure.Database.Entities;
+
+public class Theme
+{
+    public int Id { get; set; }
+
+    [MaxLength(30)] public required string Name { get; set; }
+
+    [MaxLength(30)] public required string Version { get; set; }
+
+    [MaxLength(30)] public required string Author { get; set; }
+
+    public bool IsEnabled { get; set; }
+
+    [MaxLength(20_000)] public required string CssContent { get; set; }
+}

Moonlight.Api/Infrastructure/Database/Entities/User.cs

@@ -1,18 +1,16 @@
 using System.ComponentModel.DataAnnotations;
-using Moonlight.Api.Database.Interfaces;
+using Moonlight.Api.Infrastructure.Database.Interfaces;
 
-namespace Moonlight.Api.Database.Entities;
+namespace Moonlight.Api.Infrastructure.Database.Entities;
 
 public class User : IActionTimestamps
 {
     public int Id { get; set; }
 
     // Base information
-    [MaxLength(50)]
+    [MaxLength(50)] public required string Username { get; set; }
-    public required string Username { get; set; }
 
-    [MaxLength(254)]
+    [MaxLength(254)] public required string Email { get; set; }
-    public required string Email { get; set; }
 
     // Authentication
     public DateTimeOffset InvalidateTimestamp { get; set; }

Moonlight.Api/Infrastructure/Database/Interfaces/IActionTimestamps.cs

@@ -1,4 +1,4 @@
-namespace Moonlight.Api.Database.Interfaces;
+namespace Moonlight.Api.Infrastructure.Database.Interfaces;
 
 internal interface IActionTimestamps
 {

Moonlight.Api/Infrastructure/Database/Migrations/20251225202335_AddedUsersAndSettings.Designer.cs

@@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 
 #nullable disable

Moonlight.Api/Infrastructure/Database/Migrations/20251230200748_AddedRolesAndActionTimestamps.Designer.cs

@@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 
 #nullable disable

Moonlight.Api/Infrastructure/Database/Migrations/20260116133404_AddedApiKeys.Designer.cs

@@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 
 #nullable disable

Moonlight.Api/Infrastructure/Database/Migrations/20260116134322_AdjustedLenghtsOfRoleAndApiKeyStrings.Designer.cs

@@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 
 #nullable disable

Moonlight.Api/Infrastructure/Database/Migrations/20260118005634_AddedThemes.Designer.cs

@@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 
 #nullable disable

Moonlight.Api/Infrastructure/Database/Migrations/20260129134620_SwitchedToJsonForSettingsOption.Designer.cs

@@ -0,0 +1,252 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.Api.Database.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    [Migration("20260129134620_SwitchedToJsonForSettingsOption")]
+    partial class SwitchedToJsonForSettingsOption
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("core")
+                .HasAnnotation("ProductVersion", "10.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApiKeys", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.RoleMember", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RoleMembers", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.SettingsOption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ValueJson")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SettingsOptions", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.Theme", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Author")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("CssContent")
+                        .IsRequired()
+                        .HasMaxLength(20000)
+                        .HasColumnType("character varying(20000)");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Themes", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(254)
+                        .HasColumnType("character varying(254)");
+
+                    b.Property<DateTimeOffset>("InvalidateTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.RoleMember", b =>
+                {
+                    b.HasOne("Moonlight.Api.Database.Entities.Role", "Role")
+                        .WithMany("Members")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Moonlight.Api.Database.Entities.User", "User")
+                        .WithMany("RoleMemberships")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.Role", b =>
+                {
+                    b.Navigation("Members");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.User", b =>
+                {
+                    b.Navigation("RoleMemberships");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.Api/Infrastructure/Database/Migrations/20260129134620_SwitchedToJsonForSettingsOption.cs

@@ -0,0 +1,46 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.Api.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class SwitchedToJsonForSettingsOption : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Value",
+                schema: "core",
+                table: "SettingsOptions");
+
+            migrationBuilder.AddColumn<string>(
+                name: "ValueJson",
+                schema: "core",
+                table: "SettingsOptions",
+                type: "jsonb",
+                maxLength: 4096,
+                nullable: false,
+                defaultValue: "");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ValueJson",
+                schema: "core",
+                table: "SettingsOptions");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Value",
+                schema: "core",
+                table: "SettingsOptions",
+                type: "character varying(4096)",
+                maxLength: 4096,
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

Moonlight.Api/Infrastructure/Database/Migrations/20260209114238_AddedValidUntilToApiKeys.Designer.cs

@@ -0,0 +1,255 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.Api.Database.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    [Migration("20260209114238_AddedValidUntilToApiKeys")]
+    partial class AddedValidUntilToApiKeys
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("core")
+                .HasAnnotation("ProductVersion", "10.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ValidUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApiKeys", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.RoleMember", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RoleMembers", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.SettingsOption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ValueJson")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SettingsOptions", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.Theme", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Author")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("CssContent")
+                        .IsRequired()
+                        .HasMaxLength(20000)
+                        .HasColumnType("character varying(20000)");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Themes", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(254)
+                        .HasColumnType("character varying(254)");
+
+                    b.Property<DateTimeOffset>("InvalidateTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users", "core");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.RoleMember", b =>
+                {
+                    b.HasOne("Moonlight.Api.Database.Entities.Role", "Role")
+                        .WithMany("Members")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Moonlight.Api.Database.Entities.User", "User")
+                        .WithMany("RoleMemberships")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.Role", b =>
+                {
+                    b.Navigation("Members");
+                });
+
+            modelBuilder.Entity("Moonlight.Api.Database.Entities.User", b =>
+                {
+                    b.Navigation("RoleMemberships");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.Api/Infrastructure/Database/Migrations/20260209114238_AddedValidUntilToApiKeys.cs

@@ -0,0 +1,32 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.Api.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedValidUntilToApiKeys : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "ValidUntil",
+                schema: "core",
+                table: "ApiKeys",
+                type: "timestamp with time zone",
+                nullable: false,
+                defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ValidUntil",
+                schema: "core",
+                table: "ApiKeys");
+        }
+    }
+}

Moonlight.Api/Infrastructure/Database/Migrations/DataContextModelSnapshot.cs

@@ -4,6 +4,7 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using Moonlight.Api.Database;
+using Moonlight.Api.Infrastructure.Database;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 
 #nullable disable
@@ -56,6 +57,9 @@ namespace Moonlight.Api.Database.Migrations
                     b.Property<DateTimeOffset>("UpdatedAt")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<DateTimeOffset>("ValidUntil")
+                        .HasColumnType("timestamp with time zone");
+
                     b.HasKey("Id");
 
                     b.ToTable("ApiKeys", "core");
@@ -136,10 +140,10 @@ namespace Moonlight.Api.Database.Migrations
                         .HasMaxLength(256)
                         .HasColumnType("character varying(256)");
 
-                    b.Property<string>("Value")
+                    b.Property<string>("ValueJson")
                         .IsRequired()
                         .HasMaxLength(4096)
-                        .HasColumnType("character varying(4096)");
+                        .HasColumnType("jsonb");
 
                     b.HasKey("Id");
 

Moonlight.Api/Infrastructure/Helpers/AppConsoleFormatter.cs

@@ -2,7 +2,7 @@
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Logging.Console;
 
-namespace Moonlight.Api.Helpers;
+namespace Moonlight.Api.Infrastructure.Helpers;
 
 public class AppConsoleFormatter : ConsoleFormatter
 {
@@ -58,8 +58,10 @@ public class AppConsoleFormatter : ConsoleFormatter
             textWriter.WriteLine(logEntry.Exception.ToString());
         }
         else
+        {
             textWriter.WriteLine();
         }
+    }
 
     private static (string text, string color) GetLevelInfo(LogLevel logLevel)
     {

Moonlight.Api/Infrastructure/Hooks/IDiagnoseProvider.cs

@@ -1,6 +1,6 @@
-using Moonlight.Api.Models;
+using Moonlight.Api.Admin.Sys.Diagnose;
 
-namespace Moonlight.Api.Interfaces;
+namespace Moonlight.Api.Infrastructure.Hooks;
 
 public interface IDiagnoseProvider
 {

Moonlight.Api/Infrastructure/Hooks/IUserAuthHook.cs

@@ -1,7 +1,7 @@
 using System.Security.Claims;
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
 
-namespace Moonlight.Api.Interfaces;
+namespace Moonlight.Api.Infrastructure.Hooks;
 
 public interface IUserAuthHook
 {

Moonlight.Api/Infrastructure/Hooks/IUserDeletionHook.cs

@@ -1,6 +1,6 @@
-using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Infrastructure.Database.Entities;
 
-namespace Moonlight.Api.Interfaces;
+namespace Moonlight.Api.Infrastructure.Hooks;
 
 public interface IUserDeletionHook
 {

Moonlight.Api/Infrastructure/Hooks/IUserLogoutHook.cs

@@ -0,0 +1,8 @@
+using Moonlight.Api.Infrastructure.Database.Entities;
+
+namespace Moonlight.Api.Infrastructure.Hooks;
+
+public interface IUserLogoutHook
+{
+    public Task ExecuteAsync(User user);
+}

Moonlight.Api/Infrastructure/Implementations/PermissionAuthorizationHandler.cs

@@ -1,7 +1,7 @@
 using Microsoft.AspNetCore.Authorization;
 using Moonlight.Shared;
 
-namespace Moonlight.Frontend.Implementations;
+namespace Moonlight.Api.Infrastructure.Implementations;
 
 public class PermissionAuthorizationHandler : AuthorizationHandler<PermissionRequirement>
 {