smartbotic-vectorapi/src/handlers/documents.cpp

#include "collection_registry.hpp"
#include "errors.hpp"
#include "filters.hpp"
#include "json_http.hpp"
#include "server.hpp"
#include <cstdlib>
#include <limits>
#include <optional>
namespace svapi {
namespace {
// Authorize + verify the collection exists; returns the qualified collection name.
std::string scoped(ServerDeps* d, const httplib::Request& req, int projIdx, int collIdx, KeyOp op) {
    ApiKey k = requireKey(*d, req);
    std::string project = req.matches[projIdx], name = req.matches[collIdx];
    requireCapability(*d, k, req, project, name, op);
    if (!d->registry.get(project, name)) throw ApiError(ErrCode::NotFound, "not_found", "no such collection");
    return qualify(project, name);
}

// Parses ?ttl_seconds=. Returns nullopt when absent — the caller must
// distinguish "not supplied" (leave expiry alone) from 0 (clear the expiry).
std::optional<uint32_t> ttlParam(const httplib::Request& req) {
    if (!req.has_param("ttl_seconds")) return std::nullopt;
    const std::string raw = req.get_param_value("ttl_seconds");
    if (raw.empty() || raw.find_first_not_of("0123456789") != std::string::npos)
        throw ApiError(ErrCode::Unprocessable, "validation", "ttl_seconds must be a non-negative integer");
    unsigned long long wide = std::strtoull(raw.c_str(), nullptr, 10);
    if (wide > std::numeric_limits<uint32_t>::max())
        throw ApiError(ErrCode::Unprocessable, "validation", "ttl_seconds must be a non-negative integer");
    return (uint32_t)wide;
}
}
void registerDocumentRoutes(ApiServer& s) {
    auto& svr = s.raw(); ServerDeps* d = &s.deps();

    svr.Post(R"(/api/v1/projects/([^/]+)/collections/([^/]+)/documents)", [d](const httplib::Request& req, httplib::Response& res) {
        std::string c = scoped(d, req, 1, 2, KeyOp::Insert);
        auto body = bodyJson(req);
        std::string id = body.value("id", "");
        nlohmann::json data = body.contains("data") ? body["data"] : body;
        if (data.is_object() && data.contains("id")) data.erase("id");
        const uint32_t ttl = ttlParam(req).value_or(0);
        std::string newId = d->db.client().insert(c, data, id, ttl);
        if (newId.empty()) throw ApiError(ErrCode::Unavailable, "db_error", "insert failed");
        sendJson(res, 201, {{"id", newId}});
    });

    svr.Get(R"(/api/v1/projects/([^/]+)/collections/([^/]+)/documents/([^/]+))", [d](const httplib::Request& req, httplib::Response& res) {
        std::string c = scoped(d, req, 1, 2, KeyOp::Read);
        auto doc = d->db.client().get(c, req.matches[3]);
        if (!doc) throw ApiError(ErrCode::NotFound, "not_found", "no such document");
        sendJson(res, 200, *doc);
    });

    svr.Get(R"(/api/v1/projects/([^/]+)/collections/([^/]+)/documents)", [d](const httplib::Request& req, httplib::Response& res) {
        std::string c = scoped(d, req, 1, 2, KeyOp::List);
        smartbotic::database::Client::QueryOptions opts;
        auto range = req.params.equal_range("filter");
        for (auto it = range.first; it != range.second; ++it) opts.filters.push_back(parseFilter(it->second));
        auto parseUInt = [](const std::string& v, const char* name) -> uint32_t {
            try { return (uint32_t)std::stoul(v); }
            catch (...) { throw ApiError(ErrCode::Unprocessable, "validation", std::string(name) + " must be a non-negative integer"); }
        };
        if (req.has_param("limit"))  opts.limit  = parseUInt(req.get_param_value("limit"), "limit");
        if (req.has_param("offset")) opts.offset = parseUInt(req.get_param_value("offset"), "offset");
        if (req.has_param("sort"))   opts.sortField = req.get_param_value("sort");
        if (req.has_param("desc"))   opts.sortDescending = (req.get_param_value("desc") == "true");
        auto docs = d->db.client().find(c, opts);
        sendJson(res, 200, {{"documents", docs}, {"count", docs.size()}});
    });

    svr.Patch(R"(/api/v1/projects/([^/]+)/collections/([^/]+)/documents/([^/]+))", [d](const httplib::Request& req, httplib::Response& res) {
        std::string c = scoped(d, req, 1, 2, KeyOp::Update); std::string id = req.matches[3];
        if (!d->db.client().exists(c, id)) throw ApiError(ErrCode::NotFound, "not_found", "no such document");
        nlohmann::json patchBody = bodyJson(req);
        const auto ttl = ttlParam(req);
        uint64_t v = ttl ? d->db.client().patchWithTtl(c, id, patchBody, *ttl)
                          : d->db.client().patch(c, id, patchBody);
        if (v == 0) throw ApiError(ErrCode::Unavailable, "db_error", "patch failed");
        sendJson(res, 200, {{"id", id}, {"version", v}});
    });

    svr.Put(R"(/api/v1/projects/([^/]+)/collections/([^/]+)/documents/([^/]+))", [d](const httplib::Request& req, httplib::Response& res) {
        std::string c = scoped(d, req, 1, 2, KeyOp::Update); std::string id = req.matches[3];
        if (!d->db.client().exists(c, id)) throw ApiError(ErrCode::NotFound, "not_found", "no such document");
        if (!d->db.client().update(c, id, bodyJson(req))) throw ApiError(ErrCode::Unavailable, "db_error", "update failed");
        sendJson(res, 200, {{"id", id}});
    });

    svr.Delete(R"(/api/v1/projects/([^/]+)/collections/([^/]+)/documents/([^/]+))", [d](const httplib::Request& req, httplib::Response& res) {
        std::string c = scoped(d, req, 1, 2, KeyOp::Delete); std::string id = req.matches[3];
        std::string project = req.matches[1];
        std::string err;
        if (!d->db.client().remove(c, id, err)) {
            // A restrict relation is the one refusal a caller can act on, so it
            // gets 409 plus the impact list rather than a generic failure.
            auto why = d->db.client().describeDelete(c, id);
            if (why.success && why.wouldBeBlocked)
                throw ApiError(ErrCode::Conflict, "relation_restricted",
                               err.empty() ? "delete blocked by a relation" : err,
                               {{"impacts", impactsJson(project, why)}});
            throw ApiError(ErrCode::NotFound, "not_found", "no such document");
        }
        sendJson(res, 200, {{"deleted", id}});
    });
}
}