Use the new oatpp ORM.

Author: lganzzzo

CMakeLists.txt

@@ -7,67 +7,49 @@ project(${project_name})
 set(CMAKE_CXX_STANDARD 11)
 
 add_library(${project_name}-lib
-        src/App.cpp
-        src/AppComponent.hpp
-        src/ServiceComponent.hpp
-        src/SwaggerComponent.hpp
-        src/controller/UserController.cpp
         src/controller/UserController.hpp
-        src/db/Database.cpp
-        src/db/Database.hpp
+        src/db/UserDb.hpp
         src/dto/ConfigDto.hpp
-        src/dto/ErrorDto.hpp
+        src/dto/PageDto.hpp
+        src/dto/StatusDto.hpp
         src/dto/UserDto.hpp
+        src/service/UserService.cpp
+        src/service/UserService.hpp
+        src/AppComponent.hpp
+        src/DatabaseComponent.hpp
+        src/ErrorHandler.cpp
+        src/ErrorHandler.hpp
+        src/ServiceComponent.hpp
+        src/SwaggerComponent.hpp
 )
 
 target_include_directories(${project_name}-lib PUBLIC src)
 
 ## link libs
 
-find_package(oatpp          1.2.0 REQUIRED)
-find_package(oatpp-swagger  1.2.0 REQUIRED)
+find_package(oatpp              1.2.0 REQUIRED)
+find_package(oatpp-swagger      1.2.0 REQUIRED)
+find_package(oatpp-postgresql   1.2.0 REQUIRED)
 
 target_link_libraries(${project_name}-lib
         PUBLIC oatpp::oatpp
         PUBLIC oatpp::oatpp-test
         PUBLIC oatpp::oatpp-swagger
+        PUBLIC oatpp::oatpp-postgresql
 )
 
 add_definitions(
         # Path to swagger-ui resources #
-        -DOATPP_SWAGGER_RES_PATH="${oatpp-swagger_INCLUDE_DIRS}/../bin/oatpp-swagger/res"
+        -DOATPP_SWAGGER_RES_PATH="${OATPP_BASE_DIR}/bin/oatpp-swagger/res"
 
         # Path to config file #
         -DCONFIG_PATH="${CMAKE_CURRENT_LIST_DIR}/resources/config.json"
-)
-
-#################################################################
-## link postgresql client
 
-include(FindPkgConfig)
-
-set(ENV{PKG_CONFIG_PATH} "/usr/local/pgsql/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}") ## change this if needed
-
-pkg_check_modules(PKG_PQ REQUIRED libpq)
-
-message("PKG_PQ_INCLUDE_DIRS=${PKG_PQ_INCLUDE_DIRS}")
-message("PKG_PQ_LIBRARY_DIRS=${PKG_PQ_LIBRARY_DIRS}")
-message("PKG_PQ_LIBRARIES=${PKG_PQ_LIBRARIES}")
-
-target_include_directories(${project_name}-lib
-        PUBLIC ${PKG_PQ_INCLUDE_DIRS}
-)
-
-link_directories(
-        ${PKG_PQ_LIBRARY_DIRS}
-)
-
-target_link_libraries(${project_name}-lib
-        PUBLIC ${PKG_PQ_LIBRARIES}
+        ## Path to database migration scripts
+        -DDATABASE_MIGRATIONS="${CMAKE_CURRENT_SOURCE_DIR}/sql"
 )
 
 #################################################################
-
 ## add executables
 
 add_executable(${project_name}-exe

resources/config.json

@@ -1,18 +1,14 @@
 {
   "dev": {
+    "host": "0.0.0.0",
     "port": 8000,
     "swaggerHost": "localhost:8000",
-    "dbHost": "localhost",
-    "dbUser": "postgres",
-    "dbPass": "db-pass",
-    "dbName": "postgres"
+    "dbConnectionString": "postgresql://postgres:db-pass@localhost:5432/postgres"
   },
   "local-docker": {
+    "host": "0.0.0.0",
     "port": 8000,
     "swaggerHost": "localhost:8000",
-    "dbHost": "db",
-    "dbUser": "postgres",
-    "dbPass": "db-pass",
-    "dbName": "postgres"
+    "dbConnectionString": "postgresql://postgres:db-pass@db:5432/postgres"
   }
 }

sql/001_init.sql

@@ -0,0 +1,15 @@
+
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TABLE IF NOT EXISTS AppUser (
+    id                      varchar (256) PRIMARY KEY,
+    username                varchar (256) NOT NULL,
+    email                   varchar (256) NOT NULL,
+    password                varchar (256) NOT NULL,
+    role                    varchar (256) NULL,
+    CONSTRAINT              UK_APPUSER_USERNAME UNIQUE (username),
+    CONSTRAINT              UK_APPUSER_EMAIL UNIQUE (email)
+);
+
+INSERT INTO AppUser
+(id, username, email, password, role) VALUES (uuid_generate_v4(), 'admin', 'admin@domain.com', 'admin', 'ROLE_ADMIN');

src/App.cpp

@@ -1,27 +1,22 @@
 
-#include "./controller/UserController.hpp"
-#include "./AppComponent.hpp"
-#include "./ServiceComponent.hpp"
-#include "./SwaggerComponent.hpp"
-
-#include "oatpp/network/Server.hpp"
+#include "controller/UserController.hpp"
+#include "AppComponent.hpp"
+#include "DatabaseComponent.hpp"
+#include "ServiceComponent.hpp"
+#include "SwaggerComponent.hpp"
 
 #include "oatpp-swagger/Controller.hpp"
 
-#include <iostream>
+#include "oatpp/network/Server.hpp"
 
+#include <iostream>
 
-/**
- *  run() method.
- *  1) set Environment components.
- *  2) add ApiController's endpoints to router
- *  3) run server
- */
 void run(const oatpp::base::CommandLineArguments& args) {
 
   AppComponent appComponent(args);
   ServiceComponent serviceComponent;
   SwaggerComponent swaggerComponent;
+  DatabaseComponent databaseComponent;
 
   /* create ApiControllers and add endpoints to router */
 
@@ -47,21 +42,12 @@ void run(const oatpp::base::CommandLineArguments& args) {
 
 }
 
-/**
- *  main
- */
 int main(int argc, const char * argv[]) {
 
   oatpp::base::Environment::init();
 
   run(oatpp::base::CommandLineArguments(argc, argv));
 
-  /* Print how much objects were created during app running, and what have left-probably leaked */
-  /* Disable object counting for release builds using '-D OATPP_DISABLE_ENV_OBJECT_COUNTERS' flag for better performance */
-  std::cout << "\nEnvironment:\n";
-  std::cout << "objectsCount = " << oatpp::base::Environment::getObjectsCount() << "\n";
-  std::cout << "objectsCreated = " << oatpp::base::Environment::getObjectsCreated() << "\n\n";
-
   oatpp::base::Environment::destroy();
 
   return 0;

src/DatabaseComponent.hpp

@@ -0,0 +1,37 @@
+
+#ifndef EXAMPLE_POSTGRESQL_DATABASECOMPONENT_HPP
+#define EXAMPLE_POSTGRESQL_DATABASECOMPONENT_HPP
+
+#include "db/UserDb.hpp"
+#include "dto/ConfigDto.hpp"
+
+class DatabaseComponent {
+public:
+
+  /**
+   * Create database client
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<UserDb>, userDb)([] {
+
+    OATPP_COMPONENT(oatpp::Object<ConfigDto>, config); // Get config component
+
+    /* Create database-specific ConnectionProvider */
+    auto connectionProvider = std::make_shared<oatpp::postgresql::ConnectionProvider>(config->dbConnectionString);
+
+    /* Create database-specific ConnectionPool */
+    auto connectionPool = oatpp::postgresql::ConnectionPool::createShared(connectionProvider,
+                                                                          10 /* max-connections */,
+                                                                          std::chrono::seconds(5) /* connection TTL */);
+
+    /* Create database-specific Executor */
+    auto executor = std::make_shared<oatpp::postgresql::Executor>(connectionPool);
+
+    /* Create MyClient database client */
+    return std::make_shared<UserDb>(executor);
+
+  }());
+
+
+};
+
+#endif //EXAMPLE_POSTGRESQL_DATABASECOMPONENT_HPP

src/ErrorHandler.cpp

@@ -0,0 +1,24 @@
+
+#include "ErrorHandler.hpp"
+
+ErrorHandler::ErrorHandler(const std::shared_ptr<oatpp::data::mapping::ObjectMapper>& objectMapper)
+  : m_objectMapper(objectMapper)
+{}
+
+std::shared_ptr<ErrorHandler::OutgoingResponse>
+ErrorHandler::handleError(const Status& status, const oatpp::String& message, const Headers& headers) {
+
+  auto error = StatusDto::createShared();
+  error->status = "ERROR";
+  error->code = status.code;
+  error->message = message;
+
+  auto response = ResponseFactory::createResponse(status, error, m_objectMapper);
+
+  for(const auto& pair : headers.getAll()) {
+    response->putHeader(pair.first.toString(), pair.second.toString());
+  }
+
+  return response;
+
+}

src/ErrorHandler.hpp

@@ -0,0 +1,27 @@
+
+#ifndef EXAMPLE_POSTGRESQL_ERRORHANDLER_HPP
+#define EXAMPLE_POSTGRESQL_ERRORHANDLER_HPP
+
+#include "dto/StatusDto.hpp"
+
+#include "oatpp/web/server/handler/ErrorHandler.hpp"
+#include "oatpp/web/protocol/http/outgoing/ResponseFactory.hpp"
+
+class ErrorHandler : public oatpp::web::server::handler::ErrorHandler {
+private:
+  typedef oatpp::web::protocol::http::outgoing::Response OutgoingResponse;
+  typedef oatpp::web::protocol::http::Status Status;
+  typedef oatpp::web::protocol::http::outgoing::ResponseFactory ResponseFactory;
+private:
+  std::shared_ptr<oatpp::data::mapping::ObjectMapper> m_objectMapper;
+public:
+
+  ErrorHandler(const std::shared_ptr<oatpp::data::mapping::ObjectMapper>& objectMapper);
+
+  std::shared_ptr<OutgoingResponse>
+  handleError(const Status& status, const oatpp::String& message, const Headers& headers) override;
+
+};
+
+
+#endif //EXAMPLE_POSTGRESQL_ERRORHANDLER_HPP

src/ServiceComponent.hpp

@@ -3,70 +3,33 @@
 #define ServiceComponent_hpp
 
 #include "dto/ConfigDto.hpp"
-
-#include "db/Database.hpp"
+#include "ErrorHandler.hpp"
 
 #include "oatpp/web/server/HttpConnectionHandler.hpp"
 #include "oatpp/web/server/HttpRouter.hpp"
 #include "oatpp/network/tcp/server/ConnectionProvider.hpp"
 
 #include "oatpp/parser/json/mapping/ObjectMapper.hpp"
-
 #include "oatpp/core/macro/component.hpp"
 
 class ServiceComponent {
-public:
-  
-  class ErrorHandler : public oatpp::web::server::handler::ErrorHandler {
-  public:
-    typedef oatpp::web::protocol::http::outgoing::Response OutgoingResponse;
-    typedef oatpp::web::protocol::http::Status Status;
-    typedef oatpp::web::protocol::http::outgoing::ResponseFactory ResponseFactory;
-  private:
-    std::shared_ptr<oatpp::data::mapping::ObjectMapper> m_objectMapper;
-  public:
-    
-    ErrorHandler(const std::shared_ptr<oatpp::data::mapping::ObjectMapper>& objectMapper)
-      : m_objectMapper(objectMapper)
-    {}
-    
-    OATPP_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, objectMapper);
-    
-    
-    std::shared_ptr<OutgoingResponse> handleError(const Status& status, const oatpp::String& message, const Headers& headers) override {
-
-      auto error = ErrorDto::createShared();
-      error->code = 500;
-      error->error = "Unhandled Error";
-      error->message = message;
-
-      auto response = ResponseFactory::createResponse(Status::CODE_500, error, m_objectMapper);
-
-      for(const auto& pair : headers.getAll()) {
-        response->putHeader(pair.first.toString(), pair.second.toString());
-      }
-
-      return response;
-
-    }
-    
-  };
-  
 public:
 
   /**
    *  Create ObjectMapper component to serialize/deserialize DTOs in Contoller's API
    */
   OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, apiObjectMapper)([] {
-    return oatpp::parser::json::mapping::ObjectMapper::createShared();
+    auto mapper = oatpp::parser::json::mapping::ObjectMapper::createShared();
+    mapper->getSerializer()->getConfig()->useBeautifier = true;
+    return mapper;
   }());
 
   /**
    *  Create ConnectionProvider component which listens on the port
    */
   OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ServerConnectionProvider>, serverConnectionProvider)([] {
     OATPP_COMPONENT(oatpp::Object<ConfigDto>, config); // Get config component
-    return oatpp::network::tcp::server::ConnectionProvider::createShared({"localhost", config->port});
+    return oatpp::network::tcp::server::ConnectionProvider::createShared({"localhost", config->port, oatpp::network::Address::IP_4});
   }());
 
   /**
@@ -82,18 +45,11 @@ class ServiceComponent {
   OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ConnectionHandler>, serverConnectionHandler)([] {
     OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router); // get Router component
     OATPP_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, objectMapper); // get ObjectMapper component
+
     auto connectionHandler = oatpp::web::server::HttpConnectionHandler::createShared(router);
     connectionHandler->setErrorHandler(std::make_shared<ErrorHandler>(objectMapper));
     return connectionHandler;
   }());
-  
-  OATPP_CREATE_COMPONENT(std::shared_ptr<Database>, database)([] {
-    OATPP_COMPONENT(oatpp::Object<ConfigDto>, config); // Get config component
-    auto db = std::make_shared<Database>(config->dbHost, config->dbUser, config->dbPass, config->dbName);
-    db->connect();
-    db->init();
-    return db;
-  }());
 
 };