src/paimon/rest/rest_messages.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "paimon/rest/rest_messages.h"

#include <stdexcept>

#include "paimon/rest/rest_util.h"

namespace paimon {

namespace {

constexpr const char kFieldMessage[] = "message";
constexpr const char kFieldResourceType[] = "resourceType";
constexpr const char kFieldResourceName[] = "resourceName";
constexpr const char kFieldCode[] = "code";
constexpr const char kFieldDefaults[] = "defaults";
constexpr const char kFieldOverrides[] = "overrides";
constexpr const char kFieldOwner[] = "owner";
constexpr const char kFieldCreatedAt[] = "createdAt";
constexpr const char kFieldCreatedBy[] = "createdBy";
constexpr const char kFieldUpdatedAt[] = "updatedAt";
constexpr const char kFieldUpdatedBy[] = "updatedBy";
constexpr const char kFieldName[] = "name";
constexpr const char kFieldOptions[] = "options";
constexpr const char kFieldId[] = "id";
constexpr const char kFieldLocation[] = "location";
constexpr const char kFieldDatabases[] = "databases";
constexpr const char kFieldTables[] = "tables";
constexpr const char kFieldSnapshots[] = "snapshots";
constexpr const char kFieldNextPageToken[] = "nextPageToken";
constexpr const char kFieldPath[] = "path";
constexpr const char kFieldIsExternal[] = "isExternal";
constexpr const char kFieldSchemaId[] = "schemaId";
constexpr const char kFieldSchema[] = "schema";
constexpr const char kFieldIdentifier[] = "identifier";
constexpr const char kFieldDatabase[] = "database";
constexpr const char kFieldObject[] = "object";
constexpr const char kFieldSource[] = "source";
constexpr const char kFieldDestination[] = "destination";
constexpr const char kFieldSuccess[] = "success";
constexpr const char kFieldSnapshot[] = "snapshot";
constexpr const char kFieldToken[] = "token";
constexpr const char kFieldExpiresAtMillis[] = "expiresAtMillis";
constexpr const char kFieldTableId[] = "tableId";
constexpr const char kFieldCommitUser[] = "commitUser";
constexpr const char kFieldAcquired[] = "acquired";
constexpr const char kFieldLeaseMillis[] = "leaseMillis";

void AddOptionalStringMember(rapidjson::Value* obj, const char* key,
                             const std::optional<std::string>& value,
                             rapidjson::Document::AllocatorType* allocator) {
    if (value) {
        obj->AddMember(rapidjson::StringRef(key),
                       RapidJsonUtil::SerializeValue(value.value(), allocator).Move(), *allocator);
    }
}

rapidjson::Value SerializeIdentifier(const std::string& database, const std::string& table,
                                     rapidjson::Document::AllocatorType* allocator) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldDatabase),
                  RapidJsonUtil::SerializeValue(database, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldObject),
                  RapidJsonUtil::SerializeValue(table, allocator).Move(), *allocator);
    return obj;
}

void DeserializeIdentifier(const rapidjson::Value& obj, const char* key, std::string* database,
                           std::string* table) {
    if (!obj.IsObject() || !obj.HasMember(key) || !obj[key].IsObject()) {
        throw std::invalid_argument(std::string("member '") + key +
                                    "' must exist and be an object");
    }
    const rapidjson::Value& identifier = obj[key];
    *database = RapidJsonUtil::DeserializeKeyValue<std::string>(identifier, kFieldDatabase);
    *table = RapidJsonUtil::DeserializeKeyValue<std::string>(identifier, kFieldObject);
}

std::string DeserializeRawJsonMember(const rapidjson::Value& obj, const char* key) {
    if (!obj.IsObject() || !obj.HasMember(key) || !obj[key].IsObject()) {
        throw std::invalid_argument(std::string("member '") + key +
                                    "' must exist and be an object");
    }
    return RestUtil::JsonToString(obj[key]);
}

}  // namespace

rapidjson::Value ErrorResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldMessage),
                  RapidJsonUtil::SerializeValue(message_, allocator).Move(), *allocator);
    if (!resource_type_.empty()) {
        obj.AddMember(rapidjson::StringRef(kFieldResourceType),
                      RapidJsonUtil::SerializeValue(resource_type_, allocator).Move(), *allocator);
    }
    if (!resource_name_.empty()) {
        obj.AddMember(rapidjson::StringRef(kFieldResourceName),
                      RapidJsonUtil::SerializeValue(resource_name_, allocator).Move(), *allocator);
    }
    obj.AddMember(rapidjson::StringRef(kFieldCode),
                  RapidJsonUtil::SerializeValue(code_, allocator).Move(), *allocator);
    return obj;
}

void ErrorResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    message_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldMessage, std::string());
    resource_type_ =
        RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldResourceType, std::string());
    resource_name_ =
        RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldResourceName, std::string());
    code_ = RapidJsonUtil::DeserializeKeyValue<int32_t>(obj, kFieldCode, 0);
}

rapidjson::Value ConfigResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldDefaults),
                  RapidJsonUtil::SerializeValue(defaults_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldOverrides),
                  RapidJsonUtil::SerializeValue(overrides_, allocator).Move(), *allocator);
    return obj;
}

namespace {
// The server may send null values in `defaults`/`overrides`; a null carries no value to
// merge, so it is collected in `null_keys` (when given) instead of failing the parse.
std::map<std::string, std::string> DeserializeStringMap(const rapidjson::Value& obj,
                                                        const char* key,
                                                        std::set<std::string>* null_keys) {
    std::map<std::string, std::string> result;
    if (!obj.IsObject() || !obj.HasMember(key) || obj[key].IsNull()) {
        return result;
    }
    const rapidjson::Value& map_value = obj[key];
    if (!map_value.IsObject()) {
        throw std::invalid_argument(std::string("member '") + key + "' must be an object");
    }
    for (auto iter = map_value.MemberBegin(); iter != map_value.MemberEnd(); ++iter) {
        if (iter->value.IsNull()) {
            if (null_keys != nullptr) {
                null_keys->insert(iter->name.GetString());
            }
            continue;
        }
        if (!iter->value.IsString()) {
            throw std::invalid_argument(std::string("member '") + key +
                                        "' must only contain string values");
        }
        result[iter->name.GetString()] = iter->value.GetString();
    }
    return result;
}
}  // namespace

void ConfigResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    removed_keys_.clear();
    // A null default carries no value and never unsets anything; only a null override
    // removes a key.
    defaults_ = DeserializeStringMap(obj, kFieldDefaults, nullptr);
    overrides_ = DeserializeStringMap(obj, kFieldOverrides, &removed_keys_);
}

std::map<std::string, std::string> ConfigResponse::Merge(
    const std::map<std::string, std::string>& client_options) const {
    std::map<std::string, std::string> merged = defaults_;
    for (const auto& [key, value] : client_options) {
        merged[key] = value;
    }
    for (const auto& [key, value] : overrides_) {
        merged[key] = value;
    }
    for (const std::string& key : removed_keys_) {
        merged.erase(key);
    }
    return merged;
}

void RestAuditFields::ParseFrom(const rapidjson::Value& obj) {
    owner = RapidJsonUtil::DeserializeKeyValue<std::optional<std::string>>(obj, kFieldOwner,
                                                                           std::nullopt);
    created_at = RapidJsonUtil::DeserializeKeyValue<std::optional<int64_t>>(obj, kFieldCreatedAt,
                                                                            std::nullopt);
    created_by = RapidJsonUtil::DeserializeKeyValue<std::optional<std::string>>(
        obj, kFieldCreatedBy, std::nullopt);
    updated_at = RapidJsonUtil::DeserializeKeyValue<std::optional<int64_t>>(obj, kFieldUpdatedAt,
                                                                            std::nullopt);
    updated_by = RapidJsonUtil::DeserializeKeyValue<std::optional<std::string>>(
        obj, kFieldUpdatedBy, std::nullopt);
}

void RestAuditFields::AddTo(rapidjson::Value* obj,
                            rapidjson::Document::AllocatorType* allocator) const {
    AddOptionalStringMember(obj, kFieldOwner, owner, allocator);
    if (created_at) {
        obj->AddMember(rapidjson::StringRef(kFieldCreatedAt),
                       RapidJsonUtil::SerializeValue(created_at.value(), allocator).Move(),
                       *allocator);
    }
    AddOptionalStringMember(obj, kFieldCreatedBy, created_by, allocator);
    if (updated_at) {
        obj->AddMember(rapidjson::StringRef(kFieldUpdatedAt),
                       RapidJsonUtil::SerializeValue(updated_at.value(), allocator).Move(),
                       *allocator);
    }
    AddOptionalStringMember(obj, kFieldUpdatedBy, updated_by, allocator);
}

void RestAuditFields::PutAuditOptionsTo(std::map<std::string, std::string>* options) const {
    if (owner) {
        (*options)[kFieldOwner] = owner.value();
    }
    if (created_at) {
        (*options)[kFieldCreatedAt] = std::to_string(created_at.value());
    }
    if (created_by) {
        (*options)[kFieldCreatedBy] = created_by.value();
    }
    if (updated_at) {
        (*options)[kFieldUpdatedAt] = std::to_string(updated_at.value());
    }
    if (updated_by) {
        (*options)[kFieldUpdatedBy] = updated_by.value();
    }
}

rapidjson::Value CreateDatabaseRequest::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldName),
                  RapidJsonUtil::SerializeValue(name_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldOptions),
                  RapidJsonUtil::SerializeValue(options_, allocator).Move(), *allocator);
    return obj;
}

void CreateDatabaseRequest::FromJson(const rapidjson::Value& obj) noexcept(false) {
    name_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldName);
    options_ = RapidJsonUtil::DeserializeKeyValue<std::map<std::string, std::string>>(
        obj, kFieldOptions, {});
}

rapidjson::Value GetDatabaseResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldId),
                  RapidJsonUtil::SerializeValue(id_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldName),
                  RapidJsonUtil::SerializeValue(name_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldLocation),
                  RapidJsonUtil::SerializeValue(location_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldOptions),
                  RapidJsonUtil::SerializeValue(options_, allocator).Move(), *allocator);
    audit_.AddTo(&obj, allocator);
    return obj;
}

void GetDatabaseResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    id_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldId, std::string());
    name_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldName);
    location_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldLocation, std::string());
    options_ = RapidJsonUtil::DeserializeKeyValue<std::map<std::string, std::string>>(
        obj, kFieldOptions, {});
    audit_.ParseFrom(obj);
}

rapidjson::Value ListDatabasesResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldDatabases),
                  RapidJsonUtil::SerializeValue(databases_, allocator).Move(), *allocator);
    AddOptionalStringMember(&obj, kFieldNextPageToken, next_page_token_, allocator);
    return obj;
}

void ListDatabasesResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    databases_ =
        RapidJsonUtil::DeserializeKeyValue<std::vector<std::string>>(obj, kFieldDatabases, {});
    next_page_token_ = RapidJsonUtil::DeserializeKeyValue<std::optional<std::string>>(
        obj, kFieldNextPageToken, std::nullopt);
}

rapidjson::Value ListTablesResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldTables),
                  RapidJsonUtil::SerializeValue(tables_, allocator).Move(), *allocator);
    AddOptionalStringMember(&obj, kFieldNextPageToken, next_page_token_, allocator);
    return obj;
}

void ListTablesResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    tables_ = RapidJsonUtil::DeserializeKeyValue<std::vector<std::string>>(obj, kFieldTables, {});
    next_page_token_ = RapidJsonUtil::DeserializeKeyValue<std::optional<std::string>>(
        obj, kFieldNextPageToken, std::nullopt);
}

rapidjson::Value ListSnapshotsResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldSnapshots),
                  RapidJsonUtil::SerializeValue(snapshots_, allocator).Move(), *allocator);
    AddOptionalStringMember(&obj, kFieldNextPageToken, next_page_token_, allocator);
    return obj;
}

void ListSnapshotsResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    snapshots_ =
        RapidJsonUtil::DeserializeKeyValue<std::vector<Snapshot>>(obj, kFieldSnapshots, {});
    next_page_token_ = RapidJsonUtil::DeserializeKeyValue<std::optional<std::string>>(
        obj, kFieldNextPageToken, std::nullopt);
}

rapidjson::Value GetTableResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldId),
                  RapidJsonUtil::SerializeValue(id_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldDatabase),
                  RapidJsonUtil::SerializeValue(database_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldName),
                  RapidJsonUtil::SerializeValue(name_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldPath),
                  RapidJsonUtil::SerializeValue(path_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldIsExternal),
                  RapidJsonUtil::SerializeValue(is_external_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldSchemaId),
                  RapidJsonUtil::SerializeValue(schema_id_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldSchema),
                  RestUtil::ParseToValue(schema_json_, allocator).Move(), *allocator);
    audit_.AddTo(&obj, allocator);
    return obj;
}

void GetTableResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    id_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldId, std::string());
    database_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldDatabase, std::string());
    name_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldName, std::string());
    path_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldPath);
    // Everything built from this response reads and writes below the path, and an empty one
    // bounds nothing.
    if (path_.empty()) {
        throw std::invalid_argument(std::string("member '") + kFieldPath + "' cannot be empty");
    }
    is_external_ = RapidJsonUtil::DeserializeKeyValue<bool>(obj, kFieldIsExternal, false);
    schema_id_ = RapidJsonUtil::DeserializeKeyValue<int64_t>(obj, kFieldSchemaId);
    schema_json_ = DeserializeRawJsonMember(obj, kFieldSchema);
    audit_.ParseFrom(obj);
}

rapidjson::Value GetTableTokenResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldToken),
                  RapidJsonUtil::SerializeValue(token_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldExpiresAtMillis),
                  RapidJsonUtil::SerializeValue(expires_at_millis_, allocator).Move(), *allocator);
    return obj;
}

void GetTableTokenResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    // A response without credentials must not be turned into a fall back to the catalog
    // credentials, so "token" is required while an explicitly empty object is accepted.
    token_ =
        RapidJsonUtil::DeserializeKeyValue<std::map<std::string, std::string>>(obj, kFieldToken);
    expires_at_millis_ = RapidJsonUtil::DeserializeKeyValue<int64_t>(obj, kFieldExpiresAtMillis, 0);
}

rapidjson::Value CreateTableRequest::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldIdentifier),
                  SerializeIdentifier(database_, table_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldSchema),
                  RestUtil::ParseToValue(schema_json_, allocator).Move(), *allocator);
    return obj;
}

void CreateTableRequest::FromJson(const rapidjson::Value& obj) noexcept(false) {
    DeserializeIdentifier(obj, kFieldIdentifier, &database_, &table_);
    schema_json_ = DeserializeRawJsonMember(obj, kFieldSchema);
}

rapidjson::Value RenameTableRequest::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldSource),
                  SerializeIdentifier(source_database_, source_table_, allocator).Move(),
                  *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldDestination),
                  SerializeIdentifier(destination_database_, destination_table_, allocator).Move(),
                  *allocator);
    return obj;
}

void RenameTableRequest::FromJson(const rapidjson::Value& obj) noexcept(false) {
    DeserializeIdentifier(obj, kFieldSource, &source_database_, &source_table_);
    DeserializeIdentifier(obj, kFieldDestination, &destination_database_, &destination_table_);
}

rapidjson::Value GetTableSnapshotResponse::ToJson(
    rapidjson::Document::AllocatorType* allocator) const noexcept(false) {
    rapidjson::Value wrapper(rapidjson::kNullType);
    if (snapshot_) {
        wrapper.SetObject();
        wrapper.AddMember(rapidjson::StringRef(kFieldSnapshot),
                          RapidJsonUtil::SerializeValue(snapshot_.value(), allocator).Move(),
                          *allocator);
    }
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldSnapshot), wrapper.Move(), *allocator);
    return obj;
}

void GetTableSnapshotResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    if (!obj.IsObject() || !obj.HasMember(kFieldSnapshot) ||
        (!obj[kFieldSnapshot].IsObject() && !obj[kFieldSnapshot].IsNull())) {
        throw std::invalid_argument(std::string("member '") + kFieldSnapshot +
                                    "' must exist and be an object or null");
    }
    if (obj[kFieldSnapshot].IsNull()) {
        snapshot_.reset();
        return;
    }
    snapshot_ = RapidJsonUtil::DeserializeKeyValue<Snapshot>(obj[kFieldSnapshot], kFieldSnapshot);
}

rapidjson::Value CommitTableResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldSuccess),
                  RapidJsonUtil::SerializeValue(success_, allocator).Move(), *allocator);
    return obj;
}

void CommitTableResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    // Require an explicit boolean: treating an unknown outcome as false could delete
    // manifests belonging to an accepted commit.
    success_ = RapidJsonUtil::DeserializeKeyValue<bool>(obj, kFieldSuccess);
}

rapidjson::Value CommitLockRequest::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldTableId),
                  RapidJsonUtil::SerializeValue(table_id_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldCommitUser),
                  RapidJsonUtil::SerializeValue(commit_user_, allocator).Move(), *allocator);
    return obj;
}

void CommitLockRequest::FromJson(const rapidjson::Value& obj) noexcept(false) {
    table_id_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldTableId);
    commit_user_ = RapidJsonUtil::DeserializeKeyValue<std::string>(obj, kFieldCommitUser);
}

rapidjson::Value CommitLockResponse::ToJson(rapidjson::Document::AllocatorType* allocator) const
    noexcept(false) {
    rapidjson::Value obj(rapidjson::kObjectType);
    obj.AddMember(rapidjson::StringRef(kFieldAcquired),
                  RapidJsonUtil::SerializeValue(acquired_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldCommitUser),
                  RapidJsonUtil::SerializeValue(commit_user_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldExpiresAtMillis),
                  RapidJsonUtil::SerializeValue(expires_at_millis_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldLeaseMillis),
                  RapidJsonUtil::SerializeValue(lease_millis_, allocator).Move(), *allocator);
    obj.AddMember(rapidjson::StringRef(kFieldSnapshot),
                  RapidJsonUtil::SerializeValue(snapshot_, allocator).Move(), *allocator);
    return obj;
}

void CommitLockResponse::FromJson(const rapidjson::Value& obj) noexcept(false) {
    // Required: a response that says nothing about the lease must not read as contention.
    acquired_ = RapidJsonUtil::DeserializeKeyValue<bool>(obj, kFieldAcquired);
    commit_user_ =
        RapidJsonUtil::DeserializeKeyValue<std::optional<std::string>>(obj, kFieldCommitUser);
    expires_at_millis_ = RapidJsonUtil::DeserializeKeyValue<int64_t>(obj, kFieldExpiresAtMillis, 0);
    lease_millis_ = RapidJsonUtil::DeserializeKeyValue<int64_t>(obj, kFieldLeaseMillis, 0);
    snapshot_ = RapidJsonUtil::DeserializeKeyValue<std::optional<Snapshot>>(obj, kFieldSnapshot);
}

}  // namespace paimon