chore: lint

Author: tharropoulos

Diff for: typesense/api/types.go

@@ -7,6 +7,6 @@ type ImportDocumentResponse struct {
 }
 
 type StemmingDictionaryWord struct {
-    Root string `json:"root"`
-    Word string `json:"word"`
+	Root string `json:"root"`
+	Word string `json:"word"`
 }

Diff for: typesense/stemming.go

@@ -1,18 +1,18 @@
 package typesense
 
 type StemmingInterface interface {
-    Dictionaries() StemmingDictionariesInterface
-    Dictionary(dictionaryId string) StemmingDictionaryInterface
+	Dictionaries() StemmingDictionariesInterface
+	Dictionary(dictionaryId string) StemmingDictionaryInterface
 }
 
 type stemming struct {
-    apiClient APIClientInterface
+	apiClient APIClientInterface
 }
 
 func (s *stemming) Dictionaries() StemmingDictionariesInterface {
-    return &stemmingDictionaries{apiClient: s.apiClient}
+	return &stemmingDictionaries{apiClient: s.apiClient}
 }
 
 func (s *stemming) Dictionary(dictionaryId string) StemmingDictionaryInterface {
-    return &stemmingDictionary{apiClient: s.apiClient, dictionaryId: dictionaryId}
-}
+	return &stemmingDictionary{apiClient: s.apiClient, dictionaryId: dictionaryId}
+}

Diff for: typesense/stemming_dictionaries.go

@@ -11,74 +11,74 @@ import (
 )
 
 type StemmingDictionariesInterface interface {
-    Upsert(ctx context.Context, dictionaryId string, wordRootCombinations []api.StemmingDictionaryWord) ([]*api.StemmingDictionaryWord, error)
-    UpsertJsonl(ctx context.Context, dictionaryId string, body io.Reader) (io.ReadCloser, error)
-    Retrieve(ctx context.Context) (*api.ListStemmingDictionariesResponse, error)
+	Upsert(ctx context.Context, dictionaryId string, wordRootCombinations []api.StemmingDictionaryWord) ([]*api.StemmingDictionaryWord, error)
+	UpsertJsonl(ctx context.Context, dictionaryId string, body io.Reader) (io.ReadCloser, error)
+	Retrieve(ctx context.Context) (*api.ListStemmingDictionariesResponse, error)
 }
 
 type stemmingDictionaries struct {
-    apiClient APIClientInterface
+	apiClient APIClientInterface
 }
 
 func (s *stemmingDictionaries) Upsert(ctx context.Context, dictionaryId string, wordRootCombinations []api.StemmingDictionaryWord) ([]*api.StemmingDictionaryWord, error) {
-    var buf bytes.Buffer
-    jsonEncoder := json.NewEncoder(&buf)
-    for _, combo := range wordRootCombinations {
-        if err := jsonEncoder.Encode(combo); err != nil {
-            return nil, err
-        }
-    }
+	var buf bytes.Buffer
+	jsonEncoder := json.NewEncoder(&buf)
+	for _, combo := range wordRootCombinations {
+		if err := jsonEncoder.Encode(combo); err != nil {
+			return nil, err
+		}
+	}
 
-    response, err := s.UpsertJsonl(ctx, dictionaryId, &buf)
-    if err != nil {
-        return nil, err
-    }
+	response, err := s.UpsertJsonl(ctx, dictionaryId, &buf)
+	if err != nil {
+		return nil, err
+	}
 
-    var result []*api.StemmingDictionaryWord
-    jsonDecoder := json.NewDecoder(response)
-    for jsonDecoder.More() {
-        var docResult *api.StemmingDictionaryWord
-        if err := jsonDecoder.Decode(&docResult); err != nil {
-            return result, err
-        }
-        result = append(result, docResult)
-    }
+	var result []*api.StemmingDictionaryWord
+	jsonDecoder := json.NewDecoder(response)
+	for jsonDecoder.More() {
+		var docResult *api.StemmingDictionaryWord
+		if err := jsonDecoder.Decode(&docResult); err != nil {
+			return result, err
+		}
+		result = append(result, docResult)
+	}
 
-    return result, nil
+	return result, nil
 }
 
 func (s *stemmingDictionaries) UpsertJsonl(ctx context.Context, dictionaryId string, body io.Reader) (io.ReadCloser, error) {
-    params := &api.ImportStemmingDictionaryParams{
-        Id: dictionaryId,
-    }
-    
-    response, err := s.apiClient.ImportStemmingDictionaryWithBody(ctx,
-        params, "application/octet-stream", body)
-    if err != nil {
-        return nil, err
-    }
-    if response.StatusCode != http.StatusOK {
-        defer response.Body.Close()
-        body, _ := io.ReadAll(response.Body)
-        return nil, &HTTPError{Status: response.StatusCode, Body: body}
-    }
-    return response.Body, nil
+	params := &api.ImportStemmingDictionaryParams{
+		Id: dictionaryId,
+	}
+
+	response, err := s.apiClient.ImportStemmingDictionaryWithBody(ctx,
+		params, "application/octet-stream", body)
+	if err != nil {
+		return nil, err
+	}
+	if response.StatusCode != http.StatusOK {
+		defer response.Body.Close()
+		body, _ := io.ReadAll(response.Body)
+		return nil, &HTTPError{Status: response.StatusCode, Body: body}
+	}
+	return response.Body, nil
 }
 
 func (s *stemmingDictionaries) Retrieve(ctx context.Context) (*api.ListStemmingDictionariesResponse, error) {
-    response, err := s.apiClient.ListStemmingDictionariesWithResponse(ctx)
-    if err != nil {
-        return nil, err
-    }
-    if response.JSON200 == nil {
-        emptySlice := make([]string, 0)
-        return &api.ListStemmingDictionariesResponse{
-            JSON200: &struct {
-                Dictionaries *[]string `json:"dictionaries,omitempty"`
-            }{
-                Dictionaries: &emptySlice,
-            },
-        }, nil
-    }
-    return response, nil
-}
+	response, err := s.apiClient.ListStemmingDictionariesWithResponse(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if response.JSON200 == nil {
+		emptySlice := make([]string, 0)
+		return &api.ListStemmingDictionariesResponse{
+			JSON200: &struct {
+				Dictionaries *[]string `json:"dictionaries,omitempty"`
+			}{
+				Dictionaries: &emptySlice,
+			},
+		}, nil
+	}
+	return response, nil
+}

Diff for: typesense/stemming_dictionary.go

@@ -7,21 +7,21 @@ import (
 )
 
 type StemmingDictionaryInterface interface {
-    Retrieve(ctx context.Context) (*api.StemmingDictionary, error)
+	Retrieve(ctx context.Context) (*api.StemmingDictionary, error)
 }
 
 type stemmingDictionary struct {
-    apiClient    APIClientInterface
-    dictionaryId string
+	apiClient    APIClientInterface
+	dictionaryId string
 }
 
 func (s *stemmingDictionary) Retrieve(ctx context.Context) (*api.StemmingDictionary, error) {
-    response, err := s.apiClient.GetStemmingDictionaryWithResponse(ctx, s.dictionaryId)
-    if err != nil {
-        return nil, err
-    }
-    if response.JSON200 == nil {
-        return nil, &HTTPError{Status: response.StatusCode(), Body: response.Body}
-    }
-    return response.JSON200, nil
-}
+	response, err := s.apiClient.GetStemmingDictionaryWithResponse(ctx, s.dictionaryId)
+	if err != nil {
+		return nil, err
+	}
+	if response.JSON200 == nil {
+		return nil, &HTTPError{Status: response.StatusCode(), Body: response.Body}
+	}
+	return response.JSON200, nil
+}