64 files changed, 1313 insertions, 903 deletions
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index b5275e0..001a412 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -61,10 +61,7 @@ set(command_SRCS
    resultset.cpp
    domain/propertyregistry.cpp
    domain/applicationdomaintype.cpp
-    domain/contact.cpp
+    domain/typeimplementations.cpp
-    domain/event.cpp
-    domain/mail.cpp
-    domain/folder.cpp
    test.cpp
    query.cpp
    changereplay.cpp
@@ -101,6 +98,7 @@ generate_flatbuffers(
    commands/inspection
    commands/flush
    domain/contact
+    domain/addressbook
    domain/event
    domain/mail
    domain/folder
diff --git a/common/bufferadaptor.h b/common/bufferadaptor.h
index 0ae7bf5..fd4809b 100644
--- a/common/bufferadaptor.h
+++ b/common/bufferadaptor.h
@@ -39,12 +39,12 @@ public:
    }
    virtual QVariant getProperty(const QByteArray &key) const
    {
-        qFatal("Tried to get property: " + key);
+        qFatal("Tried to get property: %s", key.data());
        return QVariant();
    }
    virtual void setProperty(const QByteArray &key, const QVariant &value)
    {
-        qFatal("Tried to get property: " + key);
+        qFatal("Tried to get property: %s", key.data());
    }
    virtual QList<QByteArray> availableProperties() const
    {
diff --git a/common/changereplay.cpp b/common/changereplay.cpp
index 532cca8..7895b66 100644
--- a/common/changereplay.cpp
+++ b/common/changereplay.cpp
@@ -29,10 +29,10 @@
 using namespace Sink;
 using namespace Sink::Storage;
-ChangeReplay::ChangeReplay(const ResourceContext &resourceContext)
+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{"changereplay"}
+    : mStorage(storageLocation(), resourceContext.instanceId(), DataStore::ReadOnly), mChangeReplayStore(storageLocation(), resourceContext.instanceId() + ".changereplay", DataStore::ReadWrite), mReplayInProgress(false), mLogCtx{ctx.subContext("changereplay")},
+    mGuard{new QObject}
 {
-    SinkTraceCtx(mLogCtx) << "Created change replay: " << resourceContext.instanceId();
 }
 qint64 ChangeReplay::getLastReplayedRevision()
@@ -54,7 +54,6 @@ bool ChangeReplay::allChangesReplayed()
        SinkWarningCtx(mLogCtx) << error.message;
    }));
    const qint64 lastReplayedRevision = getLastReplayedRevision();
-    SinkTraceCtx(mLogCtx) << "Checking if all replayed. Top revision:" << topRevision << "Last replayed:" << lastReplayedRevision;
    return (lastReplayedRevision >= topRevision);
 }
@@ -99,8 +98,12 @@ 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";
+                        SinkTraceCtx(mLogCtx) << "Done replaying" << *lastReplayedRevision << *topRevision;
                        return KAsync::value(KAsync::Break);
                    }
diff --git a/common/changereplay.h b/common/changereplay.h
index 3ca896e..edc4462 100644
--- a/common/changereplay.h
+++ b/common/changereplay.h
@@ -39,7 +39,7 @@ class SINK_EXPORT ChangeReplay : public QObject
 {
    Q_OBJECT
 public:
-    ChangeReplay(const ResourceContext &resourceContext);
+    ChangeReplay(const ResourceContext &resourceContext, const Sink::Log::Context &ctx= {});
    qint64 getLastReplayedRevision();
    virtual bool allChangesReplayed();
@@ -63,6 +63,7 @@ private:
    bool mReplayInProgress;
    Sink::Storage::DataStore::Transaction mMainStoreTransaction;
    Sink::Log::Context mLogCtx;
+    QSharedPointer<QObject> mGuard;
 };
 class NullChangeReplay : public ChangeReplay
diff --git a/common/commandprocessor.cpp b/common/commandprocessor.cpp
index 33e2f81..3507ef1 100644
--- a/common/commandprocessor.cpp
+++ b/common/commandprocessor.cpp
@@ -245,9 +245,9 @@ KAsync::Job<void> CommandProcessor::processQueue(MessageQueue *queue)
                                }
                            }
                            if (queue->isEmpty()) {
-                                return KAsync::value<KAsync::ControlFlowFlag>(KAsync::Break);
+                                return KAsync::Break;
                            } else {
-                                return KAsync::value<KAsync::ControlFlowFlag>(KAsync::Continue);
+                                return KAsync::Continue;
                            }
                        });
            }))
@@ -295,24 +295,6 @@ void CommandProcessor::setSynchronizer(const QSharedPointer<Synchronizer> &synch
    mSynchronizer->setup([this](int commandId, const QByteArray &data) {
        enqueueCommand(mSynchronizerQueue, commandId, data);
    }, mSynchronizerQueue);
-    QObject::connect(mSynchronizer.data(), &Synchronizer::replayingChanges, [this]() {
-        Sink::Notification n;
-        n.id = "changereplay";
-        n.type = Notification::Status;
-        n.message = "Replaying changes.";
-        n.code = ApplicationDomain::BusyStatus;
-        emit notify(n);
-    });
-    QObject::connect(mSynchronizer.data(), &Synchronizer::changesReplayed, [this]() {
-        Sink::Notification n;
-        n.id = "changereplay";
-        n.type = Notification::Status;
-        n.message = "All changes have been replayed.";
-        n.code = ApplicationDomain::ConnectedStatus;
-        emit notify(n);
-    });
    QObject::connect(mSynchronizer.data(), &Synchronizer::notify, this, &CommandProcessor::notify);
    setOldestUsedRevision(mSynchronizer->getLastReplayedRevision());
 }
diff --git a/common/commands.cpp b/common/commands.cpp
index ce83d03..eeb7f08 100644
--- a/common/commands.cpp
+++ b/common/commands.cpp
@@ -21,6 +21,7 @@
 #include "commands.h"
 #include <QIODevice>
+#include <log.h>
 namespace Sink {
@@ -77,27 +78,34 @@ void write(QIODevice *device, int messageId, int commandId)
    write(device, messageId, commandId, 0, 0);
 }
+static void write(QIODevice *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)
 {
    if (size > 0 && !buffer) {
        size = 0;
    }
-    device->write((const char *)&messageId, sizeof(int));
+    write(device, (const char *)&messageId, sizeof(int));
-    device->write((const char *)&commandId, sizeof(int));
+    write(device, (const char *)&commandId, sizeof(int));
-    device->write((const char *)&size, sizeof(uint));
+    write(device, (const char *)&size, sizeof(uint));
    if (buffer) {
-        device->write(buffer, size);
+        write(device, buffer, size);
    }
 }
 void write(QIODevice *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb)
 {
    const int dataSize = fbb.GetSize();
-    device->write((const char *)&messageId, sizeof(int));
+    write(device, (const char *)&messageId, sizeof(int));
-    device->write((const char *)&commandId, sizeof(int));
+    write(device, (const char *)&commandId, sizeof(int));
-    device->write((const char *)&dataSize, sizeof(int));
+    write(device, (const char *)&dataSize, sizeof(int));
-    device->write((const char *)fbb.GetBufferPointer(), dataSize);
+    write(device, (const char *)fbb.GetBufferPointer(), dataSize);
 }
 } // namespace Commands
diff --git a/common/commands/notification.fbs b/common/commands/notification.fbs
index c82fad3..517111c 100644
--- a/common/commands/notification.fbs
+++ b/common/commands/notification.fbs
@@ -2,9 +2,10 @@ namespace Sink.Commands;
 table Notification {
    type: int = 0; //See notification.h
-    identifier: string; //An identifier that links back to the something related to the notification (e.g. an entity id or a command id)
+    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
+    entities: [string]; //A list of entities this applies to
 }
 root_type Notification;
diff --git a/common/contactpreprocessor.cpp b/common/contactpreprocessor.cpp
index 0f2ca17..ac2c3bc 100644
--- a/common/contactpreprocessor.cpp
+++ b/common/contactpreprocessor.cpp
@@ -28,9 +28,11 @@ void updatedProperties(Sink::ApplicationDomain::Contact &contact, const KContact
 {
    contact.setUid(addressee.uid());
    contact.setFn(addressee.formattedName());
-    QByteArrayList emails;
+    contact.setFirstname(addressee.givenName());
+    contact.setLastname(addressee.familyName());
+    QList<Sink::ApplicationDomain::Contact::Email> emails;
    for (const auto &email : addressee.emails()) {
-        emails << email.toUtf8();
+        emails << Sink::ApplicationDomain::Contact::Email{Sink::ApplicationDomain::Contact::Email::Undefined, email};
    }
    contact.setEmails(emails);
 }
diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 34d2bae..2e0c348 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -144,7 +144,7 @@ public:
            const auto property = entity.getProperty(filterProperty);
            const auto comparator = propertyFilter.value(filterProperty);
            if (!comparator.matches(property)) {
-                SinkTraceCtx(mDatastore->mLogCtx) << "Filtering entity due to property mismatch on filter: " << filterProperty << property << ":" << comparator.value;
+                SinkTraceCtx(mDatastore->mLogCtx) << "Filtering entity due to property mismatch on filter: " << entity.identifier() << "Property: " << filterProperty << property << " Filter:" << comparator.value;
                return false;
            }
        }
@@ -152,7 +152,7 @@ public:
    }
 };
-class Reduce : public FilterBase {
+class Reduce : public Filter {
 public:
    typedef QSharedPointer<Reduce> Ptr;
@@ -198,7 +198,7 @@ public:
    QList<Aggregator> mAggregators;
    Reduce(const QByteArray &reductionProperty, const QByteArray &selectionProperty, QueryBase::Reduce::Selector::Comparator comparator, FilterBase::Ptr source, DataStoreQuery *store)
-        : FilterBase(source, store),
+        : Filter(source, store),
        mReductionProperty(reductionProperty),
        mSelectionProperty(selectionProperty),
        mSelectionComparator(comparator)
@@ -236,6 +236,11 @@ public:
        for (const auto &r : results) {
            readEntity(r, [&, this](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                //We need to apply all property filters that we have until the reduction, because the index lookup was unfiltered.
+                if (!matchesFilter(entity)) {
+                    return;
+                }
                Q_ASSERT(operation != Sink::Operation_Removal);
                for (auto &aggregator : mAggregators) {
                    if (!aggregator.property.isEmpty()) {
@@ -362,19 +367,22 @@ public:
 DataStoreQuery::DataStoreQuery(const Sink::QueryBase &query, const QByteArray &type, EntityStore &store)
    : mType(type), mStore(store), mLogCtx(store.logContext().subContext("datastorequery"))
 {
+    //This is what we use during a new query
    setupQuery(query);
 }
-DataStoreQuery::DataStoreQuery(const DataStoreQuery::State &state, const QByteArray &type, Sink::Storage::EntityStore &store)
+DataStoreQuery::DataStoreQuery(const DataStoreQuery::State &state, const QByteArray &type, Sink::Storage::EntityStore &store, bool incremental)
    : mType(type), mStore(store), mLogCtx(store.logContext().subContext("datastorequery"))
 {
+    //This is what we use when fetching more data, without having a new revision with incremental=false
+    //And this is what we use when the data changed and we want to update with incremental = true
    mCollector = state.mCollector;
    mSource = state.mSource;
    auto source = mCollector;
    while (source) {
        source->mDatastore = this;
-        source->mIncremental = true;
+        source->mIncremental = incremental;
        source = source->mSource;
    }
 }
@@ -553,6 +561,7 @@ void DataStoreQuery::setupQuery(const Sink::QueryBase &query_)
            for (const auto &aggregator : filter->aggregators) {
                reduction->mAggregators << Reduce::Aggregator(aggregator.operation, aggregator.propertyToCollect, aggregator.resultProperty);
            }
+            reduction->propertyFilter = query.getBaseFilters();
            baseSet = reduction;
        } else if (auto filter = stage.dynamicCast<Query::Bloom>()) {
            baseSet = Bloom::Ptr::create(filter->property, baseSet, this);
diff --git a/common/datastorequery.h b/common/datastorequery.h
index a797782..ee5f99e 100644
--- a/common/datastorequery.h
+++ b/common/datastorequery.h
@@ -46,7 +46,7 @@ public:
    };
    DataStoreQuery(const Sink::QueryBase &query, const QByteArray &type, Sink::Storage::EntityStore &store);
-    DataStoreQuery(const DataStoreQuery::State &state, const QByteArray &type, Sink::Storage::EntityStore &store);
+    DataStoreQuery(const DataStoreQuery::State &state, const QByteArray &type, Sink::Storage::EntityStore &store, bool incremental);
    ~DataStoreQuery();
    ResultSet execute();
    ResultSet update(qint64 baseRevision);
diff --git a/common/domain/addressbook.fbs b/common/domain/addressbook.fbs
new file mode 100644
index 0000000..c2bda2b
--- /dev/null
+++ b/common/domain/addressbook.fbs
@@ -0,0 +1,9 @@
+namespace Sink.ApplicationDomain.Buffer;
+table Addressbook {
+  name:string;
+  parent:string;
+}
+root_type Addressbook;
+file_identifier "AKFB";
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index fd88570..44f5a75 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -65,6 +65,9 @@ int registerProperty() {
    return 0;
 }
+#define SINK_REGISTER_ENTITY(ENTITY) \
+    constexpr const char *ENTITY::name;
 #define SINK_REGISTER_PROPERTY(ENTITYTYPE, PROPERTY) \
    constexpr const char *ENTITYTYPE::PROPERTY::name; \
    static int foo##ENTITYTYPE##PROPERTY = registerProperty<ENTITYTYPE, ENTITYTYPE::PROPERTY>();
@@ -72,6 +75,10 @@ int registerProperty() {
 namespace Sink {
 namespace ApplicationDomain {
+constexpr const char *SinkResource::name;
+constexpr const char *SinkAccount::name;
+SINK_REGISTER_ENTITY(Mail);
 SINK_REGISTER_PROPERTY(Mail, Sender);
 SINK_REGISTER_PROPERTY(Mail, To);
 SINK_REGISTER_PROPERTY(Mail, Cc);
@@ -90,11 +97,28 @@ SINK_REGISTER_PROPERTY(Mail, MessageId);
 SINK_REGISTER_PROPERTY(Mail, ParentMessageId);
 SINK_REGISTER_PROPERTY(Mail, ThreadId);
+SINK_REGISTER_ENTITY(Folder);
 SINK_REGISTER_PROPERTY(Folder, Name);
 SINK_REGISTER_PROPERTY(Folder, Icon);
 SINK_REGISTER_PROPERTY(Folder, SpecialPurpose);
 SINK_REGISTER_PROPERTY(Folder, Enabled);
 SINK_REGISTER_PROPERTY(Folder, Parent);
+SINK_REGISTER_PROPERTY(Folder, Count);
+SINK_REGISTER_PROPERTY(Folder, FullContentAvailable);
+SINK_REGISTER_ENTITY(Contact);
+SINK_REGISTER_PROPERTY(Contact, Uid);
+SINK_REGISTER_PROPERTY(Contact, Fn);
+SINK_REGISTER_PROPERTY(Contact, Firstname);
+SINK_REGISTER_PROPERTY(Contact, Lastname);
+SINK_REGISTER_PROPERTY(Contact, Emails);
+SINK_REGISTER_PROPERTY(Contact, Vcard);
+SINK_REGISTER_PROPERTY(Contact, Addressbook);
+SINK_REGISTER_ENTITY(Addressbook);
+SINK_REGISTER_PROPERTY(Addressbook, Name);
+SINK_REGISTER_PROPERTY(Addressbook, Parent);
+SINK_REGISTER_PROPERTY(Addressbook, LastUpdated);
 static const int foo = [] {
    QMetaType::registerEqualsComparator<Reference>();
@@ -115,10 +139,8 @@ void copyBuffer(Sink::ApplicationDomain::BufferAdaptor &buffer, Sink::Applicatio
    for (const auto &property : propertiesToCopy) {
        const auto value = buffer.getProperty(property);
        if (copyBlobs && value.canConvert<BLOB>()) {
-            auto oldPath = value.value<BLOB>().value;
+            const auto oldPath = value.value<BLOB>().value;
-            //FIXME: This is neither pretty nor save if we have multiple modifications of the same property (the first modification will remove the file).
+            const auto newPath = Sink::temporaryFileLocation() + "/" + QUuid::createUuid().toString();
-            //At least if the modification fails the file will be removed once the entity is removed.
-            auto newPath = oldPath + "copy";
            QFile::copy(oldPath, newPath);
            memoryAdaptor.setProperty(property, QVariant::fromValue(BLOB{newPath}));
        } else if (pruneReferences && value.canConvert<Reference>()) {
@@ -364,52 +386,12 @@ SinkResource ImapResource::create(const QByteArray &account)
    return resource;
 }
-template<>
+SinkResource CardDavResource::create(const QByteArray &account)
-QByteArray getTypeName<Contact>()
-{
-    return "contact";
-}
-template<>
-QByteArray getTypeName<Event>()
-{
-    return "event";
-}
-template<>
-QByteArray getTypeName<Todo>()
-{
-    return "todo";
-}
-template<>
-QByteArray getTypeName<SinkResource>()
-{
-    return "resource";
-}
-template<>
-QByteArray getTypeName<SinkAccount>()
-{
-    return "account";
-}
-template<>
-QByteArray getTypeName<Identity>()
-{
-    return "identity";
-}
-template<>
-QByteArray getTypeName<Mail>()
 {
-    return "mail";
+    auto &&resource = ApplicationDomainType::createEntity<SinkResource>();
-}
+    resource.setResourceType("sink.dav");
+    resource.setAccount(account);
-template<>
+    return resource;
-QByteArray getTypeName<Folder>()
-{
-    return "folder";
 }
 QByteArrayList getTypeNames()
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index be04db9..e5aa46e 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -28,7 +28,8 @@
 #include <QUuid>
 #include "bufferadaptor.h"
-#define SINK_ENTITY(TYPE) \
+#define SINK_ENTITY(TYPE, LOWERCASENAME) \
+    static constexpr const char *name = #LOWERCASENAME; \
    typedef QSharedPointer<TYPE> Ptr; \
    using Entity::Entity; \
    TYPE() = default; \
@@ -92,6 +93,43 @@
 namespace Sink {
 namespace ApplicationDomain {
+enum SINK_EXPORT ErrorCode {
+    NoError = 0,
+    UnknownError,
+    NoServerError,
+    ConnectionError,
+    LoginError,
+    ConfigurationError,
+    TransmissionError,
+};
+enum SINK_EXPORT SuccessCode {
+    TransmissionSuccess
+};
+enum SINK_EXPORT SyncStatus {
+    NoSyncStatus,
+    SyncInProgress,
+    SyncError,
+    SyncSuccess
+};
+/**
+ * The status of an account or resource.
+ *
+ * It is set as follows:
+ * * By default the status is offline.
+ * * If a connection to the server could be established the status is Connected.
+ * * If an error occurred that keeps the resource from operating (so non transient), the resource enters the error state.
+ * * If a long running operation is started the resource goes to the busy state (and return to the previous state after that).
+ */
+enum SINK_EXPORT Status {
+    OfflineStatus,
+    ConnectedStatus,
+    BusyStatus,
+    ErrorStatus
+};
 struct SINK_EXPORT Error {
 };
@@ -100,6 +138,11 @@ struct SINK_EXPORT Progress {
 };
+/**
+ * Internal type.
+ *
+ * Represents a BLOB property.
+ */
 struct BLOB {
    BLOB() = default;
    BLOB(const BLOB &) = default;
@@ -268,6 +311,7 @@ SINK_EXPORT QDebug operator<< (QDebug d, const BLOB &blob);
 struct SINK_EXPORT SinkAccount : public ApplicationDomainType {
+    static constexpr const char *name = "account";
    typedef QSharedPointer<SinkAccount> Ptr;
    explicit SinkAccount(const QByteArray &resourceInstanceIdentifier, const QByteArray &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor);
    explicit SinkAccount(const QByteArray &identifier);
@@ -278,8 +322,6 @@ struct SINK_EXPORT SinkAccount : public ApplicationDomainType {
    SINK_PROPERTY(QString, Icon, icon);
    SINK_PROPERTY(QString, AccountType, type);
    SINK_STATUS_PROPERTY(int, Status, status);
-    SINK_STATUS_PROPERTY(ApplicationDomain::Error, Error, error);
-    SINK_STATUS_PROPERTY(ApplicationDomain::Progress, Progress, progress);
 };
@@ -290,6 +332,7 @@ struct SINK_EXPORT SinkAccount : public ApplicationDomainType {
 * and for creating and removing resource instances.
 */
 struct SINK_EXPORT SinkResource : public ApplicationDomainType {
+    static constexpr const char *name = "resource";
    typedef QSharedPointer<SinkResource> Ptr;
    explicit SinkResource(const QByteArray &resourceInstanceIdentifier, const QByteArray &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor);
    explicit SinkResource(const QByteArray &identifier);
@@ -300,8 +343,6 @@ struct SINK_EXPORT SinkResource : public ApplicationDomainType {
    SINK_PROPERTY(QByteArray, ResourceType, type);
    SINK_PROPERTY(QByteArrayList, Capabilities, capabilities);
    SINK_STATUS_PROPERTY(int, Status, status);
-    SINK_STATUS_PROPERTY(ApplicationDomain::Error, Error, error);
-    SINK_STATUS_PROPERTY(ApplicationDomain::Progress, Progress, progress);
 };
 struct SINK_EXPORT Entity : public ApplicationDomainType {
@@ -312,16 +353,35 @@ struct SINK_EXPORT Entity : public ApplicationDomainType {
    virtual ~Entity() = default;
 };
+struct SINK_EXPORT Addressbook : public Entity {
+    SINK_ENTITY(Addressbook, addressbook);
+    SINK_REFERENCE_PROPERTY(Addressbook, Parent, parent);
+    SINK_PROPERTY(QString, Name, name);
+    SINK_EXTRACTED_PROPERTY(QDateTime, LastUpdated, lastUpdated);
+};
 struct SINK_EXPORT Contact : public Entity {
-    SINK_ENTITY(Contact);
+    struct SINK_EXPORT Email {
+        enum Type {
+            Undefined,
+            Work,
+            Home
+        };
+        Type type;
+        QString email;
+    };
+    SINK_ENTITY(Contact, contact);
    SINK_PROPERTY(QString, Uid, uid);
    SINK_PROPERTY(QString, Fn, fn);
-    SINK_PROPERTY(QByteArrayList, Emails, emails);
+    SINK_PROPERTY(QString, Firstname, firstname);
+    SINK_PROPERTY(QString, Lastname, lastname);
+    SINK_PROPERTY(QList<Email>, Emails, emails);
    SINK_PROPERTY(QByteArray, Vcard, vcard);
+    SINK_REFERENCE_PROPERTY(Addressbook, Addressbook, addressbook);
 };
 struct SINK_EXPORT Event : public Entity {
-    SINK_ENTITY(Event);
+    SINK_ENTITY(Event, event);
    SINK_PROPERTY(QString, Uid, uid);
    SINK_PROPERTY(QString, Summary, summary);
    SINK_PROPERTY(QString, Description, description);
@@ -329,20 +389,23 @@ struct SINK_EXPORT Event : public Entity {
 };
 struct SINK_EXPORT Todo : public Entity {
-    SINK_ENTITY(Todo);
+    SINK_ENTITY(Todo, todo);
 };
 struct SINK_EXPORT Calendar : public Entity {
-    SINK_ENTITY(Calendar);
+    SINK_ENTITY(Calendar, calendar);
 };
 struct SINK_EXPORT Folder : public Entity {
-    SINK_ENTITY(Folder);
+    SINK_ENTITY(Folder, folder);
    SINK_REFERENCE_PROPERTY(Folder, Parent, parent);
    SINK_PROPERTY(QString, Name, name);
    SINK_PROPERTY(QByteArray, Icon, icon);
    SINK_PROPERTY(QByteArrayList, SpecialPurpose, specialpurpose);
    SINK_PROPERTY(bool, Enabled, enabled);
+    SINK_EXTRACTED_PROPERTY(QDateTime, LastUpdated, lastUpdated);
+    SINK_EXTRACTED_PROPERTY(int, Count, count);
+    SINK_EXTRACTED_PROPERTY(bool, FullContentAvailable, fullContentAvailable);
 };
 struct SINK_EXPORT Mail : public Entity {
@@ -351,7 +414,7 @@ struct SINK_EXPORT Mail : public Entity {
        QString emailAddress;
    };
-    SINK_ENTITY(Mail);
+    SINK_ENTITY(Mail, mail);
    SINK_EXTRACTED_PROPERTY(Contact, Sender, sender);
    SINK_EXTRACTED_PROPERTY(QList<Contact>, To, to);
    SINK_EXTRACTED_PROPERTY(QList<Contact>, Cc, cc);
@@ -373,23 +436,8 @@ struct SINK_EXPORT Mail : public Entity {
 SINK_EXPORT QDebug operator<< (QDebug d, const Mail::Contact &c);
-/**
- * The status of an account or resource.
- *
- * It is set as follows:
- * * By default the status is offline.
- * * If a connection to the server could be established the status is Connected.
- * * If an error occurred that keeps the resource from operating (so non transient), the resource enters the error state.
- * * If a long running operation is started the resource goes to the busy state (and return to the previous state after that).
- */
-enum SINK_EXPORT Status {
-    OfflineStatus,
-    ConnectedStatus,
-    BusyStatus,
-    ErrorStatus
-};
 struct SINK_EXPORT Identity : public ApplicationDomainType {
+    static constexpr const char *name = "identity";
    typedef QSharedPointer<Identity> Ptr;
    explicit Identity(const QByteArray &resourceInstanceIdentifier, const QByteArray &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor);
    explicit Identity(const QByteArray &identifier);
@@ -416,6 +464,10 @@ struct SINK_EXPORT ImapResource {
    static SinkResource create(const QByteArray &account);
 };
+struct SINK_EXPORT CardDavResource {
+    static SinkResource create(const QByteArray &account);
+};
 namespace ResourceCapabilities {
 namespace Mail {
    static constexpr const char *mail = "mail";
@@ -427,6 +479,11 @@ namespace Mail {
    static constexpr const char *transport = "mail.transport";
    static constexpr const char *folderhierarchy = "mail.folderhierarchy";
 };
+namespace Contact {
+    static constexpr const char *contact = "contact";
+    static constexpr const char *addressbook = "addressbook";
+    static constexpr const char *storage = "contact.storage";
+};
 };
 namespace SpecialPurpose {
@@ -444,31 +501,10 @@ namespace Mail {
 * Do not store these types to disk, they may change over time.
 */
 template<class DomainType>
-QByteArray SINK_EXPORT getTypeName();
+QByteArray SINK_EXPORT getTypeName()
+{
-template<>
+    return DomainType::name;
-QByteArray SINK_EXPORT getTypeName<Contact>();
+}
-template<>
-QByteArray SINK_EXPORT getTypeName<Event>();
-template<>
-QByteArray SINK_EXPORT getTypeName<Todo>();
-template<>
-QByteArray SINK_EXPORT getTypeName<SinkResource>();
-template<>
-QByteArray SINK_EXPORT getTypeName<SinkAccount>();
-template<>
-QByteArray SINK_EXPORT getTypeName<Identity>();
-template<>
-QByteArray SINK_EXPORT getTypeName<Mail>();
-template<>
-QByteArray SINK_EXPORT getTypeName<Folder>();
 QByteArrayList SINK_EXPORT getTypeNames();
@@ -499,6 +535,7 @@ class SINK_EXPORT TypeImplementation;
 */
 #define SINK_REGISTER_TYPES() \
    REGISTER_TYPE(Sink::ApplicationDomain::Contact) \
+    REGISTER_TYPE(Sink::ApplicationDomain::Addressbook) \
    REGISTER_TYPE(Sink::ApplicationDomain::Event) \
    REGISTER_TYPE(Sink::ApplicationDomain::Mail) \
    REGISTER_TYPE(Sink::ApplicationDomain::Folder) \
@@ -520,6 +557,7 @@ Q_DECLARE_METATYPE(Sink::ApplicationDomain::ApplicationDomainType::Ptr)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::Entity)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::Entity::Ptr)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::Mail::Contact)
+Q_DECLARE_METATYPE(Sink::ApplicationDomain::Contact::Email)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::Error)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::Progress)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::BLOB)
diff --git a/common/domain/applicationdomaintype_p.h b/common/domain/applicationdomaintype_p.h
index 4b06864..a5a6b1d 100644
--- a/common/domain/applicationdomaintype_p.h
+++ b/common/domain/applicationdomaintype_p.h
@@ -33,13 +33,15 @@ struct TypeHelper {
    template <typename R, typename ...Args>
    R operator()(Args && ... args) const {
        if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Folder>()) {
-            return Func<Sink::ApplicationDomain::Folder>{}(std::forward<Args...>(args...)); 
+            return Func<Sink::ApplicationDomain::Folder>{}(std::forward<Args...>(args...));
        } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Mail>()) {
-            return Func<Sink::ApplicationDomain::Mail>{}(std::forward<Args...>(args...)); 
+            return Func<Sink::ApplicationDomain::Mail>{}(std::forward<Args...>(args...));
        } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Event>()) {
-            return Func<Sink::ApplicationDomain::Event>{}(std::forward<Args...>(args...)); 
+            return Func<Sink::ApplicationDomain::Event>{}(std::forward<Args...>(args...));
        } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Contact>()) {
            return Func<Sink::ApplicationDomain::Contact>{}(std::forward<Args...>(args...));
+        } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Addressbook>()) {
+            return Func<Sink::ApplicationDomain::Addressbook>{}(std::forward<Args...>(args...));
        } else {
            Q_ASSERT(false);
        }
diff --git a/common/domain/contact.cpp b/common/domain/contact.cpp
deleted file mode 100644
index ea7cac2..0000000
--- a/common/domain/contact.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2017 Sandro Knauß <knauss@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 "contact.h"
-#include <QVector>
-#include <QByteArray>
-#include <QString>
-#include "../propertymapper.h"
-#include "../typeindex.h"
-#include "entity_generated.h"
-#include "contact_generated.h"
-using namespace Sink::ApplicationDomain;
-void TypeImplementation<Contact>::configure(TypeIndex &index)
-{
-    index.addProperty<QByteArray>(Contact::Uid::name);
-}
-void TypeImplementation<Contact>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
-{
-    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);
-}
-void TypeImplementation<Contact>::configure(WritePropertyMapper<BufferBuilder> &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);
-}
-void TypeImplementation<Contact>::configure(IndexPropertyMapper &)
-{
-}
diff --git a/common/domain/contact.fbs b/common/domain/contact.fbs
index 34fb1d6..d941d5a 100644
--- a/common/domain/contact.fbs
+++ b/common/domain/contact.fbs
@@ -1,9 +1,17 @@
 namespace Sink.ApplicationDomain.Buffer;
+table ContactEmail {
+    type: int;
+    email: string;
+}
 table Contact {
  uid:string;
  fn:string;
-  emails: [string];
+  firstname:string;
+  lastname:string;
+  addressbook:string;
+  emails: [ContactEmail];
  vcard: string;
 }
diff --git a/common/domain/contact.h b/common/domain/contact.h
deleted file mode 100644
index c803a9f..0000000
--- a/common/domain/contact.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2017 Sandro Knauß <knauss@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.
- */
-#pragma once
-#include "applicationdomaintype.h"
-class QByteArray;
-template<typename T>
-class ReadPropertyMapper;
-template<typename T>
-class WritePropertyMapper;
-class IndexPropertyMapper;
-class TypeIndex;
-namespace Sink {
-namespace ApplicationDomain {
-    namespace Buffer {
-        struct Contact;
-        struct ContactBuilder;
-    }
-/**
- * Implements all type-specific code such as updating and querying indexes.
- * 
- * These are type specifiy default implementations. Theoretically a resource could implement it's own implementation.
- */
-template<>
-class TypeImplementation<Sink::ApplicationDomain::Contact> {
-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(IndexPropertyMapper &indexPropertyMapper);
-};
-}
-}
diff --git a/common/domain/domaintypes.h b/common/domain/domaintypes.h
deleted file mode 100644
index 0abdee7..0000000
--- a/common/domain/domaintypes.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "contact.h"
-#include "mail.h"
-#include "folder.h"
-#include "event.h"
diff --git a/common/domain/event.cpp b/common/domain/event.cpp
deleted file mode 100644
index 10c92bb..0000000
--- a/common/domain/event.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2014 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 "event.h"
-#include <QVector>
-#include <QByteArray>
-#include <QString>
-#include "../propertymapper.h"
-#include "../typeindex.h"
-#include "entity_generated.h"
-#include "event_generated.h"
-using namespace Sink::ApplicationDomain;
-void TypeImplementation<Event>::configure(TypeIndex &index)
-{
-    index.addProperty<QByteArray>(Event::Uid::name);
-}
-void TypeImplementation<Event>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
-{
-    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);
-}
-void TypeImplementation<Event>::configure(WritePropertyMapper<BufferBuilder> &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);
-}
-void TypeImplementation<Event>::configure(IndexPropertyMapper &)
-{
-}
diff --git a/common/domain/event.h b/common/domain/event.h
deleted file mode 100644
index b683f5f..0000000
--- a/common/domain/event.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2014 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.
- */
-#pragma once
-#include "applicationdomaintype.h"
-class QByteArray;
-template<typename T>
-class ReadPropertyMapper;
-template<typename T>
-class WritePropertyMapper;
-class IndexPropertyMapper;
-class TypeIndex;
-namespace Sink {
-namespace ApplicationDomain {
-    namespace Buffer {
-        struct Event;
-        struct EventBuilder;
-    }
-/**
- * Implements all type-specific code such as updating and querying indexes.
- * 
- * These are type specifiy default implementations. Theoretically a resource could implement it's own implementation.
- */
-template<>
-class TypeImplementation<Sink::ApplicationDomain::Event> {
-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(IndexPropertyMapper &indexPropertyMapper);
-};
-}
-}
diff --git a/common/domain/folder.cpp b/common/domain/folder.cpp
deleted file mode 100644
index 6717661..0000000
--- a/common/domain/folder.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- *   Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastfolder.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 "folder.h"
-#include <QByteArray>
-#include <QString>
-#include "../propertymapper.h"
-#include "../typeindex.h"
-#include "entitybuffer.h"
-#include "entity_generated.h"
-#include "folder_generated.h"
-using namespace Sink::ApplicationDomain;
-void TypeImplementation<Folder>::configure(TypeIndex &index)
-{
-    index.addProperty<QByteArray>(Folder::Parent::name);
-    index.addProperty<QString>(Folder::Name::name);
-}
-void TypeImplementation<Folder>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
-{
-    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);
-}
-void TypeImplementation<Folder>::configure(WritePropertyMapper<BufferBuilder> &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);
-}
-void TypeImplementation<Folder>::configure(IndexPropertyMapper &)
-{
-}
diff --git a/common/domain/folder.h b/common/domain/folder.h
deleted file mode 100644
index f232ab5..0000000
--- a/common/domain/folder.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * 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.
- */
-#pragma once
-#include "applicationdomaintype.h"
-template<typename T>
-class ReadPropertyMapper;
-template<typename T>
-class WritePropertyMapper;
-class IndexPropertyMapper;
-class TypeIndex;
-namespace Sink {
-namespace ApplicationDomain {
-    namespace Buffer {
-        struct Folder;
-        struct FolderBuilder;
-    }
-template<>
-class TypeImplementation<Sink::ApplicationDomain::Folder> {
-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(IndexPropertyMapper &indexPropertyMapper);
-};
-}
-}
diff --git a/common/domain/mail.h b/common/domain/mail.h
deleted file mode 100644
index e052448..0000000
--- a/common/domain/mail.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * 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.
- */
-#pragma once
-#include "applicationdomaintype.h"
-class QByteArray;
-template<typename T>
-class ReadPropertyMapper;
-template<typename T>
-class WritePropertyMapper;
-class IndexPropertyMapper;
-class TypeIndex;
-namespace Sink {
-namespace ApplicationDomain {
-    namespace Buffer {
-        struct Mail;
-        struct MailBuilder;
-    }
-template<>
-class TypeImplementation<Sink::ApplicationDomain::Mail> {
-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(IndexPropertyMapper &indexPropertyMapper);
-};
-}
-}
diff --git a/common/domain/propertyregistry.cpp b/common/domain/propertyregistry.cpp
index 2208193..7b9b61a 100644
--- a/common/domain/propertyregistry.cpp
+++ b/common/domain/propertyregistry.cpp
@@ -64,6 +64,17 @@ QVariant parseString<bool>(const QString &s)
 }
 template <>
+QVariant parseString<int>(const QString &s)
+{
+    bool ok = false;
+    auto n = s.toInt(&ok);
+    if (ok) {
+        return QVariant::fromValue(n);
+    }
+    return {};
+}
+template <>
 QVariant parseString<QList<QByteArray>>(const QString &s)
 {
    auto list = s.split(',');
@@ -92,6 +103,13 @@ QVariant parseString<QList<Sink::ApplicationDomain::Mail::Contact>>(const QStrin
    return QVariant{};
 }
+template <>
+QVariant parseString<QList<Sink::ApplicationDomain::Contact::Email>>(const QString &s)
+{
+    Q_ASSERT(false);
+    return QVariant{};
+}
 PropertyRegistry &PropertyRegistry::instance()
 {
    static PropertyRegistry instance;
diff --git a/common/domain/propertyregistry.h b/common/domain/propertyregistry.h
index 16df23b..758c10d 100644
--- a/common/domain/propertyregistry.h
+++ b/common/domain/propertyregistry.h
@@ -49,6 +49,9 @@ template <>
 QVariant parseString<bool>(const QString &s);
 template <>
+QVariant parseString<int>(const QString &s);
+template <>
 QVariant parseString<QList<QByteArray>>(const QString &s);
 template <>
diff --git a/common/domain/mail.cpp b/common/domain/typeimplementations.cpp
index 8cbe61b..eb3851e 100644
--- a/common/domain/mail.cpp
+++ b/common/domain/typeimplementations.cpp
@@ -16,7 +16,7 @@
 *   Free Software Foundation, Inc.,
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
 */
-#include "mail.h"
+#include "typeimplementations.h"
 #include <QVector>
 #include <QByteArray>
@@ -29,8 +29,6 @@
 #include "mail/threadindexer.h"
 #include "domainadaptor.h"
-#include "mail_generated.h"
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
@@ -102,3 +100,117 @@ void TypeImplementation<Mail>::configure(WritePropertyMapper<BufferBuilder> &pro
    propertyMapper.addMapping<Mail::MessageId>(&BufferBuilder::add_messageId);
    propertyMapper.addMapping<Mail::ParentMessageId>(&BufferBuilder::add_parentMessageId);
 }
+void TypeImplementation<Folder>::configure(TypeIndex &index)
+{
+    index.addProperty<QByteArray>(Folder::Parent::name);
+    index.addProperty<QString>(Folder::Name::name);
+}
+void TypeImplementation<Folder>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+{
+    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);
+}
+void TypeImplementation<Folder>::configure(WritePropertyMapper<BufferBuilder> &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);
+}
+void TypeImplementation<Folder>::configure(IndexPropertyMapper &)
+{
+}
+void TypeImplementation<Contact>::configure(TypeIndex &index)
+{
+    index.addProperty<QByteArray>(Contact::Uid::name);
+}
+void TypeImplementation<Contact>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+{
+    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);
+}
+void TypeImplementation<Contact>::configure(WritePropertyMapper<BufferBuilder> &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);
+}
+void TypeImplementation<Contact>::configure(IndexPropertyMapper &)
+{
+}
+void TypeImplementation<Addressbook>::configure(TypeIndex &index)
+{
+    index.addProperty<QByteArray>(Addressbook::Parent::name);
+    index.addProperty<QString>(Addressbook::Name::name);
+}
+void TypeImplementation<Addressbook>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+{
+    propertyMapper.addMapping<Addressbook::Parent, Buffer>(&Buffer::parent);
+    propertyMapper.addMapping<Addressbook::Name, Buffer>(&Buffer::name);
+}
+void TypeImplementation<Addressbook>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
+{
+    propertyMapper.addMapping<Addressbook::Parent>(&BufferBuilder::add_parent);
+    propertyMapper.addMapping<Addressbook::Name>(&BufferBuilder::add_name);
+}
+void TypeImplementation<Addressbook>::configure(IndexPropertyMapper &)
+{
+}
+void TypeImplementation<Event>::configure(TypeIndex &index)
+{
+    index.addProperty<QByteArray>(Event::Uid::name);
+}
+void TypeImplementation<Event>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+{
+    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);
+}
+void TypeImplementation<Event>::configure(WritePropertyMapper<BufferBuilder> &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);
+}
+void TypeImplementation<Event>::configure(IndexPropertyMapper &)
+{
+}
diff --git a/common/domain/typeimplementations.h b/common/domain/typeimplementations.h
new file mode 100644
index 0000000..37d6ca9
--- /dev/null
+++ b/common/domain/typeimplementations.h
@@ -0,0 +1,101 @@
+/*
+ *   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.
+ */
+#pragma once
+#include "applicationdomaintype.h"
+#include "mail_generated.h"
+#include "folder_generated.h"
+#include "event_generated.h"
+#include "contact_generated.h"
+#include "addressbook_generated.h"
+template<typename T>
+class ReadPropertyMapper;
+template<typename T>
+class WritePropertyMapper;
+class IndexPropertyMapper;
+class TypeIndex;
+/**
+ * Implements all type-specific code such as updating and querying indexes.
+ *
+ * These are type specifiy default implementations. Theoretically a resource could implement it's own implementation.
+ */
+namespace Sink {
+namespace ApplicationDomain {
+template<>
+class TypeImplementation<Sink::ApplicationDomain::Mail> {
+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(IndexPropertyMapper &indexPropertyMapper);
+};
+template<>
+class TypeImplementation<Sink::ApplicationDomain::Folder> {
+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(IndexPropertyMapper &indexPropertyMapper);
+};
+template<>
+class TypeImplementation<Sink::ApplicationDomain::Contact> {
+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(IndexPropertyMapper &indexPropertyMapper);
+};
+template<>
+class TypeImplementation<Sink::ApplicationDomain::Addressbook> {
+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(IndexPropertyMapper &indexPropertyMapper);
+};
+template<>
+class TypeImplementation<Sink::ApplicationDomain::Event> {
+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(IndexPropertyMapper &indexPropertyMapper);
+};
+}
+}
diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index 0377ef4..af5d5fc 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -26,10 +26,7 @@
 #include "domaintypeadaptorfactoryinterface.h"
 #include "domain/applicationdomaintype.h"
-#include "domain/contact.h"
+#include "domain/typeimplementations.h"
-#include "domain/event.h"
-#include "domain/mail.h"
-#include "domain/folder.h"
 #include "bufferadaptor.h"
 #include "entity_generated.h"
 #include "metadata_generated.h"
@@ -245,3 +242,15 @@ protected:
    QSharedPointer<WritePropertyMapper<ResourceBuilder>> mResourceWriteMapper;
    QSharedPointer<IndexPropertyMapper> mIndexMapper;
 };
+/**
+ * A default adaptorfactory implemenation that simply instantiates a generic resource
+ */
+template<typename DomainType>
+class DefaultAdaptorFactory : public DomainTypeAdaptorFactory<DomainType>
+{
+public:
+    DefaultAdaptorFactory() : DomainTypeAdaptorFactory<DomainType>()  {}
+    virtual ~DefaultAdaptorFactory(){}
+};
diff --git a/common/genericresource.cpp b/common/genericresource.cpp
index 5ba9e5d..7178b3d 100644
--- a/common/genericresource.cpp
+++ b/common/genericresource.cpp
@@ -31,8 +31,8 @@ using namespace Sink::Storage;
 GenericResource::GenericResource(const ResourceContext &resourceContext, const QSharedPointer<Pipeline> &pipeline )
    : Sink::Resource(),
      mResourceContext(resourceContext),
-      mPipeline(pipeline ? pipeline : QSharedPointer<Sink::Pipeline>::create(resourceContext, "resource." + resourceContext.instanceId())),
+      mPipeline(pipeline ? pipeline : QSharedPointer<Sink::Pipeline>::create(resourceContext, Log::Context{})),
-      mProcessor(QSharedPointer<CommandProcessor>::create(mPipeline.data(), resourceContext.instanceId(), "resource." + resourceContext.instanceId())),
+      mProcessor(QSharedPointer<CommandProcessor>::create(mPipeline.data(), resourceContext.instanceId(), Log::Context{})),
      mError(0),
      mClientLowerBoundRevision(std::numeric_limits<qint64>::max())
 {
diff --git a/common/index.cpp b/common/index.cpp
index f09e265..725c28b 100644
--- a/common/index.cpp
+++ b/common/index.cpp
@@ -2,31 +2,31 @@
 #include "log.h"
-SINK_DEBUG_AREA("index")
 Index::Index(const QString &storageRoot, const QString &name, Sink::Storage::DataStore::AccessMode mode)
    : mTransaction(Sink::Storage::DataStore(storageRoot, name, mode).createTransaction(mode)),
      mDb(mTransaction.openDatabase(name.toLatin1(), std::function<void(const Sink::Storage::DataStore::Error &)>(), true)),
-      mName(name)
+      mName(name),
+      mLogCtx("index." + name.toLatin1())
 {
 }
 Index::Index(const QByteArray &name, Sink::Storage::DataStore::Transaction &transaction)
-    : mDb(transaction.openDatabase(name, std::function<void(const Sink::Storage::DataStore::Error &)>(), true)), mName(name)
+    : mDb(transaction.openDatabase(name, std::function<void(const Sink::Storage::DataStore::Error &)>(), true)), mName(name),
+      mLogCtx("index." + name)
 {
 }
 void Index::add(const QByteArray &key, const QByteArray &value)
 {
    mDb.write(key, value, [&] (const Sink::Storage::DataStore::Error &error) {
-        SinkWarning() << "Error while writing value" << error;
+        SinkWarningCtx(mLogCtx) << "Error while writing value" << error;
    });
 }
 void Index::remove(const QByteArray &key, const QByteArray &value)
 {
    mDb.remove(key, value, [&] (const Sink::Storage::DataStore::Error &error) {
-        SinkWarning() << "Error while removing value: " << key << value << error << error.store;
+        SinkWarningCtx(mLogCtx) << "Error while removing value: " << key << value << error;
    });
 }
@@ -38,7 +38,7 @@ void Index::lookup(const QByteArray &key, const std::function<void(const QByteAr
            return true;
        },
        [&](const Sink::Storage::DataStore::Error &error) {
-            SinkWarning() << "Error while retrieving value" << error.message;
+            SinkWarningCtx(mLogCtx) << "Error while retrieving value:" << error << mName;
            errorHandler(Error(error.store, error.code, error.message));
        },
        matchSubStringKeys);
@@ -48,6 +48,6 @@ QByteArray Index::lookup(const QByteArray &key)
 {
    QByteArray result;
    //We have to create a deep copy, otherwise the returned data may become invalid when the transaction ends.
-    lookup(key, [&](const QByteArray &value) { result = QByteArray(value.constData(), value.size()); }, [this](const Index::Error &error) { SinkWarning() << "Error while retrieving value" << error.message; });
+    lookup(key, [&](const QByteArray &value) { result = QByteArray(value.constData(), value.size()); }, [this](const Index::Error &) { });
    return result;
 }
diff --git a/common/index.h b/common/index.h
index cfcc7a0..81dc5bf 100644
--- a/common/index.h
+++ b/common/index.h
@@ -44,5 +44,5 @@ private:
    Sink::Storage::DataStore::Transaction mTransaction;
    Sink::Storage::DataStore::NamedDatabase mDb;
    QString mName;
-    SINK_DEBUG_COMPONENT(mName.toLatin1())
+    Sink::Log::Context mLogCtx;
 };
diff --git a/common/listener.cpp b/common/listener.cpp
index f18fe1d..983e438 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -25,6 +25,7 @@
 #include "common/definitions.h"
 #include "common/resourcecontext.h"
 #include "common/adaptorfactoryregistry.h"
+#include "common/bufferutils.h"
 // commands
 #include "common/commandcompletion_generated.h"
@@ -66,7 +67,7 @@ Listener::Listener(const QByteArray &resourceInstanceIdentifier, const QByteArra
    m_checkConnectionsTimer->setInterval(1000);
    connect(m_checkConnectionsTimer.get(), &QTimer::timeout, [this]() {
        if (m_connections.isEmpty()) {
-            SinkLog() << QString("No connections, shutting down.");
+            SinkTrace() << QString("No connections, shutting down.");
            quit();
        }
    });
@@ -87,6 +88,12 @@ Listener::~Listener()
 void Listener::emergencyAbortAllConnections()
 {
+    Sink::Notification n;
+    n.type = Sink::Notification::Status;
+    n.message = "The resource crashed.";
+    n.code = Sink::ApplicationDomain::ErrorStatus;
+    notify(n);
    for (Client &client : m_connections) {
        if (client.socket) {
            SinkWarning() << "Sending panic";
@@ -406,11 +413,13 @@ void Listener::notify(const Sink::Notification &notification)
 {
    auto messageString = m_fbb.CreateString(notification.message.toUtf8().constData(), notification.message.toUtf8().size());
    auto idString = m_fbb.CreateString(notification.id.constData(), notification.id.size());
+    auto entities = Sink::BufferUtils::toVector(m_fbb, notification.entities);
    Sink::Commands::NotificationBuilder builder(m_fbb);
    builder.add_type(notification.type);
    builder.add_code(notification.code);
    builder.add_identifier(idString);
    builder.add_message(messageString);
+    builder.add_entities(entities);
    auto command = builder.Finish();
    Sink::Commands::FinishNotificationBuffer(m_fbb, command);
    for (Client &client : m_connections) {
diff --git a/common/mail/threadindexer.cpp b/common/mail/threadindexer.cpp
index 6f2933c..d91ab5f 100644
--- a/common/mail/threadindexer.cpp
+++ b/common/mail/threadindexer.cpp
@@ -101,9 +101,12 @@ 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:
+        //Try to lookup the thread by subject if not empty
-        thread = index().secondaryLookup<Mail::Subject, Mail::ThreadId>(normalizedSubject);
+        if ( !normalizedSubject.isEmpty()) {
+            thread = index().secondaryLookup<Mail::Subject, Mail::ThreadId>(normalizedSubject);
+        }
        if (thread.isEmpty()) {
            thread << QUuid::createUuid().toByteArray();
            SinkTrace() << "Created a new thread: " << thread;
@@ -121,7 +124,9 @@ 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);
-    index().index<Mail::Subject, Mail::ThreadId>(normalizedSubject, thread.first(), transaction);
+    if (!normalizedSubject.isEmpty()) {
+        index().index<Mail::Subject, Mail::ThreadId>(normalizedSubject, thread.first(), transaction);
+    }
 }
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index f935419..b12216b 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -24,12 +24,20 @@
 #include <QPointer>
 #include "log.h"
+#include "notifier.h"
+#include "notification.h"
+using namespace Sink;
+static uint getInternalIdentifer(const QByteArray &resourceId, const QByteArray &entityId)
+{
+    return qHash(resourceId + entityId);
+}
 static uint qHash(const Sink::ApplicationDomain::ApplicationDomainType &type)
 {
-    // Q_ASSERT(!type.resourceInstanceIdentifier().isEmpty());
    Q_ASSERT(!type.identifier().isEmpty());
-    return qHash(type.resourceInstanceIdentifier() + type.identifier());
+    return getInternalIdentifer(type.resourceInstanceIdentifier(), type.identifier());
 }
 static qint64 getIdentifier(const QModelIndex &idx)
@@ -44,6 +52,86 @@ template <class T, class Ptr>
 ModelResult<T, Ptr>::ModelResult(const Sink::Query &query, const QList<QByteArray> &propertyColumns, const Sink::Log::Context &ctx)
    : QAbstractItemModel(), mLogCtx(ctx.subContext("modelresult")), mPropertyColumns(propertyColumns), mQuery(query)
 {
+    if (query.flags().testFlag(Sink::Query::UpdateStatus)) {
+        Sink::Query resourceQuery;
+        resourceQuery.setFilter(query.getResourceFilter());
+        mNotifier.reset(new Sink::Notifier{resourceQuery});
+        mNotifier->registerHandler([this](const Notification &notification) {
+            switch (notification.type) {
+                case Notification::Status:
+                case Notification::Warning:
+                case Notification::Error:
+                case Notification::Info:
+                case Notification::Progress:
+                    //These are the notifications we care about
+                    break;
+                default:
+                    //We're not interested
+                    return;
+            };
+            if (notification.resource.isEmpty() || notification.entities.isEmpty()) {
+                return;
+            }
+            QVector<qint64> idList;
+            for (const auto &entity : notification.entities) {
+                auto id = getInternalIdentifer(notification.resource, entity);
+                if (mEntities.contains(id)) {
+                    idList << id;
+                }
+            }
+            if (idList.isEmpty()) {
+                //We don't have this entity in our model
+                return;
+            }
+            const int newStatus = [&] {
+                if (notification.type == Notification::Warning || notification.type == Notification::Error) {
+                    return ApplicationDomain::SyncStatus::SyncError;
+                }
+                if (notification.type == Notification::Info) {
+                    switch (notification.code) {
+                        case ApplicationDomain::SyncInProgress:
+                            return ApplicationDomain::SyncInProgress;
+                        case ApplicationDomain::SyncSuccess:
+                            return ApplicationDomain::SyncSuccess;
+                        case ApplicationDomain::SyncError:
+                            return ApplicationDomain::SyncError;
+                        case ApplicationDomain::NoSyncStatus:
+                            break;
+                    }
+                    return ApplicationDomain::NoSyncStatus;
+                }
+                if (notification.type == Notification::Progress) {
+                    return ApplicationDomain::SyncStatus::SyncInProgress;
+                }
+                return ApplicationDomain::NoSyncStatus;
+            }();
+            for (const auto id : idList) {
+                const auto oldStatus = mEntityStatus.value(id);
+                QVector<int> changedRoles;
+                if (oldStatus != newStatus) {
+                    SinkTraceCtx(mLogCtx) << "Status changed for entity:" << newStatus << ", id: " << id;
+                    mEntityStatus.insert(id, newStatus);
+                    changedRoles << StatusRole;
+                }
+                if (notification.type == Notification::Progress) {
+                    changedRoles << ProgressRole;
+                } else if (notification.type == Notification::Warning || notification.type == Notification::Error) {
+                    changedRoles << WarningRole;
+                }
+                if (!changedRoles.isEmpty()) {
+                    const auto idx = createIndexFromId(id);
+                    SinkTraceCtx(mLogCtx) << "Index changed:" << idx << changedRoles;
+                    //We don't emit the changedRoles because the consuming model likely remaps the role anyways and would then need to translate dataChanged signals as well.
+                    emit dataChanged(idx, idx);
+                }
+            }
+        });
+    }
 }
 template <class T, class Ptr>
@@ -60,7 +148,7 @@ qint64 ModelResult<T, Ptr>::parentId(const Ptr &value)
    if (!mQuery.parentProperty().isEmpty()) {
        const auto identifier = value->getProperty(mQuery.parentProperty()).toByteArray();
        if (!identifier.isEmpty()) {
-            return qHash(T(value->resourceInstanceIdentifier(), identifier, 0, QSharedPointer<Sink::ApplicationDomain::BufferAdaptor>()));
+            return getInternalIdentifer(value->resourceInstanceIdentifier(), identifier);
        }
    }
    return 0;
@@ -106,6 +194,13 @@ QVariant ModelResult<T, Ptr>::data(const QModelIndex &index, int role) const
    if (role == ChildrenFetchedRole) {
        return childrenFetched(index);
    }
+    if (role == StatusRole) {
+        auto it = mEntityStatus.constFind(index.internalId());
+        if (it != mEntityStatus.constEnd()) {
+            return *it;
+        }
+        return {};
+    }
    if (role == Qt::DisplayRole && index.isValid()) {
        if (index.column() < mPropertyColumns.size()) {
            Q_ASSERT(mEntities.contains(index.internalId()));
@@ -296,15 +391,15 @@ void ModelResult<T, Ptr>::setEmitter(const typename Sink::ResultEmitter<Ptr>::Pt
    emitter->onInitialResultSetComplete([this, guard](const Ptr &parent, bool fetchedAll) {
        SinkTraceCtx(mLogCtx) << "Initial result set complete. Fetched all: " << fetchedAll;
        Q_ASSERT(guard);
-        threadBoundary.callInMainThread([=]() {
+        Q_ASSERT(QThread::currentThread() == this->thread());
-            const qint64 parentId = parent ? qHash(*parent) : 0;
-            const auto parentIndex = createIndexFromId(parentId);
+        const qint64 parentId = parent ? qHash(*parent) : 0;
-            mEntityChildrenFetchComplete.insert(parentId);
+        const auto parentIndex = createIndexFromId(parentId);
-            if (fetchedAll) {
+        mEntityChildrenFetchComplete.insert(parentId);
-                mEntityAllChildrenFetched.insert(parentId);
+        if (fetchedAll) {
-            }
+            mEntityAllChildrenFetched.insert(parentId);
-            emit dataChanged(parentIndex, parentIndex, QVector<int>() << ChildrenFetchedRole);
+        }
-        });
+        emit dataChanged(parentIndex, parentIndex, QVector<int>() << ChildrenFetchedRole);
    });
    mEmitter = emitter;
 }
diff --git a/common/modelresult.h b/common/modelresult.h
index f30a8e1..cc263cf 100644
--- a/common/modelresult.h
+++ b/common/modelresult.h
@@ -30,15 +30,23 @@
 #include "resultprovider.h"
 #include "threadboundary.h"
+namespace Sink {
+class Notifier;
+}
 template <class T, class Ptr>
 class ModelResult : public QAbstractItemModel
 {
 public:
+    //Update the copy in store.h as well if you modify this
    enum Roles
    {
        DomainObjectRole = Qt::UserRole + 1,
        ChildrenFetchedRole,
-        DomainObjectBaseRole
+        DomainObjectBaseRole,
+        StatusRole, //ApplicationDomain::SyncStatus
+        WarningRole, //ApplicationDomain::Warning, only if status == warning || status == error
+        ProgressRole //ApplicationDomain::Progress
    };
    ModelResult(const Sink::Query &query, const QList<QByteArray> &propertyColumns, const Sink::Log::Context &);
@@ -77,9 +85,11 @@ private:
    QSet<qint64 /* entity id */> mEntityChildrenFetched;
    QSet<qint64 /* entity id */> mEntityChildrenFetchComplete;
    QSet<qint64 /* entity id */> mEntityAllChildrenFetched;
+    QMap<qint64 /* entity id */, int /* Status */> mEntityStatus;
    QList<QByteArray> mPropertyColumns;
    Sink::Query mQuery;
    std::function<void(const Ptr &)> loadEntities;
    typename Sink::ResultEmitter<Ptr>::Ptr mEmitter;
    async::ThreadBoundary threadBoundary;
+    QScopedPointer<Sink::Notifier> mNotifier;
 };
diff --git a/common/notification.cpp b/common/notification.cpp
index b399d50..e688b6d 100644
--- a/common/notification.cpp
+++ b/common/notification.cpp
@@ -19,8 +19,37 @@
 */
 #include "notification.h"
+using namespace Sink;
+static QByteArray name(int type)
+{
+    switch (type) {
+        case Notification::Shutdown:
+            return "shutdown";
+        case Notification::Status:
+            return "status";
+        case Notification::Info:
+            return "info";
+        case Notification::Warning:
+            return "warning";
+        case Notification::Error:
+            return "error";
+        case Notification::Progress:
+            return "progress";
+        case Notification::Inspection:
+            return "inspection";
+        case Notification::RevisionUpdate:
+            return "revisionupdate";
+        case Notification::FlushCompletion:
+            return "flushcompletion";
+    }
+    return "Unknown:" + QByteArray::number(type);
+}
 QDebug operator<<(QDebug dbg, const Sink::Notification &n)
 {
-    dbg << "Notification(Id: " << n.id << ", Type: " << n.type  << ", Code: " << n.code << ", Message: " << n.message << ")";
+    dbg << "Notification(Type: " << name(n.type) << "Id, : " << n.id  << ", Code: ";
+    dbg << n.code;
+    dbg << ", Message: " << n.message << ", Entities: " << n.entities << ")";
    return dbg.space();
 }
diff --git a/common/notification.h b/common/notification.h
index 8224f2a..f5379fd 100644
--- a/common/notification.h
+++ b/common/notification.h
@@ -34,22 +34,29 @@ public:
    enum NoticationType {
        Shutdown,
        Status,
+        Info,
        Warning,
+        Error,
        Progress,
        Inspection,
        RevisionUpdate,
        FlushCompletion
    };
+    /**
+     * Used as code for Inspection type notifications
+     */
    enum InspectionCode {
        Success = 0,
        Failure
    };
    QByteArray id;
+    QByteArrayList entities;
    int type = 0;
    QString message;
    //A return code. Zero typically indicates success.
    int code = 0;
+    QByteArray resource;
 };
 }
diff --git a/common/notifier.cpp b/common/notifier.cpp
index 53db5be..f52e28b 100644
--- a/common/notifier.cpp
+++ b/common/notifier.cpp
@@ -24,6 +24,8 @@
 #include "resourceaccess.h"
 #include "resourceconfig.h"
+#include "query.h"
+#include "facadefactory.h"
 #include "log.h"
 using namespace Sink;
@@ -34,37 +36,64 @@ public:
    Private() : context(new QObject)
    {
    }
+    void listenForNotifications(const QSharedPointer<ResourceAccess> &access)
+    {
+        QObject::connect(access.data(), &ResourceAccess::notification, &context, [this](const Notification &notification) {
+            for (const auto &handler : handler) {
+                handler(notification);
+            }
+        });
+        resourceAccess << access;
+    }
    QList<QSharedPointer<ResourceAccess>> resourceAccess;
    QList<std::function<void(const Notification &)>> handler;
-    QSharedPointer<QObject> context;
+    QObject context;
 };
 Notifier::Notifier(const QSharedPointer<ResourceAccess> &resourceAccess) : d(new Sink::Notifier::Private)
 {
-    QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
+    d->listenForNotifications(resourceAccess);
-        for (const auto &handler : d->handler) {
-            handler(notification);
-        }
-    });
-    d->resourceAccess << resourceAccess;
 }
 Notifier::Notifier(const QByteArray &instanceIdentifier, const QByteArray &resourceType) : d(new Sink::Notifier::Private)
 {
-    auto resourceAccess = Sink::ResourceAccess::Ptr::create(instanceIdentifier, resourceType);
+    auto resourceAccess = Sink::ResourceAccessFactory::instance().getAccess(instanceIdentifier, resourceType);
    resourceAccess->open();
-    QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
+    d->listenForNotifications(resourceAccess);
-        for (const auto &handler : d->handler) {
-            handler(notification);
-        }
-    });
-    d->resourceAccess << resourceAccess;
 }
 Notifier::Notifier(const QByteArray &instanceIdentifier) : Notifier(instanceIdentifier, ResourceConfig::getResourceType(instanceIdentifier))
 {
 }
+Notifier::Notifier(const Sink::Query &resourceQuery) : d(new Sink::Notifier::Private)
+{
+    Sink::Log::Context resourceCtx{"notifier"};
+    auto facade = FacadeFactory::instance().getFacade<ApplicationDomain::SinkResource>();
+    Q_ASSERT(facade);
+    auto result = facade->load(resourceQuery, resourceCtx);
+    auto emitter = result.second;
+    emitter->onAdded([=](const ApplicationDomain::SinkResource::Ptr &resource) {
+        auto resourceAccess = Sink::ResourceAccessFactory::instance().getAccess(resource->identifier(), ResourceConfig::getResourceType(resource->identifier()));
+        resourceAccess->open();
+        d->listenForNotifications(resourceAccess);
+    });
+    emitter->onModified([](const ApplicationDomain::SinkResource::Ptr &) {
+    });
+    emitter->onRemoved([](const ApplicationDomain::SinkResource::Ptr &) {
+    });
+    emitter->onInitialResultSetComplete([](const ApplicationDomain::SinkResource::Ptr &, bool) {
+    });
+    emitter->onComplete([resourceCtx]() {
+        SinkTraceCtx(resourceCtx) << "Resource query complete";
+    });
+    emitter->fetch({});
+    result.first.exec();
+}
 void Notifier::registerHandler(std::function<void(const Notification &)> handler)
 {
    d->handler << handler;
diff --git a/common/notifier.h b/common/notifier.h
index 290458a..b5d3dfa 100644
--- a/common/notifier.h
+++ b/common/notifier.h
@@ -23,14 +23,14 @@
 #include "sink_export.h"
 #include <QByteArray>
 #include <QSharedPointer>
+#include <functional>
-#include <KAsync/Async>
 class QAbstractItemModel;
 namespace Sink {
 class ResourceAccess;
 class Notification;
+class Query;
 class SINK_EXPORT Notifier
 {
@@ -38,6 +38,7 @@ public:
    Notifier(const QSharedPointer<ResourceAccess> &resourceAccess);
    Notifier(const QByteArray &resourceInstanceIdentifier);
    Notifier(const QByteArray &resourceInstanceIdentifier, const QByteArray &resourceType);
+    Notifier(const Sink::Query &resourceQuery);
    void registerHandler(std::function<void(const Notification &)>);
 private:
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index 887b6b3..019784e 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -175,13 +175,14 @@ KAsync::Job<qint64> Pipeline::newEntity(void const *command, size_t size)
    auto o = Sink::ApplicationDomain::ApplicationDomainType{d->resourceContext.instanceId(), key, revision, memoryAdaptor};
    o.setChangedProperties(o.availableProperties().toSet());
-    auto preprocess = [&, this](ApplicationDomain::ApplicationDomainType &newEntity) {
+    auto newEntity = *ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<ApplicationDomain::ApplicationDomainType>(o, o.availableProperties());
-        foreach (const auto &processor, d->processors[bufferType]) {
+    newEntity.setChangedProperties(newEntity.availableProperties().toSet());
-            processor->newEntity(newEntity);
-        }
+    foreach (const auto &processor, d->processors[bufferType]) {
-    };
+        processor->newEntity(newEntity);
+    }
-    if (!d->entityStore.add(bufferType, o, replayToSource, preprocess)) {
+    if (!d->entityStore.add(bufferType, o, replayToSource)) {
        return KAsync::error<qint64>(0);
    }
@@ -195,6 +196,11 @@ struct CreateHelper {
    }
 };
+static KAsync::Job<void> create(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &newEntity)
+{
+    return TypeHelper<CreateHelper>{type}.operator()<KAsync::Job<void>, const ApplicationDomain::ApplicationDomainType&>(newEntity);
+}
 KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
 {
    d->transactionItemCount++;
@@ -248,65 +254,71 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
        deletions = BufferUtils::fromVector(*modifyEntity->deletions());
    }
-    if (modifyEntity->targetResource()) {
+    const auto current = d->entityStore.readLatest(bufferType, diff.identifier());
-        auto isMove = modifyEntity->removeEntity();
+    if (current.identifier().isEmpty()) {
-        auto targetResource = BufferUtils::extractBuffer(modifyEntity->targetResource());
+        SinkWarningCtx(d->logCtx) << "Failed to read current version: " << diff.identifier();
-        auto changeset = diff.changedProperties();
+        return KAsync::error<qint64>(0);
-        const auto current = d->entityStore.readLatest(bufferType, diff.identifier());
+    }
-        if (current.identifier().isEmpty()) {
-            SinkWarningCtx(d->logCtx) << "Failed to read current version: " << diff.identifier();
-            return KAsync::error<qint64>(0);
-        }
-        auto newEntity = *ApplicationDomain::ApplicationDomainType::getInMemoryCopy<ApplicationDomain::ApplicationDomainType>(current, current.availableProperties());
+    auto newEntity = d->entityStore.applyDiff(bufferType, current, diff, deletions);
-        // Apply diff
+    bool isMove = false;
-        for (const auto &property : changeset) {
+    if (modifyEntity->targetResource()) {
-            const auto value = diff.getProperty(property);
+        isMove = modifyEntity->removeEntity();
-            if (value.isValid()) {
+        newEntity.setResource(BufferUtils::extractBuffer(modifyEntity->targetResource()));
-                newEntity.setProperty(property, value);
+    }
-            }
-        }
-        // Remove deletions
+    foreach (const auto &processor, d->processors[bufferType]) {
-        for (const auto &property : deletions) {
+        bool exitLoop = false;
-            newEntity.setProperty(property, QVariant());
+        const auto result = processor->processModification(Preprocessor::Modification, current, newEntity);
+        switch (result.action) {
+            case Preprocessor::MoveToResource:
+                isMove = true;
+                exitLoop = true;
+                break;
+            case Preprocessor::CopyToResource:
+                isMove = true;
+                exitLoop = true;
+                break;
+            case Preprocessor::DropModification:
+                SinkTraceCtx(d->logCtx) << "Dropping modification";
+                return KAsync::error<qint64>(0);
+            default:
+                break;
        }
-        newEntity.setResource(targetResource);
+        if (exitLoop) {
-        newEntity.setChangedProperties(newEntity.availableProperties().toSet());
+            break;
+        }
+    }
-        SinkTraceCtx(d->logCtx) << "Moving entity to new resource " << newEntity.identifier() << newEntity.resourceInstanceIdentifier() << targetResource;
+    //The entity is either being copied or moved
-        auto job = TypeHelper<CreateHelper>{bufferType}.operator()<KAsync::Job<void>, ApplicationDomain::ApplicationDomainType&>(newEntity);
+    if (newEntity.resourceInstanceIdentifier() != d->resourceContext.resourceInstanceIdentifier) {
-        job = job.then([this, current, isMove, targetResource, bufferType](const KAsync::Error &error) {
+        SinkTraceCtx(d->logCtx) << "Moving entity to new resource " << newEntity.identifier() << newEntity.resourceInstanceIdentifier();
-            if (!error) {
+        newEntity.setChangedProperties(newEntity.availableProperties().toSet());
-                SinkTraceCtx(d->logCtx) << "Move of " << current.identifier() << "was successfull";
+        return create(bufferType, newEntity)
-                if (isMove) {
+            .then([=](const KAsync::Error &error) {
-                    startTransaction();
+                if (!error) {
-                    flatbuffers::FlatBufferBuilder fbb;
+                    SinkTraceCtx(d->logCtx) << "Move of " << current.identifier() << "was successfull";
-                    auto entityId = fbb.CreateString(current.identifier());
+                    if (isMove) {
-                    auto type = fbb.CreateString(bufferType);
+                        flatbuffers::FlatBufferBuilder fbb;
-                    auto location = Sink::Commands::CreateDeleteEntity(fbb, current.revision(), entityId, type, true);
+                        auto entityId = fbb.CreateString(current.identifier());
-                    Sink::Commands::FinishDeleteEntityBuffer(fbb, location);
+                        auto type = fbb.CreateString(bufferType);
-                    const auto data = BufferUtils::extractBuffer(fbb);
+                        auto location = Sink::Commands::CreateDeleteEntity(fbb, current.revision(), entityId, type, true);
-                    deletedEntity(data, data.size()).exec();
+                        Sink::Commands::FinishDeleteEntityBuffer(fbb, location);
-                    commit();
+                        const auto data = BufferUtils::extractBuffer(fbb);
+                        deletedEntity(data, data.size()).exec();
+                    }
+                } else {
+                    SinkErrorCtx(d->logCtx) << "Failed to move entity " << newEntity.identifier() << " to resource " << newEntity.resourceInstanceIdentifier();
                }
-            } else {
+            })
-                SinkErrorCtx(d->logCtx) << "Failed to move entity " << targetResource << " to resource " << current.identifier();
+            .then([this] {
-            }
+                return d->entityStore.maxRevision();
-        });
+            });
-        job.exec();
-        return KAsync::value<qint64>(0);
    }
-    auto preprocess = [&, this](const ApplicationDomain::ApplicationDomainType &oldEntity, ApplicationDomain::ApplicationDomainType &newEntity) {
-        foreach (const auto &processor, d->processors[bufferType]) {
-            processor->modifiedEntity(oldEntity, newEntity);
-        }
-    };
    d->revisionChanged = true;
-    if (!d->entityStore.modify(bufferType, diff, deletions, replayToSource, preprocess)) {
+    if (!d->entityStore.modify(bufferType, current, newEntity, replayToSource)) {
        return KAsync::error<qint64>(0);
    }
@@ -331,14 +343,14 @@ KAsync::Job<qint64> Pipeline::deletedEntity(void const *command, size_t size)
    const QByteArray key = QByteArray(reinterpret_cast<char const *>(deleteEntity->entityId()->Data()), deleteEntity->entityId()->size());
    SinkTraceCtx(d->logCtx) << "Deleted Entity. Type: " << bufferType << "uid: "<< key << " replayToSource: " << replayToSource;
-    auto preprocess = [&, this](const ApplicationDomain::ApplicationDomainType &oldEntity) {
+    const auto current = d->entityStore.readLatest(bufferType, key);
-        foreach (const auto &processor, d->processors[bufferType]) {
-            processor->deletedEntity(oldEntity);
+    foreach (const auto &processor, d->processors[bufferType]) {
-        }
+        processor->deletedEntity(current);
-    };
+    }
    d->revisionChanged = true;
-    if (!d->entityStore.remove(bufferType, key, replayToSource, preprocess)) {
+    if (!d->entityStore.remove(bufferType, current, replayToSource)) {
        return KAsync::error<qint64>(0);
    }
@@ -385,6 +397,39 @@ void Preprocessor::finalizeBatch()
 {
 }
+void Preprocessor::newEntity(ApplicationDomain::ApplicationDomainType &newEntity)
+{
+}
+void Preprocessor::modifiedEntity(const ApplicationDomain::ApplicationDomainType &oldEntity, ApplicationDomain::ApplicationDomainType &newEntity)
+{
+}
+void Preprocessor::deletedEntity(const ApplicationDomain::ApplicationDomainType &oldEntity)
+{
+}
+Preprocessor::Result Preprocessor::processModification(Type type, const ApplicationDomain::ApplicationDomainType &current, ApplicationDomain::ApplicationDomainType &diff)
+{
+    switch(type) {
+        case Creation:
+            newEntity(diff);
+            return {NoAction};
+        case Modification:
+            modifiedEntity(current, diff);
+            return {NoAction};
+        case Deletion:
+            deletedEntity(current);
+            return {NoAction};
+        default:
+            break;
+    }
+    return {NoAction};
+}
 QByteArray Preprocessor::resourceInstanceIdentifier() const
 {
    return d->resourceInstanceIdentifier;
diff --git a/common/pipeline.h b/common/pipeline.h
index c6dc5fe..11d52fd 100644
--- a/common/pipeline.h
+++ b/common/pipeline.h
@@ -77,10 +77,28 @@ public:
    Preprocessor();
    virtual ~Preprocessor();
+    enum Action {
+        NoAction,
+        MoveToResource,
+        CopyToResource,
+        DropModification,
+        DeleteEntity
+    };
+    enum Type {
+        Creation,
+        Modification,
+        Deletion
+    };
+    struct Result {
+        Action action;
+    };
    virtual void startBatch();
-    virtual void newEntity(ApplicationDomain::ApplicationDomainType &newEntity) {};
+    virtual void newEntity(ApplicationDomain::ApplicationDomainType &newEntity);
-    virtual void modifiedEntity(const ApplicationDomain::ApplicationDomainType &oldEntity, ApplicationDomain::ApplicationDomainType &newEntity) {};
+    virtual void modifiedEntity(const ApplicationDomain::ApplicationDomainType &oldEntity, ApplicationDomain::ApplicationDomainType &newEntity);
-    virtual void deletedEntity(const ApplicationDomain::ApplicationDomainType &oldEntity) {};
+    virtual void deletedEntity(const ApplicationDomain::ApplicationDomainType &oldEntity);
+    virtual Result processModification(Type type, const ApplicationDomain::ApplicationDomainType &current, ApplicationDomain::ApplicationDomainType &diff);
    virtual void finalizeBatch();
    void setup(const QByteArray &resourceType, const QByteArray &resourceInstanceIdentifier, Pipeline *, Storage::EntityStore *entityStore);
diff --git a/common/propertymapper.cpp b/common/propertymapper.cpp
index 4d45644..c72cf31 100644
--- a/common/propertymapper.cpp
+++ b/common/propertymapper.cpp
@@ -22,6 +22,7 @@
 #include "applicationdomaintype.h"
 #include <QDateTime>
 #include "mail_generated.h"
+#include "contact_generated.h"
 template <>
 flatbuffers::uoffset_t variantToProperty<QString>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
@@ -110,6 +111,21 @@ flatbuffers::uoffset_t variantToProperty<QList<Sink::ApplicationDomain::Mail::Co
    return 0;
 }
+template <>
+flatbuffers::uoffset_t variantToProperty<QList<Sink::ApplicationDomain::Contact::Email>>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
+{
+    if (property.isValid()) {
+        const auto list = property.value<QList<Sink::ApplicationDomain::Contact::Email>>();
+        std::vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>> vector;
+        for (const auto &value : list) {
+            auto offset = Sink::ApplicationDomain::Buffer::CreateContactEmailDirect(fbb, value.type, value.email.toUtf8().constData()).o;
+            vector.push_back(offset);
+        }
+        return fbb.CreateVector(vector).o;
+    }
+    return 0;
+}
 QString propertyToString(const flatbuffers::String *property)
 {
@@ -217,6 +233,20 @@ QVariant propertyToVariant<QList<Sink::ApplicationDomain::Mail::Contact>>(const
 }
 template <>
+QVariant propertyToVariant<QList<Sink::ApplicationDomain::Contact::Email>>(const flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>> *property)
+{
+    if (property) {
+        QList<Sink::ApplicationDomain::Contact::Email> list;
+        for (auto it = property->begin(); it != property->end();) {
+            list << Sink::ApplicationDomain::Contact::Email{static_cast<Sink::ApplicationDomain::Contact::Email::Type>(it->type()), propertyToString(it->email())};
+            it.operator++();
+        }
+        return QVariant::fromValue(list);
+    }
+    return QVariant();
+}
+template <>
 QVariant propertyToVariant<bool>(uint8_t property)
 {
    return static_cast<bool>(property);
diff --git a/common/propertymapper.h b/common/propertymapper.h
index 70491a1..9ea0b73 100644
--- a/common/propertymapper.h
+++ b/common/propertymapper.h
@@ -29,6 +29,7 @@ namespace Sink {
 namespace ApplicationDomain {
 namespace Buffer {
    struct MailContact;
+    struct ContactEmail;
 }
 }
 }
@@ -54,6 +55,8 @@ template <typename T>
 QVariant SINK_EXPORT propertyToVariant(const Sink::ApplicationDomain::Buffer::MailContact *);
 template <typename T>
 QVariant SINK_EXPORT propertyToVariant(const flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::MailContact>> *);
+template <typename T>
+QVariant SINK_EXPORT propertyToVariant(const flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>> *);
 /**
 * The property mapper is a non-typesafe virtual dispatch.
@@ -131,6 +134,12 @@ public:
        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;
 };
@@ -218,6 +227,15 @@ public:
        });
    }
+    template <typename T>
+    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>>>))
+    {
+        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); };
+        });
+    }
 private:
    QHash<QByteArray, std::function<std::function<void(BufferBuilder &)>(const QVariant &, flatbuffers::FlatBufferBuilder &)>> mWriteAccessors;
 };
diff --git a/common/query.h b/common/query.h
index 8e9050d..5b37cdd 100644
--- a/common/query.h
+++ b/common/query.h
@@ -300,7 +300,9 @@ public:
        /** Leave the query running and continuously update the result set. */
        LiveQuery = 1,
        /** Run the query synchronously. */
-        SynchronousQuery = 2
+        SynchronousQuery = 2,
+        /** Include status updates via notifications */
+        UpdateStatus = 4
    };
    Q_DECLARE_FLAGS(Flags, Flag)
@@ -410,6 +412,11 @@ public:
        mFlags = flags;
    }
+    Flags flags() const
+    {
+        return mFlags;
+    }
    bool liveQuery() const
    {
        return mFlags.testFlag(LiveQuery);
@@ -509,6 +516,31 @@ public:
    }
    template <typename T>
+    SyncScope &resourceFilter(const ApplicationDomain::ApplicationDomainType &entity)
+    {
+        mResourceFilter.propertyFilter.insert(T::name, Comparator(entity.identifier()));
+        return *this;
+    }
+    SyncScope &resourceFilter(const QByteArray &name, const Comparator &comparator)
+    {
+        mResourceFilter.propertyFilter.insert(name, comparator);
+        return *this;
+    }
+    template <typename T>
+    SyncScope &resourceContainsFilter(const QVariant &value)
+    {
+        return resourceFilter(T::name, Comparator(value, Comparator::Contains));
+    }
+    template <typename T>
+    SyncScope &resourceFilter(const QVariant &value)
+    {
+        return resourceFilter(T::name, value);
+    }
+    template <typename T>
    SyncScope &filter(const Query::Comparator &comparator)
    {
        return filter(T::name, comparator);
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index 802fc48..43f48c0 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -51,7 +51,7 @@ public:
    virtual ~QueryWorker();
    ReplayResult executeIncrementalQuery(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, DataStoreQuery::State::Ptr state);
-    ReplayResult executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int offset, int batchsize);
+    ReplayResult executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int batchsize, DataStoreQuery::State::Ptr state);
 private:
    void resultProviderCallback(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const ResultSet::Result &result);
@@ -72,18 +72,18 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
    auto guardPtr = QPointer<QObject>(&guard);
    auto fetcher = [=](const typename DomainType::Ptr &parent) {
        const QByteArray parentId = parent ? parent->identifier() : QByteArray();
-        SinkTraceCtx(mLogCtx) << "Running fetcher. Offset: " << mOffset[parentId] << " Batchsize: " << mBatchSize;
+        SinkTraceCtx(mLogCtx) << "Running fetcher. Batchsize: " << mBatchSize;
        auto resultProvider = mResultProvider;
        auto resultTransformation = mResultTransformation;
-        auto offset = mOffset[parentId];
        auto batchSize = mBatchSize;
        auto resourceContext = mResourceContext;
        auto logCtx = mLogCtx;
+        auto state = mQueryState.value(parentId);
        const bool runAsync = !query.synchronousQuery();
        //The lambda will be executed in a separate thread, so copy all arguments
-        async::run<ReplayResult>([resultTransformation, offset, batchSize, query, bufferType, resourceContext, resultProvider, parent, logCtx]() {
+        async::run<ReplayResult>([=]() {
            QueryWorker<DomainType> worker(query, resourceContext, bufferType, resultTransformation, logCtx);
-            return worker.executeInitialQuery(query, parent, *resultProvider, offset, batchSize);
+            return worker.executeInitialQuery(query, parent, *resultProvider, batchSize, state);
        }, runAsync)
            .then([this, parentId, query, parent, resultProvider, guardPtr](const ReplayResult &result) {
                if (!guardPtr) {
@@ -91,8 +91,7 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
                    return;
                }
                mInitialQueryComplete = true;
-                mQueryState = result.queryState;
+                mQueryState[parentId] = result.queryState;
-                mOffset[parentId] += result.replayedEntities;
                // Only send the revision replayed information if we're connected to the resource, there's no need to start the resource otherwise.
                if (query.liveQuery()) {
                    mResourceAccess->sendRevisionReplayedCommand(result.newRevision);
@@ -111,10 +110,11 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
        Q_ASSERT(!query.synchronousQuery());
        // Incremental updates are always loaded directly, leaving it up to the result to discard the changes if they are not interesting
        setQuery([=]() -> KAsync::Job<void> {
+            const QByteArray parentId;
            auto resultProvider = mResultProvider;
            auto resourceContext = mResourceContext;
            auto logCtx = mLogCtx;
-            auto state = mQueryState;
+            auto state = mQueryState.value(parentId);
            if (!mInitialQueryComplete) {
                SinkWarningCtx(mLogCtx) << "Can't start the incremental query before the initial query is complete";
                fetcher({});
@@ -225,7 +225,7 @@ ReplayResult QueryWorker<DomainType>::executeIncrementalQuery(const Sink::Query
        SinkWarningCtx(mLogCtx) << "No previous query state.";
        return {0, 0, false, DataStoreQuery::State::Ptr{}};
    }
-    auto preparedQuery = DataStoreQuery{*state, ApplicationDomain::getTypeName<DomainType>(), entityStore};
+    auto preparedQuery = DataStoreQuery{*state, ApplicationDomain::getTypeName<DomainType>(), entityStore, true};
    auto resultSet = preparedQuery.update(baseRevision);
    SinkTraceCtx(mLogCtx) << "Filtered set retrieved. " << Log::TraceTime(time.elapsed());
    auto replayResult = resultSet.replaySet(0, 0, [this, query, &resultProvider](const ResultSet::Result &result) {
@@ -240,7 +240,7 @@ ReplayResult QueryWorker<DomainType>::executeIncrementalQuery(const Sink::Query
 template <class DomainType>
 ReplayResult QueryWorker<DomainType>::executeInitialQuery(
-    const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int offset, int batchsize)
+    const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, int batchsize, DataStoreQuery::State::Ptr state)
 {
    QTime time;
    time.start();
@@ -257,11 +257,17 @@ ReplayResult QueryWorker<DomainType>::executeInitialQuery(
    }
    auto entityStore = EntityStore{mResourceContext, mLogCtx};
-    auto preparedQuery = DataStoreQuery{modifiedQuery, ApplicationDomain::getTypeName<DomainType>(), entityStore};
+    auto preparedQuery = [&] {
-    auto resultSet = preparedQuery.execute();
+        if (state) {
+            return DataStoreQuery{*state, ApplicationDomain::getTypeName<DomainType>(), entityStore, false};
+        } else {
+            return DataStoreQuery{modifiedQuery, ApplicationDomain::getTypeName<DomainType>(), entityStore};
+        }
+    }();
+    auto resultSet = preparedQuery.execute();;
-    SinkTraceCtx(mLogCtx) << "Filtered set retrieved. " << Log::TraceTime(time.elapsed());
+    SinkTraceCtx(mLogCtx) << "Filtered set retrieved." << Log::TraceTime(time.elapsed());
-    auto replayResult = resultSet.replaySet(offset, batchsize, [this, query, &resultProvider](const ResultSet::Result &result) {
+    auto replayResult = resultSet.replaySet(0, batchsize, [this, query, &resultProvider](const ResultSet::Result &result) {
        resultProviderCallback(query, resultProvider, result);
    });
@@ -269,9 +275,7 @@ ReplayResult QueryWorker<DomainType>::executeInitialQuery(
        << (replayResult.replayedAll ? "Replayed all available results.\n" : "")
        << "Initial query took: " << Log::TraceTime(time.elapsed());
-    auto state = preparedQuery.getState();
+    return {entityStore.maxRevision(), replayResult.replayedEntities, replayResult.replayedAll, preparedQuery.getState()};
-    return {entityStore.maxRevision(), replayResult.replayedEntities, replayResult.replayedAll, state};
 }
 #define REGISTER_TYPE(T) \
diff --git a/common/queryrunner.h b/common/queryrunner.h
index f5c7ead..5308eac 100644
--- a/common/queryrunner.h
+++ b/common/queryrunner.h
@@ -98,11 +98,10 @@ private:
    QSharedPointer<Sink::ResourceAccessInterface> mResourceAccess;
    QSharedPointer<Sink::ResultProvider<typename DomainType::Ptr>> mResultProvider;
    ResultTransformation mResultTransformation;
-    QHash<QByteArray, qint64> mOffset;
+    QHash<QByteArray, DataStoreQuery::State::Ptr> mQueryState;
    int mBatchSize;
    QObject guard;
    Sink::Log::Context mLogCtx;
-    DataStoreQuery::State::Ptr mQueryState;
    bool mInitialQueryComplete = false;
    bool mQueryInProgress = false;
 };
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 50845ac..ad8cae9 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -547,6 +547,7 @@ static Sink::Notification getNotification(const Sink::Commands::Notification *bu
    }
    n.type = buffer->type();
    n.code = buffer->code();
+    n.entities = BufferUtils::fromVector(*buffer->entities());
    return n;
 }
@@ -601,20 +602,23 @@ bool ResourceAccess::processMessageBuffer()
                    queuedInvoke([=]() { emit notification(n); }, this);
                } break;
                case Sink::Notification::Status:
-                    if (mResourceStatus == buffer->code()) {
+                    if (mResourceStatus != buffer->code()) {
-                        SinkTrace() << "Got an unnecessary status notification";
+                        mResourceStatus = buffer->code();
-                        break;
+                        SinkTrace() << "Updated status: " << mResourceStatus;
                    }
-                    mResourceStatus = buffer->code();
+                    [[clang::fallthrough]];
-                    SinkTrace() << "Updated status: " << mResourceStatus;
+                case Sink::Notification::Info:
                    [[clang::fallthrough]];
                case Sink::Notification::Warning:
                    [[clang::fallthrough]];
+                case Sink::Notification::Error:
+                    [[clang::fallthrough]];
                case Sink::Notification::FlushCompletion:
                    [[clang::fallthrough]];
                case Sink::Notification::Progress: {
                    auto n = getNotification(buffer);
-                    SinkTrace() << "Received notification: " << n.type;
+                    SinkTrace() << "Received notification: " << n;
+                    n.resource = d->resourceInstanceIdentifier;
                    emit notification(n);
                } break;
                case Sink::Notification::RevisionUpdate:
diff --git a/common/resourcecontext.h b/common/resourcecontext.h
index 6058ac7..6ceba01 100644
--- a/common/resourcecontext.h
+++ b/common/resourcecontext.h
@@ -55,7 +55,9 @@ struct ResourceContext {
    DomainTypeAdaptorFactoryInterface &adaptorFactory(const QByteArray &type) const
    {
        auto factory = adaptorFactories.value(type);
-        Q_ASSERT(factory);
+        if (!factory) {
+            qFatal("Failed to find a factory for %s", type.constData());
+        }
        return *factory;
    }
diff --git a/common/resourcecontrol.cpp b/common/resourcecontrol.cpp
index 1f61a1c..70a3f7d 100644
--- a/common/resourcecontrol.cpp
+++ b/common/resourcecontrol.cpp
@@ -100,9 +100,9 @@ KAsync::Job<void> ResourceControl::flush(Flush::FlushType type, const QByteArray
    auto notifier = QSharedPointer<Sink::Notifier>::create(resourceAccess);
    auto id = QUuid::createUuid().toByteArray();
    return KAsync::start<void>([=](KAsync::Future<void> &future) {
-            SinkTrace() << "Waiting for notification notification " << id;
+            SinkTrace() << "Waiting for flush completion notification " << id;
            notifier->registerHandler([&future, id](const Notification &notification) {
-                SinkTrace() << "Received notification " << notification.type << notification.id;
+                SinkTrace() << "Received notification: " << notification.type << notification.id;
                if (notification.id == id) {
                    SinkTrace() << "FlushComplete";
                    if (notification.code) {
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index 4a8037d..dee0711 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -34,33 +34,42 @@ SINK_DEBUG_AREA("ResourceFacade")
 template<typename DomainType>
 ConfigNotifier LocalStorageFacade<DomainType>::sConfigNotifier;
-static void applyConfig(ConfigStore &configStore, const QByteArray &id, ApplicationDomain::ApplicationDomainType &object)
+static void applyConfig(ConfigStore &configStore, const QByteArray &id, ApplicationDomain::ApplicationDomainType &object, const QByteArrayList &requestedProperties)
 {
    const auto configurationValues = configStore.get(id);
    for (auto it = configurationValues.constBegin(); it != configurationValues.constEnd(); it++) {
        object.setProperty(it.key(), it.value());
    }
+    //Populate the object with dummy values for non-available but requested properties.
+    //This avoid a warning about non-existing properties in bufferadaptor.h
+    if (!requestedProperties.isEmpty()) {
+        for (const auto &requested: requestedProperties) {
+            if (!object.hasProperty(requested)) {
+                object.setProperty(requested, QVariant{});
+            }
+        }
+    }
 }
 template <typename DomainType>
-static typename DomainType::Ptr readFromConfig(ConfigStore &configStore, const QByteArray &id, const QByteArray &type)
+static typename DomainType::Ptr readFromConfig(ConfigStore &configStore, const QByteArray &id, const QByteArray &type, const QByteArrayList &requestedProperties)
 {
    auto object = DomainType::Ptr::create(id);
-    applyConfig(configStore, id, *object);
+    applyConfig(configStore, id, *object, requestedProperties);
    return object;
 }
 template <>
-typename ApplicationDomain::SinkAccount::Ptr readFromConfig<ApplicationDomain::SinkAccount>(ConfigStore &configStore, const QByteArray &id, const QByteArray &type)
+typename ApplicationDomain::SinkAccount::Ptr readFromConfig<ApplicationDomain::SinkAccount>(ConfigStore &configStore, const QByteArray &id, const QByteArray &type, const QByteArrayList &requestedProperties)
 {
    auto object = ApplicationDomain::SinkAccount::Ptr::create(id);
    object->setProperty(ApplicationDomain::SinkAccount::AccountType::name, type);
-    applyConfig(configStore, id, *object);
+    applyConfig(configStore, id, *object, requestedProperties);
    return object;
 }
 template <>
-typename ApplicationDomain::SinkResource::Ptr readFromConfig<ApplicationDomain::SinkResource>(ConfigStore &configStore, const QByteArray &id, const QByteArray &type)
+typename ApplicationDomain::SinkResource::Ptr readFromConfig<ApplicationDomain::SinkResource>(ConfigStore &configStore, const QByteArray &id, const QByteArray &type, const QByteArrayList &requestedProperties)
 {
    auto object = ApplicationDomain::SinkResource::Ptr::create(id);
    object->setProperty(ApplicationDomain::SinkResource::ResourceType::name, type);
@@ -70,7 +79,7 @@ typename ApplicationDomain::SinkResource::Ptr readFromConfig<ApplicationDomain::
            object->setCapabilities(res->capabilities());
        }
    }
-    applyConfig(configStore, id, *object);
+    applyConfig(configStore, id, *object, requestedProperties);
    return object;
 }
@@ -104,7 +113,7 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
            if (!query.ids().isEmpty() && !query.ids().contains(res)) {
                continue;
            }
-            auto entity = readFromConfig<DomainType>(mConfigStore, res, type);
+            auto entity = readFromConfig<DomainType>(mConfigStore, res, type, query.requestedProperties);
            if (!matchesFilter(query.getBaseFilters(), *entity)){
                SinkTraceCtx(mLogCtx) << "Skipping due to filter." << res;
                continue;
@@ -169,7 +178,7 @@ template<typename DomainType>
 void LocalStorageQueryRunner<DomainType>::statusChanged(const QByteArray &identifier)
 {
    SinkTraceCtx(mLogCtx) << "Status changed " << identifier;
-    auto entity = readFromConfig<DomainType>(mConfigStore, identifier, ApplicationDomain::getTypeName<DomainType>());
+    auto entity = readFromConfig<DomainType>(mConfigStore, identifier, ApplicationDomain::getTypeName<DomainType>(), QByteArrayList{});
    updateStatus(*entity);
    mResultProvider->modify(entity);
 }
@@ -213,7 +222,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::create(const DomainType &domai
            }
            configStore.modify(identifier, configurationValues);
        }
-        sConfigNotifier.add(::readFromConfig<DomainType>(configStore, identifier, type));
+        sConfigNotifier.add(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}));
    });
 }
@@ -242,7 +251,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::modify(const DomainType &domai
        }
        const auto type = configStore.getEntries().value(identifier);
-        sConfigNotifier.modify(::readFromConfig<DomainType>(configStore, identifier, type));
+        sConfigNotifier.modify(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}));
    });
 }
@@ -337,10 +346,12 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
    runner->setStatusUpdater([runner, monitoredResources, ctx](ApplicationDomain::SinkAccount &account) {
        Query query;
        query.filter<ApplicationDomain::SinkResource::Account>(account.identifier());
+        query.request<ApplicationDomain::SinkResource::Account>()
+             .request<ApplicationDomain::SinkResource::Capabilities>();
        const auto resources = Store::read<ApplicationDomain::SinkResource>(query);
        SinkTraceCtx(ctx) << "Found resource belonging to the account " << account.identifier() << " : " << resources;
        auto accountIdentifier = account.identifier();
-        ApplicationDomain::Status status = ApplicationDomain::ConnectedStatus;
+        QList<int> states;
        for (const auto &resource : resources) {
            auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource.identifier(), ResourceConfig::getResourceType(resource.identifier()));
            if (!monitoredResources->contains(resource.identifier())) {
@@ -353,27 +364,20 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
                Q_ASSERT(ret);
                monitoredResources->insert(resource.identifier());
            }
+            states << resourceAccess->getResourceStatus();
-            //Figure out overall status
-            auto s = resourceAccess->getResourceStatus();
-            switch (s) {
-                case ApplicationDomain::ErrorStatus:
-                    status = ApplicationDomain::ErrorStatus;
-                    break;
-                case ApplicationDomain::OfflineStatus:
-                    if (status == ApplicationDomain::ConnectedStatus) {
-                        status = ApplicationDomain::OfflineStatus;
-                    }
-                    break;
-                case ApplicationDomain::ConnectedStatus:
-                    break;
-                case ApplicationDomain::BusyStatus:
-                    if (status != ApplicationDomain::ErrorStatus) {
-                        status = ApplicationDomain::BusyStatus;
-                    }
-                    break;
-            }
        }
+        const auto status = [&] {
+            if (states.contains(ApplicationDomain::ErrorStatus)) {
+                return ApplicationDomain::ErrorStatus;
+            }
+            if (states.contains(ApplicationDomain::BusyStatus)) {
+                return ApplicationDomain::BusyStatus;
+            }
+            if (states.contains(ApplicationDomain::ConnectedStatus)) {
+                return ApplicationDomain::ConnectedStatus;
+            }
+            return ApplicationDomain::OfflineStatus;
+        }();
        account.setStatusStatus(status);
    });
    return qMakePair(KAsync::null<void>(), runner->emitter());
diff --git a/common/resultprovider.h b/common/resultprovider.h
index a2ed0b5..d6feaf9 100644
--- a/common/resultprovider.h
+++ b/common/resultprovider.h
@@ -268,8 +268,9 @@ public:
    void initialResultSetComplete(const DomainType &parent, bool replayedAll)
    {
-        QMutexLocker locker{&mMutex};
+        //This callback is only ever called from the main thread, so we don't do any locking
        if (initialResultSetCompleteHandler && guardOk()) {
+            //This can directly lead to our destruction and thus waitForMethodExecutionEnd
            initialResultSetCompleteHandler(parent, replayedAll);
        }
    }
@@ -313,6 +314,13 @@ private:
    std::function<void(void)> clearHandler;
    std::function<void(const DomainType &parent)> mFetcher;
+    /*
+     * This mutex is here to protect the emitter from getting destroyed while the producer-thread (ResultProvider) is calling into it,
+     * and vice-verca, to protect the producer thread from calling into a destroyed emitter.
+     *
+     * This is necessary because Emitter and ResultProvider have lifetimes managed by two different threads.
+     * The emitter lives in the application thread, and the resultprovider in the query thread.
+     */
    QMutex mMutex;
    bool mDone = false;
 };
diff --git a/common/specialpurposepreprocessor.cpp b/common/specialpurposepreprocessor.cpp
index be5fa50..25a6d1a 100644
--- a/common/specialpurposepreprocessor.cpp
+++ b/common/specialpurposepreprocessor.cpp
@@ -46,7 +46,7 @@ QByteArray getSpecialPurposeType(const QString &name)
 }
 }
-SpecialPurposeProcessor::SpecialPurposeProcessor(const QByteArray &resourceType, const QByteArray &resourceInstanceIdentifier) : mResourceType(resourceType), mResourceInstanceIdentifier(resourceInstanceIdentifier) {}
+SpecialPurposeProcessor::SpecialPurposeProcessor() : Sink::Preprocessor() {}
 QByteArray SpecialPurposeProcessor::findFolder(const QByteArray &specialPurpose, bool createIfMissing)
 {
@@ -60,7 +60,7 @@ QByteArray SpecialPurposeProcessor::findFolder(const QByteArray &specialPurpose,
        if (!mSpecialPurposeFolders.contains(specialPurpose) && createIfMissing) {
            SinkTrace() << "Failed to find a " << specialPurpose << " folder, creating a new one";
-            auto folder = ApplicationDomain::Folder::create(mResourceInstanceIdentifier);
+            auto folder = ApplicationDomain::Folder::create(resourceInstanceIdentifier());
            folder.setSpecialPurpose(QByteArrayList() << specialPurpose);
            folder.setName(sSpecialPurposeFolders.value(specialPurpose));
            folder.setIcon("folder");
@@ -104,7 +104,19 @@ void SpecialPurposeProcessor::moveToFolder(Sink::ApplicationDomain::ApplicationD
 void SpecialPurposeProcessor::newEntity(Sink::ApplicationDomain::ApplicationDomainType &newEntity)
 {
-    moveToFolder(newEntity);
+    auto mail = newEntity.cast<ApplicationDomain::Mail>();
+    const auto folder = mail.getFolder();
+    if (folder.isEmpty()) {
+        moveToFolder(newEntity);
+    } else {
+        bool isDraft = findFolder(ApplicationDomain::SpecialPurpose::Mail::drafts) == folder;
+        bool isSent = findFolder(ApplicationDomain::SpecialPurpose::Mail::sent) == folder;
+        bool isTrash = findFolder(ApplicationDomain::SpecialPurpose::Mail::trash) == folder;
+        mail.setDraft(isDraft);
+        mail.setTrash(isTrash);
+        mail.setSent(isSent);
+    }
 }
 void SpecialPurposeProcessor::modifiedEntity(const Sink::ApplicationDomain::ApplicationDomainType &oldEntity, Sink::ApplicationDomain::ApplicationDomainType &newEntity)
@@ -118,8 +130,8 @@ void SpecialPurposeProcessor::modifiedEntity(const Sink::ApplicationDomain::Appl
        bool isSent = findFolder(ApplicationDomain::SpecialPurpose::Mail::sent) == folder;
        bool isTrash = findFolder(ApplicationDomain::SpecialPurpose::Mail::trash) == folder;
        mail.setDraft(isDraft);
-        mail.setTrash(isSent);
+        mail.setTrash(isTrash);
-        mail.setSent(isTrash);
+        mail.setSent(isSent);
    } else {
        moveToFolder(newEntity);
    }
diff --git a/common/specialpurposepreprocessor.h b/common/specialpurposepreprocessor.h
index 6eb325c..6173aff 100644
--- a/common/specialpurposepreprocessor.h
+++ b/common/specialpurposepreprocessor.h
@@ -28,7 +28,7 @@ namespace SpecialPurpose {
 class SINK_EXPORT SpecialPurposeProcessor : public Sink::Preprocessor
 {
 public:
-    SpecialPurposeProcessor(const QByteArray &resourceType, const QByteArray &resourceInstanceIdentifier);
+    SpecialPurposeProcessor();
    void newEntity(Sink::ApplicationDomain::ApplicationDomainType &newEntity) Q_DECL_OVERRIDE;
    void modifiedEntity(const Sink::ApplicationDomain::ApplicationDomainType &oldEntity, Sink::ApplicationDomain::ApplicationDomainType &newEntity) Q_DECL_OVERRIDE;
@@ -39,6 +39,4 @@ private:
    bool isSpecialPurposeFolder(const QByteArray &folder) const;
    QHash<QByteArray, QByteArray> mSpecialPurposeFolders;
-    QByteArray mResourceType;
-    QByteArray mResourceInstanceIdentifier;
 };
diff --git a/common/storage.h b/common/storage.h
index fd349f3..71e9401 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -128,14 +128,14 @@ public:
    public:
        Transaction();
        ~Transaction();
-        bool commit(const std::function<void(const DataStore::Error &error)> &errorHandler = std::function<void(const DataStore::Error &error)>());
+        bool commit(const std::function<void(const DataStore::Error &error)> &errorHandler = {});
        void abort();
        QList<QByteArray> getDatabaseNames() const;
        bool validateNamedDatabases();
-        NamedDatabase openDatabase(const QByteArray &name = QByteArray("default"),
+        NamedDatabase openDatabase(const QByteArray &name = {"default"},
-            const std::function<void(const DataStore::Error &error)> &errorHandler = std::function<void(const DataStore::Error &error)>(), bool allowDuplicates = false) const;
+            const std::function<void(const DataStore::Error &error)> &errorHandler = {}, bool allowDuplicates = false) const;
        Transaction(Transaction &&other);
        Transaction &operator=(Transaction &&other);
@@ -189,6 +189,9 @@ public:
    static QByteArray getTypeFromRevision(const Transaction &, qint64 revision);
    static void recordRevision(Transaction &, qint64 revision, const QByteArray &uid, const QByteArray &type);
    static void removeRevision(Transaction &, qint64 revision);
+    static void recordUid(DataStore::Transaction &transaction, const QByteArray &uid);
+    static void removeUid(DataStore::Transaction &transaction, const QByteArray &uid);
+    static void getUids(const Transaction &, const std::function<void(const QByteArray &uid)> &);
    bool exists() const;
diff --git a/common/storage/entitystore.cpp b/common/storage/entitystore.cpp
index 909f1b2..b7309ab 100644
--- a/common/storage/entitystore.cpp
+++ b/common/storage/entitystore.cpp
@@ -31,8 +31,7 @@
 #include "bufferutils.h"
 #include "entity_generated.h"
 #include "applicationdomaintype_p.h"
+#include "typeimplementations.h"
-#include "domaintypes.h"
 using namespace Sink;
 using namespace Sink::Storage;
@@ -168,19 +167,15 @@ void EntityStore::copyBlobs(ApplicationDomain::ApplicationDomainType &entity, qi
    }
 }
-bool EntityStore::add(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &entity_, bool replayToSource, const PreprocessCreation &preprocess)
+bool EntityStore::add(const QByteArray &type, ApplicationDomain::ApplicationDomainType entity, bool replayToSource)
 {
-    if (entity_.identifier().isEmpty()) {
+    if (entity.identifier().isEmpty()) {
        SinkWarningCtx(d->logCtx) << "Can't write entity with an empty identifier";
        return false;
    }
-    auto entity = *ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<ApplicationDomain::ApplicationDomainType>(entity_, entity_.availableProperties());
-    entity.setChangedProperties(entity.availableProperties().toSet());
    SinkTraceCtx(d->logCtx) << "New entity " << entity;
-    preprocess(entity);
    d->typeIndex(type).add(entity.identifier(), entity, d->transaction);
    //The maxRevision may have changed meanwhile if the entity created sub-entities
@@ -205,26 +200,20 @@ bool EntityStore::add(const QByteArray &type, const ApplicationDomain::Applicati
            [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to write entity" << entity.identifier() << newRevision; });
    DataStore::setMaxRevision(d->transaction, newRevision);
    DataStore::recordRevision(d->transaction, newRevision, entity.identifier(), type);
+    DataStore::recordUid(d->transaction, entity.identifier());
    SinkTraceCtx(d->logCtx) << "Wrote entity: " << entity.identifier() << type << newRevision;
    return true;
 }
-bool EntityStore::modify(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &diff, const QByteArrayList &deletions, bool replayToSource, const PreprocessModification &preprocess)
+ApplicationDomain::ApplicationDomainType EntityStore::applyDiff(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &current, const ApplicationDomain::ApplicationDomainType &diff, const QByteArrayList &deletions) const
 {
-    auto changeset = diff.changedProperties();
-    const auto current = readLatest(type, diff.identifier());
-    if (current.identifier().isEmpty()) {
-        SinkWarningCtx(d->logCtx) << "Failed to read current version: " << diff.identifier();
-        return false;
-    }
    auto newEntity = *ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<ApplicationDomain::ApplicationDomainType>(current, current.availableProperties());
    SinkTraceCtx(d->logCtx) << "Modified entity: " << newEntity;
    // Apply diff
    //SinkTrace() << "Applying changed properties: " << changeset;
-    for (const auto &property : changeset) {
+    for (const auto &property : diff.changedProperties()) {
        const auto value = diff.getProperty(property);
        if (value.isValid()) {
            //SinkTrace() << "Setting property: " << property;
@@ -237,8 +226,25 @@ bool EntityStore::modify(const QByteArray &type, const ApplicationDomain::Applic
        //SinkTrace() << "Removing property: " << property;
        newEntity.setProperty(property, QVariant());
    }
+    return newEntity;
+}
+bool EntityStore::modify(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &diff, const QByteArrayList &deletions, bool replayToSource)
+{
+    const auto current = readLatest(type, diff.identifier());
+    if (current.identifier().isEmpty()) {
+        SinkWarningCtx(d->logCtx) << "Failed to read current version: " << diff.identifier();
+        return false;
+    }
+    auto newEntity = applyDiff(type, current, diff, deletions);
+    return modify(type, current, newEntity, replayToSource);
+}
+bool EntityStore::modify(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &current, ApplicationDomain::ApplicationDomainType newEntity, bool replayToSource)
+{
+    SinkTraceCtx(d->logCtx) << "Modified entity: " << newEntity;
-    preprocess(current, newEntity);
    d->typeIndex(type).remove(current.identifier(), current, d->transaction);
    d->typeIndex(type).add(newEntity.identifier(), newEntity, d->transaction);
@@ -250,7 +256,7 @@ bool EntityStore::modify(const QByteArray &type, const ApplicationDomain::Applic
    flatbuffers::FlatBufferBuilder metadataFbb;
    {
        //We add availableProperties to account for the properties that have been changed by the preprocessors
-        auto modifiedProperties = BufferUtils::toVector(metadataFbb, changeset + newEntity.changedProperties());
+        auto modifiedProperties = BufferUtils::toVector(metadataFbb, newEntity.changedProperties());
        auto metadataBuilder = MetadataBuilder(metadataFbb);
        metadataBuilder.add_revision(newRevision);
        metadataBuilder.add_operation(Operation_Modification);
@@ -259,7 +265,7 @@ bool EntityStore::modify(const QByteArray &type, const ApplicationDomain::Applic
        auto metadataBuffer = metadataBuilder.Finish();
        FinishMetadataBuffer(metadataFbb, metadataBuffer);
    }
-    SinkTraceCtx(d->logCtx) << "Changed properties: " << changeset + newEntity.changedProperties();
+    SinkTraceCtx(d->logCtx) << "Changed properties: " << newEntity.changedProperties();
    newEntity.setChangedProperties(newEntity.availableProperties().toSet());
@@ -275,36 +281,14 @@ bool EntityStore::modify(const QByteArray &type, const ApplicationDomain::Applic
    return true;
 }
-bool EntityStore::remove(const QByteArray &type, const QByteArray &uid, bool replayToSource, const PreprocessRemoval &preprocess)
+bool EntityStore::remove(const QByteArray &type, const Sink::ApplicationDomain::ApplicationDomainType &current, bool replayToSource)
 {
-    bool found = false;
+    const auto uid = current.identifier();
-    bool alreadyRemoved = false;
+    if (!exists(type, uid)) {
-    DataStore::mainDatabase(d->transaction, type)
-        .findLatest(uid,
-            [&found, &alreadyRemoved](const QByteArray &key, const QByteArray &data) -> bool {
-                auto entity = GetEntity(data.data());
-                if (entity && entity->metadata()) {
-                    auto metadata = GetMetadata(entity->metadata()->Data());
-                    found = true;
-                    if (metadata->operation() == Operation_Removal) {
-                        alreadyRemoved = true;
-                    }
-                }
-                return false;
-            },
-            [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to read old revision from storage: " << error.message; });
-    if (!found) {
-        SinkWarningCtx(d->logCtx) << "Remove: Failed to find entity " << uid;
-        return false;
-    }
-    if (alreadyRemoved) {
        SinkWarningCtx(d->logCtx) << "Remove: Entity is already removed " << uid;
        return false;
    }
-    const auto current = readLatest(type, uid);
-    preprocess(current);
    d->typeIndex(type).remove(current.identifier(), current, d->transaction);
    SinkTraceCtx(d->logCtx) << "Removed entity " << current;
@@ -328,6 +312,7 @@ bool EntityStore::remove(const QByteArray &type, const QByteArray &uid, bool rep
            [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to write entity" << uid << newRevision; });
    DataStore::setMaxRevision(d->transaction, newRevision);
    DataStore::recordRevision(d->transaction, newRevision, uid, type);
+    DataStore::removeUid(d->transaction, uid);
    return true;
 }
@@ -521,15 +506,9 @@ ApplicationDomain::ApplicationDomainType EntityStore::readEntity(const QByteArra
 void EntityStore::readAll(const QByteArray &type, const std::function<void(const ApplicationDomain::ApplicationDomainType &entity)> &callback)
 {
-    auto db = DataStore::mainDatabase(d->getTransaction(), type);
+    readAllUids(type, [&] (const QByteArray &uid) {
-    db.scan("",
+        readLatest(type, uid, callback);
-        [=](const QByteArray &key, const QByteArray &value) -> bool {
+    });
-            auto uid = DataStore::uidFromKey(key);
-            auto buffer = Sink::EntityBuffer{value.data(), value.size()};
-            callback(d->createApplicationDomainType(type, uid, DataStore::maxRevision(d->getTransaction()), buffer));
-            return true;
-        },
-        [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Error during query: " << error.message; });
 }
 void EntityStore::readRevisions(qint64 baseRevision, const QByteArray &expectedType, const std::function<void(const QByteArray &key)> &callback)
@@ -588,15 +567,7 @@ ApplicationDomain::ApplicationDomainType EntityStore::readPrevious(const QByteAr
 void EntityStore::readAllUids(const QByteArray &type, const std::function<void(const QByteArray &uid)> callback)
 {
-    //TODO use uid index instead
+    DataStore::getUids(d->getTransaction(), callback);
-    //FIXME we currently report each uid for every revision with the same uid
-    auto db = DataStore::mainDatabase(d->getTransaction(), type);
-    db.scan("",
-        [callback](const QByteArray &key, const QByteArray &) -> bool {
-            callback(Sink::Storage::DataStore::uidFromKey(key));
-            return true;
-        },
-        [&](const Sink::Storage::DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to read current value from storage: " << error.message; });
 }
 bool EntityStore::contains(const QByteArray &type, const QByteArray &uid)
@@ -604,6 +575,36 @@ bool EntityStore::contains(const QByteArray &type, const QByteArray &uid)
    return DataStore::mainDatabase(d->getTransaction(), type).contains(uid);
 }
+bool EntityStore::exists(const QByteArray &type, const QByteArray &uid)
+{
+    bool found = false;
+    bool alreadyRemoved = false;
+    DataStore::mainDatabase(d->transaction, type)
+        .findLatest(uid,
+            [&found, &alreadyRemoved](const QByteArray &key, const QByteArray &data) -> bool {
+                auto entity = GetEntity(data.data());
+                if (entity && entity->metadata()) {
+                    auto metadata = GetMetadata(entity->metadata()->Data());
+                    found = true;
+                    if (metadata->operation() == Operation_Removal) {
+                        alreadyRemoved = true;
+                    }
+                }
+                return false;
+            },
+            [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to read old revision from storage: " << error.message; });
+    if (!found) {
+        SinkTraceCtx(d->logCtx) << "Remove: Failed to find entity " << uid;
+        return false;
+    }
+    if (alreadyRemoved) {
+        SinkTraceCtx(d->logCtx) << "Remove: Entity is already removed " << uid;
+        return false;
+    }
+    return true;
+}
 qint64 EntityStore::maxRevision()
 {
    if (!d->exists()) {
diff --git a/common/storage/entitystore.h b/common/storage/entitystore.h
index 46410cd..00241f2 100644
--- a/common/storage/entitystore.h
+++ b/common/storage/entitystore.h
@@ -38,15 +38,13 @@ public:
    typedef QSharedPointer<EntityStore> Ptr;
    EntityStore(const ResourceContext &resourceContext, const Sink::Log::Context &);
-    typedef std::function<void(const ApplicationDomain::ApplicationDomainType &, ApplicationDomain::ApplicationDomainType &)> PreprocessModification;
-    typedef std::function<void(ApplicationDomain::ApplicationDomainType &)> PreprocessCreation;
-    typedef std::function<void(const ApplicationDomain::ApplicationDomainType &)> PreprocessRemoval;
    //Only the pipeline may call the following functions outside of tests
-    bool add(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &, bool replayToSource, const PreprocessCreation &);
+    bool add(const QByteArray &type, ApplicationDomain::ApplicationDomainType newEntity, bool replayToSource);
-    bool modify(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &, const QByteArrayList &deletions, bool replayToSource, const PreprocessModification &);
+    bool modify(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &diff, const QByteArrayList &deletions, bool replayToSource);
-    bool remove(const QByteArray &type, const QByteArray &uid, bool replayToSource, const PreprocessRemoval &);
+    bool modify(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &current, ApplicationDomain::ApplicationDomainType newEntity, bool replayToSource);
+    bool remove(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &current, bool replayToSource);
    bool cleanupRevisions(qint64 revision);
+    ApplicationDomain::ApplicationDomainType applyDiff(const QByteArray &type, const ApplicationDomain::ApplicationDomainType &current, const ApplicationDomain::ApplicationDomainType &diff, const QByteArrayList &deletions) const;
    void startTransaction(Sink::Storage::DataStore::AccessMode);
    void commitTransaction();
@@ -105,8 +103,12 @@ public:
    void readRevisions(qint64 baseRevision, const QByteArray &type, const std::function<void(const QByteArray &key)> &callback);
+    ///Db contains entity (but may already be marked as removed
    bool contains(const QByteArray &type, const QByteArray &uid);
+    ///Db contains entity and entity is not yet removed
+    bool exists(const QByteArray &type, const QByteArray &uid);
    qint64 maxRevision();
    Sink::Log::Context logContext() const;
diff --git a/common/storage_common.cpp b/common/storage_common.cpp
index d8b1f42..81a38c7 100644
--- a/common/storage_common.cpp
+++ b/common/storage_common.cpp
@@ -28,7 +28,7 @@ SINK_DEBUG_AREA("storage")
 QDebug& operator<<(QDebug &dbg, const Sink::Storage::DataStore::Error &error)
 {
-    dbg << error.message;
+    dbg << error.message << "Code: " << error.code << "Db: " << error.store;
    return dbg;
 }
@@ -146,6 +146,24 @@ void DataStore::removeRevision(DataStore::Transaction &transaction, qint64 revis
    transaction.openDatabase("revisionType").remove(QByteArray::number(revision));
 }
+void DataStore::recordUid(DataStore::Transaction &transaction, const QByteArray &uid)
+{
+    transaction.openDatabase("uids").write(uid, "");
+}
+void DataStore::removeUid(DataStore::Transaction &transaction, const QByteArray &uid)
+{
+    transaction.openDatabase("uids").remove(uid);
+}
+void DataStore::getUids(const Transaction &transaction, const std::function<void(const QByteArray &uid)> &callback)
+{
+    transaction.openDatabase("uids").scan("", [&] (const QByteArray &key, const QByteArray &) {
+        callback(key);
+        return true;
+    });
+}
 bool DataStore::isInternalKey(const char *key)
 {
    return key && strncmp(key, s_internalPrefix, s_internalPrefixSize) == 0;
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index ed385ad..08eea37 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -62,6 +62,44 @@ int getErrorCode(int e)
    return -1;
 }
+static QList<QByteArray> getDatabaseNames(MDB_txn *transaction)
+{
+    if (!transaction) {
+        SinkWarning() << "Invalid transaction";
+        return QList<QByteArray>();
+    }
+    int rc;
+    QList<QByteArray> list;
+    MDB_dbi dbi;
+    if ((rc = mdb_dbi_open(transaction, nullptr, 0, &dbi) == 0)) {
+        MDB_val key;
+        MDB_val data;
+        MDB_cursor *cursor;
+        mdb_cursor_open(transaction, dbi, &cursor);
+        if ((rc = mdb_cursor_get(cursor, &key, &data, MDB_FIRST)) == 0) {
+            list << QByteArray::fromRawData((char *)key.mv_data, key.mv_size);
+            while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
+                list << QByteArray::fromRawData((char *)key.mv_data, key.mv_size);
+            }
+        } else {
+            //Normal if we don't have any databases yet
+            if (rc == MDB_NOTFOUND) {
+                rc = 0;
+            }
+            if (rc) {
+                SinkWarning() << "Failed to get a value" << rc;
+            }
+        }
+        mdb_cursor_close(cursor);
+    } else {
+        SinkWarning() << "Failed to open db" << rc << QByteArray(mdb_strerror(rc));
+    }
+    return list;
+}
 class DataStore::NamedDatabase::Private
 {
 public:
@@ -93,6 +131,18 @@ public:
        const auto dbiName = name + db;
        if (sDbis.contains(dbiName)) {
            dbi = sDbis.value(dbiName);
+            //sDbis can contain dbi's that are not available to this transaction.
+            //We use mdb_dbi_flags to check if the dbi is valid for this transaction.
+            uint f;
+            if (mdb_dbi_flags(transaction, dbi, &f) == EINVAL) {
+                //In readonly mode we can just ignore this. In read-write we would have tried to concurrently create a db.
+                if (!readOnly) {
+                    SinkWarning() << "Tried to create database in second transaction: " << dbiName;
+                }
+                dbi = 0;
+                transaction = 0;
+                return false;
+            }
        } else {
            MDB_dbi flagtableDbi;
            if (const int rc = mdb_dbi_open(transaction, "__flagtable", readOnly ? 0 : MDB_CREATE, &flagtableDbi)) {
@@ -279,7 +329,8 @@ int DataStore::NamedDatabase::scan(const QByteArray &k, const std::function<bool
    rc = mdb_cursor_open(d->transaction, d->dbi, &cursor);
    if (rc) {
-        Error error(d->name.toLatin1() + d->db, getErrorCode(rc), QByteArray("Error during mdb_cursor open: ") + QByteArray(mdb_strerror(rc)));
+        //Invalid arguments can mean that the transaction doesn't contain the db dbi
+        Error error(d->name.toLatin1() + d->db, getErrorCode(rc), QByteArray("Error during mdb_cursor_open: ") + QByteArray(mdb_strerror(rc)) + ". Key: " + k);
        errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
        return 0;
    }
@@ -447,7 +498,6 @@ public:
    MDB_env *env;
    MDB_txn *transaction;
-    MDB_dbi dbi;
    bool requestedRead;
    std::function<void(const DataStore::Error &error)> defaultErrorHandler;
    QString name;
@@ -578,8 +628,7 @@ static bool ensureCorrectDb(DataStore::NamedDatabase &database, const QByteArray
        }
        return false;
    },
-    [](const DataStore::Error &error) -> bool{
+    [&](const DataStore::Error &) {
-        return false;
    }, false);
    //This is the first time we open this database in a write transaction, write the db name
    if (!count) {
@@ -637,35 +686,8 @@ QList<QByteArray> DataStore::Transaction::getDatabaseNames() const
        SinkWarning() << "Invalid transaction";
        return QList<QByteArray>();
    }
+    return Sink::Storage::getDatabaseNames(d->transaction);
-    int rc;
-    QList<QByteArray> list;
-    Q_ASSERT(d->transaction);
-    if ((rc = mdb_dbi_open(d->transaction, nullptr, 0, &d->dbi) == 0)) {
-        MDB_val key;
-        MDB_val data;
-        MDB_cursor *cursor;
-        mdb_cursor_open(d->transaction, d->dbi, &cursor);
-        if ((rc = mdb_cursor_get(cursor, &key, &data, MDB_FIRST)) == 0) {
-            list << QByteArray::fromRawData((char *)key.mv_data, key.mv_size);
-            while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
-                list << QByteArray::fromRawData((char *)key.mv_data, key.mv_size);
-            }
-        } else {
-            //Normal if we don't have any databases yet
-            if (rc == MDB_NOTFOUND) {
-                rc = 0;
-            }
-            if (rc) {
-                SinkWarning() << "Failed to get a value" << rc;
-            }
-        }
-        mdb_cursor_close(cursor);
-    } else {
-        SinkWarning() << "Failed to open db" << rc << QByteArray(mdb_strerror(rc));
-    }
-    return list;
 }
diff --git a/common/store.cpp b/common/store.cpp
index 1c8620b..d266098 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -92,6 +92,7 @@ QPair<typename AggregatingResultEmitter<typename DomainType::Ptr>::Ptr,  typenam
        auto facade = FacadeFactory::instance().getFacade<ApplicationDomain::SinkResource>();
        Q_ASSERT(facade);
        Sink::Query resourceQuery;
+        resourceQuery.request<ApplicationDomain::SinkResource::Capabilities>();
        if (query.liveQuery()) {
            SinkTraceCtx(ctx) << "Listening for new resources.";
            resourceQuery.setFlags(Query::LiveQuery);
@@ -103,6 +104,7 @@ QPair<typename AggregatingResultEmitter<typename DomainType::Ptr>::Ptr,  typenam
            resourceFilter.propertyFilter.insert(ApplicationDomain::SinkResource::Capabilities::name, Query::Comparator{ApplicationDomain::getTypeName<DomainType>(), Query::Comparator::Contains});
        }
        resourceQuery.setFilter(resourceFilter);
+        resourceQuery.requestedProperties << resourceFilter.propertyFilter.keys();
        auto result = facade->load(resourceQuery, resourceCtx);
        auto emitter = result.second;
@@ -249,7 +251,7 @@ KAsync::Job<void> Store::remove(const Sink::Query &query)
 KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
 {
    // All databases are going to become invalid, nuke the environments
-    // TODO: all clients should react to a notification the resource
+    // TODO: all clients should react to a notification from the resource
    Sink::Storage::DataStore::clearEnv();
    SinkTrace() << "Remove data from disk " << identifier;
    auto time = QSharedPointer<QTime>::create();
@@ -277,18 +279,18 @@ KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
 static KAsync::Job<void> synchronize(const QByteArray &resource, const Sink::SyncScope &scope)
 {
-    SinkLog() << "Synchronizing " << resource;
+    SinkLog() << "Synchronizing " << resource << scope;
    auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource, ResourceConfig::getResourceType(resource));
    return resourceAccess->synchronizeResource(scope)
        .addToContext(resourceAccess)
-        .then<void>([](const KAsync::Error &error) {
+        .then([=](const KAsync::Error &error) {
-                if (error) {
+            if (error) {
-                    SinkWarning() << "Error during sync.";
+                SinkWarning() << "Error during sync.";
-                    return KAsync::error<void>(error);
+                return KAsync::error(error);
-                }
+            }
-                SinkTrace() << "synced.";
+            SinkTrace() << "Synchronization of resource " << resource << " complete.";
-                return KAsync::null<void>();
+            return KAsync::null();
-            });
+        });
 }
 KAsync::Job<void> Store::synchronize(const Sink::Query &query)
diff --git a/common/store.h b/common/store.h
index 86e4d20..fae76e5 100644
--- a/common/store.h
+++ b/common/store.h
@@ -48,11 +48,15 @@ QString SINK_EXPORT storageLocation();
 */
 QString SINK_EXPORT getTemporaryFilePath();
+// Must be the same as in ModelResult
 enum Roles
 {
-    DomainObjectRole = Qt::UserRole + 1, // Must be the same as in ModelResult
+    DomainObjectRole = Qt::UserRole + 1,
    ChildrenFetchedRole,
-    DomainObjectBaseRole
+    DomainObjectBaseRole,
+    StatusRole, //ApplicationDomain::SyncStatus
+    WarningRole, //ApplicationDomain::Warning, only if status == warning || status == error
+    ProgressRole //ApplicationDomain::Progress
 };
 /**
diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index b147615..3e7bd30 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -33,13 +33,14 @@
 using namespace Sink;
 Synchronizer::Synchronizer(const Sink::ResourceContext &context)
-    : ChangeReplay(context),
+    : ChangeReplay(context, {"synchronizer"}),
    mLogCtx{"synchronizer"},
    mResourceContext(context),
    mEntityStore(Storage::EntityStore::Ptr::create(mResourceContext, mLogCtx)),
    mSyncStorage(Sink::storageLocation(), mResourceContext.instanceId() + ".synchronization", Sink::Storage::DataStore::DataStore::ReadWrite),
    mSyncInProgress(false)
 {
+    mCurrentState.push(ApplicationDomain::Status::OfflineStatus);
    SinkTraceCtx(mLogCtx) << "Starting synchronizer: " << mResourceContext.resourceType << mResourceContext.instanceId();
 }
@@ -252,15 +253,21 @@ void Synchronizer::modify(const DomainType &entity, const QByteArray &newResourc
 QList<Synchronizer::SyncRequest> Synchronizer::getSyncRequests(const Sink::QueryBase &query)
 {
-    QList<Synchronizer::SyncRequest> list;
+    return QList<Synchronizer::SyncRequest>() << Synchronizer::SyncRequest{query, "sync"};
-    list << Synchronizer::SyncRequest{query, "sync"};
+}
-    return list;
+void Synchronizer::mergeIntoQueue(const Synchronizer::SyncRequest &request, QList<Synchronizer::SyncRequest> &queue)
+{
+    mSyncRequestQueue << request;
 }
 void Synchronizer::synchronize(const Sink::QueryBase &query)
 {
    SinkTraceCtx(mLogCtx) << "Synchronizing";
-    mSyncRequestQueue << getSyncRequests(query);
+    auto newRequests = getSyncRequests(query);
+    for (const auto &request: newRequests) {
+        mergeIntoQueue(request, mSyncRequestQueue);
+    }
    processSyncQueue().exec();
 }
@@ -286,6 +293,42 @@ void Synchronizer::flushComplete(const QByteArray &flushId)
    }
 }
+void Synchronizer::emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id, const QByteArrayList &entities)
+{
+    Sink::Notification n;
+    n.id = id;
+    n.type = type;
+    n.message = message;
+    n.code = code;
+    n.entities = entities;
+    emit notify(n);
+}
+void Synchronizer::reportProgress(int progress, int total)
+{
+    SinkLogCtx(mLogCtx) << "Progress: " << progress << " out of " << total;
+}
+void Synchronizer::setStatusFromResult(const KAsync::Error &error, const QString &s, const QByteArray &requestId)
+{
+    if (error) {
+        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::ConfigurationError) {
+            //There is an error with the configuration.
+            setStatus(ApplicationDomain::ErrorStatus, s, requestId);
+        } else if (error.errorCode == ApplicationDomain::LoginError) {
+            //If we failed to login altough we could connect that indicates a problem with our setup.
+            setStatus(ApplicationDomain::ErrorStatus, s, requestId);
+        }
+        //We don't know what kind of error this was, so we assume it's transient and don't change ou status.
+    } else {
+        //An operation against the server worked, so we're probably online.
+        setStatus(ApplicationDomain::ConnectedStatus, s, requestId);
+    }
+}
 KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
 {
    if (request.options & SyncRequest::RequestFlush) {
@@ -310,35 +353,21 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
        });
    } else if (request.requestType == Synchronizer::SyncRequest::Synchronization) {
        return KAsync::start([this, request] {
-            Sink::Notification n;
-            n.id = request.requestId;
-            n.type = Notification::Status;
-            n.message = "Synchronization has started.";
-            n.code = ApplicationDomain::BusyStatus;
-            emit notify(n);
            SinkLogCtx(mLogCtx) << "Synchronizing: " << request.query;
+            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.
            commit();
        }).then<void>([this, request](const KAsync::Error &error) {
+            setStatusFromResult(error, "Synchronization has ended.", request.requestId);
            if (error) {
                //Emit notification with error
-                SinkWarningCtx(mLogCtx) << "Synchronization failed: " << error.errorMessage;
+                SinkWarningCtx(mLogCtx) << "Synchronization failed: " << error;
-                Sink::Notification n;
+                emitNotification(Notification::Warning, ApplicationDomain::SyncError, {}, {}, request.applicableEntities);
-                n.id = request.requestId;
-                n.type = Notification::Status;
-                n.message = "Synchronization has ended.";
-                n.code = ApplicationDomain::ErrorStatus;
-                emit notify(n);
                return KAsync::error(error);
            } else {
                SinkLogCtx(mLogCtx) << "Done Synchronizing";
-                Sink::Notification n;
+                emitNotification(Notification::Info, ApplicationDomain::SyncSuccess, {}, {}, request.applicableEntities);
-                n.id = request.requestId;
-                n.type = Notification::Status;
-                n.message = "Synchronization has ended.";
-                n.code = ApplicationDomain::ConnectedStatus;
-                emit notify(n);
                return KAsync::null();
            }
        });
@@ -347,11 +376,8 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
            Q_ASSERT(!request.requestId.isEmpty());
            //FIXME it looks like this is emitted before the replay actually finishes
            if (request.flushType == Flush::FlushReplayQueue) {
-                SinkTraceCtx(mLogCtx) << "Emitting flush completion.";
+                SinkTraceCtx(mLogCtx) << "Emitting flush completion: " << request.requestId;
-                Sink::Notification n;
+                emitNotification(Notification::FlushCompletion, 0, "", request.requestId);
-                n.type = Sink::Notification::FlushCompletion;
-                n.id = request.requestId;
-                emit notify(n);
            } else {
                flatbuffers::FlatBufferBuilder fbb;
                auto flushId = fbb.CreateString(request.requestId.toStdString());
@@ -361,7 +387,24 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
            }
        });
    } else if (request.requestType == Synchronizer::SyncRequest::ChangeReplay) {
-        return replayNextRevision();
+        if (ChangeReplay::allChangesReplayed()) {
+            return KAsync::null();
+        } else {
+            return KAsync::start([this, request] {
+                SinkLogCtx(mLogCtx) << "Replaying changes.";
+            })
+            .then(replayNextRevision())
+            .then<void>([this, request](const KAsync::Error &error) {
+                setStatusFromResult(error, "Changereplay has ended.", "changereplay");
+                if (error) {
+                    SinkWarningCtx(mLogCtx) << "Changereplay failed: " << error.errorMessage;
+                    return KAsync::error(error);
+                } else {
+                    SinkLogCtx(mLogCtx) << "Done replaying changes";
+                    return KAsync::null();
+                }
+            });
+        }
    } else {
        SinkWarningCtx(mLogCtx) << "Unknown request type: " << request.requestType;
        return KAsync::error(KAsync::Error{"Unknown request type."});
@@ -369,6 +412,34 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
 }
+void Synchronizer::setStatus(ApplicationDomain::Status state, const QString &reason, const QByteArray requestId)
+{
+    if (state != mCurrentState.top()) {
+        if (mCurrentState.top() == ApplicationDomain::BusyStatus) {
+            mCurrentState.pop();
+        }
+        mCurrentState.push(state);
+        emitNotification(Notification::Status, state, reason, requestId);
+    }
+}
+void Synchronizer::resetStatus(const QByteArray requestId)
+{
+    mCurrentState.pop();
+    emitNotification(Notification::Status, mCurrentState.top(), {}, requestId);
+}
+void Synchronizer::setBusy(bool busy, const QString &reason, const QByteArray requestId)
+{
+    if (busy) {
+        setStatus(ApplicationDomain::BusyStatus, reason, requestId);
+    } else {
+        if (mCurrentState.top() == ApplicationDomain::BusyStatus) {
+            resetStatus(requestId);
+        }
+    }
+}
 KAsync::Job<void> Synchronizer::processSyncQueue()
 {
    if (mSyncRequestQueue.isEmpty()) {
@@ -387,14 +458,20 @@ KAsync::Job<void> Synchronizer::processSyncQueue()
    }
    const auto request = mSyncRequestQueue.takeFirst();
-    return KAsync::start([this] {
+    return KAsync::start([=] {
        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");
+        }
    })
    .then(processRequest(request))
-    .then<void>([this](const KAsync::Error &error) {
+    .then<void>([this, request](const KAsync::Error &error) {
        SinkTraceCtx(mLogCtx) << "Sync request processed";
+        setBusy(false, {}, request.requestId);
        mEntityStore->abortTransaction();
        mSyncTransaction.abort();
        mMessageQueue->commit();
@@ -404,8 +481,8 @@ KAsync::Job<void> Synchronizer::processSyncQueue()
            emit changesReplayed();
        }
        if (error) {
-            SinkWarningCtx(mLogCtx) << "Error during sync: " << error.errorMessage;
+            SinkWarningCtx(mLogCtx) << "Error during sync: " << error;
-            return KAsync::error(error);
+            emitNotification(Notification::Error, error.errorCode, error.errorMessage, request.requestId);
        }
        //In case we got more requests meanwhile.
        return processSyncQueue();
@@ -499,6 +576,12 @@ KAsync::Job<void> Synchronizer::replay(const QByteArray &type, const QByteArray
    } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
        auto mail = store().readEntity<ApplicationDomain::Mail>(key);
        job = replay(mail, operation, oldRemoteId, modifiedProperties);
+    } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Contact>()) {
+        auto mail = store().readEntity<ApplicationDomain::Contact>(key);
+        job = replay(mail, operation, oldRemoteId, modifiedProperties);
+    } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Addressbook>()) {
+        auto mail = store().readEntity<ApplicationDomain::Addressbook>(key);
+        job = replay(mail, operation, oldRemoteId, modifiedProperties);
    } else {
        SinkErrorCtx(mLogCtx) << "Replayed unknown type: " << type;
    }
@@ -506,21 +589,19 @@ KAsync::Job<void> Synchronizer::replay(const QByteArray &type, const QByteArray
    return job.then([this, operation, type, uid, oldRemoteId](const QByteArray &remoteId) {
        if (operation == Sink::Operation_Creation) {
            SinkTraceCtx(mLogCtx) << "Replayed creation with remote id: " << remoteId;
-            if (remoteId.isEmpty()) {
+            if (!remoteId.isEmpty()) {
-                SinkWarningCtx(mLogCtx) << "Returned an empty remoteId from the creation";
-            } else {
                syncStore().recordRemoteId(type, uid, remoteId);
            }
        } else if (operation == Sink::Operation_Modification) {
            SinkTraceCtx(mLogCtx) << "Replayed modification with remote id: " << remoteId;
-            if (remoteId.isEmpty()) {
+            if (!remoteId.isEmpty()) {
-                SinkWarningCtx(mLogCtx) << "Returned an empty remoteId from the modification";
-            } else {
               syncStore().updateRemoteId(type, uid, remoteId);
            }
        } else if (operation == Sink::Operation_Removal) {
            SinkTraceCtx(mLogCtx) << "Replayed removal with remote id: " << oldRemoteId;
-            syncStore().removeRemoteId(type, uid, oldRemoteId);
+            if (!oldRemoteId.isEmpty()) {
+                syncStore().removeRemoteId(type, uid, oldRemoteId);
+            }
        } else {
            SinkErrorCtx(mLogCtx) << "Unkown operation" << operation;
        }
@@ -539,6 +620,11 @@ KAsync::Job<QByteArray> Synchronizer::replay(const ApplicationDomain::Contact &,
    return KAsync::null<QByteArray>();
 }
+KAsync::Job<QByteArray> Synchronizer::replay(const ApplicationDomain::Addressbook &, Sink::Operation, const QByteArray &, const QList<QByteArray> &)
+{
+    return KAsync::null<QByteArray>();
+}
 KAsync::Job<QByteArray> Synchronizer::replay(const ApplicationDomain::Mail &, Sink::Operation, const QByteArray &, const QList<QByteArray> &)
 {
    return KAsync::null<QByteArray>();
diff --git a/common/synchronizer.h b/common/synchronizer.h
index 120a8a5..b1ee122 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -21,6 +21,7 @@
 #include "sink_export.h"
 #include <QObject>
+#include <QStack>
 #include <KAsync/Async>
 #include <domainadaptor.h>
 #include <query.h>
@@ -73,9 +74,9 @@ protected:
 protected:
    ///Implement to write back changes to the server
    virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Contact &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
+    virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Addressbook &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
    virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Mail &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
    virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Folder &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
 protected:
    ///Calls the callback to enqueue the command
    void enqueueCommand(int commandId, const QByteArray &data);
@@ -134,7 +135,8 @@ protected:
            : requestId(requestId_),
            requestType(Synchronization),
            options(o),
-            query(q)
+            query(q),
+            applicableEntities(q.ids())
        {
        }
@@ -155,6 +157,7 @@ protected:
        RequestType requestType;
        RequestOptions options = NoOptions;
        Sink::QueryBase query;
+        QByteArrayList applicableEntities;
    };
    /**
@@ -175,9 +178,28 @@ protected:
     */
    virtual QList<Synchronizer::SyncRequest> getSyncRequests(const Sink::QueryBase &query);
+    /**
+     * This allows the synchronizer to merge new requests with existing requests in the queue.
+     */
+    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{});
+    /**
+     * Report progress for current task
+     */
+    void reportProgress(int progress, int total);
 protected:
    Sink::Log::Context mLogCtx;
 private:
+    QStack<ApplicationDomain::Status> mCurrentState;
+    void setStatusFromResult(const KAsync::Error &error, const QString &s, const QByteArray &requestId);
+    void setStatus(ApplicationDomain::Status busy, const QString &reason, const QByteArray requestId);
+    void resetStatus(const QByteArray requestId);
+    void setBusy(bool busy, const QString &reason, const QByteArray requestId);
    void modifyIfChanged(Storage::EntityStore &store, const QByteArray &bufferType, const QByteArray &sinkId, const Sink::ApplicationDomain::ApplicationDomainType &entity);
    KAsync::Job<void> processRequest(const SyncRequest &request);
    KAsync::Job<void> processSyncQueue();
diff --git a/common/synchronizerstore.cpp b/common/synchronizerstore.cpp
index dea4821..5364094 100644
--- a/common/synchronizerstore.cpp
+++ b/common/synchronizerstore.cpp
@@ -73,7 +73,8 @@ QByteArray SynchronizerStore::resolveLocalId(const QByteArray &bufferType, const
 {
    QByteArray remoteId = Index("localid.mapping." + bufferType, mTransaction).lookup(localId);
    if (remoteId.isEmpty()) {
-        SinkWarning() << "Couldn't find the remote id for " << bufferType << localId;
+        //This can happen if we didn't store the remote id in the first place
+        SinkTrace() << "Couldn't find the remote id for " << bufferType << localId;
        return QByteArray();
    }
    return remoteId;
diff --git a/common/typeindex.cpp b/common/typeindex.cpp
index 5589e13..153aa43 100644
--- a/common/typeindex.cpp
+++ b/common/typeindex.cpp
@@ -190,7 +190,7 @@ static QVector<QByteArray> indexLookup(Index &index, QueryBase::Comparator filte
    for (const auto &lookupKey : lookupKeys) {
        index.lookup(lookupKey, [&](const QByteArray &value) { keys << value; },
-            [lookupKey](const Index::Error &error) { SinkWarning() << "Error in index: " << error.message << lookupKey; }, true);
+            [lookupKey](const Index::Error &error) { SinkWarning() << "Lookup error in index: " << error.message << lookupKey; }, true);
    }
    return keys;
 }
@@ -272,7 +272,7 @@ QVector<QByteArray> TypeIndex::secondaryLookup<QByteArray>(const QByteArray &lef
    Index index(indexName(leftName + rightName), *mTransaction);
    const auto lookupKey = getByteArray(value);
    index.lookup(
-        lookupKey, [&](const QByteArray &value) { keys << value; }, [=](const Index::Error &error) { SinkWarning() << "Error in index: " << error.message << value; });
+        lookupKey, [&](const QByteArray &value) { keys << value; }, [=](const Index::Error &error) { SinkWarning() << "Lookup error in secondary index: " << error.message << value << lookupKey; });
    return keys;
 }
@@ -284,7 +284,7 @@ QVector<QByteArray> TypeIndex::secondaryLookup<QString>(const QByteArray &leftNa
    Index index(indexName(leftName + rightName), *mTransaction);
    const auto lookupKey = getByteArray(value);
    index.lookup(
-        lookupKey, [&](const QByteArray &value) { keys << value; }, [=](const Index::Error &error) { SinkWarning() << "Error in index: " << error.message << value; });
+        lookupKey, [&](const QByteArray &value) { keys << value; }, [=](const Index::Error &error) { SinkWarning() << "Lookup error in secondary index: " << error.message << value << lookupKey; });
    return keys;
 }