Minor improvements

Add 'Artists' field to 'Track'

.travis.yml

@@ -0,0 +1,3 @@
+language: go
+go:
+  - "1.14"

README.md

@@ -1,19 +1,17 @@
 # REST API 2.0 Discogs.com client
 
+[![Build Status](https://travis-ci.org/irlndts/go-discogs.svg?branch=master)](https://travis-ci.org/irlndts/go-discogs)[![Go Report Card](https://goreportcard.com/badge/github.com/irlndts/go-discogs)](https://goreportcard.com/report/github.com/irlndts/go-discogs)
+
 go-discogs is a Go client library for the [Discogs API](https://www.discogs.com/developers/). Check the usage section to see how to access the Discogs API.
 
-### Changelog
+The lib is under MIT but be sure you are familiar with [Discogs API Terms of Use](https://support.discogs.com/hc/en-us/articles/360009334593-API-Terms-of-Use).
-```
-14.02.2017 
-- search is implemented
-- minor improvements
-```
 
 ### Feauteres
  * Database
   * [Releases](#releases)
+  * Release Rating
   * Master Releases
-  * Release Versions
+  * Master Versions
   * Artists
   * Artist Releases
   * Label
@@ -22,7 +20,7 @@ go-discogs is a Go client library for the [Discogs API](https://www.discogs.com/
  
 Install
 --------
-    go get github.com/irlndts/go-discogs
+    go get -u github.com/irlndts/go-discogs
 
 Usage
 ---------
@@ -31,49 +29,36 @@ First of all import library and init client variable. According to discogs api d
 ```go
 import "github.com/irlndts/go-discogs"
 ```
+
+Some requests require authentification (as any user). According to [Discogs](https://www.discogs.com/developers/#page:authentication,header:authentication-discogs-auth-flow), to send requests with Discogs Auth, you have two options: sending your credentials in the query string with key and secret parameters or a [token parameter](https://www.discogs.com/settings/developers).
+This is token way example:
 ```go
-client := discogs.NewClient("TestDiscogsClient/0.0.1 +example.com", "")
+client, err := discogs.New(&discogs.Options{
-``` 
+        UserAgent: "Some Name",
-Some requests require authentication (as any user). According to [Discogs](https://www.discogs.com/developers/#page:authentication,header:authentication-discogs-auth-flow), to send requests with Discogs Auth, you have two options: sending your credentials in the query string with key and secret parameters or a token parameter. Key-secret doesn't implemented yet, but token is yes.
+        Currency:  "EUR", // optional, "USD" (default), "GBP", "EUR", "CAD", "AUD", "JPY", "CHF", "MXN", "BRL", "NZD", "SEK", "ZAR" are allowed
-```go
+        Token:     "Some Token", // optional
-client := discogs.NewClient("TestDiscogsClient/0.0.1 +example.com", "sometoken")
+        URL:       "https://api.discogs.com", // optional
+    })
 ``` 
 
 #### Releases
 ```go
-  params := &discogs.ReleaseParams{Release_id: "8138518"}
+  release, _ := client.Database.Release(9893847)
-  release, _, err := client.Release.Release(params)
+  fmt.Println(release.Artists[0].Name, " - ", release.Title) 
-  
+  // St. Petersburg Ska-Jazz Review  -  Elephant Riddim
-  fmt.Println(fmt.Println(release.Artists[0].Name, " - ", release.Title)) // St. Petersburg Ska-Jazz Review  -  Elephant Riddim
-```
-
-#### Artists
-```go
-  params := &discogs.LabelParams{Label_id: "890477", Page: 2, Per_page: 3}
-  label, _, err := client.Label.Releases(params)
-
-  for _, release := range label.Releases {
-    fmt.Println(release.Title)
-  }
-
-  /*
-    Someday / I Hate Everything About You
-    Spy Potion
-    Surf Attack From Russia
-  */
 ```
 
 #### Search
-Issue a search query to discogs database. This endpoint accepts pagination parameters
+Issue a search query to discogs database. This endpoint accepts pagination parameters.
 Authentication (as any user) is required.
 
-Use `SearchRequest` struc to create a request
+Use `SearchRequest` struct to create a request.
 ```go
 type SearchRequest struct {
     Q             string // search query (optional)
     Type          string // one of release, master, artist, label (optional)
     Title         string // search by combined “Artist Name - Release Title” title field (optional)
-    Release_title string // search release titles (optional)
+    ReleaseTitle string // search release titles (optional)
     Credit        string // search release credits (optional)
     Artist        string // search artist names (optional)
     Anv           string // search artist ANV (optional)
@@ -90,19 +75,16 @@ type SearchRequest struct {
     Contributer   string // search contributor usernames (optional)
 
     Page     int // optional
-    Per_page int // optional
+    PerPage int // optional
 }
 ```
 
 Example
 ```go
-  request:= &discogs.SearchRequest{Artist: "reggaenauts", Release_title: "river rock", Page: 0, Per_page: 1}
+  request := discogs.SearchRequest{Artist: "reggaenauts", ReleaseTitle: "river rock", Page: 0, PerPage: 1}
-  search, _, err := client.Search(request)
+  search, _ := client.Search.Search(request)
 
   for _, r := range search.Results {
     fmt.Println(r.Title)
   }
 ```
-
-etc. 
-More examples - soon

artists.go

@@ -1,58 +0,0 @@
-package discogs
-
-import (
-	"github.com/irlndts/go-apirequest"
-	"net/http"
-)
-
-type ArtistService struct {
-	api *apirequest.API
-}
-
-type ArtistParams struct {
-	Artist_id  string
-	Sort       string // year, title, format
-	Sort_order string // asc, desc
-	Page       int
-	Per_page   int
-}
-
-type Artist struct {
-	Namevariations []string `json:"namevariations"`
-	Profile        string   `json:"profile"`
-	Releases_url   string   `json:"releases_url"`
-	Resource_url   string   `json:"resource_url"`
-	Uri            string   `json:"uri"`
-	Urls           []string `json:"urls"`
-	Data_quality   string   `json:"data_quality"`
-	Id             int      `json:"id"`
-	Images         []Image  `json:"images"`
-	Members        []Member `json:"members"`
-}
-
-type ArtistReleases struct {
-	Paginastion Page            `json:"pagination"`
-	Releases    []ReleaseSource `json:"releases"`
-}
-
-func newArtistService(api *apirequest.API) *ArtistService {
-	return &ArtistService{
-		api: api.Path("artists/"),
-	}
-}
-
-func (self *ArtistService) Artist(params *ArtistParams) (*Artist, *http.Response, error) {
-	artist := new(Artist)
-	apiError := new(APIError)
-
-	resp, err := self.api.New().Get(params.Artist_id).Receive(artist, apiError)
-	return artist, resp, relevantError(err, *apiError)
-}
-
-func (self *ArtistService) Releases(params *ArtistParams) (*ArtistReleases, *http.Response, error) {
-	releases := new(ArtistReleases)
-	apiError := new(APIError)
-
-	resp, err := self.api.New().Get(params.Artist_id+"/releases").QueryStruct(params).Receive(releases, apiError)
-	return releases, resp, relevantError(err, *apiError)
-}

artists_test.go

@@ -1,26 +0,0 @@
-package discogs
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestArtistService_Artist(t *testing.T) {
-	expectedId := 1000
-
-	d := NewClient(testUserAgent, testToken)
-	artist, _, err := d.Artist.Artist(&ArtistParams{Artist_id: "1000"})
-
-	check(t, err)
-	assert(t, artist.Id == expectedId, fmt.Sprintf("Release.Title looked for %s, and received %s ", expectedId, artist.Id))
-}
-
-func TestArtistService_Releases(t *testing.T) {
-	expectedArtist := "Dave Clarke"
-
-	d := NewClient(testUserAgent, testToken)
-	releases, _, err := d.Artist.Releases(&ArtistParams{Artist_id: "1000", Sort: "year", Sort_order: "desc"})
-
-	check(t, err)
-	assert(t, releases.Releases[0].Artist == expectedArtist, fmt.Sprintf("Releses.Artist looked for %s, and received %s ", expectedArtist, releases.Releases[0].Artist))
-}

database.go

@@ -0,0 +1,208 @@
+package discogs
+
+import (
+	"net/url"
+	"strconv"
+)
+
+const (
+	releasesURI = "/releases/"
+	artistsURI  = "/artists/"
+	labelsURI   = "/labels/"
+	mastersURI  = "/masters/"
+)
+
+// DatabaseService ...
+type DatabaseService struct {
+	url      string
+	currency string
+}
+
+func newDatabaseService(url string, currency string) *DatabaseService {
+	return &DatabaseService{
+		url:      url,
+		currency: currency,
+	}
+}
+
+// Release serves relesase response from discogs
+type Release struct {
+	Title             string         `json:"title"`
+	ID                int            `json:"id"`
+	Artists           []ArtistSource `json:"artists"`
+	ArtistsSort       string         `json:"artists_sort"`
+	DataQuality       string         `json:"data_quality"`
+	Thumb             string         `json:"thumb"`
+	Community         Community      `json:"community"`
+	Companies         []Company      `json:"companies"`
+	Country           string         `json:"country"`
+	DateAdded         string         `json:"date_added"`
+	DateChanged       string         `json:"date_changed"`
+	EstimatedWeight   int            `json:"estimated_weight"`
+	ExtraArtists      []ArtistSource `json:"extraartists"`
+	FormatQuantity    int            `json:"format_quantity"`
+	Formats           []Format       `json:"formats"`
+	Genres            []string       `json:"genres"`
+	Identifiers       []Identifier   `json:"identifiers"`
+	Images            []Image        `json:"images"`
+	Labels            []LabelSource  `json:"labels"`
+	LowestPrice       float64        `json:"lowest_price"`
+	MasterID          int            `json:"master_id"`
+	MasterURL         string         `json:"master_url"`
+	Notes             string         `json:"notes,omitempty"`
+	NumForSale        int            `json:"num_for_sale,omitempty"`
+	Released          string         `json:"released"`
+	ReleasedFormatted string         `json:"released_formatted"`
+	ResourceURL       string         `json:"resource_url"`
+	Series            []Series       `json:"series"`
+	Status            string         `json:"status"`
+	Styles            []string       `json:"styles"`
+	Tracklist         []Track        `json:"tracklist"`
+	URI               string         `json:"uri"`
+	Videos            []Video        `json:"videos"`
+	Year              int            `json:"year"`
+}
+
+// Release returns release by release's ID
+func (s *DatabaseService) Release(releaseID int) (*Release, error) {
+	params := url.Values{}
+	params.Set("curr_abbr", s.currency)
+
+	var release *Release
+	err := request(s.url+releasesURI+strconv.Itoa(releaseID), params, &release)
+	return release, err
+}
+
+// ReleaseRating serves response for community release rating request
+type ReleaseRating struct {
+	ID     int    `json:"release_id"`
+	Rating Rating `json:"rating"`
+}
+
+// ReleaseRating retruns community release rating
+func (s *DatabaseService) ReleaseRating(releaseID int) (*ReleaseRating, error) {
+	var rating *ReleaseRating
+	err := request(s.url+releasesURI+strconv.Itoa(releaseID)+"/rating", nil, &rating)
+	return rating, err
+}
+
+// Artist resource represents a person in the Discogs database
+// who contributed to a Release in some capacity.
+// More information https://www.discogs.com/developers#page:database,header:database-artist
+type Artist struct {
+	ID             int      `json:"id"`
+	Name           string   `json:"name"`
+	Realname       string   `json:"realname"`
+	Members        []Member `json:"members,omitempty"`
+	Aliases        []Alias  `json:"aliases,omitempty"`
+	Namevariations []string `json:"namevariations"`
+	Images         []Image  `json:"images"`
+	Profile        string   `json:"profile"`
+	ReleasesURL    string   `json:"releases_url"`
+	ResourceURL    string   `json:"resource_url"`
+	URI            string   `json:"uri"`
+	URLs           []string `json:"urls"`
+	DataQuality    string   `json:"data_quality"`
+}
+
+// Artist represents a person in the discogs database
+func (s *DatabaseService) Artist(artistID int) (*Artist, error) {
+	var artist *Artist
+	err := request(s.url+artistsURI+strconv.Itoa(artistID), nil, &artist)
+	return artist, err
+}
+
+// ArtistReleases ...
+type ArtistReleases struct {
+	Pagination Page            `json:"pagination"`
+	Releases   []ReleaseSource `json:"releases"`
+}
+
+// ArtistReleases returns a list of releases and masters associated with the artist.
+func (s *DatabaseService) ArtistReleases(artistID int, pagination *Pagination) (*ArtistReleases, error) {
+	var releases *ArtistReleases
+	err := request(s.url+artistsURI+strconv.Itoa(artistID)+"/releases", pagination.params(), &releases)
+	return releases, err
+}
+
+// Label resource represents a label, company, recording studio, location,
+// or other entity involved with artists and releases.
+type Label struct {
+	Profile     string     `json:"profile"`
+	ReleasesURL string     `json:"releases_url"`
+	Name        string     `json:"name"`
+	ContactInfo string     `json:"contact_info"`
+	URI         string     `json:"uri"`
+	Sublabels   []Sublable `json:"sublabels"`
+	URLs        []string   `json:"urls"`
+	Images      []Image    `json:"images"`
+	ResourceURL string     `json:"resource_url"`
+	ID          int        `json:"id"`
+	DataQuality string     `json:"data_quality"`
+}
+
+// Label returns a label.
+func (s *DatabaseService) Label(labelID int) (*Label, error) {
+	var label *Label
+	err := request(s.url+labelsURI+strconv.Itoa(labelID), nil, &label)
+	return label, err
+}
+
+// LabelReleases is a list of Releases associated with the label.
+type LabelReleases struct {
+	Pagination Page            `json:"pagination"`
+	Releases   []ReleaseSource `json:"releases"`
+}
+
+// LabelReleases returns a list of Releases associated with the label.
+func (s *DatabaseService) LabelReleases(labelID int, pagination *Pagination) (*LabelReleases, error) {
+	var releases *LabelReleases
+	err := request(s.url+labelsURI+strconv.Itoa(labelID)+"/releases", pagination.params(), &releases)
+	return releases, err
+}
+
+// Master resource represents a set of similar releases.
+// Masters (also known as `master releases`) have a `main release` which is often the chronologically earliest.
+// More information https://www.discogs.com/developers#page:database,header:database-master-release
+type Master struct {
+	ID                   int            `json:"id"`
+	Styles               []string       `json:"styles"`
+	Genres               []string       `json:"genres"`
+	Title                string         `json:"title"`
+	Year                 int            `json:"year"`
+	Tracklist            []Track        `json:"tracklist"`
+	Notes                string         `json:"notes"`
+	Artists              []ArtistSource `json:"artists"`
+	Images               []Image        `json:"images"`
+	Videos               []Video        `json:"videos"`
+	NumForSale           int            `json:"num_for_sale"`
+	LowestPrice          float64        `json:"lowest_price"`
+	URI                  string         `json:"uri"`
+	MainRelease          int            `json:"main_release"`
+	MainReleaseURL       string         `json:"main_release_url"`
+	MostRecentRelease    int            `json:"most_recent_release"`
+	MostRecentReleaseURL string         `json:"most_recent_release_url"`
+	VersionsURL          string         `json:"versions_url"`
+	ResourceURL          string         `json:"resource_url"`
+	DataQuality          string         `json:"data_quality"`
+}
+
+// Master returns a master release
+func (s *DatabaseService) Master(masterID int) (*Master, error) {
+	var master *Master
+	err := request(s.url+mastersURI+strconv.Itoa(masterID), nil, &master)
+	return master, err
+}
+
+// MasterVersions retrieves a list of all releases that are versions of this master.
+type MasterVersions struct {
+	Pagination Page      `json:"pagination"`
+	Versions   []Version `json:"versions"`
+}
+
+// MasterVersions retrieves a list of all Releases that are versions of this master
+func (s *DatabaseService) MasterVersions(masterID int, pagination *Pagination) (*MasterVersions, error) {
+	var versions *MasterVersions
+	err := request(s.url+mastersURI+strconv.Itoa(masterID)+"/versions", pagination.params(), &versions)
+	return versions, err
+}

database_test.go

@@ -0,0 +1,108 @@
+package discogs
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func DatabaseServer(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		w.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
+	switch r.URL.Path {
+	case "/releases/8138518":
+		w.WriteHeader(http.StatusOK)
+		if _, err := io.WriteString(w, releaseJson); err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+	case "/masters/718441":
+		w.WriteHeader(http.StatusOK)
+		if _, err := io.WriteString(w, masterJson); err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+	case "/artists/38661":
+		w.WriteHeader(http.StatusOK)
+		if _, err := io.WriteString(w, artistJson); err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+	default:
+		w.WriteHeader(http.StatusMethodNotAllowed)
+	}
+}
+
+func compareJson(t *testing.T, got, want string) {
+	var g, w interface{}
+	if err := json.Unmarshal([]byte(got), &g); err != nil {
+		log.Fatalf("failed to unmarshal json: %s", err)
+	}
+	if err := json.Unmarshal([]byte(want), &w); err != nil {
+		log.Fatalf("failed to unmarshal json: %s", err)
+	}
+
+	if diff := cmp.Diff(g, w); diff != "" {
+		t.Errorf("(-want +got)\n%s", diff)
+	}
+}
+
+func TestDatabaseServiceRelease(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(DatabaseServer))
+	defer ts.Close()
+
+	d := initDiscogsClient(t, &Options{URL: ts.URL})
+	release, err := d.Database.Release(8138518)
+	if err != nil {
+		t.Fatalf("failed to get release: %s", err)
+	}
+
+	json, err := json.Marshal(release)
+	if err != nil {
+		t.Fatalf("failed to marshal release: %s", err)
+	}
+
+	compareJson(t, string(json), releaseJson)
+}
+
+func TestDatabaseServiceMaster(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(DatabaseServer))
+	defer ts.Close()
+
+	d := initDiscogsClient(t, &Options{URL: ts.URL})
+	master, err := d.Database.Master(718441)
+	if err != nil {
+		t.Fatalf("failed to get master: %s", err)
+	}
+
+	json, err := json.Marshal(master)
+	if err != nil {
+		t.Fatalf("failed to marshal release: %s", err)
+	}
+	compareJson(t, string(json), masterJson)
+}
+
+func TestDatabaseServiceArtist(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(DatabaseServer))
+	defer ts.Close()
+
+	d := initDiscogsClient(t, &Options{URL: ts.URL})
+	artist, err := d.Database.Artist(38661)
+	if err != nil {
+		t.Fatalf("failed to get master: %s", err)
+	}
+
+	json, err := json.Marshal(artist)
+	if err != nil {
+		t.Fatalf("failed to marshal artist: %s", err)
+	}
+	compareJson(t, string(json), artistJson)
+}

discogs.go

@@ -1,48 +1,108 @@
 package discogs
 
 import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
 	"net/http"
-
+	"net/url"
-	"github.com/irlndts/go-apirequest"
 )
 
 const (
-	discogsAPI = "https://api.discogs.com/"
+	discogsAPI = "https://api.discogs.com"
 )
 
-// Client is a Discogs client for making Discogs API requests.
+// Options is a set of options to use discogs API client
-type Client struct {
+type Options struct {
-	api     *apirequest.API
+	// Discogs API endpoint (optional).
-	Release *ReleaseService
+	URL string
-	Master  *MasterService
+	// Currency to use (optional, default is USD).
-	Artist  *ArtistService
+	Currency string
-	Label   *LabelService
+	// UserAgent to to call discogs api with.
+	UserAgent string
+	// Token provided by discogs (optional).
+	Token string
+}
+
+// Discogs is a Discogs' client for making Discogs API requests.
+type Discogs struct {
+	Database *DatabaseService
 	Search   *SearchService
 }
 
-// NewClient returns a new Client.
+var header *http.Header
-func NewClient(useragent, token string) *Client {
-	base := apirequest.New().Client(&http.Client{}).Base(discogsAPI).Add("User-Agent", useragent).Add("Authorization", "Discogs token="+token)
 
-	return &Client{
+// New returns a new discogs API client.
-		api:     base,
+func New(o *Options) (*Discogs, error) {
-		Artist:  newArtistService(base.New()),
+	header = &http.Header{}
-		Label:   newLabelService(base.New()),
+
-		Master:  newMasterService(base.New()),
+	if o == nil || o.UserAgent == "" {
-		Release: newReleaseService(base.New()),
+		return nil, ErrUserAgentInvalid
-		Search:  newSearchService(base.New()),
+	}
+
+	header.Add("User-Agent", o.UserAgent)
+
+	cur, err := currency(o.Currency)
+	if err != nil {
+		return nil, err
+	}
+
+	// set token, it's required for some queries like search
+	if o.Token != "" {
+		header.Add("Authorization", "Discogs token="+o.Token)
+	}
+
+	if o.URL == "" {
+		o.URL = discogsAPI
+	}
+
+	return &Discogs{
+		Database: newDatabaseService(o.URL, cur),
+		Search:   newSearchService(o.URL + "/database/search"),
+	}, nil
+}
+
+// currency validates currency for marketplace data.
+// Defaults to the authenticated users currency. Must be one of the following:
+// USD GBP EUR CAD AUD JPY CHF MXN BRL NZD SEK ZAR
+func currency(c string) (string, error) {
+	switch c {
+	case "USD", "GBP", "EUR", "CAD", "AUD", "JPY", "CHF", "MXN", "BRL", "NZD", "SEK", "ZAR":
+		return c, nil
+	case "":
+		return "USD", nil
+	default:
+		return "", ErrCurrencyNotSupported
 	}
 }
 
-// UserAgent sets specified user agent
+func request(path string, params url.Values, resp interface{}) error {
-// Discogs required it
+	r, err := http.NewRequest("GET", path+"?"+params.Encode(), nil)
-func (c *Client) UserAgent(useragent string) *Client {
+	if err != nil {
-	c.api.Set("User-Agent", useragent)
+		return err
-	return c
+	}
+	r.Header = *header
+
+	client := &http.Client{}
+	response, err := client.Do(r)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		switch response.StatusCode {
+		case http.StatusUnauthorized:
+			return ErrUnauthorized
+		default:
+			return fmt.Errorf("unknown error: %s", response.Status)
+		}
 	}
 
-// Token sets tokens, it's required for some queries like search
+	body, err := ioutil.ReadAll(response.Body)
-func (c *Client) Token(token string) *Client {
+	if err != nil {
-	c.api.Set("Authorization", "Discogs token="+token)
+		return err
-	return c
+	}
+
+	return json.Unmarshal(body, &resp)
 }

discogs_test.go

@@ -9,14 +9,85 @@ const (
 	testToken     = ""
 )
 
-func check(t *testing.T, e error) {
+func initDiscogsClient(t *testing.T, options *Options) *Discogs {
-	if e != nil {
+	if options == nil {
-		t.Error(e)
+		options = &Options{
+			UserAgent: testUserAgent,
+			Currency:  "USD",
+			Token:     testToken,
 		}
 	}
 
-func assert(t *testing.T, condition bool, assertion string) {
+	if options.UserAgent == "" {
-	if !condition {
+		options.UserAgent = testUserAgent
-		t.Errorf("Assertion failed: %v", assertion)
+	}
+
+	client, err := New(options)
+	if err != nil {
+		t.Fatalf("failed to create client: %s", err)
+	}
+
+	return client
+}
+
+func TestNew(t *testing.T) {
+	tests := map[string]struct {
+		options *Options
+		err     error
+	}{
+		"normal": {&Options{
+			UserAgent: testUserAgent,
+			Currency:  "USD",
+			Token:     "some token",
+		}, nil},
+		"incorrect user-agent": {&Options{
+			UserAgent: "",
+			Currency:  "USD",
+		}, ErrUserAgentInvalid},
+		"incorrect currency": {&Options{
+			UserAgent: testUserAgent,
+			Currency:  "RUR",
+		}, ErrCurrencyNotSupported},
+	}
+
+	for name := range tests {
+		tt := tests[name]
+		t.Run(name, func(t *testing.T) {
+			if _, err := New(tt.options); err != tt.err {
+				t.Errorf("err got=%s; want=%s", err, tt.err)
+			}
+		})
+	}
+}
+
+func TestCurrency(t *testing.T) {
+	tests := []struct {
+		currency string
+		want     string
+		err      error
+	}{
+		{currency: "", want: "USD", err: nil},
+		{currency: "USD", want: "USD", err: nil},
+		{currency: "GBP", want: "GBP", err: nil},
+		{currency: "EUR", want: "EUR", err: nil},
+		{currency: "CAD", want: "CAD", err: nil},
+		{currency: "AUD", want: "AUD", err: nil},
+		{currency: "JPY", want: "JPY", err: nil},
+		{currency: "CHF", want: "CHF", err: nil},
+		{currency: "MXN", want: "MXN", err: nil},
+		{currency: "BRL", want: "BRL", err: nil},
+		{currency: "NZD", want: "NZD", err: nil},
+		{currency: "SEK", want: "SEK", err: nil},
+		{currency: "ZAR", want: "ZAR", err: nil},
+		{currency: "RUR", want: "", err: ErrCurrencyNotSupported},
+	}
+	for i, tt := range tests {
+		cur, err := currency(tt.currency)
+		if err != tt.err {
+			t.Errorf("#%d err got=%s; want=%s", i, err, tt.err)
+		}
+		if cur != tt.want {
+			t.Errorf("#%d currency got=%s; want=%s", i, cur, tt.want)
+		}
 	}
 }

errors.go

@@ -2,38 +2,21 @@ package discogs
 
 import (
 	"fmt"
+	"strings"
 )
 
-// APIError represents a Discogs API Error response
+// Error represents a Discogs API error
-type APIError struct {
+type Error struct {
-	Message string `json:"message"`
+	Message string
 }
 
-func (e APIError) Error() string {
+func (e *Error) Error() string {
-	if e.Message != "" {
+	return fmt.Sprintf("discogs error: %s", strings.ToLower(e.Message))
-		return fmt.Sprintf("discogs: %v", e.Message)
-	}
-	return ""
 }
 
-// Empty returns true if empty. Otherwise, at least 1 error message/code is
+// APIErrors
-// present and false is returned.
+var (
-func (e APIError) Empty() bool {
+	ErrUnauthorized         = &Error{"authentication required"}
-	if e.Message == "" {
+	ErrCurrencyNotSupported = &Error{"currency does not supported"}
-		return true
+	ErrUserAgentInvalid     = &Error{"invalid user-agent"}
-	}
+)
-	return false
-}
-
-// relevantError returns any non-nil http-related error (creating the request,
-// getting the response, decoding) if any. If the decoded apiError is non-zero
-// the apiError is returned. Otherwise, no errors occurred, returns nil.
-func relevantError(httpError error, apiError APIError) error {
-	if httpError != nil {
-		return httpError
-	}
-	if apiError.Empty() {
-		return nil
-	}
-	return apiError
-}

examples/discogs_example.go

@@ -7,17 +7,20 @@ import (
 )
 
 func main() {
-	d := discogs.NewClient("TestDiscogsClient/0.0.1 +http://irlndts.moscow", "")
+	d, err := discogs.New(&discogs.Options{
-
+		UserAgent: "TestDiscogsClient/0.0.1 +http://example.com",
-	request := &discogs.SearchRequest{Q: "The Reggaenauts - River Rock / Thursday Kick-off", Page: 0, Per_page: 1}
+		Currency:  "USD",
-	search, _, err := d.Search.Search(request)
+		Token:     "",
-
+	})
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
 
-	for _, r := range search.Results {
+	master, err := d.Database.Master(718441)
-		fmt.Println(r.Id, r.Title)
+	if err != nil {
+		fmt.Println(err)
+		return
 	}
+	fmt.Printf("%+v\n", master)
 }

go.mod

@@ -0,0 +1,5 @@
+module github.com/irlndts/go-discogs
+
+go 1.14
+
+require github.com/google/go-cmp v0.4.0

go.sum

@@ -0,0 +1,4 @@
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

labels.go

@@ -1,58 +0,0 @@
-package discogs
-
-import (
-	"net/http"
-
-	"github.com/irlndts/go-apirequest"
-)
-
-type LabelService struct {
-	api *apirequest.API
-}
-
-type LabelParams struct {
-	Label_id string
-	Page     int
-	Per_Page int
-}
-
-type Label struct {
-	Profile      string     `json:"profile"`
-	Releases_url string     `json:"releases_url"`
-	Name         string     `json:"name"`
-	Contact_info string     `json:"contact_info"`
-	Uri          string     `json:"uri"`
-	Sublabels    []Sublable `json:"sublabels"`
-	Urls         []string   `json:"urls"`
-	Images       []Image    `json:"images"`
-	Resource_url string     `json:"resource_url"`
-	Id           int        `json:"id"`
-	Data_quality string     `json:"data_quality"`
-}
-
-type LabelReleases struct {
-	Pagination Page            `json:"pagination"`
-	Releases   []ReleaseSource `json:"releases"`
-}
-
-func newLabelService(api *apirequest.API) *LabelService {
-	return &LabelService{
-		api: api.Path("labels/"),
-	}
-}
-
-func (self *LabelService) Label(params *LabelParams) (*Label, *http.Response, error) {
-	label := new(Label)
-	apiError := new(APIError)
-
-	resp, err := self.api.New().Get(params.Label_id).Receive(label, apiError)
-	return label, resp, relevantError(err, *apiError)
-}
-
-func (self *LabelService) Releases(params *LabelParams) (*LabelReleases, *http.Response, error) {
-	releases := new(LabelReleases)
-	apiError := new(APIError)
-
-	resp, err := self.api.New().Get(params.Label_id+"/releases").QueryStruct(params).Receive(releases, apiError)
-	return releases, resp, relevantError(err, *apiError)
-}

labels_test.go

@@ -1,26 +0,0 @@
-package discogs
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestLabelService_Label(t *testing.T) {
-	expectedId := 1000
-
-	d := NewClient(testUserAgent, testToken)
-	label, _, err := d.Label.Label(&LabelParams{Label_id: "1000"})
-
-	check(t, err)
-	assert(t, label.Id == expectedId, fmt.Sprintf("Release.Title looked for %s, and received %s ", expectedId, label.Id))
-}
-
-func TestLabelService_Releases(t *testing.T) {
-	expectedId := "Cha Cha Twist"
-
-	d := NewClient(testUserAgent, testToken)
-	label, _, err := d.Label.Releases(&LabelParams{Label_id: "1000"})
-
-	check(t, err)
-	assert(t, label.Releases[0].Title == expectedId, fmt.Sprintf("Release.Title looked for %s, and received %s ", expectedId, label.Releases[0].Title))
-}

masters.go

@@ -1,63 +0,0 @@
-package discogs
-
-import (
-	"github.com/irlndts/go-apirequest"
-	"net/http"
-)
-
-type MasterService struct {
-	api *apirequest.API
-}
-
-type MasterParams struct {
-	Master_id string
-}
-
-type MasterVersionParams struct {
-	Master_id string
-	Page      int
-	Per_page  int
-}
-
-type Master struct {
-	Styles           []string `json:"styles"`
-	Genres           []string `json:"genres"`
-	Videos           []Video  `json:"videos"`
-	Title            string   `json:"title"`
-	Main_release     int      `json:"main_release"`
-	Main_release_url string   `json:"main_release_url"`
-	Uri              string   `json:"uri"`
-	Artists          []Artist `json:"artists"`
-	Version_url      string   `json:"version_url"`
-	Year             int      `json:"year"`
-	Images           []Image  `json:"images"`
-	Resource_url     string   `json:"resource_url"`
-	Tracklist        []Track  `json:"tracklist"`
-	Id               int      `json:"id"`
-	Data_quality     string   `json:"data_quality"`
-}
-
-type MasterVersions struct {
-	Pagination Page      `json:"pagination"`
-	Versions   []Version `json:"versions"`
-}
-
-func newMasterService(api *apirequest.API) *MasterService {
-	return &MasterService{
-		api: api.Path("masters/"),
-	}
-}
-
-func (self *MasterService) Master(params *MasterParams) (*Master, *http.Response, error) {
-	master := new(Master)
-	apiError := new(APIError)
-	resp, err := self.api.New().Get(params.Master_id).Receive(master, apiError)
-	return master, resp, relevantError(err, *apiError)
-}
-
-func (self *MasterService) Versions(params *MasterVersionParams) (*MasterVersions, *http.Response, error) {
-	versions := new(MasterVersions)
-	apiError := new(APIError)
-	resp, err := self.api.New().Get(params.Master_id+"/versions").QueryStruct(params).Receive(versions, apiError)
-	return versions, resp, relevantError(err, *apiError)
-}

masters_test.go

@@ -1,26 +0,0 @@
-package discogs
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestMasterService_Master(t *testing.T) {
-	expectedTitle := "Elephant Riddim"
-
-	d := NewClient(testUserAgent, testToken)
-	master, _, err := d.Master.Master(&MasterParams{Master_id: "960657"})
-
-	check(t, err)
-	assert(t, master.Title == expectedTitle, fmt.Sprintf("master.Title looked for %s, and received %s ", expectedTitle, master.Title))
-}
-
-func TestMasterService_Versions(t *testing.T) {
-	expectedTitle := "Stardiver"
-
-	d := NewClient(testUserAgent, testToken)
-	versions, _, err := d.Master.Versions(&MasterVersionParams{Master_id: "1000", Page: 1, Per_page: 1})
-
-	check(t, err)
-	assert(t, versions.Versions[0].Title == expectedTitle, fmt.Sprintf("master.Title looked for %s, and received %s ", expectedTitle, versions.Versions[0].Title))
-}

models.go

@@ -1,71 +1,99 @@
 package discogs
 
+import (
+	"net/url"
+	"strconv"
+)
+
+// Video ...
 type Video struct {
 	Description string `json:"description"`
 	Duration    int    `json:"duration"`
 	Embed       bool   `json:"embed"`
 	Title       string `json:"title"`
-	Uri         string `json:"uri"`
+	URI         string `json:"uri"`
 }
 
+// Series ...
+type Series struct {
+	Catno          string `json:"catno"`
+	EntityType     string `json:"entity_type"`
+	EntityTypeName string `json:"entity_type_name"`
+	ID             int    `json:"id"`
+	Name           string `json:"name"`
+	ResourceURL    string `json:"resource_url"`
+	ThumbnailURL   string `json:"thumbnail_url,omitempty"`
+}
+
+// ArtistSource ...
 type ArtistSource struct {
 	Anv         string `json:"anv"`
-	Id           int    `json:"id"`
+	ID          int    `json:"id"`
 	Join        string `json:"join"`
-	Name         string `json:"name:`
+	Name        string `json:"name"`
-	Resource_url string `json:"resource_url"`
+	ResourceURL string `json:"resource_url"`
 	Role        string `json:"role"`
 	Tracks      string `json:"tracks"`
 }
 
+// Image ...
 type Image struct {
 	Height      int    `json:"height"`
 	Width       int    `json:"width"`
-	Resource_url string `json:"resource_url"`
+	ResourceURL string `json:"resource_url"`
 	Type        string `json:"type"`
-	Uri          string `json:"uri"`
+	URI         string `json:"uri"`
-	Uri150       string `json:"uri150"`
+	URI150      string `json:"uri150"`
 }
 
+// Track ...
 type Track struct {
 	Duration     string         `json:"duration"`
 	Position     string         `json:"position"`
 	Title        string         `json:"title"`
 	Type         string         `json:"type_"`
-	Extraartists []ArtistSource `json:"extraartists"`
+	Extraartists []ArtistSource `json:"extraartists,omitempty"`
+	Artists      []ArtistSource `json:"artists,omitempty"`
 }
 
+// LabelSource ...
 type LabelSource struct {
 	Catno          string `json:"catno"`
-	Entity_type  string `json:"entity_type"`
+	EntityType     string `json:"entity_type"`
-	Id           int    `json:"id"`
+	EntityTypeName string `json:"entity_type_name"`
+	ID             int    `json:"id"`
 	Name           string `json:"name"`
-	Resource_url string `json:"resource_url"`
+	ResourceURL    string `json:"resource_url"`
 }
 
+// Identifier ...
 type Identifier struct {
+	Description string `json:"description,omitempty"`
 	Type        string `json:"type"`
 	Value       string `json:"value"`
 }
 
+// Format ...
 type Format struct {
 	Descriptions []string `json:"descriptions"`
 	Name         string   `json:"name"`
 	Qty          string   `json:"qty"`
 }
 
+// Company ...
 type Company struct {
 	Catno          string `json:"catno"`
-	Entity_type      string `json:"entity_type"`
+	EntityType     string `json:"entity_type"`
-	Entity_type_name string `json:"entity_type_name"`
+	EntityTypeName string `json:"entity_type_name"`
-	Id               int    `json:"id"`
+	ID             int    `json:"id"`
 	Name           string `json:"name"`
-	Resource_url     string `json:"resource_url"`
+	ResourceURL    string `json:"resource_url"`
 }
 
+// Community ...
 type Community struct {
 	Contributors []Contributor `json:"contributors"`
-	Data_quality string        `json:"string"`
+	DataQuality  string        `json:"data_quality"`
 	Have         int           `json:"have"`
 	Rating       Rating        `json:"rating"`
 	Status       string        `json:"status"`
@@ -73,71 +101,109 @@ type Community struct {
 	Want         int           `json:"want"`
 }
 
+// Submitter ...
 type Submitter struct {
-	Resource_url string `json:"resource_url"`
+	ResourceURL string `json:"resource_url"`
 	Username    string `json:"username"`
 }
 
+// Rating ...
 type Rating struct {
 	Average float32 `json:"average"`
 	Count   int     `json:"count"`
 }
 
+// Contributor ...
 type Contributor struct {
-	Resource_url string `json:"resource_url"`
+	ResourceURL string `json:"resource_url"`
 	Username    string `json:"username"`
 }
 
+// Page ...
 type Page struct {
-	Per_page int  `json:"per_page"`
+	PerPage int      `json:"per_page"`
 	Items   int      `json:"items"`
 	Page    int      `json:"page"`
-	Urls     URLS `json:"urls"`
+	URLs    URLsList `json:"urls"`
 	Pages   int      `json:"pages"`
 }
 
-type URLS struct {
+// URLsList ...
+type URLsList struct {
 	Last string `json:"last"`
 	Next string `json:"next"`
 }
 
+// Version ...
 type Version struct {
 	Catno       string `json:"catno"`
 	Country     string `json:"country"`
 	Format      string `json:"format"`
-	Id           int    `json:"id"`
+	ID          int    `json:"id"`
 	Label       string `json:"label"`
 	Released    string `json:"released"`
-	Resource_url string `json:"resource_url"`
+	ResourceURL string `json:"resource_url"`
 	Status      string `json:"status"`
 	Thumb       string `json:"thumb"`
 	Title       string `json:"title"`
 }
 
+// Member ...
 type Member struct {
 	Active      bool   `json:"active"`
-	Id           int    `json:"id"`
+	ID          int    `json:"id"`
 	Name        string `json:"name"`
-	Resource_url string `json:"resource_url"`
+	ResourceURL string `json:"resource_url"`
 }
 
+// Alias ...
+type Alias struct {
+	ID          int    `json:"id"`
+	Name        string `json:"name"`
+	ResourceURL string `json:"resource_url"`
+}
+
+// Sublable ...
 type Sublable struct {
-	Resource_url string `json:"url"`
+	ResourceURL string `json:"url"`
-	Id           int    `json:"id"`
+	ID          int    `json:"id"`
 	Name        string `json:"name"`
 }
 
+// ReleaseSource ...
 type ReleaseSource struct {
 	Artist      string `json:"artist"`
 	Catno       string `json:"catno"`
 	Format      string `json:"format"`
-	Id           int    `json:"id"`
+	ID          int    `json:"id"`
-	Resource_url string `json:"resource_url"`
+	ResourceURL string `json:"resource_url"`
 	Status      string `json:"status"`
 	Thumb       string `json:"thumb"`
 	Title       string `json:"title"`
 	Year        int    `json:"year"`
-	Main_release int    `json:"main_release"`
+	MainRelease int    `json:"main_release"`
 	Role        string `json:"role"`
 	Type        string `json:"type"`
 }
+
+// Pagination ...
+type Pagination struct {
+	Sort      string // year, title, format
+	SortOrder string // asc, desc
+	Page      int
+	PerPage   int
+}
+
+// toParams converts pagaination params to request values
+func (p *Pagination) params() url.Values {
+	if p == nil {
+		return nil
+	}
+
+	params := url.Values{}
+	params.Set("sort", p.Sort)
+	params.Set("sort_order", p.SortOrder)
+	params.Set("page", strconv.Itoa(p.Page))
+	params.Set("per_page", strconv.Itoa(p.PerPage))
+	return params
+}

releases.go

@@ -1,61 +0,0 @@
-package discogs
-
-import (
-	"github.com/irlndts/go-apirequest"
-	"net/http"
-)
-
-type ReleaseService struct {
-	api *apirequest.API
-}
-
-type ReleaseParams struct {
-	Release_id string
-}
-
-type Release struct {
-	Title              string         `json:"title"`
-	Id                 int            `json:"id"`
-	Artists            []ArtistSource `json:"artists"`
-	Data_quality       string         `json:"data_quality"`
-	Thumb              string         `json:"thumb"`
-	Community          Community      `json:"community"`
-	Companies          []Company      `json:"companies"`
-	Country            string         `json:"country"`
-	Date_added         string         `json:"date_added"`
-	Date_changed       string         `json:"date_changed"`
-	Estimated_weight   int            `json:"estimated_weight"`
-	Extraartists       []ArtistSource `json:"extraartists"`
-	Format_quantity    int            `json:"format_quantity"`
-	Formats            []Format       `json:"formats"`
-	Genres             []string       `json:"genres"`
-	Identifiers        []Identifier   `json:"identifiers"`
-	Images             []Image        `json:"images"`
-	Labels             []LabelSource  `json:"labels"`
-	Master_id          int            `json:"master_id"`
-	Master_url         string         `json:"master_url"`
-	Notes              string         `josn:"notes"`
-	Released           string         `json:"released"`
-	Released_formatted string         `json:"released_formatted"`
-	Resource_url       string         `json:"resource_url"`
-	Status             string         `json:"status"`
-	Styles             []string       `json:"styles"`
-	Tracklist          []Track        `json:"tracklist"`
-	Uri                string         `json:"uri"`
-	Videos             []Video        `json:"videos"`
-	Year               int            `json:"year"`
-}
-
-func newReleaseService(api *apirequest.API) *ReleaseService {
-	return &ReleaseService{
-		api: api.Path("releases/"),
-	}
-}
-
-func (self *ReleaseService) Release(params *ReleaseParams) (*Release, *http.Response, error) {
-	release := new(Release)
-	apiError := new(APIError)
-
-	resp, err := self.api.New().Get(params.Release_id).Receive(release, apiError)
-	return release, resp, relevantError(err, *apiError)
-}

releases_test.go

@@ -1,16 +0,0 @@
-package discogs
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestReleaseService_Release(t *testing.T) {
-	expectedTitle := "Elephant Riddim"
-
-	d := NewClient(testUserAgent, testToken)
-	release, _, err := d.Release.Release(&ReleaseParams{Release_id: "8138518"})
-
-	check(t, err)
-	assert(t, release.Title == expectedTitle, fmt.Sprintf("Release.Title looked for %s, and received %s ", expectedTitle, release.Title))
-}

search.go

@@ -1,71 +1,147 @@
 package discogs
 
 import (
-	"net/http"
+	"net/url"
-
+	"strconv"
-	"github.com/irlndts/go-apirequest"
 )
 
+// SearchService ...
 type SearchService struct {
-	api *apirequest.API
+	url string
 }
 
+func newSearchService(url string) *SearchService {
+	return &SearchService{
+		url: url,
+	}
+}
+
+// SearchRequest describes search request
 type SearchRequest struct {
-	Q             string // search query (optional)
+	Q            string // search query
-	Type          string // one of release, master, artist, label (optional)
+	Type         string // one of release, master, artist, label
-	Title         string // search by combined “Artist Name - Release Title” title field (optional)
+	Title        string // search by combined “Artist Name - Release Title” title field
-	Release_title string // search release titles (optional)
+	ReleaseTitle string // search release titles
-	Credit        string // search release credits (optional)
+	Credit       string // search release credits
-	Artist        string // search artist names (optional)
+	Artist       string // search artist names
-	Anv           string // search artist ANV (optional)
+	Anv          string // search artist ANV
-	Label         string // search label names (optional)
+	Label        string // search label names
-	Genre         string // search genres (optional)
+	Genre        string // search genres
-	Style         string // search styles (optional)
+	Style        string // search styles
-	Country       string // search release country (optional)
+	Country      string // search release country
-	Year          string // search release year (optional)
+	Year         string // search release year
-	Format        string // search formats (optional)
+	Format       string // search formats
-	Catno         string // search catalog number (optional)
+	Catno        string // search catalog number
-	Barcode       string // search barcodes (optional)
+	Barcode      string // search barcodes
-	Track         string // search track titles (optional)
+	Track        string // search track titles
-	Submitter     string // search submitter username (optional)
+	Submitter    string // search submitter username
-	Contributer   string // search contributor usernames (optional)
+	Contributor  string // search contributor usernames
 
-	Page     int // optional
+	Page    int
-	Per_page int // optional
+	PerPage int
 }
 
+func (r *SearchRequest) params() url.Values {
+	if r == nil {
+		return nil
+	}
+
+	params := url.Values{}
+
+	if r.Q != "" {
+		params.Set("q", r.Q)
+	}
+	if r.Type != "" {
+		params.Set("type", r.Type)
+	}
+	if r.Title != "" {
+		params.Set("title", r.Title)
+	}
+	if r.ReleaseTitle != "" {
+		params.Set("release_title", r.ReleaseTitle)
+	}
+	if r.Credit != "" {
+		params.Set("credit", r.Credit)
+	}
+	if r.Artist != "" {
+		params.Set("artist", r.Artist)
+	}
+	if r.Anv != "" {
+		params.Set("anv", r.Anv)
+	}
+	if r.Label != "" {
+		params.Set("label", r.Label)
+	}
+	if r.Genre != "" {
+		params.Set("genre", r.Genre)
+	}
+	if r.Style != "" {
+		params.Set("style", r.Style)
+	}
+	if r.Country != "" {
+		params.Set("country", r.Country)
+	}
+	if r.Year != "" {
+		params.Set("year", r.Year)
+	}
+	if r.Format != "" {
+		params.Set("format", r.Format)
+	}
+	if r.Catno != "" {
+		params.Set("catno", r.Catno)
+	}
+	if r.Barcode != "" {
+		params.Set("barcode", r.Barcode)
+	}
+	if r.Track != "" {
+		params.Set("track", r.Track)
+	}
+	if r.Submitter != "" {
+		params.Set("submitter", r.Submitter)
+	}
+	if r.Contributor != "" {
+		params.Set("contributor", r.Contributor)
+	}
+
+	params.Set("page", strconv.Itoa(r.Page))
+	if r.PerPage != 0 {
+		params.Set("per_page", strconv.Itoa(r.PerPage))
+	}
+	return params
+}
+
+// Search describes search response
 type Search struct {
 	Pagination Page     `json:"pagination"`
-	Results    []Result `json:"results"`
+	Results    []Result `json:"results,omitempty"`
 }
 
+// Result describes a part of search result
 type Result struct {
-	Style        []string  `json:"style"`
+	Style       []string  `json:"style,omitempty"`
-	Thumb        string    `json:"thumb"`
+	Thumb       string    `json:"thumb,omitempty"`
-	Title        string    `json:"title"`
+	CoverImage  string    `json:"cover_image,omitempty"`
-	Country      string    `json:"country"`
+	Title       string    `json:"title,omitempty"`
-	Format       []string  `json:"format"`
+	Country     string    `json:"country,omitempty"`
-	Uri          string    `json:"uri"`
+	Format      []string  `json:"format,omitempty"`
-	Community    Community `json:"community"`
+	URI         string    `json:"uri,omitempty"`
-	Label        []string  `json:"label"`
+	Community   Community `json:"community,omitempty"`
-	Catno        string    `json:"catno"`
+	Label       []string  `json:"label,omitempty"`
-	Year         string    `json:"year"`
+	Catno       string    `json:"catno,omitempty"`
-	Genre        []string  `json:"genre"`
+	Year        string    `json:"year,omitempty"`
-	Resource_url string    `json:"resource_url"`
+	Genre       []string  `json:"genre,omitempty"`
-	Type         string    `json:"type"`
+	ResourceURL string    `json:"resource_url,omitempty"`
-	Id           int       `json:"id"`
+	Type        string    `json:"type,omitempty"`
+	ID          int       `json:"id,omitempty"`
+	MasterID    int       `json:"master_id,omitempty"`
 }
 
-func newSearchService(api *apirequest.API) *SearchService {
+// Search makes search request to discogs.
-	return &SearchService{
+// Issue a search query to our database. This endpoint accepts pagination parameters.
-		api: api.Path("database/search"),
+// Authentication (as any user) is required.
-	}
+// https://www.discogs.com/developers/#page:database,header:database-search
-}
+func (s *SearchService) Search(req SearchRequest) (*Search, error) {
-
+	var search *Search
-func (self *SearchService) Search(params *SearchRequest) (*Search, *http.Response, error) {
+	err := request(s.url, req.params(), &search)
-	search := new(Search)
+	return search, err
-	apiError := new(APIError)
-
-	resp, err := self.api.New().QueryStruct(params).Receive(search, apiError)
-	return search, resp, relevantError(err, *apiError)
 }