Added support for nullable World parameters

Refactored `EconomyController` and `BankController` methods to include `@Nullable` `World` parameters. Adjusted method signatures and default behaviors to accommodate this change.

Author: NonSwag

plugin/src/main/java/net/thenextlvl/service/wrapper/service/BankServiceWrapper.java

@@ -10,6 +10,7 @@
 import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.Unmodifiable;
 import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Optional;
 import java.util.Set;
@@ -35,48 +36,28 @@ public Currency getDefaultCurrency() {
     }
 
     @Override
-    public CompletableFuture<Bank> createBank(OfflinePlayer player, String name) {
+    public CompletableFuture<Bank> createBank(OfflinePlayer player, String name, @Nullable World world) {
         return CompletableFuture.completedFuture(economy.createBank(name, player))
                 .thenApply(bank -> getBank(name).orElseThrow());
     }
 
     @Override
-    public CompletableFuture<Bank> createBank(OfflinePlayer player, String name, World world) {
-        return createBank(player, name);
-    }
-
-    @Override
-    public CompletableFuture<Bank> createBank(UUID uuid, String name) {
-        return createBank(provider.getServer().getOfflinePlayer(uuid), name);
-    }
-
-    @Override
-    public CompletableFuture<Bank> createBank(UUID uuid, String name, World world) {
+    public CompletableFuture<Bank> createBank(UUID uuid, String name, @Nullable World world) {
         return createBank(provider.getServer().getOfflinePlayer(uuid), name, world);
     }
 
     @Override
-    public CompletableFuture<Bank> loadBank(String name) {
-        return CompletableFuture.completedFuture(getBank(name).orElse(null));
+    public CompletableFuture<Optional<Bank>> loadBank(String name) {
+        return CompletableFuture.completedFuture(getBank(name));
     }
 
     @Override
-    public CompletableFuture<Bank> loadBank(UUID uuid) {
-        return CompletableFuture.completedFuture(getBank(uuid).orElse(null));
+    public CompletableFuture<Optional<Bank>> loadBank(UUID uuid, @Nullable World world) {
+        return CompletableFuture.completedFuture(getBank(uuid, world));
     }
 
     @Override
-    public CompletableFuture<Bank> loadBank(UUID uuid, World world) {
-        return CompletableFuture.completedFuture(getBank(uuid, world).orElse(null));
-    }
-
-    @Override
-    public CompletableFuture<@Unmodifiable Set<Bank>> loadBanks() {
-        return CompletableFuture.completedFuture(getBanks());
-    }
-
-    @Override
-    public CompletableFuture<@Unmodifiable Set<Bank>> loadBanks(World world) {
+    public CompletableFuture<@Unmodifiable Set<Bank>> loadBanks(@Nullable World world) {
         return CompletableFuture.completedFuture(getBanks(world));
     }
 
@@ -87,40 +68,30 @@ public CompletableFuture<Boolean> deleteBank(String name) {
     }
 
     @Override
-    public CompletableFuture<Boolean> deleteBank(UUID uuid) {
-        return deleteBank(getBank(uuid).orElseThrow().getName());
-    }
-
-    @Override
-    public CompletableFuture<Boolean> deleteBank(UUID uuid, World world) {
+    public CompletableFuture<Boolean> deleteBank(UUID uuid, @Nullable World world) {
         return deleteBank(getBank(uuid, world).orElseThrow().getName());
     }
 
     @Override
     public @Unmodifiable Set<Bank> getBanks() {
         return economy.getBanks().stream()
-                .map(bank -> new WrappedBank(bank, null, economy, plugin))
+                .map(bank -> new WrappedBank(this, bank, null, economy, plugin))
                 .collect(Collectors.toUnmodifiableSet());
     }
 
-    @Override
-    public @Unmodifiable Set<Bank> getBanks(World world) {
-        return getBanks();
-    }
-
     @Override
     public Optional<Bank> getBank(String name) {
         return Optional.of(new WrappedBank(this, name, null, economy, provider));
     }
 
     @Override
-    public Optional<Bank> getBank(UUID uuid) {
+    public Optional<Bank> getBank(UUID uuid, @Nullable World world) {
         return Optional.empty();
     }
 
     @Override
-    public Optional<Bank> getBank(UUID uuid, World world) {
-        return Optional.empty();
+    public boolean hasMultiWorldSupport() {
+        return false;
     }
 
     @Override

plugin/src/main/java/net/thenextlvl/service/wrapper/service/EconomyServiceWrapper.java

@@ -2,17 +2,17 @@
 
 import net.milkbowl.vault.economy.Economy;
 import net.thenextlvl.service.api.economy.Account;
-import net.thenextlvl.service.api.economy.currency.Currency;
 import net.thenextlvl.service.api.economy.EconomyController;
-import net.thenextlvl.service.wrapper.Wrapper;
 import net.thenextlvl.service.wrapper.service.model.WrappedAccount;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.World;
 import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.Unmodifiable;
 import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
@@ -32,90 +32,67 @@ public EconomyServiceWrapper(Economy economy, Plugin provider) {
     }
 
     @Override
-    public CompletableFuture<@Unmodifiable Set<Account>> loadAccounts() {
-        return CompletableFuture.completedFuture(getAccounts());
+    public CompletableFuture<@Unmodifiable Set<Account>> loadAccounts(@Nullable World world) {
+        return CompletableFuture.completedFuture(getAccounts(world));
     }
 
     @Override
-    public @Unmodifiable Set<Account> getAccounts() {
+    public @Unmodifiable Set<Account> getAccounts(@Nullable World world) {
         return Arrays.stream(provider.getServer().getOfflinePlayers())
-                .filter(economy::hasAccount)
-                .map(player -> new WrappedAccount(this, null, economy, player))
+                .filter(player -> economy.hasAccount(player, world != null ? world.getName() : null))
+                .map(player -> new WrappedAccount(this, world, economy, player))
                 .collect(Collectors.toUnmodifiableSet());
     }
 
     @Override
-    public Optional<Account> getAccount(OfflinePlayer player) {
-        if (!economy.hasAccount(player)) return Optional.empty();
-        return Optional.of(new WrappedAccount(this, null, economy, player));
-    }
-
-    @Override
-    public Optional<Account> getAccount(OfflinePlayer player, World world) {
-        if (!economy.hasAccount(player, world.getName())) return Optional.empty();
+    public Optional<Account> getAccount(OfflinePlayer player, @Nullable World world) {
+        if (!economy.hasAccount(player, world != null ? world.getName() : null)) return Optional.empty();
         return Optional.of(new WrappedAccount(this, world, economy, player));
     }
 
     @Override
-    public Optional<Account> getAccount(UUID uuid) {
-        return getAccount(provider.getServer().getOfflinePlayer(uuid));
-    }
-
-    @Override
-    public Optional<Account> getAccount(UUID uuid, World world) {
+    public Optional<Account> getAccount(UUID uuid, @Nullable World world) {
         return getAccount(provider.getServer().getOfflinePlayer(uuid), world);
     }
 
     @Override
-    public CompletableFuture<Account> createAccount(OfflinePlayer player) {
-        return CompletableFuture.completedFuture(economy.createPlayerAccount(player))
-                .thenApply(account -> getAccount(player).orElseThrow());
+    public CompletableFuture<Account> createAccount(OfflinePlayer player, @Nullable World world) {
+        var created = economy.createPlayerAccount(player, world != null ? world.getName() : null);
+        if (created) loadAccount(player, world).thenApply(account -> account.orElseThrow(() ->
+                new IllegalStateException("Could not find player account after creation")));
+        return CompletableFuture.failedFuture(new IllegalStateException(
+                "Similar account already exists"
+        ));
     }
 
     @Override
-    public CompletableFuture<Account> createAccount(OfflinePlayer player, World world) {
-        return CompletableFuture.completedFuture(economy.createPlayerAccount(player, world.getName()))
-                .thenApply(account -> getAccount(player, world).orElseThrow());
+    public CompletableFuture<Account> createAccount(UUID uuid, @Nullable World world) {
+        return createAccount(plugin.getServer().getOfflinePlayer(uuid), world);
     }
 
     @Override
-    public CompletableFuture<Account> createAccount(UUID uuid) {
-        return createAccount(provider.getServer().getOfflinePlayer(uuid));
-    }
-
-    @Override
-    public CompletableFuture<Account> createAccount(UUID uuid, World world) {
-        return createAccount(provider.getServer().getOfflinePlayer(uuid), world);
-    }
-
-    @Override
-    public CompletableFuture<Optional<Account>> loadAccount(OfflinePlayer player) {
-        return CompletableFuture.completedFuture(getAccount(player));
-    }
-
-    @Override
-    public CompletableFuture<Optional<Account>> loadAccount(OfflinePlayer player, World world) {
+    public CompletableFuture<Optional<Account>> loadAccount(OfflinePlayer player, @Nullable World world) {
         return CompletableFuture.completedFuture(getAccount(player, world));
     }
 
     @Override
-    public CompletableFuture<Optional<Account>> loadAccount(UUID uuid) {
-        return loadAccount(provider.getServer().getOfflinePlayer(uuid));
+    public CompletableFuture<Optional<Account>> loadAccount(UUID uuid, @Nullable World world) {
+        return loadAccount(provider.getServer().getOfflinePlayer(uuid), world);
     }
 
     @Override
-    public CompletableFuture<Optional<Account>> loadAccount(UUID uuid, World world) {
-        return loadAccount(provider.getServer().getOfflinePlayer(uuid), world);
+    public CompletableFuture<Boolean> deleteAccount(UUID uuid, @Nullable World world) {
+        return CompletableFuture.completedFuture(false);
     }
 
     @Override
-    public CompletableFuture<Boolean> deleteAccount(UUID uuid) {
+    public CompletableFuture<Boolean> deleteAccounts(List<UUID> accounts, @Nullable World world) {
         return CompletableFuture.completedFuture(false);
     }
 
     @Override
-    public CompletableFuture<Boolean> deleteAccount(UUID uuid, World world) {
-        return CompletableFuture.completedFuture(false);
+    public boolean hasMultiWorldSupport() {
+        return false;
     }
 
     @Override