more updates

Author: magiccodingman

Magic.IndexedDb/Helpers/ExpandoToTypeConverter.cs

@@ -40,50 +40,6 @@ private static void PrecomputePropertySetters(Type type)
                 PropertySetters[prop.Name] = propertySetterExp.Compile();
             }
         }
-
-        public static T ConvertExpando(ExpandoObject expando)
-        {
-            Type type = typeof(T);
-
-            if (IsConcrete && HasParameterlessConstructor)
-            {
-                // Use the fastest method: Precomputed property setters
-                var instance = Activator.CreateInstance<T>();
-                var expandoDict = (IDictionary<string, object?>)expando;
-
-                foreach (var kvp in expandoDict)
-                {
-                    if (PropertySetters.TryGetValue(kvp.Key, out var setter))
-                    {
-                        setter(instance, kvp.Value);
-                    }
-                }
-
-                return instance;
-            }
-            else if (IsConcrete) // Concrete class without a parameterless constructor
-            {
-                var instance = Activator.CreateInstance(type);
-                MagicSerializationHelper.PopulateObject(MagicSerializationHelper.SerializeObject(expando), instance);
-                return (T)instance!;
-            }
-            else
-            {
-                // Last resort: If `T` is an interface or abstract class, fall back to full JSON deserialization
-                var instance = MagicSerializationHelper.DeserializeObject<T>(MagicSerializationHelper.SerializeObject(expando))!;
-
-                // Check if we can cache this as a known type
-                if (!NonConcreteTypeCache.ContainsKey(type))
-                {
-                    NonConcreteTypeCache[type] = true;
-
-                    // Dynamically compute property setters for this type
-                    PrecomputePropertySetters(type);
-                }
-
-                return instance;
-            }
-        }
     }
 
 

Magic.IndexedDb/Helpers/PropertyMappingCache.cs

@@ -2,6 +2,7 @@
 using Magic.IndexedDb.Models;
 using Magic.IndexedDb.SchemaAnnotations;
 using System;
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,6 +16,104 @@ public static class PropertyMappingCache
     {
         internal static readonly ConcurrentDictionary<string, Dictionary<string, MagicPropertyEntry>> _propertyCache = new();
 
+
+        public static Dictionary<string, MagicPropertyEntry> GetTypeOfTProperties(Type type)
+        {
+            EnsureTypeIsCached(type);
+            if (_propertyCache.TryGetValue(type.FullName!, out var properties))
+            {
+                return properties;
+            }
+            throw new Exception("Something went very wrong getting GetTypeOfTProperties");
+        }
+
+        public 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);
+        }
+
+
+        public static IEnumerable<Type> GetAllNestedComplexTypes(IEnumerable<PropertyInfo> properties)
+        {
+            HashSet<Type> complexTypes = new();
+            Stack<Type> typeStack = new();
+
+            // Initial population of the stack
+            foreach (var property in properties)
+            {
+                if (IsComplexType(property.PropertyType))
+                {
+                    typeStack.Push(property.PropertyType);
+                    complexTypes.Add(property.PropertyType);
+                }
+            }
+
+            // Process all nested complex types
+            while (typeStack.Count > 0)
+            {
+                var currentType = typeStack.Pop();
+                var nestedProperties = currentType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+                foreach (var nestedProperty in nestedProperties)
+                {
+                    if (IsComplexType(nestedProperty.PropertyType) && !complexTypes.Contains(nestedProperty.PropertyType))
+                    {
+                        complexTypes.Add(nestedProperty.PropertyType);
+                        typeStack.Push(nestedProperty.PropertyType);
+                    }
+                }
+            }
+
+            return complexTypes;
+        }
+
+        /*public static bool IsComplexType(Type type)
+        {
+            return !(IsSimpleType(type)
+                  || type == typeof(string)
+                  || typeof(IEnumerable).IsAssignableFrom(type) // Non-generic IEnumerable
+                  || (type.IsGenericType && typeof(IEnumerable<>).IsAssignableFrom(type.GetGenericTypeDefinition())) // Generic IEnumerable<T>
+                  || type.IsArray); // Arrays are collections too
+        }*/
+
+        public static bool IsComplexType(Type type)
+        {
+            if (IsSimpleType(type) || type == typeof(string))
+                return false;
+
+            // Handle generic collections like List<T>, Dictionary<TKey, TValue>
+            if (type.IsGenericType)
+            {
+                Type genericTypeDef = type.GetGenericTypeDefinition();
+
+                // If it's a generic IEnumerable<T>, get the type argument and check if it's complex
+                if (typeof(IEnumerable<>).IsAssignableFrom(genericTypeDef))
+                {
+                    Type itemType = type.GetGenericArguments()[0];
+                    return IsComplexType(itemType);
+                }
+
+                // Otherwise, it might be a generic class like StoreRecord<T>
+                return type.GetGenericArguments().Any(IsComplexType);
+            }
+
+            // Handle non-generic collections like arrays
+            if (typeof(IEnumerable).IsAssignableFrom(type) || type.IsArray)
+                return false;
+
+            return true; // Consider anything else a complex object
+        }
+
+
+
         /// <summary>
         /// Gets the C# property name given a JavaScript property name.
         /// </summary>
@@ -160,8 +259,12 @@ internal static void EnsureTypeIsCached(Type type)
             // Initialize the dictionary for this type
             var propertyEntries = new Dictionary<string, MagicPropertyEntry>();
 
+            List<MagicPropertyEntry> newMagicPropertyEntry = new List<MagicPropertyEntry>();
             foreach (var property in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy))
             {
+                if (property.GetIndexParameters().Length > 0)
+                    continue; // 🔥 Skip indexers entirely
+
                 string propertyKey = property.Name; // Now stored as string, not PropertyInfo
 
                 var columnAttribute = property.GetCustomAttributes()
@@ -180,12 +283,21 @@ internal static void EnsureTypeIsCached(Type type)
                     property.IsDefined(typeof(MagicPrimaryKeyAttribute), inherit: true),
                     property.IsDefined(typeof(MagicNotMappedAttribute), inherit: true)
                 );
-
+                newMagicPropertyEntry.Add(magicEntry);
                 propertyEntries[propertyKey] = magicEntry; // Store property entry with string key
             }
 
             // Cache the properties for this type
             _propertyCache[typeKey] = propertyEntries;
+
+            var complexTypes = GetAllNestedComplexTypes(newMagicPropertyEntry.Select(x => x.Property));
+            if (complexTypes != null && complexTypes.Any())
+            {
+                foreach (var comp in complexTypes)
+                {
+                    EnsureTypeIsCached(comp);
+                }
+            }
         }
     }
 }

Magic.IndexedDb/IndexDbManager.cs

@@ -10,6 +10,7 @@
 using System.Text.Json.Nodes;
 using Magic.IndexedDb.Interfaces;
 using static System.Runtime.InteropServices.JavaScript.JSType;
+using Microsoft.Extensions.Options;
 
 namespace Magic.IndexedDb
 {
@@ -565,9 +566,19 @@ internal async Task CallJsAsync(string functionName, CancellationToken token, pa
 
         internal async Task<T> CallJsAsync<T>(string functionName, CancellationToken token, params ITypedArgument[] args)
         {
+
+            var ss = typeof(T);
+
             var settings = new MagicJsonSerializationSettings() { UseCamelCase = true };
             object[] serializedArgs = MagicSerializationHelper.SerializeObjects(args, settings);
-            return await this._jsModule.InvokeAsync<T>(functionName, token, serializedArgs);
+            // Invoke JavaScript function and retrieve result as a JsonElement to avoid type mismatches
+            var resultJsonElement = await _jsModule.InvokeAsync<JsonElement>(functionName, token, serializedArgs);
+
+            // Convert JsonElement to a JSON string for custom deserialization
+            string resultJson = resultJsonElement.GetRawText();
+
+            var result = MagicSerializationHelper.DeserializeObject<T>(resultJson, settings);
+            return result;
         }
     }
 }