Enhance PostgreSqlPlugin with new features and refactoring

- Added `Data` property to `InputParameter` for additional data.
- Updated `PostgreSqlPlugin` constructor to require `IGuidProvider`.
- Bumped plugin version from 1.1.1 to 1.2.0.
- Refactored `OperationMap` for readability and improved error handling.
- Simplified SQL parameter extraction with new `ExtractSqlParameters` method.
- Introduced `GuidProvider` class for generating GUIDs.
- Updated unit tests to mock `IGuidProvider` and reflect method changes.
- Renamed private methods for clarity and improved error handling.

#14

Author: ziagham

src/Models/InputParameter.cs

@@ -5,4 +5,5 @@ internal class InputParameter
     public string Operation { get; set; } = string.Empty;
     public string Sql { get; set; } = string.Empty;
     public Dictionary<string, object>? Params { get; set; }
+    public object? Data { get; set; }
 }

src/PostgreSqlPlugin.cs

@@ -1,65 +1,68 @@
 using FlowSynx.PluginCore;
 using FlowSynx.PluginCore.Extensions;
-using FlowSynx.PluginCore.Helpers;
 using FlowSynx.Plugins.PostgreSql.Models;
 using FlowSynx.Plugins.PostgreSql.Services;
 using Npgsql;
 using NpgsqlTypes;
 
 namespace FlowSynx.Plugins.PostgreSql;
 
-public class PostgreSqlPlugin: IPlugin
+public class PostgreSqlPlugin : IPlugin
 {
-    private IPluginLogger? _logger;
+    private readonly IGuidProvider _guidProvider;
     private readonly IReflectionGuard _reflectionGuard;
-    private PostgreSqlPluginSpecifications _postgreSqlSpecifications = null!;
+    private IPluginLogger? _logger;
+    private PostgreSqlPluginSpecifications _specifications = null!;
     private bool _isInitialized;
 
     public PostgreSqlPlugin()
-        : this(new DefaultReflectionGuard()) { }
+        : this(new GuidProvider(), new DefaultReflectionGuard()) { }
 
-    internal PostgreSqlPlugin(IReflectionGuard reflectionGuard)
+    internal PostgreSqlPlugin(IGuidProvider guidProvider, IReflectionGuard reflectionGuard)
     {
+        _guidProvider = guidProvider ?? throw new ArgumentNullException(nameof(guidProvider));
         _reflectionGuard = reflectionGuard ?? throw new ArgumentNullException(nameof(reflectionGuard));
     }
 
-    public PluginMetadata Metadata => new PluginMetadata
+    public PluginMetadata Metadata => new()
     {
         Id = Guid.Parse("e2c349bc-6bfc-4e1e-acce-8dbda585abcf"),
         Name = "PostgreSql",
         CompanyName = "FlowSynx",
         Description = Resources.PluginDescription,
-        Version = new Version(1, 1, 1),
+        Version = new Version(1, 2, 0),
         Category = PluginCategory.Database,
         Authors = new List<string> { "FlowSynx" },
         Copyright = "© FlowSynx. All rights reserved.",
         Icon = "flowsynx.png",
         ReadMe = "README.md",
         RepositoryUrl = "https://github.com/flowsynx/plugin-postgresql",
         ProjectUrl = "https://flowsynx.io",
-        Tags = new List<string>() { "flowSynx", "sql", "database", "data", "postgresql" },
+        Tags = new List<string> { "flowSynx", "sql", "database", "data", "postgresql" },
         MinimumFlowSynxVersion = new Version(1, 1, 1)
     };
 
     public PluginSpecifications? Specifications { get; set; }
-
     public Type SpecificationsType => typeof(PostgreSqlPluginSpecifications);
 
-    private Dictionary<string, Func<InputParameter, CancellationToken, Task<object?>>> OperationMap => new(StringComparer.OrdinalIgnoreCase)
-    {
-        ["query"] = async (parameters, cancellationToken) => await ExecuteQueryAsync(parameters, cancellationToken),
-        ["execute"] = async (parameters, cancellationToken) => { await ExecuteNonQueryAsync(parameters, cancellationToken); return null; }
-    };
+    private Dictionary<string, Func<InputParameter, CancellationToken, Task<object?>>> OperationMap =>
+        new Dictionary<string, Func<InputParameter, CancellationToken, Task<object?>>>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["query"] = async (p, t) => await ExecuteQueryAsync(p, t),
+            ["execute"] = async (p, t) => { await ExecuteNonQueryAsync(p, t); return null; }
+        };
 
     public IReadOnlyCollection<string> SupportedOperations => OperationMap.Keys;
 
     public Task Initialize(IPluginLogger logger)
     {
         ThrowIfReflection();
         ArgumentNullException.ThrowIfNull(logger);
-        _postgreSqlSpecifications = Specifications.ToObject<PostgreSqlPluginSpecifications>();
+
+        _specifications = Specifications.ToObject<PostgreSqlPluginSpecifications>();
         _logger = logger;
         _isInitialized = true;
+
         return Task.CompletedTask;
     }
 
@@ -69,185 +72,182 @@ public Task Initialize(IPluginLogger logger)
         ThrowIfReflection();
         ThrowIfNotInitialized();
 
-        var inputParameter = parameters.ToObject<InputParameter>();
-        var operation = inputParameter.Operation;
+        var input = parameters.ToObject<InputParameter>();
+        if (!OperationMap.TryGetValue(input.Operation, out var handler))
+            throw new NotSupportedException($"PostgreSQL plugin: Operation '{input.Operation}' is not supported.");
 
-        if (OperationMap.TryGetValue(operation, out var handler))
-        {
-            return await handler(inputParameter, cancellationToken);
-        }
-
-        throw new NotSupportedException($"PostgreSQL plugin: Operation '{operation}' is not supported.");
+        return await handler(input, cancellationToken);
     }
 
-    private void ThrowIfReflection()
-    {
-        if (_reflectionGuard.IsCalledViaReflection())
-            throw new InvalidOperationException(Resources.ReflectionBasedAccessIsNotAllowed);
-    }
-
-    private void ThrowIfNotInitialized()
-    {
-        if (!_isInitialized)
-            throw new InvalidOperationException($"Plugin '{Metadata.Name}' v{Metadata.Version} is not initialized.");
-    }
+    #region private methods
 
-    private async Task ExecuteNonQueryAsync(InputParameter parameters, CancellationToken cancellationToken)
+    private async Task ExecuteNonQueryAsync(InputParameter input, CancellationToken token)
     {
-        var (sql, sqlParams) = GetSqlAndParameters(parameters);
+        var (sql, sqlParams) = ExtractSqlParameters(input);
+        var connectionString = NormalizeConnectionString(_specifications.ConnectionString);
 
         try
         {
-            var connectionString = NormalizePostgresConnectionString(_postgreSqlSpecifications.ConnectionString);
-            var connection = new NpgsqlConnection(connectionString);
-            await connection.OpenAsync();
-            using var cmd = new NpgsqlCommand(parameters.Sql, connection);
-
-            AddParameters(cmd, sqlParams);
+            await using var connection = new NpgsqlConnection(connectionString);
+            await connection.OpenAsync(token);
 
-            cancellationToken.ThrowIfCancellationRequested();
+            var context = ParseInputData(input.Data);
 
-            int affectedRows = await cmd.ExecuteNonQueryAsync(cancellationToken);
-            _logger?.LogInfo($"Non-query executed successfully. Rows affected: {affectedRows}.");
+            if (context.StructuredData?.Count > 0)
+            {
+                await ExecuteStructuredDataAsync(connection, sql, context, token);
+            }
+            else
+            {
+                await ExecuteSingleNonQueryAsync(connection, sql, sqlParams, token);
+            }
         }
         catch (Exception ex)
         {
-            _logger?.LogError($"Error executing PostgreSQL sql statement. Error: {ex.Message}");
+            _logger?.LogError($"Error executing PostgreSQL SQL statement: {ex.Message}");
             throw;
         }
     }
 
-    private async Task<PluginContext> ExecuteQueryAsync(InputParameter parameters, CancellationToken cancellationToken)
+    private async Task<PluginContext> ExecuteQueryAsync(InputParameter input, CancellationToken token)
     {
-        var (sql, sqlParams) = GetSqlAndParameters(parameters);
+        var (sql, sqlParams) = ExtractSqlParameters(input);
+        var connectionString = NormalizeConnectionString(_specifications.ConnectionString);
 
         try
         {
             var result = new List<Dictionary<string, object>>();
-            var connectionString = NormalizePostgresConnectionString(_postgreSqlSpecifications.ConnectionString);
-            var connection = new NpgsqlConnection(connectionString);
-            await connection.OpenAsync();
-            using var cmd = new NpgsqlCommand(sql, connection);
+            await using var connection = new NpgsqlConnection(connectionString);
+            await connection.OpenAsync(token);
 
+            await using var cmd = new NpgsqlCommand(sql, connection);
             AddParameters(cmd, sqlParams);
 
-            cancellationToken.ThrowIfCancellationRequested();
-
-            using var reader = await cmd.ExecuteReaderAsync(cancellationToken);
-
-            while (await reader.ReadAsync(cancellationToken))
+            await using var reader = await cmd.ExecuteReaderAsync(token);
+            while (await reader.ReadAsync(token))
             {
-                var row = new Dictionary<string, object>();
-                for (int i = 0; i < reader.FieldCount; i++)
-                {
-                    row[reader.GetName(i)] = reader.GetValue(i);
-                }
+                var row = Enumerable.Range(0, reader.FieldCount)
+                                    .ToDictionary(reader.GetName, reader.GetValue);
                 result.Add(row);
             }
 
             _logger?.LogInfo($"Query executed successfully. Rows returned: {result.Count}.");
-            string key = $"{Guid.NewGuid().ToString()}";
-            return new PluginContext(key, "Data")
+
+            return new PluginContext(_guidProvider.NewGuid().ToString(), "Data")
             {
                 Format = "Database",
                 StructuredData = result
             };
         }
         catch (Exception ex)
         {
-            _logger?.LogError($"Error executing PostgreSQL sql statement. Error: {ex.Message}");
+            _logger?.LogError($"Error executing PostgreSQL query: {ex.Message}");
             throw;
         }
     }
 
-    private (string Sql, Dictionary<string, object> Parameters) GetSqlAndParameters(InputParameter parameters)
+    private async Task ExecuteStructuredDataAsync(
+        NpgsqlConnection connection, string sql, PluginContext context, CancellationToken token)
     {
-        if (string.IsNullOrEmpty(parameters.Sql))
-            throw new ArgumentException("Missing 'sql' parameter.");
-        
-        Dictionary<string, object> sqlParams = new();
+        int totalAffected = 0;
 
-        if (parameters.Params is Dictionary<string, object> paramDict)
+        foreach (var row in context.StructuredData)
         {
-            sqlParams = paramDict;
+            await using var cmd = new NpgsqlCommand(sql, connection);
+            AddParameters(cmd, row);
+            totalAffected += await cmd.ExecuteNonQueryAsync(token);
         }
 
-        return (parameters.Sql, sqlParams);
+        _logger?.LogInfo($"Executed structured SQL for {context.StructuredData.Count} rows. Total affected: {totalAffected}");
+    }
+
+    private async Task ExecuteSingleNonQueryAsync(
+        NpgsqlConnection connection, string sql, Dictionary<string, object> sqlParams, CancellationToken token)
+    {
+        await using var cmd = new NpgsqlCommand(sql, connection);
+        AddParameters(cmd, sqlParams);
+        int affected = await cmd.ExecuteNonQueryAsync(token);
+        _logger?.LogInfo($"Non-query executed successfully. Rows affected: {affected}.");
+    }
+
+    private (string Sql, Dictionary<string, object> Params) ExtractSqlParameters(InputParameter input)
+    {
+        if (string.IsNullOrWhiteSpace(input.Sql))
+            throw new ArgumentException("Missing 'sql' parameter.");
+
+        var sqlParams = input.Params as Dictionary<string, object> ?? new();
+        return (input.Sql, sqlParams);
     }
 
     private void AddParameters(NpgsqlCommand cmd, Dictionary<string, object>? parameters)
     {
-        if (parameters == null) return;
+        if (parameters is null) return;
 
-        foreach (var kvp in parameters)
+        foreach (var (key, value) in parameters)
         {
-            var paramName = kvp.Key;
-            var paramValue = kvp.Value;
+            var name = key.StartsWith("@") ? key : "@" + key;
 
-            if (paramValue == null)
-            {
-                cmd.Parameters.AddWithValue(paramName, DBNull.Value);
-            }
-            else if (paramValue is Guid guidValue)
+            cmd.Parameters.Add(value switch
             {
-                cmd.Parameters.Add(paramName, NpgsqlDbType.Uuid).Value = guidValue;
-            }
-            else if (paramValue is string strValue)
-            {
-                // Try to detect if string is Guid
-                if (Guid.TryParse(strValue, out var parsedGuid))
-                {
-                    cmd.Parameters.Add(paramName, NpgsqlDbType.Uuid).Value = parsedGuid;
-                }
-                else
-                {
-                    cmd.Parameters.AddWithValue(paramName, strValue);
-                }
-            }
-            else if (paramValue is int || paramValue is long || paramValue is double || paramValue is decimal)
-            {
-                cmd.Parameters.AddWithValue(paramName, paramValue);
-            }
-            else if (paramValue is bool boolValue)
-            {
-                cmd.Parameters.AddWithValue(paramName, boolValue);
-            }
-            else if (paramValue is DateTime dateValue)
-            {
-                cmd.Parameters.AddWithValue(paramName, NpgsqlDbType.Timestamp).Value = dateValue;
-            }
-            else
-            {
-                throw new InvalidOperationException($"Unsupported parameter type for '{paramName}': {paramValue.GetType()}");
-            }
+                null => new NpgsqlParameter(name, DBNull.Value),
+                Guid g => new NpgsqlParameter(name, NpgsqlDbType.Uuid) { Value = g },
+                string s when Guid.TryParse(s, out var parsed) => new NpgsqlParameter(name, NpgsqlDbType.Uuid) { Value = parsed },
+                string s => new NpgsqlParameter(name, s),
+                int or long or double or decimal or bool => new NpgsqlParameter(name, value),
+                DateTime dt => new NpgsqlParameter(name, NpgsqlDbType.Timestamp) { Value = dt },
+                _ => throw new InvalidOperationException($"Unsupported parameter type for '{name}': {value.GetType()}")
+            });
         }
     }
 
-    private string NormalizePostgresConnectionString(string? input)
+    private string NormalizeConnectionString(string? input)
     {
         if (string.IsNullOrWhiteSpace(input))
-            throw new Exception("Database connectionstring is required!");
+            throw new InvalidOperationException("Database connection string is required.");
+
+        if (!input.StartsWith("postgres://") && !input.StartsWith("postgresql://"))
+            return input;
+
+        var uri = new Uri(input);
+        var userInfo = uri.UserInfo.Split(':', 2);
+        var username = userInfo[0];
+        var password = userInfo.Length > 1 ? userInfo[1] : "";
 
-        if (input.StartsWith("postgres://") || input.StartsWith("postgresql://"))
+        return new NpgsqlConnectionStringBuilder
         {
-            var uri = new Uri(input);
-            var userInfo = uri.UserInfo.Split(':', 2);
-            var username = userInfo[0];
-            var password = userInfo.Length > 1 ? userInfo[1] : "";
-            var host = uri.Host;
-            var port = uri.Port == -1 ? 5432 : uri.Port;
-
-            return new NpgsqlConnectionStringBuilder
-            {
-                Host = host,
-                Port = port,
-                Username = username,
-                Password = password,
-                Database = uri.AbsolutePath.TrimStart('/'),
-                SslMode = SslMode.Require
-            }.ConnectionString;
-        }
+            Host = uri.Host,
+            Port = uri.Port == -1 ? 5432 : uri.Port,
+            Username = username,
+            Password = password,
+            Database = uri.AbsolutePath.TrimStart('/'),
+            SslMode = SslMode.Require
+        }.ConnectionString;
+    }
+
+    private PluginContext ParseInputData(object? data)
+    {
+        if (data is null)
+            throw new ArgumentNullException(nameof(data), "Input data cannot be null.");
 
-        return input;
+        return data switch
+        {
+            PluginContext context => context,
+            IEnumerable<PluginContext> => throw new NotSupportedException("List of PluginContext is not supported."),
+            _ => throw new NotSupportedException("Unsupported input data format.")
+        };
     }
+
+    private void ThrowIfReflection()
+    {
+        if (_reflectionGuard.IsCalledViaReflection())
+            throw new InvalidOperationException(Resources.ReflectionBasedAccessIsNotAllowed);
+    }
+
+    private void ThrowIfNotInitialized()
+    {
+        if (!_isInitialized)
+            throw new InvalidOperationException($"Plugin '{Metadata.Name}' v{Metadata.Version} is not initialized.");
+    }
+
+    #endregion
 }