Merge branch 'develop'

97 files changed, 1550 insertions, 916 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 53ae5df..6690c4c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,10 +3,10 @@ cmake_minimum_required(VERSION 3.0)
 cmake_policy(SET CMP0048 NEW)
 cmake_policy(SET CMP0028 NEW)
 
-project(sink VERSION 0.2.0)
+project(sink VERSION 0.3.0)
 
 option(BUILD_MAILDIR "BUILD_MAILDIR" ON)
-option(BUILD_DAV "BUILD_DAV" OFF)
+option(BUILD_DAV "BUILD_DAV" ON)
 option(AVOID_BINDING_REBUILD "AVOID_BINDING_REBUILD" OFF)
 option(CATCH_ERRORS "CATCH_ERRORS" OFF)
 option(ENABLE_MEMCHECK "Build valgrind tests" OFF)
@@ -28,7 +28,7 @@ include(KDEInstallDirs)
 find_package(Qt5 COMPONENTS REQUIRED Core Network Gui)
 find_package(KF5 COMPONENTS REQUIRED Mime Contacts)
 find_package(FlatBuffers REQUIRED 1.4.0)
-find_package(KAsync REQUIRED 0.1.0)
+find_package(KAsync REQUIRED 0.1.2)
 find_package(LMDB REQUIRED 0.9)
 
 find_program(MEMORYCHECK_COMMAND valgrind)
diff --git a/common/bufferadaptor.h b/common/bufferadaptor.h
index fd4809b..f393388 100644
--- a/common/bufferadaptor.h
+++ b/common/bufferadaptor.h
@@ -66,8 +66,7 @@ public:
     virtual QVariant getProperty(const QByteArray &key) const
     {
         if (!mValues.contains(key)) {
-            qWarning() << "Tried to read value that is not available; Did you forget to call Query::request? Property: " << key;
-            return QVariant{};
+            return {};
         }
         return mValues.value(key);
     }
diff --git a/common/bufferutils.h b/common/bufferutils.h
index 6763ced..f0460b7 100644
--- a/common/bufferutils.h
+++ b/common/bufferutils.h
@@ -38,7 +38,7 @@ static flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::
 {
     std::vector<flatbuffers::Offset<flatbuffers::String>> modifiedPropertiesList;
     for (const auto &change : list) {
-        auto s = fbb.CreateString(change);
+        auto s = fbb.CreateString(change.toStdString());
         modifiedPropertiesList.push_back(s);
     }
     return fbb.CreateVector(modifiedPropertiesList);
diff --git a/common/changereplay.cpp b/common/changereplay.cpp
index 7895b66..0adbd78 100644
--- a/common/changereplay.cpp
+++ b/common/changereplay.cpp
@@ -30,8 +30,7 @@ using namespace Sink;
 using namespace Sink::Storage;
 
 ChangeReplay::ChangeReplay(const ResourceContext &resourceContext, const Sink::Log::Context &ctx)
-    : mStorage(storageLocation(), resourceContext.instanceId(), DataStore::ReadOnly), mChangeReplayStore(storageLocation(), resourceContext.instanceId() + ".changereplay", DataStore::ReadWrite), mReplayInProgress(false), mLogCtx{ctx.subContext("changereplay")},
-    mGuard{new QObject}
+    : mStorage(storageLocation(), resourceContext.instanceId(), DataStore::ReadOnly), mChangeReplayStore(storageLocation(), resourceContext.instanceId() + ".changereplay", DataStore::ReadWrite), mReplayInProgress(false), mLogCtx{ctx.subContext("changereplay")}
 {
 }
 
@@ -84,6 +83,8 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
             auto replayStoreTransaction = mChangeReplayStore.createTransaction(DataStore::ReadOnly, [this](const DataStore::Error &error) {
                 SinkWarningCtx(mLogCtx) << error.message;
             });
+            Q_ASSERT(mMainStoreTransaction);
+            Q_ASSERT(replayStoreTransaction);
             replayStoreTransaction.openDatabase().scan("lastReplayedRevision",
                 [lastReplayedRevision](const QByteArray &key, const QByteArray &value) -> bool {
                     *lastReplayedRevision = value.toLongLong();
@@ -98,16 +99,13 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
             SinkTraceCtx(mLogCtx) << "Changereplay from " << *lastReplayedRevision << " to " << *topRevision;
             return KAsync::doWhile(
                 [this, lastReplayedRevision, topRevision]() -> KAsync::Job<KAsync::ControlFlowFlag> {
-                    if (!mGuard) {
-                        SinkTraceCtx(mLogCtx) << "Exit due to guard";
-                        return KAsync::value(KAsync::Break);
-                    }
                     if (*lastReplayedRevision >= *topRevision) {
                         SinkTraceCtx(mLogCtx) << "Done replaying" << *lastReplayedRevision << *topRevision;
                         return KAsync::value(KAsync::Break);
                     }
+                    Q_ASSERT(mMainStoreTransaction);
 
-                    KAsync::Job<void> replayJob = KAsync::null<void>();
+                    auto replayJob = KAsync::null();
                     qint64 revision = *lastReplayedRevision + 1;
                     while (revision <= *topRevision) {
                         const auto uid = DataStore::getUidFromRevision(mMainStoreTransaction, revision);
@@ -131,14 +129,14 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
                                 if (canReplay(type, key, entityBuffer)) {
                                     SinkTraceCtx(mLogCtx) << "Replaying " << key;
                                     replayJob = replay(type, key, entityBuffer);
+                                    //Set the last revision we tried to replay
+                                    *lastReplayedRevision = revision;
+                                    //Execute replay job and commit
+                                    break;
                                 } else {
-                                    SinkTraceCtx(mLogCtx) << "Cannot replay " << key;
+                                    SinkTraceCtx(mLogCtx) << "Not replaying " << key;
                                     //We silently skip over revisions that cannot be replayed, as this is not an error.
-                                    replayJob = KAsync::null();
                                 }
-                                //Set the last revision we tried to replay
-                                *lastReplayedRevision = revision;
-                                break;
                             }
                         }
                         //Bump the revision if we failed to even attempt to replay. This will simply skip over those revisions, as we can't recover from those situations.
@@ -149,22 +147,22 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
                         if (error) {
                             SinkWarningCtx(mLogCtx) << "Change replay failed: " << error  << "Last replayed revision: "  << *lastReplayedRevision;
                             //We're probably not online or so, so postpone retrying
-                            return KAsync::value(KAsync::Break);
+                            return KAsync::value(KAsync::Break).then(KAsync::error<KAsync::ControlFlowFlag>(error));
+                        }
+                        SinkTraceCtx(mLogCtx) << "Replayed until: " << *lastReplayedRevision;
+
+                        recordReplayedRevision(*lastReplayedRevision);
+                        reportProgress(*lastReplayedRevision, *topRevision);
+
+                        const bool gotMoreToReplay = (*lastReplayedRevision < *topRevision);
+                        if (gotMoreToReplay) {
+                            SinkTraceCtx(mLogCtx) << "Replaying some more...";
+                            //Replay more if we have more
+                            return KAsync::wait(0).then(KAsync::value(KAsync::Continue));
                         } else {
-                            SinkTraceCtx(mLogCtx) << "Replayed until: " << *lastReplayedRevision;
-                            recordReplayedRevision(*lastReplayedRevision);
-                            if (*lastReplayedRevision < *topRevision) {
-                                SinkTraceCtx(mLogCtx) << "Replaying some more...";
-                                //Replay more if we have more
-                                return KAsync::wait(0).then(KAsync::value(KAsync::Continue));
-                            } else {
-                                return KAsync::value(KAsync::Break);
-                            }
+                            return KAsync::value(KAsync::Break);
                         }
-                        //We shouldn't ever get here
-                        Q_ASSERT(false);
-                        return KAsync::value(KAsync::Break);
-                    });
+                    }).guard(&mGuard);
             });
         })
         .then([this](const KAsync::Error &error) {
@@ -181,7 +179,12 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
                     emit changesReplayed();
                 }
             }
-        });
+            if (error) {
+                return KAsync::error(error);
+            } else {
+                return KAsync::null();
+            }
+        }).guard(&mGuard);
 }
 
 void ChangeReplay::revisionChanged()
diff --git a/common/changereplay.h b/common/changereplay.h
index edc4462..22e26a5 100644
--- a/common/changereplay.h
+++ b/common/changereplay.h
@@ -54,6 +54,7 @@ public slots:
 protected:
     virtual KAsync::Job<void> replay(const QByteArray &type, const QByteArray &key, const QByteArray &value) = 0;
     virtual bool canReplay(const QByteArray &type, const QByteArray &key, const QByteArray &value) = 0;
+    virtual void reportProgress(int progress, int total, const QByteArrayList &applicableEntities = {}){};
     Sink::Storage::DataStore mStorage;
     KAsync::Job<void> replayNextRevision();
 
@@ -63,7 +64,7 @@ private:
     bool mReplayInProgress;
     Sink::Storage::DataStore::Transaction mMainStoreTransaction;
     Sink::Log::Context mLogCtx;
-    QSharedPointer<QObject> mGuard;
+    QObject mGuard;
 };
 
 class NullChangeReplay : public ChangeReplay
diff --git a/common/commands.cpp b/common/commands.cpp
index eeb7f08..24f2017 100644
--- a/common/commands.cpp
+++ b/common/commands.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
+ * Copyright (C) 2016 Christian Mollekopf <mollekopf@kolabsys.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,7 +21,7 @@
 
 #include "commands.h"
 
-#include <QIODevice>
+#include <QLocalSocket>
 #include <log.h>
 
 namespace Sink {
@@ -73,19 +74,19 @@ int headerSize()
     return sizeof(int) + (sizeof(uint) * 2);
 }
 
-void write(QIODevice *device, int messageId, int commandId)
+void write(QLocalSocket *device, int messageId, int commandId)
 {
     write(device, messageId, commandId, 0, 0);
 }
 
-static void write(QIODevice *device, const char *buffer, uint size)
+static void write(QLocalSocket *device, const char *buffer, uint size)
 {
     if (device->write(buffer, size) < 0) {
         SinkWarningCtx(Sink::Log::Context{"commands"}) << "Error while writing " << device->errorString();
     }
 }
 
-void write(QIODevice *device, int messageId, int commandId, const char *buffer, uint size)
+void write(QLocalSocket *device, int messageId, int commandId, const char *buffer, uint size)
 {
     if (size > 0 && !buffer) {
         size = 0;
@@ -97,15 +98,16 @@ void write(QIODevice *device, int messageId, int commandId, const char *buffer,
     if (buffer) {
         write(device, buffer, size);
     }
+    //The default implementation will happily buffer 200k bytes before sending it out which doesn't make the sytem exactly responsive.
+    //1k is arbitrary, but fits a bunch of messages at least.
+    if (device->bytesToWrite() > 1000) {
+        device->flush();
+    }
 }
 
-void write(QIODevice *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb)
+void write(QLocalSocket *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb)
 {
-    const int dataSize = fbb.GetSize();
-    write(device, (const char *)&messageId, sizeof(int));
-    write(device, (const char *)&commandId, sizeof(int));
-    write(device, (const char *)&dataSize, sizeof(int));
-    write(device, (const char *)fbb.GetBufferPointer(), dataSize);
+    write(device, messageId, commandId, (const char *)fbb.GetBufferPointer(), fbb.GetSize());
 }
 
 } // namespace Commands
diff --git a/common/commands.h b/common/commands.h
index 6d5d39b..1548eac 100644
--- a/common/commands.h
+++ b/common/commands.h
@@ -24,7 +24,7 @@
 #include <flatbuffers/flatbuffers.h>
 #include <QByteArray>
 
-class QIODevice;
+class QLocalSocket;
 
 namespace Sink {
 
@@ -55,9 +55,9 @@ enum CommandIds
 QByteArray name(int commandId);
 
 int SINK_EXPORT headerSize();
-void SINK_EXPORT write(QIODevice *device, int messageId, int commandId);
-void SINK_EXPORT write(QIODevice *device, int messageId, int commandId, const char *buffer, uint size);
-void SINK_EXPORT write(QIODevice *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb);
+void SINK_EXPORT write(QLocalSocket *device, int messageId, int commandId);
+void SINK_EXPORT write(QLocalSocket *device, int messageId, int commandId, const char *buffer, uint size);
+void SINK_EXPORT write(QLocalSocket *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb);
 }
 
 } // namespace Sink
diff --git a/common/commands/notification.fbs b/common/commands/notification.fbs
index 517111c..7ced666 100644
--- a/common/commands/notification.fbs
+++ b/common/commands/notification.fbs
@@ -5,6 +5,8 @@ table Notification {
     identifier: string; //An identifier that links back to the something related to the notification (e.g. a command id)
     message: string;
     code: int = 0; //See notification.h
+    progress: int = 0; //See notification.h
+    total: int = 0; //See notification.h
     entities: [string]; //A list of entities this applies to
 }
 
diff --git a/common/configstore.cpp b/common/configstore.cpp
index 1ae9da8..6751907 100644
--- a/common/configstore.cpp
+++ b/common/configstore.cpp
@@ -24,8 +24,6 @@
 #include <log.h>
 #include <definitions.h>
 
-SINK_DEBUG_AREA("configstore")
-
 static QSharedPointer<QSettings> getConfig(const QByteArray &identifier)
 {
     return QSharedPointer<QSettings>::create(Sink::configLocation() + "/" + identifier + ".ini", QSettings::IniFormat);
diff --git a/common/contactpreprocessor.cpp b/common/contactpreprocessor.cpp
index ac2c3bc..d331421 100644
--- a/common/contactpreprocessor.cpp
+++ b/common/contactpreprocessor.cpp
@@ -35,6 +35,8 @@ void updatedProperties(Sink::ApplicationDomain::Contact &contact, const KContact
         emails << Sink::ApplicationDomain::Contact::Email{Sink::ApplicationDomain::Contact::Email::Undefined, email};
     }
     contact.setEmails(emails);
+
+    contact.setPhoto(addressee.photo().rawData());
 }
 
 ContactPropertyExtractor::~ContactPropertyExtractor()
diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 2e0c348..4c95606 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -43,6 +43,8 @@ class Source : public FilterBase {
 
     QVector<QByteArray> mIds;
     QVector<QByteArray>::ConstIterator mIt;
+    QVector<QByteArray> mIncrementalIds;
+    QVector<QByteArray>::ConstIterator mIncrementalIt;
 
     Source (const QVector<QByteArray> &ids, DataStoreQuery *store)
         : FilterBase(store),
@@ -63,21 +65,36 @@ class Source : public FilterBase {
 
     void add(const QVector<QByteArray> &ids)
     {
-        mIds = ids;
-        mIt = mIds.constBegin();
+        mIncrementalIds = ids;
+        mIncrementalIt = mIncrementalIds.constBegin();
     }
 
     bool next(const std::function<void(const ResultSet::Result &result)> &callback) Q_DECL_OVERRIDE
     {
-        if (mIt == mIds.constEnd()) {
-            return false;
+        if (!mIncrementalIds.isEmpty()) {
+            if (mIncrementalIt == mIncrementalIds.constEnd()) {
+                return false;
+            }
+            readEntity(*mIncrementalIt, [this, callback](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                SinkTraceCtx(mDatastore->mLogCtx) << "Source: Read entity: " << entity.identifier() << operationName(operation);
+                callback({entity, operation});
+            });
+            mIncrementalIt++;
+            if (mIncrementalIt == mIncrementalIds.constEnd()) {
+                return false;
+            }
+            return true;
+        } else {
+            if (mIt == mIds.constEnd()) {
+                return false;
+            }
+            readEntity(*mIt, [this, callback](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                SinkTraceCtx(mDatastore->mLogCtx) << "Source: Read entity: " << entity.identifier() << operationName(operation);
+                callback({entity, operation});
+            });
+            mIt++;
+            return mIt != mIds.constEnd();
         }
-        readEntity(*mIt, [this, callback](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
-            SinkTraceCtx(mDatastore->mLogCtx) << "Source: Read entity: " << entity.identifier() << operationName(operation);
-            callback({entity, operation});
-        });
-        mIt++;
-        return mIt != mIds.constEnd();
     }
 };
 
@@ -599,6 +616,10 @@ ResultSet DataStoreQuery::update(qint64 baseRevision)
     return ResultSet(generator, [this]() { mCollector->skip(); });
 }
 
+void DataStoreQuery::updateComplete()
+{
+    mSource->mIncrementalIds.clear();
+}
 
 ResultSet DataStoreQuery::execute()
 {
diff --git a/common/datastorequery.h b/common/datastorequery.h
index ee5f99e..de4ae26 100644
--- a/common/datastorequery.h
+++ b/common/datastorequery.h
@@ -50,6 +50,7 @@ public:
     ~DataStoreQuery();
     ResultSet execute();
     ResultSet update(qint64 baseRevision);
+    void updateComplete();
 
     State::Ptr getState();
 
diff --git a/common/definitions.cpp b/common/definitions.cpp
index 3fc4700..17977bc 100644
--- a/common/definitions.cpp
+++ b/common/definitions.cpp
@@ -23,6 +23,17 @@
 #include <QStandardPaths>
 #include <QDir>
 
+static bool rereadDataLocation = true;
+static bool rereadConfigLocation = true;
+static bool rereadTemporaryFileLocation = true;
+
+void Sink::clearLocationCache()
+{
+    rereadDataLocation = true;
+    rereadConfigLocation = true;
+    rereadTemporaryFileLocation = true;
+}
+
 QString Sink::storageLocation()
 {
     return dataLocation() + "/storage";
@@ -30,21 +41,37 @@ QString Sink::storageLocation()
 
 QString Sink::dataLocation()
 {
-    return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/sink";
+    static QString location;
+    if (rereadDataLocation) {
+        location = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/sink";
+        rereadDataLocation = false;
+    }
+    return location;
 }
 
 QString Sink::configLocation()
 {
-    return QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/sink";
+    static QString location;
+    if (rereadConfigLocation) {
+        location = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/sink";
+        rereadConfigLocation = false;
+    }
+    return location;
 }
 
 QString Sink::temporaryFileLocation()
 {
-    auto path = dataLocation() + "/temporaryFiles";
-    //FIXME create in a singleton on startup?
-    QDir dir;
-    dir.mkpath(path);
-    return path;
+    static QString location;
+    static bool dirCreated = false;
+    if (rereadTemporaryFileLocation) {
+        location = dataLocation() + "/temporaryFiles";
+        dirCreated = QDir{}.mkpath(location);
+        rereadTemporaryFileLocation = false;
+    }
+    if (!dirCreated && QDir{}.mkpath(location)) {
+        dirCreated = true;
+    }
+    return location;
 }
 
 QString Sink::resourceStorageLocation(const QByteArray &resourceInstanceIdentifier)
diff --git a/common/definitions.h b/common/definitions.h
index e8cd45e..ce9e794 100644
--- a/common/definitions.h
+++ b/common/definitions.h
@@ -25,6 +25,7 @@
 #include <QByteArray>
 
 namespace Sink {
+void SINK_EXPORT clearLocationCache();
 QString SINK_EXPORT storageLocation();
 QString SINK_EXPORT dataLocation();
 QString SINK_EXPORT configLocation();
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index 67d463f..3718f77 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -25,8 +25,6 @@
 #include "storage.h" //for generateUid()
 #include <QFile>
 
-SINK_DEBUG_AREA("applicationdomaintype");
-
 QDebug Sink::ApplicationDomain::operator<< (QDebug d, const Sink::ApplicationDomain::Mail::Contact &c)
 {
     d << "Contact(" << c.name << ", " << c.emailAddress << ")";
@@ -114,6 +112,7 @@ SINK_REGISTER_PROPERTY(Contact, Lastname);
 SINK_REGISTER_PROPERTY(Contact, Emails);
 SINK_REGISTER_PROPERTY(Contact, Vcard);
 SINK_REGISTER_PROPERTY(Contact, Addressbook);
+SINK_REGISTER_PROPERTY(Contact, Photo);
 
 SINK_REGISTER_ENTITY(Addressbook);
 SINK_REGISTER_PROPERTY(Addressbook, Name);
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index e5aa46e..602d54c 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -377,6 +377,7 @@ struct SINK_EXPORT Contact : public Entity {
     SINK_PROPERTY(QString, Lastname, lastname);
     SINK_PROPERTY(QList<Email>, Emails, emails);
     SINK_PROPERTY(QByteArray, Vcard, vcard);
+    SINK_PROPERTY(QByteArray, Photo, photo);
     SINK_REFERENCE_PROPERTY(Addressbook, Addressbook, addressbook);
 };
 
diff --git a/common/domain/contact.fbs b/common/domain/contact.fbs
index d941d5a..e689756 100644
--- a/common/domain/contact.fbs
+++ b/common/domain/contact.fbs
@@ -13,6 +13,7 @@ table Contact {
   addressbook:string;
   emails: [ContactEmail];
   vcard: string;
+  photo: string;
 }
 
 root_type Contact;
diff --git a/common/domain/typeimplementations.cpp b/common/domain/typeimplementations.cpp
index eb3851e..47a9cf7 100644
--- a/common/domain/typeimplementations.cpp
+++ b/common/domain/typeimplementations.cpp
@@ -28,25 +28,52 @@
 #include "entity_generated.h"
 #include "mail/threadindexer.h"
 #include "domainadaptor.h"
+#include "typeimplementations_p.h"
 
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
+#define SINK_REGISTER_SERIALIZER(MAPPER, ENTITYTYPE, PROPERTY, LOWERCASEPROPERTY) \
+    MAPPER.addMapping<ENTITYTYPE::PROPERTY, Sink::ApplicationDomain::Buffer::ENTITYTYPE, Sink::ApplicationDomain::Buffer::ENTITYTYPE##Builder>(&Sink::ApplicationDomain::Buffer::ENTITYTYPE::LOWERCASEPROPERTY, &Sink::ApplicationDomain::Buffer::ENTITYTYPE##Builder::add_##LOWERCASEPROPERTY);
+
+typedef IndexConfig<Mail,
+        ValueIndex<Mail::Date>,
+        ValueIndex<Mail::Folder>,
+        ValueIndex<Mail::ParentMessageId>,
+        ValueIndex<Mail::MessageId>,
+        ValueIndex<Mail::Draft>,
+        SortedIndex<Mail::Folder, Mail::Date>,
+        SecondaryIndex<Mail::MessageId, Mail::ThreadId>,
+        SecondaryIndex<Mail::ThreadId, Mail::MessageId>,
+        CustomSecondaryIndex<Mail::MessageId, Mail::ThreadId, ThreadIndexer>
+    > MailIndexConfig;
+
+typedef IndexConfig<Folder,
+        ValueIndex<Folder::Name>,
+        ValueIndex<Folder::Parent>
+    > FolderIndexConfig;
+
+typedef IndexConfig<Contact,
+        ValueIndex<Contact::Uid>
+    > ContactIndexConfig;
+
+typedef IndexConfig<Addressbook,
+        ValueIndex<Addressbook::Parent>
+    > AddressbookIndexConfig;
+
+typedef IndexConfig<Event,
+        ValueIndex<Event::Uid>
+    > EventIndexConfig;
+
+
 void TypeImplementation<Mail>::configure(TypeIndex &index)
 {
-    // index.addProperty<Mail::Sender>();
-    /* index.addProperty<QByteArray>(Mail::SenderName::name); */
-    /* index->addProperty<QString>(Mail::Subject::name); */
-    /* index->addFulltextProperty<QString>(Mail::Subject::name); */
-    index.addProperty<Mail::Date>();
-    index.addProperty<Mail::Folder>();
-    index.addPropertyWithSorting<Mail::Folder, Mail::Date>();
-    index.addProperty<Mail::ParentMessageId>();
-    index.addProperty<Mail::MessageId>();
+    MailIndexConfig::configure(index);
+}
 
-    index.addSecondaryPropertyIndexer<Mail::MessageId, Mail::ThreadId, ThreadIndexer>();
-    index.addSecondaryProperty<Mail::MessageId, Mail::ThreadId>();
-    index.addSecondaryProperty<Mail::ThreadId, Mail::MessageId>();
+QMap<QByteArray, int> TypeImplementation<Mail>::typeDatabases()
+{
+    return merge(QMap<QByteArray, int>{{QByteArray{Mail::name} + ".main", 0}}, MailIndexConfig::databases());
 }
 
 void TypeImplementation<Mail>::configure(IndexPropertyMapper &indexPropertyMapper)
@@ -61,69 +88,44 @@ void TypeImplementation<Mail>::configure(IndexPropertyMapper &indexPropertyMappe
         });
 }
 
-void TypeImplementation<Mail>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
-{
-    propertyMapper.addMapping<Mail::Sender, Buffer>(&Buffer::sender);
-    propertyMapper.addMapping<Mail::To, Buffer>(&Buffer::to);
-    propertyMapper.addMapping<Mail::Cc, Buffer>(&Buffer::cc);
-    propertyMapper.addMapping<Mail::Bcc, Buffer>(&Buffer::bcc);
-    propertyMapper.addMapping<Mail::Subject, Buffer>(&Buffer::subject);
-    propertyMapper.addMapping<Mail::Date, Buffer>(&Buffer::date);
-    propertyMapper.addMapping<Mail::Unread, Buffer>(&Buffer::unread);
-    propertyMapper.addMapping<Mail::Important, Buffer>(&Buffer::important);
-    propertyMapper.addMapping<Mail::Folder, Buffer>(&Buffer::folder);
-    propertyMapper.addMapping<Mail::MimeMessage, Buffer>(&Buffer::mimeMessage);
-    propertyMapper.addMapping<Mail::FullPayloadAvailable, Buffer>(&Buffer::fullPayloadAvailable);
-    propertyMapper.addMapping<Mail::Draft, Buffer>(&Buffer::draft);
-    propertyMapper.addMapping<Mail::Trash, Buffer>(&Buffer::trash);
-    propertyMapper.addMapping<Mail::Sent, Buffer>(&Buffer::sent);
-    propertyMapper.addMapping<Mail::MessageId, Buffer>(&Buffer::messageId);
-    propertyMapper.addMapping<Mail::ParentMessageId, Buffer>(&Buffer::parentMessageId);
-}
-
-void TypeImplementation<Mail>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
-{
-    propertyMapper.addMapping<Mail::Sender>(&BufferBuilder::add_sender);
-    propertyMapper.addMapping<Mail::To>(&BufferBuilder::add_to);
-    propertyMapper.addMapping<Mail::Cc>(&BufferBuilder::add_cc);
-    propertyMapper.addMapping<Mail::Bcc>(&BufferBuilder::add_bcc);
-    propertyMapper.addMapping<Mail::Subject>(&BufferBuilder::add_subject);
-    propertyMapper.addMapping<Mail::Date>(&BufferBuilder::add_date);
-    propertyMapper.addMapping<Mail::Unread>(&BufferBuilder::add_unread);
-    propertyMapper.addMapping<Mail::Important>(&BufferBuilder::add_important);
-    propertyMapper.addMapping<Mail::Folder>(&BufferBuilder::add_folder);
-    propertyMapper.addMapping<Mail::MimeMessage>(&BufferBuilder::add_mimeMessage);
-    propertyMapper.addMapping<Mail::FullPayloadAvailable>(&BufferBuilder::add_fullPayloadAvailable);
-    propertyMapper.addMapping<Mail::Draft>(&BufferBuilder::add_draft);
-    propertyMapper.addMapping<Mail::Trash>(&BufferBuilder::add_trash);
-    propertyMapper.addMapping<Mail::Sent>(&BufferBuilder::add_sent);
-    propertyMapper.addMapping<Mail::MessageId>(&BufferBuilder::add_messageId);
-    propertyMapper.addMapping<Mail::ParentMessageId>(&BufferBuilder::add_parentMessageId);
+void TypeImplementation<Mail>::configure(PropertyMapper &propertyMapper)
+{
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Sender, sender);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, To, to);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Cc, cc);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Bcc, bcc);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Subject, subject);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Date, date);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Unread, unread);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Important, important);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Folder, folder);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, MimeMessage, mimeMessage);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, FullPayloadAvailable, fullPayloadAvailable);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Draft, draft);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Trash, trash);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Sent, sent);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, MessageId, messageId);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, ParentMessageId, parentMessageId);
 }
 
 
 void TypeImplementation<Folder>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Folder::Parent::name);
-    index.addProperty<QString>(Folder::Name::name);
+    FolderIndexConfig::configure(index);
 }
 
-void TypeImplementation<Folder>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Folder>::typeDatabases()
 {
-    propertyMapper.addMapping<Folder::Parent, Buffer>(&Buffer::parent);
-    propertyMapper.addMapping<Folder::Name, Buffer>(&Buffer::name);
-    propertyMapper.addMapping<Folder::Icon, Buffer>(&Buffer::icon);
-    propertyMapper.addMapping<Folder::SpecialPurpose, Buffer>(&Buffer::specialpurpose);
-    propertyMapper.addMapping<Folder::Enabled, Buffer>(&Buffer::enabled);
+    return merge(QMap<QByteArray, int>{{QByteArray{Folder::name} + ".main", 0}}, FolderIndexConfig::databases());
 }
 
-void TypeImplementation<Folder>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
+void TypeImplementation<Folder>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Folder::Parent>(&BufferBuilder::add_parent);
-    propertyMapper.addMapping<Folder::Name>(&BufferBuilder::add_name);
-    propertyMapper.addMapping<Folder::Icon>(&BufferBuilder::add_icon);
-    propertyMapper.addMapping<Folder::SpecialPurpose>(&BufferBuilder::add_specialpurpose);
-    propertyMapper.addMapping<Folder::Enabled>(&BufferBuilder::add_enabled);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Parent, parent);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Name, name);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Icon, icon);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, SpecialPurpose, specialpurpose);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Enabled, enabled);
 }
 
 void TypeImplementation<Folder>::configure(IndexPropertyMapper &)
@@ -134,29 +136,24 @@ void TypeImplementation<Folder>::configure(IndexPropertyMapper &)
 
 void TypeImplementation<Contact>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Contact::Uid::name);
+    ContactIndexConfig::configure(index);
 }
 
-void TypeImplementation<Contact>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Contact>::typeDatabases()
 {
-    propertyMapper.addMapping<Contact::Uid, Buffer>(&Buffer::uid);
-    propertyMapper.addMapping<Contact::Fn, Buffer>(&Buffer::fn);
-    propertyMapper.addMapping<Contact::Emails, Buffer>(&Buffer::emails);
-    propertyMapper.addMapping<Contact::Vcard, Buffer>(&Buffer::vcard);
-    propertyMapper.addMapping<Contact::Addressbook, Buffer>(&Buffer::addressbook);
-    propertyMapper.addMapping<Contact::Firstname, Buffer>(&Buffer::firstname);
-    propertyMapper.addMapping<Contact::Lastname, Buffer>(&Buffer::lastname);
+    return merge(QMap<QByteArray, int>{{QByteArray{Contact::name} + ".main", 0}}, ContactIndexConfig::databases());
 }
 
-void TypeImplementation<Contact>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
+void TypeImplementation<Contact>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Contact::Uid>(&BufferBuilder::add_uid);
-    propertyMapper.addMapping<Contact::Fn>(&BufferBuilder::add_fn);
-    propertyMapper.addMapping<Contact::Emails>(&BufferBuilder::add_emails);
-    propertyMapper.addMapping<Contact::Vcard>(&BufferBuilder::add_vcard);
-    propertyMapper.addMapping<Contact::Addressbook>(&BufferBuilder::add_addressbook);
-    propertyMapper.addMapping<Contact::Firstname>(&BufferBuilder::add_firstname);
-    propertyMapper.addMapping<Contact::Lastname>(&BufferBuilder::add_lastname);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Uid, uid);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Fn, fn);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Emails, emails);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Vcard, vcard);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Addressbook, addressbook);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Firstname, firstname);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Lastname, lastname);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Photo, photo);
 }
 
 void TypeImplementation<Contact>::configure(IndexPropertyMapper &)
@@ -167,20 +164,18 @@ void TypeImplementation<Contact>::configure(IndexPropertyMapper &)
 
 void TypeImplementation<Addressbook>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Addressbook::Parent::name);
-    index.addProperty<QString>(Addressbook::Name::name);
+    AddressbookIndexConfig::configure(index);
 }
 
-void TypeImplementation<Addressbook>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Addressbook>::typeDatabases()
 {
-    propertyMapper.addMapping<Addressbook::Parent, Buffer>(&Buffer::parent);
-    propertyMapper.addMapping<Addressbook::Name, Buffer>(&Buffer::name);
+    return merge(QMap<QByteArray, int>{{QByteArray{Addressbook::name} + ".main", 0}}, AddressbookIndexConfig::databases());
 }
 
-void TypeImplementation<Addressbook>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
+void TypeImplementation<Addressbook>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Addressbook::Parent>(&BufferBuilder::add_parent);
-    propertyMapper.addMapping<Addressbook::Name>(&BufferBuilder::add_name);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Addressbook, Parent, parent);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Addressbook, Name, name);
 }
 
 void TypeImplementation<Addressbook>::configure(IndexPropertyMapper &)
@@ -191,26 +186,24 @@ void TypeImplementation<Addressbook>::configure(IndexPropertyMapper &)
 
 void TypeImplementation<Event>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Event::Uid::name);
+    EventIndexConfig::configure(index);
 }
 
-void TypeImplementation<Event>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Event>::typeDatabases()
 {
-    propertyMapper.addMapping<Event::Summary, Buffer>(&Buffer::summary);
-    propertyMapper.addMapping<Event::Description, Buffer>(&Buffer::description);
-    propertyMapper.addMapping<Event::Uid, Buffer>(&Buffer::uid);
-    propertyMapper.addMapping<Event::Attachment, Buffer>(&Buffer::attachment);
+    return merge(QMap<QByteArray, int>{{QByteArray{Event::name} + ".main", 0}}, EventIndexConfig::databases());
 }
 
-void TypeImplementation<Event>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
+void TypeImplementation<Event>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Event::Summary>(&BufferBuilder::add_summary);
-    propertyMapper.addMapping<Event::Description>(&BufferBuilder::add_description);
-    propertyMapper.addMapping<Event::Uid>(&BufferBuilder::add_uid);
-    propertyMapper.addMapping<Event::Attachment>(&BufferBuilder::add_attachment);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Summary, summary);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Description, description);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Uid, uid);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Attachment, attachment);
 }
 
 void TypeImplementation<Event>::configure(IndexPropertyMapper &)
 {
 
 }
+
diff --git a/common/domain/typeimplementations.h b/common/domain/typeimplementations.h
index 37d6ca9..d36dfc1 100644
--- a/common/domain/typeimplementations.h
+++ b/common/domain/typeimplementations.h
@@ -26,10 +26,7 @@
 #include "contact_generated.h"
 #include "addressbook_generated.h"
 
-template<typename T>
-class ReadPropertyMapper;
-template<typename T>
-class WritePropertyMapper;
+class PropertyMapper;
 class IndexPropertyMapper;
 
 class TypeIndex;
@@ -48,9 +45,9 @@ public:
     typedef Sink::ApplicationDomain::Buffer::Mail Buffer;
     typedef Sink::ApplicationDomain::Buffer::MailBuilder BufferBuilder;
     static void configure(TypeIndex &index);
-    static void configure(ReadPropertyMapper<Buffer> &propertyMapper);
-    static void configure(WritePropertyMapper<BufferBuilder> &propertyMapper);
+    static void configure(PropertyMapper &propertyMapper);
     static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 
 template<>
@@ -59,9 +56,9 @@ public:
     typedef Sink::ApplicationDomain::Buffer::Folder Buffer;
     typedef Sink::ApplicationDomain::Buffer::FolderBuilder BufferBuilder;
     static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
+    static void configure(PropertyMapper &);
     static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 
 template<>
@@ -70,9 +67,9 @@ public:
     typedef Sink::ApplicationDomain::Buffer::Contact Buffer;
     typedef Sink::ApplicationDomain::Buffer::ContactBuilder BufferBuilder;
     static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
+    static void configure(PropertyMapper &);
     static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 
 template<>
@@ -81,9 +78,9 @@ public:
     typedef Sink::ApplicationDomain::Buffer::Addressbook Buffer;
     typedef Sink::ApplicationDomain::Buffer::AddressbookBuilder BufferBuilder;
     static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
+    static void configure(PropertyMapper &);
     static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 
 template<>
@@ -92,9 +89,9 @@ public:
     typedef Sink::ApplicationDomain::Buffer::Event Buffer;
     typedef Sink::ApplicationDomain::Buffer::EventBuilder BufferBuilder;
     static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
+    static void configure(PropertyMapper &);
     static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 
 }
diff --git a/common/domain/typeimplementations_p.h b/common/domain/typeimplementations_p.h
new file mode 100644
index 0000000..6f77a2d
--- /dev/null
+++ b/common/domain/typeimplementations_p.h
@@ -0,0 +1,154 @@
+/*
+ *   Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+
+#include "typeindex.h"
+#include <QMap>
+
+template <typename T, typename First>
+void mergeImpl(T &map, First f)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+}
+
+template <typename T, typename First, typename ... Tail>
+void mergeImpl(T &map, First f, Tail ...maps)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+    mergeImpl<T, Tail...>(map, maps...);
+}
+
+template <typename First, typename ... Tail>
+First merge(First f, Tail ...maps)
+{
+    First map;
+    mergeImpl(map, f, maps...);
+    return map;
+}
+
+template <typename Property>
+class ValueIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addProperty<Property>();
+    }
+
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return {{QByteArray{EntityType::name} +".index." + Property::name, 1}};
+    }
+};
+
+
+template <typename Property, typename SortProperty>
+class SortedIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addPropertyWithSorting<Property, SortProperty>();
+    }
+
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return {{QByteArray{EntityType::name} +".index." + Property::name + ".sort." + SortProperty::name, 1}};
+    }
+};
+
+template <typename Property, typename SecondaryProperty>
+class SecondaryIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addSecondaryProperty<Property, SecondaryProperty>();
+    }
+
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return {{QByteArray{EntityType::name} +".index." + Property::name + SecondaryProperty::name, 1}};
+    }
+};
+
+template <typename Property, typename SecondaryProperty, typename Indexer>
+class CustomSecondaryIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addSecondaryPropertyIndexer<Property, SecondaryProperty, Indexer>();
+    }
+
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return Indexer::databases();
+    }
+};
+
+template <typename EntityType, typename ... Indexes>
+class IndexConfig
+{
+    template <typename T>
+    static void applyIndex(TypeIndex &index)
+    {
+        T::configure(index);
+    }
+
+    ///Apply recursively for parameter pack
+    template <typename First, typename Second, typename ... Tail>
+    static void applyIndex(TypeIndex &index)
+    {
+        applyIndex<First>(index);
+        applyIndex<Second, Tail...>(index);
+    }
+
+    template <typename T>
+    static QMap<QByteArray, int> getDbs()
+    {
+        return T::template databases<EntityType>();
+    }
+
+    template <typename First, typename Second, typename ... Tail>
+    static QMap<QByteArray, int> getDbs()
+    {
+        return merge(getDbs<First>(), getDbs<Second, Tail...>());
+    }
+
+public:
+    static void configure(TypeIndex &index)
+    {
+        applyIndex<Indexes...>(index);
+    }
+
+    static QMap<QByteArray, int> databases()
+    {
+        return getDbs<Indexes...>();
+    }
+
+};
+
diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index af5d5fc..f981a1f 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -29,21 +29,19 @@
 #include "domain/typeimplementations.h"
 #include "bufferadaptor.h"
 #include "entity_generated.h"
-#include "metadata_generated.h"
 #include "entitybuffer.h"
 #include "propertymapper.h"
 #include "log.h"
-#include "dummy_generated.h"
 
 /**
  * Create a buffer from a domain object using the provided mappings
  */
 template <class Builder, class Buffer>
 flatbuffers::Offset<Buffer>
-createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, const WritePropertyMapper<Builder> &mapper)
+createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, const PropertyMapper &mapper)
 {
     // First create a primitives such as strings using the mappings
-    QList<std::function<void(Builder &)>> propertiesToAddToResource;
+    QList<std::function<void(void *builder)>> propertiesToAddToResource;
     for (const auto &property : domainObject.changedProperties()) {
         // SinkTrace() << "copying property " << property;
         const auto value = domainObject.getProperty(property);
@@ -57,7 +55,7 @@ createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObj
     // Then create all porperties using the above generated builderCalls
     Builder builder(fbb);
     for (auto propertyBuilder : propertiesToAddToResource) {
-        propertyBuilder(builder);
+        propertyBuilder(&builder);
     }
     return builder.Finish();
 }
@@ -68,7 +66,7 @@ createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObj
  * After this the buffer can be extracted from the FlatBufferBuilder object.
  */
 template <typename Buffer, typename BufferBuilder>
-static void createBufferPartBuffer(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, WritePropertyMapper<BufferBuilder> &mapper)
+static void createBufferPartBuffer(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, PropertyMapper &mapper)
 {
     auto pos = createBufferPart<BufferBuilder, Buffer>(domainObject, fbb, mapper);
     // Because we cannot template the following call
@@ -120,10 +118,8 @@ private:
 /**
  * A generic adaptor implementation that uses a property mapper to read/write values.
  */
-template <class LocalBuffer, class ResourceBuffer>
 class DatastoreBufferAdaptor : public Sink::ApplicationDomain::BufferAdaptor
 {
-    SINK_DEBUG_AREA("bufferadaptor")
 public:
     DatastoreBufferAdaptor() : BufferAdaptor()
     {
@@ -137,9 +133,7 @@ public:
 
     virtual QVariant getProperty(const QByteArray &key) const Q_DECL_OVERRIDE
     {
-        if (mResourceBuffer && mResourceMapper->hasMapping(key)) {
-            return mResourceMapper->getProperty(key, mResourceBuffer);
-        } else if (mLocalBuffer && mLocalMapper->hasMapping(key)) {
+        if (mLocalBuffer && mLocalMapper->hasMapping(key)) {
             return mLocalMapper->getProperty(key, mLocalBuffer);
         } else if (mIndex && mIndexMapper->hasMapping(key)) {
             return mIndexMapper->getProperty(key, *mIndex, *this);
@@ -152,23 +146,21 @@ public:
      */
     virtual QList<QByteArray> availableProperties() const Q_DECL_OVERRIDE
     {
-        return mResourceMapper->availableProperties() + mLocalMapper->availableProperties() + mIndexMapper->availableProperties();
+        return mLocalMapper->availableProperties() + mIndexMapper->availableProperties();
     }
 
-    LocalBuffer const *mLocalBuffer;
-    ResourceBuffer const *mResourceBuffer;
-    QSharedPointer<ReadPropertyMapper<LocalBuffer>> mLocalMapper;
-    QSharedPointer<ReadPropertyMapper<ResourceBuffer>> mResourceMapper;
+    void const *mLocalBuffer;
+    QSharedPointer<PropertyMapper> mLocalMapper;
     QSharedPointer<IndexPropertyMapper> mIndexMapper;
     TypeIndex *mIndex;
 };
 
 /**
- * The factory should define how to go from an entitybuffer (local + resource buffer), to a domain type adapter.
+ * The factory should define how to go from an entitybuffer (local buffer), to a domain type adapter.
  * It defines how values are split accross local and resource buffer.
  * This is required by the facade the read the value, and by the pipeline preprocessors to access the domain values in a generic way.
  */
-template <typename DomainType, typename ResourceBuffer = Sink::ApplicationDomain::Buffer::Dummy, typename ResourceBuilder = Sink::ApplicationDomain::Buffer::DummyBuilder>
+template <typename DomainType>
 class SINK_EXPORT DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInterface
 {
     typedef typename Sink::ApplicationDomain::TypeImplementation<DomainType>::Buffer LocalBuffer;
@@ -176,31 +168,25 @@ class SINK_EXPORT DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInte
 
 public:
     DomainTypeAdaptorFactory()
-        : mLocalMapper(QSharedPointer<ReadPropertyMapper<LocalBuffer>>::create()),
-          mResourceMapper(QSharedPointer<ReadPropertyMapper<ResourceBuffer>>::create()),
-          mLocalWriteMapper(QSharedPointer<WritePropertyMapper<LocalBuilder>>::create()),
-          mResourceWriteMapper(QSharedPointer<WritePropertyMapper<ResourceBuilder>>::create()),
+        : mPropertyMapper(QSharedPointer<PropertyMapper>::create()),
           mIndexMapper(QSharedPointer<IndexPropertyMapper>::create())
     {
-        Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mLocalMapper);
-        Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mLocalWriteMapper);
+        Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mPropertyMapper);
         Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mIndexMapper);
     }
 
     virtual ~DomainTypeAdaptorFactory(){};
 
     /**
-     * Creates an adaptor for the given domain and resource types.
+     * Creates an adaptor for the given domain types.
      *
      * This returns by default a DatastoreBufferAdaptor initialized with the corresponding property mappers.
      */
     virtual QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> createAdaptor(const Sink::Entity &entity, TypeIndex *index = nullptr) Q_DECL_OVERRIDE
     {
-        auto adaptor = QSharedPointer<DatastoreBufferAdaptor<LocalBuffer, ResourceBuffer>>::create();
+        auto adaptor = QSharedPointer<DatastoreBufferAdaptor>::create();
         adaptor->mLocalBuffer = Sink::EntityBuffer::readBuffer<LocalBuffer>(entity.local());
-        adaptor->mLocalMapper = mLocalMapper;
-        adaptor->mResourceBuffer = Sink::EntityBuffer::readBuffer<ResourceBuffer>(entity.resource());
-        adaptor->mResourceMapper = mResourceMapper;
+        adaptor->mLocalMapper = mPropertyMapper;
         adaptor->mIndexMapper = mIndexMapper;
         adaptor->mIndex = index;
         return adaptor;
@@ -210,18 +196,8 @@ public:
     createBuffer(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, void const *metadataData = 0, size_t metadataSize = 0) Q_DECL_OVERRIDE
     {
         flatbuffers::FlatBufferBuilder localFbb;
-        if (mLocalWriteMapper) {
-            // SinkTrace() << "Creating local buffer part";
-            createBufferPartBuffer<LocalBuffer, LocalBuilder>(domainObject, localFbb, *mLocalWriteMapper);
-        }
-
-        flatbuffers::FlatBufferBuilder resFbb;
-        if (mResourceWriteMapper) {
-            // SinkTrace() << "Creating resouce buffer part";
-            createBufferPartBuffer<ResourceBuffer, ResourceBuilder>(domainObject, resFbb, *mResourceWriteMapper);
-        }
-
-        Sink::EntityBuffer::assembleEntityBuffer(fbb, metadataData, metadataSize, resFbb.GetBufferPointer(), resFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
+        createBufferPartBuffer<LocalBuffer, LocalBuilder>(domainObject, localFbb, *mPropertyMapper);
+        Sink::EntityBuffer::assembleEntityBuffer(fbb, metadataData, metadataSize, 0, 0, localFbb.GetBufferPointer(), localFbb.GetSize());
         return true;
     }
 
@@ -236,10 +212,7 @@ public:
 
 
 protected:
-    QSharedPointer<ReadPropertyMapper<LocalBuffer>> mLocalMapper;
-    QSharedPointer<ReadPropertyMapper<ResourceBuffer>> mResourceMapper;
-    QSharedPointer<WritePropertyMapper<LocalBuilder>> mLocalWriteMapper;
-    QSharedPointer<WritePropertyMapper<ResourceBuilder>> mResourceWriteMapper;
+    QSharedPointer<PropertyMapper> mPropertyMapper;
     QSharedPointer<IndexPropertyMapper> mIndexMapper;
 };
 
diff --git a/common/facade.cpp b/common/facade.cpp
index 38ec1dc..9c14a23 100644
--- a/common/facade.cpp
+++ b/common/facade.cpp
@@ -104,6 +104,7 @@ KAsync::Job<void> GenericFacade<DomainType>::remove(const DomainType &domainObje
 template <class DomainType>
 QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> GenericFacade<DomainType>::load(const Sink::Query &query, const Log::Context &ctx)
 {
+    Q_ASSERT(DomainType::name == query.type() || query.type().isEmpty());
     // The runner lives for the lifetime of the query
     auto runner = new QueryRunner<DomainType>(query, mResourceContext, bufferTypeForDomainType(), ctx);
     runner->setResultTransformation(mResultTransformation);
diff --git a/common/facade.h b/common/facade.h
index 45c718b..0ec2e59 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -48,7 +48,6 @@ template <typename DomainType>
 class SINK_EXPORT GenericFacade : public Sink::StoreFacade<DomainType>
 {
 protected:
-    SINK_DEBUG_AREA("facade")
     SINK_DEBUG_COMPONENT(mResourceContext.resourceInstanceIdentifier)
 public:
     /**
diff --git a/common/genericresource.h b/common/genericresource.h
index 558145c..bffc697 100644
--- a/common/genericresource.h
+++ b/common/genericresource.h
@@ -35,8 +35,6 @@ class CommandProcessor;
  */
 class SINK_EXPORT GenericResource : public Resource
 {
-protected:
-    SINK_DEBUG_AREA("resource")
 public:
     GenericResource(const Sink::ResourceContext &context, const QSharedPointer<Pipeline> &pipeline = QSharedPointer<Pipeline>());
     virtual ~GenericResource();
diff --git a/common/listener.cpp b/common/listener.cpp
index 983e438..c9fd9d3 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -405,6 +405,7 @@ void Listener::updateClientsWithRevision(qint64 revision)
 
         SinkTrace() << "Sending revision update for " << client.name << revision;
         Sink::Commands::write(client.socket, ++m_messageId, Sink::Commands::RevisionUpdateCommand, m_fbb);
+        client.socket->flush();
     }
     m_fbb.Clear();
 }
@@ -420,6 +421,8 @@ void Listener::notify(const Sink::Notification &notification)
     builder.add_identifier(idString);
     builder.add_message(messageString);
     builder.add_entities(entities);
+    builder.add_progress(notification.progress);
+    builder.add_total(notification.total);
     auto command = builder.Finish();
     Sink::Commands::FinishNotificationBuffer(m_fbb, command);
     for (Client &client : m_connections) {
diff --git a/common/listener.h b/common/listener.h
index 8d8b529..f29130d 100644
--- a/common/listener.h
+++ b/common/listener.h
@@ -55,8 +55,6 @@ public:
 class SINK_EXPORT Listener : public QObject
 {
     Q_OBJECT
-    SINK_DEBUG_AREA("communication")
-
 public:
     Listener(const QByteArray &resourceName, const QByteArray &resourceType, QObject *parent = 0);
     ~Listener();
diff --git a/common/log.cpp b/common/log.cpp
index 045b3cc..5dfb872 100644
--- a/common/log.cpp
+++ b/common/log.cpp
@@ -1,6 +1,7 @@
 #include "log.h"
 
 #include <QString>
+#include <QDir>
 #include <QIODevice>
 #include <QCoreApplication>
 #include <QSettings>
@@ -12,12 +13,18 @@
 #include <memory>
 #include <atomic>
 #include <definitions.h>
+#include <QThreadStorage>
+#include <QStringBuilder>
 
 using namespace Sink::Log;
 
-static QSharedPointer<QSettings> config()
+static QThreadStorage<QSharedPointer<QSettings>> sSettings;
+static QSettings &config()
 {
-    return QSharedPointer<QSettings>::create(Sink::configLocation() + "/log.ini", QSettings::IniFormat);
+    if (!sSettings.hasLocalData()) {
+        sSettings.setLocalData(QSharedPointer<QSettings>::create(Sink::configLocation() + "/log.ini", QSettings::IniFormat));
+    }
+    return *sSettings.localData();
 }
 
 static QByteArray sPrimaryComponent;
@@ -173,22 +180,22 @@ DebugLevel Sink::Log::debugLevelFromName(const QByteArray &name)
 
 void Sink::Log::setDebugOutputLevel(DebugLevel debugLevel)
 {
-    config()->setValue("level", debugLevel);
+    config().setValue("level", debugLevel);
 }
 
 Sink::Log::DebugLevel Sink::Log::debugOutputLevel()
 {
-    return static_cast<Sink::Log::DebugLevel>(config()->value("level", Sink::Log::Log).toInt());
+    return static_cast<Sink::Log::DebugLevel>(config().value("level", Sink::Log::Log).toInt());
 }
 
 void Sink::Log::setDebugOutputFilter(FilterType type, const QByteArrayList &filter)
 {
     switch (type) {
         case ApplicationName:
-            config()->setValue("applicationfilter", QVariant::fromValue(filter));
+            config().setValue("applicationfilter", QVariant::fromValue(filter));
             break;
         case Area:
-            config()->setValue("areafilter", QVariant::fromValue(filter));
+            config().setValue("areafilter", QVariant::fromValue(filter));
             break;
     }
 }
@@ -197,9 +204,9 @@ QByteArrayList Sink::Log::debugOutputFilter(FilterType type)
 {
     switch (type) {
         case ApplicationName:
-            return config()->value("applicationfilter").value<QByteArrayList>();
+            return config().value("applicationfilter").value<QByteArrayList>();
         case Area:
-            return config()->value("areafilter").value<QByteArrayList>();
+            return config().value("areafilter").value<QByteArrayList>();
         default:
             return QByteArrayList();
     }
@@ -207,12 +214,12 @@ QByteArrayList Sink::Log::debugOutputFilter(FilterType type)
 
 void Sink::Log::setDebugOutputFields(const QByteArrayList &output)
 {
-    config()->setValue("outputfields", QVariant::fromValue(output));
+    config().setValue("outputfields", QVariant::fromValue(output));
 }
 
 QByteArrayList Sink::Log::debugOutputFields()
 {
-    return config()->value("outputfields").value<QByteArrayList>();
+    return config().value("outputfields").value<QByteArrayList>();
 }
 
 static QByteArray getProgramName()
@@ -277,14 +284,16 @@ static bool containsItemStartingWith(const QByteArray &pattern, const QByteArray
     for (const auto &item : list) {
         if (item.startsWith('*')) {
             auto stripped = item.mid(1);
-            stripped.endsWith('*');
-            stripped.chop(1);
+            if (stripped.endsWith('*')) {
+                stripped.chop(1);
+            }
             if (pattern.contains(stripped)) {
                 return true;
             }
-        }
-        if (pattern.startsWith(item)) {
-            return true;
+        } else {
+            if (pattern.contains(item)) {
+                return true;
+            }
         }
     }
     return false;
@@ -300,25 +309,51 @@ static bool caseInsensitiveContains(const QByteArray &pattern, const QByteArrayL
     return false;
 }
 
-QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char *file, const char *function, const char *debugArea, const char *debugComponent)
+static QByteArray getFileName(const char *file)
 {
-    static NullStream nullstream;
-    if (debugLevel < debugOutputLevel()) {
-        return QDebug(&nullstream);
-    }
+    static char sep = QDir::separator().toLatin1();
+    auto filename = QByteArray(file).split(sep).last();
+    return filename.split('.').first();
+}
 
+static QString assembleDebugArea(const char *debugArea, const char *debugComponent, const char *file)
+{
     if (sPrimaryComponent.isEmpty()) {
         sPrimaryComponent = getProgramName();
     }
-    QString fullDebugArea = sPrimaryComponent + "." + (debugComponent ? (QString::fromLatin1(debugComponent) + ".") : "") + (debugArea ? QString::fromLatin1(debugArea) : "");
+    //Using stringbuilder for fewer allocations
+    return QLatin1String{sPrimaryComponent} % QLatin1String{"."} %
+        (debugComponent ? (QLatin1String{debugComponent} + QLatin1String{"."}) : QLatin1String{""}) %
+        (debugArea ? QLatin1String{debugArea} : QLatin1String{getFileName(file)});
+}
+
+static bool isFiltered(DebugLevel debugLevel, const QByteArray &fullDebugArea)
+{
+    if (debugLevel < debugOutputLevel()) {
+        return true;
+    }
+    const auto areas = debugOutputFilter(Sink::Log::Area);
+    if ((debugLevel <= Sink::Log::Trace) && !areas.isEmpty()) {
+        if (!containsItemStartingWith(fullDebugArea, areas)) {
+            return true;
+        }
+    }
+    return false;
+}
 
+bool Sink::Log::isFiltered(DebugLevel debugLevel, const char *debugArea, const char *debugComponent, const char *file)
+{
+    return isFiltered(debugLevel, assembleDebugArea(debugArea, debugComponent, file).toLatin1());
+}
+
+QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char *file, const char *function, const char *debugArea, const char *debugComponent)
+{
+    const auto fullDebugArea = assembleDebugArea(debugArea, debugComponent, file);
     collectDebugArea(fullDebugArea);
 
-    auto areas = debugOutputFilter(Sink::Log::Area);
-    if (debugLevel <= Sink::Log::Trace && !areas.isEmpty()) {
-        if (!containsItemStartingWith(fullDebugArea.toUtf8(), areas)) {
-            return QDebug(&nullstream);
-        }
+    static NullStream nullstream;
+    if (isFiltered(debugLevel, fullDebugArea.toLatin1())) {
+        return QDebug(&nullstream);
     }
 
     QString prefix;
diff --git a/common/log.h b/common/log.h
index e85856a..8266fdb 100644
--- a/common/log.h
+++ b/common/log.h
@@ -85,30 +85,35 @@ SINK_EXPORT inline QDebug operator<<(QDebug d, const TraceTime &time)
     d << time.time << "[ms]";
     return d;
 }
+
+SINK_EXPORT bool isFiltered(DebugLevel debugLevel, const char *debugArea, const char *debugComponent, const char *file);
+
 }
 }
 
 static const char *getComponentName() { return nullptr; }
 
-#define Trace_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
-#define Log_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
-#define Warning_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
-#define Error_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
-
-#define SinkTrace_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
-#define SinkLog_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
-#define SinkWarning_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
-#define SinkError_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
-
-#define SinkTrace() Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
-#define SinkLog() Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
-#define SinkWarning() Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
-#define SinkError() Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
-
-#define SinkTraceCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
-#define SinkLogCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
-#define SinkWarningCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
-#define SinkErrorCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
+#define SINK_DEBUG_STREAM_IMPL(LEVEL, AREA, COMPONENT) if (!Sink::Log::isFiltered(LEVEL, AREA, COMPONENT, __FILE__)) Sink::Log::debugStream(LEVEL, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
+
+#define Trace_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, AREA, nullptr)
+#define Log_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, AREA, nullptr)
+#define Warning_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, AREA, nullptr)
+#define Error_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, AREA, nullptr)
+
+#define SinkTrace_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, AREA, COMPONENT)
+#define SinkLog_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, AREA, COMPONENT)
+#define SinkWarning_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, AREA, COMPONENT)
+#define SinkError_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, AREA, COMPONENT)
+
+#define SinkTrace() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, nullptr, getComponentName())
+#define SinkLog() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, nullptr, getComponentName())
+#define SinkWarning() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, nullptr, getComponentName())
+#define SinkError() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, nullptr, getComponentName())
+
+#define SinkTraceCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, CTX.name, nullptr)
+#define SinkLogCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, CTX.name, nullptr)
+#define SinkWarningCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, CTX.name, nullptr)
+#define SinkErrorCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, CTX.name, nullptr)
 
 #define SINK_DEBUG_AREA(AREA) static constexpr const char* s_sinkDebugArea{AREA};
 #define SINK_DEBUG_COMPONENT(COMPONENT) const char* getComponentName() const { return COMPONENT; };
diff --git a/common/mail/threadindexer.cpp b/common/mail/threadindexer.cpp
index d91ab5f..4171d85 100644
--- a/common/mail/threadindexer.cpp
+++ b/common/mail/threadindexer.cpp
@@ -21,74 +21,15 @@
 #include "typeindex.h"
 #include "log.h"
 
-SINK_DEBUG_AREA("threadindex")
-
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
-static QString stripOffPrefixes(const QString &subject)
-{
-    //TODO this hardcoded list is probably not good enough (especially regarding internationalization)
-    //TODO this whole routine, including internationalized re/fwd ... should go into some library.
-    //We'll require the same for generating reply/forward subjects in kube
-    static QStringList defaultReplyPrefixes = QStringList() << QLatin1String("Re\\s*:")
-                                                            << QLatin1String("Re\\[\\d+\\]:")
-                                                            << QLatin1String("Re\\d+:");
-
-    static QStringList defaultForwardPrefixes = QStringList() << QLatin1String("Fwd:")
-                                                              << QLatin1String("FW:");
-
-    QStringList replyPrefixes; // = GlobalSettings::self()->replyPrefixes();
-    if (replyPrefixes.isEmpty()) {
-        replyPrefixes = defaultReplyPrefixes;
-    }
-
-    QStringList forwardPrefixes; // = GlobalSettings::self()->forwardPrefixes();
-    if (forwardPrefixes.isEmpty()) {
-        forwardPrefixes = defaultReplyPrefixes;
-    }
-
-    const QStringList prefixRegExps = replyPrefixes + forwardPrefixes;
-
-    // construct a big regexp that
-    // 1. is anchored to the beginning of str (sans whitespace)
-    // 2. matches at least one of the part regexps in prefixRegExps
-    const QString bigRegExp = QString::fromLatin1("^(?:\\s+|(?:%1))+\\s*").arg(prefixRegExps.join(QLatin1String(")|(?:")));
-
-    static QString regExpPattern;
-    static QRegExp regExp;
-
-    regExp.setCaseSensitivity(Qt::CaseInsensitive);
-    if (regExpPattern != bigRegExp) {
-        // the prefixes have changed, so update the regexp
-        regExpPattern = bigRegExp;
-        regExp.setPattern(regExpPattern);
-    }
-
-    if(regExp.isValid()) {
-        QString tmp = subject;
-        if (regExp.indexIn( tmp ) == 0) {
-            return tmp.remove(0, regExp.matchedLength());
-        }
-    } else {
-        SinkWarning() << "bigRegExp = \""
-                   << bigRegExp << "\"\n"
-                   << "prefix regexp is invalid!";
-    }
-
-    return subject;
-}
-
-
 void ThreadIndexer::updateThreadingIndex(const QByteArray &identifier, const ApplicationDomain::ApplicationDomainType &entity, Sink::Storage::DataStore::Transaction &transaction)
 {
     auto messageId = entity.getProperty(Mail::MessageId::name);
     auto parentMessageId = entity.getProperty(Mail::ParentMessageId::name);
-    const auto subject = entity.getProperty(Mail::Subject::name);
-    const auto normalizedSubject = stripOffPrefixes(subject.toString()).toUtf8();
     if (messageId.toByteArray().isEmpty()) {
         SinkWarning() << "Found an email without messageId. This is illegal and threading will break. Entity id: " << identifier;
-        SinkWarning() << "Subject: " << subject;
     }
 
     QVector<QByteArray> thread;
@@ -101,18 +42,9 @@ void ThreadIndexer::updateThreadingIndex(const QByteArray &identifier, const App
         thread = index().secondaryLookup<Mail::MessageId, Mail::ThreadId>(parentMessageId);
         SinkTrace() << "Found parent: " << thread;
     }
-
     if (thread.isEmpty()) {
-        //Try to lookup the thread by subject if not empty
-        if ( !normalizedSubject.isEmpty()) {
-            thread = index().secondaryLookup<Mail::Subject, Mail::ThreadId>(normalizedSubject);
-        }
-        if (thread.isEmpty()) {
-            thread << QUuid::createUuid().toByteArray();
-            SinkTrace() << "Created a new thread: " << thread;
-        } else {
-            SinkTrace() << "Found thread by subject: " << thread;
-        }
+        thread << QUuid::createUuid().toByteArray();
+        SinkTrace() << "Created a new thread: " << thread;
     }
 
     Q_ASSERT(!thread.isEmpty());
@@ -124,9 +56,6 @@ void ThreadIndexer::updateThreadingIndex(const QByteArray &identifier, const App
     }
     index().index<Mail::MessageId, Mail::ThreadId>(messageId, thread.first(), transaction);
     index().index<Mail::ThreadId, Mail::MessageId>(thread.first(), messageId, transaction);
-    if (!normalizedSubject.isEmpty()) {
-        index().index<Mail::Subject, Mail::ThreadId>(normalizedSubject, thread.first(), transaction);
-    }
 }
 
 
@@ -142,6 +71,15 @@ void ThreadIndexer::modify(const ApplicationDomain::ApplicationDomainType &old,
 
 void ThreadIndexer::remove(const ApplicationDomain::ApplicationDomainType &entity)
 {
+    auto messageId = entity.getProperty(Mail::MessageId::name);
+    auto thread = index().secondaryLookup<Mail::MessageId, Mail::ThreadId>(messageId);
+    index().unindex<Mail::MessageId, Mail::ThreadId>(messageId.toByteArray(), thread.first(), transaction());
+    index().unindex<Mail::ThreadId, Mail::MessageId>(thread.first(), messageId.toByteArray(), transaction());
+}
 
+QMap<QByteArray, int> ThreadIndexer::databases()
+{
+    return {{"mail.index.messageIdthreadId", 1},
+            {"mail.index.threadIdmessageId", 1}};
 }
 
diff --git a/common/mail/threadindexer.h b/common/mail/threadindexer.h
index 064ae71..60d0863 100644
--- a/common/mail/threadindexer.h
+++ b/common/mail/threadindexer.h
@@ -29,6 +29,7 @@ public:
     virtual void add(const ApplicationDomain::ApplicationDomainType &entity) Q_DECL_OVERRIDE;
     virtual void modify(const ApplicationDomain::ApplicationDomainType &old, const ApplicationDomain::ApplicationDomainType &entity) Q_DECL_OVERRIDE;
     virtual void remove(const ApplicationDomain::ApplicationDomainType &entity) Q_DECL_OVERRIDE;
+    static QMap<QByteArray, int> databases();
 private:
     void updateThreadingIndex(const QByteArray &identifier, const ApplicationDomain::ApplicationDomainType &entity, Sink::Storage::DataStore::Transaction &transaction);
 };
diff --git a/common/mailpreprocessor.cpp b/common/mailpreprocessor.cpp
index dff3b3d..5c54fbc 100644
--- a/common/mailpreprocessor.cpp
+++ b/common/mailpreprocessor.cpp
@@ -29,8 +29,6 @@
 
 using namespace Sink;
 
-SINK_DEBUG_AREA("mailpreprocessor")
-
 QString MailPropertyExtractor::getFilePathFromMimeMessagePath(const QString &s) const
 {
     return s;
diff --git a/common/messagequeue.cpp b/common/messagequeue.cpp
index 6e79d89..362ddfd 100644
--- a/common/messagequeue.cpp
+++ b/common/messagequeue.cpp
@@ -3,8 +3,6 @@
 #include <QDebug>
 #include <log.h>
 
-SINK_DEBUG_AREA("messagequeue")
-
 MessageQueue::MessageQueue(const QString &storageRoot, const QString &name) : mStorage(storageRoot, name, Sink::Storage::DataStore::ReadWrite)
 {
 }
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index b12216b..58703ab 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -224,7 +224,6 @@ QModelIndex ModelResult<T, Ptr>::index(int row, int column, const QModelIndex &p
         return createIndex(row, column, childId);
     }
     SinkWarningCtx(mLogCtx) << "Index not available " << row << column << parent;
-    Q_ASSERT(false);
     return QModelIndex();
 }
 
diff --git a/common/notification.cpp b/common/notification.cpp
index e688b6d..da31e20 100644
--- a/common/notification.cpp
+++ b/common/notification.cpp
@@ -48,8 +48,8 @@ static QByteArray name(int type)
 
 QDebug operator<<(QDebug dbg, const Sink::Notification &n)
 {
-    dbg << "Notification(Type: " << name(n.type) << "Id, : " << n.id  << ", Code: ";
+    dbg << "Notification(Type:" << name(n.type) << "Id, :" << n.id  << ", Code:";
     dbg << n.code;
-    dbg << ", Message: " << n.message << ", Entities: " << n.entities << ")";
+    dbg << ", Message:" << n.message << ", Entities:" << n.entities << ")";
     return dbg.space();
 }
diff --git a/common/notification.h b/common/notification.h
index f5379fd..30e240c 100644
--- a/common/notification.h
+++ b/common/notification.h
@@ -56,6 +56,8 @@ public:
     QString message;
     //A return code. Zero typically indicates success.
     int code = 0;
+    int progress = 0;
+    int total = 0;
     QByteArray resource;
 };
 }
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index f5cf995..f29c7db 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -283,6 +283,8 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
             case Preprocessor::DropModification:
                 SinkTraceCtx(d->logCtx) << "Dropping modification";
                 return KAsync::error<qint64>(0);
+            case Preprocessor::NoAction:
+            case Preprocessor::DeleteEntity:
             default:
                 break;
         }
@@ -301,8 +303,8 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
                     SinkTraceCtx(d->logCtx) << "Move of " << current.identifier() << "was successfull";
                     if (isMove) {
                         flatbuffers::FlatBufferBuilder fbb;
-                        auto entityId = fbb.CreateString(current.identifier());
-                        auto type = fbb.CreateString(bufferType);
+                        auto entityId = fbb.CreateString(current.identifier().toStdString());
+                        auto type = fbb.CreateString(bufferType.toStdString());
                         auto location = Sink::Commands::CreateDeleteEntity(fbb, current.revision(), entityId, type, true);
                         Sink::Commands::FinishDeleteEntityBuffer(fbb, location);
                         const auto data = BufferUtils::extractBuffer(fbb);
@@ -448,8 +450,8 @@ void Preprocessor::createEntity(const Sink::ApplicationDomain::ApplicationDomain
     const auto entityBuffer = BufferUtils::extractBuffer(entityFbb);
 
     flatbuffers::FlatBufferBuilder fbb;
-    auto entityId = fbb.CreateString(entity.identifier());
-    auto type = fbb.CreateString(typeName);
+    auto entityId = fbb.CreateString(entity.identifier().toStdString());
+    auto type = fbb.CreateString(typeName.toStdString());
     auto delta = Sink::EntityBuffer::appendAsVector(fbb, entityBuffer.constData(), entityBuffer.size());
     auto location = Sink::Commands::CreateCreateEntity(fbb, entityId, type, delta);
     Sink::Commands::FinishCreateEntityBuffer(fbb, location);
diff --git a/common/propertymapper.cpp b/common/propertymapper.cpp
index c72cf31..dbf93a3 100644
--- a/common/propertymapper.cpp
+++ b/common/propertymapper.cpp
@@ -21,6 +21,7 @@
 
 #include "applicationdomaintype.h"
 #include <QDateTime>
+#include <QDataStream>
 #include "mail_generated.h"
 #include "contact_generated.h"
 
@@ -57,7 +58,9 @@ template <>
 flatbuffers::uoffset_t variantToProperty<QByteArray>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
 {
     if (property.isValid()) {
-        return fbb.CreateString(property.toByteArray().toStdString()).o;
+        const auto ba = property.toByteArray();
+        const auto s = fbb.CreateString(ba.constData(), ba.size());
+        return s.o;
     }
     return 0;
 }
@@ -66,7 +69,10 @@ template <>
 flatbuffers::uoffset_t variantToProperty<QDateTime>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
 {
     if (property.isValid()) {
-        return fbb.CreateString(property.toDateTime().toString().toStdString()).o;
+        QByteArray ba;
+        QDataStream ds(&ba, QIODevice::WriteOnly);
+        ds << property.toDateTime();
+        return fbb.CreateString(ba.toStdString()).o;
     }
     return 0;
 }
@@ -131,7 +137,7 @@ QString propertyToString(const flatbuffers::String *property)
 {
     if (property) {
         // We have to copy the memory, otherwise it would become eventually invalid
-        return QString::fromStdString(property->c_str());
+        return QString::fromStdString(property->str());
     }
     return QString();
 }
@@ -141,7 +147,7 @@ QVariant propertyToVariant<QString>(const flatbuffers::String *property)
 {
     if (property) {
         // We have to copy the memory, otherwise it would become eventually invalid
-        return QString::fromStdString(property->c_str());
+        return QString::fromStdString(property->str());
     }
     return QVariant();
 }
@@ -151,7 +157,7 @@ QVariant propertyToVariant<Sink::ApplicationDomain::BLOB>(const flatbuffers::Str
 {
     if (property) {
         // We have to copy the memory, otherwise it would become eventually invalid
-        auto s = QString::fromStdString(property->c_str());
+        auto s = QString::fromStdString(property->str());
         auto ext = s.endsWith(":ext");
         s.chop(4);
 
@@ -167,7 +173,7 @@ QVariant propertyToVariant<Sink::ApplicationDomain::Reference>(const flatbuffers
 {
     if (property) {
         // We have to copy the memory, otherwise it would become eventually invalid
-        return QVariant::fromValue(Sink::ApplicationDomain::Reference{QString::fromStdString(property->c_str()).toUtf8()});
+        return QVariant::fromValue(Sink::ApplicationDomain::Reference{QString::fromStdString(property->str()).toUtf8()});
     }
     return QVariant();
 }
@@ -177,7 +183,7 @@ QVariant propertyToVariant<QByteArray>(const flatbuffers::String *property)
 {
     if (property) {
         // We have to copy the memory, otherwise it would become eventually invalid
-        return QString::fromStdString(property->c_str()).toUtf8();
+        return QByteArray(property->c_str(), property->Length());
     }
     return QVariant();
 }
@@ -199,7 +205,7 @@ QVariant propertyToVariant<QByteArrayList>(const flatbuffers::Vector<flatbuffers
         QByteArrayList list;
         for (auto it = property->begin(); it != property->end();) {
             // We have to copy the memory, otherwise it would become eventually invalid
-            list << QString::fromStdString((*it)->c_str()).toUtf8();
+            list << QString::fromStdString((*it)->str()).toUtf8();
             it.operator++();
         }
         return QVariant::fromValue(list);
@@ -256,8 +262,11 @@ template <>
 QVariant propertyToVariant<QDateTime>(const flatbuffers::String *property)
 {
     if (property) {
-        // We have to copy the memory, otherwise it would become eventually invalid
-        return QDateTime::fromString(QString::fromStdString(property->c_str()));
+        auto ba = QByteArray::fromRawData(property->c_str(), property->size());
+        QDateTime dt;
+        QDataStream ds(&ba, QIODevice::ReadOnly);
+        ds >> dt;
+        return dt;
     }
     return QVariant();
 }
diff --git a/common/propertymapper.h b/common/propertymapper.h
index 9ea0b73..fd24278 100644
--- a/common/propertymapper.h
+++ b/common/propertymapper.h
@@ -65,13 +65,19 @@ QVariant SINK_EXPORT propertyToVariant(const flatbuffers::Vector<flatbuffers::Of
  * a virtual method per property, the property mapper can be filled with accessors
  * that extract the properties from resource types.
  */
-template <typename BufferType>
-class ReadPropertyMapper
+class PropertyMapper
 {
 public:
-    virtual ~ReadPropertyMapper(){};
+    virtual ~PropertyMapper(){};
 
-    virtual QVariant getProperty(const QByteArray &key, BufferType const *buffer) const
+    template <typename T, typename Buffer, typename BufferBuilder, typename FunctionReturnValue, typename Arg>
+    void addMapping(FunctionReturnValue (Buffer::*f)() const, void (BufferBuilder::*f2)(Arg))
+    {
+        addReadMapping<T, Buffer, FunctionReturnValue>(f);
+        addWriteMapping<T, BufferBuilder>(f2);
+    }
+
+    virtual QVariant getProperty(const QByteArray &key, void const *buffer) const
     {
         if (mReadAccessors.contains(key)) {
             auto accessor = mReadAccessors.value(key);
@@ -79,163 +85,69 @@ public:
         }
         return QVariant();
     }
-    bool hasMapping(const QByteArray &key) const
-    {
-        return mReadAccessors.contains(key);
-    }
-    QList<QByteArray> availableProperties() const
-    {
-        return mReadAccessors.keys();
-    }
-    void addMapping(const QByteArray &property, const std::function<QVariant(BufferType const *)> &mapping)
-    {
-        mReadAccessors.insert(property, mapping);
-    }
-
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::String *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-
-    template <typename T, typename Buffer>
-    void addMapping(uint8_t (Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-
-    template <typename T, typename Buffer>
-    void addMapping(bool (Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::Vector<uint8_t> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-
-    template <typename T, typename Buffer>
-    void addMapping(const Sink::ApplicationDomain::Buffer::MailContact *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::MailContact>> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
 
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-
-private:
-    QHash<QByteArray, std::function<QVariant(BufferType const *)>> mReadAccessors;
-};
-
-template <typename BufferBuilder>
-class WritePropertyMapper
-{
-public:
-    virtual ~WritePropertyMapper(){};
-
-    virtual void setProperty(const QByteArray &key, const QVariant &value, QList<std::function<void(BufferBuilder &)>> &builderCalls, flatbuffers::FlatBufferBuilder &fbb) const
+    virtual void setProperty(const QByteArray &key, const QVariant &value, QList<std::function<void(void *builder)>> &builderCalls, flatbuffers::FlatBufferBuilder &fbb) const
     {
         if (mWriteAccessors.contains(key)) {
             auto accessor = mWriteAccessors.value(key);
             builderCalls << accessor(value, fbb);
         }
     }
+
     bool hasMapping(const QByteArray &key) const
     {
-        return mWriteAccessors.contains(key);
-    }
-    void addMapping(const QByteArray &property, const std::function<std::function<void(BufferBuilder &)>(const QVariant &, flatbuffers::FlatBufferBuilder &)> &mapping)
-    {
-        mWriteAccessors.insert(property, mapping);
+        return mReadAccessors.contains(key);
     }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(uint8_t))
+    QList<QByteArray> availableProperties() const
     {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<typename T::Type>()); };
-        });
+        return mReadAccessors.keys();
     }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(bool))
+private:
+    void addReadMapping(const QByteArray &property, const std::function<QVariant(void const *)> &mapping)
     {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<typename T::Type>()); };
-        });
+        mReadAccessors.insert(property, mapping);
     }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::String>))
+    template <typename T, typename Buffer, typename FunctionReturnValue>
+    void addReadMapping(FunctionReturnValue (Buffer::*f)() const)
     {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
-        });
+        addReadMapping(T::name, [f](void const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((static_cast<const Buffer*>(buffer)->*f)()); });
     }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<uint8_t>>))
-    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
-        });
-    }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>))
+    void addWriteMapping(const QByteArray &property, const std::function<std::function<void(void *builder)>(const QVariant &, flatbuffers::FlatBufferBuilder &)> &mapping)
     {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
-        });
+        mWriteAccessors.insert(property, mapping);
     }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<Sink::ApplicationDomain::Buffer::MailContact>))
+    template <typename T, typename BufferBuilder>
+    void addWriteMapping(void (BufferBuilder::*f)(uint8_t))
     {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
+        addWriteMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(void *builder)> {
+            return [value, f](void *builder) { (static_cast<BufferBuilder*>(builder)->*f)(value.value<typename T::Type>()); };
         });
     }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::MailContact>>>))
+    template <typename T, typename BufferBuilder>
+    void addWriteMapping(void (BufferBuilder::*f)(bool))
     {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
+        addWriteMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(void *builder)> {
+            return [value, f](void *builder) { (static_cast<BufferBuilder*>(builder)->*f)(value.value<typename T::Type>()); };
         });
     }
 
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>>>))
+    template <typename T, typename BufferBuilder, typename Arg>
+    void addWriteMapping(void (BufferBuilder::*f)(flatbuffers::Offset<Arg>))
     {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        addWriteMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(void *builder)> {
             auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
+            return [offset, f](void *builder) { (static_cast<BufferBuilder*>(builder)->*f)(offset); };
         });
     }
 
-private:
-    QHash<QByteArray, std::function<std::function<void(BufferBuilder &)>(const QVariant &, flatbuffers::FlatBufferBuilder &)>> mWriteAccessors;
+    QHash<QByteArray, std::function<QVariant(void const *)>> mReadAccessors;
+    QHash<QByteArray, std::function<std::function<void(void *builder)>(const QVariant &, flatbuffers::FlatBufferBuilder &)>> mWriteAccessors;
 };
+
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index 43f48c0..f196965 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -231,11 +231,11 @@ ReplayResult QueryWorker<DomainType>::executeIncrementalQuery(const Sink::Query
     auto replayResult = resultSet.replaySet(0, 0, [this, query, &resultProvider](const ResultSet::Result &result) {
         resultProviderCallback(query, resultProvider, result);
     });
-
+    preparedQuery.updateComplete();
     SinkTraceCtx(mLogCtx) << "Replayed " << replayResult.replayedEntities << " results.\n"
         << (replayResult.replayedAll ? "Replayed all available results.\n" : "")
         << "Incremental query took: " << Log::TraceTime(time.elapsed());
-    return {entityStore.maxRevision(), replayResult.replayedEntities, replayResult.replayedAll, preparedQuery.getState()};
+    return {entityStore.maxRevision(), replayResult.replayedEntities, false, preparedQuery.getState()};
 }
 
 template <class DomainType>
@@ -264,7 +264,7 @@ ReplayResult QueryWorker<DomainType>::executeInitialQuery(
             return DataStoreQuery{modifiedQuery, ApplicationDomain::getTypeName<DomainType>(), entityStore};
         }
     }();
-    auto resultSet = preparedQuery.execute();;
+    auto resultSet = preparedQuery.execute();
 
     SinkTraceCtx(mLogCtx) << "Filtered set retrieved." << Log::TraceTime(time.elapsed());
     auto replayResult = resultSet.replaySet(0, batchsize, [this, query, &resultProvider](const ResultSet::Result &result) {
diff --git a/common/queryrunner.h b/common/queryrunner.h
index 5308eac..11a302f 100644
--- a/common/queryrunner.h
+++ b/common/queryrunner.h
@@ -32,8 +32,6 @@
 class QueryRunnerBase : public QObject
 {
     Q_OBJECT
-protected:
-    SINK_DEBUG_AREA("queryrunner")
 public:
     typedef std::function<void(Sink::ApplicationDomain::ApplicationDomainType &domainObject)> ResultTransformation;
 
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index ad8cae9..808d892 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -477,7 +477,7 @@ void ResourceAccess::connected()
 
     {
         flatbuffers::FlatBufferBuilder fbb;
-        auto name = fbb.CreateString(QString("PID: %1 ResourceAccess: %2").arg(QCoreApplication::applicationPid()).arg(reinterpret_cast<qlonglong>(this)).toLatin1());
+        auto name = fbb.CreateString(QString("PID: %1 ResourceAccess: %2").arg(QCoreApplication::applicationPid()).arg(reinterpret_cast<qlonglong>(this)).toLatin1().toStdString());
         auto command = Sink::Commands::CreateHandshake(fbb, name);
         Sink::Commands::FinishHandshakeBuffer(fbb, command);
         Commands::write(d->socket.data(), ++d->messageId, Commands::HandshakeCommand, fbb);
@@ -547,6 +547,8 @@ static Sink::Notification getNotification(const Sink::Commands::Notification *bu
     }
     n.type = buffer->type();
     n.code = buffer->code();
+    n.progress = buffer->progress();
+    n.total = buffer->total();
     n.entities = BufferUtils::fromVector(*buffer->entities());
     return n;
 }
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index c32566b..b6a0b34 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -101,7 +101,6 @@ protected:
 class SINK_EXPORT ResourceAccess : public ResourceAccessInterface
 {
     Q_OBJECT
-    SINK_DEBUG_AREA("communication")
 public:
     typedef QSharedPointer<ResourceAccess> Ptr;
 
@@ -158,7 +157,6 @@ private:
  */
 class SINK_EXPORT ResourceAccessFactory
 {
-    SINK_DEBUG_AREA("ResourceAccessFactory")
 public:
     static ResourceAccessFactory &instance();
     Sink::ResourceAccess::Ptr getAccess(const QByteArray &instanceIdentifier, const QByteArray resourceType);
diff --git a/common/resourcecontrol.cpp b/common/resourcecontrol.cpp
index 70a3f7d..b6a4c0b 100644
--- a/common/resourcecontrol.cpp
+++ b/common/resourcecontrol.cpp
@@ -30,8 +30,6 @@
 #include "log.h"
 #include "notifier.h"
 
-SINK_DEBUG_AREA("resourcecontrol")
-
 namespace Sink {
 
 KAsync::Job<void> ResourceControl::shutdown(const QByteArray &identifier)
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index dee0711..dab6aed 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -21,16 +21,12 @@
 #include "resourceconfig.h"
 #include "query.h"
 #include "definitions.h"
-#include "storage.h"
 #include "store.h"
 #include "resourceaccess.h"
 #include "resource.h"
-#include <QDir>
 
 using namespace Sink;
 
-SINK_DEBUG_AREA("ResourceFacade")
-
 template<typename DomainType>
 ConfigNotifier LocalStorageFacade<DomainType>::sConfigNotifier;
 
@@ -100,17 +96,24 @@ template<typename DomainType>
 LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query, const QByteArray &identifier, const QByteArray &typeName, ConfigNotifier &configNotifier, const Sink::Log::Context &ctx)
     : mResultProvider(new ResultProvider<typename DomainType::Ptr>), mConfigStore(identifier, typeName), mGuard(new QObject), mLogCtx(ctx.subContext("config"))
 {
+
+    auto matchesTypeAndIds = [query, this] (const QByteArray &type, const QByteArray &id) {
+        if (query.hasFilter(ApplicationDomain::SinkResource::ResourceType::name) && query.getFilter(ApplicationDomain::SinkResource::ResourceType::name).value.toByteArray() != type) {
+            SinkTraceCtx(mLogCtx) << "Skipping due to type.";
+            return false;
+        }
+        if (!query.ids().isEmpty() && !query.ids().contains(id)) {
+            return false;
+        }
+        return true;
+    };
+
     QObject *guard = new QObject;
-    mResultProvider->setFetcher([this, query, guard, &configNotifier](const QSharedPointer<DomainType> &) {
+    mResultProvider->setFetcher([this, query, guard, &configNotifier, matchesTypeAndIds](const QSharedPointer<DomainType> &) {
         const auto entries = mConfigStore.getEntries();
         for (const auto &res : entries.keys()) {
             const auto type = entries.value(res);
-
-            if (query.hasFilter(ApplicationDomain::SinkResource::ResourceType::name) && query.getFilter(ApplicationDomain::SinkResource::ResourceType::name).value.toByteArray() != type) {
-                SinkTraceCtx(mLogCtx) << "Skipping due to type.";
-                continue;
-            }
-            if (!query.ids().isEmpty() && !query.ids().contains(res)) {
+            if (!matchesTypeAndIds(type, res)){
                 continue;
             }
             auto entity = readFromConfig<DomainType>(mConfigStore, res, type, query.requestedProperties);
@@ -128,8 +131,14 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
     });
     if (query.liveQuery()) {
         {
-            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::added, guard, [this](const ApplicationDomain::ApplicationDomainType::Ptr &entry) {
+            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::added, guard, [this, query, matchesTypeAndIds](const ApplicationDomain::ApplicationDomainType::Ptr &entry, const QByteArray &type) {
                 auto entity = entry.staticCast<DomainType>();
+                if (!matchesTypeAndIds(type, entity->identifier())){
+                    return;
+                }
+                if (!matchesFilter(query.getBaseFilters(), *entity)){
+                    return;
+                }
                 SinkTraceCtx(mLogCtx) << "A new resource has been added: " << entity->identifier();
                 updateStatus(*entity);
                 mResultProvider->add(entity);
@@ -137,8 +146,14 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
             Q_ASSERT(ret);
         }
         {
-            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::modified, guard, [this](const ApplicationDomain::ApplicationDomainType::Ptr &entry) {
+            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::modified, guard, [this, query, matchesTypeAndIds](const ApplicationDomain::ApplicationDomainType::Ptr &entry, const QByteArray &type) {
                 auto entity = entry.staticCast<DomainType>();
+                if (!matchesTypeAndIds(type, entity->identifier())){
+                    return;
+                }
+                if (!matchesFilter(query.getBaseFilters(), *entity)){
+                    return;
+                }
                 updateStatus(*entity);
                 mResultProvider->modify(entity);
             });
@@ -222,7 +237,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::create(const DomainType &domai
             }
             configStore.modify(identifier, configurationValues);
         }
-        sConfigNotifier.add(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}));
+        sConfigNotifier.add(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}), type);
     });
 }
 
@@ -251,7 +266,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::modify(const DomainType &domai
         }
 
         const auto type = configStore.getEntries().value(identifier);
-        sConfigNotifier.modify(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}));
+        sConfigNotifier.modify(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}), type);
     });
 }
 
@@ -281,7 +296,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::remove(const DomainType &domai
         SinkTrace() << "Removing: " << identifier;
         auto configStore = ConfigStore(configStoreIdentifier, typeName);
         configStore.remove(identifier);
-        sConfigNotifier.remove(QSharedPointer<DomainType>::create(domainObject));
+        sConfigNotifier.remove(QSharedPointer<DomainType>::create(domainObject), typeName);
     });
 }
 
@@ -373,10 +388,10 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
             if (states.contains(ApplicationDomain::BusyStatus)) {
                 return ApplicationDomain::BusyStatus;
             }
-            if (states.contains(ApplicationDomain::ConnectedStatus)) {
-                return ApplicationDomain::ConnectedStatus;
+            if (states.contains(ApplicationDomain::OfflineStatus)) {
+                return ApplicationDomain::OfflineStatus;
             }
-            return ApplicationDomain::OfflineStatus;
+            return ApplicationDomain::ConnectedStatus;
         }();
         account.setStatusStatus(status);
     });
diff --git a/common/resourcefacade.h b/common/resourcefacade.h
index 1cc075c..76fadce 100644
--- a/common/resourcefacade.h
+++ b/common/resourcefacade.h
@@ -36,24 +36,24 @@ class ConfigNotifier : public QObject
 {
     Q_OBJECT
 public:
-    void add(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account)
+    void add(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type)
     {
-        emit added(account);
+        emit added(account, type);
     }
 
-    void remove(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account)
+    void remove(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type)
     {
-        emit removed(account);
+        emit removed(account, type);
     }
 
-    void modify(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account)
+    void modify(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type)
     {
-        emit modified(account);
+        emit modified(account, type);
     }
 signals:
-    void added(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account);
-    void removed(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account);
-    void modified(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account);
+    void added(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type);
+    void removed(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type);
+    void modified(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type);
 };
 
 template <typename DomainType>
diff --git a/common/specialpurposepreprocessor.cpp b/common/specialpurposepreprocessor.cpp
index 25a6d1a..54f7f46 100644
--- a/common/specialpurposepreprocessor.cpp
+++ b/common/specialpurposepreprocessor.cpp
@@ -5,8 +5,6 @@
 
 using namespace Sink;
 
-SINK_DEBUG_AREA("SpecialPurposeProcessor")
-
 static QHash<QByteArray, QString> specialPurposeFolders()
 {
     QHash<QByteArray, QString> hash;
diff --git a/common/storage.h b/common/storage.h
index 71e9401..8c129df 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -25,10 +25,19 @@
 #include <string>
 #include <functional>
 #include <QString>
+#include <QMap>
 
 namespace Sink {
 namespace Storage {
 
+struct SINK_EXPORT DbLayout {
+    typedef QMap<QByteArray, int> Databases;
+    DbLayout();
+    DbLayout(const QByteArray &, const Databases &);
+    QByteArray name;
+    Databases tables;
+};
+
 class SINK_EXPORT DataStore
 {
 public:
@@ -132,7 +141,6 @@ public:
         void abort();
 
         QList<QByteArray> getDatabaseNames() const;
-        bool validateNamedDatabases();
 
         NamedDatabase openDatabase(const QByteArray &name = {"default"},
             const std::function<void(const DataStore::Error &error)> &errorHandler = {}, bool allowDuplicates = false) const;
@@ -152,6 +160,7 @@ public:
     };
 
     DataStore(const QString &storageRoot, const QString &name, AccessMode mode = ReadOnly);
+    DataStore(const QString &storageRoot, const DbLayout &layout, AccessMode mode = ReadOnly);
     ~DataStore();
 
     Transaction createTransaction(AccessMode mode = ReadWrite, const std::function<void(const DataStore::Error &error)> &errorHandler = std::function<void(const DataStore::Error &error)>());
diff --git a/common/storage/entitystore.cpp b/common/storage/entitystore.cpp
index b7309ab..22e5ae3 100644
--- a/common/storage/entitystore.cpp
+++ b/common/storage/entitystore.cpp
@@ -36,9 +36,75 @@
 using namespace Sink;
 using namespace Sink::Storage;
 
+static QMap<QByteArray, int> baseDbs()
+{
+    return {{"revisionType", 0},
+            {"revisions", 0},
+            {"uids", 0},
+            {"default", 0},
+            {"__flagtable", 0}};
+}
+
+template <typename T, typename First>
+void mergeImpl(T &map, First f)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+}
+
+template <typename T, typename First, typename ... Tail>
+void mergeImpl(T &map, First f, Tail ...maps)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+    mergeImpl<T, Tail...>(map, maps...);
+}
+
+template <typename First, typename ... Tail>
+First merge(First f, Tail ...maps)
+{
+    First map;
+    mergeImpl(map, f, maps...);
+    return map;
+}
+
+template <class T>
+struct DbLayoutHelper {
+    void operator()(QMap<QByteArray, int> map) const {
+        mergeImpl(map, ApplicationDomain::TypeImplementation<T>::typeDatabases());
+    }
+};
+
+static Sink::Storage::DbLayout dbLayout(const QByteArray &instanceId)
+{
+    static auto databases = [] {
+        QMap<QByteArray, int> map;
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Mail>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Folder>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Contact>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Addressbook>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Event>::typeDatabases());
+        return merge(baseDbs(), map);
+    }();
+    return {instanceId, databases};
+}
+
+
 class EntityStore::Private {
 public:
-    Private(const ResourceContext &context, const Sink::Log::Context &ctx) : resourceContext(context), logCtx(ctx.subContext("entitystore")) {}
+    Private(const ResourceContext &context, const Sink::Log::Context &ctx) : resourceContext(context), logCtx(ctx.subContext("entitystore"))
+    {
+        static bool initialized = false;
+        if (!initialized) {
+            if (QDir{}.mkpath(entityBlobStorageDir())) {
+                initialized = true;
+            } else {
+                SinkWarningCtx(logCtx) << "Failed to create the directory: " << entityBlobStorageDir();
+            }
+        }
+    }
 
     ResourceContext resourceContext;
     DataStore::Transaction transaction;
@@ -56,7 +122,7 @@ public:
             return transaction;
         }
 
-        Sink::Storage::DataStore store(Sink::storageLocation(), resourceContext.instanceId(), DataStore::ReadOnly);
+        Sink::Storage::DataStore store(Sink::storageLocation(), dbLayout(resourceContext.instanceId()), DataStore::ReadOnly);
         transaction = store.createTransaction(DataStore::ReadOnly);
         return transaction;
     }
@@ -93,9 +159,14 @@ public:
         return ApplicationDomain::ApplicationDomainType{resourceContext.instanceId(), uid, revision, adaptor};
     }
 
+    QString entityBlobStorageDir()
+    {
+        return Sink::resourceStorageLocation(resourceContext.instanceId()) + "/blob";
+    }
+
     QString entityBlobStoragePath(const QByteArray &id)
     {
-        return Sink::resourceStorageLocation(resourceContext.instanceId()) + "/blob/" + id;
+        return entityBlobStorageDir() +"/"+ id;
     }
 
 };
@@ -110,9 +181,8 @@ void EntityStore::startTransaction(Sink::Storage::DataStore::AccessMode accessMo
 {
     SinkTraceCtx(d->logCtx) << "Starting transaction: " << accessMode;
     Q_ASSERT(!d->transaction);
-    Sink::Storage::DataStore store(Sink::storageLocation(), d->resourceContext.instanceId(), accessMode);
+    Sink::Storage::DataStore store(Sink::storageLocation(), dbLayout(d->resourceContext.instanceId()), accessMode);
     d->transaction = store.createTransaction(accessMode);
-    Q_ASSERT(d->transaction.validateNamedDatabases());
 }
 
 void EntityStore::commitTransaction()
@@ -138,9 +208,6 @@ bool EntityStore::hasTransaction() const
 void EntityStore::copyBlobs(ApplicationDomain::ApplicationDomainType &entity, qint64 newRevision)
 {
     const auto directory = d->entityBlobStoragePath(entity.identifier());
-    if (!QDir().mkpath(directory)) {
-        SinkWarningCtx(d->logCtx) << "Failed to create the directory: " << directory;
-    }
 
     for (const auto &property : entity.changedProperties()) {
         const auto value = entity.getProperty(property);
@@ -149,7 +216,7 @@ void EntityStore::copyBlobs(ApplicationDomain::ApplicationDomainType &entity, qi
             //Any blob that is not part of the storage yet has to be moved there.
             if (blob.isExternal) {
                 auto oldPath = blob.value;
-                auto filePath = directory + QString("/%1%2.blob").arg(QString::number(newRevision)).arg(QString::fromLatin1(property));
+                auto filePath = directory + QString("_%1%2.blob").arg(QString::number(newRevision)).arg(QString::fromLatin1(property));
                 //In case we hit the same revision again due to a rollback.
                 QFile::remove(filePath);
                 QFile origFile(oldPath);
@@ -320,6 +387,11 @@ void EntityStore::cleanupEntityRevisionsUntil(qint64 revision)
 {
     const auto uid = DataStore::getUidFromRevision(d->transaction, revision);
     const auto bufferType = DataStore::getTypeFromRevision(d->transaction, revision);
+    if (bufferType.isEmpty() || uid.isEmpty()) {
+        SinkErrorCtx(d->logCtx) << "Failed to find revision during cleanup: " << revision;
+        Q_ASSERT(false);
+        return;
+    }
     SinkTraceCtx(d->logCtx) << "Cleaning up revision " << revision << uid << bufferType;
     DataStore::mainDatabase(d->transaction, bufferType)
         .scan(uid,
@@ -337,10 +409,10 @@ void EntityStore::cleanupEntityRevisionsUntil(qint64 revision)
                         DataStore::mainDatabase(d->transaction, bufferType).remove(key);
                     }
                     if (isRemoval) {
-                        const auto directory = d->entityBlobStoragePath(uid);
-                        QDir dir(directory);
-                        if (!dir.removeRecursively()) {
-                            SinkErrorCtx(d->logCtx) << "Failed to cleanup: " << directory;
+                        QDir dir{d->entityBlobStorageDir()};
+                        const auto infoList = dir.entryInfoList(QStringList{} << QString{uid + "*"});
+                        for (const auto &fileInfo : infoList) {
+                            QFile::remove(fileInfo.filePath());
                         }
                     }
                     //Don't cleanup more than specified
@@ -614,29 +686,6 @@ qint64 EntityStore::maxRevision()
     return DataStore::maxRevision(d->getTransaction());
 }
 
-/* DataStore::Transaction getTransaction() */
-/* { */
-/*     Sink::Storage::DataStore::Transaction transaction; */
-/*     { */
-/*         Sink::Storage::DataStore storage(Sink::storageLocation(), mResourceInstanceIdentifier); */
-/*         if (!storage.exists()) { */
-/*             //This is not an error if the resource wasn't started before */
-/*             SinkLogCtx(d->logCtx) << "Store doesn't exist: " << mResourceInstanceIdentifier; */
-/*             return Sink::Storage::DataStore::Transaction(); */
-/*         } */
-/*         storage.setDefaultErrorHandler([this](const Sink::Storage::DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Error during query: " << error.store << error.message; }); */
-/*         transaction = storage.createTransaction(Sink::Storage::DataStore::ReadOnly); */
-/*     } */
-
-/*     //FIXME this is a temporary measure to recover from a failure to open the named databases correctly. */
-/*     //Once the actual problem is fixed it will be enough to simply crash if we open the wrong database (which we check in openDatabase already). */
-/*     while (!transaction.validateNamedDatabases()) { */
-/*         Sink::Storage::DataStore storage(Sink::storageLocation(), mResourceInstanceIdentifier); */
-/*         transaction = storage.createTransaction(Sink::Storage::DataStore::ReadOnly); */
-/*     } */
-/*     return transaction; */
-/* } */
-
 Sink::Log::Context EntityStore::logContext() const
 {
     return d->logCtx;
diff --git a/common/storage_common.cpp b/common/storage_common.cpp
index 81a38c7..8603787 100644
--- a/common/storage_common.cpp
+++ b/common/storage_common.cpp
@@ -24,8 +24,6 @@
 #include "log.h"
 #include <QUuid>
 
-SINK_DEBUG_AREA("storage")
-
 QDebug& operator<<(QDebug &dbg, const Sink::Storage::DataStore::Error &error)
 {
     dbg << error.message << "Code: " << error.code << "Db: " << error.store;
@@ -38,6 +36,18 @@ namespace Storage {
 static const char *s_internalPrefix = "__internal";
 static const int s_internalPrefixSize = strlen(s_internalPrefix);
 
+DbLayout::DbLayout()
+{
+
+}
+
+DbLayout::DbLayout(const QByteArray &n, const Databases &t)
+    : name(n),
+    tables(t)
+{
+
+}
+
 void errorHandler(const DataStore::Error &error)
 {
     if (error.code == DataStore::TransactionError) {
@@ -113,7 +123,7 @@ QByteArray DataStore::getUidFromRevision(const DataStore::Transaction &transacti
     transaction.openDatabase("revisions")
         .scan(QByteArray::number(revision),
             [&](const QByteArray &, const QByteArray &value) -> bool {
-                uid = value;
+                uid = QByteArray{value.constData(), value.size()};
                 return false;
             },
             [revision](const Error &error) { SinkWarning() << "Couldn't find uid for revision: " << revision << error.message; });
@@ -126,7 +136,7 @@ QByteArray DataStore::getTypeFromRevision(const DataStore::Transaction &transact
     transaction.openDatabase("revisionType")
         .scan(QByteArray::number(revision),
             [&](const QByteArray &, const QByteArray &value) -> bool {
-                type = value;
+                type = QByteArray{value.constData(), value.size()};
                 return false;
             },
             [revision](const Error &error) { SinkWarning() << "Couldn't find type for revision " << revision; });
@@ -207,6 +217,11 @@ QByteArray DataStore::generateUid()
 
 DataStore::NamedDatabase DataStore::mainDatabase(const DataStore::Transaction &t, const QByteArray &type)
 {
+    if (type.isEmpty()) {
+        SinkError() << "Tried to open main database for empty type.";
+        Q_ASSERT(false);
+        return {};
+    }
     return t.openDatabase(type + ".main");
 }
 
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index 08eea37..f7999d1 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -35,9 +35,6 @@
 #include <lmdb.h>
 #include "log.h"
 
-SINK_DEBUG_AREA("storage")
-// SINK_DEBUG_COMPONENT(d->storageRoot.toLatin1() + '/' + d->name.toLatin1())
-
 namespace Sink {
 namespace Storage {
 
@@ -169,6 +166,27 @@ public:
             if (const int rc = mdb_dbi_open(transaction, db.constData(), flags, &dbi)) {
                 //Create the db if it is not existing already
                 if (rc == MDB_NOTFOUND && !readOnly) {
+                    //Sanity check db name
+                    {
+                        auto parts = db.split('.');
+                        for (const auto &p : parts) {
+                            auto containsSpecialCharacter = [] (const QByteArray &p) {
+                                for (int i = 0; i < p.size(); i++) {
+                                    const auto c = p.at(i);
+                                    //Between 0 and z in the ascii table. Essentially ensures that the name is printable and doesn't contain special chars
+                                    if (c < 0x30 || c > 0x7A) {
+                                        return true;
+                                    }
+                                }
+                                return false;
+                            };
+                            if (p.isEmpty() || containsSpecialCharacter(p)) {
+                                SinkError() << "Tried to create a db with an invalid name. Hex:" << db.toHex() << " ASCII:" << db;
+                                Q_ASSERT(false);
+                                throw std::runtime_error("Fatal error while creating db.");
+                            }
+                        }
+                    }
                     if (const int rc = mdb_dbi_open(transaction, db.constData(), flags | MDB_CREATE, &dbi)) {
                         SinkWarning() << "Failed to create db " << QByteArray(mdb_strerror(rc));
                         Error error(name.toLatin1(), ErrorCodes::GenericError, "Error while creating database: " + QByteArray(mdb_strerror(rc)));
@@ -542,6 +560,7 @@ DataStore::Transaction::Transaction(Transaction &&other) : d(nullptr)
 DataStore::Transaction &DataStore::Transaction::operator=(DataStore::Transaction &&other)
 {
     if (&other != this) {
+        abort();
         delete d;
         d = other.d;
         other.d = nullptr;
@@ -639,11 +658,6 @@ static bool ensureCorrectDb(DataStore::NamedDatabase &database, const QByteArray
     return !openedTheWrongDatabase;
 }
 
-bool DataStore::Transaction::validateNamedDatabases()
-{
-    return true;
-}
-
 DataStore::NamedDatabase DataStore::Transaction::openDatabase(const QByteArray &db, const std::function<void(const DataStore::Error &error)> &errorHandler, bool allowDuplicates) const
 {
     if (!d) {
@@ -694,7 +708,7 @@ QList<QByteArray> DataStore::Transaction::getDatabaseNames() const
 class DataStore::Private
 {
 public:
-    Private(const QString &s, const QString &n, AccessMode m);
+    Private(const QString &s, const QString &n, AccessMode m, const DbLayout &layout = {});
     ~Private();
 
     QString storageRoot;
@@ -702,68 +716,85 @@ public:
 
     MDB_env *env;
     AccessMode mode;
+    Sink::Log::Context logCtx;
+
+    void initEnvironment(const QString &fullPath, const DbLayout &layout)
+    {
+        // Ensure the environment is only created once, and that we only have one environment per process
+        if (!(env = sEnvironments.value(fullPath))) {
+            QMutexLocker locker(&sMutex);
+            if (!(env = sEnvironments.value(fullPath))) {
+                int rc = 0;
+                if ((rc = mdb_env_create(&env))) {
+                    SinkWarningCtx(logCtx) << "mdb_env_create: " << rc << " " << mdb_strerror(rc);
+                    qCritical() << "mdb_env_create: " << rc << " " << mdb_strerror(rc);
+                } else {
+                    //Limit large enough to accomodate all our named dbs. This only starts to matter if the number gets large, otherwise it's just a bunch of extra entries in the main table.
+                    mdb_env_set_maxdbs(env, 50);
+                    const bool readOnly = (mode == ReadOnly);
+                    unsigned int flags = MDB_NOTLS;
+                    if (readOnly) {
+                        flags |= MDB_RDONLY;
+                    }
+                    if ((rc = mdb_env_open(env, fullPath.toStdString().data(), flags, 0664))) {
+                        SinkWarningCtx(logCtx) << "mdb_env_open: " << rc << ":" << mdb_strerror(rc);
+                        mdb_env_close(env);
+                        env = 0;
+                    } else {
+                        if (RUNNING_ON_VALGRIND) {
+                            // In order to run valgrind this size must be smaller than half your available RAM
+                            // https://github.com/BVLC/caffe/issues/2404
+                            mdb_env_set_mapsize(env, (size_t)10485760 * (size_t)1000); // 1MB * 1000
+                        } else {
+                            //This is the maximum size of the db (but will not be used directly), so we make it large enough that we hopefully never run into the limit.
+                            mdb_env_set_mapsize(env, (size_t)10485760 * (size_t)100000); // 1MB * 1000
+                        }
+                        Q_ASSERT(env);
+                        sEnvironments.insert(fullPath, env);
+                        //Open all available dbi's
+                        bool noLock = true;
+                        auto t = Transaction(new Transaction::Private(readOnly, nullptr, name, env, noLock));
+                        if (!layout.tables.isEmpty()) {
+
+                            //TODO upgrade db if the layout has changed:
+                            //* read existing layout
+                            //* if layout is not the same create new layout
+                        //If the db is read only, abort if the db is not yet existing.
+                        //If the db is not read-only but is not existing, ensure we have a layout and create all tables.
+
+                            for (auto it = layout.tables.constBegin(); it != layout.tables.constEnd(); it++) {
+                                bool allowDuplicates = it.value();
+                                t.openDatabase(it.key(), {}, allowDuplicates);
+                            }
+                        } else {
+                            for (const auto &db : t.getDatabaseNames()) {
+                                //Get dbi to store for future use.
+                                t.openDatabase(db);
+                            }
+                        }
+                        //To persist the dbis (this is also necessary for read-only transactions)
+                        t.commit();
+                    }
+                }
+            }
+        }
+    }
+
 };
 
-DataStore::Private::Private(const QString &s, const QString &n, AccessMode m) : storageRoot(s), name(n), env(0), mode(m)
+DataStore::Private::Private(const QString &s, const QString &n, AccessMode m, const DbLayout &layout) : storageRoot(s), name(n), env(0), mode(m), logCtx(n.toLatin1())
 {
+
     const QString fullPath(storageRoot + '/' + name);
     QFileInfo dirInfo(fullPath);
     if (!dirInfo.exists() && mode == ReadWrite) {
         QDir().mkpath(fullPath);
         dirInfo.refresh();
     }
-    Sink::Log::Context logCtx{n.toLatin1()};
     if (mode == ReadWrite && !dirInfo.permission(QFile::WriteOwner)) {
         qCritical() << fullPath << "does not have write permissions. Aborting";
     } else if (dirInfo.exists()) {
-        // Ensure the environment is only created once
-        QMutexLocker locker(&sMutex);
-
-        /*
-        * It seems we can only ever have one environment open in the process.
-        * Otherwise multi-threading breaks.
-        */
-        env = sEnvironments.value(fullPath);
-        if (!env) {
-            int rc = 0;
-            if ((rc = mdb_env_create(&env))) {
-                // TODO: handle error
-                SinkWarningCtx(logCtx) << "mdb_env_create: " << rc << " " << mdb_strerror(rc);
-            } else {
-                mdb_env_set_maxdbs(env, 50);
-                unsigned int flags = MDB_NOTLS;
-                if (mode == ReadOnly) {
-                    flags |= MDB_RDONLY;
-                }
-                if ((rc = mdb_env_open(env, fullPath.toStdString().data(), flags, 0664))) {
-                    SinkWarningCtx(logCtx) << "mdb_env_open: " << rc << ":" << mdb_strerror(rc);
-                    mdb_env_close(env);
-                    env = 0;
-                } else {
-                    if (RUNNING_ON_VALGRIND) {
-                        // In order to run valgrind this size must be smaller than half your available RAM
-                        // https://github.com/BVLC/caffe/issues/2404
-                        const size_t dbSize = (size_t)10485760 * (size_t)1000; // 1MB * 1000
-                        mdb_env_set_mapsize(env, dbSize);
-                    } else {
-                        // FIXME: dynamic resize
-                        const size_t dbSize = (size_t)10485760 * (size_t)8000; // 1MB * 8000
-                        mdb_env_set_mapsize(env, dbSize);
-                    }
-                    sEnvironments.insert(fullPath, env);
-                    //Open all available dbi's
-                    bool noLock = true;
-                    bool requestedRead = m == ReadOnly;
-                    auto t = Transaction(new Transaction::Private(requestedRead, nullptr, name, env, noLock));
-                    for (const auto &db : t.getDatabaseNames()) {
-                        //Get dbi to store for future use.
-                        t.openDatabase(db);
-                    }
-                    //To persist the dbis (this is also necessary for read-only transactions)
-                    t.commit();
-                }
-            }
-        }
+        initEnvironment(fullPath, layout);
     }
 }
 
@@ -777,6 +808,10 @@ DataStore::DataStore(const QString &storageRoot, const QString &name, AccessMode
 {
 }
 
+DataStore::DataStore(const QString &storageRoot, const DbLayout &dbLayout, AccessMode mode) : d(new Private(storageRoot, dbLayout.name, mode, dbLayout))
+{
+}
+
 DataStore::~DataStore()
 {
     delete d;
diff --git a/common/store.cpp b/common/store.cpp
index d266098..4735113 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -36,8 +36,6 @@
 #include "storage.h"
 #include "log.h"
 
-SINK_DEBUG_AREA("store")
-
 Q_DECLARE_METATYPE(QSharedPointer<Sink::ResultEmitter<Sink::ApplicationDomain::SinkResource::Ptr>>)
 Q_DECLARE_METATYPE(QSharedPointer<Sink::ResourceAccessInterface>);
 Q_DECLARE_METATYPE(std::shared_ptr<void>);
@@ -277,6 +275,19 @@ KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
         });
 }
 
+KAsync::Job<void> Store::upgrade()
+{
+    SinkLog() << "Upgrading...";
+    return fetchAll<ApplicationDomain::SinkResource>({})
+        .template each([](const ApplicationDomain::SinkResource::Ptr &resource) -> KAsync::Job<void> {
+            SinkLog() << "Removing caches for " << resource->identifier();
+            return removeDataFromDisk(resource->identifier());
+        })
+        .then([] {
+            SinkLog() << "Upgrade complete.";
+        });
+}
+
 static KAsync::Job<void> synchronize(const QByteArray &resource, const Sink::SyncScope &scope)
 {
     SinkLog() << "Synchronizing " << resource << scope;
diff --git a/common/store.h b/common/store.h
index fae76e5..34e14df 100644
--- a/common/store.h
+++ b/common/store.h
@@ -122,6 +122,18 @@ KAsync::Job<void> SINK_EXPORT synchronize(const Sink::SyncScope &query);
  */
 KAsync::Job<void> SINK_EXPORT removeDataFromDisk(const QByteArray &resourceIdentifier);
 
+/**
+ * Run upgrade jobs.
+ *
+ * Run this to upgrade your local database to a new version.
+ * Note that this may:
+ * * take a while
+ * * remove some/all of your local caches
+ *
+ * Note: The initial implementation simply calls removeDataFromDisk for all resources.
+ */
+KAsync::Job<void> SINK_EXPORT upgrade();
+
 template <class DomainType>
 KAsync::Job<DomainType> SINK_EXPORT fetchOne(const Sink::Query &query);
 
diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index 3e7bd30..3b32e68 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -304,9 +304,29 @@ void Synchronizer::emitNotification(Notification::NoticationType type, int code,
     emit notify(n);
 }
 
-void Synchronizer::reportProgress(int progress, int total)
+void Synchronizer::emitProgressNotification(Notification::NoticationType type, int progress, int total, const QByteArray &id, const QByteArrayList &entities)
 {
-    SinkLogCtx(mLogCtx) << "Progress: " << progress << " out of " << total;
+    Sink::Notification n;
+    n.id = id;
+    n.type = type;
+    n.progress = progress;
+    n.total = total;
+    n.entities = entities;
+    emit notify(n);
+}
+
+void Synchronizer::reportProgress(int progress, int total, const QByteArrayList &entities)
+{
+    if (progress > 0 && total > 0) {
+        SinkLogCtx(mLogCtx) << "Progress: " << progress << " out of " << total << mCurrentRequest.requestId << mCurrentRequest.applicableEntities;
+        const auto applicableEntities = [&] {
+            if (entities.isEmpty()) {
+                return mCurrentRequest.applicableEntities;
+            }
+            return entities;
+        }();
+        emitProgressNotification(Notification::Progress, progress, total, mCurrentRequest.requestId, applicableEntities);
+    }
 }
 
 void Synchronizer::setStatusFromResult(const KAsync::Error &error, const QString &s, const QByteArray &requestId)
@@ -315,6 +335,9 @@ void Synchronizer::setStatusFromResult(const KAsync::Error &error, const QString
         if (error.errorCode == ApplicationDomain::ConnectionError) {
             //Couldn't connect, so we assume we don't have a network connection.
             setStatus(ApplicationDomain::OfflineStatus, s, requestId);
+        } else if (error.errorCode == ApplicationDomain::NoServerError) {
+            //Failed to contact the server.
+            setStatus(ApplicationDomain::OfflineStatus, s, requestId);
         } else if (error.errorCode == ApplicationDomain::ConfigurationError) {
             //There is an error with the configuration.
             setStatus(ApplicationDomain::ErrorStatus, s, requestId);
@@ -354,6 +377,7 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
     } else if (request.requestType == Synchronizer::SyncRequest::Synchronization) {
         return KAsync::start([this, request] {
             SinkLogCtx(mLogCtx) << "Synchronizing: " << request.query;
+            setBusy(true, "Synchronization has started.", request.requestId);
             emitNotification(Notification::Info, ApplicationDomain::SyncInProgress, {}, {}, request.applicableEntities);
         }).then(synchronizeWithSource(request.query)).then([this] {
             //Commit after every request, so implementations only have to commit more if they add a lot of data.
@@ -391,11 +415,12 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
             return KAsync::null();
         } else {
             return KAsync::start([this, request] {
+                setBusy(true, "ChangeReplay has started.", request.requestId);
                 SinkLogCtx(mLogCtx) << "Replaying changes.";
             })
             .then(replayNextRevision())
             .then<void>([this, request](const KAsync::Error &error) {
-                setStatusFromResult(error, "Changereplay has ended.", "changereplay");
+                setStatusFromResult(error, "Changereplay has ended.", request.requestId);
                 if (error) {
                     SinkWarningCtx(mLogCtx) << "Changereplay failed: " << error.errorMessage;
                     return KAsync::error(error);
@@ -462,16 +487,13 @@ KAsync::Job<void> Synchronizer::processSyncQueue()
         mMessageQueue->startTransaction();
         mEntityStore->startTransaction(Sink::Storage::DataStore::ReadOnly);
         mSyncInProgress = true;
-        if (request.requestType == Synchronizer::SyncRequest::Synchronization) {
-            setBusy(true, "Synchronization has started.", request.requestId);
-        } else if (request.requestType == Synchronizer::SyncRequest::ChangeReplay) {
-            setBusy(true, "ChangeReplay has started.", "changereplay");
-        }
+        mCurrentRequest = request;
     })
     .then(processRequest(request))
     .then<void>([this, request](const KAsync::Error &error) {
         SinkTraceCtx(mLogCtx) << "Sync request processed";
         setBusy(false, {}, request.requestId);
+        mCurrentRequest = {};
         mEntityStore->abortTransaction();
         mSyncTransaction.abort();
         mMessageQueue->commit();
@@ -516,7 +538,7 @@ void Synchronizer::revisionChanged()
             return;
         }
     }
-    mSyncRequestQueue << Synchronizer::SyncRequest{Synchronizer::SyncRequest::ChangeReplay};
+    mSyncRequestQueue << Synchronizer::SyncRequest{Synchronizer::SyncRequest::ChangeReplay, "changereplay"};
     processSyncQueue().exec();
 }
 
@@ -607,11 +629,14 @@ KAsync::Job<void> Synchronizer::replay(const QByteArray &type, const QByteArray
         }
     })
     .then([this](const KAsync::Error &error) {
+        //We need to commit here otherwise the next change-replay step will abort the transaction
+        mSyncStore.clear();
+        mSyncTransaction.commit();
         if (error) {
             SinkWarningCtx(mLogCtx) << "Failed to replay change: " << error.errorMessage;
+            return KAsync::error(error);
         }
-        mSyncStore.clear();
-        mSyncTransaction.commit();
+        return KAsync::null();
     });
 }
 
diff --git a/common/synchronizer.h b/common/synchronizer.h
index b1ee122..cc082be 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -131,6 +131,8 @@ protected:
             RequestFlush
         };
 
+        SyncRequest() = default;
+
         SyncRequest(const Sink::QueryBase &q, const QByteArray &requestId_ = QByteArray(), RequestOptions o = NoOptions)
             : requestId(requestId_),
             requestType(Synchronization),
@@ -145,6 +147,12 @@ protected:
         {
         }
 
+        SyncRequest(RequestType type, const QByteArray &requestId_)
+            : requestId(requestId_),
+            requestType(type)
+        {
+        }
+
         SyncRequest(RequestType type, int flushType_, const QByteArray &requestId_)
             : flushType(flushType_),
             requestId(requestId_),
@@ -184,11 +192,12 @@ protected:
     virtual void mergeIntoQueue(const Synchronizer::SyncRequest &request, QList<Synchronizer::SyncRequest> &queue);
 
     void emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id = QByteArray{}, const QByteArrayList &entiteis = QByteArrayList{});
+    void emitProgressNotification(Notification::NoticationType type, int progress, int total, const QByteArray &id, const QByteArrayList &entities);
 
     /**
      * Report progress for current task
      */
-    void reportProgress(int progress, int total);
+    virtual void reportProgress(int progress, int total, const QByteArrayList &entities = {}) Q_DECL_OVERRIDE;
 
 protected:
     Sink::Log::Context mLogCtx;
@@ -211,6 +220,7 @@ private:
     Sink::Storage::DataStore::Transaction mSyncTransaction;
     std::function<void(int commandId, const QByteArray &data)> mEnqueue;
     QList<SyncRequest> mSyncRequestQueue;
+    SyncRequest mCurrentRequest;
     MessageQueue *mMessageQueue;
     bool mSyncInProgress;
     QMultiHash<QByteArray, SyncRequest> mPendingSyncRequests;
diff --git a/common/synchronizerstore.cpp b/common/synchronizerstore.cpp
index 5364094..79cd920 100644
--- a/common/synchronizerstore.cpp
+++ b/common/synchronizerstore.cpp
@@ -25,8 +25,6 @@
 
 using namespace Sink;
 
-SINK_DEBUG_AREA("synchronizerstore")
-
 SynchronizerStore::SynchronizerStore(Sink::Storage::DataStore::Transaction &transaction)
     : mTransaction(transaction)
 {
diff --git a/common/test.cpp b/common/test.cpp
index 90586ba..237d3bb 100644
--- a/common/test.cpp
+++ b/common/test.cpp
@@ -29,8 +29,6 @@
 #include "resourceconfig.h"
 #include "definitions.h"
 
-SINK_DEBUG_AREA("test")
-
 using namespace Sink;
 
 void Sink::Test::initTest()
@@ -83,6 +81,7 @@ void Sink::Test::initTest()
 void Sink::Test::setTestModeEnabled(bool enabled)
 {
     QStandardPaths::setTestModeEnabled(enabled);
+    Sink::clearLocationCache();
     if (enabled) {
         qputenv("SINK_TESTMODE", "TRUE");
     } else {
diff --git a/common/typeindex.cpp b/common/typeindex.cpp
index 153aa43..5a19839 100644
--- a/common/typeindex.cpp
+++ b/common/typeindex.cpp
@@ -21,18 +21,20 @@
 #include "log.h"
 #include "index.h"
 #include <QDateTime>
-
-SINK_DEBUG_AREA("typeindex")
+#include <QDataStream>
 
 using namespace Sink;
 
 static QByteArray getByteArray(const QVariant &value)
 {
     if (value.type() == QVariant::DateTime) {
-        const auto result = value.toDateTime().toString().toLatin1();
-        if (result.isEmpty()) {
-            return "nodate";
-        }
+        QByteArray result;
+        QDataStream ds(&result, QIODevice::WriteOnly);
+        ds << value.toDateTime();
+        return result;
+    }
+    if (value.type() == QVariant::Bool) {
+        return value.toBool() ? "t" : "f";
     }
     if (value.canConvert<Sink::ApplicationDomain::Reference>()) {
         const auto ba = value.value<Sink::ApplicationDomain::Reference>().value;
@@ -85,6 +87,20 @@ void TypeIndex::addProperty<QByteArray>(const QByteArray &property)
 }
 
 template <>
+void TypeIndex::addProperty<bool>(const QByteArray &property)
+{
+    auto indexer = [this, property](bool add, const QByteArray &identifier, const QVariant &value, Sink::Storage::DataStore::Transaction &transaction) {
+        if (add) {
+            Index(indexName(property), transaction).add(getByteArray(value), identifier);
+        } else {
+            Index(indexName(property), transaction).remove(getByteArray(value), identifier);
+        }
+    };
+    mIndexer.insert(property, indexer);
+    mProperties << property;
+}
+
+template <>
 void TypeIndex::addProperty<QString>(const QByteArray &property)
 {
     auto indexer = [this, property](bool add, const QByteArray &identifier, const QVariant &value, Sink::Storage::DataStore::Transaction &transaction) {
@@ -266,6 +282,18 @@ void TypeIndex::index<QString, QByteArray>(const QByteArray &leftName, const QBy
 }
 
 template <>
+void TypeIndex::unindex<QByteArray, QByteArray>(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction)
+{
+    Index(indexName(leftName + rightName), transaction).remove(getByteArray(leftValue), getByteArray(rightValue));
+}
+
+template <>
+void TypeIndex::unindex<QString, QByteArray>(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction)
+{
+    Index(indexName(leftName + rightName), transaction).remove(getByteArray(leftValue), getByteArray(rightValue));
+}
+
+template <>
 QVector<QByteArray> TypeIndex::secondaryLookup<QByteArray>(const QByteArray &leftName, const QByteArray &rightName, const QVariant &value)
 {
     QVector<QByteArray> keys;
diff --git a/common/typeindex.h b/common/typeindex.h
index 1f216a7..890c3db 100644
--- a/common/typeindex.h
+++ b/common/typeindex.h
@@ -95,6 +95,15 @@ public:
     template <typename LeftType, typename RightType>
     void index(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction);
 
+    template <typename Left, typename Right>
+    void unindex(const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction)
+    {
+        index<typename Left::Type, typename Right::Type>(Left::name, Right::name, leftValue, rightValue, transaction);
+    }
+
+    template <typename LeftType, typename RightType>
+    void unindex(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction);
+
 
 private:
     friend class Sink::Storage::EntityStore;
diff --git a/dist/sink.spec b/dist/sink.spec
index 60015f7..f5132b7 100644
--- a/dist/sink.spec
+++ b/dist/sink.spec
@@ -1,7 +1,7 @@
 
 Name:           sink
-Version:        0.2.0
-Release:            0%{?dist}
+Version:        0.3
+Release:            10%{?dist}
 Summary:        sink
 
 Group:          Applications/Desktop
@@ -18,6 +18,7 @@ BuildRequires:  kf5-kcoreaddons-devel
 BuildRequires:  kf5-kcontacts-devel
 BuildRequires:  kf5-kmime-devel
 BuildRequires:  kimap2-devel
+BuildRequires:  kdav2-devel
 BuildRequires:  libcurl-devel
 BuildRequires:  libgit2-devel
 BuildRequires:  lmdb-devel
@@ -37,17 +38,11 @@ Development headers for sink
 %prep
 %setup -q
 
-sed -i \
-    -e '/inspectiontest/d' \
-    -e '/maildirresourcetest/d' \
-    tests/CMakeLists.txt
-
 %build
 mkdir -p build/
 pushd build
 %{cmake} \
     -DQT_PLUGIN_INSTALL_DIR:PATH=%{_libdir}/qt5/plugins/ \
-    -DBUILD_DAV=OFF \
     ..
 
 make %{?_smp_mflags}
@@ -58,7 +53,6 @@ pushd build
 %make_install
 popd
 
-#rm -rf %{buildroot}%{_prefix}/mkspecs/modules/qt_KMime.pri
 rm %{buildroot}%{_prefix}/bin/resetmailbox.sh
 rm %{buildroot}%{_prefix}/bin/populatemailbox.sh
 rm %{buildroot}%{_prefix}/bin/sink_smtp_test
diff --git a/examples/davresource/CMakeLists.txt b/examples/davresource/CMakeLists.txt
index 28829d5..7091edc 100644
--- a/examples/davresource/CMakeLists.txt
+++ b/examples/davresource/CMakeLists.txt
@@ -3,10 +3,10 @@ project(sink_resource_dav)
 add_definitions(-DQT_PLUGIN)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(KPimKDAV REQUIRED)
+find_package(KPimKDAV2 REQUIRED)
 
 add_library(${PROJECT_NAME} SHARED davresource.cpp)
 qt5_use_modules(${PROJECT_NAME} Core Network)
-target_link_libraries(${PROJECT_NAME} sink KPim::KDAV)
+target_link_libraries(${PROJECT_NAME} sink KPim::KDAV2)
 
 install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${SINK_RESOURCE_PLUGINS_PATH})
diff --git a/examples/davresource/davresource.cpp b/examples/davresource/davresource.cpp
index 50471ed..465220f 100644
--- a/examples/davresource/davresource.cpp
+++ b/examples/davresource/davresource.cpp
@@ -31,19 +31,17 @@
 
 #include "contactpreprocessor.h"
 
-#include <KDAV/DavCollection>
-#include <KDAV/DavCollectionsFetchJob>
-#include <KDAV/DavItem>
-#include <KDAV/DavItemsListJob>
-#include <KDAV/DavItemFetchJob>
-#include <KDAV/EtagCache>
+#include <KDAV2/DavCollection>
+#include <KDAV2/DavCollectionsFetchJob>
+#include <KDAV2/DavItem>
+#include <KDAV2/DavItemsListJob>
+#include <KDAV2/DavItemFetchJob>
+#include <KDAV2/EtagCache>
 
 //This is the resources entity type, and not the domain type
 #define ENTITY_TYPE_CONTACT "contact"
 #define ENTITY_TYPE_ADDRESSBOOK "addressbook"
 
-SINK_DEBUG_AREA("davresource")
-
 using namespace Sink;
 
 static KAsync::Job<void> runJob(KJob *job)
@@ -87,7 +85,7 @@ public:
         return remoteId;
     }
 
-    void synchronizeAddressbooks(const KDAV::DavCollection::List &addressbookList)
+    void synchronizeAddressbooks(const KDAV2::DavCollection::List &addressbookList)
     {
         const QByteArray bufferType = ENTITY_TYPE_ADDRESSBOOK;
         SinkTrace() << "Found addressbooks " << addressbookList.size();
@@ -121,12 +119,12 @@ public:
         return list;
     }
 
-    static QByteArray getRid(const KDAV::DavItem &item)
+    static QByteArray getRid(const KDAV2::DavItem &item)
     {
         return item.url().toDisplayString().toUtf8();
     }
 
-    static QByteArray getRid(const KDAV::DavCollection &item)
+    static QByteArray getRid(const KDAV2::DavCollection &item)
     {
         return item.url().toDisplayString().toUtf8();
     }
@@ -135,7 +133,7 @@ public:
     {
         if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Addressbook>()) {
             SinkLogCtx(mLogCtx) << "Synchronizing addressbooks:" <<  mResourceUrl.url();
-            auto collectionsFetchJob = new KDAV::DavCollectionsFetchJob(mResourceUrl);
+            auto collectionsFetchJob = new KDAV2::DavCollectionsFetchJob(mResourceUrl);
             auto job = runJob(collectionsFetchJob).then([this, collectionsFetchJob] (const KAsync::Error &error) {
                 if (error) {
                     SinkWarningCtx(mLogCtx) << "Failed to synchronize addressbooks." << collectionsFetchJob->errorString();
@@ -147,29 +145,29 @@ public:
         } else if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Contact>()) {
             SinkLogCtx(mLogCtx) << "Synchronizing contacts.";
             auto ridList = QSharedPointer<QByteArrayList>::create();
-            auto collectionsFetchJob = new KDAV::DavCollectionsFetchJob(mResourceUrl);
+            auto collectionsFetchJob = new KDAV2::DavCollectionsFetchJob(mResourceUrl);
             auto job = runJob(collectionsFetchJob).then([this, collectionsFetchJob] {
                 synchronizeAddressbooks(collectionsFetchJob ->collections());
                 return collectionsFetchJob->collections();
             })
-            .serialEach([this, ridList](const KDAV::DavCollection &collection) {
+            .serialEach([this, ridList](const KDAV2::DavCollection &collection) {
                 auto collId = getRid(collection);
                 const auto addressbookLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_ADDRESSBOOK, collId);
                 auto ctag = collection.CTag().toLatin1();
                 if (ctag != syncStore().readValue(collId + "_ctagXX")) {
                     SinkTraceCtx(mLogCtx) << "Syncing " << collId;
-                    auto cache = std::shared_ptr<KDAV::EtagCache>(new KDAV::EtagCache());
-                    auto davItemsListJob = new KDAV::DavItemsListJob(collection.url(), cache);
+                    auto cache = std::shared_ptr<KDAV2::EtagCache>(new KDAV2::EtagCache());
+                    auto davItemsListJob = new KDAV2::DavItemsListJob(collection.url(), cache);
                     const QByteArray bufferType = ENTITY_TYPE_CONTACT;
                     QHash<QByteArray, Query::Comparator> mergeCriteria;
                     auto colljob = runJob(davItemsListJob).then([davItemsListJob] {
                         return KAsync::value(davItemsListJob->items());
                     })
-                    .serialEach([=] (const KDAV::DavItem &item) {
+                    .serialEach([=] (const KDAV2::DavItem &item) {
                         QByteArray rid = getRid(item);
                         if (item.etag().toLatin1() != syncStore().readValue(rid + "_etag")){
                             SinkTrace() << "Updating " << rid;
-                            auto davItemFetchJob = new KDAV::DavItemFetchJob(item);
+                            auto davItemFetchJob = new KDAV2::DavItemFetchJob(item);
                             auto itemjob = runJob(davItemFetchJob)
                             .then([=] {
                                 const auto item = davItemFetchJob->item();
@@ -180,7 +178,7 @@ public:
                                 createOrModify(bufferType, rid, contact, mergeCriteria);
                                 return item;
                             })
-                            .then([this, ridList] (const KDAV::DavItem &item) {
+                            .then([this, ridList] (const KDAV2::DavItem &item) {
                                 const auto rid = getRid(item);
                                 syncStore().writeValue(rid + "_etag", item.etag().toLatin1());
                                 ridList->append(rid);
@@ -227,24 +225,19 @@ KAsync::Job<QByteArray> replay(const ApplicationDomain::Contact &contact, Sink::
     }
 
 public:
-    KDAV::DavUrl mResourceUrl;
+    KDAV2::DavUrl mResourceUrl;
 };
 
 
 DavResource::DavResource(const Sink::ResourceContext &resourceContext)
     : Sink::GenericResource(resourceContext)
 {
-    /*
-     * Fork KIO slaves (used in kdav), instead of starting them via klauncher.
-     * Otherwise we have yet another runtime dependency that will i.e. not work in the docker container.
-     */
-    qputenv("KDE_FORK_SLAVES", "TRUE");
     auto config = ResourceConfig::getConfiguration(resourceContext.instanceId());
     auto resourceUrl = QUrl::fromUserInput(config.value("server").toString());
     resourceUrl.setUserName(config.value("username").toString());
     resourceUrl.setPassword(config.value("password").toString());
 
-    mResourceUrl = KDAV::DavUrl(resourceUrl, KDAV::CardDav);
+    mResourceUrl = KDAV2::DavUrl(resourceUrl, KDAV2::CardDav);
 
     auto synchronizer = QSharedPointer<ContactSynchronizer>::create(resourceContext);
     synchronizer->mResourceUrl = mResourceUrl;
@@ -271,7 +264,7 @@ Sink::Resource *DavResourceFactory::createResource(const ResourceContext &contex
 void DavResourceFactory::registerFacades(const QByteArray &name, Sink::FacadeFactory &factory)
 {
     factory.registerFacade<ApplicationDomain::Contact, DefaultFacade<ApplicationDomain::Contact>>(name);
-    factory.registerFacade<ApplicationDomain::Addressbook, DefaultFacade<ApplicationDomain::Contact>>(name);
+    factory.registerFacade<ApplicationDomain::Addressbook, DefaultFacade<ApplicationDomain::Addressbook>>(name);
 }
 
 void DavResourceFactory::registerAdaptorFactories(const QByteArray &name, Sink::AdaptorFactoryRegistry &registry)
diff --git a/examples/davresource/davresource.h b/examples/davresource/davresource.h
index 1ce66ea..db175a4 100644
--- a/examples/davresource/davresource.h
+++ b/examples/davresource/davresource.h
@@ -21,7 +21,7 @@
 
 #include "common/genericresource.h"
 
-#include <KDAV/DavUrl>
+#include <KDAV2/DavUrl>
 #include <KAsync/Async>
 
 #include <flatbuffers/flatbuffers.h>
@@ -48,7 +48,7 @@ public:
 private:
     QStringList listAvailableFolders();
 
-    KDAV::DavUrl mResourceUrl;
+    KDAV2::DavUrl mResourceUrl;
 };
 
 class DavResourceFactory : public Sink::ResourceFactory
diff --git a/examples/dummyresource/domainadaptor.cpp b/examples/dummyresource/domainadaptor.cpp
index dcc08c7..e7a20da 100644
--- a/examples/dummyresource/domainadaptor.cpp
+++ b/examples/dummyresource/domainadaptor.cpp
@@ -28,9 +28,6 @@ using namespace flatbuffers;
 DummyEventAdaptorFactory::DummyEventAdaptorFactory()
     : DomainTypeAdaptorFactory()
 {
-    //TODO turn this into initializeReadPropertyMapper as well?
-    mResourceMapper->addMapping<Sink::ApplicationDomain::Event::Summary, DummyEvent>(&DummyEvent::summary);
-    mResourceWriteMapper->addMapping<Sink::ApplicationDomain::Event::Summary>(&DummyEventBuilder::add_summary);
 }
 
 DummyMailAdaptorFactory::DummyMailAdaptorFactory()
diff --git a/examples/dummyresource/domainadaptor.h b/examples/dummyresource/domainadaptor.h
index e7098e9..3faaa63 100644
--- a/examples/dummyresource/domainadaptor.h
+++ b/examples/dummyresource/domainadaptor.h
@@ -22,25 +22,23 @@
 #include "event_generated.h"
 #include "mail_generated.h"
 #include "folder_generated.h"
-#include "dummy_generated.h"
-#include "dummycalendar_generated.h"
 #include "entity_generated.h"
 
-class DummyEventAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event, DummyCalendar::DummyEvent, DummyCalendar::DummyEventBuilder>
+class DummyEventAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event>
 {
 public:
     DummyEventAdaptorFactory();
     virtual ~DummyEventAdaptorFactory() {};
 };
 
-class DummyMailAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail, Sink::ApplicationDomain::Buffer::Dummy, Sink::ApplicationDomain::Buffer::DummyBuilder>
+class DummyMailAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail>
 {
 public:
     DummyMailAdaptorFactory();
     virtual ~DummyMailAdaptorFactory() {};
 };
 
-class DummyFolderAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Folder, Sink::ApplicationDomain::Buffer::Dummy, Sink::ApplicationDomain::Buffer::DummyBuilder>
+class DummyFolderAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Folder>
 {
 public:
     DummyFolderAdaptorFactory();
diff --git a/examples/dummyresource/resourcefactory.cpp b/examples/dummyresource/resourcefactory.cpp
index c1f536e..dffdfc9 100644
--- a/examples/dummyresource/resourcefactory.cpp
+++ b/examples/dummyresource/resourcefactory.cpp
@@ -42,8 +42,6 @@
 #define ENTITY_TYPE_MAIL "mail"
 #define ENTITY_TYPE_FOLDER "folder"
 
-SINK_DEBUG_AREA("dummyresource")
-
 using namespace Sink;
 
 class DummySynchronizer : public Sink::Synchronizer {
diff --git a/examples/imapresource/CMakeLists.txt b/examples/imapresource/CMakeLists.txt
index 46a8b08..5d2d38b 100644
--- a/examples/imapresource/CMakeLists.txt
+++ b/examples/imapresource/CMakeLists.txt
@@ -4,7 +4,7 @@ add_definitions(-DQT_PLUGIN)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
 find_package(KF5 COMPONENTS REQUIRED Mime)
-find_package(KIMAP2 0.0.1 REQUIRED)
+find_package(KIMAP2 0.2 REQUIRED)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
diff --git a/examples/imapresource/imapresource.cpp b/examples/imapresource/imapresource.cpp
index 0579dae..81c808b 100644
--- a/examples/imapresource/imapresource.cpp
+++ b/examples/imapresource/imapresource.cpp
@@ -46,8 +46,6 @@
 #define ENTITY_TYPE_MAIL "mail"
 #define ENTITY_TYPE_FOLDER "folder"
 
-SINK_DEBUG_AREA("imapresource")
-
 Q_DECLARE_METATYPE(QSharedPointer<Imap::ImapServerProxy>)
 
 using namespace Imap;
@@ -87,6 +85,25 @@ static QByteArray parentRid(const Imap::Folder &folder)
     return folder.parentPath().toUtf8();
 }
 
+static QByteArray getSpecialPurposeType(const QByteArrayList &flags)
+{
+    if (Imap::flagsContain(Imap::FolderFlags::Trash, flags)) {
+        return ApplicationDomain::SpecialPurpose::Mail::trash;
+    }
+    if (Imap::flagsContain(Imap::FolderFlags::Drafts, flags)) {
+        return ApplicationDomain::SpecialPurpose::Mail::drafts;
+    }
+    if (Imap::flagsContain(Imap::FolderFlags::Sent, flags)) {
+        return ApplicationDomain::SpecialPurpose::Mail::sent;
+    }
+    return {};
+}
+
+static bool hasSpecialPurposeFlag(const QByteArrayList &flags)
+{
+    return !getSpecialPurposeType(flags).isEmpty();
+}
+
 
 class ImapSynchronizer : public Sink::Synchronizer {
     Q_OBJECT
@@ -100,22 +117,29 @@ public:
     QByteArray createFolder(const Imap::Folder &f)
     {
         const auto parentFolderRid = parentRid(f);
-        SinkTraceCtx(mLogCtx) << "Creating folder: " << f.name() << parentFolderRid;
+        bool isToplevel = parentFolderRid.isEmpty();
+
+        SinkTraceCtx(mLogCtx) << "Creating folder: " << f.name() << parentFolderRid << f.flags;
 
         const auto remoteId = folderRid(f);
         Sink::ApplicationDomain::Folder folder;
         folder.setName(f.name());
         folder.setIcon("folder");
         folder.setEnabled(f.subscribed);
-        QHash<QByteArray, Query::Comparator> mergeCriteria;
-        if (SpecialPurpose::isSpecialPurposeFolderName(f.name()) && parentFolderRid.isEmpty()) {
-            auto type = SpecialPurpose::getSpecialPurposeType(f.name());
-            folder.setSpecialPurpose(QByteArrayList() << type);
-            mergeCriteria.insert(ApplicationDomain::Folder::SpecialPurpose::name, Query::Comparator(type, Query::Comparator::Contains));
+        auto specialPurpose = [&] {
+            if (hasSpecialPurposeFlag(f.flags)) {
+                return getSpecialPurposeType(f.flags);
+            } else if (SpecialPurpose::isSpecialPurposeFolderName(f.name()) && isToplevel) {
+                return SpecialPurpose::getSpecialPurposeType(f.name());
+            }
+            return QByteArray{};
+        }();
+        if (!specialPurpose.isEmpty()) {
+            folder.setSpecialPurpose(QByteArrayList() << specialPurpose);
         }
 
-        if (!parentFolderRid.isEmpty()) {
-            folder.setParent(syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, parentFolderRid));
+        if (!isToplevel) {
+            folder.setParent(syncStore().resolveRemoteId(ApplicationDomain::Folder::name, parentFolderRid));
         }
         createOrModify(ApplicationDomain::getTypeName<ApplicationDomain::Folder>(), remoteId, folder);
         return remoteId;
@@ -160,22 +184,20 @@ public:
         return flags;
     }
 
-    void synchronizeMails(const QByteArray &folderRid, const Message &message)
+    void synchronizeMails(const QByteArray &folderRid, const QByteArray &folderLocalId, const Message &message)
     {
         auto time = QSharedPointer<QTime>::create();
         time->start();
         SinkTraceCtx(mLogCtx) << "Importing new mail." << folderRid;
 
-        const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRid);
-
         const auto remoteId = assembleMailRid(folderLocalId, message.uid);
 
         Q_ASSERT(message.msg);
-        SinkTraceCtx(mLogCtx) << "Found a mail " << remoteId << message.msg->subject(true)->asUnicodeString() << message.flags;
+        SinkTraceCtx(mLogCtx) << "Found a mail " << remoteId << message.flags;
 
         auto mail = Sink::ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
         mail.setFolder(folderLocalId);
-        mail.setMimeMessage(message.msg->encodedContent());
+        mail.setMimeMessage(message.msg->encodedContent(true));
         mail.setExtractedFullPayloadAvailable(message.fullPayload);
         setFlags(mail, message.flags);
 
@@ -291,14 +313,15 @@ public:
                 SinkTraceCtx(mLogCtx) << "Uids to fetch: " << filteredAndSorted;
 
                 bool headersOnly = false;
+                const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRemoteId);
                 return imap->fetchMessages(folder, filteredAndSorted, headersOnly, [=](const Message &m) {
                     if (*maxUid < m.uid) {
                         *maxUid = m.uid;
                     }
-                    synchronizeMails(folderRemoteId, m);
+                    synchronizeMails(folderRemoteId, folderLocalId, m);
                 },
-                [this, maxUid, folder](int progress, int total) {
-                    SinkLog() << "Progress: " << progress << " out of " << total;
+                [=](int progress, int total) {
+                    reportProgress(progress, total, QByteArrayList{} << folderLocalId);
                     //commit every 10 messages
                     if ((progress % 10) == 0) {
                         commit();
@@ -335,11 +358,12 @@ public:
                     SinkLogCtx(mLogCtx) << "Fetching headers for: " << toFetch;
 
                     bool headersOnly = true;
+                    const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRemoteId);
                     return imap->fetchMessages(folder, toFetch, headersOnly, [=](const Message &m) {
-                        synchronizeMails(folderRemoteId, m);
+                        synchronizeMails(folderRemoteId, folderLocalId, m);
                     },
                     [=](int progress, int total) {
-                        SinkLogCtx(mLogCtx) << "Progress: " << progress << " out of " << total;
+                        reportProgress(progress, total, QByteArrayList{} << folderLocalId);
                         //commit every 100 messages
                         if ((progress % 100) == 0) {
                             commit();
@@ -466,7 +490,7 @@ public:
             //Otherwise fetch full payload for daterange
             auto folderList = QSharedPointer<QVector<Folder>>::create();
             return  imap->fetchFolders([folderList](const Folder &folder) {
-                if (!folder.noselect) {
+                if (!folder.noselect && folder.subscribed) {
                     *folderList << folder;
                 }
             })
@@ -480,12 +504,16 @@ public:
     KAsync::Error getError(const KAsync::Error &error)
     {
         if (error) {
-            if (error.errorCode == Imap::CouldNotConnectError) {
-                return {ApplicationDomain::ConnectionError, error.errorMessage};
-            } else if (error.errorCode == Imap::SslHandshakeError) {
-                return {ApplicationDomain::LoginError, error.errorMessage};
+            switch(error.errorCode) {
+                case Imap::CouldNotConnectError:
+                    return {ApplicationDomain::ConnectionError, error.errorMessage};
+                case Imap::SslHandshakeError:
+                    return {ApplicationDomain::LoginError, error.errorMessage};
+                case Imap::HostNotFoundError:
+                    return {ApplicationDomain::NoServerError, error.errorMessage};
+                default:
+                    return {ApplicationDomain::UnknownError, error.errorMessage};
             }
-            return {ApplicationDomain::UnknownError, error.errorMessage};
         }
         return {};
     }
@@ -539,11 +567,12 @@ public:
                     }
                     SinkLog() << "Fetching messages: " << toFetch << folderRemoteId;
                     bool headersOnly = false;
+                    const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRemoteId);
                     return imap->fetchMessages(Folder{folderRemoteId}, toFetch, headersOnly, [=](const Message &m) {
-                        synchronizeMails(folderRemoteId, m);
+                        synchronizeMails(folderRemoteId, folderLocalId, m);
                     },
                     [=](int progress, int total) {
-                        reportProgress(progress, total);
+                        reportProgress(progress, total, QByteArrayList{} << folderLocalId);
                         //commit every 100 messages
                         if ((progress % 100) == 0) {
                             commit();
@@ -554,10 +583,7 @@ public:
                     bool syncHeaders = query.hasFilter<ApplicationDomain::Mail::Folder>();
                     //FIXME If we were able to to flush in between we could just query the local store for the folder list.
                     return getFolderList(imap, query)
-                    .then([=] (const QVector<Folder> &folders) {
-                        //Synchronize folders
-                        return KAsync::value(folders)
-                        .serialEach<void>([=](const Folder &folder) {
+                        .serialEach([=](const Folder &folder) {
                             SinkLog() << "Syncing folder " << folder.path();
                             //Emit notification that the folder is being synced.
                             //The synchronizer can't do that because it has no concept of the folder filter on a mail sync scope meaning that the folder is being synchronized.
@@ -572,7 +598,6 @@ public:
                                     SinkWarning() << "Failed to sync folder: " << folder.path() << "Error: " << error.errorMessage;
                                 });
                         });
-                    });
                 }
             })
             .then([=] (const KAsync::Error &error) {
@@ -582,6 +607,15 @@ public:
         }
         return KAsync::error<void>("Nothing to do");
     }
+    static QByteArray ensureCRLF(const QByteArray &data) {
+        auto index = data.indexOf('\n');
+        if (index > 0 && data.at(index - 1) == '\r') { //First line is LF-only terminated
+            //Convert back and forth in case there's a mix. We don't want to expand CRLF into CRCRLF.
+            return KMime::LFtoCRLF(KMime::CRLFtoLF(data));
+        } else {
+            return data;
+        }
+    }
 
     KAsync::Job<QByteArray> replay(const ApplicationDomain::Mail &mail, Sink::Operation operation, const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
     {
@@ -589,10 +623,10 @@ public:
         auto login = imap->login(mUser, mPassword);
         KAsync::Job<QByteArray> job = KAsync::null<QByteArray>();
         if (operation == Sink::Operation_Creation) {
-            QString mailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, mail.getFolder());
-            QByteArray content = KMime::LFtoCRLF(mail.getMimeMessage());
-            auto flags = getFlags(mail);
-            QDateTime internalDate = mail.getDate();
+            const QString mailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, mail.getFolder());
+            const auto content = ensureCRLF(mail.getMimeMessage());
+            const auto flags = getFlags(mail);
+            const QDateTime internalDate = mail.getDate();
             job = login.then(imap->append(mailbox, content, flags, internalDate))
                 .addToContext(imap)
                 .then([mail](qint64 uid) {
@@ -623,11 +657,11 @@ public:
             const bool messageMoved = changedProperties.contains(ApplicationDomain::Mail::Folder::name);
             const bool messageChanged = changedProperties.contains(ApplicationDomain::Mail::MimeMessage::name);
             if (messageChanged || messageMoved) {
-                SinkTrace() << "Replacing message.";
                 const auto folderId = folderIdFromMailRid(oldRemoteId);
                 const QString oldMailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, folderId);
-                QByteArray content = KMime::LFtoCRLF(mail.getMimeMessage());
-                QDateTime internalDate = mail.getDate();
+                const auto content = ensureCRLF(mail.getMimeMessage());
+                const QDateTime internalDate = mail.getDate();
+                SinkTrace() << "Replacing message. Old mailbox: " << oldMailbox << "New mailbox: " << mailbox << "Flags: " << flags << "Content: " << content;
                 KIMAP2::ImapSet set;
                 set.add(uid);
                 job = login.then(imap->append(mailbox, content, flags, internalDate))
@@ -655,7 +689,7 @@ public:
                 if (error) {
                     SinkWarning() << "Error during changereplay: " << error.errorMessage;
                     return imap->logout()
-                        .then(KAsync::error<QByteArray>(error));
+                        .then(KAsync::error<QByteArray>(getError(error)));
                 }
                 return imap->logout()
                     .then(KAsync::value(remoteId));
@@ -664,6 +698,12 @@ public:
 
     KAsync::Job<QByteArray> replay(const ApplicationDomain::Folder &folder, Sink::Operation operation, const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
     {
+        if (operation != Sink::Operation_Creation) {
+            if(oldRemoteId.isEmpty()) {
+                Q_ASSERT(false);
+                return KAsync::error<QByteArray>("Tried to replay modification without old remoteId.");
+            }
+        }
         auto imap = QSharedPointer<ImapServerProxy>::create(mServer, mPort, &mSessionCache);
         auto login = imap->login(mUser, mPassword);
         if (operation == Sink::Operation_Creation) {
@@ -793,6 +833,10 @@ protected:
                 .then(imap->select(folderRemoteId))
                 .then([](Imap::SelectResult){})
                 .then(imap->fetch(set, scope, [imap, messageByUid](const Imap::Message &message) {
+                    //We avoid parsing normally, so we have to do it explicitly here
+                    if (message.msg) {
+                        message.msg->parse();
+                    }
                     messageByUid->insert(message.uid, message);
                 }));
 
diff --git a/examples/imapresource/imapserverproxy.cpp b/examples/imapresource/imapserverproxy.cpp
index 0cc43b8..538105c 100644
--- a/examples/imapresource/imapserverproxy.cpp
+++ b/examples/imapresource/imapserverproxy.cpp
@@ -37,8 +37,6 @@
 #include "log.h"
 #include "test.h"
 
-SINK_DEBUG_AREA("imapserverproxy")
-
 using namespace Imap;
 
 const char* Imap::Flags::Seen = "\\Seen";
@@ -57,6 +55,7 @@ const char* Imap::FolderFlags::Trash = "\\Trash";
 const char* Imap::FolderFlags::Archive = "\\Archive";
 const char* Imap::FolderFlags::Junk = "\\Junk";
 const char* Imap::FolderFlags::Flagged = "\\Flagged";
+const char* Imap::FolderFlags::Drafts = "\\Drafts";
 
 const char* Imap::Capabilities::Namespace = "NAMESPACE";
 const char* Imap::Capabilities::Uidplus = "UIDPLUS";
@@ -98,17 +97,25 @@ static KAsync::Job<void> runJob(KJob *job)
     });
 }
 
-ImapServerProxy::ImapServerProxy(const QString &serverUrl, int port, SessionCache *sessionCache) : mSession(new KIMAP2::Session(serverUrl, qint16(port))), mSessionCache(sessionCache)
+KIMAP2::Session *createNewSession(const QString &serverUrl, int port)
 {
-    QObject::connect(mSession, &KIMAP2::Session::sslErrors, [this](const QList<QSslError> &errors) {
+    auto newSession = new KIMAP2::Session(serverUrl, qint16(port));
+    if (Sink::Test::testModeEnabled()) {
+        newSession->setTimeout(1);
+    } else {
+        newSession->setTimeout(40);
+    }
+    QObject::connect(newSession, &KIMAP2::Session::sslErrors, [=](const QList<QSslError> &errors) {
         SinkLog() << "Received ssl error: " << errors;
-        mSession->ignoreErrors(errors);
+        newSession->ignoreErrors(errors);
     });
+    return newSession;
+}
 
-    if (Sink::Test::testModeEnabled()) {
-        mSession->setTimeout(1);
-    } else {
-        mSession->setTimeout(40);
+ImapServerProxy::ImapServerProxy(const QString &serverUrl, int port, SessionCache *sessionCache) : mSessionCache(sessionCache), mSession(nullptr)
+{
+    if (!mSessionCache || mSessionCache->isEmpty()) {
+        mSession = createNewSession(serverUrl, port);
     }
 }
 
@@ -161,12 +168,16 @@ KAsync::Job<void> ImapServerProxy::login(const QString &username, const QString
         // SinkTrace() << "Found user namespaces: " << mNamespaces.user;
     }).then([=] (const KAsync::Error &error) {
         if (error) {
-            if (error.errorCode == KIMAP2::LoginJob::ErrorCode::ERR_COULD_NOT_CONNECT) {
+            switch (error.errorCode) {
+            case KIMAP2::LoginJob::ErrorCode::ERR_HOST_NOT_FOUND:
+                return KAsync::error(HostNotFoundError, "Host not found: " + error.errorMessage);
+            case KIMAP2::LoginJob::ErrorCode::ERR_COULD_NOT_CONNECT:
                 return KAsync::error(CouldNotConnectError, "Failed to connect: " + error.errorMessage);
-            } else if (error.errorCode == KIMAP2::LoginJob::ErrorCode::ERR_SSL_HANDSHAKE_FAILED) {
+            case KIMAP2::LoginJob::ErrorCode::ERR_SSL_HANDSHAKE_FAILED:
                 return KAsync::error(SslHandshakeError, "Ssl handshake failed: " + error.errorMessage);
+            default:
+                return KAsync::error(error);
             }
-            return KAsync::error(error);
         }
         return KAsync::null();
     });
@@ -188,6 +199,12 @@ KAsync::Job<void> ImapServerProxy::logout()
     }
 }
 
+bool ImapServerProxy::isGmail() const
+{
+    //Magic capability that only gmail has
+    return mCapabilities.contains("X-GM-EXT-1");
+}
+
 KAsync::Job<SelectResult> ImapServerProxy::select(const QString &mailbox)
 {
     auto select = new KIMAP2::SelectJob(mSession);
@@ -297,6 +314,7 @@ KAsync::Job<void> ImapServerProxy::fetch(const KIMAP2::ImapSet &set, KIMAP2::Fet
     fetch->setSequenceSet(set);
     fetch->setUidBased(true);
     fetch->setScope(scope);
+    fetch->setAvoidParsing(true);
     QObject::connect(fetch, &KIMAP2::FetchJob::resultReceived, callback);
     return runJob(fetch);
 }
@@ -437,18 +455,60 @@ QString ImapServerProxy::getNamespace(const QString &name)
     return ns.name;
 }
 
+static bool caseInsensitiveContains(const QByteArray &f, const QByteArrayList &list) {
+    return list.contains(f) || list.contains(f.toLower());
+}
+
+bool Imap::flagsContain(const QByteArray &f, const QByteArrayList &flags)
+{
+    return caseInsensitiveContains(f, flags);
+}
+
+static void reportFolder(const Folder &f, QSharedPointer<QSet<QString>> reportedList, std::function<void(const Folder &)> callback) {
+    if (!reportedList->contains(f.path())) {
+        reportedList->insert(f.path());
+        auto c = f;
+        c.noselect = true;
+        callback(c);
+        if (!f.parentPath().isEmpty()){
+            reportFolder(f.parentFolder(), reportedList, callback);
+        }
+    }
+}
+
 KAsync::Job<void> ImapServerProxy::fetchFolders(std::function<void(const Folder &)> callback)
 {
     SinkTrace() << "Fetching folders";
     auto subscribedList = QSharedPointer<QSet<QString>>::create() ;
+    auto reportedList = QSharedPointer<QSet<QString>>::create() ;
     return list(KIMAP2::ListJob::NoOption, [=](const KIMAP2::MailBoxDescriptor &mailbox, const QList<QByteArray> &){
         *subscribedList << mailbox.name;
     }).then(list(KIMAP2::ListJob::IncludeUnsubscribed, [=](const KIMAP2::MailBoxDescriptor &mailbox, const QList<QByteArray> &flags) {
-        bool noselect = flags.contains(QByteArray(FolderFlags::Noselect).toLower()) || flags.contains(QByteArray(FolderFlags::Noselect));
+        bool noselect = caseInsensitiveContains(FolderFlags::Noselect, flags);
         bool subscribed = subscribedList->contains(mailbox.name);
+        if (isGmail()) {
+            bool inbox = mailbox.name.toLower() == "inbox";
+            bool sent = caseInsensitiveContains(FolderFlags::Sent, flags);
+            bool drafts = caseInsensitiveContains(FolderFlags::Drafts, flags);
+            bool trash = caseInsensitiveContains(FolderFlags::Trash, flags);
+            /**
+             * Because gmail duplicates messages all over the place we only support a few selected folders for now that should be mostly exclusive.
+             */
+            if (!(inbox || sent || drafts || trash)) {
+                return;
+            }
+        }
         SinkLog() << "Found mailbox: " << mailbox.name << flags << FolderFlags::Noselect << noselect  << " sub: " << subscribed;
         auto ns = getNamespace(mailbox.name);
-        callback(Folder{mailbox.name, ns, mailbox.separator, noselect, subscribed, flags});
+        auto folder = Folder{mailbox.name, ns, mailbox.separator, noselect, subscribed, flags};
+
+        //call callback for parents if that didn't already happen.
+        //This is necessary because we can have missing bits in the hierarchy in IMAP, but this will not work in sink because we'd end up with an incomplete tree.
+        if (!folder.parentPath().isEmpty() && !reportedList->contains(folder.parentPath())) {
+            reportFolder(folder.parentFolder(), reportedList, callback);
+        }
+        reportedList->insert(folder.path());
+        callback(folder);
     }));
 }
 
diff --git a/examples/imapresource/imapserverproxy.h b/examples/imapresource/imapserverproxy.h
index 872f032..82f4f58 100644
--- a/examples/imapresource/imapserverproxy.h
+++ b/examples/imapresource/imapserverproxy.h
@@ -31,6 +31,7 @@ namespace Imap {
 
 enum ErrorCode {
     NoError,
+    HostNotFoundError,
     CouldNotConnectError,
     SslHandshakeError
 };
@@ -60,6 +61,7 @@ namespace FolderFlags
     extern const char* Junk;
     extern const char* Flagged;
     extern const char* All;
+    extern const char* Drafts;
 }
 
 namespace Capabilities
@@ -78,6 +80,8 @@ struct Message {
     bool fullPayload;
 };
 
+bool flagsContain(const QByteArray &f, const QByteArrayList &flags);
+
 struct Folder {
     Folder() = default;
     Folder(const QString &path, const QString &ns, const QChar &separator, bool noselect_, bool subscribed_, const QByteArrayList &flags_)
@@ -114,6 +118,15 @@ struct Folder {
         return parentPath;
     }
 
+    Folder parentFolder() const
+    {
+        Folder parent;
+        parent.mPath = parentPath();
+        parent.mNamespace = mNamespace;
+        parent.mSeparator = mSeparator;
+        return parent;
+    }
+
     QString name() const
     {
         auto pathParts = mPath.split(mSeparator);
@@ -218,18 +231,18 @@ public:
                 return session;
             }
         }
-        return CachedSession{};
+        return {};
+    }
+
+    bool isEmpty() const
+    {
+        return mSessions.isEmpty();
     }
 private:
     QList<CachedSession> mSessions;
 };
 
 class ImapServerProxy {
-    KIMAP2::Session *mSession;
-    QStringList mCapabilities;
-    Namespaces mNamespaces;
-
-
 public:
     ImapServerProxy(const QString &serverUrl, int port, SessionCache *sessionCache = nullptr);
 
@@ -279,9 +292,14 @@ public:
     KAsync::Job<QVector<qint64>> fetchUids(const Folder &folder);
 
 private:
+    bool isGmail() const;
+
     QString getNamespace(const QString &name);
     QObject mGuard;
     SessionCache *mSessionCache;
+    KIMAP2::Session *mSession;
+    QStringList mCapabilities;
+    Namespaces mNamespaces;
 };
 
 }
diff --git a/examples/imapresource/tests/imapmailsyncbenchmark.cpp b/examples/imapresource/tests/imapmailsyncbenchmark.cpp
index a53c148..814e325 100644
--- a/examples/imapresource/tests/imapmailsyncbenchmark.cpp
+++ b/examples/imapresource/tests/imapmailsyncbenchmark.cpp
@@ -31,8 +31,6 @@
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
-SINK_DEBUG_AREA("ImapMailSyncBenchmark")
-
 /**
  * Test of complete system using the imap resource.
  *
diff --git a/examples/imapresource/tests/imapserverproxytest.cpp b/examples/imapresource/tests/imapserverproxytest.cpp
index 476066d..271b3d9 100644
--- a/examples/imapresource/tests/imapserverproxytest.cpp
+++ b/examples/imapresource/tests/imapserverproxytest.cpp
@@ -12,8 +12,6 @@
 
 using namespace Imap;
 
-// SINK_DEBUG_AREA("imapserverproxytest")
-
 /**
  */
 class ImapServerProxyTest : public QObject
diff --git a/examples/imapresource/tests/populatemailbox.sh b/examples/imapresource/tests/populatemailbox.sh
index a435df7..800e2e7 100644
--- a/examples/imapresource/tests/populatemailbox.sh
+++ b/examples/imapresource/tests/populatemailbox.sh
@@ -1,12 +1,23 @@
 #!/bin/bash
 
 sudo echo "sam user.doe.* cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
+#Delete all mailboxes
 sudo echo "dm user.doe.*" | cyradm --auth PLAIN -u cyrus -w admin localhost
+#Create mailboxes
 sudo echo "cm user.doe.test" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "cm user.doe.Drafts" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "cm user.doe.Trash" | cyradm --auth PLAIN -u cyrus -w admin localhost
+
+#Set acls so we can create in INBOX
 sudo echo "sam user.doe cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
 
+#Subscribe to mailboxes
+sudo echo "sub INBOX" | cyradm --auth PLAIN -u doe -w doe localhost
+sudo echo "sub INBOX.test" | cyradm --auth PLAIN -u doe -w doe localhost
+sudo echo "sub INBOX.Drafts" | cyradm --auth PLAIN -u doe -w doe localhost
+sudo echo "sub INBOX.Trash" | cyradm --auth PLAIN -u doe -w doe localhost
+
+#Create a bunch of test messages in the test folder
 # for i in `seq 1 5000`;
 # do
 #     # sudo cp /work/source/Sink/examples/imapresource/tests/data/1365777830.R28.localhost.localdomain\:2\,S /var/spool/imap/d/user/doe/test/$i.
diff --git a/examples/imapresource/tests/resetmailbox.sh b/examples/imapresource/tests/resetmailbox.sh
index 6ed198e..63d3478 100644
--- a/examples/imapresource/tests/resetmailbox.sh
+++ b/examples/imapresource/tests/resetmailbox.sh
@@ -3,8 +3,11 @@
 sudo echo "sam user.doe.* cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "dm user.doe.*" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "cm user.doe.test" | cyradm --auth PLAIN -u cyrus -w admin localhost
+sudo echo "subscribe INBOX.test" | cyradm --auth PLAIN -u doe -w doe localhost
 sudo echo "cm user.doe.Drafts" | cyradm --auth PLAIN -u cyrus -w admin localhost
+sudo echo "subscribe INBOX.Drafts" | cyradm --auth PLAIN -u doe -w doe localhost
 sudo echo "cm user.doe.Trash" | cyradm --auth PLAIN -u cyrus -w admin localhost
+sudo echo "subscribe INBOX.Trash" | cyradm --auth PLAIN -u doe -w doe localhost
 sudo echo "sam user.doe cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo cp /work/source/Sink/examples/imapresource/tests/data/1365777830.R28.localhost.localdomain\:2\,S /var/spool/imap/d/user/doe/test/1.
 sudo chown cyrus:mail /var/spool/imap/d/user/doe/test/1.
diff --git a/examples/maildirresource/maildirresource.cpp b/examples/maildirresource/maildirresource.cpp
index 40bab37..b406f63 100644
--- a/examples/maildirresource/maildirresource.cpp
+++ b/examples/maildirresource/maildirresource.cpp
@@ -43,8 +43,6 @@
 #define ENTITY_TYPE_MAIL "mail"
 #define ENTITY_TYPE_FOLDER "folder"
 
-SINK_DEBUG_AREA("maildirresource")
-
 using namespace Sink;
 
 static QString getFilePathFromMimeMessagePath(const QString &mimeMessagePath)
@@ -555,18 +553,20 @@ MaildirResource::MaildirResource(const Sink::ResourceContext &resourceContext)
     setupPreprocessors(ENTITY_TYPE_FOLDER, QVector<Sink::Preprocessor*>() << new FolderPreprocessor(mMaildirPath));
 
     KPIM::Maildir dir(mMaildirPath, true);
-    SinkTrace() << "Started maildir resource for maildir: " << mMaildirPath;
-    {
-        auto draftsFolder = dir.addSubFolder("Drafts");
-        auto remoteId = synchronizer->createFolder(draftsFolder, "folder", QByteArrayList() << "drafts");
-        auto draftsFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
-    }
-    {
-        auto trashFolder = dir.addSubFolder("Trash");
-        auto remoteId = synchronizer->createFolder(trashFolder, "folder", QByteArrayList() << "trash");
-        auto trashFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
+    if (dir.isValid(false)) {
+        {
+            auto draftsFolder = dir.addSubFolder("Drafts");
+            auto remoteId = synchronizer->createFolder(draftsFolder, "folder", QByteArrayList() << "drafts");
+            auto draftsFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
+        }
+        {
+            auto trashFolder = dir.addSubFolder("Trash");
+            auto remoteId = synchronizer->createFolder(trashFolder, "folder", QByteArrayList() << "trash");
+            auto trashFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
+        }
+        synchronizer->commit();
     }
-    synchronizer->commit();
+    SinkTrace() << "Started maildir resource for maildir: " << mMaildirPath;
 }
 
 
diff --git a/examples/mailtransportresource/mailtransport.cpp b/examples/mailtransportresource/mailtransport.cpp
index 84c1556..afe0257 100644
--- a/examples/mailtransportresource/mailtransport.cpp
+++ b/examples/mailtransportresource/mailtransport.cpp
@@ -23,8 +23,6 @@
 #include <QDebug>
 #include <common/log.h>
 
-SINK_DEBUG_AREA("mailtransport")
-
 extern "C" {
 
 #include <stdio.h>
diff --git a/examples/mailtransportresource/mailtransportresource.cpp b/examples/mailtransportresource/mailtransportresource.cpp
index c73219f..3d6f8e4 100644
--- a/examples/mailtransportresource/mailtransportresource.cpp
+++ b/examples/mailtransportresource/mailtransportresource.cpp
@@ -39,8 +39,6 @@
 
 #define ENTITY_TYPE_MAIL "mail"
 
-SINK_DEBUG_AREA("mailtransportresource")
-
 using namespace Sink;
 
 class MailtransportPreprocessor : public Sink::Preprocessor
diff --git a/examples/mailtransportresource/tests/mailtransporttest.cpp b/examples/mailtransportresource/tests/mailtransporttest.cpp
index e4cc447..2a831ed 100644
--- a/examples/mailtransportresource/tests/mailtransporttest.cpp
+++ b/examples/mailtransportresource/tests/mailtransporttest.cpp
@@ -64,7 +64,7 @@ private slots:
         message->assemble();
 
         auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
-        mail.setMimeMessage(message->encodedContent());
+        mail.setMimeMessage(message->encodedContent(true));
 
         VERIFYEXEC(Store::create(mail));
         VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
@@ -92,7 +92,7 @@ private slots:
         message->assemble();
 
         auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
-        mail.setMimeMessage(message->encodedContent());
+        mail.setMimeMessage(message->encodedContent(true));
 
         VERIFYEXEC(Store::create(mail));
         VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
diff --git a/hawd_defs/mail_query_threadleader b/hawd_defs/mail_query_threadleader
new file mode 100644
index 0000000..c555997
--- /dev/null
+++ b/hawd_defs/mail_query_threadleader
@@ -0,0 +1,8 @@
+{
+    "name": "Mail Query performance",
+    "description": "Measures performance of mail queries",
+    "columns": [
+        { "name": "rows", "type": "int" },
+        { "name": "queryResultPerMs", "type": "float", "unit": "result/ms" }
+    ]
+}
diff --git a/sinksh/CMakeLists.txt b/sinksh/CMakeLists.txt
index 82839ab..bc487c1 100644
--- a/sinksh/CMakeLists.txt
+++ b/sinksh/CMakeLists.txt
@@ -18,6 +18,7 @@ set(sink_cli_SRCS
     syntax_modules/sink_trace.cpp
     syntax_modules/sink_inspect.cpp
     syntax_modules/sink_drop.cpp
+    syntax_modules/sink_upgrade.cpp
     sinksh_utils.cpp
     repl/repl.cpp
     repl/replStates.cpp
diff --git a/sinksh/state.cpp b/sinksh/state.cpp
index 8f4a675..7e04d28 100644
--- a/sinksh/state.cpp
+++ b/sinksh/state.cpp
@@ -26,8 +26,6 @@
 
 #include "common/log.h"
 
-SINK_DEBUG_AREA("state")
-
 static bool s_hasEventLoop = false;
 
 class State::Private
diff --git a/sinksh/syntax_modules/sink_upgrade.cpp b/sinksh/syntax_modules/sink_upgrade.cpp
new file mode 100644
index 0000000..c399048
--- /dev/null
+++ b/sinksh/syntax_modules/sink_upgrade.cpp
@@ -0,0 +1,47 @@
+/*
+ *   Copyright (C) 2017 Christian Mollekopf <mollekopf@kolabsys.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+
+#include <QDebug>
+#include <QObject> // tr()
+#include <QTimer>
+
+#include "common/store.h"
+
+#include "state.h"
+#include "syntaxtree.h"
+
+namespace SinkUpgrade
+{
+
+bool upgrade(const QStringList &args, State &state)
+{
+    state.print(QObject::tr("Upgrading..."));
+    Sink::Store::upgrade().exec().waitForFinished();
+    state.printLine(QObject::tr("done"));
+    return true;
+}
+
+Syntax::List syntax()
+{
+    return Syntax::List() << Syntax{"upgrade", QObject::tr("Upgrades your storage to the latest version (be careful!)"), &SinkUpgrade::upgrade, Syntax::NotInteractive};
+}
+
+REGISTER_SYNTAX(SinkUpgrade)
+
+}
diff --git a/synchronizer/CMakeLists.txt b/synchronizer/CMakeLists.txt
index ff9ec86..e049d64 100644
--- a/synchronizer/CMakeLists.txt
+++ b/synchronizer/CMakeLists.txt
@@ -8,5 +8,5 @@ set(sinksynchronizer_SRCS
 
 add_executable(${PROJECT_NAME} ${sinksynchronizer_SRCS})
 target_link_libraries(${PROJECT_NAME} sink KAsync ${CMAKE_DL_LIBS})
-qt5_use_modules(${PROJECT_NAME} Network)
+qt5_use_modules(${PROJECT_NAME} Core Network)
 install(TARGETS ${PROJECT_NAME} ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/synchronizer/main.cpp b/synchronizer/main.cpp
index c66a2fb..3c41c67 100644
--- a/synchronizer/main.cpp
+++ b/synchronizer/main.cpp
@@ -39,8 +39,6 @@
 #include "test.h"
 #include "definitions.h"
 
-SINK_DEBUG_AREA("main")
-
 static Listener *listener = nullptr;
 
 //Print a demangled stacktrace
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index c77a736..2b3e7b1 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -16,6 +16,9 @@ add_library(sink_test SHARED testimplementations.cpp getrssusage.cpp mailtest.cp
 qt5_use_modules(sink_test Core Test Concurrent)
 target_link_libraries(sink_test sink libhawd KF5::Mime)
 
+add_executable(dbwriter dbwriter.cpp)
+target_link_libraries(dbwriter sink)
+
 include(SinkTest)
 
 manual_tests (
diff --git a/tests/dbwriter.cpp b/tests/dbwriter.cpp
new file mode 100644
index 0000000..902a607
--- /dev/null
+++ b/tests/dbwriter.cpp
@@ -0,0 +1,45 @@
+#include <QByteArrayList>
+#include <QDebug>
+#include <storage.h>
+
+int main(int argc, char *argv[])
+{
+
+    QByteArrayList arguments;
+    for (int i = 0; i < argc; i++) {
+        arguments << argv[i];
+    }
+    auto testDataPath = arguments.value(1);
+    auto dbName = arguments.value(2);
+    auto count = arguments.value(3).toInt();
+
+    if (Sink::Storage::DataStore(testDataPath, dbName, Sink::Storage::DataStore::ReadOnly).exists()) {
+        Sink::Storage::DataStore(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite).removeFromDisk();
+    }
+
+    qWarning() << "Creating db: " << testDataPath << dbName << count;
+    Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+    auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+    for (int i = 0; i < count; i++) {
+        if (!transaction) {
+            qWarning() << "No valid transaction";
+            return -1;
+        }
+        transaction.openDatabase("a", nullptr, false).write(QByteArray::number(i), "a");
+        transaction.openDatabase("b", nullptr, false).write(QByteArray::number(i), "b");
+        transaction.openDatabase("c", nullptr, false).write(QByteArray::number(i), "c");
+        transaction.openDatabase("p", nullptr, false).write(QByteArray::number(i), "c");
+        transaction.openDatabase("q", nullptr, false).write(QByteArray::number(i), "c");
+        if (i > (count/2)) {
+            for (int d = 0; d < 40; d++) {
+                transaction.openDatabase("db" + QByteArray::number(d), nullptr, false).write(QByteArray::number(i), "a");
+            }
+        }
+        if ((i % 1000) == 0) {
+            transaction.commit();
+            transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+        }
+    }
+    qWarning() << "Creating db done.";
+    return 0;
+}
diff --git a/tests/domainadaptortest.cpp b/tests/domainadaptortest.cpp
index a17152e..2aed0a9 100644
--- a/tests/domainadaptortest.cpp
+++ b/tests/domainadaptortest.cpp
@@ -14,24 +14,22 @@
 #include "metadata_generated.h"
 #include "entity_generated.h"
 
-class TestFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event, Sink::ApplicationDomain::Buffer::Event, Sink::ApplicationDomain::Buffer::EventBuilder>
+class TestFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event>
 {
 public:
-    TestFactory()
-    {
-        mResourceWriteMapper = QSharedPointer<WritePropertyMapper<Sink::ApplicationDomain::Buffer::EventBuilder>>::create();
-        Sink::ApplicationDomain::TypeImplementation<Sink::ApplicationDomain::Event>::configure(*mResourceWriteMapper);
-    }
+    TestFactory() = default;
 };
 
-class TestMailFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail, Sink::ApplicationDomain::Buffer::Mail, Sink::ApplicationDomain::Buffer::MailBuilder>
+class TestMailFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail>
 {
 public:
-    TestMailFactory()
-    {
-        mResourceWriteMapper = QSharedPointer<WritePropertyMapper<Sink::ApplicationDomain::Buffer::MailBuilder>>::create();
-        Sink::ApplicationDomain::TypeImplementation<Sink::ApplicationDomain::Mail>::configure(*mResourceWriteMapper);
-    }
+    TestMailFactory() = default;
+};
+
+class TestContactFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Contact>
+{
+public:
+    TestContactFactory() = default;
 };
 
 /**
@@ -51,7 +49,7 @@ private slots:
 
     void testCreateBufferPart()
     {
-        auto writeMapper = QSharedPointer<WritePropertyMapper<Sink::ApplicationDomain::Buffer::EventBuilder>>::create();
+        auto writeMapper = QSharedPointer<PropertyMapper>::create();
         Sink::ApplicationDomain::TypeImplementation<Sink::ApplicationDomain::Event>::configure(*writeMapper);
 
         Sink::ApplicationDomain::Event event;
@@ -104,7 +102,7 @@ private slots:
 
     void testMail()
     {
-        auto writeMapper = QSharedPointer<WritePropertyMapper<Sink::ApplicationDomain::Buffer::MailBuilder>>::create();
+        auto writeMapper = QSharedPointer<PropertyMapper>::create();
         Sink::ApplicationDomain::TypeImplementation<Sink::ApplicationDomain::Mail>::configure(*writeMapper);
 
         Sink::ApplicationDomain::Mail mail;
@@ -139,6 +137,43 @@ private slots:
         }
 
     }
+
+    void testContact()
+    {
+        auto writeMapper = QSharedPointer<PropertyMapper>::create();
+        Sink::ApplicationDomain::TypeImplementation<Sink::ApplicationDomain::Contact>::configure(*writeMapper);
+
+        auto binaryData = QByteArray::fromRawData("\xEF\xBF\xBD\x00\xEF\xBF", 5);
+
+        Sink::ApplicationDomain::Contact contact;
+        contact.setPhoto(binaryData);
+        QVERIFY(!contact.getPhoto().isEmpty());
+
+        flatbuffers::FlatBufferBuilder metadataFbb;
+        auto metadataBuilder = Sink::MetadataBuilder(metadataFbb);
+        metadataBuilder.add_revision(1);
+        auto metadataBuffer = metadataBuilder.Finish();
+        Sink::FinishMetadataBuffer(metadataFbb, metadataBuffer);
+
+        flatbuffers::FlatBufferBuilder mailFbb;
+        auto pos = createBufferPart<Sink::ApplicationDomain::Buffer::ContactBuilder, Sink::ApplicationDomain::Buffer::Contact>(contact, mailFbb, *writeMapper);
+        Sink::ApplicationDomain::Buffer::FinishContactBuffer(mailFbb, pos);
+
+        flatbuffers::FlatBufferBuilder fbb;
+        Sink::EntityBuffer::assembleEntityBuffer(
+            fbb, metadataFbb.GetBufferPointer(), metadataFbb.GetSize(), mailFbb.GetBufferPointer(), mailFbb.GetSize(), mailFbb.GetBufferPointer(), mailFbb.GetSize());
+
+        {
+            std::string data(reinterpret_cast<const char *>(fbb.GetBufferPointer()), fbb.GetSize());
+            Sink::EntityBuffer buffer((void *)(data.data()), data.size());
+
+            TestContactFactory factory;
+            auto adaptor = factory.createAdaptor(buffer.entity());
+            Sink::ApplicationDomain::Contact readContact{QByteArray{}, QByteArray{}, 0, adaptor};
+            QCOMPARE(readContact.getPhoto(), contact.getPhoto());
+        }
+
+    }
 };
 
 QTEST_MAIN(DomainAdaptorTest)
diff --git a/tests/hawd/state.cpp b/tests/hawd/state.cpp
index dfeef41..a994718 100644
--- a/tests/hawd/state.cpp
+++ b/tests/hawd/state.cpp
@@ -117,7 +117,7 @@ void State::findGitHash()
 {
 #ifdef HAVE_LIBGIT2
     git_libgit2_init();
-    git_buf root = {0};
+    git_buf root = GIT_BUF_INIT_CONST(0, 0);
     int error = git_repository_discover(&root, projectPath().toStdString().data(), 0, NULL);
     if (!error) {
         git_repository *repo = NULL;
diff --git a/tests/interresourcemovetest.cpp b/tests/interresourcemovetest.cpp
index 3ac6ad4..5438bc7 100644
--- a/tests/interresourcemovetest.cpp
+++ b/tests/interresourcemovetest.cpp
@@ -48,7 +48,7 @@ class InterResourceMoveTest : public QObject
         m.subject(true)->fromUnicodeString(subject, "utf8");
         m.messageID(true)->setIdentifier(uid);
         m.assemble();
-        return m.encodedContent();
+        return m.encodedContent(true);
     }
 
 private slots:
diff --git a/tests/mailquerybenchmark.cpp b/tests/mailquerybenchmark.cpp
index b15c8d6..00c156d 100644
--- a/tests/mailquerybenchmark.cpp
+++ b/tests/mailquerybenchmark.cpp
@@ -78,7 +78,7 @@ class MailQueryBenchmark : public QObject
         entityStore.commitTransaction();
     }
 
-    void testLoad(const Sink::Query &query, int count, int expectedSize)
+    void testLoad(const QByteArray &name, const Sink::Query &query, int count, int expectedSize)
     {
         const auto startingRss = getCurrentRSS();
 
@@ -124,7 +124,7 @@ class MailQueryBenchmark : public QObject
         std::cout << "Rss without db [kb]: " << rssWithoutDb / 1024 << std::endl;
         std::cout << "Percentage error: " << percentageRssError << std::endl;
 
-        HAWD::Dataset dataset("mail_query", mHawdState);
+        HAWD::Dataset dataset(QString{"mail_query"} + name, mHawdState);
         HAWD::Dataset::Row row = dataset.row();
         row.setValue("rows", list.size());
         row.setValue("queryResultPerMs", (qreal)list.size() / elapsed);
@@ -159,7 +159,7 @@ private slots:
         query.limit(1000);
 
         populateDatabase(50000);
-        testLoad(query, 50000, query.limit());
+        testLoad({}, query, 50000, query.limit());
     }
 
     void test50kThreadleader()
@@ -176,7 +176,7 @@ private slots:
 
         int count = 50000;
         populateDatabase(count, mailsPerFolder);
-        testLoad(query, count, query.limit());
+        testLoad("_threadleader", query, count, query.limit());
     }
 };
 
diff --git a/tests/mailsynctest.cpp b/tests/mailsynctest.cpp
index c8ba9f1..75454c0 100644
--- a/tests/mailsynctest.cpp
+++ b/tests/mailsynctest.cpp
@@ -33,8 +33,6 @@
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
-SINK_DEBUG_AREA("mailsynctest")
-
 void MailSyncTest::initTestCase()
 {
     Test::initTest();
@@ -226,7 +224,8 @@ void MailSyncTest::testListNewSubFolder()
         for (const auto &folder : folders) {
             names << folder->getName();
         }
-        QVERIFY(names.contains("sub1"));
+        ASYNCVERIFY(names.contains("sub1"));
+        return KAsync::null();
     });
     VERIFYEXEC(job);
 }
@@ -254,7 +253,8 @@ void MailSyncTest::testListRemovedSubFolder()
         for (const auto &folder : folders) {
             names << folder->getName();
         }
-        QVERIFY(!names.contains("sub1"));
+        ASYNCVERIFY(!names.contains("sub1"));
+        return KAsync::null();
     });
     VERIFYEXEC(job);
 }
@@ -270,18 +270,19 @@ void MailSyncTest::testListMails()
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(query).then([](const QList<Mail::Ptr> &mails) {
-        QCOMPARE(mails.size(), 1);
+        ASYNCCOMPARE(mails.size(), 1);
         auto mail = mails.first();
-        QVERIFY(mail->getSubject().startsWith(QString("[Nepomuk] Jenkins build is still unstable")));
+        ASYNCVERIFY(mail->getSubject().startsWith(QString("[Nepomuk] Jenkins build is still unstable")));
         const auto data = mail->getMimeMessage();
-        QVERIFY(!data.isEmpty());
+        ASYNCVERIFY(!data.isEmpty());
 
         KMime::Message m;
-        m.setContent(data);
+        m.setContent(KMime::CRLFtoLF(data));
         m.parse();
-        QCOMPARE(mail->getSubject(), m.subject(true)->asUnicodeString());
-        QVERIFY(!mail->getFolder().isEmpty());
-        QVERIFY(mail->getDate().isValid());
+        ASYNCCOMPARE(mail->getSubject(), m.subject(true)->asUnicodeString());
+        ASYNCVERIFY(!mail->getFolder().isEmpty());
+        ASYNCVERIFY(mail->getDate().isValid());
+        return KAsync::null();
     });
     VERIFYEXEC(job);
 }
@@ -302,10 +303,11 @@ void MailSyncTest::testResyncMails()
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(query).then([](const QList<Mail::Ptr> &mails) {
-        QCOMPARE(mails.size(), 1);
+        ASYNCCOMPARE(mails.size(), 1);
         auto mail = mails.first();
-        QVERIFY(!mail->getSubject().isEmpty());
-        QVERIFY(!mail->getMimeMessagePath().isEmpty());
+        ASYNCVERIFY(!mail->getSubject().isEmpty());
+        ASYNCVERIFY(!mail->getMimeMessagePath().isEmpty());
+        return KAsync::null();
     });
     VERIFYEXEC(job);
 }
@@ -330,7 +332,8 @@ void MailSyncTest::testFetchNewRemovedMessages()
 
     {
         auto job = Store::fetchAll<Mail>(query).then([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 2);
+            ASYNCCOMPARE(mails.size(), 2);
+            return KAsync::null();
         });
         VERIFYEXEC(job);
     }
@@ -342,7 +345,8 @@ void MailSyncTest::testFetchNewRemovedMessages()
 
     {
         auto job = Store::fetchAll<Mail>(query).then([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 1);
+            ASYNCCOMPARE(mails.size(), 1);
+            return KAsync::null();
         });
         VERIFYEXEC(job);
     }
@@ -365,7 +369,8 @@ void MailSyncTest::testFlagChange()
 
     {
         auto job = Store::fetchAll<Mail>(query).then([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 0);
+            ASYNCCOMPARE(mails.size(), 0);
+            return KAsync::null();
         });
         VERIFYEXEC(job);
     }
@@ -378,8 +383,9 @@ void MailSyncTest::testFlagChange()
 
     {
         auto job = Store::fetchAll<Mail>(query).then([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 1);
-            QVERIFY(mails.first()->getImportant());
+            ASYNCCOMPARE(mails.size(), 1);
+            ASYNCVERIFY(mails.first()->getImportant());
+            return KAsync::null();
         });
         VERIFYEXEC(job);
     }
@@ -394,8 +400,9 @@ void MailSyncTest::testSyncSingleFolder()
     Folder::Ptr folder;
     {
         auto job = Store::fetchAll<Folder>(Sink::Query{}.resourceFilter(mResourceInstanceIdentifier).filter<Folder::Name>("test")).template then([&](const QList<Folder::Ptr> &folders) {
-            QCOMPARE(folders.size(), 1);
+            ASYNCCOMPARE(folders.size(), 1);
             folder = folders.first();
+            return KAsync::null();
         });
         VERIFYEXEC(job);
     }
@@ -419,11 +426,13 @@ void MailSyncTest::testSyncSingleMail()
     Mail::Ptr mail;
     {
         auto job = Store::fetchAll<Mail>(Sink::Query{}.resourceFilter(mResourceInstanceIdentifier)).template then([&](const QList<Mail::Ptr> &mails) {
-            QVERIFY(mails.size() >= 1);
+            ASYNCVERIFY(mails.size() >= 1);
             mail = mails.first();
+            return KAsync::null();
         });
         VERIFYEXEC(job);
     }
+    QVERIFY(mail);
 
     auto syncScope = Sink::SyncScope{ApplicationDomain::getTypeName<Mail>()};
     syncScope.resourceFilter(mResourceInstanceIdentifier);
diff --git a/tests/mailtest.cpp b/tests/mailtest.cpp
index c51fc56..cbb56d5 100644
--- a/tests/mailtest.cpp
+++ b/tests/mailtest.cpp
@@ -31,8 +31,6 @@
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
-SINK_DEBUG_AREA("mailtest")
-
 void MailTest::initTestCase()
 {
     Test::initTest();
@@ -154,7 +152,7 @@ void MailTest::testCreateModifyDeleteMail()
     message->assemble();
 
     auto mail = Mail::create(mResourceInstanceIdentifier);
-    mail.setMimeMessage(message->encodedContent());
+    mail.setMimeMessage(message->encodedContent(true));
     mail.setFolder(folder);
 
     VERIFYEXEC(Store::create(mail));
@@ -168,7 +166,7 @@ void MailTest::testCreateModifyDeleteMail()
                 QCOMPARE(mail.getFolder(), folder.identifier());
                 QVERIFY(QFile(mail.getMimeMessagePath()).exists());
                 KMime::Message m;
-                m.setContent(mail.getMimeMessage());
+                m.setContent(KMime::CRLFtoLF(mail.getMimeMessage()));
                 m.parse();
                 QCOMPARE(m.subject(true)->asUnicodeString(), subject);
             });
@@ -184,7 +182,7 @@ void MailTest::testCreateModifyDeleteMail()
     auto message2 = KMime::Message::Ptr::create();
     message2->subject(true)->fromUnicodeString(subject2, "utf8");
     message2->assemble();
-    mail.setMimeMessage(message2->encodedContent());
+    mail.setMimeMessage(message2->encodedContent(true));
 
     VERIFYEXEC(Store::modify(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
@@ -197,7 +195,7 @@ void MailTest::testCreateModifyDeleteMail()
                 QCOMPARE(mail.getFolder(), folder.identifier());
                 QVERIFY(QFile(mail.getMimeMessagePath()).exists());
                 KMime::Message m;
-                m.setContent(mail.getMimeMessage());
+                m.setContent(KMime::CRLFtoLF(mail.getMimeMessage()));
                 m.parse();
                 QCOMPARE(m.subject(true)->asUnicodeString(), subject2);
             });
@@ -239,7 +237,7 @@ void MailTest::testMoveMail()
     message->assemble();
 
     auto mail = Mail::create(mResourceInstanceIdentifier);
-    mail.setMimeMessage(message->encodedContent());
+    mail.setMimeMessage(message->encodedContent(true));
     mail.setFolder(folder);
 
     VERIFYEXEC(Store::create(mail));
@@ -291,7 +289,7 @@ void MailTest::testMarkMailAsRead()
     message->assemble();
 
     auto mail = Mail::create(mResourceInstanceIdentifier);
-    mail.setMimeMessage(message->encodedContent());
+    mail.setMimeMessage(message->encodedContent(true));
     mail.setFolder(folder);
     mail.setUnread(true);
     VERIFYEXEC(Store::create(mail));
@@ -343,7 +341,7 @@ void MailTest::testCreateDraft()
     message->assemble();
 
     auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
-    mail.setMimeMessage(message->encodedContent());
+    mail.setMimeMessage(message->encodedContent(true));
     mail.setDraft(true);
 
     VERIFYEXEC(Store::create(mail));
@@ -393,7 +391,7 @@ void MailTest::testModifyMailToDraft()
     message->assemble();
 
     auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
-    mail.setMimeMessage(message->encodedContent());
+    mail.setMimeMessage(message->encodedContent(true));
     mail.setDraft(false);
     mail.setFolder(folder);
 
@@ -440,7 +438,7 @@ void MailTest::testModifyMailToTrash()
     message->assemble();
 
     auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
-    mail.setMimeMessage(message->encodedContent());
+    mail.setMimeMessage(message->encodedContent(true));
     mail.setTrash(false);
     mail.setFolder(folder);
 
diff --git a/tests/mailthreadtest.cpp b/tests/mailthreadtest.cpp
index 02b29f6..741eb78 100644
--- a/tests/mailthreadtest.cpp
+++ b/tests/mailthreadtest.cpp
@@ -117,7 +117,7 @@ void MailThreadTest::testIndexInMixedOrder()
 
     {
         auto mail = Mail::create(mResourceInstanceIdentifier);
-        mail.setMimeMessage(message3->encodedContent());
+        mail.setMimeMessage(message3->encodedContent(true));
         mail.setFolder(folder);
         VERIFYEXEC(Store::create(mail));
     }
@@ -140,7 +140,7 @@ void MailThreadTest::testIndexInMixedOrder()
 
     {
         auto mail = Mail::create(mResourceInstanceIdentifier);
-        mail.setMimeMessage(message2->encodedContent());
+        mail.setMimeMessage(message2->encodedContent(true));
         mail.setFolder(folder);
         VERIFYEXEC(Store::create(mail));
     }
@@ -156,7 +156,7 @@ void MailThreadTest::testIndexInMixedOrder()
 
     {
         auto mail = Mail::create(mResourceInstanceIdentifier);
-        mail.setMimeMessage(message1->encodedContent());
+        mail.setMimeMessage(message1->encodedContent(true));
         mail.setFolder(folder);
         VERIFYEXEC(Store::create(mail));
     }
diff --git a/tests/messagequeuetest.cpp b/tests/messagequeuetest.cpp
index 83fa23f..2e3bd75 100644
--- a/tests/messagequeuetest.cpp
+++ b/tests/messagequeuetest.cpp
@@ -9,8 +9,6 @@
 #include "log.h"
 #include "test.h"
 
-SINK_DEBUG_AREA("messagequeuetest")
-
 /**
  * Test of the messagequeue implementation.
  */
diff --git a/tests/notificationtest.cpp b/tests/notificationtest.cpp
index a34d325..f0d957e 100644
--- a/tests/notificationtest.cpp
+++ b/tests/notificationtest.cpp
@@ -67,12 +67,21 @@ private slots:
         VERIFYEXEC(Sink::Store::synchronize(query));
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
-        QVERIFY(statusNotifications.size() <= 3);
-        QTRY_COMPARE(statusNotifications.size(), 3);
-        //Sync
-        QCOMPARE(statusNotifications.at(0).code, static_cast<int>(ApplicationDomain::Status::ConnectedStatus));
-        QCOMPARE(statusNotifications.at(1).code, static_cast<int>(ApplicationDomain::Status::BusyStatus));
-        QCOMPARE(statusNotifications.at(2).code, static_cast<int>(ApplicationDomain::Status::ConnectedStatus));
+        using namespace Sink::ApplicationDomain;
+        {
+            QList<Status> expected = {
+                Status::ConnectedStatus,
+                Status::BusyStatus,
+                Status::ConnectedStatus,
+            };
+            qInfo() << "Received notifications " << statusNotifications;
+            QVERIFY2(statusNotifications.size() <= expected.size(), "More notifications than expected.");
+            QTRY_COMPARE(statusNotifications.size(), expected.size());
+            qInfo() << "All received notifications " << statusNotifications;
+            for (auto i = 0; i < statusNotifications.size(); i++) {
+                QCOMPARE(statusNotifications.at(i).code, static_cast<int>(expected.at(i)));
+            }
+        }
         //Changereplay
         // It can happen that we get a changereplay notification pair first and then a second one at the end,
         // we therefore currently filter all changereplay notifications (see above).
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index f639d94..714e549 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -98,10 +98,7 @@ private slots:
     void testSingle()
     {
         // Setup
-        {
-            Mail mail("sink.dummy.instance1");
-            VERIFYEXEC(Sink::Store::create<Mail>(mail));
-        }
+        VERIFYEXEC(Sink::Store::create<Mail>(Mail("sink.dummy.instance1")));
 
         // Test
         Sink::Query query;
@@ -116,10 +113,7 @@ private slots:
     void testSingleWithDelay()
     {
         // Setup
-        {
-            Mail mail("sink.dummy.instance1");
-            Sink::Store::create<Mail>(mail).exec().waitForFinished();
-        }
+        VERIFYEXEC(Sink::Store::create<Mail>(Mail("sink.dummy.instance1")));
 
         // Test
         Sink::Query query;
@@ -142,13 +136,13 @@ private slots:
             Mail mail("sink.dummy.instance1");
             mail.setExtractedMessageId("test1");
             mail.setFolder("folder1");
-            Sink::Store::create<Mail>(mail).exec().waitForFinished();
+            VERIFYEXEC(Sink::Store::create<Mail>(mail));
         }
         {
             Mail mail("sink.dummy.instance1");
             mail.setExtractedMessageId("test2");
             mail.setFolder("folder2");
-            Sink::Store::create<Mail>(mail).exec().waitForFinished();
+            VERIFYEXEC(Sink::Store::create<Mail>(mail));
         }
 
         // Test
@@ -164,13 +158,13 @@ private slots:
         auto mail = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>();
         {
             mail->setFolder("folder2");
-            Sink::Store::modify<Mail>(*mail).exec().waitForFinished();
+            VERIFYEXEC(Sink::Store::modify<Mail>(*mail));
         }
         QTRY_COMPARE(model->rowCount(), 0);
 
         {
             mail->setFolder("folder1");
-            Sink::Store::modify<Mail>(*mail).exec().waitForFinished();
+            VERIFYEXEC(Sink::Store::modify<Mail>(*mail));
         }
         QTRY_COMPARE(model->rowCount(), 1);
     }
@@ -181,8 +175,8 @@ private slots:
         // Setup
         {
             Mail mail("sink.dummy.instance1");
-            Sink::Store::create<Mail>(mail).exec().waitForFinished();
-            Sink::Store::create<Mail>(mail).exec().waitForFinished();
+            VERIFYEXEC(Sink::Store::create<Mail>(mail));
+            VERIFYEXEC(Sink::Store::create<Mail>(mail));
 
             Sink::Query query;
             query.resourceFilter("sink.dummy.instance1");
@@ -211,7 +205,7 @@ private slots:
         // Setup
         {
             Folder folder("sink.dummy.instance1");
-            Sink::Store::create<Folder>(folder).exec().waitForFinished();
+            VERIFYEXEC(Sink::Store::create<Folder>(folder));
         }
 
         // Test
@@ -387,6 +381,7 @@ private slots:
     {
         // Setup
         Folder::Ptr folderEntity;
+        const auto date = QDateTime(QDate(2015, 7, 7), QTime(12, 0));
         {
             Folder folder("sink.dummy.instance1");
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
@@ -404,7 +399,6 @@ private slots:
             folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Folder::Ptr>();
             QVERIFY(!folderEntity->identifier().isEmpty());
 
-            const auto date = QDateTime(QDate(2015, 7, 7), QTime(12, 0));
             {
                 Mail mail("sink.dummy.instance1");
                 mail.setExtractedMessageId("testSecond");
@@ -434,6 +428,11 @@ private slots:
         query.filter<Mail::Folder>(*folderEntity);
         query.sort<Mail::Date>();
         query.limit(1);
+        query.setFlags(Query::LiveQuery);
+        query.reduce<ApplicationDomain::Mail::ThreadId>(Query::Reduce::Selector::max<ApplicationDomain::Mail::Date>())
+            .count("count")
+            .collect<ApplicationDomain::Mail::Unread>("unreadCollected")
+            .collect<ApplicationDomain::Mail::Important>("importantCollected");
 
         // Ensure all local data is processed
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
@@ -449,6 +448,26 @@ private slots:
         QCOMPARE(model->rowCount(), 2);
         // We can't make any assumptions about the order of the indexes
         // QCOMPARE(model->index(1, 0).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>()->getProperty("messageId").toByteArray(), QByteArray("testSecond"));
+
+        //New revisions always go through
+        {
+            Mail mail("sink.dummy.instance1");
+            mail.setExtractedMessageId("testInjected");
+            mail.setFolder(folderEntity->identifier());
+            mail.setExtractedDate(date.addDays(-2));
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
+        }
+        QTRY_COMPARE(model->rowCount(), 3);
+
+        //Ensure we can continue fetching after the incremental update
+        model->fetchMore(QModelIndex());
+        QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
+        QCOMPARE(model->rowCount(), 4);
+
+        //Ensure we have fetched all
+        model->fetchMore(QModelIndex());
+        QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
+        QCOMPARE(model->rowCount(), 4);
     }
 
     void testReactToNewResource()
@@ -503,12 +522,13 @@ private slots:
             Folder folder2(resource2.identifier());
             VERIFYEXEC(Sink::Store::create<Folder>(folder2));
         }
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << resource1.identifier()));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << resource2.identifier()));
 
         // Test
         Sink::Query query;
         query.resourceFilter<SinkResource::Account>(account1);
 
-        // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto folders = Sink::Store::read<Folder>(query);
         QCOMPARE(folders.size(), 1);
     }
@@ -621,18 +641,50 @@ private slots:
         resource2.setResourceType("sink.dummy");
         VERIFYEXEC(Store::create(resource2));
 
-        Folder folder1(resource1.identifier());
-        VERIFYEXEC(Sink::Store::create<Folder>(folder1));
-        Folder folder2(resource2.identifier());
-        VERIFYEXEC(Sink::Store::create<Folder>(folder2));
+        VERIFYEXEC(Sink::Store::create<Folder>(Folder{resource1.identifier()}));
+        VERIFYEXEC(Sink::Store::create<Folder>(Folder{resource2.identifier()}));
 
-        // Test
-        Sink::Query query;
-        query.resourceContainsFilter<SinkResource::Capabilities>("cap1");
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(resource1.identifier()));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(resource2.identifier()));
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
-        auto folders = Sink::Store::read<Folder>(query);
+        auto folders = Sink::Store::read<Folder>(Sink::Query{}.resourceContainsFilter<SinkResource::Capabilities>("cap1"));
         QCOMPARE(folders.size(), 1);
+
+        //TODO this should be part of the regular cleanup between tests
+        VERIFYEXEC(Store::remove(resource1));
+        VERIFYEXEC(Store::remove(resource2));
+    }
+
+    void testFilteredLiveResourceSubQuery()
+    {
+        using namespace Sink;
+        using namespace Sink::ApplicationDomain;
+
+        //Setup
+        auto resource1 = ApplicationDomainType::createEntity<SinkResource>();
+        resource1.setResourceType("sink.dummy");
+        resource1.setCapabilities(QByteArrayList() << "cap1");
+        VERIFYEXEC(Store::create(resource1));
+        VERIFYEXEC(Store::create<Folder>(Folder{resource1.identifier()}));
+        VERIFYEXEC(ResourceControl::flushMessageQueue(resource1.identifier()));
+
+        auto model = Sink::Store::loadModel<Folder>(Query{Query::LiveQuery}.resourceContainsFilter<SinkResource::Capabilities>("cap1"));
+        QTRY_COMPARE(model->rowCount(), 1);
+
+        auto resource2 = ApplicationDomainType::createEntity<SinkResource>();
+        resource2.setCapabilities(QByteArrayList() << "cap2");
+        resource2.setResourceType("sink.dummy");
+        VERIFYEXEC(Store::create(resource2));
+        VERIFYEXEC(Store::create<Folder>(Folder{resource2.identifier()}));
+        VERIFYEXEC(ResourceControl::flushMessageQueue(resource2.identifier()));
+
+        //The new resource should be filtered and thus not make it in here
+        QCOMPARE(model->rowCount(), 1);
+
+        //TODO this should be part of the regular cleanup between tests
+        VERIFYEXEC(Store::remove(resource1));
+        VERIFYEXEC(Store::remove(resource2));
     }
 
     void testLivequeryUnmatchInThread()
@@ -1059,30 +1111,18 @@ private slots:
         QDateTime now{QDate{2017, 2, 3}, QTime{10, 0, 0}};
         QDateTime later{QDate{2017, 2, 3}, QTime{11, 0, 0}};
 
-        {
-            auto mail1 = Mail::createEntity<Mail>("sink.dummy.instance1");
-            mail1.setExtractedMessageId("mail1");
-            mail1.setFolder(folder1);
-            mail1.setExtractedDate(now);
-            mail1.setImportant(false);
-            VERIFYEXEC(Sink::Store::create(mail1));
-        }
-        {
-            auto mail2 = Mail::createEntity<Mail>("sink.dummy.instance1");
-            mail2.setExtractedMessageId("mail2");
-            mail2.setFolder(folder1);
-            mail2.setExtractedDate(earlier);
-            mail2.setImportant(false);
-            VERIFYEXEC(Sink::Store::create(mail2));
-        }
-        {
-            auto mail3 = Mail::createEntity<Mail>("sink.dummy.instance1");
-            mail3.setExtractedMessageId("mail3");
-            mail3.setFolder(folder1);
-            mail3.setExtractedDate(later);
-            mail3.setImportant(true);
-            VERIFYEXEC(Sink::Store::create(mail3));
-        }
+        auto createMail = [] (const QByteArray &messageid, const Folder &folder, const QDateTime &date, bool important) {
+            auto mail = Mail::createEntity<Mail>("sink.dummy.instance1");
+            mail.setExtractedMessageId(messageid);
+            mail.setFolder(folder);
+            mail.setExtractedDate(date);
+            mail.setImportant(important);
+            return mail;
+        };
+
+        VERIFYEXEC(Sink::Store::create(createMail("mail1", folder1, now, false)));
+        VERIFYEXEC(Sink::Store::create(createMail("mail2", folder1, earlier, false)));
+        VERIFYEXEC(Sink::Store::create(createMail("mail3", folder1, later, true)));
 
         // Ensure all local data is processed
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue("sink.dummy.instance1"));
diff --git a/tests/storagetest.cpp b/tests/storagetest.cpp
index 7202628..9e9bad9 100644
--- a/tests/storagetest.cpp
+++ b/tests/storagetest.cpp
@@ -487,6 +487,61 @@ private slots:
         }
     }
 
+    void testCopyTransaction()
+    {
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        {
+            auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+            transaction.openDatabase("a", nullptr, false);
+            transaction.openDatabase("b", nullptr, false);
+            transaction.openDatabase("c", nullptr, false);
+            transaction.commit();
+        }
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadOnly);
+        for (int i = 0; i < 1000; i++) {
+            transaction.openDatabase("a", nullptr, false);
+            transaction.openDatabase("b", nullptr, false);
+            transaction.openDatabase("c", nullptr, false);
+            transaction = store.createTransaction(Sink::Storage::DataStore::ReadOnly);
+        }
+    }
+
+    /*
+     * This test is meant to find problems with the multi-process architecture and initial database creation.
+     * If we create named databases dynamically (not all up front), it is possilbe that we violate the rule
+     * that mdb_open_dbi may only be used by a single thread at a time.
+     * This test is meant to stress that condition.
+     *
+     * However, it yields absolutely nothing.
+     */
+    void testReadDuringExternalProcessWrite()
+    {
+        QSKIP("Not running multiprocess test");
+
+        QList<QFuture<void>> futures;
+        for (int i = 0; i < 5; i++) {
+            futures <<  QtConcurrent::run([&]() {
+                QTRY_VERIFY(Sink::Storage::DataStore(testDataPath, dbName, Sink::Storage::DataStore::ReadOnly).exists());
+                Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadOnly);
+                auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadOnly);
+                for (int i = 0; i < 100000; i++) {
+                    transaction.openDatabase("a", nullptr, false);
+                    transaction.openDatabase("b", nullptr, false);
+                    transaction.openDatabase("c", nullptr, false);
+                    transaction.openDatabase("p", nullptr, false);
+                    transaction.openDatabase("q", nullptr, false);
+                }
+            });
+        }
+
+        //Start writing to the db from a separate process
+        QVERIFY(QProcess::startDetached(QCoreApplication::applicationDirPath() + "/dbwriter", QStringList() << testDataPath << dbName << QString::number(100000)));
+
+        for (auto future : futures) {
+            future.waitForFinished();
+        }
+
+    }
 };
 
 QTEST_MAIN(StorageTest)
diff --git a/tests/testimplementations.h b/tests/testimplementations.h
index a145265..ff9d9b8 100644
--- a/tests/testimplementations.h
+++ b/tests/testimplementations.h
@@ -33,7 +33,7 @@
 #include "mail_generated.h"
 #include "createentity_generated.h"
 
-class TestEventAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event, Sink::ApplicationDomain::Buffer::Event, Sink::ApplicationDomain::Buffer::EventBuilder>
+class TestEventAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event>
 {
 public:
     TestEventAdaptorFactory() : DomainTypeAdaptorFactory()
@@ -43,7 +43,7 @@ public:
     virtual ~TestEventAdaptorFactory(){};
 };
 
-class TestMailAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail, Sink::ApplicationDomain::Buffer::Mail, Sink::ApplicationDomain::Buffer::MailBuilder>
+class TestMailAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail>
 {
 public:
     TestMailAdaptorFactory() : DomainTypeAdaptorFactory()