nixstore 0.2.1

nixstore — read-only Nix store path-info from db.sqlite
Documentation
//! Capability keys and providers for nixstore DI 3.0.

use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};

use id_effect::{Cap, Env, caps, mock_capability, provide};
use rusqlite::Connection;

use crate::db::{open_store_db, query_path_info};
use crate::error::InfraError;
use crate::model::{PathInfo, QueryOpts};

/// Read path-info for store paths.
pub trait PathInfoStore: Send + Sync {
  fn query(&self, path: &str, opts: QueryOpts) -> Result<PathInfo, InfraError>;
}

/// Sqlite-backed store; opens DB under `store_root` on each query (RO URI).
#[derive(Debug, Clone)]
pub struct SqlitePathInfoStore {
  pub store_root: PathBuf,
}

impl SqlitePathInfoStore {
  pub fn new(store_root: impl Into<PathBuf>) -> Self {
    Self {
      store_root: store_root.into(),
    }
  }

  pub fn from_default() -> Self {
    Self::new(crate::db::DEFAULT_STORE_ROOT)
  }

  fn conn(&self) -> Result<Connection, InfraError> {
    open_store_db(&self.store_root)
  }
}

impl PathInfoStore for SqlitePathInfoStore {
  fn query(&self, path: &str, opts: QueryOpts) -> Result<PathInfo, InfraError> {
    let conn = self.conn()?;
    query_path_info(&conn, path, opts)
  }
}

/// In-memory path-info for tests.
#[derive(Default)]
pub struct MockPathInfoStore {
  pub paths: Mutex<HashMap<String, PathInfo>>,
}

impl MockPathInfoStore {
  pub fn set(&self, info: PathInfo) {
    self.paths.lock().unwrap().insert(info.path.clone(), info);
  }
}

impl PathInfoStore for MockPathInfoStore {
  fn query(&self, path: &str, opts: QueryOpts) -> Result<PathInfo, InfraError> {
    let mut info = self
      .paths
      .lock()
      .unwrap()
      .get(path)
      .cloned()
      .ok_or_else(|| InfraError::UnknownPath(path.into()))?;
    if !opts.include_referrers {
      info.referrers = None;
    }
    if !opts.include_closure_size {
      info.closure_size = None;
    }
    Ok(info)
  }
}

pub type PathInfoStoreKey = Arc<dyn PathInfoStore>;

pub type NixstoreEnv = caps!(PathInfoStoreKey);

#[derive(::id_effect::ProviderSpecDerive)]
#[provides(PathInfoStoreKey)]
pub struct SqlitePathInfoStoreLive;

impl SqlitePathInfoStoreLive {
  #[allow(clippy::new_ret_no_self)] // ProviderSpecDerive factory returns capability key
  fn new() -> PathInfoStoreKey {
    Arc::new(SqlitePathInfoStore::from_default())
  }
}

mock_capability!(
  MockPathInfoStoreLive,
  PathInfoStoreKey,
  "pathinfo/mock",
  || Arc::new(MockPathInfoStore::default()) as PathInfoStoreKey
);

pub fn live_providers() -> [id_effect::ProviderBox; 1] {
  [provide!(SqlitePathInfoStoreLive)]
}

/// Providers with a custom store root (CLI `--store`, fixtures).
pub fn providers_for_store(store_root: impl Into<PathBuf>) -> Env {
  let mut env = Env::new();
  let store: PathInfoStoreKey = Arc::new(SqlitePathInfoStore::new(store_root));
  env.insert::<Cap<PathInfoStoreKey>>(store);
  env
}

#[cfg(test)]
pub fn mock_providers() -> [id_effect::ProviderBox; 1] {
  [provide!(MockPathInfoStoreLive)]
}

#[cfg(test)]
mod tests {
  use super::*;
  use id_effect::{Effect, Exit, FromEnv, Needs, build_env, run_test};

  #[test]
  fn mock_query() {
    let mock = MockPathInfoStore::default();
    mock.set(PathInfo {
      path: "/nix/store/x".into(),
      nar_hash: "sha256-x".into(),
      nar_size: 1,
      deriver: None,
      registration_time: 0,
      ultimate: false,
      signatures: vec![],
      ca: None,
      references: vec![],
      referrers: Some(vec!["/nix/store/y".into()]),
      closure_size: Some(1),
    });
    let info = mock.query("/nix/store/x", QueryOpts::default()).expect("q");
    assert!(info.referrers.is_none());
    assert!(info.closure_size.is_none());
  }

  #[test]
  fn build_env_materializes_mock_caps() {
    let env = build_env(mock_providers()).expect("env");
    assert!(env.has::<Cap<PathInfoStoreKey>>());
  }

  #[test]
  fn run_test_reads_caps() {
    let env = NixstoreEnv::from_env(build_env(mock_providers()).expect("env"));
    let effect: Effect<bool, (), NixstoreEnv> = Effect::new(|env| {
      let _ = Needs::<PathInfoStoreKey>::need(env);
      Ok(true)
    });
    assert_eq!(run_test(effect, env), Exit::Success(true));
  }

  #[test]
  fn providers_for_store_inserts_cap() {
    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/minimal");
    let env = providers_for_store(&root);
    assert!(env.has::<Cap<PathInfoStoreKey>>());
  }
}