using System.Buffers;

using System.Collections.Concurrent;

using System.Collections.Frozen;

using System.Data;

using System.IO.Pipelines;

using System.Net;

using System.Text;

using System.Text.Json;

using System.Text.Json.Nodes;

using Microsoft.AspNetCore.DataProtection;

using Microsoft.AspNetCore.Http.Extensions;

using Microsoft.Extensions.Primitives;

using Npgsql;

using NpgsqlRest.Auth;

using NpgsqlRest.HttpClientType;

using NpgsqlRest.UploadHandlers;

using NpgsqlRest.UploadHandlers.Handlers;

using static System.Net.Mime.MediaTypeNames;

using static NpgsqlRest.ParameterParser;

namespace NpgsqlRest;

public partial class NpgsqlRestEndpoint(

NpgsqlRestMetadataEntry entry,

FrozenDictionary<string, NpgsqlRestMetadataEntry> overloads)

{

// Signals a non-value exit from inside a cache GetOrCreateAsync factory, so the result is never

// cached and concurrent waiters observe the same outcome. NoRow → the command returned no row

// (caller maps to 500); ResponseAlreadyWritten → PrepareCommand short-circuited via

// CommandCallbackAsync and already wrote the lead caller's response (caller just returns).

private enum CacheFactoryAbortReason { NoRow, ResponseAlreadyWritten }

private sealed class CacheFactoryAbortException(CacheFactoryAbortReason reason) : Exception

{

public CacheFactoryAbortReason Reason { get; } = reason;

}

// Per-cache-key execution gates for the streaming records/sets path. That path cannot use the

// value-shaped GetOrCreateAsync factory model because it streams rows to the client and disables

// caching mid-stream once a response exceeds MaxCacheableRows. The gate serializes concurrent

// requests for the same key: the lead executes and (when within limits) populates the cache, so

// the rest get a cache hit instead of re-executing; over-limit responses simply run one-at-a-time,

// which still caps concurrent DB executions per key at one.

//

// The outer map is keyed by the cache instance itself (reference identity, so distinct cache

// profiles never share a gate even if they reuse a key string) and an inner map holds one gate per

// key. SemaphoreSlim instances are never disposed — they hold no OS handle unless AvailableWaitHandle

// is touched, and their count is bounded by (cache instances × distinct keys), bounded by the schema.

private static readonly ConcurrentDictionary<IRoutineCache, ConcurrentDictionary<string, SemaphoreSlim>> _recordCacheGates

= new(ReferenceEqualityComparer.Instance);

private static SemaphoreSlim GetRecordCacheGate(IRoutineCache cache, string key) =>

_recordCacheGates

.GetOrAdd(cache, static _ => new(StringComparer.Ordinal))

.GetOrAdd(key, static _ => new SemaphoreSlim(1, 1));

public async Task InvokeAsync(HttpContext context, IServiceProvider serviceProvider, CancellationToken cancellationToken = default)

{

Routine routine = entry.Endpoint.Routine;

RoutineEndpoint endpoint = entry.Endpoint;

IRoutineSourceParameterFormatter formatter = entry.Formatter;

string? headers = null;

if (endpoint.RequestHeadersMode == RequestHeadersMode.Context)

{

SearializeHeader(Options, context, ref headers);

}

NpgsqlConnection? connection = null;

NpgsqlTransaction? transaction = null;

string? commandText = null;

bool shouldDispose = true;

bool shouldCommit = true;

// Held (when non-null) for the streaming records/sets cache path; released in the outer finally.

SemaphoreSlim? recordCacheGate = null;

IUploadHandler? uploadHandler = null;

var shouldLog = Options.LogCommands && Logger != null;

// Pooled StringBuilders - declared at top level to enable pooling in finally block

StringBuilder? cmdLog = null;

StringBuilder? cacheKeys = null;

StringBuilder? commandTextBuilder = null;

StringBuilder? rowBuilder = null;

StringBuilder? compositeFieldBuffer = null;

// Multi-command per-iteration builders — set to null after each iteration's Return,

// so outer finally won't double-return; if iteration throws, finally still cleans up.

StringBuilder? mcRowBuilder = null;

StringBuilder? mcCompositeBuffer = null;

// proxy_out: capture function output into a buffer instead of writing to the real response

MemoryStream? proxyOutBuffer = null;

Stream? proxyOutOriginalBody = null;

if (endpoint.IsProxyOut && Options.ProxyOptions.Enabled)

{

proxyOutBuffer = new MemoryStream();

proxyOutOriginalBody = context.Response.Body;

context.Response.Body = proxyOutBuffer;

}

var writer = proxyOutBuffer is not null

? PipeWriter.Create(context.Response.Body, new StreamPipeWriterOptions(leaveOpen: true))

: PipeWriter.Create(context.Response.Body);

try

{

if (endpoint.ConnectionName is not null)

{

// First check if there's a data source for this connection name (for multi-host support)

if (Options.DataSources?.TryGetValue(endpoint.ConnectionName, out var namedDataSource) is true)

{

connection = namedDataSource.CreateConnection();

}

else if (Options.ConnectionStrings?.TryGetValue(endpoint.ConnectionName, out var connectionString) is true)

{

connection = new(connectionString);

}

else

{

await ReturnErrorAsync($"Connection name {endpoint.ConnectionName} could not be found in options DataSources or ConnectionStrings dictionaries.", true, context, cancellationToken);

return;

}

}

else if (Options.ServiceProviderMode != ServiceProviderObject.None)

{

if (serviceProvider is null)

{

await ReturnErrorAsync($"ServiceProvider must be provided when ServiceProviderMode is set to {Options.ServiceProviderMode}.", true, context, cancellationToken);

return;

}

if (Options.ServiceProviderMode == ServiceProviderObject.NpgsqlDataSource)

{

connection = serviceProvider.GetRequiredService<NpgsqlDataSource>().CreateConnection();

await connection.OpenRetryAsync(Options.ConnectionRetryOptions, cancellationToken);

}

else if (Options.ServiceProviderMode == ServiceProviderObject.NpgsqlConnection)

{

shouldDispose = false;

connection = serviceProvider.GetRequiredService<NpgsqlConnection>();

}

}

else

{

if (Options.DataSource is not null)

{

connection = Options.DataSource.CreateConnection();

}

else

{

connection = new(Options.ConnectionString);

}

}

if (connection is null)

{

await ReturnErrorAsync("Connection did not initialize!", log: true, context, cancellationToken);

return;

}

// Three reasons to attach a notice handler:

// 1. LogConnectionNoticeEvents — log every notice regardless of SSE wiring.

// 2. Endpoint publishes to broadcaster — forward matching notices to subscribers.

// 3. WarnUnboundSseNotices — and the project actually uses SSE somewhere; warn when a

// RAISE in a non-publishing endpoint matches the SSE forwarding level (a likely

// missing @sse_publish annotation).

bool noticeWarnEnabled = Options.WarnUnboundSseNotices

&& Logger != null

&& NpgsqlRestSseEventSource.HasAnySseEndpoints

&& endpoint.SsePublishEnabled is false;

if ((Options.LogConnectionNoticeEvents && Logger != null)

|| endpoint.SsePublishEnabled

|| noticeWarnEnabled)

{

var currentEndpointCaptured = endpoint;

connection.Notice += (sender, args) =>

{

if (Options.LogConnectionNoticeEvents && Logger != null)

{

NpgsqlRestLogger.LogConnectionNotice(args.Notice, Options.LogConnectionNoticeEventsMode);

}

if (currentEndpointCaptured.SsePublishEnabled

&& currentEndpointCaptured.SseEventNoticeLevel is not null

&& string.Equals(args.Notice.Severity, currentEndpointCaptured.SseEventNoticeLevel.ToString(), StringComparison.OrdinalIgnoreCase))

{

NpgsqlRestSseEventSource

.Broadcaster

.Broadcast(new SseEvent(args.Notice, currentEndpointCaptured, context.Request.Headers[Options.ExecutionIdHeaderName].FirstOrDefault()));

}

else if (noticeWarnEnabled

&& string.Equals(args.Notice.Severity, Options.DefaultSseEventNoticeLevel.ToString(), StringComparison.OrdinalIgnoreCase)

&& SseUnboundWarner.TryMarkWarned(currentEndpointCaptured.Path))

{

Logger!.UnboundSseRaise(args.Notice.Severity, currentEndpointCaptured.Path);

}

};

}

if (Options.AuthenticationOptions.BasicAuth.Enabled is true || endpoint.BasicAuth?.Enabled is true)

{

if (Options.AuthenticationOptions.BasicAuth.ChallengeCommand is not null || endpoint.BasicAuth?.ChallengeCommand is not null)

{

await OpenConnectionAsync(connection, context, endpoint, cancellationToken);

}

await BasicAuthHandler.HandleAsync(context, endpoint, connection, cancellationToken);

if (context.Response.HasStarted is true)

{

return;

}

}

await using var command = NpgsqlRestCommand.Create(connection);

if (shouldLog)

{

cmdLog = StringBuilderPool.Rent();

cmdLog.Append("-- ");

cmdLog.Append(context.Request.Method);

cmdLog.Append(' ');

if (Options.AuthenticationOptions.ObfuscateAuthParameterLogValues && endpoint.IsAuth)

{

cmdLog.Append(context.Request.Scheme);

cmdLog.Append("://");

cmdLog.Append(context.Request.Host);

cmdLog.Append(context.Request.Path);

}

else

{

cmdLog.Append(context.Request.GetDisplayUrl());

}

cmdLog.Append(Environment.NewLine);

}

if (formatter.IsFormattable is false)

{

// Use pooled StringBuilder for non-formattable commands to avoid string.Concat allocations

commandTextBuilder = StringBuilderPool.Rent(routine.Expression.Length + routine.ParamCount * 16);

commandTextBuilder.Append(routine.Expression);

}

// paramsList

bool hasNulls = false;

int paramIndex = 0;

JsonObject? jsonObj = null;

Dictionary<string, JsonNode?>? bodyDict = null;

string? body = null;

// Use IQueryCollection directly to avoid ToDictionary() allocation

IQueryCollection? queryCollection = null;

// Skip local upload handling if proxy will forward the upload content

var skipUploadForProxy = endpoint.Upload is true &&

endpoint.IsProxy &&

Options.ProxyOptions.Enabled &&

Options.ProxyOptions.ForwardUploadContent;

uploadHandler = (endpoint.Upload is true && !skipUploadForProxy) ? endpoint.CreateUploadHandler() : null;

int uploadMetaParamIndex = -1;

Dictionary<string, object?>? claimsDict = null;

List<string> customHttpTypes = Options.HttpClientOptions.Enabled ? new(routine.Parameters.Length) : null!;

if (endpoint.Cached is true)

{

var prefixLen = endpoint.CacheKeyPrefix?.Length ?? 0;

cacheKeys = StringBuilderPool.Rent(routine.Expression.Length + prefixLen + (endpoint.CachedParams?.Count ?? 0) * 32);

if (endpoint.CacheKeyPrefix is not null)

{

cacheKeys.Append(endpoint.CacheKeyPrefix);

cacheKeys.Append(NpgsqlRestParameter.GetCacheKeySeparator());

}

cacheKeys.Append(routine.Expression);

}

if (endpoint.RequestParamType == RequestParamType.QueryString)

{

queryCollection = context.Request.Query;

}

if (endpoint.HasBodyParameter || endpoint.RequestParamType == RequestParamType.BodyJson)

{

context.Request.EnableBuffering();

context.Request.Body.Position = 0;

using (var reader = new StreamReader(context.Request.Body, Encoding.UTF8, detectEncodingFromByteOrderMarks: false, leaveOpen: true))

{

body = await reader.ReadToEndAsync(cancellationToken);

}

if (endpoint.RequestParamType == RequestParamType.BodyJson)

{

JsonNode? node = null;

try

{

node = JsonNode.Parse(string.IsNullOrWhiteSpace(body) ? "{}" : body);

}

catch (JsonException e)

{

Logger?.CouldNotParseJson(body, context.Request.Path, e.Message);

node = null;

}

if (node is not null)

{

try

{

jsonObj = node?.AsObject();

bodyDict = jsonObj?.ToDictionary();

}

catch (Exception e)

{

Logger?.CouldNotParseJson(body, context.Request.Path, e.Message);

bodyDict = null;

}

}

}

}

// start query string parameters

if (endpoint.RequestParamType == RequestParamType.QueryString)

{

// Early-return guard: queryCollection is non-null for the rest of this block (later

// dereferences use `!` where the compiler's flow analysis loses the narrowing).

if (queryCollection is null)

{

shouldCommit = false;

uploadHandler?.OnError(connection, context, null);

context.Response.StatusCode = StatusCodes.Status404NotFound;

await context.Response.CompleteAsync();

return;

}

// Account for path parameters when counting query string parameters

var pathParamCount = endpoint.PathParameters?.Length ?? 0;

if (queryCollection.Count + pathParamCount != routine.ParamCount && overloads.Count > 0)

{

if (overloads.TryGetValue(string.Concat(entry.Key, queryCollection.Count + pathParamCount), out var overload))

{

routine = overload.Endpoint.Routine;

endpoint = overload.Endpoint;

formatter = overload.Formatter;

if (formatter.IsFormattable is false)

{

// Reinitialize commandTextBuilder for the new routine

commandTextBuilder?.Clear();

if (commandTextBuilder is null)

{

commandTextBuilder = StringBuilderPool.Rent(routine.Expression.Length + routine.ParamCount * 16);

}

commandTextBuilder.Append(routine.Expression);

}

}

}

for (int i = 0; i < routine.Parameters.Length; i++)

{

var parameter = routine.Parameters[i].NpgsqlRestParameterMemberwiseClone();

// Resolved parameter: skip HTTP filling, set to DBNull.Value placeholder.

// The actual value will be resolved via SQL expression after the parameter loop.

if (endpoint.ResolvedParameterExpressions is not null &&

(endpoint.ResolvedParameterExpressions.ContainsKey(parameter.ActualName) ||

endpoint.ResolvedParameterExpressions.ContainsKey(parameter.ConvertedName)))

{

parameter.Value = DBNull.Value;

if (Options.HttpClientOptions.Enabled)

{

if (parameter.TypeDescriptor.CustomType is not null)

{

if (HttpClientTypes.Definitions.ContainsKey(parameter.TypeDescriptor.CustomType))

{

customHttpTypes.Add(parameter.TypeDescriptor.CustomType);

}

}

}

if (!parameter.IsVirtual) command.Parameters.Add(parameter);

hasNulls = true;

if (formatter.IsFormattable is false)

{

if (formatter.RefContext)

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex, context));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

else

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex));

}

}

paramIndex++;

if (shouldLog && Options.LogCommandParameters)

{

cmdLog!.Append("-- $").Append(paramIndex).Append(' ')

.Append(parameter.TypeDescriptor.OriginalType)

.Append(" = (resolved)").AppendLine();

}

continue;

}

if (parameter.HashOf is not null)

{

var hashValueQueryCollection = queryCollection!.TryGetValue(parameter.HashOf.ConvertedName, out var hashQsValue) ? hashQsValue.ToString() : null;

if (string.IsNullOrEmpty(hashValueQueryCollection) is true)

{

parameter.Value = DBNull.Value;

}

else

{

parameter.Value = Options.AuthenticationOptions.PasswordHasher?.HashPassword(hashValueQueryCollection) as object ?? DBNull.Value;

}

}

if (endpoint.UseUserParameters is true)

{

if (parameter.IsFromUserClaims is true && claimsDict is null)

{

claimsDict = context.User.BuildClaimsDictionary(Options.AuthenticationOptions);

}

if (parameter.IsIpAddress is true)

{

parameter.Value = context.Request.GetClientIpAddressDbParam();

}

else if (context.User?.Identity?.IsAuthenticated is true && Options.AuthenticationOptions.ParameterNameClaimsMapping.TryGetValue(parameter.ActualName, out var claimType))

{

// Claim auto-bind always wins (security routines depend on it). If the

// request also supplied a value, it would otherwise be silently dropped —

// surface that as a WARN so a parameter naming collision is visible.

if (queryCollection is not null

&& (queryCollection.ContainsKey(parameter.ConvertedName) || queryCollection.ContainsKey(parameter.ActualName)))

{

Logger?.ClaimMappedParamReceivedRequestValue(

endpoint.Path, parameter.ActualName, "query", claimType);

}

parameter.Value = claimsDict!.GetClaimDbParam(claimType);

}

else if (context.User?.Identity?.IsAuthenticated is true && parameter.IsUserClaims is true)

{

parameter.Value = claimsDict?.GetUserClaimsDbParam() ?? DBNull.Value;

}

}

if (parameter.IsUploadMetadata is true)

{

//uploadMetaParamIndex = i;

uploadMetaParamIndex = command.Parameters.Count; // the last one added

parameter.Value = DBNull.Value;

}

// body parameter

if (parameter.Value is null && endpoint.IsBodyParameter(parameter))

{

if (body is null)

{

parameter.ParamType = ParamType.BodyParam;

parameter.Value = DBNull.Value;

hasNulls = true;

if (Options.ValidateParameters is not null)

{

Options.ValidateParameters(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (Options.ValidateParametersAsync is not null)

{

await Options.ValidateParametersAsync(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (endpoint.Cached is true && endpoint.CachedParams is not null)

{

if (endpoint.CachedParams.Contains(parameter.ConvertedName) || endpoint.CachedParams.Contains(parameter.ActualName))

{

cacheKeys?.Append(NpgsqlRestParameter.GetCacheKeySeparator());

cacheKeys?.Append(parameter.GetCacheStringValue());

}

}

if (Options.HttpClientOptions.Enabled)

{

if (parameter.TypeDescriptor.CustomType is not null)

{

if (HttpClientTypes.Definitions.ContainsKey(parameter.TypeDescriptor.CustomType))

{

customHttpTypes.Add(parameter.TypeDescriptor.CustomType);

}

}

}

if (!parameter.IsVirtual) command.Parameters.Add(parameter);

if (hasNulls is false && parameter.Value == DBNull.Value)

{

hasNulls = true;

}

if (formatter.IsFormattable is false)

{

if (formatter.RefContext)

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex, context));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

else

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex));

}

}

paramIndex++;

if (shouldLog && Options.LogCommandParameters)

{

var p = Options.AuthenticationOptions.ObfuscateAuthParameterLogValues && endpoint.IsAuth ?

"***" :

FormatParameterForLog(parameter);

cmdLog!.Append("-- $").Append(paramIndex).Append(' ')

.Append(parameter.TypeDescriptor.OriginalType)

.Append(" = ").AppendLine(p);

}

}

else

{

StringValues bodyStringValues = body;

if (TryParseParameter(parameter, ref bodyStringValues, endpoint.QueryStringNullHandling))

{

parameter.ParamType = ParamType.BodyParam;

hasNulls = false;

if (Options.ValidateParameters is not null)

{

Options.ValidateParameters(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (Options.ValidateParametersAsync is not null)

{

await Options.ValidateParametersAsync(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (endpoint.Cached is true && endpoint.CachedParams is not null)

{

if (endpoint.CachedParams.Contains(parameter.ConvertedName) || endpoint.CachedParams.Contains(parameter.ActualName))

{

cacheKeys?.Append(NpgsqlRestParameter.GetCacheKeySeparator());

cacheKeys?.Append(parameter.GetCacheStringValue());

}

}

if (Options.HttpClientOptions.Enabled)

{

if (parameter.TypeDescriptor.CustomType is not null)

{

if (HttpClientTypes.Definitions.ContainsKey(parameter.TypeDescriptor.CustomType))

{

customHttpTypes.Add(parameter.TypeDescriptor.CustomType);

}

}

}

if (!parameter.IsVirtual) command.Parameters.Add(parameter);

if (hasNulls is false && parameter.Value == DBNull.Value)

{

hasNulls = true;

}

if (formatter.IsFormattable is false)

{

if (formatter.RefContext)

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex, context));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

else

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex));

}

}

paramIndex++;

if (shouldLog && Options.LogCommandParameters)

{

var p = Options.AuthenticationOptions.ObfuscateAuthParameterLogValues && endpoint.IsAuth ?

"***" :

FormatParameterForLog(parameter);

cmdLog!.Append("-- $").Append(paramIndex).Append(' ')

.Append(parameter.TypeDescriptor.OriginalType)

.Append(" = ").AppendLine(p);

}

}

}

continue;

}

// header parameter

if (parameter.Value is null &&

endpoint.RequestHeadersMode == RequestHeadersMode.Parameter &&

parameter.TypeDescriptor.HasDefault is true &&

(

string.Equals(endpoint.RequestHeadersParameterName, parameter.ConvertedName, StringComparison.Ordinal) ||

string.Equals(endpoint.RequestHeadersParameterName, parameter.ActualName, StringComparison.Ordinal)

)

)

{

if (queryCollection!.ContainsKey(parameter.ConvertedName) is false)

{

if (headers is null)

{

SearializeHeader(Options, context, ref headers);

}

parameter.ParamType = ParamType.HeaderParam;

parameter.Value = headers;

if (Options.ValidateParameters is not null)

{

Options.ValidateParameters(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (Options.ValidateParametersAsync is not null)

{

await Options.ValidateParametersAsync(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (endpoint.Cached is true && endpoint.CachedParams is not null)

{

if (endpoint.CachedParams.Contains(parameter.ConvertedName) || endpoint.CachedParams.Contains(parameter.ActualName))

{

cacheKeys?.Append(NpgsqlRestParameter.GetCacheKeySeparator());

cacheKeys?.Append(parameter.GetCacheStringValue());

}

}

if (Options.HttpClientOptions.Enabled)

{

if (parameter.TypeDescriptor.CustomType is not null)

{

if (HttpClientTypes.Definitions.ContainsKey(parameter.TypeDescriptor.CustomType))

{

customHttpTypes.Add(parameter.TypeDescriptor.CustomType);

}

}

}

if (!parameter.IsVirtual) command.Parameters.Add(parameter);

if (hasNulls is false && parameter.Value == DBNull.Value)

{

hasNulls = true;

}

if (formatter.IsFormattable is false)

{

if (formatter.RefContext)

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex, context));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

else

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex));

}

}

paramIndex++;

if (shouldLog && Options.LogCommandParameters)

{

var p = Options.AuthenticationOptions.ObfuscateAuthParameterLogValues && endpoint.IsAuth ?

"***" :

FormatParameterForLog(parameter);

cmdLog!.Append("-- $").Append(paramIndex).Append(' ')

.Append(parameter.TypeDescriptor.OriginalType)

.Append(" = ").AppendLine(p);

}

continue;

}

}

// path parameter - extract from RouteValues

if (parameter.Value is null && endpoint.HasPathParameters)

{

// Use optimized O(1) lookup via HashSet

string? matchedPathParam = endpoint.FindMatchingPathParameter(parameter.ConvertedName, parameter.ActualName);

// Try to get route value using the path parameter name from the template

if (matchedPathParam is not null && context.Request.RouteValues.TryGetValue(matchedPathParam, out var routeValue))

{

StringValues pathStringValues = routeValue?.ToString() ?? "";

if (TryParseParameter(parameter, ref pathStringValues, endpoint.QueryStringNullHandling))

{

parameter.ParamType = ParamType.PathParam;

parameter.QueryStringValues = pathStringValues;

if (Options.ValidateParameters is not null)

{

Options.ValidateParameters(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (Options.ValidateParametersAsync is not null)

{

await Options.ValidateParametersAsync(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (endpoint.Cached is true && endpoint.CachedParams is not null)

{

if (endpoint.CachedParams.Contains(parameter.ConvertedName) || endpoint.CachedParams.Contains(parameter.ActualName))

{

cacheKeys?.Append(NpgsqlRestParameter.GetCacheKeySeparator());

cacheKeys?.Append(parameter.GetCacheStringValue());

}

}

if (Options.HttpClientOptions.Enabled)

{

if (parameter.TypeDescriptor.CustomType is not null)

{

if (HttpClientTypes.Definitions.ContainsKey(parameter.TypeDescriptor.CustomType))

{

customHttpTypes.Add(parameter.TypeDescriptor.CustomType);

}

}

}

if (!parameter.IsVirtual) command.Parameters.Add(parameter);

if (hasNulls is false && parameter.Value == DBNull.Value)

{

hasNulls = true;

}

if (formatter.IsFormattable is false)

{

if (formatter.RefContext)

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex, context));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

else

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex));

}

}

paramIndex++;

if (shouldLog && Options.LogCommandParameters)

{

var p = Options.AuthenticationOptions.ObfuscateAuthParameterLogValues && endpoint.IsAuth ?

"***" :

FormatParameterForLog(parameter);

cmdLog!.Append("-- $").Append(paramIndex).Append(' ')

.Append(parameter.TypeDescriptor.OriginalType)

.Append(" = ").AppendLine(p);

}

continue;

}

}

}

if (queryCollection!.TryGetValue(parameter.ConvertedName, out var qsValue) is false)

{

if (parameter.Value is null)

{

if (Options.ValidateParameters is not null)

{

Options.ValidateParameters(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (Options.ValidateParametersAsync is not null)

{

await Options.ValidateParametersAsync(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (parameter.Value is null)

{

if (parameter.TypeDescriptor.CustomType is not null)

{

parameter.Value = DBNull.Value;

}

else if (IsProxyResponseParameter(endpoint, parameter))

{

// Proxy response parameter - set placeholder value and fall through to add it

parameter.Value = DBNull.Value;

parameter.ParamType = ParamType.QueryString;

}

else if (parameter.TypeDescriptor.HasDefault is false)

{

shouldCommit = false;

uploadHandler?.OnError(connection, context, null);

context.Response.StatusCode = StatusCodes.Status404NotFound;

await context.Response.CompleteAsync();

return;

}

else if (parameter.DefaultValue is not null)

{

// Explicit default value (SQL file annotation) — bind it

parameter.Value = parameter.DefaultValue;

parameter.ParamType = ParamType.QueryString;

}

else

{

continue;

}

}

}

}

if (parameter.Value is null && TryParseParameter(parameter, ref qsValue, endpoint.QueryStringNullHandling) is false)

{

// Check if this is a proxy response parameter - it will be filled in later

if (IsProxyResponseParameter(endpoint, parameter))

{

parameter.Value = DBNull.Value;

parameter.ParamType = ParamType.QueryString;

// Don't skip - fall through to add the parameter

}

else if (parameter.TypeDescriptor.HasDefault is false)

{

shouldCommit = false;

uploadHandler?.OnError(connection, context, null);

context.Response.StatusCode = StatusCodes.Status404NotFound;

await context.Response.CompleteAsync();

return;

}

else if (parameter.DefaultValue is not null)

{

parameter.Value = parameter.DefaultValue;

parameter.ParamType = ParamType.QueryString;

}

else

{

continue;

}

}

parameter.ParamType = ParamType.QueryString;

parameter.QueryStringValues = qsValue;

if (Options.ValidateParameters is not null)

{

Options.ValidateParameters(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (Options.ValidateParametersAsync is not null)

{

await Options.ValidateParametersAsync(new ParameterValidationValues(

context,

routine,

parameter));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

if (endpoint.Cached is true && endpoint.CachedParams is not null)

{

if (endpoint.CachedParams.Contains(parameter.ConvertedName) || endpoint.CachedParams.Contains(parameter.ActualName))

{

cacheKeys?.Append(NpgsqlRestParameter.GetCacheKeySeparator());

cacheKeys?.Append(parameter.GetCacheStringValue());

}

}

if (Options.HttpClientOptions.Enabled)

{

if (parameter.TypeDescriptor.CustomType is not null)

{

if (HttpClientTypes.Definitions.ContainsKey(parameter.TypeDescriptor.CustomType))

{

customHttpTypes.Add(parameter.TypeDescriptor.CustomType);

}

}

}

command.Parameters.Add(parameter);

if (hasNulls is false && parameter.Value == DBNull.Value)

{

hasNulls = true;

}

if (formatter.IsFormattable is false)

{

if (formatter.RefContext)

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex, context));

if (context.Response.HasStarted || context.Response.StatusCode != (int)HttpStatusCode.OK)

{

return;

}

}

else

{

commandTextBuilder!.Append(formatter.AppendCommandParameter(parameter, paramIndex));

}

}

paramIndex++;

if (shouldLog && Options.LogCommandParameters)

{

var p = Options.AuthenticationOptions.ObfuscateAuthParameterLogValues && endpoint.IsAuth ?

"***" :

FormatParameterForLog(parameter);

cmdLog!.Append("-- $").Append(paramIndex).Append(' ')

.Append(parameter.TypeDescriptor.OriginalType)

.Append(" = ").AppendLine(p);

}

}

// Skip query string validation for passthrough proxy endpoints - query will be forwarded as-is

if (!(endpoint.IsProxy && Options.ProxyOptions.Enabled && !endpoint.HasProxyResponseParameters))

{

foreach (var queryKey in queryCollection!.Keys)

{

if (routine.ParamsHash.Contains(queryKey) is false)

{

shouldCommit = false;

uploadHandler?.OnError(connection, context, null);

context.Response.StatusCode = StatusCodes.Status404NotFound;

await context.Response.CompleteAsync();

return;

}

}

}

} // end of query string parameters

// start json body parameters

else if (endpoint.RequestParamType == RequestParamType.BodyJson)

{

// Early-return guard: bodyDict is non-null for the rest of this block (later

// dereferences use `!` where the compiler's flow analysis loses the narrowing).

if (bodyDict is null)

{

// Body was present but is not a parseable JSON object - this is a client error,

// not a routing miss (parse failures are logged above via CouldNotParseJson).

shouldCommit = false;

uploadHandler?.OnError(connection, context, null);

context.Response.StatusCode = StatusCodes.Status400BadRequest;

await context.Response.CompleteAsync();

return;

}

// Account for path parameters when counting body parameters

var pathParamCount = endpoint.PathParameters?.Length ?? 0;

var expectedBodyParamCount = routine.ParamCount - pathParamCount;