using Npgsql;

using NpgsqlRest.Defaults;

using System.Collections.Frozen;

using NpgsqlRest.HttpClientType;

using NpgsqlRest.UploadHandlers;

namespace NpgsqlRest;

using Metadata = (

List<NpgsqlRestMetadataEntry> entries,

FrozenDictionary<string, NpgsqlRestMetadataEntry> overloads,

bool hasStreamingEvents);

public class NpgsqlRestMetadataEntry

{

internal NpgsqlRestMetadataEntry(RoutineEndpoint endpoint, IRoutineSourceParameterFormatter formatter, string key)

{

Endpoint = endpoint;

Formatter = formatter;

Key = key;

}

public RoutineEndpoint Endpoint { get; }

public IRoutineSourceParameterFormatter Formatter { get; }

public string Key { get; }

}

public static class NpgsqlRestBuilder

{

public static IApplicationBuilder UseNpgsqlRest(this WebApplication builder, NpgsqlRestOptions options)

{

if (options.ConnectionString is null && options.DataSource is null && options.ServiceProviderMode == ServiceProviderObject.None)

{

throw new ArgumentException("ConnectionString and DataSource are null and ServiceProviderMode is set to None. You must specify connection with connection string, DataSource object or with ServiceProvider");

}

if (options.ConnectionString is not null && options.DataSource is not null && options.ServiceProviderMode == ServiceProviderObject.None)

{

throw new ArgumentException("Both ConnectionString and DataSource are provided. Please specify only one.");

}

Options = options;

var factory = builder.Services.GetRequiredService<ILoggerFactory>();

Logger = factory.CreateLogger(options.LoggerName ?? typeof(NpgsqlRestBuilder).Namespace ?? "NpgsqlRest");

RetryStrategy? defaultStrategy = null;

if (Options.CommandRetryOptions.Enabled is true && string.IsNullOrEmpty(Options.CommandRetryOptions.DefaultStrategy) is false)

{

if (Options.CommandRetryOptions.Strategies

.TryGetValue(Options.CommandRetryOptions.DefaultStrategy, out defaultStrategy) is false)

{

Logger?.LogWarning("Default retry strategy {defaultStrategy} not found in the list of strategies, command retry strategy will be ignored.",

Options.CommandRetryOptions.DefaultStrategy);

}

}

var (

entries,

overloads,

hasStreamingEvents

) = Build(builder, defaultStrategy);

if (entries.Count == 0)

{

return builder;

}

if (Options.HttpClientOptions.Enabled is true)

{

new HttpClientTypes(builder, defaultStrategy);

}

if (hasStreamingEvents is true)

{

builder.UseMiddleware<NpgsqlRestSseEventSource>();

}

foreach (var entry in entries)

{

var handler = new NpgsqlRestEndpoint(entry, overloads);

var endpoint = entry.Endpoint;

var methodStr = endpoint.Method.ToString();

var urlInfo = string.Concat(methodStr, " ", endpoint.Path);

var routeBuilder = builder.MapMethods(endpoint.Path, [methodStr], handler.InvokeAsync);

if (options.CommandTimeout is not null && endpoint.CommandTimeout is null)

{

endpoint.CommandTimeout = options.CommandTimeout;

}

if (endpoint.RateLimiterPolicy is not null || options.DefaultRateLimitingPolicy is not null)

{

var policy = endpoint.RateLimiterPolicy ?? options.DefaultRateLimitingPolicy!;

routeBuilder.RequireRateLimiting(policy);

Logger?.EndpointEnabledRateLimiterPolicy(urlInfo, policy);

}

if (options.RouteHandlerCreated is not null)

{

options.RouteHandlerCreated(routeBuilder, endpoint);

}

Logger?.EndpointCreated(urlInfo);

if (endpoint.SseEventsPath is not null)

{

if (endpoint.SseEventNoticeLevel is null)

{

endpoint.SseEventNoticeLevel = Options.DefaultSseEventNoticeLevel;

}

Logger?.EndpointSsePath($"{endpoint.Method} {endpoint.Path}", endpoint.SseEventsPath, endpoint.SseEventNoticeLevel);

}

}

return builder;

}

private const int MaxPathLength = 2048;

private static Metadata Build(IApplicationBuilder? builder, RetryStrategy? defaultStrategy)

{

// Pre-size dictionaries with reasonable capacity to reduce allocations

Dictionary<string, NpgsqlRestMetadataEntry> lookup = new(capacity: 128);

Dictionary<string, NpgsqlRestMetadataEntry> overloads = new(capacity: 16);

// Create default upload handlers from upload handler options

Options.UploadOptions.UploadHandlers ??= Options.UploadOptions.CreateUploadHandlers();

var hasLogin = false;

if (builder is not null)

{

foreach (var handler in Options.EndpointCreateHandlers)

{

handler.Setup(builder, Options);

}

}

Options.SourcesCreated(Options.RoutineSources);

var hasCachedRoutine = false;

CommentsMode optionsCommentsMode = Options.CommentsMode;

bool hasStreamingEvents = false;

foreach (var source in Options.RoutineSources)

{

if (source.CommentsMode.HasValue)

{

Options.CommentsMode = source.CommentsMode.Value;

}

else

{

Options.CommentsMode = optionsCommentsMode;

}

foreach (var (routine, formatter) in source.Read(builder?.ApplicationServices, defaultStrategy))

{

RoutineEndpoint? endpoint = DefaultEndpoint.Create(routine);

if (endpoint is null)

{

continue;

}

if (Options.EndpointCreated is not null)

{

Options.EndpointCreated(endpoint);

if (endpoint is null)

{

continue;

}

}

if (defaultStrategy is not null && endpoint.RetryStrategy is null)

{

endpoint.RetryStrategy = defaultStrategy;

}

if (endpoint.Path.Length == 0)

{

throw new ArgumentException($"URL path for URL {endpoint.Path}, routine {routine.Name} is empty.");

}

if (endpoint.Path.Length > MaxPathLength)

{

throw new ArgumentException($"URL path for URL {endpoint.Path}, routine {routine.Name} length exceeds {MaxPathLength} characters.");

}

// Cache method string to avoid repeated ToString() calls

var method = endpoint.Method.ToString();

if (endpoint.HasBodyParameter is true && endpoint.RequestParamType == RequestParamType.BodyJson)

{

endpoint.RequestParamType = RequestParamType.QueryString;

Logger?.EndpointTypeChangedBodyParam(method, endpoint.Path, endpoint.BodyParameterName ?? "");

}

if (endpoint.Upload is true)

{

if (endpoint.Method != Method.POST)

{

Logger?.EndpointMethodChangedUpload(method, endpoint.Path, Method.POST.ToString());

endpoint.Method = Method.POST;

method = "POST"; // Update cached string

}

if (endpoint.RequestParamType == RequestParamType.BodyJson)

{

endpoint.RequestParamType = RequestParamType.QueryString;

Logger?.EndpointTypeChangedUpload(method, endpoint.Path);

}

}

var key = string.Concat(method, endpoint.Path);

var value = new NpgsqlRestMetadataEntry(endpoint, formatter, key);

if (lookup.TryGetValue(key, out var existing))

{

overloads[string.Concat(key, existing.Endpoint.Routine.ParamCount)] = existing;

}

lookup[key] = value;

// Create cache invalidation endpoint if configured and this endpoint is cached

if (endpoint.Cached is true && Options.CacheOptions.InvalidateCacheSuffix is not null)

{

var invalidatePath = endpoint.Path.EndsWith('/')

? string.Concat(endpoint.Path, Options.CacheOptions.InvalidateCacheSuffix)

: string.Concat(endpoint.Path, "/", Options.CacheOptions.InvalidateCacheSuffix);

var invalidateEndpoint = new RoutineEndpoint(

routine: routine,

path: invalidatePath,

method: endpoint.Method,

requestParamType: endpoint.RequestParamType,

requiresAuthorization: endpoint.RequiresAuthorization,

responseContentType: "application/json",

responseHeaders: endpoint.ResponseHeaders,

requestHeadersMode: endpoint.RequestHeadersMode,

requestHeadersParameterName: endpoint.RequestHeadersParameterName,

bodyParameterName: endpoint.BodyParameterName,

textResponseNullHandling: endpoint.TextResponseNullHandling,

queryStringNullHandling: endpoint.QueryStringNullHandling,

authorizeRoles: endpoint.AuthorizeRoles,

cached: true,

cachedParams: endpoint.CachedParams?.ToArray(),

connectionName: endpoint.ConnectionName

)

{

InvalidateCache = true,

BasicAuth = endpoint.BasicAuth,

RateLimiterPolicy = endpoint.RateLimiterPolicy

};

var invalidateKey = string.Concat(method, invalidatePath);

var invalidateValue = new NpgsqlRestMetadataEntry(invalidateEndpoint, formatter, invalidateKey);

lookup[invalidateKey] = invalidateValue;

// Notify endpoint create handlers about the invalidation endpoint

if (builder is not null)

{

foreach (var handler in Options.EndpointCreateHandlers)

{

handler.Handle(invalidateEndpoint);

}

}

}

if (routine.ColumnsTypeDescriptor is not null && routine.ColumnsTypeDescriptor.Length == 1)

{

bool[] unknownResultTypeList = new bool[routine.ColumnsTypeDescriptor.Length];

bool hasKnownType = false;

for (var i = 0; i < routine.ColumnsTypeDescriptor.Length; i++)

{

unknownResultTypeList[i] = routine.ColumnsTypeDescriptor[i].ShouldRenderAsUnknownType;

if (routine.ColumnsTypeDescriptor[i].ShouldRenderAsUnknownType is false)

{

hasKnownType = true;

}

}

if (hasKnownType)

{

routine.UnknownResultTypeList = unknownResultTypeList;

}

}

if (builder is not null)

{

foreach (var handler in Options.EndpointCreateHandlers)

{

handler.Handle(endpoint);

}

}

if (endpoint.SseEventsPath is not null)

{

if (endpoint.SseEventsPath.StartsWith(endpoint.Path) is false)

{

// Optimize path concatenation

var basePath = endpoint.Path.EndsWith('/') ? endpoint.Path[..^1] : endpoint.Path;

var streamPath = endpoint.SseEventsPath.StartsWith('/')

? endpoint.SseEventsPath[1..]

: endpoint.SseEventsPath;

endpoint.SseEventsPath = string.Concat(basePath, "/", streamPath);

}

NpgsqlRestSseEventSource.Paths.Add(endpoint.SseEventsPath);

hasStreamingEvents = true;

}

if (endpoint.Login is true)

{

hasLogin = true;

if (routine.IsVoid is true || routine.ReturnsUnnamedSet is true)

{

throw new ArgumentException($"{routine.Type.ToString().ToLowerInvariant()} {routine.Schema}.{routine.Name} is marked as login and it can't be void or returning unnamed data sets.");

}

}

if (endpoint.Cached is true && hasCachedRoutine is false)

{

hasCachedRoutine = true;

}

}

}

if (hasLogin is true)

{

if (Options.AuthenticationOptions.DefaultAuthenticationType is null)

{

string db = new NpgsqlConnectionStringBuilder(Options.ConnectionString).Database ?? "NpgsqlRest";

Options.AuthenticationOptions.DefaultAuthenticationType = db;

Logger?.SetDefaultAuthenticationType(db);

}

}

if (hasCachedRoutine is true && Options.CacheOptions.DefaultRoutineCache is RoutineCache)

{

RoutineCache.Start(Options);

if (builder is WebApplication app)

{

app.Lifetime.ApplicationStopping.Register(() =>

{

RoutineCache.Shutdown();

});

}

}

if (Options.UploadOptions.UploadHandlers is not null && Options.UploadOptions.UploadHandlers.ContainsKey(Options.UploadOptions.DefaultUploadHandler) is false)

{

Logger?.LogError("Default upload handler {defaultUploadHandler} not found in the list of upload handlers. Using upload endpoint with default handler may cause an error.",

Options.UploadOptions.DefaultUploadHandler);

}

// Avoid multiple enumerations by creating the list once

var entries = new List<NpgsqlRestMetadataEntry>(lookup.Values);

// Create array once if needed by callbacks or handlers

RoutineEndpoint[]? endpointsArray = null;

bool arrayPopulated = false;

if (Options.EndpointsCreated is not null)

{

endpointsArray = new RoutineEndpoint[entries.Count];

for (int i = 0; i < entries.Count; i++)

{

endpointsArray[i] = entries[i].Endpoint;

}

arrayPopulated = true;

Options.EndpointsCreated(endpointsArray);

}

if (builder is not null)

{

foreach (var handler in Options.EndpointCreateHandlers)

{

if (endpointsArray is null)

{

endpointsArray = new RoutineEndpoint[entries.Count];

}

if (!arrayPopulated)

{

for (int i = 0; i < entries.Count; i++)

{

endpointsArray[i] = entries[i].Endpoint;

}

arrayPopulated = true;

}

handler.Cleanup(endpointsArray);

handler.Cleanup();

}

}

return (entries, overloads.ToFrozenDictionary(), hasStreamingEvents);

}

}