Allow importing repositories in modules, not just dependencies

api/src/main/java/dev/plex/module/PlexModuleFile.java

@@ -13,6 +13,7 @@ public final class PlexModuleFile
     private final String version;
     private final int apiCompatibility;
     private List<String> libraries = List.of();
+    private List<String> repositories = List.of();
 
     public PlexModuleFile(String name, String main, String description, String version, int apiCompatibility)
     {
@@ -57,4 +58,14 @@ public final class PlexModuleFile
     {
         this.libraries = List.copyOf(libraries);
     }
+
+    public List<String> getRepositories()
+    {
+        return repositories;
+    }
+
+    public void setRepositories(List<String> repositories)
+    {
+        this.repositories = List.copyOf(repositories);
+    }
 }

server/src/main/java/dev/plex/PlexLibraryManager.java

@@ -10,6 +10,7 @@ import java.io.IOException;
 import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.jar.JarFile;
@@ -29,8 +30,16 @@ public class PlexLibraryManager implements PluginLoader
     {
         MavenLibraryResolver resolver = new MavenLibraryResolver();
         PluginLibraries pluginLibraries = load();
+        var repositoryUrls = new HashSet<String>();
+        pluginLibraries.asRepositories().forEach(repository ->
+        {
+            repositoryUrls.add(repository.getUrl());
+            resolver.addRepository(repository);
+        });
+        loadModuleRepositories()
+                .filter(repository -> repositoryUrls.add(repository.getUrl()))
+                .forEach(resolver::addRepository);
         pluginLibraries.asDependencies().forEach(resolver::addDependency);
-        pluginLibraries.asRepositories().forEach(resolver::addRepository);
         loadModuleDependencies().forEach(resolver::addDependency);
         classpathBuilder.addLibrary(resolver);
     }
@@ -64,7 +73,52 @@ public class PlexLibraryManager implements PluginLoader
                 .map(library -> new Dependency(new DefaultArtifact(library), null));
     }
 
+    private Stream<RemoteRepository> loadModuleRepositories()
+    {
+        File modulesFolder = new File("plugins/Plex/modules");
+        File[] moduleFiles = modulesFolder.listFiles((directory, name) -> name.endsWith(".jar"));
+
+        if (moduleFiles == null)
+        {
+            return Stream.empty();
+        }
+
+        return Arrays.stream(moduleFiles)
+                .flatMap(this::readModuleRepositories)
+                .distinct();
+    }
+
     private Stream<String> readModuleLibraries(File moduleFile)
+    {
+        YamlConfiguration moduleYml = readModuleYml(moduleFile);
+        if (moduleYml == null)
+        {
+            return Stream.empty();
+        }
+        return moduleYml.getStringList("libraries").stream();
+    }
+
+    private Stream<RemoteRepository> readModuleRepositories(File moduleFile)
+    {
+        YamlConfiguration moduleYml = readModuleYml(moduleFile);
+        if (moduleYml == null)
+        {
+            return Stream.empty();
+        }
+
+        var repositories = moduleYml.getConfigurationSection("repositories");
+        if (repositories == null)
+        {
+            return Stream.empty();
+        }
+
+        return repositories.getKeys(false).stream()
+                .map(id -> Map.entry(id, repositories.getString(id, "")))
+                .filter(entry -> !entry.getValue().isBlank())
+                .map(entry -> new RemoteRepository.Builder(entry.getKey(), "default", entry.getValue()).build());
+    }
+
+    private YamlConfiguration readModuleYml(File moduleFile)
     {
         try (JarFile jarFile = new JarFile(moduleFile))
         {
@@ -72,17 +126,17 @@ public class PlexLibraryManager implements PluginLoader
 
             if (moduleYml == null)
             {
-                return Stream.empty();
+                return null;
             }
 
             try (var in = new InputStreamReader(jarFile.getInputStream(moduleYml), StandardCharsets.UTF_8))
             {
-                return YamlConfiguration.loadConfiguration(in).getStringList("libraries").stream();
+                return YamlConfiguration.loadConfiguration(in);
             }
         }
         catch (IOException e)
         {
-            throw new RuntimeException("Failed to read module libraries from " + moduleFile.getName(), e);
+            throw new RuntimeException("Failed to read module metadata from " + moduleFile.getName(), e);
         }
     }
 

server/src/main/java/dev/plex/module/ModuleManager.java

@@ -89,9 +89,16 @@ public class ModuleManager
                     }
 
                     List<String> libraries = internalModuleConfig.getStringList("libraries");
+                    List<String> repositories = internalModuleConfig.getConfigurationSection("repositories") == null
+                            ? List.of()
+                            : internalModuleConfig.getConfigurationSection("repositories").getKeys(false).stream()
+                                    .map(id -> internalModuleConfig.getConfigurationSection("repositories").getString(id, ""))
+                                    .filter(repository -> !repository.isBlank())
+                                    .toList();
 
                     PlexModuleFile plexModuleFile = new PlexModuleFile(name, main, description, version, apiCompatibility);
                     plexModuleFile.setLibraries(libraries);
+                    plexModuleFile.setRepositories(repositories);
                     Class<? extends PlexModule> module = (Class<? extends PlexModule>) Class.forName(main, true, loader);
 
                     PlexModule plexModule = module.getConstructor().newInstance();