JustSaying

https://justeattakeaway.github.io/JustSaying/
Admin
JustSaying is a .NET library for publishing and consuming messages using AWS SNS/SQS with a fluent...
Tokens:32,192
Snippets:425
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Complete Subscriber Application Example

Source: https://justeattakeaway.github.io/JustSaying/advanced/encryption

Example of a subscriber application configured for JustSaying, with automatic decryption handled.

```csharp
services.AddJustSaying(config =>  
{
    config.Messaging(x => x.WithRegion("us-east-1"));
  
    config.Subscriptions(x =>  
    {
        // Automatic decryption - no encryption config needed  
        x.ForTopic<PatientRecordEvent>();
    });
});
  
services.AddJustSayingHandler<PatientRecordEvent, PatientRecordEventHandler>();

```

--------------------------------

### Complete JustSaying AWS Configuration Example

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration

A comprehensive example showing client, messaging, publications, and subscriptions configuration. It includes conditional configuration for development environments using LocalStack and production environments relying on IAM roles.

```csharp
services.AddJustSaying(config =>  
{
    config.Client(x =>  
    {
        if (hostEnvironment.IsDevelopment())
        {
            // LocalStack for local development  
            x.WithServiceUri(new Uri("http://localhost:4566"))  
             .WithAnonymousCredentials();  
        }
        // Production uses IAM roles automatically (no configuration needed)  
    });  

    config.Messaging(x =>  
    {
        x.WithRegion(configuration.GetValue<string>("AWS:Region"));  
    });  

    config.Publications(x =>  
    {
        x.WithTopic<OrderPlacedEvent>();  
    });  

    config.Subscriptions(x =>  
    {
        x.ForTopic<OrderPlacedEvent>();  
    });
});  

```

--------------------------------

### Install OpenTelemetry Extension Package

Source: https://justeattakeaway.github.io/JustSaying/messaging-configuration/opentelemetry

Install the `JustSaying.Extensions.OpenTelemetry` NuGet package to simplify the integration of JustSaying's `ActivitySource` and `Meter` with the OpenTelemetry SDK.

```bash
dotnet add package JustSaying.Extensions.OpenTelemetry
```

--------------------------------

### Start LocalStack via CLI

Source: https://justeattakeaway.github.io/JustSaying/advanced/testing

Command to initialize the LocalStack container using the test configuration.

```bash
docker-compose -f docker-compose.test.yml up -d  
```

--------------------------------

### Complete Publisher Application Example with Encryption

Source: https://justeattakeaway.github.io/JustSaying/advanced/encryption

Example of a publisher application configured for KMS encryption and publishing an encrypted message.

```csharp
services.AddJustSaying(config =>  
{
    config.Messaging(x => x.WithRegion("us-east-1"));
  
    config.Publications(x =>  
    {
        x.WithTopic<PatientRecordEvent>(cfg =>  
        {
            cfg.WithWriteConfiguration(w =>  
            {
                // Encrypt using KMS  
                w.Encryption = new ServerSideEncryption  
                {
                    KmsMasterKeyId = configuration["AWS:KMS:KeyId"]
                };
            });
        });
    });
});
  
// Publish encrypted message  
var publisher = serviceProvider.GetRequiredService<IMessagePublisher>();
await publisher.PublishAsync(new PatientRecordEvent  
{
    PatientId = 12345,
    MedicalData = "Sensitive information"
});

```

--------------------------------

### Production Configuration Pattern

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/credentials

Standard production setup using IAM roles automatically.

```csharp
// Production configuration - IAM role used automatically  
services.AddJustSaying(config =>  
{  
    config.Messaging(x => x.WithRegion("us-east-1"));  
    config.Publications(x => x.WithTopic<OrderPlacedEvent>());  
});
```

--------------------------------

### Start LocalStack with Docker Compose

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Command to start the LocalStack services defined in the `docker-compose.yml` file in detached mode.

```bash
docker-compose up -d

```

--------------------------------

### Configure Publisher for Compression

Source: https://justeattakeaway.github.io/JustSaying/advanced/compression

Example of applying compression settings to a specific event topic publication.

```csharp
config.Publications(x =>  
{  
    x.WithTopic<OrderDetailsEvent>(cfg =>  
    {  
        cfg.WithWriteConfiguration(w =>  
        {  
            w.CompressionOptions = new PublishCompressionOptions  
            {  
                CompressionEncoding = ContentEncodings.GzipBase64,  
                MessageLengthThreshold = 100_000  
            };  
        });  
    });  
});
```

--------------------------------

### Implement Batch Publishing in Minimal API

Source: https://justeattakeaway.github.io/JustSaying/publishing/batch-publishing

Example of using IMessageBatchPublisher within a Minimal API endpoint to process and publish bulk orders.

```csharp
// Controller endpoint  
app.MapPost("api/multi-orders",  
    async (IReadOnlyCollection<CustomerOrderModel> orders, IMessageBatchPublisher publisher) =>  
    {  
        app.Logger.LogInformation("Orders received: {@Orders}", orders);  
  
        // Transform to messages  
        var messages = orders.Select(order => new OrderPlacedEvent  
        {  
            OrderId = Random.Shared.Next(1, 100),  
            Description = order.Description  
        }).ToList();  
  
        // Publish batch  
        await publisher.PublishAsync(messages);  
  
        app.Logger.LogInformation(  
            "Orders {@OrderIds} placed",  
            messages.Select(x => x.OrderId));  
  
        return Results.Ok();  
    });  
```

--------------------------------

### Configure JustSaying for LocalStack

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Configure JustSaying to use LocalStack by setting the service URI and region. This example also includes anonymous credentials and specifies publications.

```csharp
services.AddJustSaying(config =>  
{
    config.Client(x =>  
    {
        x.WithServiceUri(new Uri("http://localhost:4566"))  
         .WithAnonymousCredentials();
    });

    config.Messaging(x =>  
    {
        x.WithRegion("us-east-1"); // LocalStack default region  
    });

    config.Publications(x =>  
    {
        x.WithTopic<OrderPlacedEvent>();
    });
});

```

--------------------------------

### Recommended: Single Call Setup for OpenTelemetry

Source: https://justeattakeaway.github.io/JustSaying/messaging-configuration/opentelemetry

Enable both tracing and metrics for JustSaying with a single call to `AddJustSayingInstrumentation()` on the `OpenTelemetryBuilder`. This method registers both traces and metrics, and further configuration for exporters and other instrumentations can be chained.

```csharp
builder.Services.AddOpenTelemetry()
    .AddJustSayingInstrumentation()
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddAspNetCoreInstrumentation()
        .AddOtlpExporter());
```

--------------------------------

### Docker Compose Setup for LocalStack

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Define a Docker Compose configuration to run LocalStack. This includes specifying the image, ports, environment variables, and volumes for persistent data.

```yaml
version: '3.8'

services:
  localstack:
    image: localstack/localstack:latest
    ports:
      - "4566:4566"
    environment:
      - SERVICES=sns,sqs
      - DEBUG=1
      - DATA_DIR=/tmp/localstack/data
    volumes:
      - "./localstack-data:/tmp/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"

```

--------------------------------

### Environment-Specific Service Endpoint Configuration

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Conditionally configure the service endpoint based on the hosting environment. This example sets up LocalStack for development and relies on IAM roles for production.

```csharp
services.AddJustSaying(config =>  
{
    config.Client(x =>  
    {
        if (hostEnvironment.IsDevelopment())
        {
            // LocalStack (local development)
            x.WithServiceUri(new Uri("http://localhost:4566"))  
             .WithAnonymousCredentials();
        }
        else
        {
            // Production uses real AWS (no service URL configuration)  
            // IAM role provides credentials automatically  
        }
    });

    config.Messaging(x =>  
    {
        x.WithRegion(configuration.GetValue<string>("AWS:Region"));
    });
});

```

--------------------------------

### Configure Publications with JustSaying

Source: https://justeattakeaway.github.io/JustSaying/publishing

Use the `Publications` fluent API within `AddJustSaying` to define where and how messages are published. This example shows publishing to both SNS topics and SQS queues.

```csharp
services.AddJustSaying(config =>  
{
    config.Publications(x =>  
    {
        // Publish to SNS topics  
        x.WithTopic<OrderPlacedEvent>();  

        // Publish to SQS queues  
        x.WithQueue<ProcessPaymentCommand>();  
    });  
});  

```

--------------------------------

### Error: No region endpoint specified

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Troubleshooting guide for the 'No region endpoint specified' error, emphasizing the need to configure the region.

```APIDOC
## Error: No region endpoint specified

### Description
This error occurs when the region is not configured. Ensure you call `.WithRegion(...)` in your messaging configuration.

### Method
Ensure `.WithRegion(...)` is called.

### Endpoint
N/A (Error Handling)

### Parameters
None

### Request Example
```csharp
config.Messaging(x =>  
{
    x.WithRegion("us-east-1"); // Required
});
```

### Response
N/A
```

--------------------------------

### Configure Advanced Write Options

Source: https://justeattakeaway.github.io/JustSaying/publishing/withqueue

Use WithWriteConfiguration to set advanced publishing options like encryption and message retention. This example shows configuring KMS encryption and message retention period.

```csharp
x.WithQueue<ProcessPaymentCommand>(cfg =>  
{
    cfg.WithWriteConfiguration(w =>  
    {
        w.WithEncryption("your-kms-key-id");
        w.WithMessageRetention(TimeSpan.FromDays(7));
    });
});  

```

--------------------------------

### Error: Invalid security token

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Troubleshooting guide for the 'The security token included in the request is invalid' error, focusing on region and credential mismatches.

```APIDOC
## Error: Invalid security token

### Description
This error may occur when credentials are valid for one region but you're trying to access resources in a different region. Verify that:
1. The region specified in `.WithRegion(...)` matches where your resources are located
2. Your IAM credentials have permissions for the specified region

### Method
Verify region and credential configuration.

### Endpoint
N/A (Error Handling)

### Parameters
None

### Request Example
```csharp
// Ensure the region in WithRegion matches your AWS resource location
config.Messaging(x =>  
{
    x.WithRegion("your-actual-region");
});

// Ensure your IAM credentials have permissions for that region
```

### Response
N/A
```

--------------------------------

### Implement Bus Startup with BackgroundService

Source: https://justeattakeaway.github.io/JustSaying/getting-started

Uses a .NET BackgroundService to manage the lifecycle of the messaging bus and publisher.

```csharp
public class BusService : BackgroundService  
{  
    private readonly IMessagingBus _bus;  
    private readonly ILogger<BusService> _logger;  
    private IMessagePublisher _publisher;  
  
    public BusService(IMessagingBus bus, ILogger<BusService> logger, IMessagePublisher publisher)  
    {  
        _bus = bus;  
        _logger = logger;  
        _publisher = publisher;  
    }  
  
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)  
    {  
        _logger.LogInformation("Bus is starting up...");  
  
        await _publisher.StartAsync(stoppingToken);  
        await _bus.StartAsync(stoppingToken);  
    }  
}
```

--------------------------------

### Configure AWS Services with JustSaying

Source: https://justeattakeaway.github.io/JustSaying/getting-started

Sets up AWS credentials and regions, including support for LocalStack in development environments.

```csharp
services.AddJustSaying(config =>  
{  
    config.Client(x =>  
    {  
        if (hostEnvironment.IsDevelopment())  
        {  
            // LocalStack for local development  
            x.WithServiceUri(new Uri("http://localhost:4566"))  
             .WithAnonymousCredentials();  
        }  
        // Production uses IAM roles automatically (no configuration needed)  
    });  
  
    config.Messaging(x => x.WithRegion("us-east-1"));  
  
    config.Publications(x => x.WithTopic<OrderPlacedEvent>());  
    config.Subscriptions(x => x.ForTopic<OrderReadyEvent>());  
});
```

--------------------------------

### Configure Subscriber for Specific Tenant Topics

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Configure subscribers to listen to specific tenant-named topics using `ForTopic<TMessage>(string topicName)`.

```csharp
config.Subscriptions(x =>  
{
    // Subscribe to specific tenant topics  
    x.ForTopic<OrderPlacedEvent>("tenant-acme-orders");  
    x.ForTopic<OrderPlacedEvent>("tenant-contoso-orders");  
});  

services.AddJustSayingHandler<OrderPlacedEvent, OrderPlacedEventHandler>();  

```

--------------------------------

### Handler Receiving Decrypted Messages

Source: https://justeattakeaway.github.io/JustSaying/advanced/encryption

Example handler that automatically receives decrypted messages. No explicit decryption logic is needed within the handler.

```csharp
public class PatientRecordEventHandler : IHandlerAsync<PatientRecordEvent>  
{
    public Task<bool> Handle(PatientRecordEvent message)  
    {
        // Message is automatically decrypted  
        Console.WriteLine($"Processing patient {message.PatientId}");
        return Task.FromResult(true);
    }
}

```

--------------------------------

### Initialize Messaging Configuration

Source: https://justeattakeaway.github.io/JustSaying/messaging-configuration

The entry point for configuring global messaging settings within the JustSaying service registration.

```csharp
services.AddJustSaying((MessagingBusBuilder config) =>  
{  
    config.Messaging((MessagingConfigurationBuilder messagingConfig) =>  
    {  
        // here  
    });  
  
});
```

--------------------------------

### KMS Key Policy for Application Access

Source: https://justeattakeaway.github.io/JustSaying/advanced/encryption

Example KMS key policy statement allowing an application role to perform decryption and generate data keys.

```json
{
    "Sid": "Allow application to use the key",
    "Effect": "Allow",
    "Principal": {
        "AWS": "arn:aws:iam::123456789012:role/YourApplicationRole"
    },
    "Action": [
        "kms:Decrypt",
        "kms:GenerateDataKey"
    ],
    "Resource": "*"
}

```

--------------------------------

### Configure SNS Topic with Tags

Source: https://justeattakeaway.github.io/JustSaying/publishing/withtopic

When creating a topic with `WithTopic<T>()`, you can provide a configuration lambda to add tags for organization and cost allocation.

```csharp
config.Publications(x =>  
{
    x.WithTopic<OrderReadyEvent>(cfg =>  
    {
        cfg.WithTag("IsOrderEvent")  
           .WithTag("Publisher", "KitchenConsole");  
    });
});  

```

--------------------------------

### Configure JustSaying for Integration Tests

Source: https://justeattakeaway.github.io/JustSaying/advanced/testing

Set up the JustSaying client to point to the local LocalStack instance.

```csharp
public class IntegrationTestBase : IDisposable  
{  
    protected IServiceProvider ServiceProvider { get; }  
  
    public IntegrationTestBase()  
    {  
        var services = new ServiceCollection();  
  
        services.AddJustSaying(config =>  
        {  
            config.Client(x =>  
            {  
                x.WithServiceUri(new Uri("http://localhost:4566"))  
                 .WithAnonymousCredentials();  
            });  
  
            config.Messaging(x => x.WithRegion("us-east-1"));  
  
            config.Publications(x =>  
            {  
                x.WithTopic<TestOrderEvent>();  
            });  
  
            config.Subscriptions(x =>  
            {  
                x.ForTopic<TestOrderEvent>();  
            });  
        });  
  
        services.AddJustSayingHandler<TestOrderEvent, TestOrderEventHandler>();  
        services.AddHostedService<BusService>();  
  
        ServiceProvider = services.BuildServiceProvider();  
    }  
  
    public void Dispose()  
    {  
        (ServiceProvider as IDisposable)?.Dispose();  
    }  
}  
```

--------------------------------

### Configure Application with Dynamic Topics

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Configure JustSaying with dynamic topic names based on message content, ensuring tenant IDs are validated. This approach requires careful management to avoid excessive topic creation.

```csharp
services.AddJustSaying(config =>
{
    config.Messaging(x => x.WithRegion("us-east-1"));

    config.Publications(x =>
    {
        // Dynamic topic based on tenant
        x.WithTopic<TenantEvent>(cfg =>
        {
            cfg.WithTopicName(msg =>
            {
                var evt = (TenantEvent)msg;

                // Validate tenant ID
                if (string.IsNullOrEmpty(evt.TenantId))
                    throw new ArgumentException("TenantId is required");

                return $"tenant-{evt.TenantId.ToLowerInvariant()}-events";
            });
        });
    });
});
```

--------------------------------

### Configure Basic Credentials

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/credentials

Uses explicit access and secret keys. Not recommended for production due to security risks.

```csharp
config.Client(x =>  
{  
    x.WithBasicCredentials(  
        configuration["AWS:AccessKey"],  
        configuration["AWS:SecretKey"]  
    );  
});
```

--------------------------------

### Configure Topic and Queue Publications

Source: https://justeattakeaway.github.io/JustSaying/publishing/write-configuration

Use `Publications` with `WithTopic` or `WithQueue` to configure write settings for topics and queues.

```csharp
config.Publications(x =>  
{
    // For topics
    x.WithTopic<OrderPlacedEvent>(cfg =>  
    {
        cfg.WithWriteConfiguration(w =>  
        {
            // Configure SNS write settings
        });
    });

    // For queues
    x.WithQueue<ProcessPaymentCommand>(cfg =>  
    {
        cfg.WithWriteConfiguration(w =>  
        {
            // Configure SQS write settings
        });
    });
});

```

--------------------------------

### Configure JustSaying Compression

Source: https://justeattakeaway.github.io/JustSaying/advanced/compression

Sets up compression within the JustSaying service configuration for a specific topic.

```csharp
services.AddJustSaying(config =>  
{  
    config.Messaging(x => x.WithRegion("us-east-1"));  
  
    config.Publications(x =>  
    {  
        x.WithTopic<LargeDataEvent>(cfg =>  
        {  
            cfg.WithWriteConfiguration(w =>  
            {  
                w.CompressionOptions = new PublishCompressionOptions  
                {  
                    CompressionEncoding = ContentEncodings.GzipBase64,  
                    MessageLengthThreshold = 100_000 // Compress if > 100KB  
                };  
            });  
        });  
    });  
});
```

--------------------------------

### Implement Single and Batch Publishing

Source: https://justeattakeaway.github.io/JustSaying/publishing/batch-publishing

Demonstrates injecting both IMessagePublisher and IMessageBatchPublisher to handle individual and bulk message publishing respectively.

```csharp
public class OrderService  
{  
    private readonly IMessagePublisher _publisher;  
    private readonly IMessageBatchPublisher _batchPublisher;  
  
    public OrderService(  
        IMessagePublisher publisher,  
        IMessageBatchPublisher batchPublisher)  
    {  
        _publisher = publisher;  
        _batchPublisher = batchPublisher;  
    }  
  
    public async Task PublishSingleOrder(OrderPlacedEvent order)  
    {  
        // Single message  
        await _publisher.PublishAsync(order);  
    }  
  
    public async Task PublishBulkOrders(IEnumerable<OrderPlacedEvent> orders)  
    {  
        // Multiple messages  
        await _batchPublisher.PublishAsync(orders);  
    }  
}  
```

--------------------------------

### Configure Region from Application Settings

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Load the region from external configuration files like appsettings.json.

```json
{
  "AWS": {  
    "Region": "us-east-1"  
  }
}
```

```csharp
services.AddJustSaying(config =>  
{  
    config.Messaging(x =>  
    {  
        x.WithRegion(configuration.GetValue<string>("AWS:Region"));  
    });  
});  
```

--------------------------------

### LocalStack Configuration

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Configure JustSaying to use LocalStack for local development, typically defaulting to 'us-east-1'.

```APIDOC
## LocalStack Configuration

### Description
LocalStack typically uses `us-east-1` as the default region.

### Method
`WithServiceUri`, `WithAnonymousCredentials`, `WithRegion`

### Endpoint
N/A (Configuration Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
services.AddJustSaying(config =>  
{
    config.Client(x =>  
    {
        if (hostEnvironment.IsDevelopment())
        {
            x.WithServiceUri(new Uri("http://localhost:4566"))
             .WithAnonymousCredentials();
        }
    });

    config.Messaging(x =>  
    {
        // LocalStack default region
        x.WithRegion("us-east-1");
    });
});
```

### Response
N/A
```

--------------------------------

### Region and Credentials Configuration

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Demonstrates how to configure both AWS region and credentials independently within JustSaying.

```APIDOC
## Region and Credentials

### Description
The region configuration is independent of credentials configuration.

### Method
`WithBasicCredentials`, `WithRegion`

### Endpoint
N/A (Configuration Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
services.AddJustSaying(config =>  
{
    // Credentials (optional - uses IAM role by default)
    config.Client(x =>  
    {
        x.WithBasicCredentials(accessKey, secretKey);
    });

    // Region (required)
    config.Messaging(x =>  
    {
        x.WithRegion("eu-west-1");
    });
});
```

### Response
N/A
```

--------------------------------

### Configure a direct queue subscription

Source: https://justeattakeaway.github.io/JustSaying/subscriptions/configuration/forqueue

Creates a queue for the specified message type using the default naming convention, along with a corresponding error queue.

```csharp
x.ForQueue<OrderReadyEvent>();
```

--------------------------------

### Configure Subscription Read Settings

Source: https://justeattakeaway.github.io/JustSaying/subscriptions/configuration/sqsreadconfiguration

Use WithReadConfiguration to access various settings for a subscription, such as message encryption, error queue behavior, and retention policies. Configuration is applied per queue or topic.

```csharp
x.ForTopic<OrderReadyEvent>(c =>
{
    c.WithReadConfiguration(rc =>
    {
        // configure here!
    });
});

```

--------------------------------

### Configure a Topic for a Message Type

Source: https://justeattakeaway.github.io/JustSaying/subscriptions/configuration/fortopic

Initializes a topic and queue pair for the specified message type T using default naming conventions.

```csharp
x.ForTopic<OrderReadyEvent>();
```

--------------------------------

### Manage LocalStack with Testcontainers

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Use Testcontainers to spin up a LocalStack instance and configure the JustSaying client to point to the local service URI.

```csharp
var localStackContainer = new ContainerBuilder()  
    .WithImage("localstack/localstack:latest")  
    .WithPortBinding(4566, 4566)  
    .WithEnvironment("SERVICES", "sns,sqs")  
    .Build();  
  
await localStackContainer.StartAsync();  
  
services.AddJustSaying(config =>  
{  
    config.Client(x =>  
    {  
        x.WithServiceUri(new Uri("http://localhost:4566"))  
         .WithAnonymousCredentials();  
    });  
});
```

--------------------------------

### Configure Region and Credentials Independently

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Region configuration is separate from credential management.

```csharp
services.AddJustSaying(config =>  
{  
    // Credentials (optional - uses IAM role by default)  
    config.Client(x =>  
    {  
        x.WithBasicCredentials(accessKey, secretKey);  
    });  
  
    // Region (required)  
    config.Messaging(x =>  
    {  
        x.WithRegion("eu-west-1");  
    });  
});  
```

--------------------------------

### Configure Publications for Batching

Source: https://justeattakeaway.github.io/JustSaying/publishing/batch-publishing

Register topics for batch publishing within the AddJustSaying configuration block.

```csharp
services.AddJustSaying(config =>  
{  
    config.Messaging(x => x.WithRegion("us-east-1"));  
  
    config.Publications(x =>  
    {  
        // This topic supports both single and batch publishing  
        x.WithTopic<OrderPlacedEvent>();  
    });  
});  
```

--------------------------------

### Troubleshoot LocalStack Connectivity

Source: https://justeattakeaway.github.io/JustSaying/advanced/testing

Commands to verify LocalStack status and inspect container logs when tests fail to connect.

```bash
docker logs justsaying-localstack-1  
```

```bash
curl http://localhost:4566/_localstack/health  
```

--------------------------------

### Configure Advanced SNS Write Options

Source: https://justeattakeaway.github.io/JustSaying/publishing/withtopic

Utilize `WithWriteConfiguration` to customize advanced publishing settings for SNS topics, such as encryption using KMS.

```csharp
x.WithTopic<OrderPlacedEvent>(cfg =>  
{
    cfg.WithWriteConfiguration(w =>  
    {
        w.Encryption = new ServerSideEncryption  
        {
            KmsMasterKeyId = "your-kms-key-id"
        };
    });
});  

```

--------------------------------

### Publishing Service for Tenant Orders

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

A service to publish order placement events, dynamically determining the topic based on the tenant ID. Ensure the OrderPlacedEvent includes the TenantId property.

```csharp
public class TenantOrderService
{
    private readonly IMessagePublisher _publisher;

    public TenantOrderService(IMessagePublisher publisher)
    {
        _publisher = publisher;
    }

    public async Task PlaceOrder(string tenantId, int orderId)
    {
        // Topic determined from TenantId at publish time
        await _publisher.PublishAsync(new OrderPlacedEvent
        {
            TenantId = tenantId,
            OrderId = orderId,
            Description = "New order"
        });
    }
}
```

--------------------------------

### Credential Configuration Methods

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/credentials

Methods available within the Client configuration fluent API to define how JustSaying authenticates with AWS.

```APIDOC
## Credential Configuration Methods

### Description
Methods to configure AWS credentials for JustSaying. By default, the library uses the AWS SDK credential provider chain (Environment variables, ~/.aws/credentials, or IAM roles).

### Methods
- **WithAnonymousCredentials()**: Uses no authentication. For testing/LocalStack only.
- **WithBasicCredentials(string accessKey, string secretKey)**: Uses explicit access and secret keys.
- **WithSessionCredentials(string accessKeyId, string secretAccessKey, string token)**: Uses temporary credentials with a session token.
- **WithCredentials(AWSCredentials credentials)**: Uses a custom AWS SDK credential provider object.

### Request Example
```csharp
config.Client(x => 
{
    x.WithBasicCredentials("accessKey", "secretKey");
});
```
```

--------------------------------

### Configure MessagingBusBuilder Publications

Source: https://justeattakeaway.github.io/JustSaying/publishing/configuration

Initializes the publication configuration block within the JustSaying service registration.

```csharp
services.AddJustSaying(config =>  
{  
    config.Publications(x =>  
    {  
        // Configure publications here  
    });  
});  
```

--------------------------------

### Mock IMessagePublisher for Unit Testing

Source: https://justeattakeaway.github.io/JustSaying/advanced/testing

Use Moq to verify that the publisher correctly sends messages to the bus.

```csharp
public class OrderServiceTests  
{  
    [Fact]  
    public async Task PlaceOrder_PublishesOrderPlacedEvent()  
    {  
        // Arrange  
        var mockPublisher = new Mock<IMessagePublisher>();  
        var service = new OrderService(mockPublisher.Object);  
  
        // Act  
        await service.PlaceOrder(123, "Test order");  
  
        // Assert  
        mockPublisher.Verify(  
            x => x.PublishAsync(  
                It.Is<OrderPlacedEvent>(e => e.OrderId == 123),  
                It.IsAny<CancellationToken>()),  
            Times.Once);  
    }  
}  
```

--------------------------------

### Configure Dependency Injection

Source: https://justeattakeaway.github.io/JustSaying/getting-started

Use the AddJustSaying extension method to configure AWS regions, publications, and subscriptions. Requires the JustSaying.Extensions.DependencyInjection package.

```csharp
public void ConfigureServices(IServiceCollection services)  
{  
    services.AddJustSaying(config =>  
        {  
            config.Messaging(x =>  
            {  
                // Configures which AWS Region to operate in  
                x.WithRegion(_configuration.GetAWSRegion());  
            });  
  
            config.Publications(x =>  
            {  
                // Creates the following if they do not already exist  
                //  - a SNS topic of name `orderplacedevent`  
                x.WithTopic<OrderPlacedEvent>();  
            });  
  
            config.Subscriptions(x =>  
            {  
                // Creates the following if they do not already exist  
                //  - a SQS queue of name `orderreadyevent`  
                //  - a SQS queue of name `orderreadyevent_error`  
                //  - a SNS topic of name `orderreadyevent`  
                //  - a SNS topic subscription on topic 'orderreadyevent' and queue 'orderreadyevent'  
                x.ForTopic<OrderReadyEvent>();  
            });  
        });  
  
    services.AddJustSayingHandler<OrderReadyEvent, OrderReadyEventHandler>();  
  
}  

```

--------------------------------

### Configure JustSaying with Service URL from Settings

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Retrieve the LocalStack service URL from configuration settings and apply it to JustSaying's client configuration. This allows externalizing endpoint configuration.

```csharp
services.AddJustSaying(config =>  
{
    config.Client(x =>  
    {
        var serviceUrl = configuration.GetValue<string>("AWS:ServiceUrl");
        if (!string.IsNullOrEmpty(serviceUrl))
        {
            x.WithServiceUri(new Uri(serviceUrl))  
             .WithAnonymousCredentials();
        }
    });

    config.Messaging(x =>  
    {
        x.WithRegion(configuration.GetValue<string>("AWS:Region"));
    });
});

```

--------------------------------

### Add Custom Middleware to Pipeline

Source: https://justeattakeaway.github.io/JustSaying/subscriptions/middleware

Use `WithMiddlewareConfiguration` to add custom middleware like `MyMiddleware` and `SimpleMessage` to the pipeline. Ensure `UseDefaults` is called to process messages.

```csharp
c.WithReadConfiguration(rc =>  
    rc.WithMiddlewareConfiguration(m =>  
    {  
        m.Use<MyMiddleware>();  
        m.UseExactlyOnce<SimpleMessage>("simple-message-lock");  
        m.UseDefaults<SimpleMessage>(typeof(SimpleMessageHandler));   // Add default middleware pipeline  
    }))  

```

--------------------------------

### Mock IMessageBatchPublisher for Unit Testing

Source: https://justeattakeaway.github.io/JustSaying/advanced/testing

Verify batch publishing behavior by mocking the IMessageBatchPublisher interface.

```csharp
[Fact]  
public async Task PlaceBulkOrders_PublishesBatchOfEvents()  
{  
    // Arrange  
    var mockBatchPublisher = new Mock<IMessageBatchPublisher>();  
    var service = new OrderService(mockBatchPublisher.Object);  
  
    var orders = new[] { "Order 1", "Order 2", "Order 3" };  
  
    // Act  
    await service.PlaceBulkOrders(orders);  
  
    // Assert  
    mockBatchPublisher.Verify(  
        x => x.PublishAsync(  
            It.Is<IEnumerable<OrderPlacedEvent>>(  
                events => events.Count() == 3),  
            It.IsAny<CancellationToken>()),  
        Times.Once);  
}  
```

--------------------------------

### Create KMS Key using AWS CLI

Source: https://justeattakeaway.github.io/JustSaying/advanced/encryption

Commands to create a new KMS key and an alias for it using the AWS CLI.

```bash
aws kms create-key \
    --description "JustSaying message encryption" \
    --key-usage ENCRYPT_DECRYPT  

aws kms create-alias \
    --alias-name alias/justsaying-messages \
    --target-key-id <key-id-from-previous-command>

```

--------------------------------

### Default AWS Credentials File Usage

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/credentials

Implicitly uses the ~/.aws/credentials file.

```csharp
// Uses ~/.aws/credentials file automatically  
services.AddJustSaying(config =>  
{  
    config.Messaging(x => x.WithRegion("us-east-1"));  
});
```

--------------------------------

### Configure JustSaying with Environment-Specific AWS Credentials

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/credentials

Configure JustSaying to use different AWS credential methods based on the hosting environment. Supports LocalStack for development, named profiles for staging, and IAM roles for production.

```csharp
services.AddJustSaying(config =>  
{
    config.Client(x =>  
    {
        if (hostEnvironment.IsDevelopment())
        {
            // LocalStack for local development
            x.WithServiceUri(new Uri("http://localhost:4566")) 
             .WithAnonymousCredentials();
        }
        else if (hostEnvironment.IsStaging())
        {
            // Named profile for staging environment
            x.WithCredentials(new StoredProfileAWSCredentials("staging"));
        }
        // Production uses IAM role (no configuration)
    });

    config.Messaging(x =>  
    {
        x.WithRegion(configuration.GetValue<string>("AWS:Region"));
    });
});

```

--------------------------------

### Configure Topic with Encryption and Compression

Source: https://justeattakeaway.github.io/JustSaying/publishing/write-configuration

Use this configuration to encrypt messages at rest using AWS KMS and compress large messages to reduce costs. Set the KMS Master Key ID and configure compression options.

```csharp
config.Publications(x =>  
{
    x.WithTopic<LargeSecureEvent>(cfg =>  
    {
        cfg.WithWriteConfiguration(w =>  
        {
            // Encrypt at rest  
            w.Encryption = new ServerSideEncryption  
            {
                KmsMasterKeyId = "your-kms-key-id"
            };

            // Compress large messages  
            w.CompressionOptions = new PublishCompressionOptions  
            {
                CompressionEncoding = ContentEncodings.GzipBase64,
                MessageLengthThreshold = 50_000
            };
        });
    });
});  

```

--------------------------------

### Configure LocalStack with Docker Compose

Source: https://justeattakeaway.github.io/JustSaying/advanced/testing

Define a LocalStack service in a docker-compose.test.yml file to simulate AWS services locally.

```yaml
version: '3.8'  
  
services:  
  localstack:  
    image: localstack/localstack:latest  
    ports:  
      - "4566:4566"  
    environment:  
      - SERVICES=sns,sqs  
      - DEBUG=1  
      - DATA_DIR=/tmp/localstack/data  
    volumes:  
      - "./localstack-data:/tmp/localstack"  
```

--------------------------------

### Configure JustSaying with .NET Aspire

Source: https://justeattakeaway.github.io/JustSaying/messaging-configuration/opentelemetry

Integrates JustSaying into a .NET Aspire application, registering message handlers, subscriptions, publications, and OpenTelemetry instrumentation for tracing and metrics.

```csharp
var builder = WebApplication.CreateBuilder(args);

// Register JustSaying
builder.Services.AddJustSaying(config =>
{
    config.Messaging(x => x.WithRegion("eu-west-1"));
    config.Subscriptions(x => x.ForTopic<OrderPlaced>());
    config.Publications(x => x.WithTopic<OrderPlaced>());
});

builder.Services.AddJustSayingHandler<OrderPlaced, OrderPlacedHandler>();

// Register OpenTelemetry with JustSaying instrumentation
builder.Services.AddOpenTelemetry()
    .AddJustSayingInstrumentation()
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddOtlpExporter());

var app = builder.Build();
app.Run();
```

--------------------------------

### Configure AWS Client with Anonymous Credentials and LocalStack

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration

Configures the AWS SDK client with anonymous credentials and a service URI for LocalStack. Use this for local development environments.

```csharp
services.AddJustSaying(config =>  
{
    config.Client(x =>  
    {
        // AWS client configuration  
        x.WithAnonymousCredentials();  
        x.WithServiceUri(new Uri("http://localhost:4566"));  
    });
});  

```

--------------------------------

### Configure Dynamic Queue Naming

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Configure JustSaying to use dynamic queue names based on message content. This is useful for tenant-specific queues.

```csharp
config.Publications(x =>
{
    x.WithQueue<OrderCommand>(cfg =>
    {
        cfg.WithQueueName(msg =>
        {
            var cmd = (OrderCommand)msg;
            return $"tenant-{cmd.TenantId}-commands";
        });
    });
});
```

--------------------------------

### Configure Environment-Specific Regions

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Dynamically set the region based on the current hosting environment.

```csharp
services.AddJustSaying(config =>  
{  
    config.Messaging(x =>  
    {  
        var region = hostEnvironment.IsProduction()  
            ? "us-east-1"  // Production in US East  
            : "us-west-2"; // Development in US West  
  
        x.WithRegion(region);  
    });  
});  
```

--------------------------------

### Configuration from Application Settings

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Store the AWS region in your application configuration files (e.g., appsettings.json) and retrieve it during startup.

```APIDOC
## Configuration from Application Settings

### Description
Store the region in your application configuration (`appsettings.json`, environment variables, etc.) and retrieve it during startup.

### Method
`WithRegion(string region)` using configuration value

### Endpoint
N/A (Configuration Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
**appsettings.json**:
```json
{
  "AWS": {
    "Region": "us-east-1"
  }
}
```

**Startup configuration**:
```csharp
services.AddJustSaying(config =>  
{
    config.Messaging(x =>  
    {
        x.WithRegion(configuration.GetValue<string>("AWS:Region"));
    });
});
```

### Response
N/A
```

--------------------------------

### Configure JustSaying Publisher

Source: https://justeattakeaway.github.io/JustSaying/Configuration

Registers an SNS topic for the specified event type within the JustSaying bus configuration.

```csharp
    services.AddJustSaying(bus =>  
    {  
        bus.Publications(publication =>  
        {  
            // Creates the SNS Topic  
            publication.WithTopic<OrderPlacedEvent>();  
        });  
    }  
```

--------------------------------

### Configure Region for LocalStack

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Set the region and service URI for local development environments using LocalStack.

```csharp
services.AddJustSaying(config =>  
{  
    config.Client(x =>  
    {  
        if (hostEnvironment.IsDevelopment())  
        {  
            x.WithServiceUri(new Uri("http://localhost:4566"))  
             .WithAnonymousCredentials();  
        }  
    });  
  
    config.Messaging(x =>  
    {  
        // LocalStack default region  
        x.WithRegion("us-east-1");  
    });  
});  
```

--------------------------------

### WithWriteConfiguration

Source: https://justeattakeaway.github.io/JustSaying/publishing/write-configuration

Configures publication behavior for SNS topics and SQS queues, including encryption, compression, and error handling.

```APIDOC
## WithWriteConfiguration

### Description
Configures publication settings for specific topics or queues. Settings are applied per topic or queue using the publication builder.

### Request Body
- **Encryption** (ServerSideEncryption) - Optional - Server-side encryption settings using AWS KMS.
- **CompressionOptions** (PublishCompressionOptions) - Optional - Compression encoding and message length threshold.
- **HandleException** (Func<Exception, Message, bool>) - Optional - Custom exception handler for publish failures.
- **Subject** (string) - Optional - Custom SNS message subject.
- **IsRawMessage** (bool) - Optional - If true, publishes without the JustSaying envelope.
- **WithEncryption** (string/ServerSideEncryption) - Optional - SQS specific encryption configuration.
- **WithErrorQueue** (void) - Optional - Enables error queue creation.
- **WithNoErrorQueue** (void) - Optional - Disables error queue creation.
- **WithMessageRetention** (TimeSpan) - Optional - Sets message retention period (60s to 14 days).
- **WithVisibilityTimeout** (TimeSpan) - Optional - Sets message visibility timeout duration.
```

--------------------------------

### Configure Multi-Region Messaging

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Create separate bus instances when publishing to or subscribing from multiple regions.

```csharp
// US East bus  
services.AddJustSaying(config =>  
{  
    config.Messaging(x => x.WithRegion("us-east-1"));  
    config.Publications(x => x.WithTopic<USOrderEvent>());  
});  
  
// EU West bus (requires additional configuration to avoid conflicts)  
// Note: Multiple bus instances require careful service registration  
```

--------------------------------

### Configure SNS Topic Encryption

Source: https://justeattakeaway.github.io/JustSaying/advanced/encryption

Use `WithWriteConfiguration` to specify KMS encryption for SNS topics. Ensure the `KmsMasterKeyId` is correctly set.

```csharp
services.AddJustSaying(config =>  
{
    config.Messaging(x => x.WithRegion("us-east-1"));
  
    config.Publications(x =>  
    {
        x.WithTopic<SecureOrderEvent>(cfg =>  
        {
            cfg.WithWriteConfiguration(w =>  
            {
                w.Encryption = new ServerSideEncryption  
                {
                    KmsMasterKeyId = "arn:aws:kms:us-east-1:123456789012:key/your-key-id"
                };
            });
        });
    });
});

```

--------------------------------

### Define Message with Tenant Information

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Define message classes that include tenant-specific properties, such as `TenantId`, which will be used to determine the topic name.

```csharp
public class OrderPlacedEvent : Message  
{
    public string TenantId { get; set; }
    public int OrderId { get; set; }
    public string Description { get; set; }
}

```

--------------------------------

### SqsReadConfiguration Fluent API

Source: https://justeattakeaway.github.io/JustSaying/subscriptions/configuration/sqsreadconfiguration

Methods available within the WithReadConfiguration block to tune subscription behavior.

```APIDOC
## SqsReadConfiguration

### Description
Configures settings for a specific queue/topic subscription using the fluent API.

### Methods
- **WithEncryption(kmsKeyId, cachingPeriod)**: Configures message level encryption using AWS KMS. Default caching period is 5 minutes.
- **WithErrorQueue()**: Specifies that an error queue should be created (default).
- **WithNoErrorQueue()**: Disables error queue creation.
- **WithErrorQueueOptOut(bool)**: Explicitly opts in or out of error queue creation.
- **WithMessageRetention(duration)**: Sets message retention duration. Default is 4 days.
- **WithVisibilityTimeout(duration)**: Sets the duration a message is invisible while being handled. Default is 30 seconds.
- **WithTopicSourceAccount(accountId)**: Configures cross-account topic subscription.
- **WithSubscriptionGroup(groupId)**: Assigns the subscription to a specific group.
- **WithMiddlewareConfiguration(config)**: Customizes the middleware pipeline.

### Usage Example
```csharp
x.ForTopic<OrderReadyEvent>(c =>  
{  
    c.WithReadConfiguration(rc =>  
    {  
        rc.WithEncryption("kms-key-id");
        rc.WithMessageRetention(TimeSpan.FromDays(7));
        rc.WithVisibilityTimeout(TimeSpan.FromSeconds(60));
    });  
});
```
```

--------------------------------

### Verify LocalStack Status

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Command to check if the LocalStack container is running.

```bash
docker ps
```

--------------------------------

### Publish Messages with Dynamic Topics

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Publish messages as usual. JustSaying automatically determines the correct topic name based on the `WithTopicName` configuration.

```csharp
// Publishes to topic: tenant-acme-orders  
await publisher.PublishAsync(new OrderPlacedEvent  
{
    TenantId = "acme",  
    OrderId = 123,  
    Description = "Office supplies"
});  

// Publishes to topic: tenant-contoso-orders  
await publisher.PublishAsync(new OrderPlacedEvent  
{
    TenantId = "contoso",  
    OrderId = 456,  
    Description = "Electronics"
});  

```

--------------------------------

### Execute Integration Test

Source: https://justeattakeaway.github.io/JustSaying/advanced/testing

Verify end-to-end message publishing and handling using the configured integration test base.

```csharp
public class MessagePublishingTests : IntegrationTestBase  
{  
    [Fact]  
    public async Task Can_Publish_And_Receive_Message()  
    {  
        // Arrange  
        var publisher = ServiceProvider.GetRequiredService<IMessagePublisher>();  
        var handler = ServiceProvider.GetRequiredService<TestOrderEventHandler>();  
  
        var message = new TestOrderEvent  
        {  
            OrderId = 123,  
            Description = "Integration test order"  
        };  
  
        // Act  
        await publisher.PublishAsync(message);  
  
        // Wait for message to be received  
        await Task.Delay(TimeSpan.FromSeconds(5));  
  
        // Assert  
        Assert.True(handler.HandledMessages.ContainsKey(123));  
    }  
}  
```

--------------------------------

### Configure Dynamic Topic Naming for Publications

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Configure publications to use dynamic topic names by providing a function to `WithTopicName`. This function receives the message and returns the topic name string.

```csharp
services.AddJustSaying(config =>  
{
    config.Messaging(x => x.WithRegion("us-east-1"));

    config.Publications(x => 
    {
        x.WithTopic<OrderPlacedEvent>(cfg => 
        {
            cfg.WithTopicName(msg => 
            {
                var order = (OrderPlacedEvent)msg;
                return $"tenant-{order.TenantId}-orders";
            });
        });
    });
});  

```

```csharp
config.Publications(x =>  
{
    x.WithTopic<OrderPlacedEvent>(cfg => 
    {
        cfg.WithTopicName(msg => 
        {
            var order = (OrderPlacedEvent)msg;
            return $"tenant-{order.TenantId}-orders";
        });
    });
});  

```

--------------------------------

### Configure Region using String

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/regions

Specify the AWS region using a region code string.

```APIDOC
## Configure Region using String

### Description
Specify the AWS region using a region code string.

### Method
`WithRegion(string region)`

### Endpoint
N/A (Configuration Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
services.AddJustSaying(config =>  
{
    config.Messaging(x =>  
    {
        x.WithRegion("us-east-1");
    });
});
```

### Response
N/A

### Common Region Codes
* `us-east-1` - US East (Virginia)
* `us-west-2` - US West (Oregon)
* `eu-west-1` - Europe (Ireland)
* `eu-central-1` - Europe (Frankfurt)
* `ap-southeast-1` - Asia Pacific (Singapore)
* `ap-northeast-1` - Asia Pacific (Tokyo)

See the AWS Regions documentation for a complete list.
```

--------------------------------

### Publish to an Existing SQS Queue by URL

Source: https://justeattakeaway.github.io/JustSaying/publishing/withqueue

Use WithQueueUrl<T>(string queueUrl) to publish messages of type T to a pre-existing SQS queue identified by its URL.

```csharp
config.Publications(x =>  
x.WithQueueUrl<ProcessPaymentCommand>("https://sqs.us-east-1.amazonaws.com/123456789012/my-queue");
});  

```

--------------------------------

### List SNS Topics using AWS CLI

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Monitor the number of SNS topics in a region using the AWS CLI and `jq` for parsing the output. This is useful for staying within AWS account limits.

```bash
aws sns list-topics --region us-east-1 | jq '.Topics | length'  

```

--------------------------------

### MessagingBusBuilder Configuration

Source: https://justeattakeaway.github.io/JustSaying/subscriptions/configuration

Configuring messaging subscriptions via the MessagingBusBuilder fluent API.

```APIDOC
## Configuration via MessagingBusBuilder

### Description
Access subscription configuration using the `MessagingBusBuilder.Subscriptions` fluent API within the service registration.

### Usage
```csharp
services.AddJustSaying((MessagingBusBuilder config) =>  
{  
    config.Subscriptions((SubscriptionsBuilder subscriptionConfig) =>  
    {  
        // Subscription configuration logic here  
    });  
});
```

### Topology Builders
- **ForTopic<T>**: Configures subscription topology for a topic.
- **ForQueue<T>**: Configures subscription topology for a queue.
```

--------------------------------

### List AWS SNS Topics

Source: https://justeattakeaway.github.io/JustSaying/advanced/dynamic-topics

Use the AWS CLI to list all SNS topics in a specific region. This command helps in monitoring and managing topics.

```bash
# List all topics
aws sns list-topics --region us-east-1
```

--------------------------------

### Configuration for LocalStack Service URL in appsettings.Development.json

Source: https://justeattakeaway.github.io/JustSaying/aws-configuration/service-endpoints

Store the LocalStack service URL and region in the `appsettings.Development.json` file for easy configuration management.

```json
{
  "AWS": {
    "ServiceUrl": "http://localhost:4566",
    "Region": "us-east-1"
  }
}

```

--------------------------------

### Create and Populate OrderAccepted Message

Source: https://justeattakeaway.github.io/JustSaying/how-justsaying-uses-sqs-sns

Instantiates an OrderAccepted message object and populates its properties, including custom ones like RaisingComponent. This object is then used for publishing.

```csharp
var orderAccepted = new OrderAccepted  
{
    OrderId = 1234,
    RaisingComponent = "orderapi",
};

```

--------------------------------

### Configure JustSaying Subscriber

Source: https://justeattakeaway.github.io/JustSaying/Configuration

Registers an SQS queue subscription, a message handler, and a background service to process incoming events.

```csharp
    services.AddJustSaying(bus =>  
    {  
        bus.Subscriptions(subscription =>  
        {  
            // Creates the SQS queue  
            // Creates the SQS to SNS subscription  
            subscription.ForTopic<OrderPlacedEvent>();  
        });  
    }  
    // Add a handler responsible for handling the event  
    services  
        .AddJustSayingHandler<OrderPlacedEvent, OrderPlacedEventHandler>();  
  
    // Add a background service that is listening for messages related to the above subscription  
    services.AddHostedService<Subscriber>();  
```

```csharp
    services.AddJustSaying(bus =>  
    {  
        bus.Subscriptions(subscription =>  
        {  
            // Creates the SQS queue  
            // Creates the SQS to SNS subscription  
            subscription.ForTopic<OrderPlacedEvent>();  
        });  
    }  
    // Add a handler responsible for handling the event  
    services  
        .AddJustSayingHandler<OrderPlacedEvent, OrderPlacedEventHandler>();  
  
    // Add a background service that is listening for messages related to the above subscriptions  
    services.AddHostedService<Subscriber>();  
```

```csharp
    services.AddJustSaying(bus =>  
    {  
        bus.Subscriptions(subscription =>  
        {  
            // Creates the SQS queue  
            // creates the SQS to SNS subscription  
            subscription.ForTopic<OrderPlacedEvent>();  
        });  
    }  
    // Add a handler responsible for handling the event  
    services  
        .AddJustSayingHandler<OrderPlacedEvent, OrderPlacedEventHandler>();  
  
    // Add a background service that is listening for messages related to the above subscriptions  
    services.AddHostedService<Subscriber>();  
```
Tokens:
Raw