Improved serialization

Author: crossivejoker

Magic.IndexedDb/IndexDbManager.cs

@@ -374,7 +374,6 @@ public MagicQuery<T> Where<T>(Expression<Func<T, bool>> predicate) where T : cla
 
             // Preprocess the predicate to break down Any and All expressions
             var preprocessedPredicate = PreprocessPredicate(predicate);
-            var asdf = preprocessedPredicate.ToString();
             CollectBinaryExpressions(preprocessedPredicate.Body, preprocessedPredicate, query.JsonQueries);
 
             return query;

Magic.IndexedDb/Models/MagicContractResolver.cs

@@ -3,6 +3,7 @@
 using System.Reflection;
 using System.Text.Json.Serialization;
 using System.Text.Json;
+using System.Collections;
 
 namespace Magic.IndexedDb.Models
 {
@@ -12,35 +13,99 @@ internal class MagicContractResolver<T> : JsonConverter<T>
 
         public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            // Defer deserialization back to built-in handling to ensure correctness
             return JsonSerializer.Deserialize<T>(ref reader, options);
         }
 
         public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
         {
-            if (value == null) return;
-
-            writer.WriteStartObject();
+            if (value == null)
+            {
+                writer.WriteNullValue();
+                return;
+            }
 
-            foreach (var property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance))
+            try
             {
-                // Check cache first
-                if (!_cachedIgnoredProperties.TryGetValue(property, out bool shouldIgnore))
+                // Handle simple or primitive types directly
+                if (IsSimpleType(typeof(T)))
                 {
-                    shouldIgnore = property.GetCustomAttributes(inherit: true)
-                                           .Any(a => a.GetType().FullName == typeof(MagicNotMappedAttribute).FullName);
-                    _cachedIgnoredProperties[property] = shouldIgnore;
+                    JsonSerializer.Serialize(writer, value, options);
+                    return;
                 }
 
-                if (!shouldIgnore)
+                // Handle collections
+                if (value is IEnumerable enumerable && typeof(T) != typeof(string))
                 {
-                    var propValue = property.GetValue(value);
+                    writer.WriteStartArray();
+                    foreach (var item in enumerable)
+                    {
+                        if (item == null)
+                            writer.WriteNullValue();
+                        else
+                            JsonSerializer.Serialize(writer, item, item.GetType(), options);
+                    }
+                    writer.WriteEndArray();
+                    return;
+                }
+
+                // Handle complex objects
+                writer.WriteStartObject();
+                foreach (var property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance))
+                {
+                    if (ShouldIgnoreProperty(property))
+                        continue;
+
                     var propName = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
+
+                    if (property.GetIndexParameters().Length > 0)
+                        continue; // Skip indexers entirely
+
+                    object? propValue;
+                    try
+                    {
+                        propValue = property.GetValue(value);
+                    }
+                    catch
+                    {
+                        // Fallback: write null if getting property fails
+                        propValue = null;
+                    }
+
                     writer.WritePropertyName(propName);
-                    JsonSerializer.Serialize(writer, propValue, property.PropertyType, options);
+                    if (propValue == null)
+                        writer.WriteNullValue();
+                    else
+                        JsonSerializer.Serialize(writer, propValue, propValue.GetType(), options);
                 }
+                writer.WriteEndObject();
+            }
+            catch
+            {
+                // Fallback to system serializer on complete failure
+                JsonSerializer.Serialize(writer, value, value.GetType(), options);
             }
+        }
 
-            writer.WriteEndObject();
+        private static bool ShouldIgnoreProperty(PropertyInfo property)
+        {
+            return _cachedIgnoredProperties.GetOrAdd(property, prop =>
+                prop.GetCustomAttributes(inherit: true)
+                    .Any(a => a.GetType().FullName == typeof(MagicNotMappedAttribute).FullName));
+        }
+
+        private static bool IsSimpleType(Type type)
+        {
+            return type.IsPrimitive ||
+                   type.IsEnum ||
+                   type == typeof(string) ||
+                   type == typeof(decimal) ||
+                   type == typeof(DateTime) ||
+                   type == typeof(DateTimeOffset) ||
+                   type == typeof(Guid) ||
+                   type == typeof(Uri) ||
+                   type == typeof(TimeSpan);
         }
     }
+
 }