Set of useful libraries for Micronaut

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-cloudwatchlogs</artifactId>
    <version>3.4.2</version>
</dependency>

implementation 'com.agorapulse:micronaut-aws-sdk-cloudwatchlogs:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-cloudwatchlogs</artifactId>
    <version>3.4.2</version>
</dependency>

package com.agorapulse.micronaut.aws.lambda;

import com.agorapulse.micronaut.aws.cloudwatchlogs.CloudWatchLogsService;

import jakarta.inject.Singleton;

@Singleton
public class LogCheckService {

    private final CloudWatchLogsService logsService;                                    (1)

    public LogCheckService(CloudWatchLogsService logsService) {
        this.logsService = logsService;
    }

    public boolean contains(String logGroup, String text) {
        return logsService.getLogEvents(logGroup)
            .anyMatch(e -> e.getMessage().contains(text));                              (2)
    }

}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-integration-testing</artifactId>
    <version>3.4.2</version>
</dependency>

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>
<!-- for Kotlin Query DSL -->
<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

annotationProcessor 'com.agorapulse:micronaut-aws-sdk-dynamodb-annotation-processor:3.4.2'
implementation 'com.agorapulse:micronaut-aws-sdk-dynamodb:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.ConvertedJson;
import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.PartitionKey;
import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.Projection;
import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.SecondaryPartitionKey;
import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.SecondarySortKey;
import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.SortKey;
import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.TimeToLive;
import io.micronaut.core.annotation.Introspected;
import software.amazon.awssdk.services.dynamodb.model.ProjectionType;

import java.time.Instant;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

@Introspected                                                                           (1)
public class DynamoDBEntity implements PlaybookAware {

    public static final String DATE_INDEX = "date";
    public static final String RANGE_INDEX = "rangeIndex";
    public static final String GLOBAL_INDEX = "globalIndex";

    private String parentId;
    private String id;
    private String rangeIndex;
    private Date date;
    private Integer number = 0;
    private Instant created;

    private Map<String, List<String>> mapProperty = new LinkedHashMap<>();
    private Set<String> stringSetProperty = new HashSet<>();
    private Options options = new Options();

    @PartitionKey                                                                       (2)
    public String getParentId() {
        return parentId;
    }

    public void setParentId(String parentId) {
        this.parentId = parentId;
    }

    @SortKey                                                                            (3)
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @SecondarySortKey(indexNames = RANGE_INDEX)                                         (4)
    public String getRangeIndex() {
        return rangeIndex;
    }

    public void setRangeIndex(String rangeIndex) {
        this.rangeIndex = rangeIndex;
    }

    @Projection(ProjectionType.ALL)                                                     (5)
    @SecondarySortKey(indexNames = DATE_INDEX)
    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }

    @Projection(ProjectionType.ALL)
    @SecondaryPartitionKey(indexNames = GLOBAL_INDEX)                                   (6)
    public String getGlobalIndex() {
        return parentId + ":" + id;
    }

    @TimeToLive("365d")                                                                 (7)
    public Instant getCreated() {
        return created;
    }

    public void setCreated(Instant created) {
        this.created = created;
    }

    public Map<String, List<String>> getMapProperty() {
        return mapProperty;
    }

    public void setMapProperty(Map<String, List<String>> mapProperty) {
        this.mapProperty = mapProperty;
    }

    public Set<String> getStringSetProperty() {
        return stringSetProperty;
    }

    public void setStringSetProperty(Set<String> stringSetProperty) {
        this.stringSetProperty = stringSetProperty;
    }

    @ConvertedJson
    public Options getOptions() {
        return options;
    }

    public void setOptions(Options options) {
        this.options = options;
    }

    //CHECKSTYLE:OFF
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        DynamoDBEntity that = (DynamoDBEntity) o;
        return Objects.equals(parentId, that.parentId) &&
            Objects.equals(id, that.id) &&
            Objects.equals(rangeIndex, that.rangeIndex) &&
            Objects.equals(date, that.date) &&
            Objects.equals(number, that.number) &&
            Objects.equals(mapProperty, that.mapProperty) &&
            Objects.equals(created, that.created) &&
            Objects.equals(stringSetProperty, that.stringSetProperty);
    }

    @Override
    public int hashCode() {
        return Objects.hash(parentId, id, rangeIndex, date, number, mapProperty, stringSetProperty);
    }

    @Override
    public String toString() {
        return "DynamoDBEntity{" +
            "parentId='" + parentId + '\'' +
            ", id='" + id + '\'' +
            ", rangeIndex='" + rangeIndex + '\'' +
            ", date=" + date +
            ", number=" + number +
            ", mapProperty=" + mapProperty +
            ", created=" + created +
            ", stringSetProperty=" + stringSetProperty +
            '}';
    }
    //CHECKSTYLE:ON
}

import com.agorapulse.micronaut.amazon.awssdk.dynamodb.annotation.*
import io.micronaut.core.annotation.Introspected
import software.amazon.awssdk.services.dynamodb.model.ProjectionType
import java.time.Instant
import java.util.*

@Introspected                                                                           (1)
class DynamoDBEntity {

    @PartitionKey                                                                       (2)
    var parentId: String? = null

    @SortKey                                                                            (3)
    var id: String? = null

    @SecondarySortKey(indexNames = [RANGE_INDEX])                                       (4)
    var rangeIndex: String? = null

    @SecondarySortKey(indexNames = [DATE_INDEX])                                        (5)
    @Projection(ProjectionType.ALL)
    var date: Date? = null

    var number = 0

    var map: Map<String, List<String>>? = null

    @SecondaryPartitionKey(indexNames = [GLOBAL_INDEX])                                 (6)
    @Projection(ProjectionType.ALL)
    fun getGlobalIndex(): String {
        return "$parentId:$id"
    }

    @TimeToLive("365d")                                                                 (7)
    var created: Instant? = null

    companion object {
        const val DATE_INDEX = "date"
        const val RANGE_INDEX = "rangeIndex"
        const val GLOBAL_INDEX = "globalIndex"
    }
}

DynamoDBServiceProvider provider = context.getBean(DynamoDBServiceProvider);
DynamoDBService<DynamoDBEntity> service = provider.findOrCreate(DynamoDBEntity.class);  (1)

service.createTable();                                                                  (2)

DynamoDBEntity entity = new DynamoDBEntity();
entity.setParentId("1");
entity.setId("1");
entity.setRangeIndex("foo");
entity.setNumber(1);
entity.setDate(new Date());
service.save(entity);                                                                   (3)

service.get("1", "1");                                                                  (4)

service.query(query ->                                                                  (5)
    query.partitionKey("1")
    .index(DynamoDBEntity.DATE_INDEX)
    .range(r -> r.between(from, to))
);

service.update(update ->                                                                (6)
    update.partitionKey("1001")
    .sortKey("1")
    .add("number", 13)
    .returns(ReturnValue.ALL_NEW)
);

service.delete("1001", "1");                                                            (7)

DynamoDBServiceProvider provider = context.getBean(DynamoDBServiceProvider)
DynamoDBService<DynamoDBEntity> s = provider.findOrCreate(DynamoDBEntity)       (1)

s.createTable()                                                                 (2)

s.save(new DynamoDBEntity(                                                      (3)
    parentId: '1',
    id: '1',
    rangeIndex: 'foo',
    date: REFERENCE_DATE.toDate()
))

s.get('1', '1')                                                                 (4)

s.query('1', DynamoDBEntity.RANGE_INDEX, 'bar').count == 1                      (5)
s.query('1', DynamoDBEntity.RANGE_INDEX, 'bar').count == 1

s.queryByDates('3', DynamoDBEntity.DATE_INDEX, [                                (6)
    after: REFERENCE_DATE.plusDays(9).toDate(),
    before: REFERENCE_DATE.plusDays(20).toDate(),
]).count == 1
s.queryByDates('3', DynamoDBEntity.DATE_INDEX, [
    after: REFERENCE_INSTANT.plus(9, ChronoUnit.DAYS),
    before: REFERENCE_INSTANT.plus(20, ChronoUnit.DAYS),
]).count == 1

s.increment('1', '1', 'number')                                                 (7)

s.delete(s.get('1', '1'))                                                       (8)

s.deleteAll('1', DynamoDBEntity.RANGE_INDEX, 'bar') == 1                        (9)

DynamoDBService<DynamoDBEntity> s = provider.findOrCreate(DynamoDBEntity.class);(1)

assertNotNull(
    s.createTable(5L, 5L)                                                       (2)
);

assertNotNull(
    s.save(createEntity("1", "1", "foo", REFERENCE_DATE.toDate()))              (3)
);

assertNotNull(
    s.get("1", "1")                                                             (4)
);

assertEquals(1,
    s.query("1", DynamoDBEntity.RANGE_INDEX, "bar").getCount().intValue()        (5)
);

assertEquals(1,
    s.queryByDates(                                                             (6)
        "3",
        DynamoDBEntity.DATE_INDEX,
        REFERENCE_DATE.plusDays(9).toDate(),
        REFERENCE_DATE.plusDays(20).toDate()
    ).getCount().intValue()
);

s.increment("1", "1", "number");                                                (7)

s.delete(s.get("1", "1"));                                                      (8)

assertEquals(1,
    s.deleteAll("1", DynamoDBEntity.RANGE_INDEX, "bar")                         (9)
);

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

@MicronautTest                                                                          (1)
@Property(name = "test.table.name", value = "DynamoDBDeclarativeJava")
public class DeclarativeServiceTest {

    @Inject DynamoDBServiceProvider provider                                            (2)

    @Test
    public void testSomething() {
        DynamoDBService<DynamoDBEntity> s = provider.findOrCreate(DynamoDBEntity.class);(3)

        // test code
    }
}

<!-- for Kinesis client -->
<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-kinesis</artifactId>
    <version>3.4.2</version>
</dependency>
<!-- for Kinesis listener -->
<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-kinesis-worker</artifactId>
    <version>3.4.2</version>
</dependency>

// for Kinesis client
annotationProcessor 'com.agorapulse:micronaut-aws-sdk-kinesis-annotation-processor:3.4.2'
implementation 'com.agorapulse:micronaut-aws-sdk-kinesis:3.4.2'
// for Kinesis listener
implementation 'com.agorapulse:micronaut-aws-sdk-kinesis-worker:3.4.2'

<!-- for Kinesis client -->
<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-kinesis</artifactId>
    <version>3.4.2</version>
</dependency>
<!-- for Kinesis listener -->
<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-kinesis-worker</artifactId>
    <version>3.4.2</version>
</dependency>

@KinesisClient                                                                          (1)
interface DefaultClient {
    void putRecordString(String record);                                                (2)

    PutRecordResult putRecord(String partitionKey, String record);                      (3)

    void putRecordAnno(@PartitionKey String id, String record);                         (4)

    void putRecord(String partitionKey, String record, String sequenceNumber);          (5)

    void putRecordAnno(                                                                 (6)
        @PartitionKey String id,
        String record,
        @SequenceNumber String sqn
    );

    void putRecordAnnoNumbers(                                                          (7)
        @PartitionKey Long id,
        String record,
        @SequenceNumber int sequenceNumber
    );
}

@KinesisClient                                                                          (1)
interface DefaultClient {
    void putRecordBytes(byte[] record);                                                 (2)

    void putRecordDataByteArray(@PartitionKey String id, byte[] value);                 (3)

    PutRecordsResult putRecords(Iterable<PutRecordsRequestEntry> entries);              (4)

    PutRecordsResult putRecords(PutRecordsRequestEntry... entries);                     (5)

    PutRecordsResult putRecord(PutRecordsRequestEntry entry);                           (6)
}

@KinesisClient                                                                          (1)
interface DefaultClient {
    void putRecordObject(Pogo pogo);                                                    (2)

    PutRecordsResult putRecordObjects(Pogo... pogo);                                    (3)

    PutRecordsResult putRecordObjects(Iterable<Pogo> pogo);                             (4)

    void putRecordDataObject(@PartitionKey String id, Pogo value);                      (5)
}

@KinesisClient                                                                          (1)
interface DefaultClient {
    PutRecordResult putEvent(MyEvent event);                                            (2)

    PutRecordsResult putEventsIterable(Iterable<MyEvent> events);                       (3)

    void putEventsArrayNoReturn(MyEvent... events);                                     (4)

    @Stream("OtherStream") PutRecordResult putEventToStream(MyEvent event);             (5)
}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

@MicronautTest                                                                          (1)
public class KinesisJavaDemoTest {

    @Inject KinesisService service;                                                     (2)

    @Test
    public void testJavaService() {
        assertNotNull(service.createStream("TestStream"));
    }
}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-lambda</artifactId>
    <version>3.4.2</version>
</dependency>

implementation 'com.agorapulse:micronaut-aws-sdk-lambda:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-lambda</artifactId>
    <version>3.4.2</version>
</dependency>

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-lambda-integration-testing</artifactId>
    <version>3.4.2</version>
</dependency>

import com.fasterxml.jackson.databind.ObjectMapper;
import io.micronaut.test.annotation.MockBean;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;

@MicronautTest                                                                          (1)
public class TestAwsLambdaRuntimeTest {

    private static final String RESPONSE_TEXT = "olleH";
    private static final String REQUEST = "{ \"message\": \"Hello\" }";

    @Inject ObjectMapper mapper;

    @Inject TestAwsLambdaRuntime aws;                                                   (2)

    @MockBean(DefaultSomeService.class) SomeService someService() {                     (3)
        SomeService mock = Mockito.mock(SomeService.class);
        when(mock.transform("Hello")).thenReturn(RESPONSE_TEXT);
        return mock;
    }

    @Test
    void handleRequest() throws Exception {                                             (4)
        assertEquals(
            RESPONSE_TEXT,
            aws.handleRequest(PojoHandler.class, REQUEST).getText()
        );
        assertEquals(
            RESPONSE_TEXT,
            aws.handleRequest(PojoHandler.class, new ByteArrayInputStream(REQUEST.getBytes(StandardCharsets.UTF_8))).getText()
        );

        assertEquals(
            RESPONSE_TEXT,
            aws.apply(FunctionHandler.class, REQUEST).getText()
        );
        assertEquals(
            RESPONSE_TEXT,
            aws.apply(FunctionHandler.class, new ByteArrayInputStream(REQUEST.getBytes(StandardCharsets.UTF_8))).getText()
        );

        assertEquals(
            RESPONSE_TEXT,
            aws.<Response>invoke(PojoHandler.class.getName(), REQUEST).getText()
        );
        assertEquals(
            RESPONSE_TEXT,
            aws.<Response>invoke(PojoHandler.class.getName(), new ByteArrayInputStream(REQUEST.getBytes(StandardCharsets.UTF_8))).getText()
        );

        assertEquals(
            RESPONSE_TEXT,
            aws.<Response>invoke(SimpleHandler.class.getName() + "::execute", REQUEST).getText()
        );
        assertEquals(
            RESPONSE_TEXT,
            aws.<Response>invoke(SimpleHandler.class.getName() + "::execute", REQUEST).getText()
        );

        assertEquals(
            RESPONSE_TEXT,
            mapper.readValue(aws.stream(PojoStreamHandler.class, REQUEST).toString(), Response.class).getText()
        );
        assertEquals(
            RESPONSE_TEXT,
            mapper.readValue(aws.stream(PojoStreamHandler.class, new ByteArrayInputStream(REQUEST.getBytes(StandardCharsets.UTF_8))).toString(), Response.class).getText()
        );

        assertEquals(
            RESPONSE_TEXT,
            mapper.readValue(aws.stream(PojoStreamHandler.class.getName(), REQUEST).toString(), Response.class).getText()
        );
        assertEquals(
            RESPONSE_TEXT,
            mapper.readValue(aws.stream(PojoStreamHandler.class.getName(), new ByteArrayInputStream(REQUEST.getBytes(StandardCharsets.UTF_8))).toString(), Response.class).getText()
        );

    }

}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-s3</artifactId>
    <version>3.4.2</version>
</dependency>

implementation 'com.agorapulse:micronaut-aws-sdk-s3:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-s3</artifactId>
    <version>3.4.2</version>
</dependency>

aws:
  s3:
    region: sa-east-1
    bucket: MyBucket                                                                    (1)
    path-style-access-enabled: true                                                     (2)

    buckets:                                                                            (3)
      test:                                                                             (4)
        bucket: TestBucket

File sampleContent = createFileWithSampleContent();

service.storeFile(TEXT_FILE_PATH, sampleContent);                               (1)

assertTrue(service.exists(TEXT_FILE_PATH));                                     (2)

Publisher<S3ObjectSummary> summaries = service.listObjectSummaries("foo");      (3)
assertEquals(Long.valueOf(0L), Flux.from(summaries).count().block());

service.storeInputStream(                                                       (1)
    KEY,
    new ByteArrayInputStream(SAMPLE_CONTENT.getBytes()),
    buildMetadata()
);

Publisher<S3ObjectSummary> fooSummaries = service.listObjectSummaries("foo");   (2)
assertEquals(KEY, Flux.from(fooSummaries).blockFirst().getKey());

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

@MicronautTest                                                                          (1)
@Property(name = "aws.s3.bucket", value = SimpleStorageServiceTest.MY_BUCKET)           (2)
public class SimpleStorageServiceTest {

    @Inject SimpleStorageService service;                                               (3)

    // test methods

}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-ses</artifactId>
    <version>3.4.2</version>
</dependency>

implementation 'com.agorapulse:micronaut-aws-sdk-ses:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-ses</artifactId>
    <version>3.4.2</version>
</dependency>

EmailDeliveryStatus status = service.send(e ->                                  (1)
    e.subject("Hi Paul")                                                        (2)
        .from("subscribe@groovycalamari.com")                                   (3)
        .to("me@sergiodelamo.com")                                              (4)
        .htmlBody("<p>This is an example body</p>")                             (5)
        .configurationSetName("configuration-set")                              (6)
        .tags(mapOfTags)                                                        (7)
        .attachment(a ->                                                        (8)
            a.filepath(filepath)                                                (9)
                .filename("test.pdf")                                           (10)
                .mimeType("application/pdf")                                    (11)
                .description("An example pdf")                                  (12)
        )
);

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-sns</artifactId>
    <version>3.4.2</version>
</dependency>

annotationProcessor 'com.agorapulse:micronaut-aws-sdk-sns-annotation-processor:3.4.2'
implementation 'com.agorapulse:micronaut-aws-sdk-sns:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-sns</artifactId>
    <version>3.4.2</version>
</dependency>

package com.agorapulse.micronaut.aws.sns;

import com.agorapulse.micronaut.aws.sns.annotation.MessageDeduplicationId;
import com.agorapulse.micronaut.aws.sns.annotation.MessageGroupId;
import com.agorapulse.micronaut.aws.sns.annotation.NotificationClient;
import com.agorapulse.micronaut.aws.sns.annotation.Topic;
import java.util.Map;

@NotificationClient                                                                             (1)
interface DefaultClient {

    String OTHER_TOPIC = "OtherTopic";

    @Topic("OtherTopic") String publishMessageToDifferentTopic(Pogo pogo);                      (2)

    String publishMessage(Pogo message);                                                        (3)
    String publishMessage(Pogo message, @MessageGroupId String groupId, @MessageDeduplicationId String deduplicationId); (4)
    String publishMessage(String subject, Pogo message);                                        (5)
    String publishMessage(String subject, Pogo message, Map<String, String> attributes);
    String publishMessage(String message);                                                      (6)
    String publishMessage(String subject, String message);
    String publishMessage(String subject, String message, Map<String, String> attributes);

    String sendSMS(String phoneNumber, String message);                                         (7)
    String sendSms(String phoneNumber, String message, Map attributes);                         (8)

}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

class SimpleNotificationServiceTest {

@MicronautTest                                                                          (1)
@Property(name = "aws.sns.topic", value = SimpleNotificationServiceTest.TEST_TOPIC)     (2)
public class SimpleNotificationServiceTest {

    @Inject SimpleNotificationService service;                                          (3)

    // tests

}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-sqs</artifactId>
    <version>3.4.2</version>
</dependency>

annotationProcessor 'com.agorapulse:micronaut-aws-sdk-sqs-annotation-processor:3.4.2'
implementation 'com.agorapulse:micronaut-aws-sdk-sqs:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-sqs</artifactId>
    <version>3.4.2</version>
</dependency>

package com.agorapulse.micronaut.aws.sqs;

import com.agorapulse.micronaut.aws.sqs.annotation.Queue;
import com.agorapulse.micronaut.aws.sqs.annotation.QueueClient;

@QueueClient                                                                            (1)
interface DefaultClient {

    @Queue(value = "OtherQueue", group = "SomeGroup")
    String sendMessageToQueue(String message);                                          (2)

    String sendMessage(Pogo message);                                                   (3)

    String sendMessage(byte[] record);                                                  (4)

    String sendMessage(String record);                                                  (5)

    String sendMessage(String record, int delay);                                       (6)

    String sendMessage(String record, String group);                                    (7)

    String sendMessage(String record, int delay, String group);                         (8)

    void deleteMessage(String messageId);                                               (9)

    String OTHER_QUEUE = "OtherQueue";
}

Map<String, String> queueAttributes = service.getQueueAttributes(TEST_QUEUE);   (1)

assertEquals("0", queueAttributes.get("DelaySeconds"));                         (2)

String msgId = service.sendMessage(DATA);                                       (1)

assertNotNull(msgId);

List<Message> messages = service.receiveMessages();                             (2)
Message first = messages.get(0);

assertEquals(DATA, first.getBody());                                            (3)
assertEquals(msgId, first.getMessageId());
assertEquals(1, messages.size());

service.deleteMessage(first.getReceiptHandle());                                (4)

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-dynamodb</artifactId>
    <version>3.4.2</version>
</dependency>

@MicronautTest                                                                          (1)
@Property(name = "aws.sqs.queue", value = SimpleQueueServiceTest.TEST_QUEUE)            (2)
public class SimpleQueueServiceTest {

    @Inject SimpleQueueService service;                                                 (3)

    // tests

}

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-amazon-awssdk-sts</artifactId>
    <version>3.4.2</version>
</dependency>

implementation 'com.agorapulse:micronaut-aws-sdk-sts:3.4.2'

<dependency>
    <groupId>com.agorapulse</groupId>
    <artifactId>micronaut-aws-sdk-sts</artifactId>
    <version>3.4.2</version>
</dependency>

service.assumeRole('session', 'arn:::my-role', 360) {
    externalId = '123456789'
}