attaching schema nodes progress

include/matador/object/foreign_node_completer.hpp

@@ -0,0 +1,110 @@
+#ifndef FOREIGN_NODE_COMPLETER_HPP
+#define FOREIGN_NODE_COMPLETER_HPP
+
+#include "matador/object/internal/shadow_schema.hpp"
+#include "matador/object/schema_node.hpp"
+#include "matador/object/join_columns_collector.hpp"
+#include "matador/object/object_ptr.hpp"
+
+#include "matador/logger/log_manager.hpp"
+
+#include <stack>
+
+namespace matador::object {
+
+/**
+ * Processes the given node and ensures
+ * that all foreign nodes needed by the given node
+ * relations are attached in schema.
+ *
+ * @tparam Type Type of node to complete
+ */
+class foreign_node_completer final {
+private:
+    using node_ptr = std::shared_ptr<schema_node>;
+
+public:
+    template<class Type>
+    static void complete(const std::shared_ptr<schema_node> &node) {
+        internal::shadow_schema shadow(node->schema_);
+        foreign_node_completer completer(shadow);
+
+        completer.complete_node<Type>(node);
+    }
+
+    template<class PrimaryKeyType>
+    static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
+    static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
+    static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
+    template<typename AttributeType>
+    static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+    template<typename AttributeType>
+    static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+
+    template<class ForeignPointerType>
+    void on_belongs_to(const char *id, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/);
+    template<class ForeignPointerType>
+    static void on_has_one(const char * id, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
+
+    template<class CollectionType>
+    void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> * = nullptr);
+    template<class CollectionType>
+    void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<!is_object_ptr<typename CollectionType::value_type>::value> * = nullptr) {}
+
+    template<class CollectionType>
+    void on_has_many_to_many(const char *id, CollectionType &collection, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr);
+    template<class CollectionType>
+    void on_has_many_to_many(const char *id, CollectionType &collection, const utils::foreign_attributes &attr);
+
+private:
+    explicit foreign_node_completer(internal::shadow_schema &shadow);
+
+    template<typename Type>
+    void complete_node(const std::shared_ptr<schema_node> &node) {
+        nodes_.push(node);
+
+        Type obj;
+        access::process(*this, obj);
+        nodes_.pop();
+    }
+
+    template<typename Type>
+    void attach_node() {
+        if (schema_.schema_contains(typeid(Type))) {
+            return;
+        }
+        const auto node = schema_node::make_node<Type>(schema_.schema(), "");
+        if (auto result = schema_.attach_node(node)) {
+            complete<Type>(result.value());
+        }
+    }
+private:
+    std::stack<node_ptr> nodes_;
+    internal::shadow_schema &schema_;
+    logger::logger log_;
+    join_columns_collector join_columns_collector_{};
+};
+
+
+template<class ForeignPointerType>
+void foreign_node_completer::on_belongs_to( const char* id, ForeignPointerType&, const utils::foreign_attributes& ) {
+    attach_node<typename ForeignPointerType::value_type>();
+}
+
+template<class CollectionType>
+void foreign_node_completer::on_has_many( const char* id, CollectionType&, const char* join_column, const utils::foreign_attributes& attr, std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value>* ) {
+    attach_node<typename CollectionType::value_type::value_type>();
+}
+
+template<class CollectionType>
+void foreign_node_completer::on_has_many_to_many( const char* id, CollectionType& collection, const char* join_column, const char* inverse_join_column, const utils::foreign_attributes& attr ) {
+    attach_node<typename CollectionType::value_type::value_type>();
+}
+
+template<class CollectionType>
+void foreign_node_completer::on_has_many_to_many( const char* id, CollectionType& collection, const utils::foreign_attributes& attr ) {
+    attach_node<typename CollectionType::value_type::value_type>();
+}
+
+}
+#endif //FOREIGN_NODE_COMPLETER_HPP

include/matador/object/internal/shadow_schema.hpp

@@ -0,0 +1,33 @@
+#ifndef SHADOW_SCHEMA_HPP
+#define SHADOW_SCHEMA_HPP
+
+#include "matador/utils/result.hpp"
+#include "matador/utils/error.hpp"
+
+#include <memory>
+#include <typeindex>
+
+namespace matador::object {
+class schema;
+class schema_node;
+}
+
+namespace matador::object::internal {
+class shadow_schema {
+private:
+  using node_ptr = std::shared_ptr<schema_node>;
+
+public:
+  explicit shadow_schema(object::schema& s);
+
+  schema& schema() const;
+  bool schema_contains(const std::type_index& ti) const;
+  [[nodiscard]] utils::result<node_ptr, utils::error> find_node(const std::type_index &type_index) const;
+  [[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const std::shared_ptr<schema_node> &node) const;
+  [[nodiscard]] utils::result<void, utils::error> detach_node(const std::shared_ptr<schema_node> &node) const;
+
+private:
+  object::schema& schema_;
+};
+}
+#endif //SHADOW_SCHEMA_HPP

include/matador/object/relation_completer.hpp

@@ -0,0 +1,338 @@
+#ifndef RELATION_COMPLETER_HPP
+#define RELATION_COMPLETER_HPP
+
+#include "matador/object/internal/shadow_schema.hpp"
+#include "matador/object/many_to_many_relation.hpp"
+#include "matador/object/join_columns_collector.hpp"
+#include "matador/object/object_ptr.hpp"
+#include "matador/object/schema_node.hpp"
+
+#include "matador/logger/log_manager.hpp"
+
+#include <stack>
+
+namespace matador::object {
+
+/*
+ *   1. has_many (MM)
+ *      no belongs to
+ *      relation table is needed
+ *      - element type is a foreign table (FT),
+ *        then relation table must look like follows:
+ *        relation_table<MM, FT>
+ *        where MM and FT must be defined as belongs to
+ *      - element type if a builtin type BT (i.e. string, int, etc.),
+ *        then the relation table must look like follows:
+ *        relation_table<MM, BT>
+ *        where MM as belongs to and BT as given type
+ *
+ *   2. has_many_to_many (MM1, MM2)
+ *      relation_table is needed
+ *      relation_table<MM1, MM2>
+ *      where MM1 and MM2 must be defined as belongs to
+ *
+ *   3. hans_many (MM) <-> belongs_to (BT)
+ *      belongs_to has foreign key to the has_many side
+ *      no relation table needed
+ *
+ *   4. has_one to belongs_to
+ *      no relation table is needed
+ *
+ *   5. has_many (MM) <-> has_one (HO)
+ *      invalid relation -> error
+ *
+ *   6. has_one
+ *      no has_many or belongs_to
+ *      invalid relation -> error
+ */
+template<typename Type>
+class relation_completer final {
+private:
+    using node_ptr = std::shared_ptr<schema_node>;
+
+public:
+  using endpoint_ptr = std::shared_ptr<relation_endpoint>;
+
+  static void complete(const std::shared_ptr<schema_node> &node) {
+    internal::shadow_schema shadow(node->schema_);
+    relation_completer completer(shadow);
+
+    completer.complete_node_relations(node);
+  }
+
+  template<class PrimaryKeyType>
+  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
+  static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
+  static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
+  template<typename AttributeType>
+  static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  template<typename AttributeType>
+  static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+
+  template<class ForeignPointerType>
+  void on_belongs_to(const char *id, ForeignPointerType &obj, const utils::foreign_attributes &attr);
+  template<class ForeignPointerType>
+  void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/);
+
+  template<class CollectionType>
+  void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> * = nullptr);
+  template<class CollectionType>
+  void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<!is_object_ptr<typename CollectionType::value_type>::value> * = nullptr);
+
+  template<class CollectionType>
+  void on_has_many_to_many(const char *id, CollectionType &collection, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr);
+  template<class CollectionType>
+  void on_has_many_to_many(const char *id, CollectionType &collection, const utils::foreign_attributes &attr);
+
+private:
+  explicit relation_completer(internal::shadow_schema &shadow)
+    : schema_(shadow)
+    , log_(logger::create_logger("relation_completer")) {
+  }
+
+  void complete_node_relations(const std::shared_ptr<schema_node> &node) {
+      nodes_.push(node);
+
+      Type obj;
+      access::process(*this, obj);
+      nodes_.pop();
+  }
+
+  static void register_relation_endpoints(const endpoint_ptr &endpoint,
+                                          const endpoint_ptr &other_endpoint);
+  static void link_relation_endpoints(const endpoint_ptr &endpoint,
+                                      const endpoint_ptr &other_endpoint);
+
+private:
+  std::stack<node_ptr> nodes_;
+  internal::shadow_schema &schema_;
+  logger::logger log_;
+  join_columns_collector join_columns_collector_{};
+};
+
+template<typename Type>
+template<class CollectionType>
+void relation_completer<Type>::on_has_many(const char *id, CollectionType &,
+                                           const char *join_column,
+                                           const utils::foreign_attributes &,
+                                           std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> * /*unused*/) {
+  // Shortcut to a value type of object_ptr::value_type in a collection
+  using value_type = typename CollectionType::value_type::value_type;
+  using relation_value_type = many_to_many_relation<value_type, Type>;
+
+    // Check if the object_ptr type is already inserted in the schema (by id)
+    auto result = schema_.find_node(typeid(value_type));
+    if (!result) {
+        // Todo: throw internal error or attach node
+        return;
+    }
+    if (const auto endpoint = nodes_.top()->info().find_relation_endpoint(typeid(relation_value_type)); endpoint == nodes_.top()->info().endpoint_end()) {
+        // Endpoint was not found
+        log_.debug("node '%s' has has many foreign keys '%s' mapped by '%s'", nodes_.top()->name().c_str(), id, join_column);
+        const auto node = schema_node::make_relation_node<relation_value_type>(
+          schema_.schema(), id, [join_column] {
+            return std::make_unique<relation_value_type>(join_column, "id");
+          });
+        result = schema_.attach_node(node);
+        if (!result) {
+            // Todo: throw internal error
+            return;
+        }
+        const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, nodes_.top());
+        const auto foreign_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
+        nodes_.top()->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
+        foreign_endpoint->node_->info_->register_relation_endpoint(nodes_.top()->type_index(), foreign_endpoint);
+        link_relation_endpoints(local_endpoint, foreign_endpoint);
+    } else {
+        const auto &foreign_node = result.value();
+        if (const auto rit = foreign_node->info_->find_relation_endpoint(nodes_.top()->type_index());
+          rit != foreign_node->info().endpoint_end()) {
+            if (rit->second->is_belongs_to()) {
+                rit->second->node_ = foreign_node;
+                const auto localEndpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, nodes_.top());
+                nodes_.top()->info_->register_relation_endpoint(nodes_.top()->type_index(), localEndpoint);
+                link_relation_endpoints(localEndpoint, rit->second);
+            } else {
+                // Todo: throw internal error relation node has invalid type
+            }
+          } else {
+              // Todo: throw internal error couldn't find relation node
+          }
+
+    }
+}
+
+template<typename Type>
+template<class CollectionType>
+void relation_completer<Type>::on_has_many(const char *id, CollectionType &, const char *join_column,
+                                           const utils::foreign_attributes &,
+                                           std::enable_if_t<!is_object_ptr<typename CollectionType::value_type>::value>
+                                           * /*unused*/) {
+  using value_type = typename CollectionType::value_type;
+  using relation_value_type = many_to_relation<Type, value_type>;
+
+  const auto node = schema_node::make_relation_node<relation_value_type>(
+    schema_.schema(), id, [join_column] {
+      return std::make_unique<relation_value_type>(join_column, "value");
+    });
+
+  const auto result = schema_.attach_node(node);
+  if (!result) {
+    // Todo: throw internal exception
+  }
+
+  const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, nodes_.top());
+  const auto foreign_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
+  nodes_.top()->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
+  foreign_endpoint->node_->info_->register_relation_endpoint(nodes_.top()->type_index(), foreign_endpoint);
+  link_relation_endpoints(local_endpoint, foreign_endpoint);
+}
+
+template<typename Type>
+template<class CollectionType>
+void relation_completer<Type>::on_has_many_to_many(const char *id,
+                                                   CollectionType &/*collection*/,
+                                                   const char *join_column,
+                                                   const char *inverse_join_column,
+                                                   const utils::foreign_attributes &/*attr*/) {
+  using relation_value_type = many_to_many_relation<typename CollectionType::value_type::value_type, Type>;
+  auto result = schema_.find_node(typeid(relation_value_type));
+  if (result) {
+    // Found relation node.
+    // Complete relation links
+    const auto &foreign_node = result.value();
+    const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, nodes_.top());
+    nodes_.top()->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type), local_endpoint);
+    const auto it = foreign_node->info_->find_relation_endpoint(nodes_.top()->type_index());
+    if (it == foreign_node->info().endpoint_end()) {
+      // Todo: Throw error
+      return;
+    }
+    link_relation_endpoints(local_endpoint, it->second);
+  } else {
+    // Relation not not found.
+    auto creator = [join_column, inverse_join_column] {
+      return std::make_unique<relation_value_type>(join_column, inverse_join_column);
+    };
+
+    auto node = schema_node::make_relation_node<relation_value_type>(schema_.schema(), id, std::move(creator));
+
+    auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, nodes_.top());
+    auto join_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
+    auto inverse_join_endpoint = std::make_shared<relation_endpoint>(inverse_join_column, relation_type::BELONGS_TO,
+                                                                     node);
+    nodes_.top()->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type), local_endpoint);
+    node->info_->register_relation_endpoint(nodes_.top()->type_index(), join_endpoint);
+    link_relation_endpoints(local_endpoint, join_endpoint);
+    node->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type),
+                                            inverse_join_endpoint);
+    result = schema_.attach_node(node);
+    if (!result) {
+      // Todo: throw internal error
+      return;
+    }
+  }
+}
+
+template<typename Type>
+template<class CollectionType>
+void relation_completer<Type>::on_has_many_to_many(const char *id,
+                                                   CollectionType &collection,
+                                                   const utils::foreign_attributes &attr) {
+  const auto join_columns = join_columns_collector_.collect<typename CollectionType::value_type::value_type>();
+  on_has_many_to_many(
+    id,
+    collection,
+    join_columns.inverse_join_column.c_str(),
+    join_columns.join_column.c_str(),
+    attr);
+}
+
+template<typename Type>
+template<class ForeignPointerType>
+void relation_completer<Type>::on_has_one(const char *id,
+                                          ForeignPointerType &/*obj*/,
+                                          const utils::foreign_attributes &/*attr*/) {
+  const auto ti = std::type_index(typeid(typename ForeignPointerType::value_type));
+  if (const auto result = schema_.find_node(ti); !result) {
+    // Node was not found
+    // Create node without the foreign relation endpoint
+    log_.debug("node '%s' has foreign key '%s' has one '%s'", nodes_.top()->name().c_str(), id, ti.name());
+    nodes_.top()->info_->
+        register_relation_endpoint(ti, std::make_shared<relation_endpoint>(id, relation_type::HAS_ONE, nodes_.top()));
+  } else {
+    const auto &foreign_node = result.value();
+    if (const auto it = foreign_node->info().find_relation_endpoint(nodes_.top()->type_index());
+      it != foreign_node->info().endpoint_end()) {
+      if (it->second->is_belongs_to()) {
+        it->second->node_ = foreign_node;
+        const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_ONE, nodes_.top());
+        nodes_.top()->info_->register_relation_endpoint(ti, endpoint);
+        link_relation_endpoints(endpoint, it->second);
+      } else {
+        // Todo: Throw internal error
+        return;
+      }
+    }
+  }
+}
+
+template<typename Type>
+template<class ForeignPointerType>
+void relation_completer<Type>::on_belongs_to(const char *id,
+                                             ForeignPointerType & /*obj*/,
+                                             const utils::foreign_attributes & /*attr*/) {
+  using value_type = typename ForeignPointerType::value_type;
+  const auto ti = std::type_index(typeid(value_type));
+  if (auto result = schema_.find_node(ti); !result) {
+    // Type was not found
+    // Create node without the foreign relation endpoint
+    log_.debug("node '%s' has foreign key '%s' belongs to '%s'", nodes_.top()->name().c_str(), id, ti.name());
+    nodes_.top()->info_->register_relation_endpoint(
+      ti, std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, node_ptr{}));
+  } else {
+    // Type was found
+    const auto &foreign_node = result.value();
+    // Check foreign node and relation endpoint
+    if (const auto it = foreign_node->info_->find_relation_endpoint(nodes_.top()->type_index());
+      it != foreign_node->info().endpoint_end()) {
+      // Found corresponding relation endpoint in the foreign node
+      if (it->second->is_has_one()) {
+        const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, nodes_.top());
+        nodes_.top()->info_->register_relation_endpoint(ti, endpoint);
+        link_relation_endpoints(endpoint, it->second);
+      } else if (it->second->foreign_endpoint()->node().type_index() == typeid(many_to_many_relation<Type, value_type>)) {
+        // Endpoint is a "many_to_many_relation". This means there
+        // is a "many_to_many_relation" node attached. Because of being a
+        // "belongs_to"-relation the "many_to_many_relation" can be removed
+        // (detach), and the endpoints must be adjusted
+        const auto foreign_endpoint = it->second->foreign_endpoint();
+        const auto detach_result = schema_.detach_node(foreign_endpoint->node_);
+        foreign_endpoint->node_ = nodes_.top();
+        nodes_.top()->info_->register_relation_endpoint(nodes_.top()->type_index(), foreign_endpoint);
+      } else {
+        // check type
+      }
+    } else {
+      // Relation node was not found, create only endpoint.
+      const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, nodes_.top());
+      nodes_.top()->info_->register_relation_endpoint(ti, endpoint);
+    }
+  }
+}
+
+template<typename Type>
+void relation_completer<Type>::register_relation_endpoints(const endpoint_ptr &endpoint,
+                                                           const endpoint_ptr &other_endpoint) {
+  endpoint->node_->info_->register_relation_endpoint(other_endpoint->node_->type_index(), endpoint);
+  other_endpoint->node_->info_->register_relation_endpoint(endpoint->node_->type_index(), other_endpoint);
+  link_relation_endpoints(endpoint, other_endpoint);
+}
+
+template<typename Type>
+void relation_completer<Type>::link_relation_endpoints(const endpoint_ptr &endpoint, const endpoint_ptr &other_endpoint) {
+  endpoint->link_foreign_endpoint(other_endpoint);
+  other_endpoint->link_foreign_endpoint(endpoint);
+}
+}
+#endif //RELATION_COMPLETER_HPP

include/matador/object/relation_endpoint.hpp

@@ -39,7 +39,7 @@ public:
   void link_foreign_endpoint(const std::shared_ptr<relation_endpoint>& endpoint);
 
 private:
-  template<typename>
+  template<typename Type>
   friend class relation_completer;
 
   std::string field_name_;

include/matador/object/schema.hpp

@@ -3,9 +3,9 @@
 
 #include "matador/logger/log_manager.hpp"
 
-#include "matador/object/join_columns_collector.hpp"
-#include "matador/object/many_to_many_relation.hpp"
 #include "matador/object/error_code.hpp"
+#include "matador/object/foreign_node_completer.hpp"
+#include "matador/object/relation_completer.hpp"
 #include "matador/object/schema_node.hpp"
 #include "matador/object/schema_node_iterator.hpp"
 
@@ -15,123 +15,16 @@
 #include "matador/logger/logger.hpp"
 
 #include <memory>
-#include <stack>
 #include <string>
 #include <unordered_set>
 
 namespace matador::object {
+namespace internal {
+class shadow_schema;
+}
+
 utils::error make_error(error_code ec, const std::string &msg);
 
-class schema;
-
-/*
- *   1. has_many (MM)
- *      no belongs to
- *      relation table is needed
- *      - element type is a foreign table (FT),
- *        then relation table must look like follows:
- *        relation_table<MM, FT>
- *        where MM and FT must be defined as belongs to
- *      - element type if a builtin type BT (i.e. string, int, etc.),
- *        then the relation table must look like follows:
- *        relation_table<MM, BT>
- *        where MM as belongs to and BT as given type
- *
- *   2. has_many_to_many (MM1, MM2)
- *      relation_table is needed
- *      relation_table<MM1, MM2>
- *      where MM1 and MM2 must be defined as belongs to
- *
- *   3. hans_many (MM) <-> belongs_to (BT)
- *      belongs_to has foreign key to the has_many side
- *      no relation table needed
- *
- *   4. has_one to belongs_to
- *      no relation table is needed
- *
- *   5. has_many (MM) <-> has_one (HO)
- *      invalid relation -> error
- *
- *   6. has_one
- *      no has_many or belongs_to
- *      invalid relation -> error
- */
-template<typename Type>
-class relation_completer final {
-public:
-  using value_type = Type;
-  using endpoint_ptr = std::shared_ptr<relation_endpoint>;
-
-  static void complete(const std::shared_ptr<schema_node> &node) {
-    relation_completer completer(node);
-
-    Type obj;
-    access::process(completer, obj);
-  }
-
-  template<class PrimaryKeyType>
-  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/,
-                             std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool,
-                                                PrimaryKeyType>> * = nullptr) {
-  }
-
-  static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {
-  }
-
-  static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {
-  }
-
-  template<typename AttributeType>
-  static void on_attribute(const char * /*id*/, AttributeType &/*val*/,
-                           const utils::field_attributes &/*attr*/ = utils::null_attributes) {
-  }
-
-  template<typename AttributeType>
-  static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/,
-                           const utils::field_attributes &/*attr*/ = utils::null_attributes) {
-  }
-
-  template<class ForeignPointerType>
-  void on_belongs_to(const char *id, ForeignPointerType &obj, const utils::foreign_attributes &attr);
-  template<class ForeignPointerType>
-  void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/);
-
-  template<class CollectionType>
-  void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr,
-                   std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> * = nullptr);
-  template<class CollectionType>
-  void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr,
-                   std::enable_if_t<!is_object_ptr<typename CollectionType::value_type>::value> * = nullptr);
-
-  template<class CollectionType>
-  void on_has_many_to_many(const char *id, CollectionType &collection, const char *join_column,
-                           const char *inverse_join_column, const utils::foreign_attributes &attr);
-  template<class CollectionType>
-  void on_has_many_to_many(const char *id, CollectionType &collection, const utils::foreign_attributes &attr);
-
-private:
-  explicit relation_completer(const std::shared_ptr<schema_node> &node)
-    : node_(node)
-      , schema_(node->schema_)
-      , log_(logger::create_logger("relation_completer")) {
-  }
-
-  static void register_relation_endpoints(const endpoint_ptr &endpoint,
-                                          const endpoint_ptr &other_endpoint);
-  static void link_relation_endpoints(const endpoint_ptr &endpoint,
-                                      const endpoint_ptr &other_endpoint);
-
-  template<typename ValueType>
-  void ensure_type_is_known();
-
-private:
-  std::shared_ptr<schema_node> node_;
-  schema &schema_;
-  logger::logger log_;
-  join_columns_collector join_columns_collector_;
-};
-
-
 class schema {
 public:
   typedef const_schema_node_iterator const_iterator; /**< Shortcut for the list const iterator. */
@@ -145,14 +38,20 @@ public:
 
   template<typename Type>
   [[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, const std::string &parent = "") {
-    // if (has_node(name)) {
-      // return utils::failure(make_error(error_code::NodeAlreadyExists, "Node '" + name + "' already exists"));
-    // }
-    auto node = schema_node::make_node<Type>(*this, name);
-    relation_completer<Type>::complete(node);
-    if (auto result = attach_node(node, parent); !result) {
-      return utils::failure(result.err());
-    }
+      if (const auto it = nodes_by_type_.find(typeid(Type)); it == nodes_by_type_.end() ) {
+          auto node = schema_node::make_node<Type>(*this, name);
+          foreign_node_completer::complete<Type>(node);
+          relation_completer<Type>::complete(node);
+          if (auto result = attach_node(node, parent); !result) {
+              return utils::failure(result.err());
+          }
+      } else if (!has_node(name)) {
+          it->second->update_name(name);
+          nodes_by_name_[name] = it->second;
+          log_.info("attach: update node name to '%s' (type: %s)", it->second->name().c_str(), it->second->type_index().name());
+      } else {
+          return utils::failure(make_error(error_code::NodeAlreadyExists, "Node '" + name + "' already exists"));
+      }
 
     return utils::ok<void>();
   }
@@ -162,16 +61,22 @@ public:
     const auto ti = std::type_index(typeid(SuperType));
     auto result = find_node(ti);
     if (!result) {
-      return utils::failure(make_error(error_code::NodeNotFound,
-                                       "Parent node '" + std::string(ti.name()) + "' not found"));
+      return utils::failure(make_error(error_code::NodeNotFound, "Parent node '" + std::string(ti.name()) + "' not found"));
     }
 
     return attach<Type>(name, (*result)->name());
   }
 
 
+  /**
+   * Detaches a given node from the schema. If the
+   * node is a parent of other nodes, these nodes  are
+   * detached as well.
+   *
+   * @param node Node to detach from schema
+   * @return Result object indicating success or failure
+   */
   [[nodiscard]] utils::result<void, utils::error> detach(const node_ptr &node);
-  // [[nodiscard]] utils::result<void, utils::error> detach(const std::string& name);
 
   /**
    * Return the first schema node.
@@ -209,6 +114,14 @@ public:
    */
   [[nodiscard]] std::string name() const;
 
+  [[nodiscard]] bool contains(const std::string &name) const;
+  [[nodiscard]] bool contains(const std::type_index &index) const;
+  template < typename Type >
+  [[nodiscard]] bool contains() const {
+    return contains(std::type_index(typeid(Type)));
+  }
+
+
   template<typename Type>
   [[nodiscard]] utils::result<object_info_ref<Type>, utils::error> info() const {
     auto result = find_node(std::type_index(typeid(Type)));
@@ -238,10 +151,8 @@ private:
   using t_node_map = std::unordered_map<std::string, node_ptr>;
   using t_type_index_node_map = std::unordered_map<std::type_index, node_ptr>;
 
-  [[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const std::shared_ptr<schema_node> &node,
-                                                                  const std::string &parent);
-  [[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const std::shared_ptr<schema_node> &node,
-                                                                  const std::type_index &type_index);
+  [[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const node_ptr &node, const std::string &parent);
+  // [[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const node_ptr &node, const std::type_index &type_index);
   [[nodiscard]] utils::result<node_ptr, utils::error> find_node(const std::string &name) const;
   [[nodiscard]] utils::result<node_ptr, utils::error> find_node(const std::type_index &type_index) const;
   template<typename Type>
@@ -257,8 +168,8 @@ private:
   void remove_node(const node_ptr &node);
 
 private:
-  template<typename Type>
-  friend class relation_completer;
+  friend class internal::shadow_schema;
+  friend class foreign_node_completer;
 
   std::string name_;
   std::shared_ptr<schema_node> root_;
@@ -267,241 +178,6 @@ private:
   t_type_index_node_map nodes_by_type_;
   logger::logger log_;
 };
-
-template<typename Type>
-template<class CollectionType>
-void relation_completer<Type>::on_has_many(const char *id, CollectionType &,
-                                           const char *join_column,
-                                           const utils::foreign_attributes &,
-                                           std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> * /*unused*/) {
-  // Shortcut to value type of object_ptr::value_type in collection
-  using value_type = typename CollectionType::value_type::value_type;
-
-  // Check if the object_ptr type is already inserted in the schema (by id)
-  if (auto result = schema_.find_node(id); !result) {
-    // Type was not found.
-    // Ensure value_type is known to the schema. Name will be added later
-    ensure_type_is_known<value_type>();
-    // Create and attach the relation node.
-    const std::type_index ti = typeid(many_to_many_relation<value_type, Type>);
-    if (const auto endpoint = node_->info().find_relation_endpoint(ti); endpoint == node_->info().endpoint_end()) {
-      // Endpoint was not found
-      log_.debug("node '%s' has has many foreign keys '%s' mapped by '%s'", node_->name().c_str(), id, join_column);
-      const auto node = schema_node::make_relation_node<many_to_many_relation<value_type, Type> >(
-        schema_, id, [join_column] {
-          return std::make_unique<many_to_many_relation<value_type, Type> >(join_column, "id");
-        });
-      result = schema_.attach_node(node, "");
-      if (!result) {
-        // Todo: throw internal error
-        return;
-      }
-      const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
-      const auto foreign_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
-      node_->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
-      foreign_endpoint->node_->info_->register_relation_endpoint(node_->type_index(), foreign_endpoint);
-      link_relation_endpoints(local_endpoint, foreign_endpoint);
-    }
-  } else {
-    // Type was found.
-    // Check if the relation node is already attached.
-    const auto &foreign_node = result.value();
-    if (const auto rit = foreign_node->info_->find_relation_endpoint(node_->type_index());
-      rit != foreign_node->info().endpoint_end()) {
-      if (rit->second->is_belongs_to()) {
-        rit->second->node_ = foreign_node;
-        const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
-        node_->info_->register_relation_endpoint(node_->type_index(), endpoint);
-        link_relation_endpoints(endpoint, rit->second);
-      } else {
-        // Todo: throw internal error relation node has invalid type
-      }
-    } else {
-      // Todo: throw internal error couldn't find relation node
-    }
-  }
-}
-
-template<typename Type>
-template<class CollectionType>
-void relation_completer<Type>::on_has_many(const char *id, CollectionType &, const char *join_column,
-                                           const utils::foreign_attributes &,
-                                           std::enable_if_t<!is_object_ptr<typename CollectionType::value_type>::value>
-                                           * /*unused*/) {
-  using value_type = typename CollectionType::value_type;
-  using relation_value_type = many_to_relation<Type, value_type>;
-
-  const auto node = schema_node::make_relation_node<relation_value_type>(
-    schema_, id, [join_column] {
-      return std::make_unique<relation_value_type>(join_column, "value");
-    });
-
-  const auto result = schema_.attach_node(node, "");
-  if (!result) {
-    // Todo: throw internal exception
-  }
-
-  const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
-  const auto foreign_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
-  node_->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
-  foreign_endpoint->node_->info_->register_relation_endpoint(node_->type_index(), foreign_endpoint);
-  link_relation_endpoints(local_endpoint, foreign_endpoint);
-}
-
-template<typename Type>
-template<class CollectionType>
-void relation_completer<Type>::on_has_many_to_many(const char *id,
-                                                   CollectionType &/*collection*/,
-                                                   const char *join_column,
-                                                   const char *inverse_join_column,
-                                                   const utils::foreign_attributes &/*attr*/) {
-  auto result = schema_.find_node(id);
-  if (result) {
-    const auto &foreign_node = result.value();
-    const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
-    node_->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type), local_endpoint);
-    const auto it = foreign_node->info_->find_relation_endpoint(node_->type_index());
-    if (it == foreign_node->info().endpoint_end()) {
-      // Todo: Throw error
-      return;
-    }
-    link_relation_endpoints(local_endpoint, it->second);
-  } else {
-    using relation_value_type = many_to_many_relation<typename CollectionType::value_type::value_type, Type>;
-    auto creator = [join_column, inverse_join_column] {
-      return std::make_unique<relation_value_type>(join_column, inverse_join_column);
-    };
-
-    auto node = schema_node::make_relation_node<relation_value_type>(schema_, id, std::move(creator));
-
-    auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
-    auto join_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
-    auto inverse_join_endpoint = std::make_shared<relation_endpoint>(inverse_join_column, relation_type::BELONGS_TO,
-                                                                     node);
-    node_->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type), local_endpoint);
-    node->info_->register_relation_endpoint(node_->type_index(), join_endpoint);
-    link_relation_endpoints(local_endpoint, join_endpoint);
-    node->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type),
-                                            inverse_join_endpoint);
-    result = schema_.attach_node(node, "");
-    if (!result) {
-      // Todo: throw internal error
-      return;
-    }
-  }
-}
-
-template<typename Type>
-template<class CollectionType>
-void relation_completer<Type>::on_has_many_to_many(const char *id,
-                                                   CollectionType &collection,
-                                                   const utils::foreign_attributes &attr) {
-  const auto join_columns = join_columns_collector_.collect<typename CollectionType::value_type::value_type>();
-  on_has_many_to_many(
-    id,
-    collection,
-    join_columns.inverse_join_column.c_str(),
-    join_columns.join_column.c_str(),
-    attr);
-}
-
-template<typename Type>
-template<class ForeignPointerType>
-void relation_completer<Type>::on_has_one(const char *id,
-                                          ForeignPointerType &/*obj*/,
-                                          const utils::foreign_attributes &/*attr*/) {
-  const auto ti = std::type_index(typeid(typename ForeignPointerType::value_type));
-  if (const auto result = schema_.find_node(ti); !result.is_ok()) {
-    // Node was not found
-    // Create node without the foreign relation endpoint
-    log_.debug("node '%s' has foreign key '%s' has one '%s'", node_->name().c_str(), id, ti.name());
-    node_->info_->
-        register_relation_endpoint(ti, std::make_shared<relation_endpoint>(id, relation_type::HAS_ONE, node_));
-  } else {
-    const auto &foreign_node = result.value();
-    if (const auto it = foreign_node->info().find_relation_endpoint(typeid(Type));
-      it != foreign_node->info().endpoint_end()) {
-      if (it->second->is_belongs_to()) {
-        it->second->node_ = foreign_node;
-        const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_ONE, node_);
-        node_->info_->register_relation_endpoint(ti, endpoint);
-        link_relation_endpoints(endpoint, it->second);
-      } else {
-        // Todo: Throw internal error
-        return;
-      }
-    }
-  }
-}
-
-template<typename Type>
-template<class ForeignPointerType>
-void relation_completer<Type>::on_belongs_to(const char *id,
-                                             ForeignPointerType & /*obj*/,
-                                             const utils::foreign_attributes & /*attr*/) {
-  using value_type = typename ForeignPointerType::value_type;
-  const auto ti = std::type_index(typeid(value_type));
-  if (auto result = schema_.find_node(ti); !result) {
-    // Type was not found
-    // Create node without the foreign relation endpoint
-    log_.debug("node '%s' has foreign key '%s' belongs to '%s'", node_->name().c_str(), id, ti.name());
-    node_->info_->register_relation_endpoint(
-      ti, std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, schema::node_ptr{}));
-  } else {
-    // Type was found
-    const auto &foreign_node = result.value();
-    // Check foreign node and relation endpoint
-    if (const auto it = foreign_node->info_->find_relation_endpoint(typeid(Type));
-      it != foreign_node->info().endpoint_end()) {
-      // Found corresponding relation endpoint in the foreign node
-      if (it->second->is_has_one()) {
-        const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, node_);
-        node_->info_->register_relation_endpoint(ti, endpoint);
-        link_relation_endpoints(endpoint, it->second);
-      } else if (it->second->foreign_endpoint()->node().type_index() == typeid(many_to_many_relation<Type,
-                   value_type>)) {
-        // Endpoint is a "many_to_many_relation". This means there
-        // is a "many_to_many_relation" node attached. Because of being a
-        // "belongs_to"-relation the "many_to_many_relation" can be removed
-        // (detach), and the endpoints must be adjusted
-        const auto foreign_endpoint = it->second->foreign_endpoint();
-        const auto detach_result = schema_.detach(foreign_endpoint->node_);
-        foreign_endpoint->node_ = node_;
-        node_->info_->register_relation_endpoint(node_->type_index(), foreign_endpoint);
-      } else {
-        // check type
-      }
-    } else {
-      // Relation node was not found, create only endpoint.
-      const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, node_);
-      node_->info_->register_relation_endpoint(ti, endpoint);
-    }
-  }
-}
-
-template<typename Type>
-void relation_completer<Type>::register_relation_endpoints(const endpoint_ptr &endpoint,
-                                                           const endpoint_ptr &other_endpoint) {
-  endpoint->node_->info_->register_relation_endpoint(other_endpoint->node_->type_index(), endpoint);
-  other_endpoint->node_->info_->register_relation_endpoint(endpoint->node_->type_index(), other_endpoint);
-  link_relation_endpoints(endpoint, other_endpoint);
-}
-
-template<typename Type>
-void relation_completer<Type>::link_relation_endpoints(const endpoint_ptr &endpoint, const endpoint_ptr &other_endpoint) {
-  endpoint->link_foreign_endpoint(other_endpoint);
-  other_endpoint->link_foreign_endpoint(endpoint);
-}
-
-template<typename Type>
-template<typename ValueType>
-void relation_completer<Type>::ensure_type_is_known() {
-  if (auto result = schema_.find_node<ValueType>(); result) {
-    return;
-  }
-  auto result = schema_.attach_node(schema_node::make_node<Type>(schema_, ""), "");
-  relation_completer<ValueType>::complete(result.value());
-}
 }
 
 #endif //SCHEMA_HPP

include/matador/object/schema_node.hpp

@@ -83,8 +83,9 @@ private:
 
 private:
   friend class schema;
-  template <typename Type>
+  template<typename Type>
   friend class relation_completer;
+  friend class foreign_node_completer;
   friend class const_schema_node_iterator;
 
   object::schema &schema_;