The new CRUD example. With oatpp ORM and SQLite.

Author: lganzzzo

.gitignore

@@ -37,4 +37,7 @@ build/
 # idea
 .idea/
 cmake-build-debug/
-*/cmake-build-debug/
+*/cmake-build-debug/
+
+# sqlite
+**/*.sqlite

CMakeLists.txt

@@ -4,14 +4,17 @@ project(crud)
 set(CMAKE_CXX_STANDARD 11)
 
 add_library(crud-lib
-        src/AppComponent.hpp
-        src/SwaggerComponent.hpp
+        src/controller/StaticController.hpp
         src/controller/UserController.hpp
-        src/db/Database.cpp
-        src/db/Database.hpp
-        src/db/model/User.hpp
+        src/db/UserDb.hpp
+        src/dto/PageDto.hpp
         src/dto/UserDto.hpp
-)
+        src/service/UserService.cpp
+        src/service/UserService.hpp
+        src/AppComponent.hpp
+        src/DatabaseComponent.hpp
+        src/SwaggerComponent.hpp
+        src/ErrorHandler.cpp src/ErrorHandler.hpp src/dto/StatusDto.hpp)
 
 ## include directories
 
@@ -22,20 +25,33 @@ target_include_directories(crud-lib PUBLIC src)
 
 find_package(oatpp          1.2.0 REQUIRED)
 find_package(oatpp-swagger  1.2.0 REQUIRED)
+find_package(oatpp-sqlite   1.2.0 REQUIRED)
 
 target_link_libraries(crud-lib
         PUBLIC oatpp::oatpp
         PUBLIC oatpp::oatpp-swagger
+        PUBLIC oatpp::oatpp-sqlite
 )
 
-## define path to swagger-ui res folder
+add_definitions(
+        ## define path to swagger-ui static resources folder
+        -DOATPP_SWAGGER_RES_PATH="${OATPP_BASE_DIR}/bin/oatpp-swagger/res"
+
+        ## SQLite databse file
+        -DDATABASE_FILE="${CMAKE_CURRENT_SOURCE_DIR}/db.sqlite"
 
-add_definitions(-DOATPP_SWAGGER_RES_PATH="${OATPP_BASE_DIR}/bin/oatpp-swagger/res")
+        ## Path to database migration scripts
+        -DDATABASE_MIGRATIONS="${CMAKE_CURRENT_SOURCE_DIR}/sql"
+)
 
+if(CMAKE_SYSTEM_NAME MATCHES Linux)
+    find_package(Threads REQUIRED)
+    target_link_libraries(crud-lib INTERFACE Threads::Threads ${CMAKE_DL_LIBS})
+endif()
 
 ## add executables
 
-add_executable(crud-exe src/App.cpp)
+add_executable(crud-exe src/App.cpp src/db/UserDb.hpp)
 target_link_libraries(crud-exe crud-lib)
 
 add_executable(crud-test

Dockerfile

@@ -4,7 +4,7 @@ ADD . /service
 
 WORKDIR /service/utility
 
-RUN ./install-oatpp-modules.sh
+RUN ./install-oatpp-modules.sh Release
 
 WORKDIR /service/build
 

sql/001_init.sql

@@ -0,0 +1,11 @@
+
+CREATE TABLE AppUser (
+    id          INTEGER PRIMARY KEY,
+    username    VARCHAR UNIQUE,
+    email       VARCHAR UNIQUE,
+    password    VARCHAR,
+    role        VARCHAR
+);
+
+INSERT INTO AppUser
+(username, email, password, role) VALUES ('admin', 'admin@domain.com', 'admin', 'ROLE_ADMIN');

src/App.cpp

@@ -1,18 +1,15 @@
 
-#include "./controller/UserController.hpp"
-#include "./AppComponent.hpp"
+#include "AppComponent.hpp"
+
+#include "controller/UserController.hpp"
+#include "controller/StaticController.hpp"
 
 #include "oatpp-swagger/Controller.hpp"
+
 #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() {
 
   AppComponent components; // Create scope Environment components
@@ -29,6 +26,9 @@ void run() {
 
   auto swaggerController = oatpp::swagger::Controller::createShared(docEndpoints);
   swaggerController->addEndpointsToRouter(router);
+
+  auto staticController = StaticController::createShared();
+  staticController->addEndpointsToRouter(router);
 
   /* create server */
 

src/AppComponent.hpp

@@ -2,16 +2,16 @@
 #ifndef AppComponent_hpp
 #define AppComponent_hpp
 
-#include "db/Database.hpp"
-
 #include "SwaggerComponent.hpp"
+#include "DatabaseComponent.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/Serializer.hpp"
-#include "oatpp/parser/json/mapping/Deserializer.hpp"
+#include "oatpp/parser/json/mapping/ObjectMapper.hpp"
 
 #include "oatpp/core/macro/component.hpp"
 
@@ -26,12 +26,26 @@ class AppComponent {
    *  Swagger component
    */
   SwaggerComponent swaggerComponent;
+
+  /**
+   * Database component
+   */
+  DatabaseComponent databaseComponent;
+
+  /**
+   * Create ObjectMapper component to serialize/deserialize DTOs in Contoller's API
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, apiObjectMapper)([] {
+    auto objectMapper = oatpp::parser::json::mapping::ObjectMapper::createShared();
+    objectMapper->getDeserializer()->getConfig()->allowUnknownFields = false;
+    return objectMapper;
+  }());
 
   /**
    *  Create ConnectionProvider component which listens on the port
    */
   OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ServerConnectionProvider>, serverConnectionProvider)([] {
-    return oatpp::network::tcp::server::ConnectionProvider::createShared({"localhost", 8000});
+    return oatpp::network::tcp::server::ConnectionProvider::createShared({"0.0.0.0", 8000, oatpp::network::Address::IP_4});
   }());
 
   /**
@@ -45,24 +59,14 @@ class AppComponent {
    *  Create ConnectionHandler component which uses Router component to route requests
    */
   OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ConnectionHandler>, serverConnectionHandler)([] {
+
     OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router); // get Router component
-    return oatpp::web::server::HttpConnectionHandler::createShared(router);
-  }());
-  
-  /**
-   *  Create ObjectMapper component to serialize/deserialize DTOs in Contoller's API
-   */
-  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, apiObjectMapper)([] {
-    auto objectMapper = oatpp::parser::json::mapping::ObjectMapper::createShared();
-    objectMapper->getDeserializer()->getConfig()->allowUnknownFields = false;
-    return objectMapper;
-  }());
-  
-  /**
-   *  Create Demo-Database component which stores information about users
-   */
-  OATPP_CREATE_COMPONENT(std::shared_ptr<Database>, database)([] {
-    return std::make_shared<Database>();
+    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;
+
   }());
 
 };

src/DatabaseComponent.hpp

@@ -0,0 +1,34 @@
+
+#ifndef CRUD_DATABASECOMPONENT_HPP
+#define CRUD_DATABASECOMPONENT_HPP
+
+#include "db/UserDb.hpp"
+
+class DatabaseComponent {
+public:
+
+  /**
+   * Create database client
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<UserDb>, userDb)([] {
+
+    /* Create database-specific ConnectionProvider */
+    auto connectionProvider = std::make_shared<oatpp::sqlite::ConnectionProvider>(DATABASE_FILE);
+
+    /* Create database-specific ConnectionPool */
+    auto connectionPool = oatpp::sqlite::ConnectionPool::createShared(connectionProvider,
+                                                                      10 /* max-connections */,
+                                                                      std::chrono::seconds(5) /* connection TTL */);
+
+    /* Create database-specific Executor */
+    auto executor = std::make_shared<oatpp::sqlite::Executor>(connectionPool);
+
+    /* Create MyClient database client */
+    return std::make_shared<UserDb>(executor);
+
+  }());
+
+
+};
+
+#endif //CRUD_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 CRUD_ERRORHANDLER_HPP
+#define CRUD_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 //CRUD_ERRORHANDLER_HPP

src/controller/StaticController.hpp

@@ -0,0 +1,45 @@
+
+#ifndef CRUD_STATICCONTROLLER_HPP
+#define CRUD_STATICCONTROLLER_HPP
+
+#include "oatpp/web/server/api/ApiController.hpp"
+#include "oatpp/parser/json/mapping/ObjectMapper.hpp"
+#include "oatpp/core/macro/codegen.hpp"
+#include "oatpp/core/macro/component.hpp"
+
+#include OATPP_CODEGEN_BEGIN(ApiController) //<- Begin Codegen
+
+class StaticController : public oatpp::web::server::api::ApiController {
+public:
+  StaticController(const std::shared_ptr<ObjectMapper>& objectMapper)
+    : oatpp::web::server::api::ApiController(objectMapper)
+  {}
+public:
+
+  static std::shared_ptr<StaticController> createShared(
+    OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper) // Inject objectMapper component here as default parameter
+  ){
+    return std::make_shared<StaticController>(objectMapper);
+  }
+
+  ENDPOINT("GET", "/", root) {
+    const char* html =
+      "<html lang='en'>"
+      "  <head>"
+      "    <meta charset=utf-8/>"
+      "  </head>"
+      "  <body>"
+      "    <p>Hello CRUD example project!</p>"
+      "    <a href='swagger/ui'>Checkout Swagger-UI page</a>"
+      "  </body>"
+      "</html>";
+    auto response = createResponse(Status::CODE_200, html);
+    response->putHeader(Header::CONTENT_TYPE, "text/html");
+    return response;
+  }
+
+};
+
+#include OATPP_CODEGEN_BEGIN(ApiController) //<- End Codegen
+
+#endif //CRUD_STATICCONTROLLER_HPP