#![forbid(unsafe_code)]
#![warn(
clippy::cargo,
missing_docs,
// clippy::missing_docs_in_private_items,
clippy::nursery,
clippy::pedantic,
future_incompatible,
rust_2018_idioms,
)]
#![allow(
clippy::missing_errors_doc, // TODO clippy::missing_errors_doc
clippy::option_if_let_else,
clippy::module_name_repetitions,
)]
pub mod permissions;
pub mod admin;
pub mod connection;
pub mod document;
pub mod limits;
pub mod schema;
pub mod transaction;
pub mod keyvalue;
pub mod api;
pub mod key;
pub mod networking;
pub mod pubsub;
use std::string::FromUtf8Error;
pub use actionable;
pub use arc_bytes;
pub use async_trait;
pub use circulate;
pub use num_traits;
pub use ordered_varint;
use schema::{view, CollectionName, SchemaName, ViewName};
use serde::{Deserialize, Serialize};
pub use transmog;
pub use transmog_pot;
use crate::{
document::{DocumentId, Header, InvalidHexadecimal},
key::NextValueError,
schema::{ApiName, InsertError},
};
#[derive(Clone, thiserror::Error, Debug, Serialize, Deserialize)]
pub enum Error {
#[error(
"database '{database_name}' was created with schema '{stored_schema}', not '{schema}'"
)]
SchemaMismatch {
database_name: String,
schema: SchemaName,
stored_schema: SchemaName,
},
#[error("schema '{0}' was already registered")]
SchemaAlreadyRegistered(SchemaName),
#[error("schema '{0}' is not registered")]
SchemaNotRegistered(SchemaName),
#[error("view '{0}' was already registered")]
ViewAlreadyRegistered(ViewName),
#[error("invalid database name: {0}")]
InvalidDatabaseName(String),
#[error("database '{0}' was not found")]
DatabaseNotFound(String),
#[error("view was not found")]
ViewNotFound,
#[error("collection was not found")]
CollectionNotFound,
#[error("api '{0}' was not found")]
ApiNotFound(ApiName),
#[error("a database with name '{0}' already exists")]
DatabaseNameAlreadyTaken(String),
#[error("error from storage: {0}")]
Database(String),
#[error("error serializing: {0}")]
Serialization(String),
#[error("error from server: {0}")]
Server(String),
#[error("a transport error occurred: '{0}'")]
Transport(String),
#[cfg(feature = "websockets")]
#[error("a websocket error occurred: '{0}'")]
Websocket(String),
#[error("a networking error occurred: '{0}'")]
Networking(networking::Error),
#[error("an io error occurred: '{0}'")]
Io(String),
#[error("a configuration error occurred: '{0}'")]
Configuration(String),
#[error("an io error in the client: '{0}'")]
Client(String),
#[error("attempted to define a collection that already has been defined")]
CollectionAlreadyDefined,
#[error("the requested document id {1} from collection {0} was not found")]
DocumentNotFound(CollectionName, Box<DocumentId>),
#[error(
"an value was provided for a `DocumentId` that was larger than `DocumentId::MAX_LENGTH`"
)]
DocumentIdTooLong,
#[error("a conflict was detected while updating document {1} from collection {0}")]
DocumentConflict(CollectionName, Box<Header>),
#[error("a unique key violation occurred: document `{existing_document}` already has the same key as `{conflicting_document}` for {view}")]
UniqueKeyViolation {
view: ViewName,
conflicting_document: Box<Header>,
existing_document: Box<Header>,
},
#[error("an error occurred generating a new unique id for {0}: {1}")]
DocumentPush(CollectionName, NextValueError),
#[error("an invalid name was used in a schema: {0}")]
InvalidName(#[from] schema::InvalidNameError),
#[error("permission error: {0}")]
PermissionDenied(#[from] actionable::PermissionDenied),
#[error("error with password: {0}")]
Password(String),
#[error("user not found")]
UserNotFound,
#[error("invalid string: {0}")]
InvalidUnicode(String),
#[error("invalid credentials")]
InvalidCredentials,
#[error("reduce is unimplemented")]
ReduceUnimplemented,
#[error("floating point operation yielded NaN")]
NotANumber,
}
impl From<pot::Error> for Error {
fn from(err: pot::Error) -> Self {
Self::Serialization(err.to_string())
}
}
impl<T> From<InsertError<T>> for Error {
fn from(err: InsertError<T>) -> Self {
err.error
}
}
impl From<view::Error> for Error {
fn from(err: view::Error) -> Self {
Self::Database(err.to_string())
}
}
impl From<FromUtf8Error> for Error {
fn from(err: FromUtf8Error) -> Self {
Self::InvalidUnicode(err.to_string())
}
}
impl From<InvalidHexadecimal> for Error {
fn from(err: InvalidHexadecimal) -> Self {
Self::Serialization(err.to_string())
}
}
#[cfg(any(feature = "test-util", test))]
#[allow(missing_docs)]
pub mod test_util;
#[cfg(feature = "encryption")]
pub const ENCRYPTION_ENABLED: bool = true;
#[cfg(not(feature = "encryption"))]
pub const ENCRYPTION_ENABLED: bool = false;
pub trait AnyError: std::error::Error + Send + Sync + 'static {}
impl<T> AnyError for T where T: std::error::Error + Send + Sync + 'static {}