use super::connection_manager::ConnectionState;
use super::database::{ReplicaDatabase, replicache_name};
use super::engine::{Engine, MutatorFn, MutatorResult, UpdateNeededReason, ZeroOptions};
use super::inspector::{Inspector, InspectorHost};
use super::query_context::{MaterializedView, Preload, RunType, WeakView};
use super::storage::DroppedDatabases;
use super::transaction::Transaction;
use super::{ApplicationError, Deferred, Error, Scheduler, SocketFactory};
use crate::ivm::ViewValue;
use crate::json::Value;
use crate::query::{AnyQuery, ZeroQuery};
use crate::schema::Schema;
use crate::ttl::Ttl;
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use std::sync::Arc;
type MutatorBody<C> = dyn Fn(&Transaction, Option<&Value>, &C) -> Result<Option<Value>, Error>;
pub struct Mutator<C> {
pub name: String,
body: Rc<MutatorBody<C>>,
}
impl<C> Clone for Mutator<C> {
fn clone(&self) -> Self {
Mutator {
name: self.name.clone(),
body: self.body.clone(),
}
}
}
impl<C> Mutator<C> {
pub fn new(
name: impl Into<String>,
body: impl Fn(&Transaction, Option<&Value>, &C) -> Result<Option<Value>, Error> + 'static,
) -> Self {
Mutator {
name: name.into(),
body: Rc::new(body),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct MutateRequest {
pub name: String,
pub args: Option<Value>,
}
impl MutateRequest {
pub fn new(name: impl Into<String>, args: Option<Value>) -> Self {
MutateRequest {
name: name.into(),
args,
}
}
}
pub struct Zero<C = ()> {
core: Rc<Core>,
context: Rc<C>,
}
struct Core {
engine: RefCell<Rc<Engine>>,
schema: Arc<Schema>,
options: ZeroOptions,
functions: Rc<HashMap<String, MutatorFn>>,
scheduler: Rc<dyn Scheduler>,
socket_factory: Option<Rc<dyn SocketFactory>>,
connection: Connection,
views: RefCell<Vec<(WeakView, AnyQuery, Ttl)>>,
preloads: RefCell<Vec<Rc<PreloadRecord>>>,
inspector: RefCell<Option<Rc<InspectorHost>>>,
}
struct PreloadRecord {
query: AnyQuery,
ttl: Ttl,
cleanup: RefCell<Rc<dyn Fn()>>,
active: Cell<bool>,
}
impl<C: 'static> Zero<C> {
pub fn new(
schema: Arc<Schema>,
context: C,
mutators: Vec<Mutator<C>>,
options: ZeroOptions,
scheduler: Rc<dyn Scheduler>,
socket_factory: Option<Rc<dyn SocketFactory>>,
) -> Result<Self, Error> {
let context = Rc::new(context);
let mut functions: HashMap<String, MutatorFn> = HashMap::new();
for m in mutators {
if functions.contains_key(&m.name) {
return Err(ApplicationError::new(format!(
"Mutator \"{}\" is registered twice",
m.name
))
.into());
}
let (body, context) = (m.body.clone(), context.clone());
functions.insert(m.name, Rc::new(move |tx, args| body(tx, args, &context)));
}
let functions = Rc::new(functions);
let engine = Engine::new(
schema.clone(),
options.clone(),
functions.clone(),
scheduler.clone(),
socket_factory.clone(),
true,
)?;
let connection = Connection::new(engine.clone());
let core = Rc::new(Core {
engine: RefCell::new(engine.clone()),
schema,
options,
functions,
scheduler,
socket_factory,
connection,
views: RefCell::default(),
preloads: RefCell::default(),
inspector: RefCell::default(),
});
Core::attach(&core, &engine);
Ok(Zero { core, context })
}
fn engine(&self) -> Rc<Engine> {
self.core.engine()
}
pub fn client_id(&self) -> String {
self.engine().client_id.clone()
}
pub fn client_group_id(&self) -> String {
self.engine().client_group_id.clone()
}
pub fn user_id(&self) -> Option<&str> {
self.core.options.user_id.as_deref()
}
pub fn schema(&self) -> &Arc<Schema> {
&self.core.schema
}
pub fn context(&self) -> &C {
&self.context
}
pub fn closed(&self) -> bool {
self.engine().closed()
}
pub fn connection(&self) -> &Connection {
&self.core.connection
}
pub fn materialize(
&self,
query: &(impl ZeroQuery<C> + ?Sized),
ttl: &Ttl,
) -> Result<MaterializedView, Error> {
let query = query.any_query(self.context());
let e = self.engine();
let view = e.event_loop.call(|| e.context.materialize(&query, ttl))?;
let mut views = self.core.views.borrow_mut();
views.retain(|(v, _, _)| v.upgrade().is_some_and(|v| !v.is_destroyed()));
views.push((view.downgrade(), query.into_owned(), ttl.clone()));
Ok(view)
}
pub fn run(
&self,
query: &(impl ZeroQuery<C> + ?Sized),
run_type: RunType,
ttl: Option<&Ttl>,
) -> Deferred<ViewValue> {
let query = query.any_query(self.context());
let e = self.engine();
e.event_loop.call(|| e.context.run(&query, run_type, ttl))
}
pub fn preload(&self, query: &(impl ZeroQuery<C> + ?Sized), ttl: &Ttl) -> Preload {
let query = query.any_query(self.context());
let e = self.engine();
let preload = e.event_loop.call(|| e.context.preload(&query, ttl));
let record = Rc::new(PreloadRecord {
query: query.into_owned(),
ttl: ttl.clone(),
cleanup: RefCell::new(preload.cleanup),
active: Cell::new(true),
});
let mut preloads = self.core.preloads.borrow_mut();
preloads.retain(|p| p.active.get());
preloads.push(record.clone());
Preload {
cleanup: Rc::new(move || {
record.active.set(false);
let cleanup = record.cleanup.borrow().clone();
cleanup();
}),
cached: preload.cached,
complete: preload.complete,
}
}
pub fn inspector(&self) -> Inspector<C> {
let host = self
.core
.inspector
.borrow_mut()
.get_or_insert_with(|| {
let core = Rc::downgrade(&self.core);
Rc::new(InspectorHost {
engine: Box::new(move || core.upgrade().map(|c| c.engine())),
schema: self.core.schema.clone(),
admin_password: RefCell::new(None),
})
})
.clone();
self.engine().query_manager.keep_evicted();
Inspector {
host,
context: self.context.clone(),
client_id: self.client_id(),
client_group_id: self.client_group_id(),
}
}
pub fn mutate(&self, name: &str, args: Option<Value>) -> MutatorResult {
let e = self.engine();
e.event_loop.call(|| e.mutate(name, args))
}
pub fn mutate_request(&self, request: MutateRequest) -> MutatorResult {
self.mutate(&request.name, request.args)
}
pub fn set_visible(&self, visible: bool) {
let e = self.engine();
e.event_loop.call(|| e.set_visible(visible));
}
pub fn reconnect_now(&self) {
let e = self.engine();
e.event_loop.call(|| e.reconnect_now());
}
pub fn when_pending_settled(&self, done: impl FnOnce() + 'static) {
let e = self.engine();
e.event_loop.call(|| e.when_pending_settled(done));
}
#[doc(hidden)]
pub fn dispatch<T>(&self, body: impl FnOnce() -> T) -> T {
self.engine().event_loop.dispatch(body)
}
pub fn close(&self) {
let e = self.engine();
e.event_loop.call(|| e.close());
}
pub fn flush_storage(&self) {
self.engine().database.flush();
}
pub fn delete(&self) -> DroppedDatabases {
self.close();
let name = replicache_name(&self.engine().database.name);
ReplicaDatabase::drop_matching(&self.core.options.storage, &|n| n == name)
}
}
impl Core {
fn engine(&self) -> Rc<Engine> {
self.engine.borrow().clone()
}
fn attach(core: &Rc<Core>, engine: &Rc<Engine>) {
let connection = Rc::downgrade(&core.connection.0);
*engine.on_update_needed.borrow_mut() = Some(Rc::new(move |reason| {
if let Some(c) = connection.upgrade() {
*c.update_needed.borrow_mut() = Some(reason.clone());
}
}));
if core.options.on_client_state_not_found.is_none() {
let core = Rc::downgrade(core);
*engine.on_client_state_not_found.borrow_mut() = Some(Rc::new(move || {
if let Some(core) = core.upgrade() {
Core::replace(&core);
}
}));
}
}
fn replace(core: &Rc<Core>) {
let old = core.engine();
if old.closed() {
return;
}
let mut options = core.options.clone();
let auth = old.auth.borrow().clone();
options.auth = (!auth.is_empty()).then_some(auth);
let new = match Engine::new(
core.schema.clone(),
options,
core.functions.clone(),
core.scheduler.clone(),
core.socket_factory.clone(),
old.visible.get(),
) {
Ok(new) => new,
Err(e) => {
old.log
.error(|| format!("Failed to replace the client: {e}"));
return;
}
};
*core.engine.borrow_mut() = new.clone();
Core::attach(core, &new);
core.connection.bind(new.clone());
let views: Vec<_> = {
let mut views = core.views.borrow_mut();
views.retain(|(v, _, _)| v.upgrade().is_some_and(|v| !v.is_destroyed()));
views
.iter()
.filter_map(|(v, q, t)| Some((v.upgrade()?, q.clone(), t.clone())))
.collect()
};
for (view, query, ttl) in views {
if let Ok(fresh) = new
.event_loop
.call(|| new.context.materialize(&query, &ttl))
{
view.rebind(fresh);
}
}
let preloads: Vec<_> = {
let mut preloads = core.preloads.borrow_mut();
preloads.retain(|p| p.active.get());
preloads.clone()
};
for record in preloads {
let preload = new
.event_loop
.call(|| new.context.preload(&record.query, &record.ttl));
*record.cleanup.borrow_mut() = preload.cleanup;
}
old.event_loop.call(|| old.close());
}
}
impl<C> Drop for Zero<C> {
fn drop(&mut self) {
let e = self.core.engine();
e.event_loop.call(|| e.close());
}
}
type StateListener = Rc<dyn Fn(&ConnectionState)>;
struct ConnectionInner {
engine: RefCell<Rc<Engine>>,
generation: Cell<u64>,
state: RefCell<ConnectionState>,
update_needed: RefCell<Option<UpdateNeededReason>>,
listeners: RefCell<Vec<(u64, StateListener)>>,
next_id: Cell<u64>,
}
#[derive(Clone)]
pub struct Connection(Rc<ConnectionInner>);
impl Connection {
fn new(engine: Rc<Engine>) -> Self {
let inner = Rc::new(ConnectionInner {
state: RefCell::new(ConnectionState::of(&engine.connection_manager.state())),
engine: RefCell::new(engine.clone()),
generation: Cell::new(0),
update_needed: RefCell::new(None),
listeners: RefCell::default(),
next_id: Cell::new(0),
});
let connection = Connection(inner);
connection.listen(&engine);
connection
}
fn bind(&self, engine: Rc<Engine>) {
*self.0.engine.borrow_mut() = engine.clone();
self.0.generation.set(self.0.generation.get() + 1);
self.listen(&engine);
self.0
.changed(ConnectionState::of(&engine.connection_manager.state()));
}
fn listen(&self, engine: &Engine) {
let weak = Rc::downgrade(&self.0);
let generation = self.0.generation.get();
let _ = engine.connection_manager.subscribe(move |s| {
let Some(inner) = weak.upgrade() else { return };
if inner.generation.get() == generation {
inner.changed(ConnectionState::of(s));
}
});
}
pub fn state(&self) -> ConnectionState {
self.0.state.borrow().clone()
}
pub fn update_needed(&self) -> Option<UpdateNeededReason> {
self.0.update_needed.borrow().clone()
}
pub fn subscribe(&self, listener: impl Fn(&ConnectionState) + 'static) -> Box<dyn Fn()> {
let id = self.0.next_id.get();
self.0.next_id.set(id + 1);
self.0.listeners.borrow_mut().push((id, Rc::new(listener)));
let weak = Rc::downgrade(&self.0);
Box::new(move || {
if let Some(inner) = weak.upgrade() {
inner.listeners.borrow_mut().retain(|(i, _)| *i != id);
}
})
}
pub fn connect(&self, auth: Option<String>) {
let e = self.0.engine.borrow().clone();
e.event_loop.call(|| e.connect(auth.map(Some)));
}
}
impl ConnectionInner {
fn changed(&self, state: ConnectionState) {
*self.state.borrow_mut() = state.clone();
let listeners: Vec<_> = self
.listeners
.borrow()
.iter()
.map(|(_, l)| l.clone())
.collect();
for l in listeners {
l(&state);
}
}
}