Refactor AddDataStore for improved modularity

This commit refactors the `AddDataStore` method in `ServiceExtensions.cs` by removing inline logic for creating storage contexts and repositories. It introduces private methods for instantiation based on data store type, enhancing code readability and maintainability. The method now registers repositories directly as singletons, simplifying the service registration process.

Author: calin-lupas_dsamcaps

src/DevExcelerateApi/Core/Extensions/ServiceExtensions.cs

@@ -120,62 +120,64 @@ internal static IServiceCollection AddCorsPolicy(this IServiceCollection service
                         policy.WithOrigins(allowedOrigins)
                             .WithMethods("POST", "GET", "PUT", "DELETE", "PATCH")
                             .AllowAnyHeader();
-                    });
+                    });            
             });
-
+            
             return services;
         }
-    
+
         internal static IServiceCollection AddDataStore(this IServiceCollection services)
         {
-            services.AddSingleton(sp=>
-            {
-                IStorageContext<GitHubWebhookEntity> githubWebhookStorageContext;
-                DataStoreOptions dataStoreOptions = sp.GetRequiredService<IOptions<DataStoreOptions>>().Value;
-                switch (dataStoreOptions.Type)
-                {
-                    case DataStoreOptions.DataStoreType.FileSystem:
-
-                        if (dataStoreOptions.FileSystem == null)
-                        {
-                            throw new InvalidOperationException("DataStore:FileSystem is required when DataStore:Type is 'FileSystem'");
-                        }
-
-                        var fullPath = Path.GetFullPath(dataStoreOptions.FileSystem.FilePath);
-                        var directory = Path.GetDirectoryName(fullPath) ?? string.Empty;
-
-                        githubWebhookStorageContext = new FileSystemStorageContext<GitHubWebhookEntity>(
-                            new FileInfo(Path.Combine(directory, $"{Path.GetFileNameWithoutExtension(fullPath)}_GitHubWebhooks{Path.GetExtension(fullPath)}")));
-                        break;
-                    case DataStoreOptions.DataStoreType.CosmosDb:
-
-                        if (dataStoreOptions.CosmosDb == null)
-                        {
-                            throw new InvalidOperationException("DataStore:CosmosDb is required when DataStore:Type is 'CosmosDb'");
-                        }
-
-                        githubWebhookStorageContext = new CosmosDbStorageContext<GitHubWebhookEntity>(
-                            dataStoreOptions.CosmosDb.ConnectionString,
-                            dataStoreOptions.CosmosDb.Database,
-                            dataStoreOptions.CosmosDb.GitHubWebhooksContainer);
-                        break;
-                    case DataStoreOptions.DataStoreType.SqlServer:
-                        if (dataStoreOptions.SqlDb == null)
-                        {
-                            throw new InvalidOperationException("DataStore:SqlDb is required when DataStore:Type is 'SqlServer'");
-                        }
-                        githubWebhookStorageContext = new SqlDbStorageContext<GitHubWebhookEntity>(dataStoreOptions.SqlDb!);
-                        break;
-                    default:
-                    {
-                        throw new InvalidOperationException("Invalid 'DataStore' setting 'dataStoreOptions.Type'.");
-                    }
-                }
+            // Register storage contexts as singletons first
+            services.AddSingleton(CreateStorageContext<GitHubWebhookEntity>);
+            services.AddSingleton(CreateStorageContext<IssueRequestEntity>);
 
-                return new GitHubWebhookRepository(githubWebhookStorageContext);
-            });
+            // Register repositories
+            services.AddSingleton<GitHubWebhookRepository>();
+            services.AddSingleton<IssueRequestRepository>();
 
             return services;
         }
+
+        private static IStorageContext<T> CreateStorageContext<T>(IServiceProvider sp) where T : IStorageEntity
+        {
+            var dataStoreOptions = sp.GetRequiredService<IOptions<DataStoreOptions>>().Value;
+            
+            return dataStoreOptions.Type switch
+            {
+                DataStoreOptions.DataStoreType.FileSystem => CreateFileSystemStorageContext<T>(dataStoreOptions.FileSystem),
+                DataStoreOptions.DataStoreType.CosmosDb => CreateCosmosDbStorageContext<T>(dataStoreOptions.CosmosDb),
+                DataStoreOptions.DataStoreType.SqlServer => CreateSqlServerStorageContext<T>(dataStoreOptions.SqlDb),
+                _ => throw new InvalidOperationException($"Invalid 'DataStore' setting '{dataStoreOptions.Type}'.")
+            };
+        }
+
+        private static FileSystemStorageContext<T> CreateFileSystemStorageContext<T>(FileSystemOptions? options) where T : IStorageEntity
+        {
+            if (options == null)
+                throw new InvalidOperationException("DataStore:FileSystem is required when DataStore:Type is 'FileSystem'");
+
+            var fullPath = Path.GetFullPath(options.FilePath);
+            var directory = Path.GetDirectoryName(fullPath) ?? string.Empty;
+            var fileName = $"{Path.GetFileNameWithoutExtension(fullPath)}_{typeof(T).Name}{Path.GetExtension(fullPath)}";
+            
+            return new FileSystemStorageContext<T>(new FileInfo(Path.Combine(directory, fileName)));
+        }
+
+        private static CosmosDbStorageContext<T> CreateCosmosDbStorageContext<T>(CosmosDbOptions? options) where T : IStorageEntity
+        {
+            if (options == null)
+                throw new InvalidOperationException("DataStore:CosmosDb is required when DataStore:Type is 'CosmosDb'");
+
+            return new CosmosDbStorageContext<T>(options.ConnectionString, options.Database);
+        }
+
+        private static SqlDbStorageContext<T> CreateSqlServerStorageContext<T>(SqlDbOptions? options) where T : IStorageEntity
+        {
+            if (options == null)
+                throw new InvalidOperationException("DataStore:SqlDb is required when DataStore:Type is 'SqlServer'");
+
+            return new SqlDbStorageContext<T>(options);
+        }
     }
 }