24 files changed, 176 insertions, 578 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 0cc30e5..7341675 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -409,9 +409,6 @@ void DataStoreQuery::setupQuery()
 {
     auto baseFilters = mQuery.getBaseFilters();
     for (const auto &k : baseFilters.keys()) {
-        if (k == ApplicationDomain::Entity::Resource::name) {
-            continue;
-        }
         const auto comparator = baseFilters.value(k);
         if (comparator.value.canConvert<Query>()) {
             SinkTrace() << "Executing subquery for property: " << k;
@@ -446,9 +443,6 @@ void DataStoreQuery::setupQuery()
         auto filter = Filter::Ptr::create(baseSet, this);
         //For incremental queries the remaining filters are not sufficient
         for (const auto &f : mQuery.getBaseFilters().keys()) {
-            if (f == ApplicationDomain::Entity::Resource::name) {
-                continue;
-            }
             filter->propertyFilter.insert(f, mQuery.getFilter(f));
         }
         baseSet = filter;
@@ -459,7 +453,7 @@ void DataStoreQuery::setupQuery()
     /* } */
 
     //Setup the rest of the filter stages on top of the base set
-    for (const auto &stage : mQuery.filterStages.mid(1)) {
+    for (const auto &stage : mQuery.getFilterStages()) {
         if (auto filter = stage.dynamicCast<Query::Filter>()) {
             auto f = Filter::Ptr::create(baseSet, this);
             f->propertyFilter = filter->propertyFilter;
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index 1c8b45a..7332bfb 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -242,7 +242,6 @@ struct SINK_EXPORT Entity : public ApplicationDomainType {
     typedef QSharedPointer<Entity> Ptr;
     using ApplicationDomainType::ApplicationDomainType;
     virtual ~Entity();
-    SINK_REFERENCE_PROPERTY(SinkResource, Resource, resource);
 };
 
 struct SINK_EXPORT Event : public Entity {
diff --git a/common/query.h b/common/query.h
index 82b04f7..ae307a2 100644
--- a/common/query.h
+++ b/common/query.h
@@ -59,46 +59,6 @@ public:
         Comparators comparator;
     };
 
-    static Query ResourceFilter(const QByteArray &identifier)
-    {
-        Query query;
-        query.resources.append(identifier);
-        return query;
-    }
-
-    static Query ResourceFilter(const QByteArrayList &identifier)
-    {
-        Query query;
-        query.resources = identifier;
-        return query;
-    }
-
-    static Query ResourceFilter(const ApplicationDomain::SinkResource &entity)
-    {
-        return ResourceFilter(entity.identifier());
-    }
-
-    static Query IdentityFilter(const QByteArray &identifier)
-    {
-        Q_ASSERT(!identifier.isEmpty());
-        Query query;
-        query.filter(identifier);
-        return query;
-    }
-
-    static Query IdentityFilter(const QByteArrayList &identifier)
-    {
-        Query query;
-        query.filter(identifier);
-        return query;
-    }
-
-    static Query IdentityFilter(const ApplicationDomain::Entity &entity)
-    {
-        auto query = IdentityFilter(entity.identifier());
-        query.resources << entity.resourceInstanceIdentifier();
-        return query;
-    }
 
     template <typename T>
     Query &request()
@@ -124,16 +84,13 @@ public:
     Query(const ApplicationDomain::Entity &value) : limit(0), liveQuery(false), synchronousQuery(false)
     {
         filter(value.identifier());
-        filter(ApplicationDomain::SinkResource(value.resourceInstanceIdentifier()));
+        resourceFilter(value.resourceInstanceIdentifier());
     }
 
-
     Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false)
     {
     }
 
-    QByteArrayList resources;
-    QByteArrayList accounts;
     QByteArrayList requestedProperties;
     QByteArray parentProperty;
     QByteArray sortProperty;
@@ -147,7 +104,10 @@ public:
         virtual ~FilterStage(){};
     };
 
-    QList<QSharedPointer<FilterStage>> filterStages;
+    QList<QSharedPointer<FilterStage>> getFilterStages()
+    {
+        return mFilterStages;
+    }
 
     /*
     * Filters
@@ -178,69 +138,45 @@ public:
 
     Query &filter(const QByteArray &id)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->ids << id;
+        mBaseFilterStage.ids << id;
         return *this;
     }
 
     Query &filter(const QByteArrayList &ids)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->ids << ids;
+        mBaseFilterStage.ids << ids;
         return *this;
     }
 
     Query &filter(const QByteArray &property, const Comparator &comparator)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->propertyFilter.insert(property, comparator);
+        mBaseFilterStage.propertyFilter.insert(property, comparator);
         return *this;
     }
 
     Comparator getFilter(const QByteArray &property) const
     {
-        if (filterStages.isEmpty()) {
-            return Comparator();
-        }
-        return filterStages.first().staticCast<Filter>()->propertyFilter.value(property);
+        return mBaseFilterStage.propertyFilter.value(property);
     }
 
     bool hasFilter(const QByteArray &property) const
     {
-        if (filterStages.isEmpty()) {
-            return false;
-        }
-        return filterStages.first().staticCast<Filter>()->propertyFilter.contains(property);
+        return mBaseFilterStage.propertyFilter.contains(property);
     }
 
     void setBaseFilters(const QHash<QByteArray, Comparator> &filter)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->propertyFilter = filter;
+        mBaseFilterStage.propertyFilter = filter;
     }
 
     QHash<QByteArray, Comparator> getBaseFilters() const
     {
-        if (filterStages.isEmpty()) {
-            return QHash<QByteArray, Comparator>();
-        }
-        return filterStages.first().staticCast<Filter>()->propertyFilter;
+        return mBaseFilterStage.propertyFilter;
     }
 
     QByteArrayList ids() const
     {
-        if (filterStages.isEmpty()) {
-            return QByteArrayList();
-        }
-        return filterStages.first().staticCast<Filter>()->ids;
+        return mBaseFilterStage.ids;
     }
 
     template <typename T>
@@ -257,18 +193,42 @@ public:
         return filter(T::name, QVariant::fromValue(q));
     }
 
-    Query &filter(const ApplicationDomain::SinkResource &resource)
+    Filter getResourceFilter() const
+    {
+        return mResourceFilter;
+    }
+
+    Query &resourceFilter(const QByteArray &id)
     {
-        resources << resource.identifier();
+        mResourceFilter.ids << id;
         return *this;
     }
 
-    Query &filter(const ApplicationDomain::SinkAccount &account)
+    template <typename T>
+    Query &resourceFilter(const ApplicationDomain::ApplicationDomainType &entity)
     {
-        accounts << account.identifier();
+        mResourceFilter.propertyFilter.insert(T::name, Comparator(entity.identifier()));
         return *this;
     }
 
+    Query &resourceFilter(const QByteArray &name, const Comparator &comparator)
+    {
+        mResourceFilter.propertyFilter.insert(name, comparator);
+        return *this;
+    }
+
+    template <typename T>
+    Query &resourceContainsFilter(const QVariant &value)
+    {
+        return resourceFilter(T::name, Comparator(value, Comparator::Contains));
+    }
+
+    template <typename T>
+    Query &resourceFilter(const QVariant &value)
+    {
+        return resourceFilter(T::name, value);
+    }
+
     class Reduce : public FilterStage {
     public:
 
@@ -318,7 +278,7 @@ public:
     Reduce &reduce(const Reduce::Selector &s)
     {
         auto reduction = QSharedPointer<Reduce>::create(T::name, s);
-        filterStages << reduction;
+        mFilterStages << reduction;
         return *reduction;
     }
 
@@ -345,7 +305,7 @@ public:
     void bloom()
     {
         auto bloom = QSharedPointer<Bloom>::create(T::name);
-        filterStages << bloom;
+        mFilterStages << bloom;
     }
 
     //Query fixtures
@@ -357,7 +317,7 @@ public:
     {
         Sink::Query query;
         if (!mail.resourceInstanceIdentifier().isEmpty()) {
-            query.filter(ApplicationDomain::SinkResource(mail.resourceInstanceIdentifier()));
+            query.resourceFilter(mail.resourceInstanceIdentifier());
         }
         query.filter(mail.identifier());
         query.sort<ApplicationDomain::Mail::Date>();
@@ -372,7 +332,7 @@ public:
     {
         Sink::Query query;
         if (!folder.resourceInstanceIdentifier().isEmpty()) {
-            query.filter(ApplicationDomain::SinkResource(folder.resourceInstanceIdentifier()));
+            query.resourceFilter(folder.resourceInstanceIdentifier());
         }
         query.filter<ApplicationDomain::Mail::Folder>(folder);
         query.sort<ApplicationDomain::Mail::Date>();
@@ -380,7 +340,10 @@ public:
         return query;
     }
 
-
+private:
+    Filter mResourceFilter;
+    Filter mBaseFilterStage;
+    QList<QSharedPointer<FilterStage>> mFilterStages;
 };
 
 }
diff --git a/common/store.cpp b/common/store.cpp
index c015ef6..0ecdcd2 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -59,25 +59,15 @@ QString Store::getTemporaryFilePath()
  */
 static QMap<QByteArray, QByteArray> getResources(const Sink::Query &query, const QByteArray &type = QByteArray())
 {
-    const QList<QByteArray> resourceFilter = query.resources;
-    const QList<QByteArray> accountFilter = query.accounts;
+    const QList<QByteArray> resourceFilter = query.getResourceFilter().ids;
 
-    auto resourceComparator = query.getFilter(Sink::ApplicationDomain::Entity::Resource::name);
 
     const auto filterResource = [&](const QByteArray &res) {
         const auto configuration = ResourceConfig::getConfiguration(res);
-        if (!accountFilter.isEmpty() && !accountFilter.contains(configuration.value(ApplicationDomain::SinkResource::Account::name).toByteArray())) {
-            return true;
-        }
-        //Subquery for the resource
-        if (resourceComparator.value.canConvert<Query>()) {
-            const auto subquery = resourceComparator.value.value<Query>();
-            const auto baseFilters = subquery.getBaseFilters();
-            for (const auto &filterProperty : baseFilters.keys()) {
-                const auto filter = baseFilters.value(filterProperty);
-                if (!filter.matches(configuration.value(filterProperty))) {
-                    return true;
-                }
+        for (const auto &filterProperty : query.getResourceFilter().propertyFilter.keys()) {
+            const auto filter = query.getResourceFilter().propertyFilter.value(filterProperty);
+            if (!filter.matches(configuration.value(filterProperty))) {
+                return true;
             }
         }
         return false;
@@ -159,7 +149,7 @@ QSharedPointer<QAbstractItemModel> Store::loadModel(Query query)
     auto aggregatingEmitter = AggregatingResultEmitter<typename DomainType::Ptr>::Ptr::create();
     model->setEmitter(aggregatingEmitter);
 
-    if (query.liveQuery && query.resources.isEmpty() && !ApplicationDomain::isGlobalType(ApplicationDomain::getTypeName<DomainType>())) {
+    if (query.liveQuery && query.getResourceFilter().ids.isEmpty() && !ApplicationDomain::isGlobalType(ApplicationDomain::getTypeName<DomainType>())) {
         SinkTrace() << "Listening for new resources";
         auto facade = FacadeFactory::instance().getFacade<ApplicationDomain::SinkResource>("", "");
         Q_ASSERT(facade);
@@ -267,8 +257,8 @@ KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
 
 KAsync::Job<void> Store::synchronize(const Sink::Query &query)
 {
-    SinkTrace() << "synchronize" << query.resources;
     auto resources = getResources(query).keys();
+    SinkTrace() << "synchronize" << resources;
     //FIXME only necessary because each doesn't propagate errors
     auto errorFlag = new bool;
     return KAsync::value(resources)
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index d6f2d90..9d87b1c 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,6 +1,3 @@
-# the client
-add_subdirectory(client)
-
 # a simple dummy resource implementation
 add_subdirectory(dummyresource)
 
diff --git a/examples/client/CMakeLists.txt b/examples/client/CMakeLists.txt
deleted file mode 100644
index ef00368..0000000
--- a/examples/client/CMakeLists.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-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} sink)
-qt5_use_modules(${PROJECT_NAME} Widgets Network)
-install(TARGETS ${PROJECT_NAME} ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/examples/client/console.cpp b/examples/client/console.cpp
deleted file mode 100644
index 8b4f1a5..0000000
--- a/examples/client/console.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
- *
- * 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 "console.h"
-
-#include <QFontDatabase>
-#include <QLabel>
-#include <QTextBrowser>
-#include <QVBoxLayout>
-
-static Console *s_console = 0;
-
-Console *Console::main()
-{
-    if (!s_console) {
-        s_console = new Console(QString());
-    }
-    return s_console;
-}
-
-Console::Console(const QString &title)
-    : QWidget(0)
-{
-    if (!s_console) {
-        s_console = this;
-    }
-
-    resize(1000, 1500);
-
-    QVBoxLayout *topLayout = new QVBoxLayout(this);
-
-    QLabel *titleLabel = new QLabel(this);
-    titleLabel->setText(title);
-    QFont font = titleLabel->font();
-    font.setWeight(QFont::Bold);
-    titleLabel->setFont(font);
-    titleLabel->setAlignment(Qt::AlignCenter);
-
-    QFont consoleFont = QFontDatabase::systemFont(QFontDatabase::FixedFont);
-    consoleFont.setPointSize(7);
-    m_textDisplay = new QTextBrowser(this);
-    m_textDisplay->document()->setDefaultFont(consoleFont);
-    topLayout->addWidget(titleLabel);
-    topLayout->addWidget(m_textDisplay, 10);
-
-    show();
-    m_timestamper.start();
-}
-
-Console::~Console()
-{
-
-}
-
-void Console::log(const QString &message)
-{
-    m_textDisplay->append(QString::number(m_timestamper.elapsed()).rightJustified(6) + ": " + message);
-}
-
diff --git a/examples/client/console.h b/examples/client/console.h
deleted file mode 100644
index a6fef01..0000000
--- a/examples/client/console.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
- *
- * 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 <QTime>
-#include <QWidget>
-
-class QTextBrowser;
-
-class Console : public QWidget
-{
-    Q_OBJECT
-public:
-    static Console *main();
-    Console(const QString &title);
-    ~Console();
-
-    void log(const QString &message);
-
-private:
-    QTextBrowser *m_textDisplay;
-    QTime m_timestamper;
-    static Console *s_output;
-};
diff --git a/examples/client/main.cpp b/examples/client/main.cpp
deleted file mode 100644
index f4b472f..0000000
--- a/examples/client/main.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the
- *   Free Software Foundation, Inc.,
- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
- */
-
-#include <QApplication>
-#include <QCommandLineParser>
-#include <QCommandLineOption>
-#include <QTime>
-
-#include "common/store.h"
-#include "common/log.h"
-
-#include <QWidget>
-#include <QTreeView>
-#include <QVBoxLayout>
-#include <QLabel>
-#include <QPushButton>
-#include <QItemSelectionModel>
-#include <iostream>
-
-/**
- * A small abstraction layer to use the sink store with the type available as string.
- */
-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;
-    virtual KAsync::Job<void> modify(const Sink::ApplicationDomain::ApplicationDomainType &type) = 0;
-    virtual KAsync::Job<void> remove(const Sink::ApplicationDomain::ApplicationDomainType &type) = 0;
-    virtual QSharedPointer<QAbstractItemModel> loadModel(const Sink::Query &query) = 0;
-};
-
-template <typename T>
-class Store : public StoreBase {
-public:
-    Sink::ApplicationDomain::ApplicationDomainType::Ptr getObject() Q_DECL_OVERRIDE {
-        return T::Ptr::create();
-    }
-
-    Sink::ApplicationDomain::ApplicationDomainType::Ptr getObject(const QByteArray &resourceInstanceIdentifier, const QByteArray &identifier = QByteArray()) Q_DECL_OVERRIDE {
-        return T::Ptr::create(resourceInstanceIdentifier, identifier, 0, QSharedPointer<Sink::ApplicationDomain::MemoryBufferAdaptor>::create());
-    }
-
-    KAsync::Job<void> create(const Sink::ApplicationDomain::ApplicationDomainType &type) Q_DECL_OVERRIDE {
-        return Sink::Store::create<T>(*static_cast<const T*>(&type));
-    }
-
-    KAsync::Job<void> modify(const Sink::ApplicationDomain::ApplicationDomainType &type) Q_DECL_OVERRIDE {
-        return Sink::Store::modify<T>(*static_cast<const T*>(&type));
-    }
-
-    KAsync::Job<void> remove(const Sink::ApplicationDomain::ApplicationDomainType &type) Q_DECL_OVERRIDE {
-        return Sink::Store::remove<T>(*static_cast<const T*>(&type));
-    }
-
-    QSharedPointer<QAbstractItemModel> loadModel(const Sink::Query &query) Q_DECL_OVERRIDE {
-        return Sink::Store::loadModel<T>(query);
-    }
-};
-
-StoreBase& getStore(const QString &type)
-{
-    if (type == "folder") {
-        static Store<Sink::ApplicationDomain::Folder> store;
-        return store;
-    } else if (type == "mail") {
-        static Store<Sink::ApplicationDomain::Mail> store;
-        return store;
-    } else if (type == "event") {
-        static Store<Sink::ApplicationDomain::Event> store;
-        return store;
-    } else if (type == "resource") {
-        static Store<Sink::ApplicationDomain::SinkResource> store;
-        return store;
-    }
-    Q_ASSERT(false);
-    qWarning() << "Trying to get a store that doesn't exist, falling back to event";
-    static Store<Sink::ApplicationDomain::Event> store;
-    return store;
-}
-
-template <typename T>
-class View : public QWidget
-{
-public:
-    View(QAbstractItemModel *model)
-        : QWidget()
-    {
-        auto modelView = new QTreeView(this);
-        modelView->setModel(model);
-        resize(1000, 1500);
-
-        auto topLayout = new QVBoxLayout(this);
-
-        auto titleLabel = new QLabel(this);
-        titleLabel->setText("Demo");
-        auto font = titleLabel->font();
-        font.setWeight(QFont::Bold);
-        titleLabel->setFont(font);
-        titleLabel->setAlignment(Qt::AlignCenter);
-
-        auto syncButton = new QPushButton(this);
-        syncButton->setText("Synchronize!");
-        QObject::connect(syncButton, &QPushButton::pressed, []() {
-            Sink::Query query;
-            query.resources << "sink.dummy.instance1";
-            Sink::Store::synchronize(query).exec();
-        });
-
-        auto removeButton = new QPushButton(this);
-        removeButton->setText("Remove");
-        QObject::connect(removeButton, &QPushButton::pressed, [modelView]() {
-            for (auto index : modelView->selectionModel()->selectedIndexes()) {
-                auto object = index.data(Sink::Store::DomainObjectRole).value<typename T::Ptr>();
-                Sink::Store::remove(*object).exec();
-            }
-        });
-
-        topLayout->addWidget(titleLabel);
-        topLayout->addWidget(syncButton);
-        topLayout->addWidget(removeButton);
-        topLayout->addWidget(modelView, 10);
-
-        show();
-    }
-
-};
-
-static QSharedPointer<QAbstractItemModel> loadModel(const QString &type, Sink::Query query)
-{
-    QTime time;
-    time.start();
-    if (type == "folder") {
-        query.requestedProperties << "name" << "parent";
-    } else if (type == "mail") {
-        query.requestedProperties << "subject" << "folder" << "date";
-    } else if (type == "event") {
-        query.requestedProperties << "summary";
-    } else if (type == "resource") {
-        query.requestedProperties << "type";
-    }
-    auto model = getStore(type).loadModel(query);
-    qDebug() << "Folder type " << type;
-    qDebug() << "Loaded model in " << time.elapsed() << " ms";
-    Q_ASSERT(model);
-    return model;
-}
-
-QMap<QString, QString> consumeMap(QList<QString> &list)
-{
-    QMap<QString, QString> map;
-    while(list.size() >= 2) {
-        map.insert(list.at(0), list.at(1));
-        list = list.mid(2);
-    }
-    return map;
-}
-
-int main(int argc, char *argv[])
-{
-    QApplication app(argc, argv);
-
-    QCommandLineParser cliOptions;
-    cliOptions.addPositionalArgument(QObject::tr("[type]"),
-                                     QObject::tr("A type to work with"));
-    cliOptions.addPositionalArgument(QObject::tr("[resource]"),
-                                     QObject::tr("A resource to connect to"));
-    cliOptions.addOption(QCommandLineOption("debuglevel", "A debuglevel from 0-6", "debuglevel"));
-    cliOptions.addHelpOption();
-    cliOptions.process(app);
-    QStringList args = cliOptions.positionalArguments();
-
-    if (cliOptions.isSet("debuglevel")) {
-        Sink::Log::setDebugOutputLevel(static_cast<Sink::Log::DebugLevel>(cliOptions.value("debuglevel").toInt()));
-    }
-
-    auto type = !args.isEmpty() ? args.takeFirst() : QByteArray();
-    auto resources = args;
-
-    Sink::Query query;
-    for (const auto &res : resources) {
-        query.resources << res.toLatin1();
-    }
-    query.liveQuery = true;
-    if (type == "folder") {
-        query.parentProperty = "parent";
-    }
-    auto model = loadModel(type, query);
-    if (type == "folder") {
-        QObject::connect(model.data(), &QAbstractItemModel::rowsInserted, [model](const QModelIndex &index, int start, int end) {
-            for (int i = start; i <= end; i++) {
-                model->fetchMore(model->index(i, 0, index));
-            }
-        });
-        auto view = QSharedPointer<View<Sink::ApplicationDomain::Folder> >::create(model.data());
-        app.exec();
-    } else if (type == "mail") {
-        auto view = QSharedPointer<View<Sink::ApplicationDomain::Mail> >::create(model.data());
-        app.exec();
-    } else if (type == "event") {
-        auto view = QSharedPointer<View<Sink::ApplicationDomain::Event> >::create(model.data());
-        app.exec();
-    }
-    return 0;
-}
diff --git a/examples/imapresource/tests/imapmailsyncbenchmark.cpp b/examples/imapresource/tests/imapmailsyncbenchmark.cpp
index 1cf8861..824b769 100644
--- a/examples/imapresource/tests/imapmailsyncbenchmark.cpp
+++ b/examples/imapresource/tests/imapmailsyncbenchmark.cpp
@@ -107,7 +107,7 @@ private slots:
     void testSync()
     {
         Sink::Query query;
-        query.resources << mResourceInstanceIdentifier;
+        query.resourceFilter(mResourceInstanceIdentifier);
         query.request<Folder::Name>().request<Folder::SpecialPurpose>();
 
         QTime time;
@@ -117,7 +117,7 @@ private slots:
         VERIFYEXEC(Store::synchronize(query));
         SinkLog() << "Sync took: " << Sink::Log::TraceTime(time.elapsed());
 
-        VERIFYEXEC(ResourceControl::flushMessageQueue(query.resources));
+        VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
         SinkLog() << "Total took: " << Sink::Log::TraceTime(time.elapsed());
 
         time.start();
@@ -125,7 +125,7 @@ private slots:
         VERIFYEXEC(Store::synchronize(query));
         SinkLog() << "ReSync took: " << Sink::Log::TraceTime(time.elapsed());
 
-        VERIFYEXEC(ResourceControl::flushMessageQueue(query.resources));
+        VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
         SinkLog() << "Total resync took: " << Sink::Log::TraceTime(time.elapsed());
     }
 };
diff --git a/examples/mailtransportresource/tests/mailtransporttest.cpp b/examples/mailtransportresource/tests/mailtransporttest.cpp
index fdd591b..e44aa23 100644
--- a/examples/mailtransportresource/tests/mailtransporttest.cpp
+++ b/examples/mailtransportresource/tests/mailtransporttest.cpp
@@ -61,10 +61,10 @@ private slots:
 
         VERIFYEXEC(Store::create(mail));
         VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
-        VERIFYEXEC(Store::synchronize(Query::ResourceFilter(mResourceInstanceIdentifier)));
+        VERIFYEXEC(Store::synchronize(Query().resourceFilter(mResourceInstanceIdentifier)));
         VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::ExistenceInspection(mail, true)));
 
-        auto sentMail = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail).request<Mail::Sent>().request<Mail::Subject>());
+        auto sentMail = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Sent>().request<Mail::Subject>());
         QVERIFY(sentMail.getSent());
         QVERIFY(!sentMail.getSubject().isEmpty());
     }
diff --git a/sinksh/syntax_modules/sink_count.cpp b/sinksh/syntax_modules/sink_count.cpp
index fde7c33..7e04c79 100644
--- a/sinksh/syntax_modules/sink_count.cpp
+++ b/sinksh/syntax_modules/sink_count.cpp
@@ -51,7 +51,7 @@ bool count(const QStringList &args, State &state)
 
     Sink::Query query;
     for (const auto &res : resources) {
-        query.resources << res.toLatin1();
+        query.resourceFilter(res.toLatin1());
     }
     query.liveQuery = false;
 
diff --git a/sinksh/syntax_modules/sink_list.cpp b/sinksh/syntax_modules/sink_list.cpp
index 2d7ef5f..e176aab 100644
--- a/sinksh/syntax_modules/sink_list.cpp
+++ b/sinksh/syntax_modules/sink_list.cpp
@@ -59,8 +59,7 @@ bool list(const QStringList &args, State &state)
     auto filterIndex = args.indexOf("--filter");
     if (filterIndex >= 0) {
         for (int i = 1; i < filterIndex; i++) {
-            query.resources << args.at(i).toLatin1();
-            query.filter(Sink::ApplicationDomain::SinkResource(args.at(i).toLatin1()));
+            query.resourceFilter(args.at(i).toLatin1());
         }
         for (int i = filterIndex + 1; i < args.size(); i++) {
             auto filter = args.at(i).split("=");
diff --git a/sinksh/syntax_modules/sink_show.cpp b/sinksh/syntax_modules/sink_show.cpp
index 5197e77..45fd62c 100644
--- a/sinksh/syntax_modules/sink_show.cpp
+++ b/sinksh/syntax_modules/sink_show.cpp
@@ -60,7 +60,7 @@ bool show(const QStringList &args, State &state)
     if (queryForResourceOrAgent) {
         query.filter(resource.toLatin1());
     } else {
-        query.filter(Sink::ApplicationDomain::SinkResource(resource.toLatin1()));
+        query.resourceFilter(resource.toLatin1());
     }
     query.liveQuery = false;
 
diff --git a/sinksh/syntax_modules/sink_sync.cpp b/sinksh/syntax_modules/sink_sync.cpp
index e3c51ff..1c7ed0f 100644
--- a/sinksh/syntax_modules/sink_sync.cpp
+++ b/sinksh/syntax_modules/sink_sync.cpp
@@ -41,7 +41,7 @@ bool sync(const QStringList &args, State &state)
 {
     Sink::Query query;
     for (const auto &res : args) {
-        query.resources << res.toLatin1();
+        query.resourceFilter(res.toLatin1());
     }
 
     QTimer::singleShot(0, [query, state]() {
diff --git a/tests/accountstest.cpp b/tests/accountstest.cpp
index 260602c..8216210 100644
--- a/tests/accountstest.cpp
+++ b/tests/accountstest.cpp
@@ -139,7 +139,7 @@ private slots:
             QCOMPARE(account->getStatus(), static_cast<int>(Sink::ApplicationDomain::OfflineStatus));
 
             //Synchronize to connect
-            VERIFYEXEC(Sink::Store::synchronize(Query::ResourceFilter(res)));
+            VERIFYEXEC(Sink::Store::synchronize(Query().resourceFilter(res.identifier())));
 
             QTRY_COMPARE_WITH_TIMEOUT(model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::SinkAccount::Ptr>()->getStatus(), static_cast<int>(Sink::ApplicationDomain::ConnectedStatus), 1000);
         }
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index 44eb845..fd3d5f0 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -104,7 +104,7 @@ private slots:
         ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
 
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
 
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
@@ -115,7 +115,7 @@ private slots:
     void testLoadWithoutResource()
     {
         Sink::Query query;
-        query.resources << "nonexisting.resource";
+        query.resourceFilter("nonexisting.resource");
         query.liveQuery = false;
 
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
@@ -129,7 +129,7 @@ private slots:
         ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
 
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
 
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
@@ -147,7 +147,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
         query.parentProperty = "parent";
 
@@ -170,7 +170,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
         query.parentProperty = "parent";
 
@@ -193,7 +193,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = true;
         query.parentProperty = "parent";
 
@@ -268,7 +268,7 @@ private slots:
         ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
 
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
 
         bool gotValue = false;
diff --git a/tests/dummyresourcebenchmark.cpp b/tests/dummyresourcebenchmark.cpp
index ffaa8f6..8c6afb4 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -13,6 +13,8 @@
 #include "log.h"
 #include "resourceconfig.h"
 #include "notification_generated.h"
+#include "test.h"
+#include "testutils.h"
 
 #include "hawd/dataset.h"
 #include "hawd/formatter.h"
@@ -98,8 +100,8 @@ private slots:
         // Ensure everything is processed
         {
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            query.resourceFilter("sink.dummy.instance1");
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
         }
         auto allProcessedTime = time.elapsed();
 
@@ -127,7 +129,7 @@ private slots:
         {
             time.start();
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             query.filter("uid", Sink::Query::Comparator("testuid"));
             auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index a7a492c..2ff31e5 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -12,6 +12,7 @@
 #include "pipeline.h"
 #include "log.h"
 #include "test.h"
+#include "testutils.h"
 
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
@@ -66,10 +67,10 @@ private slots:
         event.setProperty("summary", "summaryValue");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1") ;
+        auto query = Query().resourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query.filter<Event::Uid>("testuid"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
@@ -88,10 +89,10 @@ private slots:
         event.setProperty("uid", "testuid2");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1") ;
+        auto query = Query().resourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query.filter<Event::Uid>("testuid"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
@@ -113,10 +114,10 @@ private slots:
         event.setProperty("summary", "summaryValue2");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1") ;
+        auto query = Query().resourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query.filter<Event::Summary>("summaryValue2"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
@@ -143,11 +144,11 @@ private slots:
 
     void testSyncAndFacade()
     {
-        const auto query = Query::ResourceFilter("sink.dummy.instance1");
+        const auto query = Query().resourceFilter("sink.dummy.instance1");
 
         // Ensure all local data is processed
         Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query);
         QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -159,12 +160,12 @@ private slots:
 
     void testSyncAndFacadeMail()
     {
-        auto query = Query::ResourceFilter("sink.dummy.instance1");
+        auto query = Query().resourceFilter("sink.dummy.instance1");
         query.request<Mail::Subject>();
 
         // Ensure all local data is processed
         Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -182,10 +183,10 @@ private slots:
         event.setProperty("summary", "summaryValue");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1").filter<Event::Uid>("testuid");
+        auto query = Query().resourceFilter("sink.dummy.instance1").filter<Event::Uid>("testuid");
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test create
         Event event2;
@@ -204,7 +205,7 @@ private slots:
         Sink::Store::modify<Event>(event2).exec().waitForFinished();
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test modify
         {
@@ -219,7 +220,7 @@ private slots:
         Sink::Store::remove<Event>(event2).exec().waitForFinished();
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test remove
         {
@@ -231,7 +232,7 @@ private slots:
 
     void testWriteModifyDeleteLive()
     {
-        auto query = Query::ResourceFilter("sink.dummy.instance1");
+        auto query = Query().resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
         query.filter<Event::Uid>("testuid");
 
diff --git a/tests/mailsynctest.cpp b/tests/mailsynctest.cpp
index 8260978..98ac685 100644
--- a/tests/mailsynctest.cpp
+++ b/tests/mailsynctest.cpp
@@ -81,12 +81,12 @@ void MailSyncTest::testListFolders()
     }
 
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>().request<Folder::SpecialPurpose>();
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([=](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -121,14 +121,14 @@ void MailSyncTest::testListFolders()
 void MailSyncTest::testListNewFolder()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     createFolder(QStringList() << "test2");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -143,17 +143,17 @@ void MailSyncTest::testListNewFolder()
 void MailSyncTest::testListRemovedFolder()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     removeFolder(QStringList() << "test2");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -171,14 +171,14 @@ void MailSyncTest::testListFolderHierarchy()
         QSKIP("Missing capability folder.hierarchy");
     }
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>().request<Folder::Parent>();
 
     createFolder(QStringList() << "test" << "sub");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([=](const QList<Folder::Ptr> &folders) {
         QHash<QString, Folder::Ptr> map;
@@ -214,14 +214,14 @@ void MailSyncTest::testListNewSubFolder()
         QSKIP("Missing capability mail.folderhierarchy");
     }
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     createFolder(QStringList() << "test" << "sub1");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -239,17 +239,17 @@ void MailSyncTest::testListRemovedSubFolder()
         QSKIP("Missing capability folder.hierarchy");
     }
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     removeFolder(QStringList() << "test" << "sub1");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -264,12 +264,12 @@ void MailSyncTest::testListRemovedSubFolder()
 void MailSyncTest::testListMails()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
         QCOMPARE(mails.size(), 1);
@@ -290,15 +290,15 @@ void MailSyncTest::testListMails()
 void MailSyncTest::testResyncMails()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
         QCOMPARE(mails.size(), 1);
@@ -309,20 +309,20 @@ void MailSyncTest::testResyncMails()
 void MailSyncTest::testFetchNewRemovedMessages()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>();
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto msg = KMime::Message::Ptr::create();
     msg->subject(true)->fromUnicodeString("Foobar", "utf8");
     msg->assemble();
     auto messageIdentifier = createMessage(QStringList() << "test", msg->encodedContent(true));
 
-    Store::synchronize(query).exec().waitForFinished();
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(Store::synchronize(query));
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
@@ -333,8 +333,8 @@ void MailSyncTest::testFetchNewRemovedMessages()
 
     removeMessage(QStringList() << "test", messageIdentifier);
 
-    Store::synchronize(query).exec().waitForFinished();
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(Store::synchronize(query));
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
@@ -347,7 +347,8 @@ void MailSyncTest::testFetchNewRemovedMessages()
 void MailSyncTest::testFlagChange()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
+    query.filter<Mail::Important>(true);
     query.request<Mail::Subject>().request<Mail::Important>();
 
     auto msg = KMime::Message::Ptr::create();
@@ -355,13 +356,12 @@ void MailSyncTest::testFlagChange()
     msg->assemble();
     auto messageIdentifier = createMessage(QStringList() << "test", msg->encodedContent(true));
 
-    Store::synchronize(query).exec().waitForFinished();
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(Store::synchronize(query));
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 2);
-            QVERIFY(!mails.at(1)->getImportant());
+            QCOMPARE(mails.size(), 0);
         });
         VERIFYEXEC(job);
     }
@@ -370,12 +370,12 @@ void MailSyncTest::testFlagChange()
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 2);
-            QVERIFY(mails.at(1)->getImportant());
+            QCOMPARE(mails.size(), 1);
+            QVERIFY(mails.first()->getImportant());
         });
         VERIFYEXEC(job);
     }
@@ -389,7 +389,7 @@ void MailSyncTest::testFailingSync()
     VERIFYEXEC(Store::create(resource));
 
     Sink::Query query;
-    query.resources << resource.identifier();
+    query.resourceFilter(resource.identifier());
 
     // Ensure sync fails if resource is misconfigured
     auto future = Store::synchronize(query).exec();
diff --git a/tests/mailtest.cpp b/tests/mailtest.cpp
index ed145d4..3339838 100644
--- a/tests/mailtest.cpp
+++ b/tests/mailtest.cpp
@@ -298,7 +298,7 @@ void MailTest::testMarkMailAsRead()
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(Query()
-                                        .filter(SinkResource(mResourceInstanceIdentifier))
+                                        .resourceFilter(mResourceInstanceIdentifier)
                                         .request<Mail::Folder>()
                                         .request<Mail::Subject>()
                                     )
@@ -315,7 +315,7 @@ void MailTest::testMarkMailAsRead()
 
     // Verify that we can still query for all relevant information
     auto job2 = Store::fetchAll<Mail>(Query()
-                                        .filter(SinkResource(mResourceInstanceIdentifier))
+                                        .resourceFilter(mResourceInstanceIdentifier)
                                         .request<Mail::Folder>()
                                         .request<Mail::Subject>()
                                         .request<Mail::MimeMessage>()
@@ -351,7 +351,7 @@ void MailTest::testCreateDraft()
 
     QByteArray folderIdentifier;
 
-    auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail).request<Mail::Folder>());
+    auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
     folderIdentifier = createdDraft.getFolder();
     QVERIFY(!folderIdentifier.isEmpty());
 
@@ -370,7 +370,7 @@ void MailTest::testCreateDraft()
     //Ensure the folder is also existing
     {
         ApplicationDomain::Folder folder;
-        auto folders = Store::read<ApplicationDomain::Folder>(Query::IdentityFilter(folderIdentifier));
+        auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier));
         QCOMPARE(folders.size(), 1);
         folder = folders.first();
         VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, true)));
@@ -400,7 +400,7 @@ void MailTest::testModifyMailToDraft()
     VERIFYEXEC(Store::create(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
-    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail));
+    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query(mail));
     modifiedMail.setDraft(true);
     VERIFYEXEC(Store::modify(modifiedMail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
@@ -408,7 +408,7 @@ void MailTest::testModifyMailToDraft()
 
     QByteArray folderIdentifier;
     {
-        auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail).request<Mail::Folder>());
+        auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
         folderIdentifier = createdDraft.getFolder();
         QVERIFY(!folderIdentifier.isEmpty());
     }
@@ -416,7 +416,7 @@ void MailTest::testModifyMailToDraft()
     //Ensure the folder is also existing
     {
         ApplicationDomain::Folder folder;
-        auto folders = Store::read<ApplicationDomain::Folder>(Query::IdentityFilter(folderIdentifier).request<Folder::SpecialPurpose>());
+        auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier).request<Folder::SpecialPurpose>());
         QCOMPARE(folders.size(), 1);
         folder = folders.first();
         QVERIFY(folder.getSpecialPurpose().contains("drafts"));
@@ -447,7 +447,7 @@ void MailTest::testModifyMailToTrash()
     VERIFYEXEC(Store::create(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
-    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail));
+    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query(mail));
     modifiedMail.setTrash(true);
     VERIFYEXEC(Store::modify(modifiedMail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
@@ -455,7 +455,7 @@ void MailTest::testModifyMailToTrash()
 
     QByteArray folderIdentifier;
     {
-        auto createdMail = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail).request<Mail::Folder>());
+        auto createdMail = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
         folderIdentifier = createdMail.getFolder();
         QVERIFY(!folderIdentifier.isEmpty());
     }
@@ -463,7 +463,7 @@ void MailTest::testModifyMailToTrash()
     //Ensure the folder is also existing
     {
         ApplicationDomain::Folder folder;
-        auto folders = Store::read<ApplicationDomain::Folder>(Query::IdentityFilter(folderIdentifier).request<Folder::SpecialPurpose>());
+        auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier).request<Folder::SpecialPurpose>());
         QCOMPARE(folders.size(), 1);
         folder = folders.first();
         QVERIFY(folder.getSpecialPurpose().contains("trash"));
diff --git a/tests/mailthreadtest.cpp b/tests/mailthreadtest.cpp
index 6ba54df..b6b0da2 100644
--- a/tests/mailthreadtest.cpp
+++ b/tests/mailthreadtest.cpp
@@ -66,14 +66,14 @@ void MailThreadTest::init()
 void MailThreadTest::testListThreadLeader()
 {
     Sink::Query query;
-    query.filter(SinkResource(mResourceInstanceIdentifier));
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
     query.sort<Mail::Date>();
     query.reduce<Mail::ThreadId>(Query::Reduce::Selector::max<Mail::Date>());
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto mails = Store::read<Mail>(query);
     QCOMPARE(mails.size(), 1);
@@ -125,7 +125,7 @@ void MailThreadTest::testIndexInMixedOrder()
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto query = Sink::Query::threadLeaders(folder);
-    query.filter(SinkResource(mResourceInstanceIdentifier));
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
 
     Mail threadLeader;
diff --git a/tests/modelinteractivitytest.cpp b/tests/modelinteractivitytest.cpp
index 1ac0e2d..df0c772 100644
--- a/tests/modelinteractivitytest.cpp
+++ b/tests/modelinteractivitytest.cpp
@@ -11,6 +11,7 @@
 #include "log.h"
 #include "modelresult.h"
 #include "test.h"
+#include "testutils.h"
 
 static int blockingTime;
 
@@ -76,10 +77,10 @@ private slots:
         }
 
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
 
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test
         QTime time;
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index db17026..e978787 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -49,7 +49,7 @@ private slots:
     {
         // Test
         Sink::Query query;
-        query.resources << "foobar";
+        query.resourceFilter("foobar");
         query.liveQuery = true;
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -69,7 +69,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -87,11 +87,11 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = false;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // 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<Mail>(query);
@@ -118,7 +118,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
         query.filter<Mail::Folder>("folder1");
 
@@ -150,7 +150,7 @@ private slots:
             Sink::Store::create<Mail>(mail).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
             Sink::Store::synchronize(query).exec().waitForFinished();
@@ -164,7 +164,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter(SinkResource("sink.dummy.instance1"));
+        query.resourceFilter("sink.dummy.instance1");
         query.filter(id);
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -181,7 +181,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -199,10 +199,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -218,11 +218,11 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.parentProperty = "parent";
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // 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<Folder>(query);
@@ -252,12 +252,12 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = false;
         query.filter<Mail::Uid>("test1");
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Mail>(query);
@@ -274,10 +274,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -294,11 +294,11 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.filter<Mail::Folder>(*folderEntity);
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Mail>(query);
@@ -318,10 +318,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -348,12 +348,12 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.filter<Mail::Folder>(*folderEntity);
         query.filter<Mail::Uid>("test1");
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Mail>(query);
@@ -370,10 +370,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -408,14 +408,14 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter(SinkResource("sink.dummy.instance1"));
+        query.resourceFilter("sink.dummy.instance1");
         query.filter<Mail::Folder>(*folderEntity);
         query.sort<Mail::Date>();
         query.limit = 1;
         query.liveQuery = false;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -485,7 +485,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter(account1);
+        query.resourceFilter<SinkResource::Account>(account1);
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto folders = Sink::Store::read<Folder>(query);
@@ -517,7 +517,7 @@ private slots:
         }
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1").exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         //Setup two folders with a mail each, ensure we only get the mail from the folder that matches the folder filter.
         Query query;
@@ -538,12 +538,12 @@ private slots:
         auto resource1 = ApplicationDomainType::createEntity<SinkResource>();
         resource1.setResourceType("sink.dummy");
         resource1.setCapabilities(QByteArrayList() << "cap1");
-        Store::create(resource1).exec().waitForFinished();
+        VERIFYEXEC(Store::create(resource1));
 
         auto resource2 = ApplicationDomainType::createEntity<SinkResource>();
         resource2.setCapabilities(QByteArrayList() << "cap2");
         resource2.setResourceType("sink.dummy");
-        Store::create(resource2).exec().waitForFinished();
+        VERIFYEXEC(Store::create(resource2));
 
         Folder folder1(resource1.identifier());
         VERIFYEXEC(Sink::Store::create<Folder>(folder1));
@@ -552,7 +552,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter<Folder::Resource>(Sink::Query().containsFilter<SinkResource::Capabilities>("cap1"));
+        query.resourceContainsFilter<SinkResource::Capabilities>("cap1");
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto folders = Sink::Store::read<Folder>(query);