refactor MSGraphDbUtils to use with DI

bartizan · bartizan · commit 2f9d7eea1797 · 2025-07-30T12:52:49.000+03:00
diff --git a/DevProxy.Abstractions/Utils/MSGraphDbUtils.cs b/DevProxy.Abstractions/Utils/MSGraphDbUtils.cs
@@ -9,17 +9,18 @@
 
 namespace DevProxy.Abstractions.Utils;
 
-public static class MSGraphDbUtils
+public sealed class MSGraphDbUtils(HttpClient httpClient, ILogger<MSGraphDbUtils> logger) : IDisposable
 {
-    private static readonly Dictionary<string, OpenApiDocument> _openApiDocuments = [];
     private static readonly string[] graphVersions = ["v1.0", "beta"];
-
-    private static SqliteConnection? _msGraphDbConnection;
+    private readonly Dictionary<string, OpenApiDocument> _openApiDocuments = [];
+    private readonly HttpClient _httpClient = httpClient;
+    private readonly ILogger<MSGraphDbUtils> _logger = logger;
+    private SqliteConnection? _msGraphDbConnection;
 
     // v1 refers to v1 of the db schema, not the graph version
     public static string MSGraphDbFilePath => Path.Combine(ProxyUtils.AppFolder!, "msgraph-openapi-v1.db");
 
-    public static SqliteConnection MSGraphDbConnection
+    public SqliteConnection MSGraphDbConnection
     {
         get
         {
@@ -33,12 +34,12 @@ public static SqliteConnection MSGraphDbConnection
         }
     }
 
-    public static async Task<int> GenerateMSGraphDbAsync(ILogger logger, bool skipIfUpdatedToday, CancellationToken cancellationToken)
+    public async Task<int> GenerateMSGraphDbAsync(bool skipIfUpdatedToday, CancellationToken cancellationToken)
     {
         var appFolder = ProxyUtils.AppFolder;
         if (string.IsNullOrEmpty(appFolder))
         {
-            logger.LogError("App folder {AppFolder} not found", appFolder);
+            _logger.LogError("App folder {AppFolder} not found", appFolder);
             return 1;
         }
 
@@ -48,61 +49,64 @@ public static async Task<int> GenerateMSGraphDbAsync(ILogger logger, bool skipIf
             var modifiedToday = dbFileInfo.Exists && dbFileInfo.LastWriteTime.Date == DateTime.Now.Date;
             if (modifiedToday && skipIfUpdatedToday)
             {
-                logger.LogInformation("Microsoft Graph database already updated today");
+                _logger.LogInformation("Microsoft Graph database already updated today");
                 return 1;
             }
 
-            await UpdateOpenAPIGraphFilesIfNecessaryAsync(appFolder, logger, cancellationToken);
-            await LoadOpenAPIFilesAsync(appFolder, logger, cancellationToken);
+            await UpdateOpenAPIGraphFilesIfNecessaryAsync(appFolder, cancellationToken);
+            await LoadOpenAPIFilesAsync(appFolder, cancellationToken);
             if (_openApiDocuments.Count < 1)
             {
-                logger.LogDebug("No OpenAPI files found or couldn't load them");
+                _logger.LogDebug("No OpenAPI files found or couldn't load them");
                 return 1;
             }
 
-            var dbConnection = MSGraphDbConnection;
-            await CreateDbAsync(dbConnection, logger, cancellationToken);
-            await FillDataAsync(dbConnection, logger, cancellationToken);
+            await CreateDbAsync(cancellationToken);
+            await FillDataAsync(cancellationToken);
 
-            logger.LogInformation("Microsoft Graph database successfully updated");
+            _logger.LogInformation("Microsoft Graph database successfully updated");
 
             return 0;
         }
         catch (Exception ex)
         {
-            logger.LogError(ex, "Error generating Microsoft Graph database");
+            _logger.LogError(ex, "Error generating Microsoft Graph database");
             return 1;
         }
 
     }
 
     private static string GetGraphOpenApiYamlFileName(string version) => $"graph-{version.Replace(".", "_", StringComparison.OrdinalIgnoreCase)}-openapi.yaml";
 
-    private static async Task CreateDbAsync(SqliteConnection dbConnection, ILogger logger, CancellationToken cancellationToken)
+    private async Task CreateDbAsync(CancellationToken cancellationToken)
     {
-        logger.LogInformation("Creating database...");
+        _logger.LogInformation("Creating database...");
+
+        var dbConnection = MSGraphDbConnection;
 
-        logger.LogDebug("Dropping endpoints table...");
+        _logger.LogDebug("Dropping endpoints table...");
         var dropTable = dbConnection.CreateCommand();
         dropTable.CommandText = "DROP TABLE IF EXISTS endpoints";
         _ = await dropTable.ExecuteNonQueryAsync(cancellationToken);
 
-        logger.LogDebug("Creating endpoints table...");
+        _logger.LogDebug("Creating endpoints table...");
         var createTable = dbConnection.CreateCommand();
         // when you change the schema, increase the db version number in ProxyUtils
         createTable.CommandText = "CREATE TABLE IF NOT EXISTS endpoints (path TEXT, graphVersion TEXT, hasSelect BOOLEAN)";
         _ = await createTable.ExecuteNonQueryAsync(cancellationToken);
 
-        logger.LogDebug("Creating index on endpoints and version...");
+        _logger.LogDebug("Creating index on endpoints and version...");
         // Add an index on the path and graphVersion columns
         var createIndex = dbConnection.CreateCommand();
         createIndex.CommandText = "CREATE INDEX IF NOT EXISTS idx_endpoints_path_version ON endpoints (path, graphVersion)";
         _ = await createIndex.ExecuteNonQueryAsync(cancellationToken);
     }
 
-    private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger logger, CancellationToken cancellationToken)
+    private async Task FillDataAsync(CancellationToken cancellationToken)
     {
-        logger.LogInformation("Filling database...");
+        _logger.LogInformation("Filling database...");
+
+        var dbConnection = MSGraphDbConnection;
 
         var i = 0;
 
@@ -113,7 +117,7 @@ private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger l
             var graphVersion = openApiDocument.Key;
             var document = openApiDocument.Value;
 
-            logger.LogDebug("Filling database for {GraphVersion}...", graphVersion);
+            _logger.LogDebug("Filling database for {GraphVersion}...", graphVersion);
 
             var insertEndpoint = dbConnection.CreateCommand();
             insertEndpoint.CommandText = "INSERT INTO endpoints (path, graphVersion, hasSelect) VALUES (@path, @graphVersion, @hasSelect)";
@@ -125,20 +129,20 @@ private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger l
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
-                logger.LogTrace("Endpoint {GraphVersion}{Key}...", graphVersion, path.Key);
+                _logger.LogTrace("Endpoint {GraphVersion}{Key}...", graphVersion, path.Key);
 
                 // Get the GET operation for this path
                 var getOperation = path.Value.Operations.FirstOrDefault(o => o.Key == OperationType.Get).Value;
                 if (getOperation == null)
                 {
-                    logger.LogTrace("No GET operation found for {GraphVersion}{Key}", graphVersion, path.Key);
+                    _logger.LogTrace("No GET operation found for {GraphVersion}{Key}", graphVersion, path.Key);
                     continue;
                 }
 
                 // Check if the GET operation has a $select parameter
                 var hasSelect = getOperation.Parameters.Any(p => p.Name == "$select");
 
-                logger.LogTrace("Inserting endpoint {GraphVersion}{Key} with hasSelect={HasSelect}...", graphVersion, path.Key, hasSelect);
+                _logger.LogTrace("Inserting endpoint {GraphVersion}{Key} with hasSelect={HasSelect}...", graphVersion, path.Key, hasSelect);
                 insertEndpoint.Parameters["@path"].Value = path.Key;
                 insertEndpoint.Parameters["@graphVersion"].Value = graphVersion;
                 insertEndpoint.Parameters["@hasSelect"].Value = hasSelect;
@@ -147,54 +151,53 @@ private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger l
             }
         }
 
-        logger.LogInformation("Inserted {EndpointCount} endpoints in the database", i);
+        _logger.LogInformation("Inserted {EndpointCount} endpoints in the database", i);
     }
 
-    private static async Task UpdateOpenAPIGraphFilesIfNecessaryAsync(string folder, ILogger logger, CancellationToken cancellationToken)
+    private async Task UpdateOpenAPIGraphFilesIfNecessaryAsync(string folder, CancellationToken cancellationToken)
     {
-        logger.LogInformation("Checking for updated OpenAPI files...");
+        _logger.LogInformation("Checking for updated OpenAPI files...");
 
         foreach (var version in graphVersions)
         {
             try
             {
                 var file = new FileInfo(Path.Combine(folder, GetGraphOpenApiYamlFileName(version)));
-                logger.LogDebug("Checking for updated OpenAPI file {File}...", file);
+                _logger.LogDebug("Checking for updated OpenAPI file {File}...", file);
                 if (file.Exists && file.LastWriteTime.Date == DateTime.Now.Date)
                 {
-                    logger.LogInformation("File {File} already updated today", file);
+                    _logger.LogInformation("File {File} already updated today", file);
                     continue;
                 }
 
                 var url = $"https://raw.githubusercontent.com/microsoftgraph/msgraph-metadata/master/openapi/{version}/openapi.yaml";
-                logger.LogInformation("Downloading OpenAPI file from {Url}...", url);
+                _logger.LogInformation("Downloading OpenAPI file from {Url}...", url);
 
-                using var client = new HttpClient();
-                var response = await client.GetStringAsync(url, cancellationToken);
+                var response = await _httpClient.GetStringAsync(url, cancellationToken);
                 await File.WriteAllTextAsync(file.FullName, response, cancellationToken);
 
-                logger.LogDebug("Downloaded OpenAPI file from {Url} to {File}", url, file);
+                _logger.LogDebug("Downloaded OpenAPI file from {Url} to {File}", url, file);
             }
             catch (Exception ex)
             {
-                logger.LogError(ex, "Error updating OpenAPI files");
+                _logger.LogError(ex, "Error updating OpenAPI files");
             }
         }
     }
 
-    private static async Task LoadOpenAPIFilesAsync(string folder, ILogger logger, CancellationToken cancellationToken)
+    private async Task LoadOpenAPIFilesAsync(string folder, CancellationToken cancellationToken)
     {
-        logger.LogInformation("Loading OpenAPI files...");
+        _logger.LogInformation("Loading OpenAPI files...");
 
         foreach (var version in graphVersions)
         {
             var filePath = Path.Combine(folder, GetGraphOpenApiYamlFileName(version));
             var file = new FileInfo(filePath);
-            logger.LogDebug("Loading OpenAPI file for {FilePath}...", filePath);
+            _logger.LogDebug("Loading OpenAPI file for {FilePath}...", filePath);
 
             if (!file.Exists)
             {
-                logger.LogDebug("File {FilePath} does not exist", filePath);
+                _logger.LogDebug("File {FilePath} does not exist", filePath);
                 continue;
             }
 
@@ -203,12 +206,18 @@ private static async Task LoadOpenAPIFilesAsync(string folder, ILogger logger, C
                 var openApiDocument = await new OpenApiStreamReader().ReadAsync(file.OpenRead(), cancellationToken);
                 _openApiDocuments[version] = openApiDocument.OpenApiDocument;
 
-                logger.LogDebug("Added OpenAPI file {FilePath} for {Version}", filePath, version);
+                _logger.LogDebug("Added OpenAPI file {FilePath} for {Version}", filePath, version);
             }
             catch (Exception ex)
             {
-                logger.LogError(ex, "Error loading OpenAPI file {FilePath}", filePath);
+                _logger.LogError(ex, "Error loading OpenAPI file {FilePath}", filePath);
             }
         }
     }
+
+    public void Dispose()
+    {
+        _msGraphDbConnection?.Dispose();
+        _httpClient?.Dispose();
+    }
 }
diff --git a/DevProxy.Plugins/Guidance/GraphSelectGuidancePlugin.cs b/DevProxy.Plugins/Guidance/GraphSelectGuidancePlugin.cs
@@ -13,16 +13,19 @@ namespace DevProxy.Plugins.Guidance;
 
 public sealed class GraphSelectGuidancePlugin(
     ILogger<GraphSelectGuidancePlugin> logger,
-    ISet<UrlToWatch> urlsToWatch) : BasePlugin(logger, urlsToWatch)
+    ISet<UrlToWatch> urlsToWatch,
+    MSGraphDbUtils msGraphDbUtils) : BasePlugin(logger, urlsToWatch)
 {
+    private readonly MSGraphDbUtils _msGraphDbUtils = msGraphDbUtils;
+
     public override string Name => nameof(GraphSelectGuidancePlugin);
 
     public override async Task InitializeAsync(InitArgs e, CancellationToken cancellationToken)
     {
         await base.InitializeAsync(e, cancellationToken);
 
         // let's not await so that it doesn't block the proxy startup
-        _ = MSGraphDbUtils.GenerateMSGraphDbAsync(Logger, true, cancellationToken);
+        _ = _msGraphDbUtils.GenerateMSGraphDbAsync(true, cancellationToken);
     }
 
     public override Task AfterResponseAsync(ProxyResponseArgs e, CancellationToken cancellationToken)
@@ -82,7 +85,7 @@ private bool EndpointSupportsSelect(string graphVersion, string relativeUrl)
 
         try
         {
-            var dbConnection = MSGraphDbUtils.MSGraphDbConnection;
+            var dbConnection = _msGraphDbUtils.MSGraphDbConnection;
             // lookup information from the database
             var selectEndpoint = dbConnection.CreateCommand();
             selectEndpoint.CommandText = "SELECT hasSelect FROM endpoints WHERE path = @path AND graphVersion = @graphVersion";
diff --git a/DevProxy/Commands/MsGraphDbCommand.cs b/DevProxy/Commands/MsGraphDbCommand.cs
@@ -10,11 +10,13 @@ namespace DevProxy.Commands;
 sealed class MsGraphDbCommand : Command
 {
     private readonly ILogger _logger;
+    private readonly MSGraphDbUtils _msGraphDbUtils;
 
-    public MsGraphDbCommand(ILogger<MsGraphDbCommand> logger) :
+    public MsGraphDbCommand(ILogger<MsGraphDbCommand> logger, MSGraphDbUtils msGraphDbUtils) :
         base("msgraphdb", "Generate a local SQLite database with Microsoft Graph API metadata")
     {
         _logger = logger;
+        _msGraphDbUtils = msGraphDbUtils;
         ConfigureCommand();
     }
 
@@ -25,6 +27,6 @@ private void ConfigureCommand()
 
     private async Task GenerateMsGraphDbAsync(ParseResult parseResult, CancellationToken cancellationToken)
     {
-        _ = await MSGraphDbUtils.GenerateMSGraphDbAsync(_logger, false, cancellationToken);
+        _ = await _msGraphDbUtils.GenerateMSGraphDbAsync(false, cancellationToken);
     }
 }
diff --git a/DevProxy/Extensions/IServiceCollectionExtensions.cs b/DevProxy/Extensions/IServiceCollectionExtensions.cs
@@ -5,6 +5,7 @@
 using DevProxy;
 using DevProxy.Abstractions.LanguageModel;
 using DevProxy.Abstractions.Proxy;
+using DevProxy.Abstractions.Utils;
 using DevProxy.Commands;
 using DevProxy.Proxy;
 
@@ -46,6 +47,7 @@ static IServiceCollection AddApplicationServices(
             .AddSingleton<ProxyEngine>()
             .AddSingleton<DevProxyCommand>()
             .AddSingleton<Announcement>()
+            .AddSingleton<MSGraphDbUtils>()
             .AddHttpClient();
 
         _ = services.AddPlugins(configuration, options);

Original file line number	Diff line number	Diff line change
`@@ -9,17 +9,18 @@`
`9`	`9`
`10`	`10`	`namespace DevProxy.Abstractions.Utils;`
`11`	`11`
`12`		`-public static class MSGraphDbUtils`
	`12`	`+public sealed class MSGraphDbUtils(HttpClient httpClient, ILogger<MSGraphDbUtils> logger) : IDisposable`
`13`	`13`	`{`
`14`		`- private static readonly Dictionary<string, OpenApiDocument> _openApiDocuments = [];`
`15`	`14`	`private static readonly string[] graphVersions = ["v1.0", "beta"];`
`16`		`-`
`17`		`- private static SqliteConnection? _msGraphDbConnection;`
	`15`	`+ private readonly Dictionary<string, OpenApiDocument> _openApiDocuments = [];`
	`16`	`+ private readonly HttpClient _httpClient = httpClient;`
	`17`	`+ private readonly ILogger<MSGraphDbUtils> _logger = logger;`
	`18`	`+ private SqliteConnection? _msGraphDbConnection;`
`18`	`19`
`19`	`20`	`// v1 refers to v1 of the db schema, not the graph version`
`20`	`21`	`public static string MSGraphDbFilePath => Path.Combine(ProxyUtils.AppFolder!, "msgraph-openapi-v1.db");`
`21`	`22`
`22`		`- public static SqliteConnection MSGraphDbConnection`
	`23`	`+ public SqliteConnection MSGraphDbConnection`
`23`	`24`	`{`
`24`	`25`	`get`
`25`	`26`	`{`
`@@ -33,12 +34,12 @@ public static SqliteConnection MSGraphDbConnection`
`33`	`34`	`}`
`34`	`35`	`}`
`35`	`36`
`36`		`- public static async Task<int> GenerateMSGraphDbAsync(ILogger logger, bool skipIfUpdatedToday, CancellationToken cancellationToken)`
	`37`	`+ public async Task<int> GenerateMSGraphDbAsync(bool skipIfUpdatedToday, CancellationToken cancellationToken)`
`37`	`38`	`{`
`38`	`39`	`var appFolder = ProxyUtils.AppFolder;`
`39`	`40`	`if (string.IsNullOrEmpty(appFolder))`
`40`	`41`	`{`
`41`		`- logger.LogError("App folder {AppFolder} not found", appFolder);`
	`42`	`+ _logger.LogError("App folder {AppFolder} not found", appFolder);`
`42`	`43`	`return 1;`
`43`	`44`	`}`
`44`	`45`
`@@ -48,61 +49,64 @@ public static async Task<int> GenerateMSGraphDbAsync(ILogger logger, bool skipIf`
`48`	`49`	`var modifiedToday = dbFileInfo.Exists && dbFileInfo.LastWriteTime.Date == DateTime.Now.Date;`
`49`	`50`	`if (modifiedToday && skipIfUpdatedToday)`
`50`	`51`	`{`
`51`		`- logger.LogInformation("Microsoft Graph database already updated today");`
	`52`	`+ _logger.LogInformation("Microsoft Graph database already updated today");`
`52`	`53`	`return 1;`
`53`	`54`	`}`
`54`	`55`
`55`		`- await UpdateOpenAPIGraphFilesIfNecessaryAsync(appFolder, logger, cancellationToken);`
`56`		`- await LoadOpenAPIFilesAsync(appFolder, logger, cancellationToken);`
	`56`	`+ await UpdateOpenAPIGraphFilesIfNecessaryAsync(appFolder, cancellationToken);`
	`57`	`+ await LoadOpenAPIFilesAsync(appFolder, cancellationToken);`
`57`	`58`	`if (_openApiDocuments.Count < 1)`
`58`	`59`	`{`
`59`		`- logger.LogDebug("No OpenAPI files found or couldn't load them");`
	`60`	`+ _logger.LogDebug("No OpenAPI files found or couldn't load them");`
`60`	`61`	`return 1;`
`61`	`62`	`}`
`62`	`63`
`63`		`- var dbConnection = MSGraphDbConnection;`
`64`		`- await CreateDbAsync(dbConnection, logger, cancellationToken);`
`65`		`- await FillDataAsync(dbConnection, logger, cancellationToken);`
	`64`	`+ await CreateDbAsync(cancellationToken);`
	`65`	`+ await FillDataAsync(cancellationToken);`
`66`	`66`
`67`		`- logger.LogInformation("Microsoft Graph database successfully updated");`
	`67`	`+ _logger.LogInformation("Microsoft Graph database successfully updated");`
`68`	`68`
`69`	`69`	`return 0;`
`70`	`70`	`}`
`71`	`71`	`catch (Exception ex)`
`72`	`72`	`{`
`73`		`- logger.LogError(ex, "Error generating Microsoft Graph database");`
	`73`	`+ _logger.LogError(ex, "Error generating Microsoft Graph database");`
`74`	`74`	`return 1;`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`private static string GetGraphOpenApiYamlFileName(string version) => $"graph-{version.Replace(".", "_", StringComparison.OrdinalIgnoreCase)}-openapi.yaml";`
`80`	`80`
`81`		`- private static async Task CreateDbAsync(SqliteConnection dbConnection, ILogger logger, CancellationToken cancellationToken)`
	`81`	`+ private async Task CreateDbAsync(CancellationToken cancellationToken)`
`82`	`82`	`{`
`83`		`- logger.LogInformation("Creating database...");`
	`83`	`+ _logger.LogInformation("Creating database...");`
	`84`	`+`
	`85`	`+ var dbConnection = MSGraphDbConnection;`
`84`	`86`
`85`		`- logger.LogDebug("Dropping endpoints table...");`
	`87`	`+ _logger.LogDebug("Dropping endpoints table...");`
`86`	`88`	`var dropTable = dbConnection.CreateCommand();`
`87`	`89`	`dropTable.CommandText = "DROP TABLE IF EXISTS endpoints";`
`88`	`90`	`_ = await dropTable.ExecuteNonQueryAsync(cancellationToken);`
`89`	`91`
`90`		`- logger.LogDebug("Creating endpoints table...");`
	`92`	`+ _logger.LogDebug("Creating endpoints table...");`
`91`	`93`	`var createTable = dbConnection.CreateCommand();`
`92`	`94`	`// when you change the schema, increase the db version number in ProxyUtils`
`93`	`95`	`createTable.CommandText = "CREATE TABLE IF NOT EXISTS endpoints (path TEXT, graphVersion TEXT, hasSelect BOOLEAN)";`
`94`	`96`	`_ = await createTable.ExecuteNonQueryAsync(cancellationToken);`
`95`	`97`
`96`		`- logger.LogDebug("Creating index on endpoints and version...");`
	`98`	`+ _logger.LogDebug("Creating index on endpoints and version...");`
`97`	`99`	`// Add an index on the path and graphVersion columns`
`98`	`100`	`var createIndex = dbConnection.CreateCommand();`
`99`	`101`	`createIndex.CommandText = "CREATE INDEX IF NOT EXISTS idx_endpoints_path_version ON endpoints (path, graphVersion)";`
`100`	`102`	`_ = await createIndex.ExecuteNonQueryAsync(cancellationToken);`
`101`	`103`	`}`
`102`	`104`
`103`		`- private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger logger, CancellationToken cancellationToken)`
	`105`	`+ private async Task FillDataAsync(CancellationToken cancellationToken)`
`104`	`106`	`{`
`105`		`- logger.LogInformation("Filling database...");`
	`107`	`+ _logger.LogInformation("Filling database...");`
	`108`	`+`
	`109`	`+ var dbConnection = MSGraphDbConnection;`
`106`	`110`
`107`	`111`	`var i = 0;`
`108`	`112`
`@@ -113,7 +117,7 @@ private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger l`
`113`	`117`	`var graphVersion = openApiDocument.Key;`
`114`	`118`	`var document = openApiDocument.Value;`
`115`	`119`
`116`		`- logger.LogDebug("Filling database for {GraphVersion}...", graphVersion);`
	`120`	`+ _logger.LogDebug("Filling database for {GraphVersion}...", graphVersion);`
`117`	`121`
`118`	`122`	`var insertEndpoint = dbConnection.CreateCommand();`
`119`	`123`	`insertEndpoint.CommandText = "INSERT INTO endpoints (path, graphVersion, hasSelect) VALUES (@path, @graphVersion, @hasSelect)";`
`@@ -125,20 +129,20 @@ private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger l`
`125`	`129`	`{`
`126`	`130`	`cancellationToken.ThrowIfCancellationRequested();`
`127`	`131`
`128`		`- logger.LogTrace("Endpoint {GraphVersion}{Key}...", graphVersion, path.Key);`
	`132`	`+ _logger.LogTrace("Endpoint {GraphVersion}{Key}...", graphVersion, path.Key);`
`129`	`133`
`130`	`134`	`// Get the GET operation for this path`
`131`	`135`	`var getOperation = path.Value.Operations.FirstOrDefault(o => o.Key == OperationType.Get).Value;`
`132`	`136`	`if (getOperation == null)`
`133`	`137`	`{`
`134`		`- logger.LogTrace("No GET operation found for {GraphVersion}{Key}", graphVersion, path.Key);`
	`138`	`+ _logger.LogTrace("No GET operation found for {GraphVersion}{Key}", graphVersion, path.Key);`
`135`	`139`	`continue;`
`136`	`140`	`}`
`137`	`141`
`138`	`142`	`// Check if the GET operation has a $select parameter`
`139`	`143`	`var hasSelect = getOperation.Parameters.Any(p => p.Name == "$select");`
`140`	`144`
`141`		`- logger.LogTrace("Inserting endpoint {GraphVersion}{Key} with hasSelect={HasSelect}...", graphVersion, path.Key, hasSelect);`
	`145`	`+ _logger.LogTrace("Inserting endpoint {GraphVersion}{Key} with hasSelect={HasSelect}...", graphVersion, path.Key, hasSelect);`
`142`	`146`	`insertEndpoint.Parameters["@path"].Value = path.Key;`
`143`	`147`	`insertEndpoint.Parameters["@graphVersion"].Value = graphVersion;`
`144`	`148`	`insertEndpoint.Parameters["@hasSelect"].Value = hasSelect;`
`@@ -147,54 +151,53 @@ private static async Task FillDataAsync(SqliteConnection dbConnection, ILogger l`
`147`	`151`	`}`
`148`	`152`	`}`
`149`	`153`
`150`		`- logger.LogInformation("Inserted {EndpointCount} endpoints in the database", i);`
	`154`	`+ _logger.LogInformation("Inserted {EndpointCount} endpoints in the database", i);`
`151`	`155`	`}`
`152`	`156`
`153`		`- private static async Task UpdateOpenAPIGraphFilesIfNecessaryAsync(string folder, ILogger logger, CancellationToken cancellationToken)`
	`157`	`+ private async Task UpdateOpenAPIGraphFilesIfNecessaryAsync(string folder, CancellationToken cancellationToken)`
`154`	`158`	`{`
`155`		`- logger.LogInformation("Checking for updated OpenAPI files...");`
	`159`	`+ _logger.LogInformation("Checking for updated OpenAPI files...");`
`156`	`160`
`157`	`161`	`foreach (var version in graphVersions)`
`158`	`162`	`{`
`159`	`163`	`try`
`160`	`164`	`{`
`161`	`165`	`var file = new FileInfo(Path.Combine(folder, GetGraphOpenApiYamlFileName(version)));`
`162`		`- logger.LogDebug("Checking for updated OpenAPI file {File}...", file);`
	`166`	`+ _logger.LogDebug("Checking for updated OpenAPI file {File}...", file);`
`163`	`167`	`if (file.Exists && file.LastWriteTime.Date == DateTime.Now.Date)`
`164`	`168`	`{`
`165`		`- logger.LogInformation("File {File} already updated today", file);`
	`169`	`+ _logger.LogInformation("File {File} already updated today", file);`
`166`	`170`	`continue;`
`167`	`171`	`}`
`168`	`172`
`169`	`173`	`var url = $"https://raw.githubusercontent.com/microsoftgraph/msgraph-metadata/master/openapi/{version}/openapi.yaml";`
`170`		`- logger.LogInformation("Downloading OpenAPI file from {Url}...", url);`
	`174`	`+ _logger.LogInformation("Downloading OpenAPI file from {Url}...", url);`
`171`	`175`
`172`		`- using var client = new HttpClient();`
`173`		`- var response = await client.GetStringAsync(url, cancellationToken);`
	`176`	`+ var response = await _httpClient.GetStringAsync(url, cancellationToken);`
`174`	`177`	`await File.WriteAllTextAsync(file.FullName, response, cancellationToken);`
`175`	`178`
`176`		`- logger.LogDebug("Downloaded OpenAPI file from {Url} to {File}", url, file);`
	`179`	`+ _logger.LogDebug("Downloaded OpenAPI file from {Url} to {File}", url, file);`
`177`	`180`	`}`
`178`	`181`	`catch (Exception ex)`
`179`	`182`	`{`
`180`		`- logger.LogError(ex, "Error updating OpenAPI files");`
	`183`	`+ _logger.LogError(ex, "Error updating OpenAPI files");`
`181`	`184`	`}`
`182`	`185`	`}`
`183`	`186`	`}`
`184`	`187`
`185`		`- private static async Task LoadOpenAPIFilesAsync(string folder, ILogger logger, CancellationToken cancellationToken)`
	`188`	`+ private async Task LoadOpenAPIFilesAsync(string folder, CancellationToken cancellationToken)`
`186`	`189`	`{`
`187`		`- logger.LogInformation("Loading OpenAPI files...");`
	`190`	`+ _logger.LogInformation("Loading OpenAPI files...");`
`188`	`191`
`189`	`192`	`foreach (var version in graphVersions)`
`190`	`193`	`{`
`191`	`194`	`var filePath = Path.Combine(folder, GetGraphOpenApiYamlFileName(version));`
`192`	`195`	`var file = new FileInfo(filePath);`
`193`		`- logger.LogDebug("Loading OpenAPI file for {FilePath}...", filePath);`
	`196`	`+ _logger.LogDebug("Loading OpenAPI file for {FilePath}...", filePath);`
`194`	`197`
`195`	`198`	`if (!file.Exists)`
`196`	`199`	`{`
`197`		`- logger.LogDebug("File {FilePath} does not exist", filePath);`
	`200`	`+ _logger.LogDebug("File {FilePath} does not exist", filePath);`
`198`	`201`	`continue;`
`199`	`202`	`}`
`200`	`203`
`@@ -203,12 +206,18 @@ private static async Task LoadOpenAPIFilesAsync(string folder, ILogger logger, C`
`203`	`206`	`var openApiDocument = await new OpenApiStreamReader().ReadAsync(file.OpenRead(), cancellationToken);`
`204`	`207`	`_openApiDocuments[version] = openApiDocument.OpenApiDocument;`
`205`	`208`
`206`		`- logger.LogDebug("Added OpenAPI file {FilePath} for {Version}", filePath, version);`
	`209`	`+ _logger.LogDebug("Added OpenAPI file {FilePath} for {Version}", filePath, version);`
`207`	`210`	`}`
`208`	`211`	`catch (Exception ex)`
`209`	`212`	`{`
`210`		`- logger.LogError(ex, "Error loading OpenAPI file {FilePath}", filePath);`
	`213`	`+ _logger.LogError(ex, "Error loading OpenAPI file {FilePath}", filePath);`
`211`	`214`	`}`
`212`	`215`	`}`
`213`	`216`	`}`
	`217`	`+`
	`218`	`+ public void Dispose()`
	`219`	`+ {`
	`220`	`+ _msGraphDbConnection?.Dispose();`
	`221`	`+ _httpClient?.Dispose();`
	`222`	`+ }`
`214`	`223`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,13 @@ namespace DevProxy.Commands;`
`10`	`10`	`sealed class MsGraphDbCommand : Command`
`11`	`11`	`{`
`12`	`12`	`private readonly ILogger _logger;`
	`13`	`+ private readonly MSGraphDbUtils _msGraphDbUtils;`
`13`	`14`
`14`		`- public MsGraphDbCommand(ILogger<MsGraphDbCommand> logger) :`
	`15`	`+ public MsGraphDbCommand(ILogger<MsGraphDbCommand> logger, MSGraphDbUtils msGraphDbUtils) :`
`15`	`16`	`base("msgraphdb", "Generate a local SQLite database with Microsoft Graph API metadata")`
`16`	`17`	`{`
`17`	`18`	`_logger = logger;`
	`19`	`+ _msGraphDbUtils = msGraphDbUtils;`
`18`	`20`	`ConfigureCommand();`
`19`	`21`	`}`
`20`	`22`
`@@ -25,6 +27,6 @@ private void ConfigureCommand()`
`25`	`27`
`26`	`28`	`private async Task GenerateMsGraphDbAsync(ParseResult parseResult, CancellationToken cancellationToken)`
`27`	`29`	`{`
`28`		`- _ = await MSGraphDbUtils.GenerateMSGraphDbAsync(_logger, false, cancellationToken);`
	`30`	`+ _ = await _msGraphDbUtils.GenerateMSGraphDbAsync(false, cancellationToken);`
`29`	`31`	`}`
`30`	`32`	`}`