nixq 0.2.1

nixq — JSON/attrpath query: get, hasAttrs, subset, force-path, normalize, diff
Documentation
//! Effect programs for CLI commands.

use std::path::PathBuf;

use id_effect::{Effect, Needs, effect};
use serde_json::Value;

use crate::caps::{JsonSourceKey, NixqEnv};
use crate::diff::{structural_diff, values_equal};
use crate::error::{InfraError, PathError, PredicateResult};
use crate::force_path::force_paths;
use crate::normalize::normalize_value;
use crate::optics::{value_contains_subset, value_has_attrs};
use crate::path::{get_at_path, parse_attrpath};

fn parse_json(bytes: &[u8]) -> Result<Value, InfraError> {
  serde_json::from_slice(bytes).map_err(|e| InfraError::Json(e.to_string()))
}

pub fn load_json(input: PathBuf) -> Effect<Value, InfraError, NixqEnv> {
  effect!(|r| {
      let src = (~JsonSourceKey).clone();
      let bytes = ~src.read(&input);
      ~parse_json(&bytes)
  })
}

pub fn cmd_get(input: PathBuf, attrpath: String) -> Effect<Value, InfraError, NixqEnv> {
  effect!(|r| {
      let src = (~JsonSourceKey).clone();
      let bytes = ~src.read(&input);
      let value = ~parse_json(&bytes);
      let path = ~parse_attrpath(&attrpath).map_err(|e| InfraError::Json(e.to_string()));
      ~get_at_path(&value, &path)
          .cloned()
          .ok_or_else(|| InfraError::Json(PathError::NotFound(path.display()).to_string()))
  })
}

pub fn cmd_has_attrs(
  input: PathBuf,
  attrs: Vec<String>,
) -> Effect<PredicateResult, InfraError, NixqEnv> {
  effect!(|r| {
      let src = (~JsonSourceKey).clone();
      let bytes = ~src.read(&input);
      let value = ~parse_json(&bytes);
      PredicateResult::from_bool(value_has_attrs(&value, &attrs))
  })
}

pub fn cmd_subset(
  input: PathBuf,
  expected: PathBuf,
) -> Effect<PredicateResult, InfraError, NixqEnv> {
  // Multi-read: Effect::new (effect! would join_binds2 adjacent ~reads).
  Effect::new(move |env| {
    let src = Needs::<JsonSourceKey>::need(env).clone();
    let actual = parse_json(&src.read(&input)?)?;
    let expect = parse_json(&src.read(&expected)?)?;
    Ok(PredicateResult::from_bool(value_contains_subset(
      &actual, &expect,
    )))
  })
}

pub fn cmd_force_path(
  input: PathBuf,
  paths: Vec<String>,
) -> Effect<PredicateResult, InfraError, NixqEnv> {
  effect!(|r| {
      let src = (~JsonSourceKey).clone();
      let bytes = ~src.read(&input);
      let value = ~parse_json(&bytes);
      PredicateResult::from_bool(force_paths(&value, &paths).is_ok())
  })
}

pub fn cmd_normalize(input: PathBuf) -> Effect<Value, InfraError, NixqEnv> {
  effect!(|r| {
      let src = (~JsonSourceKey).clone();
      let bytes = ~src.read(&input);
      let value = ~parse_json(&bytes);
      normalize_value(&value)
  })
}

pub fn cmd_diff(input: PathBuf, right: PathBuf) -> Effect<String, InfraError, NixqEnv> {
  // Multi-read: Effect::new (effect! would join_binds2 adjacent ~reads).
  Effect::new(move |env| {
    let src = Needs::<JsonSourceKey>::need(env).clone();
    let left = parse_json(&src.read(&input)?)?;
    let right_v = parse_json(&src.read(&right)?)?;
    if values_equal(&left, &right_v) {
      return Ok(String::new());
    }
    Ok(structural_diff(
      &normalize_value(&left),
      &normalize_value(&right_v),
    ))
  })
}

/// Delegate path-info to nixstore as an Effect (wire `NixstoreEnv` at the CLI edge).
pub fn cmd_path_info(
  paths: Vec<String>,
  flags: nixstore::PathInfoFlags,
) -> Effect<Value, nixstore::InfraError, nixstore::NixstoreEnv> {
  nixstore::cmd_path_info(paths, flags)
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::caps::{JsonSourceKey, MockJsonSource, mock_providers};
  use id_effect::{Cap, Exit, FromEnv, build_env, run_test};
  use std::sync::Arc;

  fn env_with(mock: Arc<MockJsonSource>) -> NixqEnv {
    let mut raw = build_env(mock_providers()).expect("env");
    raw.insert::<Cap<JsonSourceKey>>(mock as JsonSourceKey);
    NixqEnv::from_env(raw)
  }

  #[test]
  fn cmd_get_reads_attrpath() {
    let mock = Arc::new(MockJsonSource::default());
    mock.set_file("in.json", br#"{"a":{"b":2}}"#);
    let exit = run_test(
      cmd_get(PathBuf::from("in.json"), "a.b".into()),
      env_with(mock),
    );
    assert!(matches!(exit, Exit::Success(v) if v == serde_json::json!(2)));
  }

  #[test]
  fn cmd_has_attrs_predicate() {
    let mock = Arc::new(MockJsonSource::default());
    mock.set_file("in.json", br#"{"a":1,"b":2}"#);
    let exit = run_test(
      cmd_has_attrs(PathBuf::from("in.json"), vec!["a".into()]),
      env_with(mock),
    );
    assert!(matches!(exit, Exit::Success(PredicateResult::True)));
  }

  #[test]
  fn cmd_subset_false_when_missing() {
    let mock = Arc::new(MockJsonSource::default());
    mock.set_file("a.json", br#"{"a":1}"#);
    mock.set_file("e.json", br#"{"b":1}"#);
    let exit = run_test(
      cmd_subset(PathBuf::from("a.json"), PathBuf::from("e.json")),
      env_with(mock),
    );
    assert!(matches!(exit, Exit::Success(PredicateResult::False)));
  }

  #[test]
  fn cmd_force_path_and_normalize() {
    let mock = Arc::new(MockJsonSource::default());
    mock.set_file(
      "d.json",
      br#"{"outPath":"/nix/store/x","name":"x","builder":"b"}"#,
    );
    let exit = run_test(
      cmd_force_path(PathBuf::from("d.json"), vec!["outPath".into()]),
      env_with(mock.clone()),
    );
    assert!(matches!(exit, Exit::Success(PredicateResult::True)));

    let exit = run_test(cmd_normalize(PathBuf::from("d.json")), env_with(mock));
    match exit {
      Exit::Success(v) => {
        assert_eq!(v["type"], "derivation");
        assert_eq!(v["outPath"], "/nix/store/x");
      }
      other => panic!("unexpected {other:?}"),
    }
  }

  #[test]
  fn cmd_diff_equal_and_unequal() {
    let mock = Arc::new(MockJsonSource::default());
    mock.set_file("l.json", br#"{"a":1}"#);
    mock.set_file("r.json", br#"{"a":1}"#);
    let exit = run_test(
      cmd_diff(PathBuf::from("l.json"), PathBuf::from("r.json")),
      env_with(mock.clone()),
    );
    assert!(matches!(exit, Exit::Success(s) if s.is_empty()));

    mock.set_file("r2.json", br#"{"a":2}"#);
    let exit = run_test(
      cmd_diff(PathBuf::from("l.json"), PathBuf::from("r2.json")),
      env_with(mock),
    );
    assert!(matches!(exit, Exit::Success(s) if s.contains("~ $.a")));
  }

  #[test]
  fn load_json_and_error_paths() {
    let mock = Arc::new(MockJsonSource::default());
    mock.set_file("ok.json", br#"{"k":1}"#);
    mock.set_file("bad.json", b"not-json");
    assert!(matches!(
      run_test(load_json(PathBuf::from("ok.json")), env_with(mock.clone())),
      Exit::Success(_)
    ));
    assert!(matches!(
      run_test(load_json(PathBuf::from("bad.json")), env_with(mock.clone())),
      Exit::Failure(_)
    ));

    mock.set_file("obj.json", br#"{"a":1}"#);
    assert!(matches!(
      run_test(
        cmd_get(PathBuf::from("obj.json"), "missing".into()),
        env_with(mock.clone())
      ),
      Exit::Failure(_)
    ));
    assert!(matches!(
      run_test(
        cmd_get(PathBuf::from("obj.json"), ".".into()),
        env_with(mock.clone())
      ),
      Exit::Failure(_)
    ));
    assert!(matches!(
      run_test(
        cmd_has_attrs(PathBuf::from("obj.json"), vec!["z".into()]),
        env_with(mock.clone())
      ),
      Exit::Success(PredicateResult::False)
    ));
    assert!(matches!(
      run_test(
        cmd_force_path(PathBuf::from("obj.json"), vec!["a.b".into()]),
        env_with(mock.clone())
      ),
      Exit::Success(PredicateResult::False)
    ));
    mock.set_file("e.json", br#"{"a":1}"#);
    assert!(matches!(
      run_test(
        cmd_subset(PathBuf::from("obj.json"), PathBuf::from("e.json")),
        env_with(mock)
      ),
      Exit::Success(PredicateResult::True)
    ));
  }
}

#[cfg(test)]
mod path_info_tests {
  use super::*;
  use id_effect::{FromEnv, run_blocking};
  use nixstore::PathInfoFlags;

  #[test]
  fn path_info_fixture_json() {
    let root =
      std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../nixstore/fixtures/minimal");
    let path = "/nix/store/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-a".to_string();
    let env = nixstore::NixstoreEnv::from_env(nixstore::providers_for_store(&root));
    let v = run_blocking(
      cmd_path_info(
        vec![path.clone()],
        PathInfoFlags {
          json: true,
          closure_size: true,
          referrers: true,
          ..Default::default()
        },
      ),
      env,
    )
    .expect("query");
    assert_eq!(v[&path]["narSize"], 100);
    assert_eq!(v[&path]["closureSize"], 350);
  }
}