diff --git a/libpldmresponder/meson.build b/libpldmresponder/meson.build
index e4e6a87..ab3aeb4 100644
--- a/libpldmresponder/meson.build
+++ b/libpldmresponder/meson.build
@@ -10,6 +10,7 @@
   'bios.cpp',
   'bios_table.cpp',
   'bios_parser.cpp',
+  'pdr_utils.cpp',
   'pdr.cpp',
   'effecters.cpp',
   'platform.cpp',
diff --git a/libpldmresponder/pdr.cpp b/libpldmresponder/pdr.cpp
index e252cb3..d2c8214 100644
--- a/libpldmresponder/pdr.cpp
+++ b/libpldmresponder/pdr.cpp
@@ -8,11 +8,145 @@
 
 namespace pdr
 {
+using namespace pldm::responder::pdr_utils;
 
-Repo& get(const std::string& dir)
+void generate(const std::string& dir, RepoInterface& repo)
 {
-    using namespace internal;
-    static IndexedRepo repo;
+    // A map of PDR type to a lambda that handles creation of that PDR type.
+    // The lambda essentially would parse the platform specific PDR JSONs to
+    // generate the PDR structures. This function iterates through the map to
+    // invoke all lambdas, so that all PDR types can be created.
+    std::map<Type, std::function<void(const Json& json, RepoInterface& repo)>>
+        generators = {
+            {PLDM_STATE_EFFECTER_PDR,
+             [](const auto& json, RepoInterface& repo) {
+                 static const std::vector<Json> emptyList{};
+                 static const Json empty{};
+                 auto entries = json.value("entries", emptyList);
+                 for (const auto& e : entries)
+                 {
+                     size_t pdrSize = 0;
+                     auto effecters = e.value("effecters", emptyList);
+                     static const Json empty{};
+                     for (const auto& effecter : effecters)
+                     {
+                         auto set = effecter.value("set", empty);
+                         auto statesSize = set.value("size", 0);
+                         if (!statesSize)
+                         {
+                             std::cerr << "Malformed PDR JSON return "
+                                          "pdrEntry;- no state set "
+                                          "info, TYPE="
+                                       << PLDM_STATE_EFFECTER_PDR << "\n";
+                             throw InternalFailure();
+                         }
+                         pdrSize += sizeof(state_effecter_possible_states) -
+                                    sizeof(bitfield8_t) +
+                                    (sizeof(bitfield8_t) * statesSize);
+                     }
+                     pdrSize +=
+                         sizeof(pldm_state_effecter_pdr) - sizeof(uint8_t);
+
+                     std::vector<uint8_t> entry{};
+                     entry.resize(pdrSize);
+
+                     pldm_state_effecter_pdr* pdr =
+                         reinterpret_cast<pldm_state_effecter_pdr*>(
+                             entry.data());
+                     pdr->hdr.record_handle = 0;
+                     pdr->hdr.version = 1;
+                     pdr->hdr.type = PLDM_STATE_EFFECTER_PDR;
+                     pdr->hdr.record_change_num = 0;
+                     pdr->hdr.length = pdrSize - sizeof(pldm_pdr_hdr);
+
+                     pdr->terminus_handle = 0;
+                     pdr->effecter_id = effecter::nextId();
+                     pdr->entity_type = e.value("type", 0);
+                     pdr->entity_instance = e.value("instance", 0);
+                     pdr->container_id = e.value("container", 0);
+                     pdr->effecter_semantic_id = 0;
+                     pdr->effecter_init = PLDM_NO_INIT;
+                     pdr->has_description_pdr = false;
+                     pdr->composite_effecter_count = effecters.size();
+
+                     using namespace effecter::dbus_mapping;
+                     Paths paths{};
+                     uint8_t* start = entry.data() +
+                                      sizeof(pldm_state_effecter_pdr) -
+                                      sizeof(uint8_t);
+                     for (const auto& effecter : effecters)
+                     {
+                         auto set = effecter.value("set", empty);
+                         state_effecter_possible_states* possibleStates =
+                             reinterpret_cast<state_effecter_possible_states*>(
+                                 start);
+                         possibleStates->state_set_id = set.value("id", 0);
+                         possibleStates->possible_states_size =
+                             set.value("size", 0);
+
+                         start += sizeof(possibleStates->state_set_id) +
+                                  sizeof(possibleStates->possible_states_size);
+                         static const std::vector<uint8_t> emptyStates{};
+                         auto states = set.value("states", emptyStates);
+                         for (const auto& state : states)
+                         {
+                             auto index = state / 8;
+                             auto bit = state - (index * 8);
+                             bitfield8_t* bf =
+                                 reinterpret_cast<bitfield8_t*>(start + index);
+                             bf->byte |= 1 << bit;
+                         }
+                         start += possibleStates->possible_states_size;
+
+                         auto dbus = effecter.value("dbus", empty);
+                         paths.emplace_back(std::move(dbus));
+                     }
+                     add(pdr->effecter_id, std::move(paths));
+                     PdrEntry pdrEntry{};
+                     pdrEntry.data = entry.data();
+                     pdrEntry.size = pdrSize;
+                     repo.addRecord(pdrEntry);
+                 }
+             }}};
+
+    Type pdrType{};
+    for (const auto& dirEntry : fs::directory_iterator(dir))
+    {
+        try
+        {
+            auto json = readJson(dirEntry.path().string());
+            if (!json.empty())
+            {
+                pdrType = json.value("pdrType", 0);
+                generators.at(pdrType)(json, repo);
+            }
+        }
+        catch (const InternalFailure& e)
+        {
+            std::cerr << "PDR config directory does not exist or empty, TYPE= "
+                      << pdrType << "PATH= " << dirEntry
+                      << " ERROR=" << e.what() << "\n";
+        }
+        catch (const Json::exception& e)
+        {
+            std::cerr << "Failed parsing PDR JSON file, TYPE= " << pdrType
+                      << "PATH= " << dirEntry << " ERROR=" << e.what() << "\n";
+            pldm::utils::reportError(
+                "xyz.openbmc_project.bmc.pldm.InternalFailure");
+        }
+        catch (const std::exception& e)
+        {
+            std::cerr << "Failed parsing PDR JSON file, TYPE= " << pdrType
+                      << " ERROR=" << e.what() << "\n";
+            pldm::utils::reportError(
+                "xyz.openbmc_project.bmc.pldm.InternalFailure");
+        }
+    }
+}
+
+RepoInterface& getRepo(const std::string& dir)
+{
+    static Repo repo;
     if (repo.empty())
     {
         generate(dir, repo);
@@ -21,6 +155,48 @@
     return repo;
 }
 
+Repo getRepoByType(const std::string& dir, Type pdrType)
+{
+    Repo pdrRepo;
+    RepoInterface& repo = getRepo(dir);
+
+    uint8_t* pdrData = nullptr;
+    uint32_t pdrSize{};
+    auto record = pldm_pdr_find_record_by_type(repo.getPdr(), pdrType, NULL,
+                                               &pdrData, &pdrSize);
+    while (record)
+    {
+        PdrEntry pdrEntry{};
+        pdrEntry.data = pdrData;
+        pdrEntry.size = pdrSize;
+        pdrEntry.handle.recordHandle = repo.getRecordHandle(record);
+        pdrRepo.addRecord(pdrEntry);
+
+        pdrData = nullptr;
+        pdrSize = 0;
+        record = pldm_pdr_find_record_by_type(repo.getPdr(), pdrType, record,
+                                              &pdrData, &pdrSize);
+    }
+
+    return pdrRepo;
+}
+
+const pldm_pdr_record* getRecordByHandle(RepoInterface& pdrRepo,
+                                         RecordHandle recordHandle,
+                                         PdrEntry& pdrEntry)
+{
+    uint8_t* pdrData = nullptr;
+    auto record =
+        pldm_pdr_find_record(pdrRepo.getPdr(), recordHandle, &pdrData,
+                             &pdrEntry.size, &pdrEntry.handle.nextRecordHandle);
+    if (record)
+    {
+        pdrEntry.data = pdrData;
+    }
+
+    return record;
+}
+
 } // namespace pdr
 } // namespace responder
 } // namespace pldm
diff --git a/libpldmresponder/pdr.hpp b/libpldmresponder/pdr.hpp
index 9432f3e..0cf9385 100644
--- a/libpldmresponder/pdr.hpp
+++ b/libpldmresponder/pdr.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "effecters.hpp"
+#include "libpldmresponder/pdr_utils.hpp"
 #include "utils.hpp"
 
 #include <stdint.h>
@@ -15,12 +16,15 @@
 #include <vector>
 #include <xyz/openbmc_project/Common/error.hpp>
 
+#include "libpldm/pdr.h"
 #include "libpldm/platform.h"
 
 using InternalFailure =
     sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
 namespace fs = std::filesystem;
 
+using namespace pldm::responder::pdr_utils;
+
 namespace pldm
 {
 
@@ -29,294 +33,42 @@
 
 namespace pdr
 {
-
-using Type = uint8_t;
-using Json = nlohmann::json;
-using RecordHandle = uint32_t;
-using Entry = std::vector<uint8_t>;
-using Pdr = std::vector<Entry>;
-
-/** @class Repo
- *
- *  @brief Abstract class describing the interface API to the PDR repository
- *
- *  Concrete implementations of this must handle storing and addressing the
- *  PDR entries by a "record handle", which can be indices, offsets, etc.
- */
-class Repo
-{
-  public:
-    virtual ~Repo() = default;
-
-    /** @brief Add a new entry to the PDR
-     *
-     *  @param[in] entry - new PDR entry
-     */
-    virtual void add(Entry&& entry) = 0;
-
-    /** @brief Access PDR entry at inout record handle
-     *
-     *  @param[in] handle - record handle
-     *
-     *  @return Entry - PDR entry
-     */
-    virtual Entry at(RecordHandle handle) const = 0;
-
-    /** @brief Get next available record handle for assignment
-     *
-     *  @return RecordHandle - PDR record handle
-     */
-    virtual RecordHandle getNextRecordHandle() const = 0;
-
-    /** @brief Get record handle immediately suceeding the input record
-     *         handle
-     *
-     *  @param[in] current - input record handle
-     *
-     *  @return RecordHandle - PDR record handle
-     */
-    virtual RecordHandle getNextRecordHandle(RecordHandle current) const = 0;
-
-    /** @brief Get number of entries in the PDR
-     *
-     *  @return size_t - number of entries
-     */
-    virtual size_t numEntries() const = 0;
-
-    /** @brief Check if PDR is empty
-     *
-     *  @return bool - true if PDR is empty, false otherwise
-     */
-    virtual bool empty() const = 0;
-
-    /** @brief Empty the PDR
-     */
-    virtual void makeEmpty() = 0;
-};
-
-namespace internal
-{
-
-/** @brief Parse PDR JSON file and output Json object
- *
- *  @param[in] path - path of PDR JSON file
- *
- *  @return Json - Json object
- */
-inline Json readJson(const std::string& path)
-{
-    std::ifstream jsonFile(path);
-    if (!jsonFile.is_open())
-    {
-        std::cout << "Error opening PDR JSON file, PATH=" << path.c_str()
-                  << std::endl;
-        return {};
-    }
-
-    return Json::parse(jsonFile);
-}
-
-/** @class IndexedRepo
- *
- *  @brief Inherits and implements Repo
- *
- *  Stores the PDR as a vector of entries, and addresses PDR entries based on an
- *  incrementing record handle, starting at 1.
- */
-class IndexedRepo : public Repo
-{
-  public:
-    void add(Entry&& entry)
-    {
-        repo.emplace_back(std::move(entry));
-    }
-
-    Entry at(RecordHandle handle) const
-    {
-        if (!handle)
-        {
-            handle = 1;
-        }
-        return repo.at(handle - 1);
-    }
-
-    RecordHandle getNextRecordHandle() const
-    {
-        return repo.size() + 1;
-    }
-
-    RecordHandle getNextRecordHandle(RecordHandle current) const
-    {
-        if (current >= repo.size())
-        {
-            return 0;
-        }
-        if (!current)
-        {
-            current = 1;
-        }
-        return current + 1;
-    }
-
-    size_t numEntries() const
-    {
-        return repo.size();
-    }
-
-    bool empty() const
-    {
-        return repo.empty();
-    }
-
-    void makeEmpty()
-    {
-        repo.clear();
-    }
-
-  private:
-    Pdr repo{};
-};
-
 /** @brief Parse PDR JSONs and build PDR repository
  *
  *  @param[in] dir - directory housing platform specific PDR JSON files
- *  @tparam[in] repo - instance of concrete implementation of Repo
+ *  @param[in] repo - instance of the concrete implementation of RepoInterface
  */
-template <typename T>
-void generate(const std::string& dir, T& repo)
-{
-    using namespace internal;
-    // A map of PDR type to a lambda that handles creation of that PDR type.
-    // The lambda essentially would parse the platform specific PDR JSONs to
-    // generate the PDR structures. This function iterates through the map to
-    // invoke all lambdas, so that all PDR types can be created.
-    std::map<Type, std::function<void(const Json& json, T& repo)>> generators =
-        {{PLDM_STATE_EFFECTER_PDR, [](const auto& json, T& repo) {
-              static const std::vector<Json> emptyList{};
-              static const Json empty{};
-              auto entries = json.value("entries", emptyList);
-              for (const auto& e : entries)
-              {
-                  size_t pdrSize = 0;
-                  auto effecters = e.value("effecters", emptyList);
-                  static const Json empty{};
-                  for (const auto& effecter : effecters)
-                  {
-                      auto set = effecter.value("set", empty);
-                      auto statesSize = set.value("size", 0);
-                      if (!statesSize)
-                      {
-                          std::cerr
-                              << "Malformed PDR JSON - no state set info, TYPE="
-                              << PLDM_STATE_EFFECTER_PDR << "\n";
-                          throw InternalFailure();
-                      }
-                      pdrSize += sizeof(state_effecter_possible_states) -
-                                 sizeof(bitfield8_t) +
-                                 (sizeof(bitfield8_t) * statesSize);
-                  }
-                  pdrSize += sizeof(pldm_state_effecter_pdr) - sizeof(uint8_t);
-
-                  Entry pdrEntry{};
-                  pdrEntry.resize(pdrSize);
-
-                  pldm_state_effecter_pdr* pdr =
-                      reinterpret_cast<pldm_state_effecter_pdr*>(
-                          pdrEntry.data());
-                  pdr->hdr.record_handle = repo.getNextRecordHandle();
-                  pdr->hdr.version = 1;
-                  pdr->hdr.type = PLDM_STATE_EFFECTER_PDR;
-                  pdr->hdr.record_change_num = 0;
-                  pdr->hdr.length = pdrSize - sizeof(pldm_pdr_hdr);
-
-                  pdr->terminus_handle = 0;
-                  pdr->effecter_id = effecter::nextId();
-                  pdr->entity_type = e.value("type", 0);
-                  pdr->entity_instance = e.value("instance", 0);
-                  pdr->container_id = e.value("container", 0);
-                  pdr->effecter_semantic_id = 0;
-                  pdr->effecter_init = PLDM_NO_INIT;
-                  pdr->has_description_pdr = false;
-                  pdr->composite_effecter_count = effecters.size();
-
-                  using namespace effecter::dbus_mapping;
-                  Paths paths{};
-                  uint8_t* start = pdrEntry.data() +
-                                   sizeof(pldm_state_effecter_pdr) -
-                                   sizeof(uint8_t);
-                  for (const auto& effecter : effecters)
-                  {
-                      auto set = effecter.value("set", empty);
-                      state_effecter_possible_states* possibleStates =
-                          reinterpret_cast<state_effecter_possible_states*>(
-                              start);
-                      possibleStates->state_set_id = set.value("id", 0);
-                      possibleStates->possible_states_size =
-                          set.value("size", 0);
-
-                      start += sizeof(possibleStates->state_set_id) +
-                               sizeof(possibleStates->possible_states_size);
-                      static const std::vector<uint8_t> emptyStates{};
-                      auto states = set.value("states", emptyStates);
-                      for (const auto& state : states)
-                      {
-                          auto index = state / 8;
-                          auto bit = state - (index * 8);
-                          bitfield8_t* bf =
-                              reinterpret_cast<bitfield8_t*>(start + index);
-                          bf->byte |= 1 << bit;
-                      }
-                      start += possibleStates->possible_states_size;
-
-                      auto dbus = effecter.value("dbus", empty);
-                      paths.emplace_back(std::move(dbus));
-                  }
-                  add(pdr->effecter_id, std::move(paths));
-                  repo.add(std::move(pdrEntry));
-              }
-          }}};
-
-    Type pdrType{};
-    for (const auto& dirEntry : fs::directory_iterator(dir))
-    {
-        try
-        {
-            auto json = readJson(dirEntry.path().string());
-            if (!json.empty())
-            {
-                pdrType = json.value("pdrType", 0);
-                generators.at(pdrType)(json, repo);
-            }
-        }
-        catch (const InternalFailure& e)
-        {
-        }
-        catch (const Json::exception& e)
-        {
-            std::cerr << "Failed parsing PDR JSON file, TYPE= " << pdrType
-                      << " ERROR=" << e.what() << "\n";
-            pldm::utils::reportError(
-                "xyz.openbmc_project.bmc.pldm.InternalFailure");
-        }
-        catch (const std::exception& e)
-        {
-            std::cerr << "Failed parsing PDR JSON file, TYPE= " << pdrType
-                      << " ERROR=" << e.what() << "\n";
-            pldm::utils::reportError(
-                "xyz.openbmc_project.bmc.pldm.InternalFailure");
-        }
-    }
-}
-
-} // namespace internal
+void generate(const std::string& dir, RepoInterface& repo);
 
 /** @brief Build (if not built already) and retrieve PDR
  *
  *  @param[in] dir - directory housing platform specific PDR JSON files
  *
- *  @return Repo& - Reference to instance of pdr::Repo
+ *  @return RepoInterface& - Reference to instance of pdr::RepoInterface
  */
-Repo& get(const std::string& dir);
+RepoInterface& getRepo(const std::string& dir);
+
+/** @brief Build (if not built already) and retrieve PDR by the PDR types
+ *
+ *  @param[in] dir - directory housing platform specific PDR JSON files
+ *  @param[in] pdrType - the type of PDRs
+ *
+ *  @return Repo - Instance of pdr::Repo
+ */
+Repo getRepoByType(const std::string& dir, Type pdrType);
+
+/** @brief Get the record of PDR by the record handle
+ *
+ *  @param[in] pdrRepo - pdr::RepoInterface
+ *  @param[in] recordHandle - The recordHandle value for the PDR to be
+ * retrieved.
+ *  @param[out] pdrEntry - PDR entry structure reference
+ *
+ *  @return pldm_pdr_record - Instance of pdr::RepoInterface
+ */
+const pldm_pdr_record* getRecordByHandle(RepoInterface& pdrRepo,
+                                         RecordHandle recordHandle,
+                                         PdrEntry& pdrEntry);
 
 } // namespace pdr
 } // namespace responder
diff --git a/libpldmresponder/pdr_utils.cpp b/libpldmresponder/pdr_utils.cpp
new file mode 100644
index 0000000..850dbcb
--- /dev/null
+++ b/libpldmresponder/pdr_utils.cpp
@@ -0,0 +1,70 @@
+#include "pdr.hpp"
+
+namespace pldm
+{
+
+namespace responder
+{
+
+namespace pdr_utils
+{
+
+const pldm_pdr* Repo::getPdr()
+{
+    return repo;
+}
+
+RecordHandle Repo::addRecord(const PdrEntry& pdrEntry)
+{
+    return pldm_pdr_add(repo, pdrEntry.data, pdrEntry.size,
+                        pdrEntry.handle.recordHandle);
+}
+
+const pldm_pdr_record* Repo::getFirstRecord(PdrEntry& pdrEntry)
+{
+    constexpr uint32_t firstNum = 0;
+    uint8_t* pdrData = nullptr;
+    auto record =
+        pldm_pdr_find_record(getPdr(), firstNum, &pdrData, &pdrEntry.size,
+                             &pdrEntry.handle.nextRecordHandle);
+    if (record)
+    {
+        pdrEntry.data = pdrData;
+    }
+
+    return record;
+}
+
+const pldm_pdr_record* Repo::getNextRecord(const pldm_pdr_record* currRecord,
+                                           PdrEntry& pdrEntry)
+{
+    uint8_t* pdrData = nullptr;
+    auto record =
+        pldm_pdr_get_next_record(getPdr(), currRecord, &pdrData, &pdrEntry.size,
+                                 &pdrEntry.handle.nextRecordHandle);
+    if (record)
+    {
+        pdrEntry.data = pdrData;
+    }
+
+    return record;
+}
+
+uint32_t Repo::getRecordHandle(const pldm_pdr_record* record)
+{
+    return pldm_pdr_get_record_handle(getPdr(), record);
+}
+
+uint32_t Repo::getRecordCount()
+{
+    return pldm_pdr_get_record_count(getPdr());
+}
+
+bool Repo::empty()
+{
+    return !getRecordCount();
+}
+
+} // namespace pdr_utils
+} // namespace responder
+} // namespace pldm
diff --git a/libpldmresponder/pdr_utils.hpp b/libpldmresponder/pdr_utils.hpp
new file mode 100644
index 0000000..4c2af02
--- /dev/null
+++ b/libpldmresponder/pdr_utils.hpp
@@ -0,0 +1,180 @@
+#pragma once
+
+#include <stdint.h>
+
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <xyz/openbmc_project/Common/error.hpp>
+
+#include "libpldm/pdr.h"
+
+using InternalFailure =
+    sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
+
+namespace fs = std::filesystem;
+
+namespace pldm
+{
+
+namespace responder
+{
+
+namespace pdr_utils
+{
+
+/** @struct PdrEntry
+ *  PDR entry structure that acts as a PDR record structure in the PDR
+ *  repository to handle PDR APIs.
+ */
+struct PdrEntry
+{
+    uint8_t* data;
+    uint32_t size;
+    union
+    {
+        uint32_t recordHandle;
+        uint32_t nextRecordHandle;
+    } handle;
+};
+using Type = uint8_t;
+using Json = nlohmann::json;
+using RecordHandle = uint32_t;
+
+/** @brief Parse PDR JSON file and output Json object
+ *
+ *  @param[in] path - path of PDR JSON file
+ *
+ *  @return Json - Json object
+ */
+inline Json readJson(const std::string& path)
+{
+    fs::path dir(path);
+    if (!fs::exists(dir) || fs::is_empty(dir))
+    {
+        throw InternalFailure();
+    }
+
+    std::ifstream jsonFile(path);
+    if (!jsonFile.is_open())
+    {
+        std::cerr << "Error opening PDR JSON file, PATH=" << path << "\n";
+        return {};
+    }
+
+    return Json::parse(jsonFile);
+}
+
+/**
+ *  @class RepoInterface
+ *
+ *  @brief Abstract class describing the interface API to the PDR repository,
+ *         this class wraps operations used to handle the new PDR APIs.
+ */
+class RepoInterface
+{
+  public:
+    virtual ~RepoInterface() = default;
+
+    /** @brief Get an opaque pldm_pdr structure
+     *
+     *  @return pldm_pdr - pldm_pdr structure
+     */
+    virtual const pldm_pdr* getPdr() = 0;
+
+    /** @brief Add a PDR record to a PDR repository
+     *
+     *  @param[in] pdrEntry - PDR records entry(data, size, recordHandle)
+     *
+     *  @return uint32_t - record handle assigned to PDR record
+     */
+    virtual RecordHandle addRecord(const PdrEntry& pdrEntry) = 0;
+
+    /** @brief Get the first PDR record from a PDR repository
+     *
+     *  @param[in] pdrEntry - PDR records entry(data, size, nextRecordHandle)
+     *
+     *  @return opaque pointer acting as PDR record handle, will be NULL if
+     *          record was not found
+     */
+    virtual const pldm_pdr_record* getFirstRecord(PdrEntry& pdrEntry) = 0;
+
+    /** @brief Get the next PDR record from a PDR repository
+     *
+     *  @param[in] currRecord - opaque pointer acting as a PDR record handle
+     *  @param[in] pdrEntry - PDR records entry(data, size, nextRecordHandle)
+     *
+     *  @return opaque pointer acting as PDR record handle, will be NULL if
+     *          record was not found
+     */
+    virtual const pldm_pdr_record*
+        getNextRecord(const pldm_pdr_record* currRecord,
+                      PdrEntry& pdrEntry) = 0;
+
+    /** @brief Get record handle of a PDR record
+     *
+     *  @param[in] record - opaque pointer acting as a PDR record handle
+     *
+     *  @return uint32_t - record handle assigned to PDR record; 0 if record is
+     *                     not found
+     */
+    virtual uint32_t getRecordHandle(const pldm_pdr_record* record) = 0;
+
+    /** @brief Get number of records in a PDR repository
+     *
+     *  @return uint32_t - number of records
+     */
+    virtual uint32_t getRecordCount() = 0;
+
+    /** @brief Determine if records are empty in a PDR repository
+     *
+     *  @return bool - true means empty and false means not empty
+     */
+    virtual bool empty() = 0;
+
+  protected:
+    pldm_pdr* repo;
+};
+
+/**
+ *  @class Repo
+ *
+ *  Wrapper class to handle the PDR APIs
+ *
+ *  This class wraps operations used to handle PDR APIs.
+ */
+class Repo : public RepoInterface
+{
+  public:
+    Repo()
+    {
+        repo = pldm_pdr_init();
+    }
+
+    ~Repo()
+    {
+        pldm_pdr_destroy(repo);
+    }
+
+    const pldm_pdr* getPdr();
+
+    RecordHandle addRecord(const PdrEntry& pdrEntry);
+
+    const pldm_pdr_record* getFirstRecord(PdrEntry& pdrEntry);
+
+    const pldm_pdr_record* getNextRecord(const pldm_pdr_record* currRecord,
+                                         PdrEntry& pdrEntry);
+
+    uint32_t getRecordHandle(const pldm_pdr_record* record);
+
+    uint32_t getRecordCount();
+
+    bool empty();
+};
+
+} // namespace pdr_utils
+} // namespace responder
+} // namespace pldm
diff --git a/libpldmresponder/platform.cpp b/libpldmresponder/platform.cpp
index 3f93ff4..4d297f0 100644
--- a/libpldmresponder/platform.cpp
+++ b/libpldmresponder/platform.cpp
@@ -36,41 +36,40 @@
         return CmdHandler::ccOnlyResponse(request, rc);
     }
 
-    uint32_t nextRecordHandle{};
     uint16_t respSizeBytes{};
     uint8_t* recordData = nullptr;
     try
     {
-        pdr::Repo& pdrRepo = pdr::get(PDR_JSONS_DIR);
-        nextRecordHandle = pdrRepo.getNextRecordHandle(recordHandle);
-        pdr::Entry e;
+        pdr_utils::RepoInterface& pdrRepo = pdr::getRepo(PDR_JSONS_DIR);
+        pdr_utils::PdrEntry e;
+        auto record = pdr::getRecordByHandle(pdrRepo, recordHandle, e);
+        if (record == NULL)
+        {
+            return CmdHandler::ccOnlyResponse(
+                request, PLDM_PLATFORM_INVALID_RECORD_HANDLE);
+        }
+
         if (reqSizeBytes)
         {
-            e = pdrRepo.at(recordHandle);
-            respSizeBytes = e.size();
+            respSizeBytes = e.size;
             if (respSizeBytes > reqSizeBytes)
             {
                 respSizeBytes = reqSizeBytes;
             }
-            recordData = e.data();
+            recordData = e.data;
         }
         response.resize(sizeof(pldm_msg_hdr) + PLDM_GET_PDR_MIN_RESP_BYTES +
                             respSizeBytes,
                         0);
         responsePtr = reinterpret_cast<pldm_msg*>(response.data());
         rc = encode_get_pdr_resp(request->hdr.instance_id, PLDM_SUCCESS,
-                                 nextRecordHandle, 0, PLDM_START, respSizeBytes,
-                                 recordData, 0, responsePtr);
+                                 e.handle.nextRecordHandle, 0, PLDM_START,
+                                 respSizeBytes, recordData, 0, responsePtr);
         if (rc != PLDM_SUCCESS)
         {
             return ccOnlyResponse(request, rc);
         }
     }
-    catch (const std::out_of_range& e)
-    {
-        return CmdHandler::ccOnlyResponse(request,
-                                          PLDM_PLATFORM_INVALID_RECORD_HANDLE);
-    }
     catch (const std::exception& e)
     {
         std::cerr << "Error accessing PDR, HANDLE=" << recordHandle
diff --git a/libpldmresponder/platform.hpp b/libpldmresponder/platform.hpp
index 3de0e1f..dde51e0 100644
--- a/libpldmresponder/platform.hpp
+++ b/libpldmresponder/platform.hpp
@@ -4,6 +4,7 @@
 
 #include "handler.hpp"
 #include "libpldmresponder/pdr.hpp"
+#include "libpldmresponder/pdr_utils.hpp"
 #include "utils.hpp"
 
 #include <stdint.h>
@@ -66,6 +67,7 @@
         const DBusInterface& dBusIntf, effecter::Id effecterId,
         const std::vector<set_effecter_state_field>& stateField)
     {
+        using namespace pldm::responder::pdr;
         using namespace std::string_literals;
         using DBusProperty = std::variant<std::string, bool>;
         using StateSetId = uint16_t;
@@ -89,46 +91,42 @@
         state_effecter_possible_states* states = nullptr;
         pldm_state_effecter_pdr* pdr = nullptr;
         uint8_t compEffecterCnt = stateField.size();
-        uint32_t recordHndl{};
-        Repo& pdrRepo = get(PDR_JSONS_DIR);
-        pdr::Entry pdrEntry{};
 
-        while (!pdr)
+        pdr_utils::Repo repo =
+            getRepoByType(PDR_JSONS_DIR, PLDM_STATE_EFFECTER_PDR);
+        if (repo.empty())
         {
-            pdrEntry = pdrRepo.at(recordHndl);
-            pldm_pdr_hdr* header =
-                reinterpret_cast<pldm_pdr_hdr*>(pdrEntry.data());
-            if (header->type != PLDM_STATE_EFFECTER_PDR)
+            std::cerr << "Failed to get record by PDR type\n";
+            return PLDM_PLATFORM_INVALID_EFFECTER_ID;
+        }
+        PdrEntry pdrEntry{};
+        auto pdrRecord = repo.getFirstRecord(pdrEntry);
+        while (pdrRecord)
+        {
+            pdr = reinterpret_cast<pldm_state_effecter_pdr*>(pdrEntry.data);
+            if (pdr->effecter_id != effecterId)
             {
-                recordHndl = pdrRepo.getNextRecordHandle(recordHndl);
-                if (recordHndl)
-                {
-                    continue;
-                }
-                return PLDM_PLATFORM_INVALID_EFFECTER_ID;
+                pdr = nullptr;
+                pdrRecord = repo.getNextRecord(pdrRecord, pdrEntry);
+                continue;
             }
-            pdr = reinterpret_cast<pldm_state_effecter_pdr*>(pdrEntry.data());
-            recordHndl = pdr->hdr.record_handle;
-            if (pdr->effecter_id == effecterId)
+
+            states = reinterpret_cast<state_effecter_possible_states*>(
+                pdr->possible_states);
+            if (compEffecterCnt > pdr->composite_effecter_count)
             {
-                states = reinterpret_cast<state_effecter_possible_states*>(
-                    pdr->possible_states);
-                if (compEffecterCnt > pdr->composite_effecter_count)
-                {
-                    std::cerr
-                        << "The requester sent wrong composite effecter"
-                        << " count for the effecter, EFFECTER_ID=" << effecterId
-                        << "COMP_EFF_CNT=" << compEffecterCnt << "\n";
-                    return PLDM_ERROR_INVALID_DATA;
-                }
-                break;
+                std::cerr << "The requester sent wrong composite effecter"
+                          << " count for the effecter, EFFECTER_ID="
+                          << effecterId << "COMP_EFF_CNT=" << compEffecterCnt
+                          << "\n";
+                return PLDM_ERROR_INVALID_DATA;
             }
-            recordHndl = pdrRepo.getNextRecordHandle(recordHndl);
-            if (!recordHndl)
-            {
-                return PLDM_PLATFORM_INVALID_EFFECTER_ID;
-            }
-            pdr = nullptr;
+            break;
+        }
+
+        if (!pdr)
+        {
+            return PLDM_PLATFORM_INVALID_EFFECTER_ID;
         }
 
         std::map<StateSetId, std::function<int(const std::string& objPath,
diff --git a/test/libpldmresponder_pdr_state_effecter_test.cpp b/test/libpldmresponder_pdr_state_effecter_test.cpp
index e758f63..c2b114c 100644
--- a/test/libpldmresponder_pdr_state_effecter_test.cpp
+++ b/test/libpldmresponder_pdr_state_effecter_test.cpp
@@ -1,5 +1,6 @@
 #include "libpldmresponder/effecters.hpp"
 #include "libpldmresponder/pdr.hpp"
+#include "libpldmresponder/pdr_utils.hpp"
 
 #include "libpldm/platform.h"
 
@@ -9,17 +10,19 @@
 
 TEST(GeneratePDR, testGoodJson)
 {
-    using namespace pdr;
     using namespace effecter::dbus_mapping;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    pdr_utils::Repo pdrRepo = pdr::getRepoByType(
+        "./pdr_jsons/state_effecter/good", PLDM_STATE_EFFECTER_PDR);
 
     // 2 entries
-    ASSERT_EQ(pdrRepo.numEntries(), 2);
+    ASSERT_EQ(pdrRepo.getRecordCount(), 2);
 
     // Check first PDR
-    pdr::Entry e = pdrRepo.at(1);
+    pdr_utils::PdrEntry e;
+    auto record1 = pdr::getRecordByHandle(pdrRepo, 1, e);
+    ASSERT_NE(record1, nullptr);
     pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data());
+        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
 
     ASSERT_EQ(pdr->hdr.record_handle, 1);
     ASSERT_EQ(pdr->hdr.version, 1);
@@ -48,8 +51,9 @@
     ASSERT_EQ(paths[0], "/foo/bar");
 
     // Check second PDR
-    e = pdrRepo.at(2);
-    pdr = reinterpret_cast<pldm_state_effecter_pdr*>(e.data());
+    auto record2 = pdr::getRecordByHandle(pdrRepo, 2, e);
+    ASSERT_NE(record2, nullptr);
+    pdr = reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
 
     ASSERT_EQ(pdr->hdr.record_handle, 2);
     ASSERT_EQ(pdr->hdr.version, 1);
@@ -91,19 +95,14 @@
 
 TEST(GeneratePDR, testNoJson)
 {
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/not_there");
-
-    ASSERT_EQ(pdrRepo.numEntries(), 2);
+    ASSERT_THROW(pdr_utils::readJson("./pdr_jsons/not_there"), std::exception);
 }
 
 TEST(GeneratePDR, testMalformedJson)
 {
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
-    ASSERT_EQ(pdrRepo.numEntries(), 2);
-    pdrRepo.makeEmpty();
-    ASSERT_THROW(pldm::responder::pdr::internal::readJson(
-                     "./pdr_jsons/state_effecter/malformed"),
+    pdr_utils::Repo pdrRepo = pdr::getRepoByType(
+        "./pdr_jsons/state_effecter/good", PLDM_STATE_EFFECTER_PDR);
+    ASSERT_EQ(pdrRepo.getRecordCount(), 2);
+    ASSERT_THROW(pdr_utils::readJson("./pdr_jsons/state_effecter/malformed"),
                  std::exception);
 }
diff --git a/test/libpldmresponder_platform_test.cpp b/test/libpldmresponder_platform_test.cpp
index 208edc3..8252920 100644
--- a/test/libpldmresponder_platform_test.cpp
+++ b/test/libpldmresponder_platform_test.cpp
@@ -1,5 +1,6 @@
 #include "libpldmresponder/effecters.hpp"
 #include "libpldmresponder/pdr.hpp"
+#include "libpldmresponder/pdr_utils.hpp"
 #include "libpldmresponder/platform.hpp"
 
 #include <iostream>
@@ -9,87 +10,76 @@
 #include <gtest/gtest.h>
 
 using namespace pldm::responder;
-using namespace pldm::responder::pdr;
 
 TEST(getPDR, testGoodPath)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    *reqCount = 100;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->request_count = 100;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-    start = responsePtr->payload;
-    start += sizeof(uint8_t);
-    uint32_t* nextRecordHandle = reinterpret_cast<uint32_t*>(start);
-    ASSERT_EQ(*nextRecordHandle, 2);
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* recordCount = reinterpret_cast<uint16_t*>(start);
-    ASSERT_EQ(*recordCount != 0, true);
-    start += sizeof(uint16_t);
-    // Check a bit of the PDR common header
-    pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(start);
-    ASSERT_EQ(pdr->hdr.record_handle, 1);
-    ASSERT_EQ(pdr->hdr.version, 1);
+    struct pldm_get_pdr_resp* resp =
+        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
+    ASSERT_EQ(2, resp->next_record_handle);
+    ASSERT_EQ(true, resp->response_count != 0);
+
+    pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data);
+    ASSERT_EQ(hdr->record_handle, 1);
+    ASSERT_EQ(hdr->version, 1);
 }
 
 TEST(getPDR, testShortRead)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    // Read 1 byte of PDR
-    *reqCount = 1;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->request_count = 1;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
-
-    ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-    start = responsePtr->payload;
-    start +=
-        sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* recordCount = reinterpret_cast<uint16_t*>(start);
-    ASSERT_EQ(*recordCount, 1);
+    struct pldm_get_pdr_resp* resp =
+        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
+    ASSERT_EQ(1, resp->response_count);
 }
 
 TEST(getPDR, testBadRecordHandle)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    uint32_t* recordHandle = reinterpret_cast<uint32_t*>(start);
-    *recordHandle = 100000;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    *reqCount = 1;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->record_handle = 100000;
+    request->request_count = 1;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
     ASSERT_EQ(responsePtr->payload[0], PLDM_PLATFORM_INVALID_RECORD_HANDLE);
@@ -99,73 +89,66 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    uint32_t* recordHandle = reinterpret_cast<uint32_t*>(start);
-    *recordHandle = 3;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->record_handle = 1;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
-
-    ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-    start = responsePtr->payload;
-    start += sizeof(uint8_t);
-    uint32_t* nextRecordHandle = reinterpret_cast<uint32_t*>(start);
-    ASSERT_EQ(*nextRecordHandle, 0);
+    struct pldm_get_pdr_resp* resp =
+        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
+    ASSERT_EQ(2, resp->next_record_handle);
 }
 
 TEST(getPDR, testFindPDR)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    *reqCount = 100;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->request_count = 100;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
 
     // Let's try to find a PDR of type stateEffecter (= 11) and entity type =
     // 100
     bool found = false;
     uint32_t handle = 0; // start asking for PDRs from recordHandle 0
-    uint32_t* recordHandle = nullptr;
     while (!found)
     {
-        start = request->payload;
-        recordHandle = reinterpret_cast<uint32_t*>(start);
-        *recordHandle = handle;
+        request->record_handle = handle;
         platform::Handler handler;
-        auto response = handler.getPDR(request, requestPayloadLength);
+        auto response = handler.getPDR(req, requestPayloadLength);
         auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+        struct pldm_get_pdr_resp* resp =
+            reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+        ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
 
-        ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-        start = responsePtr->payload;
-        start += sizeof(uint8_t);
-        uint32_t* nextRecordHandle = reinterpret_cast<uint32_t*>(start);
-        handle = *nextRecordHandle; // point to the next pdr in case current is
-                                    // not what we want
-        start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t) +
-                 sizeof(uint16_t);
-        pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-        uint32_t intType = hdr->type;
+        handle = resp->next_record_handle; // point to the next pdr in case
+                                           // current is not what we want
+
+        pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data);
         std::cerr << "PDR next record handle " << handle << "\n";
-        std::cerr << "PDR type " << intType << "\n";
+        std::cerr << "PDR type " << hdr->type << "\n";
         if (hdr->type == PLDM_STATE_EFFECTER_PDR)
         {
             pldm_state_effecter_pdr* pdr =
-                reinterpret_cast<pldm_state_effecter_pdr*>(start);
+                reinterpret_cast<pldm_state_effecter_pdr*>(resp->record_data);
             std::cerr << "PDR entity type " << pdr->entity_type << "\n";
             if (pdr->entity_type == 100)
             {
@@ -174,7 +157,7 @@
                 break;
             }
         }
-        if (!*nextRecordHandle) // no more records
+        if (!resp->next_record_handle) // no more records
         {
             break;
         }
@@ -204,10 +187,13 @@
 
 TEST(setStateEffecterStatesHandler, testGoodRequest)
 {
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
-    pdr::Entry e = pdrRepo.at(1);
+    pdr_utils::Repo pdrRepo = pdr::getRepoByType(
+        "./pdr_jsons/state_effecter/good", PLDM_STATE_EFFECTER_PDR);
+    pdr_utils::PdrEntry e;
+    auto record1 = pdr::getRecordByHandle(pdrRepo, 1, e);
+    ASSERT_NE(record1, nullptr);
     pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data());
+        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
 
     std::vector<set_effecter_state_field> stateField;
@@ -232,10 +218,13 @@
 
 TEST(setStateEffecterStatesHandler, testBadRequest)
 {
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
-    pdr::Entry e = pdrRepo.at(1);
+    pdr_utils::Repo pdrRepo = pdr::getRepoByType(
+        "./pdr_jsons/state_effecter/good", PLDM_STATE_EFFECTER_PDR);
+    pdr_utils::PdrEntry e;
+    auto record1 = pdr::getRecordByHandle(pdrRepo, 1, e);
+    ASSERT_NE(record1, nullptr);
     pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data());
+        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
 
     std::vector<set_effecter_state_field> stateField;