Add full typed MongoDB repository support to StorageAPI

pom.xml

@@ -154,6 +154,25 @@
                 </exclusion>
             </exclusions>
         </dependency>
+
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+            <version>2.17.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>2.17.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.17.1</version>
+        </dependency>
+
     </dependencies>
 
 </project>

src/main/java/xyz/refinedev/api/storage/mongo/model/Model.java

@@ -0,0 +1,9 @@
+package xyz.refinedev.api.storage.mongo.model;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public interface Model {
+
+  @JsonProperty("_id")
+  String getId();
+}

src/main/java/xyz/refinedev/api/storage/mongo/repository/MongoObjectRepository.java

@@ -0,0 +1,40 @@
+package xyz.refinedev.api.storage.mongo.repository;
+
+import com.google.common.collect.Lists;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.ReplaceOptions;
+import lombok.RequiredArgsConstructor;
+import xyz.refinedev.api.storage.mongo.model.Model;
+
+import java.util.List;
+
+@RequiredArgsConstructor
+public class MongoObjectRepository<O extends Model> implements ObjectRepository<O> {
+
+  private final MongoCollection<O> collection;
+
+  @Override
+  public O find(String id) {
+    return collection.find(Filters.eq("_id", id)).first();
+  }
+
+  @Override
+  public void remove(String id) {
+    collection.deleteOne(Filters.eq("_id", id));
+  }
+
+  @Override
+  public void save(O model) {
+    collection.replaceOne(
+        Filters.eq("_id", model.getId()),
+        model,
+        new ReplaceOptions().upsert(true)
+    );
+  }
+
+  @Override
+  public List<O> findAll() {
+    return collection.find().into(Lists.newArrayList());
+  }
+}

src/main/java/xyz/refinedev/api/storage/mongo/repository/ObjectRepository.java

@@ -0,0 +1,12 @@
+package xyz.refinedev.api.storage.mongo.repository;
+
+import xyz.refinedev.api.storage.mongo.model.Model;
+
+import java.util.List;
+
+public interface ObjectRepository<O extends Model> {
+  O find(String id);
+  void remove(String id);
+  void save(O model);
+  List<O> findAll();
+}

src/main/java/xyz/refinedev/api/storage/mongo/storage/MongoStorage.java

@@ -0,0 +1,124 @@
+package xyz.refinedev.api.storage.mongo.storage;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.ReplaceOptions;
+
+import com.mongodb.client.model.Updates;
+import lombok.RequiredArgsConstructor;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import xyz.refinedev.api.storage.mongo.model.Model;
+import xyz.refinedev.api.storage.mongo.repository.MongoObjectRepository;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * This Project is property of Refine Development © 2021 - 2022
+ * Redistribution of this Project is not allowed
+ *
+ * @author Drizzy
+ * Created: 7/27/2022
+ * Project: StorageAPI
+ *
+ * Legacy implementation using {@link Document} + Gson.
+ *
+ * @deprecated Use {@link MongoStorageManager} with typed repositories instead.
+ */
+
+@Deprecated
+@SuppressWarnings("unused")
+@RequiredArgsConstructor
+public class MongoStorage<V> {
+
+  private static final ReplaceOptions REPLACE_OPTIONS = new ReplaceOptions().upsert(true);
+
+  private final MongoCollection<Document> collection;
+  private final Gson gson;
+  private final Type typeToken = new TypeToken<V>() {}.getType();
+
+  public <T extends Model> MongoObjectRepository<T> asRepository(MongoCollection<T> typedCollection) {
+    return new MongoObjectRepository<>(typedCollection);
+  }
+
+  public CompletableFuture<List<V>> fetchAllEntries() {
+    return CompletableFuture.supplyAsync(() -> {
+      List<V> found = new ArrayList<>();
+      for (Document document : this.collection.find()) {
+        if (document == null) continue;
+        found.add(this.gson.fromJson(document.toJson(), typeToken));
+      }
+      return found;
+    });
+  }
+
+  public CompletableFuture<List<Document>> fetchAllRawEntries() {
+    return CompletableFuture.supplyAsync(() -> {
+      List<Document> found = new ArrayList<>();
+      for (Document document : this.collection.find()) {
+        found.add(document);
+      }
+      return found;
+    });
+  }
+
+  public void saveData(UUID key, V value, Type type) {
+    CompletableFuture.runAsync(() -> this.saveDataSync(key, value, type));
+  }
+
+  public void saveDataSync(UUID key, V value, Type type) {
+    Bson query = Filters.eq("_id", key.toString());
+    Document parsed = Document.parse(gson.toJson(value, type));
+    this.collection.replaceOne(query, parsed, REPLACE_OPTIONS);
+  }
+
+  public void saveRawData(UUID key, Document document) {
+    CompletableFuture.runAsync(() -> this.saveRawDataSync(key, document));
+  }
+
+  public void saveRawDataSync(UUID key, Document document) {
+    Bson query = Filters.eq("_id", key.toString());
+    this.collection.replaceOne(query, document, REPLACE_OPTIONS);
+  }
+
+  public V loadData(UUID key, Type type) {
+    Bson query = Filters.eq("_id", key.toString());
+    Document document = this.collection.find(query).first();
+    if (document == null) return null;
+    return this.gson.fromJson(document.toJson(), type);
+  }
+
+  public CompletableFuture<V> loadDataAsync(UUID key, Type type) {
+    return CompletableFuture.supplyAsync(() -> this.loadData(key, type));
+  }
+
+  public Document loadRawData(UUID key) {
+    Bson query = Filters.eq("_id", key.toString());
+    return this.collection.find(query).first();
+  }
+
+  public CompletableFuture<Document> loadRawDataAsync(UUID key) {
+    return CompletableFuture.supplyAsync(() -> this.loadRawData(key));
+  }
+
+  public void deleteData(UUID key) {
+    CompletableFuture.runAsync(() -> {
+      Bson query = Filters.eq("_id", key.toString());
+      this.collection.deleteOne(query);
+    });
+  }
+
+  public CompletableFuture<Long> deleteKeyInAll(String key) {
+    return CompletableFuture.supplyAsync(() -> {
+      Bson combinedUpdate = Updates.unset(key);
+      return collection.updateMany(new Document(), combinedUpdate).getModifiedCount();
+    });
+  }
+}

src/main/java/xyz/refinedev/api/storage/mongo/storage/MongoStorageManager.java

@@ -0,0 +1,49 @@
+package xyz.refinedev.api.storage.mongo.storage;
+
+import com.mongodb.ConnectionString;
+import com.mongodb.MongoClientSettings;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import lombok.Getter;
+import xyz.refinedev.api.storage.mongo.model.Model;
+import xyz.refinedev.api.storage.mongo.repository.MongoObjectRepository;
+import xyz.refinedev.api.storage.mongo.repository.ObjectRepository;
+import org.bson.codecs.configuration.CodecRegistry;
+import org.bson.codecs.pojo.PojoCodecProvider;
+
+import static org.bson.codecs.configuration.CodecRegistries.*;
+
+@Getter
+public class MongoStorageManager {
+
+  private final MongoClient client;
+  private final MongoDatabase database;
+
+  public MongoStorageManager(String connectionUri, String dbName) {
+    ConnectionString connString = new ConnectionString(connectionUri);
+
+    CodecRegistry pojoCodecRegistry = fromRegistries(
+        MongoClientSettings.getDefaultCodecRegistry(),
+        fromProviders(PojoCodecProvider.builder().automatic(true).build())
+    );
+
+    MongoClientSettings settings = MongoClientSettings.builder()
+        .applyConnectionString(connString)
+        .codecRegistry(pojoCodecRegistry)
+        .build();
+
+    this.client = MongoClients.create(settings);
+    this.database = client.getDatabase(dbName);
+  }
+
+  public <T extends Model> ObjectRepository<T> getRepository(Class<T> clazz, String collectionName) {
+    MongoCollection<T> collection = database.getCollection(collectionName, clazz);
+    return new MongoObjectRepository<>(collection);
+  }
+
+  public void close() {
+    client.close();
+  }
+}