Classes
class	statement
class	database
class	transaction
struct	staging_guard
struct	export_table

Typedefs
using	json = nlohmann::json

Enumerations
enum class	database_access { ordinary , immutable_readonly , ordinary , immutable_readonly }
enum class	database_access { ordinary , immutable_readonly , ordinary , immutable_readonly }

Functions
void	fail (std::string message)
std::string	sqlite_message (sqlite3 *db, std::string_view operation)
std::string	sqlite_immutable_uri (const fs::path &path)
std::string	read_bytes (const fs::path &path)
json	read_json (const fs::path &path)
void	write_bytes (const fs::path &path, std::string_view bytes)
std::string	lowercase (std::string value)
bool	is_sha256 (std::string_view value)
void	require_sha256 (std::string_view value, std::string_view field)
std::string	canonical_json (const json &value)
std::string	require_string (const json &object, std::string_view key, std::string_view context)
std::optional< int >	optional_integer (const json &object, std::string_view key, std::string_view context)
std::optional< double >	optional_number (const json &object, std::string_view key, std::string_view context)
const json &	array_or_empty (const json &object, std::string_view key, std::string_view context)
void	configure_connection (const database &db)
fs::path	schema_path (std::string_view filename)
void	create_candidate_schema (const database &db)
std::string	domain_name (graph_domain)
fs::path	domain_path (const fs::path &root, graph_domain domain)
std::string	read_active_id (const fs::path &root, graph_domain domain)
void	write_active_id (const fs::path &root, graph_domain domain, std::string_view id)
fs::path	make_staging_directory (const fs::path &root, graph_domain domain, std::string_view seed)
void	remove_staging_sqlite_sidecars (const fs::path &database_path, const fs::path &expected_staging_directory)
void	validate_stable_contract_id (std::string_view value, std::string_view context)
int	require_integer (const json &object, std::string_view key, std::string_view context)
double	require_number (const json &object, std::string_view key, std::string_view context)
void	require_only_fields (const json &object, std::initializer_list< std::string_view > fields, std::string_view context)
void	import_candidate_plan (sqlite3 *db, const json &control, const json &payload)
bool	query_has_row (sqlite3 *db, std::string_view sql)
void	add_problem_if (integrity_report &report, sqlite3 *db, std::string_view sql, std::string message)
integrity_report	inspect_database (graph_domain domain, const fs::path &database_path, const database_access access=database_access::ordinary)
void	seal_and_validate_database (const graph_domain domain, const fs::path &database_path)
const std::vector< export_table > &	export_tables (graph_domain domain)
json	sqlite_value (sqlite3_stmt *statement_value, int column)
snapshot_result	snapshot_from_directory (const fs::path &root, graph_domain domain, std::string id, bool verify_hashes)
snapshot_result	finalize_snapshot (const fs::path &root, graph_domain domain, staging_guard &staging, std::string snapshot_id, std::string database_hash, std::string export_hash, std::size_t applied, std::size_t skipped)
void	require_valid_contract (arachnespace::contracts::contract_name expected, const json &document, std::string_view context)
json	read_candidate_payload (const fs::path &path)
std::string	utc_now ()
json	artifact (std::string storage_ref, std::string sha256, std::uintmax_t byte_length, std::string media_type)
json	write_validation_report (const fs::path &staging_path, graph_domain domain, std::string_view snapshot_id)

Variables
constexpr std::string_view	candidate_contract = "research_candidate_graph_snapshot_v1"

Typedef Documentation

◆ json

using arachne::penelope::anonymous_namespace{store.cpp}::json = nlohmann::json

Definition at line 36 of file store.cpp.

Enumeration Type Documentation

◆ database_access [1/2]

enum class arachne::penelope::anonymous_namespace{store.cpp}::database_access

strong

Enumerator
ordinary
immutable_readonly
ordinary
immutable_readonly

Definition at line 126 of file store.cpp.

126{ ordinary, immutable_readonly };

arachne::penelope::anonymous_namespace{store.cpp}::database_access::ordinary

@ ordinary

Definition store.cpp:126

arachne::penelope::anonymous_namespace{store.cpp}::database_access::immutable_readonly

@ immutable_readonly

Definition store.cpp:126

◆ database_access [2/2]

enum class arachne::penelope::anonymous_namespace{store.cpp}::database_access

strong

Enumerator
ordinary
immutable_readonly
ordinary
immutable_readonly

Definition at line 126 of file store.cpp.

126{ ordinary, immutable_readonly };

Function Documentation

◆ add_problem_if()

void arachne::penelope::anonymous_namespace{store.cpp}::add_problem_if	(	integrity_report &	report,
		sqlite3 *	db,
		std::string_view	sql,
		std::string	message )

Definition at line 1029 of file store.cpp.

      {
        if (query_has_row(db, sql)) {
            report.problems.push_back(std::move(message));
        }
    }

◆ array_or_empty()

const json & arachne::penelope::anonymous_namespace{store.cpp}::array_or_empty	(	const json &	object,
		std::string_view	key,
		std::string_view	context )

Definition at line 364 of file store.cpp.

      {
        static const json empty = json::array();
        const auto it = object.find(std::string(key));
        if (it == object.end()) {
            return empty;
        }
        if (!it->is_array()) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be an array"
            );
        }
        return *it;
    }

◆ artifact()

json arachne::penelope::anonymous_namespace{store.cpp}::artifact	(	std::string	storage_ref,
		std::string	sha256,
		std::uintmax_t	byte_length,
		std::string	media_type )

Definition at line 1484 of file store.cpp.

      {
        return {
            { "storage_ref", std::move(storage_ref) },
            { "sha256", std::move(sha256) },
            { "byte_length", byte_length },
            { "media_type", std::move(media_type) },
        };
    }

◆ canonical_json()

std::string arachne::penelope::anonymous_namespace{store.cpp}::canonical_json ( const json & value )

Definition at line 300 of file store.cpp.

                                                {
        if (value.is_discarded()) {
            fail("discarded JSON cannot be persisted");
        }
        try {
            return value.dump();
        } catch (const json::exception& error) {
            fail(std::string("cannot serialize JSON: ") + error.what());
        }
    }

◆ configure_connection()

void arachne::penelope::anonymous_namespace{store.cpp}::configure_connection ( const database & db )

Definition at line 381 of file store.cpp.

                                                  {
        db.exec("PRAGMA foreign_keys = ON");
        db.exec("PRAGMA journal_mode = WAL");
        db.exec("PRAGMA synchronous = NORMAL");
    }

Referenced by arachne::penelope::store::replace_candidate_snapshot(), and seal_and_validate_database().

Here is the caller graph for this function:

◆ create_candidate_schema()

void arachne::penelope::anonymous_namespace{store.cpp}::create_candidate_schema ( const database & db )

Definition at line 405 of file store.cpp.

                                                     {
        db.exec(read_bytes(schema_path("candidate_v1.sql")));
    }

Referenced by arachne::penelope::store::replace_candidate_snapshot().

Here is the caller graph for this function:

◆ domain_name()

std::string arachne::penelope::anonymous_namespace{store.cpp}::domain_name ( graph_domain )

Definition at line 409 of file store.cpp.

409{ return "candidate"; }

Referenced by domain_path(), and write_validation_report().

Here is the caller graph for this function:

◆ domain_path()

fs::path arachne::penelope::anonymous_namespace{store.cpp}::domain_path	(	const fs::path &	root,
		graph_domain	domain )

Definition at line 411 of file store.cpp.

                                                                {
        return root / domain_name(domain);
    }

References domain_name().

Referenced by finalize_snapshot(), make_staging_directory(), read_active_id(), snapshot_from_directory(), and write_active_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ export_tables()

const std::vector< export_table > & arachne::penelope::anonymous_namespace{store.cpp}::export_tables ( graph_domain domain )

Definition at line 1153 of file store.cpp.

                                                                      {
        static const std::vector<export_table> candidate {
            { "candidate_graph_info", "singleton" },
            { "candidate_groups", "id" },
            { "candidate_nodes", "id" },
            { "candidate_edges", "id" },
        };
        static_cast<void>(domain);
        return candidate;
    }

◆ fail()

void arachne::penelope::anonymous_namespace{store.cpp}::fail ( std::string message )

Definition at line 42 of file store.cpp.

                                              {
        throw store_error(std::move(message));
    }

Referenced by arachne::penelope::anonymous_namespace{store.cpp}::database::database().

Here is the caller graph for this function:

◆ finalize_snapshot()

snapshot_result arachne::penelope::anonymous_namespace{store.cpp}::finalize_snapshot	(	const fs::path &	root,
		graph_domain	domain,
		staging_guard &	staging,
		std::string	snapshot_id,
		std::string	database_hash,
		std::string	export_hash,
		std::size_t	applied,
		std::size_t	skipped )

Definition at line 1240 of file store.cpp.

      {
        const fs::path final_directory
            = domain_path(root, domain) / "snapshots" / snapshot_id;
        if (fs::exists(final_directory)) {
            const snapshot_result existing
                = snapshot_from_directory(root, domain, snapshot_id, true);
            if (existing.database_sha256 != database_hash
                || existing.export_sha256 != export_hash) {
                fail("snapshot ID collision with different content");
            }
        } else {
            std::error_code error;
            fs::rename(staging.path, final_directory, error);
            if (error) {
                fail(
                    "cannot publish immutable snapshot directory: "
                    + error.message()
                );
            }
            staging.keep = true;
        }
        const std::string previous = read_active_id(root, domain);
        const bool changed = previous != snapshot_id;
        if (changed) {
            write_active_id(root, domain, snapshot_id);
        }
        snapshot_result result = snapshot_from_directory(
            root, domain, std::move(snapshot_id), true
        );
        result.applied_inputs = applied;
        result.skipped_inputs = skipped;
        result.activated = changed;
        result.changed = changed;
        return result;
    }

References arachne::penelope::snapshot_result::activated, arachne::penelope::snapshot_result::applied_inputs, arachne::penelope::snapshot_result::changed, arachne::penelope::snapshot_result::database_sha256, domain_path(), arachne::penelope::snapshot_result::export_sha256, arachne::penelope::anonymous_namespace{store.cpp}::staging_guard::keep, read_active_id(), arachne::penelope::snapshot_result::skipped_inputs, snapshot_from_directory(), and write_active_id().

Here is the call graph for this function:

◆ import_candidate_plan()

void arachne::penelope::anonymous_namespace{store.cpp}::import_candidate_plan	(	sqlite3 *	db,
		const json &	control,
		const json &	payload )

Definition at line 594 of file store.cpp.

      {
        if (!payload.is_object()) {
            fail("candidate materialization payload must be a JSON object");
        }
        require_only_fields(
            payload,
            { "artifact_type", "format_version", "plan_id", "source_snapshot",
              "algorithm", "groups", "candidates", "works", "relations" },
            "candidate payload"
        );
        if (payload.value("artifact_type", std::string {})
                != "research_candidate_graph_materialization_v1"
            || payload.value("format_version", 0) != 1) {
            fail(
                "candidate payload must identify "
                "research_candidate_graph_materialization_v1"
            );
        }
        const std::string payload_plan_id
            = require_string(payload, "plan_id", "candidate payload");
        validate_stable_contract_id(
            payload_plan_id, "candidate payload.plan_id"
        );
        if (payload_plan_id
            != require_string(control, "plan_id", "candidate control")) {
            fail(
                "candidate payload plan_id does not match its control contract"
            );
        }
        for (const std::string_view key :
             { "groups", "candidates", "works", "relations" }) {
            const auto it = payload.find(std::string(key));
            if (it == payload.end() || !it->is_array()) {
                fail(
                    "candidate payload." + std::string(key)
                    + " must be an array"
                );
            }
        }
        const auto& source = control.at("source_snapshot");
        const std::string source_id
            = require_string(source, "snapshot_id", "control.source_snapshot");
        const std::string source_ref
            = require_string(source, "storage_ref", "control.source_snapshot");
        const std::string source_hash = lowercase(
            require_string(source, "sha256", "control.source_snapshot")
        );
        const auto& payload_source = payload.at("source_snapshot");
        require_only_fields(
            payload_source, { "snapshot_id", "storage_ref", "sha256" },
            "payload.source_snapshot"
        );
        if (require_string(
                payload_source, "snapshot_id", "payload.source_snapshot"
            ) != source_id
            || require_string(
                   payload_source, "storage_ref", "payload.source_snapshot"
               ) != source_ref
            || lowercase(require_string(
                   payload_source, "sha256", "payload.source_snapshot"
               ))
                != source_hash) {
            fail(
                "candidate payload source snapshot does not match its control "
                "contract"
            );
        }
        const auto& product = control.at("product_snapshot");
        const std::string product_id = require_string(
            product, "snapshot_id", "control.product_snapshot"
        );
        const std::string product_hash = lowercase(
            require_string(product, "sha256", "control.product_snapshot")
        );
        const std::string algorithm
            = require_string(control, "algorithm_version", "control");
        const auto& configuration = control.at("configuration");
        const std::string configuration_hash = lowercase(
            require_string(configuration, "sha256", "control.configuration")
        );
        const json configuration_values = configuration.at("values");
        if (crypto::sha256(canonical_json(configuration_values))
            != configuration_hash) {
            fail(
                "candidate control configuration hash does not bind its "
                "configuration values"
            );
        }
        const auto& payload_algorithm = payload.at("algorithm");
        require_only_fields(
            payload_algorithm, { "name", "version", "configuration_sha256" },
            "payload.algorithm"
        );
        const std::string payload_algorithm_name
            = require_string(payload_algorithm, "name", "payload.algorithm");
        const std::string payload_algorithm_version
            = require_string(payload_algorithm, "version", "payload.algorithm");
        if (algorithm
            != payload_algorithm_name + "-" + payload_algorithm_version) {
            fail(
                "candidate payload algorithm identity/version differs from "
                "its control"
            );
        }
        if (lowercase(require_string(
                payload_algorithm, "configuration_sha256", "payload.algorithm"
            ))
            != configuration_hash) {
            fail(
                "candidate payload configuration hash differs from its control"
            );
        }
        statement graph_info(
            db,
            "INSERT INTO candidate_graph_info"
            "(singleton,plan_version,source_snapshot_id,source_storage_ref,"
            "source_snapshot_sha256,product_snapshot_id,product_snapshot_"
            "sha256,"
            "algorithm_version,configuration_sha256,configuration_json)"
            " VALUES(1,1,?1,?2,?3,?4,?5,?6,?7,?8)"
        );
        graph_info.text(1, source_id);
        graph_info.text(2, source_ref);
        graph_info.text(3, source_hash);
        graph_info.text(4, product_id);
        graph_info.text(5, product_hash);
        graph_info.text(6, algorithm);
        graph_info.text(7, configuration_hash);
        graph_info.text(8, canonical_json(configuration_values));
        graph_info.done();
 
        std::unordered_set<std::string> groups;
        std::vector<json> ordered_groups;
        for (const auto& group : array_or_empty(payload, "groups", "payload")) {
            if (!group.is_object()) {
                fail("payload.groups entries must be objects");
            }
            ordered_groups.push_back(group);
        }
        std::ranges::sort(ordered_groups, [](const json& lhs, const json& rhs) {
            return lhs.value("group_id", std::string {})
                < rhs.value("group_id", std::string {});
        });
        std::unordered_map<std::string, int> expected_group_counts;
        for (const auto& group : ordered_groups) {
            const std::string where
                = "groups[" + std::to_string(groups.size()) + "]";
            require_only_fields(
                group,
                { "group_id", "label", "order", "candidate_count", "rationale",
                  "attributes" },
                where
            );
            const std::string id = require_string(group, "group_id", where);
            validate_stable_contract_id(id, where + ".group_id");
            if (!groups.emplace(id).second) {
                fail(where + " duplicates group ID " + id);
            }
            const int candidate_count
                = require_integer(group, "candidate_count", where);
            if (candidate_count < 0) {
                fail(where + ".candidate_count must be non-negative");
            }
            expected_group_counts.emplace(id, candidate_count);
            json metadata { { "candidate_count", candidate_count },
                            { "rationale",
                              require_string(group, "rationale", where) } };
            if (const auto attributes = group.find("attributes");
                attributes != group.end()) {
                if (!attributes->is_object()) {
                    fail(where + ".attributes must be an object");
                }
                metadata["attributes"] = *attributes;
            }
            statement insert(
                db,
                "INSERT INTO candidate_groups(id,label,ordinal,metadata_json)"
                " VALUES(?1,?2,?3,?4)"
            );
            insert.text(1, id);
            insert.text(2, require_string(group, "label", where));
            insert.integer(3, require_integer(group, "order", where));
            insert.text(4, canonical_json(metadata));
            insert.done();
        }
 
        std::unordered_set<std::string> nodes;
        std::unordered_set<std::string> candidates;
        std::unordered_map<std::string, std::string> candidate_groups;
        std::unordered_map<std::string, int> actual_group_counts;
        std::size_t node_index = 0;
        for (const auto& node :
             array_or_empty(payload, "candidates", "payload")) {
            const std::string where
                = "candidates[" + std::to_string(node_index++) + "]";
            if (!node.is_object()) {
                fail(where + " must be an object");
            }
            require_only_fields(
                node,
                { "candidate_id", "external_id", "label", "kind", "rank",
                  "coverage", "group_id", "selection_reasons",
                  "source_snapshot_id", "attributes" },
                where
            );
            const std::string id = require_string(node, "candidate_id", where);
            validate_stable_contract_id(id, where + ".candidate_id");
            if (!nodes.emplace(id).second) {
                fail(where + " duplicates candidate node ID " + id);
            }
            candidates.emplace(id);
            const std::string group_id
                = require_string(node, "group_id", where);
            if (!groups.contains(group_id)) {
                fail(where + ".group_id references an unknown group");
            }
            candidate_groups.emplace(id, group_id);
            ++actual_group_counts[group_id];
            const std::string kind = require_string(node, "kind", where);
            if (kind != "candidate" && kind != "grey") {
                fail(where + ".kind must be candidate or grey");
            }
            const auto& reasons = node.at("selection_reasons");
            if (!reasons.is_array() || reasons.empty()) {
                fail(where + ".selection_reasons must be a non-empty array");
            }
            for (const auto& reason : reasons) {
                if (!reason.is_string()
                    || reason.get_ref<const std::string&>().empty()) {
                    fail(
                        where
                        + ".selection_reasons must contain non-empty strings"
                    );
                }
            }
            if (require_string(node, "source_snapshot_id", where)
                != source_id) {
                fail(where + " references the wrong source snapshot");
            }
            json source_metadata {
                { "source_snapshot_id",
                  require_string(node, "source_snapshot_id", where) },
                { "external_id", require_string(node, "external_id", where) }
            };
            if (const auto attributes = node.find("attributes");
                attributes != node.end()) {
                if (!attributes->is_object()) {
                    fail(where + ".attributes must be an object");
                }
                source_metadata["attributes"] = *attributes;
            }
            statement insert(
                db,
                "INSERT INTO candidate_nodes"
                "(id,entity_ref,entity_type,label,rank,coverage,group_id,is_"
                "grey,"
                "selection_reason_json,source_metadata_json)"
                " VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10)"
            );
            insert.text(1, id);
            insert.text(2, require_string(node, "external_id", where));
            insert.text(3, kind);
            insert.text(4, require_string(node, "label", where));
            insert.integer(5, require_integer(node, "rank", where));
            insert.real(6, require_number(node, "coverage", where));
            insert.text(7, group_id);
            insert.integer(8, kind == "grey" ? 1 : 0);
            insert.text(9, canonical_json(reasons));
            insert.text(10, canonical_json(source_metadata));
            insert.done();
        }
        for (const auto& [group, expected] : expected_group_counts) {
            if (actual_group_counts[group] != expected) {
                fail(
                    "group candidate_count does not match candidate "
                    "membership: "
                    + group
                );
            }
        }
 
        std::size_t work_index = 0;
        for (const auto& work : array_or_empty(payload, "works", "payload")) {
            const std::string where
                = "works[" + std::to_string(work_index++) + "]";
            if (!work.is_object()) {
                fail(where + " must be an object");
            }
            require_only_fields(
                work,
                { "work_id", "candidate_id", "external_id", "label", "year",
                  "source_snapshot_id", "attributes" },
                where
            );
            const std::string id = require_string(work, "work_id", where);
            validate_stable_contract_id(id, where + ".work_id");
            if (!nodes.emplace(id).second) {
                fail(where + " duplicates a candidate/work node ID " + id);
            }
            const std::string candidate_id
                = require_string(work, "candidate_id", where);
            if (!candidates.contains(candidate_id)) {
                fail(where + ".candidate_id references an unknown candidate");
            }
            if (require_string(work, "source_snapshot_id", where)
                != source_id) {
                fail(where + " references the wrong source snapshot");
            }
            json metadata { { "candidate_id", candidate_id },
                            { "source_snapshot_id", source_id } };
            if (const auto year = optional_integer(work, "year", where)) {
                metadata["year"] = *year;
            }
            if (const auto attributes = work.find("attributes");
                attributes != work.end()) {
                if (!attributes->is_object()) {
                    fail(where + ".attributes must be an object");
                }
                metadata["attributes"] = *attributes;
            }
            statement insert(
                db,
                "INSERT INTO candidate_nodes"
                "(id,entity_ref,entity_type,label,rank,coverage,group_id,is_"
                "grey,"
                "selection_reason_json,source_metadata_json)"
                " VALUES(?1,?2,'candidate_work',?3,NULL,0,?4,0,'[]',?5)"
            );
            insert.text(1, id);
            insert.text(2, require_string(work, "external_id", where));
            insert.text(3, require_string(work, "label", where));
            insert.text(4, candidate_groups.at(candidate_id));
            insert.text(5, canonical_json(metadata));
            insert.done();
        }
 
        std::unordered_set<std::string> edges;
        std::size_t edge_index = 0;
        for (const auto& edge :
             array_or_empty(payload, "relations", "payload")) {
            const std::string where
                = "relations[" + std::to_string(edge_index++) + "]";
            if (!edge.is_object()) {
                fail(where + " must be an object");
            }
            require_only_fields(
                edge,
                { "relation_id", "source_id", "target_id", "relation_type",
                  "weight", "provenance", "attributes" },
                where
            );
            const std::string id = require_string(edge, "relation_id", where);
            validate_stable_contract_id(id, where + ".relation_id");
            if (!edges.emplace(id).second) {
                fail(where + " duplicates candidate edge ID " + id);
            }
            const std::string subject
                = require_string(edge, "source_id", where);
            const std::string object = require_string(edge, "target_id", where);
            if (!nodes.contains(subject) || !nodes.contains(object)) {
                fail(where + " references an unknown candidate node");
            }
            const auto& provenance = edge.at("provenance");
            require_only_fields(
                provenance,
                { "origin", "source_snapshot_id", "algorithm_version",
                  "explanation" },
                where + ".provenance"
            );
            if (require_string(provenance, "origin", where + ".provenance")
                    != "algorithmic_external"
                || require_string(
                       provenance, "source_snapshot_id", where + ".provenance"
                   ) != source_id
                || require_string(
                       provenance, "algorithm_version", where + ".provenance"
                   ) != payload_algorithm_version) {
                fail(where + ".provenance is inconsistent with payload inputs");
            }
            (void)require_string(
                provenance, "explanation", where + ".provenance"
            );
            json edge_metadata = provenance;
            if (const auto attributes = edge.find("attributes");
                attributes != edge.end()) {
                if (!attributes->is_object()) {
                    fail(where + ".attributes must be an object");
                }
                edge_metadata["attributes"] = *attributes;
            }
            statement insert(
                db,
                "INSERT INTO candidate_edges"
                "(id,subject_id,relation_type,object_id,weight,metadata_json)"
                " VALUES(?1,?2,?3,?4,?5,?6)"
            );
            insert.text(1, id);
            insert.text(2, subject);
            insert.text(3, require_string(edge, "relation_type", where));
            insert.text(4, object);
            insert.optional_real(5, optional_number(edge, "weight", where));
            insert.text(6, canonical_json(edge_metadata));
            insert.done();
        }
 
        const auto& summary = control.at("summary");
        if (require_integer(summary, "candidate_count", "control.summary")
                != static_cast<int>(
                    array_or_empty(payload, "candidates", "payload").size()
                )
            || require_integer(summary, "edge_count", "control.summary")
                != static_cast<int>(
                    array_or_empty(payload, "relations", "payload").size()
                )
            || require_integer(summary, "group_count", "control.summary")
                != static_cast<int>(ordered_groups.size())) {
            fail(
                "candidate control summary does not match the resolved payload"
            );
        }
    }

References arachne::penelope::anonymous_namespace{store.cpp}::statement::done(), and validate_stable_contract_id().

Here is the call graph for this function:

◆ inspect_database()

integrity_report arachne::penelope::anonymous_namespace{store.cpp}::inspect_database	(	graph_domain	domain,
		const fs::path &	database_path,
		const database_access	access = database_access::ordinary )

Definition at line 1038 of file store.cpp.

      {
        static_cast<void>(domain);
        integrity_report report;
        if (!fs::is_regular_file(database_path)) {
            report.problems.push_back("database file does not exist");
            return report;
        }
        try {
            database db(database_path, SQLITE_OPEN_READONLY, access);
            db.exec("PRAGMA foreign_keys = ON");
            {
                statement check(db.get(), "PRAGMA integrity_check");
                bool saw_result = false;
                while (check.row()) {
                    saw_result = true;
                    const auto* raw = sqlite3_column_text(check.get(), 0);
                    const std::string value = raw == nullptr
                        ? std::string {}
                        : reinterpret_cast<const char*>(raw);
                    if (value != "ok") {
                        report.problems.push_back("SQLite integrity: " + value);
                    }
                }
                if (!saw_result) {
                    report.problems.push_back(
                        "SQLite integrity_check returned no result"
                    );
                }
            }
            {
                statement foreign_keys(db.get(), "PRAGMA foreign_key_check");
                while (foreign_keys.row()) {
                    const auto* table
                        = sqlite3_column_text(foreign_keys.get(), 0);
                    report.problems.push_back(
                        "foreign-key violation in table "
                        + std::string(
                            table == nullptr
                                ? "unknown"
                                : reinterpret_cast<const char*>(table)
                        )
                    );
                }
            }
 
            add_problem_if(
                report, db.get(),
                "SELECT 1 WHERE (SELECT count(*) FROM "
                "candidate_graph_info)<>1",
                "candidate database must contain exactly one graph-info row"
            );
            add_problem_if(
                report, db.get(),
                "SELECT 1 FROM candidate_edges WHERE subject_id=object_id "
                "LIMIT 1",
                "candidate graph contains a self edge"
            );
        } catch (const std::exception& error) {
            report.problems.push_back(error.what());
        }
        report.ok = report.problems.empty();
        return report;
    }

References arachne::penelope::anonymous_namespace{store.cpp}::database::database(), arachne::penelope::anonymous_namespace{store.cpp}::database::get(), arachne::penelope::anonymous_namespace{store.cpp}::statement::get(), arachne::penelope::integrity_report::ok, and arachne::penelope::anonymous_namespace{store.cpp}::statement::row().

Referenced by arachne::penelope::store::integrity_check(), and seal_and_validate_database().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_sha256()

bool arachne::penelope::anonymous_namespace{store.cpp}::is_sha256 ( std::string_view value )

Definition at line 286 of file store.cpp.

                                         {
        return value.size() == 64
            && std::ranges::all_of(value, [](unsigned char c) {
                   return std::isdigit(c) != 0 || (c >= 'a' && c <= 'f')
                       || (c >= 'A' && c <= 'F');
               });
    }

◆ lowercase()

std::string arachne::penelope::anonymous_namespace{store.cpp}::lowercase ( std::string value )

Definition at line 279 of file store.cpp.

                                         {
        std::ranges::transform(value, value.begin(), [](unsigned char c) {
            return static_cast<char>(std::tolower(c));
        });
        return value;
    }

◆ make_staging_directory()

fs::path arachne::penelope::anonymous_namespace{store.cpp}::make_staging_directory	(	const fs::path &	root,
		graph_domain	domain,
		std::string_view	seed )

Definition at line 451 of file store.cpp.

      {
        const fs::path staging = domain_path(root, domain) / ".staging";
        fs::create_directories(staging);
        const std::string base = "stage-" + crypto::sha256(seed).substr(0, 20);
        for (std::size_t suffix = 0; suffix < 1000; ++suffix) {
            fs::path result = staging / base;
            if (suffix != 0) {
                result += "-" + std::to_string(suffix);
            }
            std::error_code error;
            if (fs::create_directory(result, error)) {
                return result;
            }
            if (error) {
                fail("cannot create staging directory: " + error.message());
            }
        }
        fail("cannot allocate a unique staging directory");
    }

References domain_path(), and arachne::crypto::sha256().

Here is the call graph for this function:

◆ optional_integer()

std::optional< int > arachne::penelope::anonymous_namespace{store.cpp}::optional_integer	(	const json &	object,
		std::string_view	key,
		std::string_view	context )

Definition at line 325 of file store.cpp.

      {
        const auto it = object.find(std::string(key));
        if (it == object.end() || it->is_null()) {
            return std::nullopt;
        }
        if (!it->is_number_integer()) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be an integer or null"
            );
        }
        return it->get<int>();
    }

◆ optional_number()

std::optional< double > arachne::penelope::anonymous_namespace{store.cpp}::optional_number	(	const json &	object,
		std::string_view	key,
		std::string_view	context )

Definition at line 341 of file store.cpp.

      {
        const auto it = object.find(std::string(key));
        if (it == object.end() || it->is_null()) {
            return std::nullopt;
        }
        if (!it->is_number()) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be a number or null"
            );
        }
        const double result = it->get<double>();
        if (!std::isfinite(result)) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be finite"
            );
        }
        return result;
    }

◆ query_has_row()

bool arachne::penelope::anonymous_namespace{store.cpp}::query_has_row	(	sqlite3 *	db,
		std::string_view	sql )

Definition at line 1024 of file store.cpp.

                                                        {
        statement query(db, sql);
        return query.row();
    }

References arachne::penelope::anonymous_namespace{store.cpp}::statement::row().

Here is the call graph for this function:

◆ read_active_id()

std::string arachne::penelope::anonymous_namespace{store.cpp}::read_active_id	(	const fs::path &	root,
		graph_domain	domain )

Definition at line 415 of file store.cpp.

                                                                      {
        const fs::path pointer = domain_path(root, domain) / "ACTIVE";
        std::error_code error;
        if (!fs::exists(pointer, error)) {
            return {};
        }
        std::string id = read_bytes(pointer);
        while (!id.empty()
               && std::isspace(static_cast<unsigned char>(id.back()))) {
            id.pop_back();
        }
        if (id.empty() || !std::ranges::all_of(id, [](unsigned char c) {
                return std::isalnum(c) != 0 || c == '-' || c == '_';
            })) {
            fail("invalid ACTIVE pointer content: " + pointer.string());
        }
        return id;
    }

References domain_path(), and read_bytes().

Referenced by finalize_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_bytes()

std::string arachne::penelope::anonymous_namespace{store.cpp}::read_bytes ( const fs::path & path )

Definition at line 246 of file store.cpp.

                                             {
        std::ifstream input(path, std::ios::binary);
        if (!input) {
            fail("cannot read file: " + path.string());
        }
        std::ostringstream data;
        data << input.rdbuf();
        if (!input.eof() && input.fail()) {
            fail("failed while reading file: " + path.string());
        }
        return data.str();
    }

Referenced by read_active_id(), and read_candidate_payload().

Here is the caller graph for this function:

◆ read_candidate_payload()

json arachne::penelope::anonymous_namespace{store.cpp}::read_candidate_payload ( const fs::path & path )

Definition at line 1400 of file store.cpp.

                                                    {
        const std::string bytes = read_bytes(path);
        try {
            return json::parse(bytes);
        } catch (const json::parse_error&) {
            json result {
                { "groups", json::array() },
                { "candidates", json::array() },
                { "works", json::array() },
                { "relations", json::array() },
            };
            std::istringstream lines(bytes);
            std::string line;
            std::size_t line_number = 0;
            while (std::getline(lines, line)) {
                ++line_number;
                if (line.empty()) {
                    continue;
                }
                json record;
                try {
                    record = json::parse(line);
                } catch (const json::exception& error) {
                    fail(
                        "invalid candidate JSONL line "
                        + std::to_string(line_number) + ": " + error.what()
                    );
                }
                if (!record.is_object()) {
                    fail("candidate JSONL records must be objects");
                }
                const std::string kind
                    = record.value("record_type", std::string {});
                if (kind.empty() || kind == "header") {
                    const json data
                        = record.contains("data") ? record["data"] : record;
                    if (!data.is_object()) {
                        fail("candidate JSONL header data must be an object");
                    }
                    for (const auto& [key, value] : data.items()) {
                        if (key != "record_type" && key != "data") {
                            result[key] = value;
                        }
                    }
                    continue;
                }
                static const std::map<std::string, std::string, std::less<>>
                    arrays {
                        { "group", "groups" },
                        { "candidate", "candidates" },
                        { "work", "works" },
                        { "relation", "relations" },
                    };
                const auto destination = arrays.find(kind);
                if (destination == arrays.end()) {
                    fail("unknown candidate JSONL record_type: " + kind);
                }
                json data = record.contains("data") ? record["data"] : record;
                if (!data.is_object()) {
                    fail("candidate JSONL record data must be an object");
                }
                data.erase("record_type");
                result[destination->second].push_back(std::move(data));
            }
            return result;
        }
    }

References read_bytes().

Here is the call graph for this function:

◆ read_json()

json arachne::penelope::anonymous_namespace{store.cpp}::read_json ( const fs::path & path )

Definition at line 259 of file store.cpp.

                                       {
        try {
            return json::parse(read_bytes(path));
        } catch (const json::exception& error) {
            fail("invalid JSON in " + path.string() + ": " + error.what());
        }
    }

◆ remove_staging_sqlite_sidecars()

void arachne::penelope::anonymous_namespace{store.cpp}::remove_staging_sqlite_sidecars	(	const fs::path &	database_path,
		const fs::path &	expected_staging_directory )

Definition at line 473 of file store.cpp.

      {
        if (database_path.filename() != "graph.sqlite"
            || database_path.parent_path() != expected_staging_directory) {
            fail("refusing to clean SQLite sidecars outside expected staging");
        }
 
        const std::string directory_name
            = expected_staging_directory.filename().string();
        const bool snapshot_staging
            = expected_staging_directory.parent_path().filename() == ".staging"
            && directory_name.starts_with("stage-");
        std::error_code error;
        const fs::file_status staging_status
            = fs::symlink_status(expected_staging_directory, error);
        if (!snapshot_staging || error || !fs::is_directory(staging_status)) {
            fail("refusing to clean SQLite sidecars outside safe staging");
        }
 
        for (const std::string_view suffix : { "-wal", "-shm", "-journal" }) {
            fs::path sidecar = database_path;
            sidecar += suffix;
            error.clear();
            const fs::file_status status = fs::symlink_status(sidecar, error);
            if (error == std::errc::no_such_file_or_directory
                || (!error && status.type() == fs::file_type::not_found)) {
                continue;
            }
            if (error || !fs::is_regular_file(status)) {
                fail(
                    "refusing to remove unsafe staging sidecar: "
                    + sidecar.string()
                );
            }
            if (!fs::remove(sidecar, error) || error) {
                fail(
                    "cannot remove checkpointed staging sidecar: "
                    + sidecar.string() + ": " + error.message()
                );
            }
        }
    }

Referenced by arachne::penelope::store::checkpoint_staging().

Here is the caller graph for this function:

◆ require_integer()

int arachne::penelope::anonymous_namespace{store.cpp}::require_integer	(	const json &	object,
		std::string_view	key,
		std::string_view	context )

Definition at line 536 of file store.cpp.

      {
        const auto value = object.find(std::string(key));
        if (value == object.end() || !value->is_number_integer()) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be an integer"
            );
        }
        try {
            return value->get<int>();
        } catch (const json::exception&) {
            fail(
                std::string(context) + "." + std::string(key)
                + " is outside the supported integer range"
            );
        }
    }

◆ require_number()

double arachne::penelope::anonymous_namespace{store.cpp}::require_number	(	const json &	object,
		std::string_view	key,
		std::string_view	context )

Definition at line 556 of file store.cpp.

      {
        const auto value = object.find(std::string(key));
        if (value == object.end() || !value->is_number()) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be a number"
            );
        }
        const double result = value->get<double>();
        if (!std::isfinite(result)) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be finite"
            );
        }
        return result;
    }

◆ require_only_fields()

void arachne::penelope::anonymous_namespace{store.cpp}::require_only_fields	(	const json &	object,
		std::initializer_list< std::string_view >	fields,
		std::string_view	context )

Definition at line 576 of file store.cpp.

      {
        if (!object.is_object()) {
            fail(std::string(context) + " must be an object");
        }
        const std::set<std::string_view> allowed(fields);
        for (const auto& [key, value] : object.items()) {
            (void)value;
            if (!allowed.contains(key)) {
                fail(
                    std::string(context) + " contains unsupported field " + key
                );
            }
        }
    }

◆ require_sha256()

void arachne::penelope::anonymous_namespace{store.cpp}::require_sha256	(	std::string_view	value,
		std::string_view	field )

Definition at line 294 of file store.cpp.

                                                                    {
        if (!is_sha256(value)) {
            fail(std::string(field) + " must be a 64-character SHA-256 digest");
        }
    }

Referenced by arachne::penelope::store::replace_candidate_snapshot(), and snapshot_from_directory().

Here is the caller graph for this function:

◆ require_string()

std::string arachne::penelope::anonymous_namespace{store.cpp}::require_string	(	const json &	object,
		std::string_view	key,
		std::string_view	context )

Definition at line 311 of file store.cpp.

      {
        const auto it = object.find(std::string(key));
        if (it == object.end() || !it->is_string()
            || it->get_ref<const std::string&>().empty()) {
            fail(
                std::string(context) + "." + std::string(key)
                + " must be a non-empty string"
            );
        }
        return it->get<std::string>();
    }

◆ require_valid_contract()

void arachne::penelope::anonymous_namespace{store.cpp}::require_valid_contract	(	arachnespace::contracts::contract_name	expected,
		const json &	document,
		std::string_view	context )

Definition at line 1382 of file store.cpp.

      {
        const auto validation
            = arachnespace::contracts::validate(expected, document);
        if (validation.valid()) {
            return;
        }
        std::string message
            = std::string(context) + " contract validation failed";
        for (const auto& diagnostic : validation.diagnostics) {
            message += "\n- " + diagnostic.instance_path + " ["
                + diagnostic.code + "] " + diagnostic.message;
        }
        fail(std::move(message));
    }

◆ schema_path()

fs::path arachne::penelope::anonymous_namespace{store.cpp}::schema_path ( std::string_view filename )

Definition at line 387 of file store.cpp.

                                                {
        const fs::path compiled
            = fs::path(__FILE__).parent_path().parent_path().parent_path()
            / "schema" / filename;
        const std::array candidates {
            compiled,
            fs::current_path() / "schema" / filename,
            fs::current_path() / "arachne" / "schema" / filename,
        };
        for (const auto& path : candidates) {
            std::error_code error;
            if (fs::is_regular_file(path, error)) {
                return path;
            }
        }
        fail("cannot locate schema file " + std::string(filename));
    }

◆ seal_and_validate_database()

void arachne::penelope::anonymous_namespace{store.cpp}::seal_and_validate_database	(	const graph_domain	domain,
		const fs::path &	database_path )

Definition at line 1105 of file store.cpp.

      {
        {
            database db(database_path, SQLITE_OPEN_READWRITE);
            configure_connection(db);
            db.exec("PRAGMA optimize");
            {
                statement checkpoint(
                    db.get(), "PRAGMA wal_checkpoint(TRUNCATE)"
                );
                if (!checkpoint.row()
                    || sqlite3_column_int(checkpoint.get(), 0) != 0) {
                    fail("SQLite WAL checkpoint did not complete");
                }
            }
            statement required_mode(db.get(), "PRAGMA journal_mode");
            if (!required_mode.row()) {
                fail("cannot inspect checkpointed database journal mode");
            }
            const auto* mode = sqlite3_column_text(required_mode.get(), 0);
            const std::string actual_mode = mode == nullptr
                ? std::string {}
                : lowercase(reinterpret_cast<const char*>(mode));
            if (actual_mode != "wal") {
                fail(
                    "checkpointed database did not retain required WAL mode: "
                    + actual_mode
                );
            }
        }
        const auto report = inspect_database(
            domain, database_path, database_access::immutable_readonly
        );
        if (!report.ok) {
            std::string message = "database integrity validation failed";
            for (const auto& problem : report.problems) {
                message += "\n- " + problem;
            }
            fail(std::move(message));
        }
    }

References configure_connection(), arachne::penelope::anonymous_namespace{store.cpp}::database::database(), arachne::penelope::anonymous_namespace{store.cpp}::database::get(), arachne::penelope::anonymous_namespace{store.cpp}::statement::get(), immutable_readonly, inspect_database(), arachne::penelope::integrity_report::ok, and arachne::penelope::anonymous_namespace{store.cpp}::statement::row().

Referenced by arachne::penelope::store::checkpoint_staging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ snapshot_from_directory()

snapshot_result arachne::penelope::anonymous_namespace{store.cpp}::snapshot_from_directory	(	const fs::path &	root,
		graph_domain	domain,
		std::string	id,
		bool	verify_hashes )

Definition at line 1192 of file store.cpp.

      {
        const fs::path directory = domain_path(root, domain) / "snapshots" / id;
        snapshot_result result;
        result.domain = domain;
        result.snapshot_id = std::move(id);
        result.database_path = directory / "graph.sqlite";
        result.export_path = directory / "graph.jsonl";
        result.metadata_path = directory / "metadata.json";
        const json metadata = read_json(result.metadata_path);
        const auto validation = arachnespace::contracts::validate(
            arachnespace::contracts::contract_name::
                research_candidate_graph_snapshot,
            metadata
        );
        if (!validation.valid()
            || metadata.value("contract", std::string {})
                != candidate_contract
            || metadata.value("snapshot_id", std::string {})
                != result.snapshot_id) {
            fail("snapshot metadata does not match ACTIVE pointer");
        }
        result.database_sha256 = lowercase(require_string(
            metadata.at("database"), "sha256", "metadata.database"
        ));
        const auto& exports = metadata.at("exports");
        if (exports.empty() || !exports.front().is_object()
            || !exports.front().contains("artifact")) {
            fail("snapshot metadata has no deterministic export artifact");
        }
        result.export_sha256 = lowercase(require_string(
            exports.front().at("artifact"), "sha256",
            "metadata.exports[0].artifact"
        ));
        require_sha256(result.database_sha256, "metadata.database_sha256");
        require_sha256(result.export_sha256, "metadata.export_sha256");
        if (verify_hashes
            && (crypto::sha256_file(result.database_path)
                    != result.database_sha256
                || crypto::sha256_file(result.export_path)
                    != result.export_sha256)) {
            fail("active snapshot content hash does not match metadata");
        }
        return result;
    }

References arachne::penelope::snapshot_result::database_sha256, arachne::penelope::snapshot_result::domain, domain_path(), arachne::penelope::snapshot_result::export_sha256, require_sha256(), arachnespace::contracts::research_candidate_graph_snapshot, arachne::crypto::sha256_file(), and arachne::penelope::snapshot_result::snapshot_id.

Referenced by finalize_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_immutable_uri()

std::string arachne::penelope::anonymous_namespace{store.cpp}::sqlite_immutable_uri ( const fs::path & path )

Definition at line 128 of file store.cpp.

                                                       {
        static constexpr char hex[] = "0123456789ABCDEF";
        const std::string native
            = fs::absolute(path).lexically_normal().generic_string();
        std::string result = "file:";
        result.reserve(native.size() + 24U);
        for (const char raw_value : native) {
            const auto value = static_cast<unsigned char>(raw_value);
            if (std::isalnum(value) != 0 || value == '/' || value == ':'
                || value == '-' || value == '.' || value == '_'
                || value == '~') {
                result.push_back(static_cast<char>(value));
            } else {
                result.push_back('%');
                result.push_back(hex[value >> 4U]);
                result.push_back(hex[value & 0x0FU]);
            }
        }
        result += "?immutable=1";
        return result;
    }

Referenced by arachne::penelope::anonymous_namespace{store.cpp}::database::database().

Here is the caller graph for this function:

◆ sqlite_message()

std::string arachne::penelope::anonymous_namespace{store.cpp}::sqlite_message	(	sqlite3 *	db,
		std::string_view	operation )

Definition at line 46 of file store.cpp.

                                                                    {
        return std::string(operation) + ": "
            + (db == nullptr ? "unknown SQLite error" : sqlite3_errmsg(db));
    }

◆ sqlite_value()

json arachne::penelope::anonymous_namespace{store.cpp}::sqlite_value	(	sqlite3_stmt *	statement_value,
		int	column )

Definition at line 1164 of file store.cpp.

                                                                 {
        switch (sqlite3_column_type(statement_value, column)) {
        case SQLITE_NULL:
            return nullptr;
        case SQLITE_INTEGER:
            return sqlite3_column_int64(statement_value, column);
        case SQLITE_FLOAT: {
            const double value = sqlite3_column_double(statement_value, column);
            if (!std::isfinite(value)) {
                fail("database contains a non-finite number");
            }
            return value;
        }
        case SQLITE_TEXT: {
            const auto* value = sqlite3_column_text(statement_value, column);
            const int bytes = sqlite3_column_bytes(statement_value, column);
            return std::string(
                reinterpret_cast<const char*>(value),
                static_cast<std::size_t>(bytes)
            );
        }
        case SQLITE_BLOB:
            fail("canonical graph tables must not contain BLOB values");
        default:
            fail("unknown SQLite column type");
        }
    }

◆ utc_now()

std::string arachne::penelope::anonymous_namespace{store.cpp}::utc_now ( )

Definition at line 1468 of file store.cpp.

                        {
        const std::time_t now = std::time(nullptr);
        std::tm broken_down {};
        if (gmtime_r(&now, &broken_down) == nullptr) {
            fail("cannot create snapshot activation timestamp");
        }
        std::array<char, 32> buffer {};
        if (std::strftime(
                buffer.data(), buffer.size(), "%Y-%m-%dT%H:%M:%SZ", &broken_down
            )
            == 0) {
            fail("cannot format snapshot activation timestamp");
        }
        return buffer.data();
    }

◆ validate_stable_contract_id()

void arachne::penelope::anonymous_namespace{store.cpp}::validate_stable_contract_id	(	std::string_view	value,
		std::string_view	context )

Definition at line 524 of file store.cpp.

      {
        if (value.empty() || value.size() > 128
            || !std::ranges::all_of(value, [](unsigned char c) {
                   return std::isalnum(c) != 0 || c == '_' || c == '-'
                       || c == '.' || c == ':';
               })) {
            fail(std::string(context) + " must be a safe, non-empty stable ID");
        }
    }

Referenced by import_candidate_plan().

Here is the caller graph for this function:

◆ write_active_id()

void arachne::penelope::anonymous_namespace{store.cpp}::write_active_id	(	const fs::path &	root,
		graph_domain	domain,
		std::string_view	id )

Definition at line 434 of file store.cpp.

      {
        const fs::path parent = domain_path(root, domain);
        const fs::path pointer = parent / "ACTIVE";
        const fs::path temporary
            = parent / (".ACTIVE-" + crypto::sha256(id).substr(0, 16) + ".tmp");
        write_bytes(temporary, std::string(id) + "\n");
        if (std::rename(temporary.c_str(), pointer.c_str()) != 0) {
            std::error_code ignored;
            fs::remove(temporary, ignored);
            fail(
                "cannot atomically replace ACTIVE pointer: " + pointer.string()
            );
        }
    }

References domain_path(), and arachne::crypto::sha256().

Referenced by finalize_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_bytes()

void arachne::penelope::anonymous_namespace{store.cpp}::write_bytes	(	const fs::path &	path,
		std::string_view	bytes )

Definition at line 267 of file store.cpp.

                                                               {
        std::ofstream output(path, std::ios::binary | std::ios::trunc);
        if (!output) {
            fail("cannot write file: " + path.string());
        }
        output.write(bytes.data(), static_cast<std::streamsize>(bytes.size()));
        output.flush();
        if (!output) {
            fail("failed while writing file: " + path.string());
        }
    }

◆ write_validation_report()

json arachne::penelope::anonymous_namespace{store.cpp}::write_validation_report	(	const fs::path &	staging_path,
		graph_domain	domain,
		std::string_view	snapshot_id )

Definition at line 1496 of file store.cpp.

      {
        const json report {
            { "format_version", 1 },
            { "domain", domain_name(domain) },
            { "snapshot_id", snapshot_id },
            { "passed", true },
            { "checks",
              { { "sqlite_integrity", "ok" },
                { "foreign_keys", "ok" },
                { "domain_structure", "ok" } } },
        };
        const fs::path path = staging_path / "validation.json";
        write_bytes(path, canonical_json(report) + "\n");
        return artifact(
            domain_name(domain) + "/snapshots/" + std::string(snapshot_id)
                + "/validation.json",
            crypto::sha256_file(path), fs::file_size(path), "application/json"
        );
    }

References domain_name().

Here is the call graph for this function:

Variable Documentation

◆ candidate_contract

std::string_view arachne::penelope::anonymous_namespace{store.cpp}::candidate_contract = "research_candidate_graph_snapshot_v1"

constexpr

Definition at line 39 of file store.cpp.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ json

Enumeration Type Documentation

◆ database_access [1/2]

◆ database_access [2/2]

Function Documentation

◆ add_problem_if()

◆ array_or_empty()

◆ artifact()

◆ canonical_json()

◆ configure_connection()

◆ create_candidate_schema()

◆ domain_name()

◆ domain_path()

◆ export_tables()

◆ fail()

◆ finalize_snapshot()

◆ import_candidate_plan()

◆ inspect_database()

◆ is_sha256()

◆ lowercase()

◆ make_staging_directory()

◆ optional_integer()

◆ optional_number()

◆ query_has_row()

◆ read_active_id()

◆ read_bytes()

◆ read_candidate_payload()

◆ read_json()

◆ remove_staging_sqlite_sidecars()

◆ require_integer()

◆ require_number()

◆ require_only_fields()

◆ require_sha256()

◆ require_string()

◆ require_valid_contract()

◆ schema_path()

◆ seal_and_validate_database()

◆ snapshot_from_directory()

◆ sqlite_immutable_uri()

◆ sqlite_message()

◆ sqlite_value()

◆ utc_now()

◆ validate_stable_contract_id()

◆ write_active_id()

◆ write_bytes()

◆ write_validation_report()

Variable Documentation

◆ candidate_contract