Use the Query::filter api.

10 files changed, 234 insertions, 254 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 0fc9234..3c4ae00 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -146,6 +146,7 @@ public:
     typedef QSharedPointer<Reduce> Ptr;
 
     QHash<QByteArray, QVariant> mAggregateValues;
+    QSet<QByteArray> mReducedValues;
     QByteArray mReductionProperty;
     QByteArray mSelectionProperty;
     Query::Reduce::Selector::Comparator mSelectionComparator;
@@ -184,7 +185,9 @@ public:
         bool foundValue = false;
         while(!foundValue && mSource->next([this, callback, &foundValue](Sink::Operation operation, const QByteArray &uid, const Sink::EntityBuffer &entityBuffer) {
                 auto reductionValue = getProperty(entityBuffer.entity(), mReductionProperty);
-                if (!mAggregateValues.contains(getByteArray(reductionValue))) {
+                if (!mReducedValues.contains(getByteArray(reductionValue))) {
+                    //Only reduce every value once.
+                    mReducedValues.insert(getByteArray(reductionValue));
                     QVariant selectionResultValue;
                     QByteArray selectionResult;
                     auto results = indexLookup(mReductionProperty, reductionValue);
@@ -373,17 +376,16 @@ QVector<QByteArray> DataStoreQuery::indexLookup(const QByteArray &property, cons
 void DataStoreQuery::setupQuery()
 {
     FilterBase::Ptr baseSet;
-    QSet<QByteArray> remainingFilters;
+    QSet<QByteArray> remainingFilters = mQuery.getBaseFilters().keys().toSet();
     QByteArray appliedSorting;
     if (!mQuery.ids.isEmpty()) {
         mSource = Source::Ptr::create(mQuery.ids.toVector(), this);
         baseSet = mSource;
-        remainingFilters = mQuery.propertyFilter.keys().toSet();
     } else {
         QSet<QByteArray> appliedFilters;
 
         auto resultSet = mTypeIndex.query(mQuery, appliedFilters, appliedSorting, mTransaction);
-        remainingFilters = mQuery.propertyFilter.keys().toSet() - appliedFilters;
+        remainingFilters = remainingFilters - appliedFilters;
 
         // We do a full scan if there were no indexes available to create the initial set.
         if (appliedFilters.isEmpty()) {
@@ -394,12 +396,12 @@ void DataStoreQuery::setupQuery()
         }
         baseSet = mSource;
     }
-    if (!mQuery.propertyFilter.isEmpty()) {
+    if (!mQuery.getBaseFilters().isEmpty()) {
         auto filter = Filter::Ptr::create(baseSet, this);
-        filter->propertyFilter = mQuery.propertyFilter;
-        /* for (const auto &f : remainingFilters) { */
-        /*     filter->propertyFilter.insert(f, mQuery.propertyFilter.value(f)); */
-        /* } */
+        //For incremental queries the remaining filters are not sufficient
+        for (const auto &f : mQuery.getBaseFilters().keys()) {
+            filter->propertyFilter.insert(f, mQuery.getFilter(f));
+        }
         baseSet = filter;
     }
     /* if (appliedSorting.isEmpty() && !mQuery.sortProperty.isEmpty()) { */
@@ -407,15 +409,16 @@ void DataStoreQuery::setupQuery()
     /*     baseSet = Sort::Ptr::create(baseSet, mQuery.sortProperty); */
     /* } */
 
+    //Setup the rest of the filter stages on top of the base set
     for (const auto &stage : mQuery.filterStages) {
         if (auto filter = stage.dynamicCast<Query::Filter>()) {
-
+            auto f = Filter::Ptr::create(baseSet, this);
+            f->propertyFilter = filter->propertyFilter;
+            baseSet = f;
         } else if (auto filter = stage.dynamicCast<Query::Reduce>()) {
-            auto reduce = Reduce::Ptr::create(filter->property, filter->selector.property, filter->selector.comparator, baseSet, this);
-            baseSet = reduce;
+            baseSet = Reduce::Ptr::create(filter->property, filter->selector.property, filter->selector.comparator, baseSet, this);
         } else if (auto filter = stage.dynamicCast<Query::Bloom>()) {
-            auto reduce = Bloom::Ptr::create(filter->property, baseSet, this);
-            baseSet = reduce;
+            baseSet = Bloom::Ptr::create(filter->property, baseSet, this);
         }
     }
 
diff --git a/common/query.h b/common/query.h
index 0c6260b..3362ac7 100644
--- a/common/query.h
+++ b/common/query.h
@@ -58,26 +58,6 @@ public:
         Comparators comparator;
     };
 
-
-    static Query PropertyFilter(const QByteArray &key, const QVariant &value)
-    {
-        Query query;
-        query.propertyFilter.insert(key, Comparator(value));
-        return query;
-    }
-
-    static Query PropertyContainsFilter(const QByteArray &key, const QVariant &value)
-    {
-        Query query;
-        query.propertyFilter.insert(key, Comparator(value, Comparator::Contains));
-        return query;
-    }
-
-    static Query PropertyFilter(const QByteArray &key, const ApplicationDomain::Entity &entity)
-    {
-        return PropertyFilter(key, QVariant::fromValue(entity.identifier()));
-    }
-
     static Query ResourceFilter(const QByteArray &identifier)
     {
         Query query;
@@ -97,33 +77,6 @@ public:
         return ResourceFilter(entity.identifier());
     }
 
-    static Query AccountFilter(const QByteArray &identifier)
-    {
-        Query query;
-        query.accounts.append(identifier);
-        return query;
-    }
-
-    static Query CapabilityFilter(const QByteArray &capability)
-    {
-        Query query;
-        query.propertyFilter.insert("capabilities", Comparator(capability, Comparator::Contains));
-        return query;
-    }
-
-    static Query AccountFilter(const QByteArrayList &identifier)
-    {
-        Q_ASSERT(!identifier.isEmpty());
-        Query query;
-        query.accounts = identifier;
-        return query;
-    }
-
-    static Query AccountFilter(const ApplicationDomain::SinkAccount &entity)
-    {
-        return AccountFilter(entity.identifier());
-    }
-
     static Query IdentityFilter(const QByteArray &identifier)
     {
         Q_ASSERT(!identifier.isEmpty());
@@ -146,24 +99,17 @@ public:
         return query;
     }
 
-    static Query RequestedProperties(const QByteArrayList &properties)
-    {
-        Query query;
-        query.requestedProperties = properties;
-        return query;
-    }
-
-    static Query RequestTree(const QByteArray &parentProperty)
+    template <typename T>
+    Query &request()
     {
-        Query query;
-        query.parentProperty = parentProperty;
-        return query;
+        requestedProperties << T::name;
+        return *this;
     }
 
     template <typename T>
-    Query &request()
+    Query &requestTree()
     {
-        requestedProperties << T::name;
+        parentProperty = T::name;
         return *this;
     }
 
@@ -227,9 +173,8 @@ public:
     * Filters
     */
     class Filter : public FilterStage {
-        QByteArrayList ids;
+    public:
         QHash<QByteArray, Comparator> propertyFilter;
-        QByteArray sortProperty;
     };
 
     template <typename T>
@@ -239,6 +184,12 @@ public:
     }
 
     template <typename T>
+    Query &containsFilter(const QVariant &value)
+    {
+        return filter(T::name, Comparator(value, Comparator::Contains));
+    }
+
+    template <typename T>
     Query &filter(const Comparator &comparator)
     {
         return filter(T::name, comparator);
@@ -362,6 +313,39 @@ public:
         filterStages << bloom;
     }
 
+    //Query fixtures
+
+    /**
+     * Returns the complete thread, containing all mails from all folders.
+     */
+    static Query completeThread(const ApplicationDomain::Mail &mail)
+    {
+        Sink::Query query;
+        if (!mail.resourceInstanceIdentifier().isEmpty()) {
+            query.filter(ApplicationDomain::SinkResource(mail.resourceInstanceIdentifier()));
+        }
+        query.ids << mail.identifier();
+        query.sort<ApplicationDomain::Mail::Date>();
+        query.bloom<ApplicationDomain::Mail::ThreadId>();
+        return query;
+    }
+
+    /**
+     * Returns thread leaders only, sorted by date.
+     */
+    static Query threadLeaders(const ApplicationDomain::Folder &folder)
+    {
+        Sink::Query query;
+        if (!folder.resourceInstanceIdentifier().isEmpty()) {
+            query.filter(ApplicationDomain::SinkResource(folder.resourceInstanceIdentifier()));
+        }
+        query.filter<ApplicationDomain::Mail::Folder>(folder);
+        query.sort<ApplicationDomain::Mail::Date>();
+        query.reduce<ApplicationDomain::Mail::ThreadId>(Query::Reduce::Selector::max<ApplicationDomain::Mail::Date>());
+        return query;
+    }
+
+
 };
 
 }
diff --git a/common/test.cpp b/common/test.cpp
index 1a8e11d..97c42ef 100644
--- a/common/test.cpp
+++ b/common/test.cpp
@@ -147,7 +147,7 @@ public:
             }
             SinkTrace() << "-------------------------.";
             for (const auto &res : mTestAccount->entities<T>()) {
-                qDebug() << "Parent filter " << query.propertyFilter.value("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
+                qDebug() << "Parent filter " << query.getFilter("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
                 auto parentProperty = res->getProperty("parent").toByteArray();
                 if ((!parent && parentProperty.isEmpty()) || (parent && parentProperty == parent->identifier()) || query.parentProperty.isEmpty()) {
                     qDebug() << "Found a match" << res->identifier();
diff --git a/sinksh/syntax_modules/sink_list.cpp b/sinksh/syntax_modules/sink_list.cpp
index b20f3d4..2d7ef5f 100644
--- a/sinksh/syntax_modules/sink_list.cpp
+++ b/sinksh/syntax_modules/sink_list.cpp
@@ -60,11 +60,11 @@ bool list(const QStringList &args, State &state)
     if (filterIndex >= 0) {
         for (int i = 1; i < filterIndex; i++) {
             query.resources << args.at(i).toLatin1();
-            query += Sink::Query::ResourceFilter(args.at(i).toLatin1());
+            query.filter(Sink::ApplicationDomain::SinkResource(args.at(i).toLatin1()));
         }
         for (int i = filterIndex + 1; i < args.size(); i++) {
             auto filter = args.at(i).split("=");
-            query += Sink::Query::PropertyFilter(filter.at(0).toLatin1(), filter.at(1));
+            query.filter(filter.at(0).toLatin1(), QVariant::fromValue(filter.at(1)));
         }
 
     }
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index b5405cf..44eb845 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -61,7 +61,7 @@ public:
             }
             SinkTrace() << "-------------------------.";
             for (const auto &res : results) {
-                qDebug() << "Parent filter " << query.propertyFilter.value("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
+                qDebug() << "Parent filter " << query.getFilter("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
                 auto parentProperty = res->getProperty("parent").toByteArray();
                 if ((!parent && parentProperty.isEmpty()) || (parent && parentProperty == parent->identifier()) || query.parentProperty.isEmpty()) {
                     qDebug() << "Found a hit" << res->identifier();
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index 687a33b..a7a492c 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -14,6 +14,7 @@
 #include "test.h"
 
 using namespace Sink;
+using namespace Sink::ApplicationDomain;
 
 /**
  * Test of complete system using the dummy resource.
@@ -32,7 +33,7 @@ private slots:
         Sink::Test::initTest();
         auto factory = Sink::ResourceFactory::load("sink.dummy");
         QVERIFY(factory);
-        DummyResource::removeFromDisk("sink.dummy.instance1");
+        ::DummyResource::removeFromDisk("sink.dummy.instance1");
         ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
     }
 
@@ -52,49 +53,49 @@ private slots:
 
     void testProperty()
     {
-        Sink::ApplicationDomain::Event event;
+        Event event;
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
     }
 
     void testWriteToFacadeAndQueryByUid()
     {
-        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
+        Event event("sink.dummy.instance1");
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
-        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
+        Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        const 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();
 
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query + Query::PropertyFilter("uid", "testuid"));
+        auto model = Sink::Store::loadModel<Event>(query.filter<Event::Uid>("testuid"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
         QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid"));
     }
 
     void testWriteToFacadeAndQueryByUid2()
     {
-        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
+        Event event("sink.dummy.instance1");
         event.setProperty("summary", "summaryValue");
 
         event.setProperty("uid", "testuid");
-        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
+        Sink::Store::create<Event>(event).exec().waitForFinished();
 
         event.setProperty("uid", "testuid2");
-        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
+        Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        const 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();
 
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query + Query::PropertyFilter("uid", "testuid"));
+        auto model = Sink::Store::loadModel<Event>(query.filter<Event::Uid>("testuid"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
 
         qDebug() << value->getProperty("uid").toByteArray();
         QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid"));
@@ -102,24 +103,24 @@ private slots:
 
     void testWriteToFacadeAndQueryBySummary()
     {
-        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
+        Event event("sink.dummy.instance1");
 
         event.setProperty("uid", "testuid");
         event.setProperty("summary", "summaryValue1");
-        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
+        Sink::Store::create<Event>(event).exec().waitForFinished();
 
         event.setProperty("uid", "testuid2");
         event.setProperty("summary", "summaryValue2");
-        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
+        Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        const 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();
 
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query + Query::PropertyFilter("summary", "summaryValue2"));
+        auto model = Sink::Store::loadModel<Event>(query.filter<Event::Summary>("summaryValue2"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
 
         qDebug() << value->getProperty("uid").toByteArray();
         QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid2"));
@@ -128,7 +129,7 @@ private slots:
     void testResourceSync()
     {
         auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.dummy.instance1");
-        DummyResource resource("sink.dummy.instance1", pipeline);
+        ::DummyResource resource("sink.dummy.instance1", pipeline);
         auto job = resource.synchronizeWithSource();
         // TODO pass in optional timeout?
         auto future = job.exec();
@@ -148,9 +149,9 @@ private slots:
         Sink::Store::synchronize(query).exec().waitForFinished();
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
 
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
+        auto model = Sink::Store::loadModel<Event>(query);
         QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
-        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
 
         QVERIFY(!value->getProperty("summary").toString().isEmpty());
         qDebug() << value->getProperty("summary").toString();
@@ -158,39 +159,40 @@ private slots:
 
     void testSyncAndFacadeMail()
     {
-        const 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();
 
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
+        auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
-        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Mail::Ptr>();
+        auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>();
 
-        QVERIFY(!value->getProperty("subject").toString().isEmpty());
-        qDebug() << value->getProperty("subject").toString();
+        qWarning() << value->getSubject() << value->identifier();
+        QVERIFY(!value->getSubject().isEmpty());
     }
 
     void testWriteModifyDelete()
     {
-        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
+        Event event("sink.dummy.instance1");
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
-        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
+        Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        const auto query = Query::ResourceFilter("sink.dummy.instance1") + Query::PropertyFilter("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();
 
         // Test create
-        Sink::ApplicationDomain::Event event2;
+        Event event2;
         {
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
+            auto model = Sink::Store::loadModel<Event>(query);
             QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
 
             QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid"));
             QCOMPARE(value->getProperty("summary").toByteArray(), QByteArray("summaryValue"));
@@ -199,29 +201,29 @@ private slots:
 
         event2.setProperty("uid", "testuid");
         event2.setProperty("summary", "summaryValue2");
-        Sink::Store::modify<Sink::ApplicationDomain::Event>(event2).exec().waitForFinished();
+        Sink::Store::modify<Event>(event2).exec().waitForFinished();
 
         // Ensure all local data is processed
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
 
         // Test modify
         {
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
+            auto model = Sink::Store::loadModel<Event>(query);
             QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
 
             QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid"));
             QCOMPARE(value->getProperty("summary").toByteArray(), QByteArray("summaryValue2"));
         }
 
-        Sink::Store::remove<Sink::ApplicationDomain::Event>(event2).exec().waitForFinished();
+        Sink::Store::remove<Event>(event2).exec().waitForFinished();
 
         // Ensure all local data is processed
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
 
         // Test remove
         {
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
+            auto model = Sink::Store::loadModel<Event>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
             QTRY_COMPARE(model->rowCount(QModelIndex()), 0);
         }
@@ -231,22 +233,22 @@ private slots:
     {
         auto query = Query::ResourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
-        query += Query::PropertyFilter("uid", "testuid");
+        query.filter<Event::Uid>("testuid");
 
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
+        auto model = Sink::Store::loadModel<Event>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
 
-        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
+        Event event("sink.dummy.instance1");
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
-        Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
+        Sink::Store::create<Event>(event).exec().waitForFinished();
 
         // Test create
-        Sink::ApplicationDomain::Event event2;
+        Event event2;
         {
             QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
             QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid"));
             QCOMPARE(value->getProperty("summary").toByteArray(), QByteArray("summaryValue"));
             event2 = *value;
@@ -254,18 +256,18 @@ private slots:
 
         event2.setProperty("uid", "testuid");
         event2.setProperty("summary", "summaryValue2");
-        Sink::Store::modify<Sink::ApplicationDomain::Event>(event2).exec().waitForFinished();
+        Sink::Store::modify<Event>(event2).exec().waitForFinished();
 
         // Test modify
         {
             // TODO wait for a change signal
             QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Event::Ptr>();
+            auto value = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Event::Ptr>();
             QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid"));
             QCOMPARE(value->getProperty("summary").toByteArray(), QByteArray("summaryValue2"));
         }
 
-        Sink::Store::remove<Sink::ApplicationDomain::Event>(event2).exec().waitForFinished();
+        Sink::Store::remove<Event>(event2).exec().waitForFinished();
 
         // Test remove
         {
diff --git a/tests/mailquerybenchmark.cpp b/tests/mailquerybenchmark.cpp
index 450955f..1d96819 100644
--- a/tests/mailquerybenchmark.cpp
+++ b/tests/mailquerybenchmark.cpp
@@ -45,6 +45,9 @@
 #include "createentity_generated.h"
 #include "getrssusage.h"
 
+using namespace Sink;
+using namespace Sink::ApplicationDomain;
+
 /**
  * Benchmark mail query performance.
  */
@@ -62,7 +65,7 @@ class MailQueryBenchmark : public QObject
         auto pipeline = QSharedPointer<Sink::Pipeline>::create(resourceIdentifier);
         pipeline->setResourceType("test");
 
-        auto indexer = QSharedPointer<DefaultIndexUpdater<Sink::ApplicationDomain::Mail>>::create();
+        auto indexer = QSharedPointer<DefaultIndexUpdater<Mail>>::create();
 
         pipeline->setPreprocessors("mail", QVector<Sink::Preprocessor *>() << indexer.data());
 
@@ -71,13 +74,13 @@ class MailQueryBenchmark : public QObject
         pipeline->startTransaction();
         const auto date = QDateTime::currentDateTimeUtc();
         for (int i = 0; i < count; i++) {
-            auto domainObject = Sink::ApplicationDomain::Mail::Ptr::create();
+            auto domainObject = Mail::Ptr::create();
             domainObject->setProperty("uid", "uid");
             domainObject->setProperty("subject", QString("subject%1").arg(i));
             domainObject->setProperty("date", date.addSecs(count));
             domainObject->setProperty("folder", "folder1");
             // domainObject->setProperty("attachment", attachment);
-            const auto command = createCommand<Sink::ApplicationDomain::Mail>(*domainObject, *domainTypeAdaptorFactory);
+            const auto command = createCommand<Mail>(*domainObject, *domainTypeAdaptorFactory);
             pipeline->newEntity(command.data(), command.size());
         }
         pipeline->commit();
@@ -92,18 +95,18 @@ class MailQueryBenchmark : public QObject
         QTime time;
         time.start();
 
-        auto resultSet = QSharedPointer<Sink::ResultProvider<Sink::ApplicationDomain::Mail::Ptr>>::create();
+        auto resultSet = QSharedPointer<Sink::ResultProvider<Mail::Ptr>>::create();
         auto resourceAccess = QSharedPointer<TestResourceAccess>::create();
         TestMailResourceFacade facade(resourceIdentifier, resourceAccess);
 
         auto ret = facade.load(query);
         ret.first.exec().waitForFinished();
         auto emitter = ret.second;
-        QList<Sink::ApplicationDomain::Mail::Ptr> list;
-        emitter->onAdded([&list](const Sink::ApplicationDomain::Mail::Ptr &mail) { list << mail; });
+        QList<Mail::Ptr> list;
+        emitter->onAdded([&list](const Mail::Ptr &mail) { list << mail; });
         bool done = false;
-        emitter->onInitialResultSetComplete([&done](const Sink::ApplicationDomain::Mail::Ptr &mail) { done = true; });
-        emitter->fetch(Sink::ApplicationDomain::Mail::Ptr());
+        emitter->onInitialResultSetComplete([&done](const Mail::Ptr &mail) { done = true; });
+        emitter->fetch(Mail::Ptr());
         QTRY_VERIFY(done);
         QCOMPARE(list.size(), query.limit);
 
@@ -149,18 +152,18 @@ private slots:
     void init()
     {
         resourceIdentifier = "sink.test.instance1";
-        Sink::AdaptorFactoryRegistry::instance().registerFactory<Sink::ApplicationDomain::Mail, TestMailAdaptorFactory>("test");
+        Sink::AdaptorFactoryRegistry::instance().registerFactory<Mail, TestMailAdaptorFactory>("test");
     }
 
     void test50k()
     {
         Sink::Query query;
         query.liveQuery = false;
-        query.requestedProperties << "uid"
-                                  << "subject"
-                                  << "date";
-        query.sortProperty = "date";
-        query += Sink::Query::PropertyFilter("folder", "folder1");
+        query.request<Mail::Uid>()
+             .request<Mail::Subject>()
+             .request<Mail::Date>();
+        query.sort<Mail::Date>();
+        query.filter<Mail::Folder>("folder1");
         query.limit = 1000;
 
         populateDatabase(50000);
diff --git a/tests/mailtest.cpp b/tests/mailtest.cpp
index 925fb70..ed145d4 100644
--- a/tests/mailtest.cpp
+++ b/tests/mailtest.cpp
@@ -39,12 +39,13 @@ void MailTest::initTestCase()
     QVERIFY(isBackendAvailable());
     resetTestEnvironment();
     auto resource = createResource();
+    QVERIFY(!resource.getResourceType().isEmpty());
     QVERIFY(!resource.identifier().isEmpty());
 
     VERIFYEXEC(Store::create(resource));
 
     mResourceInstanceIdentifier = resource.identifier();
-    mCapabilities = resource.getProperty("capabilities").value<QByteArrayList>();
+    mCapabilities = resource.getCapabilities();
 }
 
 void MailTest::cleanup()
@@ -82,7 +83,7 @@ void MailTest::testCreateModifyDeleteFolder()
     VERIFYEXEC(Store::create(folder));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
     {
-        auto job = Store::fetchAll<Folder>(Query::RequestedProperties(QByteArrayList() << Folder::Name::name << Folder::Icon::name))
+        auto job = Store::fetchAll<Folder>(Query().request<Folder::Name>().request<Folder::Icon>())
             .syncThen<void, QList<Folder::Ptr>>([=](const QList<Folder::Ptr> &folders) {
                 QCOMPARE(folders.size(), baseCount + 1);
                 QHash<QString, Folder::Ptr> foldersByName;
@@ -108,7 +109,7 @@ void MailTest::testCreateModifyDeleteFolder()
         VERIFYEXEC(Store::modify(folder));
         VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
         {
-            auto job = Store::fetchAll<Folder>(Query::RequestedProperties(QByteArrayList() << Folder::Name::name << Folder::Icon::name))
+            auto job = Store::fetchAll<Folder>(Query().request<Folder::Name>().request<Folder::Icon>())
                 .syncThen<void, QList<Folder::Ptr>>([=](const QList<Folder::Ptr> &folders) {
                     QCOMPARE(folders.size(), baseCount + 1);
                     QHash<QString, Folder::Ptr> foldersByName;
@@ -129,7 +130,7 @@ void MailTest::testCreateModifyDeleteFolder()
     VERIFYEXEC(Store::remove(folder));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
     {
-        auto job = Store::fetchAll<Folder>(Query::RequestedProperties(QByteArrayList() << Folder::Name::name << Folder::Icon::name))
+        auto job = Store::fetchAll<Folder>(Query().request<Folder::Name>().request<Folder::Icon>())
             .syncThen<void, QList<Folder::Ptr>>([=](const QList<Folder::Ptr> &folders) {
                 QCOMPARE(folders.size(), baseCount);
             });
@@ -159,7 +160,7 @@ void MailTest::testCreateModifyDeleteMail()
     VERIFYEXEC(Store::create(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
     {
-        auto job = Store::fetchAll<Mail>(Query::RequestedProperties(QByteArrayList() << Mail::Folder::name << Mail::Subject::name << Mail::MimeMessage::name))
+        auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>())
             .syncThen<void, QList<Mail::Ptr>>([=](const QList<Mail::Ptr> &mails) {
                 QCOMPARE(mails.size(), 1);
                 auto mail = *mails.first();
@@ -188,7 +189,7 @@ void MailTest::testCreateModifyDeleteMail()
     VERIFYEXEC(Store::modify(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
     {
-        auto job = Store::fetchAll<Mail>(Query::RequestedProperties(QByteArrayList() << Mail::Folder::name << Mail::Subject::name << Mail::MimeMessage::name))
+        auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>())
             .syncThen<void, QList<Mail::Ptr>>([=](const QList<Mail::Ptr> &mails) {
                 QCOMPARE(mails.size(), 1);
                 auto mail = *mails.first();
@@ -210,7 +211,7 @@ void MailTest::testCreateModifyDeleteMail()
     VERIFYEXEC(Store::remove(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
     {
-        auto job = Store::fetchAll<Mail>(Query::RequestedProperties(QByteArrayList() << Mail::Folder::name << Mail::Subject::name))
+        auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>())
             .syncThen<void, QList<Mail::Ptr>>([=](const QList<Mail::Ptr> &mails) {
                 QCOMPARE(mails.size(), 0);
             });
@@ -246,7 +247,7 @@ void MailTest::testMoveMail()
 
     Mail modifiedMail;
     {
-        auto job = Store::fetchAll<Mail>(Query::RequestedProperties(QByteArrayList() << Mail::Folder::name << Mail::Subject::name << Mail::MimeMessage::name))
+        auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>())
             .syncThen<void, QList<Mail::Ptr>>([=, &modifiedMail](const QList<Mail::Ptr> &mails) {
                 QCOMPARE(mails.size(), 1);
                 auto mail = *mails.first();
@@ -265,7 +266,7 @@ void MailTest::testMoveMail()
     VERIFYEXEC(Store::modify(modifiedMail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
     {
-        auto job = Store::fetchAll<Mail>(Query::RequestedProperties(QByteArrayList() << Mail::Folder::name << Mail::Subject::name << Mail::MimeMessage::name))
+        auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>())
             .syncThen<void, QList<Mail::Ptr>>([=](const QList<Mail::Ptr> &mails) {
                 QCOMPARE(mails.size(), 1);
                 auto mail = *mails.first();
@@ -296,9 +297,11 @@ void MailTest::testMarkMailAsRead()
     VERIFYEXEC(Store::create(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
-    auto job = Store::fetchAll<Mail>(Query::ResourceFilter(mResourceInstanceIdentifier) +
-                                Query::RequestedProperties(QByteArrayList() << Mail::Folder::name
-                                                                            << Mail::Subject::name))
+    auto job = Store::fetchAll<Mail>(Query()
+                                        .filter(SinkResource(mResourceInstanceIdentifier))
+                                        .request<Mail::Folder>()
+                                        .request<Mail::Subject>()
+                                    )
         .then<void, QList<Mail::Ptr>>([this](const QList<Mail::Ptr> &mails) {
             ASYNCCOMPARE(mails.size(), 1);
             auto mail = mails.first();
@@ -311,11 +314,13 @@ void MailTest::testMarkMailAsRead()
     VERIFYEXEC(job);
 
     // Verify that we can still query for all relevant information
-    auto job2 = Store::fetchAll<Mail>(
-                        Query::ResourceFilter(mResourceInstanceIdentifier) + Query::RequestedProperties(QByteArrayList() << Mail::Folder::name
-                                                                                                                         << Mail::Subject::name
-                                                                                                                         << Mail::MimeMessage::name
-                                                                                                                         << Mail::Unread::name))
+    auto job2 = Store::fetchAll<Mail>(Query()
+                                        .filter(SinkResource(mResourceInstanceIdentifier))
+                                        .request<Mail::Folder>()
+                                        .request<Mail::Subject>()
+                                        .request<Mail::MimeMessage>()
+                                        .request<Mail::Unread>()
+                                    )
         .then<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
             ASYNCCOMPARE(mails.size(), 1);
             auto mail = mails.first();
diff --git a/tests/mailthreadtest.cpp b/tests/mailthreadtest.cpp
index e9fe499..6ba54df 100644
--- a/tests/mailthreadtest.cpp
+++ b/tests/mailthreadtest.cpp
@@ -75,11 +75,9 @@ void MailThreadTest::testListThreadLeader()
     VERIFYEXEC(Store::synchronize(query));
     ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
 
-    auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
-        QCOMPARE(mails.size(), 1);
-        QVERIFY(mails.first()->getSubject().startsWith(QString("ThreadLeader")));
-    });
-    VERIFYEXEC(job);
+    auto mails = Store::read<Mail>(query);
+    QCOMPARE(mails.size(), 1);
+    QVERIFY(mails.first().getSubject().startsWith(QString("ThreadLeader")));
 }
 
 /*
@@ -126,25 +124,19 @@ void MailThreadTest::testIndexInMixedOrder()
     }
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
-    Sink::Query query;
+    auto query = Sink::Query::threadLeaders(folder);
     query.filter(SinkResource(mResourceInstanceIdentifier));
     query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
-    query.filter<Mail::Folder>(folder);
-    query.sort<Mail::Date>();
-    query.reduce<Mail::ThreadId>(Query::Reduce::Selector::max<Mail::Date>());
 
     Mail threadLeader;
 
     //Ensure we find the thread leader
     {
-        auto job = Store::fetchAll<Mail>(query)
-            .syncThen<void, QList<Mail::Ptr>>([=, &threadLeader](const QList<Mail::Ptr> &mails) {
-                QCOMPARE(mails.size(), 1);
-                auto mail = *mails.first();
-                threadLeader = mail;
-                QCOMPARE(mail.getSubject(), QString::fromLatin1("Re: Re: 1"));
-            });
-        VERIFYEXEC(job);
+        auto mails = Store::read<Mail>(query);
+        QCOMPARE(mails.size(), 1);
+        auto mail = mails.first();
+        threadLeader = mail;
+        QCOMPARE(mail.getSubject(), QString::fromLatin1("Re: Re: 1"));
     }
 
     {
@@ -157,13 +149,10 @@ void MailThreadTest::testIndexInMixedOrder()
 
     //Ensure we find the thread leader still
     {
-        auto job = Store::fetchAll<Mail>(query)
-            .syncThen<void, QList<Mail::Ptr>>([=](const QList<Mail::Ptr> &mails) {
-                QCOMPARE(mails.size(), 1);
-                auto mail = *mails.first();
-                QCOMPARE(mail.getSubject(), QString::fromLatin1("Re: Re: 1"));
-            });
-        VERIFYEXEC(job);
+        auto mails = Store::read<Mail>(query);
+        QCOMPARE(mails.size(), 1);
+        auto mail = mails.first();
+        QCOMPARE(mail.getSubject(), QString::fromLatin1("Re: Re: 1"));
     }
 
     {
@@ -176,20 +165,13 @@ void MailThreadTest::testIndexInMixedOrder()
 
     //Ensure the thread is complete
     {
-        Sink::Query query;
-        query.filter(SinkResource(mResourceInstanceIdentifier));
-        query.ids << threadLeader.identifier();
+        auto query = Sink::Query::completeThread(threadLeader);
         query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
-        query.sort<Mail::Date>();
-        query.bloom<Mail::ThreadId>();
-
-        auto job = Store::fetchAll<Mail>(query)
-            .syncThen<void, QList<Mail::Ptr>>([=](const QList<Mail::Ptr> &mails) {
-                QCOMPARE(mails.size(), 3);
-                auto mail = *mails.first();
-                QCOMPARE(mail.getSubject(), QString::fromLatin1("Re: Re: 1"));
-            });
-        VERIFYEXEC(job);
+
+        auto mails = Store::read<Mail>(query);
+        QCOMPARE(mails.size(), 3);
+        auto mail = mails.first();
+        QCOMPARE(mail.getSubject(), QString::fromLatin1("Re: Re: 1"));
     }
 
     /* VERIFYEXEC(Store::remove(mail)); */
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index ab2a7e5..be1e0f6 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -12,6 +12,7 @@
 #include "test.h"
 #include "testutils.h"
 
+using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
 /**
@@ -52,7 +53,7 @@ private slots:
         query.liveQuery = true;
 
         // 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);
+        auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 0);
     }
@@ -62,8 +63,8 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
-            Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+            Mail mail("sink.dummy.instance1");
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
         }
 
         // Test
@@ -72,7 +73,7 @@ private slots:
         query.liveQuery = true;
 
         // 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);
+        auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_COMPARE(model->rowCount(), 1);
     }
 
@@ -80,8 +81,8 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
-            Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+            Mail mail("sink.dummy.instance1");
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
         }
 
         // Test
@@ -93,7 +94,7 @@ private slots:
         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);
+        auto model = Sink::Store::loadModel<Mail>(query);
 
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);
@@ -125,7 +126,7 @@ private slots:
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_COMPARE(model->rowCount(), 1);
 
-        auto mail = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Mail::Ptr>();
+        auto mail = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>();
         {
             mail->setFolder("folder2");
             Sink::Store::modify<Mail>(*mail).exec().waitForFinished();
@@ -144,9 +145,9 @@ private slots:
         QByteArray id;
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
-            Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
-            Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+            Mail mail("sink.dummy.instance1");
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
 
             Sink::Query query;
             query.resources << "sink.dummy.instance1";
@@ -155,17 +156,17 @@ private slots:
             Sink::Store::synchronize(query).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);
+            auto model = Sink::Store::loadModel<Mail>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
             QVERIFY(model->rowCount() >= 1);
-            id = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Mail::Ptr>()->identifier();
+            id = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>()->identifier();
         }
 
         // Test
         Sink::Query query;
         query.resources << "sink.dummy.instance1";
         query.ids << id;
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
+        auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);
     }
@@ -174,8 +175,8 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
-            Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
+            Folder folder("sink.dummy.instance1");
+            Sink::Store::create<Folder>(folder).exec().waitForFinished();
         }
 
         // Test
@@ -184,9 +185,9 @@ private slots:
         query.liveQuery = true;
 
         // 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::Folder>(query);
+        auto model = Sink::Store::loadModel<Folder>(query);
         QTRY_COMPARE(model->rowCount(), 1);
-        auto folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
+        auto folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Folder::Ptr>();
         QVERIFY(!folderEntity->identifier().isEmpty());
     }
 
@@ -194,8 +195,8 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
-            Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
+            Folder folder("sink.dummy.instance1");
+            Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
             query.resources << "sink.dummy.instance1";
@@ -203,16 +204,16 @@ private slots:
             // Ensure all local data is processed
             Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
 
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
+            auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
             QCOMPARE(model->rowCount(), 1);
 
-            auto folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
+            auto folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Folder::Ptr>();
             QVERIFY(!folderEntity->identifier().isEmpty());
 
-            Sink::ApplicationDomain::Folder subfolder("sink.dummy.instance1");
+            Folder subfolder("sink.dummy.instance1");
             subfolder.setProperty("parent", folderEntity->identifier());
-            Sink::Store::create<Sink::ApplicationDomain::Folder>(subfolder).exec().waitForFinished();
+            Sink::Store::create<Folder>(subfolder).exec().waitForFinished();
         }
 
         // Test
@@ -224,7 +225,7 @@ private slots:
         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);
+        auto model = Sink::Store::loadModel<Folder>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);
         model->fetchMore(model->index(0, 0));
@@ -236,30 +237,30 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
+            Mail mail("sink.dummy.instance1");
             mail.setProperty("uid", "test1");
             mail.setProperty("sender", "doe@example.org");
-            Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
         }
 
         {
-            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
+            Mail mail("sink.dummy.instance1");
             mail.setProperty("uid", "test2");
             mail.setProperty("sender", "doe@example.org");
-            Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
         }
 
         // Test
         Sink::Query query;
         query.resources << "sink.dummy.instance1";
         query.liveQuery = false;
-        query += Sink::Query::PropertyFilter("uid", "test1");
+        query.filter<Mail::Uid>("test1");
 
         // Ensure all local data is processed
         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);
+        auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);
     }
@@ -267,10 +268,10 @@ private slots:
     void testMailByFolder()
     {
         // Setup
-        Sink::ApplicationDomain::Folder::Ptr folderEntity;
+        Folder::Ptr folderEntity;
         {
-            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
-            Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
+            Folder folder("sink.dummy.instance1");
+            Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
             query.resources << "sink.dummy.instance1";
@@ -278,29 +279,29 @@ private slots:
             // Ensure all local data is processed
             Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
 
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
+            auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
             QCOMPARE(model->rowCount(), 1);
 
-            folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
+            folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Folder::Ptr>();
             QVERIFY(!folderEntity->identifier().isEmpty());
 
-            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
+            Mail mail("sink.dummy.instance1");
             mail.setProperty("uid", "test1");
             mail.setProperty("folder", folderEntity->identifier());
-            Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+            Sink::Store::create<Mail>(mail).exec().waitForFinished();
         }
 
         // Test
         Sink::Query query;
         query.resources << "sink.dummy.instance1";
-        query += Sink::Query::PropertyFilter("folder", *folderEntity);
+        query.filter<Mail::Folder>(*folderEntity);
 
         // Ensure all local data is processed
         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);
+        auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 1);
     }
@@ -363,10 +364,10 @@ private slots:
     void testMailByFolderSortedByDate()
     {
         // Setup
-        Sink::ApplicationDomain::Folder::Ptr folderEntity;
+        Folder::Ptr folderEntity;
         {
-            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
-            Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
+            Folder folder("sink.dummy.instance1");
+            Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
             query.resources << "sink.dummy.instance1";
@@ -374,71 +375,71 @@ private slots:
             // Ensure all local data is processed
             Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
 
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
+            auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
             QCOMPARE(model->rowCount(), 1);
 
-            folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
+            folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Folder::Ptr>();
             QVERIFY(!folderEntity->identifier().isEmpty());
 
             const auto date = QDateTime(QDate(2015, 7, 7), QTime(12, 0));
             {
-                Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
+                Mail mail("sink.dummy.instance1");
                 mail.setProperty("uid", "testSecond");
                 mail.setProperty("folder", folderEntity->identifier());
                 mail.setProperty("date", date.addDays(-1));
-                Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+                Sink::Store::create<Mail>(mail).exec().waitForFinished();
             }
             {
-                Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
+                Mail mail("sink.dummy.instance1");
                 mail.setProperty("uid", "testLatest");
                 mail.setProperty("folder", folderEntity->identifier());
                 mail.setProperty("date", date);
-                Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+                Sink::Store::create<Mail>(mail).exec().waitForFinished();
             }
             {
-                Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
+                Mail mail("sink.dummy.instance1");
                 mail.setProperty("uid", "testLast");
                 mail.setProperty("folder", folderEntity->identifier());
                 mail.setProperty("date", date.addDays(-2));
-                Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
+                Sink::Store::create<Mail>(mail).exec().waitForFinished();
             }
         }
 
         // Test
         Sink::Query query;
         query.resources << "sink.dummy.instance1";
-        query += Sink::Query::PropertyFilter("folder", *folderEntity);
-        query.sortProperty = "date";
+        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();
 
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
+        auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         // The model is not sorted, but the limited set is sorted, so we can only test for the latest result.
         QCOMPARE(model->rowCount(), 1);
-        QCOMPARE(model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Mail::Ptr>()->getProperty("uid").toByteArray(), QByteArray("testLatest"));
+        QCOMPARE(model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>()->getProperty("uid").toByteArray(), QByteArray("testLatest"));
 
         model->fetchMore(QModelIndex());
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         QCOMPARE(model->rowCount(), 2);
         // We can't make any assumptions about the order of the indexes
-        // QCOMPARE(model->index(1, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Mail::Ptr>()->getProperty("uid").toByteArray(), QByteArray("testSecond"));
+        // QCOMPARE(model->index(1, 0).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>()->getProperty("uid").toByteArray(), QByteArray("testSecond"));
     }
 
     void testReactToNewResource()
     {
         Sink::Query query;
         query.liveQuery = true;
-        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
+        auto model = Sink::Store::loadModel<Folder>(query);
         QTRY_COMPARE(model->rowCount(QModelIndex()), 0);
 
-        auto res = Sink::ApplicationDomain::DummyResource::create("");
+        auto res = DummyResource::create("");
         VERIFYEXEC(Sink::Store::create(res));
-        auto folder = Sink::ApplicationDomain::Folder::create(res.identifier());
+        auto folder = Folder::create(res.identifier());
         VERIFYEXEC(Sink::Store::create(folder));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);