9 files changed, 129 insertions, 124 deletions

diff --git a/framework/domain/accountfactory.cpp b/framework/domain/accountfactory.cpp
index 10f01f65..182a0a1d 100644
--- a/framework/domain/accountfactory.cpp
+++ b/framework/domain/accountfactory.cpp
@@ -43,8 +43,8 @@ QString AccountFactory::name() const
 void AccountFactory::setAccountId(const QString &accountId)
 {
     mAccountId = accountId;
-    Sink::Store::fetchOne<Sink::ApplicationDomain::SinkAccount>(Sink::Query::IdentityFilter(accountId.toUtf8()))
-        .then<void, Sink::ApplicationDomain::SinkAccount>([this](const Sink::ApplicationDomain::SinkAccount &account) {
+    Sink::Store::fetchOne<Sink::ApplicationDomain::SinkAccount>(Sink::Query().filter(accountId.toUtf8()))
+        .syncThen<void, Sink::ApplicationDomain::SinkAccount>([this](const Sink::ApplicationDomain::SinkAccount &account) {
             mAccountType = account.getProperty("type").toByteArray();
             loadPackage();
         }).exec();
diff --git a/framework/domain/accountscontroller.cpp b/framework/domain/accountscontroller.cpp
index 2f47fa03..5cb60d0c 100644
--- a/framework/domain/accountscontroller.cpp
+++ b/framework/domain/accountscontroller.cpp
@@ -34,9 +34,9 @@ void AccountsController::createAccount(const QString &accountType)
 {
     auto account = Sink::ApplicationDomain::ApplicationDomainType::createEntity<Sink::ApplicationDomain::SinkAccount>();
     account.setProperty("type", accountType);
-    Sink::Store::create(account).then<void>([]() {},
-    [](int errorCode, const QString &errorMessage) {
-        qWarning() << "Error while creating account: " << errorMessage;
-    })
-    .exec();
+    Sink::Store::create(account).syncThen<void>([](const KAsync::Error &error) {
+        if (error) {
+            qWarning() << "Error while creating account: " << error.errorMessage;
+        }
+    }).exec();
 }
diff --git a/framework/domain/actions/sinkactions.cpp b/framework/domain/actions/sinkactions.cpp
index 921fe748..cc8d324e 100644
--- a/framework/domain/actions/sinkactions.cpp
+++ b/framework/domain/actions/sinkactions.cpp
@@ -28,20 +28,22 @@
 SINK_DEBUG_AREA("sinkactions")
 
 using namespace Kube;
+using namespace Sink;
+using namespace Sink::ApplicationDomain;
 
 static ActionHandlerHelper markAsReadHandler("org.kde.kube.actions.mark-as-read",
     [](Context *context) -> bool {
         return context->property("mail").isValid();
     },
     [](Context *context) {
-        auto mail = context->property("mail").value<Sink::ApplicationDomain::Mail::Ptr>();
+        auto mail = context->property("mail").value<Mail::Ptr>();
         if (!mail) {
             SinkWarning() << "Failed to get the mail mail: " << context->property("mail");
             return;
         }
         mail->setProperty("unread", false);
         SinkLog() << "Mark as read " << mail->identifier();
-        Sink::Store::modify(*mail).exec();
+        Store::modify(*mail).exec();
     }
 );
 
@@ -50,14 +52,14 @@ static ActionHandlerHelper moveToTrashHandler("org.kde.kube.actions.move-to-tras
         return context->property("mail").isValid();
     },
     [](Context *context) {
-        auto mail = context->property("mail").value<Sink::ApplicationDomain::Mail::Ptr>();
+        auto mail = context->property("mail").value<Mail::Ptr>();
         if (!mail) {
             SinkWarning() << "Failed to get the mail mail: " << context->property("mail");
             return;
         }
         mail->setTrash(true);
         SinkLog() << "Move to trash " << mail->identifier();
-        Sink::Store::modify(*mail).exec();
+        Store::modify(*mail).exec();
     }
 );
 
@@ -66,13 +68,13 @@ static ActionHandlerHelper deleteHandler("org.kde.kube.actions.delete",
         return context->property("mail").isValid();
     },
     [](Context *context) {
-        auto mail = context->property("mail").value<Sink::ApplicationDomain::Mail::Ptr>();
+        auto mail = context->property("mail").value<Mail::Ptr>();
         if (!mail) {
             SinkWarning() << "Failed to get the mail mail: " << context->property("mail");
             return;
         }
         SinkLog() << "Remove " << mail->identifier();
-        Sink::Store::remove(*mail).exec();
+        Store::remove(*mail).exec();
     }
 );
 
@@ -81,12 +83,12 @@ static ActionHandlerHelper synchronizeHandler("org.kde.kube.actions.synchronize"
         return true;
     },
     [](Context *context) {
-        if (auto folder = context->property("folder").value<Sink::ApplicationDomain::Folder::Ptr>()) {
+        if (auto folder = context->property("folder").value<Folder::Ptr>()) {
             SinkLog() << "Synchronizing resource " << folder->resourceInstanceIdentifier();
-            Sink::Store::synchronize(Sink::Query::ResourceFilter(folder->resourceInstanceIdentifier())).exec();
+            Store::synchronize(Query().resourceFilter(folder->resourceInstanceIdentifier())).exec();
         } else {
             SinkLog() << "Synchronizing all";
-            Sink::Store::synchronize(Sink::Query()).exec();
+            Store::synchronize(Query()).exec();
         }
     }
 );
@@ -102,17 +104,17 @@ static ActionHandlerHelper sendMailHandler("org.kde.kube.actions.sendmail",
         auto message = context->property("message").value<KMime::Message::Ptr>();
         SinkLog() << "Sending a mail: ";
 
-        Sink::Query query;
-        query += Sink::Query::CapabilityFilter(Sink::ApplicationDomain::ResourceCapabilities::Mail::transport);
-        query += Sink::Query::AccountFilter(accountId);
-        Sink::Store::fetchAll<Sink::ApplicationDomain::SinkResource>(query)
-            .then<void, KAsync::Job<void>, QList<Sink::ApplicationDomain::SinkResource::Ptr>>([=](const QList<Sink::ApplicationDomain::SinkResource::Ptr> &resources) -> KAsync::Job<void> {
+        Query query;
+        query.containsFilter<ApplicationDomain::SinkResource::Capabilities>(ApplicationDomain::ResourceCapabilities::Mail::transport);
+        query.filter<SinkResource::Account>(accountId);
+        Store::fetchAll<ApplicationDomain::SinkResource>(query)
+            .then<void, QList<ApplicationDomain::SinkResource::Ptr>>([=](const QList<ApplicationDomain::SinkResource::Ptr> &resources) -> KAsync::Job<void> {
                 if (!resources.isEmpty()) {
                     auto resourceId = resources[0]->identifier();
                     SinkTrace() << "Sending message via resource: " << resourceId;
-                    Sink::ApplicationDomain::Mail mail(resourceId);
+                    Mail mail(resourceId);
                     mail.setBlobProperty("mimeMessage", message->encodedContent());
-                    return Sink::Store::create(mail);
+                    return Store::create(mail);
                 }
                 SinkWarning() << "Failed to find a mailtransport resource";
                 return KAsync::error<void>(0, "Failed to find a MailTransport resource.");
@@ -127,30 +129,30 @@ static ActionHandlerHelper saveAsDraft("org.kde.kube.actions.save-as-draft",
         return !accountId.isEmpty() && message;
     },
     ActionHandlerHelper::JobHandler([](Context *context) -> KAsync::Job<void> {
-        SinkWarning() << "executing save as draft";
+        SinkLog() << "Executing the save-as-draft action";
         const auto accountId = context->property("accountId").value<QByteArray>();
         const auto message = context->property("message").value<KMime::Message::Ptr>();
-        auto existingMail = context->property("existingMail").value<Sink::ApplicationDomain::Mail>();
+        auto existingMail = context->property("existingMail").value<Mail>();
         if (!message) {
             SinkWarning() << "Failed to get the mail: " << context->property("mail");
             return KAsync::error<void>(1, "Failed to get the mail: " + context->property("mail").toString());
         }
 
         if (existingMail.identifier().isEmpty()) {
-            Sink::Query query;
-            query += Sink::Query::CapabilityFilter(Sink::ApplicationDomain::ResourceCapabilities::Mail::drafts);
-            query += Sink::Query::AccountFilter(accountId);
-            return Sink::Store::fetchOne<Sink::ApplicationDomain::SinkResource>(query)
-                .then<void, KAsync::Job<void>, Sink::ApplicationDomain::SinkResource>([=](const Sink::ApplicationDomain::SinkResource &resource) -> KAsync::Job<void> {
-                    Sink::ApplicationDomain::Mail mail(resource.identifier());
-                    mail.setProperty("draft", true);
-                    mail.setBlobProperty("mimeMessage", message->encodedContent());
-                    return Sink::Store::create(mail);
+            Query query;
+            query.containsFilter<SinkResource::Capabilities>(ApplicationDomain::ResourceCapabilities::Mail::drafts);
+            query.filter<SinkResource::Account>(accountId);
+            return Store::fetchOne<SinkResource>(query)
+                .then<void, SinkResource>([=](const SinkResource &resource) -> KAsync::Job<void> {
+                    Mail mail(resource.identifier());
+                    mail.setDraft(true);
+                    mail.setMimeMessage(message->encodedContent());
+                    return Store::create(mail);
                 });
         } else {
             SinkWarning() << "Modifying an existing mail" << existingMail.identifier();
-            existingMail.setBlobProperty("mimeMessage", message->encodedContent());
-            return Sink::Store::modify(existingMail);
+            existingMail.setMimeMessage(message->encodedContent());
+            return Store::modify(existingMail);
         }
     })
 );
diff --git a/framework/domain/composercontroller.cpp b/framework/domain/composercontroller.cpp
index 2dcf1bb1..b2ad7ecc 100644
--- a/framework/domain/composercontroller.cpp
+++ b/framework/domain/composercontroller.cpp
@@ -133,7 +133,7 @@ void ComposerController::loadMessage(const QVariant &message, bool loadAsDraft)
 {
     Sink::Query query(*message.value<Sink::ApplicationDomain::Mail::Ptr>());
     query.request<Sink::ApplicationDomain::Mail::MimeMessage>();
-    Sink::Store::fetchOne<Sink::ApplicationDomain::Mail>(query).then<void, Sink::ApplicationDomain::Mail>([this, loadAsDraft](const Sink::ApplicationDomain::Mail &mail) {
+    Sink::Store::fetchOne<Sink::ApplicationDomain::Mail>(query).syncThen<void, Sink::ApplicationDomain::Mail>([this, loadAsDraft](const Sink::ApplicationDomain::Mail &mail) {
         m_existingMail = mail;
         const auto mailData = KMime::CRLFtoLF(mail.getMimeMessage());
         if (!mailData.isEmpty()) {
diff --git a/framework/domain/folderlistmodel.cpp b/framework/domain/folderlistmodel.cpp
index 14d3d5a7..7cf5ad5d 100644
--- a/framework/domain/folderlistmodel.cpp
+++ b/framework/domain/folderlistmodel.cpp
@@ -22,11 +22,14 @@
 #include <sink/store.h>
 #include <settings/settings.h>
 
+using namespace Sink;
+using namespace Sink::ApplicationDomain;
+
 FolderListModel::FolderListModel(QObject *parent) : QIdentityProxyModel()
 {
-    Sink::Query query;
+    Query query;
     query.liveQuery = true;
-    query.requestedProperties << "name" << "icon" << "parent";
+    query.request<Folder::Name>().request<Folder::Icon>().request<Folder::Parent>();
     query.parentProperty = "parent";
     runQuery(query);
 }
@@ -57,34 +60,32 @@ QVariant FolderListModel::data(const QModelIndex &idx, int role) const
         case Icon:
             return srcIdx.sibling(srcIdx.row(), 1).data(Qt::DisplayRole).toString();
         case Id:
-            return srcIdx.data(Sink::Store::DomainObjectBaseRole).value<Sink::ApplicationDomain::ApplicationDomainType::Ptr>()->identifier();
+            return srcIdx.data(Store::DomainObjectBaseRole).value<ApplicationDomainType::Ptr>()->identifier();
         case DomainObject:
-            return srcIdx.data(Sink::Store::DomainObjectRole);
+            return srcIdx.data(Store::DomainObjectRole);
     }
     return QIdentityProxyModel::data(idx, role);
 }
 
-void FolderListModel::runQuery(const Sink::Query &query)
+void FolderListModel::runQuery(const Query &query)
 {
-    mModel = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
+    mModel = Store::loadModel<Folder>(query);
     setSourceModel(mModel.data());
 }
 
 void FolderListModel::setAccountId(const QVariant &accountId)
 {
     const auto account = accountId.toString().toUtf8();
-    Sink::Store::fetchAll<Sink::ApplicationDomain::SinkResource>(Sink::Query::PropertyFilter("account", QVariant::fromValue(account)))
-        .then<void, QList<Sink::ApplicationDomain::SinkResource::Ptr>>([this, account](const QList<Sink::ApplicationDomain::SinkResource::Ptr> &resources) {
-            Sink::Query query;
-            query.liveQuery = true;
-            query.requestedProperties << "name" << "icon" << "parent";
-            query.parentProperty = "parent";
-            for (const auto &r : resources) {
-                qDebug() << "Found resources for account: " << r->identifier() << account;
-                query.resources << r->identifier();
-            }
-            runQuery(query);
-        }).exec();
+
+    //Get all folders of an account
+    auto query = Query();
+    query.resourceFilter<SinkResource::Account>(account);
+    query.liveQuery = true;
+    query.request<Folder::Name>()
+         .request<Folder::Icon>()
+         .request<Folder::Parent>();
+    query.parentProperty = Folder::Parent::name;
+    runQuery(query);
 }
 
 QVariant FolderListModel::accountId() const
diff --git a/framework/domain/identitiesmodel.cpp b/framework/domain/identitiesmodel.cpp
index adb5d625..1958d2f5 100644
--- a/framework/domain/identitiesmodel.cpp
+++ b/framework/domain/identitiesmodel.cpp
@@ -83,7 +83,7 @@ void IdentitiesModel::runQuery(const Sink::Query &query)
     setSourceModel(mModel.data());
 
     Sink::Store::fetchAll<Sink::ApplicationDomain::SinkAccount>(Sink::Query())
-        .then<void, QList<Sink::ApplicationDomain::SinkAccount::Ptr> >([this](const QList<Sink::ApplicationDomain::SinkAccount::Ptr> &accounts) {
+        .syncThen<void, QList<Sink::ApplicationDomain::SinkAccount::Ptr> >([this](const QList<Sink::ApplicationDomain::SinkAccount::Ptr> &accounts) {
             for (const auto &account : accounts) {
                 mAccountNames.insert(account->identifier(), account->getProperty("name").toString());
                 mAccountIcons.insert(account->identifier(), account->getProperty("icon").toString());
diff --git a/framework/domain/maillistmodel.cpp b/framework/domain/maillistmodel.cpp
index e3f555c4..9afb6408 100644
--- a/framework/domain/maillistmodel.cpp
+++ b/framework/domain/maillistmodel.cpp
@@ -107,7 +107,7 @@ void MailListModel::setParentFolder(const QVariant &parentFolder)
     }
     Sink::Query query;
     query.liveQuery = true;
-    query.resources << folder->resourceInstanceIdentifier();
+    query.resourceFilter(folder->resourceInstanceIdentifier());
     query.sort<Mail::Date>();
     query.limit = 100;
     query.request<Mail::Subject>();
diff --git a/framework/domain/messageparser.cpp b/framework/domain/messageparser.cpp
index 262be0b7..febd1363 100644
--- a/framework/domain/messageparser.cpp
+++ b/framework/domain/messageparser.cpp
@@ -101,7 +101,8 @@ QVariant PartModel::data(const QModelIndex &index, int role) const
             case Type:
                 return part->metaObject()->className();
             case IsHidden:
-                return part->property("isHidden").toBool();
+                return false;
+                //return part->property("isHidden").toBool();
 
         }
     }
diff --git a/framework/domain/settings/accountsettings.cpp b/framework/domain/settings/accountsettings.cpp
index cf348f39..ea798a73 100644
--- a/framework/domain/settings/accountsettings.cpp
+++ b/framework/domain/settings/accountsettings.cpp
@@ -23,6 +23,9 @@
 #include <QDir>
 #include <QUrl>
 
+using namespace Sink;
+using namespace Sink::ApplicationDomain;
+
 AccountSettings::AccountSettings(QObject *parent)
     : QObject(parent)
 {
@@ -130,87 +133,83 @@ void AccountSettings::saveAccount()
 {
     qDebug() << "Saving account " << mAccountIdentifier << mMailtransportIdentifier;
     Q_ASSERT(!mAccountIdentifier.isEmpty());
-    Sink::ApplicationDomain::SinkAccount account(mAccountIdentifier);
-    account.setProperty("type", "imap");
-    account.setProperty("name", mName);
-    account.setProperty("icon", mIcon);
+    SinkAccount account(mAccountIdentifier);
+    account.setAccountType("imap");
+    account.setName(mName);
+    account.setIcon(mIcon);
     Q_ASSERT(!account.identifier().isEmpty());
-    Sink::Store::modify(account).then<void>([]() {},
-    [](int errorCode, const QString &errorMessage) {
-        qWarning() << "Error while creating account: " << errorMessage;
-    })
-    .exec();
+    Store::modify(account)
+        .onError([](const KAsync::Error &error) {
+            qWarning() << "Error while creating account: " << error.errorMessage;;
+        })
+        .exec();
 }
 
 void AccountSettings::loadAccount()
 {
     Q_ASSERT(!mAccountIdentifier.isEmpty());
-    Sink::Store::fetchOne<Sink::ApplicationDomain::SinkAccount>(Sink::Query::IdentityFilter(mAccountIdentifier))
-        .then<void, Sink::ApplicationDomain::SinkAccount>([this](const Sink::ApplicationDomain::SinkAccount &account) {
-            mIcon = account.getProperty("icon").toString();
-            mName = account.getProperty("name").toString();
+    Store::fetchOne<SinkAccount>(Query().filter(mAccountIdentifier))
+        .syncThen<void, SinkAccount>([this](const SinkAccount &account) {
+            mIcon = account.getIcon();
+            mName = account.getName();
             emit changed();
         }).exec();
 }
 
 void AccountSettings::loadImapResource()
 {
-    Sink::Store::fetchOne<Sink::ApplicationDomain::SinkResource>(Sink::Query::AccountFilter(mAccountIdentifier) + Sink::Query::CapabilityFilter(Sink::ApplicationDomain::ResourceCapabilities::Mail::storage))
-        .then<void, Sink::ApplicationDomain::SinkResource>([this](const Sink::ApplicationDomain::SinkResource &resource) {
+    Store::fetchOne<SinkResource>(Query().filter<SinkResource::Account>(mAccountIdentifier).containsFilter<SinkResource::Capabilities>(ResourceCapabilities::Mail::storage))
+        .syncThen<void, SinkResource>([this](const SinkResource &resource) {
             mImapIdentifier = resource.identifier();
             mImapServer = resource.getProperty("server").toString();
             mImapUsername = resource.getProperty("username").toString();
             mImapPassword = resource.getProperty("password").toString();
             emit imapResourceChanged();
-        },
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Failed to find the imap resource: " << errorMessage;
+        }).onError([](const KAsync::Error &error) {
+            qWarning() << "Failed to find the imap resource: " << error.errorMessage;
         }).exec();
 }
 
 void AccountSettings::loadMaildirResource()
 {
-    Sink::Store::fetchOne<Sink::ApplicationDomain::SinkResource>(Sink::Query::AccountFilter(mAccountIdentifier) + Sink::Query::CapabilityFilter(Sink::ApplicationDomain::ResourceCapabilities::Mail::storage))
-        .then<void, Sink::ApplicationDomain::SinkResource>([this](const Sink::ApplicationDomain::SinkResource &resource) {
+    Store::fetchOne<SinkResource>(Query().filter<SinkResource::Account>(mAccountIdentifier).containsFilter<SinkResource::Capabilities>(ResourceCapabilities::Mail::storage))
+        .syncThen<void, SinkResource>([this](const SinkResource &resource) {
             mMaildirIdentifier = resource.identifier();
             auto path = resource.getProperty("path").toString();
             if (mPath != path) {
                 mPath = path;
                 emit pathChanged();
             }
-        },
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Failed to find the maildir resource: " << errorMessage;
+        }).onError([](const KAsync::Error &error) {
+            qWarning() << "Failed to find the maildir resource: " << error.errorMessage;
         }).exec();
 }
 
 void AccountSettings::loadMailtransportResource()
 {
-    Sink::Store::fetchOne<Sink::ApplicationDomain::SinkResource>(Sink::Query::AccountFilter(mAccountIdentifier) + Sink::Query::CapabilityFilter(Sink::ApplicationDomain::ResourceCapabilities::Mail::transport))
-        .then<void, Sink::ApplicationDomain::SinkResource>([this](const Sink::ApplicationDomain::SinkResource &resource) {
+    Store::fetchOne<SinkResource>(Query().filter<SinkResource::Account>(mAccountIdentifier).containsFilter<SinkResource::Capabilities>(ResourceCapabilities::Mail::transport))
+        .syncThen<void, SinkResource>([this](const SinkResource &resource) {
             mMailtransportIdentifier = resource.identifier();
             mSmtpServer = resource.getProperty("server").toString();
             mSmtpUsername = resource.getProperty("username").toString();
             mSmtpPassword = resource.getProperty("password").toString();
             emit smtpResourceChanged();
-        },
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Failed to find the smtp resource: " << errorMessage;
+        }).onError([](const KAsync::Error &error) {
+            qWarning() << "Failed to find the smtp resource: " << error.errorMessage;
         }).exec();
 }
 
 void AccountSettings::loadIdentity()
 {
     //FIXME this assumes that we only ever have one identity per account
-    Sink::Store::fetchOne<Sink::ApplicationDomain::Identity>(Sink::Query::AccountFilter(mAccountIdentifier))
-        .then<void, Sink::ApplicationDomain::Identity>([this](const Sink::ApplicationDomain::Identity &identity) {
+    Store::fetchOne<Identity>(Query().filter<Identity::Account>(mAccountIdentifier))
+        .syncThen<void, Identity>([this](const Identity &identity) {
             mIdentityIdentifier = identity.identifier();
             mUsername = identity.getProperty("username").toString();
             mEmailAddress = identity.getProperty("address").toString();
             emit identityChanged();
-        },
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Failed to find the identity resource: " << errorMessage;
+        }).onError([](const KAsync::Error &error) {
+            qWarning() << "Failed to find the identity resource: " << error.errorMessage;
         }).exec();
 }
 
@@ -220,25 +219,26 @@ template<typename ResourceType>
 static QByteArray saveResource(const QByteArray &accountIdentifier, const QByteArray &identifier, const std::map<QByteArray, QVariant> &properties)
 {
     if (!identifier.isEmpty()) {
-        Sink::ApplicationDomain::SinkResource resource(identifier);
+        SinkResource resource(identifier);
         for (const auto &pair : properties) {
             resource.setProperty(pair.first, pair.second);
         }
-        Sink::Store::modify(resource).then<void>([](){}, [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Error while modifying resource: " << errorMessage;
-        })
-        .exec();
+        Store::modify(resource)
+            .onError([](const KAsync::Error &error) {
+                qWarning() << "Error while modifying resource: " << error.errorMessage;
+            })
+            .exec();
     } else {
         auto resource = ResourceType::create(accountIdentifier);
         auto newIdentifier = resource.identifier();
         for (const auto &pair : properties) {
             resource.setProperty(pair.first, pair.second);
         }
-        Sink::Store::create(resource).template then<void>([]() {},
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Error while creating resource: " << errorMessage;
-        })
-        .exec();
+        Store::create(resource)
+            .onError([](const KAsync::Error &error) {
+                qWarning() << "Error while creating resource: " << error.errorMessage;
+            })
+            .exec();
         return newIdentifier;
     }
     return identifier;
@@ -246,7 +246,7 @@ static QByteArray saveResource(const QByteArray &accountIdentifier, const QByteA
 
 void AccountSettings::saveImapResource()
 {
-    mImapIdentifier = saveResource<Sink::ApplicationDomain::ImapResource>(mAccountIdentifier, mImapIdentifier, {
+    mImapIdentifier = saveResource<ImapResource>(mAccountIdentifier, mImapIdentifier, {
             {"server", mImapServer},
             {"username", mImapUsername},
             {"password", mImapPassword},
@@ -255,14 +255,14 @@ void AccountSettings::saveImapResource()
 
 void AccountSettings::saveMaildirResource()
 {
-    mMaildirIdentifier = saveResource<Sink::ApplicationDomain::MaildirResource>(mAccountIdentifier, mMaildirIdentifier, {
+    mMaildirIdentifier = saveResource<MaildirResource>(mAccountIdentifier, mMaildirIdentifier, {
             {"path", mPath},
         });
 }
 
 void AccountSettings::saveMailtransportResource()
 {
-    mMailtransportIdentifier = saveResource<Sink::ApplicationDomain::MailtransportResource>(mAccountIdentifier, mMailtransportIdentifier, {
+    mMailtransportIdentifier = saveResource<MailtransportResource>(mAccountIdentifier, mMailtransportIdentifier, {
             {"server", mSmtpServer},
             {"username", mSmtpUsername},
             {"password", mSmtpPassword},
@@ -272,22 +272,23 @@ void AccountSettings::saveMailtransportResource()
 void AccountSettings::saveIdentity()
 {
     if (!mIdentityIdentifier.isEmpty()) {
-        Sink::ApplicationDomain::Identity identity(mMailtransportIdentifier);
+        Identity identity(mMailtransportIdentifier);
         identity.setProperty("username", mUsername);
         identity.setProperty("address", mEmailAddress);
-        Sink::Store::modify(identity).then<void>([](){}, [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Error while modifying identity: " << errorMessage;
+        Store::modify(identity)
+        .onError([](const KAsync::Error &error) {
+            qWarning() << "Error while modifying identity: " << error.errorMessage;
         })
         .exec();
     } else {
-        auto identity = Sink::ApplicationDomain::ApplicationDomainType::createEntity<Sink::ApplicationDomain::Identity>();
+        auto identity = ApplicationDomainType::createEntity<Identity>();
         mIdentityIdentifier = identity.identifier();
-        identity.setProperty("account", mAccountIdentifier);
+        identity.setAccount(mAccountIdentifier);
         identity.setProperty("username", mUsername);
         identity.setProperty("address", mEmailAddress);
-        Sink::Store::create(identity).then<void>([]() {},
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Error while creating identity: " << errorMessage;
+        Store::create(identity)
+        .onError([](const KAsync::Error &error) {
+            qWarning() << "Error while creating identity: " << error.errorMessage;
         })
         .exec();
     }
@@ -298,10 +299,10 @@ void AccountSettings::removeResource(const QByteArray &identifier)
     if (identifier.isEmpty()) {
         qWarning() << "We're missing an identifier";
     } else {
-        Sink::ApplicationDomain::SinkResource resource("", identifier, 0, QSharedPointer<Sink::ApplicationDomain::MemoryBufferAdaptor>::create());
-        Sink::Store::remove(resource).template then<void>([]() {},
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Error while removing resource: " << errorMessage;
+        SinkResource resource(identifier);
+        Store::remove(resource)
+        .onError([](const KAsync::Error &error) {
+            qWarning() << "Error while removing resource: " << error.errorMessage;
         })
         .exec();
     }
@@ -312,10 +313,10 @@ void AccountSettings::removeAccount()
     if (mAccountIdentifier.isEmpty()) {
         qWarning() << "We're missing an identifier";
     } else {
-        Sink::ApplicationDomain::SinkAccount account("", mAccountIdentifier, 0, QSharedPointer<Sink::ApplicationDomain::MemoryBufferAdaptor>::create());
-        Sink::Store::remove(account).then<void>([]() {},
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Error while removing account: " << errorMessage;
+        SinkAccount account(mAccountIdentifier);
+        Store::remove(account)
+        .onError([](const KAsync::Error &error) {
+            qWarning() << "Error while removing account: " << error.errorMessage;
         })
         .exec();
     }
@@ -326,10 +327,10 @@ void AccountSettings::removeIdentity()
     if (mIdentityIdentifier.isEmpty()) {
         qWarning() << "We're missing an identifier";
     } else {
-        Sink::ApplicationDomain::Identity identity("", mIdentityIdentifier, 0, QSharedPointer<Sink::ApplicationDomain::MemoryBufferAdaptor>::create());
-        Sink::Store::remove(identity).then<void>([]() {},
-        [](int errorCode, const QString &errorMessage) {
-            qWarning() << "Error while removing identity: " << errorMessage;
+        Identity identity(mIdentityIdentifier);
+        Store::remove(identity)
+        .onError([](const KAsync::Error &error) {
+            qWarning() << "Error while removing identity: " << error.errorMessage;
         })
         .exec();
     }