- mvp of working Manticore migration

Author: Lamarcke

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.21.3
+FROM golang:1.23.7
 
 WORKDIR /app
 

docker-compose.yml

@@ -6,17 +6,15 @@ services:
   manticore:
     image: manticoresearch/manticore:7.4.6
     environment:
-      EXTRA: 1
-      # Will attempt to index 'gamenode' on startup
-      CREATE_PLAIN_TABLES: gamenode
+      CREATE_PLAIN_TABLES: games:0 3 * * *;users:0 * * * *;games;users
 
     restart: no
     ports:
       # Note: ManticoreSearch as minimum built-in security,
       # so it's not recommended to expose it to the host in production.
       # SQL port, use it with care.
-      - "127.0.0.1:9306:9306"
-      - "127.0.0.1:9308:9308"
+      - "9306:9306"
+      - "9308:9308"
 
     ulimits:
       nproc: 65535
@@ -31,8 +29,12 @@ services:
       - manticore:/var/lib/manticore
       - ./manticore.conf:/etc/manticoresearch/manticore.conf
 
-    network_mode: host
+    networks:
+      - game_node_app
 
+networks:
+  game_node_app:
+    external: true
 
 volumes:
   manticore:

main.go

@@ -77,6 +77,32 @@ func main() {
 		_, _ = w.Write(responseBytes)
 		return
 	})
+	r.Post("/search/games/autocomplete", func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		reqDtoBytes, _ := io.ReadAll(r.Body)
+
+		var reqDto games.GameAutocompleteRequestDto
+		err := json.Unmarshal(reqDtoBytes, &reqDto)
+		if err != nil {
+			slog.Error("Error while responding to request: ", "err", err)
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		response, err := games.Autocomplete(&reqDto)
+		w.Header().Set("Content-Type", "application/json")
+		if err != nil {
+			slog.Error("Error while responding to request: ", "err", err)
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		responseBytes, _ := json.Marshal(response)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write(responseBytes)
+		return
+	})
 	r.Post("/search/users", func(w http.ResponseWriter, r *http.Request) {
 		defer r.Body.Close()
 		reqDtoBytes, _ := io.ReadAll(r.Body)

manticore.conf

@@ -82,7 +82,6 @@ source games_source {
   sql_attr_bigint = status
   sql_attr_bigint = num_views
   sql_attr_bigint = num_likes
-
 }
 
 source users_source {
@@ -103,21 +102,22 @@ source users_source {
     sql_attr_timestamp = created_at
     sql_attr_timestamp = updated_at
     sql_attr_string = user_id
-
-
 }
 
 table games {
   dict = keywords
   type = plain
+  min_infix_len = 3
+  index_exact_words = 1
+  expand_keywords = 1
   source = games_source
   path = /var/lib/manticore/games
 }
 
 table users {
   dict = keywords
   type = plain
+  min_infix_len = 3
   source = users_source
   path = /var/lib/manticore/users
-  min_infix_len = 3
 }

schema/schema.go

@@ -2,55 +2,6 @@ package schema
 
 type AnyMap map[string]interface{}
 
-type UserManticoreSearchSource struct {
-	UserId   string `json:"user_id"`
-	Username string `json:"username"`
-}
-
-type UserManticoreResponseHit struct {
-	ID     string                    `json:"_id"`
-	Score  int                       `json:"_score"`
-	Source UserManticoreSearchSource `json:"_source"`
-}
-
-type UserManticoreSearchHits struct {
-	MaxScore      *float64                   `json:"max_score,omitempty"`
-	Total         *int                       `json:"total,omitempty"`
-	TotalRelation *string                    `json:"total_relation,omitempty"`
-	Hits          []UserManticoreResponseHit `json:"hits,omitempty"`
-}
-
-type UserManticoreSearchResponse struct {
-	Took         *int                     `json:"took,omitempty"`
-	TimedOut     *bool                    `json:"timed_out,omitempty"`
-	Aggregations map[string]interface{}   `json:"aggregations,omitempty"`
-	Hits         *UserManticoreSearchHits `json:"hits,omitempty"`
-	Profile      *map[string]interface{}  `json:"profile,omitempty"`
-	Warning      map[string]interface{}   `json:"warning,omitempty"`
-}
-
-type UserDto struct {
-	UserId   string `json:"userId"`
-	Username string `json:"username"`
-}
-
-type UserSearchResponseData struct {
-	Took    *int32                 `json:"took,omitempty"`
-	Items   *[]UserDto             `json:"items,omitempty"`
-	Profile map[string]interface{} `json:"profile,omitempty"`
-}
-
-type UserSearchResponseDto struct {
-	Data       *UserSearchResponseData `json:"data"`
-	Pagination *PaginationInfo         `json:"pagination"`
-}
-
-type UserSearchRequestDto struct {
-	Query string `json:"query"`
-	Limit *int32 `json:"limit"`
-	Page  *int32 `json:"page"`
-}
-
 const DefaultLimit int32 = 20
 
 type PaginationInfo struct {

search/games/autocomplete.go

@@ -0,0 +1,45 @@
+package games
+
+import (
+	"fmt"
+)
+
+// Autocomplete games autocomplete handler
+//
+//	@Summary      Autocomplete games names using Manticore engine
+//	@Description  Returns a parsed search response from the Manticore engine
+//	@Tags         search
+//	@Accept       json
+//	@Produce      json
+//	@Param        query   body      games.GameAutocompleteRequestDto  true  ""
+//	@Success      200  {object}   games.GameAutocompleteResponseDto
+//	@Router       /search/games/autocomplete [post]
+func Autocomplete(dto *GameAutocompleteRequestDto) (*GameAutocompleteResponseDto, error) {
+	autocompleteQuery := fmt.Sprintf("^\"%s*\"", dto.Query)
+
+	limit := int32(5)
+
+	searchRequest := GameSearchRequestDto{
+		Query: autocompleteQuery,
+		Limit: &limit,
+	}
+
+	searchResponseDto, err := Search(&searchRequest)
+	if err != nil {
+		return nil, err
+	}
+
+	items := searchResponseDto.Data.Items
+
+	response := GameAutocompleteResponseDto{Data: make([]string, 0), Total: 0}
+
+	if items != nil && len(*items) > 0 {
+		for _, game := range *items {
+			response.Data = append(response.Data, game.Name)
+		}
+
+		response.Total = uint(len(*items))
+	}
+
+	return &response, nil
+}

search/games/parser.go

@@ -3,9 +3,7 @@ package games
 import (
 	"game-node-search/schema"
 	Manticoresearch "github.com/manticoresoftware/manticoresearch-go"
-	"github.com/mitchellh/mapstructure"
 	"log/slog"
-	"strconv"
 	"time"
 )
 
@@ -15,6 +13,12 @@ func buildPaginationInfo(mr *Manticoresearch.SearchResponse, limit *int32, curre
 		i := schema.DefaultLimit
 		limitToUse = &i
 	}
+
+	if currentPage == nil {
+		p := int32(1)
+		currentPage = &p
+	}
+
 	var paginationInfo = schema.PaginationInfo{
 		TotalItems:  0,
 		TotalPages:  0,
@@ -47,18 +51,24 @@ func buildResponseData(mr *Manticoresearch.SearchResponse) (*ResponseData, error
 	}
 
 	if mr.Hits != nil && mr.Hits.Hits != nil && len(mr.Hits.Hits) > 0 {
+
 		for _, hit := range mr.Hits.Hits {
-			var convertedHit ManticoreResponseHit
-			err := mapstructure.Decode(hit, convertedHit)
+			hitJson, err := json.Marshal(hit)
 			if err != nil {
-				slog.Error("Error while decoding results to return type.", "err", err)
+				slog.Error("Error while decoding results to JSON.", "err", err)
 				return nil, err
 			}
 
-			hitIdNumber, _ := strconv.ParseUint(convertedHit.ID, 10, 64)
+			var convertedHit ManticoreResponseHit
+
+			err = json.Unmarshal(hitJson, &convertedHit)
+			if err != nil {
+				slog.Error("Error while decoding results from JSON.", "err", err)
+				return nil, err
+			}
 
 			searchGame := SearchGame{
-				ID:                     hitIdNumber,
+				ID:                     convertedHit.ID,
 				Name:                   convertedHit.Source.Name,
 				Slug:                   convertedHit.Source.Slug,
 				Summary:                convertedHit.Source.Summary,
@@ -87,5 +97,9 @@ func buildResponseData(mr *Manticoresearch.SearchResponse) (*ResponseData, error
 
 	data.Items = &searchGames
 
+	if searchGames == nil {
+		data.Items = &[]SearchGame{}
+	}
+
 	return &data, nil
 }

search/games/schema.go

@@ -31,7 +31,7 @@ type ManticoreResponseHitSource struct {
 }
 
 type ManticoreResponseHit struct {
-	ID    string `json:"_id"`
+	ID    uint64 `json:"_id"`
 	Score int    `json:"_score"`
 	// To avoid re-mapping here, we only map the final SearchGame which is used in GameSearchResponseHit
 	// This is basically SearchGame as returned by ManticoreSearch, in snake_case.
@@ -88,13 +88,22 @@ type GameSearchResponseDto struct {
 }
 
 type GameSearchRequestDto struct {
-	Query     string    `json:"query"`
-	Category  *[]int    `json:"category,omitempty"`
-	Status    *[]int    `json:"status,omitempty"`
-	Genres    *[]string `json:"genres"`
-	Themes    *[]string `json:"themes"`
-	Platforms *[]string `json:"platforms"`
-	Limit     *int32    `json:"limit,omitempty"`
-	Page      *int32    `json:"page,omitempty"`
-	Profile   *bool     `json:"profile,omitempty"`
+	Query     string   `json:"query"`
+	Category  []int    `json:"category,omitempty"`
+	Status    []int    `json:"status,omitempty"`
+	Genres    []string `json:"genres,omitempty"`
+	Themes    []string `json:"themes,omitempty"`
+	Platforms []string `json:"platforms,omitempty"`
+	Limit     *int32   `json:"limit,omitempty"`
+	Page      *int32   `json:"page,omitempty"`
+	Profile   *bool    `json:"profile,omitempty"`
+}
+
+type GameAutocompleteRequestDto struct {
+	Query string `json:"query"`
+}
+
+type GameAutocompleteResponseDto struct {
+	Total uint     `json:"total"`
+	Data  []string `json:"data"`
 }