Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

refactor(ses): split SesService into per-domain services behind a facade (#2357)

Kenshin Okinaka3726b88fc966
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesAccountService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesAccountService.java
new file mode 100644
index 0000000000..0e526d568e
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesAccountService.java
@@ -0,0 +1,70 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.AccountVdmAttributes;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Account-level SES settings, extracted from {@link SesService} as part of the store-based domain
+ * split. Reached through the {@code SesService} facade, which delegates here.
+ *
+ * <p>Owns the account sending-enabled flag ({@code accountSettingsStore}) and the VDM (Virtual
+ * Deliverability Manager) attributes ({@code accountVdmStore}). Account suppression is account-level
+ * too, but it shares {@code validateSuppressionReason} with the suppression list, so it lives in
+ * {@link SesSuppressionService} instead.
+ */
+@ApplicationScoped
+public class SesAccountService {
+
+ private static final Logger LOG = Logger.getLogger(SesAccountService.class);
+
+ private final StorageBackend<String, Boolean> accountSettingsStore;
+ private final StorageBackend<String, AccountVdmAttributes> accountVdmStore;
+
+ @Inject
+ public SesAccountService(StorageFactory storageFactory) {
+ this.accountSettingsStore = storageFactory.create("ses", "ses-account-settings.json",
+ new TypeReference<Map<String, Boolean>>() {});
+ this.accountVdmStore = storageFactory.create("ses", "ses-account-vdm.json",
+ new TypeReference<Map<String, AccountVdmAttributes>>() {});
+ }
+
+ SesAccountService(StorageBackend<String, Boolean> accountSettingsStore,
+ StorageBackend<String, AccountVdmAttributes> accountVdmStore) {
+ this.accountSettingsStore = accountSettingsStore;
+ this.accountVdmStore = accountVdmStore;
+ }
+
+ public boolean isAccountSendingEnabled(String region) {
+ return accountSettingsStore.get("sending::" + region).orElse(true);
+ }
+
+ public void setAccountSendingEnabled(String region, boolean enabled) {
+ accountSettingsStore.put("sending::" + region, enabled);
+ LOG.infov("Updated account sending enabled for region {0}: {1}", region, enabled);
+ }
+
+ // VDM (Virtual Deliverability Manager) is opt-in and per region: GetAccount omits VdmAttributes
+ // entirely until PutAccountVdmAttributes is called for the region, so this returns empty when the
+ // region was never configured. The whole tuple is stored under one region key so GetAccount never
+ // observes a partially updated state.
+ public Optional<AccountVdmAttributes> findAccountVdmAttributes(String region) {
+ return accountVdmStore.get(accountVdmKey(region));
+ }
+
+ public void putAccountVdmAttributes(String region, AccountVdmAttributes vdm) {
+ accountVdmStore.put(accountVdmKey(region), vdm);
+ LOG.infov("Updated account VDM attributes for region {0}: enabled={1}", region, vdm.vdmEnabled());
+ }
+
+ private static String accountVdmKey(String region) {
+ return "account-vdm::" + region;
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesContactService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesContactService.java
new file mode 100644
index 0000000000..e3d1de2c0d
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesContactService.java
@@ -0,0 +1,583 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.Contact;
+import io.github.hectorvent.floci.services.ses.model.ContactList;
+import io.github.hectorvent.floci.services.ses.model.Tag;
+import io.github.hectorvent.floci.services.ses.model.Topic;
+import io.github.hectorvent.floci.services.ses.model.TopicPreference;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.time.Clock;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * Contact lists and contacts (the {@code contactListStore} + {@code contactStore}), extracted from
+ * {@link SesService} as the fifth step of the store-based domain split.
+ *
+ * <p>New facet: a multi-store domain — one service owns both stores and the locks that serialize
+ * them (contact create/update against contact-list deletion), collapsing two SesService constructor
+ * arguments into one. It also owns the list-management contact behaviour used during a send
+ * ({@link #getOrAutoCreateContact}, {@link #isListManagementOptedOut}, {@link #unsubscribeContact});
+ * the facade's send orchestration ({@code collectListManagementOptOuts}) stays in {@link SesService}
+ * and calls into this service, keeping the shared {@code extractEmailAddress} send helper there.
+ */
+@ApplicationScoped
+public class SesContactService {
+
+ private static final Logger LOG = Logger.getLogger(SesContactService.class);
+
+ private static final Set<String> SUBSCRIPTION_STATUSES = Set.of("OPT_IN", "OPT_OUT");
+ private static final Pattern CONTACT_LIST_NAME_CHARS = Pattern.compile("^[A-Za-z0-9_-]{1,64}$");
+ private static final Pattern EMAIL_PATTERN = Pattern.compile("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$");
+ private static final int MAX_TOPICS_PER_LIST = 20;
+ private static final int MAX_DISPLAY_NAME_LENGTH = 128;
+ private static final int MAX_LIST_DESCRIPTION_LENGTH = 500;
+
+ private final StorageBackend<String, ContactList> contactListStore;
+ private final StorageBackend<String, Contact> contactStore;
+ // Guards the one-list-per-account check-then-create so concurrent creates can't both pass.
+ private final Object contactListCreateLock = new Object();
+ // Serializes contact create/update against contact-list deletion so a concurrent delete
+ // can't purge the list between validation and the write, leaving an orphaned contact.
+ private final Object contactMutationLock = new Object();
+ private final Clock clock;
+
+ @Inject
+ public SesContactService(StorageFactory storageFactory, Clock clock) {
+ this.contactListStore = storageFactory.create("ses", "ses-contact-lists.json",
+ new TypeReference<Map<String, ContactList>>() {});
+ this.contactStore = storageFactory.create("ses", "ses-contacts.json",
+ new TypeReference<Map<String, Contact>>() {});
+ this.clock = clock;
+ }
+
+ SesContactService(StorageBackend<String, ContactList> contactListStore,
+ StorageBackend<String, Contact> contactStore, Clock clock) {
+ this.contactListStore = contactListStore;
+ this.contactStore = contactStore;
+ this.clock = clock;
+ }
+
+ // ─────────────────────────── Contact lists ───────────────────────────
+
+ public ContactList createContactList(String name, String description, List<Topic> topics,
+ List<Tag> tags, String region) {
+ validateContactListInput(name, description, topics);
+ ContactList list = new ContactList(name);
+ list.setDescription(description);
+ list.setTopics(topics);
+ list.setTags(tags);
+ Instant now = Instant.now();
+ list.setCreatedTimestamp(now);
+ list.setLastUpdatedTimestamp(now);
+ // AWS allows at most one contact list per account per region (verified against real AWS).
+ // A duplicate name hits this same limit before any "already exists" check, so
+ // AlreadyExistsException is never reachable for contact lists. Lock only the check-then-put
+ // so concurrent calls can't both observe an empty region; building and logging stay outside.
+ synchronized (contactListCreateLock) {
+ if (!listContactLists(region).isEmpty()) {
+ throw new AwsException("BadRequestException",
+ "A maximum of 1 Lists allowed per account.", 400);
+ }
+ contactListStore.put(contactListKey(region, name), list);
+ }
+ LOG.infov("Created SES contact list: {0} in region {1}", name, region);
+ return list;
+ }
+
+ public ContactList getContactList(String name, String region) {
+ return contactListStore.get(contactListKey(region, name))
+ .orElseThrow(() -> contactListNotFound(name));
+ }
+
+ public List<ContactList> listContactLists(String region) {
+ String prefix = "contactList::" + region + "::";
+ return contactListStore.scan(k -> k.startsWith(prefix)).stream()
+ .sorted(Comparator.comparing(ContactList::getContactListName))
+ .toList();
+ }
+
+ public ContactList updateContactList(String name, String description, boolean descriptionPresent,
+ List<Topic> topics, String region) {
+ validateContactListInput(name, description, topics);
+ String key = contactListKey(region, name);
+ ContactList existing = contactListStore.get(key).orElseThrow(() -> contactListNotFound(name));
+ if (topics != null) {
+ existing.setTopics(topics);
+ }
+ if (descriptionPresent) {
+ existing.setDescription(description);
+ }
+ existing.setLastUpdatedTimestamp(Instant.now());
+ contactListStore.put(key, existing);
+ LOG.infov("Updated SES contact list: {0} in region {1}", name, region);
+ return existing;
+ }
+
+ public void deleteContactList(String name, String region) {
+ String key = contactListKey(region, name);
+ // Existence check, list delete, and contact purge all under the lock: concurrent deletes
+ // can't both pass the check (one must 404), and a concurrent create/update can't slip a
+ // contact in after the purge. Contacts are stored independently, so purging them here keeps
+ // them from leaking into a same-named list recreated later (AWS deletes them with the list).
+ String prefix = "contact::" + region + "::" + name + "::";
+ synchronized (contactMutationLock) {
+ if (contactListStore.get(key).isEmpty()) {
+ throw contactListNotFound(name);
+ }
+ contactListStore.delete(key);
+ // Delete by the actual stored keys (not keys rebuilt from each value's EmailAddress),
+ // so a persisted entry whose key and EmailAddress diverge is still purged.
+ List<String> contactKeys = contactStore.keys().stream()
+ .filter(k -> k.startsWith(prefix))
+ .toList();
+ for (String contactKey : contactKeys) {
+ contactStore.delete(contactKey);
+ }
+ }
+ LOG.infov("Deleted SES contact list: {0} in region {1}", name, region);
+ }
+
+ private static AwsException contactListNotFound(String name) {
+ return new AwsException("NotFoundException",
+ "List with name: " + name + " doesn't exist.", 404);
+ }
+
+ // SES V2 surfaces missing/invalid input as Smithy validation errors. Field paths and the
+ // enum value order are taken verbatim from real AWS.
+ private static AwsException validationError(String fieldPath, String constraint) {
+ return new AwsException("BadRequestException",
+ "1 validation error detected: Value at '" + fieldPath
+ + "' failed to satisfy constraint: " + constraint, 400);
+ }
+
+ private static void validateContactListName(String name) {
+ if (name == null) {
+ throw validationError("contactListName", "Member must not be null");
+ }
+ if (name.isBlank()) {
+ throw new AwsException("BadRequestException", "ContactListName can't be blank.", 400);
+ }
+ if (!CONTACT_LIST_NAME_CHARS.matcher(name).matches()) {
+ throw new AwsException("BadRequestException",
+ "ContactListName can contain up to 64 characters. Only alphanumeric characters, "
+ + "underscores(_) and hyphens(-) are allowed.", 400);
+ }
+ }
+
+ private static void validateDescription(String description) {
+ if (description != null && description.length() > MAX_LIST_DESCRIPTION_LENGTH) {
+ throw new AwsException("BadRequestException",
+ "List description can contain up to 500 characters.", 400);
+ }
+ }
+
+ // Validates Create/Update input in the same two-phase order as real AWS (verified by probe):
+ // protocol-layer (Smithy) checks across all fields first, then service-level constraints with
+ // ContactListName ahead of topic/description constraints.
+ private static void validateContactListInput(String name, String description, List<Topic> topics) {
+ // Phase 1 — protocol-layer (Smithy) validation: null members and the subscription-status
+ // enum. AWS reports these before any service-level constraint.
+ if (name == null) {
+ throw validationError("contactListName", "Member must not be null");
+ }
+ if (topics != null) {
+ for (int i = 0; i < topics.size(); i++) {
+ Topic t = topics.get(i);
+ String member = "topics." + (i + 1) + ".member.";
+ if (t.getTopicName() == null) {
+ throw validationError(member + "topicName", "Member must not be null");
+ }
+ if (t.getDisplayName() == null) {
+ throw validationError(member + "displayName", "Member must not be null");
+ }
+ if (t.getDefaultSubscriptionStatus() == null) {
+ throw validationError(member + "defaultSubscriptionStatus", "Member must not be null");
+ }
+ if (!SUBSCRIPTION_STATUSES.contains(t.getDefaultSubscriptionStatus())) {
+ throw validationError(member + "defaultSubscriptionStatus",
+ "Member must satisfy enum value set: [OPT_OUT, OPT_IN]");
+ }
+ }
+ }
+ // Phase 2 — service-level constraints: ContactListName first, then topics, then description.
+ if (name.isBlank()) {
+ throw new AwsException("BadRequestException", "ContactListName can't be blank.", 400);
+ }
+ if (!CONTACT_LIST_NAME_CHARS.matcher(name).matches()) {
+ throw new AwsException("BadRequestException",
+ "ContactListName can contain up to 64 characters. Only alphanumeric characters, "
+ + "underscores(_) and hyphens(-) are allowed.", 400);
+ }
+ if (topics != null) {
+ if (topics.size() > MAX_TOPICS_PER_LIST) {
+ throw new AwsException("BadRequestException",
+ "Maximum of <" + MAX_TOPICS_PER_LIST + "> topics allowed per ContactList", 400);
+ }
+ Set<String> seenNames = new HashSet<>();
+ for (Topic t : topics) {
+ if (t.getTopicName().isBlank()) {
+ throw new AwsException("BadRequestException", "TopicName can't be blank.", 400);
+ }
+ if (!CONTACT_LIST_NAME_CHARS.matcher(t.getTopicName()).matches()) {
+ throw new AwsException("BadRequestException",
+ "TopicName can contain up to 64 characters. Only alphanumeric characters, "
+ + "underscores(_) and hyphens(-) are allowed.", 400);
+ }
+ if (t.getDisplayName().length() > MAX_DISPLAY_NAME_LENGTH) {
+ throw new AwsException("BadRequestException",
+ "Topic DisplayName can contain up to <" + MAX_DISPLAY_NAME_LENGTH
+ + "> characters.", 400);
+ }
+ if (!seenNames.add(t.getTopicName())) {
+ throw new AwsException("BadRequestException",
+ "Duplicate topic names are not allowed within a List.", 400);
+ }
+ }
+ }
+ validateDescription(description);
+ }
+
+ private static String contactListKey(String region, String name) {
+ // Validate in the key builder so Get/Update/Delete reject an invalid ContactListName with
+ // the AWS validation error (400) rather than a 404, matching configSetKey. Verified
+ // against real AWS: read/delete with an invalid name returns the same constraint message.
+ validateContactListName(name);
+ return "contactList::" + region + "::" + name;
+ }
+
+ // ─────────────────────────── Contacts ───────────────────────────
+
+ public Contact createContact(String listName, String emailAddress, List<TopicPreference> topicPreferences,
+ Boolean unsubscribeAll, String attributesData, String region) {
+ validateContactInput(listName, emailAddress, topicPreferences, region);
+ Contact contact = new Contact(emailAddress);
+ contact.setTopicPreferences(topicPreferences);
+ contact.setUnsubscribeAll(unsubscribeAll != null && unsubscribeAll);
+ contact.setAttributesData(attributesData);
+ Instant now = Instant.now(clock);
+ contact.setCreatedTimestamp(now);
+ contact.setLastUpdatedTimestamp(now);
+ String key = contactKey(region, listName, emailAddress);
+ // Re-check the list, duplicate, and put under the lock so a concurrent deleteContactList
+ // can't purge the list between validation and the write (which would orphan this contact).
+ synchronized (contactMutationLock) {
+ getContactList(listName, region);
+ if (contactStore.get(key).isPresent()) {
+ throw new AwsException("AlreadyExistsException",
+ emailAddress + " already exists in List.", 400);
+ }
+ contactStore.put(key, contact);
+ }
+ LOG.infov("Created SES contact {0} in list {1} (region {2})", emailAddress, listName, region);
+ return contact;
+ }
+
+ // Read operations return the resolved ContactList alongside the contact(s) so the controller
+ // can render TopicDefaultPreferences without a second getContactList round-trip (which would
+ // open a TOCTOU window where a concurrent delete turns a successful read into "List not found").
+ public record ContactWithList(Contact contact, ContactList list) {
+ }
+
+ public record ContactsWithList(List<Contact> contacts, ContactList list) {
+ }
+
+ public ContactWithList getContact(String listName, String emailAddress, String region) {
+ validateEmailAddress(emailAddress);
+ ContactList list = getContactList(listName, region);
+ Contact contact = contactStore.get(contactKey(region, listName, emailAddress))
+ .orElseThrow(() -> contactNotFound(emailAddress));
+ return new ContactWithList(contact, list);
+ }
+
+ public ContactsWithList listContacts(String listName, String region) {
+ ContactList list = getContactList(listName, region);
+ String prefix = "contact::" + region + "::" + listName + "::";
+ List<Contact> contacts = contactStore.scan(k -> k.startsWith(prefix)).stream()
+ .sorted(Comparator.comparing(Contact::getEmailAddress,
+ Comparator.nullsFirst(Comparator.naturalOrder())))
+ .toList();
+ return new ContactsWithList(contacts, list);
+ }
+
+ public Contact updateContact(String listName, String emailAddress, List<TopicPreference> topicPreferences,
+ boolean topicPreferencesPresent, Boolean unsubscribeAll, String attributesData,
+ String region) {
+ validateContactInput(listName, emailAddress, topicPreferences, region);
+ String key = contactKey(region, listName, emailAddress);
+ Contact existing;
+ // Re-check the list and read-modify-write under the lock so a concurrent deleteContactList
+ // can't purge the contact/list between validation and the write (which would resurrect it).
+ synchronized (contactMutationLock) {
+ getContactList(listName, region);
+ existing = contactStore.get(key).orElseThrow(() -> contactNotFound(emailAddress));
+ // Verified against real AWS: TopicPreferences merge by topic name (omitting keeps existing);
+ // AttributesData and UnsubscribeAll are replaced (omitting clears / resets them).
+ if (topicPreferencesPresent) {
+ existing.setTopicPreferences(mergeTopicPreferences(existing.getTopicPreferences(), topicPreferences));
+ }
+ existing.setUnsubscribeAll(unsubscribeAll != null && unsubscribeAll);
+ existing.setAttributesData(attributesData);
+ existing.setLastUpdatedTimestamp(Instant.now(clock));
+ contactStore.put(key, existing);
+ }
+ LOG.infov("Updated SES contact {0} in list {1}", emailAddress, listName);
+ return existing;
+ }
+
+ public void deleteContact(String listName, String emailAddress, String region) {
+ validateEmailAddress(emailAddress);
+ String key = contactKey(region, listName, emailAddress);
+ // List re-check + existence check + delete under the lock (matching create/update): a
+ // concurrent deleteContactList then surfaces "list not found" rather than "contact not
+ // found", and an updateContact can't put a just-deleted contact back (resurrecting it).
+ synchronized (contactMutationLock) {
+ getContactList(listName, region);
+ if (contactStore.get(key).isEmpty()) {
+ throw contactNotFound(emailAddress);
+ }
+ contactStore.delete(key);
+ }
+ LOG.infov("Deleted SES contact {0} in list {1}", emailAddress, listName);
+ }
+
+ /**
+ * Derives {@code TopicDefaultPreferences}: each list topic the contact has not set an explicit
+ * preference for, carrying that topic's default subscription status.
+ */
+ public List<TopicPreference> deriveTopicDefaultPreferences(Contact contact, ContactList list) {
+ Set<String> explicit = new HashSet<>();
+ for (TopicPreference p : contact.getTopicPreferences()) {
+ explicit.add(p.getTopicName());
+ }
+ List<TopicPreference> defaults = new ArrayList<>();
+ for (Topic t : list.getTopics()) {
+ if (!explicit.contains(t.getTopicName())) {
+ defaults.add(new TopicPreference(t.getTopicName(), t.getDefaultSubscriptionStatus()));
+ }
+ }
+ return defaults;
+ }
+
+ private static AwsException contactNotFound(String emailAddress) {
+ return new AwsException("NotFoundException", emailAddress + " doesn't exist in List.", 404);
+ }
+
+ // Validation order verified against real AWS: protocol-layer (Smithy) topic-preference checks
+ // first, then EmailAddress format, then contact-list existence, then topic existence.
+ private void validateContactInput(String listName, String emailAddress, List<TopicPreference> prefs,
+ String region) {
+ if (prefs != null) {
+ for (int i = 0; i < prefs.size(); i++) {
+ TopicPreference p = prefs.get(i);
+ String member = "topicPreferences." + (i + 1) + ".member.";
+ if (p.getTopicName() == null) {
+ throw validationError(member + "topicName", "Member must not be null");
+ }
+ if (p.getSubscriptionStatus() == null) {
+ throw validationError(member + "subscriptionStatus", "Member must not be null");
+ }
+ if (!SUBSCRIPTION_STATUSES.contains(p.getSubscriptionStatus())) {
+ throw validationError(member + "subscriptionStatus",
+ "Member must satisfy enum value set: [OPT_OUT, OPT_IN]");
+ }
+ }
+ }
+ validateEmailAddress(emailAddress);
+ ContactList list = getContactList(listName, region);
+ if (prefs != null && !prefs.isEmpty()) {
+ Set<String> topicNames = new HashSet<>();
+ for (Topic t : list.getTopics()) {
+ topicNames.add(t.getTopicName());
+ }
+ for (TopicPreference p : prefs) {
+ if (!topicNames.contains(p.getTopicName())) {
+ throw new AwsException("BadRequestException",
+ "List: " + listName + " doesn't contain Topic: " + p.getTopicName(), 400);
+ }
+ }
+ }
+ }
+
+ private static List<TopicPreference> mergeTopicPreferences(List<TopicPreference> existing,
+ List<TopicPreference> provided) {
+ Map<String, TopicPreference> byTopic = new LinkedHashMap<>();
+ if (existing != null) {
+ for (TopicPreference p : existing) {
+ byTopic.put(p.getTopicName(), p);
+ }
+ }
+ if (provided != null) {
+ for (TopicPreference p : provided) {
+ byTopic.put(p.getTopicName(), p);
+ }
+ }
+ return new ArrayList<>(byTopic.values());
+ }
+
+ private static void validateEmailAddress(String emailAddress) {
+ // Verified against real AWS: a missing/null required member is a Smithy validation error,
+ // an empty/blank value is "can't be blank", and only a non-blank malformed value is "invalid".
+ if (emailAddress == null) {
+ throw validationError("emailAddress", "Member must not be null");
+ }
+ if (emailAddress.isBlank()) {
+ throw new AwsException("BadRequestException", "EmailAddress can't be blank.", 400);
+ }
+ if (!EMAIL_PATTERN.matcher(emailAddress).matches()) {
+ throw new AwsException("BadRequestException",
+ "EmailAddress <" + emailAddress + "> is invalid", 400);
+ }
+ }
+
+ private static String contactKey(String region, String listName, String emailAddress) {
+ return "contact::" + region + "::" + listName + "::" + emailAddress;
+ }
+
+ // ──────────────── List-management contact behaviour (used by the send path) ────────────────
+
+ /**
+ * Returns the contact for {@code email} in {@code list}, creating it automatically when absent —
+ * AWS creates a contact on the list when {@code ListManagementOptions} names a recipient that is
+ * not yet a contact. The auto-created contact has no explicit topic preferences (its effective
+ * per-topic status derives from the list topic defaults) and is not unsubscribed. Creation runs
+ * under {@code contactMutationLock} so a concurrent contact-list deletion can't orphan it.
+ */
+ public Contact getOrAutoCreateContact(ContactList list, String email, String region) {
+ String key = contactKey(region, list.getContactListName(), email);
+ Contact existing = contactStore.get(key).orElse(null);
+ if (existing != null) {
+ return existing;
+ }
+ synchronized (contactMutationLock) {
+ Contact raced = contactStore.get(key).orElse(null);
+ if (raced != null) {
+ return raced;
+ }
+ // Re-check the list under the lock so a concurrent deleteContactList (which purges the
+ // list and its contacts under the same lock) can't be followed by this creating an
+ // orphaned contact for a list that no longer exists.
+ getContactList(list.getContactListName(), region);
+ Contact contact = new Contact(email);
+ Instant now = Instant.now(clock);
+ contact.setCreatedTimestamp(now);
+ contact.setLastUpdatedTimestamp(now);
+ contactStore.put(key, contact);
+ LOG.infov("Auto-created SES contact {0} in list {1} on send (region {2})",
+ email, list.getContactListName(), region);
+ return contact;
+ }
+ }
+
+ /**
+ * Whether a contact is opted out for a list-managed send. A contact with {@code UnsubscribeAll}
+ * is opted out of everything. When no topic is given, only {@code UnsubscribeAll} suppresses
+ * (AWS documents suppression of whole-list unsubscribers). When a topic is given, an explicit
+ * {@code OPT_OUT} preference for that topic suppresses; absent an explicit preference, the topic's
+ * {@code DefaultSubscriptionStatus} is used — the default-status fallback at send time is not
+ * documented by AWS but mirrors the effective-status model AWS uses for {@code ListContacts}.
+ */
+ public boolean isListManagementOptedOut(Contact contact, ContactList list, String topicName) {
+ if (contact.isUnsubscribeAll()) {
+ return true;
+ }
+ if (topicName == null) {
+ return false;
+ }
+ String explicit = explicitTopicStatus(contact, topicName);
+ if (explicit != null) {
+ return "OPT_OUT".equals(explicit);
+ }
+ return "OPT_OUT".equals(defaultTopicStatus(list, topicName));
+ }
+
+ private static String explicitTopicStatus(Contact contact, String topicName) {
+ if (contact.getTopicPreferences() == null) {
+ return null;
+ }
+ for (TopicPreference pref : contact.getTopicPreferences()) {
+ if (topicName.equals(pref.getTopicName())) {
+ return pref.getSubscriptionStatus();
+ }
+ }
+ return null;
+ }
+
+ public String defaultTopicStatus(ContactList list, String topicName) {
+ if (list.getTopics() == null) {
+ return null;
+ }
+ for (Topic topic : list.getTopics()) {
+ if (topicName.equals(topic.getTopicName())) {
+ return topic.getDefaultSubscriptionStatus();
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Applies a list-management unsubscribe (the action behind the {@code /_aws/ses/unsubscribe}
+ * link): with a topic, sets that topic's preference to {@code OPT_OUT}; without a topic,
+ * unsubscribes the contact from the whole list ({@code UnsubscribeAll}). The contact is created
+ * if it does not exist yet, consistent with send-time auto-creation. Runs under
+ * {@code contactMutationLock} so a concurrent contact-list deletion can't orphan it.
+ */
+ public void unsubscribeContact(String listName, String emailAddress, String topicName, String region) {
+ validateEmailAddress(emailAddress);
+ String effectiveTopic = (topicName == null || topicName.isBlank()) ? null : topicName;
+ String key = contactKey(region, listName, emailAddress);
+ synchronized (contactMutationLock) {
+ ContactList list = getContactList(listName, region);
+ if (effectiveTopic != null && defaultTopicStatus(list, effectiveTopic) == null) {
+ throw new AwsException("BadRequestException",
+ "Topic " + effectiveTopic + " does not exist in contact list " + listName + ".", 400);
+ }
+ Contact contact = contactStore.get(key).orElseGet(() -> {
+ Contact created = new Contact(emailAddress);
+ created.setCreatedTimestamp(Instant.now(clock));
+ return created;
+ });
+ if (effectiveTopic == null) {
+ contact.setUnsubscribeAll(true);
+ } else {
+ setTopicPreference(contact, effectiveTopic, "OPT_OUT");
+ }
+ contact.setLastUpdatedTimestamp(Instant.now(clock));
+ contactStore.put(key, contact);
+ }
+ LOG.infov("List-management unsubscribe: {0} from list {1} topic {2} (region {3})",
+ emailAddress, listName, effectiveTopic == null ? "<all>" : effectiveTopic, region);
+ }
+
+ private static void setTopicPreference(Contact contact, String topicName, String status) {
+ // Copy into a fresh mutable list and set it back, so this works even if the contact's
+ // preferences were stored as an unmodifiable list (setTopicPreferences keeps the list as-is).
+ List<TopicPreference> prefs = new ArrayList<>(contact.getTopicPreferences());
+ boolean found = false;
+ for (TopicPreference pref : prefs) {
+ if (topicName.equals(pref.getTopicName())) {
+ pref.setSubscriptionStatus(status);
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ prefs.add(new TopicPreference(topicName, status));
+ }
+ contact.setTopicPreferences(prefs);
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java
index 8c5d0d457b..17c41f983c 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java
@@ -1685,7 +1685,7 @@ public class SesController {
if (body != null && !body.isBlank()) {
requireJsonObject(objectMapper.readTree(body));
}
- SesService.ContactsWithList listed = sesService.listContacts(contactListName, region);
+ SesContactService.ContactsWithList listed = sesService.listContacts(contactListName, region);
ObjectNode result = objectMapper.createObjectNode();
ArrayNode arr = result.putArray("Contacts");
for (Contact c : listed.contacts()) {
@@ -1705,7 +1705,7 @@ public class SesController {
@PathParam("contactListName") String contactListName,
@PathParam("emailAddress") String emailAddress) {
String region = regionResolver.resolveRegion(headers);
- SesService.ContactWithList result = sesService.getContact(contactListName, emailAddress, region);
+ SesContactService.ContactWithList result = sesService.getContact(contactListName, emailAddress, region);
return Response.ok(contactJson(result.contact(), result.list(), true)).build();
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesCvetService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesCvetService.java
new file mode 100644
index 0000000000..76086794b4
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesCvetService.java
@@ -0,0 +1,123 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.CustomVerificationEmailTemplate;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Storage for custom verification email templates (the {@code cvetStore}), extracted from
+ * {@link SesService} as the third step of the store-based domain split.
+ *
+ * <p>This owns only the persistence and the concurrency guard. The cross-domain parts stay in the
+ * {@link SesService} facade, which orchestrates them: {@code validateCustomVerificationTemplate}
+ * (its "From must be a verified identity" check reaches the Identity domain) runs in the facade
+ * before create/update delegate here, and {@code sendCustomVerificationEmail} stays in the facade
+ * and only reads a template through {@link #find}. This is the facade-as-coordinator model:
+ * a domain used by the send path is not turned into a cross-service dependency.
+ */
+@ApplicationScoped
+public class SesCvetService {
+
+ private static final Logger LOG = Logger.getLogger(SesCvetService.class);
+
+ private final StorageBackend<String, CustomVerificationEmailTemplate> cvetStore;
+ // Serializes custom-verification-template create/update/delete check-then-write so concurrent
+ // creates for the same name can't both succeed and an update can't resurrect a concurrently
+ // deleted template.
+ private final Object cvetMutationLock = new Object();
+
+ @Inject
+ public SesCvetService(StorageFactory storageFactory) {
+ this.cvetStore = storageFactory.create("ses", "ses-custom-verification-templates.json",
+ new TypeReference<Map<String, CustomVerificationEmailTemplate>>() {});
+ }
+
+ SesCvetService(StorageBackend<String, CustomVerificationEmailTemplate> cvetStore) {
+ this.cvetStore = cvetStore;
+ }
+
+ public void createCustomVerificationEmailTemplate(CustomVerificationEmailTemplate template, String region) {
+ String key = cvetKey(region, template.getTemplateName());
+ // Lock only the check-then-put so concurrent creates for the same name can't both observe
+ // the key as absent; the facade's validation and this logging stay outside the lock.
+ synchronized (cvetMutationLock) {
+ if (cvetStore.get(key).isPresent()) {
+ // v1-native code (verified: CustomVerificationEmailTemplateAlreadyExists / 400);
+ // remapV1Exception translates it to AlreadyExistsException / 400 for the v2 boundary.
+ throw new AwsException("CustomVerificationEmailTemplateAlreadyExists",
+ "Custom verification email template <" + template.getTemplateName() + "> already exists", 400);
+ }
+ cvetStore.put(key, template);
+ }
+ LOG.infov("Created custom verification email template {0} in region {1}",
+ template.getTemplateName(), region);
+ }
+
+ public CustomVerificationEmailTemplate getCustomVerificationEmailTemplate(String templateName, String region) {
+ return cvetStore.get(cvetKey(region, templateName)).orElseThrow(() -> cvetNotFound(templateName));
+ }
+
+ public List<CustomVerificationEmailTemplate> listCustomVerificationEmailTemplates(String region) {
+ String prefix = "cvet::" + region + "::";
+ return cvetStore.scan(k -> k.startsWith(prefix)).stream()
+ .sorted(Comparator.comparing(CustomVerificationEmailTemplate::getTemplateName,
+ Comparator.nullsFirst(Comparator.naturalOrder())))
+ .toList();
+ }
+
+ public void updateCustomVerificationEmailTemplate(CustomVerificationEmailTemplate template, String region) {
+ String key = cvetKey(region, template.getTemplateName());
+ // Guard the existence check and the put together so a concurrent delete can't slip between
+ // them and have the update resurrect the just-deleted template.
+ synchronized (cvetMutationLock) {
+ if (cvetStore.get(key).isEmpty()) {
+ throw cvetNotFound(template.getTemplateName());
+ }
+ cvetStore.put(key, template);
+ }
+ LOG.infov("Updated custom verification email template {0} in region {1}",
+ template.getTemplateName(), region);
+ }
+
+ public void deleteCustomVerificationEmailTemplate(String templateName, String region) {
+ String key = cvetKey(region, templateName);
+ // Guard the check-then-delete on the same lock as create/update so the three mutations
+ // serialize against each other.
+ synchronized (cvetMutationLock) {
+ if (cvetStore.get(key).isEmpty()) {
+ throw cvetNotFound(templateName);
+ }
+ cvetStore.delete(key);
+ }
+ LOG.infov("Deleted custom verification email template {0} in region {1}", templateName, region);
+ }
+
+ /**
+ * Looks up a template without throwing, so the facade's {@code sendCustomVerificationEmail} can
+ * raise its own send-specific "does not exist" message rather than the CRUD one.
+ */
+ public Optional<CustomVerificationEmailTemplate> find(String templateName, String region) {
+ return cvetStore.get(cvetKey(region, templateName));
+ }
+
+ private static AwsException cvetNotFound(String templateName) {
+ // v1-native code (verified: CustomVerificationEmailTemplateDoesNotExist / 400).
+ // SesController.remapV1Exception translates it to NotFoundException / 404 for the v2 boundary.
+ return new AwsException("CustomVerificationEmailTemplateDoesNotExist",
+ "Custom verification email template <" + templateName + "> does not exist", 400);
+ }
+
+ private static String cvetKey(String region, String templateName) {
+ return "cvet::" + region + "::" + templateName;
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpService.java
new file mode 100644
index 0000000000..af196dc063
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpService.java
@@ -0,0 +1,91 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.DedicatedIpPool;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Dedicated IP pools (the {@code dedicatedIpPoolStore}), extracted from {@link SesService} as part of
+ * the store-based domain split. A clean leaf reached through the {@code SesService}
+ * facade, which delegates here; the facade's configuration-set delivery-options validation also
+ * checks pool existence through {@link #dedicatedIpPoolExists}.
+ */
+@ApplicationScoped
+public class SesDedicatedIpService {
+
+ private static final Logger LOG = Logger.getLogger(SesDedicatedIpService.class);
+
+ private static final Set<String> SCALING_MODES = Set.of("STANDARD", "MANAGED");
+
+ private final StorageBackend<String, DedicatedIpPool> dedicatedIpPoolStore;
+
+ @Inject
+ public SesDedicatedIpService(StorageFactory storageFactory) {
+ this.dedicatedIpPoolStore = storageFactory.create("ses", "ses-dedicated-ip-pools.json",
+ new TypeReference<Map<String, DedicatedIpPool>>() {});
+ }
+
+ SesDedicatedIpService(StorageBackend<String, DedicatedIpPool> dedicatedIpPoolStore) {
+ this.dedicatedIpPoolStore = dedicatedIpPoolStore;
+ }
+
+ public DedicatedIpPool createDedicatedIpPool(String poolName, String scalingMode, String region) {
+ if (poolName == null || poolName.isBlank()) {
+ throw new AwsException("BadRequestException", "PoolName is required.", 400);
+ }
+ String effectiveScaling = (scalingMode == null || scalingMode.isBlank()) ? "STANDARD" : scalingMode;
+ if (!SCALING_MODES.contains(effectiveScaling)) {
+ throw new AwsException("BadRequestException", "The ScalingMode parameter is invalid.", 400);
+ }
+ String key = dedicatedIpPoolKey(region, poolName);
+ if (dedicatedIpPoolStore.get(key).isPresent()) {
+ throw new AwsException("AlreadyExistsException",
+ "The pool <" + poolName + "> already exists.", 400);
+ }
+ DedicatedIpPool pool = new DedicatedIpPool(poolName, effectiveScaling);
+ dedicatedIpPoolStore.put(key, pool);
+ LOG.infov("Created SES dedicated IP pool: {0} in region {1}", poolName, region);
+ return pool;
+ }
+
+ public DedicatedIpPool getDedicatedIpPool(String poolName, String region) {
+ return dedicatedIpPoolStore.get(dedicatedIpPoolKey(region, poolName))
+ .orElseThrow(() -> new AwsException("NotFoundException",
+ "The requested pool <" + poolName + "> does not exist.", 404));
+ }
+
+ public boolean dedicatedIpPoolExists(String poolName, String region) {
+ return dedicatedIpPoolStore.get(dedicatedIpPoolKey(region, poolName)).isPresent();
+ }
+
+ public List<String> listDedicatedIpPools(String region) {
+ String prefix = "dedicatedIpPool::" + region + "::";
+ return dedicatedIpPoolStore.scan(k -> k.startsWith(prefix)).stream()
+ .map(DedicatedIpPool::getPoolName)
+ .sorted()
+ .toList();
+ }
+
+ public void deleteDedicatedIpPool(String poolName, String region) {
+ String key = dedicatedIpPoolKey(region, poolName);
+ if (dedicatedIpPoolStore.get(key).isEmpty()) {
+ throw new AwsException("NotFoundException",
+ "The requested pool <" + poolName + "> does not exist.", 404);
+ }
+ dedicatedIpPoolStore.delete(key);
+ LOG.infov("Deleted SES dedicated IP pool: {0} in region {1}", poolName, region);
+ }
+
+ private static String dedicatedIpPoolKey(String region, String name) {
+ return "dedicatedIpPool::" + region + "::" + name;
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesPolicyService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesPolicyService.java
new file mode 100644
index 0000000000..35b74f4bc8
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesPolicyService.java
@@ -0,0 +1,211 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * Identity sending-authorization policies (the {@code policyStore}), extracted from
+ * {@link SesService} as the fourth step of the store-based domain split.
+ *
+ * <p>New facet vs the earlier steps: a two-way relationship with the (not-yet-extracted) Identity
+ * domain. The facade keeps the identity-existence check ({@code requireIdentityExists} reads the
+ * identity store) and runs it before delegating the v2 mutators here. In the other direction, the
+ * facade's {@code deleteIdentity} calls {@link #deletePoliciesForIdentity} so an identity's policies
+ * are purged with it — the monolith depending on the extracted service, which is how the pieces will
+ * fit once Identity is itself extracted.
+ */
+@ApplicationScoped
+public class SesPolicyService {
+
+ private static final Logger LOG = Logger.getLogger(SesPolicyService.class);
+
+ static final int MAX_POLICIES_PER_IDENTITY = 20;
+ private static final Pattern POLICY_NAME_CHARS = Pattern.compile("[A-Za-z0-9_-]+");
+
+ private final StorageBackend<String, String> policyStore;
+ // Serializes the per-identity policy count check-then-put so concurrent creates can't both pass.
+ private final Object policyMutationLock = new Object();
+ private final ObjectMapper objectMapper;
+
+ @Inject
+ public SesPolicyService(StorageFactory storageFactory, ObjectMapper objectMapper) {
+ this.policyStore = storageFactory.create("ses", "ses-identity-policies.json",
+ new TypeReference<Map<String, String>>() {});
+ this.objectMapper = objectMapper;
+ }
+
+ SesPolicyService(StorageBackend<String, String> policyStore, ObjectMapper objectMapper) {
+ this.policyStore = policyStore;
+ this.objectMapper = objectMapper;
+ }
+
+ // v1 PutIdentityPolicy: upsert (create or overwrite); v1 does not require the identity to exist.
+ public void putIdentityPolicy(String identity, String policyName, String policy, String region) {
+ validatePolicyName(policyName);
+ String normalized = normalizePolicy(policy);
+ String key = policyKey(region, identity, policyName);
+ synchronized (policyMutationLock) {
+ if (policyStore.get(key).isEmpty()) {
+ enforcePolicyLimit(region, identity, false);
+ }
+ policyStore.put(key, normalized);
+ }
+ LOG.infov("SES PutIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ }
+
+ // v2 CreateEmailIdentityPolicy: fails if the name already exists. The identity-existence check is
+ // done by the SesService facade before this is called.
+ public void createEmailIdentityPolicy(String identity, String policyName, String policy, String region) {
+ validatePolicyName(policyName);
+ String normalized = normalizePolicy(policy);
+ String key = policyKey(region, identity, policyName);
+ synchronized (policyMutationLock) {
+ if (policyStore.get(key).isPresent()) {
+ throw new AwsException("AlreadyExistsException",
+ "Policy <" + policyName + "> already exists", 400);
+ }
+ enforcePolicyLimit(region, identity, true);
+ policyStore.put(key, normalized);
+ }
+ LOG.infov("SES v2 CreateEmailIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ }
+
+ // v2 UpdateEmailIdentityPolicy: fails if the name is missing. Identity check done by the facade.
+ public void updateEmailIdentityPolicy(String identity, String policyName, String policy, String region) {
+ validatePolicyName(policyName);
+ String normalized = normalizePolicy(policy);
+ String key = policyKey(region, identity, policyName);
+ synchronized (policyMutationLock) {
+ if (policyStore.get(key).isEmpty()) {
+ throw policyNotFound(policyName);
+ }
+ policyStore.put(key, normalized);
+ }
+ LOG.infov("SES v2 UpdateEmailIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ }
+
+ // v1 GetIdentityPolicies: requested names only, missing silently omitted; no identity check.
+ public Map<String, String> getIdentityPolicies(String identity, List<String> policyNames, String region) {
+ Map<String, String> out = new LinkedHashMap<>();
+ for (String name : policyNames) {
+ policyStore.get(policyKey(region, identity, name)).ifPresent(doc -> out.put(name, doc));
+ }
+ return out;
+ }
+
+ // All policies for the identity, keyed by policy name.
+ public Map<String, String> listAllPolicies(String identity, String region) {
+ String prefix = policyPrefix(region, identity);
+ Map<String, String> out = new LinkedHashMap<>();
+ for (String key : policyStore.keys()) {
+ if (key.startsWith(prefix)) {
+ policyStore.get(key).ifPresent(doc -> out.put(key.substring(prefix.length()), doc));
+ }
+ }
+ return out;
+ }
+
+ // v1 ListIdentityPolicies: policy names (sorted); no identity check.
+ public List<String> listIdentityPolicyNames(String identity, String region) {
+ return listAllPolicies(identity, region).keySet().stream().sorted().toList();
+ }
+
+ // v2 DeleteEmailIdentityPolicy: NotFound if the policy is missing. Identity check done by the facade.
+ public void deleteEmailIdentityPolicy(String identity, String policyName, String region) {
+ String key = policyKey(region, identity, policyName);
+ synchronized (policyMutationLock) {
+ if (policyStore.get(key).isEmpty()) {
+ throw policyNotFound(policyName);
+ }
+ policyStore.delete(key);
+ }
+ LOG.infov("SES v2 DeleteEmailIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ }
+
+ // v1 DeleteIdentityPolicy: idempotent; no identity check, no error on a missing policy.
+ public void deleteIdentityPolicy(String identity, String policyName, String region) {
+ policyStore.delete(policyKey(region, identity, policyName));
+ LOG.infov("SES DeleteIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ }
+
+ /**
+ * Purges every policy attached to an identity. Called by the facade's {@code deleteIdentity} so
+ * policies can't resurrect into a same-named identity recreated later (and the per-identity count
+ * stays correct).
+ */
+ public void deletePoliciesForIdentity(String identity, String region) {
+ synchronized (policyMutationLock) {
+ String prefix = policyPrefix(region, identity);
+ for (String key : List.copyOf(policyStore.keys())) {
+ if (key.startsWith(prefix)) {
+ policyStore.delete(key);
+ }
+ }
+ }
+ }
+
+ private void enforcePolicyLimit(String region, String identity, boolean v2) {
+ long count = policyStore.keys().stream()
+ .filter(k -> k.startsWith(policyPrefix(region, identity))).count();
+ if (count >= MAX_POLICIES_PER_IDENTITY) {
+ String msg = "Number of policies for <" + identity
+ + "> exceeds max allowed number of policies per resource";
+ throw new AwsException(v2 ? "LimitExceededException" : "InvalidParameterValue", msg, 400);
+ }
+ }
+
+ // Error codes are the v1 (Query) codes verified against AWS; the v2 controller remaps them to
+ // BadRequestException. The messages are identical across v1 and v2.
+ private static void validatePolicyName(String policyName) {
+ if (policyName == null || policyName.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "PolicyName is required.", 400);
+ }
+ if (policyName.length() > 64) {
+ throw new AwsException("ValidationError",
+ "1 validation error detected: Value at 'policyName' failed to satisfy constraint: "
+ + "Member must have length less than or equal to 64", 400);
+ }
+ if (!POLICY_NAME_CHARS.matcher(policyName).matches()) {
+ throw new AwsException("InvalidParameterValue",
+ "PolicyName is invalid. Policy names must only include alpha-numeric characters, "
+ + "dashes, and underscores.", 400);
+ }
+ }
+
+ private String normalizePolicy(String policy) {
+ if (policy == null || policy.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "Policy is required.", 400);
+ }
+ try {
+ // AWS returns the policy with insignificant whitespace stripped; compact it to match.
+ return objectMapper.readTree(policy).toString();
+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
+ // Floci does not validate policy semantics; keep an unparseable document verbatim.
+ LOG.debugv("Identity policy is not valid JSON, storing as-is: {0}", e.getMessage());
+ return policy;
+ }
+ }
+
+ private static AwsException policyNotFound(String policyName) {
+ return new AwsException("NotFoundException", "Policy <" + policyName + "> does not exist", 404);
+ }
+
+ private static String policyKey(String region, String identity, String policyName) {
+ return policyPrefix(region, identity) + policyName;
+ }
+
+ private static String policyPrefix(String region, String identity) {
+ return "policy::" + region + "::" + identity + "::";
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesReceiptRuleService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesReceiptRuleService.java
new file mode 100644
index 0000000000..23cd91d3e2
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesReceiptRuleService.java
@@ -0,0 +1,175 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.ReceiptRuleSet;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.time.Clock;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * Owns the SES receipt-rule-set domain (the {@code receiptRuleSetStore}). Extracted from
+ * {@link SesService} as the first step of the store-based domain split: a leaf
+ * domain with no cross-service coupling, reached only through the {@code SesService} facade, which
+ * now delegates its {@code *ReceiptRuleSet*} methods here.
+ *
+ * <p>Floci has no inbound-mail endpoint, so receipt rule sets are stored inertly: a set never holds
+ * any rules and routes no mail. They exist only so the management API round-trips (enough to unblock
+ * tools such as Terraform that declare a rule set during bootstrap).
+ */
+@ApplicationScoped
+public class SesReceiptRuleService {
+
+ private static final Logger LOG = Logger.getLogger(SesReceiptRuleService.class);
+
+ // These RuleSetName constraints are not in the botocore model: service-2.json (SES 2010-12-01)
+ // declares ReceiptRuleSetName as a bare {"type": "string"} with no pattern or length. They were
+ // established by probing real SES in us-west-2 via boto3 (2026-08): a character outside
+ // ^[a-zA-Z0-9_.-]+$ is a Smithy ValidationError, and a name that is >64 chars or does not
+ // start/end with an alphanumeric is a service-level "Not a valid ruleSetName" InvalidParameterValue.
+ // Re-verify against live SES (not the model, which can't confirm it) if these ever need to change.
+ private static final Pattern RULE_SET_NAME_CHARS = Pattern.compile("^[a-zA-Z0-9_.-]+$");
+
+ private final StorageBackend<String, ReceiptRuleSet> receiptRuleSetStore;
+ // Serializes receipt-rule-set create (check-then-put) and set-active (clear-then-set) so the
+ // one-active-per-region invariant and duplicate-name rejection hold under concurrency.
+ private final Object receiptRuleSetLock = new Object();
+ private final Clock clock;
+
+ @Inject
+ public SesReceiptRuleService(StorageFactory storageFactory, Clock clock) {
+ this.receiptRuleSetStore = storageFactory.create("ses", "ses-receipt-rule-sets.json",
+ new TypeReference<Map<String, ReceiptRuleSet>>() {});
+ this.clock = clock;
+ }
+
+ SesReceiptRuleService(StorageBackend<String, ReceiptRuleSet> receiptRuleSetStore, Clock clock) {
+ this.receiptRuleSetStore = receiptRuleSetStore;
+ this.clock = clock;
+ }
+
+ public ReceiptRuleSet createReceiptRuleSet(String name, String region) {
+ requireRuleSetName(name);
+ String key = receiptRuleSetKey(region, name);
+ ReceiptRuleSet ruleSet = new ReceiptRuleSet(name, Instant.now(clock));
+ synchronized (receiptRuleSetLock) {
+ if (receiptRuleSetStore.get(key).isPresent()) {
+ throw new AwsException("AlreadyExists", "Rule set already exists: " + name, 400);
+ }
+ receiptRuleSetStore.put(key, ruleSet);
+ }
+ LOG.infov("Created SES receipt rule set: {0} in region {1}", name, region);
+ return ruleSet;
+ }
+
+ public ReceiptRuleSet describeReceiptRuleSet(String name, String region) {
+ requireRuleSetName(name);
+ return receiptRuleSetStore.get(receiptRuleSetKey(region, name))
+ .orElseThrow(() -> ruleSetDoesNotExist(name));
+ }
+
+ public List<ReceiptRuleSet> listReceiptRuleSets(String region) {
+ String prefix = "receiptRuleSet::" + region + "::";
+ List<ReceiptRuleSet> all = new ArrayList<>(receiptRuleSetStore.scan(k -> k.startsWith(prefix)));
+ all.sort(Comparator.comparing(ReceiptRuleSet::getCreatedTimestamp,
+ Comparator.nullsLast(Comparator.naturalOrder()))
+ .thenComparing(ReceiptRuleSet::getName, Comparator.nullsLast(Comparator.naturalOrder())));
+ return all;
+ }
+
+ public void deleteReceiptRuleSet(String name, String region) {
+ requireRuleSetName(name);
+ // Hold the lock so the active-check-then-delete is atomic and a concurrent set-active/clear
+ // (which scans and re-puts active sets) can't resurrect the rule set we just deleted.
+ synchronized (receiptRuleSetLock) {
+ ReceiptRuleSet existing = receiptRuleSetStore.get(receiptRuleSetKey(region, name)).orElse(null);
+ if (existing != null && existing.isActive()) {
+ // AWS rejects deleting the active rule set (verified: CannotDelete / 400).
+ throw new AwsException("CannotDelete", "Cannot delete active rule set: " + name, 400);
+ }
+ // AWS is idempotent otherwise: deleting a non-existent rule set succeeds without error.
+ receiptRuleSetStore.delete(receiptRuleSetKey(region, name));
+ }
+ LOG.infov("Deleted SES receipt rule set: {0} in region {1}", name, region);
+ }
+
+ public void setActiveReceiptRuleSet(String name, String region) {
+ // No RuleSetName clears the account's active rule set (matches AWS).
+ boolean clearOnly = name == null || name.isBlank();
+ if (!clearOnly) {
+ requireRuleSetName(name);
+ }
+ synchronized (receiptRuleSetLock) {
+ if (!clearOnly) {
+ ReceiptRuleSet target = receiptRuleSetStore.get(receiptRuleSetKey(region, name))
+ .orElseThrow(() -> ruleSetDoesNotExist(name));
+ clearActiveReceiptRuleSet(region);
+ target.setActive(true);
+ receiptRuleSetStore.put(receiptRuleSetKey(region, name), target);
+ } else {
+ clearActiveReceiptRuleSet(region);
+ }
+ }
+ if (clearOnly) {
+ LOG.infov("Cleared active SES receipt rule set in region {0}", region);
+ } else {
+ LOG.infov("Set active SES receipt rule set: {0} in region {1}", name, region);
+ }
+ }
+
+ public ReceiptRuleSet describeActiveReceiptRuleSet(String region) {
+ String prefix = "receiptRuleSet::" + region + "::";
+ // Read under the lock so a concurrent set-active replacement (clear-then-set) can't expose its
+ // intermediate no-active state — the reader sees either the old or the new active set.
+ synchronized (receiptRuleSetLock) {
+ return receiptRuleSetStore.scan(k -> k.startsWith(prefix)).stream()
+ .filter(ReceiptRuleSet::isActive)
+ .findFirst()
+ .orElse(null);
+ }
+ }
+
+ private void clearActiveReceiptRuleSet(String region) {
+ String prefix = "receiptRuleSet::" + region + "::";
+ for (ReceiptRuleSet rs : receiptRuleSetStore.scan(k -> k.startsWith(prefix))) {
+ if (rs.isActive()) {
+ rs.setActive(false);
+ receiptRuleSetStore.put(receiptRuleSetKey(region, rs.getName()), rs);
+ }
+ }
+ }
+
+ private static void requireRuleSetName(String name) {
+ if (name == null || name.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "RuleSetName is required.", 400);
+ }
+ if (!RULE_SET_NAME_CHARS.matcher(name).matches()) {
+ throw new AwsException("ValidationError",
+ "1 validation error detected: Value at 'ruleSetName' failed to satisfy constraint: "
+ + "Member must satisfy regular expression pattern: ^[a-zA-Z0-9_.-]+$", 400);
+ }
+ if (name.length() > 64
+ || !Character.isLetterOrDigit(name.charAt(0))
+ || !Character.isLetterOrDigit(name.charAt(name.length() - 1))) {
+ throw new AwsException("InvalidParameterValue", "Not a valid ruleSetName: " + name, 400);
+ }
+ }
+
+ private static AwsException ruleSetDoesNotExist(String name) {
+ return new AwsException("RuleSetDoesNotExist", "Rule set does not exist: " + name, 400);
+ }
+
+ private static String receiptRuleSetKey(String region, String name) {
+ return "receiptRuleSet::" + region + "::" + name;
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesSentEmailService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesSentEmailService.java
new file mode 100644
index 0000000000..767ced6018
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesSentEmailService.java
@@ -0,0 +1,59 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.SentEmail;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Sent-email records (the {@code emailStore}), extracted from {@link SesService} as part of the
+ * store-based domain split. This is the send path's output sink: the facade's send methods keep the
+ * whole send orchestration and only hand the finished record here through {@link #record}, while the
+ * send-statistics and inspection endpoints read it back through {@link #countInRegion} /
+ * {@link #listAll} / {@link #clear}. Nothing else reads the store, so it is a clean leaf.
+ */
+@ApplicationScoped
+public class SesSentEmailService {
+
+ private static final Logger LOG = Logger.getLogger(SesSentEmailService.class);
+
+ private final StorageBackend<String, SentEmail> emailStore;
+
+ @Inject
+ public SesSentEmailService(StorageFactory storageFactory) {
+ this.emailStore = storageFactory.create("ses", "ses-emails.json",
+ new TypeReference<Map<String, SentEmail>>() {});
+ }
+
+ SesSentEmailService(StorageBackend<String, SentEmail> emailStore) {
+ this.emailStore = emailStore;
+ }
+
+ public void record(String region, String messageId, SentEmail email) {
+ emailStore.put(emailKey(region, messageId), email);
+ }
+
+ public long countInRegion(String region) {
+ String prefix = "email::" + region + "::";
+ return emailStore.scan(k -> k.startsWith(prefix)).size();
+ }
+
+ public List<SentEmail> listAll() {
+ return emailStore.scan(k -> k.startsWith("email::"));
+ }
+
+ public void clear() {
+ emailStore.clear();
+ LOG.info("Cleared all SES emails");
+ }
+
+ private static String emailKey(String region, String messageId) {
+ return "email::" + region + "::" + messageId;
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java
index 5229e61ec5..47cbb11516 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java
@@ -84,37 +84,31 @@ public class SesService {
private static final SecureRandom BOUNDARY_RANDOM = new SecureRandom();
private final StorageBackend<String, Identity> identityStore;
- private final StorageBackend<String, SentEmail> emailStore;
- private final StorageBackend<String, Boolean> accountSettingsStore;
- private final StorageBackend<String, EmailTemplate> templateStore;
+ // Sent-email records extracted to SesSentEmailService. The send path records finished emails via
+ // it; send-statistics and inspection read back through it.
+ private final SesSentEmailService sentEmailService;
+ // Account-level settings, extracted to its own service. The facade delegates.
+ private final SesAccountService accountService;
+ // Email templates extracted to SesTemplateService. The facade delegates; the templated-send path
+ // reads via it, and ARN-dispatched tagging reads/writes via its find/save.
+ private final SesTemplateService templateService;
private final StorageBackend<String, ConfigurationSet> configSetStore;
- private final StorageBackend<String, SuppressedDestination> suppressionStore;
- private final StorageBackend<String, AccountSuppressionAttributes> accountSuppressionStore;
- private final StorageBackend<String, AccountVdmAttributes> accountVdmStore;
- private final StorageBackend<String, DedicatedIpPool> dedicatedIpPoolStore;
- private final StorageBackend<String, ContactList> contactListStore;
- private final StorageBackend<String, Contact> contactStore;
- // Identity (sending authorization) policies: key policy::<region>::<identity>::<policyName>,
- // value the (normalized) policy JSON. One store shared by the v1 and v2 policy APIs.
- private final StorageBackend<String, String> policyStore;
- private final StorageBackend<String, ReceiptRuleSet> receiptRuleSetStore;
- // Custom verification email templates (key cvet::<region>::<name>), shared by the v1 and v2 APIs.
- private final StorageBackend<String, CustomVerificationEmailTemplate> cvetStore;
- // Guards the one-list-per-account check-then-create so concurrent creates can't both pass.
- private final Object contactListCreateLock = new Object();
- // Serializes contact create/update against contact-list deletion so a concurrent delete
- // can't purge the list between validation and the write, leaving an orphaned contact.
- private final Object contactMutationLock = new Object();
- // Serializes the per-identity policy count check-then-put so concurrent creates can't both pass.
- private final Object policyMutationLock = new Object();
- static final int MAX_POLICIES_PER_IDENTITY = 20;
- // Serializes receipt-rule-set create (check-then-put) and set-active (clear-then-set) so the
- // one-active-per-region invariant and duplicate-name rejection hold under concurrency.
- private final Object receiptRuleSetLock = new Object();
- // Serializes custom-verification-template create/update/delete check-then-write so concurrent
- // creates for the same name can't both succeed and an update can't resurrect a concurrently
- // deleted template.
- private final Object cvetMutationLock = new Object();
+ // Account suppression attributes + the per-address suppression list (two stores) extracted to
+ // SesSuppressionService. The facade delegates; its send filters read via it.
+ private final SesSuppressionService suppressionService;
+ // Dedicated IP pools extracted to SesDedicatedIpService. The facade delegates.
+ private final SesDedicatedIpService dedicatedIpService;
+ // Contact lists and contacts (two stores) extracted to SesContactService. The
+ // facade delegates, and its send-path list-management orchestration calls into the service.
+ private final SesContactService contactService;
+ // Identity (sending authorization) policy storage, extracted to SesPolicyService.
+ // The facade keeps the identity-existence check and delegates the rest.
+ private final SesPolicyService policyService;
+ // Receipt-rule-set domain, extracted to its own service. The facade delegates.
+ private final SesReceiptRuleService receiptRuleService;
+ // Custom verification email templates: storage extracted to SesCvetService. The
+ // facade keeps the identity-dependent validation and the send path; the service owns the store.
+ private final SesCvetService cvetService;
private final SmtpRelay smtpRelay;
private final ObjectMapper objectMapper;
private final SesEventPublisher eventPublisher;
@@ -127,37 +121,27 @@ public class SesService {
private final ConcurrentHashMap<String, DkimLookupCacheEntry> dkimLookupCache = new ConcurrentHashMap<>();
@Inject
- public SesService(StorageFactory storageFactory, SmtpRelay smtpRelay, ObjectMapper objectMapper,
+ public SesService(StorageFactory storageFactory, SesReceiptRuleService receiptRuleService,
+ SesAccountService accountService, SesCvetService cvetService,
+ SesPolicyService policyService, SesContactService contactService,
+ SesSuppressionService suppressionService, SesDedicatedIpService dedicatedIpService,
+ SesTemplateService templateService, SesSentEmailService sentEmailService,
+ SmtpRelay smtpRelay, ObjectMapper objectMapper,
SesEventPublisher eventPublisher, EmulatorConfig config, Route53Service route53Service,
Clock clock) {
this.identityStore = storageFactory.create("ses", "ses-identities.json",
new TypeReference<Map<String, Identity>>() {});
- this.emailStore = storageFactory.create("ses", "ses-emails.json",
- new TypeReference<Map<String, SentEmail>>() {});
- this.accountSettingsStore = storageFactory.create("ses", "ses-account-settings.json",
- new TypeReference<Map<String, Boolean>>() {});
- this.templateStore = storageFactory.create("ses", "ses-templates.json",
- new TypeReference<Map<String, EmailTemplate>>() {});
+ this.sentEmailService = sentEmailService;
+ this.accountService = accountService;
+ this.templateService = templateService;
this.configSetStore = storageFactory.create("ses", "ses-config-sets.json",
new TypeReference<Map<String, ConfigurationSet>>() {});
- this.suppressionStore = storageFactory.create("ses", "ses-suppression.json",
- new TypeReference<Map<String, SuppressedDestination>>() {});
- this.accountSuppressionStore = storageFactory.create("ses", "ses-account-suppression.json",
- new TypeReference<Map<String, AccountSuppressionAttributes>>() {});
- this.accountVdmStore = storageFactory.create("ses", "ses-account-vdm.json",
- new TypeReference<Map<String, AccountVdmAttributes>>() {});
- this.dedicatedIpPoolStore = storageFactory.create("ses", "ses-dedicated-ip-pools.json",
- new TypeReference<Map<String, DedicatedIpPool>>() {});
- this.contactListStore = storageFactory.create("ses", "ses-contact-lists.json",
- new TypeReference<Map<String, ContactList>>() {});
- this.contactStore = storageFactory.create("ses", "ses-contacts.json",
- new TypeReference<Map<String, Contact>>() {});
- this.policyStore = storageFactory.create("ses", "ses-identity-policies.json",
- new TypeReference<Map<String, String>>() {});
- this.receiptRuleSetStore = storageFactory.create("ses", "ses-receipt-rule-sets.json",
- new TypeReference<Map<String, ReceiptRuleSet>>() {});
- this.cvetStore = storageFactory.create("ses", "ses-custom-verification-templates.json",
- new TypeReference<Map<String, CustomVerificationEmailTemplate>>() {});
+ this.suppressionService = suppressionService;
+ this.dedicatedIpService = dedicatedIpService;
+ this.contactService = contactService;
+ this.policyService = policyService;
+ this.receiptRuleService = receiptRuleService;
+ this.cvetService = cvetService;
this.smtpRelay = smtpRelay;
this.objectMapper = objectMapper;
this.eventPublisher = eventPublisher;
@@ -168,59 +152,50 @@ public class SesService {
}
SesService(StorageBackend<String, Identity> identityStore,
- StorageBackend<String, SentEmail> emailStore,
- StorageBackend<String, Boolean> accountSettingsStore,
- StorageBackend<String, EmailTemplate> templateStore,
+ SesSentEmailService sentEmailService,
+ SesAccountService accountService,
+ SesTemplateService templateService,
StorageBackend<String, ConfigurationSet> configSetStore,
- StorageBackend<String, SuppressedDestination> suppressionStore,
- StorageBackend<String, AccountSuppressionAttributes> accountSuppressionStore,
- StorageBackend<String, AccountVdmAttributes> accountVdmStore,
- StorageBackend<String, DedicatedIpPool> dedicatedIpPoolStore,
- StorageBackend<String, ContactList> contactListStore,
- StorageBackend<String, Contact> contactStore,
- StorageBackend<String, String> policyStore,
- StorageBackend<String, ReceiptRuleSet> receiptRuleSetStore,
- StorageBackend<String, CustomVerificationEmailTemplate> cvetStore,
+ SesSuppressionService suppressionService,
+ SesDedicatedIpService dedicatedIpService,
+ SesContactService contactService,
+ SesPolicyService policyService,
+ SesReceiptRuleService receiptRuleService,
+ SesCvetService cvetService,
SmtpRelay smtpRelay,
ObjectMapper objectMapper,
Clock clock) {
- this(identityStore, emailStore, accountSettingsStore, templateStore, configSetStore, suppressionStore,
- accountSuppressionStore, accountVdmStore, dedicatedIpPoolStore, contactListStore, contactStore,
- policyStore, receiptRuleSetStore, cvetStore, smtpRelay, objectMapper, null, clock);
+ this(identityStore, sentEmailService, accountService, templateService, configSetStore, suppressionService,
+ dedicatedIpService, contactService, policyService,
+ receiptRuleService, cvetService, smtpRelay, objectMapper, null, clock);
}
SesService(StorageBackend<String, Identity> identityStore,
- StorageBackend<String, SentEmail> emailStore,
- StorageBackend<String, Boolean> accountSettingsStore,
- StorageBackend<String, EmailTemplate> templateStore,
+ SesSentEmailService sentEmailService,
+ SesAccountService accountService,
+ SesTemplateService templateService,
StorageBackend<String, ConfigurationSet> configSetStore,
- StorageBackend<String, SuppressedDestination> suppressionStore,
- StorageBackend<String, AccountSuppressionAttributes> accountSuppressionStore,
- StorageBackend<String, AccountVdmAttributes> accountVdmStore,
- StorageBackend<String, DedicatedIpPool> dedicatedIpPoolStore,
- StorageBackend<String, ContactList> contactListStore,
- StorageBackend<String, Contact> contactStore,
- StorageBackend<String, String> policyStore,
- StorageBackend<String, ReceiptRuleSet> receiptRuleSetStore,
- StorageBackend<String, CustomVerificationEmailTemplate> cvetStore,
+ SesSuppressionService suppressionService,
+ SesDedicatedIpService dedicatedIpService,
+ SesContactService contactService,
+ SesPolicyService policyService,
+ SesReceiptRuleService receiptRuleService,
+ SesCvetService cvetService,
SmtpRelay smtpRelay,
ObjectMapper objectMapper,
Route53Service route53Service,
Clock clock) {
this.identityStore = identityStore;
- this.emailStore = emailStore;
- this.accountSettingsStore = accountSettingsStore;
- this.templateStore = templateStore;
+ this.sentEmailService = sentEmailService;
+ this.accountService = accountService;
+ this.templateService = templateService;
this.configSetStore = configSetStore;
- this.suppressionStore = suppressionStore;
- this.accountSuppressionStore = accountSuppressionStore;
- this.accountVdmStore = accountVdmStore;
- this.dedicatedIpPoolStore = dedicatedIpPoolStore;
- this.contactListStore = contactListStore;
- this.contactStore = contactStore;
- this.policyStore = policyStore;
- this.receiptRuleSetStore = receiptRuleSetStore;
- this.cvetStore = cvetStore;
+ this.suppressionService = suppressionService;
+ this.dedicatedIpService = dedicatedIpService;
+ this.contactService = contactService;
+ this.policyService = policyService;
+ this.receiptRuleService = receiptRuleService;
+ this.cvetService = cvetService;
this.smtpRelay = smtpRelay;
this.objectMapper = objectMapper;
this.eventPublisher = null;
@@ -288,14 +263,7 @@ public class SesService {
// Policies are sub-resources of the identity; drop them too so they can't resurrect into a
// same-named identity recreated later (and so the per-identity count stays correct).
- synchronized (policyMutationLock) {
- String policyPrefix = policyPrefix(region, identityValue);
- for (String policyKey : new ArrayList<>(policyStore.keys())) {
- if (policyKey.startsWith(policyPrefix)) {
- policyStore.delete(policyKey);
- }
- }
- }
+ policyService.deletePoliciesForIdentity(identityValue, region);
LOG.infov("Deleted identity: {0}", identityValue);
}
@@ -368,7 +336,7 @@ public class SesService {
if (additionalHeaders != null && !additionalHeaders.isEmpty()) {
email.setHeaders(additionalHeaders);
}
- emailStore.put("email::" + region + "::" + messageId, email);
+ sentEmailService.record(region, messageId, email);
List<String> relayedTo = filterUnsuppressed(toAddresses, suppressedReasons);
List<String> relayedCc = filterUnsuppressed(ccAddresses, suppressedReasons);
@@ -440,7 +408,7 @@ public class SesService {
String messageId = UUID.randomUUID().toString();
SentEmail email = new SentEmail(messageId, region, effectiveSource, effectiveDestinations, rawMessage);
- emailStore.put("email::" + region + "::" + messageId, email);
+ sentEmailService.record(region, messageId, email);
List<String> relayedDestinations = filterUnsuppressed(effectiveDestinations, suppressedReasons);
if (!relayedDestinations.isEmpty()) {
@@ -656,8 +624,7 @@ public class SesService {
}
public long getSentEmailCount(String region) {
- String prefix = "email::" + region + "::";
- return emailStore.scan(k -> k.startsWith(prefix)).size();
+ return sentEmailService.countInRegion(region);
}
public void setIdentityNotificationTopic(String identityValue, String notificationType,
@@ -1142,38 +1109,27 @@ public class SesService {
}
public List<SentEmail> getEmails() {
- return emailStore.scan(k -> k.startsWith("email::"));
+ return sentEmailService.listAll();
}
public void clearEmails() {
- emailStore.clear();
- LOG.info("Cleared all SES emails");
+ sentEmailService.clear();
}
public boolean isAccountSendingEnabled(String region) {
- return accountSettingsStore.get("sending::" + region).orElse(true);
+ return accountService.isAccountSendingEnabled(region);
}
public void setAccountSendingEnabled(String region, boolean enabled) {
- accountSettingsStore.put("sending::" + region, enabled);
- LOG.infov("Updated account sending enabled for region {0}: {1}", region, enabled);
+ accountService.setAccountSendingEnabled(region, enabled);
}
- // VDM (Virtual Deliverability Manager) is opt-in and per region: GetAccount omits VdmAttributes
- // entirely until PutAccountVdmAttributes is called for the region, so this returns empty when the
- // region was never configured. The whole tuple is stored under one region key so GetAccount never
- // observes a partially updated state.
public Optional<AccountVdmAttributes> findAccountVdmAttributes(String region) {
- return accountVdmStore.get(accountVdmKey(region));
+ return accountService.findAccountVdmAttributes(region);
}
public void putAccountVdmAttributes(String region, AccountVdmAttributes vdm) {
- accountVdmStore.put(accountVdmKey(region), vdm);
- LOG.infov("Updated account VDM attributes for region {0}: enabled={1}", region, vdm.vdmEnabled());
- }
-
- private static String accountVdmKey(String region) {
- return "account-vdm::" + region;
+ accountService.putAccountVdmAttributes(region, vdm);
}
public void setConfigurationSetSendingEnabled(String configSetName, boolean enabled, String region) {
@@ -1186,65 +1142,27 @@ public class SesService {
// ──────────────────────────── Templates ────────────────────────────
+ // Email templates live in SesTemplateService; the facade forwards. The templated-send path below
+ // reads them back through getTemplate, and ARN-dispatched tagging through find/save.
+
public EmailTemplate createTemplate(EmailTemplate template, String region) {
- validateTemplate(template);
- if (template.getTags() != null) {
- for (Tag tag : template.getTags()) {
- validateTag(tag);
- }
- }
- String key = templateKey(region, template.getTemplateName());
- if (templateStore.get(key).isPresent()) {
- throw new AwsException("AlreadyExists",
- "Template " + template.getTemplateName() + " already exists.", 400);
- }
- Instant now = Instant.now();
- template.setCreatedTimestamp(now);
- template.setLastUpdatedTimestamp(now);
- templateStore.put(key, template);
- LOG.infov("Created SES template: {0} in region {1}", template.getTemplateName(), region);
- return template;
+ return templateService.createTemplate(template, region);
}
public EmailTemplate getTemplate(String templateName, String region) {
- return templateStore.get(templateKey(region, templateName))
- .orElseThrow(() -> new AwsException("TemplateDoesNotExist",
- "Template " + templateName + " does not exist.", 400));
+ return templateService.getTemplate(templateName, region);
}
public EmailTemplate updateTemplate(EmailTemplate template, String region) {
- validateTemplate(template);
- String key = templateKey(region, template.getTemplateName());
- EmailTemplate existing = templateStore.get(key)
- .orElseThrow(() -> new AwsException("TemplateDoesNotExist",
- "Template " + template.getTemplateName() + " does not exist.", 400));
- template.setCreatedTimestamp(existing.getCreatedTimestamp());
- template.setLastUpdatedTimestamp(Instant.now());
- // Tags are managed exclusively via Tag/UntagResource — preserve them on update.
- template.setTags(existing.getTags());
- templateStore.put(key, template);
- LOG.infov("Updated SES template: {0} in region {1}", template.getTemplateName(), region);
- return template;
+ return templateService.updateTemplate(template, region);
}
public void deleteTemplate(String templateName, String region) {
- String key = templateKey(region, templateName);
- if (templateStore.get(key).isEmpty()) {
- throw new AwsException("TemplateDoesNotExist",
- "Template " + templateName + " does not exist.", 400);
- }
- templateStore.delete(key);
- LOG.infov("Deleted SES template: {0} in region {1}", templateName, region);
+ templateService.deleteTemplate(templateName, region);
}
public List<EmailTemplate> listTemplates(String region) {
- String prefix = "template::" + region + "::";
- List<EmailTemplate> all = new ArrayList<>(templateStore.scan(k -> k.startsWith(prefix)));
- all.sort(Comparator.comparing(EmailTemplate::getCreatedTimestamp,
- Comparator.nullsLast(Comparator.naturalOrder()))
- .thenComparing(EmailTemplate::getTemplateName,
- Comparator.nullsLast(Comparator.naturalOrder())));
- return all;
+ return templateService.listTemplates(region);
}
// ──────────── Custom verification email templates (v1 + v2 shared store) ────────────
@@ -1253,64 +1171,29 @@ public class SesService {
// From-verified check against its own identity store (it does track verified identities).
public void createCustomVerificationEmailTemplate(CustomVerificationEmailTemplate template, String region) {
+ // The From-verified check inside validation reaches the Identity domain, so the facade
+ // validates here before the storage service performs the create.
validateCustomVerificationTemplate(template, region);
- String key = cvetKey(region, template.getTemplateName());
- // Lock only the check-then-put so concurrent creates for the same name can't both observe
- // the key as absent; validation and logging stay outside the lock.
- synchronized (cvetMutationLock) {
- if (cvetStore.get(key).isPresent()) {
- // v1-native code (verified: CustomVerificationEmailTemplateAlreadyExists / 400);
- // remapV1Exception translates it to AlreadyExistsException / 400 for the v2 boundary.
- throw new AwsException("CustomVerificationEmailTemplateAlreadyExists",
- "Custom verification email template <" + template.getTemplateName() + "> already exists", 400);
- }
- cvetStore.put(key, template);
- }
- LOG.infov("Created custom verification email template {0} in region {1}",
- template.getTemplateName(), region);
+ cvetService.createCustomVerificationEmailTemplate(template, region);
}
public CustomVerificationEmailTemplate getCustomVerificationEmailTemplate(String templateName, String region) {
- return cvetStore.get(cvetKey(region, templateName)).orElseThrow(() -> cvetNotFound(templateName));
+ return cvetService.getCustomVerificationEmailTemplate(templateName, region);
}
public List<CustomVerificationEmailTemplate> listCustomVerificationEmailTemplates(String region) {
- String prefix = "cvet::" + region + "::";
- return cvetStore.scan(k -> k.startsWith(prefix)).stream()
- .sorted(Comparator.comparing(CustomVerificationEmailTemplate::getTemplateName,
- Comparator.nullsFirst(Comparator.naturalOrder())))
- .toList();
+ return cvetService.listCustomVerificationEmailTemplates(region);
}
public void updateCustomVerificationEmailTemplate(CustomVerificationEmailTemplate template, String region) {
- // Validate required fields (including TemplateName) before the existence check so a missing or
- // blank name yields the required-field InvalidParameterValue rather than NotFoundException,
- // matching createCustomVerificationEmailTemplate.
+ // Validate (including the From-verified identity check and the required-field checks) before
+ // delegating the storage update, matching createCustomVerificationEmailTemplate.
validateCustomVerificationTemplate(template, region);
- String key = cvetKey(region, template.getTemplateName());
- // Guard the existence check and the put together so a concurrent delete can't slip between
- // them and have the update resurrect the just-deleted template.
- synchronized (cvetMutationLock) {
- if (cvetStore.get(key).isEmpty()) {
- throw cvetNotFound(template.getTemplateName());
- }
- cvetStore.put(key, template);
- }
- LOG.infov("Updated custom verification email template {0} in region {1}",
- template.getTemplateName(), region);
+ cvetService.updateCustomVerificationEmailTemplate(template, region);
}
public void deleteCustomVerificationEmailTemplate(String templateName, String region) {
- String key = cvetKey(region, templateName);
- // Guard the check-then-delete on the same lock as create/update so the three mutations
- // serialize against each other.
- synchronized (cvetMutationLock) {
- if (cvetStore.get(key).isEmpty()) {
- throw cvetNotFound(templateName);
- }
- cvetStore.delete(key);
- }
- LOG.infov("Deleted custom verification email template {0} in region {1}", templateName, region);
+ cvetService.deleteCustomVerificationEmailTemplate(templateName, region);
}
// AWS appends this exact disclaimer to the end of every custom verification email and it cannot
@@ -1342,7 +1225,7 @@ public class SesService {
if (templateName == null || templateName.isBlank()) {
throw new AwsException("InvalidParameterValue", "TemplateName is required.", 400);
}
- CustomVerificationEmailTemplate template = cvetStore.get(cvetKey(region, templateName))
+ CustomVerificationEmailTemplate template = cvetService.find(templateName, region)
.orElseThrow(() -> new AwsException("CustomVerificationEmailTemplateDoesNotExist",
"Template <" + templateName + "> does not exist", 400));
if (!isVerifiedSender(template.getFromEmailAddress(), region)) {
@@ -1369,7 +1252,7 @@ public class SesService {
SentEmail email = new SentEmail(messageId, region, template.getFromEmailAddress(),
List.of(emailAddress), List.of(), List.of(), List.of(),
template.getTemplateSubject(), null, renderedHtml);
- emailStore.put("email::" + region + "::" + messageId, email);
+ sentEmailService.record(region, messageId, email);
smtpRelay.relay(template.getFromEmailAddress(), List.of(emailAddress), List.of(), List.of(),
List.of(), template.getTemplateSubject(), null, renderedHtml, List.of());
LOG.infov("SES custom verification email sent: to={0}, template={1}, messageId={2}",
@@ -1471,17 +1354,6 @@ public class SesService {
}
}
- private static AwsException cvetNotFound(String templateName) {
- // v1-native code (verified: CustomVerificationEmailTemplateDoesNotExist / 400).
- // SesController.remapV1Exception translates it to NotFoundException / 404 for the v2 boundary.
- return new AwsException("CustomVerificationEmailTemplateDoesNotExist",
- "Custom verification email template <" + templateName + "> does not exist", 400);
- }
-
- private static String cvetKey(String region, String templateName) {
- return "cvet::" + region + "::" + templateName;
- }
-
public ConfigurationSet createConfigurationSet(ConfigurationSet configSet, String region) {
if (configSet == null) {
throw new AwsException("InvalidParameterValue",
@@ -1490,7 +1362,7 @@ public class SesService {
String key = configSetKey(region, configSet.getName());
if (configSet.getTags() != null) {
for (Tag tag : configSet.getTags()) {
- validateTag(tag);
+ SesTags.validate(tag);
}
}
if (configSet.getSuppressionOptions() != null
@@ -1752,304 +1624,114 @@ public class SesService {
// ──────────────────────── Receipt rule sets (inbound) ────────────────────────
//
- // Floci has no inbound-mail endpoint, so receipt rule sets are stored inertly: a set never holds
- // any rules and routes no mail. They exist only so the management API round-trips (enough to
- // unblock tools such as Terraform that declare a rule set during bootstrap).
+ // Receipt rule sets live in SesReceiptRuleService; this facade
+ // just forwards, keeping the v1 SesQueryHandler call sites unchanged.
public ReceiptRuleSet createReceiptRuleSet(String name, String region) {
- requireRuleSetName(name);
- String key = receiptRuleSetKey(region, name);
- ReceiptRuleSet ruleSet = new ReceiptRuleSet(name, Instant.now(clock));
- synchronized (receiptRuleSetLock) {
- if (receiptRuleSetStore.get(key).isPresent()) {
- throw new AwsException("AlreadyExists", "Rule set already exists: " + name, 400);
- }
- receiptRuleSetStore.put(key, ruleSet);
- }
- LOG.infov("Created SES receipt rule set: {0} in region {1}", name, region);
- return ruleSet;
+ return receiptRuleService.createReceiptRuleSet(name, region);
}
public ReceiptRuleSet describeReceiptRuleSet(String name, String region) {
- requireRuleSetName(name);
- return receiptRuleSetStore.get(receiptRuleSetKey(region, name))
- .orElseThrow(() -> ruleSetDoesNotExist(name));
+ return receiptRuleService.describeReceiptRuleSet(name, region);
}
public List<ReceiptRuleSet> listReceiptRuleSets(String region) {
- String prefix = "receiptRuleSet::" + region + "::";
- List<ReceiptRuleSet> all = new ArrayList<>(receiptRuleSetStore.scan(k -> k.startsWith(prefix)));
- all.sort(Comparator.comparing(ReceiptRuleSet::getCreatedTimestamp,
- Comparator.nullsLast(Comparator.naturalOrder()))
- .thenComparing(ReceiptRuleSet::getName, Comparator.nullsLast(Comparator.naturalOrder())));
- return all;
+ return receiptRuleService.listReceiptRuleSets(region);
}
public void deleteReceiptRuleSet(String name, String region) {
- requireRuleSetName(name);
- // Hold the lock so the active-check-then-delete is atomic and a concurrent set-active/clear
- // (which scans and re-puts active sets) can't resurrect the rule set we just deleted.
- synchronized (receiptRuleSetLock) {
- ReceiptRuleSet existing = receiptRuleSetStore.get(receiptRuleSetKey(region, name)).orElse(null);
- if (existing != null && existing.isActive()) {
- // AWS rejects deleting the active rule set (verified: CannotDelete / 400).
- throw new AwsException("CannotDelete", "Cannot delete active rule set: " + name, 400);
- }
- // AWS is idempotent otherwise: deleting a non-existent rule set succeeds without error.
- receiptRuleSetStore.delete(receiptRuleSetKey(region, name));
- }
- LOG.infov("Deleted SES receipt rule set: {0} in region {1}", name, region);
+ receiptRuleService.deleteReceiptRuleSet(name, region);
}
public void setActiveReceiptRuleSet(String name, String region) {
- // No RuleSetName clears the account's active rule set (matches AWS).
- boolean clearOnly = name == null || name.isBlank();
- if (!clearOnly) {
- requireRuleSetName(name);
- }
- synchronized (receiptRuleSetLock) {
- if (!clearOnly) {
- ReceiptRuleSet target = receiptRuleSetStore.get(receiptRuleSetKey(region, name))
- .orElseThrow(() -> ruleSetDoesNotExist(name));
- clearActiveReceiptRuleSet(region);
- target.setActive(true);
- receiptRuleSetStore.put(receiptRuleSetKey(region, name), target);
- } else {
- clearActiveReceiptRuleSet(region);
- }
- }
- if (clearOnly) {
- LOG.infov("Cleared active SES receipt rule set in region {0}", region);
- } else {
- LOG.infov("Set active SES receipt rule set: {0} in region {1}", name, region);
- }
+ receiptRuleService.setActiveReceiptRuleSet(name, region);
}
public ReceiptRuleSet describeActiveReceiptRuleSet(String region) {
- String prefix = "receiptRuleSet::" + region + "::";
- // Read under the lock so a concurrent set-active replacement (clear-then-set) can't expose its
- // intermediate no-active state — the reader sees either the old or the new active set.
- synchronized (receiptRuleSetLock) {
- return receiptRuleSetStore.scan(k -> k.startsWith(prefix)).stream()
- .filter(ReceiptRuleSet::isActive)
- .findFirst()
- .orElse(null);
- }
- }
-
- private void clearActiveReceiptRuleSet(String region) {
- String prefix = "receiptRuleSet::" + region + "::";
- for (ReceiptRuleSet rs : receiptRuleSetStore.scan(k -> k.startsWith(prefix))) {
- if (rs.isActive()) {
- rs.setActive(false);
- receiptRuleSetStore.put(receiptRuleSetKey(region, rs.getName()), rs);
- }
- }
- }
-
- // These RuleSetName constraints are not in the botocore model: service-2.json (SES 2010-12-01)
- // declares ReceiptRuleSetName as a bare {"type": "string"} with no pattern or length. They were
- // established by probing real SES in us-west-2 via boto3 (2026-08): a character outside
- // ^[a-zA-Z0-9_.-]+$ is a Smithy ValidationError, and a name that is >64 chars or does not
- // start/end with an alphanumeric is a service-level "Not a valid ruleSetName" InvalidParameterValue.
- // Re-verify against live SES (not the model, which can't confirm it) if these ever need to change.
- private static final Pattern RULE_SET_NAME_CHARS = Pattern.compile("^[a-zA-Z0-9_.-]+$");
-
- private static void requireRuleSetName(String name) {
- if (name == null || name.isBlank()) {
- throw new AwsException("InvalidParameterValue", "RuleSetName is required.", 400);
- }
- if (!RULE_SET_NAME_CHARS.matcher(name).matches()) {
- throw new AwsException("ValidationError",
- "1 validation error detected: Value at 'ruleSetName' failed to satisfy constraint: "
- + "Member must satisfy regular expression pattern: ^[a-zA-Z0-9_.-]+$", 400);
- }
- if (name.length() > 64
- || !Character.isLetterOrDigit(name.charAt(0))
- || !Character.isLetterOrDigit(name.charAt(name.length() - 1))) {
- throw new AwsException("InvalidParameterValue", "Not a valid ruleSetName: " + name, 400);
- }
- }
-
- private static AwsException ruleSetDoesNotExist(String name) {
- return new AwsException("RuleSetDoesNotExist", "Rule set does not exist: " + name, 400);
- }
-
- private static String receiptRuleSetKey(String region, String name) {
- return "receiptRuleSet::" + region + "::" + name;
+ return receiptRuleService.describeActiveReceiptRuleSet(region);
}
// ──────────────────────── Dedicated IP Pools ────────────────────────
- private static final java.util.Set<String> SCALING_MODES = java.util.Set.of("STANDARD", "MANAGED");
+ // Storage lives in SesDedicatedIpService; the facade forwards.
public DedicatedIpPool createDedicatedIpPool(String poolName, String scalingMode, String region) {
- if (poolName == null || poolName.isBlank()) {
- throw new AwsException("BadRequestException", "PoolName is required.", 400);
- }
- String effectiveScaling = (scalingMode == null || scalingMode.isBlank()) ? "STANDARD" : scalingMode;
- if (!SCALING_MODES.contains(effectiveScaling)) {
- throw new AwsException("BadRequestException", "The ScalingMode parameter is invalid.", 400);
- }
- String key = dedicatedIpPoolKey(region, poolName);
- if (dedicatedIpPoolStore.get(key).isPresent()) {
- throw new AwsException("AlreadyExistsException",
- "The pool <" + poolName + "> already exists.", 400);
- }
- DedicatedIpPool pool = new DedicatedIpPool(poolName, effectiveScaling);
- dedicatedIpPoolStore.put(key, pool);
- LOG.infov("Created SES dedicated IP pool: {0} in region {1}", poolName, region);
- return pool;
+ return dedicatedIpService.createDedicatedIpPool(poolName, scalingMode, region);
}
public DedicatedIpPool getDedicatedIpPool(String poolName, String region) {
- return dedicatedIpPoolStore.get(dedicatedIpPoolKey(region, poolName))
- .orElseThrow(() -> new AwsException("NotFoundException",
- "The requested pool <" + poolName + "> does not exist.", 404));
+ return dedicatedIpService.getDedicatedIpPool(poolName, region);
}
public boolean dedicatedIpPoolExists(String poolName, String region) {
- return dedicatedIpPoolStore.get(dedicatedIpPoolKey(region, poolName)).isPresent();
+ return dedicatedIpService.dedicatedIpPoolExists(poolName, region);
}
public List<String> listDedicatedIpPools(String region) {
- String prefix = "dedicatedIpPool::" + region + "::";
- return dedicatedIpPoolStore.scan(k -> k.startsWith(prefix)).stream()
- .map(DedicatedIpPool::getPoolName)
- .sorted()
- .toList();
+ return dedicatedIpService.listDedicatedIpPools(region);
}
public void deleteDedicatedIpPool(String poolName, String region) {
- String key = dedicatedIpPoolKey(region, poolName);
- if (dedicatedIpPoolStore.get(key).isEmpty()) {
- throw new AwsException("NotFoundException",
- "The requested pool <" + poolName + "> does not exist.", 404);
- }
- dedicatedIpPoolStore.delete(key);
- LOG.infov("Deleted SES dedicated IP pool: {0} in region {1}", poolName, region);
+ dedicatedIpService.deleteDedicatedIpPool(poolName, region);
}
- private static String dedicatedIpPoolKey(String region, String name) {
- return "dedicatedIpPool::" + region + "::" + name;
- }
- private static final Set<String> SUBSCRIPTION_STATUSES = Set.of("OPT_IN", "OPT_OUT");
- private static final Pattern CONTACT_LIST_NAME_CHARS = Pattern.compile("^[A-Za-z0-9_-]{1,64}$");
- private static final int MAX_TOPICS_PER_LIST = 20;
- private static final int MAX_DISPLAY_NAME_LENGTH = 128;
- private static final int MAX_LIST_DESCRIPTION_LENGTH = 500;
+ // Contact lists and contacts live in SesContactService; the facade forwards.
+ // Its send-path list-management (collectListManagementOptOuts) also calls into that service.
public ContactList createContactList(String name, String description, List<Topic> topics,
List<Tag> tags, String region) {
- validateContactListInput(name, description, topics);
- ContactList list = new ContactList(name);
- list.setDescription(description);
- list.setTopics(topics);
- list.setTags(tags);
- Instant now = Instant.now();
- list.setCreatedTimestamp(now);
- list.setLastUpdatedTimestamp(now);
- // AWS allows at most one contact list per account per region (verified against real AWS).
- // A duplicate name hits this same limit before any "already exists" check, so
- // AlreadyExistsException is never reachable for contact lists. Lock only the check-then-put
- // so concurrent calls can't both observe an empty region; building and logging stay outside.
- synchronized (contactListCreateLock) {
- if (!listContactLists(region).isEmpty()) {
- throw new AwsException("BadRequestException",
- "A maximum of 1 Lists allowed per account.", 400);
- }
- contactListStore.put(contactListKey(region, name), list);
- }
- LOG.infov("Created SES contact list: {0} in region {1}", name, region);
- return list;
+ return contactService.createContactList(name, description, topics, tags, region);
}
public ContactList getContactList(String name, String region) {
- return contactListStore.get(contactListKey(region, name))
- .orElseThrow(() -> contactListNotFound(name));
+ return contactService.getContactList(name, region);
}
public List<ContactList> listContactLists(String region) {
- String prefix = "contactList::" + region + "::";
- return contactListStore.scan(k -> k.startsWith(prefix)).stream()
- .sorted(Comparator.comparing(ContactList::getContactListName))
- .toList();
+ return contactService.listContactLists(region);
}
public ContactList updateContactList(String name, String description, boolean descriptionPresent,
List<Topic> topics, String region) {
- validateContactListInput(name, description, topics);
- String key = contactListKey(region, name);
- ContactList existing = contactListStore.get(key).orElseThrow(() -> contactListNotFound(name));
- if (topics != null) {
- existing.setTopics(topics);
- }
- if (descriptionPresent) {
- existing.setDescription(description);
- }
- existing.setLastUpdatedTimestamp(Instant.now());
- contactListStore.put(key, existing);
- LOG.infov("Updated SES contact list: {0} in region {1}", name, region);
- return existing;
+ return contactService.updateContactList(name, description, descriptionPresent, topics, region);
}
public void deleteContactList(String name, String region) {
- String key = contactListKey(region, name);
- // Existence check, list delete, and contact purge all under the lock: concurrent deletes
- // can't both pass the check (one must 404), and a concurrent create/update can't slip a
- // contact in after the purge. Contacts are stored independently, so purging them here keeps
- // them from leaking into a same-named list recreated later (AWS deletes them with the list).
- String prefix = "contact::" + region + "::" + name + "::";
- synchronized (contactMutationLock) {
- if (contactListStore.get(key).isEmpty()) {
- throw contactListNotFound(name);
- }
- contactListStore.delete(key);
- // Delete by the actual stored keys (not keys rebuilt from each value's EmailAddress),
- // so a persisted entry whose key and EmailAddress diverge is still purged.
- List<String> contactKeys = contactStore.keys().stream()
- .filter(k -> k.startsWith(prefix))
- .toList();
- for (String contactKey : contactKeys) {
- contactStore.delete(contactKey);
- }
- }
- LOG.infov("Deleted SES contact list: {0} in region {1}", name, region);
+ contactService.deleteContactList(name, region);
}
- private static AwsException contactListNotFound(String name) {
- return new AwsException("NotFoundException",
- "List with name: " + name + " doesn't exist.", 404);
+ public Contact createContact(String listName, String emailAddress, List<TopicPreference> topicPreferences,
+ Boolean unsubscribeAll, String attributesData, String region) {
+ return contactService.createContact(listName, emailAddress, topicPreferences, unsubscribeAll,
+ attributesData, region);
}
- // SES V2 surfaces missing/invalid input as Smithy validation errors. Field paths and the
- // enum value order are taken verbatim from real AWS.
- private static AwsException validationError(String fieldPath, String constraint) {
- return new AwsException("BadRequestException",
- "1 validation error detected: Value at '" + fieldPath
- + "' failed to satisfy constraint: " + constraint, 400);
+ public SesContactService.ContactWithList getContact(String listName, String emailAddress, String region) {
+ return contactService.getContact(listName, emailAddress, region);
}
- private static void validateContactListName(String name) {
- if (name == null) {
- throw validationError("contactListName", "Member must not be null");
- }
- if (name.isBlank()) {
- throw new AwsException("BadRequestException", "ContactListName can't be blank.", 400);
- }
- if (!CONTACT_LIST_NAME_CHARS.matcher(name).matches()) {
- throw new AwsException("BadRequestException",
- "ContactListName can contain up to 64 characters. Only alphanumeric characters, "
- + "underscores(_) and hyphens(-) are allowed.", 400);
- }
+ public SesContactService.ContactsWithList listContacts(String listName, String region) {
+ return contactService.listContacts(listName, region);
}
- private static void validateDescription(String description) {
- if (description != null && description.length() > MAX_LIST_DESCRIPTION_LENGTH) {
- throw new AwsException("BadRequestException",
- "List description can contain up to 500 characters.", 400);
- }
+ public Contact updateContact(String listName, String emailAddress, List<TopicPreference> topicPreferences,
+ boolean topicPreferencesPresent, Boolean unsubscribeAll, String attributesData,
+ String region) {
+ return contactService.updateContact(listName, emailAddress, topicPreferences, topicPreferencesPresent,
+ unsubscribeAll, attributesData, region);
+ }
+
+ public void deleteContact(String listName, String emailAddress, String region) {
+ contactService.deleteContact(listName, emailAddress, region);
+ }
+
+ public List<TopicPreference> deriveTopicDefaultPreferences(Contact contact, ContactList list) {
+ return contactService.deriveTopicDefaultPreferences(contact, list);
+ }
+
+ public void unsubscribeContact(String listName, String emailAddress, String topicName, String region) {
+ contactService.unsubscribeContact(listName, emailAddress, topicName, region);
}
// ──────────────── Identity (sending authorization) policies ────────────────
@@ -2058,112 +1740,43 @@ public class SesService {
// against real AWS. Floci stores and returns policies but does not enforce the authorization
// (Principal-account existence, Resource-ARN match, or send-time checks) — it has no account
// registry and does not gate sending, so these are treated as metadata.
- private static final Pattern POLICY_NAME_CHARS = Pattern.compile("[A-Za-z0-9_-]+");
+ // Policy storage lives in SesPolicyService; this facade forwards, and for the v2 mutators it runs
+ // the identity-existence check (an Identity-domain read) first, before delegating.
- // v1 PutIdentityPolicy: upsert (create or overwrite); v1 does not require the identity to exist.
public void putIdentityPolicy(String identity, String policyName, String policy, String region) {
- validatePolicyName(policyName);
- String normalized = normalizePolicy(policy);
- String key = policyKey(region, identity, policyName);
- synchronized (policyMutationLock) {
- if (policyStore.get(key).isEmpty()) {
- enforcePolicyLimit(region, identity, false);
- }
- policyStore.put(key, normalized);
- }
- LOG.infov("SES PutIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ policyService.putIdentityPolicy(identity, policyName, policy, region);
}
- // v2 CreateEmailIdentityPolicy: fails if the name already exists; requires the identity.
public void createEmailIdentityPolicy(String identity, String policyName, String policy, String region) {
requireIdentityExists(identity, region);
- validatePolicyName(policyName);
- String normalized = normalizePolicy(policy);
- String key = policyKey(region, identity, policyName);
- synchronized (policyMutationLock) {
- if (policyStore.get(key).isPresent()) {
- throw new AwsException("AlreadyExistsException",
- "Policy <" + policyName + "> already exists", 400);
- }
- enforcePolicyLimit(region, identity, true);
- policyStore.put(key, normalized);
- }
- LOG.infov("SES v2 CreateEmailIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ policyService.createEmailIdentityPolicy(identity, policyName, policy, region);
}
- // v2 UpdateEmailIdentityPolicy: fails if the name is missing; requires the identity.
public void updateEmailIdentityPolicy(String identity, String policyName, String policy, String region) {
requireIdentityExists(identity, region);
- validatePolicyName(policyName);
- String normalized = normalizePolicy(policy);
- String key = policyKey(region, identity, policyName);
- synchronized (policyMutationLock) {
- if (policyStore.get(key).isEmpty()) {
- throw policyNotFound(policyName);
- }
- policyStore.put(key, normalized);
- }
- LOG.infov("SES v2 UpdateEmailIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ policyService.updateEmailIdentityPolicy(identity, policyName, policy, region);
}
- // v2 GetEmailIdentityPolicies: all policies for the identity; requires the identity.
public Map<String, String> getEmailIdentityPolicies(String identity, String region) {
requireIdentityExists(identity, region);
- return listPolicies(region, identity);
+ return policyService.listAllPolicies(identity, region);
}
- // v1 GetIdentityPolicies: requested names only, missing silently omitted; no identity check.
public Map<String, String> getIdentityPolicies(String identity, List<String> policyNames, String region) {
- Map<String, String> out = new LinkedHashMap<>();
- for (String name : policyNames) {
- policyStore.get(policyKey(region, identity, name)).ifPresent(doc -> out.put(name, doc));
- }
- return out;
+ return policyService.getIdentityPolicies(identity, policyNames, region);
}
- // v1 ListIdentityPolicies: policy names (sorted); no identity check.
public List<String> listIdentityPolicyNames(String identity, String region) {
- return listPolicies(region, identity).keySet().stream().sorted().toList();
+ return policyService.listIdentityPolicyNames(identity, region);
}
- // v2 DeleteEmailIdentityPolicy: requires the identity; NotFound if the policy is missing.
public void deleteEmailIdentityPolicy(String identity, String policyName, String region) {
requireIdentityExists(identity, region);
- String key = policyKey(region, identity, policyName);
- synchronized (policyMutationLock) {
- if (policyStore.get(key).isEmpty()) {
- throw policyNotFound(policyName);
- }
- policyStore.delete(key);
- }
- LOG.infov("SES v2 DeleteEmailIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
+ policyService.deleteEmailIdentityPolicy(identity, policyName, region);
}
- // v1 DeleteIdentityPolicy: idempotent; no identity check, no error on a missing policy.
public void deleteIdentityPolicy(String identity, String policyName, String region) {
- policyStore.delete(policyKey(region, identity, policyName));
- LOG.infov("SES DeleteIdentityPolicy: {0} on {1} (region {2})", policyName, identity, region);
- }
-
- private Map<String, String> listPolicies(String region, String identity) {
- String prefix = policyPrefix(region, identity);
- Map<String, String> out = new LinkedHashMap<>();
- for (String key : policyStore.keys()) {
- if (key.startsWith(prefix)) {
- policyStore.get(key).ifPresent(doc -> out.put(key.substring(prefix.length()), doc));
- }
- }
- return out;
- }
-
- private void enforcePolicyLimit(String region, String identity, boolean v2) {
- long count = policyStore.keys().stream()
- .filter(k -> k.startsWith(policyPrefix(region, identity))).count();
- if (count >= MAX_POLICIES_PER_IDENTITY) {
- String msg = "Number of policies for <" + identity
- + "> exceeds max allowed number of policies per resource";
- throw new AwsException(v2 ? "LimitExceededException" : "InvalidParameterValue", msg, 400);
- }
+ policyService.deleteIdentityPolicy(identity, policyName, region);
}
private void requireIdentityExists(String identity, String region) {
@@ -2173,313 +1786,7 @@ public class SesService {
}
}
- // Error codes are the v1 (Query) codes verified against AWS; the v2 controller remaps them to
- // BadRequestException. The messages are identical across v1 and v2.
- private static void validatePolicyName(String policyName) {
- if (policyName == null || policyName.isBlank()) {
- throw new AwsException("InvalidParameterValue", "PolicyName is required.", 400);
- }
- if (policyName.length() > 64) {
- throw new AwsException("ValidationError",
- "1 validation error detected: Value at 'policyName' failed to satisfy constraint: "
- + "Member must have length less than or equal to 64", 400);
- }
- if (!POLICY_NAME_CHARS.matcher(policyName).matches()) {
- throw new AwsException("InvalidParameterValue",
- "PolicyName is invalid. Policy names must only include alpha-numeric characters, "
- + "dashes, and underscores.", 400);
- }
- }
-
- private String normalizePolicy(String policy) {
- if (policy == null || policy.isBlank()) {
- throw new AwsException("InvalidParameterValue", "Policy is required.", 400);
- }
- try {
- // AWS returns the policy with insignificant whitespace stripped; compact it to match.
- return objectMapper.readTree(policy).toString();
- } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
- // Floci does not validate policy semantics; keep an unparseable document verbatim.
- LOG.debugv("Identity policy is not valid JSON, storing as-is: {0}", e.getMessage());
- return policy;
- }
- }
-
- private static AwsException policyNotFound(String policyName) {
- return new AwsException("NotFoundException", "Policy <" + policyName + "> does not exist", 404);
- }
-
- private static String policyKey(String region, String identity, String policyName) {
- return policyPrefix(region, identity) + policyName;
- }
-
- private static String policyPrefix(String region, String identity) {
- return "policy::" + region + "::" + identity + "::";
- }
-
- // Validates Create/Update input in the same two-phase order as real AWS (verified by probe):
- // protocol-layer (Smithy) checks across all fields first, then service-level constraints with
- // ContactListName ahead of topic/description constraints.
- private static void validateContactListInput(String name, String description, List<Topic> topics) {
- // Phase 1 — protocol-layer (Smithy) validation: null members and the subscription-status
- // enum. AWS reports these before any service-level constraint.
- if (name == null) {
- throw validationError("contactListName", "Member must not be null");
- }
- if (topics != null) {
- for (int i = 0; i < topics.size(); i++) {
- Topic t = topics.get(i);
- String member = "topics." + (i + 1) + ".member.";
- if (t.getTopicName() == null) {
- throw validationError(member + "topicName", "Member must not be null");
- }
- if (t.getDisplayName() == null) {
- throw validationError(member + "displayName", "Member must not be null");
- }
- if (t.getDefaultSubscriptionStatus() == null) {
- throw validationError(member + "defaultSubscriptionStatus", "Member must not be null");
- }
- if (!SUBSCRIPTION_STATUSES.contains(t.getDefaultSubscriptionStatus())) {
- throw validationError(member + "defaultSubscriptionStatus",
- "Member must satisfy enum value set: [OPT_OUT, OPT_IN]");
- }
- }
- }
- // Phase 2 — service-level constraints: ContactListName first, then topics, then description.
- if (name.isBlank()) {
- throw new AwsException("BadRequestException", "ContactListName can't be blank.", 400);
- }
- if (!CONTACT_LIST_NAME_CHARS.matcher(name).matches()) {
- throw new AwsException("BadRequestException",
- "ContactListName can contain up to 64 characters. Only alphanumeric characters, "
- + "underscores(_) and hyphens(-) are allowed.", 400);
- }
- if (topics != null) {
- if (topics.size() > MAX_TOPICS_PER_LIST) {
- throw new AwsException("BadRequestException",
- "Maximum of <" + MAX_TOPICS_PER_LIST + "> topics allowed per ContactList", 400);
- }
- Set<String> seenNames = new HashSet<>();
- for (Topic t : topics) {
- if (t.getTopicName().isBlank()) {
- throw new AwsException("BadRequestException", "TopicName can't be blank.", 400);
- }
- if (!CONTACT_LIST_NAME_CHARS.matcher(t.getTopicName()).matches()) {
- throw new AwsException("BadRequestException",
- "TopicName can contain up to 64 characters. Only alphanumeric characters, "
- + "underscores(_) and hyphens(-) are allowed.", 400);
- }
- if (t.getDisplayName().length() > MAX_DISPLAY_NAME_LENGTH) {
- throw new AwsException("BadRequestException",
- "Topic DisplayName can contain up to <" + MAX_DISPLAY_NAME_LENGTH
- + "> characters.", 400);
- }
- if (!seenNames.add(t.getTopicName())) {
- throw new AwsException("BadRequestException",
- "Duplicate topic names are not allowed within a List.", 400);
- }
- }
- }
- validateDescription(description);
- }
-
- private static String contactListKey(String region, String name) {
- // Validate in the key builder so Get/Update/Delete reject an invalid ContactListName with
- // the AWS validation error (400) rather than a 404, matching configSetKey. Verified
- // against real AWS: read/delete with an invalid name returns the same constraint message.
- validateContactListName(name);
- return "contactList::" + region + "::" + name;
- }
-
- // ─────────────────────────── Contacts ───────────────────────────
-
- private static final Pattern EMAIL_PATTERN = Pattern.compile("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$");
-
- public Contact createContact(String listName, String emailAddress, List<TopicPreference> topicPreferences,
- Boolean unsubscribeAll, String attributesData, String region) {
- validateContactInput(listName, emailAddress, topicPreferences, region);
- Contact contact = new Contact(emailAddress);
- contact.setTopicPreferences(topicPreferences);
- contact.setUnsubscribeAll(unsubscribeAll != null && unsubscribeAll);
- contact.setAttributesData(attributesData);
- Instant now = Instant.now(clock);
- contact.setCreatedTimestamp(now);
- contact.setLastUpdatedTimestamp(now);
- String key = contactKey(region, listName, emailAddress);
- // Re-check the list, duplicate, and put under the lock so a concurrent deleteContactList
- // can't purge the list between validation and the write (which would orphan this contact).
- synchronized (contactMutationLock) {
- getContactList(listName, region);
- if (contactStore.get(key).isPresent()) {
- throw new AwsException("AlreadyExistsException",
- emailAddress + " already exists in List.", 400);
- }
- contactStore.put(key, contact);
- }
- LOG.infov("Created SES contact {0} in list {1} (region {2})", emailAddress, listName, region);
- return contact;
- }
-
- // Read operations return the resolved ContactList alongside the contact(s) so the controller
- // can render TopicDefaultPreferences without a second getContactList round-trip (which would
- // open a TOCTOU window where a concurrent delete turns a successful read into "List not found").
- public record ContactWithList(Contact contact, ContactList list) {
- }
-
- public record ContactsWithList(List<Contact> contacts, ContactList list) {
- }
-
- public ContactWithList getContact(String listName, String emailAddress, String region) {
- validateEmailAddress(emailAddress);
- ContactList list = getContactList(listName, region);
- Contact contact = contactStore.get(contactKey(region, listName, emailAddress))
- .orElseThrow(() -> contactNotFound(emailAddress));
- return new ContactWithList(contact, list);
- }
-
- public ContactsWithList listContacts(String listName, String region) {
- ContactList list = getContactList(listName, region);
- String prefix = "contact::" + region + "::" + listName + "::";
- List<Contact> contacts = contactStore.scan(k -> k.startsWith(prefix)).stream()
- .sorted(Comparator.comparing(Contact::getEmailAddress,
- Comparator.nullsFirst(Comparator.naturalOrder())))
- .toList();
- return new ContactsWithList(contacts, list);
- }
-
- public Contact updateContact(String listName, String emailAddress, List<TopicPreference> topicPreferences,
- boolean topicPreferencesPresent, Boolean unsubscribeAll, String attributesData,
- String region) {
- validateContactInput(listName, emailAddress, topicPreferences, region);
- String key = contactKey(region, listName, emailAddress);
- Contact existing;
- // Re-check the list and read-modify-write under the lock so a concurrent deleteContactList
- // can't purge the contact/list between validation and the write (which would resurrect it).
- synchronized (contactMutationLock) {
- getContactList(listName, region);
- existing = contactStore.get(key).orElseThrow(() -> contactNotFound(emailAddress));
- // Verified against real AWS: TopicPreferences merge by topic name (omitting keeps existing);
- // AttributesData and UnsubscribeAll are replaced (omitting clears / resets them).
- if (topicPreferencesPresent) {
- existing.setTopicPreferences(mergeTopicPreferences(existing.getTopicPreferences(), topicPreferences));
- }
- existing.setUnsubscribeAll(unsubscribeAll != null && unsubscribeAll);
- existing.setAttributesData(attributesData);
- existing.setLastUpdatedTimestamp(Instant.now(clock));
- contactStore.put(key, existing);
- }
- LOG.infov("Updated SES contact {0} in list {1}", emailAddress, listName);
- return existing;
- }
-
- public void deleteContact(String listName, String emailAddress, String region) {
- validateEmailAddress(emailAddress);
- String key = contactKey(region, listName, emailAddress);
- // List re-check + existence check + delete under the lock (matching create/update): a
- // concurrent deleteContactList then surfaces "list not found" rather than "contact not
- // found", and an updateContact can't put a just-deleted contact back (resurrecting it).
- synchronized (contactMutationLock) {
- getContactList(listName, region);
- if (contactStore.get(key).isEmpty()) {
- throw contactNotFound(emailAddress);
- }
- contactStore.delete(key);
- }
- LOG.infov("Deleted SES contact {0} in list {1}", emailAddress, listName);
- }
-
- /**
- * Derives {@code TopicDefaultPreferences}: each list topic the contact has not set an explicit
- * preference for, carrying that topic's default subscription status.
- */
- public List<TopicPreference> deriveTopicDefaultPreferences(Contact contact, ContactList list) {
- Set<String> explicit = new HashSet<>();
- for (TopicPreference p : contact.getTopicPreferences()) {
- explicit.add(p.getTopicName());
- }
- List<TopicPreference> defaults = new ArrayList<>();
- for (Topic t : list.getTopics()) {
- if (!explicit.contains(t.getTopicName())) {
- defaults.add(new TopicPreference(t.getTopicName(), t.getDefaultSubscriptionStatus()));
- }
- }
- return defaults;
- }
-
- private static AwsException contactNotFound(String emailAddress) {
- return new AwsException("NotFoundException", emailAddress + " doesn't exist in List.", 404);
- }
-
- // Validation order verified against real AWS: protocol-layer (Smithy) topic-preference checks
- // first, then EmailAddress format, then contact-list existence, then topic existence.
- private void validateContactInput(String listName, String emailAddress, List<TopicPreference> prefs,
- String region) {
- if (prefs != null) {
- for (int i = 0; i < prefs.size(); i++) {
- TopicPreference p = prefs.get(i);
- String member = "topicPreferences." + (i + 1) + ".member.";
- if (p.getTopicName() == null) {
- throw validationError(member + "topicName", "Member must not be null");
- }
- if (p.getSubscriptionStatus() == null) {
- throw validationError(member + "subscriptionStatus", "Member must not be null");
- }
- if (!SUBSCRIPTION_STATUSES.contains(p.getSubscriptionStatus())) {
- throw validationError(member + "subscriptionStatus",
- "Member must satisfy enum value set: [OPT_OUT, OPT_IN]");
- }
- }
- }
- validateEmailAddress(emailAddress);
- ContactList list = getContactList(listName, region);
- if (prefs != null && !prefs.isEmpty()) {
- Set<String> topicNames = new HashSet<>();
- for (Topic t : list.getTopics()) {
- topicNames.add(t.getTopicName());
- }
- for (TopicPreference p : prefs) {
- if (!topicNames.contains(p.getTopicName())) {
- throw new AwsException("BadRequestException",
- "List: " + listName + " doesn't contain Topic: " + p.getTopicName(), 400);
- }
- }
- }
- }
-
- private static List<TopicPreference> mergeTopicPreferences(List<TopicPreference> existing,
- List<TopicPreference> provided) {
- Map<String, TopicPreference> byTopic = new LinkedHashMap<>();
- if (existing != null) {
- for (TopicPreference p : existing) {
- byTopic.put(p.getTopicName(), p);
- }
- }
- if (provided != null) {
- for (TopicPreference p : provided) {
- byTopic.put(p.getTopicName(), p);
- }
- }
- return new ArrayList<>(byTopic.values());
- }
-
- private static void validateEmailAddress(String emailAddress) {
- // Verified against real AWS: a missing/null required member is a Smithy validation error,
- // an empty/blank value is "can't be blank", and only a non-blank malformed value is "invalid".
- if (emailAddress == null) {
- throw validationError("emailAddress", "Member must not be null");
- }
- if (emailAddress.isBlank()) {
- throw new AwsException("BadRequestException", "EmailAddress can't be blank.", 400);
- }
- if (!EMAIL_PATTERN.matcher(emailAddress).matches()) {
- throw new AwsException("BadRequestException",
- "EmailAddress <" + emailAddress + "> is invalid", 400);
- }
- }
- private static String contactKey(String region, String listName, String emailAddress) {
- return "contact::" + region + "::" + listName + "::" + emailAddress;
- }
static void validateConfigurationSetName(String name) {
if (name == null || name.isBlank()) {
@@ -2740,7 +2047,7 @@ public class SesService {
+ "Member must have length greater than or equal to 1", 400);
}
for (Tag t : newTags) {
- validateTag(t);
+ SesTags.validate(t);
}
switch (ref.type()) {
case "configuration-set" -> tagConfigurationSet(ref.name(), ref.region(), newTags);
@@ -2810,19 +2117,18 @@ public class SesService {
}
private List<Tag> listEmailTemplateTags(String name, String region) {
- EmailTemplate template = templateStore.get(templateKey(region, name))
+ EmailTemplate template = templateService.find(name, region)
.orElseThrow(() -> new AwsException("NotFoundException",
"No Template present with name: " + name, 404));
return new ArrayList<>(template.getTags());
}
private void tagEmailTemplate(String name, String region, List<Tag> newTags) {
- String key = templateKey(region, name);
- EmailTemplate template = templateStore.get(key)
+ EmailTemplate template = templateService.find(name, region)
.orElseThrow(() -> new AwsException("NotFoundException",
"No Template present with name: " + name, 404));
template.setTags(mergeTags(template.getTags(), newTags));
- templateStore.put(key, template);
+ templateService.save(template, region);
LOG.infov("Tagged SES template: {0} (region {1}, +{2} tags)", name, region, newTags.size());
}
@@ -2871,7 +2177,7 @@ public class SesService {
public void setIdentityTags(String identityValue, String region, List<Tag> tags) {
if (tags != null) {
for (Tag tag : tags) {
- validateTag(tag);
+ SesTags.validate(tag);
}
}
String key = identityKey(region, identityValue);
@@ -2883,13 +2189,12 @@ public class SesService {
}
private void untagEmailTemplate(String name, String region, List<String> tagKeys) {
- String key = templateKey(region, name);
- EmailTemplate template = templateStore.get(key)
+ EmailTemplate template = templateService.find(name, region)
.orElseThrow(() -> new AwsException("NotFoundException",
"No Template present with name: " + name, 404));
Set<String> toRemove = new HashSet<>(tagKeys);
template.getTags().removeIf(t -> toRemove.contains(t.key()));
- templateStore.put(key, template);
+ templateService.save(template, region);
LOG.infov("Untagged SES template: {0} (region {1}, -{2} keys)", name, region, tagKeys.size());
}
@@ -2921,132 +2226,32 @@ public class SesService {
return new ResourceRef(parsed.region(), resource.substring(0, slash), resource.substring(slash + 1));
}
- // ──────────────────── Account-level suppression attributes ────────────────────
+ // ──────────────────── Suppression (account attributes + list) ────────────────────
+ // Storage lives in SesSuppressionService; the facade forwards, and its send
+ // filters (collectSuppressedReasons / resolveSuppressionReason) read entries back through it.
public AccountSuppressionAttributes getAccountSuppressionAttributes(String region) {
- return accountSuppressionStore.get(accountSuppressionKey(region))
- .orElseGet(SesService::defaultAccountSuppressionAttributes);
- }
-
- private static AccountSuppressionAttributes defaultAccountSuppressionAttributes() {
- // Fresh SES accounts default to auto-suppression on both BOUNCE and COMPLAINT;
- // an explicit PUT (including an empty list) overrides this.
- AccountSuppressionAttributes attrs = new AccountSuppressionAttributes();
- attrs.setSuppressedReasons(new ArrayList<>(List.of("BOUNCE", "COMPLAINT")));
- return attrs;
+ return suppressionService.getAccountSuppressionAttributes(region);
}
public void putAccountSuppressionAttributes(String region, List<String> suppressedReasons) {
- List<String> sanitized = new ArrayList<>();
- if (suppressedReasons != null) {
- for (String r : suppressedReasons) {
- validateSuppressionReason(r, "suppressedReasons", true);
- sanitized.add(r);
- }
- }
- AccountSuppressionAttributes attrs = new AccountSuppressionAttributes();
- attrs.setSuppressedReasons(sanitized);
- accountSuppressionStore.put(accountSuppressionKey(region), attrs);
- LOG.infov("Updated account suppression attributes for region {0}: {1}", region, sanitized);
- }
-
- private static String accountSuppressionKey(String region) {
- return "account-suppression::" + region;
+ suppressionService.putAccountSuppressionAttributes(region, suppressedReasons);
}
- // ──────────────────────────── Suppression list ────────────────────────────
-
public void putSuppressedDestination(String region, String emailAddress, String reason) {
- String normalized = normalizeSuppressionEmail(emailAddress);
- validateSuppressionReason(reason, "reason", false);
- String key = suppressionKey(region, normalized);
- SuppressionMatch match = existingSuppressionMatch(region, emailAddress, normalized).orElse(null);
- SuppressedDestination entry = match != null ? match.entry() : new SuppressedDestination(normalized, reason);
- entry.setEmailAddress(normalized);
- entry.setReason(reason);
- entry.setLastUpdateTime(Instant.now());
- // Write the canonical key first, then drop a legacy key it migrated from,
- // so a failed write can't lose the entry. The legacy form was persisted by
- // a pre-canonicalization Floci (trim-only key); migrating it avoids leaving
- // a stuck duplicate after a re-PUT.
- suppressionStore.put(key, entry);
- if (match != null && !match.key().equals(key)) {
- suppressionStore.delete(match.key());
- }
- LOG.infov("Suppressed destination {0} in region {1} (reason={2})", normalized, region, reason);
+ suppressionService.putSuppressedDestination(region, emailAddress, reason);
}
public SuppressedDestination getSuppressedDestination(String region, String emailAddress) {
- String normalized = normalizeSuppressionEmail(emailAddress);
- return existingSuppressionMatch(region, emailAddress, normalized)
- .map(SuppressionMatch::entry)
- .orElseThrow(() -> new AwsException("NotFoundException",
- "Email address " + normalized + " does not exist on your suppression list.",
- 404));
+ return suppressionService.getSuppressedDestination(region, emailAddress);
}
public void deleteSuppressedDestination(String region, String emailAddress) {
- String normalized = normalizeSuppressionEmail(emailAddress);
- SuppressionMatch match = existingSuppressionMatch(region, emailAddress, normalized)
- .orElseThrow(() -> new AwsException("NotFoundException",
- "Email address " + normalized + " does not exist on your suppression list.",
- 404));
- suppressionStore.delete(match.key());
- LOG.infov("Removed suppression entry for {0} in region {1}", normalized, region);
- }
-
- /** A suppression entry together with the storage key it currently lives under. */
- private record SuppressionMatch(String key, SuppressedDestination entry) {
- }
-
- /**
- * Resolve a suppression entry by its canonical (domain-lower-cased) key, falling
- * back to the legacy raw-trimmed key used by a pre-canonicalization Floci. Returns
- * the entry and the key it was found under in a single read per candidate, so
- * callers don't re-fetch the store.
- */
- private Optional<SuppressionMatch> existingSuppressionMatch(String region, String rawEmail, String normalized) {
- String canonical = suppressionKey(region, normalized);
- Optional<SuppressedDestination> hit = suppressionStore.get(canonical);
- if (hit.isPresent()) {
- return Optional.of(new SuppressionMatch(canonical, hit.get()));
- }
- String legacy = suppressionKey(region, rawEmail.trim());
- if (!legacy.equals(canonical)) {
- Optional<SuppressedDestination> legacyHit = suppressionStore.get(legacy);
- if (legacyHit.isPresent()) {
- return Optional.of(new SuppressionMatch(legacy, legacyHit.get()));
- }
- }
- return Optional.empty();
+ suppressionService.deleteSuppressedDestination(region, emailAddress);
}
public List<SuppressedDestination> listSuppressedDestinations(String region, List<String> reasonFilters) {
- Set<String> filters = new HashSet<>();
- if (reasonFilters != null) {
- for (String r : reasonFilters) {
- if (r != null && !r.isBlank()) {
- validateSuppressionReason(r, "reasons", true);
- filters.add(r);
- }
- }
- }
- String prefix = "suppression::" + region + "::";
- List<SuppressedDestination> all = new ArrayList<>(suppressionStore.scan(k -> k.startsWith(prefix)));
- all.sort(Comparator.comparing(SuppressedDestination::getLastUpdateTime,
- Comparator.nullsLast(Comparator.naturalOrder()))
- .thenComparing(SuppressedDestination::getEmailAddress,
- Comparator.nullsLast(Comparator.naturalOrder())));
- if (filters.isEmpty()) {
- return all;
- }
- return all.stream()
- .filter(s -> filters.contains(s.getReason()))
- .toList();
- }
-
- private static String suppressionKey(String region, String emailAddress) {
- return "suppression::" + region + "::" + emailAddress;
+ return suppressionService.listSuppressedDestinations(region, reasonFilters);
}
/**
@@ -3074,9 +2279,7 @@ public class SesService {
if (address == null || address.isBlank() || result.containsKey(address)) {
continue;
}
- String normalized = normalizeSuppressionEmail(address);
- SuppressedDestination entry = existingSuppressionMatch(region, address, normalized)
- .map(SuppressionMatch::entry)
+ SuppressedDestination entry = suppressionService.findSuppressedDestination(region, address)
.orElse(null);
if (entry != null && entry.getReason() != null
&& reasonFilter.contains(entry.getReason())) {
@@ -3102,13 +2305,13 @@ public class SesService {
|| listManagement.contactListName().isBlank() || addresses == null || addresses.isEmpty()) {
return Map.of();
}
- ContactList list = getContactList(listManagement.contactListName(), region);
+ ContactList list = contactService.getContactList(listManagement.contactListName(), region);
String topicName = listManagement.topicName();
String effectiveTopic = (topicName == null || topicName.isBlank()) ? null : topicName;
// Fail fast on a topic that isn't defined on the list rather than silently skipping
// suppression (a typo would otherwise send to everyone). AWS does not document this, so the
// exact error is best-effort.
- if (effectiveTopic != null && defaultTopicStatus(list, effectiveTopic) == null) {
+ if (effectiveTopic != null && contactService.defaultTopicStatus(list, effectiveTopic) == null) {
throw new AwsException("BadRequestException",
"Topic " + effectiveTopic + " does not exist in contact list "
+ list.getContactListName() + ".", 400);
@@ -3122,93 +2325,14 @@ public class SesService {
if (email == null || email.isBlank()) {
continue;
}
- Contact contact = getOrAutoCreateContact(list, email, region);
- if (isListManagementOptedOut(contact, list, effectiveTopic)) {
+ Contact contact = contactService.getOrAutoCreateContact(list, email, region);
+ if (contactService.isListManagementOptedOut(contact, list, effectiveTopic)) {
optOuts.put(address, "BOUNCE");
}
}
return optOuts;
}
- /**
- * Returns the contact for {@code email} in {@code list}, creating it automatically when absent —
- * AWS creates a contact on the list when {@code ListManagementOptions} names a recipient that is
- * not yet a contact. The auto-created contact has no explicit topic preferences (its effective
- * per-topic status derives from the list topic defaults) and is not unsubscribed. Creation runs
- * under {@code contactMutationLock} so a concurrent contact-list deletion can't orphan it.
- */
- private Contact getOrAutoCreateContact(ContactList list, String email, String region) {
- String key = contactKey(region, list.getContactListName(), email);
- Contact existing = contactStore.get(key).orElse(null);
- if (existing != null) {
- return existing;
- }
- synchronized (contactMutationLock) {
- Contact raced = contactStore.get(key).orElse(null);
- if (raced != null) {
- return raced;
- }
- // Re-check the list under the lock so a concurrent deleteContactList (which purges the
- // list and its contacts under the same lock) can't be followed by this creating an
- // orphaned contact for a list that no longer exists.
- getContactList(list.getContactListName(), region);
- Contact contact = new Contact(email);
- Instant now = Instant.now(clock);
- contact.setCreatedTimestamp(now);
- contact.setLastUpdatedTimestamp(now);
- contactStore.put(key, contact);
- LOG.infov("Auto-created SES contact {0} in list {1} on send (region {2})",
- email, list.getContactListName(), region);
- return contact;
- }
- }
-
- /**
- * Whether a contact is opted out for a list-managed send. A contact with {@code UnsubscribeAll}
- * is opted out of everything. When no topic is given, only {@code UnsubscribeAll} suppresses
- * (AWS documents suppression of whole-list unsubscribers). When a topic is given, an explicit
- * {@code OPT_OUT} preference for that topic suppresses; absent an explicit preference, the topic's
- * {@code DefaultSubscriptionStatus} is used — the default-status fallback at send time is not
- * documented by AWS but mirrors the effective-status model AWS uses for {@code ListContacts}.
- */
- private static boolean isListManagementOptedOut(Contact contact, ContactList list, String topicName) {
- if (contact.isUnsubscribeAll()) {
- return true;
- }
- if (topicName == null) {
- return false;
- }
- String explicit = explicitTopicStatus(contact, topicName);
- if (explicit != null) {
- return "OPT_OUT".equals(explicit);
- }
- return "OPT_OUT".equals(defaultTopicStatus(list, topicName));
- }
-
- private static String explicitTopicStatus(Contact contact, String topicName) {
- if (contact.getTopicPreferences() == null) {
- return null;
- }
- for (TopicPreference pref : contact.getTopicPreferences()) {
- if (topicName.equals(pref.getTopicName())) {
- return pref.getSubscriptionStatus();
- }
- }
- return null;
- }
-
- private static String defaultTopicStatus(ContactList list, String topicName) {
- if (list.getTopics() == null) {
- return null;
- }
- for (Topic topic : list.getTopics()) {
- if (topicName.equals(topic.getTopicName())) {
- return topic.getDefaultSubscriptionStatus();
- }
- }
- return null;
- }
-
private static final String UNSUBSCRIBE_PLACEHOLDER = "{{amazonSESUnsubscribeUrl}}";
private static boolean hasListManagement(ListManagementOptions listManagement) {
@@ -3275,57 +2399,6 @@ public class SesService {
return out;
}
- /**
- * Applies a list-management unsubscribe (the action behind the {@code /_aws/ses/unsubscribe}
- * link): with a topic, sets that topic's preference to {@code OPT_OUT}; without a topic,
- * unsubscribes the contact from the whole list ({@code UnsubscribeAll}). The contact is created
- * if it does not exist yet, consistent with send-time auto-creation. Runs under
- * {@code contactMutationLock} so a concurrent contact-list deletion can't orphan it.
- */
- public void unsubscribeContact(String listName, String emailAddress, String topicName, String region) {
- validateEmailAddress(emailAddress);
- String effectiveTopic = (topicName == null || topicName.isBlank()) ? null : topicName;
- String key = contactKey(region, listName, emailAddress);
- synchronized (contactMutationLock) {
- ContactList list = getContactList(listName, region);
- if (effectiveTopic != null && defaultTopicStatus(list, effectiveTopic) == null) {
- throw new AwsException("BadRequestException",
- "Topic " + effectiveTopic + " does not exist in contact list " + listName + ".", 400);
- }
- Contact contact = contactStore.get(key).orElseGet(() -> {
- Contact created = new Contact(emailAddress);
- created.setCreatedTimestamp(Instant.now(clock));
- return created;
- });
- if (effectiveTopic == null) {
- contact.setUnsubscribeAll(true);
- } else {
- setTopicPreference(contact, effectiveTopic, "OPT_OUT");
- }
- contact.setLastUpdatedTimestamp(Instant.now(clock));
- contactStore.put(key, contact);
- }
- LOG.infov("List-management unsubscribe: {0} from list {1} topic {2} (region {3})",
- emailAddress, listName, effectiveTopic == null ? "<all>" : effectiveTopic, region);
- }
-
- private static void setTopicPreference(Contact contact, String topicName, String status) {
- // Copy into a fresh mutable list and set it back, so this works even if the contact's
- // preferences were stored as an unmodifiable list (setTopicPreferences keeps the list as-is).
- List<TopicPreference> prefs = new ArrayList<>(contact.getTopicPreferences());
- boolean found = false;
- for (TopicPreference pref : prefs) {
- if (topicName.equals(pref.getTopicName())) {
- pref.setSubscriptionStatus(status);
- found = true;
- break;
- }
- }
- if (!found) {
- prefs.add(new TopicPreference(topicName, status));
- }
- contact.setTopicPreferences(prefs);
- }
/**
* Filter out recipients whose effective suppression reason is non-null. Returns a new
@@ -3362,7 +2435,7 @@ public class SesService {
* callers (publishSendEvents) to map the recipient to a synthetic Bounce / Complaint
* event without consulting the store again. Both the per-address suppression entries
* and the account-level / per-CS {@code suppressedReasons} go through
- * {@link #validateSuppressionReason} / {@link #validateConfigSetSuppressionReason},
+ * {@link SesSuppressionService}'s reason validation / {@link #validateConfigSetSuppressionReason},
* which enforce exact case-sensitive equality with the two canonical values, so
* {@code entry.getReason()} is guaranteed to be canonical and downstream
* {@code .equals("BOUNCE")} / {@code .equals("COMPLAINT")} checks are safe.
@@ -3371,12 +2444,9 @@ public class SesService {
if (emailAddress == null || emailAddress.isBlank()) {
return null;
}
- // Share the same normalization used when entries are stored
- // (`normalizeSuppressionEmail`) so lookups can't drift apart from inserts,
- // with the same legacy-key fallback as GET/DELETE.
- String normalized = normalizeSuppressionEmail(emailAddress);
- SuppressedDestination entry = existingSuppressionMatch(region, emailAddress, normalized)
- .map(SuppressionMatch::entry)
+ // Read through the suppression service so this shares its normalization and legacy-key
+ // fallback with GET/DELETE (lookups can't drift apart from inserts).
+ SuppressedDestination entry = suppressionService.findSuppressedDestination(region, emailAddress)
.orElse(null);
if (entry == null || entry.getReason() == null) {
return null;
@@ -3388,46 +2458,6 @@ public class SesService {
return effective.contains(entry.getReason()) ? entry.getReason() : null;
}
- private static String normalizeSuppressionEmail(String emailAddress) {
- if (emailAddress == null || emailAddress.isBlank()) {
- throw new AwsException("BadRequestException", "EmailAddress is required.", 400);
- }
- // AWS trims the EmailAddress and canonicalizes only the domain to lower
- // case; the local-part keeps its case. Verified against real AWS SES V2
- // (2026-06-15): `[email protected]` and `[email protected]` collapse to one
- // suppression entry (`[email protected]`), but `Foo@x` and `foo@x` are two
- // distinct entries. Lower-casing the whole address would wrongly merge
- // local-part variants and alter the stored value on read-back.
- // Locale.ROOT avoids the JVM-locale Turkish-i pitfall.
- String trimmed = emailAddress.trim();
- int at = trimmed.lastIndexOf('@');
- if (at < 0) {
- return trimmed;
- }
- return trimmed.substring(0, at) + "@" + trimmed.substring(at + 1).toLowerCase(Locale.ROOT);
- }
-
- /**
- * Validation message used by PutAccountSuppressionAttributes,
- * PutSuppressedDestination, and ListSuppressedDestinations — all three
- * return the AWS "1 validation error detected: Value at '<fieldName>'
- * failed to satisfy constraint: ..." V1-style nested message verbatim.
- * (Verified against real AWS V2 SES on 2026-06-03.) The {@code nested}
- * flag controls whether the inner enum constraint is wrapped in
- * {@code Member must satisfy constraint: [...]} — PutSuppressedDestination
- * (single Reason field) returns the unwrapped form; the two list-bearing
- * APIs return the wrapped form.
- */
- private static void validateSuppressionReason(String reason, String fieldName, boolean nested) {
- if (reason == null || (!"BOUNCE".equals(reason) && !"COMPLAINT".equals(reason))) {
- String constraint = nested
- ? "Member must satisfy constraint: [Member must satisfy enum value set: [BOUNCE, COMPLAINT]]"
- : "Member must satisfy enum value set: [BOUNCE, COMPLAINT]";
- throw new AwsException("BadRequestException",
- "1 validation error detected: Value at '" + fieldName + "' failed to satisfy constraint: "
- + constraint, 400);
- }
- }
/**
* Validation message used by PutConfigurationSetSuppressionOptions. AWS
@@ -3454,25 +2484,6 @@ public class SesService {
return "Reason " + reason + " is invalid, must be one of [BOUNCE, COMPLAINT].";
}
- static void validateTag(Tag tag) {
- if (tag == null) {
- throw new AwsException("InvalidParameterValue", "Tag must not be null.", 400);
- }
- String key = tag.key();
- if (key == null || key.isEmpty()) {
- throw new AwsException("InvalidParameterValue", "Tag Key is required.", 400);
- }
- if (key.length() > 128) {
- throw new AwsException("InvalidParameterValue",
- "Tag Key must be 1-128 characters.", 400);
- }
- String value = tag.value();
- if (value != null && value.length() > 256) {
- throw new AwsException("InvalidParameterValue",
- "Tag Value must be 0-256 characters.", 400);
- }
- }
-
public String sendTemplatedEmail(String source, List<String> toAddresses, List<String> ccAddresses,
List<String> bccAddresses, List<String> replyToAddresses,
String templateName, JsonNode templateData,
@@ -3800,36 +2811,6 @@ public class SesService {
return out.toString();
}
- private static void validateTemplate(EmailTemplate template) {
- if (template == null) {
- throw new AwsException("InvalidTemplate", "Template is required.", 400);
- }
- validateTemplateName(template.getTemplateName());
- boolean hasSubject = template.getSubject() != null && !template.getSubject().isBlank();
- boolean hasText = template.getTextPart() != null && !template.getTextPart().isBlank();
- boolean hasHtml = template.getHtmlPart() != null && !template.getHtmlPart().isBlank();
- if (!hasSubject && !hasText && !hasHtml) {
- throw new AwsException("InvalidTemplate",
- "Template must have at least a subject, text, or html part.", 400);
- }
- }
-
- private static void validateTemplateName(String templateName) {
- if (templateName == null || templateName.isBlank()) {
- throw new AwsException("InvalidTemplate", "TemplateName is required.", 400);
- }
- if (Character.isWhitespace(templateName.charAt(0))
- || Character.isWhitespace(templateName.charAt(templateName.length() - 1))) {
- throw new AwsException("InvalidTemplate",
- "TemplateName must not contain leading or trailing whitespace.", 400);
- }
- }
-
- private static String templateKey(String region, String templateName) {
- validateTemplateName(templateName);
- return "template::" + region + "::" + templateName;
- }
-
/**
* Extracts the template name from an SES template ARN of the form
* {@code arn:aws:ses:<region>:<account>:template/<name>}. Region and
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesSuppressionService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesSuppressionService.java
new file mode 100644
index 0000000000..143a32ca4e
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesSuppressionService.java
@@ -0,0 +1,236 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.AccountSuppressionAttributes;
+import io.github.hectorvent.floci.services.ses.model.SuppressedDestination;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * Suppression: the account-level suppression attributes and the per-address suppression list,
+ * extracted from {@link SesService} as the sixth step of the store-based domain split.
+ *
+ * <p>New facet: this resolves the shared-helper deferral called out in the account step. The
+ * account-suppression and suppression-list sub-domains share {@code validateSuppressionReason}, so
+ * rather than splitting one off, both stores move together into this service and the helper becomes
+ * a private detail of it. The send path keeps its cross-domain orchestration
+ * ({@code getEffectiveSuppressedReasons} reads a configuration set's options or falls back here;
+ * {@code collectSuppressedReasons}/{@code resolveSuppressionReason} filter a send) in the
+ * {@link SesService} facade, which reads entries back through {@link #findSuppressedDestination}.
+ */
+@ApplicationScoped
+public class SesSuppressionService {
+
+ private static final Logger LOG = Logger.getLogger(SesSuppressionService.class);
+
+ private final StorageBackend<String, SuppressedDestination> suppressionStore;
+ private final StorageBackend<String, AccountSuppressionAttributes> accountSuppressionStore;
+
+ @Inject
+ public SesSuppressionService(StorageFactory storageFactory) {
+ this.suppressionStore = storageFactory.create("ses", "ses-suppression.json",
+ new TypeReference<Map<String, SuppressedDestination>>() {});
+ this.accountSuppressionStore = storageFactory.create("ses", "ses-account-suppression.json",
+ new TypeReference<Map<String, AccountSuppressionAttributes>>() {});
+ }
+
+ SesSuppressionService(StorageBackend<String, SuppressedDestination> suppressionStore,
+ StorageBackend<String, AccountSuppressionAttributes> accountSuppressionStore) {
+ this.suppressionStore = suppressionStore;
+ this.accountSuppressionStore = accountSuppressionStore;
+ }
+
+ // ──────────────────── Account-level suppression attributes ────────────────────
+
+ public AccountSuppressionAttributes getAccountSuppressionAttributes(String region) {
+ return accountSuppressionStore.get(accountSuppressionKey(region))
+ .orElseGet(SesSuppressionService::defaultAccountSuppressionAttributes);
+ }
+
+ private static AccountSuppressionAttributes defaultAccountSuppressionAttributes() {
+ // Fresh SES accounts default to auto-suppression on both BOUNCE and COMPLAINT;
+ // an explicit PUT (including an empty list) overrides this.
+ AccountSuppressionAttributes attrs = new AccountSuppressionAttributes();
+ attrs.setSuppressedReasons(new ArrayList<>(List.of("BOUNCE", "COMPLAINT")));
+ return attrs;
+ }
+
+ public void putAccountSuppressionAttributes(String region, List<String> suppressedReasons) {
+ List<String> sanitized = new ArrayList<>();
+ if (suppressedReasons != null) {
+ for (String r : suppressedReasons) {
+ validateSuppressionReason(r, "suppressedReasons", true);
+ sanitized.add(r);
+ }
+ }
+ AccountSuppressionAttributes attrs = new AccountSuppressionAttributes();
+ attrs.setSuppressedReasons(sanitized);
+ accountSuppressionStore.put(accountSuppressionKey(region), attrs);
+ LOG.infov("Updated account suppression attributes for region {0}: {1}", region, sanitized);
+ }
+
+ private static String accountSuppressionKey(String region) {
+ return "account-suppression::" + region;
+ }
+
+ // ──────────────────────────── Suppression list ────────────────────────────
+
+ public void putSuppressedDestination(String region, String emailAddress, String reason) {
+ String normalized = normalizeSuppressionEmail(emailAddress);
+ validateSuppressionReason(reason, "reason", false);
+ String key = suppressionKey(region, normalized);
+ SuppressionMatch match = existingSuppressionMatch(region, emailAddress, normalized).orElse(null);
+ SuppressedDestination entry = match != null ? match.entry() : new SuppressedDestination(normalized, reason);
+ entry.setEmailAddress(normalized);
+ entry.setReason(reason);
+ entry.setLastUpdateTime(Instant.now());
+ // Write the canonical key first, then drop a legacy key it migrated from,
+ // so a failed write can't lose the entry. The legacy form was persisted by
+ // a pre-canonicalization Floci (trim-only key); migrating it avoids leaving
+ // a stuck duplicate after a re-PUT.
+ suppressionStore.put(key, entry);
+ if (match != null && !match.key().equals(key)) {
+ suppressionStore.delete(match.key());
+ }
+ LOG.infov("Suppressed destination {0} in region {1} (reason={2})", normalized, region, reason);
+ }
+
+ public SuppressedDestination getSuppressedDestination(String region, String emailAddress) {
+ String normalized = normalizeSuppressionEmail(emailAddress);
+ return existingSuppressionMatch(region, emailAddress, normalized)
+ .map(SuppressionMatch::entry)
+ .orElseThrow(() -> new AwsException("NotFoundException",
+ "Email address " + normalized + " does not exist on your suppression list.",
+ 404));
+ }
+
+ public void deleteSuppressedDestination(String region, String emailAddress) {
+ String normalized = normalizeSuppressionEmail(emailAddress);
+ SuppressionMatch match = existingSuppressionMatch(region, emailAddress, normalized)
+ .orElseThrow(() -> new AwsException("NotFoundException",
+ "Email address " + normalized + " does not exist on your suppression list.",
+ 404));
+ suppressionStore.delete(match.key());
+ LOG.infov("Removed suppression entry for {0} in region {1}", normalized, region);
+ }
+
+ /**
+ * Reads a suppression entry without throwing, so the facade's send-path filters
+ * ({@code collectSuppressedReasons} / {@code resolveSuppressionReason}) can look one up by raw
+ * address and share this service's normalization and legacy-key fallback.
+ */
+ public Optional<SuppressedDestination> findSuppressedDestination(String region, String rawEmail) {
+ if (rawEmail == null || rawEmail.isBlank()) {
+ return Optional.empty();
+ }
+ String normalized = normalizeSuppressionEmail(rawEmail);
+ return existingSuppressionMatch(region, rawEmail, normalized).map(SuppressionMatch::entry);
+ }
+
+ /** A suppression entry together with the storage key it currently lives under. */
+ private record SuppressionMatch(String key, SuppressedDestination entry) {
+ }
+
+ /**
+ * Resolve a suppression entry by its canonical (domain-lower-cased) key, falling
+ * back to the legacy raw-trimmed key used by a pre-canonicalization Floci. Returns
+ * the entry and the key it was found under in a single read per candidate, so
+ * callers don't re-fetch the store.
+ */
+ private Optional<SuppressionMatch> existingSuppressionMatch(String region, String rawEmail, String normalized) {
+ String canonical = suppressionKey(region, normalized);
+ Optional<SuppressedDestination> hit = suppressionStore.get(canonical);
+ if (hit.isPresent()) {
+ return Optional.of(new SuppressionMatch(canonical, hit.get()));
+ }
+ String legacy = suppressionKey(region, rawEmail.trim());
+ if (!legacy.equals(canonical)) {
+ Optional<SuppressedDestination> legacyHit = suppressionStore.get(legacy);
+ if (legacyHit.isPresent()) {
+ return Optional.of(new SuppressionMatch(legacy, legacyHit.get()));
+ }
+ }
+ return Optional.empty();
+ }
+
+ public List<SuppressedDestination> listSuppressedDestinations(String region, List<String> reasonFilters) {
+ Set<String> filters = new HashSet<>();
+ if (reasonFilters != null) {
+ for (String r : reasonFilters) {
+ if (r != null && !r.isBlank()) {
+ validateSuppressionReason(r, "reasons", true);
+ filters.add(r);
+ }
+ }
+ }
+ String prefix = "suppression::" + region + "::";
+ List<SuppressedDestination> all = new ArrayList<>(suppressionStore.scan(k -> k.startsWith(prefix)));
+ all.sort(Comparator.comparing(SuppressedDestination::getLastUpdateTime,
+ Comparator.nullsLast(Comparator.naturalOrder()))
+ .thenComparing(SuppressedDestination::getEmailAddress,
+ Comparator.nullsLast(Comparator.naturalOrder())));
+ if (filters.isEmpty()) {
+ return all;
+ }
+ return all.stream()
+ .filter(s -> filters.contains(s.getReason()))
+ .toList();
+ }
+
+ private static String suppressionKey(String region, String emailAddress) {
+ return "suppression::" + region + "::" + emailAddress;
+ }
+
+ private static String normalizeSuppressionEmail(String emailAddress) {
+ if (emailAddress == null || emailAddress.isBlank()) {
+ throw new AwsException("BadRequestException", "EmailAddress is required.", 400);
+ }
+ // AWS trims the EmailAddress and canonicalizes only the domain to lower
+ // case; the local-part keeps its case. Verified against real AWS SES V2
+ // (2026-06-15): `[email protected]` and `[email protected]` collapse to one
+ // suppression entry (`[email protected]`), but `Foo@x` and `foo@x` are two
+ // distinct entries. Lower-casing the whole address would wrongly merge
+ // local-part variants and alter the stored value on read-back.
+ // Locale.ROOT avoids the JVM-locale Turkish-i pitfall.
+ String trimmed = emailAddress.trim();
+ int at = trimmed.lastIndexOf('@');
+ if (at < 0) {
+ return trimmed;
+ }
+ return trimmed.substring(0, at) + "@" + trimmed.substring(at + 1).toLowerCase(Locale.ROOT);
+ }
+
+ /**
+ * Validation message used by PutAccountSuppressionAttributes, PutSuppressedDestination, and
+ * ListSuppressedDestinations — all three return the AWS "1 validation error detected: Value at
+ * '<fieldName>' failed to satisfy constraint: ..." V1-style nested message verbatim. (Verified
+ * against real AWS V2 SES on 2026-06-03.) The {@code nested} flag controls whether the inner enum
+ * constraint is wrapped in {@code Member must satisfy constraint: [...]} — PutSuppressedDestination
+ * (single Reason field) returns the unwrapped form; the two list-bearing APIs return the wrapped
+ * form. Shared by the two sub-domains above, which is why they were extracted together.
+ */
+ private static void validateSuppressionReason(String reason, String fieldName, boolean nested) {
+ if (reason == null || (!"BOUNCE".equals(reason) && !"COMPLAINT".equals(reason))) {
+ String constraint = nested
+ ? "Member must satisfy constraint: [Member must satisfy enum value set: [BOUNCE, COMPLAINT]]"
+ : "Member must satisfy enum value set: [BOUNCE, COMPLAINT]";
+ throw new AwsException("BadRequestException",
+ "1 validation error detected: Value at '" + fieldName + "' failed to satisfy constraint: "
+ + constraint, 400);
+ }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesTags.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesTags.java
new file mode 100644
index 0000000000..0e1700d096
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesTags.java
@@ -0,0 +1,32 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.services.ses.model.Tag;
+
+/**
+ * Shared SES resource-tag validation. Lives outside the facade so the extracted domain services can
+ * validate tags without depending back on {@link SesService}.
+ */
+final class SesTags {
+
+ private SesTags() {}
+
+ static void validate(Tag tag) {
+ if (tag == null) {
+ throw new AwsException("InvalidParameterValue", "Tag must not be null.", 400);
+ }
+ String key = tag.key();
+ if (key == null || key.isEmpty()) {
+ throw new AwsException("InvalidParameterValue", "Tag Key is required.", 400);
+ }
+ if (key.length() > 128) {
+ throw new AwsException("InvalidParameterValue",
+ "Tag Key must be 1-128 characters.", 400);
+ }
+ String value = tag.value();
+ if (value != null && value.length() > 256) {
+ throw new AwsException("InvalidParameterValue",
+ "Tag Value must be 0-256 characters.", 400);
+ }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesTemplateService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesTemplateService.java
new file mode 100644
index 0000000000..3a43e325f3
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesTemplateService.java
@@ -0,0 +1,154 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.EmailTemplate;
+import io.github.hectorvent.floci.services.ses.model.Tag;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import org.jboss.logging.Logger;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Email templates (the {@code templateStore}), extracted from {@link SesService} as part of the
+ * store-based domain split. Reached through the {@code SesService} facade, which delegates the CRUD
+ * here; the facade's templated-send path reads templates back through {@link #getTemplate}, and its
+ * ARN-dispatched tagging reads/writes through {@link #find} / {@link #save}.
+ *
+ * <p>Tag validation is a shared cross-resource concern, so {@code createTemplate} calls
+ * {@link SesTags#validate} rather than depending back on the facade. The template ARN parser
+ * ({@code SesService.templateNameFromArn}) stays on the facade because external callers reference it
+ * statically.
+ */
+@ApplicationScoped
+public class SesTemplateService {
+
+ private static final Logger LOG = Logger.getLogger(SesTemplateService.class);
+
+ private final StorageBackend<String, EmailTemplate> templateStore;
+
+ @Inject
+ public SesTemplateService(StorageFactory storageFactory) {
+ this.templateStore = storageFactory.create("ses", "ses-templates.json",
+ new TypeReference<Map<String, EmailTemplate>>() {});
+ }
+
+ SesTemplateService(StorageBackend<String, EmailTemplate> templateStore) {
+ this.templateStore = templateStore;
+ }
+
+ public EmailTemplate createTemplate(EmailTemplate template, String region) {
+ validateTemplate(template);
+ if (template.getTags() != null) {
+ for (Tag tag : template.getTags()) {
+ SesTags.validate(tag);
+ }
+ }
+ String key = templateKey(region, template.getTemplateName());
+ if (templateStore.get(key).isPresent()) {
+ throw new AwsException("AlreadyExists",
+ "Template " + template.getTemplateName() + " already exists.", 400);
+ }
+ Instant now = Instant.now();
+ template.setCreatedTimestamp(now);
+ template.setLastUpdatedTimestamp(now);
+ templateStore.put(key, template);
+ LOG.infov("Created SES template: {0} in region {1}", template.getTemplateName(), region);
+ return template;
+ }
+
+ public EmailTemplate getTemplate(String templateName, String region) {
+ return templateStore.get(templateKey(region, templateName))
+ .orElseThrow(() -> new AwsException("TemplateDoesNotExist",
+ "Template " + templateName + " does not exist.", 400));
+ }
+
+ public EmailTemplate updateTemplate(EmailTemplate template, String region) {
+ validateTemplate(template);
+ String key = templateKey(region, template.getTemplateName());
+ EmailTemplate existing = templateStore.get(key)
+ .orElseThrow(() -> new AwsException("TemplateDoesNotExist",
+ "Template " + template.getTemplateName() + " does not exist.", 400));
+ template.setCreatedTimestamp(existing.getCreatedTimestamp());
+ template.setLastUpdatedTimestamp(Instant.now());
+ // Tags are managed exclusively via Tag/UntagResource — preserve them on update.
+ template.setTags(existing.getTags());
+ templateStore.put(key, template);
+ LOG.infov("Updated SES template: {0} in region {1}", template.getTemplateName(), region);
+ return template;
+ }
+
+ public void deleteTemplate(String templateName, String region) {
+ String key = templateKey(region, templateName);
+ if (templateStore.get(key).isEmpty()) {
+ throw new AwsException("TemplateDoesNotExist",
+ "Template " + templateName + " does not exist.", 400);
+ }
+ templateStore.delete(key);
+ LOG.infov("Deleted SES template: {0} in region {1}", templateName, region);
+ }
+
+ public List<EmailTemplate> listTemplates(String region) {
+ String prefix = "template::" + region + "::";
+ List<EmailTemplate> all = new ArrayList<>(templateStore.scan(k -> k.startsWith(prefix)));
+ all.sort(Comparator.comparing(EmailTemplate::getCreatedTimestamp,
+ Comparator.nullsLast(Comparator.naturalOrder()))
+ .thenComparing(EmailTemplate::getTemplateName,
+ Comparator.nullsLast(Comparator.naturalOrder())));
+ return all;
+ }
+
+ /**
+ * Reads a template without throwing, so the facade's ARN-dispatched tagging can look one up by
+ * name and reuse this service's key derivation.
+ */
+ public Optional<EmailTemplate> find(String templateName, String region) {
+ return templateStore.get(templateKey(region, templateName));
+ }
+
+ /**
+ * Persists a template under its canonical key, so the facade's tagging can write the merged tags
+ * back without owning the key derivation.
+ */
+ public void save(EmailTemplate template, String region) {
+ templateStore.put(templateKey(region, template.getTemplateName()), template);
+ }
+
+ private static void validateTemplate(EmailTemplate template) {
+ if (template == null) {
+ throw new AwsException("InvalidTemplate", "Template is required.", 400);
+ }
+ validateTemplateName(template.getTemplateName());
+ boolean hasSubject = template.getSubject() != null && !template.getSubject().isBlank();
+ boolean hasText = template.getTextPart() != null && !template.getTextPart().isBlank();
+ boolean hasHtml = template.getHtmlPart() != null && !template.getHtmlPart().isBlank();
+ if (!hasSubject && !hasText && !hasHtml) {
+ throw new AwsException("InvalidTemplate",
+ "Template must have at least a subject, text, or html part.", 400);
+ }
+ }
+
+ private static void validateTemplateName(String templateName) {
+ if (templateName == null || templateName.isBlank()) {
+ throw new AwsException("InvalidTemplate", "TemplateName is required.", 400);
+ }
+ if (Character.isWhitespace(templateName.charAt(0))
+ || Character.isWhitespace(templateName.charAt(templateName.length() - 1))) {
+ throw new AwsException("InvalidTemplate",
+ "TemplateName must not contain leading or trailing whitespace.", 400);
+ }
+ }
+
+ private static String templateKey(String region, String templateName) {
+ validateTemplateName(templateName);
+ return "template::" + region + "::" + templateName;
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesAccountServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesAccountServiceTest.java
new file mode 100644
index 0000000000..9803d399eb
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesAccountServiceTest.java
@@ -0,0 +1,57 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.AccountVdmAttributes;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted account domain: the account sending-enabled flag and
+ * the VDM attributes. The service is constructed with just its own two stores — no 14-argument
+ * SesService needed.
+ */
+class SesAccountServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private SesAccountService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesAccountService(new InMemoryStorage<>(), new InMemoryStorage<>());
+ }
+
+ @Test
+ void sendingEnabled_defaultsTrue() {
+ assertTrue(service.isAccountSendingEnabled(REGION));
+ }
+
+ @Test
+ void setSendingEnabled_roundTrips() {
+ service.setAccountSendingEnabled(REGION, false);
+ assertFalse(service.isAccountSendingEnabled(REGION));
+
+ service.setAccountSendingEnabled(REGION, true);
+ assertTrue(service.isAccountSendingEnabled(REGION));
+ }
+
+ @Test
+ void sendingEnabled_isPerRegion() {
+ service.setAccountSendingEnabled(REGION, false);
+ assertTrue(service.isAccountSendingEnabled("eu-west-1"));
+ }
+
+ @Test
+ void vdmAttributes_absentUntilConfigured_thenRoundTrip() {
+ // Opt-in: a never-configured region has no VdmAttributes at all.
+ assertTrue(service.findAccountVdmAttributes(REGION).isEmpty());
+
+ service.putAccountVdmAttributes(REGION, new AccountVdmAttributes(true, true, false));
+ AccountVdmAttributes vdm = service.findAccountVdmAttributes(REGION).orElseThrow();
+ assertTrue(vdm.vdmEnabled());
+ assertTrue(vdm.engagementMetrics());
+ assertFalse(vdm.optimizedSharedDelivery());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesContactServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesContactServiceTest.java
new file mode 100644
index 0000000000..b1ea5b0854
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesContactServiceTest.java
@@ -0,0 +1,73 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.Contact;
+import io.github.hectorvent.floci.services.ses.model.ContactList;
+import io.github.hectorvent.floci.services.ses.model.Topic;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.Clock;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted contact domain. New facet: a multi-store service
+ * (contact lists + contacts) constructed with just its two stores and a clock — the two SesService
+ * constructor arguments collapse into one. Also exercises the list-management behaviour the send
+ * path calls into.
+ */
+class SesContactServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private static final String LIST = "news";
+ private SesContactService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesContactService(new InMemoryStorage<>(), new InMemoryStorage<>(), Clock.systemUTC());
+ service.createContactList(LIST, "desc",
+ List.of(new Topic("Sports", "Sports", "OPT_OUT", "d")), List.of(), REGION);
+ }
+
+ @Test
+ void secondContactList_hitsOneListLimit() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.createContactList("other", "d", List.of(), List.of(), REGION));
+ assertEquals("BadRequestException", e.getErrorCode());
+ }
+
+ @Test
+ void createContact_thenGet_roundTrips() {
+ service.createContact(LIST, "[email protected]", List.of(), false, null, REGION);
+ assertEquals("[email protected]", service.getContact(LIST, "[email protected]", REGION).contact().getEmailAddress());
+ }
+
+ @Test
+ void deleteContactList_purgesContacts() {
+ service.createContact(LIST, "[email protected]", List.of(), false, null, REGION);
+ service.deleteContactList(LIST, REGION);
+ // The list — and its contacts — are gone.
+ assertThrows(AwsException.class, () -> service.listContacts(LIST, REGION));
+ }
+
+ @Test
+ void getOrAutoCreateContact_createsOnSend() {
+ ContactList list = service.getContactList(LIST, REGION);
+ Contact created = service.getOrAutoCreateContact(list, "[email protected]", REGION);
+ assertEquals("[email protected]", created.getEmailAddress());
+ assertTrue(service.getContact(LIST, "[email protected]", REGION).contact() != null);
+ }
+
+ @Test
+ void unsubscribeAll_thenListManagementOptedOut() {
+ ContactList list = service.getContactList(LIST, REGION);
+ service.unsubscribeContact(LIST, "[email protected]", null, REGION);
+ Contact c = service.getContact(LIST, "[email protected]", REGION).contact();
+ assertTrue(service.isListManagementOptedOut(c, list, null));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesCvetServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesCvetServiceTest.java
new file mode 100644
index 0000000000..c3cfb956ef
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesCvetServiceTest.java
@@ -0,0 +1,75 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.CustomVerificationEmailTemplate;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted CVET storage domain. The identity-dependent
+ * validation lives in the SesService facade, so this service is a pure store — constructed with just
+ * its own store and unit-tested without a 14-argument SesService.
+ */
+class SesCvetServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private SesCvetService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesCvetService(new InMemoryStorage<>());
+ }
+
+ private static CustomVerificationEmailTemplate template(String name) {
+ CustomVerificationEmailTemplate t = new CustomVerificationEmailTemplate();
+ t.setTemplateName(name);
+ t.setFromEmailAddress("[email protected]");
+ t.setTemplateSubject("Verify");
+ t.setTemplateContent("Hello");
+ t.setSuccessRedirectionURL("https://example.com/ok");
+ t.setFailureRedirectionURL("https://example.com/no");
+ return t;
+ }
+
+ @Test
+ void create_thenGet_roundTrips() {
+ service.createCustomVerificationEmailTemplate(template("t1"), REGION);
+ assertEquals("t1", service.getCustomVerificationEmailTemplate("t1", REGION).getTemplateName());
+ }
+
+ @Test
+ void create_duplicate_throwsAlreadyExists() {
+ service.createCustomVerificationEmailTemplate(template("t1"), REGION);
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.createCustomVerificationEmailTemplate(template("t1"), REGION));
+ assertEquals("CustomVerificationEmailTemplateAlreadyExists", e.getErrorCode());
+ }
+
+ @Test
+ void get_unknown_throwsDoesNotExist() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.getCustomVerificationEmailTemplate("ghost", REGION));
+ assertEquals("CustomVerificationEmailTemplateDoesNotExist", e.getErrorCode());
+ }
+
+ @Test
+ void delete_removesIt_andFindReflectsIt() {
+ service.createCustomVerificationEmailTemplate(template("t1"), REGION);
+ assertTrue(service.find("t1", REGION).isPresent());
+
+ service.deleteCustomVerificationEmailTemplate("t1", REGION);
+ assertTrue(service.find("t1", REGION).isEmpty());
+ }
+
+ @Test
+ void update_unknown_throwsDoesNotExist() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.updateCustomVerificationEmailTemplate(template("ghost"), REGION));
+ assertEquals("CustomVerificationEmailTemplateDoesNotExist", e.getErrorCode());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpServiceTest.java
new file mode 100644
index 0000000000..b4cbccc963
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpServiceTest.java
@@ -0,0 +1,80 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.DedicatedIpPool;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted dedicated-IP-pool domain: create/get/list/delete plus
+ * the scaling-mode and duplicate validation. The service is constructed with just its own store — no
+ * 14-argument SesService needed.
+ */
+class SesDedicatedIpServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private SesDedicatedIpService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesDedicatedIpService(new InMemoryStorage<>());
+ }
+
+ @Test
+ void create_defaultsScalingModeToStandard() {
+ DedicatedIpPool pool = service.createDedicatedIpPool("pool-a", null, REGION);
+ assertEquals("pool-a", pool.getPoolName());
+ assertEquals("STANDARD", pool.getScalingMode());
+ assertTrue(service.dedicatedIpPoolExists("pool-a", REGION));
+ }
+
+ @Test
+ void create_rejectsBlankName() {
+ assertThrows(AwsException.class, () -> service.createDedicatedIpPool(" ", "STANDARD", REGION));
+ }
+
+ @Test
+ void create_rejectsInvalidScalingMode() {
+ assertThrows(AwsException.class, () -> service.createDedicatedIpPool("pool-a", "TURBO", REGION));
+ }
+
+ @Test
+ void create_rejectsDuplicate() {
+ service.createDedicatedIpPool("pool-a", "STANDARD", REGION);
+ assertThrows(AwsException.class, () -> service.createDedicatedIpPool("pool-a", "STANDARD", REGION));
+ }
+
+ @Test
+ void get_missingThrows() {
+ assertThrows(AwsException.class, () -> service.getDedicatedIpPool("ghost", REGION));
+ }
+
+ @Test
+ void list_isSortedAndPerRegion() {
+ service.createDedicatedIpPool("pool-b", "STANDARD", REGION);
+ service.createDedicatedIpPool("pool-a", "STANDARD", REGION);
+ service.createDedicatedIpPool("pool-other", "STANDARD", "eu-west-1");
+
+ assertEquals(List.of("pool-a", "pool-b"), service.listDedicatedIpPools(REGION));
+ }
+
+ @Test
+ void delete_removesPool() {
+ service.createDedicatedIpPool("pool-a", "MANAGED", REGION);
+ service.deleteDedicatedIpPool("pool-a", REGION);
+ assertFalse(service.dedicatedIpPoolExists("pool-a", REGION));
+ }
+
+ @Test
+ void delete_missingThrows() {
+ assertThrows(AwsException.class, () -> service.deleteDedicatedIpPool("ghost", REGION));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesPolicyServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesPolicyServiceTest.java
new file mode 100644
index 0000000000..1c682e1e06
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesPolicyServiceTest.java
@@ -0,0 +1,74 @@
+package io.github.hectorvent.floci.services.ses;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted identity-policy domain. The identity-existence check
+ * stays in the SesService facade, so this service is a pure policy store — unit-tested with just its
+ * store and an ObjectMapper, and it exercises the reverse-coupling helper deletePoliciesForIdentity.
+ */
+class SesPolicyServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private static final String IDENTITY = "[email protected]";
+ private SesPolicyService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesPolicyService(new InMemoryStorage<>(), new ObjectMapper());
+ }
+
+ @Test
+ void create_thenList_roundTrips() {
+ service.createEmailIdentityPolicy(IDENTITY, "p1", "{\"Version\":\"2012-10-17\"}", REGION);
+ assertTrue(service.listAllPolicies(IDENTITY, REGION).containsKey("p1"));
+ }
+
+ @Test
+ void create_duplicate_throwsAlreadyExists() {
+ service.createEmailIdentityPolicy(IDENTITY, "p1", "{}", REGION);
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.createEmailIdentityPolicy(IDENTITY, "p1", "{}", REGION));
+ assertEquals("AlreadyExistsException", e.getErrorCode());
+ }
+
+ @Test
+ void update_missing_throwsNotFound() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.updateEmailIdentityPolicy(IDENTITY, "ghost", "{}", REGION));
+ assertEquals("NotFoundException", e.getErrorCode());
+ }
+
+ @Test
+ void invalidPolicyName_throws() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.createEmailIdentityPolicy(IDENTITY, "bad name!", "{}", REGION));
+ assertEquals("InvalidParameterValue", e.getErrorCode());
+ }
+
+ @Test
+ void enforcesPerIdentityLimit() {
+ for (int i = 0; i < SesPolicyService.MAX_POLICIES_PER_IDENTITY; i++) {
+ service.createEmailIdentityPolicy(IDENTITY, "p" + i, "{}", REGION);
+ }
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.createEmailIdentityPolicy(IDENTITY, "one-too-many", "{}", REGION));
+ assertEquals("LimitExceededException", e.getErrorCode());
+ }
+
+ @Test
+ void deletePoliciesForIdentity_purgesAll() {
+ service.putIdentityPolicy(IDENTITY, "p1", "{}", REGION);
+ service.putIdentityPolicy(IDENTITY, "p2", "{}", REGION);
+ service.deletePoliciesForIdentity(IDENTITY, REGION);
+ assertTrue(service.listAllPolicies(IDENTITY, REGION).isEmpty());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesReceiptRuleServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesReceiptRuleServiceTest.java
new file mode 100644
index 0000000000..2b196e4466
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesReceiptRuleServiceTest.java
@@ -0,0 +1,70 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.ReceiptRuleSet;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.Clock;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Unit test for the extracted receipt-rule domain. The payoff of the split: the
+ * service is constructed with just its own store and a clock — no 14-argument SesService needed.
+ */
+class SesReceiptRuleServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private SesReceiptRuleService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesReceiptRuleService(new InMemoryStorage<>(), Clock.systemUTC());
+ }
+
+ @Test
+ void create_thenDescribe_roundTrips() {
+ service.createReceiptRuleSet("rules-a", REGION);
+ assertEquals("rules-a", service.describeReceiptRuleSet("rules-a", REGION).getName());
+ }
+
+ @Test
+ void create_duplicate_throwsAlreadyExists() {
+ service.createReceiptRuleSet("rules-a", REGION);
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.createReceiptRuleSet("rules-a", REGION));
+ assertEquals("AlreadyExists", e.getErrorCode());
+ }
+
+ @Test
+ void describe_unknown_throwsRuleSetDoesNotExist() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.describeReceiptRuleSet("ghost", REGION));
+ assertEquals("RuleSetDoesNotExist", e.getErrorCode());
+ }
+
+ @Test
+ void setActive_thenDescribeActive_andDeleteActiveRejected() {
+ service.createReceiptRuleSet("rules-a", REGION);
+ service.setActiveReceiptRuleSet("rules-a", REGION);
+
+ ReceiptRuleSet active = service.describeActiveReceiptRuleSet(REGION);
+ assertNotNull(active);
+ assertEquals("rules-a", active.getName());
+
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.deleteReceiptRuleSet("rules-a", REGION));
+ assertEquals("CannotDelete", e.getErrorCode());
+ }
+
+ @Test
+ void invalidName_throwsValidationError() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.createReceiptRuleSet("bad name!", REGION));
+ assertEquals("ValidationError", e.getErrorCode());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesSentEmailServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesSentEmailServiceTest.java
new file mode 100644
index 0000000000..08d46e5d6a
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesSentEmailServiceTest.java
@@ -0,0 +1,72 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.SentEmail;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted sent-email record domain: the send path's output sink plus the
+ * per-region count and the inspection list/clear. The service is constructed with just its own store
+ * — no 14-argument SesService needed.
+ */
+class SesSentEmailServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private SesSentEmailService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesSentEmailService(new InMemoryStorage<>());
+ }
+
+ private static SentEmail email(String messageId, String region) {
+ SentEmail e = new SentEmail();
+ e.setMessageId(messageId);
+ e.setRegion(region);
+ e.setSource("[email protected]");
+ return e;
+ }
+
+ @Test
+ void record_thenListAll() {
+ service.record(REGION, "m1", email("m1", REGION));
+ service.record(REGION, "m2", email("m2", REGION));
+
+ List<SentEmail> all = service.listAll();
+ assertEquals(2, all.size());
+ }
+
+ @Test
+ void countInRegion_isPerRegion() {
+ service.record(REGION, "m1", email("m1", REGION));
+ service.record(REGION, "m2", email("m2", REGION));
+ service.record("eu-west-1", "m3", email("m3", "eu-west-1"));
+
+ assertEquals(2, service.countInRegion(REGION));
+ assertEquals(1, service.countInRegion("eu-west-1"));
+ assertEquals(0, service.countInRegion("ap-northeast-1"));
+ }
+
+ @Test
+ void record_sameMessageId_isOverwrittenNotDuplicated() {
+ service.record(REGION, "m1", email("m1", REGION));
+ service.record(REGION, "m1", email("m1", REGION));
+ assertEquals(1, service.countInRegion(REGION));
+ }
+
+ @Test
+ void clear_removesEverything() {
+ service.record(REGION, "m1", email("m1", REGION));
+ service.record("eu-west-1", "m2", email("m2", "eu-west-1"));
+
+ service.clear();
+ assertTrue(service.listAll().isEmpty());
+ assertEquals(0, service.countInRegion(REGION));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceDkimLookupCacheTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceDkimLookupCacheTest.java
index d99b4f55dd..2984e17207 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceDkimLookupCacheTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceDkimLookupCacheTest.java
@@ -51,19 +51,16 @@ class SesServiceDkimLookupCacheTest {
clock.reset();
service = new SesService(
identityStore,
- new InMemoryStorage<String, SentEmail>(),
- new InMemoryStorage<String, Boolean>(),
- new InMemoryStorage<String, EmailTemplate>(),
+ new SesSentEmailService(new InMemoryStorage<String, SentEmail>()),
+ new SesAccountService(new InMemoryStorage<String, Boolean>(), new InMemoryStorage<String, AccountVdmAttributes>()),
+ new SesTemplateService(new InMemoryStorage<String, EmailTemplate>()),
new InMemoryStorage<String, ConfigurationSet>(),
- new InMemoryStorage<String, SuppressedDestination>(),
- new InMemoryStorage<String, AccountSuppressionAttributes>(),
- new InMemoryStorage<String, AccountVdmAttributes>(),
- new InMemoryStorage<String, DedicatedIpPool>(),
- new InMemoryStorage<String, ContactList>(),
- new InMemoryStorage<String, Contact>(),
- new InMemoryStorage<String, String>(),
- new InMemoryStorage<String, ReceiptRuleSet>(),
- new InMemoryStorage<String, CustomVerificationEmailTemplate>(),
+ new SesSuppressionService(new InMemoryStorage<String, SuppressedDestination>(), new InMemoryStorage<String, AccountSuppressionAttributes>()),
+ new SesDedicatedIpService(new InMemoryStorage<String, DedicatedIpPool>()),
+ new SesContactService(new InMemoryStorage<String, ContactList>(), new InMemoryStorage<String, Contact>(), clock),
+ new SesPolicyService(new InMemoryStorage<String, String>(), new ObjectMapper()),
+ new SesReceiptRuleService(new InMemoryStorage<String, ReceiptRuleSet>(), clock),
+ new SesCvetService(new InMemoryStorage<String, CustomVerificationEmailTemplate>()),
mock(SmtpRelay.class),
new ObjectMapper(),
route53Service,
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.java
index a79707eb53..0a169adc95 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceLegacyDkimTokensTest.java
@@ -40,19 +40,16 @@ class SesServiceLegacyDkimTokensTest {
identityStore = new InMemoryStorage<>();
service = new SesService(
identityStore,
- new InMemoryStorage<String, SentEmail>(),
- new InMemoryStorage<String, Boolean>(),
- new InMemoryStorage<String, EmailTemplate>(),
+ new SesSentEmailService(new InMemoryStorage<String, SentEmail>()),
+ new SesAccountService(new InMemoryStorage<String, Boolean>(), new InMemoryStorage<String, AccountVdmAttributes>()),
+ new SesTemplateService(new InMemoryStorage<String, EmailTemplate>()),
new InMemoryStorage<String, ConfigurationSet>(),
- new InMemoryStorage<String, SuppressedDestination>(),
- new InMemoryStorage<String, AccountSuppressionAttributes>(),
- new InMemoryStorage<String, AccountVdmAttributes>(),
- new InMemoryStorage<String, DedicatedIpPool>(),
- new InMemoryStorage<String, ContactList>(),
- new InMemoryStorage<String, Contact>(),
- new InMemoryStorage<String, String>(),
- new InMemoryStorage<String, ReceiptRuleSet>(),
- new InMemoryStorage<String, CustomVerificationEmailTemplate>(),
+ new SesSuppressionService(new InMemoryStorage<String, SuppressedDestination>(), new InMemoryStorage<String, AccountSuppressionAttributes>()),
+ new SesDedicatedIpService(new InMemoryStorage<String, DedicatedIpPool>()),
+ new SesContactService(new InMemoryStorage<String, ContactList>(), new InMemoryStorage<String, Contact>(), Clock.systemUTC()),
+ new SesPolicyService(new InMemoryStorage<String, String>(), new ObjectMapper()),
+ new SesReceiptRuleService(new InMemoryStorage<String, ReceiptRuleSet>(), Clock.systemUTC()),
+ new SesCvetService(new InMemoryStorage<String, CustomVerificationEmailTemplate>()),
mock(SmtpRelay.class),
new ObjectMapper(),
Clock.systemUTC());
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceListManagementTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceListManagementTest.java
index 97798409e8..341b9f7dac 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceListManagementTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceListManagementTest.java
@@ -60,19 +60,16 @@ class SesServiceListManagementTest {
contactStore = new InMemoryStorage<>();
service = new SesService(
new InMemoryStorage<String, Identity>(),
- new InMemoryStorage<String, SentEmail>(),
- new InMemoryStorage<String, Boolean>(),
- new InMemoryStorage<String, EmailTemplate>(),
+ new SesSentEmailService(new InMemoryStorage<String, SentEmail>()),
+ new SesAccountService(new InMemoryStorage<String, Boolean>(), new InMemoryStorage<String, AccountVdmAttributes>()),
+ new SesTemplateService(new InMemoryStorage<String, EmailTemplate>()),
new InMemoryStorage<String, ConfigurationSet>(),
- new InMemoryStorage<String, SuppressedDestination>(),
- new InMemoryStorage<String, AccountSuppressionAttributes>(),
- new InMemoryStorage<String, AccountVdmAttributes>(),
- new InMemoryStorage<String, DedicatedIpPool>(),
- new InMemoryStorage<String, ContactList>(),
- contactStore,
- new InMemoryStorage<String, String>(),
- new InMemoryStorage<String, ReceiptRuleSet>(),
- new InMemoryStorage<String, CustomVerificationEmailTemplate>(),
+ new SesSuppressionService(new InMemoryStorage<String, SuppressedDestination>(), new InMemoryStorage<String, AccountSuppressionAttributes>()),
+ new SesDedicatedIpService(new InMemoryStorage<String, DedicatedIpPool>()),
+ new SesContactService(new InMemoryStorage<String, ContactList>(), contactStore, Clock.systemUTC()),
+ new SesPolicyService(new InMemoryStorage<String, String>(), new ObjectMapper()),
+ new SesReceiptRuleService(new InMemoryStorage<String, ReceiptRuleSet>(), Clock.systemUTC()),
+ new SesCvetService(new InMemoryStorage<String, CustomVerificationEmailTemplate>()),
smtpRelay,
new ObjectMapper(),
Clock.systemUTC());
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java
index df42df70c8..1303cbf99c 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java
@@ -39,19 +39,16 @@ class SesServiceSmtpTest {
emailStore = new InMemoryStorage<>();
service = new SesService(
new InMemoryStorage<String, Identity>(),
- emailStore,
- new InMemoryStorage<String, Boolean>(),
- new InMemoryStorage<String, EmailTemplate>(),
+ new SesSentEmailService(emailStore),
+ new SesAccountService(new InMemoryStorage<String, Boolean>(), new InMemoryStorage<String, AccountVdmAttributes>()),
+ new SesTemplateService(new InMemoryStorage<String, EmailTemplate>()),
new InMemoryStorage<String, ConfigurationSet>(),
- new InMemoryStorage<String, SuppressedDestination>(),
- new InMemoryStorage<String, AccountSuppressionAttributes>(),
- new InMemoryStorage<String, AccountVdmAttributes>(),
- new InMemoryStorage<String, DedicatedIpPool>(),
- new InMemoryStorage<String, ContactList>(),
- new InMemoryStorage<String, Contact>(),
- new InMemoryStorage<String, String>(),
- new InMemoryStorage<String, ReceiptRuleSet>(),
- new InMemoryStorage<String, CustomVerificationEmailTemplate>(),
+ new SesSuppressionService(new InMemoryStorage<String, SuppressedDestination>(), new InMemoryStorage<String, AccountSuppressionAttributes>()),
+ new SesDedicatedIpService(new InMemoryStorage<String, DedicatedIpPool>()),
+ new SesContactService(new InMemoryStorage<String, ContactList>(), new InMemoryStorage<String, Contact>(), Clock.systemUTC()),
+ new SesPolicyService(new InMemoryStorage<String, String>(), new ObjectMapper()),
+ new SesReceiptRuleService(new InMemoryStorage<String, ReceiptRuleSet>(), Clock.systemUTC()),
+ new SesCvetService(new InMemoryStorage<String, CustomVerificationEmailTemplate>()),
smtpRelay,
new ObjectMapper(),
Clock.systemUTC());
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionLegacyKeyTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionLegacyKeyTest.java
index b9715bab3e..da31f35285 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionLegacyKeyTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionLegacyKeyTest.java
@@ -47,19 +47,16 @@ class SesServiceSuppressionLegacyKeyTest {
suppressionStore = new InMemoryStorage<>();
service = new SesService(
new InMemoryStorage<String, Identity>(),
- new InMemoryStorage<String, SentEmail>(),
- new InMemoryStorage<String, Boolean>(),
- new InMemoryStorage<String, EmailTemplate>(),
+ new SesSentEmailService(new InMemoryStorage<String, SentEmail>()),
+ new SesAccountService(new InMemoryStorage<String, Boolean>(), new InMemoryStorage<String, AccountVdmAttributes>()),
+ new SesTemplateService(new InMemoryStorage<String, EmailTemplate>()),
new InMemoryStorage<String, ConfigurationSet>(),
- suppressionStore,
- new InMemoryStorage<String, AccountSuppressionAttributes>(),
- new InMemoryStorage<String, AccountVdmAttributes>(),
- new InMemoryStorage<String, DedicatedIpPool>(),
- new InMemoryStorage<String, ContactList>(),
- new InMemoryStorage<String, Contact>(),
- new InMemoryStorage<String, String>(),
- new InMemoryStorage<String, ReceiptRuleSet>(),
- new InMemoryStorage<String, CustomVerificationEmailTemplate>(),
+ new SesSuppressionService(suppressionStore, new InMemoryStorage<String, AccountSuppressionAttributes>()),
+ new SesDedicatedIpService(new InMemoryStorage<String, DedicatedIpPool>()),
+ new SesContactService(new InMemoryStorage<String, ContactList>(), new InMemoryStorage<String, Contact>(), Clock.systemUTC()),
+ new SesPolicyService(new InMemoryStorage<String, String>(), new ObjectMapper()),
+ new SesReceiptRuleService(new InMemoryStorage<String, ReceiptRuleSet>(), Clock.systemUTC()),
+ new SesCvetService(new InMemoryStorage<String, CustomVerificationEmailTemplate>()),
mock(SmtpRelay.class),
new ObjectMapper(),
Clock.systemUTC());
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionReasonTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionReasonTest.java
index 749b71309b..6e51671de8 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionReasonTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionReasonTest.java
@@ -47,19 +47,16 @@ class SesServiceSuppressionReasonTest {
accountSuppressionStore = new InMemoryStorage<>();
service = new SesService(
new InMemoryStorage<String, Identity>(),
- new InMemoryStorage<String, SentEmail>(),
- new InMemoryStorage<String, Boolean>(),
- new InMemoryStorage<String, EmailTemplate>(),
+ new SesSentEmailService(new InMemoryStorage<String, SentEmail>()),
+ new SesAccountService(new InMemoryStorage<String, Boolean>(), new InMemoryStorage<String, AccountVdmAttributes>()),
+ new SesTemplateService(new InMemoryStorage<String, EmailTemplate>()),
new InMemoryStorage<String, ConfigurationSet>(),
- suppressionStore,
- accountSuppressionStore,
- new InMemoryStorage<String, AccountVdmAttributes>(),
- new InMemoryStorage<String, DedicatedIpPool>(),
- new InMemoryStorage<String, ContactList>(),
- new InMemoryStorage<String, Contact>(),
- new InMemoryStorage<String, String>(),
- new InMemoryStorage<String, ReceiptRuleSet>(),
- new InMemoryStorage<String, CustomVerificationEmailTemplate>(),
+ new SesSuppressionService(suppressionStore, accountSuppressionStore),
+ new SesDedicatedIpService(new InMemoryStorage<String, DedicatedIpPool>()),
+ new SesContactService(new InMemoryStorage<String, ContactList>(), new InMemoryStorage<String, Contact>(), Clock.systemUTC()),
+ new SesPolicyService(new InMemoryStorage<String, String>(), new ObjectMapper()),
+ new SesReceiptRuleService(new InMemoryStorage<String, ReceiptRuleSet>(), Clock.systemUTC()),
+ new SesCvetService(new InMemoryStorage<String, CustomVerificationEmailTemplate>()),
mock(SmtpRelay.class),
new ObjectMapper(),
Clock.systemUTC());
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesSuppressionServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesSuppressionServiceTest.java
new file mode 100644
index 0000000000..00286b3abe
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesSuppressionServiceTest.java
@@ -0,0 +1,67 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.SuppressedDestination;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted suppression domain. New facet: this closes the
+ * shared-helper deferral from the account step — account suppression and the suppression list both
+ * live here and share the (now private) reason validation, exercised by both paths below. Two stores,
+ * one service.
+ */
+class SesSuppressionServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private SesSuppressionService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesSuppressionService(new InMemoryStorage<>(), new InMemoryStorage<>());
+ }
+
+ @Test
+ void accountSuppression_defaultsToBounceAndComplaint() {
+ assertEquals(List.of("BOUNCE", "COMPLAINT"),
+ service.getAccountSuppressionAttributes(REGION).getSuppressedReasons());
+ }
+
+ @Test
+ void putAccountSuppression_rejectsInvalidReason() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.putAccountSuppressionAttributes(REGION, List.of("NONSENSE")));
+ assertEquals("BadRequestException", e.getErrorCode());
+ }
+
+ @Test
+ void suppressedDestination_putGetDelete_roundTrips() {
+ service.putSuppressedDestination(REGION, "[email protected]", "BOUNCE");
+ SuppressedDestination got = service.getSuppressedDestination(REGION, "[email protected]");
+ assertEquals("BOUNCE", got.getReason());
+
+ service.deleteSuppressedDestination(REGION, "[email protected]");
+ assertTrue(service.findSuppressedDestination(REGION, "[email protected]").isEmpty());
+ }
+
+ @Test
+ void putSuppressedDestination_rejectsInvalidReason() {
+ AwsException e = assertThrows(AwsException.class,
+ () -> service.putSuppressedDestination(REGION, "[email protected]", "NONSENSE"));
+ assertEquals("BadRequestException", e.getErrorCode());
+ }
+
+ @Test
+ void findSuppressedDestination_normalizesDomainCase() {
+ service.putSuppressedDestination(REGION, "[email protected]", "COMPLAINT");
+ // Domain is canonicalized to lower case, so a differently-cased domain resolves the entry.
+ assertTrue(service.findSuppressedDestination(REGION, "[email protected]").isPresent());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateServiceTest.java
new file mode 100644
index 0000000000..dac05f38b6
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateServiceTest.java
@@ -0,0 +1,115 @@
+package io.github.hectorvent.floci.services.ses;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.EmailTemplate;
+import io.github.hectorvent.floci.services.ses.model.Tag;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit test for the extracted email-template domain: CRUD plus the template-shape validation and
+ * duplicate/not-found handling. The service is constructed with just its own store — no 14-argument
+ * SesService needed.
+ */
+class SesTemplateServiceTest {
+
+ private static final String REGION = "us-east-1";
+ private SesTemplateService service;
+
+ @BeforeEach
+ void setUp() {
+ service = new SesTemplateService(new InMemoryStorage<>());
+ }
+
+ private static EmailTemplate template(String name) {
+ return new EmailTemplate(name, "Subject", "text body", "<p>html</p>");
+ }
+
+ @Test
+ void create_thenGet_roundTrips() {
+ EmailTemplate created = service.createTemplate(template("welcome"), REGION);
+ assertNotNull(created.getCreatedTimestamp());
+ assertNotNull(created.getLastUpdatedTimestamp());
+
+ EmailTemplate fetched = service.getTemplate("welcome", REGION);
+ assertEquals("Subject", fetched.getSubject());
+ }
+
+ @Test
+ void create_rejectsDuplicate() {
+ service.createTemplate(template("welcome"), REGION);
+ assertThrows(AwsException.class, () -> service.createTemplate(template("welcome"), REGION));
+ }
+
+ @Test
+ void create_rejectsBlankName() {
+ assertThrows(AwsException.class, () -> service.createTemplate(template(" "), REGION));
+ }
+
+ @Test
+ void create_rejectsEmptyBody() {
+ assertThrows(AwsException.class,
+ () -> service.createTemplate(new EmailTemplate("empty", null, null, null), REGION));
+ }
+
+ @Test
+ void get_missingThrows() {
+ assertThrows(AwsException.class, () -> service.getTemplate("ghost", REGION));
+ }
+
+ @Test
+ void update_preservesCreatedTimestamp_missingThrows() {
+ EmailTemplate created = service.createTemplate(template("welcome"), REGION);
+
+ EmailTemplate update = template("welcome");
+ update.setSubject("Updated");
+ EmailTemplate updated = service.updateTemplate(update, REGION);
+ assertEquals(created.getCreatedTimestamp(), updated.getCreatedTimestamp());
+ assertEquals("Updated", service.getTemplate("welcome", REGION).getSubject());
+
+ assertThrows(AwsException.class, () -> service.updateTemplate(template("ghost"), REGION));
+ }
+
+ @Test
+ void delete_removesTemplate_missingThrows() {
+ service.createTemplate(template("welcome"), REGION);
+ service.deleteTemplate("welcome", REGION);
+ assertThrows(AwsException.class, () -> service.getTemplate("welcome", REGION));
+ assertThrows(AwsException.class, () -> service.deleteTemplate("welcome", REGION));
+ }
+
+ @Test
+ void list_isSortedByCreationAndPerRegion() {
+ service.createTemplate(template("a"), REGION);
+ service.createTemplate(template("b"), REGION);
+ service.createTemplate(template("other"), "eu-west-1");
+
+ List<EmailTemplate> list = service.listTemplates(REGION);
+ assertEquals(2, list.size());
+ assertEquals("a", list.get(0).getTemplateName());
+ assertEquals("b", list.get(1).getTemplateName());
+ }
+
+ @Test
+ void findAndSave_supportFacadeTagging() {
+ service.createTemplate(template("welcome"), REGION);
+ assertTrue(service.find("ghost", REGION).isEmpty());
+
+ EmailTemplate found = service.find("welcome", REGION).orElseThrow();
+ found.setTags(List.of(new Tag("team", "ses")));
+ service.save(found, REGION);
+
+ EmailTemplate reloaded = service.find("welcome", REGION).orElseThrow();
+ assertEquals(1, reloaded.getTags().size());
+ assertEquals("team", reloaded.getTags().get(0).key());
+ assertEquals("ses", reloaded.getTags().get(0).value());
+ }
+}