feat: add enum support

core/src/main/java/net/staticstudios/data/DataManager.java

@@ -1423,22 +1423,42 @@ public void registerValueSerializer(ValueSerializer<?, ?> serializer) {
                 return s;
             }
         }
-
-        throw new IllegalStateException("No ValueSerializer registered for type " + deserializedType.getName());
+        return null;
     }
 
     public <T> T deserialize(Class<T> clazz, Object serialized) {
         if (serialized == null || Primitives.isPrimitive(clazz)) {
             return (T) serialized;
         }
-        return (T) deserialize(getValueSerializer(clazz), serialized);
+
+        ValueSerializer<?, ?> valueSerializer = getValueSerializer(clazz);
+        if (valueSerializer != null) {
+            return (T) deserialize(valueSerializer, serialized);
+        }
+
+        if (clazz.isEnum()) {
+            return (T) Enum.valueOf((Class<Enum>) clazz, serialized.toString());
+        }
+
+        throw new IllegalStateException("No suitable deserializer found for type " + clazz.getName());
     }
 
     public <T> T serialize(Object deserialized) {
         if (deserialized == null || Primitives.isPrimitive(deserialized.getClass())) {
             return (T) deserialized;
         }
-        return (T) serialize(getValueSerializer(deserialized.getClass()), deserialized);
+
+        ValueSerializer<?, ?> valueSerializer = getValueSerializer(deserialized.getClass());
+        if (valueSerializer != null) {
+            return (T) serialize(valueSerializer, deserialized);
+        }
+
+        if (deserialized instanceof Enum) {
+            return (T) ((Enum<?>) deserialized).name();
+        }
+
+        throw new IllegalStateException("No suitable deserializer found for type " + deserialized.getClass().getName());
+
     }
 
     private <D, S> D deserialize(ValueSerializer<D, S> serializer, Object serialized) {
@@ -1453,8 +1473,17 @@ public Class<?> getSerializedType(Class<?> clazz) {
         if (Primitives.isPrimitive(clazz)) {
             return clazz;
         }
+
         ValueSerializer<?, ?> serializer = getValueSerializer(clazz);
-        return serializer.getSerializedType();
+        if (serializer != null) {
+            return serializer.getSerializedType();
+        }
+
+        if (clazz.isEnum()) {
+            return String.class;
+        }
+
+        throw new IllegalStateException("No suitable serializer found for type " + clazz.getName());
     }
 
     public <T> T copy(T value, Class<T> dataType) {

core/src/test/java/net/staticstudios/data/EnumTest.java

@@ -0,0 +1,28 @@
+package net.staticstudios.data;
+
+import net.staticstudios.data.misc.DataTest;
+import net.staticstudios.data.mock.account.AccountStatus;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+public class EnumTest extends DataTest {
+
+    @Test
+    public void testEnums() {
+        DataManager dataManager = getMockEnvironments().getFirst().dataManager();
+        dataManager.load(AccountStatus.class);
+        dataManager.finishLoading();
+
+        AccountStatus status = AccountStatus.builder(dataManager)
+                .id(1)
+                .insert(InsertMode.SYNC);
+
+        assertSame(AccountStatus.Status.ACTIVE, status.getStatus());
+
+        status.setStatus(AccountStatus.Status.INACTIVE);
+
+        assertSame(AccountStatus.Status.INACTIVE, status.getStatus());
+
+    }
+}

core/src/test/java/net/staticstudios/data/mock/account/AccountStatus.java

@@ -0,0 +1,26 @@
+package net.staticstudios.data.mock.account;
+
+import net.staticstudios.data.*;
+
+@Data( schema = "public", table = "test_account_status")
+public class AccountStatus extends UniqueData {
+
+    @IdColumn(name = "id")
+    public PersistentValue<Integer> id;
+    @Column(name = "status")
+
+    @DefaultValue("ACTIVE")
+    public PersistentValue<Status> status;
+
+    public Status getStatus() {
+        return status.get();
+    }
+
+    public void setStatus(Status status) {
+        this.status.set(status);
+    }
+
+    public enum Status {
+        ACTIVE, INACTIVE
+    }
+}