Implement brewery repo, SQL procs and tests

src/Core/API/API.Core/Program.cs

@@ -1,20 +1,15 @@
 using API.Core;
 using API.Core.Authentication;
-using API.Core.Contracts.Common;
-using Domain.Exceptions;
 using FluentValidation;
 using FluentValidation.AspNetCore;
 using Infrastructure.Email;
-using Infrastructure.Email.Templates;
 using Infrastructure.Email.Templates.Rendering;
 using Infrastructure.Jwt;
 using Infrastructure.PasswordHashing;
 using Infrastructure.Repository.Auth;
 using Infrastructure.Repository.Sql;
 using Infrastructure.Repository.UserAccount;
-using Microsoft.AspNetCore.Authentication;
+using Infrastructure.Repository.Breweries;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Filters;
 using Service.Auth;
 using Service.Emails;
 using Service.UserManagement.User;
@@ -55,6 +50,7 @@ builder.Services.AddSingleton<
 
 builder.Services.AddScoped<IUserAccountRepository, UserAccountRepository>();
 builder.Services.AddScoped<IAuthRepository, AuthRepository>();
+builder.Services.AddScoped<IBreweryRepository, BreweryRepository>();
 
 builder.Services.AddScoped<IUserService, UserService>();
 builder.Services.AddScoped<ILoginService, LoginService>();

src/Core/Database/Database.Migrations/scripts/01-schema/schema.sql

@@ -37,7 +37,7 @@ CREATE TABLE dbo.UserAccount
 
     UpdatedAt DATETIME,
 
-    DateOfBirth DATETIME NOT NULL,
+    DateOfBirth DATE NOT NULL,
 
     Timer ROWVERSION,
 
@@ -49,7 +49,6 @@ CREATE TABLE dbo.UserAccount
 
     CONSTRAINT AK_Email
         UNIQUE (Email)
-
 );
 
 ----------------------------------------------------------------------------
@@ -109,7 +108,7 @@ CREATE TABLE UserAvatar -- delete avatar photo when user account is deleted
 
     CONSTRAINT AK_UserAvatar_UserAccountID
         UNIQUE (UserAccountID)
-)
+);
 
 CREATE NONCLUSTERED INDEX IX_UserAvatar_UserAccount
     ON UserAvatar(UserAccountID);
@@ -125,8 +124,7 @@ CREATE TABLE UserVerification -- delete verification data when user account is d
     UserAccountID UNIQUEIDENTIFIER NOT NULL,
 
     VerificationDateTime DATETIME NOT NULL
-        CONSTRAINT DF_VerificationDateTime
+        CONSTRAINT DF_VerificationDateTime DEFAULT GETDATE(),
-        DEFAULT GETDATE(),
 
     Timer ROWVERSION,
 
@@ -155,13 +153,13 @@ CREATE TABLE UserCredential -- delete credentials when user account is deleted
 
     UserAccountID UNIQUEIDENTIFIER NOT NULL,
 
-    CreatedAt DATETIME
+    CreatedAt DATETIME NOT NULL
-        CONSTRAINT DF_UserCredential_CreatedAt DEFAULT GETDATE() NOT NULL,
+        CONSTRAINT DF_UserCredential_CreatedAt DEFAULT GETDATE(),
 
-    Expiry DATETIME
+    Expiry DATETIME NOT NULL
-        CONSTRAINT DF_UserCredential_Expiry DEFAULT DATEADD(DAY, 90, GETDATE()) NOT NULL,
+        CONSTRAINT DF_UserCredential_Expiry DEFAULT DATEADD(DAY, 90, GETDATE()),
 
-    Hash NVARCHAR(MAX) NOT NULL,
+    Hash NVARCHAR(256) NOT NULL,
     -- uses argon2
 
     IsRevoked BIT NOT NULL
@@ -177,12 +175,16 @@ CREATE TABLE UserCredential -- delete credentials when user account is deleted
     CONSTRAINT FK_UserCredential_UserAccount
         FOREIGN KEY (UserAccountID)
         REFERENCES UserAccount(UserAccountID)
-        ON DELETE CASCADE,
+        ON DELETE CASCADE
 );
 
 CREATE NONCLUSTERED INDEX IX_UserCredential_UserAccount
     ON UserCredential(UserAccountID);
 
+CREATE NONCLUSTERED INDEX IX_UserCredential_Account_Active
+    ON UserCredential(UserAccountID, IsRevoked, Expiry)
+    INCLUDE (Hash);
+
 ----------------------------------------------------------------------------
 ----------------------------------------------------------------------------
 
@@ -195,8 +197,8 @@ CREATE TABLE UserFollow
 
     FollowingID UNIQUEIDENTIFIER NOT NULL,
 
-    CreatedAt DATETIME
+    CreatedAt DATETIME NOT NULL
-        CONSTRAINT DF_UserFollow_CreatedAt DEFAULT GETDATE() NOT NULL,
+        CONSTRAINT DF_UserFollow_CreatedAt DEFAULT GETDATE(),
 
     Timer ROWVERSION,
 
@@ -205,11 +207,13 @@ CREATE TABLE UserFollow
 
     CONSTRAINT FK_UserFollow_UserAccount
         FOREIGN KEY (UserAccountID)
-        REFERENCES UserAccount(UserAccountID),
+        REFERENCES UserAccount(UserAccountID)
+        ON DELETE NO ACTION,
 
     CONSTRAINT FK_UserFollow_UserAccountFollowing
         FOREIGN KEY (FollowingID)
-        REFERENCES UserAccount(UserAccountID),
+        REFERENCES UserAccount(UserAccountID)
+        ON DELETE NO ACTION,
 
     CONSTRAINT CK_CannotFollowOwnAccount
         CHECK (UserAccountID != FollowingID)
@@ -221,7 +225,6 @@ CREATE NONCLUSTERED INDEX IX_UserFollow_UserAccount_FollowingID
 CREATE NONCLUSTERED INDEX IX_UserFollow_FollowingID_UserAccount
     ON UserFollow(FollowingID, UserAccountID);
 
-
 ----------------------------------------------------------------------------
 ----------------------------------------------------------------------------
 
@@ -299,7 +302,6 @@ CREATE TABLE City
 CREATE NONCLUSTERED INDEX IX_City_StateProvince
     ON City(StateProvinceID);
 
-
 ----------------------------------------------------------------------------
 ----------------------------------------------------------------------------
 
@@ -308,6 +310,8 @@ CREATE TABLE BreweryPost -- A user cannot be deleted if they have a post
     BreweryPostID UNIQUEIDENTIFIER
         CONSTRAINT DF_BreweryPostID DEFAULT NEWID(),
 
+    BreweryName NVARCHAR(256) NOT NULL,
+
     PostedByID UNIQUEIDENTIFIER NOT NULL,
 
     Description NVARCHAR(512) NOT NULL,
@@ -325,15 +329,15 @@ CREATE TABLE BreweryPost -- A user cannot be deleted if they have a post
     CONSTRAINT FK_BreweryPost_UserAccount
         FOREIGN KEY (PostedByID)
         REFERENCES UserAccount(UserAccountID)
-        ON DELETE NO ACTION,
+        ON DELETE NO ACTION
-
+);
-)
 
 CREATE NONCLUSTERED INDEX IX_BreweryPost_PostedByID
     ON BreweryPost(PostedByID);
 
 ----------------------------------------------------------------------------
 ----------------------------------------------------------------------------
+
 CREATE TABLE BreweryPostLocation
 (
     BreweryPostLocationID UNIQUEIDENTIFIER
@@ -349,7 +353,7 @@ CREATE TABLE BreweryPostLocation
 
     CityID UNIQUEIDENTIFIER NOT NULL,
 
-    Coordinates GEOGRAPHY NOT NULL,
+    Coordinates GEOGRAPHY NULL,
 
     Timer ROWVERSION,
 
@@ -362,7 +366,11 @@ CREATE TABLE BreweryPostLocation
     CONSTRAINT FK_BreweryPostLocation_BreweryPost
         FOREIGN KEY (BreweryPostID)
         REFERENCES BreweryPost(BreweryPostID)
-        ON DELETE CASCADE
+        ON DELETE CASCADE,
+
+    CONSTRAINT FK_BreweryPostLocation_City
+        FOREIGN KEY (CityID)
+        REFERENCES City(CityID)
 );
 
 CREATE NONCLUSTERED INDEX IX_BreweryPostLocation_BreweryPost
@@ -371,6 +379,18 @@ CREATE NONCLUSTERED INDEX IX_BreweryPostLocation_BreweryPost
 CREATE NONCLUSTERED INDEX IX_BreweryPostLocation_City
     ON BreweryPostLocation(CityID);
 
+-- To assess when the time comes:
+
+-- This would allow for efficient spatial queries to find breweries within a certain distance of a location, but it adds overhead to insert/update operations.
+
+-- CREATE SPATIAL INDEX SIDX_BreweryPostLocation_Coordinates
+--     ON BreweryPostLocation(Coordinates)
+--     USING GEOGRAPHY_GRID
+--     WITH (
+--         GRIDS = (LEVEL_1 = MEDIUM, LEVEL_2 = MEDIUM, LEVEL_3 = MEDIUM, LEVEL_4 = MEDIUM),
+--         CELLS_PER_OBJECT = 16
+--     );
+
 ----------------------------------------------------------------------------
 ----------------------------------------------------------------------------
 
@@ -410,6 +430,7 @@ ON BreweryPostPhoto(BreweryPostID, PhotoID);
 
 ----------------------------------------------------------------------------
 ----------------------------------------------------------------------------
+
 CREATE TABLE BeerStyle
 (
     BeerStyleID UNIQUEIDENTIFIER
@@ -444,7 +465,7 @@ CREATE TABLE BeerPost
     -- Alcohol By Volume (typically 0-67%)
 
     IBU INT NOT NULL,
-    -- International Bitterness Units (typically 0-100)
+    -- International Bitterness Units (typically 0-120)
 
     PostedByID UNIQUEIDENTIFIER NOT NULL,
 
@@ -464,7 +485,8 @@ CREATE TABLE BeerPost
 
     CONSTRAINT FK_BeerPost_PostedBy
         FOREIGN KEY (PostedByID)
-        REFERENCES UserAccount(UserAccountID),
+        REFERENCES UserAccount(UserAccountID)
+        ON DELETE NO ACTION,
 
     CONSTRAINT FK_BeerPost_BeerStyle
         FOREIGN KEY (BeerStyleID)
@@ -539,17 +561,35 @@ CREATE TABLE BeerPostComment
 
     BeerPostID UNIQUEIDENTIFIER NOT NULL,
 
+    CommentedByID UNIQUEIDENTIFIER NOT NULL,
+
     Rating INT NOT NULL,
 
+    CreatedAt DATETIME NOT NULL
+        CONSTRAINT DF_BeerPostComment_CreatedAt DEFAULT GETDATE(),
+
+    UpdatedAt DATETIME NULL,
+
     Timer ROWVERSION,
 
     CONSTRAINT PK_BeerPostComment
         PRIMARY KEY (BeerPostCommentID),
 
     CONSTRAINT FK_BeerPostComment_BeerPost
-       FOREIGN KEY (BeerPostID) REFERENCES BeerPost(BeerPostID)
+        FOREIGN KEY (BeerPostID)
-)
+        REFERENCES BeerPost(BeerPostID),
+
+    CONSTRAINT FK_BeerPostComment_UserAccount
+        FOREIGN KEY (CommentedByID)
+        REFERENCES UserAccount(UserAccountID)
+        ON DELETE NO ACTION,
+
+    CONSTRAINT CHK_BeerPostComment_Rating
+        CHECK (Rating BETWEEN 1 AND 5)
+);
 
 CREATE NONCLUSTERED INDEX IX_BeerPostComment_BeerPost
-    ON BeerPostComment(BeerPostID)
+    ON BeerPostComment(BeerPostID);
 
+CREATE NONCLUSTERED INDEX IX_BeerPostComment_CommentedBy
+    ON BeerPostComment(CommentedByID);

src/Core/Database/Database.Migrations/scripts/03-crud/05-Breweries/USP_CreateBrewery.sql

@@ -0,0 +1,50 @@
+CREATE OR ALTER PROCEDURE dbo.USP_CreateBrewery(
+    @BreweryName NVARCHAR(256),
+    @Description NVARCHAR(512),
+    @PostedByID UNIQUEIDENTIFIER,
+    @CityID UNIQUEIDENTIFIER,
+    @AddressLine1 NVARCHAR(256),
+    @AddressLine2 NVARCHAR(256) = NULL,
+    @PostalCode NVARCHAR(20),
+    @Coordinates GEOGRAPHY = NULL
+)
+AS
+BEGIN
+    SET NOCOUNT ON;
+    SET XACT_ABORT ON;
+
+    IF @BreweryName IS NULL
+        THROW 50001, 'Brewery name cannot be null.', 1;
+
+    IF @Description IS NULL
+        THROW 50002, 'Brewery description cannot be null.', 1;
+
+    IF NOT EXISTS (SELECT 1
+                   FROM dbo.UserAccount
+                   WHERE UserAccountID = @PostedByID)
+        THROW 50404, 'User not found.', 1;
+
+    IF NOT EXISTS (SELECT 1
+                   FROM dbo.City
+                   WHERE CityID = @CityID)
+        THROW 50404, 'City not found.', 1;
+
+    DECLARE @NewBreweryID UNIQUEIDENTIFIER = NEWID();
+    DECLARE @NewBrewerLocationID UNIQUEIDENTIFIER = NEWID();
+
+    BEGIN TRANSACTION;
+
+    INSERT INTO dbo.BreweryPost
+        (BreweryPostID, BreweryName, Description, PostedByID)
+    VALUES (@NewBreweryID, @BreweryName, @Description, @PostedByID);
+
+    INSERT INTO dbo.BreweryPostLocation
+    (BreweryPostLocationID, BreweryPostID, CityID, AddressLine1, AddressLine2, PostalCode, Coordinates)
+    VALUES (@NewBrewerLocationID, @NewBreweryID, @CityID, @AddressLine1, @AddressLine2, @PostalCode, @Coordinates);
+
+    COMMIT TRANSACTION;
+
+    SELECT @NewBreweryID        AS BreweryPostID,
+           @NewBrewerLocationID AS BreweryPostLocationID;
+
+END

src/Core/Database/Database.Migrations/scripts/03-crud/05-Breweries/USP_GetBreweryById.sql

@@ -0,0 +1,9 @@
+CREATE OR ALTER PROCEDURE dbo.USP_GetBreweryById @BreweryPostID UNIQUEIDENTIFIER
+AS
+BEGIN
+    SELECT *
+    FROM BreweryPost bp
+             INNER JOIN BreweryPostLocation bpl
+                        ON bp.BreweryPostID = bpl.BreweryPostID
+    WHERE bp.BreweryPostID = @BreweryPostID;
+END

src/Core/Domain/Domain.Entities/Entities/BreweryPost.cs

@@ -0,0 +1,13 @@
+namespace Domain.Entities;
+
+public class BreweryPost
+{
+    public Guid BreweryPostId { get; set; }
+    public Guid PostedById { get; set; }
+    public string BreweryName { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+    public byte[]? Timer { get; set; }
+    public BreweryPostLocation? Location { get; set; }
+}

src/Core/Domain/Domain.Entities/Entities/BreweryPostLocation.cs

@@ -0,0 +1,13 @@
+namespace Domain.Entities;
+
+public class BreweryPostLocation
+{
+   public Guid BreweryPostLocationId { get; set; }
+   public Guid BreweryPostId { get; set; }
+   public string AddressLine1 { get; set; } = string.Empty;
+   public string? AddressLine2 { get; set; }
+   public string PostalCode { get; set; } = string.Empty;
+   public Guid CityId { get; set; }
+   public byte[]? Coordinates { get; set; }
+   public byte[]? Timer { get; set; }
+}

src/Core/Infrastructure/Infrastructure.Email/Infrastructure.Email.csproj

@@ -7,6 +7,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MailKit" Version="4.9.0" />
+    <PackageReference Include="MailKit" Version="4.15.1" />
   </ItemGroup>
 </Project>

src/Core/Infrastructure/Infrastructure.Repository.Tests/Breweries/BreweryRepository.test.cs

@@ -0,0 +1,108 @@
+using Apps72.Dev.Data.DbMocker;
+using FluentAssertions;
+using Infrastructure.Repository.Breweries;
+using Infrastructure.Repository.Tests.Database;
+using Domain.Entities;
+
+namespace Infrastructure.Repository.Tests.Breweries;
+
+public class BreweryRepositoryTest
+{
+    private static BreweryRepository CreateRepo(MockDbConnection conn) =>
+        new(new TestConnectionFactory(conn));
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsBrewery_WhenExists()
+    {
+        var breweryId = Guid.NewGuid();
+        var conn = new MockDbConnection();
+
+        // Repository calls the stored procedure
+        const string getByIdSql = "USP_GetBreweryById";
+
+        var locationId = Guid.NewGuid();
+
+        conn.Mocks.When(cmd => cmd.CommandText == getByIdSql)
+            .ReturnsTable(
+                MockTable
+                    .WithColumns(
+                        ("BreweryPostId", typeof(Guid)),
+                        ("PostedById", typeof(Guid)),
+                        ("BreweryName", typeof(string)),
+                        ("Description", typeof(string)),
+                        ("CreatedAt", typeof(DateTime)),
+                        ("UpdatedAt", typeof(DateTime?)),
+                        ("Timer", typeof(byte[])),
+                        ("BreweryPostLocationId", typeof(Guid)),
+                        ("CityId", typeof(Guid)),
+                        ("AddressLine1", typeof(string)),
+                        ("AddressLine2", typeof(string)),
+                        ("PostalCode", typeof(string)),
+                        ("Coordinates", typeof(byte[]))
+                    )
+                    .AddRow(
+                        breweryId,
+                        Guid.NewGuid(),
+                        "Test Brewery",
+                        "A test brewery description",
+                        DateTime.UtcNow,
+                        null,
+                        null,
+                        locationId,
+                        Guid.NewGuid(),
+                        "123 Main St",
+                        null,
+                        "12345",
+                        null
+                    )
+            );
+
+        var repo = CreateRepo(conn);
+        var result = await repo.GetByIdAsync(breweryId);
+        result.Should().NotBeNull();
+        result!.BreweryPostId.Should().Be(breweryId);
+        result.Location.Should().NotBeNull();
+        result.Location!.BreweryPostLocationId.Should().Be(locationId);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ReturnsNull_WhenNotExists()
+    {
+        var conn = new MockDbConnection();
+        conn.Mocks.When(cmd => cmd.CommandText == "USP_GetBreweryById")
+            .ReturnsTable(MockTable.Empty());
+        var repo = CreateRepo(conn);
+        var result = await repo.GetByIdAsync(Guid.NewGuid());
+        result.Should().BeNull();
+
+    }
+
+    [Fact]
+    public async Task CreateAsync_ExecutesSuccessfully()
+    {
+        var conn = new MockDbConnection();
+        conn.Mocks.When(cmd => cmd.CommandText == "USP_CreateBrewery")
+            .ReturnsScalar(1);
+        var repo = CreateRepo(conn);
+        var brewery = new BreweryPost
+        {
+            BreweryPostId = Guid.NewGuid(),
+            PostedById = Guid.NewGuid(),
+            BreweryName = "Test Brewery",
+            Description = "A test brewery description",
+            CreatedAt = DateTime.UtcNow,
+            Location = new BreweryPostLocation
+            {
+                BreweryPostLocationId = Guid.NewGuid(),
+                CityId = Guid.NewGuid(),
+                AddressLine1 = "123 Main St",
+                PostalCode = "12345",
+                Coordinates = [0x00, 0x01]
+            }
+        };
+        
+        // Should not throw
+        var act = async () => await repo.CreateAsync(brewery);
+        await act.Should().NotThrowAsync();
+    }
+}

src/Core/Infrastructure/Infrastructure.Repository/Auth/AuthRepository.cs

@@ -35,16 +35,7 @@ public class AuthRepository(ISqlConnectionFactory connectionFactory)
         var result = await command.ExecuteScalarAsync();
         var userAccountId = result != null ? (Guid)result : Guid.Empty;
 
-        return new Domain.Entities.UserAccount
+        return await GetUserByIdAsync(userAccountId) ?? throw new Exception("Failed to retrieve newly registered user.");
-        {
-            UserAccountId = userAccountId,
-            Username = username,
-            FirstName = firstName,
-            LastName = lastName,
-            Email = email,
-            DateOfBirth = dateOfBirth,
-            CreatedAt = DateTime.UtcNow,
-        };
     }
 
     public async Task<Domain.Entities.UserAccount?> GetUserByEmailAsync(

src/Core/Infrastructure/Infrastructure.Repository/Breweries/BreweryRepository.cs

@@ -0,0 +1,161 @@
+using System.Data.Common;
+using Domain.Entities;
+using Infrastructure.Repository.Sql;
+
+namespace Infrastructure.Repository.Breweries;
+
+public interface IBreweryRepository
+{
+    Task<BreweryPost?> GetByIdAsync(Guid id);
+    Task<IEnumerable<BreweryPost>> GetAllAsync(int? limit, int? offset);
+    Task UpdateAsync(BreweryPost brewery);
+    Task DeleteAsync(Guid id);
+    Task CreateAsync(BreweryPost brewery);
+}
+
+public class BreweryRepository : Repository<BreweryPost>, IBreweryRepository
+{
+    private readonly ISqlConnectionFactory _connectionFactory;
+
+    public BreweryRepository(ISqlConnectionFactory connectionFactory)
+        : base(connectionFactory)
+    {
+        _connectionFactory = connectionFactory;
+    }
+
+    public async Task<BreweryPost?> GetByIdAsync(Guid id)
+    {
+        await using var connection = await CreateConnection();
+        await using var command = connection.CreateCommand();
+        command.CommandType = System.Data.CommandType.StoredProcedure;
+
+        command.CommandText = "USP_GetBreweryById";
+        AddParameter(command, "@BreweryPostID", id);
+
+        await using var reader = await command.ExecuteReaderAsync();
+        if (await reader.ReadAsync())
+        {
+            return MapToEntity(reader);
+        }
+        return null;
+    }
+
+    public Task<IEnumerable<BreweryPost>> GetAllAsync(int? limit, int? offset)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task UpdateAsync(BreweryPost brewery)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task DeleteAsync(Guid id)
+    {
+        throw new NotImplementedException();
+    }
+
+    public async Task CreateAsync(BreweryPost brewery)
+    {
+        await using var connection = await CreateConnection();
+        await using var command = connection.CreateCommand();
+
+        command.CommandText = "USP_CreateBrewery";
+        command.CommandType = System.Data.CommandType.StoredProcedure;
+
+        if (brewery.Location is null)
+        {
+            throw new ArgumentException("Location must be provided when creating a brewery.");
+        }
+
+        AddParameter(command, "@BreweryName", brewery.BreweryName);
+        AddParameter(command, "@Description", brewery.Description);
+        AddParameter(command, "@PostedByID", brewery.PostedById);
+        AddParameter(command, "@CityID", brewery.Location?.CityId);
+        AddParameter(command, "@AddressLine1", brewery.Location?.AddressLine1);
+        AddParameter(command, "@AddressLine2", brewery.Location?.AddressLine2);
+        AddParameter(command, "@PostalCode", brewery.Location?.PostalCode);
+        AddParameter(command, "@Coordinates", brewery.Location?.Coordinates);
+        await command.ExecuteNonQueryAsync();
+
+    }
+
+    protected override BreweryPost MapToEntity(DbDataReader reader)
+    {
+        var brewery = new BreweryPost();
+
+        var ordBreweryPostId = reader.GetOrdinal("BreweryPostId");
+        var ordPostedById = reader.GetOrdinal("PostedById");
+        var ordBreweryName = reader.GetOrdinal("BreweryName");
+        var ordDescription = reader.GetOrdinal("Description");
+        var ordCreatedAt = reader.GetOrdinal("CreatedAt");
+        var ordUpdatedAt = reader.GetOrdinal("UpdatedAt");
+        var ordTimer = reader.GetOrdinal("Timer");
+
+        brewery.BreweryPostId = reader.GetGuid(ordBreweryPostId);
+        brewery.PostedById = reader.GetGuid(ordPostedById);
+        brewery.BreweryName = reader.GetString(ordBreweryName);
+        brewery.Description = reader.GetString(ordDescription);
+        brewery.CreatedAt = reader.GetDateTime(ordCreatedAt);
+
+        brewery.UpdatedAt = reader.IsDBNull(ordUpdatedAt) ? null : reader.GetDateTime(ordUpdatedAt);
+
+        // Read timer (varbinary/rowversion) robustly
+        if (reader.IsDBNull(ordTimer))
+        {
+            brewery.Timer = null;
+        }
+        else
+        {
+            try
+            {
+                brewery.Timer = reader.GetFieldValue<byte[]>(ordTimer);
+            }
+            catch
+            {
+                var length = reader.GetBytes(ordTimer, 0, null, 0, 0);
+                var buffer = new byte[length];
+                reader.GetBytes(ordTimer, 0, buffer, 0, (int)length);
+                brewery.Timer = buffer;
+            }
+        }
+
+        // Map BreweryPostLocation if columns are present
+        try
+        {
+            var ordLocationId = reader.GetOrdinal("BreweryPostLocationId");
+            if (!reader.IsDBNull(ordLocationId))
+            {
+                var location = new BreweryPostLocation
+                {
+                    BreweryPostLocationId = reader.GetGuid(ordLocationId),
+                    BreweryPostId = reader.GetGuid(reader.GetOrdinal("BreweryPostId")),
+                    CityId = reader.GetGuid(reader.GetOrdinal("CityId")),
+                    AddressLine1 = reader.GetString(reader.GetOrdinal("AddressLine1")),
+                    AddressLine2 = reader.IsDBNull(reader.GetOrdinal("AddressLine2")) ? null : reader.GetString(reader.GetOrdinal("AddressLine2")),
+                    PostalCode = reader.GetString(reader.GetOrdinal("PostalCode")),
+                    Coordinates = reader.IsDBNull(reader.GetOrdinal("Coordinates")) ? null : reader.GetFieldValue<byte[]>(reader.GetOrdinal("Coordinates"))
+                };
+                brewery.Location = location;
+            }
+        }
+        catch (IndexOutOfRangeException)
+        {
+            // Location columns not present, skip mapping location
+        }
+
+        return brewery;
+    }
+
+    private static void AddParameter(
+        DbCommand command,
+        string name,
+        object? value
+    )
+    {
+        var p = command.CreateParameter();
+        p.ParameterName = name;
+        p.Value = value ?? DBNull.Value;
+        command.Parameters.Add(p);
+    }
+}