feat(settings): redesigned UI, new field types, decoded-value API

framework/SimpleModule.Core/Settings/SettingDefinition.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 namespace SimpleModule.Core.Settings;
 
 public class SettingDefinition
@@ -9,4 +11,12 @@ public class SettingDefinition
     public SettingScope Scope { get; set; }
     public string? DefaultValue { get; set; }
     public SettingType Type { get; set; }
+    public IReadOnlyList<string>? AllowedValues { get; set; }
+    public double? Min { get; set; }
+    public double? Max { get; set; }
+    public string? Pattern { get; set; }
+    public bool Required { get; set; }
+    public bool Sensitive { get; set; }
+    public int Order { get; set; }
+    public string? Placeholder { get; set; }
 }

framework/SimpleModule.Core/Settings/SettingType.cs

@@ -6,4 +6,11 @@ public enum SettingType
     Number = 1,
     Bool = 2,
     Json = 3,
+    Select = 4,
+    Color = 5,
+    Url = 6,
+    Email = 7,
+    Password = 8,
+    MultilineText = 9,
+    DateTime = 10,
 }

modules/Core/src/SimpleModule.Core/types.ts

@@ -0,0 +1,19 @@
+// Auto-generated from [Dto] types — do not edit
+export interface SettingDefinition {
+  key: string;
+  displayName: string;
+  description: string;
+  group: string;
+  scope: any;
+  defaultValue: string;
+  type: any;
+  allowedValues: string[];
+  min: number | null;
+  max: number | null;
+  pattern: string;
+  required: boolean;
+  sensitive: boolean;
+  order: number;
+  placeholder: string;
+}
+

modules/Localization/tests/SimpleModule.Localization.Tests/Unit/LocaleResolutionMiddlewareTests.cs

@@ -232,24 +232,58 @@ private sealed class FakeSettingsContracts(string? language, Action? onGet = nul
             return Task.FromResult(language);
         }
 
+        public Task<System.Text.Json.JsonElement?> ResolveUserSettingElementAsync(
+            string key,
+            string userId
+        )
+        {
+            if (language is null)
+                return Task.FromResult<System.Text.Json.JsonElement?>(null);
+            using var doc = System.Text.Json.JsonDocument.Parse(
+                System.Text.Json.JsonSerializer.Serialize(language)
+            );
+            return Task.FromResult<System.Text.Json.JsonElement?>(doc.RootElement.Clone());
+        }
+
         public Task SetSettingAsync(
             string key,
-            string value,
+            System.Text.Json.JsonElement value,
             SettingScope scope,
             string? userId = null
         )
         {
             return Task.CompletedTask;
         }
 
+        public Task SetManyAsync(IReadOnlyList<BulkSettingUpdate> updates)
+        {
+            return Task.CompletedTask;
+        }
+
         public Task DeleteSettingAsync(string key, SettingScope scope, string? userId = null)
         {
             return Task.CompletedTask;
         }
 
-        public Task<IEnumerable<Setting>> GetSettingsAsync(SettingsFilter? filter = null)
+        public Task ResetToDefaultAsync(string key, SettingScope scope, string? userId = null)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task<IEnumerable<SettingValueDto>> GetSettingValuesAsync(
+            SettingsFilter? filter = null
+        )
+        {
+            return Task.FromResult<IEnumerable<SettingValueDto>>([]);
+        }
+
+        public Task<SettingValueDto?> GetSettingValueAsync(
+            string key,
+            SettingScope scope,
+            string? userId = null
+        )
         {
-            return Task.FromResult<IEnumerable<Setting>>([]);
+            return Task.FromResult<SettingValueDto?>(null);
         }
     }
 

modules/Settings/src/SimpleModule.Settings.Contracts/BulkUpdateSettingsRequest.cs

@@ -0,0 +1,19 @@
+using System.Text.Json;
+using SimpleModule.Core;
+using SimpleModule.Core.Settings;
+
+namespace SimpleModule.Settings.Contracts;
+
+[Dto]
+public class BulkSettingUpdate
+{
+    public string Key { get; set; } = string.Empty;
+    public SettingScope Scope { get; set; }
+    public JsonElement Value { get; set; }
+}
+
+[Dto]
+public class BulkUpdateSettingsRequest
+{
+    public IReadOnlyList<BulkSettingUpdate> Updates { get; set; } = [];
+}

modules/Settings/src/SimpleModule.Settings.Contracts/ISettingsContracts.cs

@@ -1,3 +1,4 @@
+using System.Text.Json;
 using SimpleModule.Core.Settings;
 
 namespace SimpleModule.Settings.Contracts;
@@ -7,7 +8,15 @@ public interface ISettingsContracts
     Task<string?> GetSettingAsync(string key, SettingScope scope, string? userId = null);
     Task<T?> GetSettingAsync<T>(string key, SettingScope scope, string? userId = null);
     Task<string?> ResolveUserSettingAsync(string key, string userId);
-    Task SetSettingAsync(string key, string value, SettingScope scope, string? userId = null);
+    Task<JsonElement?> ResolveUserSettingElementAsync(string key, string userId);
+    Task SetSettingAsync(string key, JsonElement value, SettingScope scope, string? userId = null);
+    Task SetManyAsync(IReadOnlyList<BulkSettingUpdate> updates);
     Task DeleteSettingAsync(string key, SettingScope scope, string? userId = null);
-    Task<IEnumerable<Setting>> GetSettingsAsync(SettingsFilter? filter = null);
+    Task ResetToDefaultAsync(string key, SettingScope scope, string? userId = null);
+    Task<IEnumerable<SettingValueDto>> GetSettingValuesAsync(SettingsFilter? filter = null);
+    Task<SettingValueDto?> GetSettingValueAsync(
+        string key,
+        SettingScope scope,
+        string? userId = null
+    );
 }

modules/Settings/src/SimpleModule.Settings.Contracts/Setting.cs

@@ -1,12 +1,25 @@
+using System.Text.Json;
+using SimpleModule.Core;
 using SimpleModule.Core.Settings;
 
 namespace SimpleModule.Settings.Contracts;
 
-public class Setting
+[Dto]
+public class SettingValueDto
 {
-    public string Key { get; set; } = string.Empty;
-    public string? Value { get; set; }
+    public string Key { get; set; } = "";
     public SettingScope Scope { get; set; }
+    public JsonElement? Value { get; set; }
+    public bool IsOverridden { get; set; }
     public string? UserId { get; set; }
-    public DateTimeOffset UpdatedAt { get; set; }
+    public DateTimeOffset? UpdatedAt { get; set; }
+}
+
+[Dto]
+public class UserSettingValueDto
+{
+    public string Key { get; set; } = "";
+    public JsonElement? Value { get; set; }
+    public JsonElement? ResolvedValue { get; set; }
+    public bool IsOverridden { get; set; }
 }

modules/Settings/src/SimpleModule.Settings.Contracts/SettingsConstants.cs

@@ -13,7 +13,9 @@ public static class Api
             public const string GetSettings = "/";
             public const string GetSetting = "/{key}";
             public const string GetDefinitions = "/definitions";
+            public const string GetResolvedSetting = "/{key}/resolved";
             public const string UpdateSetting = "/";
+            public const string BulkUpdateSettings = "/bulk";
             public const string DeleteSetting = "/{key}";
             public const string GetMySettings = "/me";
             public const string UpdateMySetting = "/me";

modules/Settings/src/SimpleModule.Settings.Contracts/UpdateSettingRequest.cs

@@ -1,10 +1,13 @@
+using System.Text.Json;
+using SimpleModule.Core;
 using SimpleModule.Core.Settings;
 
 namespace SimpleModule.Settings.Contracts;
 
+[Dto]
 public class UpdateSettingRequest
 {
     public string Key { get; set; } = string.Empty;
-    public string? Value { get; set; }
     public SettingScope Scope { get; set; }
+    public JsonElement Value { get; set; }
 }

modules/Settings/src/SimpleModule.Settings/Endpoints/Settings/BulkUpdateSettingsEndpoint.cs

@@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using SimpleModule.Core;
+using SimpleModule.Core.Authorization;
+using SimpleModule.Core.Settings;
+using SimpleModule.Settings.Contracts;
+
+namespace SimpleModule.Settings.Endpoints.Settings;
+
+public class BulkUpdateSettingsEndpoint : IEndpoint
+{
+    public const string Route = SettingsConstants.Routes.Api.BulkUpdateSettings;
+    public const string Method = "PUT";
+
+    public void Map(IEndpointRouteBuilder app) =>
+        app.MapPut(
+                Route,
+                async Task<IResult> (
+                    BulkUpdateSettingsRequest request,
+                    ISettingsContracts settings
+                ) =>
+                {
+                    var userScopedKey = request.Updates.FirstOrDefault(u => u.Scope == SettingScope.User)?.Key;
+                    if (userScopedKey is not null)
+                    {
+                        return TypedResults.Problem(
+                            detail: "Use /api/settings/me to set user-scoped settings.",
+                            statusCode: StatusCodes.Status400BadRequest,
+                            title: "Invalid scope"
+                        );
+                    }
+
+                    try
+                    {
+                        await settings.SetManyAsync(request.Updates);
+                        return TypedResults.Ok(new { count = request.Updates.Count });
+                    }
+                    catch (SettingValidationException ex)
+                    {
+                        return TypedResults.ValidationProblem(
+                            new Dictionary<string, string[]> { [ex.Key] = ex.Errors.ToArray() }
+                        );
+                    }
+                }
+            )
+            .RequirePermission(SettingsPermissions.Update);
+}

modules/Settings/src/SimpleModule.Settings/Endpoints/Settings/DeleteSettingEndpoint.cs

@@ -2,6 +2,7 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
 using SimpleModule.Core;
+using SimpleModule.Core.Authorization;
 using SimpleModule.Core.Settings;
 using SimpleModule.Settings.Contracts;
 
@@ -15,11 +16,20 @@ public class DeleteSettingEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder app) =>
         app.MapDelete(
                 Route,
-                async (string key, SettingScope scope, ISettingsContracts settings) =>
+                async Task<IResult> (string key, SettingScope? scope, ISettingsContracts settings) =>
                 {
-                    await settings.DeleteSettingAsync(key, scope);
+                    if (scope is null)
+                    {
+                        return TypedResults.Problem(
+                            detail: "Query parameter 'scope' is required.",
+                            statusCode: StatusCodes.Status400BadRequest,
+                            title: "Missing required parameter"
+                        );
+                    }
+
+                    await settings.ResetToDefaultAsync(key, scope.Value);
                     return TypedResults.NoContent();
                 }
             )
-            .RequireAuthorization();
+            .RequirePermission(SettingsPermissions.Update);
 }

modules/Settings/src/SimpleModule.Settings/Endpoints/Settings/GetResolvedSettingEndpoint.cs

@@ -0,0 +1,30 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using SimpleModule.Core;
+using SimpleModule.Settings.Contracts;
+
+namespace SimpleModule.Settings.Endpoints.Settings;
+
+public class GetResolvedSettingEndpoint : IEndpoint
+{
+    public const string Route = SettingsConstants.Routes.Api.GetResolvedSetting;
+
+    public void Map(IEndpointRouteBuilder app) =>
+        app.MapGet(
+                Route,
+                async Task<IResult> (
+                    string key,
+                    ISettingsContracts settings,
+                    ClaimsPrincipal principal
+                ) =>
+                {
+                    var userId =
+                        principal.FindFirstValue(ClaimTypes.NameIdentifier) ?? string.Empty;
+                    var value = await settings.ResolveUserSettingElementAsync(key, userId);
+                    return TypedResults.Ok(new { key, value });
+                }
+            )
+            .RequireAuthorization();
+}

modules/Settings/src/SimpleModule.Settings/Endpoints/Settings/GetSettingEndpoint.cs

@@ -14,19 +14,23 @@ public class GetSettingEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder app) =>
         app.MapGet(
                 Route,
-                async Task<IResult> (string key, SettingScope scope, ISettingsContracts settings) =>
+                async Task<IResult> (
+                    string key,
+                    SettingScope? scope,
+                    ISettingsContracts settings
+                ) =>
                 {
-                    var value = await settings.GetSettingAsync(key, scope);
-                    return value is not null
-                        ? TypedResults.Ok(
-                            new
-                            {
-                                key,
-                                value,
-                                scope,
-                            }
-                        )
-                        : TypedResults.NotFound();
+                    if (scope is null)
+                    {
+                        return TypedResults.Problem(
+                            detail: "Query parameter 'scope' is required.",
+                            statusCode: StatusCodes.Status400BadRequest,
+                            title: "Missing required parameter"
+                        );
+                    }
+
+                    var dto = await settings.GetSettingValueAsync(key, scope.Value);
+                    return dto is not null ? TypedResults.Ok(dto) : TypedResults.NotFound();
                 }
             )
             .RequireAuthorization();

modules/Settings/src/SimpleModule.Settings/Endpoints/Settings/GetSettingsEndpoint.cs

@@ -14,10 +14,15 @@ public class GetSettingsEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder app) =>
         app.MapGet(
                 Route,
-                async (ISettingsContracts settings, SettingScope? scope) =>
+                async (ISettingsContracts settings, SettingScope? scope, string? group) =>
                 {
-                    var filter = scope is not null ? new SettingsFilter { Scope = scope } : null;
-                    var results = await settings.GetSettingsAsync(filter);
+                    SettingsFilter? filter = null;
+                    if (scope is not null || group is not null)
+                    {
+                        filter = new SettingsFilter { Scope = scope, Group = group };
+                    }
+
+                    var results = await settings.GetSettingValuesAsync(filter);
                     return TypedResults.Ok(results);
                 }
             )