Update errors (#204)

curquiza · web-flow · commit c8e43ea0e73c · 2021-11-08T19:00:00.000+01:00
diff --git a/src/client.rs b/src/client.rs
@@ -179,7 +179,7 @@ impl Client {
         match self.delete_index(uid).await {
             Ok (_) => Ok(true),
             Err (Error::MeiliSearchError {
-                message: _,
+                error_message: _,
                 error_code: ErrorCode::IndexNotFound,
                 error_type: _,
                 error_link: _,
diff --git a/src/errors.rs b/src/errors.rs
@@ -1,10 +1,13 @@
 /// An enum representing the errors that can occur.
+
 #[derive(Debug)]
 #[non_exhaustive]
 pub enum Error {
+    /// The exhaustive list of MeiliSearch errors: https://github.com/meilisearch/specifications/blob/main/text/0061-error-format-and-definitions.md
+    /// Also check out: https://github.com/meilisearch/MeiliSearch/blob/main/meilisearch-error/src/lib.rs
     MeiliSearchError {
         /// The human readable error message
-        message: String,
+        error_message: String,
         /// The error code of the error.  Officially documented at
         /// https://docs.meilisearch.com/errors.
         error_code: ErrorCode,
@@ -18,7 +21,7 @@ pub enum Error {
     /// There is no MeiliSearch server listening on the [specified host]
     /// (../client/struct.Client.html#method.new).
     UnreachableServer,
-    /// The MeiliSearch server returned invalid JSON for a request.
+    /// The MeiliSearch server returned an invalid JSON for a request.
     ParseError(serde_json::Error),
     /// This MeiliSearch SDK generated an invalid request (which was not sent).
     /// It probably comes from an invalid API key resulting in an invalid HTTP header.
@@ -50,64 +53,41 @@ pub enum ErrorType {
 #[derive(Debug, Clone)]
 #[non_exhaustive]
 pub enum ErrorCode {
-    /// An error occurred while trying to create an index.
     IndexCreationFailed,
-    /// An index with this UID already exists. You may want to use the
-    /// [`get_or_create` method](../client/struct.Client.html#method.get_or_create).
     IndexAlreadyExists,
-    /// No index was found with that UID. You may want to use the [get_or_create
-    /// method](../client/struct.Client.html#method.get_or_create).
     IndexNotFound,
-    /// There was an error in the provided index format. Index UIDs can only be
-    /// composed of alphanumeric characters, hyphens (-), and underscores (_).
     InvalidIndexUid,
-    /// An internal error occurred while trying to access the requested index.
-    IndexNotAccessible,
-    /// The database is in an invalid state.  Deleting the database and
-    /// re-indexing should solve the problem.
     InvalidState,
-    /// MeiliSearch couldn't infer the primary key for the given documents.
-    /// Consider specifying the key manually.
-    MissingPrimaryKey,
-    /// The index already has a set primary key which can't be changed.
-    PrimaryKeyAlreadyPresent,
-    /// A document was added with more than 65,535 fields.
+    PrimaryKeyInferenceFailed,
+    IndexPrimaryKeyAlreadyPresent,
+    InvalidRankingRule,
+    InvalidStoreFile,
     MaxFieldsLimitExceeded,
-    /// A document is missing its primary key.
     MissingDocumentId,
-
-    /// The filter provided with the search was invalid.
+    InvalidDocumentId,
     InvalidFilter,
-
-    /// The request is invalid, check the error message for more information.
+    InvalidSort,
+    BadParameter,
     BadRequest,
-    /// The requested document can't be retrieved. Either it doesn't exist, or
-    /// the database was left in an inconsistent state.
+    DatabaseSizeLimitReached,
     DocumentNotFound,
-    /// MeiliSearch experienced an internal error. Check the error message and
-    /// open an issue if necessary.
     InternalError,
-    /// The provided token is invalid.
-    InvalidToken,
-    /// The MeiliSearch instance is under maintenance.
-    Maintenance,
-    /// The requested resources are protected with an API key, which was not
-    /// provided in the request header.
+    InvalidGeoField,
+    InvalidApiKey,
     MissingAuthorizationHeader,
-    /// The requested resources could not be found.
-    NotFound,
-    /// The payload sent to the server was too large.
+    TaskNotFound,
+    DumpNotFound,
+    NoSpaceLeftOnDevice,
     PayloadTooLarge,
-    /// The document exists in store, but there was an error retrieving it. This
-    /// is likely caused by an inconsistent state in the database.
     UnretrievableDocument,
-    /// The payload content type is not supported by MeiliSearch. Currently,
-    /// MeiliSearch only supports JSON payloads.
+    SearchError,
     UnsupportedMediaType,
-    /// A dump creation is already in progress and a new one can't be triggered until the previous dump creation is not finished.
-    DumpAlreadyInProgress,
-    /// An error occured during dump creation process, task aborted.
+    DumpAlreadyProcessing,
     DumpProcessFailed,
+    MissingContentType,
+    MalformedPayload,
+    InvalidContentType,
+    MissingPayload,
 
     /// That's unexpected. Please open a GitHub issue after ensuring you are
     /// using the supported version of the MeiliSearch server.
@@ -134,19 +114,19 @@ impl ErrorType {
     /// MeiliSearch.
     pub fn as_str(&self) -> &'static str {
         match self {
-            ErrorType::InvalidRequest => "invalid_request_error",
-            ErrorType::Internal => "internal_error",
-            ErrorType::Authentication => "authentication_error",
+            ErrorType::InvalidRequest => "invalid_request",
+            ErrorType::Internal => "internal",
+            ErrorType::Authentication => "authentication",
         }
     }
     /// Converts the error type string returned by MeiliSearch into an
-    /// `ErrorType` enum.  If the error type input is not recognized, None is
+    /// `ErrorType` enum. If the error type input is not recognized, None is
     /// returned.
     pub fn parse(input: &str) -> Option<Self> {
         match input {
-            "invalid_request_error" => Some(ErrorType::InvalidRequest),
-            "internal_error" => Some(ErrorType::Internal),
-            "authentication_error" => Some(ErrorType::Authentication),
+            "invalid_request" => Some(ErrorType::InvalidRequest),
+            "internal" => Some(ErrorType::Internal),
+            "authentication" => Some(ErrorType::Authentication),
             _ => None,
         }
     }
@@ -161,57 +141,81 @@ impl ErrorCode {
             ErrorCode::IndexAlreadyExists => "index_already_exists",
             ErrorCode::IndexNotFound => "index_not_found",
             ErrorCode::InvalidIndexUid => "invalid_index_uid",
-            ErrorCode::IndexNotAccessible => "index_not_accessible",
             ErrorCode::InvalidState => "invalid_state",
-            ErrorCode::MissingPrimaryKey => "missing_primary_key",
-            ErrorCode::PrimaryKeyAlreadyPresent => "primary_key_already_present",
+            ErrorCode::PrimaryKeyInferenceFailed => "primary_key_inference_failed",
+            ErrorCode::IndexPrimaryKeyAlreadyPresent => "index_primary_key_already_exists",
+            ErrorCode::InvalidRankingRule => "invalid_ranking_rule",
+            ErrorCode::InvalidStoreFile => "invalid_store_file",
             ErrorCode::MaxFieldsLimitExceeded => "max_field_limit_exceeded",
             ErrorCode::MissingDocumentId => "missing_document_id",
+            ErrorCode::InvalidDocumentId => "invalid_document_id",
             ErrorCode::InvalidFilter => "invalid_filter",
+            ErrorCode::InvalidSort => "invalid_sort",
+            ErrorCode::BadParameter => "bad_parameter",
             ErrorCode::BadRequest => "bad_request",
+            ErrorCode::DatabaseSizeLimitReached => "database_size_limit_reached",
             ErrorCode::DocumentNotFound => "document_not_found",
             ErrorCode::InternalError => "internal",
-            ErrorCode::InvalidToken => "invalid_token",
-            ErrorCode::Maintenance => "maintenance",
+            ErrorCode::InvalidGeoField => "invalid_geo_field",
+            ErrorCode::InvalidApiKey => "invalid_api_key",
             ErrorCode::MissingAuthorizationHeader => "missing_authorization_header",
-            ErrorCode::NotFound => "not_found",
+            ErrorCode::TaskNotFound => "task_not_found",
+            ErrorCode::DumpNotFound => "dump_not_found",
+            ErrorCode::NoSpaceLeftOnDevice => "no_space_left_on_device",
             ErrorCode::PayloadTooLarge => "payload_too_large",
             ErrorCode::UnretrievableDocument => "unretrievable_document",
+            ErrorCode::SearchError => "search_error",
             ErrorCode::UnsupportedMediaType => "unsupported_media_type",
-            ErrorCode::DumpAlreadyInProgress => "dump_already_in_progress",
+            ErrorCode::DumpAlreadyProcessing => "dump_already_processing",
             ErrorCode::DumpProcessFailed => "dump_process_failed",
+            ErrorCode::MissingContentType => "missing_content_type",
+            ErrorCode::MalformedPayload => "malformed_payload",
+            ErrorCode::InvalidContentType => "invalid_content_type",
+            ErrorCode::MissingPayload => "missing_payload",
             // Other than this variant, all the other `&str`s are 'static
             ErrorCode::Unknown(inner) => &inner.0,
         }
     }
     /// Converts the error code string returned by MeiliSearch into an `ErrorCode`
-    /// enum.  If the error type input is not recognized, `ErrorCode::Unknown`
+    /// enum. If the error type input is not recognized, `ErrorCode::Unknown`
     /// is returned.
     pub fn parse(input: &str) -> Self {
         match input {
             "index_creation_failed" => ErrorCode::IndexCreationFailed,
             "index_already_exists" => ErrorCode::IndexAlreadyExists,
             "index_not_found" => ErrorCode::IndexNotFound,
             "invalid_index_uid" => ErrorCode::InvalidIndexUid,
-            "index_not_accessible" => ErrorCode::IndexNotAccessible,
             "invalid_state" => ErrorCode::InvalidState,
-            "missing_primary_key" => ErrorCode::MissingPrimaryKey,
-            "primary_key_already_present" => ErrorCode::PrimaryKeyAlreadyPresent,
+            "primary_key_inference_failed" => ErrorCode::PrimaryKeyInferenceFailed,
+            "index_primary_key_already_exists" => ErrorCode::IndexPrimaryKeyAlreadyPresent,
+            "invalid_ranking_rule" => ErrorCode::InvalidRankingRule,
+            "invalid_store_file" => ErrorCode::InvalidStoreFile,
             "max_field_limit_exceeded" => ErrorCode::MaxFieldsLimitExceeded,
             "missing_document_id" => ErrorCode::MissingDocumentId,
+            "invalid_document_id" => ErrorCode::InvalidDocumentId,
             "invalid_filter" => ErrorCode::InvalidFilter,
+            "invalid_sort" => ErrorCode::InvalidSort,
+            "bad_parameter" => ErrorCode::BadParameter,
             "bad_request" => ErrorCode::BadRequest,
+            "database_size_limit_reached" => ErrorCode::DatabaseSizeLimitReached,
             "document_not_found" => ErrorCode::DocumentNotFound,
             "internal" => ErrorCode::InternalError,
-            "invalid_token" => ErrorCode::InvalidToken,
-            "maintenance" => ErrorCode::Maintenance,
+            "invalid_geo_field" => ErrorCode::InvalidGeoField,
+            "invalid_api_key" => ErrorCode::InvalidApiKey,
             "missing_authorization_header" => ErrorCode::MissingAuthorizationHeader,
-            "not_found" => ErrorCode::NotFound,
+            "task_not_found" => ErrorCode::TaskNotFound,
+            "dump_not_found" => ErrorCode::DumpNotFound,
+            "no_space_left_on_device" => ErrorCode::NoSpaceLeftOnDevice,
             "payload_too_large" => ErrorCode::PayloadTooLarge,
             "unretrievable_document" => ErrorCode::UnretrievableDocument,
+            "search_error" => ErrorCode::SearchError,
             "unsupported_media_type" => ErrorCode::UnsupportedMediaType,
-            "dump_already_in_progress" => ErrorCode::DumpAlreadyInProgress,
+            "dump_already_processing" => ErrorCode::DumpAlreadyProcessing,
             "dump_process_failed" => ErrorCode::DumpProcessFailed,
+            "missing_content_type" => ErrorCode::MissingContentType,
+            "malformed_payload" => ErrorCode::MalformedPayload,
+            "invalid_content_type" => ErrorCode::InvalidContentType,
+            "missing_payload" => ErrorCode::MissingPayload,
             inner => ErrorCode::Unknown(UnknownErrorCode(inner.to_string())),
         }
     }
@@ -230,7 +234,7 @@ impl std::fmt::Display for Error {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         match self {
             Error::MeiliSearchError {
-                message,
+                error_message,
                 error_code,
                 error_type,
                 error_link,
@@ -239,7 +243,7 @@ impl std::fmt::Display for Error {
                 "Meilisearch {}: {}: {}. {}",
                 error_type.as_str(),
                 error_code,
-                message,
+                error_message,
                 error_link,
             ),
             Error::UnreachableServer => write!(fmt, "The MeiliSearch server can't be reached."),
@@ -255,37 +259,37 @@ impl std::error::Error for Error {}
 impl From<&serde_json::Value> for Error {
     fn from(json: &serde_json::Value) -> Error {
 
-        let message = json
+        let error_message = json
             .get("message")
             .and_then(|v| v.as_str())
             .map(|s| s.to_string())
             .unwrap_or_else(|| json.to_string());
 
         let error_link = json
-            .get("errorLink")
+            .get("link")
             .and_then(|v| v.as_str())
             .map(|s| s.to_string())
             .unwrap_or_else(String::new);
 
         let error_type = json
-            .get("errorType")
+            .get("type")
             .and_then(|v| v.as_str())
             .and_then(|s| ErrorType::parse(s))
             .unwrap_or(ErrorType::Internal);
 
-        // If the response doesn't contain an errorType field, the error type
+        // If the response doesn't contain a type field, the error type
         // is assumed to be an internal error.
 
         let error_code = json
-            .get("errorCode")
+            .get("code")
             .and_then(|v| v.as_str())
             .map(|s| ErrorCode::parse(s))
             .unwrap_or_else(|| {
-                ErrorCode::Unknown(UnknownErrorCode(String::from("missing errorCode")))
+                ErrorCode::Unknown(UnknownErrorCode(String::from("missing error code")))
             });
 
         Error::MeiliSearchError {
-            message,
+            error_message,
             error_code,
             error_type,
             error_link,
diff --git a/src/indexes.rs b/src/indexes.rs
@@ -111,7 +111,7 @@ impl Index {
         match self.delete().await {
             Ok (_) => Ok(true),
             Err (Error::MeiliSearchError {
-                message: _,
+                error_message: _,
                 error_code: ErrorCode::IndexNotFound,
                 error_type: _,
                 error_link: _,
diff --git a/src/request.rs b/src/request.rs
@@ -143,7 +143,7 @@ fn parse_response<Output: DeserializeOwned>(
                 return Ok(output);
             }
             Err(e) => {
-                error!("Request succeed but failed to parse response");
+                error!("Request succeeded but failed to parse response");
                 return Err(Error::ParseError(e));
             }
         };

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ fn parse_response<Output: DeserializeOwned>(`
`143`	`143`	`return Ok(output);`
`144`	`144`	`}`
`145`	`145`	`Err(e) => {`
`146`		`- error!("Request succeed but failed to parse response");`
	`146`	`+ error!("Request succeeded but failed to parse response");`
`147`	`147`	`return Err(Error::ParseError(e));`
`148`	`148`	`}`
`149`	`149`	`};`