AppFlowy/frontend/rust-lib/flowy-revision-persistence/src/lib.rs

mod disk_cache_impl;

use flowy_error::{FlowyError, FlowyResult};
use revision_model::{Revision, RevisionRange};
use std::fmt::Debug;
use std::sync::Arc;

pub trait RevisionDiskCache<Connection>: Sync + Send {
  type Error: Debug;
  fn create_revision_records(&self, revision_records: Vec<SyncRecord>) -> Result<(), Self::Error>;

  fn get_connection(&self) -> Result<Connection, Self::Error>;

  // Read all the records if the rev_ids is None
  fn read_revision_records(
    &self,
    object_id: &str,
    rev_ids: Option<Vec<i64>>,
  ) -> Result<Vec<SyncRecord>, Self::Error>;

  // Read the revision which rev_id >= range.start && rev_id <= range.end
  fn read_revision_records_with_range(
    &self,
    object_id: &str,
    range: &RevisionRange,
  ) -> Result<Vec<SyncRecord>, Self::Error>;

  fn update_revision_record(&self, changesets: Vec<RevisionChangeset>) -> FlowyResult<()>;

  // Delete all the records if the rev_ids is None
  fn delete_revision_records(
    &self,
    object_id: &str,
    rev_ids: Option<Vec<i64>>,
  ) -> Result<(), Self::Error>;

  // Delete and insert will be executed in the same transaction.
  // It deletes all the records if the deleted_rev_ids is None and then insert the new records
  fn delete_and_insert_records(
    &self,
    object_id: &str,
    deleted_rev_ids: Option<Vec<i64>>,
    inserted_records: Vec<SyncRecord>,
  ) -> Result<(), Self::Error>;
}

impl<T, Connection> RevisionDiskCache<Connection> for Arc<T>
where
  T: RevisionDiskCache<Connection, Error = FlowyError>,
{
  type Error = FlowyError;

  fn create_revision_records(&self, revision_records: Vec<SyncRecord>) -> Result<(), Self::Error> {
    (**self).create_revision_records(revision_records)
  }

  fn get_connection(&self) -> Result<Connection, Self::Error> {
    (**self).get_connection()
  }

  fn read_revision_records(
    &self,
    object_id: &str,
    rev_ids: Option<Vec<i64>>,
  ) -> Result<Vec<SyncRecord>, Self::Error> {
    (**self).read_revision_records(object_id, rev_ids)
  }

  fn read_revision_records_with_range(
    &self,
    object_id: &str,
    range: &RevisionRange,
  ) -> Result<Vec<SyncRecord>, Self::Error> {
    (**self).read_revision_records_with_range(object_id, range)
  }

  fn update_revision_record(&self, changesets: Vec<RevisionChangeset>) -> FlowyResult<()> {
    (**self).update_revision_record(changesets)
  }

  fn delete_revision_records(
    &self,
    object_id: &str,
    rev_ids: Option<Vec<i64>>,
  ) -> Result<(), Self::Error> {
    (**self).delete_revision_records(object_id, rev_ids)
  }

  fn delete_and_insert_records(
    &self,
    object_id: &str,
    deleted_rev_ids: Option<Vec<i64>>,
    inserted_records: Vec<SyncRecord>,
  ) -> Result<(), Self::Error> {
    (**self).delete_and_insert_records(object_id, deleted_rev_ids, inserted_records)
  }
}

#[derive(Clone, Debug)]
pub struct SyncRecord {
  pub revision: Revision,
  pub state: RevisionState,
  pub write_to_disk: bool,
}

impl SyncRecord {
  pub fn new(revision: Revision) -> Self {
    Self {
      revision,
      state: RevisionState::Sync,
      write_to_disk: true,
    }
  }

  pub fn ack(&mut self) {
    self.state = RevisionState::Ack;
  }
}

pub struct RevisionChangeset {
  pub object_id: String,
  pub rev_id: i64,
  pub state: RevisionState,
}

/// Sync: revision is not synced to the server
/// Ack: revision is synced to the server
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum RevisionState {
  Sync = 0,
  Ack = 1,
}

impl RevisionState {
  pub fn is_need_sync(&self) -> bool {
    match self {
      RevisionState::Sync => true,
      RevisionState::Ack => false,
    }
  }
}

impl AsRef<RevisionState> for RevisionState {
  fn as_ref(&self) -> &RevisionState {
    self
  }
}