Merge pull request #6 from PandaTechAM/development

updated readme

Author: HaikAsatryan

Readme.md

@@ -1,12 +1,23 @@
-# Pandatech.MassTransit.PostgresOutbox
+- [1. Pandatech.MassTransit.PostgresOutbox](#1-pandatechmasstransitpostgresoutbox)
+  - [1.1. Features](#11-features)
+  - [1.2. Getting Started](#12-getting-started)
+  - [1.3. Installation](#13-installation)
+  - [1.4. Configuration](#14-configuration)
+  - [1.5. Usage](#15-usage)
+    - [1.5.1. Configuration](#151-configuration)
+    - [1.5.2. Publishing Messages (Outbox Pattern)](#152-publishing-messages-outbox-pattern)
+    - [1.5.3. Consuming Messages (Inbox Pattern)](#153-consuming-messages-inbox-pattern)
+  - [1.6. License](#16-license)
+
+# 1. Pandatech.MassTransit.PostgresOutbox
 
 Welcome to the Pandatech MassTransit PostgreSQL Outbox Extension repository. This library is designed to enhance
 MassTransit's capabilities by introducing robust support for the Outbox and Inbox patterns with a particular focus on
 PostgreSQL, alongside seamless integration with multiple DbContexts in Entity Framework Core. This extension is ideal
 for developers seeking to ensure reliable message delivery and processing in distributed, microservice-oriented
 architectures.
 
-## Features
+## 1.1. Features
 
 - **Multiple DbContext Support**: Operate within complex systems using multiple data contexts without hassle.
 - **Outbox Pattern Implementation**: Reliably handle message sending operations, ensuring no messages are lost in
@@ -17,23 +28,23 @@ architectures.
   control, making your message handling processes more robust.
 - **Seamless Integration**: Designed to fit effortlessly into existing MassTransit and EF Core based projects.
 
-## Getting Started
+## 1.2. Getting Started
 
 To get started with the Pandatech MassTransit PostgreSQL Outbox Extension, ensure you have the following prerequisites:
 
 - .NET Core 8 or later
 - An existing MassTransit project
 - PostgreSQL database
 
-## Installation
+## 1.3. Installation
 
 The library can be installed via NuGet Package Manager. Use the following command:
 
 ```bash
 Install-Package Pandatech.MassTransit.PostgresOutbox
 ``` 
 
-## Configuration
+## 1.4. Configuration
 
 Before diving into the usage, it's essential to configure the Pandatech MassTransit PostgreSQL Outbox Extension in your
 application. This involves setting up your DbContexts, configuring MassTransit to use the extension, and initializing
@@ -42,47 +53,45 @@ the Outbox and Inbox features.
 Stay tuned for the next sections where we'll cover the usage details, showcasing how you can leverage this powerful
 extension to enhance your distributed systems.
 
-## Usage
+## 1.5. Usage
+
 Take into account that examples below are given for configuring both inbox and outbox patterns.
-If you need only one of those , consider using appropriate methods available(eg. instead of AddOutboxInboxServices use AddInboxServices and etc).
+If you need only one of those , consider using appropriate methods available(eg. instead of AddOutboxInboxServices use
+AddInboxServices and etc).
 
-Configuration
+### 1.5.1. Configuration
 
-Entity Configuration: Ensure your DbContext implements the IOutboxDbContext and IInboxDbContext interfaces.
-Configure your entities and generate migrations. 
-Call ConfigureInboxOutboxEntities on your ModelBuilder to configure the necessary tables for inbox and outbox patterns.
+**Entity Configuration:** Ensure your `DbContext` implements the `IOutboxDbContext` and `IInboxDbContext` interfaces.
+Configure your entities and generate migrations.
+Call `ConfigureInboxOutboxEntities` on your `ModelBuilder` to configure the necessary tables for inbox and outbox patterns.
 
 ```csharp
-
 protected override void OnModelCreating(ModelBuilder modelBuilder)
 {
     modelBuilder.ConfigureInboxOutboxEntities();
 }
 ```
-
-And you need to call UseQueryLocks() inside AddDbContext or AddDbContextPool , this needs for enabling ForUpdate feature.
-
+And you need to call `UseQueryLocks()` inside `AddDbContext` or `AddDbContextPool` , this needs for enabling `ForUpdate`
+feature.
 ```csharp
-  builder.Services.AddDbContextPool<PostgresContext>(options =>
+builder.Services.AddDbContextPool<PostgresContext>(options =>
          options.UseNpgsql(connectionString)
                 .UseQueryLocks());
 ```
 
-Service Registration: Register essential services on startup, specifying the DbContext type. 
+**Service Registration:** Register essential services on startup, specifying the `DbContext` type.
 You can optionally override settings(its optional parameter).
 
 ```csharp
-
 services.AddOutboxInboxServices<PostgresContext>();
 ```
 
-Publishing Messages (Outbox Pattern)
+### 1.5.2. Publishing Messages (Outbox Pattern)
 
-To publish a message using the outbox pattern, call the AddToOutbox method on your DbContext, 
-specifying your message. Remember to call SaveChanges() to persist the message to the database.
+To publish a message using the outbox pattern, call the `AddToOutbox` method on your `DbContext`,
+specifying your message. Remember to call `SaveChanges()` to persist the message to the database.
 
 ```csharp
-
 dbContext.Orders.Add(new Order
 {
     Amount = 555,
@@ -96,10 +105,10 @@ dbContext.AddToOutbox(new OrderCreatedEvent());
 dbContext.SaveChanges();
 ```
 
-Consuming Messages (Inbox Pattern)
+### 1.5.3. Consuming Messages (Inbox Pattern)
 
 To consume messages using the inbox pattern, create a consumer that inherits from
-InboxConsumer<TMessage, TDbContext> class, specifying the message type and DbContext type as generic arguments.
+`InboxConsumer<TMessage, TDbContext>` class, specifying the message type and `DbContext` type as generic arguments.
 
 ```csharp
 
@@ -120,6 +129,6 @@ public class YourConsumer : InboxConsumer<YourMessage, PostgresContext>
 }
 ```
 
-## License
+## 1.6. License
 
 Pandatech.MassTransit.PostgresOutbox is licensed under the MIT License.

src/MassTransit.PostgresOutbox/Abstractions/IInboxDbContext.cs

@@ -1,10 +1,9 @@
 using MassTransit.PostgresOutbox.Entities;
 using Microsoft.EntityFrameworkCore;
 
-namespace MassTransit.PostgresOutbox.Abstractions
+namespace MassTransit.PostgresOutbox.Abstractions;
+
+public interface IInboxDbContext
 {
-    public interface IInboxDbContext
-    {
-        public DbSet<InboxMessage> InboxMessages { get; set; }
-    }
-}
+    public DbSet<InboxMessage> InboxMessages { get; set; }
+}

src/MassTransit.PostgresOutbox/Abstractions/IOutboxDbContext.cs

@@ -1,10 +1,9 @@
 using MassTransit.PostgresOutbox.Entities;
 using Microsoft.EntityFrameworkCore;
 
-namespace MassTransit.PostgresOutbox.Abstractions
+namespace MassTransit.PostgresOutbox.Abstractions;
+
+public interface IOutboxDbContext
 {
-    public interface IOutboxDbContext
-    {
-        public DbSet<OutboxMessage> OutboxMessages { get; set; }
-    }
-}
+    public DbSet<OutboxMessage> OutboxMessages { get; set; }
+}

src/MassTransit.PostgresOutbox/Abstractions/InboxConsumer.cs

@@ -6,76 +6,75 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
-namespace MassTransit.PostgresOutbox.Abstractions
+namespace MassTransit.PostgresOutbox.Abstractions;
+
+public abstract class InboxConsumer<TMessage, TDbContext> : IConsumer<TMessage>
+   where TMessage : class
+   where TDbContext : DbContext, IInboxDbContext
 {
-    public abstract class InboxConsumer<TMessage, TDbContext> : IConsumer<TMessage>
-      where TMessage : class
-      where TDbContext : DbContext, IInboxDbContext
-   {
-      private readonly string _consumerId;
-      private readonly IServiceScopeFactory _serviceScopeFactory;
+   private readonly string _consumerId;
+   private readonly IServiceScopeFactory _serviceScopeFactory;
 
-      protected InboxConsumer(IServiceScopeFactory serviceScopeFactory)
-      {
-         _consumerId = GetType().ToString();
-         _serviceScopeFactory = serviceScopeFactory;
-      }
+   protected InboxConsumer(IServiceScopeFactory serviceScopeFactory)
+   {
+      _consumerId = GetType().ToString();
+      _serviceScopeFactory = serviceScopeFactory;
+   }
 
-      public async Task Consume(ConsumeContext<TMessage> context)
-      {
-         using var scope = _serviceScopeFactory.CreateScope();
-         var messageId = context.Headers.Get<Guid>(Constants.OutboxMessageId);
+   public async Task Consume(ConsumeContext<TMessage> context)
+   {
+      using var scope = _serviceScopeFactory.CreateScope();
+      var messageId = context.Headers.Get<Guid>(Constants.OutboxMessageId);
 
-         var dbContext = scope.ServiceProvider.GetRequiredService<TDbContext>();
-         var logger = scope.ServiceProvider.GetRequiredService<ILogger<InboxConsumer<TMessage, TDbContext>>>();
+      var dbContext = scope.ServiceProvider.GetRequiredService<TDbContext>();
+      var logger = scope.ServiceProvider.GetRequiredService<ILogger<InboxConsumer<TMessage, TDbContext>>>();
 
-         var exists = await dbContext.InboxMessages.AnyAsync(x => x.MessageId == messageId && x.ConsumerId == _consumerId);
+      var exists = await dbContext.InboxMessages.AnyAsync(x => x.MessageId == messageId && x.ConsumerId == _consumerId);
 
-         if (!exists)
+      if (!exists)
+      {
+         dbContext.InboxMessages.Add(new InboxMessage
          {
-            dbContext.InboxMessages.Add(new InboxMessage
-            {
-               MessageId = messageId!.Value,
-               CreatedAt = DateTime.UtcNow,
-               State = MessageState.New,
-               ConsumerId = _consumerId,
-            });
+            MessageId = messageId!.Value,
+            CreatedAt = DateTime.UtcNow,
+            State = MessageState.New,
+            ConsumerId = _consumerId,
+         });
 
-            await dbContext.SaveChangesAsync();
-         }
-
-         using var transactionScope = await dbContext.Database.BeginTransactionAsync(System.Data.IsolationLevel.ReadCommitted);
+         await dbContext.SaveChangesAsync();
+      }
 
-         var inboxMessage = await dbContext.InboxMessages
-                                           .Where(x => x.MessageId == messageId)
-                                           .Where(x => x.ConsumerId == _consumerId)
-                                           .Where(x => x.State == MessageState.New)
-                                           .ForUpdate(LockBehavior.SkipLocked)
-                                           .FirstOrDefaultAsync();
+      using var transactionScope = await dbContext.Database.BeginTransactionAsync(System.Data.IsolationLevel.ReadCommitted);
 
-         if (inboxMessage == null)
-         {
-            return;
-         }
+      var inboxMessage = await dbContext.InboxMessages
+         .Where(x => x.MessageId == messageId)
+         .Where(x => x.ConsumerId == _consumerId)
+         .Where(x => x.State == MessageState.New)
+         .ForUpdate(LockBehavior.SkipLocked)
+         .FirstOrDefaultAsync();
 
-         try
-         {
-            await Consume(context.Message);
-            inboxMessage.State = MessageState.Done;
-         }
-         catch (Exception ex)
-         {
-            logger.LogError(ex, "Exception thrown while consuming message");
-            throw;
-         }
-         finally
-         {
-            inboxMessage!.UpdatedAt = DateTime.UtcNow;
-            await dbContext.SaveChangesAsync();
-            await transactionScope.CommitAsync();
-         }
+      if (inboxMessage == null)
+      {
+         return;
       }
 
-      public abstract Task Consume(TMessage message);
+      try
+      {
+         await Consume(context.Message);
+         inboxMessage.State = MessageState.Done;
+      }
+      catch (Exception ex)
+      {
+         logger.LogError(ex, "Exception thrown while consuming message");
+         throw;
+      }
+      finally
+      {
+         inboxMessage!.UpdatedAt = DateTime.UtcNow;
+         await dbContext.SaveChangesAsync();
+         await transactionScope.CommitAsync();
+      }
    }
-}
+
+   public abstract Task Consume(TMessage message);
+}

src/MassTransit.PostgresOutbox/Constants.cs

@@ -1,7 +1,6 @@
-namespace MassTransit.PostgresOutbox
+namespace MassTransit.PostgresOutbox;
+
+public class Constants
 {
-   public class Constants
-   {
-      public const string OutboxMessageId = "OutboxMessageId";
-   }
-}
+   public const string OutboxMessageId = "OutboxMessageId";
+}

src/MassTransit.PostgresOutbox/Entities/InboxMessage.cs

@@ -1,13 +1,12 @@
 using MassTransit.PostgresOutbox.Enums;
 
-namespace MassTransit.PostgresOutbox.Entities
+namespace MassTransit.PostgresOutbox.Entities;
+
+public class InboxMessage
 {
-    public class InboxMessage
-    {
-        public required Guid MessageId { get; set; }
-        public required string ConsumerId { get; set; }
-        public MessageState State { get; set; } = MessageState.New;
-        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
-        public DateTime? UpdatedAt { get; set; }
-    }
-}
+    public required Guid MessageId { get; set; }
+    public required string ConsumerId { get; set; }
+    public MessageState State { get; set; } = MessageState.New;
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime? UpdatedAt { get; set; }
+}

src/MassTransit.PostgresOutbox/Entities/OutboxMessage.cs

@@ -1,15 +1,13 @@
 using MassTransit.PostgresOutbox.Enums;
 
-namespace MassTransit.PostgresOutbox.Entities
-{
-    public class OutboxMessage
-    {
-        public required Guid Id { get; set; }
-        public MessageState State { get; set; } = MessageState.New;
-        public required string Payload { get; set; }
-        public required string Type { get; set; }
-        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
-        public DateTime? UpdatedAt { get; set; }
+namespace MassTransit.PostgresOutbox.Entities;
 
-    }
-}
+public class OutboxMessage
+{
+    public required Guid Id { get; set; }
+    public MessageState State { get; set; } = MessageState.New;
+    public required string Payload { get; set; }
+    public required string Type { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime? UpdatedAt { get; set; }
+}

src/MassTransit.PostgresOutbox/Enums/MessageState.cs

@@ -1,8 +1,7 @@
-namespace MassTransit.PostgresOutbox.Enums
+namespace MassTransit.PostgresOutbox.Enums;
+
+public enum MessageState
 {
-   public enum MessageState
-   {
-      New = 1,
-      Done = 2,
-   }
-}
+    New = 1,
+    Done = 2,
+}