From f5694c21e7368df035386ca9f565925b259dee92 Mon Sep 17 00:00:00 2001
From: Graham Packer <graham.packer@morganstanley.com>
Date: Mon, 27 Jan 2025 12:52:42 +0000
Subject: [PATCH] Removed Record Builder annotations (#716) (#844)

---
 calm-hub/pom.xml                              |  21 --
 .../java/integration/MongoAdrIntegration.java |  58 ++---
 .../java/org/finos/calm/domain/adr/Adr.java   | 209 +++++++++++++++---
 .../org/finos/calm/domain/adr/AdrMeta.java    | 106 ++++++++-
 .../org/finos/calm/domain/adr/Decision.java   |   4 -
 .../java/org/finos/calm/domain/adr/Link.java  |   4 -
 .../finos/calm/domain/adr/NewAdrRequest.java  |   4 -
 .../org/finos/calm/domain/adr/Option.java     |   4 -
 .../org/finos/calm/resources/AdrResource.java |  57 +++--
 .../finos/calm/store/mongo/MongoAdrStore.java |  68 +++---
 .../calm/resources/TestAdrResourceShould.java | 135 ++++++-----
 .../store/mongo/TestMongoAdrStoreShould.java  | 165 +++++++-------
 12 files changed, 515 insertions(+), 320 deletions(-)

diff --git a/calm-hub/pom.xml b/calm-hub/pom.xml
index 9fb82398c..3ec531131 100644
--- a/calm-hub/pom.xml
+++ b/calm-hub/pom.xml
@@ -44,12 +44,6 @@
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-mongodb-client</artifactId>
     </dependency>
-    <dependency>
-      <groupId>io.soabase.record-builder</groupId>
-      <artifactId>record-builder-core</artifactId>
-      <version>44</version>
-      <scope>provided</scope>
-    </dependency>
     <dependency>
       <groupId>com.fasterxml.jackson.datatype</groupId>
       <artifactId>jackson-datatype-jsr310</artifactId>
@@ -215,21 +209,6 @@
         </execution>
       </executions>
     </plugin>
-
-    <!-- Record Builder Plugin -->
-    <plugin>
-      <groupId>org.apache.maven.plugins</groupId>
-      <artifactId>maven-compiler-plugin</artifactId>
-      <configuration>
-        <annotationProcessorPaths>
-          <path>
-            <groupId>io.soabase.record-builder</groupId>
-            <artifactId>record-builder-processor</artifactId>
-            <version>44</version>
-          </path>
-        </annotationProcessorPaths>
-      </configuration>
-    </plugin>
     </plugins>
   </build>
   <profiles>
diff --git a/calm-hub/src/integration-test/java/integration/MongoAdrIntegration.java b/calm-hub/src/integration-test/java/integration/MongoAdrIntegration.java
index 1c3f15388..107fa3bca 100644
--- a/calm-hub/src/integration-test/java/integration/MongoAdrIntegration.java
+++ b/calm-hub/src/integration-test/java/integration/MongoAdrIntegration.java
@@ -11,14 +11,10 @@
 import org.eclipse.microprofile.config.ConfigProvider;
 import org.finos.calm.domain.adr.Adr;
 import org.finos.calm.domain.adr.AdrMeta;
-import org.finos.calm.domain.adr.AdrMetaBuilder;
 import org.finos.calm.domain.adr.Decision;
-import org.finos.calm.domain.adr.DecisionBuilder;
-import org.finos.calm.domain.adr.LinkBuilder;
+import org.finos.calm.domain.adr.Link;
 import org.finos.calm.domain.adr.NewAdrRequest;
-import org.finos.calm.domain.adr.NewAdrRequestBuilder;
 import org.finos.calm.domain.adr.Option;
-import org.finos.calm.domain.adr.OptionBuilder;
 import org.finos.calm.domain.adr.Status;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.MethodOrderer;
@@ -50,27 +46,17 @@ public class MongoAdrIntegration {
     private final String TITLE = "My ADR";
     private final String PROBLEM_STATEMENT = "My problem is...";
     private final List<String> DECISION_DRIVERS = List.of("a", "b", "c");
-    private final Option OPTION_A = OptionBuilder.builder().name("Option 1").description("optionDescription")
-            .positiveConsequences(List.of("a")).negativeConsequences(List.of("b")).build();
-    private final Option OPTION_B = OptionBuilder.builder().name("Option 2").description("optionDescription")
-            .positiveConsequences(List.of("c")).negativeConsequences(List.of("d")).build();
+    private final Option OPTION_A = new Option("Option A", "optionDescription", List.of("a"), List.of("b"));
+    private final Option OPTION_B = new Option("Option B", "optionDescription", List.of("c"), List.of("d"));
     private final List<Option> CONSIDERED_OPTIONS = List.of(OPTION_A, OPTION_B);
     private final String RATIONALE = "This is the best option";
-    private final Decision DECISION_OUTCOME = DecisionBuilder.builder()
-            .rationale(RATIONALE)
-            .chosenOption(OPTION_A)
-            .build();
-
-    private final NewAdrRequest newAdr = NewAdrRequestBuilder.builder()
-            .title(TITLE)
-            .contextAndProblemStatement(PROBLEM_STATEMENT)
-            .decisionDrivers(DECISION_DRIVERS)
-            .consideredOptions(CONSIDERED_OPTIONS)
-            .decisionOutcome(DECISION_OUTCOME)
-            .links(List.of(LinkBuilder.builder().rel("abc").href("http://abc.com").build()))
-            .build();
-
-    private final Adr adr = Adr.builderFromNewAdr(newAdr).status(Status.draft).build();
+    private final Decision DECISION_OUTCOME = new Decision(OPTION_A, RATIONALE);
+    private final List<Link> LINKS = List.of(new Link("abc", "http://abc.com"));
+
+    private final NewAdrRequest newAdr = new NewAdrRequest(TITLE, PROBLEM_STATEMENT, DECISION_DRIVERS,
+            CONSIDERED_OPTIONS, DECISION_OUTCOME, LINKS);
+
+    private final Adr adr = new Adr.AdrBuilder(newAdr).setStatus(Status.draft).build();
 
     @BeforeEach
     public void setupAdrs() {
@@ -123,12 +109,12 @@ void end_to_end_verify_create_an_adr() throws JsonProcessingException {
 
     @Test
     @Order(3)
-    void end_to_end_verify_get_adr_revision() throws JsonProcessingException {
-        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
-                .namespace("finos")
-                .id(1)
-                .revision(1)
-                .adrContent(adr)
+    void end_to_end_verify_get_adr_revision() {
+        AdrMeta expectedAdrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace("finos")
+                .setId(1)
+                .setRevision(1)
+                .setAdr(adr)
                 .build();
 
         AdrMeta actualAdrMeta = given()
@@ -152,11 +138,11 @@ void end_to_end_verify_get_adr() {
                 .body()
                 .as(AdrMeta.class);
 
-        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
-                .namespace("finos")
-                .id(1)
-                .revision(1)
-                .adrContent(adr)
+        AdrMeta expectedAdrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace("finos")
+                .setId(1)
+                .setRevision(1)
+                .setAdr(adr)
                 .build();
         assertEquals(expectedAdrMeta, actualAdrMeta);
     }
@@ -204,7 +190,7 @@ void end_to_end_verify_status_changed() throws JsonProcessingException {
                 .when().get("/calm/namespaces/finos/adrs/1/revisions/3")
                 .then()
                 .statusCode(200)
-                .body("adrContent.status", equalTo("proposed"));
+                .body("adr.status", equalTo("proposed"));
     }
 
 }
\ No newline at end of file
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Adr.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Adr.java
index 126ca4980..7b18cf1bc 100644
--- a/calm-hub/src/main/java/org/finos/calm/domain/adr/Adr.java
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Adr.java
@@ -4,39 +4,91 @@
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
-import io.soabase.recordbuilder.core.RecordBuilder;
 
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Objects;
 
-@RecordBuilder.Options(enableWither = false)
-@RecordBuilder
-public record Adr(
-        String title,
-        Status status,
-        @JsonDeserialize(using = LocalDateTimeDeserializer.class)
-        @JsonSerialize(using = LocalDateTimeSerializer.class)
-        LocalDateTime creationDateTime,
-        @JsonDeserialize(using = LocalDateTimeDeserializer.class)
-        @JsonSerialize(using = LocalDateTimeSerializer.class)
-        LocalDateTime updateDateTime,
-        String contextAndProblemStatement,
-        List<String> decisionDrivers,
-        List<Option> consideredOptions,
-        Decision decisionOutcome,
-        List<Link> links
-
-) {
-
-    public static AdrBuilder builderFromNewAdr(NewAdrRequest newAdrRequest) {
-        return AdrBuilder.builder()
-                .title(newAdrRequest.title())
-                .contextAndProblemStatement(newAdrRequest.contextAndProblemStatement())
-                .decisionDrivers(newAdrRequest.decisionDrivers())
-                .consideredOptions(newAdrRequest.consideredOptions())
-                .decisionOutcome(newAdrRequest.decisionOutcome())
-                .links(newAdrRequest.links());
+public class Adr {
+    private String title;
+    private Status status;
+    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime creationDateTime;
+    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime updateDateTime;
+    private String contextAndProblemStatement;
+    private List<String> decisionDrivers;
+    private List<Option> consideredOptions;
+    private Decision decisionOutcome;
+    private List<Link> links;
+
+    public Adr() {
+
+    }
+
+    public Adr(
+            String title,
+            Status status,
+            @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+            @JsonSerialize(using = LocalDateTimeSerializer.class)
+            LocalDateTime creationDateTime,
+            @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+            @JsonSerialize(using = LocalDateTimeSerializer.class)
+            LocalDateTime updateDateTime,
+            String contextAndProblemStatement,
+            List<String> decisionDrivers,
+            List<Option> consideredOptions,
+            Decision decisionOutcome,
+            List<Link> links
+
+    ) {
+        this.title = title;
+        this.status = status;
+        this.creationDateTime = creationDateTime;
+        this.updateDateTime = updateDateTime;
+        this.contextAndProblemStatement = contextAndProblemStatement;
+        this.decisionDrivers = decisionDrivers;
+        this.consideredOptions = consideredOptions;
+        this.decisionOutcome = decisionOutcome;
+        this.links = links;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public Status getStatus() {
+        return status;
+    }
+
+    public LocalDateTime getCreationDateTime() {
+        return creationDateTime;
+    }
+
+    public LocalDateTime getUpdateDateTime() {
+        return updateDateTime;
+    }
+
+    public String getContextAndProblemStatement() {
+        return contextAndProblemStatement;
+    }
+
+    public List<String> getDecisionDrivers() {
+        return decisionDrivers;
+    }
+
+    public List<Option> getConsideredOptions() {
+        return consideredOptions;
+    }
+
+    public Decision getDecisionOutcome() {
+        return decisionOutcome;
+    }
+
+    public List<Link> getLinks() {
+        return links;
     }
 
     // does not include datetimes in equals
@@ -58,4 +110,105 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(title, status, contextAndProblemStatement, decisionDrivers, consideredOptions, decisionOutcome, links);
     }
+
+    @Override
+    public String toString() {
+        return "Adr[" +
+                "title=" + title + ", " +
+                "status=" + status + ", " +
+                "creationDateTime=" + creationDateTime + ", " +
+                "updateDateTime=" + updateDateTime + ", " +
+                "contextAndProblemStatement=" + contextAndProblemStatement + ", " +
+                "decisionDrivers=" + decisionDrivers + ", " +
+                "consideredOptions=" + consideredOptions + ", " +
+                "decisionOutcome=" + decisionOutcome + ", " +
+                "links=" + links + ']';
+    }
+
+    public static class AdrBuilder {
+        private String title;
+        private Status status;
+        private LocalDateTime creationDateTime;
+        private LocalDateTime updateDateTime;
+        private String contextAndProblemStatement;
+        private List<String> decisionDrivers;
+        private List<Option> consideredOptions;
+        private Decision decisionOutcome;
+        private List<Link> links;
+
+        public AdrBuilder() {
+
+        }
+
+        public AdrBuilder(Adr adr) {
+            this.title = adr.getTitle();
+            this.status = adr.getStatus();
+            this.creationDateTime = adr.getCreationDateTime();
+            this.updateDateTime = adr.getUpdateDateTime();
+            this.contextAndProblemStatement = adr.getContextAndProblemStatement();
+            this.decisionDrivers = adr.getDecisionDrivers();
+            this.consideredOptions = adr.getConsideredOptions();
+            this.decisionOutcome = adr.getDecisionOutcome();
+            this.links = adr.getLinks();
+        }
+
+        public AdrBuilder(NewAdrRequest newAdrRequest) {
+            this.title = newAdrRequest.title();
+            this.contextAndProblemStatement = newAdrRequest.contextAndProblemStatement();
+            this.decisionDrivers = newAdrRequest.decisionDrivers();
+            this.consideredOptions = newAdrRequest.consideredOptions();
+            this.decisionOutcome = newAdrRequest.decisionOutcome();
+            this.links = newAdrRequest.links();
+        }
+
+        public AdrBuilder setTitle(String title) {
+            this.title = title;
+            return this;
+        }
+
+        public AdrBuilder setStatus(Status status) {
+            this.status = status;
+            return this;
+        }
+
+        public AdrBuilder setCreationDateTime(LocalDateTime creationDateTime) {
+            this.creationDateTime = creationDateTime;
+            return this;
+        }
+
+        public AdrBuilder setUpdateDateTime(LocalDateTime updateDateTime) {
+            this.updateDateTime = updateDateTime;
+            return this;
+        }
+
+        public AdrBuilder setContextAndProblemStatement(String contextAndProblemStatement) {
+            this.contextAndProblemStatement = contextAndProblemStatement;
+            return this;
+        }
+
+        public AdrBuilder setDecisionDrivers(List<String> decisionDrivers) {
+            this.decisionDrivers = decisionDrivers;
+            return this;
+        }
+
+        public AdrBuilder setConsideredOptions(List<Option> consideredOptions) {
+            this.consideredOptions = consideredOptions;
+            return this;
+        }
+
+        public AdrBuilder setDecisionOutcome(Decision decisionOutcome) {
+            this.decisionOutcome = decisionOutcome;
+            return this;
+        }
+
+        public AdrBuilder setLinks(List<Link> links) {
+            this.links = links;
+            return this;
+        }
+
+        public Adr build() {
+            return new Adr(title, status, creationDateTime, updateDateTime, contextAndProblemStatement, decisionDrivers, consideredOptions, decisionOutcome, links);
+        }
+    }
+
 }
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/AdrMeta.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/AdrMeta.java
index 6f56f1312..db555ab6f 100644
--- a/calm-hub/src/main/java/org/finos/calm/domain/adr/AdrMeta.java
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/AdrMeta.java
@@ -1,13 +1,111 @@
 package org.finos.calm.domain.adr;
 
-import io.soabase.recordbuilder.core.RecordBuilder;
+import java.util.Objects;
 
 /**
  * Represents an ADR and the associated namespace, id, and revision.
  * The ADR is represented as a String in JSON format.
  */
-@RecordBuilder.Options(enableWither = false)
-@RecordBuilder
-public record AdrMeta(String namespace, int id, int revision, Adr adrContent) {
+public class AdrMeta {
+    private String namespace;
+    private int id;
+    private int revision;
+    private Adr adr;
+
+    public AdrMeta() {
+
+    }
+
+    public AdrMeta(String namespace, int id, int revision, Adr adr) {
+        this.namespace = namespace;
+        this.id = id;
+        this.revision = revision;
+        this.adr = adr;
+    }
+
+    public String getNamespace() {
+        return namespace;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public int getRevision() {
+        return revision;
+    }
+
+    public Adr getAdr() {
+        return adr;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(obj == this) return true;
+        if(obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (AdrMeta) obj;
+        return Objects.equals(this.namespace, that.namespace) &&
+                this.id == that.id &&
+                this.revision == that.revision &&
+                Objects.equals(this.adr, that.adr);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(namespace, id, revision, adr);
+    }
+
+    @Override
+    public String toString() {
+        return "AdrMeta[" +
+                "namespace=" + namespace + ", " +
+                "id=" + id + ", " +
+                "revision=" + revision + ", " +
+                "adr=" + adr + ']';
+    }
+
+    public static class AdrMetaBuilder {
+
+        private String namespace;
+        private int id;
+        private int revision;
+        private Adr adr;
+
+
+        public AdrMetaBuilder() {
+
+        }
+
+        public AdrMetaBuilder(AdrMeta adrMeta) {
+            this.namespace = adrMeta.getNamespace();
+            this.id = adrMeta.getId();
+            this.revision = adrMeta.getRevision();
+            this.adr = adrMeta.getAdr();
+        }
+
+        public AdrMetaBuilder setNamespace(String namespace) {
+            this.namespace = namespace;
+            return this;
+        }
+
+        public AdrMetaBuilder setId(int id) {
+            this.id = id;
+            return this;
+        }
+
+        public AdrMetaBuilder setRevision(int revision) {
+            this.revision = revision;
+            return this;
+        }
+
+        public AdrMetaBuilder setAdr(Adr adr) {
+            this.adr = adr;
+            return this;
+        }
+
+        public AdrMeta build() {
+            return new AdrMeta(namespace, id, revision, adr);
+        }
+    }
 
 }
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Decision.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Decision.java
index 0aac4805d..beecdf3e8 100644
--- a/calm-hub/src/main/java/org/finos/calm/domain/adr/Decision.java
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Decision.java
@@ -1,8 +1,4 @@
 package org.finos.calm.domain.adr;
 
-import io.soabase.recordbuilder.core.RecordBuilder;
-
-@RecordBuilder.Options(enableWither = false)
-@RecordBuilder
 public record Decision(Option chosenOption, String rationale) {
 }
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Link.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Link.java
index 4f5ff57a1..91e1da291 100644
--- a/calm-hub/src/main/java/org/finos/calm/domain/adr/Link.java
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Link.java
@@ -1,8 +1,4 @@
 package org.finos.calm.domain.adr;
 
-import io.soabase.recordbuilder.core.RecordBuilder;
-
-@RecordBuilder.Options(enableWither = false)
-@RecordBuilder
 public record Link(String rel, String href) {
 }
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/NewAdrRequest.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/NewAdrRequest.java
index 9a076b4f3..f5ffa741c 100644
--- a/calm-hub/src/main/java/org/finos/calm/domain/adr/NewAdrRequest.java
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/NewAdrRequest.java
@@ -1,11 +1,7 @@
 package org.finos.calm.domain.adr;
 
-import io.soabase.recordbuilder.core.RecordBuilder;
-
 import java.util.List;
 
-@RecordBuilder.Options(enableWither = false)
-@RecordBuilder
 public record NewAdrRequest(
     String title,
     String contextAndProblemStatement,
diff --git a/calm-hub/src/main/java/org/finos/calm/domain/adr/Option.java b/calm-hub/src/main/java/org/finos/calm/domain/adr/Option.java
index 4db4dfe4d..5d58ab8ef 100644
--- a/calm-hub/src/main/java/org/finos/calm/domain/adr/Option.java
+++ b/calm-hub/src/main/java/org/finos/calm/domain/adr/Option.java
@@ -1,10 +1,6 @@
 package org.finos.calm.domain.adr;
 
-import io.soabase.recordbuilder.core.RecordBuilder;
-
 import java.util.List;
 
-@RecordBuilder.Options(enableWither = false)
-@RecordBuilder
 public record Option(String name, String description, List<String> positiveConsequences, List<String> negativeConsequences) {
 }
diff --git a/calm-hub/src/main/java/org/finos/calm/resources/AdrResource.java b/calm-hub/src/main/java/org/finos/calm/resources/AdrResource.java
index 1840210e2..a21fc4d7d 100644
--- a/calm-hub/src/main/java/org/finos/calm/resources/AdrResource.java
+++ b/calm-hub/src/main/java/org/finos/calm/resources/AdrResource.java
@@ -15,7 +15,6 @@
 import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
 import org.finos.calm.domain.adr.Adr;
 import org.finos.calm.domain.adr.AdrMeta;
-import org.finos.calm.domain.adr.AdrMetaBuilder;
 import org.finos.calm.domain.adr.Status;
 import org.finos.calm.domain.adr.NewAdrRequest;
 import org.finos.calm.domain.ValueWrapper;
@@ -84,16 +83,16 @@ public Response getAdrsForNamespace(@PathParam("namespace") String namespace) {
             description = "Creates an ADR for a given namespace with an allocated ID and revision 1"
     )
     public Response createAdrForNamespace(@PathParam("namespace") String namespace, NewAdrRequest newAdrRequest) {
-        Adr adrContent = Adr.builderFromNewAdr(newAdrRequest)
-                .status(Status.draft)
-                .creationDateTime(LocalDateTime.now())
-                .updateDateTime(LocalDateTime.now())
+        Adr adr = new Adr.AdrBuilder(newAdrRequest)
+                .setStatus(Status.draft)
+                .setCreationDateTime(LocalDateTime.now())
+                .setUpdateDateTime(LocalDateTime.now())
                 .build();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .revision(1)
-                .adrContent(adrContent)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setRevision(1)
+                .setAdr(adr)
                 .build();
 
         try {
@@ -120,14 +119,14 @@ public Response createAdrForNamespace(@PathParam("namespace") String namespace,
             description = "Updates an ADR for a given namespace. Creates a new revision."
     )
     public Response updateAdrForNamespace(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId, NewAdrRequest newAdrRequest) {
-        Adr adrContent = Adr.builderFromNewAdr(newAdrRequest)
-                .updateDateTime(LocalDateTime.now())
+        Adr adr = new Adr.AdrBuilder(newAdrRequest)
+                .setUpdateDateTime(LocalDateTime.now())
                 .build();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(adrId)
-                .adrContent(adrContent)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(adrId)
+                .setAdr(adr)
                 .build();
 
         try {
@@ -158,9 +157,9 @@ public Response updateAdrForNamespace(@PathParam("namespace") String namespace,
             )
     })
     public Response getAdr(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId) {
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(adrId)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(adrId)
                 .build();
 
         try {
@@ -185,9 +184,9 @@ public Response getAdr(@PathParam("namespace") String namespace, @PathParam("adr
             description = "The most recent revision is the canonical ADR, with others available for audit or exploring changes."
     )
     public Response getAdrRevisions(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId) {
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(adrId)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(adrId)
                 .build();
 
         try {
@@ -219,10 +218,10 @@ public Response getAdrRevisions(@PathParam("namespace") String namespace, @PathP
             )
     })
     public Response getAdrRevision(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId, @PathParam("revision") int revision) {
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(adrId)
-                .revision(revision)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(adrId)
+                .setRevision(revision)
                 .build();
 
         try {
@@ -250,9 +249,9 @@ public Response getAdrRevision(@PathParam("namespace") String namespace, @PathPa
     )
     public Response updateAdrStatusForNamespace(@PathParam("namespace") String namespace, @PathParam("adrId") int adrId, @PathParam("status") Status status) throws URISyntaxException {
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(adrId)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(adrId)
                 .build();
 
         try {
@@ -263,7 +262,7 @@ public Response updateAdrStatusForNamespace(@PathParam("namespace") String names
     }
 
     private Response adrWithLocationResponse(AdrMeta adrMeta) throws URISyntaxException {
-        return Response.created(new URI("/calm/namespaces/" + adrMeta.namespace() + "/adrs/" + adrMeta.id() + "/revisions/" + adrMeta.revision())).build();
+        return Response.created(new URI("/calm/namespaces/" + adrMeta.getNamespace() + "/adrs/" + adrMeta.getId() + "/revisions/" + adrMeta.getRevision())).build();
     }
 
     private Response handleException(Exception e, String namespace) {
diff --git a/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoAdrStore.java b/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoAdrStore.java
index 507194a52..45e5d2672 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoAdrStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/mongo/MongoAdrStore.java
@@ -16,8 +16,6 @@
 import org.bson.conversions.Bson;
 import org.finos.calm.domain.adr.Adr;
 import org.finos.calm.domain.adr.AdrMeta;
-import org.finos.calm.domain.adr.AdrMetaBuilder;
-import org.finos.calm.domain.adr.AdrBuilder;
 import org.finos.calm.domain.adr.Status;
 import org.finos.calm.domain.exception.AdrNotFoundException;
 import org.finos.calm.domain.exception.AdrParseException;
@@ -70,13 +68,13 @@ public List<Integer> getAdrsForNamespace(String namespace) throws NamespaceNotFo
 
     @Override
     public AdrMeta createAdrForNamespace(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrParseException {
-        if(!namespaceStore.namespaceExists(adrMeta.namespace())) {
+        if(!namespaceStore.namespaceExists(adrMeta.getNamespace())) {
             throw new NamespaceNotFoundException();
         }
 
-        String adrContentStr;
+        String adrStr;
         try {
-        adrContentStr = objectMapper.writeValueAsString(adrMeta.adrContent());
+        adrStr = objectMapper.writeValueAsString(adrMeta.getAdr());
         } catch(JsonProcessingException e) {
             log.error("Could not write ADR Content to String", e);
             throw new AdrParseException();
@@ -84,14 +82,14 @@ public AdrMeta createAdrForNamespace(AdrMeta adrMeta) throws NamespaceNotFoundEx
 
         int id = counterStore.getNextAdrSequenceValue();
         Document adrDocument = new Document("adrId", id).append("revisions",
-                new Document(String.valueOf(adrMeta.revision()), Document.parse(adrContentStr)));
+                new Document(String.valueOf(adrMeta.getRevision()), Document.parse(adrStr)));
 
         adrCollection.updateOne(
-                Filters.eq("namespace", adrMeta.namespace()),
+                Filters.eq("namespace", adrMeta.getNamespace()),
                 Updates.push("adrs", adrDocument),
                 new UpdateOptions().upsert(true));
 
-        return AdrMetaBuilder.builder(adrMeta).id(id).build();
+        return new AdrMeta.AdrMetaBuilder(adrMeta).setId(id).build();
     }
 
     @Override
@@ -116,14 +114,14 @@ public AdrMeta getAdrRevision(AdrMeta adrMeta) throws NamespaceNotFoundException
         Document revisionsDoc = retrieveRevisionsDoc(adrDoc, adrMeta);
 
         // Return the ADR JSON blob for the specified revision
-        Document revisionDoc = (Document) revisionsDoc.get(String.valueOf(adrMeta.revision()));
-        log.info("RevisionDoc: [{}], Revision: [{}]", adrDoc.get("revisions"), adrMeta.revision());
+        Document revisionDoc = (Document) revisionsDoc.get(String.valueOf(adrMeta.getRevision()));
+        log.info("RevisionDoc: [{}], Revision: [{}]", adrDoc.get("revisions"), adrMeta.getRevision());
         if(revisionDoc == null) {
             throw new AdrRevisionNotFoundException();
         }
         try {
-            return AdrMetaBuilder.builder(adrMeta)
-                    .adrContent(objectMapper.readValue(revisionDoc.toJson(), Adr.class))
+            return new AdrMeta.AdrMetaBuilder(adrMeta)
+                    .setAdr(objectMapper.readValue(revisionDoc.toJson(), Adr.class))
                     .build();
         } catch(JsonProcessingException e) {
             log.error("Could not parse stored ADR to ADR Content.", e);
@@ -136,13 +134,13 @@ public AdrMeta updateAdrForNamespace(AdrMeta adrMeta) throws NamespaceNotFoundEx
         Document adrDoc = retrieveAdrDoc(adrMeta);
         AdrMeta latestRevision = retrieveLatestRevision(adrMeta, adrDoc);
 
-        int newRevision = latestRevision.revision() + 1;
-        AdrMeta newAdrMeta = AdrMetaBuilder.builder(adrMeta)
-                .adrContent(AdrBuilder.builder(adrMeta.adrContent())
-                        .status(latestRevision.adrContent().status())
-                        .creationDateTime(latestRevision.adrContent().creationDateTime())
+        int newRevision = latestRevision.getRevision() + 1;
+        AdrMeta newAdrMeta = new AdrMeta.AdrMetaBuilder(adrMeta)
+                .setAdr(new Adr.AdrBuilder(adrMeta.getAdr())
+                        .setStatus(latestRevision.getAdr().getStatus())
+                        .setCreationDateTime(latestRevision.getAdr().getCreationDateTime())
                         .build())
-                .revision(newRevision)
+                .setRevision(newRevision)
                 .build();
 
         writeAdrToMongo(newAdrMeta);
@@ -154,11 +152,11 @@ public AdrMeta updateAdrStatus(AdrMeta adrMeta, Status status) throws AdrNotFoun
         Document adrDoc = retrieveAdrDoc(adrMeta);
         AdrMeta latestRevision = retrieveLatestRevision(adrMeta, adrDoc);
 
-        int newRevisionNum = latestRevision.revision() + 1;
-        AdrMeta newRevision = AdrMetaBuilder.builder(latestRevision)
-                .revision(newRevisionNum)
-                .adrContent(AdrBuilder.builder(latestRevision.adrContent())
-                        .status(status)
+        int newRevisionNum = latestRevision.getRevision() + 1;
+        AdrMeta newRevision = new AdrMeta.AdrMetaBuilder(latestRevision)
+                .setRevision(newRevisionNum)
+                .setAdr(new Adr.AdrBuilder(latestRevision.getAdr())
+                        .setStatus(status)
                         .build())
                 .build();
         writeAdrToMongo(newRevision);
@@ -183,8 +181,8 @@ private List<Document> retrieveAdrsDocs(String namespace) throws NamespaceNotFou
     }
 
     private Document retrieveAdrDoc(AdrMeta adrMeta) throws NamespaceNotFoundException, AdrNotFoundException {
-        List<Document> adrsDoc = retrieveAdrsDocs(adrMeta.namespace());
-        Optional<Document> adrOpt = adrsDoc.stream().filter(adrDoc -> adrMeta.id() == adrDoc.getInteger("adrId")).findAny();
+        List<Document> adrsDoc = retrieveAdrsDocs(adrMeta.getNamespace());
+        Optional<Document> adrOpt = adrsDoc.stream().filter(adrDoc -> adrMeta.getId() == adrDoc.getInteger("adrId")).findAny();
         return adrOpt.orElseThrow(AdrNotFoundException::new);
     }
 
@@ -192,7 +190,7 @@ private Document retrieveRevisionsDoc(Document adrDoc, AdrMeta adrMeta) throws A
         Document revisionsDoc = (Document) adrDoc.get("revisions");
 
         if(revisionsDoc == null || revisionsDoc.isEmpty()) {
-            log.error("Could not find the latest revision of ADR [{}]", adrMeta.id());
+            log.error("Could not find the latest revision of ADR [{}]", adrMeta.getId());
             throw new AdrRevisionNotFoundException();
         }
 
@@ -213,11 +211,11 @@ private AdrMeta retrieveLatestRevision(AdrMeta adrMeta, Document adrDoc) throws
         Document revisionDoc = (Document) revisionsDoc.get(String.valueOf(latestRevision));
         log.info("RevisionDoc: [{}], Revision: [{}]", revisionDoc, latestRevision);
         try {
-            return AdrMetaBuilder.builder()
-                    .namespace(adrMeta.namespace())
-                    .id(adrMeta.id())
-                    .revision(latestRevision)
-                    .adrContent(objectMapper.readValue(revisionDoc.toJson(), Adr.class))
+            return new AdrMeta.AdrMetaBuilder()
+                    .setNamespace(adrMeta.getNamespace())
+                    .setId(adrMeta.getId())
+                    .setRevision(latestRevision)
+                    .setAdr(objectMapper.readValue(revisionDoc.toJson(), Adr.class))
                     .build();
         } catch(JsonProcessingException e) {
             log.error("Could not parse stored ADR to ADR Content.", e);
@@ -228,11 +226,11 @@ private AdrMeta retrieveLatestRevision(AdrMeta adrMeta, Document adrDoc) throws
     private void writeAdrToMongo(AdrMeta adrMeta) throws AdrPersistenceException, AdrParseException {
 
         try {
-            Document adrDocument = Document.parse(objectMapper.writeValueAsString(adrMeta.adrContent()));
-            Document filter = new Document("namespace", adrMeta.namespace())
-                    .append("adrs.adrId", adrMeta.id());
+            Document adrDocument = Document.parse(objectMapper.writeValueAsString(adrMeta.getAdr()));
+            Document filter = new Document("namespace", adrMeta.getNamespace())
+                    .append("adrs.adrId", adrMeta.getId());
             Document update = new Document("$set",
-                    new Document("adrs.$.revisions." + adrMeta.revision(), adrDocument));
+                    new Document("adrs.$.revisions." + adrMeta.getRevision(), adrDocument));
 
             adrCollection.updateOne(filter, update, new UpdateOptions().upsert(true));
 
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
index d34b60ff1..1db044170 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
@@ -3,9 +3,8 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import io.quarkus.test.InjectMock;
 import io.quarkus.test.junit.QuarkusTest;
+import org.finos.calm.domain.adr.Adr;
 import org.finos.calm.domain.adr.AdrMeta;
-import org.finos.calm.domain.adr.AdrMetaBuilder;
-import org.finos.calm.domain.adr.AdrBuilder;
 import org.finos.calm.domain.adr.Status;
 import org.finos.calm.domain.exception.AdrNotFoundException;
 import org.finos.calm.domain.exception.AdrParseException;
@@ -85,18 +84,18 @@ void respond_correctly_when_creating_adr(String namespace, Throwable exceptionTo
         if (exceptionToThrow != null) {
             when(mockAdrStore.createAdrForNamespace(any(AdrMeta.class))).thenThrow(exceptionToThrow);
         } else {
-            AdrMeta adrMeta = AdrMetaBuilder.builder()
-                    .adrContent(
-                            AdrBuilder.builder()
-                                    .title("My ADR")
-                                    .status(Status.draft)
-                                    .creationDateTime(LocalDateTime.now())
-                                    .updateDateTime(LocalDateTime.now())
+            AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                    .setAdr(
+                            new Adr.AdrBuilder()
+                                    .setTitle("My ADR")
+                                    .setStatus(Status.draft)
+                                    .setCreationDateTime(LocalDateTime.now())
+                                    .setUpdateDateTime(LocalDateTime.now())
                                     .build()
                     )
-                    .id(12)
-                    .revision(1)
-                    .namespace(namespace)
+                    .setId(12)
+                    .setRevision(1)
+                    .setNamespace(namespace)
                     .build();
             when(mockAdrStore.createAdrForNamespace(any(AdrMeta.class))).thenReturn(adrMeta);
         }
@@ -112,14 +111,14 @@ void respond_correctly_when_creating_adr(String namespace, Throwable exceptionTo
                 .statusCode(expectedStatusCode)
                 .header("Location", locationHeader);
 
-        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
-                .adrContent(
-                        AdrBuilder.builder()
-                                .title("My ADR")
-                                .status(Status.draft)
+        AdrMeta expectedAdrMeta = new AdrMeta.AdrMetaBuilder()
+                .setAdr(
+                        new Adr.AdrBuilder()
+                                .setTitle("My ADR")
+                                .setStatus(Status.draft)
                                 .build())
-                .revision(1)
-                .namespace(namespace)
+                .setRevision(1)
+                .setNamespace(namespace)
                 .build();
 
         verify(mockAdrStore, times(1)).createAdrForNamespace(expectedAdrMeta);
@@ -145,18 +144,18 @@ void respond_correctly_to_update_adr(String namespace, Throwable exceptionToThro
         if (exceptionToThrow != null) {
             when(mockAdrStore.updateAdrForNamespace(any(AdrMeta.class))).thenThrow(exceptionToThrow);
         } else {
-            AdrMeta adrMeta = AdrMetaBuilder.builder()
-                    .adrContent(
-                            AdrBuilder.builder()
-                                    .title("My ADR")
-                                    .status(Status.draft)
-                                    .creationDateTime(LocalDateTime.now())
-                                    .updateDateTime(LocalDateTime.now())
+            AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                    .setAdr(
+                            new Adr.AdrBuilder()
+                                    .setTitle("My ADR")
+                                    .setStatus(Status.draft)
+                                    .setCreationDateTime(LocalDateTime.now())
+                                    .setUpdateDateTime(LocalDateTime.now())
                                     .build()
                     )
-                    .id(1)
-                    .revision(2)
-                    .namespace(namespace)
+                    .setId(1)
+                    .setRevision(2)
+                    .setNamespace(namespace)
                     .build();
             when(mockAdrStore.updateAdrForNamespace(any(AdrMeta.class))).thenReturn(adrMeta);
         }
@@ -169,13 +168,13 @@ void respond_correctly_to_update_adr(String namespace, Throwable exceptionToThro
                 .then()
                 .statusCode(expectedStatusCode);
 
-        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
-                .adrContent(
-                        AdrBuilder.builder()
-                                .title("My ADR")
+        AdrMeta expectedAdrMeta = new AdrMeta.AdrMetaBuilder()
+                .setAdr(
+                        new Adr.AdrBuilder()
+                                .setTitle("My ADR")
                                 .build())
-                .id(1)
-                .namespace(namespace)
+                .setId(1)
+                .setNamespace(namespace)
                 .build();
 
         verify(mockAdrStore, times(1)).updateAdrForNamespace(expectedAdrMeta);
@@ -220,9 +219,9 @@ void respond_correctly_to_get_adr_revisions_query(String namespace, Throwable ex
     }
 
     private void verifyExpectedAdrRevisions(String namespace) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException {
-        AdrMeta expectedAdrToRetrieveMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(12)
+        AdrMeta expectedAdrToRetrieveMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(12)
                 .build();
 
         verify(mockAdrStore, times(1)).getAdrRevisions(expectedAdrToRetrieveMeta);
@@ -242,11 +241,11 @@ static Stream<Arguments> provideParametersForGetAdrRevisionTests() {
     @ParameterizedTest
     @MethodSource("provideParametersForGetAdrRevisionTests")
     void respond_correctly_to_get_adr_revision(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException {
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(12)
-                .revision(1)
-                .adrContent(AdrBuilder.builder().title("My title").build())
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(12)
+                .setRevision(1)
+                .setAdr(new Adr.AdrBuilder().setTitle("My title").build())
                 .build();
 
         if (exceptionToThrow != null) {
@@ -280,11 +279,11 @@ void respond_correctly_to_get_adr_revision(String namespace, Throwable exception
     @ParameterizedTest
     @MethodSource("provideParametersForGetAdrRevisionTests")
     void respond_correctly_to_get_adr(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrParseException {
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(12)
-                .revision(2)
-                .adrContent(AdrBuilder.builder().title("My title").build())
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(12)
+                .setRevision(2)
+                .setAdr(new Adr.AdrBuilder().setTitle("My title").build())
                 .build();
 
         if (exceptionToThrow != null) {
@@ -334,18 +333,18 @@ void respond_correctly_on_update_adr_status(String namespace, Throwable exceptio
         if (exceptionToThrow != null) {
             when(mockAdrStore.updateAdrStatus(any(AdrMeta.class), any(Status.class))).thenThrow(exceptionToThrow);
         } else {
-            AdrMeta adrMeta = AdrMetaBuilder.builder()
-                    .adrContent(
-                            AdrBuilder.builder()
-                                    .title("My ADR")
-                                    .status(Status.proposed)
-                                    .creationDateTime(LocalDateTime.now())
-                                    .updateDateTime(LocalDateTime.now())
+            AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                    .setAdr(
+                            new Adr.AdrBuilder()
+                                    .setTitle("My ADR")
+                                    .setStatus(Status.proposed)
+                                    .setCreationDateTime(LocalDateTime.now())
+                                    .setUpdateDateTime(LocalDateTime.now())
                                     .build()
                     )
-                    .id(1)
-                    .revision(2)
-                    .namespace(namespace)
+                    .setId(1)
+                    .setRevision(2)
+                    .setNamespace(namespace)
                     .build();
             when(mockAdrStore.updateAdrStatus(any(AdrMeta.class), any(Status.class))).thenReturn(adrMeta);
         }
@@ -358,28 +357,28 @@ void respond_correctly_on_update_adr_status(String namespace, Throwable exceptio
                 .then()
                 .statusCode(expectedStatusCode);
 
-        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
-                .id(1)
-                .namespace(namespace)
+        AdrMeta expectedAdrMeta = new AdrMeta.AdrMetaBuilder()
+                .setId(1)
+                .setNamespace(namespace)
                 .build();
 
         verify(mockAdrStore, times(1)).updateAdrStatus(expectedAdrMeta, Status.proposed);
     }
 
     private void verifyExpectedGetAdrRevision(String namespace) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException {
-        AdrMeta expectedAdrToRetrieveMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(12)
-                .revision(1)
+        AdrMeta expectedAdrToRetrieveMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(12)
+                .setRevision(1)
                 .build();
 
         verify(mockAdrStore, times(1)).getAdrRevision(expectedAdrToRetrieveMeta);
     }
 
     private void verifyExpectedGetAdr(String namespace) throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrParseException {
-        AdrMeta expectedAdrToRetrieveMeta = AdrMetaBuilder.builder()
-                .namespace(namespace)
-                .id(12)
+        AdrMeta expectedAdrToRetrieveMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(namespace)
+                .setId(12)
                 .build();
 
         verify(mockAdrStore, times(1)).getAdr(expectedAdrToRetrieveMeta);
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
index 0bf2a43d5..92532c623 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
@@ -19,9 +19,8 @@
 import org.bson.BsonDocument;
 import org.bson.Document;
 import org.bson.conversions.Bson;
+import org.finos.calm.domain.adr.Adr;
 import org.finos.calm.domain.adr.AdrMeta;
-import org.finos.calm.domain.adr.AdrMetaBuilder;
-import org.finos.calm.domain.adr.AdrBuilder;
 import org.finos.calm.domain.adr.Status;
 import org.finos.calm.domain.exception.AdrNotFoundException;
 import org.finos.calm.domain.exception.AdrParseException;
@@ -69,15 +68,15 @@ public class TestMongoAdrStoreShould {
     private MongoCollection<Document> adrCollection;
     private MongoAdrStore mongoAdrStore;
     private final String NAMESPACE = "finos";
-    private final AdrMeta simpleAdrMeta = AdrMetaBuilder.builder()
-            .namespace(NAMESPACE)
-            .id(42)
-            .revision(2)
-            .adrContent(AdrBuilder.builder()
-                    .title("My ADR")
-                    .status(Status.superseded)
-                    .creationDateTime(LocalDateTime.now())
-                    .updateDateTime(LocalDateTime.now())
+    private final AdrMeta simpleAdrMeta = new AdrMeta.AdrMetaBuilder()
+            .setNamespace(NAMESPACE)
+            .setId(42)
+            .setRevision(2)
+            .setAdr(new Adr.AdrBuilder()
+                    .setTitle("My ADR")
+                    .setStatus(Status.superseded)
+                    .setCreationDateTime(LocalDateTime.now())
+                    .setUpdateDateTime(LocalDateTime.now())
                     .build())
             .build();
 
@@ -157,7 +156,7 @@ void get_adrs_for_namespace_returns_values() throws NamespaceNotFoundException {
     void return_a_namespace_exception_when_namespace_does_not_exist_when_creating_an_adr() {
         when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
         String namespace = "does-not-exist";
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(namespace).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(namespace).build();
 
         assertThrows(NamespaceNotFoundException.class,
                 () -> mongoAdrStore.createAdrForNamespace(adrMeta));
@@ -170,24 +169,24 @@ void return_created_adr_when_parameters_are_valid() throws NamespaceNotFoundExce
         int sequenceNumber = 42;
         when(namespaceStore.namespaceExists(anyString())).thenReturn(true);
         when(counterStore.getNextAdrSequenceValue()).thenReturn(sequenceNumber);
-        AdrMeta adrMetaToCreate = AdrMetaBuilder.builder()
-                .adrContent(AdrBuilder.builder().build())
-                .namespace(validNamespace)
-                .revision(1)
+        AdrMeta adrMetaToCreate = new AdrMeta.AdrMetaBuilder()
+                .setAdr(new Adr.AdrBuilder().build())
+                .setNamespace(validNamespace)
+                .setRevision(1)
                 .build();
 
         AdrMeta adrMeta = mongoAdrStore.createAdrForNamespace(adrMetaToCreate);
 
-        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder()
-                .adrContent(AdrBuilder.builder().build())
-                .namespace(validNamespace)
-                .revision(1)
-                .id(sequenceNumber)
+        AdrMeta expectedAdrMeta = new AdrMeta.AdrMetaBuilder()
+                .setAdr(new Adr.AdrBuilder().build())
+                .setNamespace(validNamespace)
+                .setRevision(1)
+                .setId(sequenceNumber)
                 .build();
 
         assertThat(adrMeta, is(expectedAdrMeta));
-        Document expectedDoc = new Document("adrId", adrMeta.id()).append("revisions",
-                new Document("1", Document.parse(objectMapper.writeValueAsString(adrMeta.adrContent()))));
+        Document expectedDoc = new Document("adrId", adrMeta.getId()).append("revisions",
+                new Document("1", Document.parse(objectMapper.writeValueAsString(adrMeta.getAdr()))));
 
         verify(adrCollection).updateOne(
                 eq(Filters.eq("namespace", validNamespace)),
@@ -198,12 +197,12 @@ void return_created_adr_when_parameters_are_valid() throws NamespaceNotFoundExce
     @Test
     void get_adr_revisions_for_invalid_namespace_throws_exception() {
         when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace("does-not-exist").build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace("does-not-exist").build();
 
         assertThrows(NamespaceNotFoundException.class,
                 () -> mongoAdrStore.getAdrRevisions(adrMeta));
 
-        verify(namespaceStore).namespaceExists(adrMeta.namespace());
+        verify(namespaceStore).namespaceExists(adrMeta.getNamespace());
     }
 
     private FindIterable<Document> setupInvalidAdr() {
@@ -221,12 +220,12 @@ private FindIterable<Document> setupInvalidAdr() {
     @Test
     void get_adr_revisions_for_invalid_adr_throws_exception() {
         FindIterable<Document> findIterable = setupInvalidAdr();
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE).build();
 
         assertThrows(AdrNotFoundException.class,
                 () -> mongoAdrStore.getAdrRevisions(adrMeta));
 
-        verify(adrCollection).find(new Document("namespace", adrMeta.namespace()));
+        verify(adrCollection).find(new Document("namespace", adrMeta.getNamespace()));
         verify(findIterable).projection(Projections.fields(Projections.include("adrs")));
     }
 
@@ -234,7 +233,7 @@ void get_adr_revisions_for_invalid_adr_throws_exception() {
     void get_adr_revisions_for_valid_adr_returns_list_of_revisions() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException {
         mockSetupAdrDocumentWithRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).id(42).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE).setId(42).build();
         List<Integer> adrRevisions = mongoAdrStore.getAdrRevisions(adrMeta);
 
         assertThat(adrRevisions, is(List.of(1)));
@@ -243,23 +242,23 @@ void get_adr_revisions_for_valid_adr_returns_list_of_revisions() throws Namespac
     @Test
     void get_adr_revision_for_invalid_namespace_throws_exception() {
         when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace("does-not-exist").build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace("does-not-exist").build();
 
         assertThrows(NamespaceNotFoundException.class,
                 () -> mongoAdrStore.getAdrRevision(adrMeta));
 
-        verify(namespaceStore).namespaceExists(adrMeta.namespace());
+        verify(namespaceStore).namespaceExists(adrMeta.getNamespace());
     }
 
     @Test
     void throw_an_exception_for_an_invalid_adr_when_retrieving_adr_revision() {
         FindIterable<Document> findIterable = setupInvalidAdr();
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE).build();
 
         assertThrows(AdrNotFoundException.class,
                 () -> mongoAdrStore.getAdrRevision(adrMeta));
 
-        verify(adrCollection).find(new Document("namespace", adrMeta.namespace()));
+        verify(adrCollection).find(new Document("namespace", adrMeta.getNamespace()));
         verify(findIterable).projection(Projections.fields(Projections.include("adrs")));
     }
 
@@ -267,11 +266,11 @@ void throw_an_exception_for_an_invalid_adr_when_retrieving_adr_revision() {
     void return_an_adr_revision() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, AdrParseException, JsonProcessingException {
         mockSetupAdrDocumentWithRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
-                .id(42).revision(1).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE)
+                .setId(42).setRevision(1).build();
 
         AdrMeta adrMetaRevision = mongoAdrStore.getAdrRevision(adrMeta);
-        AdrMeta expectedAdrRevisionMeta = AdrMetaBuilder.builder(simpleAdrMeta).revision(1).build();
+        AdrMeta expectedAdrRevisionMeta = new AdrMeta.AdrMetaBuilder(simpleAdrMeta).setRevision(1).build();
         assertEquals(expectedAdrRevisionMeta, adrMetaRevision);
     }
 
@@ -288,7 +287,7 @@ private void mockSetupAdrDocumentWithRevisions() throws JsonProcessingException
     private Document setupAdrRevisionDocument() throws JsonProcessingException {
         //Set up an ADR document with 2 ADRs in (one with a valid revision)
         Map<String, Document> revisionMap = new HashMap<>();
-        revisionMap.put("1", Document.parse(objectMapper.writeValueAsString(simpleAdrMeta.adrContent())));
+        revisionMap.put("1", Document.parse(objectMapper.writeValueAsString(simpleAdrMeta.getAdr())));
         Document targetStoredAdr = new Document("adrId", 42)
                 .append("revisions", new Document(revisionMap));
 
@@ -302,8 +301,8 @@ private Document setupAdrRevisionDocument() throws JsonProcessingException {
     void throw_an_exception_when_revision_of_adr_does_not_exist() throws JsonProcessingException {
         mockSetupAdrDocumentWithRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
-                .id(42).revision(9).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE)
+                .setId(42).setRevision(9).build();
 
         assertThrows(AdrRevisionNotFoundException.class,
                 () -> mongoAdrStore.getAdrRevision(adrMeta));
@@ -313,8 +312,8 @@ void throw_an_exception_when_revision_of_adr_does_not_exist() throws JsonProcess
     void throw_an_exception_when_no_revision_exists_when_getting_adr()  {
         mockSetupAdrDocumentWithNoRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
-                .id(42).revision(1).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE)
+                .setId(42).setRevision(1).build();
 
         assertThrows(AdrRevisionNotFoundException.class,
                 () -> mongoAdrStore.getAdr(adrMeta));
@@ -342,35 +341,35 @@ private void mockSetupAdrDocumentWithNoRevisions() {
     @Test
     void throw_an_exception_for_an_invalid_adr_when_retrieving_adr() {
         FindIterable<Document> findIterable = setupInvalidAdr();
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE).id(7).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE).setId(7).build();
 
         assertThrows(AdrNotFoundException.class,
                 () -> mongoAdrStore.getAdr(adrMeta));
 
-        verify(adrCollection).find(new Document("namespace", adrMeta.namespace()));
+        verify(adrCollection).find(new Document("namespace", adrMeta.getNamespace()));
         verify(findIterable).projection(Projections.fields(Projections.include("adrs")));
     }
 
     @Test
     void get_adr_for_invalid_namespace_throws_exception() {
         when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace("does-not-exist").build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace("does-not-exist").build();
 
         assertThrows(NamespaceNotFoundException.class,
                 () -> mongoAdrStore.getAdr(adrMeta));
 
-        verify(namespaceStore).namespaceExists(adrMeta.namespace());
+        verify(namespaceStore).namespaceExists(adrMeta.getNamespace());
     }
 
     @Test
     void return_the_latest_adr_revision() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrParseException {
         mockSetupAdrDocumentWithRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder().namespace(NAMESPACE)
-                .id(42).build();
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder().setNamespace(NAMESPACE)
+                .setId(42).build();
 
         AdrMeta latestAdrMeta = mongoAdrStore.getAdr(adrMeta);
-        AdrMeta expectedAdrMeta = AdrMetaBuilder.builder(simpleAdrMeta).revision(1).build();
+        AdrMeta expectedAdrMeta = new AdrMeta.AdrMetaBuilder(simpleAdrMeta).setRevision(1).build();
         assertEquals(expectedAdrMeta, latestAdrMeta);
     }
 
@@ -378,24 +377,24 @@ void return_the_latest_adr_revision() throws NamespaceNotFoundException, AdrNotF
     void throw_an_exception_when_update_adr_with_a_namespace_that_doesnt_exists() {
         when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
                 .build();
 
         assertThrows(NamespaceNotFoundException.class,
                 () -> mongoAdrStore.updateAdrForNamespace(adrMeta));
 
-        verify(namespaceStore, times(1)).namespaceExists(adrMeta.namespace());
+        verify(namespaceStore, times(1)).namespaceExists(adrMeta.getNamespace());
     }
 
     @Test
     void throw_an_exception_when_updating_an_adr_that_doesnt_exist() throws JsonProcessingException {
         mockSetupAdrDocumentWithRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(22)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(22)
                 .build();
 
         assertThrows(AdrNotFoundException.class,
@@ -406,10 +405,10 @@ void throw_an_exception_when_updating_an_adr_that_doesnt_exist() throws JsonProc
     void throw_an_exception_when_updating_an_adr_but_no_revisions_exist() {
         mockSetupAdrDocumentWithNoRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
-                .adrContent(AdrBuilder.builder().build())
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
+                .setAdr(new Adr.AdrBuilder().build())
                 .build();
 
         assertThrows(AdrRevisionNotFoundException.class,
@@ -422,10 +421,10 @@ void throw_an_exception_when_updating_an_adr_but_mongo_cannot_write_update() thr
         when(adrCollection.updateOne(any(Bson.class), any(Bson.class), any(UpdateOptions.class)))
                 .thenThrow(new MongoWriteException(new WriteError(1, "error", new BsonDocument()), new ServerAddress(), List.of()));
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
-                .adrContent(AdrBuilder.builder().build())
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
+                .setAdr(new Adr.AdrBuilder().build())
                 .build();
 
         assertThrows(AdrPersistenceException.class,
@@ -435,11 +434,11 @@ void throw_an_exception_when_updating_an_adr_but_mongo_cannot_write_update() thr
     @Test
     void return_successfully_when_correctly_updating_an_adr() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrPersistenceException, AdrParseException {
         mockSetupAdrDocumentWithRevisions();
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
-                .revision(2)
-                .adrContent(AdrBuilder.builder().build())
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
+                .setRevision(2)
+                .setAdr(new Adr.AdrBuilder().build())
                 .build();
 
         mongoAdrStore.updateAdrForNamespace(adrMeta);
@@ -451,24 +450,24 @@ void return_successfully_when_correctly_updating_an_adr() throws NamespaceNotFou
     void throw_an_exception_when_updating_status_with_a_namespace_that_doesnt_exists() {
         when(namespaceStore.namespaceExists(anyString())).thenReturn(false);
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
                 .build();
 
         assertThrows(NamespaceNotFoundException.class,
                 () -> mongoAdrStore.updateAdrStatus(adrMeta, Status.accepted));
 
-        verify(namespaceStore, times(1)).namespaceExists(adrMeta.namespace());
+        verify(namespaceStore, times(1)).namespaceExists(adrMeta.getNamespace());
     }
 
     @Test
     void throw_an_exception_when_updating_the_status_of_an_adr_that_doesnt_exist() throws JsonProcessingException {
         mockSetupAdrDocumentWithRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(22)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(22)
                 .build();
 
         assertThrows(AdrNotFoundException.class,
@@ -479,9 +478,9 @@ void throw_an_exception_when_updating_the_status_of_an_adr_that_doesnt_exist() t
     void throw_an_exception_when_updating_the_status_of_an_adr_but_no_revisions_exist() {
         mockSetupAdrDocumentWithNoRevisions();
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
                 .build();
 
         assertThrows(AdrRevisionNotFoundException.class,
@@ -494,9 +493,9 @@ void throw_an_exception_when_updating_the_status_of_an_adr_but_mongo_cannot_writ
         when(adrCollection.updateOne(any(Bson.class), any(Bson.class), any(UpdateOptions.class)))
                 .thenThrow(new MongoWriteException(new WriteError(1, "error", new BsonDocument()), new ServerAddress(), List.of()));
 
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
                 .build();
 
         assertThrows(AdrPersistenceException.class,
@@ -506,9 +505,9 @@ void throw_an_exception_when_updating_the_status_of_an_adr_but_mongo_cannot_writ
     @Test
     void return_successfully_when_correctly_updating_the_status_of_an_adr() throws NamespaceNotFoundException, AdrNotFoundException, AdrRevisionNotFoundException, JsonProcessingException, AdrPersistenceException, AdrParseException {
         mockSetupAdrDocumentWithRevisions();
-        AdrMeta adrMeta = AdrMetaBuilder.builder()
-                .namespace(NAMESPACE)
-                .id(42)
+        AdrMeta adrMeta = new AdrMeta.AdrMetaBuilder()
+                .setNamespace(NAMESPACE)
+                .setId(42)
                 .build();
 
         mongoAdrStore.updateAdrStatus(adrMeta, Status.accepted);