Phase 3 sub-commit 1: ReactiveObject (single-entity twin)
ReactiveObject mirrors ReactiveListModel for a single entity. Loads via GET <baseUrl><source>, stays in sync via Mercure SSE on `topic`, and exposes the entity's JSON keys on a `data` QQmlPropertyMap so QML reads them as `obj.data.title` with bindings that re-evaluate on change. Properties: - source / topic / baseUrl / token (configuration) - data (QQmlPropertyMap*) — entity fields - ready — initial fetch finished - exists — entity present (false on 404 / delete) - pending — at least one optimistic mutation in flight - error invoke(method, path, body, optimistic) is identical in shape to ReactiveListModel.invoke(): apply optimistic to `data`, send the request with an Idempotency-Key, clear `pending` on the matching Mercure echo, roll back on 4xx/5xx or 10s timeout. The rollback restores backed-up values and removes keys we added optimistically. Wired into the QML module; the skeleton builds clean. Used by Phase 3 sub-commit 3's todo edit form. Includes the merged CI trigger change (workflow now runs on `main` branch only, not `dev` — keeps Gitea-runner pressure low while we're iterating on dev). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
336
framework/qml/src/ReactiveObject.cpp
Normal file
336
framework/qml/src/ReactiveObject.cpp
Normal file
@@ -0,0 +1,336 @@
|
||||
#include "ReactiveObject.h"
|
||||
|
||||
#include "MercureClient.h"
|
||||
|
||||
#include <QJsonDocument>
|
||||
#include <QJsonObject>
|
||||
#include <QJsonValue>
|
||||
#include <QNetworkAccessManager>
|
||||
#include <QNetworkReply>
|
||||
#include <QNetworkRequest>
|
||||
#include <QRandomGenerator>
|
||||
#include <QTimer>
|
||||
#include <QUrl>
|
||||
|
||||
namespace PhpQml::Bridge {
|
||||
|
||||
ReactiveObject::ReactiveObject(QObject* parent)
|
||||
: QObject(parent)
|
||||
, m_data(new QQmlPropertyMap(this))
|
||||
, m_nam(new QNetworkAccessManager(this))
|
||||
, m_mercure(new MercureClient(this))
|
||||
{
|
||||
connect(m_mercure, &MercureClient::update,
|
||||
this, &ReactiveObject::onMercureUpdate);
|
||||
}
|
||||
|
||||
ReactiveObject::~ReactiveObject()
|
||||
{
|
||||
qDeleteAll(m_echoTimers);
|
||||
}
|
||||
|
||||
void ReactiveObject::setBaseUrl(const QString& v)
|
||||
{
|
||||
if (m_baseUrl == v) return;
|
||||
m_baseUrl = v;
|
||||
rewireMercure();
|
||||
emit baseUrlChanged();
|
||||
if (!m_source.isEmpty()) refresh();
|
||||
}
|
||||
|
||||
void ReactiveObject::setToken(const QString& v)
|
||||
{
|
||||
if (m_token == v) return;
|
||||
m_token = v;
|
||||
emit tokenChanged();
|
||||
}
|
||||
|
||||
void ReactiveObject::setSource(const QString& v)
|
||||
{
|
||||
if (m_source == v) return;
|
||||
m_source = v;
|
||||
emit sourceChanged();
|
||||
if (!m_baseUrl.isEmpty()) refresh();
|
||||
}
|
||||
|
||||
void ReactiveObject::setTopic(const QString& v)
|
||||
{
|
||||
if (m_topic == v) return;
|
||||
m_topic = v;
|
||||
rewireMercure();
|
||||
emit topicChanged();
|
||||
}
|
||||
|
||||
void ReactiveObject::rewireMercure()
|
||||
{
|
||||
if (m_baseUrl.isEmpty() || m_topic.isEmpty()) return;
|
||||
m_mercure->stop();
|
||||
m_mercure->setHubUrl(m_baseUrl + QStringLiteral("/.well-known/mercure"));
|
||||
m_mercure->setTopic(m_topic);
|
||||
m_mercure->start();
|
||||
}
|
||||
|
||||
void ReactiveObject::refresh()
|
||||
{
|
||||
fetchInitial();
|
||||
}
|
||||
|
||||
void ReactiveObject::fetchInitial()
|
||||
{
|
||||
if (m_baseUrl.isEmpty() || m_source.isEmpty()) return;
|
||||
if (m_pendingFetch) {
|
||||
m_pendingFetch->abort();
|
||||
m_pendingFetch->deleteLater();
|
||||
m_pendingFetch = nullptr;
|
||||
}
|
||||
|
||||
QNetworkRequest req(QUrl(m_baseUrl + m_source));
|
||||
req.setRawHeader("Accept", "application/json");
|
||||
if (!m_token.isEmpty()) {
|
||||
req.setRawHeader("Authorization", "Bearer " + m_token.toUtf8());
|
||||
}
|
||||
req.setTransferTimeout(5000);
|
||||
|
||||
setReady(false);
|
||||
m_pendingFetch = m_nam->get(req);
|
||||
connect(m_pendingFetch, &QNetworkReply::finished,
|
||||
this, &ReactiveObject::onFetchFinished);
|
||||
}
|
||||
|
||||
void ReactiveObject::onFetchFinished()
|
||||
{
|
||||
QNetworkReply* reply = m_pendingFetch;
|
||||
m_pendingFetch = nullptr;
|
||||
if (!reply) return;
|
||||
reply->deleteLater();
|
||||
|
||||
const int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
|
||||
if (reply->error() != QNetworkReply::NoError) {
|
||||
setError(reply->errorString());
|
||||
return;
|
||||
}
|
||||
if (status == 404) {
|
||||
clearData();
|
||||
setExists(false);
|
||||
setError(QString());
|
||||
setReady(true);
|
||||
return;
|
||||
}
|
||||
if (status < 200 || status >= 300) {
|
||||
setError(QStringLiteral("GET %1 returned HTTP %2").arg(m_source).arg(status));
|
||||
return;
|
||||
}
|
||||
|
||||
QJsonParseError err{};
|
||||
const QJsonDocument doc = QJsonDocument::fromJson(reply->readAll(), &err);
|
||||
if (err.error != QJsonParseError::NoError || !doc.isObject()) {
|
||||
setError(QStringLiteral("Initial fetch did not return a JSON object."));
|
||||
return;
|
||||
}
|
||||
|
||||
applyPayload(doc.object());
|
||||
setExists(true);
|
||||
setError(QString());
|
||||
setReady(true);
|
||||
}
|
||||
|
||||
void ReactiveObject::onMercureUpdate(const QString& data, const QString& /*id*/)
|
||||
{
|
||||
QJsonParseError err{};
|
||||
const QJsonDocument doc = QJsonDocument::fromJson(data.toUtf8(), &err);
|
||||
if (err.error != QJsonParseError::NoError || !doc.isObject()) return;
|
||||
const QJsonObject envelope = doc.object();
|
||||
|
||||
const int version = envelope.value(QStringLiteral("version")).toInt();
|
||||
if (m_lastVersion > 0 && version > m_lastVersion + 1) {
|
||||
// gap — re-fetch to recover
|
||||
m_lastVersion = 0;
|
||||
refresh();
|
||||
return;
|
||||
}
|
||||
m_lastVersion = std::max(m_lastVersion, version);
|
||||
|
||||
const QString op = envelope.value(QStringLiteral("op")).toString();
|
||||
const QString key = envelope.value(QStringLiteral("correlationKey")).toString();
|
||||
|
||||
if (op == QStringLiteral("delete")) {
|
||||
clearData();
|
||||
setExists(false);
|
||||
} else if (op == QStringLiteral("upsert") || op == QStringLiteral("replace")) {
|
||||
applyPayload(envelope.value(QStringLiteral("data")).toObject());
|
||||
setExists(true);
|
||||
}
|
||||
|
||||
if (!key.isEmpty()) {
|
||||
const QByteArray k = key.toUtf8();
|
||||
if (m_inFlight.contains(k)) {
|
||||
m_inFlight.remove(k);
|
||||
if (auto* t = m_echoTimers.take(k)) t->deleteLater();
|
||||
if (m_inFlight.isEmpty()) setPending(false);
|
||||
emit commandSucceeded(key, {});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ReactiveObject::applyPayload(const QJsonObject& payload)
|
||||
{
|
||||
for (auto it = payload.constBegin(); it != payload.constEnd(); ++it) {
|
||||
m_data->insert(it.key(), it.value().toVariant());
|
||||
}
|
||||
}
|
||||
|
||||
void ReactiveObject::clearData()
|
||||
{
|
||||
const QStringList keys = m_data->keys();
|
||||
for (const QString& k : keys) {
|
||||
m_data->clear(k);
|
||||
}
|
||||
}
|
||||
|
||||
void ReactiveObject::setReady(bool r)
|
||||
{
|
||||
if (m_ready == r) return;
|
||||
m_ready = r;
|
||||
emit readyChanged();
|
||||
}
|
||||
|
||||
void ReactiveObject::setPending(bool p)
|
||||
{
|
||||
if (m_pending == p) return;
|
||||
m_pending = p;
|
||||
emit pendingChanged();
|
||||
}
|
||||
|
||||
void ReactiveObject::setExists(bool e)
|
||||
{
|
||||
if (m_exists == e) return;
|
||||
m_exists = e;
|
||||
emit existsChanged();
|
||||
}
|
||||
|
||||
void ReactiveObject::setError(const QString& e)
|
||||
{
|
||||
if (m_error == e) return;
|
||||
m_error = e;
|
||||
emit errorChanged();
|
||||
}
|
||||
|
||||
void ReactiveObject::invoke(const QString& method,
|
||||
const QString& path,
|
||||
const QVariant& body,
|
||||
const QVariantMap& optimistic)
|
||||
{
|
||||
if (m_baseUrl.isEmpty()) return;
|
||||
|
||||
const QByteArray key = buildIdempotencyKey();
|
||||
|
||||
InFlight in;
|
||||
for (auto it = optimistic.constBegin(); it != optimistic.constEnd(); ++it) {
|
||||
if (m_data->keys().contains(it.key())) {
|
||||
in.backup.insert(it.key(), m_data->value(it.key()));
|
||||
} else {
|
||||
in.addedKeys << it.key();
|
||||
}
|
||||
m_data->insert(it.key(), it.value());
|
||||
}
|
||||
m_inFlight.insert(key, in);
|
||||
setPending(true);
|
||||
|
||||
QNetworkRequest req(QUrl(m_baseUrl + path));
|
||||
req.setRawHeader("Accept", "application/json");
|
||||
req.setRawHeader("Idempotency-Key", key);
|
||||
if (!m_token.isEmpty()) {
|
||||
req.setRawHeader("Authorization", "Bearer " + m_token.toUtf8());
|
||||
}
|
||||
|
||||
QByteArray bytes;
|
||||
if (body.isValid() && !body.isNull()) {
|
||||
bytes = QJsonDocument(QJsonObject::fromVariantMap(body.toMap())).toJson(QJsonDocument::Compact);
|
||||
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
|
||||
}
|
||||
|
||||
QNetworkReply* reply = nullptr;
|
||||
if (method == QStringLiteral("POST")) {
|
||||
reply = m_nam->post(req, bytes);
|
||||
} else if (method == QStringLiteral("PATCH")) {
|
||||
reply = m_nam->sendCustomRequest(req, "PATCH", bytes);
|
||||
} else if (method == QStringLiteral("DELETE")) {
|
||||
reply = m_nam->deleteResource(req);
|
||||
} else {
|
||||
rollbackOptimistic(key);
|
||||
return;
|
||||
}
|
||||
m_replyToKey.insert(reply, key);
|
||||
connect(reply, &QNetworkReply::finished,
|
||||
this, &ReactiveObject::onCommandReplyFinished);
|
||||
|
||||
auto* t = new QTimer(this);
|
||||
t->setSingleShot(true);
|
||||
t->setInterval(kEchoTimeoutMs);
|
||||
connect(t, &QTimer::timeout, this, [this, key]() {
|
||||
if (!m_inFlight.contains(key)) return;
|
||||
rollbackOptimistic(key);
|
||||
emit commandTimedOut(QString::fromUtf8(key));
|
||||
});
|
||||
t->start();
|
||||
m_echoTimers.insert(key, t);
|
||||
}
|
||||
|
||||
void ReactiveObject::rollbackOptimistic(const QByteArray& key)
|
||||
{
|
||||
auto it = m_inFlight.find(key);
|
||||
if (it == m_inFlight.end()) return;
|
||||
InFlight in = it.value();
|
||||
m_inFlight.erase(it);
|
||||
if (auto* t = m_echoTimers.take(key)) t->deleteLater();
|
||||
|
||||
for (auto bit = in.backup.constBegin(); bit != in.backup.constEnd(); ++bit) {
|
||||
m_data->insert(bit.key(), bit.value());
|
||||
}
|
||||
for (const QString& k : in.addedKeys) {
|
||||
m_data->clear(k);
|
||||
}
|
||||
if (m_inFlight.isEmpty()) setPending(false);
|
||||
}
|
||||
|
||||
void ReactiveObject::onCommandReplyFinished()
|
||||
{
|
||||
auto* reply = qobject_cast<QNetworkReply*>(sender());
|
||||
if (!reply) return;
|
||||
const QByteArray key = m_replyToKey.take(reply);
|
||||
reply->deleteLater();
|
||||
|
||||
const int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
|
||||
if (reply->error() == QNetworkReply::NoError && status >= 200 && status < 300) {
|
||||
// Wait for Mercure echo to clear pending (server's view of truth).
|
||||
return;
|
||||
}
|
||||
|
||||
QJsonParseError err{};
|
||||
const QJsonDocument doc = QJsonDocument::fromJson(reply->readAll(), &err);
|
||||
QVariant problem;
|
||||
if (err.error == QJsonParseError::NoError && doc.isObject()) {
|
||||
problem = doc.object().toVariantMap();
|
||||
}
|
||||
rollbackOptimistic(key);
|
||||
emit commandFailed(QString::fromUtf8(key), status, problem);
|
||||
}
|
||||
|
||||
QByteArray ReactiveObject::buildIdempotencyKey() const
|
||||
{
|
||||
auto* gen = QRandomGenerator::system();
|
||||
quint64 a = gen->generate64();
|
||||
quint64 b = gen->generate64();
|
||||
a = (a & 0xFFFFFFFFFFFF0FFFULL) | 0x0000000000004000ULL;
|
||||
b = (b & 0x3FFFFFFFFFFFFFFFULL) | 0x8000000000000000ULL;
|
||||
return QString::asprintf(
|
||||
"%08llx-%04llx-%04llx-%04llx-%012llx",
|
||||
(unsigned long long) ((a >> 32) & 0xFFFFFFFFULL),
|
||||
(unsigned long long) ((a >> 16) & 0xFFFFULL),
|
||||
(unsigned long long) (a & 0xFFFFULL),
|
||||
(unsigned long long) ((b >> 48) & 0xFFFFULL),
|
||||
(unsigned long long) (b & 0xFFFFFFFFFFFFULL)
|
||||
).toLatin1();
|
||||
}
|
||||
|
||||
} // namespace PhpQml::Bridge
|
||||
136
framework/qml/src/ReactiveObject.h
Normal file
136
framework/qml/src/ReactiveObject.h
Normal file
@@ -0,0 +1,136 @@
|
||||
#pragma once
|
||||
|
||||
#include <QHash>
|
||||
#include <QJsonObject>
|
||||
#include <QObject>
|
||||
#include <QQmlPropertyMap>
|
||||
#include <QString>
|
||||
#include <QtQmlIntegration>
|
||||
|
||||
class QNetworkAccessManager;
|
||||
class QNetworkReply;
|
||||
class QTimer;
|
||||
|
||||
namespace PhpQml::Bridge {
|
||||
|
||||
class MercureClient;
|
||||
|
||||
/// Single-entity twin of ReactiveListModel.
|
||||
///
|
||||
/// Loads via HTTP GET on `source`, then keeps the entity in sync via
|
||||
/// Mercure SSE on `topic`. The entity's JSON keys are exposed as
|
||||
/// QML-bindable properties on `data` (a QQmlPropertyMap), so QML
|
||||
/// reads them as `obj.data.title` etc. and re-evaluates on change.
|
||||
///
|
||||
/// `invoke()` provides optimistic mutations identical in shape to
|
||||
/// ReactiveListModel.invoke(): apply locally + Idempotency-Key + roll
|
||||
/// back on `4xx`/`5xx`/timeout, clear `pending` on the matching
|
||||
/// Mercure echo (PLAN.md §5).
|
||||
class ReactiveObject : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
QML_ELEMENT
|
||||
|
||||
Q_PROPERTY(QString baseUrl READ baseUrl WRITE setBaseUrl NOTIFY baseUrlChanged)
|
||||
Q_PROPERTY(QString token READ token WRITE setToken NOTIFY tokenChanged)
|
||||
Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged)
|
||||
Q_PROPERTY(QString topic READ topic WRITE setTopic NOTIFY topicChanged)
|
||||
Q_PROPERTY(QQmlPropertyMap* data READ data CONSTANT)
|
||||
Q_PROPERTY(bool ready READ ready NOTIFY readyChanged)
|
||||
Q_PROPERTY(bool pending READ pending NOTIFY pendingChanged)
|
||||
Q_PROPERTY(bool exists READ exists NOTIFY existsChanged)
|
||||
Q_PROPERTY(QString error READ error NOTIFY errorChanged)
|
||||
|
||||
public:
|
||||
explicit ReactiveObject(QObject* parent = nullptr);
|
||||
~ReactiveObject() override;
|
||||
|
||||
QString baseUrl() const { return m_baseUrl; }
|
||||
void setBaseUrl(const QString& v);
|
||||
|
||||
QString token() const { return m_token; }
|
||||
void setToken(const QString& v);
|
||||
|
||||
QString source() const { return m_source; }
|
||||
void setSource(const QString& v);
|
||||
|
||||
QString topic() const { return m_topic; }
|
||||
void setTopic(const QString& v);
|
||||
|
||||
QQmlPropertyMap* data() const { return m_data; }
|
||||
bool ready() const noexcept { return m_ready; }
|
||||
bool pending() const noexcept { return m_pending; }
|
||||
bool exists() const noexcept { return m_exists; }
|
||||
QString error() const { return m_error; }
|
||||
|
||||
Q_INVOKABLE void refresh();
|
||||
|
||||
/// Same shape as ReactiveListModel::invoke(). The optimistic diff
|
||||
/// is applied to `data`'s keys; rollback restores the prior values
|
||||
/// on failure.
|
||||
Q_INVOKABLE void invoke(const QString& method,
|
||||
const QString& path,
|
||||
const QVariant& body,
|
||||
const QVariantMap& optimistic);
|
||||
|
||||
signals:
|
||||
void baseUrlChanged();
|
||||
void tokenChanged();
|
||||
void sourceChanged();
|
||||
void topicChanged();
|
||||
void readyChanged();
|
||||
void pendingChanged();
|
||||
void existsChanged();
|
||||
void errorChanged();
|
||||
|
||||
void commandSucceeded(const QString& correlationKey, const QVariant& response);
|
||||
void commandFailed(const QString& correlationKey, int status, const QVariant& problem);
|
||||
void commandTimedOut(const QString& correlationKey);
|
||||
|
||||
private slots:
|
||||
void onFetchFinished();
|
||||
void onMercureUpdate(const QString& data, const QString& id);
|
||||
void onCommandReplyFinished();
|
||||
|
||||
private:
|
||||
void rewireMercure();
|
||||
void fetchInitial();
|
||||
void applyPayload(const QJsonObject& payload);
|
||||
void clearData();
|
||||
|
||||
void setReady(bool r);
|
||||
void setPending(bool p);
|
||||
void setExists(bool e);
|
||||
void setError(const QString& e);
|
||||
|
||||
QByteArray buildIdempotencyKey() const;
|
||||
void rollbackOptimistic(const QByteArray& key);
|
||||
|
||||
QString m_baseUrl;
|
||||
QString m_token;
|
||||
QString m_source;
|
||||
QString m_topic;
|
||||
bool m_ready = false;
|
||||
bool m_pending = false;
|
||||
bool m_exists = false;
|
||||
QString m_error;
|
||||
|
||||
QQmlPropertyMap* m_data = nullptr;
|
||||
QNetworkAccessManager* m_nam = nullptr;
|
||||
QNetworkReply* m_pendingFetch = nullptr;
|
||||
MercureClient* m_mercure = nullptr;
|
||||
|
||||
int m_lastVersion = 0;
|
||||
|
||||
struct InFlight {
|
||||
QHash<QString, QVariant> backup; // pre-mutation values for rollback
|
||||
QStringList addedKeys; // keys we added (need removal on rollback)
|
||||
};
|
||||
QHash<QByteArray, InFlight> m_inFlight;
|
||||
QHash<QNetworkReply*, QByteArray> m_replyToKey;
|
||||
QHash<QByteArray, QTimer*> m_echoTimers;
|
||||
|
||||
static constexpr int kEchoTimeoutMs = 10000;
|
||||
};
|
||||
|
||||
} // namespace PhpQml::Bridge
|
||||
Reference in New Issue
Block a user