1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
//! An Entry is a unit of data in a Holochain Source Chain.
//!
//! This module contains all the necessary definitions for Entry, which broadly speaking
//! refers to any data which will be written into the ContentAddressableStorage, or the EntityAttributeValueStorage.
//! It defines serialization behaviour for entries. Here you can find the complete list of
//! entry_types, and special entries, like deletion_entry and cap_entry.
use crate::action::ChainTopOrdering;
use holochain_integrity_types::EntryDefIndex;
use holochain_integrity_types::EntryType;
use holochain_integrity_types::EntryVisibility;
use holochain_integrity_types::ScopedEntryDefIndex;
use holochain_integrity_types::ZomeIndex;
use holochain_serialized_bytes::prelude::*;
mod app_entry_bytes;
pub use app_entry_bytes::*;
pub use holochain_integrity_types::entry::*;
#[derive(
Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
)]
/// Either an [`EntryDefIndex`] or one of:
/// - [`EntryType::CapGrant`](crate::prelude::EntryType::CapGrant)
/// - [`EntryType::CapClaim`](crate::prelude::EntryType::CapClaim)
/// Which don't have an index.
pub enum EntryDefLocation {
/// App defined entries always have a unique [`u8`] index
/// within the Dna.
App(AppEntryDefLocation),
/// [`crate::EntryDefId::CapClaim`] is committed to and
/// validated by all integrity zomes in the dna.
CapClaim,
/// [`crate::EntryDefId::CapGrant`] is committed to and
/// validated by all integrity zomes in the dna.
CapGrant,
}
#[derive(
Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
)]
/// The location of an app entry definition.
pub struct AppEntryDefLocation {
/// The zome that defines this entry type.
pub zome_index: ZomeIndex,
/// The entry type within the zome.
pub entry_def_index: EntryDefIndex,
}
#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
/// Options for controlling how get works
pub struct GetOptions {
/// If this is true the get call will wait for
/// the latest data before returning.
/// If it is false you will get whatever is locally
/// available on this conductor.
pub strategy: GetStrategy,
}
impl GetOptions {
/// This will get you the content
/// with latest metadata if it can
/// otherwise it will fallback to what
/// you have cached locally.
///
/// This call is guaranteed to not go to
/// the network if you are an authority
/// for this hash.
pub fn latest() -> Self {
Self {
strategy: GetStrategy::Latest,
}
}
/// Gets the content but does not
/// try to get the latest metadata.
/// This will save a network call if the
/// entry is local (cached, authored or integrated).
///
/// This will fallback to the network if the content
/// is not found locally
pub fn content() -> Self {
Self {
strategy: GetStrategy::Content,
}
}
}
impl Default for GetOptions {
fn default() -> Self {
Self::latest()
}
}
#[derive(PartialEq, Debug, Clone, Copy, Serialize, Deserialize)]
/// Describes the get call and what information
/// the caller is concerned about.
/// This helps the subconscious avoid unnecessary network calls.
pub enum GetStrategy {
/// Will try to get the latest metadata but fallback
/// to the cache if none is found.
/// Does not go to the network if you are an authority for the data.
Latest,
/// Will try to get the content locally but go
/// to the network if it is not found.
/// Does not go to the network if you are an authority for the data.
Content,
}
/// Zome input to create an entry.
#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, SerializedBytes)]
pub struct CreateInput {
/// The global type index for this entry (if it has one).
pub entry_location: EntryDefLocation,
/// The visibility of this entry.
pub entry_visibility: EntryVisibility,
/// Entry body.
pub entry: crate::entry::Entry,
/// ChainTopBehaviour for the write.
pub chain_top_ordering: ChainTopOrdering,
}
impl CreateInput {
/// Constructor.
pub fn new(
entry_location: impl Into<EntryDefLocation>,
entry_visibility: EntryVisibility,
entry: crate::entry::Entry,
chain_top_ordering: ChainTopOrdering,
) -> Self {
Self {
entry_location: entry_location.into(),
entry_visibility,
entry,
chain_top_ordering,
}
}
/// Consume into an Entry.
pub fn into_entry(self) -> Entry {
self.entry
}
/// Accessor.
pub fn chain_top_ordering(&self) -> &ChainTopOrdering {
&self.chain_top_ordering
}
}
impl AsRef<crate::Entry> for CreateInput {
fn as_ref(&self) -> &crate::Entry {
&self.entry
}
}
/// Zome input for get and get_details calls.
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct GetInput {
/// Any DHT hash to pass to get or get_details.
pub any_dht_hash: holo_hash::AnyDhtHash,
/// Options for the call.
pub get_options: crate::entry::GetOptions,
}
impl GetInput {
/// Constructor.
pub fn new(any_dht_hash: holo_hash::AnyDhtHash, get_options: crate::entry::GetOptions) -> Self {
Self {
any_dht_hash,
get_options,
}
}
}
/// Zome input type for all update operations.
#[derive(PartialEq, Debug, Deserialize, Serialize, Clone)]
pub struct UpdateInput {
/// Action of the record being updated.
pub original_action_address: holo_hash::ActionHash,
/// Entry body.
pub entry: crate::entry::Entry,
/// ChainTopBehaviour for the write.
pub chain_top_ordering: ChainTopOrdering,
}
/// Zome input for all delete operations.
#[derive(PartialEq, Debug, Deserialize, Serialize, Clone)]
pub struct DeleteInput {
/// Action of the record being deleted.
pub deletes_action_hash: holo_hash::ActionHash,
/// Chain top ordering behaviour for the delete.
pub chain_top_ordering: ChainTopOrdering,
}
impl DeleteInput {
/// Constructor.
pub fn new(
deletes_action_hash: holo_hash::ActionHash,
chain_top_ordering: ChainTopOrdering,
) -> Self {
Self {
deletes_action_hash,
chain_top_ordering,
}
}
}
impl From<holo_hash::ActionHash> for DeleteInput {
/// Sets [`ChainTopOrdering`] to `default` = `Strict` when created from a hash.
fn from(deletes_action_hash: holo_hash::ActionHash) -> Self {
Self {
deletes_action_hash,
chain_top_ordering: ChainTopOrdering::default(),
}
}
}
impl EntryDefLocation {
/// Create an [`EntryDefLocation::App`].
pub fn app(
zome_index: impl Into<ZomeIndex>,
entry_def_index: impl Into<EntryDefIndex>,
) -> Self {
Self::App(AppEntryDefLocation {
zome_index: zome_index.into(),
entry_def_index: entry_def_index.into(),
})
}
}
impl From<ScopedEntryDefIndex> for AppEntryDefLocation {
fn from(s: ScopedEntryDefIndex) -> Self {
Self {
zome_index: s.zome_index,
entry_def_index: s.zome_type,
}
}
}
impl From<ScopedEntryDefIndex> for EntryDefLocation {
fn from(s: ScopedEntryDefIndex) -> Self {
Self::App(s.into())
}
}
/// Check the entry variant matches the variant in the actions entry type
pub fn entry_type_matches(entry_type: &EntryType, entry: &Entry) -> bool {
#[allow(clippy::match_like_matches_macro)]
match (entry_type, entry) {
(EntryType::AgentPubKey, Entry::Agent(_)) => true,
(EntryType::App(_), Entry::App(_)) => true,
(EntryType::App(_), Entry::CounterSign(_, _)) => true,
(EntryType::CapClaim, Entry::CapClaim(_)) => true,
(EntryType::CapGrant, Entry::CapGrant(_)) => true,
_ => false,
}
}