sdaves
diff --git a/‎NpgsqlRest/HttpClientType/HttpClientTypeHandler.cs‎
Lines changed: 14 additions & 11 deletions b/‎NpgsqlRest/HttpClientType/HttpClientTypeHandler.cs‎
Lines changed: 14 additions & 11 deletions
diff --git a/‎plugins/NpgsqlRest.SqlFileSource/SqlFileSource.cs‎
Lines changed: 6 additions & 4 deletions b/‎plugins/NpgsqlRest.SqlFileSource/SqlFileSource.cs‎
Lines changed: 6 additions & 4 deletions
@@ -17,6 +17,7 @@ public class HttpClientTypeHandler(HttpTypeDefinition definition, Dictionary<str
     /// HttpClient for self-referencing calls (relative paths). Uses SelfBaseUrl or a custom handler.
     /// </summary>
     private static HttpClient? _selfClient;
+    private string? _resolvedUrl;
 
     /// <summary>
     /// Base URL for resolving relative paths (e.g., "/api/test" → "http://localhost:5000/api/test").
@@ -47,14 +48,16 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)
         for (int attempt = 0; attempt <= maxRetries; attempt++)
         {
             var startTimestamp = Stopwatch.GetTimestamp();
+            _resolvedUrl = ResolveValue(definition.Url);
+            var resolvedUrl = _resolvedUrl;
             if (attempt == 0)
             {
-                Logger?.LogDebug("HTTP client starting {Method} request to '{Url}'", definition.Method, definition.Url);
+                Logger?.LogDebug("HTTP client starting {Method} request to '{Url}'", definition.Method, resolvedUrl);
             }
             else
             {
                 Logger?.LogDebug("HTTP client retrying {Method} request to '{Url}' (attempt {Attempt}/{MaxRetries})",
-                    definition.Method, definition.Url, attempt + 1, maxRetries + 1);
+                    definition.Method, resolvedUrl, attempt + 1, maxRetries + 1);
             }
 
             try
@@ -87,12 +90,12 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)
 
                     var elapsed = Stopwatch.GetElapsedTime(startTimestamp);
                     Logger?.LogDebug("Internal request to '{Url}' completed with status {StatusCode} in {Elapsed}ms",
-                        definition.Url, StatusCode, elapsed.TotalMilliseconds.ToString("F1"));
+                        resolvedUrl, StatusCode, elapsed.TotalMilliseconds.ToString("F1"));
 
                     if (!IsSuccess && attempt < maxRetries && ShouldRetry(StatusCode))
                     {
                         Logger?.LogWarning("Internal request to '{Url}' returned {StatusCode}, retrying after {Delay}ms",
-                            definition.Url, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);
+                            resolvedUrl, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);
                         await Task.Delay(definition.RetryDelays![attempt], cancellationToken);
                         continue;
                     }
@@ -110,7 +113,7 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)
                 if (!IsSuccess && attempt < maxRetries && ShouldRetry(StatusCode))
                 {
                     Logger?.LogWarning("HTTP client request to '{Url}' returned {StatusCode}, retrying after {Delay}ms",
-                        definition.Url, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);
+                        resolvedUrl, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);
                     await Task.Delay(definition.RetryDelays![attempt], cancellationToken);
                     continue;
                 }
@@ -124,12 +127,12 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)
                 if (attempt < maxRetries)
                 {
                     Logger?.LogWarning("HTTP client request to '{Url}' timed out, retrying after {Delay}ms",
-                        definition.Url, definition.RetryDelays![attempt].TotalMilliseconds);
+                        resolvedUrl, definition.RetryDelays![attempt].TotalMilliseconds);
                     await Task.Delay(definition.RetryDelays![attempt], cancellationToken);
                     continue;
                 }
                 Logger?.LogWarning("HTTP client request to '{Url}' timed out after {Timeout}s",
-                    definition.Url, definition.Timeout?.TotalSeconds ?? 30);
+                    resolvedUrl, definition.Timeout?.TotalSeconds ?? 30);
             }
             catch (HttpRequestException ex)
             {
@@ -139,19 +142,19 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)
                 if (attempt < maxRetries)
                 {
                     Logger?.LogWarning("HTTP client request to '{Url}' failed ({Message}), retrying after {Delay}ms",
-                        definition.Url, ex.Message, definition.RetryDelays![attempt].TotalMilliseconds);
+                        resolvedUrl, ex.Message, definition.RetryDelays![attempt].TotalMilliseconds);
                     await Task.Delay(definition.RetryDelays![attempt], cancellationToken);
                     continue;
                 }
                 Logger?.LogError(ex, "HTTP client request to '{Url}' failed with status {StatusCode}",
-                    definition.Url, StatusCode);
+                    resolvedUrl, StatusCode);
             }
             catch (Exception ex)
             {
                 StatusCode = 0;
                 IsSuccess = false;
                 ErrorMessage = ex.Message;
-                Logger?.LogError(ex, "HTTP client request to '{Url}' failed with unexpected error", definition.Url);
+                Logger?.LogError(ex, "HTTP client request to '{Url}' failed with unexpected error", resolvedUrl);
                 return; // Unexpected errors are not retryable
             }
         }
@@ -229,7 +232,7 @@ private async Task ProcessResponseAsync(HttpResponseMessage response, long start
 
         var duration = Stopwatch.GetElapsedTime(startTimestamp);
         Logger?.LogDebug("HTTP client request to '{Url}' completed with status {StatusCode}, content-type: {ContentType}, body length: {BodyLength}, duration: {Duration}ms",
-            definition.Url, StatusCode, ContentType, Body?.Length ?? 0, duration.TotalMilliseconds);
+            _resolvedUrl ?? definition.Url, StatusCode, ContentType, Body?.Length ?? 0, duration.TotalMilliseconds);
     }
 
     private static string BuildHeadersJson(HttpResponseMessage response)
 
@@ -217,7 +217,7 @@ private static (Routine, IRoutineSourceParameterFormatter)? ProcessFile(
         }
 
         // Build mapping of expanded param index → (httpTypeName, fieldName) for HTTP type fields
-        Dictionary<int, (string HttpTypeName, string FieldName, short Position)>? expandedHttpFields = null;
+        Dictionary<int, (string HttpTypeName, string FieldName, short Position, string FieldType)>? expandedHttpFields = null;
         if (httpTypeExpansions is not null)
         {
             expandedHttpFields = BuildExpandedFieldMap(httpTypeExpansions);
@@ -244,6 +244,8 @@ private static (Routine, IRoutineSourceParameterFormatter)? ProcessFile(
                 customTypePosition = httpField.Position;
                 originalParameterName = $"${i + 1}";
                 convertedName = httpField.FieldName;
+                // Use the composite field type instead of relying on Describe inference
+                typeName = httpField.FieldType;
             }
             else
             {
@@ -626,10 +628,10 @@ private static string ReplaceParamRef(string sql, string oldRef, string newRef)
     /// <summary>
     /// Build a mapping from expanded parameter index to (httpTypeName, fieldName, position).
     /// </summary>
-    private static Dictionary<int, (string HttpTypeName, string FieldName, short Position)> BuildExpandedFieldMap(
+    private static Dictionary<int, (string HttpTypeName, string FieldName, short Position, string FieldType)> BuildExpandedFieldMap(
         Dictionary<int, (string TypeName, string ParamName, string[] FieldNames, string[] FieldTypes)> expansions)
     {
-        var map = new Dictionary<int, (string, string, short)>();
+        var map = new Dictionary<int, (string, string, short, string)>();
 
         // Calculate cumulative shifts
         var sortedExpansions = expansions.OrderBy(e => e.Key).ToList();
@@ -640,7 +642,7 @@ private static string ReplaceParamRef(string sql, string oldRef, string newRef)
             int expandedStartIndex = origIndex + cumulativeShift;
             for (int f = 0; f < expansion.FieldNames.Length; f++)
             {
-                map[expandedStartIndex + f] = (expansion.TypeName, expansion.FieldNames[f], (short)(f + 1));
+                map[expandedStartIndex + f] = (expansion.TypeName, expansion.FieldNames[f], (short)(f + 1), expansion.FieldTypes[f]);
             }
             cumulativeShift += expansion.FieldNames.Length - 1;
         }
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ public class HttpClientTypeHandler(HttpTypeDefinition definition, Dictionary<str`
`17`	`17`	`/// HttpClient for self-referencing calls (relative paths). Uses SelfBaseUrl or a custom handler.`
`18`	`18`	`/// </summary>`
`19`	`19`	`private static HttpClient? _selfClient;`
	`20`	`+ private string? _resolvedUrl;`
`20`	`21`
`21`	`22`	`/// <summary>`
`22`	`23`	`/// Base URL for resolving relative paths (e.g., "/api/test" → "http://localhost:5000/api/test").`
`@@ -47,14 +48,16 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)`
`47`	`48`	`for (int attempt = 0; attempt <= maxRetries; attempt++)`
`48`	`49`	`{`
`49`	`50`	`var startTimestamp = Stopwatch.GetTimestamp();`
	`51`	`+ _resolvedUrl = ResolveValue(definition.Url);`
	`52`	`+ var resolvedUrl = _resolvedUrl;`
`50`	`53`	`if (attempt == 0)`
`51`	`54`	`{`
`52`		`- Logger?.LogDebug("HTTP client starting {Method} request to '{Url}'", definition.Method, definition.Url);`
	`55`	`+ Logger?.LogDebug("HTTP client starting {Method} request to '{Url}'", definition.Method, resolvedUrl);`
`53`	`56`	`}`
`54`	`57`	`else`
`55`	`58`	`{`
`56`	`59`	`Logger?.LogDebug("HTTP client retrying {Method} request to '{Url}' (attempt {Attempt}/{MaxRetries})",`
`57`		`- definition.Method, definition.Url, attempt + 1, maxRetries + 1);`
	`60`	`+ definition.Method, resolvedUrl, attempt + 1, maxRetries + 1);`
`58`	`61`	`}`
`59`	`62`
`60`	`63`	`try`
`@@ -87,12 +90,12 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)`
`87`	`90`
`88`	`91`	`var elapsed = Stopwatch.GetElapsedTime(startTimestamp);`
`89`	`92`	`Logger?.LogDebug("Internal request to '{Url}' completed with status {StatusCode} in {Elapsed}ms",`
`90`		`- definition.Url, StatusCode, elapsed.TotalMilliseconds.ToString("F1"));`
	`93`	`+ resolvedUrl, StatusCode, elapsed.TotalMilliseconds.ToString("F1"));`
`91`	`94`
`92`	`95`	`if (!IsSuccess && attempt < maxRetries && ShouldRetry(StatusCode))`
`93`	`96`	`{`
`94`	`97`	`Logger?.LogWarning("Internal request to '{Url}' returned {StatusCode}, retrying after {Delay}ms",`
`95`		`- definition.Url, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);`
	`98`	`+ resolvedUrl, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);`
`96`	`99`	`await Task.Delay(definition.RetryDelays![attempt], cancellationToken);`
`97`	`100`	`continue;`
`98`	`101`	`}`
`@@ -110,7 +113,7 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)`
`110`	`113`	`if (!IsSuccess && attempt < maxRetries && ShouldRetry(StatusCode))`
`111`	`114`	`{`
`112`	`115`	`Logger?.LogWarning("HTTP client request to '{Url}' returned {StatusCode}, retrying after {Delay}ms",`
`113`		`- definition.Url, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);`
	`116`	`+ resolvedUrl, StatusCode, definition.RetryDelays![attempt].TotalMilliseconds);`
`114`	`117`	`await Task.Delay(definition.RetryDelays![attempt], cancellationToken);`
`115`	`118`	`continue;`
`116`	`119`	`}`
`@@ -124,12 +127,12 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)`
`124`	`127`	`if (attempt < maxRetries)`
`125`	`128`	`{`
`126`	`129`	`Logger?.LogWarning("HTTP client request to '{Url}' timed out, retrying after {Delay}ms",`
`127`		`- definition.Url, definition.RetryDelays![attempt].TotalMilliseconds);`
	`130`	`+ resolvedUrl, definition.RetryDelays![attempt].TotalMilliseconds);`
`128`	`131`	`await Task.Delay(definition.RetryDelays![attempt], cancellationToken);`
`129`	`132`	`continue;`
`130`	`133`	`}`
`131`	`134`	`Logger?.LogWarning("HTTP client request to '{Url}' timed out after {Timeout}s",`
`132`		`- definition.Url, definition.Timeout?.TotalSeconds ?? 30);`
	`135`	`+ resolvedUrl, definition.Timeout?.TotalSeconds ?? 30);`
`133`	`136`	`}`
`134`	`137`	`catch (HttpRequestException ex)`
`135`	`138`	`{`
`@@ -139,19 +142,19 @@ public async Task InvokeAsync(CancellationToken cancellationToken = default)`
`139`	`142`	`if (attempt < maxRetries)`
`140`	`143`	`{`
`141`	`144`	`Logger?.LogWarning("HTTP client request to '{Url}' failed ({Message}), retrying after {Delay}ms",`
`142`		`- definition.Url, ex.Message, definition.RetryDelays![attempt].TotalMilliseconds);`
	`145`	`+ resolvedUrl, ex.Message, definition.RetryDelays![attempt].TotalMilliseconds);`
`143`	`146`	`await Task.Delay(definition.RetryDelays![attempt], cancellationToken);`
`144`	`147`	`continue;`
`145`	`148`	`}`
`146`	`149`	`Logger?.LogError(ex, "HTTP client request to '{Url}' failed with status {StatusCode}",`
`147`		`- definition.Url, StatusCode);`
	`150`	`+ resolvedUrl, StatusCode);`
`148`	`151`	`}`
`149`	`152`	`catch (Exception ex)`
`150`	`153`	`{`
`151`	`154`	`StatusCode = 0;`
`152`	`155`	`IsSuccess = false;`
`153`	`156`	`ErrorMessage = ex.Message;`
`154`		`- Logger?.LogError(ex, "HTTP client request to '{Url}' failed with unexpected error", definition.Url);`
	`157`	`+ Logger?.LogError(ex, "HTTP client request to '{Url}' failed with unexpected error", resolvedUrl);`
`155`	`158`	`return; // Unexpected errors are not retryable`
`156`	`159`	`}`
`157`	`160`	`}`
`@@ -229,7 +232,7 @@ private async Task ProcessResponseAsync(HttpResponseMessage response, long start`
`229`	`232`
`230`	`233`	`var duration = Stopwatch.GetElapsedTime(startTimestamp);`
`231`	`234`	`Logger?.LogDebug("HTTP client request to '{Url}' completed with status {StatusCode}, content-type: {ContentType}, body length: {BodyLength}, duration: {Duration}ms",`
`232`		`- definition.Url, StatusCode, ContentType, Body?.Length ?? 0, duration.TotalMilliseconds);`
	`235`	`+ _resolvedUrl ?? definition.Url, StatusCode, ContentType, Body?.Length ?? 0, duration.TotalMilliseconds);`
`233`	`236`	`}`
`234`	`237`
`235`	`238`	`private static string BuildHeadersJson(HttpResponseMessage response)`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ private static (Routine, IRoutineSourceParameterFormatter)? ProcessFile(`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`// Build mapping of expanded param index → (httpTypeName, fieldName) for HTTP type fields`
`220`		`- Dictionary<int, (string HttpTypeName, string FieldName, short Position)>? expandedHttpFields = null;`
	`220`	`+ Dictionary<int, (string HttpTypeName, string FieldName, short Position, string FieldType)>? expandedHttpFields = null;`
`221`	`221`	`if (httpTypeExpansions is not null)`
`222`	`222`	`{`
`223`	`223`	`expandedHttpFields = BuildExpandedFieldMap(httpTypeExpansions);`
`@@ -244,6 +244,8 @@ private static (Routine, IRoutineSourceParameterFormatter)? ProcessFile(`
`244`	`244`	`customTypePosition = httpField.Position;`
`245`	`245`	`originalParameterName = $"${i + 1}";`
`246`	`246`	`convertedName = httpField.FieldName;`
	`247`	`+ // Use the composite field type instead of relying on Describe inference`
	`248`	`+ typeName = httpField.FieldType;`
`247`	`249`	`}`
`248`	`250`	`else`
`249`	`251`	`{`
`@@ -626,10 +628,10 @@ private static string ReplaceParamRef(string sql, string oldRef, string newRef)`
`626`	`628`	`/// <summary>`
`627`	`629`	`/// Build a mapping from expanded parameter index to (httpTypeName, fieldName, position).`
`628`	`630`	`/// </summary>`
`629`		`- private static Dictionary<int, (string HttpTypeName, string FieldName, short Position)> BuildExpandedFieldMap(`
	`631`	`+ private static Dictionary<int, (string HttpTypeName, string FieldName, short Position, string FieldType)> BuildExpandedFieldMap(`
`630`	`632`	`Dictionary<int, (string TypeName, string ParamName, string[] FieldNames, string[] FieldTypes)> expansions)`
`631`	`633`	`{`
`632`		`- var map = new Dictionary<int, (string, string, short)>();`
	`634`	`+ var map = new Dictionary<int, (string, string, short, string)>();`
`633`	`635`
`634`	`636`	`// Calculate cumulative shifts`
`635`	`637`	`var sortedExpansions = expansions.OrderBy(e => e.Key).ToList();`
`@@ -640,7 +642,7 @@ private static string ReplaceParamRef(string sql, string oldRef, string newRef)`
`640`	`642`	`int expandedStartIndex = origIndex + cumulativeShift;`
`641`	`643`	`for (int f = 0; f < expansion.FieldNames.Length; f++)`
`642`	`644`	`{`
`643`		`- map[expandedStartIndex + f] = (expansion.TypeName, expansion.FieldNames[f], (short)(f + 1));`
	`645`	`+ map[expandedStartIndex + f] = (expansion.TypeName, expansion.FieldNames[f], (short)(f + 1), expansion.FieldTypes[f]);`
`644`	`646`	`}`
`645`	`647`	`cumulativeShift += expansion.FieldNames.Length - 1;`
`646`	`648`	`}`