feat(backend): support multiple script languages instead of the hardcoded ones

ScriptBeeWebApp/src/Gateway/Adapters/Web/EndpointDefinitions/ProjectStructure/GetProjectStructureEndpoint.cs

@@ -15,6 +15,7 @@ public class GetProjectStructureEndpoint : IEndpointDefinition
     public void DefineServices(IServiceCollection services)
     {
         services.AddScoped<IGetProjectFilesUseCase, GetProjectFilesService>();
+        services.AddScoped<IGetAvailableScriptTypesUseCase, GetAvailableScriptTypesService>();
     }
 
     public void DefineEndpoints(IEndpointRouteBuilder app)
@@ -79,19 +80,17 @@ private static async Task<
         );
     }
 
-    private static async Task<Ok<WebGetAvailableScriptTypesResponse>> GetAvailableScriptTypes(
+    private static Ok<WebGetAvailableScriptTypesResponse> GetAvailableScriptTypes(
+        IGetAvailableScriptTypesUseCase useCase,
         [FromRoute] string projectId
     )
     {
-        await Task.CompletedTask;
-        // TODO FIXIT: remove hardcoded value
+        var scriptTypes = useCase.GetAvailableScriptTypes();
 
         return TypedResults.Ok(
-            new WebGetAvailableScriptTypesResponse([
-                new WebScriptLanguage("csharp", ".cs"),
-                new WebScriptLanguage("python", ".py"),
-                new WebScriptLanguage("javascript", ".js"),
-            ])
+            new WebGetAvailableScriptTypesResponse(
+                scriptTypes.Select(s => new WebScriptLanguage(s.Name, s.Extension)).ToList()
+            )
         );
     }
 }

ScriptBeeWebApp/src/Gateway/Application/Service.Gateway/ProjectStructure/GetAvailableScriptTypesService.cs

@@ -0,0 +1,33 @@
+using ScriptBee.Domain.Model.Plugins.Manifest;
+using ScriptBee.Domain.Model.ProjectStructure;
+using ScriptBee.Plugins.Loader;
+using ScriptBee.UseCases.Gateway.ProjectStructure;
+
+namespace ScriptBee.Service.Gateway.ProjectStructure;
+
+public class GetAvailableScriptTypesService(IPluginRepository pluginRepository)
+    : IGetAvailableScriptTypesUseCase
+{
+    public IEnumerable<ScriptLanguage> GetAvailableScriptTypes()
+    {
+        var defaultLanguages = new List<ScriptLanguage>
+        {
+            new("csharp", ".cs"),
+            new("python", ".py"),
+            new("javascript", ".js"),
+        };
+
+        var pluginLanguages = pluginRepository
+            .GetLoadedPlugins()
+            .SelectMany(p => p.Manifest.ExtensionPoints)
+            .OfType<ScriptRunnerPluginExtensionPoint>()
+            .Where(r =>
+                !defaultLanguages.Any(dl =>
+                    dl.Name.Equals(r.Language, StringComparison.InvariantCultureIgnoreCase)
+                )
+            )
+            .Select(r => new ScriptLanguage(r.Language, r.Extension));
+
+        return defaultLanguages.Concat(pluginLanguages);
+    }
+}

ScriptBeeWebApp/src/Gateway/Application/UseCases.Gateway/ProjectStructure/IGetAvailableScriptTypesUseCase.cs

@@ -0,0 +1,8 @@
+using ScriptBee.Domain.Model.ProjectStructure;
+
+namespace ScriptBee.UseCases.Gateway.ProjectStructure;
+
+public interface IGetAvailableScriptTypesUseCase
+{
+    IEnumerable<ScriptLanguage> GetAvailableScriptTypes();
+}

ScriptBeeWebApp/test/Gateway/Adapters/Web.Tests/EndpointDefinitions/ProjectStructure/GetProjectStructureEndpointTest.cs

@@ -233,4 +233,34 @@ [new ScriptId(Guid.NewGuid())]
 
         await response.AssertResponse(HttpStatusCode.OK, responsePath);
     }
+
+    [Theory]
+    [FilePath("TestData/GetProjectStructure/available-script-types.json")]
+    public async Task GetAvailableScriptTypes_ShouldReturnOk(string responsePath)
+    {
+        var useCase = Substitute.For<IGetAvailableScriptTypesUseCase>();
+        useCase
+            .GetAvailableScriptTypes()
+            .Returns(
+                new List<ScriptLanguage>
+                {
+                    new("csharp", ".cs"),
+                    new("python", ".py"),
+                    new("javascript", ".js"),
+                }
+            );
+
+        TestApiCaller<Program> api = new("/api/projects/id/structure/available-script-types");
+        var response = await api.GetApi(
+            new TestWebApplicationFactory<Program>(
+                outputHelper,
+                services =>
+                {
+                    services.AddSingleton(useCase);
+                }
+            )
+        );
+
+        await response.AssertResponse(HttpStatusCode.OK, responsePath);
+    }
 }

ScriptBeeWebApp/test/Gateway/Adapters/Web.Tests/EndpointDefinitions/ProjectStructure/TestData/GetProjectStructure/available-script-types.json

@@ -0,0 +1,16 @@
+{
+  "data": [
+    {
+      "name": "csharp",
+      "extension": ".cs"
+    },
+    {
+      "name": "python",
+      "extension": ".py"
+    },
+    {
+      "name": "javascript",
+      "extension": ".js"
+    }
+  ]
+}

ScriptBeeWebApp/test/Gateway/Application/Service.Gateway.Tests/ProjectStructure/GetAvailableScriptTypesServiceTests.cs

@@ -0,0 +1,101 @@
+using NSubstitute;
+using ScriptBee.Domain.Model.Plugins;
+using ScriptBee.Domain.Model.Plugins.Manifest;
+using ScriptBee.Domain.Model.ProjectStructure;
+using ScriptBee.Plugins.Loader;
+using ScriptBee.Service.Gateway.ProjectStructure;
+
+namespace ScriptBee.Service.Gateway.Tests.ProjectStructure;
+
+public class GetAvailableScriptTypesServiceTests
+{
+    private readonly IPluginRepository _pluginRepository = Substitute.For<IPluginRepository>();
+    private readonly GetAvailableScriptTypesService _service;
+
+    public GetAvailableScriptTypesServiceTests()
+    {
+        _service = new GetAvailableScriptTypesService(_pluginRepository);
+    }
+
+    [Fact]
+    public void GivenNoPlugins_WhenGetAvailableScriptTypes_ThenReturnDefaults()
+    {
+        _pluginRepository.GetLoadedPlugins().Returns(Enumerable.Empty<Plugin>());
+
+        var result = _service.GetAvailableScriptTypes();
+
+        var languages = result.ToList();
+        languages.Count.ShouldBe(3);
+        languages.ShouldContain(new ScriptLanguage("csharp", ".cs"));
+        languages.ShouldContain(new ScriptLanguage("python", ".py"));
+        languages.ShouldContain(new ScriptLanguage("javascript", ".js"));
+    }
+
+    [Fact]
+    public void GivenPlugins_WhenGetAvailableScriptTypes_ThenReturnDefaultsAndPlugins()
+    {
+        var manifest = new PluginManifest
+        {
+            ExtensionPoints =
+            [
+                new ScriptRunnerPluginExtensionPoint { Language = "lua", Extension = ".lua" },
+            ],
+        };
+        var plugin = new Plugin("path", new PluginId("lua-plugin", new Version(1, 0)), manifest);
+        _pluginRepository.GetLoadedPlugins().Returns(new List<Plugin> { plugin });
+
+        var result = _service.GetAvailableScriptTypes();
+
+        var languages = result.ToList();
+        languages.Count.ShouldBe(4);
+        languages.ShouldContain(new ScriptLanguage("csharp", ".cs"));
+        languages.ShouldContain(new ScriptLanguage("python", ".py"));
+        languages.ShouldContain(new ScriptLanguage("javascript", ".js"));
+        languages.ShouldContain(new ScriptLanguage("lua", ".lua"));
+    }
+
+    [Fact]
+    public void GivenPluginWithDefaultName_WhenGetAvailableScriptTypes_ThenDoNotDuplicate()
+    {
+        var manifest = new PluginManifest
+        {
+            ExtensionPoints =
+            [
+                new ScriptRunnerPluginExtensionPoint { Language = "CSharp", Extension = ".cs" },
+            ],
+        };
+        var plugin = new Plugin("path", new PluginId("csharp-plugin", new Version(1, 0)), manifest);
+        _pluginRepository.GetLoadedPlugins().Returns(new List<Plugin> { plugin });
+
+        var result = _service.GetAvailableScriptTypes();
+
+        result.Count().ShouldBe(3);
+    }
+
+    [Fact]
+    public void GivenPluginsWithOtherExtensionPoints_WhenGetAvailableScriptTypes_ThenReturnOnlyScriptRunnerDefaultsAndPlugins()
+    {
+        var manifest = new PluginManifest
+        {
+            ExtensionPoints =
+            [
+                new ScriptRunnerPluginExtensionPoint { Language = "lua", Extension = ".lua" },
+                new LinkerPluginExtensionPoint
+                {
+                    Kind = "Linker",
+                    EntryPoint = "Entry",
+                    Version = "1.0",
+                },
+            ],
+        };
+        var plugin = new Plugin("path", new PluginId("lua-plugin", new Version(1, 0)), manifest);
+        _pluginRepository.GetLoadedPlugins().Returns(new List<Plugin> { plugin });
+
+        var result = _service.GetAvailableScriptTypes();
+
+        var languages = result.ToList();
+        languages.Count.ShouldBe(4);
+        languages.ShouldContain(new ScriptLanguage("lua", ".lua"));
+        languages.ShouldNotContain(new ScriptLanguage("Linker", ""));
+    }
+}