1use super::connection_manager::ConnectionState;
5use super::database::{ReplicaDatabase, replicache_name};
6use super::engine::{Engine, MutatorFn, MutatorResult, UpdateNeededReason, ZeroOptions};
7use super::inspector::{Inspector, InspectorHost};
8use super::query_context::{MaterializedView, Preload, RunType, WeakView};
9use super::storage::DroppedDatabases;
10use super::transaction::Transaction;
11use super::{ApplicationError, Deferred, Error, Scheduler, SocketFactory};
12use crate::ivm::ViewValue;
13use crate::json::Value;
14use crate::query::{AnyQuery, ZeroQuery};
15use crate::schema::Schema;
16use crate::ttl::Ttl;
17use std::cell::{Cell, RefCell};
18use std::collections::HashMap;
19use std::rc::Rc;
20use std::sync::Arc;
21
22type MutatorBody<C> = dyn Fn(&Transaction, Option<&Value>, &C) -> Result<Option<Value>, Error>;
23
24pub struct Mutator<C> {
33 pub name: String,
35 body: Rc<MutatorBody<C>>,
36}
37
38impl<C> Clone for Mutator<C> {
39 fn clone(&self) -> Self {
40 Mutator {
41 name: self.name.clone(),
42 body: self.body.clone(),
43 }
44 }
45}
46
47impl<C> Mutator<C> {
48 pub fn new(
51 name: impl Into<String>,
52 body: impl Fn(&Transaction, Option<&Value>, &C) -> Result<Option<Value>, Error> + 'static,
53 ) -> Self {
54 Mutator {
55 name: name.into(),
56 body: Rc::new(body),
57 }
58 }
59}
60
61#[derive(Clone, Debug, PartialEq)]
65pub struct MutateRequest {
66 pub name: String,
68 pub args: Option<Value>,
70}
71
72impl MutateRequest {
73 pub fn new(name: impl Into<String>, args: Option<Value>) -> Self {
76 MutateRequest {
77 name: name.into(),
78 args,
79 }
80 }
81}
82
83pub struct Zero<C = ()> {
91 core: Rc<Core>,
92 context: Rc<C>,
93}
94
95struct Core {
99 engine: RefCell<Rc<Engine>>,
100 schema: Arc<Schema>,
101 options: ZeroOptions,
102 functions: Rc<HashMap<String, MutatorFn>>,
103 scheduler: Rc<dyn Scheduler>,
104 socket_factory: Option<Rc<dyn SocketFactory>>,
105 connection: Connection,
106 views: RefCell<Vec<(WeakView, AnyQuery, Ttl)>>,
107 preloads: RefCell<Vec<Rc<PreloadRecord>>>,
108 inspector: RefCell<Option<Rc<InspectorHost>>>,
110}
111
112struct PreloadRecord {
115 query: AnyQuery,
116 ttl: Ttl,
117 cleanup: RefCell<Rc<dyn Fn()>>,
118 active: Cell<bool>,
119}
120
121impl<C: 'static> Zero<C> {
122 pub fn new(
137 schema: Arc<Schema>,
138 context: C,
139 mutators: Vec<Mutator<C>>,
140 options: ZeroOptions,
141 scheduler: Rc<dyn Scheduler>,
142 socket_factory: Option<Rc<dyn SocketFactory>>,
143 ) -> Result<Self, Error> {
144 let context = Rc::new(context);
145 let mut functions: HashMap<String, MutatorFn> = HashMap::new();
146 for m in mutators {
147 if functions.contains_key(&m.name) {
148 return Err(ApplicationError::new(format!(
149 "Mutator \"{}\" is registered twice",
150 m.name
151 ))
152 .into());
153 }
154 let (body, context) = (m.body.clone(), context.clone());
155 functions.insert(m.name, Rc::new(move |tx, args| body(tx, args, &context)));
156 }
157 let functions = Rc::new(functions);
158 let engine = Engine::new(
159 schema.clone(),
160 options.clone(),
161 functions.clone(),
162 scheduler.clone(),
163 socket_factory.clone(),
164 true,
165 )?;
166 let connection = Connection::new(engine.clone());
167 let core = Rc::new(Core {
168 engine: RefCell::new(engine.clone()),
169 schema,
170 options,
171 functions,
172 scheduler,
173 socket_factory,
174 connection,
175 views: RefCell::default(),
176 preloads: RefCell::default(),
177 inspector: RefCell::default(),
178 });
179 Core::attach(&core, &engine);
180 Ok(Zero { core, context })
181 }
182
183 fn engine(&self) -> Rc<Engine> {
184 self.core.engine()
185 }
186
187 pub fn client_id(&self) -> String {
189 self.engine().client_id.clone()
190 }
191
192 pub fn client_group_id(&self) -> String {
195 self.engine().client_group_id.clone()
196 }
197
198 pub fn user_id(&self) -> Option<&str> {
200 self.core.options.user_id.as_deref()
201 }
202
203 pub fn schema(&self) -> &Arc<Schema> {
205 &self.core.schema
206 }
207
208 pub fn context(&self) -> &C {
210 &self.context
211 }
212
213 pub fn closed(&self) -> bool {
215 self.engine().closed()
216 }
217
218 pub fn connection(&self) -> &Connection {
220 &self.core.connection
221 }
222
223 pub fn materialize(
226 &self,
227 query: &(impl ZeroQuery<C> + ?Sized),
228 ttl: &Ttl,
229 ) -> Result<MaterializedView, Error> {
230 let query = query.any_query(self.context());
231 let e = self.engine();
232 let view = e.event_loop.call(|| e.context.materialize(&query, ttl))?;
233 let mut views = self.core.views.borrow_mut();
234 views.retain(|(v, _, _)| v.upgrade().is_some_and(|v| !v.is_destroyed()));
235 views.push((view.downgrade(), query.into_owned(), ttl.clone()));
236 Ok(view)
237 }
238
239 pub fn run(
246 &self,
247 query: &(impl ZeroQuery<C> + ?Sized),
248 run_type: RunType,
249 ttl: Option<&Ttl>,
250 ) -> Deferred<ViewValue> {
251 let query = query.any_query(self.context());
252 let e = self.engine();
253 e.event_loop.call(|| e.context.run(&query, run_type, ttl))
254 }
255
256 pub fn preload(&self, query: &(impl ZeroQuery<C> + ?Sized), ttl: &Ttl) -> Preload {
260 let query = query.any_query(self.context());
261 let e = self.engine();
262 let preload = e.event_loop.call(|| e.context.preload(&query, ttl));
263 let record = Rc::new(PreloadRecord {
264 query: query.into_owned(),
265 ttl: ttl.clone(),
266 cleanup: RefCell::new(preload.cleanup),
267 active: Cell::new(true),
268 });
269 let mut preloads = self.core.preloads.borrow_mut();
270 preloads.retain(|p| p.active.get());
271 preloads.push(record.clone());
272 Preload {
273 cleanup: Rc::new(move || {
274 record.active.set(false);
275 let cleanup = record.cleanup.borrow().clone();
276 cleanup();
277 }),
278 cached: preload.cached,
279 complete: preload.complete,
280 }
281 }
282
283 pub fn inspector(&self) -> Inspector<C> {
286 let host = self
287 .core
288 .inspector
289 .borrow_mut()
290 .get_or_insert_with(|| {
291 let core = Rc::downgrade(&self.core);
292 Rc::new(InspectorHost {
293 engine: Box::new(move || core.upgrade().map(|c| c.engine())),
294 schema: self.core.schema.clone(),
295 admin_password: RefCell::new(None),
296 })
297 })
298 .clone();
299 self.engine().query_manager.keep_evicted();
301 Inspector {
302 host,
303 context: self.context.clone(),
304 client_id: self.client_id(),
305 client_group_id: self.client_group_id(),
306 }
307 }
308
309 pub fn mutate(&self, name: &str, args: Option<Value>) -> MutatorResult {
313 let e = self.engine();
314 e.event_loop.call(|| e.mutate(name, args))
315 }
316
317 pub fn mutate_request(&self, request: MutateRequest) -> MutatorResult {
321 self.mutate(&request.name, request.args)
322 }
323
324 pub fn set_visible(&self, visible: bool) {
328 let e = self.engine();
329 e.event_loop.call(|| e.set_visible(visible));
330 }
331
332 pub fn reconnect_now(&self) {
334 let e = self.engine();
335 e.event_loop.call(|| e.reconnect_now());
336 }
337
338 pub fn when_pending_settled(&self, done: impl FnOnce() + 'static) {
341 let e = self.engine();
342 e.event_loop.call(|| e.when_pending_settled(done));
343 }
344
345 #[doc(hidden)]
348 pub fn dispatch<T>(&self, body: impl FnOnce() -> T) -> T {
349 self.engine().event_loop.dispatch(body)
350 }
351
352 pub fn close(&self) {
355 let e = self.engine();
356 e.event_loop.call(|| e.close());
357 }
358
359 pub fn flush_storage(&self) {
363 self.engine().database.flush();
364 }
365
366 pub fn delete(&self) -> DroppedDatabases {
371 self.close();
372 let name = replicache_name(&self.engine().database.name);
373 ReplicaDatabase::drop_matching(&self.core.options.storage, &|n| n == name)
374 }
375}
376
377impl Core {
378 fn engine(&self) -> Rc<Engine> {
379 self.engine.borrow().clone()
380 }
381
382 fn attach(core: &Rc<Core>, engine: &Rc<Engine>) {
385 let connection = Rc::downgrade(&core.connection.0);
386 *engine.on_update_needed.borrow_mut() = Some(Rc::new(move |reason| {
387 if let Some(c) = connection.upgrade() {
388 *c.update_needed.borrow_mut() = Some(reason.clone());
389 }
390 }));
391 if core.options.on_client_state_not_found.is_none() {
392 let core = Rc::downgrade(core);
393 *engine.on_client_state_not_found.borrow_mut() = Some(Rc::new(move || {
394 if let Some(core) = core.upgrade() {
395 Core::replace(&core);
396 }
397 }));
398 }
399 }
400
401 fn replace(core: &Rc<Core>) {
404 let old = core.engine();
405 if old.closed() {
406 return;
407 }
408 let mut options = core.options.clone();
411 let auth = old.auth.borrow().clone();
412 options.auth = (!auth.is_empty()).then_some(auth);
413 let new = match Engine::new(
414 core.schema.clone(),
415 options,
416 core.functions.clone(),
417 core.scheduler.clone(),
418 core.socket_factory.clone(),
419 old.visible.get(),
420 ) {
421 Ok(new) => new,
422 Err(e) => {
423 old.log
424 .error(|| format!("Failed to replace the client: {e}"));
425 return;
426 }
427 };
428 *core.engine.borrow_mut() = new.clone();
429 Core::attach(core, &new);
430 core.connection.bind(new.clone());
431 let views: Vec<_> = {
432 let mut views = core.views.borrow_mut();
433 views.retain(|(v, _, _)| v.upgrade().is_some_and(|v| !v.is_destroyed()));
434 views
435 .iter()
436 .filter_map(|(v, q, t)| Some((v.upgrade()?, q.clone(), t.clone())))
437 .collect()
438 };
439 for (view, query, ttl) in views {
440 if let Ok(fresh) = new
441 .event_loop
442 .call(|| new.context.materialize(&query, &ttl))
443 {
444 view.rebind(fresh);
445 }
446 }
447 let preloads: Vec<_> = {
448 let mut preloads = core.preloads.borrow_mut();
449 preloads.retain(|p| p.active.get());
450 preloads.clone()
451 };
452 for record in preloads {
453 let preload = new
454 .event_loop
455 .call(|| new.context.preload(&record.query, &record.ttl));
456 *record.cleanup.borrow_mut() = preload.cleanup;
457 }
458 old.event_loop.call(|| old.close());
459 }
460}
461
462impl<C> Drop for Zero<C> {
463 fn drop(&mut self) {
466 let e = self.core.engine();
467 e.event_loop.call(|| e.close());
468 }
469}
470
471type StateListener = Rc<dyn Fn(&ConnectionState)>;
472
473struct ConnectionInner {
474 engine: RefCell<Rc<Engine>>,
475 generation: Cell<u64>,
477 state: RefCell<ConnectionState>,
478 update_needed: RefCell<Option<UpdateNeededReason>>,
479 listeners: RefCell<Vec<(u64, StateListener)>>,
480 next_id: Cell<u64>,
481}
482
483#[derive(Clone)]
486pub struct Connection(Rc<ConnectionInner>);
487
488impl Connection {
489 fn new(engine: Rc<Engine>) -> Self {
490 let inner = Rc::new(ConnectionInner {
491 state: RefCell::new(ConnectionState::of(&engine.connection_manager.state())),
492 engine: RefCell::new(engine.clone()),
493 generation: Cell::new(0),
494 update_needed: RefCell::new(None),
495 listeners: RefCell::default(),
496 next_id: Cell::new(0),
497 });
498 let connection = Connection(inner);
499 connection.listen(&engine);
500 connection
501 }
502
503 fn bind(&self, engine: Rc<Engine>) {
505 *self.0.engine.borrow_mut() = engine.clone();
506 self.0.generation.set(self.0.generation.get() + 1);
507 self.listen(&engine);
508 self.0
509 .changed(ConnectionState::of(&engine.connection_manager.state()));
510 }
511
512 fn listen(&self, engine: &Engine) {
513 let weak = Rc::downgrade(&self.0);
514 let generation = self.0.generation.get();
515 let _ = engine.connection_manager.subscribe(move |s| {
518 let Some(inner) = weak.upgrade() else { return };
519 if inner.generation.get() == generation {
520 inner.changed(ConnectionState::of(s));
521 }
522 });
523 }
524
525 pub fn state(&self) -> ConnectionState {
527 self.0.state.borrow().clone()
528 }
529
530 pub fn update_needed(&self) -> Option<UpdateNeededReason> {
533 self.0.update_needed.borrow().clone()
534 }
535
536 pub fn subscribe(&self, listener: impl Fn(&ConnectionState) + 'static) -> Box<dyn Fn()> {
539 let id = self.0.next_id.get();
540 self.0.next_id.set(id + 1);
541 self.0.listeners.borrow_mut().push((id, Rc::new(listener)));
542 let weak = Rc::downgrade(&self.0);
543 Box::new(move || {
544 if let Some(inner) = weak.upgrade() {
545 inner.listeners.borrow_mut().retain(|(i, _)| *i != id);
546 }
547 })
548 }
549
550 pub fn connect(&self, auth: Option<String>) {
554 let e = self.0.engine.borrow().clone();
555 e.event_loop.call(|| e.connect(auth.map(Some)));
556 }
557}
558
559impl ConnectionInner {
560 fn changed(&self, state: ConnectionState) {
561 *self.state.borrow_mut() = state.clone();
562 let listeners: Vec<_> = self
563 .listeners
564 .borrow()
565 .iter()
566 .map(|(_, l)| l.clone())
567 .collect();
568 for l in listeners {
569 l(&state);
570 }
571 }
572}