57 files changed, 941 insertions, 659 deletions
diff --git a/common/bufferadaptor.h b/common/bufferadaptor.h
index fd4809b..f393388 100644
--- a/common/bufferadaptor.h
+++ b/common/bufferadaptor.h
@@ -66,8 +66,7 @@ public:
    virtual QVariant getProperty(const QByteArray &key) const
    {
        if (!mValues.contains(key)) {
-            qWarning() << "Tried to read value that is not available; Did you forget to call Query::request? Property: " << key;
+            return {};
-            return QVariant{};
        }
        return mValues.value(key);
    }
diff --git a/common/bufferutils.h b/common/bufferutils.h
index 6763ced..f0460b7 100644
--- a/common/bufferutils.h
+++ b/common/bufferutils.h
@@ -38,7 +38,7 @@ static flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::
 {
    std::vector<flatbuffers::Offset<flatbuffers::String>> modifiedPropertiesList;
    for (const auto &change : list) {
-        auto s = fbb.CreateString(change);
+        auto s = fbb.CreateString(change.toStdString());
        modifiedPropertiesList.push_back(s);
    }
    return fbb.CreateVector(modifiedPropertiesList);
diff --git a/common/changereplay.cpp b/common/changereplay.cpp
index 7895b66..0adbd78 100644
--- a/common/changereplay.cpp
+++ b/common/changereplay.cpp
@@ -30,8 +30,7 @@ using namespace Sink;
 using namespace Sink::Storage;
 ChangeReplay::ChangeReplay(const ResourceContext &resourceContext, const Sink::Log::Context &ctx)
-    : mStorage(storageLocation(), resourceContext.instanceId(), DataStore::ReadOnly), mChangeReplayStore(storageLocation(), resourceContext.instanceId() + ".changereplay", DataStore::ReadWrite), mReplayInProgress(false), mLogCtx{ctx.subContext("changereplay")},
+    : mStorage(storageLocation(), resourceContext.instanceId(), DataStore::ReadOnly), mChangeReplayStore(storageLocation(), resourceContext.instanceId() + ".changereplay", DataStore::ReadWrite), mReplayInProgress(false), mLogCtx{ctx.subContext("changereplay")}
-    mGuard{new QObject}
 {
 }
@@ -84,6 +83,8 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
            auto replayStoreTransaction = mChangeReplayStore.createTransaction(DataStore::ReadOnly, [this](const DataStore::Error &error) {
                SinkWarningCtx(mLogCtx) << error.message;
            });
+            Q_ASSERT(mMainStoreTransaction);
+            Q_ASSERT(replayStoreTransaction);
            replayStoreTransaction.openDatabase().scan("lastReplayedRevision",
                [lastReplayedRevision](const QByteArray &key, const QByteArray &value) -> bool {
                    *lastReplayedRevision = value.toLongLong();
@@ -98,16 +99,13 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
            SinkTraceCtx(mLogCtx) << "Changereplay from " << *lastReplayedRevision << " to " << *topRevision;
            return KAsync::doWhile(
                [this, lastReplayedRevision, topRevision]() -> KAsync::Job<KAsync::ControlFlowFlag> {
-                    if (!mGuard) {
-                        SinkTraceCtx(mLogCtx) << "Exit due to guard";
-                        return KAsync::value(KAsync::Break);
-                    }
                    if (*lastReplayedRevision >= *topRevision) {
                        SinkTraceCtx(mLogCtx) << "Done replaying" << *lastReplayedRevision << *topRevision;
                        return KAsync::value(KAsync::Break);
                    }
+                    Q_ASSERT(mMainStoreTransaction);
-                    KAsync::Job<void> replayJob = KAsync::null<void>();
+                    auto replayJob = KAsync::null();
                    qint64 revision = *lastReplayedRevision + 1;
                    while (revision <= *topRevision) {
                        const auto uid = DataStore::getUidFromRevision(mMainStoreTransaction, revision);
@@ -131,14 +129,14 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
                                if (canReplay(type, key, entityBuffer)) {
                                    SinkTraceCtx(mLogCtx) << "Replaying " << key;
                                    replayJob = replay(type, key, entityBuffer);
+                                    //Set the last revision we tried to replay
+                                    *lastReplayedRevision = revision;
+                                    //Execute replay job and commit
+                                    break;
                                } else {
-                                    SinkTraceCtx(mLogCtx) << "Cannot replay " << key;
+                                    SinkTraceCtx(mLogCtx) << "Not replaying " << key;
                                    //We silently skip over revisions that cannot be replayed, as this is not an error.
-                                    replayJob = KAsync::null();
                                }
-                                //Set the last revision we tried to replay
-                                *lastReplayedRevision = revision;
-                                break;
                            }
                        }
                        //Bump the revision if we failed to even attempt to replay. This will simply skip over those revisions, as we can't recover from those situations.
@@ -149,22 +147,22 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
                        if (error) {
                            SinkWarningCtx(mLogCtx) << "Change replay failed: " << error  << "Last replayed revision: "  << *lastReplayedRevision;
                            //We're probably not online or so, so postpone retrying
-                            return KAsync::value(KAsync::Break);
+                            return KAsync::value(KAsync::Break).then(KAsync::error<KAsync::ControlFlowFlag>(error));
+                        }
+                        SinkTraceCtx(mLogCtx) << "Replayed until: " << *lastReplayedRevision;
+                        recordReplayedRevision(*lastReplayedRevision);
+                        reportProgress(*lastReplayedRevision, *topRevision);
+                        const bool gotMoreToReplay = (*lastReplayedRevision < *topRevision);
+                        if (gotMoreToReplay) {
+                            SinkTraceCtx(mLogCtx) << "Replaying some more...";
+                            //Replay more if we have more
+                            return KAsync::wait(0).then(KAsync::value(KAsync::Continue));
                        } else {
-                            SinkTraceCtx(mLogCtx) << "Replayed until: " << *lastReplayedRevision;
+                            return KAsync::value(KAsync::Break);
-                            recordReplayedRevision(*lastReplayedRevision);
-                            if (*lastReplayedRevision < *topRevision) {
-                                SinkTraceCtx(mLogCtx) << "Replaying some more...";
-                                //Replay more if we have more
-                                return KAsync::wait(0).then(KAsync::value(KAsync::Continue));
-                            } else {
-                                return KAsync::value(KAsync::Break);
-                            }
                        }
-                        //We shouldn't ever get here
+                    }).guard(&mGuard);
-                        Q_ASSERT(false);
-                        return KAsync::value(KAsync::Break);
-                    });
            });
        })
        .then([this](const KAsync::Error &error) {
@@ -181,7 +179,12 @@ KAsync::Job<void> ChangeReplay::replayNextRevision()
                    emit changesReplayed();
                }
            }
-        });
+            if (error) {
+                return KAsync::error(error);
+            } else {
+                return KAsync::null();
+            }
+        }).guard(&mGuard);
 }
 void ChangeReplay::revisionChanged()
diff --git a/common/changereplay.h b/common/changereplay.h
index edc4462..22e26a5 100644
--- a/common/changereplay.h
+++ b/common/changereplay.h
@@ -54,6 +54,7 @@ public slots:
 protected:
    virtual KAsync::Job<void> replay(const QByteArray &type, const QByteArray &key, const QByteArray &value) = 0;
    virtual bool canReplay(const QByteArray &type, const QByteArray &key, const QByteArray &value) = 0;
+    virtual void reportProgress(int progress, int total, const QByteArrayList &applicableEntities = {}){};
    Sink::Storage::DataStore mStorage;
    KAsync::Job<void> replayNextRevision();
@@ -63,7 +64,7 @@ private:
    bool mReplayInProgress;
    Sink::Storage::DataStore::Transaction mMainStoreTransaction;
    Sink::Log::Context mLogCtx;
-    QSharedPointer<QObject> mGuard;
+    QObject mGuard;
 };
 class NullChangeReplay : public ChangeReplay
diff --git a/common/commands.cpp b/common/commands.cpp
index eeb7f08..24f2017 100644
--- a/common/commands.cpp
+++ b/common/commands.cpp
@@ -1,5 +1,6 @@
 /*
 * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
+ * Copyright (C) 2016 Christian Mollekopf <mollekopf@kolabsys.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -20,7 +21,7 @@
 #include "commands.h"
-#include <QIODevice>
+#include <QLocalSocket>
 #include <log.h>
 namespace Sink {
@@ -73,19 +74,19 @@ int headerSize()
    return sizeof(int) + (sizeof(uint) * 2);
 }
-void write(QIODevice *device, int messageId, int commandId)
+void write(QLocalSocket *device, int messageId, int commandId)
 {
    write(device, messageId, commandId, 0, 0);
 }
-static void write(QIODevice *device, const char *buffer, uint size)
+static void write(QLocalSocket *device, const char *buffer, uint size)
 {
    if (device->write(buffer, size) < 0) {
        SinkWarningCtx(Sink::Log::Context{"commands"}) << "Error while writing " << device->errorString();
    }
 }
-void write(QIODevice *device, int messageId, int commandId, const char *buffer, uint size)
+void write(QLocalSocket *device, int messageId, int commandId, const char *buffer, uint size)
 {
    if (size > 0 && !buffer) {
        size = 0;
@@ -97,15 +98,16 @@ void write(QIODevice *device, int messageId, int commandId, const char *buffer,
    if (buffer) {
        write(device, buffer, size);
    }
+    //The default implementation will happily buffer 200k bytes before sending it out which doesn't make the sytem exactly responsive.
+    //1k is arbitrary, but fits a bunch of messages at least.
+    if (device->bytesToWrite() > 1000) {
+        device->flush();
+    }
 }
-void write(QIODevice *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb)
+void write(QLocalSocket *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb)
 {
-    const int dataSize = fbb.GetSize();
+    write(device, messageId, commandId, (const char *)fbb.GetBufferPointer(), fbb.GetSize());
-    write(device, (const char *)&messageId, sizeof(int));
-    write(device, (const char *)&commandId, sizeof(int));
-    write(device, (const char *)&dataSize, sizeof(int));
-    write(device, (const char *)fbb.GetBufferPointer(), dataSize);
 }
 } // namespace Commands
diff --git a/common/commands.h b/common/commands.h
index 6d5d39b..1548eac 100644
--- a/common/commands.h
+++ b/common/commands.h
@@ -24,7 +24,7 @@
 #include <flatbuffers/flatbuffers.h>
 #include <QByteArray>
-class QIODevice;
+class QLocalSocket;
 namespace Sink {
@@ -55,9 +55,9 @@ enum CommandIds
 QByteArray name(int commandId);
 int SINK_EXPORT headerSize();
-void SINK_EXPORT write(QIODevice *device, int messageId, int commandId);
+void SINK_EXPORT write(QLocalSocket *device, int messageId, int commandId);
-void SINK_EXPORT write(QIODevice *device, int messageId, int commandId, const char *buffer, uint size);
+void SINK_EXPORT write(QLocalSocket *device, int messageId, int commandId, const char *buffer, uint size);
-void SINK_EXPORT write(QIODevice *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb);
+void SINK_EXPORT write(QLocalSocket *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb);
 }
 } // namespace Sink
diff --git a/common/commands/notification.fbs b/common/commands/notification.fbs
index 517111c..7ced666 100644
--- a/common/commands/notification.fbs
+++ b/common/commands/notification.fbs
@@ -5,6 +5,8 @@ table Notification {
    identifier: string; //An identifier that links back to the something related to the notification (e.g. a command id)
    message: string;
    code: int = 0; //See notification.h
+    progress: int = 0; //See notification.h
+    total: int = 0; //See notification.h
    entities: [string]; //A list of entities this applies to
 }
diff --git a/common/configstore.cpp b/common/configstore.cpp
index 1ae9da8..6751907 100644
--- a/common/configstore.cpp
+++ b/common/configstore.cpp
@@ -24,8 +24,6 @@
 #include <log.h>
 #include <definitions.h>
-SINK_DEBUG_AREA("configstore")
 static QSharedPointer<QSettings> getConfig(const QByteArray &identifier)
 {
    return QSharedPointer<QSettings>::create(Sink::configLocation() + "/" + identifier + ".ini", QSettings::IniFormat);
diff --git a/common/contactpreprocessor.cpp b/common/contactpreprocessor.cpp
index ac2c3bc..d331421 100644
--- a/common/contactpreprocessor.cpp
+++ b/common/contactpreprocessor.cpp
@@ -35,6 +35,8 @@ void updatedProperties(Sink::ApplicationDomain::Contact &contact, const KContact
        emails << Sink::ApplicationDomain::Contact::Email{Sink::ApplicationDomain::Contact::Email::Undefined, email};
    }
    contact.setEmails(emails);
+    contact.setPhoto(addressee.photo().rawData());
 }
 ContactPropertyExtractor::~ContactPropertyExtractor()
diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 2e0c348..4c95606 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -43,6 +43,8 @@ class Source : public FilterBase {
    QVector<QByteArray> mIds;
    QVector<QByteArray>::ConstIterator mIt;
+    QVector<QByteArray> mIncrementalIds;
+    QVector<QByteArray>::ConstIterator mIncrementalIt;
    Source (const QVector<QByteArray> &ids, DataStoreQuery *store)
        : FilterBase(store),
@@ -63,21 +65,36 @@ class Source : public FilterBase {
    void add(const QVector<QByteArray> &ids)
    {
-        mIds = ids;
+        mIncrementalIds = ids;
-        mIt = mIds.constBegin();
+        mIncrementalIt = mIncrementalIds.constBegin();
    }
    bool next(const std::function<void(const ResultSet::Result &result)> &callback) Q_DECL_OVERRIDE
    {
-        if (mIt == mIds.constEnd()) {
+        if (!mIncrementalIds.isEmpty()) {
-            return false;
+            if (mIncrementalIt == mIncrementalIds.constEnd()) {
+                return false;
+            }
+            readEntity(*mIncrementalIt, [this, callback](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                SinkTraceCtx(mDatastore->mLogCtx) << "Source: Read entity: " << entity.identifier() << operationName(operation);
+                callback({entity, operation});
+            });
+            mIncrementalIt++;
+            if (mIncrementalIt == mIncrementalIds.constEnd()) {
+                return false;
+            }
+            return true;
+        } else {
+            if (mIt == mIds.constEnd()) {
+                return false;
+            }
+            readEntity(*mIt, [this, callback](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                SinkTraceCtx(mDatastore->mLogCtx) << "Source: Read entity: " << entity.identifier() << operationName(operation);
+                callback({entity, operation});
+            });
+            mIt++;
+            return mIt != mIds.constEnd();
        }
-        readEntity(*mIt, [this, callback](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
-            SinkTraceCtx(mDatastore->mLogCtx) << "Source: Read entity: " << entity.identifier() << operationName(operation);
-            callback({entity, operation});
-        });
-        mIt++;
-        return mIt != mIds.constEnd();
    }
 };
@@ -599,6 +616,10 @@ ResultSet DataStoreQuery::update(qint64 baseRevision)
    return ResultSet(generator, [this]() { mCollector->skip(); });
 }
+void DataStoreQuery::updateComplete()
+{
+    mSource->mIncrementalIds.clear();
+}
 ResultSet DataStoreQuery::execute()
 {
diff --git a/common/datastorequery.h b/common/datastorequery.h
index ee5f99e..de4ae26 100644
--- a/common/datastorequery.h
+++ b/common/datastorequery.h
@@ -50,6 +50,7 @@ public:
    ~DataStoreQuery();
    ResultSet execute();
    ResultSet update(qint64 baseRevision);
+    void updateComplete();
    State::Ptr getState();
diff --git a/common/definitions.cpp b/common/definitions.cpp
index 3fc4700..17977bc 100644
--- a/common/definitions.cpp
+++ b/common/definitions.cpp
@@ -23,6 +23,17 @@
 #include <QStandardPaths>
 #include <QDir>
+static bool rereadDataLocation = true;
+static bool rereadConfigLocation = true;
+static bool rereadTemporaryFileLocation = true;
+void Sink::clearLocationCache()
+{
+    rereadDataLocation = true;
+    rereadConfigLocation = true;
+    rereadTemporaryFileLocation = true;
+}
 QString Sink::storageLocation()
 {
    return dataLocation() + "/storage";
@@ -30,21 +41,37 @@ QString Sink::storageLocation()
 QString Sink::dataLocation()
 {
-    return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/sink";
+    static QString location;
+    if (rereadDataLocation) {
+        location = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/sink";
+        rereadDataLocation = false;
+    }
+    return location;
 }
 QString Sink::configLocation()
 {
-    return QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/sink";
+    static QString location;
+    if (rereadConfigLocation) {
+        location = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/sink";
+        rereadConfigLocation = false;
+    }
+    return location;
 }
 QString Sink::temporaryFileLocation()
 {
-    auto path = dataLocation() + "/temporaryFiles";
+    static QString location;
-    //FIXME create in a singleton on startup?
+    static bool dirCreated = false;
-    QDir dir;
+    if (rereadTemporaryFileLocation) {
-    dir.mkpath(path);
+        location = dataLocation() + "/temporaryFiles";
-    return path;
+        dirCreated = QDir{}.mkpath(location);
+        rereadTemporaryFileLocation = false;
+    }
+    if (!dirCreated && QDir{}.mkpath(location)) {
+        dirCreated = true;
+    }
+    return location;
 }
 QString Sink::resourceStorageLocation(const QByteArray &resourceInstanceIdentifier)
diff --git a/common/definitions.h b/common/definitions.h
index e8cd45e..ce9e794 100644
--- a/common/definitions.h
+++ b/common/definitions.h
@@ -25,6 +25,7 @@
 #include <QByteArray>
 namespace Sink {
+void SINK_EXPORT clearLocationCache();
 QString SINK_EXPORT storageLocation();
 QString SINK_EXPORT dataLocation();
 QString SINK_EXPORT configLocation();
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index 67d463f..3718f77 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -25,8 +25,6 @@
 #include "storage.h" //for generateUid()
 #include <QFile>
-SINK_DEBUG_AREA("applicationdomaintype");
 QDebug Sink::ApplicationDomain::operator<< (QDebug d, const Sink::ApplicationDomain::Mail::Contact &c)
 {
    d << "Contact(" << c.name << ", " << c.emailAddress << ")";
@@ -114,6 +112,7 @@ SINK_REGISTER_PROPERTY(Contact, Lastname);
 SINK_REGISTER_PROPERTY(Contact, Emails);
 SINK_REGISTER_PROPERTY(Contact, Vcard);
 SINK_REGISTER_PROPERTY(Contact, Addressbook);
+SINK_REGISTER_PROPERTY(Contact, Photo);
 SINK_REGISTER_ENTITY(Addressbook);
 SINK_REGISTER_PROPERTY(Addressbook, Name);
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index e5aa46e..602d54c 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -377,6 +377,7 @@ struct SINK_EXPORT Contact : public Entity {
    SINK_PROPERTY(QString, Lastname, lastname);
    SINK_PROPERTY(QList<Email>, Emails, emails);
    SINK_PROPERTY(QByteArray, Vcard, vcard);
+    SINK_PROPERTY(QByteArray, Photo, photo);
    SINK_REFERENCE_PROPERTY(Addressbook, Addressbook, addressbook);
 };
diff --git a/common/domain/contact.fbs b/common/domain/contact.fbs
index d941d5a..e689756 100644
--- a/common/domain/contact.fbs
+++ b/common/domain/contact.fbs
@@ -13,6 +13,7 @@ table Contact {
  addressbook:string;
  emails: [ContactEmail];
  vcard: string;
+  photo: string;
 }
 root_type Contact;
diff --git a/common/domain/typeimplementations.cpp b/common/domain/typeimplementations.cpp
index eb3851e..47a9cf7 100644
--- a/common/domain/typeimplementations.cpp
+++ b/common/domain/typeimplementations.cpp
@@ -28,25 +28,52 @@
 #include "entity_generated.h"
 #include "mail/threadindexer.h"
 #include "domainadaptor.h"
+#include "typeimplementations_p.h"
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
+#define SINK_REGISTER_SERIALIZER(MAPPER, ENTITYTYPE, PROPERTY, LOWERCASEPROPERTY) \
+    MAPPER.addMapping<ENTITYTYPE::PROPERTY, Sink::ApplicationDomain::Buffer::ENTITYTYPE, Sink::ApplicationDomain::Buffer::ENTITYTYPE##Builder>(&Sink::ApplicationDomain::Buffer::ENTITYTYPE::LOWERCASEPROPERTY, &Sink::ApplicationDomain::Buffer::ENTITYTYPE##Builder::add_##LOWERCASEPROPERTY);
+typedef IndexConfig<Mail,
+        ValueIndex<Mail::Date>,
+        ValueIndex<Mail::Folder>,
+        ValueIndex<Mail::ParentMessageId>,
+        ValueIndex<Mail::MessageId>,
+        ValueIndex<Mail::Draft>,
+        SortedIndex<Mail::Folder, Mail::Date>,
+        SecondaryIndex<Mail::MessageId, Mail::ThreadId>,
+        SecondaryIndex<Mail::ThreadId, Mail::MessageId>,
+        CustomSecondaryIndex<Mail::MessageId, Mail::ThreadId, ThreadIndexer>
+    > MailIndexConfig;
+typedef IndexConfig<Folder,
+        ValueIndex<Folder::Name>,
+        ValueIndex<Folder::Parent>
+    > FolderIndexConfig;
+typedef IndexConfig<Contact,
+        ValueIndex<Contact::Uid>
+    > ContactIndexConfig;
+typedef IndexConfig<Addressbook,
+        ValueIndex<Addressbook::Parent>
+    > AddressbookIndexConfig;
+typedef IndexConfig<Event,
+        ValueIndex<Event::Uid>
+    > EventIndexConfig;
 void TypeImplementation<Mail>::configure(TypeIndex &index)
 {
-    // index.addProperty<Mail::Sender>();
+    MailIndexConfig::configure(index);
-    /* index.addProperty<QByteArray>(Mail::SenderName::name); */
+}
-    /* index->addProperty<QString>(Mail::Subject::name); */
-    /* index->addFulltextProperty<QString>(Mail::Subject::name); */
-    index.addProperty<Mail::Date>();
-    index.addProperty<Mail::Folder>();
-    index.addPropertyWithSorting<Mail::Folder, Mail::Date>();
-    index.addProperty<Mail::ParentMessageId>();
-    index.addProperty<Mail::MessageId>();
-    index.addSecondaryPropertyIndexer<Mail::MessageId, Mail::ThreadId, ThreadIndexer>();
+QMap<QByteArray, int> TypeImplementation<Mail>::typeDatabases()
-    index.addSecondaryProperty<Mail::MessageId, Mail::ThreadId>();
+{
-    index.addSecondaryProperty<Mail::ThreadId, Mail::MessageId>();
+    return merge(QMap<QByteArray, int>{{QByteArray{Mail::name} + ".main", 0}}, MailIndexConfig::databases());
 }
 void TypeImplementation<Mail>::configure(IndexPropertyMapper &indexPropertyMapper)
@@ -61,69 +88,44 @@ void TypeImplementation<Mail>::configure(IndexPropertyMapper &indexPropertyMappe
        });
 }
-void TypeImplementation<Mail>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+void TypeImplementation<Mail>::configure(PropertyMapper &propertyMapper)
-{
+{
-    propertyMapper.addMapping<Mail::Sender, Buffer>(&Buffer::sender);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Sender, sender);
-    propertyMapper.addMapping<Mail::To, Buffer>(&Buffer::to);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, To, to);
-    propertyMapper.addMapping<Mail::Cc, Buffer>(&Buffer::cc);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Cc, cc);
-    propertyMapper.addMapping<Mail::Bcc, Buffer>(&Buffer::bcc);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Bcc, bcc);
-    propertyMapper.addMapping<Mail::Subject, Buffer>(&Buffer::subject);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Subject, subject);
-    propertyMapper.addMapping<Mail::Date, Buffer>(&Buffer::date);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Date, date);
-    propertyMapper.addMapping<Mail::Unread, Buffer>(&Buffer::unread);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Unread, unread);
-    propertyMapper.addMapping<Mail::Important, Buffer>(&Buffer::important);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Important, important);
-    propertyMapper.addMapping<Mail::Folder, Buffer>(&Buffer::folder);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Folder, folder);
-    propertyMapper.addMapping<Mail::MimeMessage, Buffer>(&Buffer::mimeMessage);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, MimeMessage, mimeMessage);
-    propertyMapper.addMapping<Mail::FullPayloadAvailable, Buffer>(&Buffer::fullPayloadAvailable);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, FullPayloadAvailable, fullPayloadAvailable);
-    propertyMapper.addMapping<Mail::Draft, Buffer>(&Buffer::draft);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Draft, draft);
-    propertyMapper.addMapping<Mail::Trash, Buffer>(&Buffer::trash);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Trash, trash);
-    propertyMapper.addMapping<Mail::Sent, Buffer>(&Buffer::sent);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, Sent, sent);
-    propertyMapper.addMapping<Mail::MessageId, Buffer>(&Buffer::messageId);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, MessageId, messageId);
-    propertyMapper.addMapping<Mail::ParentMessageId, Buffer>(&Buffer::parentMessageId);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Mail, ParentMessageId, parentMessageId);
-}
-void TypeImplementation<Mail>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
-{
-    propertyMapper.addMapping<Mail::Sender>(&BufferBuilder::add_sender);
-    propertyMapper.addMapping<Mail::To>(&BufferBuilder::add_to);
-    propertyMapper.addMapping<Mail::Cc>(&BufferBuilder::add_cc);
-    propertyMapper.addMapping<Mail::Bcc>(&BufferBuilder::add_bcc);
-    propertyMapper.addMapping<Mail::Subject>(&BufferBuilder::add_subject);
-    propertyMapper.addMapping<Mail::Date>(&BufferBuilder::add_date);
-    propertyMapper.addMapping<Mail::Unread>(&BufferBuilder::add_unread);
-    propertyMapper.addMapping<Mail::Important>(&BufferBuilder::add_important);
-    propertyMapper.addMapping<Mail::Folder>(&BufferBuilder::add_folder);
-    propertyMapper.addMapping<Mail::MimeMessage>(&BufferBuilder::add_mimeMessage);
-    propertyMapper.addMapping<Mail::FullPayloadAvailable>(&BufferBuilder::add_fullPayloadAvailable);
-    propertyMapper.addMapping<Mail::Draft>(&BufferBuilder::add_draft);
-    propertyMapper.addMapping<Mail::Trash>(&BufferBuilder::add_trash);
-    propertyMapper.addMapping<Mail::Sent>(&BufferBuilder::add_sent);
-    propertyMapper.addMapping<Mail::MessageId>(&BufferBuilder::add_messageId);
-    propertyMapper.addMapping<Mail::ParentMessageId>(&BufferBuilder::add_parentMessageId);
 }
 void TypeImplementation<Folder>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Folder::Parent::name);
+    FolderIndexConfig::configure(index);
-    index.addProperty<QString>(Folder::Name::name);
 }
-void TypeImplementation<Folder>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Folder>::typeDatabases()
 {
-    propertyMapper.addMapping<Folder::Parent, Buffer>(&Buffer::parent);
+    return merge(QMap<QByteArray, int>{{QByteArray{Folder::name} + ".main", 0}}, FolderIndexConfig::databases());
-    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)
+void TypeImplementation<Folder>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Folder::Parent>(&BufferBuilder::add_parent);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Parent, parent);
-    propertyMapper.addMapping<Folder::Name>(&BufferBuilder::add_name);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Name, name);
-    propertyMapper.addMapping<Folder::Icon>(&BufferBuilder::add_icon);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Icon, icon);
-    propertyMapper.addMapping<Folder::SpecialPurpose>(&BufferBuilder::add_specialpurpose);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, SpecialPurpose, specialpurpose);
-    propertyMapper.addMapping<Folder::Enabled>(&BufferBuilder::add_enabled);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Folder, Enabled, enabled);
 }
 void TypeImplementation<Folder>::configure(IndexPropertyMapper &)
@@ -134,29 +136,24 @@ void TypeImplementation<Folder>::configure(IndexPropertyMapper &)
 void TypeImplementation<Contact>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Contact::Uid::name);
+    ContactIndexConfig::configure(index);
 }
-void TypeImplementation<Contact>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Contact>::typeDatabases()
 {
-    propertyMapper.addMapping<Contact::Uid, Buffer>(&Buffer::uid);
+    return merge(QMap<QByteArray, int>{{QByteArray{Contact::name} + ".main", 0}}, ContactIndexConfig::databases());
-    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)
+void TypeImplementation<Contact>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Contact::Uid>(&BufferBuilder::add_uid);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Uid, uid);
-    propertyMapper.addMapping<Contact::Fn>(&BufferBuilder::add_fn);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Fn, fn);
-    propertyMapper.addMapping<Contact::Emails>(&BufferBuilder::add_emails);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Emails, emails);
-    propertyMapper.addMapping<Contact::Vcard>(&BufferBuilder::add_vcard);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Vcard, vcard);
-    propertyMapper.addMapping<Contact::Addressbook>(&BufferBuilder::add_addressbook);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Addressbook, addressbook);
-    propertyMapper.addMapping<Contact::Firstname>(&BufferBuilder::add_firstname);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Firstname, firstname);
-    propertyMapper.addMapping<Contact::Lastname>(&BufferBuilder::add_lastname);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Lastname, lastname);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Contact, Photo, photo);
 }
 void TypeImplementation<Contact>::configure(IndexPropertyMapper &)
@@ -167,20 +164,18 @@ void TypeImplementation<Contact>::configure(IndexPropertyMapper &)
 void TypeImplementation<Addressbook>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Addressbook::Parent::name);
+    AddressbookIndexConfig::configure(index);
-    index.addProperty<QString>(Addressbook::Name::name);
 }
-void TypeImplementation<Addressbook>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Addressbook>::typeDatabases()
 {
-    propertyMapper.addMapping<Addressbook::Parent, Buffer>(&Buffer::parent);
+    return merge(QMap<QByteArray, int>{{QByteArray{Addressbook::name} + ".main", 0}}, AddressbookIndexConfig::databases());
-    propertyMapper.addMapping<Addressbook::Name, Buffer>(&Buffer::name);
 }
-void TypeImplementation<Addressbook>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
+void TypeImplementation<Addressbook>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Addressbook::Parent>(&BufferBuilder::add_parent);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Addressbook, Parent, parent);
-    propertyMapper.addMapping<Addressbook::Name>(&BufferBuilder::add_name);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Addressbook, Name, name);
 }
 void TypeImplementation<Addressbook>::configure(IndexPropertyMapper &)
@@ -191,26 +186,24 @@ void TypeImplementation<Addressbook>::configure(IndexPropertyMapper &)
 void TypeImplementation<Event>::configure(TypeIndex &index)
 {
-    index.addProperty<QByteArray>(Event::Uid::name);
+    EventIndexConfig::configure(index);
 }
-void TypeImplementation<Event>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+QMap<QByteArray, int> TypeImplementation<Event>::typeDatabases()
 {
-    propertyMapper.addMapping<Event::Summary, Buffer>(&Buffer::summary);
+    return merge(QMap<QByteArray, int>{{QByteArray{Event::name} + ".main", 0}}, EventIndexConfig::databases());
-    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)
+void TypeImplementation<Event>::configure(PropertyMapper &propertyMapper)
 {
-    propertyMapper.addMapping<Event::Summary>(&BufferBuilder::add_summary);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Summary, summary);
-    propertyMapper.addMapping<Event::Description>(&BufferBuilder::add_description);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Description, description);
-    propertyMapper.addMapping<Event::Uid>(&BufferBuilder::add_uid);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Uid, uid);
-    propertyMapper.addMapping<Event::Attachment>(&BufferBuilder::add_attachment);
+    SINK_REGISTER_SERIALIZER(propertyMapper, Event, Attachment, attachment);
 }
 void TypeImplementation<Event>::configure(IndexPropertyMapper &)
 {
 }
diff --git a/common/domain/typeimplementations.h b/common/domain/typeimplementations.h
index 37d6ca9..d36dfc1 100644
--- a/common/domain/typeimplementations.h
+++ b/common/domain/typeimplementations.h
@@ -26,10 +26,7 @@
 #include "contact_generated.h"
 #include "addressbook_generated.h"
-template<typename T>
+class PropertyMapper;
-class ReadPropertyMapper;
-template<typename T>
-class WritePropertyMapper;
 class IndexPropertyMapper;
 class TypeIndex;
@@ -48,9 +45,9 @@ public:
    typedef Sink::ApplicationDomain::Buffer::Mail Buffer;
    typedef Sink::ApplicationDomain::Buffer::MailBuilder BufferBuilder;
    static void configure(TypeIndex &index);
-    static void configure(ReadPropertyMapper<Buffer> &propertyMapper);
+    static void configure(PropertyMapper &propertyMapper);
-    static void configure(WritePropertyMapper<BufferBuilder> &propertyMapper);
    static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 template<>
@@ -59,9 +56,9 @@ public:
    typedef Sink::ApplicationDomain::Buffer::Folder Buffer;
    typedef Sink::ApplicationDomain::Buffer::FolderBuilder BufferBuilder;
    static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
+    static void configure(PropertyMapper &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
    static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 template<>
@@ -70,9 +67,9 @@ public:
    typedef Sink::ApplicationDomain::Buffer::Contact Buffer;
    typedef Sink::ApplicationDomain::Buffer::ContactBuilder BufferBuilder;
    static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
+    static void configure(PropertyMapper &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
    static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 template<>
@@ -81,9 +78,9 @@ public:
    typedef Sink::ApplicationDomain::Buffer::Addressbook Buffer;
    typedef Sink::ApplicationDomain::Buffer::AddressbookBuilder BufferBuilder;
    static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
+    static void configure(PropertyMapper &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
    static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 template<>
@@ -92,9 +89,9 @@ public:
    typedef Sink::ApplicationDomain::Buffer::Event Buffer;
    typedef Sink::ApplicationDomain::Buffer::EventBuilder BufferBuilder;
    static void configure(TypeIndex &);
-    static void configure(ReadPropertyMapper<Buffer> &);
+    static void configure(PropertyMapper &);
-    static void configure(WritePropertyMapper<BufferBuilder> &);
    static void configure(IndexPropertyMapper &indexPropertyMapper);
+    static QMap<QByteArray, int> typeDatabases();
 };
 }
diff --git a/common/domain/typeimplementations_p.h b/common/domain/typeimplementations_p.h
new file mode 100644
index 0000000..6f77a2d
--- /dev/null
+++ b/common/domain/typeimplementations_p.h
@@ -0,0 +1,154 @@
+/*
+ *   Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+#include "typeindex.h"
+#include <QMap>
+template <typename T, typename First>
+void mergeImpl(T &map, First f)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+}
+template <typename T, typename First, typename ... Tail>
+void mergeImpl(T &map, First f, Tail ...maps)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+    mergeImpl<T, Tail...>(map, maps...);
+}
+template <typename First, typename ... Tail>
+First merge(First f, Tail ...maps)
+{
+    First map;
+    mergeImpl(map, f, maps...);
+    return map;
+}
+template <typename Property>
+class ValueIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addProperty<Property>();
+    }
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return {{QByteArray{EntityType::name} +".index." + Property::name, 1}};
+    }
+};
+template <typename Property, typename SortProperty>
+class SortedIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addPropertyWithSorting<Property, SortProperty>();
+    }
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return {{QByteArray{EntityType::name} +".index." + Property::name + ".sort." + SortProperty::name, 1}};
+    }
+};
+template <typename Property, typename SecondaryProperty>
+class SecondaryIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addSecondaryProperty<Property, SecondaryProperty>();
+    }
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return {{QByteArray{EntityType::name} +".index." + Property::name + SecondaryProperty::name, 1}};
+    }
+};
+template <typename Property, typename SecondaryProperty, typename Indexer>
+class CustomSecondaryIndex
+{
+public:
+    static void configure(TypeIndex &index)
+    {
+        index.addSecondaryPropertyIndexer<Property, SecondaryProperty, Indexer>();
+    }
+    template <typename EntityType>
+    static QMap<QByteArray, int> databases()
+    {
+        return Indexer::databases();
+    }
+};
+template <typename EntityType, typename ... Indexes>
+class IndexConfig
+{
+    template <typename T>
+    static void applyIndex(TypeIndex &index)
+    {
+        T::configure(index);
+    }
+    ///Apply recursively for parameter pack
+    template <typename First, typename Second, typename ... Tail>
+    static void applyIndex(TypeIndex &index)
+    {
+        applyIndex<First>(index);
+        applyIndex<Second, Tail...>(index);
+    }
+    template <typename T>
+    static QMap<QByteArray, int> getDbs()
+    {
+        return T::template databases<EntityType>();
+    }
+    template <typename First, typename Second, typename ... Tail>
+    static QMap<QByteArray, int> getDbs()
+    {
+        return merge(getDbs<First>(), getDbs<Second, Tail...>());
+    }
+public:
+    static void configure(TypeIndex &index)
+    {
+        applyIndex<Indexes...>(index);
+    }
+    static QMap<QByteArray, int> databases()
+    {
+        return getDbs<Indexes...>();
+    }
+};
diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index af5d5fc..f981a1f 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -29,21 +29,19 @@
 #include "domain/typeimplementations.h"
 #include "bufferadaptor.h"
 #include "entity_generated.h"
-#include "metadata_generated.h"
 #include "entitybuffer.h"
 #include "propertymapper.h"
 #include "log.h"
-#include "dummy_generated.h"
 /**
 * Create a buffer from a domain object using the provided mappings
 */
 template <class Builder, class Buffer>
 flatbuffers::Offset<Buffer>
-createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, const WritePropertyMapper<Builder> &mapper)
+createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, const PropertyMapper &mapper)
 {
    // First create a primitives such as strings using the mappings
-    QList<std::function<void(Builder &)>> propertiesToAddToResource;
+    QList<std::function<void(void *builder)>> propertiesToAddToResource;
    for (const auto &property : domainObject.changedProperties()) {
        // SinkTrace() << "copying property " << property;
        const auto value = domainObject.getProperty(property);
@@ -57,7 +55,7 @@ createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObj
    // Then create all porperties using the above generated builderCalls
    Builder builder(fbb);
    for (auto propertyBuilder : propertiesToAddToResource) {
-        propertyBuilder(builder);
+        propertyBuilder(&builder);
    }
    return builder.Finish();
 }
@@ -68,7 +66,7 @@ createBufferPart(const Sink::ApplicationDomain::ApplicationDomainType &domainObj
 * After this the buffer can be extracted from the FlatBufferBuilder object.
 */
 template <typename Buffer, typename BufferBuilder>
-static void createBufferPartBuffer(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, WritePropertyMapper<BufferBuilder> &mapper)
+static void createBufferPartBuffer(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, PropertyMapper &mapper)
 {
    auto pos = createBufferPart<BufferBuilder, Buffer>(domainObject, fbb, mapper);
    // Because we cannot template the following call
@@ -120,10 +118,8 @@ private:
 /**
 * A generic adaptor implementation that uses a property mapper to read/write values.
 */
-template <class LocalBuffer, class ResourceBuffer>
 class DatastoreBufferAdaptor : public Sink::ApplicationDomain::BufferAdaptor
 {
-    SINK_DEBUG_AREA("bufferadaptor")
 public:
    DatastoreBufferAdaptor() : BufferAdaptor()
    {
@@ -137,9 +133,7 @@ public:
    virtual QVariant getProperty(const QByteArray &key) const Q_DECL_OVERRIDE
    {
-        if (mResourceBuffer && mResourceMapper->hasMapping(key)) {
+        if (mLocalBuffer && mLocalMapper->hasMapping(key)) {
-            return mResourceMapper->getProperty(key, mResourceBuffer);
-        } else if (mLocalBuffer && mLocalMapper->hasMapping(key)) {
            return mLocalMapper->getProperty(key, mLocalBuffer);
        } else if (mIndex && mIndexMapper->hasMapping(key)) {
            return mIndexMapper->getProperty(key, *mIndex, *this);
@@ -152,23 +146,21 @@ public:
     */
    virtual QList<QByteArray> availableProperties() const Q_DECL_OVERRIDE
    {
-        return mResourceMapper->availableProperties() + mLocalMapper->availableProperties() + mIndexMapper->availableProperties();
+        return mLocalMapper->availableProperties() + mIndexMapper->availableProperties();
    }
-    LocalBuffer const *mLocalBuffer;
+    void const *mLocalBuffer;
-    ResourceBuffer const *mResourceBuffer;
+    QSharedPointer<PropertyMapper> mLocalMapper;
-    QSharedPointer<ReadPropertyMapper<LocalBuffer>> mLocalMapper;
-    QSharedPointer<ReadPropertyMapper<ResourceBuffer>> mResourceMapper;
    QSharedPointer<IndexPropertyMapper> mIndexMapper;
    TypeIndex *mIndex;
 };
 /**
- * The factory should define how to go from an entitybuffer (local + resource buffer), to a domain type adapter.
+ * The factory should define how to go from an entitybuffer (local buffer), to a domain type adapter.
 * It defines how values are split accross local and resource buffer.
 * This is required by the facade the read the value, and by the pipeline preprocessors to access the domain values in a generic way.
 */
-template <typename DomainType, typename ResourceBuffer = Sink::ApplicationDomain::Buffer::Dummy, typename ResourceBuilder = Sink::ApplicationDomain::Buffer::DummyBuilder>
+template <typename DomainType>
 class SINK_EXPORT DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInterface
 {
    typedef typename Sink::ApplicationDomain::TypeImplementation<DomainType>::Buffer LocalBuffer;
@@ -176,31 +168,25 @@ class SINK_EXPORT DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInte
 public:
    DomainTypeAdaptorFactory()
-        : mLocalMapper(QSharedPointer<ReadPropertyMapper<LocalBuffer>>::create()),
+        : mPropertyMapper(QSharedPointer<PropertyMapper>::create()),
-          mResourceMapper(QSharedPointer<ReadPropertyMapper<ResourceBuffer>>::create()),
-          mLocalWriteMapper(QSharedPointer<WritePropertyMapper<LocalBuilder>>::create()),
-          mResourceWriteMapper(QSharedPointer<WritePropertyMapper<ResourceBuilder>>::create()),
          mIndexMapper(QSharedPointer<IndexPropertyMapper>::create())
    {
-        Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mLocalMapper);
+        Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mPropertyMapper);
-        Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mLocalWriteMapper);
        Sink::ApplicationDomain::TypeImplementation<DomainType>::configure(*mIndexMapper);
    }
    virtual ~DomainTypeAdaptorFactory(){};
    /**
-     * Creates an adaptor for the given domain and resource types.
+     * Creates an adaptor for the given domain types.
     *
     * This returns by default a DatastoreBufferAdaptor initialized with the corresponding property mappers.
     */
    virtual QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> createAdaptor(const Sink::Entity &entity, TypeIndex *index = nullptr) Q_DECL_OVERRIDE
    {
-        auto adaptor = QSharedPointer<DatastoreBufferAdaptor<LocalBuffer, ResourceBuffer>>::create();
+        auto adaptor = QSharedPointer<DatastoreBufferAdaptor>::create();
        adaptor->mLocalBuffer = Sink::EntityBuffer::readBuffer<LocalBuffer>(entity.local());
-        adaptor->mLocalMapper = mLocalMapper;
+        adaptor->mLocalMapper = mPropertyMapper;
-        adaptor->mResourceBuffer = Sink::EntityBuffer::readBuffer<ResourceBuffer>(entity.resource());
-        adaptor->mResourceMapper = mResourceMapper;
        adaptor->mIndexMapper = mIndexMapper;
        adaptor->mIndex = index;
        return adaptor;
@@ -210,18 +196,8 @@ public:
    createBuffer(const Sink::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, void const *metadataData = 0, size_t metadataSize = 0) Q_DECL_OVERRIDE
    {
        flatbuffers::FlatBufferBuilder localFbb;
-        if (mLocalWriteMapper) {
+        createBufferPartBuffer<LocalBuffer, LocalBuilder>(domainObject, localFbb, *mPropertyMapper);
-            // SinkTrace() << "Creating local buffer part";
+        Sink::EntityBuffer::assembleEntityBuffer(fbb, metadataData, metadataSize, 0, 0, localFbb.GetBufferPointer(), localFbb.GetSize());
-            createBufferPartBuffer<LocalBuffer, LocalBuilder>(domainObject, localFbb, *mLocalWriteMapper);
-        }
-        flatbuffers::FlatBufferBuilder resFbb;
-        if (mResourceWriteMapper) {
-            // SinkTrace() << "Creating resouce buffer part";
-            createBufferPartBuffer<ResourceBuffer, ResourceBuilder>(domainObject, resFbb, *mResourceWriteMapper);
-        }
-        Sink::EntityBuffer::assembleEntityBuffer(fbb, metadataData, metadataSize, resFbb.GetBufferPointer(), resFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
        return true;
    }
@@ -236,10 +212,7 @@ public:
 protected:
-    QSharedPointer<ReadPropertyMapper<LocalBuffer>> mLocalMapper;
+    QSharedPointer<PropertyMapper> mPropertyMapper;
-    QSharedPointer<ReadPropertyMapper<ResourceBuffer>> mResourceMapper;
-    QSharedPointer<WritePropertyMapper<LocalBuilder>> mLocalWriteMapper;
-    QSharedPointer<WritePropertyMapper<ResourceBuilder>> mResourceWriteMapper;
    QSharedPointer<IndexPropertyMapper> mIndexMapper;
 };
diff --git a/common/facade.cpp b/common/facade.cpp
index 38ec1dc..9c14a23 100644
--- a/common/facade.cpp
+++ b/common/facade.cpp
@@ -104,6 +104,7 @@ KAsync::Job<void> GenericFacade<DomainType>::remove(const DomainType &domainObje
 template <class DomainType>
 QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> GenericFacade<DomainType>::load(const Sink::Query &query, const Log::Context &ctx)
 {
+    Q_ASSERT(DomainType::name == query.type() || query.type().isEmpty());
    // The runner lives for the lifetime of the query
    auto runner = new QueryRunner<DomainType>(query, mResourceContext, bufferTypeForDomainType(), ctx);
    runner->setResultTransformation(mResultTransformation);
diff --git a/common/facade.h b/common/facade.h
index 45c718b..0ec2e59 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -48,7 +48,6 @@ template <typename DomainType>
 class SINK_EXPORT GenericFacade : public Sink::StoreFacade<DomainType>
 {
 protected:
-    SINK_DEBUG_AREA("facade")
    SINK_DEBUG_COMPONENT(mResourceContext.resourceInstanceIdentifier)
 public:
    /**
diff --git a/common/genericresource.h b/common/genericresource.h
index 558145c..bffc697 100644
--- a/common/genericresource.h
+++ b/common/genericresource.h
@@ -35,8 +35,6 @@ class CommandProcessor;
 */
 class SINK_EXPORT GenericResource : public Resource
 {
-protected:
-    SINK_DEBUG_AREA("resource")
 public:
    GenericResource(const Sink::ResourceContext &context, const QSharedPointer<Pipeline> &pipeline = QSharedPointer<Pipeline>());
    virtual ~GenericResource();
diff --git a/common/listener.cpp b/common/listener.cpp
index 983e438..c9fd9d3 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -405,6 +405,7 @@ void Listener::updateClientsWithRevision(qint64 revision)
        SinkTrace() << "Sending revision update for " << client.name << revision;
        Sink::Commands::write(client.socket, ++m_messageId, Sink::Commands::RevisionUpdateCommand, m_fbb);
+        client.socket->flush();
    }
    m_fbb.Clear();
 }
@@ -420,6 +421,8 @@ void Listener::notify(const Sink::Notification &notification)
    builder.add_identifier(idString);
    builder.add_message(messageString);
    builder.add_entities(entities);
+    builder.add_progress(notification.progress);
+    builder.add_total(notification.total);
    auto command = builder.Finish();
    Sink::Commands::FinishNotificationBuffer(m_fbb, command);
    for (Client &client : m_connections) {
diff --git a/common/listener.h b/common/listener.h
index 8d8b529..f29130d 100644
--- a/common/listener.h
+++ b/common/listener.h
@@ -55,8 +55,6 @@ public:
 class SINK_EXPORT Listener : public QObject
 {
    Q_OBJECT
-    SINK_DEBUG_AREA("communication")
 public:
    Listener(const QByteArray &resourceName, const QByteArray &resourceType, QObject *parent = 0);
    ~Listener();
diff --git a/common/log.cpp b/common/log.cpp
index 045b3cc..5dfb872 100644
--- a/common/log.cpp
+++ b/common/log.cpp
@@ -1,6 +1,7 @@
 #include "log.h"
 #include <QString>
+#include <QDir>
 #include <QIODevice>
 #include <QCoreApplication>
 #include <QSettings>
@@ -12,12 +13,18 @@
 #include <memory>
 #include <atomic>
 #include <definitions.h>
+#include <QThreadStorage>
+#include <QStringBuilder>
 using namespace Sink::Log;
-static QSharedPointer<QSettings> config()
+static QThreadStorage<QSharedPointer<QSettings>> sSettings;
+static QSettings &config()
 {
-    return QSharedPointer<QSettings>::create(Sink::configLocation() + "/log.ini", QSettings::IniFormat);
+    if (!sSettings.hasLocalData()) {
+        sSettings.setLocalData(QSharedPointer<QSettings>::create(Sink::configLocation() + "/log.ini", QSettings::IniFormat));
+    }
+    return *sSettings.localData();
 }
 static QByteArray sPrimaryComponent;
@@ -173,22 +180,22 @@ DebugLevel Sink::Log::debugLevelFromName(const QByteArray &name)
 void Sink::Log::setDebugOutputLevel(DebugLevel debugLevel)
 {
-    config()->setValue("level", debugLevel);
+    config().setValue("level", debugLevel);
 }
 Sink::Log::DebugLevel Sink::Log::debugOutputLevel()
 {
-    return static_cast<Sink::Log::DebugLevel>(config()->value("level", Sink::Log::Log).toInt());
+    return static_cast<Sink::Log::DebugLevel>(config().value("level", Sink::Log::Log).toInt());
 }
 void Sink::Log::setDebugOutputFilter(FilterType type, const QByteArrayList &filter)
 {
    switch (type) {
        case ApplicationName:
-            config()->setValue("applicationfilter", QVariant::fromValue(filter));
+            config().setValue("applicationfilter", QVariant::fromValue(filter));
            break;
        case Area:
-            config()->setValue("areafilter", QVariant::fromValue(filter));
+            config().setValue("areafilter", QVariant::fromValue(filter));
            break;
    }
 }
@@ -197,9 +204,9 @@ QByteArrayList Sink::Log::debugOutputFilter(FilterType type)
 {
    switch (type) {
        case ApplicationName:
-            return config()->value("applicationfilter").value<QByteArrayList>();
+            return config().value("applicationfilter").value<QByteArrayList>();
        case Area:
-            return config()->value("areafilter").value<QByteArrayList>();
+            return config().value("areafilter").value<QByteArrayList>();
        default:
            return QByteArrayList();
    }
@@ -207,12 +214,12 @@ QByteArrayList Sink::Log::debugOutputFilter(FilterType type)
 void Sink::Log::setDebugOutputFields(const QByteArrayList &output)
 {
-    config()->setValue("outputfields", QVariant::fromValue(output));
+    config().setValue("outputfields", QVariant::fromValue(output));
 }
 QByteArrayList Sink::Log::debugOutputFields()
 {
-    return config()->value("outputfields").value<QByteArrayList>();
+    return config().value("outputfields").value<QByteArrayList>();
 }
 static QByteArray getProgramName()
@@ -277,14 +284,16 @@ static bool containsItemStartingWith(const QByteArray &pattern, const QByteArray
    for (const auto &item : list) {
        if (item.startsWith('*')) {
            auto stripped = item.mid(1);
-            stripped.endsWith('*');
+            if (stripped.endsWith('*')) {
-            stripped.chop(1);
+                stripped.chop(1);
+            }
            if (pattern.contains(stripped)) {
                return true;
            }
-        }
+        } else {
-        if (pattern.startsWith(item)) {
+            if (pattern.contains(item)) {
-            return true;
+                return true;
+            }
        }
    }
    return false;
@@ -300,25 +309,51 @@ static bool caseInsensitiveContains(const QByteArray &pattern, const QByteArrayL
    return false;
 }
-QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char *file, const char *function, const char *debugArea, const char *debugComponent)
+static QByteArray getFileName(const char *file)
 {
-    static NullStream nullstream;
+    static char sep = QDir::separator().toLatin1();
-    if (debugLevel < debugOutputLevel()) {
+    auto filename = QByteArray(file).split(sep).last();
-        return QDebug(&nullstream);
+    return filename.split('.').first();
-    }
+}
+static QString assembleDebugArea(const char *debugArea, const char *debugComponent, const char *file)
+{
    if (sPrimaryComponent.isEmpty()) {
        sPrimaryComponent = getProgramName();
    }
-    QString fullDebugArea = sPrimaryComponent + "." + (debugComponent ? (QString::fromLatin1(debugComponent) + ".") : "") + (debugArea ? QString::fromLatin1(debugArea) : "");
+    //Using stringbuilder for fewer allocations
+    return QLatin1String{sPrimaryComponent} % QLatin1String{"."} %
+        (debugComponent ? (QLatin1String{debugComponent} + QLatin1String{"."}) : QLatin1String{""}) %
+        (debugArea ? QLatin1String{debugArea} : QLatin1String{getFileName(file)});
+}
+static bool isFiltered(DebugLevel debugLevel, const QByteArray &fullDebugArea)
+{
+    if (debugLevel < debugOutputLevel()) {
+        return true;
+    }
+    const auto areas = debugOutputFilter(Sink::Log::Area);
+    if ((debugLevel <= Sink::Log::Trace) && !areas.isEmpty()) {
+        if (!containsItemStartingWith(fullDebugArea, areas)) {
+            return true;
+        }
+    }
+    return false;
+}
+bool Sink::Log::isFiltered(DebugLevel debugLevel, const char *debugArea, const char *debugComponent, const char *file)
+{
+    return isFiltered(debugLevel, assembleDebugArea(debugArea, debugComponent, file).toLatin1());
+}
+QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char *file, const char *function, const char *debugArea, const char *debugComponent)
+{
+    const auto fullDebugArea = assembleDebugArea(debugArea, debugComponent, file);
    collectDebugArea(fullDebugArea);
-    auto areas = debugOutputFilter(Sink::Log::Area);
+    static NullStream nullstream;
-    if (debugLevel <= Sink::Log::Trace && !areas.isEmpty()) {
+    if (isFiltered(debugLevel, fullDebugArea.toLatin1())) {
-        if (!containsItemStartingWith(fullDebugArea.toUtf8(), areas)) {
+        return QDebug(&nullstream);
-            return QDebug(&nullstream);
-        }
    }
    QString prefix;
diff --git a/common/log.h b/common/log.h
index e85856a..8266fdb 100644
--- a/common/log.h
+++ b/common/log.h
@@ -85,30 +85,35 @@ SINK_EXPORT inline QDebug operator<<(QDebug d, const TraceTime &time)
    d << time.time << "[ms]";
    return d;
 }
+SINK_EXPORT bool isFiltered(DebugLevel debugLevel, const char *debugArea, const char *debugComponent, const char *file);
 }
 }
 static const char *getComponentName() { return nullptr; }
-#define Trace_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
+#define SINK_DEBUG_STREAM_IMPL(LEVEL, AREA, COMPONENT) if (!Sink::Log::isFiltered(LEVEL, AREA, COMPONENT, __FILE__)) Sink::Log::debugStream(LEVEL, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
-#define Log_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
-#define Warning_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
+#define Trace_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, AREA, nullptr)
-#define Error_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
+#define Log_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, AREA, nullptr)
+#define Warning_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, AREA, nullptr)
-#define SinkTrace_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
+#define Error_area(AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, AREA, nullptr)
-#define SinkLog_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
-#define SinkWarning_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
+#define SinkTrace_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, AREA, COMPONENT)
-#define SinkError_(COMPONENT, AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, AREA, COMPONENT)
+#define SinkLog_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, AREA, COMPONENT)
+#define SinkWarning_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, AREA, COMPONENT)
-#define SinkTrace() Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
+#define SinkError_(COMPONENT, AREA) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, AREA, COMPONENT)
-#define SinkLog() Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
-#define SinkWarning() Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
+#define SinkTrace() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, nullptr, getComponentName())
-#define SinkError() Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, s_sinkDebugArea, getComponentName())
+#define SinkLog() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, nullptr, getComponentName())
+#define SinkWarning() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, nullptr, getComponentName())
-#define SinkTraceCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
+#define SinkError() SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, nullptr, getComponentName())
-#define SinkLogCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
-#define SinkWarningCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
+#define SinkTraceCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Trace, CTX.name, nullptr)
-#define SinkErrorCtx(CTX) Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, CTX.name)
+#define SinkLogCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Log, CTX.name, nullptr)
+#define SinkWarningCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Warning, CTX.name, nullptr)
+#define SinkErrorCtx(CTX) SINK_DEBUG_STREAM_IMPL(Sink::Log::DebugLevel::Error, CTX.name, nullptr)
 #define SINK_DEBUG_AREA(AREA) static constexpr const char* s_sinkDebugArea{AREA};
 #define SINK_DEBUG_COMPONENT(COMPONENT) const char* getComponentName() const { return COMPONENT; };
diff --git a/common/mail/threadindexer.cpp b/common/mail/threadindexer.cpp
index d91ab5f..4171d85 100644
--- a/common/mail/threadindexer.cpp
+++ b/common/mail/threadindexer.cpp
@@ -21,74 +21,15 @@
 #include "typeindex.h"
 #include "log.h"
-SINK_DEBUG_AREA("threadindex")
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
-static QString stripOffPrefixes(const QString &subject)
-{
-    //TODO this hardcoded list is probably not good enough (especially regarding internationalization)
-    //TODO this whole routine, including internationalized re/fwd ... should go into some library.
-    //We'll require the same for generating reply/forward subjects in kube
-    static QStringList defaultReplyPrefixes = QStringList() << QLatin1String("Re\\s*:")
-                                                            << QLatin1String("Re\\[\\d+\\]:")
-                                                            << QLatin1String("Re\\d+:");
-    static QStringList defaultForwardPrefixes = QStringList() << QLatin1String("Fwd:")
-                                                              << QLatin1String("FW:");
-    QStringList replyPrefixes; // = GlobalSettings::self()->replyPrefixes();
-    if (replyPrefixes.isEmpty()) {
-        replyPrefixes = defaultReplyPrefixes;
-    }
-    QStringList forwardPrefixes; // = GlobalSettings::self()->forwardPrefixes();
-    if (forwardPrefixes.isEmpty()) {
-        forwardPrefixes = defaultReplyPrefixes;
-    }
-    const QStringList prefixRegExps = replyPrefixes + forwardPrefixes;
-    // construct a big regexp that
-    // 1. is anchored to the beginning of str (sans whitespace)
-    // 2. matches at least one of the part regexps in prefixRegExps
-    const QString bigRegExp = QString::fromLatin1("^(?:\\s+|(?:%1))+\\s*").arg(prefixRegExps.join(QLatin1String(")|(?:")));
-    static QString regExpPattern;
-    static QRegExp regExp;
-    regExp.setCaseSensitivity(Qt::CaseInsensitive);
-    if (regExpPattern != bigRegExp) {
-        // the prefixes have changed, so update the regexp
-        regExpPattern = bigRegExp;
-        regExp.setPattern(regExpPattern);
-    }
-    if(regExp.isValid()) {
-        QString tmp = subject;
-        if (regExp.indexIn( tmp ) == 0) {
-            return tmp.remove(0, regExp.matchedLength());
-        }
-    } else {
-        SinkWarning() << "bigRegExp = \""
-                   << bigRegExp << "\"\n"
-                   << "prefix regexp is invalid!";
-    }
-    return subject;
-}
 void ThreadIndexer::updateThreadingIndex(const QByteArray &identifier, const ApplicationDomain::ApplicationDomainType &entity, Sink::Storage::DataStore::Transaction &transaction)
 {
    auto messageId = entity.getProperty(Mail::MessageId::name);
    auto parentMessageId = entity.getProperty(Mail::ParentMessageId::name);
-    const auto subject = entity.getProperty(Mail::Subject::name);
-    const auto normalizedSubject = stripOffPrefixes(subject.toString()).toUtf8();
    if (messageId.toByteArray().isEmpty()) {
        SinkWarning() << "Found an email without messageId. This is illegal and threading will break. Entity id: " << identifier;
-        SinkWarning() << "Subject: " << subject;
    }
    QVector<QByteArray> thread;
@@ -101,18 +42,9 @@ void ThreadIndexer::updateThreadingIndex(const QByteArray &identifier, const App
        thread = index().secondaryLookup<Mail::MessageId, Mail::ThreadId>(parentMessageId);
        SinkTrace() << "Found parent: " << thread;
    }
    if (thread.isEmpty()) {
-        //Try to lookup the thread by subject if not empty
+        thread << QUuid::createUuid().toByteArray();
-        if ( !normalizedSubject.isEmpty()) {
+        SinkTrace() << "Created a new thread: " << thread;
-            thread = index().secondaryLookup<Mail::Subject, Mail::ThreadId>(normalizedSubject);
-        }
-        if (thread.isEmpty()) {
-            thread << QUuid::createUuid().toByteArray();
-            SinkTrace() << "Created a new thread: " << thread;
-        } else {
-            SinkTrace() << "Found thread by subject: " << thread;
-        }
    }
    Q_ASSERT(!thread.isEmpty());
@@ -124,9 +56,6 @@ void ThreadIndexer::updateThreadingIndex(const QByteArray &identifier, const App
    }
    index().index<Mail::MessageId, Mail::ThreadId>(messageId, thread.first(), transaction);
    index().index<Mail::ThreadId, Mail::MessageId>(thread.first(), messageId, transaction);
-    if (!normalizedSubject.isEmpty()) {
-        index().index<Mail::Subject, Mail::ThreadId>(normalizedSubject, thread.first(), transaction);
-    }
 }
@@ -142,6 +71,15 @@ void ThreadIndexer::modify(const ApplicationDomain::ApplicationDomainType &old,
 void ThreadIndexer::remove(const ApplicationDomain::ApplicationDomainType &entity)
 {
+    auto messageId = entity.getProperty(Mail::MessageId::name);
+    auto thread = index().secondaryLookup<Mail::MessageId, Mail::ThreadId>(messageId);
+    index().unindex<Mail::MessageId, Mail::ThreadId>(messageId.toByteArray(), thread.first(), transaction());
+    index().unindex<Mail::ThreadId, Mail::MessageId>(thread.first(), messageId.toByteArray(), transaction());
+}
+QMap<QByteArray, int> ThreadIndexer::databases()
+{
+    return {{"mail.index.messageIdthreadId", 1},
+            {"mail.index.threadIdmessageId", 1}};
 }
diff --git a/common/mail/threadindexer.h b/common/mail/threadindexer.h
index 064ae71..60d0863 100644
--- a/common/mail/threadindexer.h
+++ b/common/mail/threadindexer.h
@@ -29,6 +29,7 @@ public:
    virtual void add(const ApplicationDomain::ApplicationDomainType &entity) Q_DECL_OVERRIDE;
    virtual void modify(const ApplicationDomain::ApplicationDomainType &old, const ApplicationDomain::ApplicationDomainType &entity) Q_DECL_OVERRIDE;
    virtual void remove(const ApplicationDomain::ApplicationDomainType &entity) Q_DECL_OVERRIDE;
+    static QMap<QByteArray, int> databases();
 private:
    void updateThreadingIndex(const QByteArray &identifier, const ApplicationDomain::ApplicationDomainType &entity, Sink::Storage::DataStore::Transaction &transaction);
 };
diff --git a/common/mailpreprocessor.cpp b/common/mailpreprocessor.cpp
index dff3b3d..5c54fbc 100644
--- a/common/mailpreprocessor.cpp
+++ b/common/mailpreprocessor.cpp
@@ -29,8 +29,6 @@
 using namespace Sink;
-SINK_DEBUG_AREA("mailpreprocessor")
 QString MailPropertyExtractor::getFilePathFromMimeMessagePath(const QString &s) const
 {
    return s;
diff --git a/common/messagequeue.cpp b/common/messagequeue.cpp
index 6e79d89..362ddfd 100644
--- a/common/messagequeue.cpp
+++ b/common/messagequeue.cpp
@@ -3,8 +3,6 @@
 #include <QDebug>
 #include <log.h>
-SINK_DEBUG_AREA("messagequeue")
 MessageQueue::MessageQueue(const QString &storageRoot, const QString &name) : mStorage(storageRoot, name, Sink::Storage::DataStore::ReadWrite)
 {
 }
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index b12216b..58703ab 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -224,7 +224,6 @@ QModelIndex ModelResult<T, Ptr>::index(int row, int column, const QModelIndex &p
        return createIndex(row, column, childId);
    }
    SinkWarningCtx(mLogCtx) << "Index not available " << row << column << parent;
-    Q_ASSERT(false);
    return QModelIndex();
 }
diff --git a/common/notification.cpp b/common/notification.cpp
index e688b6d..da31e20 100644
--- a/common/notification.cpp
+++ b/common/notification.cpp
@@ -48,8 +48,8 @@ static QByteArray name(int type)
 QDebug operator<<(QDebug dbg, const Sink::Notification &n)
 {
-    dbg << "Notification(Type: " << name(n.type) << "Id, : " << n.id  << ", Code: ";
+    dbg << "Notification(Type:" << name(n.type) << "Id, :" << n.id  << ", Code:";
    dbg << n.code;
-    dbg << ", Message: " << n.message << ", Entities: " << n.entities << ")";
+    dbg << ", Message:" << n.message << ", Entities:" << n.entities << ")";
    return dbg.space();
 }
diff --git a/common/notification.h b/common/notification.h
index f5379fd..30e240c 100644
--- a/common/notification.h
+++ b/common/notification.h
@@ -56,6 +56,8 @@ public:
    QString message;
    //A return code. Zero typically indicates success.
    int code = 0;
+    int progress = 0;
+    int total = 0;
    QByteArray resource;
 };
 }
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index f5cf995..f29c7db 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -283,6 +283,8 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
            case Preprocessor::DropModification:
                SinkTraceCtx(d->logCtx) << "Dropping modification";
                return KAsync::error<qint64>(0);
+            case Preprocessor::NoAction:
+            case Preprocessor::DeleteEntity:
            default:
                break;
        }
@@ -301,8 +303,8 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
                    SinkTraceCtx(d->logCtx) << "Move of " << current.identifier() << "was successfull";
                    if (isMove) {
                        flatbuffers::FlatBufferBuilder fbb;
-                        auto entityId = fbb.CreateString(current.identifier());
+                        auto entityId = fbb.CreateString(current.identifier().toStdString());
-                        auto type = fbb.CreateString(bufferType);
+                        auto type = fbb.CreateString(bufferType.toStdString());
                        auto location = Sink::Commands::CreateDeleteEntity(fbb, current.revision(), entityId, type, true);
                        Sink::Commands::FinishDeleteEntityBuffer(fbb, location);
                        const auto data = BufferUtils::extractBuffer(fbb);
@@ -448,8 +450,8 @@ void Preprocessor::createEntity(const Sink::ApplicationDomain::ApplicationDomain
    const auto entityBuffer = BufferUtils::extractBuffer(entityFbb);
    flatbuffers::FlatBufferBuilder fbb;
-    auto entityId = fbb.CreateString(entity.identifier());
+    auto entityId = fbb.CreateString(entity.identifier().toStdString());
-    auto type = fbb.CreateString(typeName);
+    auto type = fbb.CreateString(typeName.toStdString());
    auto delta = Sink::EntityBuffer::appendAsVector(fbb, entityBuffer.constData(), entityBuffer.size());
    auto location = Sink::Commands::CreateCreateEntity(fbb, entityId, type, delta);
    Sink::Commands::FinishCreateEntityBuffer(fbb, location);
diff --git a/common/propertymapper.cpp b/common/propertymapper.cpp
index c72cf31..dbf93a3 100644
--- a/common/propertymapper.cpp
+++ b/common/propertymapper.cpp
@@ -21,6 +21,7 @@
 #include "applicationdomaintype.h"
 #include <QDateTime>
+#include <QDataStream>
 #include "mail_generated.h"
 #include "contact_generated.h"
@@ -57,7 +58,9 @@ template <>
 flatbuffers::uoffset_t variantToProperty<QByteArray>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
 {
    if (property.isValid()) {
-        return fbb.CreateString(property.toByteArray().toStdString()).o;
+        const auto ba = property.toByteArray();
+        const auto s = fbb.CreateString(ba.constData(), ba.size());
+        return s.o;
    }
    return 0;
 }
@@ -66,7 +69,10 @@ template <>
 flatbuffers::uoffset_t variantToProperty<QDateTime>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
 {
    if (property.isValid()) {
-        return fbb.CreateString(property.toDateTime().toString().toStdString()).o;
+        QByteArray ba;
+        QDataStream ds(&ba, QIODevice::WriteOnly);
+        ds << property.toDateTime();
+        return fbb.CreateString(ba.toStdString()).o;
    }
    return 0;
 }
@@ -131,7 +137,7 @@ QString propertyToString(const flatbuffers::String *property)
 {
    if (property) {
        // We have to copy the memory, otherwise it would become eventually invalid
-        return QString::fromStdString(property->c_str());
+        return QString::fromStdString(property->str());
    }
    return QString();
 }
@@ -141,7 +147,7 @@ QVariant propertyToVariant<QString>(const flatbuffers::String *property)
 {
    if (property) {
        // We have to copy the memory, otherwise it would become eventually invalid
-        return QString::fromStdString(property->c_str());
+        return QString::fromStdString(property->str());
    }
    return QVariant();
 }
@@ -151,7 +157,7 @@ QVariant propertyToVariant<Sink::ApplicationDomain::BLOB>(const flatbuffers::Str
 {
    if (property) {
        // We have to copy the memory, otherwise it would become eventually invalid
-        auto s = QString::fromStdString(property->c_str());
+        auto s = QString::fromStdString(property->str());
        auto ext = s.endsWith(":ext");
        s.chop(4);
@@ -167,7 +173,7 @@ QVariant propertyToVariant<Sink::ApplicationDomain::Reference>(const flatbuffers
 {
    if (property) {
        // We have to copy the memory, otherwise it would become eventually invalid
-        return QVariant::fromValue(Sink::ApplicationDomain::Reference{QString::fromStdString(property->c_str()).toUtf8()});
+        return QVariant::fromValue(Sink::ApplicationDomain::Reference{QString::fromStdString(property->str()).toUtf8()});
    }
    return QVariant();
 }
@@ -177,7 +183,7 @@ QVariant propertyToVariant<QByteArray>(const flatbuffers::String *property)
 {
    if (property) {
        // We have to copy the memory, otherwise it would become eventually invalid
-        return QString::fromStdString(property->c_str()).toUtf8();
+        return QByteArray(property->c_str(), property->Length());
    }
    return QVariant();
 }
@@ -199,7 +205,7 @@ QVariant propertyToVariant<QByteArrayList>(const flatbuffers::Vector<flatbuffers
        QByteArrayList list;
        for (auto it = property->begin(); it != property->end();) {
            // We have to copy the memory, otherwise it would become eventually invalid
-            list << QString::fromStdString((*it)->c_str()).toUtf8();
+            list << QString::fromStdString((*it)->str()).toUtf8();
            it.operator++();
        }
        return QVariant::fromValue(list);
@@ -256,8 +262,11 @@ template <>
 QVariant propertyToVariant<QDateTime>(const flatbuffers::String *property)
 {
    if (property) {
-        // We have to copy the memory, otherwise it would become eventually invalid
+        auto ba = QByteArray::fromRawData(property->c_str(), property->size());
-        return QDateTime::fromString(QString::fromStdString(property->c_str()));
+        QDateTime dt;
+        QDataStream ds(&ba, QIODevice::ReadOnly);
+        ds >> dt;
+        return dt;
    }
    return QVariant();
 }
diff --git a/common/propertymapper.h b/common/propertymapper.h
index 9ea0b73..fd24278 100644
--- a/common/propertymapper.h
+++ b/common/propertymapper.h
@@ -65,13 +65,19 @@ QVariant SINK_EXPORT propertyToVariant(const flatbuffers::Vector<flatbuffers::Of
 * a virtual method per property, the property mapper can be filled with accessors
 * that extract the properties from resource types.
 */
-template <typename BufferType>
+class PropertyMapper
-class ReadPropertyMapper
 {
 public:
-    virtual ~ReadPropertyMapper(){};
+    virtual ~PropertyMapper(){};
-    virtual QVariant getProperty(const QByteArray &key, BufferType const *buffer) const
+    template <typename T, typename Buffer, typename BufferBuilder, typename FunctionReturnValue, typename Arg>
+    void addMapping(FunctionReturnValue (Buffer::*f)() const, void (BufferBuilder::*f2)(Arg))
+    {
+        addReadMapping<T, Buffer, FunctionReturnValue>(f);
+        addWriteMapping<T, BufferBuilder>(f2);
+    }
+    virtual QVariant getProperty(const QByteArray &key, void const *buffer) const
    {
        if (mReadAccessors.contains(key)) {
            auto accessor = mReadAccessors.value(key);
@@ -79,163 +85,69 @@ public:
        }
        return QVariant();
    }
-    bool hasMapping(const QByteArray &key) const
-    {
-        return mReadAccessors.contains(key);
-    }
-    QList<QByteArray> availableProperties() const
-    {
-        return mReadAccessors.keys();
-    }
-    void addMapping(const QByteArray &property, const std::function<QVariant(BufferType const *)> &mapping)
-    {
-        mReadAccessors.insert(property, mapping);
-    }
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::String *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-    template <typename T, typename Buffer>
-    void addMapping(uint8_t (Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-    template <typename T, typename Buffer>
-    void addMapping(bool (Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::Vector<uint8_t> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-    template <typename T, typename Buffer>
-    void addMapping(const Sink::ApplicationDomain::Buffer::MailContact *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-    template <typename T, typename Buffer>
-    void addMapping(const flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::MailContact>> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-    template <typename T, typename Buffer>
+    virtual void setProperty(const QByteArray &key, const QVariant &value, QList<std::function<void(void *builder)>> &builderCalls, flatbuffers::FlatBufferBuilder &fbb) const
-    void addMapping(const flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>> *(Buffer::*f)() const)
-    {
-        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
-    }
-private:
-    QHash<QByteArray, std::function<QVariant(BufferType const *)>> mReadAccessors;
-};
-template <typename BufferBuilder>
-class WritePropertyMapper
-{
-public:
-    virtual ~WritePropertyMapper(){};
-    virtual void setProperty(const QByteArray &key, const QVariant &value, QList<std::function<void(BufferBuilder &)>> &builderCalls, flatbuffers::FlatBufferBuilder &fbb) const
    {
        if (mWriteAccessors.contains(key)) {
            auto accessor = mWriteAccessors.value(key);
            builderCalls << accessor(value, fbb);
        }
    }
    bool hasMapping(const QByteArray &key) const
    {
-        return mWriteAccessors.contains(key);
+        return mReadAccessors.contains(key);
-    }
-    void addMapping(const QByteArray &property, const std::function<std::function<void(BufferBuilder &)>(const QVariant &, flatbuffers::FlatBufferBuilder &)> &mapping)
-    {
-        mWriteAccessors.insert(property, mapping);
    }
-    template <typename T>
+    QList<QByteArray> availableProperties() const
-    void addMapping(void (BufferBuilder::*f)(uint8_t))
    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        return mReadAccessors.keys();
-            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<typename T::Type>()); };
-        });
    }
-    template <typename T>
+private:
-    void addMapping(void (BufferBuilder::*f)(bool))
+    void addReadMapping(const QByteArray &property, const std::function<QVariant(void const *)> &mapping)
    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        mReadAccessors.insert(property, mapping);
-            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<typename T::Type>()); };
-        });
    }
-    template <typename T>
+    template <typename T, typename Buffer, typename FunctionReturnValue>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::String>))
+    void addReadMapping(FunctionReturnValue (Buffer::*f)() const)
    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        addReadMapping(T::name, [f](void const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((static_cast<const Buffer*>(buffer)->*f)()); });
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
-        });
    }
-    template <typename T>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<uint8_t>>))
-    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
-        });
-    }
-    template <typename T>
+    void addWriteMapping(const QByteArray &property, const std::function<std::function<void(void *builder)>(const QVariant &, flatbuffers::FlatBufferBuilder &)> &mapping)
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>))
    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        mWriteAccessors.insert(property, mapping);
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
-        });
    }
-    template <typename T>
+    template <typename T, typename BufferBuilder>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<Sink::ApplicationDomain::Buffer::MailContact>))
+    void addWriteMapping(void (BufferBuilder::*f)(uint8_t))
    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        addWriteMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(void *builder)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
+            return [value, f](void *builder) { (static_cast<BufferBuilder*>(builder)->*f)(value.value<typename T::Type>()); };
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
        });
    }
-    template <typename T>
+    template <typename T, typename BufferBuilder>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::MailContact>>>))
+    void addWriteMapping(void (BufferBuilder::*f)(bool))
    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        addWriteMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(void *builder)> {
-            auto offset = variantToProperty<typename T::Type>(value, fbb);
+            return [value, f](void *builder) { (static_cast<BufferBuilder*>(builder)->*f)(value.value<typename T::Type>()); };
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
        });
    }
-    template <typename T>
+    template <typename T, typename BufferBuilder, typename Arg>
-    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Sink::ApplicationDomain::Buffer::ContactEmail>>>))
+    void addWriteMapping(void (BufferBuilder::*f)(flatbuffers::Offset<Arg>))
    {
-        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+        addWriteMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(void *builder)> {
            auto offset = variantToProperty<typename T::Type>(value, fbb);
-            return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
+            return [offset, f](void *builder) { (static_cast<BufferBuilder*>(builder)->*f)(offset); };
        });
    }
-private:
+    QHash<QByteArray, std::function<QVariant(void const *)>> mReadAccessors;
-    QHash<QByteArray, std::function<std::function<void(BufferBuilder &)>(const QVariant &, flatbuffers::FlatBufferBuilder &)>> mWriteAccessors;
+    QHash<QByteArray, std::function<std::function<void(void *builder)>(const QVariant &, flatbuffers::FlatBufferBuilder &)>> mWriteAccessors;
 };
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index 43f48c0..f196965 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -231,11 +231,11 @@ ReplayResult QueryWorker<DomainType>::executeIncrementalQuery(const Sink::Query
    auto replayResult = resultSet.replaySet(0, 0, [this, query, &resultProvider](const ResultSet::Result &result) {
        resultProviderCallback(query, resultProvider, result);
    });
+    preparedQuery.updateComplete();
    SinkTraceCtx(mLogCtx) << "Replayed " << replayResult.replayedEntities << " results.\n"
        << (replayResult.replayedAll ? "Replayed all available results.\n" : "")
        << "Incremental query took: " << Log::TraceTime(time.elapsed());
-    return {entityStore.maxRevision(), replayResult.replayedEntities, replayResult.replayedAll, preparedQuery.getState()};
+    return {entityStore.maxRevision(), replayResult.replayedEntities, false, preparedQuery.getState()};
 }
 template <class DomainType>
@@ -264,7 +264,7 @@ ReplayResult QueryWorker<DomainType>::executeInitialQuery(
            return DataStoreQuery{modifiedQuery, ApplicationDomain::getTypeName<DomainType>(), entityStore};
        }
    }();
-    auto resultSet = preparedQuery.execute();;
+    auto resultSet = preparedQuery.execute();
    SinkTraceCtx(mLogCtx) << "Filtered set retrieved." << Log::TraceTime(time.elapsed());
    auto replayResult = resultSet.replaySet(0, batchsize, [this, query, &resultProvider](const ResultSet::Result &result) {
diff --git a/common/queryrunner.h b/common/queryrunner.h
index 5308eac..11a302f 100644
--- a/common/queryrunner.h
+++ b/common/queryrunner.h
@@ -32,8 +32,6 @@
 class QueryRunnerBase : public QObject
 {
    Q_OBJECT
-protected:
-    SINK_DEBUG_AREA("queryrunner")
 public:
    typedef std::function<void(Sink::ApplicationDomain::ApplicationDomainType &domainObject)> ResultTransformation;
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index ad8cae9..808d892 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -477,7 +477,7 @@ void ResourceAccess::connected()
    {
        flatbuffers::FlatBufferBuilder fbb;
-        auto name = fbb.CreateString(QString("PID: %1 ResourceAccess: %2").arg(QCoreApplication::applicationPid()).arg(reinterpret_cast<qlonglong>(this)).toLatin1());
+        auto name = fbb.CreateString(QString("PID: %1 ResourceAccess: %2").arg(QCoreApplication::applicationPid()).arg(reinterpret_cast<qlonglong>(this)).toLatin1().toStdString());
        auto command = Sink::Commands::CreateHandshake(fbb, name);
        Sink::Commands::FinishHandshakeBuffer(fbb, command);
        Commands::write(d->socket.data(), ++d->messageId, Commands::HandshakeCommand, fbb);
@@ -547,6 +547,8 @@ static Sink::Notification getNotification(const Sink::Commands::Notification *bu
    }
    n.type = buffer->type();
    n.code = buffer->code();
+    n.progress = buffer->progress();
+    n.total = buffer->total();
    n.entities = BufferUtils::fromVector(*buffer->entities());
    return n;
 }
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index c32566b..b6a0b34 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -101,7 +101,6 @@ protected:
 class SINK_EXPORT ResourceAccess : public ResourceAccessInterface
 {
    Q_OBJECT
-    SINK_DEBUG_AREA("communication")
 public:
    typedef QSharedPointer<ResourceAccess> Ptr;
@@ -158,7 +157,6 @@ private:
 */
 class SINK_EXPORT ResourceAccessFactory
 {
-    SINK_DEBUG_AREA("ResourceAccessFactory")
 public:
    static ResourceAccessFactory &instance();
    Sink::ResourceAccess::Ptr getAccess(const QByteArray &instanceIdentifier, const QByteArray resourceType);
diff --git a/common/resourcecontrol.cpp b/common/resourcecontrol.cpp
index 70a3f7d..b6a4c0b 100644
--- a/common/resourcecontrol.cpp
+++ b/common/resourcecontrol.cpp
@@ -30,8 +30,6 @@
 #include "log.h"
 #include "notifier.h"
-SINK_DEBUG_AREA("resourcecontrol")
 namespace Sink {
 KAsync::Job<void> ResourceControl::shutdown(const QByteArray &identifier)
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index dee0711..dab6aed 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -21,16 +21,12 @@
 #include "resourceconfig.h"
 #include "query.h"
 #include "definitions.h"
-#include "storage.h"
 #include "store.h"
 #include "resourceaccess.h"
 #include "resource.h"
-#include <QDir>
 using namespace Sink;
-SINK_DEBUG_AREA("ResourceFacade")
 template<typename DomainType>
 ConfigNotifier LocalStorageFacade<DomainType>::sConfigNotifier;
@@ -100,17 +96,24 @@ template<typename DomainType>
 LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query, const QByteArray &identifier, const QByteArray &typeName, ConfigNotifier &configNotifier, const Sink::Log::Context &ctx)
    : mResultProvider(new ResultProvider<typename DomainType::Ptr>), mConfigStore(identifier, typeName), mGuard(new QObject), mLogCtx(ctx.subContext("config"))
 {
+    auto matchesTypeAndIds = [query, this] (const QByteArray &type, const QByteArray &id) {
+        if (query.hasFilter(ApplicationDomain::SinkResource::ResourceType::name) && query.getFilter(ApplicationDomain::SinkResource::ResourceType::name).value.toByteArray() != type) {
+            SinkTraceCtx(mLogCtx) << "Skipping due to type.";
+            return false;
+        }
+        if (!query.ids().isEmpty() && !query.ids().contains(id)) {
+            return false;
+        }
+        return true;
+    };
    QObject *guard = new QObject;
-    mResultProvider->setFetcher([this, query, guard, &configNotifier](const QSharedPointer<DomainType> &) {
+    mResultProvider->setFetcher([this, query, guard, &configNotifier, matchesTypeAndIds](const QSharedPointer<DomainType> &) {
        const auto entries = mConfigStore.getEntries();
        for (const auto &res : entries.keys()) {
            const auto type = entries.value(res);
+            if (!matchesTypeAndIds(type, res)){
-            if (query.hasFilter(ApplicationDomain::SinkResource::ResourceType::name) && query.getFilter(ApplicationDomain::SinkResource::ResourceType::name).value.toByteArray() != type) {
-                SinkTraceCtx(mLogCtx) << "Skipping due to type.";
-                continue;
-            }
-            if (!query.ids().isEmpty() && !query.ids().contains(res)) {
                continue;
            }
            auto entity = readFromConfig<DomainType>(mConfigStore, res, type, query.requestedProperties);
@@ -128,8 +131,14 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
    });
    if (query.liveQuery()) {
        {
-            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::added, guard, [this](const ApplicationDomain::ApplicationDomainType::Ptr &entry) {
+            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::added, guard, [this, query, matchesTypeAndIds](const ApplicationDomain::ApplicationDomainType::Ptr &entry, const QByteArray &type) {
                auto entity = entry.staticCast<DomainType>();
+                if (!matchesTypeAndIds(type, entity->identifier())){
+                    return;
+                }
+                if (!matchesFilter(query.getBaseFilters(), *entity)){
+                    return;
+                }
                SinkTraceCtx(mLogCtx) << "A new resource has been added: " << entity->identifier();
                updateStatus(*entity);
                mResultProvider->add(entity);
@@ -137,8 +146,14 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
            Q_ASSERT(ret);
        }
        {
-            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::modified, guard, [this](const ApplicationDomain::ApplicationDomainType::Ptr &entry) {
+            auto ret = QObject::connect(&configNotifier, &ConfigNotifier::modified, guard, [this, query, matchesTypeAndIds](const ApplicationDomain::ApplicationDomainType::Ptr &entry, const QByteArray &type) {
                auto entity = entry.staticCast<DomainType>();
+                if (!matchesTypeAndIds(type, entity->identifier())){
+                    return;
+                }
+                if (!matchesFilter(query.getBaseFilters(), *entity)){
+                    return;
+                }
                updateStatus(*entity);
                mResultProvider->modify(entity);
            });
@@ -222,7 +237,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::create(const DomainType &domai
            }
            configStore.modify(identifier, configurationValues);
        }
-        sConfigNotifier.add(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}));
+        sConfigNotifier.add(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}), type);
    });
 }
@@ -251,7 +266,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::modify(const DomainType &domai
        }
        const auto type = configStore.getEntries().value(identifier);
-        sConfigNotifier.modify(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}));
+        sConfigNotifier.modify(::readFromConfig<DomainType>(configStore, identifier, type, QByteArrayList{}), type);
    });
 }
@@ -281,7 +296,7 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::remove(const DomainType &domai
        SinkTrace() << "Removing: " << identifier;
        auto configStore = ConfigStore(configStoreIdentifier, typeName);
        configStore.remove(identifier);
-        sConfigNotifier.remove(QSharedPointer<DomainType>::create(domainObject));
+        sConfigNotifier.remove(QSharedPointer<DomainType>::create(domainObject), typeName);
    });
 }
@@ -373,10 +388,10 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
            if (states.contains(ApplicationDomain::BusyStatus)) {
                return ApplicationDomain::BusyStatus;
            }
-            if (states.contains(ApplicationDomain::ConnectedStatus)) {
+            if (states.contains(ApplicationDomain::OfflineStatus)) {
-                return ApplicationDomain::ConnectedStatus;
+                return ApplicationDomain::OfflineStatus;
            }
-            return ApplicationDomain::OfflineStatus;
+            return ApplicationDomain::ConnectedStatus;
        }();
        account.setStatusStatus(status);
    });
diff --git a/common/resourcefacade.h b/common/resourcefacade.h
index 1cc075c..76fadce 100644
--- a/common/resourcefacade.h
+++ b/common/resourcefacade.h
@@ -36,24 +36,24 @@ class ConfigNotifier : public QObject
 {
    Q_OBJECT
 public:
-    void add(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account)
+    void add(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type)
    {
-        emit added(account);
+        emit added(account, type);
    }
-    void remove(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account)
+    void remove(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type)
    {
-        emit removed(account);
+        emit removed(account, type);
    }
-    void modify(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account)
+    void modify(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type)
    {
-        emit modified(account);
+        emit modified(account, type);
    }
 signals:
-    void added(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account);
+    void added(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type);
-    void removed(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account);
+    void removed(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type);
-    void modified(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account);
+    void modified(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &account, const QByteArray &type);
 };
 template <typename DomainType>
diff --git a/common/specialpurposepreprocessor.cpp b/common/specialpurposepreprocessor.cpp
index 25a6d1a..54f7f46 100644
--- a/common/specialpurposepreprocessor.cpp
+++ b/common/specialpurposepreprocessor.cpp
@@ -5,8 +5,6 @@
 using namespace Sink;
-SINK_DEBUG_AREA("SpecialPurposeProcessor")
 static QHash<QByteArray, QString> specialPurposeFolders()
 {
    QHash<QByteArray, QString> hash;
diff --git a/common/storage.h b/common/storage.h
index 71e9401..8c129df 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -25,10 +25,19 @@
 #include <string>
 #include <functional>
 #include <QString>
+#include <QMap>
 namespace Sink {
 namespace Storage {
+struct SINK_EXPORT DbLayout {
+    typedef QMap<QByteArray, int> Databases;
+    DbLayout();
+    DbLayout(const QByteArray &, const Databases &);
+    QByteArray name;
+    Databases tables;
+};
 class SINK_EXPORT DataStore
 {
 public:
@@ -132,7 +141,6 @@ public:
        void abort();
        QList<QByteArray> getDatabaseNames() const;
-        bool validateNamedDatabases();
        NamedDatabase openDatabase(const QByteArray &name = {"default"},
            const std::function<void(const DataStore::Error &error)> &errorHandler = {}, bool allowDuplicates = false) const;
@@ -152,6 +160,7 @@ public:
    };
    DataStore(const QString &storageRoot, const QString &name, AccessMode mode = ReadOnly);
+    DataStore(const QString &storageRoot, const DbLayout &layout, AccessMode mode = ReadOnly);
    ~DataStore();
    Transaction createTransaction(AccessMode mode = ReadWrite, const std::function<void(const DataStore::Error &error)> &errorHandler = std::function<void(const DataStore::Error &error)>());
diff --git a/common/storage/entitystore.cpp b/common/storage/entitystore.cpp
index b7309ab..22e5ae3 100644
--- a/common/storage/entitystore.cpp
+++ b/common/storage/entitystore.cpp
@@ -36,9 +36,75 @@
 using namespace Sink;
 using namespace Sink::Storage;
+static QMap<QByteArray, int> baseDbs()
+{
+    return {{"revisionType", 0},
+            {"revisions", 0},
+            {"uids", 0},
+            {"default", 0},
+            {"__flagtable", 0}};
+}
+template <typename T, typename First>
+void mergeImpl(T &map, First f)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+}
+template <typename T, typename First, typename ... Tail>
+void mergeImpl(T &map, First f, Tail ...maps)
+{
+    for (auto it = f.constBegin(); it != f.constEnd(); it++) {
+        map.insert(it.key(), it.value());
+    }
+    mergeImpl<T, Tail...>(map, maps...);
+}
+template <typename First, typename ... Tail>
+First merge(First f, Tail ...maps)
+{
+    First map;
+    mergeImpl(map, f, maps...);
+    return map;
+}
+template <class T>
+struct DbLayoutHelper {
+    void operator()(QMap<QByteArray, int> map) const {
+        mergeImpl(map, ApplicationDomain::TypeImplementation<T>::typeDatabases());
+    }
+};
+static Sink::Storage::DbLayout dbLayout(const QByteArray &instanceId)
+{
+    static auto databases = [] {
+        QMap<QByteArray, int> map;
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Mail>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Folder>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Contact>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Addressbook>::typeDatabases());
+        mergeImpl(map, ApplicationDomain::TypeImplementation<ApplicationDomain::Event>::typeDatabases());
+        return merge(baseDbs(), map);
+    }();
+    return {instanceId, databases};
+}
 class EntityStore::Private {
 public:
-    Private(const ResourceContext &context, const Sink::Log::Context &ctx) : resourceContext(context), logCtx(ctx.subContext("entitystore")) {}
+    Private(const ResourceContext &context, const Sink::Log::Context &ctx) : resourceContext(context), logCtx(ctx.subContext("entitystore"))
+    {
+        static bool initialized = false;
+        if (!initialized) {
+            if (QDir{}.mkpath(entityBlobStorageDir())) {
+                initialized = true;
+            } else {
+                SinkWarningCtx(logCtx) << "Failed to create the directory: " << entityBlobStorageDir();
+            }
+        }
+    }
    ResourceContext resourceContext;
    DataStore::Transaction transaction;
@@ -56,7 +122,7 @@ public:
            return transaction;
        }
-        Sink::Storage::DataStore store(Sink::storageLocation(), resourceContext.instanceId(), DataStore::ReadOnly);
+        Sink::Storage::DataStore store(Sink::storageLocation(), dbLayout(resourceContext.instanceId()), DataStore::ReadOnly);
        transaction = store.createTransaction(DataStore::ReadOnly);
        return transaction;
    }
@@ -93,9 +159,14 @@ public:
        return ApplicationDomain::ApplicationDomainType{resourceContext.instanceId(), uid, revision, adaptor};
    }
+    QString entityBlobStorageDir()
+    {
+        return Sink::resourceStorageLocation(resourceContext.instanceId()) + "/blob";
+    }
    QString entityBlobStoragePath(const QByteArray &id)
    {
-        return Sink::resourceStorageLocation(resourceContext.instanceId()) + "/blob/" + id;
+        return entityBlobStorageDir() +"/"+ id;
    }
 };
@@ -110,9 +181,8 @@ void EntityStore::startTransaction(Sink::Storage::DataStore::AccessMode accessMo
 {
    SinkTraceCtx(d->logCtx) << "Starting transaction: " << accessMode;
    Q_ASSERT(!d->transaction);
-    Sink::Storage::DataStore store(Sink::storageLocation(), d->resourceContext.instanceId(), accessMode);
+    Sink::Storage::DataStore store(Sink::storageLocation(), dbLayout(d->resourceContext.instanceId()), accessMode);
    d->transaction = store.createTransaction(accessMode);
-    Q_ASSERT(d->transaction.validateNamedDatabases());
 }
 void EntityStore::commitTransaction()
@@ -138,9 +208,6 @@ bool EntityStore::hasTransaction() const
 void EntityStore::copyBlobs(ApplicationDomain::ApplicationDomainType &entity, qint64 newRevision)
 {
    const auto directory = d->entityBlobStoragePath(entity.identifier());
-    if (!QDir().mkpath(directory)) {
-        SinkWarningCtx(d->logCtx) << "Failed to create the directory: " << directory;
-    }
    for (const auto &property : entity.changedProperties()) {
        const auto value = entity.getProperty(property);
@@ -149,7 +216,7 @@ void EntityStore::copyBlobs(ApplicationDomain::ApplicationDomainType &entity, qi
            //Any blob that is not part of the storage yet has to be moved there.
            if (blob.isExternal) {
                auto oldPath = blob.value;
-                auto filePath = directory + QString("/%1%2.blob").arg(QString::number(newRevision)).arg(QString::fromLatin1(property));
+                auto filePath = directory + QString("_%1%2.blob").arg(QString::number(newRevision)).arg(QString::fromLatin1(property));
                //In case we hit the same revision again due to a rollback.
                QFile::remove(filePath);
                QFile origFile(oldPath);
@@ -320,6 +387,11 @@ void EntityStore::cleanupEntityRevisionsUntil(qint64 revision)
 {
    const auto uid = DataStore::getUidFromRevision(d->transaction, revision);
    const auto bufferType = DataStore::getTypeFromRevision(d->transaction, revision);
+    if (bufferType.isEmpty() || uid.isEmpty()) {
+        SinkErrorCtx(d->logCtx) << "Failed to find revision during cleanup: " << revision;
+        Q_ASSERT(false);
+        return;
+    }
    SinkTraceCtx(d->logCtx) << "Cleaning up revision " << revision << uid << bufferType;
    DataStore::mainDatabase(d->transaction, bufferType)
        .scan(uid,
@@ -337,10 +409,10 @@ void EntityStore::cleanupEntityRevisionsUntil(qint64 revision)
                        DataStore::mainDatabase(d->transaction, bufferType).remove(key);
                    }
                    if (isRemoval) {
-                        const auto directory = d->entityBlobStoragePath(uid);
+                        QDir dir{d->entityBlobStorageDir()};
-                        QDir dir(directory);
+                        const auto infoList = dir.entryInfoList(QStringList{} << QString{uid + "*"});
-                        if (!dir.removeRecursively()) {
+                        for (const auto &fileInfo : infoList) {
-                            SinkErrorCtx(d->logCtx) << "Failed to cleanup: " << directory;
+                            QFile::remove(fileInfo.filePath());
                        }
                    }
                    //Don't cleanup more than specified
@@ -614,29 +686,6 @@ qint64 EntityStore::maxRevision()
    return DataStore::maxRevision(d->getTransaction());
 }
-/* DataStore::Transaction getTransaction() */
-/* { */
-/*     Sink::Storage::DataStore::Transaction transaction; */
-/*     { */
-/*         Sink::Storage::DataStore storage(Sink::storageLocation(), mResourceInstanceIdentifier); */
-/*         if (!storage.exists()) { */
-/*             //This is not an error if the resource wasn't started before */
-/*             SinkLogCtx(d->logCtx) << "Store doesn't exist: " << mResourceInstanceIdentifier; */
-/*             return Sink::Storage::DataStore::Transaction(); */
-/*         } */
-/*         storage.setDefaultErrorHandler([this](const Sink::Storage::DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Error during query: " << error.store << error.message; }); */
-/*         transaction = storage.createTransaction(Sink::Storage::DataStore::ReadOnly); */
-/*     } */
-/*     //FIXME this is a temporary measure to recover from a failure to open the named databases correctly. */
-/*     //Once the actual problem is fixed it will be enough to simply crash if we open the wrong database (which we check in openDatabase already). */
-/*     while (!transaction.validateNamedDatabases()) { */
-/*         Sink::Storage::DataStore storage(Sink::storageLocation(), mResourceInstanceIdentifier); */
-/*         transaction = storage.createTransaction(Sink::Storage::DataStore::ReadOnly); */
-/*     } */
-/*     return transaction; */
-/* } */
 Sink::Log::Context EntityStore::logContext() const
 {
    return d->logCtx;
diff --git a/common/storage_common.cpp b/common/storage_common.cpp
index 81a38c7..8603787 100644
--- a/common/storage_common.cpp
+++ b/common/storage_common.cpp
@@ -24,8 +24,6 @@
 #include "log.h"
 #include <QUuid>
-SINK_DEBUG_AREA("storage")
 QDebug& operator<<(QDebug &dbg, const Sink::Storage::DataStore::Error &error)
 {
    dbg << error.message << "Code: " << error.code << "Db: " << error.store;
@@ -38,6 +36,18 @@ namespace Storage {
 static const char *s_internalPrefix = "__internal";
 static const int s_internalPrefixSize = strlen(s_internalPrefix);
+DbLayout::DbLayout()
+{
+}
+DbLayout::DbLayout(const QByteArray &n, const Databases &t)
+    : name(n),
+    tables(t)
+{
+}
 void errorHandler(const DataStore::Error &error)
 {
    if (error.code == DataStore::TransactionError) {
@@ -113,7 +123,7 @@ QByteArray DataStore::getUidFromRevision(const DataStore::Transaction &transacti
    transaction.openDatabase("revisions")
        .scan(QByteArray::number(revision),
            [&](const QByteArray &, const QByteArray &value) -> bool {
-                uid = value;
+                uid = QByteArray{value.constData(), value.size()};
                return false;
            },
            [revision](const Error &error) { SinkWarning() << "Couldn't find uid for revision: " << revision << error.message; });
@@ -126,7 +136,7 @@ QByteArray DataStore::getTypeFromRevision(const DataStore::Transaction &transact
    transaction.openDatabase("revisionType")
        .scan(QByteArray::number(revision),
            [&](const QByteArray &, const QByteArray &value) -> bool {
-                type = value;
+                type = QByteArray{value.constData(), value.size()};
                return false;
            },
            [revision](const Error &error) { SinkWarning() << "Couldn't find type for revision " << revision; });
@@ -207,6 +217,11 @@ QByteArray DataStore::generateUid()
 DataStore::NamedDatabase DataStore::mainDatabase(const DataStore::Transaction &t, const QByteArray &type)
 {
+    if (type.isEmpty()) {
+        SinkError() << "Tried to open main database for empty type.";
+        Q_ASSERT(false);
+        return {};
+    }
    return t.openDatabase(type + ".main");
 }
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index 08eea37..f7999d1 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -35,9 +35,6 @@
 #include <lmdb.h>
 #include "log.h"
-SINK_DEBUG_AREA("storage")
-// SINK_DEBUG_COMPONENT(d->storageRoot.toLatin1() + '/' + d->name.toLatin1())
 namespace Sink {
 namespace Storage {
@@ -169,6 +166,27 @@ public:
            if (const int rc = mdb_dbi_open(transaction, db.constData(), flags, &dbi)) {
                //Create the db if it is not existing already
                if (rc == MDB_NOTFOUND && !readOnly) {
+                    //Sanity check db name
+                    {
+                        auto parts = db.split('.');
+                        for (const auto &p : parts) {
+                            auto containsSpecialCharacter = [] (const QByteArray &p) {
+                                for (int i = 0; i < p.size(); i++) {
+                                    const auto c = p.at(i);
+                                    //Between 0 and z in the ascii table. Essentially ensures that the name is printable and doesn't contain special chars
+                                    if (c < 0x30 || c > 0x7A) {
+                                        return true;
+                                    }
+                                }
+                                return false;
+                            };
+                            if (p.isEmpty() || containsSpecialCharacter(p)) {
+                                SinkError() << "Tried to create a db with an invalid name. Hex:" << db.toHex() << " ASCII:" << db;
+                                Q_ASSERT(false);
+                                throw std::runtime_error("Fatal error while creating db.");
+                            }
+                        }
+                    }
                    if (const int rc = mdb_dbi_open(transaction, db.constData(), flags | MDB_CREATE, &dbi)) {
                        SinkWarning() << "Failed to create db " << QByteArray(mdb_strerror(rc));
                        Error error(name.toLatin1(), ErrorCodes::GenericError, "Error while creating database: " + QByteArray(mdb_strerror(rc)));
@@ -542,6 +560,7 @@ DataStore::Transaction::Transaction(Transaction &&other) : d(nullptr)
 DataStore::Transaction &DataStore::Transaction::operator=(DataStore::Transaction &&other)
 {
    if (&other != this) {
+        abort();
        delete d;
        d = other.d;
        other.d = nullptr;
@@ -639,11 +658,6 @@ static bool ensureCorrectDb(DataStore::NamedDatabase &database, const QByteArray
    return !openedTheWrongDatabase;
 }
-bool DataStore::Transaction::validateNamedDatabases()
-{
-    return true;
-}
 DataStore::NamedDatabase DataStore::Transaction::openDatabase(const QByteArray &db, const std::function<void(const DataStore::Error &error)> &errorHandler, bool allowDuplicates) const
 {
    if (!d) {
@@ -694,7 +708,7 @@ QList<QByteArray> DataStore::Transaction::getDatabaseNames() const
 class DataStore::Private
 {
 public:
-    Private(const QString &s, const QString &n, AccessMode m);
+    Private(const QString &s, const QString &n, AccessMode m, const DbLayout &layout = {});
    ~Private();
    QString storageRoot;
@@ -702,68 +716,85 @@ public:
    MDB_env *env;
    AccessMode mode;
+    Sink::Log::Context logCtx;
+    void initEnvironment(const QString &fullPath, const DbLayout &layout)
+    {
+        // Ensure the environment is only created once, and that we only have one environment per process
+        if (!(env = sEnvironments.value(fullPath))) {
+            QMutexLocker locker(&sMutex);
+            if (!(env = sEnvironments.value(fullPath))) {
+                int rc = 0;
+                if ((rc = mdb_env_create(&env))) {
+                    SinkWarningCtx(logCtx) << "mdb_env_create: " << rc << " " << mdb_strerror(rc);
+                    qCritical() << "mdb_env_create: " << rc << " " << mdb_strerror(rc);
+                } else {
+                    //Limit large enough to accomodate all our named dbs. This only starts to matter if the number gets large, otherwise it's just a bunch of extra entries in the main table.
+                    mdb_env_set_maxdbs(env, 50);
+                    const bool readOnly = (mode == ReadOnly);
+                    unsigned int flags = MDB_NOTLS;
+                    if (readOnly) {
+                        flags |= MDB_RDONLY;
+                    }
+                    if ((rc = mdb_env_open(env, fullPath.toStdString().data(), flags, 0664))) {
+                        SinkWarningCtx(logCtx) << "mdb_env_open: " << rc << ":" << mdb_strerror(rc);
+                        mdb_env_close(env);
+                        env = 0;
+                    } else {
+                        if (RUNNING_ON_VALGRIND) {
+                            // In order to run valgrind this size must be smaller than half your available RAM
+                            // https://github.com/BVLC/caffe/issues/2404
+                            mdb_env_set_mapsize(env, (size_t)10485760 * (size_t)1000); // 1MB * 1000
+                        } else {
+                            //This is the maximum size of the db (but will not be used directly), so we make it large enough that we hopefully never run into the limit.
+                            mdb_env_set_mapsize(env, (size_t)10485760 * (size_t)100000); // 1MB * 1000
+                        }
+                        Q_ASSERT(env);
+                        sEnvironments.insert(fullPath, env);
+                        //Open all available dbi's
+                        bool noLock = true;
+                        auto t = Transaction(new Transaction::Private(readOnly, nullptr, name, env, noLock));
+                        if (!layout.tables.isEmpty()) {
+                            //TODO upgrade db if the layout has changed:
+                            //* read existing layout
+                            //* if layout is not the same create new layout
+                        //If the db is read only, abort if the db is not yet existing.
+                        //If the db is not read-only but is not existing, ensure we have a layout and create all tables.
+                            for (auto it = layout.tables.constBegin(); it != layout.tables.constEnd(); it++) {
+                                bool allowDuplicates = it.value();
+                                t.openDatabase(it.key(), {}, allowDuplicates);
+                            }
+                        } else {
+                            for (const auto &db : t.getDatabaseNames()) {
+                                //Get dbi to store for future use.
+                                t.openDatabase(db);
+                            }
+                        }
+                        //To persist the dbis (this is also necessary for read-only transactions)
+                        t.commit();
+                    }
+                }
+            }
+        }
+    }
 };
-DataStore::Private::Private(const QString &s, const QString &n, AccessMode m) : storageRoot(s), name(n), env(0), mode(m)
+DataStore::Private::Private(const QString &s, const QString &n, AccessMode m, const DbLayout &layout) : storageRoot(s), name(n), env(0), mode(m), logCtx(n.toLatin1())
 {
    const QString fullPath(storageRoot + '/' + name);
    QFileInfo dirInfo(fullPath);
    if (!dirInfo.exists() && mode == ReadWrite) {
        QDir().mkpath(fullPath);
        dirInfo.refresh();
    }
-    Sink::Log::Context logCtx{n.toLatin1()};
    if (mode == ReadWrite && !dirInfo.permission(QFile::WriteOwner)) {
        qCritical() << fullPath << "does not have write permissions. Aborting";
    } else if (dirInfo.exists()) {
-        // Ensure the environment is only created once
+        initEnvironment(fullPath, layout);
-        QMutexLocker locker(&sMutex);
-        /*
-        * It seems we can only ever have one environment open in the process.
-        * Otherwise multi-threading breaks.
-        */
-        env = sEnvironments.value(fullPath);
-        if (!env) {
-            int rc = 0;
-            if ((rc = mdb_env_create(&env))) {
-                // TODO: handle error
-                SinkWarningCtx(logCtx) << "mdb_env_create: " << rc << " " << mdb_strerror(rc);
-            } else {
-                mdb_env_set_maxdbs(env, 50);
-                unsigned int flags = MDB_NOTLS;
-                if (mode == ReadOnly) {
-                    flags |= MDB_RDONLY;
-                }
-                if ((rc = mdb_env_open(env, fullPath.toStdString().data(), flags, 0664))) {
-                    SinkWarningCtx(logCtx) << "mdb_env_open: " << rc << ":" << mdb_strerror(rc);
-                    mdb_env_close(env);
-                    env = 0;
-                } else {
-                    if (RUNNING_ON_VALGRIND) {
-                        // In order to run valgrind this size must be smaller than half your available RAM
-                        // https://github.com/BVLC/caffe/issues/2404
-                        const size_t dbSize = (size_t)10485760 * (size_t)1000; // 1MB * 1000
-                        mdb_env_set_mapsize(env, dbSize);
-                    } else {
-                        // FIXME: dynamic resize
-                        const size_t dbSize = (size_t)10485760 * (size_t)8000; // 1MB * 8000
-                        mdb_env_set_mapsize(env, dbSize);
-                    }
-                    sEnvironments.insert(fullPath, env);
-                    //Open all available dbi's
-                    bool noLock = true;
-                    bool requestedRead = m == ReadOnly;
-                    auto t = Transaction(new Transaction::Private(requestedRead, nullptr, name, env, noLock));
-                    for (const auto &db : t.getDatabaseNames()) {
-                        //Get dbi to store for future use.
-                        t.openDatabase(db);
-                    }
-                    //To persist the dbis (this is also necessary for read-only transactions)
-                    t.commit();
-                }
-            }
-        }
    }
 }
@@ -777,6 +808,10 @@ DataStore::DataStore(const QString &storageRoot, const QString &name, AccessMode
 {
 }
+DataStore::DataStore(const QString &storageRoot, const DbLayout &dbLayout, AccessMode mode) : d(new Private(storageRoot, dbLayout.name, mode, dbLayout))
+{
+}
 DataStore::~DataStore()
 {
    delete d;
diff --git a/common/store.cpp b/common/store.cpp
index d266098..4735113 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -36,8 +36,6 @@
 #include "storage.h"
 #include "log.h"
-SINK_DEBUG_AREA("store")
 Q_DECLARE_METATYPE(QSharedPointer<Sink::ResultEmitter<Sink::ApplicationDomain::SinkResource::Ptr>>)
 Q_DECLARE_METATYPE(QSharedPointer<Sink::ResourceAccessInterface>);
 Q_DECLARE_METATYPE(std::shared_ptr<void>);
@@ -277,6 +275,19 @@ KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
        });
 }
+KAsync::Job<void> Store::upgrade()
+{
+    SinkLog() << "Upgrading...";
+    return fetchAll<ApplicationDomain::SinkResource>({})
+        .template each([](const ApplicationDomain::SinkResource::Ptr &resource) -> KAsync::Job<void> {
+            SinkLog() << "Removing caches for " << resource->identifier();
+            return removeDataFromDisk(resource->identifier());
+        })
+        .then([] {
+            SinkLog() << "Upgrade complete.";
+        });
+}
 static KAsync::Job<void> synchronize(const QByteArray &resource, const Sink::SyncScope &scope)
 {
    SinkLog() << "Synchronizing " << resource << scope;
diff --git a/common/store.h b/common/store.h
index fae76e5..34e14df 100644
--- a/common/store.h
+++ b/common/store.h
@@ -122,6 +122,18 @@ KAsync::Job<void> SINK_EXPORT synchronize(const Sink::SyncScope &query);
 */
 KAsync::Job<void> SINK_EXPORT removeDataFromDisk(const QByteArray &resourceIdentifier);
+/**
+ * Run upgrade jobs.
+ *
+ * Run this to upgrade your local database to a new version.
+ * Note that this may:
+ * * take a while
+ * * remove some/all of your local caches
+ *
+ * Note: The initial implementation simply calls removeDataFromDisk for all resources.
+ */
+KAsync::Job<void> SINK_EXPORT upgrade();
 template <class DomainType>
 KAsync::Job<DomainType> SINK_EXPORT fetchOne(const Sink::Query &query);
diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index 3e7bd30..3b32e68 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -304,9 +304,29 @@ void Synchronizer::emitNotification(Notification::NoticationType type, int code,
    emit notify(n);
 }
-void Synchronizer::reportProgress(int progress, int total)
+void Synchronizer::emitProgressNotification(Notification::NoticationType type, int progress, int total, const QByteArray &id, const QByteArrayList &entities)
 {
-    SinkLogCtx(mLogCtx) << "Progress: " << progress << " out of " << total;
+    Sink::Notification n;
+    n.id = id;
+    n.type = type;
+    n.progress = progress;
+    n.total = total;
+    n.entities = entities;
+    emit notify(n);
+}
+void Synchronizer::reportProgress(int progress, int total, const QByteArrayList &entities)
+{
+    if (progress > 0 && total > 0) {
+        SinkLogCtx(mLogCtx) << "Progress: " << progress << " out of " << total << mCurrentRequest.requestId << mCurrentRequest.applicableEntities;
+        const auto applicableEntities = [&] {
+            if (entities.isEmpty()) {
+                return mCurrentRequest.applicableEntities;
+            }
+            return entities;
+        }();
+        emitProgressNotification(Notification::Progress, progress, total, mCurrentRequest.requestId, applicableEntities);
+    }
 }
 void Synchronizer::setStatusFromResult(const KAsync::Error &error, const QString &s, const QByteArray &requestId)
@@ -315,6 +335,9 @@ void Synchronizer::setStatusFromResult(const KAsync::Error &error, const QString
        if (error.errorCode == ApplicationDomain::ConnectionError) {
            //Couldn't connect, so we assume we don't have a network connection.
            setStatus(ApplicationDomain::OfflineStatus, s, requestId);
+        } else if (error.errorCode == ApplicationDomain::NoServerError) {
+            //Failed to contact the server.
+            setStatus(ApplicationDomain::OfflineStatus, s, requestId);
        } else if (error.errorCode == ApplicationDomain::ConfigurationError) {
            //There is an error with the configuration.
            setStatus(ApplicationDomain::ErrorStatus, s, requestId);
@@ -354,6 +377,7 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
    } else if (request.requestType == Synchronizer::SyncRequest::Synchronization) {
        return KAsync::start([this, request] {
            SinkLogCtx(mLogCtx) << "Synchronizing: " << request.query;
+            setBusy(true, "Synchronization has started.", request.requestId);
            emitNotification(Notification::Info, ApplicationDomain::SyncInProgress, {}, {}, request.applicableEntities);
        }).then(synchronizeWithSource(request.query)).then([this] {
            //Commit after every request, so implementations only have to commit more if they add a lot of data.
@@ -391,11 +415,12 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
            return KAsync::null();
        } else {
            return KAsync::start([this, request] {
+                setBusy(true, "ChangeReplay has started.", request.requestId);
                SinkLogCtx(mLogCtx) << "Replaying changes.";
            })
            .then(replayNextRevision())
            .then<void>([this, request](const KAsync::Error &error) {
-                setStatusFromResult(error, "Changereplay has ended.", "changereplay");
+                setStatusFromResult(error, "Changereplay has ended.", request.requestId);
                if (error) {
                    SinkWarningCtx(mLogCtx) << "Changereplay failed: " << error.errorMessage;
                    return KAsync::error(error);
@@ -462,16 +487,13 @@ KAsync::Job<void> Synchronizer::processSyncQueue()
        mMessageQueue->startTransaction();
        mEntityStore->startTransaction(Sink::Storage::DataStore::ReadOnly);
        mSyncInProgress = true;
-        if (request.requestType == Synchronizer::SyncRequest::Synchronization) {
+        mCurrentRequest = request;
-            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, request](const KAsync::Error &error) {
        SinkTraceCtx(mLogCtx) << "Sync request processed";
        setBusy(false, {}, request.requestId);
+        mCurrentRequest = {};
        mEntityStore->abortTransaction();
        mSyncTransaction.abort();
        mMessageQueue->commit();
@@ -516,7 +538,7 @@ void Synchronizer::revisionChanged()
            return;
        }
    }
-    mSyncRequestQueue << Synchronizer::SyncRequest{Synchronizer::SyncRequest::ChangeReplay};
+    mSyncRequestQueue << Synchronizer::SyncRequest{Synchronizer::SyncRequest::ChangeReplay, "changereplay"};
    processSyncQueue().exec();
 }
@@ -607,11 +629,14 @@ KAsync::Job<void> Synchronizer::replay(const QByteArray &type, const QByteArray
        }
    })
    .then([this](const KAsync::Error &error) {
+        //We need to commit here otherwise the next change-replay step will abort the transaction
+        mSyncStore.clear();
+        mSyncTransaction.commit();
        if (error) {
            SinkWarningCtx(mLogCtx) << "Failed to replay change: " << error.errorMessage;
+            return KAsync::error(error);
        }
-        mSyncStore.clear();
+        return KAsync::null();
-        mSyncTransaction.commit();
    });
 }
diff --git a/common/synchronizer.h b/common/synchronizer.h
index b1ee122..cc082be 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -131,6 +131,8 @@ protected:
            RequestFlush
        };
+        SyncRequest() = default;
        SyncRequest(const Sink::QueryBase &q, const QByteArray &requestId_ = QByteArray(), RequestOptions o = NoOptions)
            : requestId(requestId_),
            requestType(Synchronization),
@@ -145,6 +147,12 @@ protected:
        {
        }
+        SyncRequest(RequestType type, const QByteArray &requestId_)
+            : requestId(requestId_),
+            requestType(type)
+        {
+        }
        SyncRequest(RequestType type, int flushType_, const QByteArray &requestId_)
            : flushType(flushType_),
            requestId(requestId_),
@@ -184,11 +192,12 @@ protected:
    virtual void mergeIntoQueue(const Synchronizer::SyncRequest &request, QList<Synchronizer::SyncRequest> &queue);
    void emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id = QByteArray{}, const QByteArrayList &entiteis = QByteArrayList{});
+    void emitProgressNotification(Notification::NoticationType type, int progress, int total, const QByteArray &id, const QByteArrayList &entities);
    /**
     * Report progress for current task
     */
-    void reportProgress(int progress, int total);
+    virtual void reportProgress(int progress, int total, const QByteArrayList &entities = {}) Q_DECL_OVERRIDE;
 protected:
    Sink::Log::Context mLogCtx;
@@ -211,6 +220,7 @@ private:
    Sink::Storage::DataStore::Transaction mSyncTransaction;
    std::function<void(int commandId, const QByteArray &data)> mEnqueue;
    QList<SyncRequest> mSyncRequestQueue;
+    SyncRequest mCurrentRequest;
    MessageQueue *mMessageQueue;
    bool mSyncInProgress;
    QMultiHash<QByteArray, SyncRequest> mPendingSyncRequests;
diff --git a/common/synchronizerstore.cpp b/common/synchronizerstore.cpp
index 5364094..79cd920 100644
--- a/common/synchronizerstore.cpp
+++ b/common/synchronizerstore.cpp
@@ -25,8 +25,6 @@
 using namespace Sink;
-SINK_DEBUG_AREA("synchronizerstore")
 SynchronizerStore::SynchronizerStore(Sink::Storage::DataStore::Transaction &transaction)
    : mTransaction(transaction)
 {
diff --git a/common/test.cpp b/common/test.cpp
index 90586ba..237d3bb 100644
--- a/common/test.cpp
+++ b/common/test.cpp
@@ -29,8 +29,6 @@
 #include "resourceconfig.h"
 #include "definitions.h"
-SINK_DEBUG_AREA("test")
 using namespace Sink;
 void Sink::Test::initTest()
@@ -83,6 +81,7 @@ void Sink::Test::initTest()
 void Sink::Test::setTestModeEnabled(bool enabled)
 {
    QStandardPaths::setTestModeEnabled(enabled);
+    Sink::clearLocationCache();
    if (enabled) {
        qputenv("SINK_TESTMODE", "TRUE");
    } else {
diff --git a/common/typeindex.cpp b/common/typeindex.cpp
index 153aa43..5a19839 100644
--- a/common/typeindex.cpp
+++ b/common/typeindex.cpp
@@ -21,18 +21,20 @@
 #include "log.h"
 #include "index.h"
 #include <QDateTime>
+#include <QDataStream>
-SINK_DEBUG_AREA("typeindex")
 using namespace Sink;
 static QByteArray getByteArray(const QVariant &value)
 {
    if (value.type() == QVariant::DateTime) {
-        const auto result = value.toDateTime().toString().toLatin1();
+        QByteArray result;
-        if (result.isEmpty()) {
+        QDataStream ds(&result, QIODevice::WriteOnly);
-            return "nodate";
+        ds << value.toDateTime();
-        }
+        return result;
+    }
+    if (value.type() == QVariant::Bool) {
+        return value.toBool() ? "t" : "f";
    }
    if (value.canConvert<Sink::ApplicationDomain::Reference>()) {
        const auto ba = value.value<Sink::ApplicationDomain::Reference>().value;
@@ -85,6 +87,20 @@ void TypeIndex::addProperty<QByteArray>(const QByteArray &property)
 }
 template <>
+void TypeIndex::addProperty<bool>(const QByteArray &property)
+{
+    auto indexer = [this, property](bool add, const QByteArray &identifier, const QVariant &value, Sink::Storage::DataStore::Transaction &transaction) {
+        if (add) {
+            Index(indexName(property), transaction).add(getByteArray(value), identifier);
+        } else {
+            Index(indexName(property), transaction).remove(getByteArray(value), identifier);
+        }
+    };
+    mIndexer.insert(property, indexer);
+    mProperties << property;
+}
+template <>
 void TypeIndex::addProperty<QString>(const QByteArray &property)
 {
    auto indexer = [this, property](bool add, const QByteArray &identifier, const QVariant &value, Sink::Storage::DataStore::Transaction &transaction) {
@@ -266,6 +282,18 @@ void TypeIndex::index<QString, QByteArray>(const QByteArray &leftName, const QBy
 }
 template <>
+void TypeIndex::unindex<QByteArray, QByteArray>(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction)
+{
+    Index(indexName(leftName + rightName), transaction).remove(getByteArray(leftValue), getByteArray(rightValue));
+}
+template <>
+void TypeIndex::unindex<QString, QByteArray>(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction)
+{
+    Index(indexName(leftName + rightName), transaction).remove(getByteArray(leftValue), getByteArray(rightValue));
+}
+template <>
 QVector<QByteArray> TypeIndex::secondaryLookup<QByteArray>(const QByteArray &leftName, const QByteArray &rightName, const QVariant &value)
 {
    QVector<QByteArray> keys;
diff --git a/common/typeindex.h b/common/typeindex.h
index 1f216a7..890c3db 100644
--- a/common/typeindex.h
+++ b/common/typeindex.h
@@ -95,6 +95,15 @@ public:
    template <typename LeftType, typename RightType>
    void index(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction);
+    template <typename Left, typename Right>
+    void unindex(const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction)
+    {
+        index<typename Left::Type, typename Right::Type>(Left::name, Right::name, leftValue, rightValue, transaction);
+    }
+    template <typename LeftType, typename RightType>
+    void unindex(const QByteArray &leftName, const QByteArray &rightName, const QVariant &leftValue, const QVariant &rightValue, Sink::Storage::DataStore::Transaction &transaction);
 private:
    friend class Sink::Storage::EntityStore;