Added a builder like struct for the search function (Related with issue )

Cargo.toml

@@ -41,6 +41,7 @@ log = "0.4.14"
 maybe-async = "0.2.6"
 serde = { version = "1.0.130", default-features = false }
 serde_json = "1.0.67"
+strum = { version = "0.24.0", features = ["derive"] }
 sha2 = "0.10.0"
 thiserror = "1.0.29"
 url = "2.2.2"

examples/search_query.rs

@@ -0,0 +1,13 @@
+use rspotify::search::SearchQuery;
+
+#[tokio::main]
+async fn main() {
+    let query: String = SearchQuery::default()
+        .any("any")
+        .artist("Lisa")
+        .track("Demon slayer")
+        .album("Another Album")
+        .into();
+
+    println!("{}", query);
+}

src/clients/base.rs

@@ -7,6 +7,7 @@ use crate::{
     http::{BaseHttpClient, Form, Headers, HttpClient, Query},
     join_ids,
     model::*,
+    search::SearchQuery,
     sync::Mutex,
     util::build_map,
     ClientResult, Config, Credentials, Token,
@@ -436,9 +437,9 @@ where
     ///   relevant audio content that is hosted externally.  
     ///
     /// [Reference](https://developer.spotify.com/documentation/web-api/reference/#/operations/search)
-    async fn search(
+    async fn search<T: Into<String> + Send>(
         &self,
-        q: &str,
+        q: T,
         _type: SearchType,
         market: Option<Market>,
         include_external: Option<IncludeExternal>,
@@ -447,8 +448,9 @@ where
     ) -> ClientResult<SearchResult> {
         let limit = limit.map(|s| s.to_string());
         let offset = offset.map(|s| s.to_string());
+        let q: String = q.into();
         let params = build_map([
-            ("q", Some(q)),
+            ("q", Some(&q)),
             ("type", Some(_type.into())),
             ("market", market.map(Into::into)),
             ("include_external", include_external.map(Into::into)),

src/lib.rs

@@ -125,6 +125,7 @@ mod auth_code;
 mod auth_code_pkce;
 mod client_creds;
 pub mod clients;
+pub mod search;
 pub mod sync;
 mod util;
 

src/search/mod.rs

@@ -0,0 +1,96 @@
+use std::collections::HashMap;
+
+use strum::Display;
+
+#[derive(Debug, Display, PartialEq, Eq, Hash)]
+#[strum(serialize_all = "snake_case")]
+pub enum SearchFilter {
+    Album,
+    Artist,
+    Track,
+    Year,
+    Upc,
+    #[strum(serialize = "tag:hipster")]
+    TagHipster,
+    #[strum(serialize = "tag:new")]
+    TagNew,
+    Isrc,
+    Genre,
+}
+
+#[derive(Debug, Default)]
+pub struct SearchQuery {
+    no_filter_query: String,
+    query_map: HashMap<SearchFilter, String>,
+}
+
+impl SearchQuery {
+    pub fn any<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.no_filter_query = str.into();
+        self
+    }
+
+    pub fn album<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.query_map.insert(SearchFilter::Album, str.into());
+        self
+    }
+
+    pub fn artist<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.query_map.insert(SearchFilter::Artist, str.into());
+        self
+    }
+
+    pub fn track<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.query_map.insert(SearchFilter::Track, str.into());
+        self
+    }
+
+    pub fn year<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.query_map.insert(SearchFilter::Year, str.into());
+        self
+    }
+
+    pub fn upc<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.query_map.insert(SearchFilter::Upc, str.into());
+        self
+    }
+
+    pub fn tag_new(&mut self) -> &mut Self {
+        self.query_map.insert(SearchFilter::TagNew, "".into());
+        self
+    }
+
+    pub fn tag_hipster(&mut self) -> &mut Self {
+        self.query_map.insert(SearchFilter::TagHipster, "".into());
+        self
+    }
+
+    pub fn isrc<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.query_map.insert(SearchFilter::Isrc, str.into());
+        self
+    }
+
+    pub fn genre<T: Into<String>>(&mut self, str: T) -> &mut Self {
+        self.query_map.insert(SearchFilter::Genre, str.into());
+        self
+    }
+}
+
+impl From<&mut SearchQuery> for String {
+    fn from(val: &mut SearchQuery) -> Self {
+        let mut rep = val.no_filter_query.clone();
+        rep.push(' ');
+        rep.push_str(
+            val.query_map
+                .iter()
+                .map(|entry| match entry.0 {
+                    SearchFilter::TagNew | SearchFilter::TagHipster => format!("{} ", entry.0),
+                    _ => format!("{}:{} ", entry.0, entry.1),
+                })
+                .collect::<String>()
+                .as_str(),
+        );
+
+        rep
+    }
+}

tests/test_with_oauth.rs

@@ -23,7 +23,9 @@ use rspotify::{
         SearchType, ShowId, TimeLimits, TimeRange, TrackId, UserId,
     },
     prelude::*,
-    scopes, AuthCodeSpotify, ClientResult, Credentials, OAuth, Token,
+    scopes,
+    search::SearchQuery,
+    AuthCodeSpotify, ClientResult, Credentials, OAuth, Token,
 };
 
 use std::env;
@@ -444,10 +446,16 @@ async fn test_repeat() {
 #[maybe_async::test(feature = "__sync", async(feature = "__async", tokio::test))]
 #[ignore]
 async fn test_search_album() {
-    let query = "album:arrival artist:abba";
     oauth_client()
         .await
-        .search(query, SearchType::Album, None, None, Some(10), Some(0))
+        .search(
+            SearchQuery::default().album("arrival").artist("abba"),
+            SearchType::Album,
+            None,
+            None,
+            Some(10),
+            Some(0),
+        )
         .await
         .unwrap();
 }