Program.cs

using System.Security.Cryptography.X509Certificates;
using Microsoft.AspNetCore.Cors.Infrastructure;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Http.Json;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using ModuWeb.Cors;
using ModuWeb.Extensions;
using ModuWeb.SessionSystem;
using ModuWeb.Storage;
using ModuWeb.ViewEngine;

namespace ModuWeb;

internal class Program
{
    internal static void Main(string[] args)
    {
        var builder = WebApplication.CreateSlimBuilder(args);

        builder.Services.AddSingleton<ICorsPolicyProvider, DynamicCorsPolicyProvider>();
        
        builder.Services.AddSingleton<IStorageService>(provider =>
        {
            var baseDbPathConfig = builder.Configuration["BaseDbPath"] ?? "db";
            var normalizedPath = baseDbPathConfig.Replace('/', Path.DirectorySeparatorChar)
                .Replace('\\', Path.DirectorySeparatorChar)
                .Trim(Path.DirectorySeparatorChar);
            var dbPath = Path.Combine(builder.Environment.ContentRootPath, normalizedPath,
                "storage.db");
            return new LiteDbStorageService(dbPath);
        });
        builder.Services.AddSingleton<ISessionService>(provider =>
        {
            var storage = provider.GetRequiredService<IStorageService>();
            var config = provider.GetRequiredService<IConfiguration>();
            return new LiteDbSessionService(storage, config);
        });
        builder.Services.AddSingleton<IModuleViewEngine, ModuleViewEngine>();
        builder.Services.AddCors();
        var url = builder.Configuration["Url"] ?? "http://*:5000";
        builder.WebHost.UseUrls(url);

        if (builder.Configuration.GetValue<bool>("UseHttps"))
        {
            builder.WebHost.UseKestrelHttpsConfiguration();
            builder.WebHost.ConfigureKestrel(options =>
            {
                var certPath = builder.Configuration["Certificate:Path"];
                var keyPath = builder.Configuration["Certificate:KeyPath"];
                if (!string.IsNullOrEmpty(certPath) && !string.IsNullOrEmpty(keyPath))
                {
                    options.ConfigureHttpsDefaults(https =>
                    {
                        https.ServerCertificate = X509Certificate2.CreateFromPemFile(certPath, keyPath);
                    });
                }
            });
        }

        builder.Services.Configure<JsonOptions>(options => options.JsonSerializerOptions());

        builder.Services.Configure<FormOptions>(options =>
        {
            options.MultipartBodyLengthLimit = builder.Configuration.GetValue<int>("MaxRequestBodySize") * 1024 * 1024;
        });
        builder.Services.Configure<KestrelServerOptions>(options =>
        {
            options.Limits.MaxRequestBodySize = builder.Configuration.GetValue<int>("MaxRequestBodySize") * 1024 * 1024;
        });

        var app = builder.Build();
        app.UseCors(); 

        var modulesPath = Path.Combine(builder.Environment.ContentRootPath, "modules");

        ModuleManager.Instance = new(modulesPath,
            builder.Configuration.GetSection("LoadOrder").Get<string[]>() ?? Array.Empty<string>(), app.Services);

        Logger.Info($"Module base path: `{builder.Configuration["BaseApiPath"]}`");
        app.UseStaticFiles();
        app.UseMiddleware<ModuleCorsGuardMiddleware>();
        app.UseMiddleware<ModuleMiddleware>(builder.Configuration["BaseApiPath"]);

        app.Use(async (context, next) =>
        {
            await next();
            if (context.Response.StatusCode == 404)
            {
                context.Response.ContentType = "text/plain";
                await context.Response.WriteAsync("Module not found");
            }
        });

        app.Run();
    }
}