{project-title}

@Immutable
@Introspected(builder = @Introspected.IntrospectionBuilder(builderClass = Customer.Builder.class))
public record Customer(
    @PartitionKey Long id,
    @SortKey String name
) {

    public static class Builder {
        public Builder id(Long id) { /* ... */ }
        public Builder name(String name) { /* ... */ }
        public Customer build() { /* ... */ }
    }

}

@MicronautTest                                                                          // (1)
@Property(name = "aws.dynamodb.create-tables", value = "true")                          // (2)
class DynamoDbLoaderTest {

    private static final Fixt FIXT = Fixt.create(DynamoDbLoaderTest.class);             // (3)

    @Inject DynamoDbLoader loader;
    @Inject DynamoDBServiceProvider provider;

    @AfterEach
    void cleanUp() {
        var service = provider.findOrCreate(TestEntity.class);
        service.deleteAll(service.findAll("1"));
    }

    @Test
    void loadIntoDynamoDb() {

        Map<Class<?>, Iterable<String>> mappings = Map.of(
            TestEntity.class, List.of("test-entity.csv")                                // (4)
        );

        loader.loadAll(FIXT::readText, mappings);                                       // (5)

        TestEntity fromDb = provider.findOrCreate(TestEntity.class).get("1", null);     // (6)
        TestEntity referenceEntity = getReferenceEntity();
        assertEquals(referenceEntity, fromDb);
    }

    @Test
    void skipLoadingTo() {
        List<TestEntity> loaded = loader.readAll(                                       // (7)
            FIXT::readText, TestEntity.class, List.of("test-entity.csv")
        ).toList();

        assertEquals(1, loaded.size());

        TestEntity fromDb = provider.findOrCreate(TestEntity.class).get("1", null);

        assertNull(fromDb);
    }

    private static TestEntity getReferenceEntity() {
        TestEntity referenceEntity = new TestEntity();
        referenceEntity.setId("1");
        referenceEntity.setName("test-one");
        referenceEntity.setActive(true);
        referenceEntity.setCreated(Instant.parse("2019-01-01T00:00:00Z"));
        referenceEntity.setCount(2);
        referenceEntity.setValue(3.4);
        referenceEntity.setData(Map.of("string", "text"));
        referenceEntity.setTags(Set.of("one", "two", "three"));
        return referenceEntity;
    }

}

aws:
  kinesis:
    stream: DefaultStream                              # (1)
    streams:
      other:                                           # (2)
        stream: OtherStream                            # (3)
    listener:
      application: my-application                      # (4)
      worker-id: my-worker-id                          # (5)
      stream: ListenerStream                           # (6)
    listeners:
      other:                                           # (7)
        stream: OtherListenerStream

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

    PutRecordResponse 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)

    PutRecordsResponse putRecords(Iterable<PutRecordsRequestEntry> entries);            // (4)

    PutRecordsResponse putRecords(PutRecordsRequestEntry... entries);                   // (5)

    PutRecordsResponse putRecord(PutRecordsRequestEntry entry);                         // (6)
}

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

    PutRecordsResponse putRecordObjects(Pogo... pogo);                                  // (3)

    PutRecordsResponse putRecordObjects(Iterable<Pogo> pogo);                           // (4)

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

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

    PutRecordsResponse putEventsIterable(Iterable<MyEvent> events);                     // (3)

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

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

@Singleton                                                                              // (1)
public class KinesisListenerTester {

    @KinesisListener
    public void listenString(String string) {                                           // (2)
        String message = "EXECUTED: listenString(" + string + ")";
        logExecution(message);
    }

    @KinesisListener
    public void listenRecord(KinesisClientRecord record) {                              // (3)
        logExecution("EXECUTED: listenRecord(" + record + ")");
    }


    @KinesisListener
    public void listenStringRecord(String string, KinesisClientRecord record) {         // (4)
        logExecution("EXECUTED: listenStringRecord(" + string + ", " + record + ")");
    }

    @KinesisListener
    public void listenObject(MyEvent event) {                                           // (5)
        logExecution("EXECUTED: listenObject(" + event + ")");
    }

    @KinesisListener
    public void listenObjectRecord(MyEvent event, KinesisClientRecord record) {         // (6)
        logExecution("EXECUTED: listenObjectRecord(" + event + ", " + record + ")");
    }

    @KinesisListener
    public void listenPogoRecord(Pogo event) {                                          // (7)
        logExecution("EXECUTED: listenPogoRecord(" + event + ")");
    }

    public List<String> getExecutions() {
        return executions;
    }

    public void setExecutions(List<String> executions) {
        this.executions = executions;
    }

    private void logExecution(String message) {
        executions.add(message);
        System.err.println(message);
    }

    private List<String> executions = new CopyOnWriteArrayList<>();
}

aws:
  lambda:
    functions:
      hello:                          # (1)
        function: HelloFunction       # (2)

package com.agorapulse.micronaut.amazon.awssdk.lambda;

import com.agorapulse.micronaut.amazon.awssdk.lambda.annotation.LambdaClient;

@LambdaClient("hello")                                                                  // (1)
public interface HelloConfigurationClient {

    HelloResponse hello(String name);                                                   // (2)

}

package com.agorapulse.micronaut.amazon.awssdk.lambda;

import com.agorapulse.micronaut.amazon.awssdk.lambda.annotation.Body;
import com.agorapulse.micronaut.amazon.awssdk.lambda.annotation.LambdaClient;

@LambdaClient(function = "HelloFunction")                                               // (1)
public interface HelloBodyClient {

    HelloResponse hello(@Body HelloRequest request);                                    // (2)

}

package com.agorapulse.micronaut.amazon.awssdk.lambda;

import com.agorapulse.testing.fixt.Fixt;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.zeroturnaround.zip.ZipUtil;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.services.lambda.LambdaClient;
import software.amazon.awssdk.services.lambda.model.Runtime;

import jakarta.inject.Inject;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.util.Collections;

@MicronautTest                                                                          // (1)
public class HelloClientTest {

    private static final Fixt FIXT = Fixt.create(AbstractClientSpec.class);             // (2)

    @TempDir private File tmp;
    @Inject private LambdaClient lambda;                                                // (3)
    @Inject private HelloClient client;                                                 // (4)

    @BeforeEach
    public void setupSpec() {
        prepareHelloFunction();                                                         // (5)
    }

    @Test
    public void invokeFunction() {
        HelloResponse result = client.hello("Vlad");                                    // (6)
        Assertions.assertEquals("Hello Vlad", result.getMessage());                     // (7)
    }

    private void prepareHelloFunction() {
        boolean alreadyExists = lambda.listFunctions()
            .functions()
            .stream()
            .anyMatch(fn -> "HelloFunction".equals(fn.functionName()));

        if (alreadyExists) {
            return;
        }

        File functionDir = new File(tmp, "HelloFunction");
        functionDir.mkdirs();

        FIXT.copyTo("HelloFunction", functionDir);

        File functionArchive = new File(tmp, "function.zip");
        ZipUtil.pack(functionDir, functionArchive);

        lambda.createFunction(create -> create.functionName("HelloFunction")
            .runtime(Runtime.NODEJS16_X)
            .role("HelloRole")
            .handler("index.handler")
            .environment(e ->
                e.variables(Collections.singletonMap("MICRONAUT_ENVIRONMENTS", "itest"))//(8)
            )
            .code(code -> {
                try {
                    InputStream archiveStream = Files.newInputStream(functionArchive.toPath());
                    SdkBytes archiveBytes = SdkBytes.fromInputStream(archiveStream);
                    code.zipFile(archiveBytes);
                } catch (IOException e) {
                    throw new IllegalStateException(
                        "Failed to create function from archive " + functionArchive, e
                    );
                }
            })
            .build());
    }

}

aws:
  s3:
    bucket: DefaultBucket                          # (1)
    use-path-style-urls: true                      # (2)
    buckets:
      test:                                        # (3)
        bucket: SomeOtherBucket                    # (4)

service.createBucket(MY_BUCKET);                                                // (1)

assertTrue(service.listBucketNames().contains(MY_BUCKET));                      // (2)

File sampleContent = createFileWithSampleContent();

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

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

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

service.storeInputStream(                                                       // (1)
    KEY,
    new ByteArrayInputStream(SAMPLE_CONTENT.getBytes()),
    metadata -> {
        metadata.contentLength((long) SAMPLE_CONTENT.length())
            .contentType("text/plain")
            .contentDisposition("bar.baz");
    }
);

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

String url = service.generatePresignedUrl(KEY, TOMORROW);                       // (1)

assertEquals(SAMPLE_CONTENT, download(url));                                    // (2)

File file = new File(tmp, "bar.baz");                                           // (1)

service.getFile(KEY, file);                                                     // (2)
assertTrue(file.exists());

assertEquals(SAMPLE_CONTENT, new String(Files.readAllBytes(Paths.get(file.toURI()))));

service.deleteFile(TEXT_FILE_PATH);                                             // (1)
assertFalse(service.exists(TEXT_FILE_PATH));                                    // (2)

service.deleteBucket();                                                         // (1)
assertFalse(service.listBucketNames().contains(MY_BUCKET));                     // (2)

aws:
    ses:
        use-base64-encoding-for-multipart-emails: true

aws:
  sns:
    topic: TestTopic                              # (1)
    ios:
      arn: 'arn:aws:sns:eu-west-1:123456789:...'  # (2)
    android:
      arn: 'arn:aws:sns:eu-west-1:123456789:...'  # (3)
    amazon:
      arn: 'arn:aws:sns:eu-west-1:123456789:...'  # (4)
    topics:
      test:                                       # (5)
        topic: SomeOtherTopic                     # (6)

package com.agorapulse.micronaut.amazon.awssdk.sns;

import com.agorapulse.micronaut.amazon.awssdk.sns.annotation.MessageDeduplicationId;
import com.agorapulse.micronaut.amazon.awssdk.sns.annotation.MessageGroupId;
import com.agorapulse.micronaut.amazon.awssdk.sns.annotation.NotificationClient;
import com.agorapulse.micronaut.amazon.awssdk.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)

}

aws:
  sqs:
    queue-name-prefix: dev_                         # (1)
    auto-create-queue: true                         # (2)
    cache-queue-urls: true                          # (3)
    queue: DefaultQueue                             # (4)
    fifo: false                                     # (5)
    content-based-deduplication: false              # (6)
    delay-seconds: 0                                # (7)
    message-retention-period: 345600                # (8)
    maximum-message-size: 262144                    # (9)
    visibility-timeout: 30                          # (10)
    queues:
      test:                                         # (11)
        queue: SomeOtherQueue                       # (12)

package com.agorapulse.micronaut.amazon.awssdk.sqs;

import com.agorapulse.micronaut.amazon.awssdk.sqs.annotation.Queue;
import com.agorapulse.micronaut.amazon.awssdk.sqs.annotation.QueueClient;
import org.reactivestreams.Publisher;

import java.util.List;

@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 sendStringMessages(Publisher<String> messages);                                // (9)

    Publisher<String> sendMessages(Publisher<Pogo> messages);                           // (10)

    void deleteMessage(String messageId);                                               // (11)

    List<String> sendMessages(List<Pogo> messages);                                     // (12)

    List<String> sendStringMessages(List<String> messages);                             // (13)

    List<String> sendMessages(Pogo[] messages);                                         // (14)

    List<String> sendStringMessages(String[] messages);                                 // (15)

    void sendMessagesVoid(List<Pogo> messages);                                         // (16)

    String OTHER_QUEUE = "OtherQueue";
}

String queueUrl = service.createQueue(TEST_QUEUE);                              // (1)

assertTrue(service.listQueueUrls().contains(queueUrl));                         // (2)

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

assertEquals("0", queueAttributes
    .get(QueueAttributeName.DELAY_SECONDS));                                    // (2)

service.deleteQueue(TEST_QUEUE);                                                // (1)

assertFalse(service.listQueueUrls().contains(queueUrl));                        // (2)

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

assertNotNull(msgId);

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

assertEquals(DATA, first.body());                                               // (3)
assertEquals(msgId, first.messageId());
assertEquals(1, messages.size());

service.deleteMessage(first.receiptHandle());                                   // (4)