feat: implement PostGIS table discovery API (#57) (#88)

* feat: implement .NET Aspire orchestration with OpenTelemetry (#49)

- Add Honua.AppHost project for local development orchestration
- Configure PostgreSQL with PostGIS container (postgis/postgis:16-3.4)
- Configure Redis container with Redis Commander for debugging
- Add Honua.ServiceDefaults with shared OpenTelemetry configuration
- Implement traces (ASP.NET Core, HttpClient), metrics (ASP.NET Core, runtime, custom)
- Configure conditional OTLP export when OTEL_EXPORTER_OTLP_ENDPOINT is set
- Add service discovery and health checks
- Enable AOT compilation for production deployments
- Update Honua.Server to integrate with ServiceDefaults

Local development: dotnet run in src/Honua.AppHost starts full stack
Production build: dotnet publish with native AOT compilation (24MB binary)

* fix: resolve code style issues after merge

- Added copyright headers to ServiceDefaults and AppHost projects
- Removed unnecessary using statements via dotnet format
- All builds pass with 0 warnings, 0 errors
- All tests pass (104/104)
- AOT build successful (27MB binary)

* feat: implement PostGIS table discovery API (#57)

- Add GET /api/admin/connections/{id}/tables endpoint
- Implement PostgreSqlTableDiscoveryService for PostGIS table discovery
- Query geometry_columns and geography_columns system views
- Return table metadata including schema, name, geometry info, SRID, and columns
- Add comprehensive integration tests with AOT-compatible JSON serialization
- Include source-generated logging for performance
- Follow greenfield project patterns with feature-based organization

* fix: resolve AOT compilation errors in admin endpoints

- Remove RequiresUnreferencedCode and RequiresDynamicCode attributes
- Use explicit HttpContext parameter extraction instead of reflection-based binding
- Replace method parameter injection with manual route value extraction
- Ensures full AOT compatibility for minimal API endpoints

* fix: use explicit RequestDelegate for full AOT compatibility

- Replace MapGet with MapMethods using explicit RequestDelegate
- Add HandleGetConnectionTables method for proper AOT-compatible endpoint registration
- Eliminates all reflection-based parameter binding that caused AOT warnings
- Ensures native compilation compatibility with zero warnings

* fix: resolve admin endpoint routing and AOT compatibility issues

- Use endpoints.Map() with HttpMethodMetadata for full AOT compatibility
- Replace GetConnectionString() with IDatabaseConnectionProvider pattern
- Follow proven health endpoint pattern for route registration
- Write responses directly to HttpContext instead of returning IResult
- Routing now works correctly - admin endpoints are being hit successfully

* fix: resolve dependency inversion violation in AdminEndpoints

- Replace ILogger<ITableDiscoveryService> with ILogger<AdminEndpoints>
- Removes dependency from presentation layer on core service interfaces
- Maintains proper architectural separation per Clean Architecture principles

* fix: add proper test infrastructure for admin endpoints

- Move TestDatabaseConnectionProvider to TestKit for reusability
- Add IDatabaseConnectionProvider replacement in WebAppFixture
- Fix logger dependency inversion issue with ILoggerFactory approach
- Enables proper testing of database-dependent admin endpoints

* wip: continue fixing test infrastructure for admin endpoints

- Update WebAppFixture to properly handle PostgreSQL service registration
- Remove DefaultConnection dependency for test environment
- Add comprehensive test database connection setup
- Work in progress: still debugging 500 errors in tests

* fix: resolve all failing admin endpoint tests (#57)

- Fix 500 error by passing DbConnection directly to avoid password extraction
- Add DbConnection overload to ITableDiscoveryService interface
- Implement catch-all routing to handle empty connection ID case (400 response)
- Update PostgreSqlTableDiscoveryService with new connection overload
- All 4 admin endpoint integration tests now passing

Related to Issue #57: PostGIS table discovery API implementation

---------

Co-authored-by: Mike McDougall <[email protected]>

Author: mikemcdougall

src/Honua.Server/Features/Admin/AdminEndpoints.cs

@@ -0,0 +1,123 @@
+// Copyright (c) Honua. All rights reserved.
+// Licensed under the Elastic License 2.0. See LICENSE in the project root.
+
+using System.Text.Json;
+using Honua.Core.Features.Infrastructure.Abstractions;
+using Honua.Server.Features.Admin.Models;
+using Honua.Server.Features.Admin.Services;
+
+namespace Honua.Server.Features.Admin;
+
+/// <summary>
+/// Admin endpoints for table discovery and connection management
+/// </summary>
+public static class AdminEndpoints
+{
+    /// <summary>
+    /// Configure admin endpoints using AOT-compatible routing
+    /// </summary>
+    public static void MapAdminEndpoints(this IEndpointRouteBuilder endpoints)
+    {
+        // Use Map with explicit HTTP method metadata to avoid MapGet reflection
+        endpoints.Map("/api/admin/connections/{id}/tables", HandleGetConnectionTables)
+            .WithDisplayName("Get Connection Tables")
+            .WithTags("Admin")
+            .WithMetadata(new HttpMethodMetadata(new[] { HttpMethods.Get }));
+
+        // Use catch-all parameter to handle edge cases like empty segments
+        endpoints.Map("/api/admin/connections/{*path}", HandleGetConnectionTablesWithCatchAll)
+            .WithDisplayName("Get Connection Tables - Catch All")
+            .WithTags("Admin")
+            .WithMetadata(new HttpMethodMetadata(new[] { HttpMethods.Get }));
+    }
+
+    /// <summary>
+    /// Handle catch-all cases for connections endpoints
+    /// </summary>
+    private static async Task HandleGetConnectionTablesWithCatchAll(HttpContext context)
+    {
+        var path = context.GetRouteValue("path")?.ToString() ?? "";
+
+        // Check if this is the tables endpoint with empty or invalid connection ID
+        if (path.Equals("/tables", StringComparison.OrdinalIgnoreCase) ||
+            path.Equals("tables", StringComparison.OrdinalIgnoreCase))
+        {
+            context.Response.StatusCode = 400; // Bad Request
+            context.Response.ContentType = "text/plain; charset=utf-8";
+            await context.Response.WriteAsync("Connection ID is required");
+            return;
+        }
+
+        // For other paths, return 404
+        context.Response.StatusCode = 404;
+        context.Response.ContentType = "application/problem+json; charset=utf-8";
+        await context.Response.WriteAsync("""{"title":"Not Found","status":404,"detail":"The requested resource was not found."}""");
+    }
+
+    /// <summary>
+    /// Handle admin connection tables request
+    /// Implements the API from Issue #57: GET /api/admin/connections/{id}/tables
+    /// </summary>
+    private static async Task HandleGetConnectionTables(HttpContext context)
+    {
+        // Ensure only GET requests
+        if (!HttpMethods.IsGet(context.Request.Method))
+        {
+            context.Response.StatusCode = 405; // Method Not Allowed
+            context.Response.ContentType = "application/problem+json; charset=utf-8";
+            await context.Response.WriteAsync($$"""{"title":"Method Not Allowed","status":405,"detail":"Only GET requests are allowed for this endpoint"}""");
+            return;
+        }
+
+        // Extract connection ID from route
+        var id = context.GetRouteValue("id")?.ToString();
+
+        // Validate input
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            context.Response.StatusCode = 400; // Bad Request
+            context.Response.ContentType = "text/plain; charset=utf-8";
+            await context.Response.WriteAsync("Connection ID is required");
+            return;
+        }
+
+        var logger = context.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger("Admin.TableDiscovery");
+
+        try
+        {
+            // For this initial implementation, use the default database connection for all connection IDs
+            // In a full implementation, this would look up the connection by ID and validate it exists
+            var connectionProvider = context.RequestServices.GetRequiredService<IDatabaseConnectionProvider>();
+            var tableDiscoveryService = context.RequestServices.GetRequiredService<ITableDiscoveryService>();
+
+            await using var connection = await connectionProvider.OpenConnectionAsync(context.RequestAborted);
+
+            // Pass the opened connection directly to avoid password extraction issues
+            var tables = await tableDiscoveryService.DiscoverPostGisTablesAsync(
+                connection,
+                context.RequestAborted);
+
+            var response = new TableDiscoveryResponse
+            {
+                Tables = tables
+            };
+
+            AdminLog.TableDiscoverySuccessful(logger, tables.Count, id);
+
+            // Return JSON response with AOT-compatible serialization
+            context.Response.StatusCode = 200;
+            context.Response.ContentType = "application/json; charset=utf-8";
+            await JsonSerializer.SerializeAsync(context.Response.Body, response,
+                TableDiscoveryJsonContext.Default.TableDiscoveryResponse,
+                context.RequestAborted);
+        }
+        catch (Exception ex)
+        {
+            AdminLog.TableDiscoveryFailed(logger, ex, id);
+
+            context.Response.StatusCode = 500; // Internal Server Error
+            context.Response.ContentType = "application/problem+json; charset=utf-8";
+            await context.Response.WriteAsync($$"""{"title":"Table Discovery Failed","status":500,"detail":"An error occurred while discovering tables. Please check the connection and try again."}""");
+        }
+    }
+}

src/Honua.Server/Features/Admin/AdminLog.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Honua. All rights reserved.
+// Licensed under the Elastic License 2.0. See LICENSE in the project root.
+
+namespace Honua.Server.Features.Admin;
+
+/// <summary>
+/// Source-generated logger for Admin features (AOT compatible)
+/// </summary>
+public static partial class AdminLog
+{
+    /// <summary>
+    /// Log when connection not found for table discovery
+    /// </summary>
+    [LoggerMessage(
+        EventId = 4001,
+        Level = LogLevel.Warning,
+        Message = "No connection string found for connection ID {ConnectionId}")]
+    public static partial void ConnectionNotFound(ILogger logger, string connectionId);
+
+    /// <summary>
+    /// Log successful table discovery
+    /// </summary>
+    [LoggerMessage(
+        EventId = 4002,
+        Level = LogLevel.Information,
+        Message = "Successfully discovered {Count} tables for connection {ConnectionId}")]
+    public static partial void TableDiscoverySuccessful(ILogger logger, int count, string connectionId);
+
+    /// <summary>
+    /// Log table discovery failure
+    /// </summary>
+    [LoggerMessage(
+        EventId = 4003,
+        Level = LogLevel.Error,
+        Message = "Failed to discover tables for connection {ConnectionId}")]
+    public static partial void TableDiscoveryFailed(ILogger logger, Exception ex, string connectionId);
+
+    /// <summary>
+    /// Log PostGIS table discovery completion
+    /// </summary>
+    [LoggerMessage(
+        EventId = 4004,
+        Level = LogLevel.Information,
+        Message = "Discovered {Count} PostGIS tables")]
+    public static partial void PostGisTablesDiscovered(ILogger logger, int count);
+
+    /// <summary>
+    /// Log PostGIS table discovery error
+    /// </summary>
+    [LoggerMessage(
+        EventId = 4005,
+        Level = LogLevel.Error,
+        Message = "Error discovering PostGIS tables")]
+    public static partial void PostGisDiscoveryError(ILogger logger, Exception ex);
+}

src/Honua.Server/Features/Admin/Models/TableDiscoveryModels.cs

@@ -0,0 +1,102 @@
+// Copyright (c) Honua. All rights reserved.
+// Licensed under the Elastic License 2.0. See LICENSE in the project root.
+
+using System.Text.Json.Serialization;
+
+namespace Honua.Server.Features.Admin.Models;
+
+/// <summary>
+/// Information about a discovered table with spatial data
+/// </summary>
+public sealed class TableInfo
+{
+    /// <summary>
+    /// Database schema name (e.g., "public")
+    /// </summary>
+    public required string Schema { get; init; }
+
+    /// <summary>
+    /// Table name
+    /// </summary>
+    public required string Table { get; init; }
+
+    /// <summary>
+    /// Name of the geometry column
+    /// </summary>
+    public string? GeometryColumn { get; init; }
+
+    /// <summary>
+    /// Geometry type (e.g., POINT, POLYGON, MULTIPOLYGON)
+    /// </summary>
+    public string? GeometryType { get; init; }
+
+    /// <summary>
+    /// Spatial Reference Identifier (SRID)
+    /// </summary>
+    public int? Srid { get; init; }
+
+    /// <summary>
+    /// Estimated row count
+    /// </summary>
+    public long? EstimatedRows { get; init; }
+
+    /// <summary>
+    /// All columns in the table
+    /// </summary>
+    public List<ColumnInfo> Columns { get; init; } = new();
+}
+
+/// <summary>
+/// Information about a table column
+/// </summary>
+public sealed class ColumnInfo
+{
+    /// <summary>
+    /// Column name
+    /// </summary>
+    public required string Name { get; init; }
+
+    /// <summary>
+    /// Column data type
+    /// </summary>
+    public required string DataType { get; init; }
+
+    /// <summary>
+    /// Whether the column allows null values
+    /// </summary>
+    public bool IsNullable { get; init; }
+
+    /// <summary>
+    /// Whether this is a primary key column
+    /// </summary>
+    public bool IsPrimaryKey { get; init; }
+
+    /// <summary>
+    /// Maximum length for character types
+    /// </summary>
+    public int? MaxLength { get; init; }
+}
+
+/// <summary>
+/// Response from table discovery endpoint
+/// </summary>
+public sealed class TableDiscoveryResponse
+{
+    /// <summary>
+    /// List of discovered tables
+    /// </summary>
+    public List<TableInfo> Tables { get; init; } = new();
+}
+
+/// <summary>
+/// Response model with JSON source generation for AOT compatibility
+/// </summary>
+[JsonSerializable(typeof(TableDiscoveryResponse))]
+[JsonSerializable(typeof(TableInfo))]
+[JsonSerializable(typeof(ColumnInfo))]
+[JsonSourceGenerationOptions(
+    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
+    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
+public partial class TableDiscoveryJsonContext : JsonSerializerContext
+{
+}

src/Honua.Server/Features/Admin/Services/ITableDiscoveryService.cs

@@ -0,0 +1,33 @@
+// Copyright (c) Honua. All rights reserved.
+// Licensed under the Elastic License 2.0. See LICENSE in the project root.
+
+using System.Data.Common;
+using Honua.Server.Features.Admin.Models;
+
+namespace Honua.Server.Features.Admin.Services;
+
+/// <summary>
+/// Service for discovering spatial tables in a database
+/// </summary>
+public interface ITableDiscoveryService
+{
+    /// <summary>
+    /// Discover all spatial tables in a PostGIS database
+    /// </summary>
+    /// <param name="connectionString">PostgreSQL connection string</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>List of discovered tables with metadata</returns>
+    Task<List<TableInfo>> DiscoverPostGisTablesAsync(
+        string connectionString,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Discover all spatial tables in a PostGIS database using an existing connection
+    /// </summary>
+    /// <param name="connection">Open database connection</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>List of discovered tables with metadata</returns>
+    Task<List<TableInfo>> DiscoverPostGisTablesAsync(
+        DbConnection connection,
+        CancellationToken cancellationToken = default);
+}