She's running, but not initiating. WIll finish soon

Author: magiccodingman

Magic.IndexedDb/Factories/MagicDbFactory.cs

@@ -85,17 +85,17 @@ private async ValueTask<IndexedDbManager> GetOrCreateDatabaseAsync(string dbName
         {
             if (_databases.TryGetValue(dbName, out var dbManager))
                 return dbManager; // Return cached instance
-
+/*
             var registeredStores = _serviceProvider.GetServices<DbStore>();
             var dbStore = registeredStores.FirstOrDefault(db => db.Name == dbName)
                 ?? throw new MagicException($"Database {dbName} is not registered.");
-
+*/
             var jsModule = await GetJsModuleAsync(); // Ensure shared JS module is ready
 
             // Create & Open the database (formerly in IndexedDbManager)
             var manager = new IndexedDbManager(jsModule);
-            await new MagicJsInvoke(jsModule).CallJsAsync(Cache.MagicDbJsImportPath,
-                IndexedDbFunctions.CREATE_DATABASES, cancellationToken, new TypedArgument<DbStore>(dbStore));
+            /*await new MagicJsInvoke(jsModule).CallJsAsync(Cache.MagicDbJsImportPath,
+                IndexedDbFunctions.CREATE_DATABASES, cancellationToken, new TypedArgument<DbStore>(dbStore));*/
 
             _databases[dbName] = manager; // Cache the opened database
             return manager;

Magic.IndexedDb/Helpers/MagicValidator.cs

@@ -13,11 +13,7 @@ internal static class MagicValidator
         public static void ValidateTables()
         {
             var errors = new StringBuilder();
-            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
-            var magicTableClasses = assemblies
-                .SelectMany(a => a.GetTypes())
-                .Where(SchemaHelper.HasMagicTableInterface) // Uses the helper method
-                .ToList();
+            var magicTableClasses = SchemaHelper.GetAllMagicTables();
 
 
             foreach (var type in magicTableClasses)
@@ -61,6 +57,29 @@ public static void ValidateTables()
                         errors.AppendLine($"Error: Property '{prop.Name}' in class '{type.Name}' has multiple Magic attributes ({string.Join(", ", appliedMagicAttributes.Select(a => a.Name))}). A property can have at most one Magic attribute.");
                     }
                 }
+
+                var instance = Activator.CreateInstance(type);
+                var getCompoundKeyMethod = type.GetMethod("GetCompoundKey", BindingFlags.Public | BindingFlags.Instance);
+                var getCompoundIndexesMethod = type.GetMethod("GetCompoundIndexes", BindingFlags.Public | BindingFlags.Instance);
+
+                if (getCompoundKeyMethod == null || getCompoundIndexesMethod == null)
+                {
+                    errors.AppendLine($"Error: Class '{type.Name}' is missing required methods 'GetCompoundKey()' or 'GetCompoundIndexes()'.");
+                }
+                else
+                {
+                    try
+                    {
+                        // Call both methods and force any errors to surface
+                        var compoundKey = getCompoundKeyMethod.Invoke(instance, null);
+                        var compoundIndexes = getCompoundIndexesMethod.Invoke(instance, null);
+                    }
+                    catch (TargetInvocationException tie) when (tie.InnerException != null)
+                    {
+                        // Extract and log the **actual** exception instead of the generic wrapper
+                        errors.AppendLine($"Error: Class '{type.Name}' encountered an issue when calling 'GetCompoundKey()' or 'GetCompoundIndexes()'. Exception: {tie.InnerException.Message}");
+                    }
+                }
             }
 
             if (errors.Length > 0)

Magic.IndexedDb/Helpers/SchemaHelper.cs

@@ -15,21 +15,35 @@ public static class SchemaHelper
         //private static readonly ConcurrentDictionary<string, List<StoreSchema>> _databaseSchemasCache = new();
         //private static bool _schemasScanned = false;
         //private static readonly object _lock = new();
-        internal static readonly ConcurrentDictionary<string, Type> _schemaCache = new();
+        internal static readonly ConcurrentDictionary<Type, IMagicTableBase?> _schemaCache = new();
 
         internal static void EnsureSchemaIsCached(Type type)
         {
-            string typeKey = type.FullName!;
-
-            _schemaCache.GetOrAdd(typeKey, _ =>
+            _schemaCache.GetOrAdd(type, _ =>
             {
-                if (!typeof(IMagicTableBase).IsAssignableFrom(type))
-                    throw new InvalidOperationException($"Type {type.Name} does not implement IMagicTableBase.");
-
-                return type; // Cache the type itself
+                // Check if the type implements IMagicTableBase
+                return typeof(IMagicTableBase).IsAssignableFrom(type)
+                    ? (Activator.CreateInstance(type) as IMagicTableBase) // Store the instance if valid
+                    : null; // Store null if it doesn’t implement IMagicTableBase
             });
         }
 
+
+        public static bool ImplementsIMagicTable(Type type)
+        {
+            return type.GetInterfaces().Any(i => i.IsGenericType
+            && i.GetGenericTypeDefinition() == typeof(IMagicTable<>));
+        }
+
+        public static List<Type>? GetAllMagicTables()
+        {
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+            return assemblies
+                .SelectMany(a => a.GetTypes())
+                .Where(t => t.IsClass && !t.IsAbstract && SchemaHelper.ImplementsIMagicTable(t))
+                .ToList();
+        }
+
         private static readonly ConcurrentDictionary<Type, string> _tableNameCache = new();
         private static readonly ConcurrentDictionary<Type, string> _databaseNameCache = new();
 
@@ -143,16 +157,24 @@ public static StoreSchema GetStoreSchema(Type type)
             PropertyMappingCache.EnsureTypeIsCached(type);
             EnsureSchemaIsCached(type);
 
-            if (!_schemaCache.TryGetValue(type.FullName!, out var cachedType))
-                throw new InvalidOperationException($"Type {type.Name} is not cached and does not implement IMagicTableBase.");
+            // Retrieve the cached entry
+            if (!_schemaCache.TryGetValue(type, out var instance))
+            {
+                throw new InvalidOperationException($"Type {type.Name} is not cached.");
+            }
 
-            var instance = Activator.CreateInstance(cachedType) as IMagicTableBase;
+            // Ensure the type actually implements IMagicTableBase
             if (instance == null)
-                throw new InvalidOperationException($"Failed to create an instance of {cachedType.Name}.");
+            {
+                throw new InvalidOperationException($"Type {type.Name} does not implement IMagicTableBase and cannot be used as a Magic Table.");
+            }
 
+            // Retrieve table name
             var tableName = instance.GetTableName();
             if (string.IsNullOrWhiteSpace(tableName))
-                throw new InvalidOperationException($"Type {cachedType.Name} returned an invalid table name.");
+            {
+                throw new InvalidOperationException($"Type {type.Name} returned an invalid table name.");
+            }
 
             var schema = new StoreSchema
             {
@@ -165,7 +187,9 @@ public static StoreSchema GetStoreSchema(Type type)
                 .FirstOrDefault(prop => PropertyMappingCache.GetPropertyEntry(prop, type).PrimaryKey);
 
             if (primaryKeyProperty == null)
+            {
                 throw new InvalidOperationException($"The entity {type.Name} does not have a primary key attribute.");
+            }
 
             schema.PrimaryKey = PropertyMappingCache.GetJsPropertyName(primaryKeyProperty, type);
 
@@ -183,5 +207,6 @@ public static StoreSchema GetStoreSchema(Type type)
 
             return schema;
         }
+
     }
 }

TestWasm/Models/Person.cs

@@ -12,7 +12,7 @@ public class Nested
     }
 
 
-    public class Person : MagicTableTool<Person>, IMagicTable<DbSets>
+    public class Person : MagicTableTool<Person>, IMagicTable<Person.DbSets>
     {
         public List<IMagicCompoundIndex> GetCompoundIndexes() =>
             new List<IMagicCompoundIndex>() {
@@ -21,7 +21,7 @@ public List<IMagicCompoundIndex> GetCompoundIndexes() =>
 
         //public IMagicCompoundIndex? GetCompoundKey() => null;
         public IMagicCompoundKey? GetCompoundKey() => 
-            CreateCompoundKey(x => x._Id, x => x.GUIY);
+            CreateCompoundKey(x => x.Name, x => x.GUIY);
 
         public string GetTableName() => "Person";
         public IndexedDbSet GetDefaultDatabase() => IndexDbContext.Client;