cachekit-rs 0.7.0

Caching for Rust (beta). Supports cachekit.io SaaS, Redis, Memcached, local File, and Cloudflare Workers.
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
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

[package]
name = "cachekit-rs"
version = "0.7.0"
edition.workspace = true
rust-version.workspace = true
license.workspace = true
repository.workspace = true
description = "Caching for Rust (beta). Supports cachekit.io SaaS, Redis, Memcached, local File, and Cloudflare Workers."
readme = "../../README.md"
homepage = "https://cachekit.io"
keywords = ["cache", "redis", "encryption", "moka", "cloudflare-workers"]
categories = ["caching", "web-programming", "cryptography"]

[lib]
name = "cachekit"

[features]
default = ["cachekitio", "encryption", "l1", "reliability"]
cachekitio = ["dep:reqwest", "dep:serde_json"]
redis = ["dep:fred"]
# Memcached backend (native only). rust-memcache is sync (r2d2-pooled, socket
# read/write timeouts); ops run on tokio's blocking pool via spawn_blocking,
# each under a tokio/time budget so a wedged server can't hang callers.
memcached = ["dep:memcache", "tokio/rt", "tokio/time"]
# Local filesystem backend (native only). tokio/rt provides spawn_blocking so
# disk I/O never blocks the async executor; libc provides O_NOFOLLOW/ELOOP
# constants and rustix provides safe flock/geteuid on unix.
file = ["tokio/rt", "tokio/sync", "dep:libc", "dep:rustix"]
workers = ["dep:worker", "dep:js-sys", "dep:getrandom", "dep:serde_json"]
# cachekit-core's `encryption` feature folds aes-gcm in automatically on wasm32
# (`wasm` is a pure alias for `encryption`). No separate `cachekit-core/wasm`
# activation needed. Deliberately version-free: the fact is version-independent,
# and a pinned version in prose is the only part that rots (LAB-866 precedent).
encryption = ["cachekit-core/encryption"]
# tokio/rt provides Handle::try_current + spawn for the L1 stale-while-
# revalidate background refresh (native only — `workers`+`l1` is a compile
# error, so this never reaches wasm32).
l1 = ["dep:moka", "tokio/rt"]
macros = ["dep:cachekit-macros"]
# Retry with backoff + circuit breaker around backend ops, and cross-process
# cold-miss suppression via LockableBackend. Native only (needs tokio timers).
reliability = ["tokio/time"]
# Opt into ?Send / Rc on native targets (for tokio::task::LocalSet, single-threaded
# runtimes, etc.). Same code paths that wasm32 already uses.
unsync = []

[dependencies]
cachekit-core = { version = "0.4", features = ["messagepack"] }
serde = { version = "1", features = ["derive"] }
rmp-serde = "1"
thiserror = "2.0"
async-trait = "0.1"
blake2 = "0.10"
bytes = "1"
zeroize = { version = "1", features = ["derive"] }
urlencoding = "2"
hex = "0.4"
url = "2"
uuid = { version = "1", features = ["v4", "js"] }
# `sync` only: runtime-independent primitives for cold-miss single-flight.
# Compiles on wasm32. Features stack per consumer: `reliability` adds `time`
# (native only); the `memcached`/`file` backends add `rt` (spawn_blocking) —
# see the feature declarations above.
tokio = { version = "1", default-features = false, features = ["sync"] }

# Optional: HTTP backend (native)
reqwest = { version = "0.12", optional = true, default-features = false, features = ["rustls-tls", "json"] }
serde_json = { version = "1", optional = true }

# Optional: Redis backend. `i-scripts` exposes EVAL for the atomic
# compare-and-delete lock release (LockableBackend).
fred = { version = "9", optional = true, features = ["i-scripts"] }

# Optional: Memcached backend. rust-memcache with no default features — the
# `tls` feature would pull openssl into a rustls-only SDK (and the previously
# used async-memcached 0.6 shipped toxiproxy_rust/openssl as runtime deps,
# which is why it was dropped — expert panel, LAB-429). Held at 0.19: 0.20.0
# uses `is_multiple_of`/let-chains and breaks this workspace's 1.85 MSRV.
memcache = { version = "0.19", optional = true, default-features = false }

# Optional: L1 in-process cache
moka = { version = "0.12", optional = true, features = ["sync"] }

# Optional: Cloudflare Workers
worker = { version = "0.4", optional = true }
js-sys = { version = "0.3", optional = true }
getrandom = { version = "0.2", optional = true, features = ["js"] }

# Optional: proc-macro decorator
cachekit-macros = { version = "0.7.0", path = "../cachekit-macros", optional = true }

# Optional (file backend, unix only): libc for the O_NOFOLLOW/ELOOP constants
# (std has no portable spelling); rustix for safe flock/geteuid wrappers —
# this workspace forbids `unsafe`, so raw libc calls are off the table.
[target.'cfg(unix)'.dependencies]
libc = { version = "0.2", optional = true }
rustix = { version = "1", optional = true, default-features = false, features = ["fs", "process", "std"] }

# Non-optional on wasm32, regardless of features: `SystemTime::now()` panics on
# wasm32-unknown-unknown, so session.rs reads `js_sys::Date::now()` there
# (LAB-1079). Target-gated rather than feature-gated so every wasm32 build of
# session_headers() — workers AND cachekitio — gets the safe clock.
[target.'cfg(target_arch = "wasm32")'.dependencies]
js-sys = "0.3"

[dev-dependencies]
serde_json = "1"

# Native-only test machinery: tokio's rt-multi-thread (and tempfile's fs use)
# cannot build for wasm32, and cargo compiles the whole dev-dep graph whenever
# any integration test compiles — so these must not be in the wasm32 dev graph.
[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
tokio = { version = "1", features = ["macros", "rt-multi-thread", "sync", "time"] }
serial_test = "3"
tempfile = "3"

# wasm32 runtime tests (tests/wasm_session_tests.rs) — compile-only CI let the
# SystemTime::now() trap ship in five releases (LAB-1079). Exact-pinned because
# wasm-bindgen-test releases in lockstep with wasm-bindgen, and CI's
# wasm-bindgen-test-runner binary must match the locked wasm-bindgen version
# byte-for-byte (bump this, the lockfile, and the runner pin in ci.yml together).
[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
wasm-bindgen-test = "=0.3.71"

[lints]
workspace = true