105 files changed, 1994 insertions, 1196 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6fa2c09..0bbd9f3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 2.8.12)
 option(BUILD_MAILDIR "BUILD_MAILDIR" ON)
 option(AVOID_BINDING_REBUILD "AVOID_BINDING_REBUILD" OFF)
+option(CATCH_ERRORS "CATCH_ERRORS" OFF)
 # ECM setup
 find_package(ECM 0.0.10 REQUIRED NO_MODULE)
@@ -41,8 +42,27 @@ function(generate_flatbuffers _target)
    endforeach(fbs)
 endfunction(generate_flatbuffers)
+add_custom_target(analyze)
+function(add_clang_static_analysis target)
+    get_target_property(SRCs ${target} SOURCES)
+    get_target_property(INCLUDEs ${target} INCLUDE_DIRECTORIES)
+    add_library(${target}_analyze OBJECT EXCLUDE_FROM_ALL ${SRCs})
+    set_target_properties(${target}_analyze PROPERTIES
+        COMPILE_OPTIONS "--analyze"
+        EXCLUDE_FROM_DEFAULT_BUILD true
+        INCLUDE_DIRECTORIES "${INCLUDEs};${KDE_INSTALL_FULL_INCLUDEDIR}/KF5/" # Had to hardcode include directory to find KAsync includes
+        #COMPILE_FLAGS is deprecated, but the only way that -Xanalyzer isn't erronously deduplicated
+        COMPILE_FLAGS "-Xanalyzer -analyzer-eagerly-assume -Xanalyzer -analyzer-opt-analyze-nested-blocks"
+    )
+    target_compile_options(${target}_analyze PRIVATE ${Qt5Core_EXECUTABLE_COMPILE_FLAGS})# Necessary to get options such as fPIC
+    add_dependencies(analyze ${target}_analyze)
+endfunction()
 set(CMAKE_AUTOMOC ON)
-add_definitions("-Wall -std=c++0x -g")
+if (${CATCH_ERRORS})
+    add_definitions("-Werror -Wall -Weverything -Wno-unused-function -Wno-cast-align -Wno-used-but-marked-unused -Wno-shadow -Wno-weak-vtables -Wno-global-constructors -Wno-deprecated -Wno-weak-template-vtables -Wno-exit-time-destructors -Wno-covered-switch-default -Wno-shorten-64-to-32 -Wno-documentation -Wno-old-style-cast -Wno-extra-semi -Wno-unused-parameter -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-padded -Wno-missing-noreturn -Wno-missing-prototypes -Wno-documentation-unknown-command -Wno-sign-conversion")
+endif()
+add_definitions("-std=c++0x -g")
 include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} ${FLATBUFFERS_INCLUDE_DIR} ${CMAKE_BINARY_DIR}/common)
 include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/common ${CMAKE_SOURCE_DIR}/common/domain)
diff --git a/README b/README.md
index 4ab63c6..e4a94a0 100644
--- a/README
+++ b/README.md
@@ -1,7 +1,8 @@
-This repository contains a draft of a possible successor to Akonadi 1.
+# Sink
-It is currently entirely experimental and should not be considered a definite
+Sink is a data access layer handling synchronization, caching and indexing.
-replacement for Akonadi 1 at this point in time.
+To build it's documentation please run the builddocs.sh script or see the docs/ subdirectory.
 Discussion of the code should be done on the kde-pim at kde.org mailing list
 or in #kontact on IRC.
@@ -13,7 +14,7 @@ development easy (and easy for others to coordinate with):
    https://github.com/nvie/gitflow
-You can find information about the overall design here:
+For further information see:
-    https://community.kde.org/KDE_PIM/Akonadi_Next
+    https://phabricator.kde.org/project/view/5/
diff --git a/builddocs.sh b/builddocs.sh
new file mode 100755
index 0000000..41e48a4
--- /dev/null
+++ b/builddocs.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+mkdocs build
+echo "The HTML files for the documentation can be found in the site/ subdirectory."
+echo "To view the docs in a browser run 'mkdocs serve'"
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index a80ef95..fe72605 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -1,41 +1,45 @@
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(domain)
-project(sinkcommon)
+project(sink)
-ecm_setup_version("0.1" VARIABLE_PREFIX SinkCommon
+ecm_setup_version("0.1" VARIABLE_PREFIX Sink
-                        VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/sinkcommon_version.h"
+                        VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/sink_version.h"
-                        PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/SinkCommonConfigVersion.cmake"
+                        PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/SinkConfigVersion.cmake"
                        SOVERSION 0
 )
 ########### CMake Config Files ###########
-set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/SinkCommon")
+set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/Sink")
 ecm_configure_package_config_file(
-  "${CMAKE_CURRENT_SOURCE_DIR}/SinkCommonConfig.cmake.in"
+  "${CMAKE_CURRENT_SOURCE_DIR}/SinkConfig.cmake.in"
-  "${CMAKE_CURRENT_BINARY_DIR}/SinkCommonConfig.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/SinkConfig.cmake"
  INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
 )
 install(FILES
-  "${CMAKE_CURRENT_BINARY_DIR}/SinkCommonConfig.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/SinkConfig.cmake"
-  "${CMAKE_CURRENT_BINARY_DIR}/SinkCommonConfigVersion.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/SinkConfigVersion.cmake"
  DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
  COMPONENT Devel
 )
-install(EXPORT SinkCommonTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE SinkCommonTargets.cmake)
+add_definitions("-fvisibility=hidden")
+install(EXPORT SinkTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE SinkTargets.cmake)
 set(storage_SRCS storage_lmdb.cpp)
 set(storage_LIBS lmdb)
 set(command_SRCS
+    store.cpp
+    notifier.cpp
+    resourcecontrol.cpp
    modelresult.cpp
    definitions.cpp
    log.cpp
    entitybuffer.cpp
-    clientapi.cpp
    facadefactory.cpp
    commands.cpp
    facade.cpp
@@ -85,7 +89,7 @@ generate_flatbuffers(
    queuedcommand
 )
-generate_export_header(${PROJECT_NAME} BASE_NAME SinkCommon EXPORT_FILE_NAME sinkcommon_export.h)
+generate_export_header(${PROJECT_NAME} BASE_NAME Sink EXPORT_FILE_NAME sink_export.h)
 SET_TARGET_PROPERTIES(${PROJECT_NAME}
    PROPERTIES LINKER_LANGUAGE CXX
    VERSION "0.1"
@@ -95,15 +99,20 @@ SET_TARGET_PROPERTIES(${PROJECT_NAME}
 qt5_use_modules(${PROJECT_NAME} Network)
 target_link_libraries(${PROJECT_NAME} ${storage_LIBS} KF5::Async)
 install(TARGETS ${PROJECT_NAME}
-    EXPORT SinkCommonTargets ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} ${LIBRARY_NAMELINK} )
+    EXPORT SinkTargets ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} ${LIBRARY_NAMELINK} )
+add_clang_static_analysis(${PROJECT_NAME})
 install(FILES
-    clientapi.h
+    store.h
+    notifier.h
+    resourcecontrol.h
    domain/applicationdomaintype.h
    query.h
    inspection.h
    notification.h
    bufferadaptor.h
+    ${CMAKE_CURRENT_BINARY_DIR}/sink_export.h
    DESTINATION ${INCLUDE_INSTALL_DIR}/${PROJECT_NAME} COMPONENT Devel
 )
diff --git a/common/SinkCommonConfig.cmake.in b/common/SinkConfig.cmake.in
index 6c2a1c2..930b2db 100644
--- a/common/SinkCommonConfig.cmake.in
+++ b/common/SinkConfig.cmake.in
@@ -2,4 +2,4 @@
 find_dependency(KF5Mime "@KMIME_LIB_VERSION@")
-include("${CMAKE_CURRENT_LIST_DIR}/SinkCommonTargets.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/SinkTargets.cmake")
diff --git a/common/clientapi.h b/common/clientapi.h
deleted file mode 100644
index 64c4f64..0000000
--- a/common/clientapi.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-#include <QString>
-#include <QSharedPointer>
-#include <Async/Async>
-#include "query.h"
-#include "inspection.h"
-#include "applicationdomaintype.h"
-class QAbstractItemModel;
-namespace Sink {
-class ResourceAccess;
-class Notification;
-/**
- * Store interface used in the client API.
- */
-class Store {
-public:
-    static QString storageLocation();
-    static QByteArray resourceName(const QByteArray &instanceIdentifier);
-    enum Roles {
-        DomainObjectRole = Qt::UserRole + 1, //Must be the same as in ModelResult
-        ChildrenFetchedRole,
-        DomainObjectBaseRole
-    };
-    /**
-     * Asynchronusly load a dataset with tree structure information
-     */
-    template <class DomainType>
-    static QSharedPointer<QAbstractItemModel> loadModel(Query query);
-    /**
-     * Create a new entity.
-     */
-    template <class DomainType>
-    static KAsync::Job<void> create(const DomainType &domainObject);
-    /**
-     * Modify an entity.
-     * 
-     * This includes moving etc. since these are also simple settings on a property.
-     */
-    template <class DomainType>
-    static KAsync::Job<void> modify(const DomainType &domainObject);
-    /**
-     * Remove an entity.
-     */
-    template <class DomainType>
-    static KAsync::Job<void> remove(const DomainType &domainObject);
-    /**
-     * Synchronize data to local cache.
-     */
-    static KAsync::Job<void> synchronize(const Sink::Query &query);
-    /**
-     * Shutdown resource.
-     */
-    static KAsync::Job<void> shutdown(const QByteArray &resourceIdentifier);
-    /**
-     * Start resource.
-     * 
-     * The resource is ready for operation once this command completes.
-     * This command is only necessary if a resource was shutdown previously,
-     * otherwise the resource process will automatically start as necessary.
-     */
-    static KAsync::Job<void> start(const QByteArray &resourceIdentifier);
-    /**
-     * Flushes any pending messages to disk
-     */
-    static KAsync::Job<void> flushMessageQueue(const QByteArrayList &resourceIdentifier);
-    /**
-     * Flushes any pending messages that haven't been replayed to the source.
-     */
-    static KAsync::Job<void> flushReplayQueue(const QByteArrayList &resourceIdentifier);
-    /**
-     * Removes a resource from disk.
-     */
-    static void removeFromDisk(const QByteArray &resourceIdentifier);
-    template <class DomainType>
-    static KAsync::Job<DomainType> fetchOne(const Sink::Query &query);
-    template <class DomainType>
-    static KAsync::Job<QList<typename DomainType::Ptr> > fetchAll(const Sink::Query &query);
-    template <class DomainType>
-    static KAsync::Job<QList<typename DomainType::Ptr> > fetch(const Sink::Query &query, int minimumAmount = 0);
-};
-namespace Resources {
-    template <class DomainType>
-    KAsync::Job<void> inspect(const Inspection &inspectionCommand);
-}
-class Notifier {
-public:
-    Notifier(const QSharedPointer<ResourceAccess> &resourceAccess);
-    // Notifier(const QByteArray &resource);
-    // Notifier(const QByteArrayList &resource);
-    void registerHandler(std::function<void(const Notification &)>);
-private:
-    class Private;
-    QScopedPointer<Private> d;
-};
-}
diff --git a/common/commands.cpp b/common/commands.cpp
index 8b915f0..5d38afa 100644
--- a/common/commands.cpp
+++ b/common/commands.cpp
@@ -61,6 +61,8 @@ QByteArray name(int commandId)
            return "RevisionReplayed";
        case InspectionCommand:
            return "Inspection";
+        case RemoveFromDiskCommand:
+            return "RemoveFromDisk";
        case CustomCommand:
            return "Custom";
    };
diff --git a/common/commands.h b/common/commands.h
index 19c827e..64abd76 100644
--- a/common/commands.h
+++ b/common/commands.h
@@ -20,7 +20,7 @@
 #pragma once
-#include <sinkcommon_export.h>
+#include "sink_export.h"
 #include <flatbuffers/flatbuffers.h>
 #include <QByteArray>
@@ -48,16 +48,17 @@ enum CommandIds {
    PingCommand,
    RevisionReplayedCommand,
    InspectionCommand,
+    RemoveFromDiskCommand,
    CustomCommand = 0xffff
 };
 QByteArray name(int commandId);
-int SINKCOMMON_EXPORT headerSize();
+int SINK_EXPORT headerSize();
-void SINKCOMMON_EXPORT write(QIODevice *device, int messageId, int commandId);
+void SINK_EXPORT write(QIODevice *device, int messageId, int commandId);
-void SINKCOMMON_EXPORT write(QIODevice *device, int messageId, int commandId, const char *buffer, uint size);
+void SINK_EXPORT write(QIODevice *device, int messageId, int commandId, const char *buffer, uint size);
-void SINKCOMMON_EXPORT write(QIODevice *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb);
+void SINK_EXPORT write(QIODevice *device, int messageId, int commandId, flatbuffers::FlatBufferBuilder &fbb);
 }
diff --git a/common/commands/notification.fbs b/common/commands/notification.fbs
index ff01fc5..8750ff5 100644
--- a/common/commands/notification.fbs
+++ b/common/commands/notification.fbs
@@ -1,6 +1,6 @@
 namespace Sink.Commands;
-enum NotificationType : byte { Shutdown = 1, Status, Warning, Progress, Inspection }
+enum NotificationType : byte { Shutdown = 1, Status, Warning, Progress, Inspection, RevisionUpdate }
 enum NotificationCode : byte { Success = 0, Failure = 1, UserCode }
 table Notification {
diff --git a/common/definitions.h b/common/definitions.h
index 5834f01..029d3f8 100644
--- a/common/definitions.h
+++ b/common/definitions.h
@@ -20,10 +20,11 @@
 #pragma once
+#include "sink_export.h"
 #include <QString>
 #include <QByteArray>
 namespace Sink {
-    QString storageLocation();
+    QString SINK_EXPORT storageLocation();
-    QByteArray resourceName(const QByteArray &instanceIdentifier);
+    QByteArray SINK_EXPORT resourceName(const QByteArray &instanceIdentifier);
 }
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index b0433be..df10327 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -64,6 +64,12 @@ ApplicationDomainType::~ApplicationDomainType()
 {
 }
+bool ApplicationDomainType::hasProperty(const QByteArray &key) const
+{
+    Q_ASSERT(mAdaptor);
+    return mAdaptor->availableProperties().contains(key);
+}
 QVariant ApplicationDomainType::getProperty(const QByteArray &key) const
 {
    Q_ASSERT(mAdaptor);
@@ -76,13 +82,18 @@ QVariant ApplicationDomainType::getProperty(const QByteArray &key) const
 void ApplicationDomainType::setProperty(const QByteArray &key, const QVariant &value)
 {
    Q_ASSERT(mAdaptor);
-    mChangeSet.insert(key, value);
+    mChangeSet.insert(key);
    mAdaptor->setProperty(key, value);
 }
+void ApplicationDomainType::setChangedProperties(const QSet<QByteArray> &changeset)
+{
+    mChangeSet = changeset;
+}
 QByteArrayList ApplicationDomainType::changedProperties() const
 {
-    return mChangeSet.keys();
+    return mChangeSet.toList();
 }
 qint64 ApplicationDomainType::revision() const
@@ -100,6 +111,36 @@ QByteArray ApplicationDomainType::identifier() const
    return mIdentifier;
 }
+Entity::~Entity()
+{
+}
+Event::~Event()
+{
+}
+Todo::~Todo()
+{
+}
+Mail::~Mail()
+{
+}
+Folder::~Folder()
+{
+}
+SinkResource::~SinkResource()
+{
+}
 template<>
 QByteArray getTypeName<Event>()
 {
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index 63f030c..32d8999 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -19,9 +19,11 @@
 */
 #pragma once
+#include "sink_export.h"
 #include <QSharedPointer>
 #include <QVariant>
 #include <QByteArray>
+#include <QDebug>
 #include "bufferadaptor.h"
 namespace Sink {
@@ -35,7 +37,7 @@ namespace ApplicationDomain {
 *
 * ApplicationDomainTypes don't adhere to any standard and are meant to be extended frequently (hence the non-typesafe interface).
 */
-class ApplicationDomainType {
+class SINK_EXPORT ApplicationDomainType {
 public:
    typedef QSharedPointer<ApplicationDomainType> Ptr;
@@ -55,16 +57,19 @@ public:
    virtual ~ApplicationDomainType();
-    virtual QVariant getProperty(const QByteArray &key) const;
+    bool hasProperty(const QByteArray &key) const;
-    virtual void setProperty(const QByteArray &key, const QVariant &value);
+    QVariant getProperty(const QByteArray &key) const;
-    virtual QByteArrayList changedProperties() const;
+    void setProperty(const QByteArray &key, const QVariant &value);
+    void setChangedProperties(const QSet<QByteArray> &changeset);
+    QByteArrayList changedProperties() const;
    qint64 revision() const;
    QByteArray resourceInstanceIdentifier() const;
    QByteArray identifier() const;
 private:
+    friend QDebug operator<<(QDebug, const ApplicationDomainType &);
    QSharedPointer<BufferAdaptor> mAdaptor;
-    QHash<QByteArray, QVariant> mChangeSet;
+    QSet<QByteArray> mChangeSet;
    /*
     * Each domain object needs to store the resource, identifier, revision triple so we can link back to the storage location.
     */
@@ -82,34 +87,50 @@ inline bool operator==(const ApplicationDomainType& lhs, const ApplicationDomain
            && lhs.resourceInstanceIdentifier() == rhs.resourceInstanceIdentifier();
 }
-struct Entity : public ApplicationDomainType {
+inline QDebug operator<< (QDebug d, const ApplicationDomainType &type)
+{
+    d << "ApplicationDomainType(\n";
+    for (const auto &property : type.mAdaptor->availableProperties()) {
+        d << " " << property << "\t" << type.getProperty(property) << "\n";
+    }
+    d << ")";
+    return d;
+}
+struct SINK_EXPORT Entity : public ApplicationDomainType {
    typedef QSharedPointer<Entity> Ptr;
    using ApplicationDomainType::ApplicationDomainType;
+    virtual ~Entity();
 };
-struct Event : public Entity {
+struct SINK_EXPORT Event : public Entity {
    typedef QSharedPointer<Event> Ptr;
    using Entity::Entity;
+    virtual ~Event();
 };
-struct Todo : public Entity {
+struct SINK_EXPORT Todo : public Entity {
    typedef QSharedPointer<Todo> Ptr;
    using Entity::Entity;
+    virtual ~Todo();
 };
-struct Calendar : public Entity {
+struct SINK_EXPORT Calendar : public Entity {
    typedef QSharedPointer<Calendar> Ptr;
    using Entity::Entity;
+    virtual ~Calendar();
 };
-struct Mail : public Entity {
+struct SINK_EXPORT Mail : public Entity {
    typedef QSharedPointer<Mail> Ptr;
    using Entity::Entity;
+    virtual ~Mail();
 };
-struct Folder : public Entity {
+struct SINK_EXPORT Folder : public Entity {
    typedef QSharedPointer<Folder> Ptr;
    using Entity::Entity;
+    virtual ~Folder();
 };
 /**
@@ -118,9 +139,10 @@ struct Folder : public Entity {
 * This type is used for configuration of resources,
 * and for creating and removing resource instances.
 */
-struct SinkResource : public ApplicationDomainType {
+struct SINK_EXPORT SinkResource : public ApplicationDomainType {
    typedef QSharedPointer<SinkResource> Ptr;
    using ApplicationDomainType::ApplicationDomainType;
+    virtual ~SinkResource();
 };
 /**
@@ -129,22 +151,22 @@ struct SinkResource : public ApplicationDomainType {
 * Do not store these types to disk, they may change over time.
 */
 template<class DomainType>
-QByteArray getTypeName();
+QByteArray SINK_EXPORT getTypeName();
 template<>
-QByteArray getTypeName<Event>();
+QByteArray SINK_EXPORT getTypeName<Event>();
 template<>
-QByteArray getTypeName<Todo>();
+QByteArray SINK_EXPORT getTypeName<Todo>();
 template<>
-QByteArray getTypeName<SinkResource>();
+QByteArray SINK_EXPORT getTypeName<SinkResource>();
 template<>
-QByteArray getTypeName<Mail>();
+QByteArray SINK_EXPORT getTypeName<Mail>();
 template<>
-QByteArray getTypeName<Folder>();
+QByteArray SINK_EXPORT getTypeName<Folder>();
 /**
 * Type implementation.
@@ -153,7 +175,7 @@ QByteArray getTypeName<Folder>();
 * Contains all non-resource specific, but type-specific code.
 */
 template<typename DomainType>
-class TypeImplementation;
+class SINK_EXPORT TypeImplementation;
 }
 }
diff --git a/common/domain/event.cpp b/common/domain/event.cpp
index 9f81eb8..4210125 100644
--- a/common/domain/event.cpp
+++ b/common/domain/event.cpp
@@ -69,6 +69,7 @@ QSharedPointer<ReadPropertyMapper<TypeImplementation<Event>::Buffer> > TypeImple
 {
    auto propertyMapper = QSharedPointer<ReadPropertyMapper<Buffer> >::create();
    propertyMapper->addMapping<QString, Buffer>("summary", &Buffer::summary);
+    propertyMapper->addMapping<QString, Buffer>("description", &Buffer::description);
    propertyMapper->addMapping<QString, Buffer>("uid", &Buffer::uid);
    propertyMapper->addMapping<QByteArray, Buffer>("attachment", &Buffer::attachment);
    return propertyMapper;
@@ -78,6 +79,7 @@ QSharedPointer<WritePropertyMapper<TypeImplementation<Event>::BufferBuilder> > T
 {
    auto propertyMapper = QSharedPointer<WritePropertyMapper<BufferBuilder> >::create();
    propertyMapper->addMapping<QString>("summary", &BufferBuilder::add_summary);
+    propertyMapper->addMapping<QString>("description", &BufferBuilder::add_description);
    propertyMapper->addMapping<QString>("uid", &BufferBuilder::add_uid);
    propertyMapper->addMapping<QByteArray>("attachment", &BufferBuilder::add_attachment);
    return propertyMapper;
diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index d43fad7..893c8d0 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -19,6 +19,7 @@
 #pragma once
+#include "sink_export.h"
 #include <QVariant>
 #include <QByteArray>
 #include <functional>
@@ -121,7 +122,7 @@ public:
 * 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, typename ResourceBuilder>
-class DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInterface
+class SINK_EXPORT DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInterface
 {
    typedef typename Sink::ApplicationDomain::TypeImplementation<DomainType>::Buffer LocalBuffer;
    typedef typename Sink::ApplicationDomain::TypeImplementation<DomainType>::BufferBuilder LocalBuilder;
diff --git a/common/domaintypeadaptorfactoryinterface.h b/common/domaintypeadaptorfactoryinterface.h
index d974bbf..4d0ce04 100644
--- a/common/domaintypeadaptorfactoryinterface.h
+++ b/common/domaintypeadaptorfactoryinterface.h
@@ -38,5 +38,11 @@ public:
    typedef QSharedPointer<DomainTypeAdaptorFactoryInterface> Ptr;
    virtual ~DomainTypeAdaptorFactoryInterface() {};
    virtual QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> createAdaptor(const Sink::Entity &entity) = 0;
+    /*
+     * Creates a buffer from @param domainType
+     *
+     * Note that this only serialized parameters that are part of ApplicationDomainType::changedProperties()
+     */
    virtual void createBuffer(const Sink::ApplicationDomain::ApplicationDomainType &domainType, flatbuffers::FlatBufferBuilder &fbb, void const *metadataData = 0, size_t metadataSize = 0) = 0;
 };
diff --git a/common/entitybuffer.cpp b/common/entitybuffer.cpp
index 0e5435a..b4a5cb2 100644
--- a/common/entitybuffer.cpp
+++ b/common/entitybuffer.cpp
@@ -18,6 +18,12 @@ EntityBuffer::EntityBuffer(const void *dataValue, int dataSize)
    }
 }
+EntityBuffer::EntityBuffer(const QByteArray &data)
+    : EntityBuffer(data.constData(), data.size())
+{
+}
 bool EntityBuffer::isValid() const
 {
    return mEntity;
@@ -25,6 +31,7 @@ bool EntityBuffer::isValid() const
 const Sink::Entity &EntityBuffer::entity()
 {
+    Q_ASSERT(mEntity);
    return *mEntity;
 }
diff --git a/common/entitybuffer.h b/common/entitybuffer.h
index c9c2453..474a619 100644
--- a/common/entitybuffer.h
+++ b/common/entitybuffer.h
@@ -1,14 +1,17 @@
 #pragma once
+#include "sink_export.h"
 #include <functional>
 #include <flatbuffers/flatbuffers.h>
+#include <QByteArray>
 namespace Sink {
 struct Entity;
-class EntityBuffer {
+class SINK_EXPORT EntityBuffer {
 public:
    EntityBuffer(const void *dataValue, int size);
+    EntityBuffer(const QByteArray &data);
    const uint8_t *resourceBuffer();
    const uint8_t *metadataBuffer();
    const uint8_t *localBuffer();
diff --git a/common/facade.cpp b/common/facade.cpp
index 8cb776c..1b91ce4 100644
--- a/common/facade.cpp
+++ b/common/facade.cpp
@@ -29,6 +29,14 @@
 using namespace Sink;
+#undef DEBUG_AREA
+#define DEBUG_AREA "client.facade"
+/**
+ * A factory for resource access instances that caches the instance for some time.
+ * 
+ * This avoids constantly recreating connections, and should allow a single process to have one connection per resource.
+ */
 class ResourceAccessFactory {
 public:
    static ResourceAccessFactory &instance()
@@ -140,6 +148,7 @@ QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr>
 {
    //The runner lives for the lifetime of the query
    auto runner = new QueryRunner<DomainType>(query, mResourceAccess, mResourceInstanceIdentifier, mDomainTypeAdaptorFactory, bufferTypeForDomainType());
+    runner->setResultTransformation(mResultTransformation);
    return qMakePair(KAsync::null<void>(), runner->emitter());
 }
diff --git a/common/facade.h b/common/facade.h
index c25464f..a85b1de 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -19,6 +19,7 @@
 #pragma once
+#include "sink_export.h"
 #include "facadeinterface.h"
 #include <QByteArray>
@@ -43,7 +44,7 @@ namespace Sink {
 * Additionally a resource only has to provide a synchronizer plugin to execute the synchronization
 */
 template <typename DomainType>
-class GenericFacade: public Sink::StoreFacade<DomainType>
+class SINK_EXPORT GenericFacade: public Sink::StoreFacade<DomainType>
 {
 public:
    /**
@@ -59,9 +60,10 @@ public:
    KAsync::Job<void> create(const DomainType &domainObject) Q_DECL_OVERRIDE;
    KAsync::Job<void> modify(const DomainType &domainObject) Q_DECL_OVERRIDE;
    KAsync::Job<void> remove(const DomainType &domainObject) Q_DECL_OVERRIDE;
-    QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> load(const Sink::Query &query) Q_DECL_OVERRIDE;
+    virtual QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> load(const Sink::Query &query) Q_DECL_OVERRIDE;
 protected:
+    std::function<void(Sink::ApplicationDomain::ApplicationDomainType &domainObject)> mResultTransformation;
    //TODO use one resource access instance per application & per resource
    QSharedPointer<Sink::ResourceAccessInterface> mResourceAccess;
    DomainTypeAdaptorFactoryInterface::Ptr mDomainTypeAdaptorFactory;
diff --git a/common/facadefactory.h b/common/facadefactory.h
index 3dca63b..ef2a3f9 100644
--- a/common/facadefactory.h
+++ b/common/facadefactory.h
@@ -20,6 +20,7 @@
 #pragma once
+#include "sink_export.h"
 #include <QByteArray>
 #include <QDebug>
 #include <QMutex>
@@ -37,7 +38,7 @@ namespace Sink {
 *
 * If we were to provide default implementations for certain capabilities. Here would be the place to do so.
 */
-class FacadeFactory {
+class SINK_EXPORT FacadeFactory {
 public:
    typedef std::function<std::shared_ptr<void>(const QByteArray &)> FactoryFunction;
diff --git a/common/genericresource.cpp b/common/genericresource.cpp
index c7326d3..2688df0 100644
--- a/common/genericresource.cpp
+++ b/common/genericresource.cpp
@@ -17,11 +17,17 @@
 #include <QUuid>
 #include <QDataStream>
+#include <QTime>
 static int sBatchSize = 100;
+//This interval directly affects the roundtrip time of single commands
+static int sCommitInterval = 10;
 using namespace Sink;
+#undef DEBUG_AREA
+#define DEBUG_AREA "resource.changereplay"
 /**
 * Replays changes from the storage one by one.
 *
@@ -87,7 +93,7 @@ public Q_SLOTS:
                const auto uid = Storage::getUidFromRevision(mainStoreTransaction, revision);
                const auto type = Storage::getTypeFromRevision(mainStoreTransaction, revision);
                const auto key = Storage::assembleKey(uid, revision);
-                mainStoreTransaction.openDatabase(type + ".main").scan(key, [&lastReplayedRevision, type, this](const QByteArray &key, const QByteArray &value) -> bool {
+                Storage::mainDatabase(mainStoreTransaction, type).scan(key, [&lastReplayedRevision, type, this](const QByteArray &key, const QByteArray &value) -> bool {
                    mReplayFunction(type, key, value).exec();
                    //TODO make for loop async, and pass to async replay function together with type
                    Trace() << "Replaying " << key;
@@ -110,6 +116,9 @@ private:
    ReplayFunction mReplayFunction;
 };
+#undef DEBUG_AREA
+#define DEBUG_AREA "resource.commandprocessor"
 /**
 * Drives the pipeline using the output from all command queues
 */
@@ -197,7 +206,6 @@ private slots:
            default:
                return KAsync::error<qint64>(-1, "Unhandled command");
        }
-        return KAsync::null<qint64>();
    }
    KAsync::Job<qint64, qint64> processQueuedCommand(const QByteArray &data)
@@ -226,15 +234,17 @@ private slots:
    //Process all messages of this queue
    KAsync::Job<void> processQueue(MessageQueue *queue)
    {
+        auto time = QSharedPointer<QTime>::create();
        return KAsync::start<void>([this](){
            mPipeline->startTransaction();
        }).then(KAsync::dowhile(
            [queue]() { return !queue->isEmpty(); },
-            [this, queue](KAsync::Future<void> &future) {
+            [this, queue, time](KAsync::Future<void> &future) {
-                queue->dequeueBatch(sBatchSize, [this](const QByteArray &data) {
+                queue->dequeueBatch(sBatchSize, [this, time](const QByteArray &data) {
-                        return KAsync::start<void>([this, data](KAsync::Future<void> &future) {
+                        time->start();
-                            processQueuedCommand(data).then<void, qint64>([&future, this](qint64 createdRevision) {
+                        return KAsync::start<void>([this, data, time](KAsync::Future<void> &future) {
-                                Trace() << "Created revision " << createdRevision;
+                            processQueuedCommand(data).then<void, qint64>([&future, this, time](qint64 createdRevision) {
+                                Trace() << "Created revision " << createdRevision << ". Processing took: " << Log::TraceTime(time->elapsed());
                                future.setFinished();
                            }).exec();
                        });
@@ -256,21 +266,27 @@ private slots:
    KAsync::Job<void> processPipeline()
    {
+        auto time = QSharedPointer<QTime>::create();
+        time->start();
        mPipeline->startTransaction();
        Trace() << "Cleaning up from " << mPipeline->cleanedUpRevision() + 1 << " to " << mLowerBoundRevision;
        for (qint64 revision = mPipeline->cleanedUpRevision() + 1; revision <= mLowerBoundRevision; revision++) {
            mPipeline->cleanupRevision(revision);
        }
        mPipeline->commit();
+        Trace() << "Cleanup done." << Log::TraceTime(time->elapsed());
        //Go through all message queues
        auto it = QSharedPointer<QListIterator<MessageQueue*> >::create(mCommandQueues);
        return KAsync::dowhile(
            [it]() { return it->hasNext(); },
            [it, this](KAsync::Future<void> &future) {
+                auto time = QSharedPointer<QTime>::create();
+                time->start();
                auto queue = it->next();
-                processQueue(queue).then<void>([&future]() {
+                processQueue(queue).then<void>([&future, time]() {
-                    Trace() << "Queue processed";
+                    Trace() << "Queue processed." << Log::TraceTime(time->elapsed());
                    future.setFinished();
                }).exec();
            }
@@ -287,6 +303,8 @@ private:
    InspectionFunction mInspect;
 };
+#undef DEBUG_AREA
+#define DEBUG_AREA "resource"
 GenericResource::GenericResource(const QByteArray &resourceInstanceIdentifier, const QSharedPointer<Pipeline> &pipeline)
    : Sink::Resource(),
@@ -313,12 +331,14 @@ GenericResource::GenericResource(const QByteArray &resourceInstanceIdentifier, c
            QVariant expectedValue;
            s >> expectedValue;
            inspect(inspectionType, inspectionId, domainType, entityId, property, expectedValue).then<void>([=]() {
+                Log_area("resource.inspection") << "Inspection was successful: " << inspectionType << inspectionId << entityId;
                Sink::Notification n;
                n.type = Sink::Commands::NotificationType_Inspection;
                n.id = inspectionId;
                n.code = Sink::Commands::NotificationCode_Success;
                emit notify(n);
            }, [=](int code, const QString &message) {
+                Log() << "Inspection failed: "<< inspectionType << inspectionId << entityId << message;
                Sink::Notification n;
                n.type = Sink::Commands::NotificationType_Inspection;
                n.message = message;
@@ -341,7 +361,7 @@ GenericResource::GenericResource(const QByteArray &resourceInstanceIdentifier, c
    mClientLowerBoundRevision = mPipeline->cleanedUpRevision();
    mProcessor->setOldestUsedRevision(mSourceChangeReplay->getLastReplayedRevision());
-    mCommitQueueTimer.setInterval(100);
+    mCommitQueueTimer.setInterval(sCommitInterval);
    mCommitQueueTimer.setSingleShot(true);
    QObject::connect(&mCommitQueueTimer, &QTimer::timeout, &mUserQueue, &MessageQueue::commit);
 }
@@ -381,13 +401,18 @@ KAsync::Job<void> GenericResource::replay(Sink::Storage &synchronizationStore, c
    return KAsync::null<void>();
 }
+void GenericResource::removeDataFromDisk()
+{
+    removeFromDisk(mResourceInstanceIdentifier);
+}
 void GenericResource::removeFromDisk(const QByteArray &instanceIdentifier)
 {
-    Warning() << "Removing from generic resource";
    Sink::Storage(Sink::storageLocation(), instanceIdentifier, Sink::Storage::ReadWrite).removeFromDisk();
    Sink::Storage(Sink::storageLocation(), instanceIdentifier + ".userqueue", Sink::Storage::ReadWrite).removeFromDisk();
    Sink::Storage(Sink::storageLocation(), instanceIdentifier + ".synchronizerqueue", Sink::Storage::ReadWrite).removeFromDisk();
    Sink::Storage(Sink::storageLocation(), instanceIdentifier + ".changereplay", Sink::Storage::ReadWrite).removeFromDisk();
+    Sink::Storage(Sink::storageLocation(), instanceIdentifier + ".synchronization", Sink::Storage::ReadWrite).removeFromDisk();
 }
 qint64 GenericResource::diskUsage(const QByteArray &instanceIdentifier)
@@ -556,38 +581,39 @@ void GenericResource::deleteEntity(const QByteArray &sinkId, qint64 revision, co
 void GenericResource::recordRemoteId(const QByteArray &bufferType, const QByteArray &localId, const QByteArray &remoteId, Sink::Storage::Transaction &transaction)
 {
-    Index index("rid.mapping." + bufferType, transaction);
+    Index("rid.mapping." + bufferType, transaction).add(remoteId, localId);;
-    Index localIndex("localid.mapping." + bufferType, transaction);
+    Index("localid.mapping." + bufferType, transaction).add(localId, remoteId);
-    index.add(remoteId, localId);
-    localIndex.add(localId, remoteId);
 }
 void GenericResource::removeRemoteId(const QByteArray &bufferType, const QByteArray &localId, const QByteArray &remoteId, Sink::Storage::Transaction &transaction)
 {
-    Index index("rid.mapping." + bufferType, transaction);
+    Index("rid.mapping." + bufferType, transaction).remove(remoteId, localId);
-    Index localIndex("localid.mapping." + bufferType, transaction);
+    Index("localid.mapping." + bufferType, transaction).remove(localId, remoteId);
-    index.remove(remoteId, localId);
+}
-    localIndex.remove(localId, remoteId);
+void GenericResource::updateRemoteId(const QByteArray &bufferType, const QByteArray &localId, const QByteArray &remoteId, Sink::Storage::Transaction &transaction)
+{
+    const auto oldRemoteId = Index("localid.mapping." + bufferType, transaction).lookup(localId);
+    removeRemoteId(bufferType, localId, oldRemoteId, transaction);
+    recordRemoteId(bufferType, localId, remoteId, transaction);
 }
 QByteArray GenericResource::resolveRemoteId(const QByteArray &bufferType, const QByteArray &remoteId, Sink::Storage::Transaction &transaction)
 {
    //Lookup local id for remote id, or insert a new pair otherwise
    Index index("rid.mapping." + bufferType, transaction);
-    Index localIndex("localid.mapping." + bufferType, transaction);
    QByteArray sinkId = index.lookup(remoteId);
    if (sinkId.isEmpty()) {
        sinkId = QUuid::createUuid().toString().toUtf8();
        index.add(remoteId, sinkId);
-        localIndex.add(sinkId, remoteId);
+        Index("localid.mapping." + bufferType, transaction).add(sinkId, remoteId);
    }
    return sinkId;
 }
 QByteArray GenericResource::resolveLocalId(const QByteArray &bufferType, const QByteArray &localId, Sink::Storage::Transaction &transaction)
 {
-    Index index("localid.mapping." + bufferType, transaction);
+    QByteArray remoteId = Index("localid.mapping." + bufferType, transaction).lookup(localId);
-    QByteArray remoteId = index.lookup(localId);
    if (remoteId.isEmpty()) {
        Warning() << "Couldn't find the remote id for " << localId;
        return QByteArray();
@@ -633,7 +659,7 @@ static QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> getLatest(const Si
 void GenericResource::createOrModify(Sink::Storage::Transaction &transaction, Sink::Storage::Transaction &synchronizationTransaction, DomainTypeAdaptorFactoryInterface &adaptorFactory, const QByteArray &bufferType, const QByteArray &remoteId, const Sink::ApplicationDomain::ApplicationDomainType &entity)
 {
-    auto mainDatabase = transaction.openDatabase(bufferType + ".main");
+    auto mainDatabase = Storage::mainDatabase(transaction, bufferType);
    const auto sinkId = resolveRemoteId(bufferType, remoteId, synchronizationTransaction);
    const auto found = mainDatabase.contains(sinkId);
    if (!found) {
@@ -663,4 +689,7 @@ void GenericResource::createOrModify(Sink::Storage::Transaction &transaction, Si
 }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
 #include "genericresource.moc"
+#pragma clang diagnostic pop
diff --git a/common/genericresource.h b/common/genericresource.h
index 4ae2645..ceb6b61 100644
--- a/common/genericresource.h
+++ b/common/genericresource.h
@@ -19,7 +19,7 @@
 */
 #pragma once
-#include <sinkcommon_export.h>
+#include "sink_export.h"
 #include <resource.h>
 #include <messagequeue.h>
 #include <flatbuffers/flatbuffers.h>
@@ -37,7 +37,7 @@ class Preprocessor;
 /**
 * Generic Resource implementation.
 */
-class SINKCOMMON_EXPORT GenericResource : public Resource
+class SINK_EXPORT GenericResource : public Resource
 {
 public:
    GenericResource(const QByteArray &resourceInstanceIdentifier, const QSharedPointer<Pipeline> &pipeline = QSharedPointer<Pipeline>());
@@ -52,6 +52,7 @@ public:
    int error() const;
+    void removeDataFromDisk() Q_DECL_OVERRIDE;
    static void removeFromDisk(const QByteArray &instanceIdentifier);
    static qint64 diskUsage(const QByteArray &instanceIdentifier);
@@ -74,6 +75,7 @@ protected:
     */
    void recordRemoteId(const QByteArray &bufferType, const QByteArray &localId, const QByteArray &remoteId, Sink::Storage::Transaction &transaction);
    void removeRemoteId(const QByteArray &bufferType, const QByteArray &localId, const QByteArray &remoteId, Sink::Storage::Transaction &transaction);
+    void updateRemoteId(const QByteArray &bufferType, const QByteArray &localId, const QByteArray &remoteId, Sink::Storage::Transaction &transaction);
    /**
     * Tries to find a local id for the remote id, and creates a new local id otherwise.
diff --git a/common/index.h b/common/index.h
index 20213b2..1a5b250 100644
--- a/common/index.h
+++ b/common/index.h
@@ -1,5 +1,6 @@
 #pragma once
+#include "sink_export.h"
 #include <string>
 #include <functional>
 #include <QString>
@@ -8,7 +9,7 @@
 /**
 * An index for value pairs.
 */
-class Index
+class SINK_EXPORT Index
 {
 public:
    enum ErrorCodes {
diff --git a/common/inspection.h b/common/inspection.h
index b9f6bf3..d85eab6 100644
--- a/common/inspection.h
+++ b/common/inspection.h
@@ -24,7 +24,7 @@
 #include "applicationdomaintype.h"
 namespace Sink {
-    namespace Resources {
+    namespace ResourceControl {
 struct Inspection {
    static Inspection PropertyInspection(const Sink::ApplicationDomain::Entity &entity, const QByteArray &property, const QVariant &expectedValue)
diff --git a/common/listener.cpp b/common/listener.cpp
index 13ebbbb..ed6f305 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -39,6 +39,9 @@
 #include <QTime>
 #include <QDataStream>
+#undef DEBUG_AREA
+#define DEBUG_AREA "resource.communication"
 Listener::Listener(const QByteArray &resourceInstanceIdentifier, QObject *parent)
    : QObject(parent),
      m_server(new QLocalServer(this)),
@@ -234,7 +237,7 @@ void Listener::processCommand(int commandId, uint messageId, const QByteArray &c
                    job = job.then<void>(loadResource()->processAllMessages());
                }
                job.then<void>([callback, timer]() {
-                    Trace() << "Sync took " << timer->elapsed();
+                    Trace() << "Sync took " << Sink::Log::TraceTime(timer->elapsed());
                    callback(true);
                }).exec();
                return;
@@ -272,6 +275,14 @@ void Listener::processCommand(int commandId, uint messageId, const QByteArray &c
            loadResource()->setLowerBoundRevision(lowerBoundRevision());
        }
            break;
+        case Sink::Commands::RemoveFromDiskCommand: {
+            Log() << QString("\tReceived a remove from disk command from %1").arg(client.name);
+            m_resource->removeDataFromDisk();
+            delete m_resource;
+            m_resource = nullptr;
+            loadResource()->setLowerBoundRevision(0);
+        }
+            break;
        default:
            if (commandId > Sink::Commands::CustomCommand) {
                Log() << QString("\tReceived custom command from %1: ").arg(client.name) << commandId;
@@ -424,3 +435,7 @@ Sink::Resource *Listener::loadResource()
    return m_resource;
 }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
+#include "moc_listener.cpp"
+#pragma clang diagnostic pop
diff --git a/common/listener.h b/common/listener.h
index e17f315..5bcc93e 100644
--- a/common/listener.h
+++ b/common/listener.h
@@ -19,6 +19,7 @@
 #pragma once
+#include "sink_export.h"
 #include <QObject>
 #include <QPointer>
@@ -56,7 +57,7 @@ public:
    qint64 currentRevision;
 };
-class Listener : public QObject
+class SINK_EXPORT Listener : public QObject
 {
    Q_OBJECT
diff --git a/common/listmodelresult.h b/common/listmodelresult.h
deleted file mode 100644
index 71a0d09..0000000
--- a/common/listmodelresult.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) version 3, or any
- * later version accepted by the membership of KDE e.V. (or its
- * successor approved by the membership of KDE e.V.), which shall
- * act as a proxy defined in Section 6 of version 3 of the license.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-#include <QAbstractListModel>
-#include <QDebug>
-#include "resultprovider.h"
-enum Roles {
-    DomainObjectRole = Qt::UserRole + 1
-};
-template<class T>
-class ListModelResult : public QAbstractListModel
-{
-public:
-    ListModelResult(const QList<QByteArray> &propertyColumns)
-        :QAbstractListModel(),
-        mPropertyColumns(propertyColumns)
-    {
-    }
-    ListModelResult(const QSharedPointer<Sink::ResultEmitter<T> > &emitter, const QList<QByteArray> &propertyColumns)
-        :QAbstractListModel(),
-        mPropertyColumns(propertyColumns)
-    {
-        setEmitter(emitter);
-    }
-    void setEmitter(const QSharedPointer<Sink::ResultEmitter<T> > &emitter)
-    {
-        beginResetModel();
-        mEntities.clear();
-        mEmitter = emitter;
-        emitter->onAdded([this](const T &value) {
-            const auto keys = mEntities.keys();
-            int index = 0;
-            for (; index < keys.size(); index++) {
-                if (value->identifier() < keys.at(index)) {
-                    break;
-                }
-            }
-            beginInsertRows(QModelIndex(), index, index);
-            mEntities.insert(value->identifier(), value);
-            endInsertRows();
-        });
-        emitter->onModified([this](const T &value) {
-            auto i = mEntities.keys().indexOf(value->identifier());
-            mEntities.remove(value->identifier());
-            mEntities.insert(value->identifier(), value);
-            auto idx = index(i, 0, QModelIndex());
-            emit dataChanged(idx, idx);
-        });
-        emitter->onRemoved([this](const T &value) {
-            auto index = mEntities.keys().indexOf(value->identifier());
-            beginRemoveRows(QModelIndex(), index, index);
-            mEntities.remove(value->identifier());
-            endRemoveRows();
-        });
-        emitter->onInitialResultSetComplete([this]() {
-        });
-        emitter->onComplete([this]() {
-            mEmitter.clear();
-        });
-        emitter->onClear([this]() {
-            beginResetModel();
-            mEntities.clear();
-            endResetModel();
-        });
-        endResetModel();
-    }
-    int rowCount(const QModelIndex &parent = QModelIndex()) const
-    {
-        return mEntities.size();
-    }
-    int columnCount(const QModelIndex &parent = QModelIndex()) const
-    {
-        return mPropertyColumns.size();
-    }
-    virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const
-    {
-        if (index.row() >= mEntities.size()) {
-            qWarning() << "Out of bounds access";
-            return QVariant();
-        }
-        if (role == Qt::DisplayRole) {
-            if (index.column() < mPropertyColumns.size()) {
-                auto entity = mEntities.value(mEntities.keys().at(index.row()));
-                return entity->getProperty(mPropertyColumns.at(index.column())).toString();
-            }
-        }
-        if (role == DomainObjectRole) {
-            return QVariant::fromValue(mEntities.value(mEntities.keys().at(index.row())));
-        }
-        return QVariant();
-    }
-private:
-    QSharedPointer<Sink::ResultEmitter<T> > mEmitter;
-    QMap<QByteArray, T> mEntities;
-    QList<QByteArray> mPropertyColumns;
-};
diff --git a/common/log.cpp b/common/log.cpp
index 45bbec1..96c6f82 100644
--- a/common/log.cpp
+++ b/common/log.cpp
@@ -3,11 +3,19 @@
 #include <QString>
 #include <QIODevice>
 #include <QCoreApplication>
+#include <QSettings>
+#include <QStandardPaths>
+#include <QSharedPointer>
 #include <iostream>
 #include <unistd.h>
 using namespace Sink::Log;
+static QSharedPointer<QSettings> config()
+{
+    return QSharedPointer<QSettings>::create(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/sink/log.ini", QSettings::IniFormat);
+}
 class DebugStream: public QIODevice
 {
 public:
@@ -17,24 +25,24 @@ public:
    {
        open(WriteOnly);
    }
-    virtual ~DebugStream(){};
+    virtual ~DebugStream();
    bool isSequential() const { return true; }
    qint64 readData(char *, qint64) { return 0; /* eof */ }
    qint64 readLineData(char *, qint64) { return 0; /* eof */ }
    qint64 writeData(const char *data, qint64 len)
    {
-        const QByteArray buf = QByteArray::fromRawData(data, len);
+        std::cout << data << std::endl;
-        // if (!qgetenv("IMAP_TRACE").isEmpty()) {
-            // qt_message_output(QtDebugMsg, buf.trimmed().constData());
-            std::cout << buf.trimmed().constData() << std::endl;
-        // }
        return len;
    }
 private:
    Q_DISABLE_COPY(DebugStream)
 };
+//Virtual method anchor
+DebugStream::~DebugStream()
+{}
 class NullStream: public QIODevice
 {
 public:
@@ -43,7 +51,7 @@ public:
    {
        open(WriteOnly);
    }
-    virtual ~NullStream(){};
+    virtual ~NullStream();
    bool isSequential() const { return true; }
    qint64 readData(char *, qint64) { return 0; /* eof */ }
@@ -56,6 +64,10 @@ private:
    Q_DISABLE_COPY(NullStream)
 };
+//Virtual method anchor
+NullStream::~NullStream()
+{}
    /*
     * ANSI color codes:
     * 0: reset colors/style
@@ -130,31 +142,95 @@ DebugLevel Sink::Log::debugLevelFromName(const QByteArray &name)
 void Sink::Log::setDebugOutputLevel(DebugLevel debugLevel)
 {
-    qputenv("SINKDEBUGLEVEL", debugLevelName(debugLevel));
+    config()->setValue("level", debugLevel);
 }
 Sink::Log::DebugLevel Sink::Log::debugOutputLevel()
 {
-    return debugLevelFromName(qgetenv("SINKDEBUGLEVEL"));
+    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));
+            break;
+        case Area:
+            config()->setValue("areafilter", QVariant::fromValue(filter));
+            break;
+    }
+}
+QByteArrayList Sink::Log::debugOutputFilter(FilterType type)
+{
+    switch (type) {
+        case ApplicationName:
+            return config()->value("applicationfilter").value<QByteArrayList>();
+        case Area:
+            return config()->value("areafilter").value<QByteArrayList>();
+    }
+}
+void Sink::Log::setDebugOutputFields(const QByteArrayList &output)
+{
+    config()->setValue("outputfields", QVariant::fromValue(output));
+}
+QByteArrayList Sink::Log::debugOutputFields()
+{
+    return config()->value("outputfields").value<QByteArrayList>();
+}
+static QByteArray getProgramName()
+{
+    if (QCoreApplication::instance()) {
+        return QCoreApplication::instance()->applicationName().toLocal8Bit();
+    } else {
+        return "<unknown program name>";
+    }
+}
+static bool containsItemStartingWith(const QByteArray &pattern, const QByteArrayList &list)
+{
+    for (const auto &item : list) {
+        if (pattern.startsWith(item)) {
+            return true;
+        }
+    }
+    return false;
+}
+static bool caseInsensitiveContains(const QByteArray &pattern, const QByteArrayList &list)
+{
+    for (const auto &item : list) {
+        if (item.toLower() == pattern) {
+            return true;
+        }
+    }
+    return false;
 }
 QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char* file, const char* function, const char* debugArea)
 {
-    DebugLevel debugOutputLevel = debugLevelFromName(qgetenv("SINKDEBUGLEVEL"));
+    static NullStream nullstream;
-    if (debugLevel < debugOutputLevel) {
+    if (debugLevel < debugOutputLevel()) {
-        static NullStream stream;
+        return QDebug(&nullstream);
-        return QDebug(&stream);
    }
-    static DebugStream stream;
+    auto areas = debugOutputFilter(Sink::Log::Area);
-    QDebug debug(&stream);
+    if (debugArea && !areas.isEmpty()) {
+        if (!containsItemStartingWith(debugArea, areas)) {
+            return QDebug(&nullstream);
+        }
+    }
+    static QByteArray programName = getProgramName();
-    static QByteArray programName;
+    auto filter = debugOutputFilter(Sink::Log::ApplicationName);
-    if (programName.isEmpty()) {
+    if (!filter.isEmpty() && !filter.contains(programName)) {
-        if (QCoreApplication::instance())
+        if (!containsItemStartingWith(programName, filter)) {
-            programName = QCoreApplication::instance()->applicationName().toLocal8Bit();
+            return QDebug(&nullstream);
-        else
+        }
-            programName = "<unknown program name>";
    }
    QString prefix;
@@ -175,29 +251,54 @@ QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char* file,
            prefix = "Error:  ";
            prefixColorCode = ANSI_Colors::Red;
            break;
-        default:
-            break;
    };
-    bool showLocation = false;
+    auto debugOutput = debugOutputFields();
-    bool showProgram = true;
+    bool showLocation = debugOutput.isEmpty() ? false : caseInsensitiveContains("location", debugOutput);
+    bool showFunction = debugOutput.isEmpty() ? false : caseInsensitiveContains("function", debugOutput);
+    bool showProgram = debugOutput.isEmpty() ? false : caseInsensitiveContains("application", debugOutput);
+    bool useColor = true;
+    bool multiline = false;
    const QString resetColor = colorCommand(ANSI_Colors::Reset);
    QString output;
-    output += colorCommand(QList<int>() << ANSI_Colors::Bold << prefixColorCode) + prefix + resetColor;
+    if (useColor) {
+        output += colorCommand(QList<int>() << ANSI_Colors::Bold << prefixColorCode);
+    }
+    output += prefix;
+    if (useColor) {
+        output += resetColor;
+    }
    if (showProgram) {
-        output += QString(" %1(%2)").arg(QString::fromLatin1(programName)).arg(unsigned(getpid()));
+        int width = 10;
+        output += QString(" %1(%2)").arg(QString::fromLatin1(programName).leftJustified(width, ' ', true)).arg(unsigned(getpid())).rightJustified(width + 8, ' ');
    }
    if (debugArea) {
-        output += colorCommand(QList<int>() << ANSI_Colors::Bold << prefixColorCode) + QString(" %1 ").arg(QString::fromLatin1(debugArea)) + resetColor;
+        if (useColor) {
+            output += colorCommand(QList<int>() << ANSI_Colors::Bold << prefixColorCode);
+        }
+        output += QString(" %1 ").arg(QString::fromLatin1(debugArea).leftJustified(25, ' ', true));
+        if (useColor) {
+            output += resetColor;
+        }
+    }
+    if (showFunction) {
+        output += QString(" %3").arg(QString::fromLatin1(function).leftJustified(25, ' ', true));
    }
    if (showLocation) {
-        output += QString(" %3").arg(function);
+        const auto filename = QString::fromLatin1(file).split('/').last();
-        output += QString("%1:%2").arg(file).arg(line);
+        output += QString(" %1:%2").arg(filename.right(25)).arg(QString::number(line).leftJustified(4, ' ')).leftJustified(30, ' ', true);
+    }
+    if (multiline) {
+        output += "\n  ";
    }
    output += ":";
-    debug << output;
+    static DebugStream stream;
+    QDebug debug(&stream);
+    debug.noquote().nospace() << output;
-    return debug;
+    return debug.space().quote();
 }
diff --git a/common/log.h b/common/log.h
index 483f16f..415c7f7 100644
--- a/common/log.h
+++ b/common/log.h
@@ -1,5 +1,6 @@
 #pragma once
+#include "sink_export.h"
 #include <QDebug>
 namespace Sink {
@@ -12,19 +13,75 @@ enum DebugLevel {
    Error
 };
-QByteArray debugLevelName(DebugLevel debugLevel);
+QByteArray SINK_EXPORT debugLevelName(DebugLevel debugLevel);
-DebugLevel debugLevelFromName(const QByteArray &name);
+DebugLevel SINK_EXPORT debugLevelFromName(const QByteArray &name);
-void setDebugOutputLevel(DebugLevel);
+/**
-DebugLevel debugOutputLevel();
+ * Sets the debug output level.
+ *
+ * Everything below is ignored.
+ */
+void SINK_EXPORT setDebugOutputLevel(DebugLevel);
+DebugLevel SINK_EXPORT debugOutputLevel();
-QDebug debugStream(DebugLevel debugLevel, int line, const char* file, const char* function, const char* debugArea = 0);
+enum FilterType {
+    Area,
+    ApplicationName
+};
+/**
+ * Sets a debug output filter.
+ * 
+ * Everything that is not matching the filter is ignored.
+ * An empty filter matches everything.
+ *
+ * Note: In case of resources the application name is the identifier.
+ */
+void SINK_EXPORT setDebugOutputFilter(FilterType, const QByteArrayList &filter);
+QByteArrayList SINK_EXPORT debugOutputFilter(FilterType type);
+/**
+ * Set the debug output fields.
+ *
+ * Currently supported are:
+ * * Name: Application name used for filter.
+ * * Function: The function name:
+ * * Location: The source code location.
+ *
+ * These are additional items to the default ones (level, area, message).
+ */
+void SINK_EXPORT setDebugOutputFields(const QByteArrayList &filter);
+QByteArrayList SINK_EXPORT debugOutputFields();
+QDebug SINK_EXPORT debugStream(DebugLevel debugLevel, int line, const char* file, const char* function, const char* debugArea = 0);
+struct SINK_EXPORT TraceTime
+{
+    TraceTime(int i) : time(i){};
+    const int time;
+};
+inline QDebug SINK_EXPORT operator<<(QDebug d, const TraceTime &time)
+{
+    d << time.time << "[ms]";
+    return d;
+}
 }
 }
-#define Trace() Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO)
+#define DEBUG_AREA nullptr
-#define Log() Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO)
-#define Warning() Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO)
+#define Trace_() Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO)
+#define Log_() Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO)
+#define Trace_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
+#define Log_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
+#define Warning_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
+#define Error_area(AREA) Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, AREA)
+#define Trace() Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, DEBUG_AREA)
+#define Log() Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, DEBUG_AREA)
+#define Warning() Sink::Log::debugStream(Sink::Log::DebugLevel::Warning, __LINE__, __FILE__, Q_FUNC_INFO, DEBUG_AREA)
 //FIXME Error clashes with Storage::Error and MessageQueue::Error
-#define ErrorMsg() Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO)
+#define ErrorMsg() Sink::Log::debugStream(Sink::Log::DebugLevel::Error, __LINE__, __FILE__, Q_FUNC_INFO, DEBUG_AREA)
diff --git a/common/messagequeue.cpp b/common/messagequeue.cpp
index 1055922..73198a5 100644
--- a/common/messagequeue.cpp
+++ b/common/messagequeue.cpp
@@ -174,3 +174,7 @@ bool MessageQueue::isEmpty()
    return count == 0;
 }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
+#include "moc_messagequeue.cpp"
+#pragma clang diagnostic pop
diff --git a/common/messagequeue.h b/common/messagequeue.h
index 3206388..9399055 100644
--- a/common/messagequeue.h
+++ b/common/messagequeue.h
@@ -1,5 +1,6 @@
 #pragma once
+#include "sink_export.h"
 #include <QObject>
 #include <QByteArrayList>
 #include <string>
@@ -11,7 +12,7 @@
 /**
 * A persistent FIFO message queue.
 */
-class MessageQueue : public QObject
+class SINK_EXPORT MessageQueue : public QObject
 {
    Q_OBJECT
 public:
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index 3a9fb95..f28c665 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -24,6 +24,9 @@
 #include "domain/folder.h"
 #include "log.h"
+#undef DEBUG_AREA
+#define DEBUG_AREA "client.modelresult"
 static  uint qHash(const Sink::ApplicationDomain::ApplicationDomainType &type)
 {
    Q_ASSERT(!type.resourceInstanceIdentifier().isEmpty());
diff --git a/common/notification.h b/common/notification.h
index ae24bd2..cf69a99 100644
--- a/common/notification.h
+++ b/common/notification.h
@@ -19,7 +19,7 @@
 */
 #pragma once
-#include <sinkcommon_export.h>
+#include "sink_export.h"
 #include <QString>
 namespace Sink
@@ -28,7 +28,7 @@ namespace Sink
 /**
 * A notification
 */
-class SINKCOMMON_EXPORT Notification
+class SINK_EXPORT Notification
 {
 public:
    QByteArray id;
diff --git a/common/notifier.cpp b/common/notifier.cpp
new file mode 100644
index 0000000..e4248df
--- /dev/null
+++ b/common/notifier.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "notifier.h"
+#include <functional>
+#include "resourceaccess.h"
+#include "log.h"
+using namespace Sink;
+class Sink::Notifier::Private {
+public:
+    Private()
+        : context(new QObject)
+    {
+    }
+    QList<QSharedPointer<ResourceAccess> > resourceAccess;
+    QList<std::function<void(const Notification &)> > handler;
+    QSharedPointer<QObject> context;
+};
+Notifier::Notifier(const QSharedPointer<ResourceAccess> &resourceAccess)
+    : d(new Sink::Notifier::Private)
+{
+    QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
+        for (const auto &handler : d->handler) {
+            handler(notification);
+        }
+    });
+    d->resourceAccess << resourceAccess;
+}
+Notifier::Notifier(const QByteArray &instanceIdentifier)
+    : d(new Sink::Notifier::Private)
+{
+    auto resourceAccess = Sink::ResourceAccess::Ptr::create(instanceIdentifier);
+    resourceAccess->open();
+    QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
+        for (const auto &handler : d->handler) {
+            handler(notification);
+        }
+    });
+    d->resourceAccess << resourceAccess;
+}
+void Notifier::registerHandler(std::function<void(const Notification &)> handler)
+{
+    d->handler << handler;
+}
diff --git a/common/listmodelresult.cpp b/common/notifier.h
index 6ef1c5f..d16a311 100644
--- a/common/listmodelresult.cpp
+++ b/common/notifier.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -18,4 +18,29 @@
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
-#include "listmodelresult.h"
+#pragma once
+#include "sink_export.h"
+#include <QByteArray>
+#include <QSharedPointer>
+#include <Async/Async>
+class QAbstractItemModel;
+namespace Sink {
+class ResourceAccess;
+class Notification;
+class SINK_EXPORT Notifier {
+public:
+    Notifier(const QSharedPointer<ResourceAccess> &resourceAccess);
+    Notifier(const QByteArray &resourceInstanceIdentifier);
+    void registerHandler(std::function<void(const Notification &)>);
+private:
+    class Private;
+    QSharedPointer<Private> d;
+};
+}
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index 401c26d..93d8236 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -25,6 +25,7 @@
 #include <QVector>
 #include <QUuid>
 #include <QDebug>
+#include <QTime>
 #include "entity_generated.h"
 #include "metadata_generated.h"
 #include "createentity_generated.h"
@@ -36,6 +37,9 @@
 #include "definitions.h"
 #include "bufferutils.h"
+#undef DEBUG_AREA
+#define DEBUG_AREA "resource.pipeline"
 namespace Sink
 {
@@ -53,8 +57,24 @@ public:
    QHash<QString, QVector<Preprocessor *> > processors;
    QHash<QString, DomainTypeAdaptorFactoryInterface::Ptr> adaptorFactory;
    bool revisionChanged;
+    void storeNewRevision(qint64 newRevision, const flatbuffers::FlatBufferBuilder &fbb, const QByteArray &bufferType, const QByteArray &uid);
+    QTime transactionTime;
+    int transactionItemCount;
 };
+void Pipeline::Private::storeNewRevision(qint64 newRevision, const flatbuffers::FlatBufferBuilder &fbb, const QByteArray &bufferType, const QByteArray &uid)
+{
+    Storage::mainDatabase(transaction, bufferType).write(Storage::assembleKey(uid, newRevision), BufferUtils::extractBuffer(fbb),
+        [uid, newRevision](const Storage::Error &error) {
+            Warning() << "Failed to write entity" << uid << newRevision;
+        }
+    );
+    revisionChanged = true;
+    Storage::setMaxRevision(transaction, newRevision);
+    Storage::recordRevision(transaction, newRevision, uid, bufferType);
+}
 Pipeline::Pipeline(const QString &resourceName, QObject *parent)
    : QObject(parent),
      d(new Private(resourceName))
@@ -86,7 +106,10 @@ void Pipeline::startTransaction()
    if (d->transaction) {
        return;
    }
-    d->transaction = std::move(storage().createTransaction(Sink::Storage::ReadWrite));
+    Trace() << "Starting transaction.";
+    d->transactionTime.start();
+    d->transactionItemCount = 0;
+    d->transaction = std::move(storage().createTransaction(Storage::ReadWrite));
 }
 void Pipeline::commit()
@@ -96,8 +119,9 @@ void Pipeline::commit()
    // for (auto processor : d->processors[bufferType]) {
    //     processor->finalize();
    // }
-    const auto revision = Sink::Storage::maxRevision(d->transaction);
+    const auto revision = Storage::maxRevision(d->transaction);
-    Trace() << "Committing " << revision;
+    const auto elapsed = d->transactionTime.elapsed();
+    Trace() << "Committing revision: " << revision << ":" << d->transactionItemCount << " items in: " << Log::TraceTime(elapsed) << " " << (double)elapsed/(double)qMax(d->transactionItemCount, 1) << "[ms/item]";
    if (d->transaction) {
        d->transaction.commit();
    }
@@ -118,41 +142,30 @@ Storage &Pipeline::storage() const
    return d->storage;
 }
-void Pipeline::storeNewRevision(qint64 newRevision, const flatbuffers::FlatBufferBuilder &fbb, const QByteArray &bufferType, const QByteArray &uid)
-{
-    d->transaction.openDatabase(bufferType + ".main").write(Sink::Storage::assembleKey(uid, newRevision), BufferUtils::extractBuffer(fbb),
-        [](const Sink::Storage::Error &error) {
-            Warning() << "Failed to write entity";
-        }
-    );
-    d->revisionChanged = true;
-    Sink::Storage::setMaxRevision(d->transaction, newRevision);
-    Sink::Storage::recordRevision(d->transaction, newRevision, uid, bufferType);
-}
 KAsync::Job<qint64> Pipeline::newEntity(void const *command, size_t size)
 {
    Trace() << "Pipeline: New Entity";
+    d->transactionItemCount++;
    {
        flatbuffers::Verifier verifyer(reinterpret_cast<const uint8_t *>(command), size);
-        if (!Sink::Commands::VerifyCreateEntityBuffer(verifyer)) {
+        if (!Commands::VerifyCreateEntityBuffer(verifyer)) {
            Warning() << "invalid buffer, not a create entity buffer";
            return KAsync::error<qint64>(0);
        }
    }
-    auto createEntity = Sink::Commands::GetCreateEntity(command);
+    auto createEntity = Commands::GetCreateEntity(command);
    const bool replayToSource = createEntity->replayToSource();
    const QByteArray bufferType = QByteArray(reinterpret_cast<char const*>(createEntity->domainType()->Data()), createEntity->domainType()->size());
    {
        flatbuffers::Verifier verifyer(reinterpret_cast<const uint8_t *>(createEntity->delta()->Data()), createEntity->delta()->size());
-        if (!Sink::VerifyEntityBuffer(verifyer)) {
+        if (!VerifyEntityBuffer(verifyer)) {
            Warning() << "invalid buffer, not an entity buffer";
            return KAsync::error<qint64>(0);
        }
    }
-    auto entity = Sink::GetEntity(createEntity->delta()->Data());
+    auto entity = GetEntity(createEntity->delta()->Data());
    if (!entity->resource()->size() && !entity->local()->size()) {
        Warning() << "No local and no resource buffer while trying to create entity.";
        return KAsync::error<qint64>(0);
@@ -161,7 +174,7 @@ KAsync::Job<qint64> Pipeline::newEntity(void const *command, size_t size)
    QByteArray key;
    if (createEntity->entityId()) {
        key = QByteArray(reinterpret_cast<char const*>(createEntity->entityId()->Data()), createEntity->entityId()->size());
-        if (d->transaction.openDatabase(bufferType + ".main").contains(key)) {
+        if (Storage::mainDatabase(d->transaction, bufferType).contains(key)) {
            ErrorMsg() << "An entity with this id already exists: " << key;
            return KAsync::error<qint64>(0);
        }
@@ -171,21 +184,21 @@ KAsync::Job<qint64> Pipeline::newEntity(void const *command, size_t size)
        key = QUuid::createUuid().toString().toUtf8();
    }
    Q_ASSERT(!key.isEmpty());
-    const qint64 newRevision = Sink::Storage::maxRevision(d->transaction) + 1;
+    const qint64 newRevision = Storage::maxRevision(d->transaction) + 1;
    //Add metadata buffer
    flatbuffers::FlatBufferBuilder metadataFbb;
-    auto metadataBuilder = Sink::MetadataBuilder(metadataFbb);
+    auto metadataBuilder = MetadataBuilder(metadataFbb);
    metadataBuilder.add_revision(newRevision);
-    metadataBuilder.add_operation(Sink::Operation_Creation);
+    metadataBuilder.add_operation(Operation_Creation);
    metadataBuilder.add_replayToSource(replayToSource);
    auto metadataBuffer = metadataBuilder.Finish();
-    Sink::FinishMetadataBuffer(metadataFbb, metadataBuffer);
+    FinishMetadataBuffer(metadataFbb, metadataBuffer);
    flatbuffers::FlatBufferBuilder fbb;
    EntityBuffer::assembleEntityBuffer(fbb, metadataFbb.GetBufferPointer(), metadataFbb.GetSize(), entity->resource()->Data(), entity->resource()->size(), entity->local()->Data(), entity->local()->size());
-    storeNewRevision(newRevision, fbb, bufferType, key);
+    d->storeNewRevision(newRevision, fbb, bufferType, key);
    auto adaptorFactory = d->adaptorFactory.value(bufferType);
    if (!adaptorFactory) {
@@ -194,14 +207,14 @@ KAsync::Job<qint64> Pipeline::newEntity(void const *command, size_t size)
    }
    Log() << "Pipeline: wrote entity: " << key << newRevision << bufferType;
-    d->transaction.openDatabase(bufferType + ".main").scan(Sink::Storage::assembleKey(key, newRevision), [this, bufferType, newRevision, adaptorFactory, key](const QByteArray &, const QByteArray &value) -> bool {
+    Storage::mainDatabase(d->transaction, bufferType).scan(Storage::assembleKey(key, newRevision), [this, bufferType, newRevision, adaptorFactory, key](const QByteArray &, const QByteArray &value) -> bool {
-        auto entity = Sink::GetEntity(value);
+        auto entity = GetEntity(value);
        auto adaptor = adaptorFactory->createAdaptor(*entity);
        for (auto processor : d->processors[bufferType]) {
            processor->newEntity(key, newRevision, *adaptor, d->transaction);
        }
        return false;
-    }, [this](const Sink::Storage::Error &error) {
+    }, [this](const Storage::Error &error) {
        ErrorMsg() << "Failed to find value in pipeline: " << error.message;
    });
    return KAsync::start<qint64>([newRevision](){
@@ -212,17 +225,18 @@ KAsync::Job<qint64> Pipeline::newEntity(void const *command, size_t size)
 KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
 {
    Trace() << "Pipeline: Modified Entity";
+    d->transactionItemCount++;
-    const qint64 newRevision = Sink::Storage::maxRevision(d->transaction) + 1;
+    const qint64 newRevision = Storage::maxRevision(d->transaction) + 1;
    {
        flatbuffers::Verifier verifyer(reinterpret_cast<const uint8_t *>(command), size);
-        if (!Sink::Commands::VerifyModifyEntityBuffer(verifyer)) {
+        if (!Commands::VerifyModifyEntityBuffer(verifyer)) {
            Warning() << "invalid buffer, not a modify entity buffer";
            return KAsync::error<qint64>(0);
        }
    }
-    auto modifyEntity = Sink::Commands::GetModifyEntity(command);
+    auto modifyEntity = Commands::GetModifyEntity(command);
    Q_ASSERT(modifyEntity);
    const qint64 baseRevision = modifyEntity->revision();
@@ -236,7 +250,7 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
    }
    {
        flatbuffers::Verifier verifyer(reinterpret_cast<const uint8_t *>(modifyEntity->delta()->Data()), modifyEntity->delta()->size());
-        if (!Sink::VerifyEntityBuffer(verifyer)) {
+        if (!VerifyEntityBuffer(verifyer)) {
            Warning() << "invalid buffer, not an entity buffer";
            return KAsync::error<qint64>(0);
        }
@@ -249,13 +263,13 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
        return KAsync::error<qint64>(0);
    }
-    auto diffEntity = Sink::GetEntity(modifyEntity->delta()->Data());
+    auto diffEntity = GetEntity(modifyEntity->delta()->Data());
    Q_ASSERT(diffEntity);
    auto diff = adaptorFactory->createAdaptor(*diffEntity);
-    QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current;
+    QSharedPointer<ApplicationDomain::BufferAdaptor> current;
-    d->transaction.openDatabase(bufferType + ".main").findLatest(key, [&current, adaptorFactory](const QByteArray &key, const QByteArray &data) -> bool {
+    Storage::mainDatabase(d->transaction, bufferType).findLatest(key, [&current, adaptorFactory](const QByteArray &key, const QByteArray &data) -> bool {
-        Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
+        EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
        if (!buffer.isValid()) {
            Warning() << "Read invalid buffer from disk";
        } else {
@@ -273,15 +287,22 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
    }
    //resource and uid don't matter at this point
-    const Sink::ApplicationDomain::ApplicationDomainType existingObject("", "", newRevision, current);
+    const ApplicationDomain::ApplicationDomainType existingObject("", "", newRevision, current);
-    auto newObject = Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<Sink::ApplicationDomain::ApplicationDomainType>(existingObject);
+    auto newObject = ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<ApplicationDomain::ApplicationDomainType>(existingObject);
    //Apply diff
    //FIXME only apply the properties that are available in the buffer
    Trace() << "Applying changed properties: " << diff->availableProperties();
+    QSet<QByteArray> changeset;
    for (const auto &property : diff->availableProperties()) {
-        newObject->setProperty(property, diff->getProperty(property));
+        changeset << property;
+        const auto value = diff->getProperty(property);
+        if (value.isValid()) {
+            newObject->setProperty(property, value);
+        }
    }
+    //Altough we only set some properties, we want all to be serialized
+    newObject->setChangedProperties(changeset);
    //Remove deletions
    if (modifyEntity->deletions()) {
@@ -292,26 +313,29 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
    //Add metadata buffer
    flatbuffers::FlatBufferBuilder metadataFbb;
-    auto metadataBuilder = Sink::MetadataBuilder(metadataFbb);
+    auto metadataBuilder = MetadataBuilder(metadataFbb);
    metadataBuilder.add_revision(newRevision);
-    metadataBuilder.add_operation(Sink::Operation_Modification);
+    metadataBuilder.add_operation(Operation_Modification);
    metadataBuilder.add_replayToSource(replayToSource);
    auto metadataBuffer = metadataBuilder.Finish();
-    Sink::FinishMetadataBuffer(metadataFbb, metadataBuffer);
+    FinishMetadataBuffer(metadataFbb, metadataBuffer);
    flatbuffers::FlatBufferBuilder fbb;
    adaptorFactory->createBuffer(*newObject, fbb, metadataFbb.GetBufferPointer(), metadataFbb.GetSize());
-    storeNewRevision(newRevision, fbb, bufferType, key);
+    d->storeNewRevision(newRevision, fbb, bufferType, key);
    Log() << "Pipeline: modified entity: " << key << newRevision << bufferType;
-    d->transaction.openDatabase(bufferType + ".main").scan(Sink::Storage::assembleKey(key, newRevision), [this, bufferType, newRevision, adaptorFactory, current, key](const QByteArray &, const QByteArray &value) -> bool {
+    Storage::mainDatabase(d->transaction, bufferType).scan(Storage::assembleKey(key, newRevision), [this, bufferType, newRevision, adaptorFactory, current, key](const QByteArray &k, const QByteArray &value) -> bool {
-        auto entity = Sink::GetEntity(value);
+        if (value.isEmpty()) {
+            ErrorMsg() << "Read buffer is empty.";
+        }
+        auto entity = GetEntity(value.data());
        auto newEntity = adaptorFactory->createAdaptor(*entity);
        for (auto processor : d->processors[bufferType]) {
            processor->modifiedEntity(key, newRevision, *current, *newEntity, d->transaction);
        }
        return false;
-    }, [this](const Sink::Storage::Error &error) {
+    }, [this](const Storage::Error &error) {
        ErrorMsg() << "Failed to find value in pipeline: " << error.message;
    });
    return KAsync::start<qint64>([newRevision](){
@@ -322,15 +346,16 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
 KAsync::Job<qint64> Pipeline::deletedEntity(void const *command, size_t size)
 {
    Trace() << "Pipeline: Deleted Entity";
+    d->transactionItemCount++;
    {
        flatbuffers::Verifier verifyer(reinterpret_cast<const uint8_t *>(command), size);
-        if (!Sink::Commands::VerifyDeleteEntityBuffer(verifyer)) {
+        if (!Commands::VerifyDeleteEntityBuffer(verifyer)) {
            Warning() << "invalid buffer, not a delete entity buffer";
            return KAsync::error<qint64>(0);
        }
    }
-    auto deleteEntity = Sink::Commands::GetDeleteEntity(command);
+    auto deleteEntity = Commands::GetDeleteEntity(command);
    const bool replayToSource = deleteEntity->replayToSource();
    const QByteArray bufferType = QByteArray(reinterpret_cast<char const*>(deleteEntity->domainType()->Data()), deleteEntity->domainType()->size());
@@ -338,13 +363,12 @@ KAsync::Job<qint64> Pipeline::deletedEntity(void const *command, size_t size)
    bool found = false;
    bool alreadyRemoved = false;
-    d->transaction.openDatabase(bufferType + ".main").findLatest(key, [&found, &alreadyRemoved](const QByteArray &key, const QByteArray &data) -> bool {
+    Storage::mainDatabase(d->transaction, bufferType).findLatest(key, [&found, &alreadyRemoved](const QByteArray &key, const QByteArray &data) -> bool {
-        Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
+        auto entity = GetEntity(data.data());
-        auto entity = Sink::GetEntity(data.data());
        if (entity && entity->metadata()) {
-            auto metadata = Sink::GetMetadata(entity->metadata()->Data());
+            auto metadata = GetMetadata(entity->metadata()->Data());
            found = true;
-            if (metadata->operation() == Sink::Operation_Removal) {
+            if (metadata->operation() == Operation_Removal) {
                alreadyRemoved = true;
            }
@@ -364,16 +388,16 @@ KAsync::Job<qint64> Pipeline::deletedEntity(void const *command, size_t size)
        return KAsync::error<qint64>(0);
    }
-    const qint64 newRevision = Sink::Storage::maxRevision(d->transaction) + 1;
+    const qint64 newRevision = Storage::maxRevision(d->transaction) + 1;
    //Add metadata buffer
    flatbuffers::FlatBufferBuilder metadataFbb;
-    auto metadataBuilder = Sink::MetadataBuilder(metadataFbb);
+    auto metadataBuilder = MetadataBuilder(metadataFbb);
    metadataBuilder.add_revision(newRevision);
-    metadataBuilder.add_operation(Sink::Operation_Removal);
+    metadataBuilder.add_operation(Operation_Removal);
    metadataBuilder.add_replayToSource(replayToSource);
    auto metadataBuffer = metadataBuilder.Finish();
-    Sink::FinishMetadataBuffer(metadataFbb, metadataBuffer);
+    FinishMetadataBuffer(metadataFbb, metadataBuffer);
    flatbuffers::FlatBufferBuilder fbb;
    EntityBuffer::assembleEntityBuffer(fbb, metadataFbb.GetBufferPointer(), metadataFbb.GetSize(), 0, 0, 0, 0);
@@ -384,20 +408,20 @@ KAsync::Job<qint64> Pipeline::deletedEntity(void const *command, size_t size)
        return KAsync::error<qint64>(0);
    }
-    QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current;
+    QSharedPointer<ApplicationDomain::BufferAdaptor> current;
-    d->transaction.openDatabase(bufferType + ".main").findLatest(key, [this, bufferType, newRevision, adaptorFactory, key, &current](const QByteArray &, const QByteArray &data) -> bool {
+    Storage::mainDatabase(d->transaction, bufferType).findLatest(key, [this, bufferType, newRevision, adaptorFactory, key, &current](const QByteArray &, const QByteArray &data) -> bool {
-        Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
+        EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
        if (!buffer.isValid()) {
            Warning() << "Read invalid buffer from disk";
        } else {
            current = adaptorFactory->createAdaptor(buffer.entity());
        }
        return false;
-    }, [this](const Sink::Storage::Error &error) {
+    }, [this](const Storage::Error &error) {
        ErrorMsg() << "Failed to find value in pipeline: " << error.message;
    });
-    storeNewRevision(newRevision, fbb, bufferType, key);
+    d->storeNewRevision(newRevision, fbb, bufferType, key);
    Log() << "Pipeline: deleted entity: "<< newRevision;
    for (auto processor : d->processors[bufferType]) {
@@ -411,33 +435,33 @@ KAsync::Job<qint64> Pipeline::deletedEntity(void const *command, size_t size)
 void Pipeline::cleanupRevision(qint64 revision)
 {
-    const auto uid = Sink::Storage::getUidFromRevision(d->transaction, revision);
+    const auto uid = Storage::getUidFromRevision(d->transaction, revision);
-    const auto bufferType = Sink::Storage::getTypeFromRevision(d->transaction, revision);
+    const auto bufferType = Storage::getTypeFromRevision(d->transaction, revision);
    Trace() << "Cleaning up revision " << revision << uid << bufferType;
-    d->transaction.openDatabase(bufferType + ".main").scan(uid, [&](const QByteArray &key, const QByteArray &data) -> bool {
+    Storage::mainDatabase(d->transaction, bufferType).scan(uid, [&](const QByteArray &key, const QByteArray &data) -> bool {
-        Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
+        EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
        if (!buffer.isValid()) {
            Warning() << "Read invalid buffer from disk";
        } else {
-            const auto metadata =  flatbuffers::GetRoot<Sink::Metadata>(buffer.metadataBuffer());
+            const auto metadata =  flatbuffers::GetRoot<Metadata>(buffer.metadataBuffer());
            const qint64 rev = metadata->revision();
            //Remove old revisions, and the current if the entity has already been removed
-            if (rev < revision || metadata->operation() == Sink::Operation_Removal) {
+            if (rev < revision || metadata->operation() == Operation_Removal) {
-                Sink::Storage::removeRevision(d->transaction, rev);
+                Storage::removeRevision(d->transaction, rev);
-                d->transaction.openDatabase(bufferType + ".main").remove(key);
+                Storage::mainDatabase(d->transaction, bufferType).remove(key);
            }
        }
        return true;
-    }, [](const Sink::Storage::Error &error) {
+    }, [](const Storage::Error &error) {
        Warning() << "Error while reading: " << error.message;
    }, true);
-    Sink::Storage::setCleanedUpRevision(d->transaction, revision);
+    Storage::setCleanedUpRevision(d->transaction, revision);
 }
 qint64 Pipeline::cleanedUpRevision()
 {
-    return Sink::Storage::cleanedUpRevision(d->transaction);
+    return Storage::cleanedUpRevision(d->transaction);
 }
 Preprocessor::Preprocessor()
@@ -459,3 +483,7 @@ void Preprocessor::finalize()
 } // namespace Sink
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
+#include "moc_pipeline.cpp"
+#pragma clang diagnostic pop
diff --git a/common/pipeline.h b/common/pipeline.h
index 60a5fa5..096771f 100644
--- a/common/pipeline.h
+++ b/common/pipeline.h
@@ -25,7 +25,7 @@
 #include <QSharedDataPointer>
 #include <QObject>
-#include <sinkcommon_export.h>
+#include "sink_export.h"
 #include <storage.h>
 #include <Async/Async>
@@ -37,7 +37,7 @@ namespace Sink
 class Preprocessor;
-class SINKCOMMON_EXPORT Pipeline : public QObject
+class SINK_EXPORT Pipeline : public QObject
 {
    Q_OBJECT
@@ -73,13 +73,11 @@ Q_SIGNALS:
    void revisionUpdated(qint64);
 private:
-    void storeNewRevision(qint64 newRevision, const flatbuffers::FlatBufferBuilder &fbb, const QByteArray &bufferType, const QByteArray &uid);
    class Private;
    Private * const d;
 };
-class SINKCOMMON_EXPORT Preprocessor
+class SINK_EXPORT Preprocessor
 {
 public:
    Preprocessor();
diff --git a/common/propertymapper.h b/common/propertymapper.h
index efde72c..57202ab 100644
--- a/common/propertymapper.h
+++ b/common/propertymapper.h
@@ -19,6 +19,7 @@
 #pragma once
+#include "sink_export.h"
 #include <QVariant>
 #include <QByteArray>
 #include <functional>
@@ -28,17 +29,17 @@
 * Defines how to convert qt primitives to flatbuffer ones
 */
 template <class T>
-flatbuffers::uoffset_t variantToProperty(const QVariant &, flatbuffers::FlatBufferBuilder &fbb);
+flatbuffers::uoffset_t SINK_EXPORT variantToProperty(const QVariant &, flatbuffers::FlatBufferBuilder &fbb);
 /**
 * Defines how to convert flatbuffer primitives to qt ones
 */
 template <typename T>
-QVariant propertyToVariant(const flatbuffers::String *);
+QVariant SINK_EXPORT propertyToVariant(const flatbuffers::String *);
 template <typename T>
-QVariant propertyToVariant(uint8_t);
+QVariant SINK_EXPORT propertyToVariant(uint8_t);
 template <typename T>
-QVariant propertyToVariant(const flatbuffers::Vector<uint8_t> *);
+QVariant SINK_EXPORT propertyToVariant(const flatbuffers::Vector<uint8_t> *);
 /**
@@ -52,6 +53,8 @@ template<typename BufferType>
 class ReadPropertyMapper
 {
 public:
+    virtual ~ReadPropertyMapper(){};
    virtual QVariant getProperty(const QByteArray &key, BufferType const *buffer) const
    {
        if (mReadAccessors.contains(key)) {
@@ -106,6 +109,8 @@ 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)) {
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index 25d69b1..22682d3 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -26,6 +26,9 @@
 #include "domainadaptor.h"
 #include "asyncutils.h"
+#undef DEBUG_AREA
+#define DEBUG_AREA "client.queryrunner"
 using namespace Sink;
 /*
@@ -38,14 +41,14 @@ template<typename DomainType>
 class QueryWorker : public QObject
 {
 public:
-    QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType);
+    QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType, const QueryRunnerBase::ResultTransformation &transformation);
    virtual ~QueryWorker();
    qint64 executeIncrementalQuery(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider);
    qint64 executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider);
 private:
-    static void replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties);
+    void replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties);
    void readEntity(const Sink::Storage::NamedDatabase &db, const QByteArray &key, const std::function<void(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &, Sink::Operation)> &resultCallback);
@@ -57,6 +60,7 @@ private:
    qint64 load(const Sink::Query &query, const std::function<ResultSet(Sink::Storage::Transaction &, QSet<QByteArray> &)> &baseSetRetriever, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, bool initialQuery);
 private:
+    QueryRunnerBase::ResultTransformation mResultTransformation;
    DomainTypeAdaptorFactoryInterface::Ptr mDomainTypeAdaptorFactory;
    QByteArray mResourceInstanceIdentifier;
    QByteArray mBufferType;
@@ -72,11 +76,11 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
 {
    Trace() << "Starting query";
    //We delegate loading of initial data to the result provider, os it can decide for itself what it needs to load.
-    mResultProvider->setFetcher([this, query, instanceIdentifier, factory, bufferType](const typename DomainType::Ptr &parent) {
+    mResultProvider->setFetcher([=](const typename DomainType::Ptr &parent) {
        Trace() << "Running fetcher";
        auto resultProvider = mResultProvider;
-        async::run<qint64>([query, instanceIdentifier, factory, bufferType, parent, resultProvider]() -> qint64 {
+        async::run<qint64>([=]() -> qint64 {
-                QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType);
+                QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType, mResultTransformation);
                const qint64 newRevision = worker.executeInitialQuery(query, parent, *resultProvider);
                return newRevision;
            })
@@ -91,18 +95,17 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
    // In case of a live query we keep the runner for as long alive as the result provider exists
    if (query.liveQuery) {
        //Incremental updates are always loaded directly, leaving it up to the result to discard the changes if they are not interesting
-        setQuery([this, query, instanceIdentifier, factory, bufferType] () -> KAsync::Job<void> {
+        setQuery([=] () -> KAsync::Job<void> {
            auto resultProvider = mResultProvider;
-            return async::run<qint64>([query, instanceIdentifier, factory, bufferType, resultProvider]() -> qint64 {
+            return async::run<qint64>([=]() -> qint64 {
-                    QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType);
+                    QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType, mResultTransformation);
                    const qint64 newRevision = worker.executeIncrementalQuery(query, *resultProvider);
                    return newRevision;
                })
                .template then<void, qint64>([query, this](qint64 newRevision) {
                    //Only send the revision replayed information if we're connected to the resource, there's no need to start the resource otherwise.
                    mResourceAccess->sendRevisionReplayedCommand(newRevision);
-                })
+                });
-                .template then<void>([](){});
        });
        //Ensure the connection is open, if it wasn't already opened
        //TODO If we are not connected already, we have to check for the latest revision once connected, otherwise we could miss some updates
@@ -118,6 +121,12 @@ QueryRunner<DomainType>::~QueryRunner()
 }
 template<class DomainType>
+void QueryRunner<DomainType>::setResultTransformation(const ResultTransformation &transformation)
+{
+    mResultTransformation = transformation;
+}
+template<class DomainType>
 typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr QueryRunner<DomainType>::emitter()
 {
    return mResultProvider->emitter();
@@ -129,7 +138,7 @@ static inline ResultSet fullScan(const Sink::Storage::Transaction &transaction,
 {
    //TODO use a result set with an iterator, to read values on demand
    QVector<QByteArray> keys;
-    transaction.openDatabase(bufferType + ".main").scan(QByteArray(), [&](const QByteArray &key, const QByteArray &value) -> bool {
+    Storage::mainDatabase(transaction, bufferType).scan(QByteArray(), [&](const QByteArray &key, const QByteArray &value) -> bool {
        //Skip internals
        if (Sink::Storage::isInternalKey(key)) {
            return true;
@@ -147,8 +156,9 @@ static inline ResultSet fullScan(const Sink::Storage::Transaction &transaction,
 template<class DomainType>
-QueryWorker<DomainType>::QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType)
+QueryWorker<DomainType>::QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType, const QueryRunnerBase::ResultTransformation &transformation)
    : QObject(),
+    mResultTransformation(transformation),
    mDomainTypeAdaptorFactory(factory),
    mResourceInstanceIdentifier(instanceIdentifier),
    mBufferType(bufferType),
@@ -167,20 +177,25 @@ template<class DomainType>
 void QueryWorker<DomainType>::replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties)
 {
    int counter = 0;
-    while (resultSet.next([&resultProvider, &counter, &properties](const Sink::ApplicationDomain::ApplicationDomainType::Ptr &value, Sink::Operation operation) -> bool {
+    while (resultSet.next([this, &resultProvider, &counter, &properties](const Sink::ApplicationDomain::ApplicationDomainType::Ptr &value, Sink::Operation operation) -> bool {
+        //FIXME allow maildir resource to set the mimeMessage property
+        auto valueCopy = Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>();
+        if (mResultTransformation) {
+            mResultTransformation(*valueCopy);
+        }
        counter++;
        switch (operation) {
        case Sink::Operation_Creation:
            // Trace() << "Got creation";
-            resultProvider.add(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
+            resultProvider.add(valueCopy);
            break;
        case Sink::Operation_Modification:
            // Trace() << "Got modification";
-            resultProvider.modify(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
+            resultProvider.modify(valueCopy);
            break;
        case Sink::Operation_Removal:
            // Trace() << "Got removal";
-            resultProvider.remove(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
+            resultProvider.remove(valueCopy);
            break;
        }
        return true;
@@ -319,7 +334,7 @@ qint64 QueryWorker<DomainType>::load(const Sink::Query &query, const std::functi
        Warning() << "Error during query: " << error.store << error.message;
    });
    auto transaction = storage.createTransaction(Sink::Storage::ReadOnly);
-    auto db = transaction.openDatabase(mBufferType + ".main");
+    auto db = Storage::mainDatabase(transaction, mBufferType);
    QSet<QByteArray> remainingFilters;
    auto resultSet = baseSetRetriever(transaction, remainingFilters);
diff --git a/common/queryrunner.h b/common/queryrunner.h
index 0ee6a81..04e4587 100644
--- a/common/queryrunner.h
+++ b/common/queryrunner.h
@@ -32,6 +32,9 @@
 class QueryRunnerBase : public QObject
 {
    Q_OBJECT
+public:
+    typedef std::function<void(Sink::ApplicationDomain::ApplicationDomainType &domainObject)> ResultTransformation;
 protected:
    typedef std::function<KAsync::Job<void>()> QueryFunction;
@@ -43,7 +46,6 @@ protected:
        queryFunction = query;
    }
 protected slots:
    /**
     * Rerun query with new revision
@@ -82,10 +84,17 @@ public:
    QueryRunner(const Sink::Query &query, const Sink::ResourceAccessInterface::Ptr &, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType);
    virtual ~QueryRunner();
+    /**
+     * Allows you to run a transformation on every result.
+     * This transformation is executed in the query thread.
+     */
+    void setResultTransformation(const ResultTransformation &transformation);
    typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr emitter();
 private:
    QSharedPointer<Sink::ResourceAccessInterface> mResourceAccess;
    QSharedPointer<Sink::ResultProvider<typename DomainType::Ptr> > mResultProvider;
+    ResultTransformation mResultTransformation;
 };
diff --git a/common/resource.cpp b/common/resource.cpp
index 8c448a8..5cbb2f2 100644
--- a/common/resource.cpp
+++ b/common/resource.cpp
@@ -34,7 +34,7 @@ Resource::Resource()
    : QObject(),
    d(0)
 {
+    Q_UNUSED(d);
 }
 Resource::~Resource()
@@ -63,6 +63,11 @@ void Resource::setLowerBoundRevision(qint64 revision)
    Q_UNUSED(revision)
 }
+void Resource::removeDataFromDisk()
+{
+}
 class ResourceFactory::Private
 {
 public:
@@ -75,7 +80,7 @@ ResourceFactory::ResourceFactory(QObject *parent)
    : QObject(parent),
      d(0)
 {
+    Q_UNUSED(d);
 }
 ResourceFactory::~ResourceFactory()
@@ -129,3 +134,9 @@ ResourceFactory *ResourceFactory::load(const QString &resourceName)
 }
 } // namespace Sink
+//Ignore warning I don't know how to fix in a moc file
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
+#include "moc_resource.cpp"
+#pragma clang diagnostic pop
diff --git a/common/resource.h b/common/resource.h
index 30d6c46..ab30cb9 100644
--- a/common/resource.h
+++ b/common/resource.h
@@ -19,7 +19,7 @@
 */
 #pragma once
-#include <sinkcommon_export.h>
+#include "sink_export.h"
 #include <Async/Async>
 #include "notification.h"
@@ -31,7 +31,7 @@ class FacadeFactory;
 /**
 * Resource interface
 */
-class SINKCOMMON_EXPORT Resource : public QObject
+class SINK_EXPORT Resource : public QObject
 {
    Q_OBJECT
 public:
@@ -55,6 +55,11 @@ public:
     */
    virtual void setLowerBoundRevision(qint64 revision);
+    /**
+     * Remove the data from disk
+     */
+    virtual void removeDataFromDisk();
 Q_SIGNALS:
    void revisionUpdated(qint64);
    void notify(Notification);
@@ -67,7 +72,7 @@ private:
 /**
 * Factory interface for resource to implement.
 */
-class ResourceFactory : public QObject
+class SINK_EXPORT ResourceFactory : public QObject
 {
 public:
    static ResourceFactory *load(const QString &resourceName);
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 0c435c9..80d60e8 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -41,11 +41,13 @@
 #include <QProcess>
 #include <QDataStream>
 #include <QBuffer>
+#include <QTime>
 #undef Trace
-#define Trace() Sink::Log::debugStream(Sink::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, "ResourceAccess")
+#define TracePrivate() Trace_area("client.communication." + resourceInstanceIdentifier)
+#define Trace() Trace_area("client.communication." + d->resourceInstanceIdentifier)
 #undef Log
-#define Log(IDENTIFIER) Sink::Log::debugStream(Sink::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, "ResourceAccess("+IDENTIFIER+")")
+#define Log() Log_area("client.communication." + d->resourceInstanceIdentifier)
 static void queuedInvoke(const std::function<void()> &f, QObject *context = 0)
 {
@@ -168,45 +170,48 @@ KAsync::Job<void> ResourceAccess::Private::tryToConnect()
        return !socket;
    },
    [this, counter](KAsync::Future<void> &future) {
-        Trace() << "Loop";
+        TracePrivate() << "Loop";
-        KAsync::wait(50)
+        connectToServer(resourceInstanceIdentifier)
-        .then(connectToServer(resourceInstanceIdentifier))
        .then<void, QSharedPointer<QLocalSocket> >([this, &future](const QSharedPointer<QLocalSocket> &s) {
            Q_ASSERT(s);
            socket = s;
            future.setFinished();
-        },
+        }, [&future, counter, this](int errorCode, const QString &errorString) {
-        [&future, counter](int errorCode, const QString &errorString) {
+            static int waitTime = 10;
-            const int maxRetries = 10;
+            static int timeout = 500;
+            static int maxRetries = timeout / waitTime;
            if (*counter > maxRetries) {
-                Trace() << "Giving up";
+                TracePrivate() << "Giving up";
                future.setError(-1, "Failed to connect to socket");
            } else {
-                future.setFinished();
+                KAsync::wait(waitTime).then<void>([&future]() {
+                    future.setFinished();
+                }).exec();
            }
            *counter = *counter + 1;
-        }).exec();
+        })
+        .exec();
    });
 }
 KAsync::Job<void> ResourceAccess::Private::initializeSocket()
 {
    return KAsync::start<void>([this](KAsync::Future<void> &future) {
-        Trace() << "Trying to connect";
+        TracePrivate() << "Trying to connect";
        connectToServer(resourceInstanceIdentifier).then<void, QSharedPointer<QLocalSocket> >([this, &future](const QSharedPointer<QLocalSocket> &s) {
-            Trace() << "Connected to resource, without having to start it.";
+            TracePrivate() << "Connected to resource, without having to start it.";
            Q_ASSERT(s);
            socket = s;
            future.setFinished();
        },
        [this, &future](int errorCode, const QString &errorString) {
-            Trace() << "Failed to connect, starting resource";
+            TracePrivate() << "Failed to connect, starting resource";
            //We failed to connect, so let's start the resource
            QStringList args;
            args << resourceInstanceIdentifier;
            qint64 pid = 0;
            if (QProcess::startDetached("sink_synchronizer", args, QDir::homePath(), &pid)) {
-                Trace() << "Started resource " << pid;
+                TracePrivate() << "Started resource " << pid;
                tryToConnect()
                .then<void>([&future]() {
                    future.setFinished();
@@ -232,12 +237,12 @@ ResourceAccess::ResourceAccess(const QByteArray &resourceInstanceIdentifier)
    : ResourceAccessInterface(),
      d(new Private(getResourceName(resourceInstanceIdentifier), resourceInstanceIdentifier, this))
 {
-    log("Starting access");
+    Log() << "Starting access";
 }
 ResourceAccess::~ResourceAccess()
 {
-    log("Closing access");
+    Log() << "Closing access";
    if (!d->resultHandler.isEmpty()) {
        Warning() << "Left jobs running while shutting down ResourceAccess: " << d->resultHandler.keys();
    }
@@ -380,9 +385,11 @@ void ResourceAccess::open()
    if (d->openingSocket) {
        return;
    }
+    auto time = QSharedPointer<QTime>::create();
+    time->start();
    d->openingSocket = true;
-    d->initializeSocket().then<void>([this]() {
+    d->initializeSocket().then<void>([this, time]() {
-        Trace() << "Socket is initialized";
+        Trace() << "Socket is initialized." << Log::TraceTime(time->elapsed());
        d->openingSocket = false;
        QObject::connect(d->socket.data(), &QLocalSocket::disconnected,
                this, &ResourceAccess::disconnected);
@@ -400,7 +407,7 @@ void ResourceAccess::open()
 void ResourceAccess::close()
 {
-    log(QString("Closing %1").arg(d->socket->fullServerName()));
+    Log() << QString("Closing %1").arg(d->socket->fullServerName());
    Trace() << "Pending commands: " << d->pendingCommands.size();
    Trace() << "Queued commands: " << d->commandQueue.size();
    d->socket->close();
@@ -412,7 +419,7 @@ void ResourceAccess::sendCommand(const QSharedPointer<QueuedCommand> &command)
    //TODO: we should have a timeout for commands
    d->messageId++;
    const auto messageId = d->messageId;
-    log(QString("Sending command \"%1\" with messageId %2").arg(QString(Sink::Commands::name(command->commandId))).arg(d->messageId));
+    Log() << QString("Sending command \"%1\" with messageId %2").arg(QString(Sink::Commands::name(command->commandId))).arg(d->messageId);
    Q_ASSERT(command->callback);
    registerCallback(d->messageId, [this, messageId, command](int errorCode, QString errorMessage) {
        Trace() << "Command complete " << messageId;
@@ -452,7 +459,7 @@ void ResourceAccess::connected()
        return;
    }
-    log(QString("Connected: %1").arg(d->socket->fullServerName()));
+    Log() << QString("Connected: %1").arg(d->socket->fullServerName());
    {
        flatbuffers::FlatBufferBuilder fbb;
@@ -472,7 +479,7 @@ void ResourceAccess::connected()
 void ResourceAccess::disconnected()
 {
-    log(QString("Disconnected from %1").arg(d->socket->fullServerName()));
+    Log() << QString("Disconnected from %1").arg(d->socket->fullServerName());
    d->socket->close();
    emit ready(false);
 }
@@ -480,7 +487,7 @@ void ResourceAccess::disconnected()
 void ResourceAccess::connectionError(QLocalSocket::LocalSocketError error)
 {
    if (error == QLocalSocket::PeerClosedError) {
-        Log(d->resourceInstanceIdentifier) << "The resource closed the connection.";
+        Log() << "The resource closed the connection.";
        d->abortPendingOperations();
    } else {
        Warning() << QString("Connection error: %1 : %2").arg(error).arg(d->socket->errorString());
@@ -524,14 +531,17 @@ bool ResourceAccess::processMessageBuffer()
    switch (commandId) {
        case Commands::RevisionUpdateCommand: {
            auto buffer = Commands::GetRevisionUpdate(d->partialMessageBuffer.constData() + headerSize);
-            log(QString("Revision updated to: %1").arg(buffer->revision()));
+            Log() << QString("Revision updated to: %1").arg(buffer->revision());
+            Notification n;
+            n.type = Sink::Commands::NotificationType::NotificationType_RevisionUpdate;
+            emit notification(n);
            emit revisionChanged(buffer->revision());
            break;
        }
        case Commands::CommandCompletionCommand: {
            auto buffer = Commands::GetCommandCompletion(d->partialMessageBuffer.constData() + headerSize);
-            log(QString("Command with messageId %1 completed %2").arg(buffer->id()).arg(buffer->success() ? "sucessfully" : "unsuccessfully"));
+            Log() << QString("Command with messageId %1 completed %2").arg(buffer->id()).arg(buffer->success() ? "sucessfully" : "unsuccessfully");
            d->completeCommands << buffer->id();
            //The callbacks can result in this object getting destroyed directly, so we need to ensure we finish our work first
@@ -544,11 +554,11 @@ bool ResourceAccess::processMessageBuffer()
            auto buffer = Commands::GetNotification(d->partialMessageBuffer.constData() + headerSize);
            switch (buffer->type()) {
                case Sink::Commands::NotificationType::NotificationType_Shutdown:
-                    Log(d->resourceInstanceIdentifier) << "Received shutdown notification.";
+                    Log() << "Received shutdown notification.";
                    close();
                    break;
                case Sink::Commands::NotificationType::NotificationType_Inspection: {
-                    Log(d->resourceInstanceIdentifier) << "Received inspection notification.";
+                    Log() << "Received inspection notification.";
                    Notification n;
                    if (buffer->identifier()) {
                        //Don't use fromRawData, the buffer is gone once we invoke emit notification
@@ -566,6 +576,10 @@ bool ResourceAccess::processMessageBuffer()
                    }, this);
                }
                    break;
+                case Sink::Commands::NotificationType::NotificationType_Status:
+                case Sink::Commands::NotificationType::NotificationType_Warning:
+                case Sink::Commands::NotificationType::NotificationType_Progress:
+                case Sink::Commands::NotificationType::NotificationType_RevisionUpdate:
                default:
                    Warning() << "Received unknown notification: " << buffer->type();
                    break;
@@ -580,9 +594,9 @@ bool ResourceAccess::processMessageBuffer()
    return d->partialMessageBuffer.size() >= headerSize;
 }
-void ResourceAccess::log(const QString &message)
-{
-    Log(d->resourceInstanceIdentifier) << this << message;
 }
-}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
+#include "moc_resourceaccess.cpp"
+#pragma clang diagnostic pop
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index 73b676b..4c10adb 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -20,6 +20,7 @@
 #pragma once
+#include "sink_export.h"
 #include <QLocalSocket>
 #include <QObject>
 #include <QTimer>
@@ -34,7 +35,7 @@ namespace Sink
 struct QueuedCommand;
-class ResourceAccessInterface : public QObject
+class SINK_EXPORT ResourceAccessInterface : public QObject
 {
    Q_OBJECT
 public:
@@ -62,7 +63,7 @@ public Q_SLOTS:
    virtual void close() = 0;
 };
-class ResourceAccess : public ResourceAccessInterface
+class SINK_EXPORT ResourceAccess : public ResourceAccessInterface
 {
    Q_OBJECT
 public:
@@ -100,7 +101,6 @@ private Q_SLOTS:
 private:
    void connected();
-    void log(const QString &message);
    void registerCallback(uint messageId, const std::function<void(int error, const QString &)> &callback);
    void sendCommand(const QSharedPointer<QueuedCommand> &command);
diff --git a/common/resourceconfig.h b/common/resourceconfig.h
index cc9cb94..2108caa 100644
--- a/common/resourceconfig.h
+++ b/common/resourceconfig.h
@@ -19,12 +19,13 @@
 #pragma once
+#include "sink_export.h"
 #include <QList>
 #include <QByteArray>
 #include <QVariant>
 #include <QMap>
-class ResourceConfig
+class SINK_EXPORT ResourceConfig
 {
 public:
    static QMap<QByteArray, QByteArray> getResources();
diff --git a/common/resourcecontrol.cpp b/common/resourcecontrol.cpp
new file mode 100644
index 0000000..83558bd
--- /dev/null
+++ b/common/resourcecontrol.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "resourcecontrol.h"
+#include <QTime>
+#include <QUuid>
+#include <functional>
+#include "resourceaccess.h"
+#include "commands.h"
+#include "log.h"
+#include "notifier.h"
+#undef DEBUG_AREA
+#define DEBUG_AREA "client.resourcecontrol"
+namespace Sink
+{
+KAsync::Job<void> ResourceControl::shutdown(const QByteArray &identifier)
+{
+    Trace() << "shutdown " << identifier;
+    auto time = QSharedPointer<QTime>::create();
+    time->start();
+    return ResourceAccess::connectToServer(identifier).then<void, QSharedPointer<QLocalSocket>>([identifier, time](QSharedPointer<QLocalSocket> socket, KAsync::Future<void> &future) {
+        //We can't currently reuse the socket
+        socket->close();
+        auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(identifier);
+        resourceAccess->open();
+        resourceAccess->sendCommand(Sink::Commands::ShutdownCommand).then<void>([&future, resourceAccess, time]() {
+            Trace() << "Shutdown complete." << Log::TraceTime(time->elapsed());
+            future.setFinished();
+        }).exec();
+    },
+    [](int, const QString &) {
+        Trace() << "Resource is already closed.";
+        //Resource isn't started, nothing to shutdown
+    });
+}
+KAsync::Job<void> ResourceControl::start(const QByteArray &identifier)
+{
+    Trace() << "start " << identifier;
+    auto time = QSharedPointer<QTime>::create();
+    time->start();
+    auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(identifier);
+    resourceAccess->open();
+    return resourceAccess->sendCommand(Sink::Commands::PingCommand).then<void>([resourceAccess, time]() {
+        Trace() << "Start complete." << Log::TraceTime(time->elapsed());
+    });
+}
+KAsync::Job<void> ResourceControl::flushMessageQueue(const QByteArrayList &resourceIdentifier)
+{
+    Trace() << "flushMessageQueue" << resourceIdentifier;
+    return KAsync::iterate(resourceIdentifier)
+    .template each<void, QByteArray>([](const QByteArray &resource, KAsync::Future<void> &future) {
+        Trace() << "Flushing message queue " << resource;
+        auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(resource);
+        resourceAccess->open();
+        resourceAccess->synchronizeResource(false, true).then<void>([&future, resourceAccess]() {
+            future.setFinished();
+        }).exec();
+    });
+}
+KAsync::Job<void> ResourceControl::flushReplayQueue(const QByteArrayList &resourceIdentifier)
+{
+    return flushMessageQueue(resourceIdentifier);
+}
+template <class DomainType>
+KAsync::Job<void> ResourceControl::inspect(const Inspection &inspectionCommand)
+{
+    auto resource = inspectionCommand.resourceIdentifier;
+    auto time = QSharedPointer<QTime>::create();
+    time->start();
+    Trace() << "Sending inspection " << resource;
+    auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(resource);
+    resourceAccess->open();
+    auto notifier = QSharedPointer<Sink::Notifier>::create(resourceAccess);
+    auto id = QUuid::createUuid().toByteArray();
+    return resourceAccess->sendInspectionCommand(id, ApplicationDomain::getTypeName<DomainType>(), inspectionCommand.entityIdentifier, inspectionCommand.property, inspectionCommand.expectedValue)
+        .template then<void>([resourceAccess, notifier, id, time](KAsync::Future<void> &future) {
+            notifier->registerHandler([&future, id, time](const Notification &notification) {
+                if (notification.id == id) {
+                    Trace() << "Inspection complete." << Log::TraceTime(time->elapsed());
+                    if (notification.code) {
+                        future.setError(-1, "Inspection returned an error: " + notification.message);
+                    } else {
+                        future.setFinished();
+                    }
+                }
+            });
+        });
+}
+#define REGISTER_TYPE(T) template KAsync::Job<void> ResourceControl::inspect<T>(const Inspection &); \
+REGISTER_TYPE(ApplicationDomain::Event);
+REGISTER_TYPE(ApplicationDomain::Mail);
+REGISTER_TYPE(ApplicationDomain::Folder);
+REGISTER_TYPE(ApplicationDomain::SinkResource);
+} // namespace Sink
diff --git a/common/resourcecontrol.h b/common/resourcecontrol.h
new file mode 100644
index 0000000..5bfa67f
--- /dev/null
+++ b/common/resourcecontrol.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include "sink_export.h"
+#include <QByteArray>
+#include <Async/Async>
+#include "inspection.h"
+namespace Sink {
+namespace ResourceControl {
+template <class DomainType>
+KAsync::Job<void> SINK_EXPORT inspect(const Inspection &inspectionCommand);
+/**
+ * Shutdown resource.
+ */
+KAsync::Job<void> SINK_EXPORT shutdown(const QByteArray &resourceIdentifier);
+/**
+ * Start resource.
+ * 
+ * The resource is ready for operation once this command completes.
+ * This command is only necessary if a resource was shutdown previously,
+ * otherwise the resource process will automatically start as necessary.
+ */
+KAsync::Job<void> SINK_EXPORT start(const QByteArray &resourceIdentifier);
+/**
+ * Flushes any pending messages to disk
+ */
+KAsync::Job<void> SINK_EXPORT flushMessageQueue(const QByteArrayList &resourceIdentifier);
+/**
+ * Flushes any pending messages that haven't been replayed to the source.
+ */
+KAsync::Job<void> SINK_EXPORT flushReplayQueue(const QByteArrayList &resourceIdentifier);
+    }
+}
diff --git a/common/resultprovider.h b/common/resultprovider.h
index 6958dbf..2d6efbe 100644
--- a/common/resultprovider.h
+++ b/common/resultprovider.h
@@ -27,8 +27,6 @@
 #include "resultset.h"
 #include "log.h"
-using namespace async;
 namespace Sink {
 /**
@@ -47,6 +45,11 @@ public:
    }
+    virtual ~ResultProviderInterface()
+    {
+    }
    virtual void add(const T &value) = 0;
    virtual void modify(const T &value) = 0;
    virtual void remove(const T &value) = 0;
@@ -183,7 +186,7 @@ public:
    void onDone(const std::function<void()> &callback)
    {
-        mThreadBoundary = QSharedPointer<ThreadBoundary>::create();
+        mThreadBoundary = QSharedPointer<async::ThreadBoundary>::create();
        mOnDoneCallback = callback;
    }
@@ -212,7 +215,7 @@ private:
    QWeakPointer<ResultEmitter<T> > mResultEmitter;
    std::function<void()> mOnDoneCallback;
-    QSharedPointer<ThreadBoundary> mThreadBoundary;
+    QSharedPointer<async::ThreadBoundary> mThreadBoundary;
    std::function<void(const T &parent)> mFetcher;
 };
@@ -327,7 +330,7 @@ private:
    std::function<void(void)> clearHandler;
    std::function<void(const DomainType &parent)> mFetcher;
-    ThreadBoundary mThreadBoundary;
+    async::ThreadBoundary mThreadBoundary;
 };
 template<class DomainType>
diff --git a/common/storage.h b/common/storage.h
index 2d34f1f..ac03947 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -21,7 +21,7 @@
 #pragma once
-#include <sinkcommon_export.h>
+#include "sink_export.h"
 #include <string>
 #include <functional>
 #include <QString>
@@ -29,7 +29,7 @@
 namespace Sink
 {
-class SINKCOMMON_EXPORT Storage {
+class SINK_EXPORT Storage {
 public:
    enum AccessMode { ReadOnly, ReadWrite };
@@ -180,6 +180,13 @@ public:
    qint64 diskUsage() const;
    void removeFromDisk() const;
+    /**
+     * Clears all cached environments.
+     * 
+     * This only ever has to be called if a database was removed from another process.
+     */
+    static void clearEnv();
    static qint64 maxRevision(const Sink::Storage::Transaction &);
    static void setMaxRevision(Sink::Storage::Transaction &, qint64 revision);
@@ -200,6 +207,8 @@ public:
    static QByteArray assembleKey(const QByteArray &key, qint64 revision);
    static QByteArray uidFromKey(const QByteArray &key);
+    static NamedDatabase mainDatabase(const Sink::Storage::Transaction &, const QByteArray &type);
 private:
    std::function<void(const Storage::Error &error)> mErrorHandler;
diff --git a/common/storage_common.cpp b/common/storage_common.cpp
index ea97ac2..0b842d1 100644
--- a/common/storage_common.cpp
+++ b/common/storage_common.cpp
@@ -156,6 +156,11 @@ QByteArray Storage::uidFromKey(const QByteArray &key)
    return key.mid(0, 38);
 }
+Storage::NamedDatabase Storage::mainDatabase(const Sink::Storage::Transaction &t, const QByteArray &type)
+{
+    return t.openDatabase(type + ".main");
+}
 bool Storage::NamedDatabase::contains(const QByteArray &uid)
 {
    bool found = false;
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index 6539eb0..1efffc4 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -156,8 +156,8 @@ void Storage::NamedDatabase::remove(const QByteArray &k, const QByteArray &value
                     const std::function<void(const Storage::Error &error)> &errorHandler)
 {
    if (!d || !d->transaction) {
-        Error error(d->name.toLatin1() + d->db, ErrorCodes::GenericError, "Not open");
        if (d) {
+            Error error(d->name.toLatin1() + d->db, ErrorCodes::GenericError, "Not open");
            errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
        }
        return;
@@ -443,8 +443,8 @@ Storage::NamedDatabase Storage::Transaction::openDatabase(const QByteArray &db,
    d->implicitCommit = true;
    auto p = new Storage::NamedDatabase::Private(db, allowDuplicates, d->defaultErrorHandler, d->name, d->transaction);
    if (!p->openDatabase(d->requestedRead, errorHandler)) {
-        return Storage::NamedDatabase();
        delete p;
+        return Storage::NamedDatabase();
    }
    return Storage::NamedDatabase(p);
 }
@@ -463,7 +463,7 @@ QList<QByteArray> Storage::Transaction::getDatabaseNames() const
        MDB_val data;
        MDB_cursor *cursor;
-        rc = mdb_cursor_open(d->transaction, d->dbi, &cursor);
+        mdb_cursor_open(d->transaction, d->dbi, &cursor);
        if ((rc = mdb_cursor_get(cursor, &key, &data, MDB_FIRST)) == 0) {
            list << QByteArray::fromRawData((char*)key.mv_data, key.mv_size);
            while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
@@ -615,4 +615,12 @@ void Storage::removeFromDisk() const
    mdb_env_close(env);
 }
+void Storage::clearEnv()
+{
+    for (auto env : Storage::Private::sEnvironments) {
+        mdb_env_close(env);
+    }
+    Storage::Private::sEnvironments.clear();
+}
 } // namespace Sink
diff --git a/common/clientapi.cpp b/common/store.cpp
index be9f3fd..6f080b5 100644
--- a/common/clientapi.cpp
+++ b/common/store.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -18,14 +18,10 @@
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
-#include "clientapi.h"
+#include "store.h"
-#include <QtConcurrent/QtConcurrentRun>
+#include <QTime>
-#include <QTimer>
-#include <QEventLoop>
 #include <QAbstractItemModel>
-#include <QDir>
-#include <QUuid>
 #include <functional>
 #include <memory>
@@ -39,6 +35,9 @@
 #include "storage.h"
 #include "log.h"
+#undef DEBUG_AREA
+#define DEBUG_AREA "client.store"
 namespace Sink
 {
@@ -47,11 +46,6 @@ QString Store::storageLocation()
    return Sink::storageLocation();
 }
-QByteArray Store::resourceName(const QByteArray &instanceIdentifier)
-{
-    return Sink::resourceName(instanceIdentifier);
-}
 static QList<QByteArray> getResources(const QList<QByteArray> &resourceFilter, const QByteArray &type)
 {
    //Return the global resource (signified by an empty name) for types that don't eblong to a specific resource
@@ -156,47 +150,21 @@ KAsync::Job<void> Store::remove(const DomainType &domainObject)
    });
 }
-KAsync::Job<void> Store::shutdown(const QByteArray &identifier)
+KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
-{
-    Trace() << "shutdown " << identifier;
-    return ResourceAccess::connectToServer(identifier).then<void, QSharedPointer<QLocalSocket>>([identifier](QSharedPointer<QLocalSocket> socket, KAsync::Future<void> &future) {
-        //We can't currently reuse the socket
-        socket->close();
-        auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(identifier);
-        resourceAccess->open();
-        resourceAccess->sendCommand(Sink::Commands::ShutdownCommand).then<void>([&future, resourceAccess]() {
-            Trace() << "Shutdown complete";
-            future.setFinished();
-        }).exec();
-    },
-    [](int, const QString &) {
-        Trace() << "Resource is already closed.";
-        //Resource isn't started, nothing to shutdown
-    })
-    //FIXME JOBAPI this is only required because we don't care about the return value of connectToServer
-    .template then<void>([](){});
-}
-KAsync::Job<void> Store::start(const QByteArray &identifier)
 {
-    Trace() << "start " << identifier;
+    //All databases are going to become invalid, nuke the environments
+    //TODO: all clients should react to a notification the resource
+    Sink::Storage::clearEnv();
+    Trace() << "Remove data from disk " << identifier;
+    auto time = QSharedPointer<QTime>::create();
+    time->start();
    auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(identifier);
    resourceAccess->open();
-    return resourceAccess->sendCommand(Sink::Commands::PingCommand).then<void>([resourceAccess]() {
+    return resourceAccess->sendCommand(Sink::Commands::RemoveFromDiskCommand).then<void>([resourceAccess, time]() {
-        Trace() << "Start complete";
+        Trace() << "Remove from disk complete." << Log::TraceTime(time->elapsed());
    });
 }
-void Store::removeFromDisk(const QByteArray &identifier)
-{
-    //TODO By calling the resource executable with a --remove option instead
-    //we can ensure that no other resource process is running at the same time
-    QDir dir(Sink::storageLocation());
-    for (const auto &folder : dir.entryList(QStringList() << identifier + "*")) {
-        Sink::Storage(Sink::storageLocation(), folder, Sink::Storage::ReadWrite).removeFromDisk();
-    }
-}
 KAsync::Job<void> Store::synchronize(const Sink::Query &query)
 {
    Trace() << "synchronize" << query.resources;
@@ -208,30 +176,7 @@ KAsync::Job<void> Store::synchronize(const Sink::Query &query)
        resourceAccess->synchronizeResource(true, false).then<void>([&future, resourceAccess]() {
            future.setFinished();
        }).exec();
-    })
+    });
-    //FIXME JOBAPI this is only required because we don't care about the return value of each (and each shouldn't even have a return value)
-    .template then<void>([](){});
-}
-KAsync::Job<void> Store::flushMessageQueue(const QByteArrayList &resourceIdentifier)
-{
-    Trace() << "flushMessageQueue" << resourceIdentifier;
-    return KAsync::iterate(resourceIdentifier)
-    .template each<void, QByteArray>([](const QByteArray &resource, KAsync::Future<void> &future) {
-        Trace() << "Flushing message queue " << resource;
-        auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(resource);
-        resourceAccess->open();
-        resourceAccess->synchronizeResource(false, true).then<void>([&future, resourceAccess]() {
-            future.setFinished();
-        }).exec();
-    })
-    //FIXME JOBAPI this is only required because we don't care about the return value of each (and each shouldn't even have a return value)
-    .template then<void>([](){});
-}
-KAsync::Job<void> Store::flushReplayQueue(const QByteArrayList &resourceIdentifier)
-{
-    return flushMessageQueue(resourceIdentifier);
 }
 template <class DomainType>
@@ -295,63 +240,10 @@ KAsync::Job<QList<typename DomainType::Ptr> > Store::fetch(const Sink::Query &qu
    });
 }
-template <class DomainType>
-KAsync::Job<void> Resources::inspect(const Inspection &inspectionCommand)
-{
-    auto resource = inspectionCommand.resourceIdentifier;
-    Trace() << "Sending inspection " << resource;
-    auto resourceAccess = QSharedPointer<Sink::ResourceAccess>::create(resource);
-    resourceAccess->open();
-    auto notifier = QSharedPointer<Sink::Notifier>::create(resourceAccess);
-    auto id = QUuid::createUuid().toByteArray();
-    return resourceAccess->sendInspectionCommand(id, ApplicationDomain::getTypeName<DomainType>(), inspectionCommand.entityIdentifier, inspectionCommand.property, inspectionCommand.expectedValue)
-        .template then<void>([resourceAccess, notifier, id](KAsync::Future<void> &future) {
-            notifier->registerHandler([&future, id](const Notification &notification) {
-                if (notification.id == id) {
-                    if (notification.code) {
-                        future.setError(-1, "Inspection returned an error: " + notification.message);
-                    } else {
-                        future.setFinished();
-                    }
-                }
-            });
-        });
-}
-class Sink::Notifier::Private {
-public:
-    Private()
-        : context(new QObject)
-    {
-    }
-    QList<QSharedPointer<ResourceAccess> > resourceAccess;
-    QList<std::function<void(const Notification &)> > handler;
-    QSharedPointer<QObject> context;
-};
-Notifier::Notifier(const QSharedPointer<ResourceAccess> &resourceAccess)
-    : d(new Sink::Notifier::Private)
-{
-    QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
-        for (const auto &handler : d->handler) {
-            handler(notification);
-        }
-    });
-    d->resourceAccess << resourceAccess;
-}
-void Notifier::registerHandler(std::function<void(const Notification &)> handler)
-{
-    d->handler << handler;
-}
 #define REGISTER_TYPE(T) template KAsync::Job<void> Store::remove<T>(const T &domainObject); \
    template KAsync::Job<void> Store::create<T>(const T &domainObject); \
    template KAsync::Job<void> Store::modify<T>(const T &domainObject); \
    template QSharedPointer<QAbstractItemModel> Store::loadModel<T>(Query query); \
-    template KAsync::Job<void> Resources::inspect<T>(const Inspection &); \
    template KAsync::Job<T> Store::fetchOne<T>(const Query &); \
    template KAsync::Job<QList<T::Ptr> > Store::fetchAll<T>(const Query &); \
    template KAsync::Job<QList<T::Ptr> > Store::fetch<T>(const Query &, int); \
diff --git a/common/store.h b/common/store.h
new file mode 100644
index 0000000..6696833
--- /dev/null
+++ b/common/store.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include "sink_export.h"
+#include <QString>
+#include <QSharedPointer>
+#include <Async/Async>
+#include "query.h"
+#include "applicationdomaintype.h"
+class QAbstractItemModel;
+namespace Sink {
+/**
+ * The unified Sink Store.
+ * 
+ * This is the primary interface for clients to interact with Sink.
+ * It provides a unified store where all data provided by various resources can be accessed and modified.
+ */
+namespace Store {
+QString SINK_EXPORT storageLocation();
+enum Roles {
+    DomainObjectRole = Qt::UserRole + 1, //Must be the same as in ModelResult
+    ChildrenFetchedRole,
+    DomainObjectBaseRole
+};
+/**
+    * Asynchronusly load a dataset with tree structure information
+    */
+template <class DomainType>
+QSharedPointer<QAbstractItemModel> SINK_EXPORT loadModel(Query query);
+/**
+ * Create a new entity.
+ */
+template <class DomainType>
+KAsync::Job<void> SINK_EXPORT create(const DomainType &domainObject);
+/**
+ * Modify an entity.
+ * 
+ * This includes moving etc. since these are also simple settings on a property.
+ */
+template <class DomainType>
+KAsync::Job<void> SINK_EXPORT modify(const DomainType &domainObject);
+/**
+ * Remove an entity.
+ */
+template <class DomainType>
+KAsync::Job<void> SINK_EXPORT remove(const DomainType &domainObject);
+/**
+ * Synchronize data to local cache.
+ */
+KAsync::Job<void> SINK_EXPORT synchronize(const Sink::Query &query);
+/**
+ * Removes all resource data from disk.
+ * 
+ * This will not touch the configuration. All commands that that arrived at the resource before this command will be dropped. All commands that arrived later will be executed.
+ */
+KAsync::Job<void> SINK_EXPORT removeDataFromDisk(const QByteArray &resourceIdentifier);
+template <class DomainType>
+KAsync::Job<DomainType> SINK_EXPORT fetchOne(const Sink::Query &query);
+template <class DomainType>
+KAsync::Job<QList<typename DomainType::Ptr> > SINK_EXPORT fetchAll(const Sink::Query &query);
+template <class DomainType>
+KAsync::Job<QList<typename DomainType::Ptr> > SINK_EXPORT fetch(const Sink::Query &query, int minimumAmount = 0);
+    }
+}
diff --git a/common/threadboundary.h b/common/threadboundary.h
index 0d8ed3b..7bea4ea 100644
--- a/common/threadboundary.h
+++ b/common/threadboundary.h
@@ -20,6 +20,8 @@
 #pragma once
+#include "sink_export.h"
 #include <QObject>
 #include <functional>
@@ -29,7 +31,7 @@ namespace async {
 * A helper class to invoke a method in a different thread using the event loop.
 * The ThreadBoundary object must live in the thread where the function should be called.
 */
-class ThreadBoundary : public QObject {
+class SINK_EXPORT ThreadBoundary : public QObject {
    Q_OBJECT
 public:
    ThreadBoundary();
diff --git a/common/typeindex.cpp b/common/typeindex.cpp
index 03ad8f7..b1bcf6a 100644
--- a/common/typeindex.cpp
+++ b/common/typeindex.cpp
@@ -22,6 +22,9 @@
 #include "index.h"
 #include <QDateTime>
+#undef DEBUG_AREA
+#define DEBUG_AREA "common.typeindex"
 TypeIndex::TypeIndex(const QByteArray &type)
    : mType(type)
 {
@@ -111,9 +114,9 @@ ResultSet TypeIndex::query(const Sink::Query &query, QSet<QByteArray> &appliedFi
                Warning() << "Error in index: " <<  error.message << property;
            });
            appliedFilters << property;
+            Trace() << "Index lookup on " << property << " found " << keys.size() << " keys.";
+            return ResultSet(keys);
        }
-        Trace() << "Index lookup on " << property << " found " << keys.size() << " keys.";
-        return ResultSet(keys);
    }
    Trace() << "No matching index";
    return ResultSet(keys);
diff --git a/docs/building.md b/docs/building.md
index 907827d..17ef54b 100644
--- a/docs/building.md
+++ b/docs/building.md
@@ -85,3 +85,15 @@ mkdir build && cd build
 cmake ..
 make install
 ```
+# Dependencies
+* ExtraCmakeModules >= 0.0.10
+* Qt >= 5.2
+* KF5::Async >= 0.1
+* flatbuffers >= 1.0
+* libgit2
+* readline
+## Maildir Resource
+* KF5::Mime
diff --git a/docs/clientapi.md b/docs/clientapi.md
index 219f972..be8ff19 100644
--- a/docs/clientapi.md
+++ b/docs/clientapi.md
@@ -13,16 +13,6 @@ The client API consists of:
 * property-level on-demand loading of data
 * streaming support for large properties (attachments)
-## Domain Types
-A set of standardized domain types is defined. This is necessary to decouple applications from resources (so a calendar can access events from all resources), and to have a "language" for queries.
-The definition of the domain model directly affects:
-* granularity for data retrieval (email property, or individual subject, date, ...)
-* queriable properties for filtering and sorting (sender, id, ...)
-The purpose of these domain types is strictly to be the interface and the types are not necessarily meant to be used by applications directly, or to be restricted by any other specifications (such as ical). By nature these types will be part of the evolving interface, and will need to be adjusted for every new property that an application must understand.
 ## Store Facade
 The store is always accessed through a store specific facade, which hides:
@@ -52,118 +42,12 @@ Each modification is associated with a specific revision, which allows the synch
 ### Conflict Resolution
 Conflicts can occur at two points:
-* While i.e. an editor is open and we receive an update for the same entity
+* In the client: While i.e. an editor is open and we receive an update for the same entity
-* After a modification is sent to the synchronizer but before it's processed
+* In the synchronizer: After a modification is sent to the synchronizer but before it's processed
 In the first case the client is repsonsible to resolve the conflict, in the latter case it's the synchronizer's responsibility.
 A small window exists where the client has already started the modification (i.e. command is in socket), and a notification has not yet arrived that the same entity has been changed. In such a case the synchronizer may reject the modification because it has the revision the modification refers to no longer available.
-This design allows the synchronizer to be in control of the revisions, and keeps it from having to wait for all clients to update until it can drop revisions.
-## Query System
-The query system should allow for efficient retrieval for just the amount of data required by the client. Efficient querying is supported by the indexes provided by the resources.
-The query always retrieves a set of entities matching the query, while not necessarily all properties of the entity need to be populated.
-Queries should are declarative to keep the specification simple and to allow the implementation to choose the most efficient execution.
-Queries can be kept open (live) to receive updates as the store changes.
-### Query
-The query consists of:
-* a set of filters to match the wanted entities
-* the set of properties to retrieve for each entity
-Queryable properties are defined by the [[Domain Types]] above.
-### Query Result
-The result is returned directly after running the query in form of a QAbstractItemModel. Each row in the model represents a matching entity.
-The model allows to access the domain object directly, or to access individual properties directly via the rows columns.
-The model is always populated asynchronously. It is therefore initially empty and will then populate itself gradually, through the regular update mechanisms (rowsInserted).
-Tree Queries allow the application to query for i.e. a folder hierarchy in a single query. This is necessary for performance reasons to avoid recursive querying in large hierarchies. To avoid on the other hand loading large hierchies directly into memory, the model only populates the toplevel rows automatically, all other rows need to be populated by calling `QAbstractItemModel::fetchMore(QModelIndex);`. This way the resource can deal efficiently with the query (i.e. by avoiding the many roundtrips that would be necessary with recursive queries), while keeping the amount of data in memory to a minimum (i.e. if the majority of the folder tree is collapsed in the view anyways). A tree result set can therefore be seen as a set of sets, where every subset corresponds to the children of one parent.
-If the query is live, the model updates itself if the update applies to one of the already loaded subsets (otherwise it's currently irrelevant and will load once the subset is loaded).
-#### Enhancements
-* Asynchronous loading of entities/properties can be achieved by returning an invalid QVariant initially, and emitting dataChanged once the value is loaded.
-* To avoid loading a large list when not all data is necessary, a batch size could be defined to guarantee for instance that there is sufficient data to fill the screen, and the fetchMore mechanism can be used to gradually load more data as required when scrolling in the application.
-#### Filter
-A filter consists of:
-* a property to filter on as defined by the [[Domain Types]]
-* a comparator to use
-* a value
-The available comparators are:
-* equal
-* greater than
-* less than
-* inclusive range
-Value types include:
-* Null
-* Bool
-* Regular Expression
-* Substring
-* A type-specific literal value (e.g. string, number, date, ..)
-Filters can be combined using AND, OR, NOT.
-#### Example
-```
-query =  {
-    offset: int
-    limit: int
-    filter = {
-        and {
-            collection = foo
-            or {
-                resource = res1
-                resource = res2
-            }
-        }
-    }
-}
-```
-possible API:
-```
-query.filter().and().property("collection") = "foo"
-query.filter().and().or().property("resource") = "res1"
-query.filter().and().or().property("resource") = "res2"
-query.filter().and().property("start-date") = InclusiveRange(QDateTime, QDateTime)
-```
-The problem is that it is difficult to adjust an individual resource property like that.
-### Usecases ###
-Mail:
-* All mails in folder X within date-range Y that are unread.
-* All mails (in all folders) that contain the string X in property Y.
-Todos:
-* Give me all the todos in that collection where their RELATED-TO field maps to no other todo UID field in the collection
-* Give me all the todos in that collection where their RELATED-TO field has a given value
-* Give me all the collections which have a given collection as parent and which have a descendant matching a criteria on its attributes;
-Events:
-* All events of calendar X within date-range Y.
-Generic:
-* entity with identifier X
-* all entities of resource X
 ### Lazy Loading ###
 The system provides property-level lazy loading. This allows i.e. to defer downloading of attachments until the attachments is accessed, at the expense of having to have access to the source (which could be connected via internet).
@@ -173,12 +57,3 @@ Note: We should perhaps define a minimum set of properties that *must* be availa
 ### Data streaming ###
 Large properties such as attachments should be streamable. An API that allows to retrieve a single property of a defined entity in a streamable fashion is probably enough.
-### Indexes ###
-Since only properties of the domain types can be queried, default implementations for commonly used indexes can be provided. These indexes are populated by generic preprocessors that use the domain-type interface to extract properties from individual entites.
-## Notifications ##
-A notification mechanism is required to inform clients about changes. Running queries will automatically update the result-set if a notification is received.
-Note: A notification could supply a hint on what changed, allowing clients to ignore revisions with irrelevant changes. 
-A running query can do all of that transparently behind the scenes. Note that the hints should indeed only hint what has changed, and not supply the actual changeset. These hints should be tailored to what we see as useful, and must therefore be easy to modify.
diff --git a/docs/design.md b/docs/design.md
index 4451b49..2890450 100644
--- a/docs/design.md
+++ b/docs/design.md
@@ -1,101 +1,45 @@
-# Design Goals
-## Axioms
-1. Personal information is stored in multiple sources (address books, email stores, calendar files, ...)
-2. These sources may local, remote or a mix of local and remote
-## Requirements
-1. Local mirrors of these sources must be available to 1..N local clients simultaneously
-2. Local clients must be able to make (or at least request) changes to the data in the local mirrors
-3. Local mirrors must be usable without network, even if the source is remote
-4. Local mirrors must be able to syncronoize local changes to their sources (local or remote)
-5. Local mirrors must be able to syncronize remote changes and propagate those to local clients
-6. Content must be searchable by a number of terms (dates, identities, body text ...)
-7. This must all run with acceptable performance on a moderate consumer-grade desktop system
-Nice to haves:
-1. As-close-to-zero-copy-as-possible for data
-2. Simple change notification semantics
-3. Resource-specific syncronization techniques
-4. Data agnostic storage
-Immediate goals:
-1. Ease development of new features in existing resources
-2. Ease maintenance of existing resources
-3. Make adding new resources easy
-4. Make adding new types of data or data relations easy
-5. Improve performance relative to existing Akonadi implementation
-Long-term goals:
-1. Project view: given a query, show all items in all stores that match that query easily and quickly
-Implications of the above:
-* Local mirrors must support multi-reader, but are probably best served with single-writer semantics as this simplifies both local change recording as well as remote synchronization by keeping it in one process which can process write requests (local or remote) in sequential fashion.
-* There is no requirement for a central server if the readers can concurrently access the local mirror directly
-* A storage system which requires a schema (e.g. relational databases) are a poor fit given the desire for data agnosticism and low memory copying
 # Overview
-## Client API
+Sink is a data access layer that additionally handles synchronization with external sources and indexing of data for efficient queries.
-The client facing API hides all Sink internals from the applications and emulates a unified store that provides data through a standardized interface. 
+## Store
+The client facing Store API hides all Sink internals from the applications and emulates a unified store that provides data through a standardized interface. 
 This allows applications to transparently use various data sources with various data source formats.
 ## Resource
 A resource is a plugin that provides access to an additional source. It consists of a store, a synchronizer process that executes synchronization & change replay to the source and maintains the store, as well as a facade plugin for the client api.
-## Store
+## Storage / Indexes
 Each resource maintains a store that can either store the full dataset for offline access or only metadata for quick lookups. Resources can define how data is stored.
+The store consists of revisions with every revision containing one entity.
+The store additionally contains various secondary indexes for efficient lookups.
 ## Types
 ### Domain Type
-The domain types exposed in the public interface.
+The domain types exposed in the public interface provide standardized access to the store. The domain types and their properties directly define the granularity of data retrieval and thus also what queries can be executed.
 ### Buffer Type
-The individual buffer types as specified by the resource. The are internal types that don't necessarily have a 1:1 mapping to the domain types, although that is the default case that the default implementations expect.
+The buffers used by the resources in the store may be different from resource to resource, and don't necessarily have a 1:1 mapping to the domain types.
+This allows resources to store data in a way that is convenient/efficient for synchronization, altough it may require a bit more effort when accessing the data.
+The individual buffer types are specified by the resource and internal to it. Default buffer types exist of all domain types.
+### Commands
+Commands are used to modify the store. The resource processes commands that are generated by clients and the synchronizer.
+### Notifications
+The resource emits notifications to inform clients of new revisions and other changes.
 ## Mechanisms
 ### Change Replay
 The change replay is based on the revisions in the store. Clients (as well as also the write-back mechanism that replays changes to the source), are informed that a new revision is available. Each client can then go through all new revisions (starting from the last seen revision), and thus update its state to the latest revision.
-### Preprocessor pipeline
+### Synchronization
-Each resource has an internal pipeline of preprocessors that can be used for tasks such as indexing or filtering. The pipeline guarantees that the preprocessor steps are executed before the entity is persisted.
+The synchronizer executes a periodic synchronization that results in change commands to synchronize the store with the source.
+The change-replay mechanism is used to write back changes to the source that happened locally.
-# Tradeoffs/Design Decisions
-* Key-Value store instead of relational
-    * `+` Schemaless, easier to evolve
-    * `-` No need to fully normalize the data in order to make it queriable. And without full normalization SQL is not really useful and bad performance wise. 
-    * `-` We need to maintain our own indexes
-* Individual store per resource
-    * Storage format defined by resource individually
-        * `-` Each resource needs to define it's own schema
-        * `+` Resources can adjust storage format to map well on what it has to synchronize
-        * `+` Synchronization state can directly be embedded into messages
-    * `+` Individual resources could switch to another store technology
-    * `+` Easier maintenance
-    * `+` Resource is only responsible for it's own store and doesn't accidentaly break another resources store
-    * `-` Inter`-`resource moves are both more complicated and more expensive from a client perspective
-    * `+` Inter`-`resource moves become simple additions and removals from a resource perspective
-    * `-` No system`-`wide unique id per message (only resource/id tuple identifies a message uniquely) 
-    * `+` Stores can work fully concurrently (also for writing)
-* Indexes defined and maintained by resources
+### Command processing
-    * `-` Relational queries accross resources are expensive (depending on the query perhaps not even feasible)
+The resources have an internal persitant command queue hat is populated by the synchronizer and clients continuously processed.
-    * `-` Each resource needs to define it's own set of indexes
-    * `+` Flexible design as it allows to change indexes on a per resource level
-    * `+` Indexes can be optimized towards resources main usecases
-    * `+` Indexes can be shared with the source (IMAP serverside threading)
-* Shared domain types as common interface for client applications
+Each resource has an internal pipeline of preprocessors that can be used for tasks such as indexing or filtering, and through which every command goes before it enters the store. The pipeline guarantees that the preprocessor steps are executed on any command before the entity is persisted.
-    * `-` yet another abstraction layer that requires translation to other layers and maintenance
-    * `+` decoupling of domain logic from data access
-    * `+` allows to evolve types according to needs (not coupled to specific application domain types)
-# Risks
-* key-value store does not perform with large amounts of data
-* query performance is not sufficient
-* turnaround time for modifications is too high to feel responsive
-* design turns out similarly complex as Akonadi
diff --git a/docs/designgoals.md b/docs/designgoals.md
new file mode 100644
index 0000000..4ffeeac
--- /dev/null
+++ b/docs/designgoals.md
@@ -0,0 +1,39 @@
+# Design Goals
+## Axioms
+1. Personal information is stored in multiple sources (address books, email stores, calendar files, ...)
+2. These sources may local, remote or a mix of local and remote
+## Requirements
+1. Local mirrors of these sources must be available to 1..N local clients simultaneously
+2. Local clients must be able to make (or at least request) changes to the data in the local mirrors
+3. Local mirrors must be usable without network, even if the source is remote
+4. Local mirrors must be able to syncronoize local changes to their sources (local or remote)
+5. Local mirrors must be able to syncronize remote changes and propagate those to local clients
+6. Content must be searchable by a number of terms (dates, identities, body text ...)
+7. This must all run with acceptable performance on a moderate consumer-grade desktop system
+Nice to haves:
+1. As-close-to-zero-copy-as-possible for data
+2. Simple change notification semantics
+3. Resource-specific syncronization techniques
+4. Data agnostic storage
+Immediate goals:
+1. Ease development of new features in existing resources
+2. Ease maintenance of existing resources
+3. Make adding new resources easy
+4. Make adding new types of data or data relations easy
+5. Improve performance relative to existing Akonadi implementation
+Long-term goals:
+1. Project view: given a query, show all items in all stores that match that query easily and quickly
+Implications of the above:
+* Local mirrors must support multi-reader, but are probably best served with single-writer semantics as this simplifies both local change recording as well as remote synchronization by keeping it in one process which can process write requests (local or remote) in sequential fashion.
+* There is no requirement for a central server if the readers can concurrently access the local mirror directly
+* A storage system which requires a schema (e.g. relational databases) are a poor fit given the desire for data agnosticism and low memory copying
diff --git a/docs/index.md b/docs/index.md
index 3019cfd..90d04b6 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,17 +1,18 @@
-# Index
+Sink is a data access layer handling synchronization, caching and indexing.
-* Design
-    * Design Goals
+Discussion of the code should be done on the kde-pim at kde.org mailing list
-    * Overview
+or in #kontact on IRC.
-    * Client API
-    * Storage
+Note that all feature development should happen in feature branches, and that
-    * Resource
+the mainline development branch is "develop". Master is for releases. It is
-    * Facade
+recommended (though not required) to use the ["git flow" tools](https://github.com/nvie/gitflow) to make branched
-    * Logging
+development easy (and easy for others to coordinate with).
-* Extending Akoandi Next
-    * Steps to add support for new types
+For further information on the project see the [KDE Phabricator instance](https://phabricator.kde.org/project/view/5/).
-    * Steps for adding support for a type to a resource
 # Documentation
 This documentation is built using [mkdocs.org](http://mkdocs.org).
 Use `mkdocs serve` to run a local webserver to view the docs.
+The documentation is also published at [http://api.kde.org/doc/sink/](http://api.kde.org/doc/sink/) and rebuilt nightly.
diff --git a/docs/logging.md b/docs/logging.md
index a495a7a..3d5ea61 100644
--- a/docs/logging.md
+++ b/docs/logging.md
@@ -10,13 +10,34 @@ For debugging purposes a logging framework is required. Simple qDebugs() proved
    * logfiles
    * a commandline monitor tool
    * some other developer tool
+This way we get complete logs also if some resource was not started from the console (i.e. because it was already running).
 ## Debug levels
-* trace: trace individual codepaths. Likely outputs way to much information for all normal cases and likely is only ever temporarily enabled. Trace points are likely only inserted into code fragments that are known to be problematic.
+* trace: trace individual codepaths. Likely outputs way to much information for all normal cases and likely is only ever temporarily enabled for certain areas.
 * log: Comprehensive debug output. Enabled on demand
 * warning: Only warnings, should always be logged.
 * error: Critical messages that should never appear. Should always be logged.
+## Debug areas
+Debug areas split the code into sections that can be enabled/disabled as one.
+This is supposed to give finer grained control over what is logged or displayed.
+Debug areas may align with classes, but don't have to, the should be made so that they are useful.
+Areas could be:
+* resource.sync.performance
+* resource.sync
+* resource.listener
+* resource.pipeline
+* resource.store
+* resource.communication
+* client.communication
+* client.communication.org.sink.resource.maildir.identifier1
+* client.queryrunner
+* client.queryrunner.performance
+* common.typeindex
 ## Collected information
 Additionally to the regular message we want:
@@ -24,5 +45,5 @@ Additionally to the regular message we want:
 * threadid?
 * timestamp
 * sourcefile + position + function name
-* application name / resource identfier
+* application name / resource identifier
-* component identifier (i.e. resource access)
+* area (i.e. resource access)
diff --git a/docs/queries.md b/docs/queries.md
new file mode 100644
index 0000000..8676392
--- /dev/null
+++ b/docs/queries.md
@@ -0,0 +1,104 @@
+## Query System
+The query system should allow for efficient retrieval for just the amount of data required by the client. Efficient querying is supported by the indexes provided by the resources.
+The query always retrieves a set of entities matching the query, while not necessarily all properties of the entity need to be populated.
+Queries are declarative to keep the specification simple and to allow the implementation to choose the most efficient execution.
+Queries can be kept open (live) to receive updates as the store changes.
+### Query
+The query consists of:
+* a set of filters to match the wanted entities
+* the set of properties to retrieve for each entity
+Queryable properties are defined by the [[Domain Types]] above.
+### Query Result
+The result is returned directly after running the query in form of a QAbstractItemModel. Each row in the model represents a matching entity.
+The model allows to access the domain object directly, or to access individual properties directly via the rows columns.
+The model is always populated asynchronously. It is therefore initially empty and will then populate itself gradually, through the regular update mechanisms (rowsInserted).
+Tree Queries allow the application to query for i.e. a folder hierarchy in a single query. This is necessary for performance reasons to avoid recursive querying in large hierarchies. To avoid on the other hand loading large hierchies directly into memory, the model only populates the toplevel rows automatically, all other rows need to be populated by calling `QAbstractItemModel::fetchMore(QModelIndex);`. This way the resource can deal efficiently with the query (i.e. by avoiding the many roundtrips that would be necessary with recursive queries), while keeping the amount of data in memory to a minimum (i.e. if the majority of the folder tree is collapsed in the view anyways). A tree result set can therefore be seen as a set of sets, where every subset corresponds to the children of one parent.
+If the query is live, the model updates itself if the update applies to one of the already loaded subsets (otherwise it's currently irrelevant and will load once the subset is loaded).
+#### Enhancements
+* Asynchronous loading of entities/properties can be achieved by returning an invalid QVariant initially, and emitting dataChanged once the value is loaded.
+* To avoid loading a large list when not all data is necessary, a batch size could be defined to guarantee for instance that there is sufficient data to fill the screen, and the fetchMore mechanism can be used to gradually load more data as required when scrolling in the application.
+#### Filter
+A filter consists of:
+* a property to filter on as defined by the [[Domain Types]]
+* a comparator to use
+* a value
+The available comparators are:
+* equal
+* greater than
+* less than
+* inclusive range
+Value types include:
+* Null
+* Bool
+* Regular Expression
+* Substring
+* A type-specific literal value (e.g. string, number, date, ..)
+Filters can be combined using AND, OR, NOT.
+#### Example
+```
+query =  {
+    offset: int
+    limit: int
+    filter = {
+        and {
+            collection = foo
+            or {
+                resource = res1
+                resource = res2
+            }
+        }
+    }
+}
+```
+possible API:
+```
+query.filter().and().property("collection") = "foo"
+query.filter().and().or().property("resource") = "res1"
+query.filter().and().or().property("resource") = "res2"
+query.filter().and().property("start-date") = InclusiveRange(QDateTime, QDateTime)
+```
+The problem is that it is difficult to adjust an individual resource property like that.
+### Usecases ###
+Mail:
+* All mails in folder X within date-range Y that are unread.
+* All mails (in all folders) that contain the string X in property Y.
+Todos:
+* Give me all the todos in that collection where their RELATED-TO field maps to no other todo UID field in the collection
+* Give me all the todos in that collection where their RELATED-TO field has a given value
+* Give me all the collections which have a given collection as parent and which have a descendant matching a criteria on its attributes;
+Events:
+* All events of calendar X within date-range Y.
+Generic:
+* entity with identifier X
+* all entities of resource X
diff --git a/docs/resource.md b/docs/resource.md
index defbf9a..8c87522 100644
--- a/docs/resource.md
+++ b/docs/resource.md
@@ -4,7 +4,7 @@ The resource consists of:
 * a plugin providing the client-api facade
 * a configuration setting of the filters
-# Synchronizer
+## Synchronizer
 The synchronizer process is responsible for processing all commands, executing synchronizations with the source, and replaying changes to the source.
 Processing of commands happens in the pipeline which executes all preprocessors ebfore the entity is persisted.
@@ -16,7 +16,15 @@ The synchronizer process has the following primary components:
 * Listener: Opens a socket and listens for incoming connections. On connection all incoming commands are read and entered into command queues. Control commands (i.e. a sync) don't require persistency and are therefore processed directly.
 * Synchronization: Handles synchronization to the source, as well as change-replay to the source. The modification commands generated by the synchronization enter the command queue as well.
-# Preprocessors
+A resource can:
+* provide a full mirror of the source.
+* provide metadata for efficient access to the source.
+In the former case the local mirror is fully functional locally and changes can be replayed to the source once a connection is established again.
+It the latter case the resource is only functional if a connection to the source is available (which is i.e. not a problem if the source is a local maildir on disk).
+## Preprocessors
 Preprocessors are small processors that are guaranteed to be processed before an new/modified/deleted entity reaches storage. They can therefore be used for various tasks that need to be executed on every entity.
 Usecases:
@@ -33,16 +41,29 @@ The following kinds of preprocessors exist:
 Preprocessors are typically read-only, to i.e. not break signatures of emails. Extra flags that are accessible through the sink domain model, can therefore be stored in the local buffer of each resource.
-## Requirements
+### Requirements
 * A preprocessor must work with batch processing. Because batch-processing is vital for efficient writing to the database, all preprocessors have to be included in the batch processing.
 * Preprocessors need to be fast, since they directly affect how fast a message is processed by the system.
-## Design
+### Design
 Commands are processed in batches. Each preprocessor thus has the following workflow:
 * startBatch is called: The preprocessor can do necessary preparation steps to prepare for the batch (like starting a transaction on an external database)
 * add/modify/remove is called for every command in the batch: The preprocessor executes the desired actions.
 * endBatch is called: If the preprocessor wrote to an external database it can now commit the transaction.
+### Generic Preprocessors
+Most preprocessors will likely be used by several resources, and are either completely generic, or domain specific (such as only for mail).
+It is therefore desirable to have default implementations for common preprocessors that are ready to be plugged in.
+The domain type adaptors provide a generic interface to access most properties of the entities, on top of which generic preprocessors can be implemented.
+It is that way trivial to i.e. implement a preprocessor that populates a hierarchy index of collections.
+### Preprocessors generating additional entities
+A preprocessor, such as an email threading preprocessors, might generate additional entities (A thread entity is a regular entity, just like the mail that spawned the thread).
+In such a case the preprocessor must invoke the complete pipeline for the new entity.
 ## Indexes
 Most indexes are implemented as preprocessors to guarantee that they are always updated together with the data.
@@ -65,6 +86,9 @@ Index types:
    * sort indexes (i.e. sorted by date)
        * Could also be a lookup in the range index (increase date range until sufficient matches are available)
+### Default implementations
+Since only properties of the domain types can be queried, default implementations for commonly used indexes can be provided. These indexes are populated by generic preprocessors that use the domain-type interface to extract properties from individual entites.
 ### Example index implementations
 * uid lookup
    * add:
@@ -106,25 +130,14 @@ Building the index on-demand is a matter of replaying the relevant dataset and u
 The indexes status information can be recorded using the latest revision the index has been updated with.
-## Generic Preprocessors
-Most preprocessors will likely be used by several resources, and are either completely generic, or domain specific (such as only for mail).
-It is therefore desirable to have default implementations for common preprocessors that are ready to be plugged in.
-The domain type adaptors provide a generic interface to access most properties of the entities, on top of which generic preprocessors can be implemented.
-It is that way trivial to i.e. implement a preprocessor that populates a hierarchy index of collections.
-## Preprocessors generating additional entities
-A preprocessor, such as an email threading preprocessors, might generate additional entities (A thread entity is a regular entity, just like the mail that spawned the thread).
-In such a case the preprocessor must invoke the complete pipeline for the new entity.
 # Pipeline
 A pipeline is an assembly of a set of preprocessors with a defined order. A modification is always persisted at the end of the pipeline once all preprocessors have been processed.
-# Synchronization / Change Replay
+# Synchronization
-* The synchronization can either:
+The synchronization can either:
-    * Generate a full diff directly on top of the db. The diffing process can work against a single revision/snapshot (using transactions). It then generates a necessary changeset for the store.
-    * If the source supports incremental changes the changeset can directly be generated from that information.
+* Generate a full diff directly on top of the db. The diffing process can work against a single revision/snapshot (using transactions). It then generates a necessary changeset for the store.
+* If the source supports incremental changes the changeset can directly be generated from that information.
 The changeset is then simply inserted in the regular modification queue and processed like all other modifications. The synchronizer has to ensure only changes are replayed to the source that didn't come from it already. This is done by marking changes that don't require changereplay to the source.
@@ -142,8 +155,12 @@ The remoteid mapping has to be updated in two places:
 * New entities that are synchronized immediately get a localid assinged, that is then recorded together with the remoteid. This is required to be able to reference other entities directly in the command queue (i.e. for parent folders).
 * Entities created by clients get a remoteid assigned during change replay, so the entity can be recognized during the next sync.
+## Change Replay
+To replay local changes to the source the synchronizer replays all revisions of the store and maintains the current replay state in the synchronization store.
+Changes that already come from the source via synchronizer are not replayed to the source again.
 # Testing / Inspection
-Resources new to be tested, which often requires inspections into the current state of the resource. This is difficult in an asynchronous system where the whole backend logic is encapsulated in a separate process without running tests in a vastly different setup from how it will be run in production.
+Resources have to be tested, which often requires inspections into the current state of the resource. This is difficult in an asynchronous system where the whole backend logic is encapsulated in a separate process without running tests in a vastly different setup from how it will be run in production.
 To alleviate this inspection commands are introduced. Inspection commands are special commands that the resource processes just like all other commands, and that have the sole purpose of inspecting the current resource state. Because the command is processed with the same mechanism as other commands we can rely on ordering of commands in a way that a prior command is guaranteed to be executed once the inspection command is processed.
diff --git a/docs/akonadish.md b/docs/sinksh.md
index 9884169..9884169 100644
--- a/docs/akonadish.md
+++ b/docs/sinksh.md
diff --git a/docs/storage.md b/docs/storage.md
index 4852131..afd55d8 100644
--- a/docs/storage.md
+++ b/docs/storage.md
@@ -1,17 +1,3 @@
-## Store access
-Access to the entities happens through a well defined interface that defines a property-map for each supported domain type. A property map could look like:
-```
-Event {
-  startDate: QDateTime
-  subject: QString
-  ...
-}
-```
-This property map can be freely extended with new properties for various features. It shouldn't adhere to any external specification and exists solely to define how to access the data.
-Clients will map these properties to the values of their domain object implementations, and resources will map the properties to the values in their buffers.
 ## Storage Model
 The storage model is simple:
 ```
@@ -42,8 +28,7 @@ Each entity can be as normalized/denormalized as useful. It is not necessary to
 Denormalized:
-* priority is that mime message stays intact (signatures/encryption)
+* priority is that the mime message stays intact (signatures/encryption)
-* could we still provide a streaming api for attachments?
 ```
 Mail {
@@ -55,7 +40,7 @@ Mail {
 Normalized:
 * priority is that we can access individual members efficiently.
-* we don't care about exact reproducability of e.g. ical file
+* we don't care about exact reproducability of e.g. an ical file
 ```
 Event {
  id
@@ -101,7 +86,7 @@ The resource can be effectively removed from disk (besides configuration),
 by deleting the directories matching `$RESOURCE_IDENTIFIER*` and everything they contain.
 #### Design Considerations
-* The stores are split by buffertype, so a full scan (which is done by type), doesn't require filtering by type first. The downside is that an additional lookup is required to get from revision to the data.
+The stores are split by buffertype, so a full scan (which is done by type), doesn't require filtering by type first. The downside is that an additional lookup is required to get from revision to the data.
 ### Revisions
 Every operation (create/delete/modify), leads to a new revision. The revision is an ever increasing number for the complete store.
@@ -167,6 +152,8 @@ Using regular files as the interface has the advantages:
 The copy is necessary to guarantee that the file remains for the client/resource even if the resource removes the file on it's side as part of a sync.
 The copy could be optimized by using hardlinks, which is not a portable solution though. For some next-gen copy-on-write filesystems copying is a very cheap operation.
+A downside of having a file based design is that it's not possible to directly stream from a remote resource i.e. into the application memory, it always has to go via a file.
 ## Database choice
 By design we're interested in key-value stores or perhaps document databases. This is because a fixed schema is not useful for this design, which makes
 SQL not very useful (it would just be a very slow key-value store). While document databases would allow for indexes on certain properties (which is something we need), we did not yet find any contenders that looked like they would be useful for this system.
diff --git a/docs/terminology.md b/docs/terminology.md
index 1826bec..5238c79 100644
--- a/docs/terminology.md
+++ b/docs/terminology.md
@@ -13,7 +13,7 @@ It is recommended to familiarize yourself with the terms before going further in
 * resource: A plugin which provides client command processing, a store facade and synchronization for a given type of store. The resource also manages the configuration for a given source including server settings, local paths, etc.
 * store facade: An object provided by resources which provides transformations between domain objects and the store.
 * synchronizer: The operating system process responsible for overseeing the process of modifying and synchronizing a store. To accomplish this, a synchronizer loads the correct resource plugin, manages pipelines and handles client communication. One synchronizer is created for each source that is accessed by clients; these processes are shared by all clients.
-* Preprocessor: A component that takes an entity and performs some modification of it (e.g. changes the folder an email is in) or processes it in some way (e.g. indexes it)
+* preprocessor: A component that takes an entity and performs some modification of it (e.g. changes the folder an email is in) or processes it in some way (e.g. indexes it)
 * pipeline: A run-time definable set of filters which are applied to an entity after a resource has performed a specific kind of function on it (create, modify, delete)
 * query: A declarative method for requesting entities from one or more sources that match a given set of constraints
 * command: Clients request modifications, additions and deletions to the store by sending commands to a synchronizer for processing
diff --git a/docs/tradeoffs.md b/docs/tradeoffs.md
new file mode 100644
index 0000000..d0e32c1
--- /dev/null
+++ b/docs/tradeoffs.md
@@ -0,0 +1,36 @@
+# Tradeoffs/Design Decisions
+* Key-Value store instead of relational
+    * `+` Schemaless, easier to evolve
+    * `-` No need to fully normalize the data in order to make it queriable. And without full normalization SQL is not really useful and bad performance wise. 
+    * `-` We need to maintain our own indexes
+* Individual store per resource
+    * Storage format defined by resource individually
+        * `-` Each resource needs to define it's own schema
+        * `+` Resources can adjust storage format to map well on what it has to synchronize
+        * `+` Synchronization state can directly be embedded into messages
+    * `+` Individual resources could switch to another store technology
+    * `+` Easier maintenance
+    * `+` Resource is only responsible for it's own store and doesn't accidentaly break another resources store
+    * `-` Inter`-`resource moves are both more complicated and more expensive from a client perspective
+    * `+` Inter`-`resource moves become simple additions and removals from a resource perspective
+    * `-` No system`-`wide unique id per message (only resource/id tuple identifies a message uniquely) 
+    * `+` Stores can work fully concurrently (also for writing)
+* Indexes defined and maintained by resources
+    * `-` Relational queries accross resources are expensive (depending on the query perhaps not even feasible)
+    * `-` Each resource needs to define it's own set of indexes
+    * `+` Flexible design as it allows to change indexes on a per resource level
+    * `+` Indexes can be optimized towards resources main usecases
+    * `+` Indexes can be shared with the source (IMAP serverside threading)
+* Shared domain types as common interface for client applications
+    * `-` yet another abstraction layer that requires translation to other layers and maintenance
+    * `+` decoupling of domain logic from data access
+    * `+` allows to evolve types according to needs (not coupled to specific application domain types)
+# Risks
+* key-value store does not perform with large amounts of data
+* query performance is not sufficient
+* turnaround time for modifications is too high to feel responsive
+* design turns out similarly complex as Akonadi
diff --git a/examples/client/CMakeLists.txt b/examples/client/CMakeLists.txt
index 85840c4..ef00368 100644
--- a/examples/client/CMakeLists.txt
+++ b/examples/client/CMakeLists.txt
@@ -3,6 +3,6 @@ project(sink_client)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 add_executable(${PROJECT_NAME} main.cpp console.cpp)
-target_link_libraries(${PROJECT_NAME} sinkcommon)
+target_link_libraries(${PROJECT_NAME} sink)
 qt5_use_modules(${PROJECT_NAME} Widgets Network)
 install(TARGETS ${PROJECT_NAME} ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/examples/client/main.cpp b/examples/client/main.cpp
index f437c19..07e780e 100644
--- a/examples/client/main.cpp
+++ b/examples/client/main.cpp
@@ -22,7 +22,7 @@
 #include <QCommandLineOption>
 #include <QTime>
-#include "common/clientapi.h"
+#include "common/store.h"
 #include "common/log.h"
 #include <QWidget>
@@ -38,6 +38,7 @@
 */
 class StoreBase {
 public:
+    virtual ~StoreBase(){};
    virtual Sink::ApplicationDomain::ApplicationDomainType::Ptr getObject() = 0;
    virtual Sink::ApplicationDomain::ApplicationDomainType::Ptr getObject(const QByteArray &resourceInstanceIdentifier, const QByteArray &identifier = QByteArray()) = 0;
    virtual KAsync::Job<void> create(const Sink::ApplicationDomain::ApplicationDomainType &type) = 0;
diff --git a/examples/dummyresource/CMakeLists.txt b/examples/dummyresource/CMakeLists.txt
index 6ffac9a..6400f0c 100644
--- a/examples/dummyresource/CMakeLists.txt
+++ b/examples/dummyresource/CMakeLists.txt
@@ -7,6 +7,6 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 add_library(${PROJECT_NAME} SHARED facade.cpp resourcefactory.cpp domainadaptor.cpp dummystore.cpp)
 generate_flatbuffers(${PROJECT_NAME} dummycalendar)
 qt5_use_modules(${PROJECT_NAME} Core Network)
-target_link_libraries(${PROJECT_NAME} sinkcommon)
+target_link_libraries(${PROJECT_NAME} sink)
 install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${SINK_RESOURCE_PLUGINS_PATH})
diff --git a/examples/dummyresource/resourcefactory.cpp b/examples/dummyresource/resourcefactory.cpp
index 31633d7..48858da 100644
--- a/examples/dummyresource/resourcefactory.cpp
+++ b/examples/dummyresource/resourcefactory.cpp
@@ -95,12 +95,17 @@ Sink::ApplicationDomain::Folder::Ptr DummyResource::createFolder(const QByteArra
 void DummyResource::synchronize(const QByteArray &bufferType, const QMap<QString, QMap<QString, QVariant> > &data, Sink::Storage::Transaction &transaction, Sink::Storage::Transaction &synchronizationTransaction, DomainTypeAdaptorFactoryInterface &adaptorFactory, std::function<Sink::ApplicationDomain::ApplicationDomainType::Ptr(const QByteArray &ridBuffer, const QMap<QString, QVariant> &data, Sink::Storage::Transaction &)> createEntity)
 {
+    auto time = QSharedPointer<QTime>::create();
+    time->start();
    //TODO find items to remove
+    int count = 0;
    for (auto it = data.constBegin(); it != data.constEnd(); it++) {
+        count++;
        const auto remoteId = it.key().toUtf8();
        auto entity = createEntity(remoteId, it.value(), synchronizationTransaction);
        createOrModify(transaction, synchronizationTransaction, adaptorFactory, bufferType, remoteId, *entity);
    }
+    Trace() << "Sync of " << count << " entities of type " << bufferType << " done." << Sink::Log::TraceTime(time->elapsed());
 }
 KAsync::Job<void> DummyResource::synchronizeWithSource(Sink::Storage &mainStore, Sink::Storage &synchronizationStore)
@@ -128,6 +133,11 @@ KAsync::Job<void> DummyResource::replay(Sink::Storage &synchronizationStore, con
    return KAsync::null<void>();
 }
+void DummyResource::removeDataFromDisk()
+{
+    removeFromDisk(mResourceInstanceIdentifier);
+}
 void DummyResource::removeFromDisk(const QByteArray &instanceIdentifier)
 {
    GenericResource::removeFromDisk(instanceIdentifier);
diff --git a/examples/dummyresource/resourcefactory.h b/examples/dummyresource/resourcefactory.h
index 240bb9f..865f6e5 100644
--- a/examples/dummyresource/resourcefactory.h
+++ b/examples/dummyresource/resourcefactory.h
@@ -39,6 +39,7 @@ public:
    DummyResource(const QByteArray &instanceIdentifier, const QSharedPointer<Sink::Pipeline> &pipeline = QSharedPointer<Sink::Pipeline>());
    KAsync::Job<void> synchronizeWithSource(Sink::Storage &mainStore, Sink::Storage &synchronizationStore) Q_DECL_OVERRIDE;
    using GenericResource::synchronizeWithSource;
+    void removeDataFromDisk() Q_DECL_OVERRIDE;
    static void removeFromDisk(const QByteArray &instanceIdentifier);
    KAsync::Job<void> inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue) Q_DECL_OVERRIDE;
 private:
diff --git a/examples/maildirresource/CMakeLists.txt b/examples/maildirresource/CMakeLists.txt
index baacd44..efaa266 100644
--- a/examples/maildirresource/CMakeLists.txt
+++ b/examples/maildirresource/CMakeLists.txt
@@ -8,7 +8,7 @@ find_package(KF5 COMPONENTS REQUIRED Mime)
 add_library(${PROJECT_NAME} SHARED facade.cpp maildirresource.cpp domainadaptor.cpp)
 # generate_flatbuffers(${PROJECT_NAME} dummycalendar)
 qt5_use_modules(${PROJECT_NAME} Core Network)
-target_link_libraries(${PROJECT_NAME} sinkcommon maildir KF5::Mime)
+target_link_libraries(${PROJECT_NAME} sink maildir KF5::Mime)
 install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${SINK_RESOURCE_PLUGINS_PATH})
diff --git a/examples/maildirresource/facade.cpp b/examples/maildirresource/facade.cpp
index 7178ab9..a7a0348 100644
--- a/examples/maildirresource/facade.cpp
+++ b/examples/maildirresource/facade.cpp
@@ -19,17 +19,47 @@
 #include "facade.h"
+#include <QDir>
+#include <QFileInfo>
 #include "domainadaptor.h"
+#include "queryrunner.h"
 MaildirResourceMailFacade::MaildirResourceMailFacade(const QByteArray &instanceIdentifier)
    : Sink::GenericFacade<Sink::ApplicationDomain::Mail>(instanceIdentifier, QSharedPointer<MaildirMailAdaptorFactory>::create())
 {
+    mResultTransformation = [](Sink::ApplicationDomain::ApplicationDomainType &value) {
+        if (value.hasProperty("mimeMessage")) {
+            const auto property = value.getProperty("mimeMessage");
+            //Transform the mime message property into the actual path on disk.
+            const auto mimeMessage = property.toString();
+            auto parts = mimeMessage.split('/');
+            auto key = parts.takeLast();
+            const auto folderPath = parts.join('/');
+            const auto path =  folderPath + "/cur/";
+            Trace() << "Looking for mail in: " << path << key;
+            QDir dir(path);
+            const QFileInfoList list = dir.entryInfoList(QStringList() << (key+"*"), QDir::Files);
+            if (list.size() != 1) {
+                Warning() << "Failed to find message " << path << key << list.size();
+                value.setProperty("mimeMessage", QVariant());
+            } else {
+                value.setProperty("mimeMessage", list.at(0).filePath());
+            }
+        }
+    };
 }
 MaildirResourceMailFacade::~MaildirResourceMailFacade()
 {
 }
+QPair<KAsync::Job<void>, Sink::ResultEmitter<Sink::ApplicationDomain::Mail::Ptr>::Ptr> MaildirResourceMailFacade::load(const Sink::Query &query)
+{
+    return Sink::GenericFacade<Sink::ApplicationDomain::Mail>::load(query);
+}
 MaildirResourceFolderFacade::MaildirResourceFolderFacade(const QByteArray &instanceIdentifier)
    : Sink::GenericFacade<Sink::ApplicationDomain::Folder>(instanceIdentifier, QSharedPointer<MaildirFolderAdaptorFactory>::create())
diff --git a/examples/maildirresource/facade.h b/examples/maildirresource/facade.h
index a243b0d..38981d0 100644
--- a/examples/maildirresource/facade.h
+++ b/examples/maildirresource/facade.h
@@ -26,6 +26,7 @@ class MaildirResourceMailFacade : public Sink::GenericFacade<Sink::ApplicationDo
 public:
    MaildirResourceMailFacade(const QByteArray &instanceIdentifier);
    virtual ~MaildirResourceMailFacade();
+    QPair<KAsync::Job<void>, Sink::ResultEmitter<Sink::ApplicationDomain::Mail::Ptr>::Ptr> load(const Sink::Query &query) Q_DECL_OVERRIDE;
 };
 class MaildirResourceFolderFacade : public Sink::GenericFacade<Sink::ApplicationDomain::Folder>
diff --git a/examples/maildirresource/libmaildir/maildir.cpp b/examples/maildirresource/libmaildir/maildir.cpp
index 3d4630f..59e7e5c 100644
--- a/examples/maildirresource/libmaildir/maildir.cpp
+++ b/examples/maildirresource/libmaildir/maildir.cpp
@@ -142,7 +142,6 @@ public:
    {
        // KeyCache* keyCache = KeyCache::self();
        // if (keyCache->isNewKey(path, key)) {
-        qWarning() << path + QString::fromLatin1("/new/") + key;
        if (QFile::exists(path + QString::fromLatin1("/new/") + key)) {
 #ifdef DEBUG_KEYCACHE_CONSITENCY
          if (!QFile::exists(path + QString::fromLatin1("/new/") + key)) {
@@ -178,6 +177,13 @@ public:
        return realKey;
    }
+    static QString stripFlags(const QString& key)
+    {
+        const QRegExp rx = *(statusSeparatorRx());
+        const int index = key.indexOf(rx);
+        return key.mid(0, index);
+    }
    static QString subDirNameForFolderName(const QString &folderName)
    {
        return QString::fromLatin1(".%1.directory").arg(folderName);
@@ -560,7 +566,20 @@ QDateTime Maildir::lastModified(const QString& key) const
    return info.lastModified();
 }
-QByteArray Maildir::readEntryHeadersFromFile(const QString& file) const
+QString Maildir::getKeyFromFile(const QString& file)
+{
+    return Maildir::Private::stripFlags(file.split('/').last());
+}
+QString Maildir::getDirectoryFromFile( const QString& file )
+{
+    auto parts = file.split('/');
+    parts.removeLast(); //File
+    parts.removeLast(); //cur/new/tmp
+    return parts.join('/') + "/";
+}
+QByteArray Maildir::readEntryHeadersFromFile(const QString& file)
 {
    QByteArray result;
@@ -643,9 +662,14 @@ QString Maildir::addEntry(const QByteArray& data)
    QFile f(key);
    bool result = f.open(QIODevice::WriteOnly);
+    if (!result) {
+       qWarning() << f.errorString();
+       qWarning() << "Cannot write to mail file: " << key;
+    }
    result = result & (f.write(data) != -1);
    f.close();
    if (!result) {
+       qWarning() << "Cannot write to mail file: " << key;
       // d->lastError = i18n("Cannot write to mail file %1." , key);
       return QString();
    }
@@ -688,88 +712,89 @@ bool Maildir::removeEntry(const QString& key)
    // return QFile::remove(realKey);
 }
-// QString Maildir::changeEntryFlags(const QString& key, const Sink::Item::Flags& flags)
+QString Maildir::changeEntryFlags(const QString& key, const Maildir::Flags& flags)
-// {
+{
-//     QString realKey(d->findRealKey(key));
+    QString realKey(d->findRealKey(key));
-//     if (realKey.isEmpty()) {
+    if (realKey.isEmpty()) {
-//         qWarning() << "Maildir::changeEntryFlags unable to find: " << key;
+        qWarning() << "Maildir::changeEntryFlags unable to find: " << key;
-//         d->lastError = i18n("Cannot locate mail file %1." , key);
+        // d->lastError = i18n("Cannot locate mail file %1." , key);
-//         return QString();
+        return QString();
-//     }
+    }
-//
-//     const QRegExp rx = *(statusSeparatorRx());
+    const QRegExp rx = *(statusSeparatorRx());
-//     QString finalKey = key.left(key.indexOf(rx));
+    QString finalKey = key.left(key.indexOf(rx));
-//
-//     QStringList mailDirFlags;
+    QStringList mailDirFlags;
-//     Q_FOREACH (const Sink::Item::Flag &flag, flags) {
+    if (flags & Forwarded)
-//       if (flag == Sink::MessageFlags::Forwarded)
+        mailDirFlags << QLatin1String("P");
-//         mailDirFlags << QLatin1String("P");
+    if (flags & Replied)
-//       if (flag == Sink::MessageFlags::Replied)
+        mailDirFlags << QLatin1String("R");
-//         mailDirFlags << QLatin1String("R");
+    if (flags & Seen)
-//       if (flag == Sink::MessageFlags::Seen)
+        mailDirFlags << QLatin1String("S");
-//         mailDirFlags << QLatin1String("S");
+    if (flags & Deleted)
-//       if (flag == Sink::MessageFlags::Deleted)
+        mailDirFlags << QLatin1String("T");
-//         mailDirFlags << QLatin1String("T");
+    if (flags & Flagged)
-//       if (flag == Sink::MessageFlags::Flagged)
+        mailDirFlags << QLatin1String("F");
-//         mailDirFlags << QLatin1String("F");
-//     }
+    mailDirFlags.sort();
-//     mailDirFlags.sort();
+    if (!mailDirFlags.isEmpty()) {
-//     if (!mailDirFlags.isEmpty()) {
+#ifdef Q_OS_WIN
-// #ifdef Q_OS_WIN
+      finalKey.append(QLatin1String("!2,") + mailDirFlags.join(QString()));
-//       finalKey.append(QLatin1String("!2,") + mailDirFlags.join(QString()));
+#else
-// #else
+      finalKey.append(QLatin1String(":2,") + mailDirFlags.join(QString()));
-//       finalKey.append(QLatin1String(":2,") + mailDirFlags.join(QString()));
+#endif
-// #endif
+    }
-//     }
-//
+    QString newUniqueKey = finalKey; //key without path
-//     QString newUniqueKey = finalKey; //key without path
+    finalKey.prepend(d->path + QString::fromLatin1("/cur/"));
-//     finalKey.prepend(d->path + QString::fromLatin1("/cur/"));
-//
+    if (realKey == finalKey) {
-//     if (realKey == finalKey) {
+      // Somehow it already is named this way (e.g. migration bug -> wrong status in sink)
-//       // Somehow it already is named this way (e.g. migration bug -> wrong status in sink)
+      qWarning() << "File already named that way: " << newUniqueKey << finalKey;
-//       return newUniqueKey;
+      return newUniqueKey;
-//     }
+    }
-//
-//     QFile f(realKey);
+    QFile f(realKey);
-//     if (QFile::exists(finalKey)) {
+    if (QFile::exists(finalKey)) {
-//       QFile destFile(finalKey);
+      QFile destFile(finalKey);
-//       QByteArray destContent;
+      QByteArray destContent;
-//       if (destFile.open(QIODevice::ReadOnly)) {
+      if (destFile.open(QIODevice::ReadOnly)) {
-//         destContent = destFile.readAll();
+        destContent = destFile.readAll();
-//         destFile.close();
+        destFile.close();
-//       }
+      }
-//       QByteArray sourceContent;
+      QByteArray sourceContent;
-//       if (f.open(QIODevice::ReadOnly)) {
+      if (f.open(QIODevice::ReadOnly)) {
-//         sourceContent = f.readAll();
+        sourceContent = f.readAll();
-//         f.close();
+        f.close();
-//       }
+      }
-//
-//       if (destContent != sourceContent) {
+      if (destContent != sourceContent) {
-//          QString newFinalKey = QLatin1String("1-") + newUniqueKey;
+         QString newFinalKey = QLatin1String("1-") + newUniqueKey;
-//          int i = 1;
+         int i = 1;
-//          while (QFile::exists(d->path + QString::fromLatin1("/cur/") + newFinalKey)) {
+         while (QFile::exists(d->path + QString::fromLatin1("/cur/") + newFinalKey)) {
-//            i++;
+           i++;
-//            newFinalKey = QString::number(i) + QLatin1Char('-') + newUniqueKey;
+           newFinalKey = QString::number(i) + QLatin1Char('-') + newUniqueKey;
-//          }
+         }
-//          finalKey = d->path + QString::fromLatin1("/cur/") + newFinalKey;
+         finalKey = d->path + QString::fromLatin1("/cur/") + newFinalKey;
-//       } else {
+      } else {
-//             QFile::remove(finalKey); //they are the same
+            QFile::remove(finalKey); //they are the same
-//       }
+      }
-//     }
+    }
-//
-//     if (!f.rename(finalKey)) {
+    if (!f.rename(finalKey)) {
-//         qWarning() << "Maildir: Failed to rename entry: " << f.fileName() << " to "  << finalKey  << "! Error: " << f.errorString();
+        qWarning() << "Maildir: Failed to rename entry: " << f.fileName() << " to "  << finalKey  << "! Error: " << f.errorString();
-//         d->lastError = i18n("Failed to update the file name %1 to %2 on the disk. The error was: %3." , f.fileName(), finalKey, f.errorString());
+        // d->lastError = i18n("Failed to update the file name %1 to %2 on the disk. The error was: %3." , f.fileName(), finalKey, f.errorString());
-//         return QString();
+        return QString();
-//      }
+    }
-//
+    qWarning() << "Renamed file: " << f.fileName() << finalKey;
-//     KeyCache *keyCache = KeyCache::self();
-//     keyCache->removeKey(d->path, key);
+    // KeyCache *keyCache = KeyCache::self();
-//     keyCache->addCurKey(d->path, newUniqueKey);
+    // keyCache->removeKey(d->path, key);
-//
+    // keyCache->addCurKey(d->path, newUniqueKey);
-//     return newUniqueKey;
-// }
+    return newUniqueKey;
-//
+}
 Maildir::Flags Maildir::readEntryFlags(const QString& key)
 {
    Flags flags;
diff --git a/examples/maildirresource/libmaildir/maildir.h b/examples/maildirresource/libmaildir/maildir.h
index a89a832..6c68656 100644
--- a/examples/maildirresource/libmaildir/maildir.h
+++ b/examples/maildirresource/libmaildir/maildir.h
@@ -167,13 +167,14 @@ public:
     */
    QByteArray readEntry( const QString& key ) const;
-    enum MailFlags {
+    enum Flag {
-        Forwarded,
+        Forwarded = 0x1,
-        Replied,
+        Replied = 0x2,
-        Seen,
+        Seen = 0x4,
-        Flagged
+        Flagged = 0x8,
+        Deleted = 0x10
    };
-    Q_DECLARE_FLAGS(Flags, MailFlags);
+    Q_DECLARE_FLAGS(Flags, Flag);
    /**
     * Return the flags encoded in the maildir file name for an entry
@@ -184,7 +185,7 @@ public:
     * Return the contents of the headers section of the file the maildir with the given @p file, that
     * is a full path to the file. You can get it by using findRealKey(key) .
     */
-    QByteArray readEntryHeadersFromFile( const QString& file ) const;
+    static QByteArray readEntryHeadersFromFile( const QString& file );
    /**
     * Return the contents of the headers section of the file the maildir with the given @p key.
@@ -211,7 +212,7 @@ public:
     * Change the flags for an entry specified by @p key. Returns the new key of the entry (the key might change because
     * flags are stored in the unique filename).
     */
-    // QString changeEntryFlags( const QString& key, const Sink::Item::Flags& flags );
+    QString changeEntryFlags( const QString& key, const Flags& flags );
    /**
     * Moves this maildir into @p destination.
@@ -261,6 +262,19 @@ public:
     querying the last error string. */
    QString lastError() const;
+    /**
+     * Returns the key from the file identified by the full path @param file.
+     */
+    static QString getKeyFromFile( const QString& file );
+    /**
+     * Returns the directory from a file.
+     * 
+     * Strips key and new/cur/tmp.
+     * The returned path is ended with a trailing slash.
+     */
+    static QString getDirectoryFromFile( const QString& file );
 private:
    void swap( const Maildir& );
    class Private;
diff --git a/examples/maildirresource/maildirresource.cpp b/examples/maildirresource/maildirresource.cpp
index 33883a7..0ddd8f8 100644
--- a/examples/maildirresource/maildirresource.cpp
+++ b/examples/maildirresource/maildirresource.cpp
@@ -46,6 +46,9 @@
 #define ENTITY_TYPE_MAIL "mail"
 #define ENTITY_TYPE_FOLDER "folder"
+#undef DEBUG_AREA
+#define DEBUG_AREA "resource.maildir"
 MaildirResource::MaildirResource(const QByteArray &instanceIdentifier, const QSharedPointer<Sink::Pipeline> &pipeline)
    : Sink::GenericResource(instanceIdentifier, pipeline),
    mMailAdaptorFactory(QSharedPointer<MaildirMailAdaptorFactory>::create()),
@@ -103,7 +106,7 @@ void MaildirResource::synchronizeFolders(Sink::Storage::Transaction &transaction
            //we should rather iterate over an index that contains every uid exactly once. The remoteId index would be such an index,
            //but we currently fail to iterate over all entries in an index it seems.
            // auto remoteIds = synchronizationTransaction.openDatabase("rid.mapping." + bufferType, std::function<void(const Sink::Storage::Error &)>(), true);
-            auto mainDatabase = transaction.openDatabase(bufferType + ".main");
+            auto mainDatabase = Sink::Storage::mainDatabase(transaction, bufferType);
            mainDatabase.scan("", [&](const QByteArray &key, const QByteArray &) {
                callback(key);
                return true;
@@ -132,6 +135,8 @@ void MaildirResource::synchronizeFolders(Sink::Storage::Transaction &transaction
 void MaildirResource::synchronizeMails(Sink::Storage::Transaction &transaction, Sink::Storage::Transaction &synchronizationTransaction, const QString &path)
 {
    Trace() << "Synchronizing mails" << path;
+    auto time = QSharedPointer<QTime>::create();
+    time->start();
    const QByteArray bufferType = ENTITY_TYPE_MAIL;
    KPIM::Maildir maildir(path, true);
@@ -162,7 +167,9 @@ void MaildirResource::synchronizeMails(Sink::Storage::Transaction &transaction,
        }
    );
+    int count = 0;
    while (entryIterator->hasNext()) {
+        count++;
        const QString filePath = QDir::fromNativeSeparators(entryIterator->next());
        const QString fileName = entryIterator->fileName();
        const auto remoteId = filePath.toUtf8();
@@ -172,6 +179,7 @@ void MaildirResource::synchronizeMails(Sink::Storage::Transaction &transaction,
        msg->parse();
        const auto flags = maildir.readEntryFlags(fileName);
+        const auto maildirKey = maildir.getKeyFromFile(fileName);
        Trace() << "Found a mail " << filePath << " : " << fileName << msg->subject(true)->asUnicodeString();
@@ -181,12 +189,16 @@ void MaildirResource::synchronizeMails(Sink::Storage::Transaction &transaction,
        mail.setProperty("senderName", msg->from(true)->asUnicodeString());
        mail.setProperty("date", msg->date(true)->dateTime());
        mail.setProperty("folder", folderLocalId);
-        mail.setProperty("mimeMessage", filePath);
+        //We only store the directory path + key, so we facade can add the changing bits (flags)
+        mail.setProperty("mimeMessage", KPIM::Maildir::getDirectoryFromFile(filePath) + maildirKey);
        mail.setProperty("unread", !flags.testFlag(KPIM::Maildir::Seen));
        mail.setProperty("important", flags.testFlag(KPIM::Maildir::Flagged));
        createOrModify(transaction, synchronizationTransaction, *mMailAdaptorFactory, bufferType, remoteId, mail);
    }
+    const auto elapsed = time->elapsed();
+    Trace() << "Synchronized " << count << " mails in " << listingPath << Sink::Log::TraceTime(elapsed) << " " << elapsed/qMax(count, 1) << " [ms/mail]";
 }
 KAsync::Job<void> MaildirResource::synchronizeWithSource(Sink::Storage &mainStore, Sink::Storage &synchronizationStore)
@@ -216,7 +228,7 @@ KAsync::Job<void> MaildirResource::replay(Sink::Storage &synchronizationStore, c
    Trace() << "Replaying " << key << type;
    if (type == ENTITY_TYPE_FOLDER) {
-        Sink::EntityBuffer buffer(value.data(), value.size());
+        Sink::EntityBuffer buffer(value);
        const Sink::Entity &entity = buffer.entity();
        const auto metadataBuffer = Sink::EntityBuffer::readBuffer<Sink::Metadata>(entity.metadata());
        if (metadataBuffer && !metadataBuffer->replayToSource()) {
@@ -248,7 +260,7 @@ KAsync::Job<void> MaildirResource::replay(Sink::Storage &synchronizationStore, c
            Warning() << "Unkown operation" << operation;
        }
    } else if (type == ENTITY_TYPE_MAIL) {
-        Sink::EntityBuffer buffer(value.data(), value.size());
+        Sink::EntityBuffer buffer(value);
        const Sink::Entity &entity = buffer.entity();
        const auto metadataBuffer = Sink::EntityBuffer::readBuffer<Sink::Metadata>(entity.metadata());
        if (metadataBuffer && !metadataBuffer->replayToSource()) {
@@ -268,10 +280,19 @@ KAsync::Job<void> MaildirResource::replay(Sink::Storage &synchronizationStore, c
            }
            const auto parentFolderPath = parentFolderRemoteId;
            KPIM::Maildir maildir(parentFolderPath, false);
-            //FIXME assemble the MIME message
+            if (!maildir.isValid(true)) {
-            const auto id = maildir.addEntry("foobar");
+                return KAsync::error<void>(1, "Invalid folder " + parentFolderPath);
-            Trace() << "Creating a new mail: " << id;
+            }
-            recordRemoteId(ENTITY_TYPE_MAIL, mail.identifier(), id.toUtf8(), synchronizationTransaction);
+            //FIXME move the mime message from the mimeMessage property to the proper place.
+            Trace() << "Creating a new mail.";
+            const auto remoteId = maildir.addEntry("foobar");
+            if (remoteId.isEmpty()) {
+                Warning() << "Failed to create mail: " << remoteId;
+                return KAsync::error<void>(1, "Failed to create mail.");
+            } else {
+                Trace() << "Mail created: " << remoteId;
+                recordRemoteId(ENTITY_TYPE_MAIL, mail.identifier(), remoteId.toUtf8(), synchronizationTransaction);
+            }
        } else if (operation == Sink::Operation_Removal) {
            const auto uid = Sink::Storage::uidFromKey(key);
            const auto remoteId = resolveLocalId(ENTITY_TYPE_MAIL, uid, synchronizationTransaction);
@@ -279,7 +300,26 @@ KAsync::Job<void> MaildirResource::replay(Sink::Storage &synchronizationStore, c
            QFile::remove(remoteId);
            removeRemoteId(ENTITY_TYPE_MAIL, uid, remoteId, synchronizationTransaction);
        } else if (operation == Sink::Operation_Modification) {
-            Warning() << "Mail modifications are not implemented";
+            const auto uid = Sink::Storage::uidFromKey(key);
+            const auto remoteId = resolveLocalId(ENTITY_TYPE_MAIL, uid, synchronizationTransaction);
+            Trace() << "Modifying a mail: " << remoteId;
+            auto parts = remoteId.split('/');
+            const auto filename = parts.takeLast(); //filename
+            parts.removeLast(); //cur/new folder
+            auto maildirPath = parts.join('/');
+            KPIM::Maildir maildir(maildirPath, false);
+            const Sink::ApplicationDomain::Mail mail(mResourceInstanceIdentifier, Sink::Storage::uidFromKey(key), revision, mMailAdaptorFactory->createAdaptor(entity));
+            //get flags from
+            KPIM::Maildir::Flags flags;
+            if (!mail.getProperty("unread").toBool()) {
+                flags |= KPIM::Maildir::Seen;
+            }
+            auto newRemoteId = maildir.changeEntryFlags(filename, flags);
+            updateRemoteId(ENTITY_TYPE_MAIL, uid, QString(maildirPath + "/cur/" + newRemoteId).toUtf8(), synchronizationTransaction);
        } else {
            Warning() << "Unkown operation" << operation;
        }
@@ -299,20 +339,32 @@ KAsync::Job<void> MaildirResource::inspect(int inspectionType, const QByteArray
    auto synchronizationTransaction = synchronizationStore->createTransaction(Sink::Storage::ReadOnly);
    Trace() << "Inspecting " << inspectionType << domainType << entityId << property << expectedValue;
    if (domainType == ENTITY_TYPE_MAIL) {
-        if (inspectionType == Sink::Resources::Inspection::PropertyInspectionType) {
+        if (inspectionType == Sink::ResourceControl::Inspection::PropertyInspectionType) {
            if (property == "unread") {
                const auto remoteId = resolveLocalId(ENTITY_TYPE_MAIL, entityId, synchronizationTransaction);
                const auto flags = KPIM::Maildir::readEntryFlags(remoteId.split('/').last());
-                if (expectedValue.toBool() && !(flags & KPIM::Maildir::Seen)) {
+                if (expectedValue.toBool() && (flags & KPIM::Maildir::Seen)) {
-                    return KAsync::error<void>(1, "Expected seen but couldn't find it.");
+                    return KAsync::error<void>(1, "Expected unread but couldn't find it.");
                }
-                if (!expectedValue.toBool() && (flags & KPIM::Maildir::Seen)) {
+                if (!expectedValue.toBool() && !(flags & KPIM::Maildir::Seen)) {
-                    return KAsync::error<void>(1, "Expected seen but couldn't find it.");
+                    return KAsync::error<void>(1, "Expected read but couldn't find it.");
+                }
+                return KAsync::null<void>();
+            }
+            if (property == "subject") {
+                const auto remoteId = resolveLocalId(ENTITY_TYPE_MAIL, entityId, synchronizationTransaction);
+                KMime::Message *msg = new KMime::Message;
+                msg->setHead(KMime::CRLFtoLF(KPIM::Maildir::readEntryHeadersFromFile(remoteId)));
+                msg->parse();
+                if (msg->subject(true)->asUnicodeString() != expectedValue.toString()) {
+                    return KAsync::error<void>(1, "Subject not as expected: " + msg->subject(true)->asUnicodeString());
                }
                return KAsync::null<void>();
            }
        }
-        if (inspectionType == Sink::Resources::Inspection::ExistenceInspectionType) {
+        if (inspectionType == Sink::ResourceControl::Inspection::ExistenceInspectionType) {
            const auto remoteId = resolveLocalId(ENTITY_TYPE_MAIL, entityId, synchronizationTransaction);
            if (QFileInfo(remoteId).exists() != expectedValue.toBool()) {
                return KAsync::error<void>(1, "Wrong file existence: " + remoteId);
diff --git a/examples/maildirresource/maildirresource.h b/examples/maildirresource/maildirresource.h
index 9af2f39..32eb88c 100644
--- a/examples/maildirresource/maildirresource.h
+++ b/examples/maildirresource/maildirresource.h
@@ -32,12 +32,15 @@ class MaildirMailAdaptorFactory;
 class MaildirFolderAdaptorFactory;
 /**
- * A maildir resource
+ * A maildir resource.
 * 
 * Implementation details:
 * The remoteid's have the following formats:
 * files: full file path
 * directories: full directory path
+ * 
+ * The resource moves all messages from new to cur during sync and thus expectes all messages that are in the store to always reside in cur.
+ * The tmp directory is never directly used
 */
 class MaildirResource : public Sink::GenericResource
 {
diff --git a/hawd_defs/facade_query b/hawd_defs/facade_query
new file mode 100644
index 0000000..8567a5d
--- /dev/null
+++ b/hawd_defs/facade_query
@@ -0,0 +1,8 @@
+{
+    "name": "Read performance",
+    "description": "Measures performance of the query system",
+    "columns": [
+        { "name": "rows", "type": "int" },
+        { "name": "queryTimePerResult", "type": "float", "unit": "result/ms" }
+    ]
+}
diff --git a/mkdocs.yml b/mkdocs.yml
index 21f9471..07299f4 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -1,14 +1,19 @@
 site_name: Sink
 pages:
 - Home: index.md
- Terminology: terminology.md
+- Design:
- Overview: design.md
+    - Terminology: terminology.md
- Resource: resource.md
+    - "Design Goals": designgoals.md
- Storage: storage.md
+    - Overview: design.md
- Logging: logging.md
+    - "Client API": clientapi.md
- "Client API": clientapi.md
+    - "Application Domain Types": applicationdomaintypes.md
- sinksh: sinksh.md
+    - Queries: queries.md
- "Application Domain Types": applicationdomaintypes.md
+    - Resource: resource.md
- "Extending Sink": extending.md
+    - "Store and Indexes": storage.md
+    - Logging: logging.md
+    - "Tradeoffs and Design Decisions": tradeoffs.md
+- Development:
+    - "Extending Sink": extending.md
 - Building: building.md
+- "Sink Shell": sinksh.md
 theme: readthedocs
diff --git a/sinksh/CMakeLists.txt b/sinksh/CMakeLists.txt
index 1489fb3..3149347 100644
--- a/sinksh/CMakeLists.txt
+++ b/sinksh/CMakeLists.txt
@@ -2,7 +2,6 @@ project(sinksh)
 find_package(Readline REQUIRED)
 set(sink_cli_SRCS
    main.cpp
    syntaxtree.cpp
@@ -24,6 +23,6 @@ set(sink_cli_SRCS
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 add_executable(${PROJECT_NAME} ${sink_cli_SRCS})
-target_link_libraries(${PROJECT_NAME} Qt5::Core ${Readline_LIBRARY} sinkcommon)
+target_link_libraries(${PROJECT_NAME} Qt5::Core ${Readline_LIBRARY} sink)
 install(TARGETS ${PROJECT_NAME} ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/sinksh/repl/replStates.cpp b/sinksh/repl/replStates.cpp
index 43b1353..0cd2620 100644
--- a/sinksh/repl/replStates.cpp
+++ b/sinksh/repl/replStates.cpp
@@ -168,4 +168,8 @@ static char *sink_cli_next_tab_complete_match(const char *text, int state)
    return rl_filename_completion_function(text, state);
 }
+//Ignore warning I don't know how to fix in a moc file
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
 #include "moc_replStates.cpp"
+#pragma clang diagnostic pop
diff --git a/sinksh/sinksh_utils.cpp b/sinksh/sinksh_utils.cpp
index fa06b34..d5b1c22 100644
--- a/sinksh/sinksh_utils.cpp
+++ b/sinksh/sinksh_utils.cpp
@@ -20,7 +20,7 @@
 #include "sinksh_utils.h"
-#include "common/clientapi.h"
+#include "common/store.h"
 #include "utils.h"
diff --git a/sinksh/sinksh_utils.h b/sinksh/sinksh_utils.h
index 457f644..bc4f6e5 100644
--- a/sinksh/sinksh_utils.h
+++ b/sinksh/sinksh_utils.h
@@ -24,7 +24,7 @@
 #include <QSharedPointer>
 #include "common/query.h"
-#include "common/clientapi.h"
+#include "common/store.h"
 #include "state.h"
@@ -47,6 +47,7 @@ QMap<QString, QString> keyValueMapFromArgs(const QStringList &args);
 */
 class StoreBase {
 public:
+    virtual ~StoreBase() {};
    virtual Sink::ApplicationDomain::ApplicationDomainType::Ptr getObject() = 0;
    virtual Sink::ApplicationDomain::ApplicationDomainType::Ptr getObject(const QByteArray &resourceInstanceIdentifier, const QByteArray &identifier = QByteArray()) = 0;
    virtual KAsync::Job<void> create(const Sink::ApplicationDomain::ApplicationDomainType &type) = 0;
diff --git a/sinksh/syntax_modules/core_syntax.cpp b/sinksh/syntax_modules/core_syntax.cpp
index f5b6274..e90d894 100644
--- a/sinksh/syntax_modules/core_syntax.cpp
+++ b/sinksh/syntax_modules/core_syntax.cpp
@@ -25,6 +25,7 @@
 #include "state.h"
 #include "syntaxtree.h"
 #include "utils.h"
+#include "common/log.h"
 namespace CoreSyntax
 {
@@ -32,7 +33,6 @@ namespace CoreSyntax
 bool exit(const QStringList &, State &)
 {
    ::exit(0);
-    return true;
 }
 bool showHelp(const QStringList &commands, State &state)
@@ -164,6 +164,49 @@ bool printLoggingLevel(const QStringList &commands, State &state)
    return true;
 }
+bool setLoggingAreas(const QStringList &commands, State &state)
+{
+    if (commands.isEmpty()) {
+        state.printError(QObject::tr("Wrong number of arguments; expected logging areas."));
+        return false;
+    }
+    QByteArrayList areas;
+    for (const auto &c : commands) {
+        areas << c.toLatin1();
+    }
+    Sink::Log::setDebugOutputFilter(Sink::Log::Area, areas);
+    return true;
+}
+bool setLoggingFilter(const QStringList &commands, State &state)
+{
+    if (commands.isEmpty()) {
+        state.printError(QObject::tr("Wrong number of arguments; expected resource identifier or application names."));
+        return false;
+    }
+    QByteArrayList filter;
+    for (const auto &c : commands) {
+        filter << c.toLatin1();
+    }
+    Sink::Log::setDebugOutputFilter(Sink::Log::ApplicationName, filter);
+    return true;
+}
+bool setLoggingFields(const QStringList &commands, State &state)
+{
+    QByteArrayList output;
+    for (const auto &c : commands) {
+        output << c.toLatin1();
+    }
+    Sink::Log::setDebugOutputFields(output);
+    return true;
+}
 Syntax::List syntax()
 {
    Syntax::List syntax;
@@ -187,6 +230,16 @@ Syntax::List syntax()
    logging.completer = [](const QStringList &, const QString &fragment, State &state) -> QStringList { return Utils::filteredCompletions(QStringList() << "trace" << "log" << "warning" << "error", fragment, Qt::CaseInsensitive); };
    set.children << logging;
+    Syntax loggingAreas("loggingAreas", QObject::tr("Set logging areas."), &CoreSyntax::setLoggingAreas);
+    set.children << loggingAreas;
+    Syntax loggingFilter("loggingFilter", QObject::tr("Set logging filter."), &CoreSyntax::setLoggingFilter);
+    set.children << loggingFilter;
+    Syntax loggingFields("loggingFields", QObject::tr("Set logging fields."), &CoreSyntax::setLoggingFields);
+    loggingFields.completer = [](const QStringList &, const QString &fragment, State &state) -> QStringList { return Utils::filteredCompletions(QStringList() << "name" << "function" << "location" << "", fragment, Qt::CaseInsensitive); };
+    set.children << loggingFields;
    syntax << set;
    Syntax get("get", QObject::tr("Gets settings for the session"));
diff --git a/sinksh/syntax_modules/sink_clear.cpp b/sinksh/syntax_modules/sink_clear.cpp
index d02c638..72d9a14 100644
--- a/sinksh/syntax_modules/sink_clear.cpp
+++ b/sinksh/syntax_modules/sink_clear.cpp
@@ -41,7 +41,7 @@ bool clear(const QStringList &args, State &state)
 {
    for (const auto &resource : args) {
        state.print(QObject::tr("Removing local cache for '%1' ...").arg(resource));
-        Sink::Store::removeFromDisk(resource.toLatin1());
+        Sink::Store::removeDataFromDisk(resource.toLatin1()).exec().waitForFinished();
        state.printLine(QObject::tr("done"));
    }
diff --git a/synchronizer/CMakeLists.txt b/synchronizer/CMakeLists.txt
index f2802a4..9e9d8d4 100644
--- a/synchronizer/CMakeLists.txt
+++ b/synchronizer/CMakeLists.txt
@@ -7,6 +7,6 @@ set(sinksynchronizer_SRCS
 )
 add_executable(${PROJECT_NAME} ${sinksynchronizer_SRCS})
-target_link_libraries(${PROJECT_NAME} sinkcommon KF5::Async)
+target_link_libraries(${PROJECT_NAME} sink KF5::Async)
 qt5_use_modules(${PROJECT_NAME} Widgets Network)
 install(TARGETS ${PROJECT_NAME} ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/synchronizer/main.cpp b/synchronizer/main.cpp
index e9c17e7..d7a18e2 100644
--- a/synchronizer/main.cpp
+++ b/synchronizer/main.cpp
@@ -26,6 +26,9 @@
 #include "listener.h"
 #include "log.h"
+#undef DEBUG_AREA
+#define DEBUG_AREA "resource"
 void crashHandler(int sig) {
    std::fprintf(stderr, "Error: signal %d\n", sig);
@@ -70,6 +73,7 @@ int main(int argc, char *argv[])
    }
    const QByteArray instanceIdentifier = argv[1];
+    app.setApplicationName(instanceIdentifier);
    QLockFile lockfile(instanceIdentifier + ".lock");
    lockfile.setStaleLockTime(500);
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b01a329..b8ee5a5 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -15,7 +15,7 @@ macro(manual_tests)
        add_executable(${_testname} ${_testname}.cpp testimplementations.cpp getrssusage.cpp)
        generate_flatbuffers(${_testname} calendar)
        qt5_use_modules(${_testname} Core Test Concurrent)
-        target_link_libraries(${_testname} sinkcommon libhawd)
+        target_link_libraries(${_testname} sink libhawd)
    endforeach(_testname)
 endmacro(manual_tests)
@@ -25,7 +25,7 @@ macro(auto_tests)
        generate_flatbuffers(${_testname} calendar)
        add_test(${_testname} ${_testname})
        qt5_use_modules(${_testname} Core Test Concurrent)
-        target_link_libraries(${_testname} sinkcommon libhawd)
+        target_link_libraries(${_testname} sink libhawd)
    endforeach(_testname)
 endmacro(auto_tests)
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index a85b03b..0e21ca6 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -2,7 +2,7 @@
 #include <QDebug>
 #include <functional>
-#include "clientapi.h"
+#include "store.h"
 #include "facade.h"
 #include "resourceconfig.h"
 #include "modelresult.h"
diff --git a/tests/databasepopulationandfacadequerybenchmark.cpp b/tests/databasepopulationandfacadequerybenchmark.cpp
index 8581c49..63daebc 100644
--- a/tests/databasepopulationandfacadequerybenchmark.cpp
+++ b/tests/databasepopulationandfacadequerybenchmark.cpp
@@ -10,7 +10,10 @@
 #include <common/synclistresult.h>
 #include <common/definitions.h>
 #include <common/query.h>
-#include <common/clientapi.h>
+#include <common/store.h>
+#include "hawd/dataset.h"
+#include "hawd/formatter.h"
 #include <iostream>
 #include <math.h>
@@ -31,6 +34,7 @@ class DatabasePopulationAndFacadeQueryBenchmark : public QObject
    QByteArray identifier;
    QList<double> mRssGrowthPerEntity;
    QList<double> mTimePerEntity;
+    HAWD::State mHawdState;
    void populateDatabase(int count)
    {
@@ -40,7 +44,7 @@ class DatabasePopulationAndFacadeQueryBenchmark : public QObject
        {
            Sink::Storage storage(Sink::storageLocation(), identifier, Sink::Storage::ReadWrite);
            auto transaction = storage.createTransaction(Sink::Storage::ReadWrite);
-            auto db = transaction.openDatabase("event.main");
+            auto db = Sink::Storage::mainDatabase(transaction, "event");
            int bufferSizeTotal = 0;
            int keysSizeTotal = 0;
@@ -129,6 +133,13 @@ class DatabasePopulationAndFacadeQueryBenchmark : public QObject
        std::cout << "Rss without db [kb]: " << rssWithoutDb/1024 << std::endl;
        std::cout << "Percentage error: " << percentageRssError << std::endl;
+        HAWD::Dataset dataset("facade_query", mHawdState);
+        HAWD::Dataset::Row row = dataset.row();
+        row.setValue("rows", list.size());
+        row.setValue("queryTimePerResult", (qreal)list.size()/elapsed);
+        dataset.insertRow(row);
+        HAWD::Formatter::print(dataset);
        mTimePerEntity << static_cast<double>(elapsed)/static_cast<double>(count);
        mRssGrowthPerEntity << rssGrowthPerEntity;
diff --git a/tests/domainadaptortest.cpp b/tests/domainadaptortest.cpp
index ff8f639..f523173 100644
--- a/tests/domainadaptortest.cpp
+++ b/tests/domainadaptortest.cpp
@@ -5,7 +5,7 @@
 #include <QDebug>
 #include "dummyresource/resourcefactory.h"
-#include "clientapi.h"
+#include "store.h"
 #include "common/domainadaptor.h"
 #include "common/entitybuffer.h"
diff --git a/tests/dummyresourcebenchmark.cpp b/tests/dummyresourcebenchmark.cpp
index e511613..9afc775 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -4,12 +4,15 @@
 #include "dummyresource/resourcefactory.h"
 #include "dummyresource/domainadaptor.h"
-#include "clientapi.h"
+#include "store.h"
+#include "notifier.h"
+#include "resourcecontrol.h"
 #include "commands.h"
 #include "entitybuffer.h"
 #include "pipeline.h"
 #include "log.h"
 #include "resourceconfig.h"
+#include "notification_generated.h"
 #include "hawd/dataset.h"
 #include "hawd/formatter.h"
@@ -71,9 +74,43 @@ private Q_SLOTS:
        });
    }
+    //Ensure we can process a command in less than 0.1s
+    void testCommandResponsiveness()
+    {
+        //Test responsiveness including starting the process.
+        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
+        QTime time;
+        time.start();
+        Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+        event.setProperty("uid", "testuid");
+        QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
+        event.setProperty("summary", "summaryValue");
+        auto notifier = QSharedPointer<Sink::Notifier>::create("org.kde.dummy.instance1");
+        bool gotNotification = false;
+        int duration = 0;
+        notifier->registerHandler([&gotNotification, &duration, &time](const Sink::Notification &notification) {
+            if (notification.type == Sink::Commands::NotificationType::NotificationType_RevisionUpdate) {
+                gotNotification = true;
+                duration = time.elapsed();
+            }
+        });
+        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec();
+        //Wait for notification
+        QTRY_VERIFY(gotNotification);
+        QVERIFY2(duration < 100, QString::fromLatin1("Processing a create command took more than 100ms: %1").arg(duration).toLatin1());
+        Sink::ResourceControl::shutdown("org.kde.dummy.instance1").exec().waitForFinished();
+        qDebug() << "Single command took [ms]: " << duration;
+    }
    void testWriteToFacade()
    {
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
+        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
        QTime time;
        time.start();
@@ -92,7 +129,7 @@ private Q_SLOTS:
        {
            Sink::Query query;
            query.resources << "org.kde.dummy.instance1";
-            Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        }
        auto allProcessedTime = time.elapsed();
@@ -138,7 +175,7 @@ private Q_SLOTS:
    void testWriteInProcess()
    {
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
+        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
        QTime time;
        time.start();
@@ -226,7 +263,7 @@ private Q_SLOTS:
    //This allows to run individual parts without doing a cleanup, but still cleaning up normally
    void testCleanupForCompleteTest()
    {
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
+        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
    }
 private:
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index 82c713d..7d9ad24 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -3,10 +3,11 @@
 #include <QString>
 #include "dummyresource/resourcefactory.h"
-#include "clientapi.h"
+#include "store.h"
 #include "commands.h"
 #include "entitybuffer.h"
 #include "resourceconfig.h"
+#include "resourcecontrol.h"
 #include "modelresult.h"
 #include "pipeline.h"
 #include "log.h"
@@ -19,6 +20,9 @@
 class DummyResourceTest : public QObject
 {
    Q_OBJECT
+    QTime time;
 private Q_SLOTS:
    void initTestCase()
    {
@@ -29,20 +33,18 @@ private Q_SLOTS:
        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
    }
-    void cleanup()
-    {
-        Sink::Store::shutdown(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
-        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
-        QVERIFY(factory);
-        Sink::Store::start(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
-    }
    void init()
    {
        qDebug();
        qDebug() << "-----------------------------------------";
        qDebug();
+        time.start();
+    }
+    void cleanup()
+    {
+        qDebug() << "Test took " << time.elapsed();
+        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
    }
    void testProperty()
@@ -64,7 +66,7 @@ private Q_SLOTS:
        query.resources << "org.kde.dummy.instance1";
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        query.propertyFilter.insert("uid", "testuid");
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
@@ -88,7 +90,7 @@ private Q_SLOTS:
        query.resources << "org.kde.dummy.instance1";
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        query.propertyFilter.insert("uid", "testuid");
@@ -116,7 +118,7 @@ private Q_SLOTS:
        query.resources << "org.kde.dummy.instance1";
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        query.propertyFilter.insert("summary", "summaryValue2");
@@ -150,7 +152,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
        QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -167,7 +169,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -190,7 +192,7 @@ private Q_SLOTS:
        query.propertyFilter.insert("uid", "testuid");
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test create
        Sink::ApplicationDomain::Event event2;
@@ -209,7 +211,7 @@ private Q_SLOTS:
        Sink::Store::modify<Sink::ApplicationDomain::Event>(event2).exec().waitForFinished();
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test modify
        {
@@ -224,7 +226,7 @@ private Q_SLOTS:
        Sink::Store::remove<Sink::ApplicationDomain::Event>(event2).exec().waitForFinished();
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test remove
        {
diff --git a/tests/dummyresourcewritebenchmark.cpp b/tests/dummyresourcewritebenchmark.cpp
index 1a8893b..6c05a1e 100644
--- a/tests/dummyresourcewritebenchmark.cpp
+++ b/tests/dummyresourcewritebenchmark.cpp
@@ -6,7 +6,7 @@
 #include "dummyresource/resourcefactory.h"
 #include "dummyresource/domainadaptor.h"
-#include "clientapi.h"
+#include "store.h"
 #include "commands.h"
 #include "entitybuffer.h"
 #include "pipeline.h"
@@ -120,6 +120,7 @@ class DummyResourceWriteBenchmark : public QObject
            resource.processCommand(Sink::Commands::CreateEntityCommand, command);
        }
        auto appendTime = time.elapsed();
+        Q_UNUSED(appendTime);
        auto bufferSizeTotal = bufferSize * num;
        //Wait until all messages have been processed
diff --git a/tests/hawd/CMakeLists.txt b/tests/hawd/CMakeLists.txt
index 268e7a9..d754726 100644
--- a/tests/hawd/CMakeLists.txt
+++ b/tests/hawd/CMakeLists.txt
@@ -26,7 +26,7 @@ set(SRCS
 add_library(lib${PROJECT_NAME} SHARED ${lib_SRCS})
 generate_export_header(lib${PROJECT_NAME} BASE_NAME HAWD EXPORT_FILE_NAME hawd_export.h)
 qt5_use_modules(lib${PROJECT_NAME} Core)
-target_link_libraries(lib${PROJECT_NAME} sinkcommon)
+target_link_libraries(lib${PROJECT_NAME} sink)
 if (LIBGIT2_FOUND)
   target_link_libraries(lib${PROJECT_NAME} ${LIBGIT2_LIBRARIES})
 endif(LIBGIT2_FOUND)
diff --git a/tests/hawd/dataset.cpp b/tests/hawd/dataset.cpp
index fd931e8..372a4b6 100644
--- a/tests/hawd/dataset.cpp
+++ b/tests/hawd/dataset.cpp
@@ -216,8 +216,8 @@ QString Dataset::Row::toString(const QStringList &cols, int standardCols, const
 Dataset::Dataset(const QString &name, const State &state)
    : m_definition(state.datasetDefinition(name)),
      m_storage(state.resultsPath(), name, Sink::Storage::ReadWrite),
-      m_commitHash(state.commitHash()),
+      m_transaction(std::move(m_storage.createTransaction())),
-      m_transaction(std::move(m_storage.createTransaction()))
+      m_commitHash(state.commitHash())
 {
 }
diff --git a/tests/indextest.cpp b/tests/indextest.cpp
index 7ec95ce..a435e97 100644
--- a/tests/indextest.cpp
+++ b/tests/indextest.cpp
@@ -3,7 +3,7 @@
 #include <QString>
 #include <QQueue>
-#include "clientapi.h"
+#include "store.h"
 #include "storage.h"
 #include "index.h"
diff --git a/tests/inspectiontest.cpp b/tests/inspectiontest.cpp
index c876aa9..79e5863 100644
--- a/tests/inspectiontest.cpp
+++ b/tests/inspectiontest.cpp
@@ -3,7 +3,8 @@
 #include <QString>
 #include "dummyresource/resourcefactory.h"
-#include "clientapi.h"
+#include "store.h"
+#include "resourcecontrol.h"
 #include "resourceconfig.h"
 #include "log.h"
@@ -21,17 +22,8 @@ private Q_SLOTS:
        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
        QVERIFY(factory);
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
-    }
+        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
-    void cleanup()
-    {
-        Sink::Store::shutdown(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
-        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
-        QVERIFY(factory);
-        Sink::Store::start(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
    }
    void testInspection_data()
@@ -50,8 +42,8 @@ private Q_SLOTS:
        Mail mail(QByteArray("org.kde.dummy.instance1"), QByteArray("identifier"), 0, QSharedPointer<MemoryBufferAdaptor::MemoryBufferAdaptor>::create());
        //testInspection is a magic property that the dummyresource supports
-        auto inspectionCommand = Resources::Inspection::PropertyInspection(mail, "testInspection", success);
+        auto inspectionCommand = ResourceControl::Inspection::PropertyInspection(mail, "testInspection", success);
-        auto result = Resources::inspect<Mail>(inspectionCommand).exec();
+        auto result = ResourceControl::inspect<Mail>(inspectionCommand).exec();
        result.waitForFinished();
        if (success) {
            QVERIFY(!result.errorCode());
diff --git a/tests/maildirresourcetest.cpp b/tests/maildirresourcetest.cpp
index 6ad6ca6..28a1d44 100644
--- a/tests/maildirresourcetest.cpp
+++ b/tests/maildirresourcetest.cpp
@@ -3,7 +3,8 @@
 #include <QString>
 #include "maildirresource/maildirresource.h"
-#include "clientapi.h"
+#include "store.h"
+#include "resourcecontrol.h"
 #include "commands.h"
 #include "entitybuffer.h"
 #include "resourceconfig.h"
@@ -68,7 +69,7 @@ private Q_SLOTS:
    void cleanup()
    {
-        Sink::Store::shutdown(QByteArray("org.kde.maildir.instance1")).exec().waitForFinished();
+        Sink::ResourceControl::shutdown(QByteArray("org.kde.maildir.instance1")).exec().waitForFinished();
        MaildirResource::removeFromDisk("org.kde.maildir.instance1");
        QDir dir(targetPath);
        dir.removeRecursively();
@@ -80,7 +81,7 @@ private Q_SLOTS:
        qDebug() << "-----------------------------------------";
        qDebug();
        copyRecursively(TESTDATAPATH "/maildir1", targetPath);
-        Sink::Store::start(QByteArray("org.kde.maildir.instance1")).exec().waitForFinished();
+        Sink::ResourceControl::start(QByteArray("org.kde.maildir.instance1")).exec().waitForFinished();
    }
    void testListFolders()
@@ -90,7 +91,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
        QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -105,7 +106,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
        QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -123,7 +124,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        auto query = Query::ResourceFilter("org.kde.maildir.instance1");
        Store::synchronize(query).exec().waitForFinished();
-        Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto result = Store::fetchOne<Folder>(
                Query::ResourceFilter("org.kde.maildir.instance1") + Query::RequestedProperties(QByteArrayList() << "name")
            )
@@ -149,7 +150,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto mailModel = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(mailModel->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -158,6 +159,9 @@ private Q_SLOTS:
        QVERIFY(!mail->getProperty("subject").toString().isEmpty());
        QVERIFY(!mail->getProperty("mimeMessage").toString().isEmpty());
        QVERIFY(mail->getProperty("date").toDateTime().isValid());
+        QFileInfo info(mail->getProperty("mimeMessage").toString());
+        QVERIFY(info.exists());
    }
@@ -169,7 +173,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/";
        QDir dir(targetPath);
@@ -177,7 +181,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
        QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -193,11 +197,11 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto mailModel = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(mailModel->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -212,7 +216,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/cur/1365777830.R28.localhost.localdomain:2,S";
        QFile file(targetPath);
@@ -220,7 +224,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto mailModel = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(mailModel->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -233,7 +237,7 @@ private Q_SLOTS:
        query.resources << "org.kde.maildir.instance1";
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        Sink::ApplicationDomain::Folder folder("org.kde.maildir.instance1");
        folder.setProperty("name", "testCreateFolder");
@@ -241,7 +245,7 @@ private Q_SLOTS:
        Sink::Store::create(folder).exec().waitForFinished();
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/testCreateFolder";
        QFileInfo file(targetPath);
@@ -259,7 +263,7 @@ private Q_SLOTS:
        Sink::ApplicationDomain::Folder folder("org.kde.maildir.instance1");
        folder.setProperty("name", "testCreateFolder");
        Sink::Store::create(folder).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        QTRY_VERIFY(QFileInfo(targetPath).exists());
        Sink::Query folderQuery;
@@ -271,7 +275,7 @@ private Q_SLOTS:
        auto createdFolder = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
        Sink::Store::remove(*createdFolder).exec().waitForFinished();
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        QTRY_VERIFY(!QFileInfo(targetPath).exists());
    }
@@ -281,15 +285,16 @@ private Q_SLOTS:
        query.resources << "org.kde.maildir.instance1";
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        Sink::ApplicationDomain::Mail mail("org.kde.maildir.instance1");
        mail.setProperty("name", "testCreateMail");
+        //FIXME instead of properties, ensure the mimeMessage property is used and the file is moved as expected
        Sink::Store::create(mail).exec().waitForFinished();
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/new";
        QDir dir(targetPath);
@@ -304,29 +309,28 @@ private Q_SLOTS:
        auto query = Query::ResourceFilter("org.kde.maildir.instance1");
        Store::synchronize(query).exec().waitForFinished();
-        Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        auto result = Store::fetchOne<Folder>(
-                Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("name", "maildir1") + Query::RequestedProperties(QByteArrayList() << "name")
+            Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("name", "maildir1") + Query::RequestedProperties(QByteArrayList() << "name")
+        )
+        .then<void, KAsync::Job<void>, Folder>([query](const Folder &folder) {
+            return Store::fetchAll<Mail>(
+                Query::PropertyFilter("folder", folder) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject")
            )
-            .then<void, KAsync::Job<void>, Folder>([query](const Folder &folder) {
+            .then<void, KAsync::Job<void>, QList<Mail::Ptr> >([query](const QList<Mail::Ptr> &mails) {
-                return Store::fetchAll<Mail>(
+                //Can't use QCOMPARE because it tries to return FIXME Implement ASYNCCOMPARE
-                    Query::PropertyFilter("folder", folder) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject")
+                if (mails.size() != 1) {
-                )
+                    return KAsync::error<void>(1, "Wrong number of mails.");
-                .then<void, KAsync::Job<void>, QList<Mail::Ptr> >([query](const QList<Mail::Ptr> &mails) {
+                }
-                    //Can't use QCOMPARE because it tries to return FIXME Implement ASYNCCOMPARE
+                auto mail = mails.first();
-                    if (mails.size() != 1) {
-                        return KAsync::error<void>(1, "Wrong number of mails.");
+                return Store::remove(*mail)
-                    }
+                    .then(ResourceControl::flushReplayQueue(query.resources)) //The change needs to be replayed already
-                    auto mail = mails.first();
+                    .then(ResourceControl::inspect<Mail>(ResourceControl::Inspection::ExistenceInspection(*mail, false)));
+            });
-                    return Store::remove(*mail)
+        })
-                        .then(Store::flushReplayQueue(query.resources)) //The change needs to be replayed already
+        .exec();
-                        .then(Resources::inspect<Mail>(Resources::Inspection::ExistenceInspection(*mail, false)));
-                })
-                .then<void>([](){});
-            })
-            .exec();
        result.waitForFinished();
        QVERIFY(!result.errorCode());
    }
@@ -338,33 +342,64 @@ private Q_SLOTS:
        auto query = Query::ResourceFilter("org.kde.maildir.instance1");
        Store::synchronize(query).exec().waitForFinished();
-        Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        Folder f;
        auto result = Store::fetchOne<Folder>(
-                Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("name", "maildir1") + Query::RequestedProperties(QByteArrayList() << "name")
+            Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("name", "maildir1") + Query::RequestedProperties(QByteArrayList() << "name")
+        )
+        .then<void, KAsync::Job<void>, Folder>([query, &f](const Folder &folder) {
+            f = folder;
+            return Store::fetchAll<Mail>(
+                Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("folder", folder) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject")
            )
-            .then<void, KAsync::Job<void>, Folder>([query](const Folder &folder) {
+            .then<void, KAsync::Job<void>, QList<Mail::Ptr> >([query](const QList<Mail::Ptr> &mails) {
-                Trace() << "Found a folder" << folder.identifier();
+                //Can't use QCOMPARE because it tries to return FIXME Implement ASYNCCOMPARE
-                return Store::fetchAll<Mail>(
+                if (mails.size() != 1) {
-                    Query::PropertyFilter("folder", folder) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject")
+                    return KAsync::error<void>(1, "Wrong number of mails.");
-                )
+                }
-                .then<void, KAsync::Job<void>, QList<Mail::Ptr> >([query](const QList<Mail::Ptr> &mails) {
+                auto mail = mails.first();
-                    //Can't use QCOMPARE because it tries to return FIXME Implement ASYNCCOMPARE
+                mail->setProperty("unread", true);
-                    if (mails.size() != 1) {
+                return Store::modify(*mail)
-                        return KAsync::error<void>(1, "Wrong number of mails.");
+                .then<void>(ResourceControl::flushReplayQueue(query.resources)) //The change needs to be replayed already
-                    }
+                .then(ResourceControl::inspect<Mail>(ResourceControl::Inspection::PropertyInspection(*mail, "unread", true)))
-                    auto mail = mails.first();
+                .then(ResourceControl::inspect<Mail>(ResourceControl::Inspection::PropertyInspection(*mail, "subject", mail->getProperty("subject"))));
-                    mail->setProperty("unread", true);
+            });
-                    auto inspectionCommand = Resources::Inspection::PropertyInspection(*mail, "unread", true);
+        })
-                    return Store::modify(*mail)
+        .exec();
-                        .then<void>(Store::flushReplayQueue(query.resources)) //The change needs to be replayed already
-                        .then(Resources::inspect<Mail>(inspectionCommand));
-                })
-                .then<void>([](){});
-            })
-            .exec();
        result.waitForFinished();
        QVERIFY(!result.errorCode());
+        //Verify that we can still query for all relevant information
+        auto result2 = Store::fetchAll<Mail>(
+            Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("folder", f) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject" << "mimeMessage" << "unread")
+        )
+        .then<void, KAsync::Job<void>, QList<Mail::Ptr> >([](const QList<Mail::Ptr> &mails) {
+            //Can't use QCOMPARE because it tries to return FIXME Implement ASYNCCOMPARE
+            if (mails.size() != 1) {
+                qWarning() << "Wrong number of mails";
+                return KAsync::error<void>(1, "Wrong number of mails.");
+            }
+            auto mail = mails.first();
+            if (mail->getProperty("subject").toString().isEmpty()) {
+                qWarning() << "Wrong subject";
+                return KAsync::error<void>(1, "Wrong subject.");
+            }
+            if (mail->getProperty("unread").toBool() != true) {
+                qWarning() << "Not unread";
+                return KAsync::error<void>(1, "Not unread.");
+            }
+            QFileInfo info(mail->getProperty("mimeMessage").toString());
+            if (!info.exists()) {
+                qWarning() << "Wrong subject";
+                return KAsync::error<void>(1, "Can't find mime message.");
+            }
+            return KAsync::null<void>();
+        })
+        .exec();
+        result2.waitForFinished();
+        QVERIFY(!result2.errorCode());
    }
 };
diff --git a/tests/messagequeuetest.cpp b/tests/messagequeuetest.cpp
index c835b53..454ace2 100644
--- a/tests/messagequeuetest.cpp
+++ b/tests/messagequeuetest.cpp
@@ -3,7 +3,7 @@
 #include <QString>
 #include <QQueue>
-#include "clientapi.h"
+#include "store.h"
 #include "storage.h"
 #include "messagequeue.h"
 #include "log.h"
diff --git a/tests/modelinteractivitytest.cpp b/tests/modelinteractivitytest.cpp
index 14c9fd0..3f6e697 100644
--- a/tests/modelinteractivitytest.cpp
+++ b/tests/modelinteractivitytest.cpp
@@ -4,7 +4,8 @@
 #include <iostream>
 #include "dummyresource/resourcefactory.h"
-#include "clientapi.h"
+#include "store.h"
+#include "resourcecontrol.h"
 #include "commands.h"
 #include "resourceconfig.h"
 #include "log.h"
@@ -46,15 +47,13 @@ private Q_SLOTS:
    void initTestCase()
    {
        Sink::Log::setDebugOutputLevel(Sink::Log::Warning);
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
+        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
    }
    void cleanup()
    {
-        Sink::Store::shutdown(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
-        Sink::Store::start(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
    }
    void init()
@@ -75,7 +74,7 @@ private Q_SLOTS:
        query.resources << "org.kde.dummy.instance1";
        query.liveQuery = true;
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test
        QTime time;
diff --git a/tests/pipelinetest.cpp b/tests/pipelinetest.cpp
index c74d319..d6073dc 100644
--- a/tests/pipelinetest.cpp
+++ b/tests/pipelinetest.cpp
@@ -11,7 +11,7 @@
 #include "modifyentity_generated.h"
 #include "deleteentity_generated.h"
 #include "dummyresource/resourcefactory.h"
-#include "clientapi.h"
+#include "store.h"
 #include "commands.h"
 #include "entitybuffer.h"
 #include "resourceconfig.h"
@@ -52,7 +52,7 @@ static QByteArray getEntity(const QByteArray &dbEnv, const QByteArray &name, con
    return result;
 }
-flatbuffers::FlatBufferBuilder &createEvent(flatbuffers::FlatBufferBuilder &entityFbb, const QString &s = QString("summary"))
+flatbuffers::FlatBufferBuilder &createEvent(flatbuffers::FlatBufferBuilder &entityFbb, const QString &s = QString("summary"), const QString &d = QString())
 {
    flatbuffers::FlatBufferBuilder eventFbb;
    eventFbb.Clear();
@@ -66,9 +66,13 @@ flatbuffers::FlatBufferBuilder &createEvent(flatbuffers::FlatBufferBuilder &enti
    {
        auto uid = localFbb.CreateString("testuid");
        auto summary = localFbb.CreateString(s.toStdString());
+        auto description = localFbb.CreateString(d.toStdString());
        auto localBuilder = Sink::ApplicationDomain::Buffer::EventBuilder(localFbb);
        localBuilder.add_uid(uid);
        localBuilder.add_summary(summary);
+        if (!d.isEmpty()) {
+            localBuilder.add_description(description);
+        }
        auto location = localBuilder.Finish();
        Sink::ApplicationDomain::Buffer::FinishEventBuffer(localFbb, location);
    }
@@ -203,7 +207,7 @@ private Q_SLOTS:
    void testModify()
    {
        flatbuffers::FlatBufferBuilder entityFbb;
-        auto command = createEntityCommand(createEvent(entityFbb));
+        auto command = createEntityCommand(createEvent(entityFbb, "summary", "description"));
        Sink::Pipeline pipeline("org.kde.pipelinetest.instance1");
@@ -233,7 +237,9 @@ private Q_SLOTS:
        QVERIFY(!buffer.isEmpty());
        Sink::EntityBuffer entityBuffer(buffer.data(), buffer.size());
        auto adaptor = adaptorFactory->createAdaptor(entityBuffer.entity());
-        QCOMPARE(adaptor->getProperty("summary").toString(), QString("summary2"));
+        QVERIFY2(adaptor->getProperty("summary").toString() == QString("summary2"), "The modification isn't applied.");
+        //Ensure we didn't modify anything else
+        QVERIFY2(adaptor->getProperty("description").toString() == QString("description"), "The modification has sideeffects.");
        //Both revisions are in the store at this point
        QCOMPARE(getKeys("org.kde.pipelinetest.instance1", "event.main").size(), 2);
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index 62db15b..16376b9 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -3,7 +3,8 @@
 #include <QString>
 #include "dummyresource/resourcefactory.h"
-#include "clientapi.h"
+#include "store.h"
+#include "resourcecontrol.h"
 #include "commands.h"
 #include "resourceconfig.h"
 #include "log.h"
@@ -23,17 +24,13 @@ private Q_SLOTS:
        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
        QVERIFY(factory);
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
+        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
    }
    void cleanup()
    {
-        Sink::Store::shutdown(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
-        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
-        QVERIFY(factory);
-        Sink::Store::start(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
    }
    void init()
@@ -90,7 +87,7 @@ private Q_SLOTS:
        query.liveQuery = false;
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch after the data is available and don't rely on the live query mechanism to deliver the actual data
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
@@ -165,7 +162,7 @@ private Q_SLOTS:
            query.resources << "org.kde.dummy.instance1";
            //Ensure all local data is processed
-            Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
            QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -185,7 +182,7 @@ private Q_SLOTS:
        query.parentProperty = "parent";
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch after the data is available and don't rely on the live query mechanism to deliver the actual data
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
@@ -214,7 +211,7 @@ private Q_SLOTS:
        query.propertyFilter.insert("uid", "test1");
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch before the data is available and rely on the live query mechanism to deliver the actual data
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
@@ -234,7 +231,7 @@ private Q_SLOTS:
            query.resources << "org.kde.dummy.instance1";
            //Ensure all local data is processed
-            Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
            QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -255,7 +252,7 @@ private Q_SLOTS:
        query.propertyFilter.insert("folder", folderEntity->identifier());
        //Ensure all local data is processed
-        Sink::Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch before the data is available and rely on the live query mechanism to deliver the actual data
        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);