icydb 0.201.2

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
Documentation 
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

//! Module: traits
//!
//! Responsibility: public trait facade and application entity contract.
//! Does not own: core trait implementation semantics.
//! Boundary: re-exports stable trait names and narrows facade-only contracts.

pub use icydb_core::db::{EntityKey, EntityKeyBytes, EntityKeyBytesError};
pub use icydb_core::traits::{
    Add, AddAssign, CanisterKind, Debug, Default, Deserialize, DeserializeOwned, Div, DivAssign,
    EntityCreateInput, EntityCreateMaterialization, EntityCreateType, EntityKind, EntityPlacement,
    EntitySchema, Eq, FieldTypeMeta, From, Hash, Inner, Kind, Mul, MulAssign, NumericValue,
    Ordering, PartialEq, Path, Rem, Serialize, SingletonEntity, Storable, StoreKind, Sub,
    SubAssign, TypeKind,
};
pub use icydb_core::value::{Collection, MapCollection};
pub use icydb_core::visitor::{
    Sanitize, SanitizeAuto, SanitizeCustom, Sanitizer, Validate, ValidateAuto, ValidateCustom,
    Validator, Visitable,
};

///
/// Entity
///
/// Public semantic entity contract for application and repository helpers.
///
/// This trait intentionally hides the lower-level persisted-row and
/// value-projection traits from normal generic bounds. Runtime/session internals
/// still use those storage contracts directly where they encode, decode, plan,
/// or execute persisted rows.
///

pub trait Entity: icydb_core::db::PersistedRow {}

impl<T> Entity for T where T: icydb_core::db::PersistedRow {}

///
/// EntityFor
///
/// Session-local entity contract for APIs that must prove an entity is wired to
/// the current canister's generated store registry.
///
/// Application helpers should prefer `Entity` unless they are themselves
/// generic over a concrete `DbSession<C>`.
///

pub trait EntityFor<C: CanisterKind>: Entity<Canister = C> {}

impl<T, C> EntityFor<C> for T
where
    T: Entity<Canister = C>,
    C: CanisterKind,
{
}

///
/// CreateInput
///
/// Public semantic create-input contract for authored insert payloads.
///
/// Generated create input types implement the lower-level materialization
/// bridge; this trait is the application-facing name for that intent.
///

pub trait CreateInput: EntityCreateInput
where
    Self::Entity: Entity,
{
}

impl<T> CreateInput for T
where
    T: EntityCreateInput,
    T::Entity: Entity,
{
}

///
/// CreateInputFor
///
/// Session-local create-input contract for APIs that must prove the materialized
/// entity is wired to the current canister's generated store registry.
///

pub trait CreateInputFor<C: CanisterKind>: CreateInput
where
    Self::Entity: EntityFor<C>,
{
}

impl<T, C> CreateInputFor<C> for T
where
    T: CreateInput,
    T::Entity: EntityFor<C>,
    C: CanisterKind,
{
}