mid coding commit

core/startos/src/config/action.rs

@@ -0,0 +1,116 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use color_eyre::eyre::eyre;
+use models::ImageId;
+use patch_db::HasModel;
+use serde::{Deserialize, Serialize};
+use tracing::instrument;
+
+use super::{Config, ConfigSpec};
+use crate::context::RpcContext;
+use crate::dependencies::Dependencies;
+use crate::prelude::*;
+use crate::procedure::docker::DockerContainers;
+use crate::procedure::{PackageProcedure, ProcedureName};
+use crate::s9pk::manifest::PackageId;
+use crate::status::health_check::HealthCheckId;
+use crate::util::Version;
+use crate::volume::Volumes;
+use crate::{Error, ResultExt};
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct ConfigRes {
+    pub config: Option<Config>,
+    pub spec: ConfigSpec,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, HasModel)]
+#[model = "Model<Self>"]
+pub struct ConfigActions {
+    pub get: PackageProcedure,
+    pub set: PackageProcedure,
+}
+impl ConfigActions {
+    #[instrument(skip_all)]
+    pub fn validate(
+        &self,
+        _container: &Option<DockerContainers>,
+        eos_version: &Version,
+        volumes: &Volumes,
+        image_ids: &BTreeSet<ImageId>,
+    ) -> Result<(), Error> {
+        self.get
+            .validate(eos_version, volumes, image_ids, true)
+            .with_ctx(|_| (crate::ErrorKind::ValidateS9pk, "Config Get"))?;
+        self.set
+            .validate(eos_version, volumes, image_ids, true)
+            .with_ctx(|_| (crate::ErrorKind::ValidateS9pk, "Config Set"))?;
+        Ok(())
+    }
+    #[instrument(skip_all)]
+    pub async fn get(
+        &self,
+        ctx: &RpcContext,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        volumes: &Volumes,
+    ) -> Result<ConfigRes, Error> {
+        self.get
+            .execute(
+                ctx,
+                pkg_id,
+                pkg_version,
+                ProcedureName::GetConfig,
+                volumes,
+                None::<()>,
+                None,
+            )
+            .await
+            .and_then(|res| {
+                res.map_err(|e| Error::new(eyre!("{}", e.1), crate::ErrorKind::ConfigGen))
+            })
+    }
+
+    #[instrument(skip_all)]
+    pub async fn set(
+        &self,
+        ctx: &RpcContext,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        dependencies: &Dependencies,
+        volumes: &Volumes,
+        input: &Config,
+    ) -> Result<SetResult, Error> {
+        let res: SetResult = self
+            .set
+            .execute(
+                ctx,
+                pkg_id,
+                pkg_version,
+                ProcedureName::SetConfig,
+                volumes,
+                Some(input),
+                None,
+            )
+            .await
+            .and_then(|res| {
+                res.map_err(|e| {
+                    Error::new(eyre!("{}", e.1), crate::ErrorKind::ConfigRulesViolation)
+                })
+            })?;
+        Ok(SetResult {
+            depends_on: res
+                .depends_on
+                .into_iter()
+                .filter(|(pkg, _)| dependencies.0.contains_key(pkg))
+                .collect(),
+        })
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct SetResult {
+    pub depends_on: BTreeMap<PackageId, BTreeSet<HealthCheckId>>,
+}

core/startos/src/config/mod.rs

@@ -0,0 +1,287 @@
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+
+use color_eyre::eyre::eyre;
+use indexmap::IndexSet;
+use itertools::Itertools;
+use models::{ErrorKind, OptionExt};
+use patch_db::value::InternedString;
+use patch_db::Value;
+use regex::Regex;
+use rpc_toolkit::command;
+use tracing::instrument;
+
+use crate::context::RpcContext;
+use crate::prelude::*;
+use crate::s9pk::manifest::PackageId;
+use crate::util::display_none;
+use crate::util::serde::{display_serializable, parse_stdin_deserializable, IoFormat};
+use crate::Error;
+
+pub mod action;
+pub mod spec;
+pub mod util;
+
+pub use spec::{ConfigSpec, Defaultable};
+use util::NumRange;
+
+use self::action::ConfigRes;
+use self::spec::ValueSpecPointer;
+
+pub type Config = patch_db::value::InOMap<InternedString, Value>;
+pub trait TypeOf {
+    fn type_of(&self) -> &'static str;
+}
+impl TypeOf for Value {
+    fn type_of(&self) -> &'static str {
+        match self {
+            Value::Array(_) => "list",
+            Value::Bool(_) => "boolean",
+            Value::Null => "null",
+            Value::Number(_) => "number",
+            Value::Object(_) => "object",
+            Value::String(_) => "string",
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ConfigurationError {
+    #[error("Timeout Error")]
+    TimeoutError(#[from] TimeoutError),
+    #[error("No Match: {0}")]
+    NoMatch(#[from] NoMatchWithPath),
+    #[error("System Error: {0}")]
+    SystemError(Error),
+    #[error("Permission Denied: {0}")]
+    PermissionDenied(ValueSpecPointer),
+}
+impl From<ConfigurationError> for Error {
+    fn from(err: ConfigurationError) -> Self {
+        let kind = match &err {
+            ConfigurationError::SystemError(e) => e.kind,
+            _ => crate::ErrorKind::ConfigGen,
+        };
+        crate::Error::new(err, kind)
+    }
+}
+
+#[derive(Clone, Copy, Debug, thiserror::Error)]
+#[error("Timeout Error")]
+pub struct TimeoutError;
+
+#[derive(Clone, Debug, thiserror::Error)]
+pub struct NoMatchWithPath {
+    pub path: Vec<InternedString>,
+    pub error: MatchError,
+}
+impl NoMatchWithPath {
+    pub fn new(error: MatchError) -> Self {
+        NoMatchWithPath {
+            path: Vec::new(),
+            error,
+        }
+    }
+    pub fn prepend(mut self, seg: InternedString) -> Self {
+        self.path.push(seg);
+        self
+    }
+}
+impl std::fmt::Display for NoMatchWithPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {}", self.path.iter().rev().join("."), self.error)
+    }
+}
+impl From<NoMatchWithPath> for Error {
+    fn from(e: NoMatchWithPath) -> Self {
+        ConfigurationError::from(e).into()
+    }
+}
+
+#[derive(Clone, Debug, thiserror::Error)]
+pub enum MatchError {
+    #[error("String {0:?} Does Not Match Pattern {1}")]
+    Pattern(Arc<String>, Regex),
+    #[error("String {0:?} Is Not In Enum {1:?}")]
+    Enum(Arc<String>, IndexSet<String>),
+    #[error("Field Is Not Nullable")]
+    NotNullable,
+    #[error("Length Mismatch: expected {0}, actual: {1}")]
+    LengthMismatch(NumRange<usize>, usize),
+    #[error("Invalid Type: expected {0}, actual: {1}")]
+    InvalidType(&'static str, &'static str),
+    #[error("Number Out Of Range: expected {0}, actual: {1}")]
+    OutOfRange(NumRange<f64>, f64),
+    #[error("Number Is Not Integral: {0}")]
+    NonIntegral(f64),
+    #[error("Variant {0:?} Is Not In Union {1:?}")]
+    Union(Arc<String>, IndexSet<String>),
+    #[error("Variant Is Missing Tag {0:?}")]
+    MissingTag(InternedString),
+    #[error("Property {0:?} Of Variant {1:?} Conflicts With Union Tag")]
+    PropertyMatchesUnionTag(InternedString, String),
+    #[error("Name of Property {0:?} Conflicts With Map Tag Name")]
+    PropertyNameMatchesMapTag(String),
+    #[error("Pointer Is Invalid: {0}")]
+    InvalidPointer(spec::ValueSpecPointer),
+    #[error("Object Key Is Invalid: {0}")]
+    InvalidKey(String),
+    #[error("Value In List Is Not Unique")]
+    ListUniquenessViolation,
+}
+
+#[command(rename = "config-spec", cli_only, blocking, display(display_none))]
+pub fn verify_spec(#[arg] path: PathBuf) -> Result<(), Error> {
+    let mut file = std::fs::File::open(&path)?;
+    let format = match path.extension().and_then(|s| s.to_str()) {
+        Some("yaml") | Some("yml") => IoFormat::Yaml,
+        Some("json") => IoFormat::Json,
+        Some("toml") => IoFormat::Toml,
+        Some("cbor") => IoFormat::Cbor,
+        _ => {
+            return Err(Error::new(
+                eyre!("Unknown file format. Expected one of yaml, json, toml, cbor."),
+                crate::ErrorKind::Deserialization,
+            ));
+        }
+    };
+    let _: ConfigSpec = format.from_reader(&mut file)?;
+
+    Ok(())
+}
+
+#[command(subcommands(get, set))]
+pub fn config(#[arg] id: PackageId) -> Result<PackageId, Error> {
+    Ok(id)
+}
+
+#[command(display(display_serializable))]
+#[instrument(skip_all)]
+pub async fn get(
+    #[context] ctx: RpcContext,
+    #[parent_data] id: PackageId,
+    #[allow(unused_variables)]
+    #[arg(long = "format")]
+    format: Option<IoFormat>,
+) -> Result<ConfigRes, Error> {
+    let db = ctx.db.peek().await;
+    let manifest = db
+        .as_package_data()
+        .as_idx(&id)
+        .or_not_found(&id)?
+        .as_installed()
+        .or_not_found(&id)?
+        .as_manifest();
+    let action = manifest
+        .as_config()
+        .de()?
+        .ok_or_else(|| Error::new(eyre!("{} has no config", id), crate::ErrorKind::NotFound))?;
+
+    let volumes = manifest.as_volumes().de()?;
+    let version = manifest.as_version().de()?;
+    action.get(&ctx, &id, &version, &volumes).await
+}
+
+#[command(
+    subcommands(self(set_impl(async, context(RpcContext))), set_dry),
+    display(display_none),
+    metadata(sync_db = true)
+)]
+#[instrument(skip_all)]
+pub fn set(
+    #[parent_data] id: PackageId,
+    #[allow(unused_variables)]
+    #[arg(long = "format")]
+    format: Option<IoFormat>,
+    #[arg(long = "timeout")] timeout: Option<crate::util::serde::Duration>,
+    #[arg(stdin, parse(parse_stdin_deserializable))] config: Option<Config>,
+) -> Result<(PackageId, Option<Config>, Option<Duration>), Error> {
+    Ok((id, config, timeout.map(|d| *d)))
+}
+
+#[command(rename = "dry", display(display_serializable))]
+#[instrument(skip_all)]
+pub async fn set_dry(
+    #[context] ctx: RpcContext,
+    #[parent_data] (id, config, timeout): (PackageId, Option<Config>, Option<Duration>),
+) -> Result<BTreeMap<PackageId, String>, Error> {
+    let breakages = BTreeMap::new();
+    let overrides = Default::default();
+
+    let configure_context = ConfigureContext {
+        breakages,
+        timeout,
+        config,
+        dry_run: true,
+        overrides,
+    };
+    let breakages = configure(&ctx, &id, configure_context).await?;
+
+    Ok(breakages)
+}
+
+pub struct ConfigureContext {
+    pub breakages: BTreeMap<PackageId, String>,
+    pub timeout: Option<Duration>,
+    pub config: Option<Config>,
+    pub overrides: BTreeMap<PackageId, Config>,
+    pub dry_run: bool,
+}
+
+#[instrument(skip_all)]
+pub async fn set_impl(
+    ctx: RpcContext,
+    (id, config, timeout): (PackageId, Option<Config>, Option<Duration>),
+) -> Result<(), Error> {
+    let breakages = BTreeMap::new();
+    let overrides = Default::default();
+
+    let configure_context = ConfigureContext {
+        breakages,
+        timeout,
+        config,
+        dry_run: false,
+        overrides,
+    };
+    configure(&ctx, &id, configure_context).await?;
+    Ok(())
+}
+
+#[instrument(skip_all)]
+pub async fn configure(
+    ctx: &RpcContext,
+    id: &PackageId,
+    configure_context: ConfigureContext,
+) -> Result<BTreeMap<PackageId, String>, Error> {
+    let db = ctx.db.peek().await;
+    let package = db
+        .as_package_data()
+        .as_idx(id)
+        .or_not_found(&id)?
+        .as_installed()
+        .or_not_found(&id)?;
+    let version = package.as_manifest().as_version().de()?;
+    ctx.managers
+        .get(&(id.clone(), version.clone()))
+        .await
+        .ok_or_else(|| {
+            Error::new(
+                eyre!("There is no manager running for {id:?} and {version:?}"),
+                ErrorKind::Unknown,
+            )
+        })?
+        .configure(configure_context)
+        .await
+}
+
+macro_rules! not_found {
+    ($x:expr) => {
+        crate::Error::new(
+            color_eyre::eyre::eyre!("Could not find {} at {}:{}", $x, module_path!(), line!()),
+            crate::ErrorKind::Incoherent,
+        )
+    };
+}
+pub(crate) use not_found;

core/startos/src/config/util.rs

@@ -0,0 +1,406 @@
+use std::borrow::Cow;
+use std::ops::{Bound, RangeBounds, RangeInclusive};
+
+use patch_db::Value;
+use rand::distributions::Distribution;
+use rand::Rng;
+
+use super::Config;
+
+pub const STATIC_NULL: Value = Value::Null;
+
+#[derive(Clone, Debug)]
+pub struct CharSet(pub Vec<(RangeInclusive<char>, usize)>, usize);
+impl CharSet {
+    pub fn contains(&self, c: &char) -> bool {
+        self.0.iter().any(|r| r.0.contains(c))
+    }
+    pub fn gen<R: Rng>(&self, rng: &mut R) -> char {
+        let mut idx = rng.gen_range(0..self.1);
+        for r in &self.0 {
+            if idx < r.1 {
+                return std::convert::TryFrom::try_from(
+                    rand::distributions::Uniform::new_inclusive(
+                        u32::from(*r.0.start()),
+                        u32::from(*r.0.end()),
+                    )
+                    .sample(rng),
+                )
+                .unwrap();
+            } else {
+                idx -= r.1;
+            }
+        }
+        unreachable!()
+    }
+}
+impl Default for CharSet {
+    fn default() -> Self {
+        CharSet(vec![('!'..='~', 94)], 94)
+    }
+}
+impl<'de> serde::de::Deserialize<'de> for CharSet {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        let mut res = Vec::new();
+        let mut len = 0;
+        let mut a: Option<char> = None;
+        let mut b: Option<char> = None;
+        let mut in_range = false;
+        for c in s.chars() {
+            match c {
+                ',' => match (a, b, in_range) {
+                    (Some(start), Some(end), _) => {
+                        if !end.is_ascii() {
+                            return Err(serde::de::Error::custom("Invalid Character"));
+                        }
+                        if start >= end {
+                            return Err(serde::de::Error::custom("Invalid Bounds"));
+                        }
+                        let l = u32::from(end) - u32::from(start) + 1;
+                        res.push((start..=end, l as usize));
+                        len += l as usize;
+                        a = None;
+                        b = None;
+                        in_range = false;
+                    }
+                    (Some(start), None, false) => {
+                        len += 1;
+                        res.push((start..=start, 1));
+                        a = None;
+                    }
+                    (Some(_), None, true) => {
+                        b = Some(',');
+                    }
+                    (None, None, false) => {
+                        a = Some(',');
+                    }
+                    _ => {
+                        return Err(serde::de::Error::custom("Syntax Error"));
+                    }
+                },
+                '-' => {
+                    if a.is_none() {
+                        a = Some('-');
+                    } else if !in_range {
+                        in_range = true;
+                    } else if b.is_none() {
+                        b = Some('-')
+                    } else {
+                        return Err(serde::de::Error::custom("Syntax Error"));
+                    }
+                }
+                _ => {
+                    if a.is_none() {
+                        a = Some(c);
+                    } else if in_range && b.is_none() {
+                        b = Some(c);
+                    } else {
+                        return Err(serde::de::Error::custom("Syntax Error"));
+                    }
+                }
+            }
+        }
+        match (a, b) {
+            (Some(start), Some(end)) => {
+                if !end.is_ascii() {
+                    return Err(serde::de::Error::custom("Invalid Character"));
+                }
+                if start >= end {
+                    return Err(serde::de::Error::custom("Invalid Bounds"));
+                }
+                let l = u32::from(end) - u32::from(start) + 1;
+                res.push((start..=end, l as usize));
+                len += l as usize;
+            }
+            (Some(c), None) => {
+                len += 1;
+                res.push((c..=c, 1));
+            }
+            _ => (),
+        }
+
+        Ok(CharSet(res, len))
+    }
+}
+impl serde::ser::Serialize for CharSet {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        <&str>::serialize(
+            &self
+                .0
+                .iter()
+                .map(|r| match r.1 {
+                    1 => format!("{}", r.0.start()),
+                    _ => format!("{}-{}", r.0.start(), r.0.end()),
+                })
+                .collect::<Vec<_>>()
+                .join(",")
+                .as_str(),
+            serializer,
+        )
+    }
+}
+
+pub trait MergeWith {
+    fn merge_with(&mut self, other: &serde_json::Value);
+}
+
+impl MergeWith for serde_json::Value {
+    fn merge_with(&mut self, other: &serde_json::Value) {
+        use serde_json::Value::Object;
+        if let (Object(orig), Object(ref other)) = (self, other) {
+            for (key, val) in other.into_iter() {
+                match (orig.get_mut(key), val) {
+                    (Some(new_orig @ Object(_)), other @ Object(_)) => {
+                        new_orig.merge_with(other);
+                    }
+                    (None, _) => {
+                        orig.insert(key.clone(), val.clone());
+                    }
+                    _ => (),
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn merge_with_tests() {
+    use serde_json::json;
+
+    let mut a = json!(
+        {"a": 1, "c": {"d": "123"}, "i": [1,2,3], "j": {}, "k":[1,2,3], "l": "test"}
+    );
+    a.merge_with(
+        &json!({"a":"a", "b": "b", "c":{"d":"d", "e":"e"}, "f":{"g":"g"}, "h": [1,2,3], "i":"i", "j":[1,2,3], "k":{}}),
+    );
+    assert_eq!(
+        a,
+        json!({"a": 1, "c": {"d": "123", "e":"e"}, "b":"b", "f": {"g":"g"}, "h":[1,2,3], "i":[1,2,3], "j": {}, "k":[1,2,3], "l": "test"})
+    )
+}
+pub mod serde_regex {
+    use regex::Regex;
+    use serde::*;
+
+    pub fn serialize<S>(regex: &Regex, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        <&str>::serialize(&regex.as_str(), serializer)
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Regex, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Regex::new(&s).map_err(|e| de::Error::custom(e))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct NumRange<T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd>(
+    pub (Bound<T>, Bound<T>),
+);
+impl<T> std::ops::Deref for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+{
+    type Target = (Bound<T>, Bound<T>);
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<'de, T> serde::de::Deserialize<'de> for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+    <T as std::str::FromStr>::Err: std::fmt::Display,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        let mut split = s.split(",");
+        let start = split
+            .next()
+            .map(|s| match s.get(..1) {
+                Some("(") => match s.get(1..2) {
+                    Some("*") => Ok(Bound::Unbounded),
+                    _ => s[1..]
+                        .trim()
+                        .parse()
+                        .map(Bound::Excluded)
+                        .map_err(|e| serde::de::Error::custom(e)),
+                },
+                Some("[") => s[1..]
+                    .trim()
+                    .parse()
+                    .map(Bound::Included)
+                    .map_err(|e| serde::de::Error::custom(e)),
+                _ => Err(serde::de::Error::custom(format!(
+                    "Could not parse left bound: {}",
+                    s
+                ))),
+            })
+            .transpose()?
+            .unwrap();
+        let end = split
+            .next()
+            .map(|s| match s.get(s.len() - 1..) {
+                Some(")") => match s.get(s.len() - 2..s.len() - 1) {
+                    Some("*") => Ok(Bound::Unbounded),
+                    _ => s[..s.len() - 1]
+                        .trim()
+                        .parse()
+                        .map(Bound::Excluded)
+                        .map_err(|e| serde::de::Error::custom(e)),
+                },
+                Some("]") => s[..s.len() - 1]
+                    .trim()
+                    .parse()
+                    .map(Bound::Included)
+                    .map_err(|e| serde::de::Error::custom(e)),
+                _ => Err(serde::de::Error::custom(format!(
+                    "Could not parse right bound: {}",
+                    s
+                ))),
+            })
+            .transpose()?
+            .unwrap_or(Bound::Unbounded);
+
+        Ok(NumRange((start, end)))
+    }
+}
+impl<T> std::fmt::Display for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.start_bound() {
+            Bound::Excluded(n) => write!(f, "({},", n)?,
+            Bound::Included(n) => write!(f, "[{},", n)?,
+            Bound::Unbounded => write!(f, "(*,")?,
+        };
+        match self.end_bound() {
+            Bound::Excluded(n) => write!(f, "{})", n),
+            Bound::Included(n) => write!(f, "{}]", n),
+            Bound::Unbounded => write!(f, "*)"),
+        }
+    }
+}
+impl<T> serde::ser::Serialize for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        <&str>::serialize(&format!("{}", self).as_str(), serializer)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum UniqueBy {
+    Any(Vec<UniqueBy>),
+    All(Vec<UniqueBy>),
+    Exactly(String),
+    NotUnique,
+}
+impl UniqueBy {
+    pub fn eq(&self, lhs: &Config, rhs: &Config) -> bool {
+        match self {
+            UniqueBy::Any(any) => any.iter().any(|u| u.eq(lhs, rhs)),
+            UniqueBy::All(all) => all.iter().all(|u| u.eq(lhs, rhs)),
+            UniqueBy::Exactly(key) => lhs.get(&**key) == rhs.get(&**key),
+            UniqueBy::NotUnique => false,
+        }
+    }
+}
+impl Default for UniqueBy {
+    fn default() -> Self {
+        UniqueBy::NotUnique
+    }
+}
+impl<'de> serde::de::Deserialize<'de> for UniqueBy {
+    fn deserialize<D: serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = UniqueBy;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "a key, an \"any\" object, or an \"all\" object")
+            }
+            fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
+                Ok(UniqueBy::Exactly(v.to_owned()))
+            }
+            fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
+                Ok(UniqueBy::Exactly(v))
+            }
+            fn visit_map<A: serde::de::MapAccess<'de>>(
+                self,
+                mut map: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut variant = None;
+                while let Some(key) = map.next_key::<Cow<str>>()? {
+                    match key.as_ref() {
+                        "any" => {
+                            return Ok(UniqueBy::Any(map.next_value()?));
+                        }
+                        "all" => {
+                            return Ok(UniqueBy::All(map.next_value()?));
+                        }
+                        _ => {
+                            variant = Some(key);
+                        }
+                    }
+                }
+                Err(serde::de::Error::unknown_variant(
+                    variant.unwrap_or_default().as_ref(),
+                    &["any", "all"],
+                ))
+            }
+            fn visit_unit<E: serde::de::Error>(self) -> Result<Self::Value, E> {
+                Ok(UniqueBy::NotUnique)
+            }
+            fn visit_none<E: serde::de::Error>(self) -> Result<Self::Value, E> {
+                Ok(UniqueBy::NotUnique)
+            }
+        }
+        deserializer.deserialize_any(Visitor)
+    }
+}
+
+impl serde::ser::Serialize for UniqueBy {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        use serde::ser::SerializeMap;
+
+        match self {
+            UniqueBy::Any(any) => {
+                let mut map = serializer.serialize_map(Some(1))?;
+                map.serialize_key("any")?;
+                map.serialize_value(any)?;
+                map.end()
+            }
+            UniqueBy::All(all) => {
+                let mut map = serializer.serialize_map(Some(1))?;
+                map.serialize_key("all")?;
+                map.serialize_value(all)?;
+                map.end()
+            }
+            UniqueBy::Exactly(key) => serializer.serialize_str(key),
+            UniqueBy::NotUnique => serializer.serialize_unit(),
+        }
+    }
+}