Initial QSfera import

Server/services/search/pkg/bleve/backend.go

@@ -0,0 +1,230 @@
+package bleve
+
+import (
+	"context"
+	"math"
+	"strings"
+	"time"
+
+	"github.com/blevesearch/bleve/v2"
+	"github.com/blevesearch/bleve/v2/search/query"
+	storageProvider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+	"github.com/opencloud-eu/reva/v2/pkg/errtypes"
+	"github.com/opencloud-eu/reva/v2/pkg/storagespace"
+	"github.com/opencloud-eu/reva/v2/pkg/utils"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"github.com/qsfera/server/pkg/log"
+	"github.com/qsfera/server/services/search/pkg/search"
+
+	searchMessage "github.com/qsfera/server/protogen/gen/qsfera/messages/search/v0"
+	searchService "github.com/qsfera/server/protogen/gen/qsfera/services/search/v0"
+	searchQuery "github.com/qsfera/server/services/search/pkg/query"
+)
+
+const defaultBatchSize = 50
+
+var _ search.Engine = (*Backend)(nil) // ensure Backend implements Engine
+
+type Backend struct {
+	index        bleve.Index
+	queryCreator searchQuery.Creator[query.Query]
+	log          log.Logger
+}
+
+func NewBackend(index bleve.Index, queryCreator searchQuery.Creator[query.Query], log log.Logger) *Backend {
+	return &Backend{
+		index:        index,
+		queryCreator: queryCreator,
+		log:          log,
+	}
+}
+
+// Search executes a search request operation within the index.
+// Returns a SearchIndexResponse object or an error.
+func (b *Backend) Search(_ context.Context, sir *searchService.SearchIndexRequest) (*searchService.SearchIndexResponse, error) {
+	createdQuery, err := b.queryCreator.Create(sir.Query)
+	if err != nil {
+		if searchQuery.IsValidationError(err) {
+			return nil, errtypes.BadRequest(err.Error())
+		}
+		return nil, err
+	}
+
+	q := bleve.NewConjunctionQuery(
+		// Skip documents that have been marked as deleted
+		&query.BoolFieldQuery{
+			Bool:     false,
+			FieldVal: "Deleted",
+		},
+		createdQuery,
+	)
+
+	if sir.Ref != nil {
+		q.Conjuncts = append(
+			q.Conjuncts,
+			&query.TermQuery{
+				FieldVal: "RootID",
+				Term: storagespace.FormatResourceID(
+					&storageProvider.ResourceId{
+						StorageId: sir.Ref.GetResourceId().GetStorageId(),
+						SpaceId:   sir.Ref.GetResourceId().GetSpaceId(),
+						OpaqueId:  sir.Ref.GetResourceId().GetOpaqueId(),
+					},
+				),
+			},
+		)
+	}
+
+	bleveReq := bleve.NewSearchRequest(q)
+	bleveReq.Highlight = bleve.NewHighlight()
+
+	switch {
+	case sir.PageSize == -1:
+		bleveReq.Size = math.MaxInt
+	case sir.PageSize == 0:
+		bleveReq.Size = 200
+	default:
+		bleveReq.Size = int(sir.PageSize)
+	}
+
+	bleveReq.Fields = []string{"*"}
+	res, err := b.index.Search(bleveReq)
+	if err != nil {
+		return nil, err
+	}
+
+	matches := make([]*searchMessage.Match, 0, len(res.Hits))
+	totalMatches := res.Total
+	for _, hit := range res.Hits {
+		if sir.Ref != nil {
+			hitPath := strings.TrimSuffix(getFieldValue[string](hit.Fields, "Path"), "/")
+			requestedPath := utils.MakeRelativePath(sir.Ref.Path)
+			isRoot := hitPath == requestedPath
+
+			if !isRoot && requestedPath != "." && !strings.HasPrefix(hitPath, requestedPath+"/") {
+				totalMatches--
+				continue
+			}
+		}
+
+		rootID, err := storagespace.ParseID(getFieldValue[string](hit.Fields, "RootID"))
+		if err != nil {
+			return nil, err
+		}
+
+		rID, err := storagespace.ParseID(getFieldValue[string](hit.Fields, "ID"))
+		if err != nil {
+			return nil, err
+		}
+
+		pID, _ := storagespace.ParseID(getFieldValue[string](hit.Fields, "ParentID"))
+		match := &searchMessage.Match{
+			Score: float32(hit.Score),
+			Entity: &searchMessage.Entity{
+				Ref: &searchMessage.Reference{
+					ResourceId: resourceIDtoSearchID(rootID),
+					Path:       getFieldValue[string](hit.Fields, "Path"),
+				},
+				Id:         resourceIDtoSearchID(rID),
+				Name:       getFieldValue[string](hit.Fields, "Name"),
+				ParentId:   resourceIDtoSearchID(pID),
+				Size:       uint64(getFieldValue[float64](hit.Fields, "Size")),
+				Type:       uint64(getFieldValue[float64](hit.Fields, "Type")),
+				MimeType:   getFieldValue[string](hit.Fields, "MimeType"),
+				Deleted:    getFieldValue[bool](hit.Fields, "Deleted"),
+				Tags:       getFieldSliceValue[string](hit.Fields, "Tags"),
+				Favorites:  getFieldSliceValue[string](hit.Fields, "Favorites"),
+				Highlights: getFragmentValue(hit.Fragments, "Content", 0),
+				Audio:      getAudioValue[searchMessage.Audio](hit.Fields),
+				Image:      getImageValue[searchMessage.Image](hit.Fields),
+				Location:   getLocationValue[searchMessage.GeoCoordinates](hit.Fields),
+				Photo:      getPhotoValue[searchMessage.Photo](hit.Fields),
+			},
+		}
+
+		if mtime, err := time.Parse(time.RFC3339, getFieldValue[string](hit.Fields, "Mtime")); err == nil {
+			match.Entity.LastModifiedTime = &timestamppb.Timestamp{Seconds: mtime.Unix(), Nanos: int32(mtime.Nanosecond())}
+		}
+
+		matches = append(matches, match)
+	}
+
+	return &searchService.SearchIndexResponse{
+		Matches:      matches,
+		TotalMatches: int32(totalMatches),
+	}, nil
+}
+
+func (b *Backend) DocCount() (uint64, error) {
+	return b.index.DocCount()
+}
+
+func (b *Backend) Upsert(id string, r search.Resource) error {
+	batch, err := b.NewBatch(defaultBatchSize)
+	if err != nil {
+		return err
+	}
+
+	if err := batch.Upsert(id, r); err != nil {
+		return err
+	}
+
+	return batch.Push()
+}
+
+func (b *Backend) Move(rootID, parentID, location string) error {
+	batch, err := b.NewBatch(defaultBatchSize)
+	if err != nil {
+		return err
+	}
+
+	if err := batch.Move(rootID, parentID, location); err != nil {
+		return err
+	}
+
+	return batch.Push()
+}
+
+func (b *Backend) Delete(id string) error {
+	batch, err := b.NewBatch(defaultBatchSize)
+	if err != nil {
+		return err
+	}
+
+	if err := batch.Delete(id); err != nil {
+		return err
+	}
+
+	return batch.Push()
+}
+
+func (b *Backend) Restore(id string) error {
+	batch, err := b.NewBatch(defaultBatchSize)
+	if err != nil {
+		return err
+	}
+
+	if err := batch.Restore(id); err != nil {
+		return err
+	}
+
+	return batch.Push()
+}
+
+func (b *Backend) Purge(id string, onlyDeleted bool) error {
+	batch, err := b.NewBatch(defaultBatchSize)
+	if err != nil {
+		return err
+	}
+
+	if err := batch.Purge(id, onlyDeleted); err != nil {
+		return err
+	}
+
+	return batch.Push()
+}
+
+func (b *Backend) NewBatch(size int) (search.BatchOperator, error) {
+	return NewBatch(b.index, size)
+}

Server/services/search/pkg/bleve/backend_test.go

@@ -0,0 +1,710 @@
+package bleve_test
+
+import (
+	"context"
+	"fmt"
+
+	bleveSearch "github.com/blevesearch/bleve/v2"
+	sprovider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	libregraph "github.com/opencloud-eu/libre-graph-api-go"
+	"github.com/opencloud-eu/reva/v2/pkg/storagespace"
+
+	"github.com/qsfera/server/pkg/log"
+	searchmsg "github.com/qsfera/server/protogen/gen/qsfera/messages/search/v0"
+	searchsvc "github.com/qsfera/server/protogen/gen/qsfera/services/search/v0"
+	"github.com/qsfera/server/services/search/pkg/bleve"
+	"github.com/qsfera/server/services/search/pkg/content"
+	bleveQuery "github.com/qsfera/server/services/search/pkg/query/bleve"
+	"github.com/qsfera/server/services/search/pkg/search"
+)
+
+var _ = Describe("Bleve", func() {
+	var (
+		eng *bleve.Backend
+		idx bleveSearch.Index
+
+		doSearch = func(id string, query, path string) (*searchsvc.SearchIndexResponse, error) {
+			rID, err := storagespace.ParseID(id)
+			if err != nil {
+				return nil, err
+			}
+
+			return eng.Search(context.Background(), &searchsvc.SearchIndexRequest{
+				Query: query,
+				Ref: &searchmsg.Reference{
+					ResourceId: &searchmsg.ResourceID{
+						StorageId: rID.StorageId,
+						SpaceId:   rID.SpaceId,
+						OpaqueId:  rID.OpaqueId,
+					},
+					Path: path,
+				},
+			})
+		}
+
+		assertDocCount = func(id string, query string, expectedCount int) []*searchmsg.Match {
+			res, err := doSearch(id, query, "")
+
+			ExpectWithOffset(1, err).ToNot(HaveOccurred())
+			ExpectWithOffset(1, len(res.Matches)).To(Equal(expectedCount), "query returned unexpected number of results: "+query)
+			return res.Matches
+		}
+
+		rootResource   search.Resource
+		parentResource search.Resource
+		childResource  search.Resource
+		childResource2 search.Resource
+	)
+
+	BeforeEach(func() {
+		mapping, err := bleve.NewMapping()
+		Expect(err).ToNot(HaveOccurred())
+
+		idx, err = bleveSearch.NewMemOnly(mapping)
+		Expect(err).ToNot(HaveOccurred())
+
+		eng = bleve.NewBackend(idx, bleveQuery.DefaultCreator, log.Logger{})
+		Expect(err).ToNot(HaveOccurred())
+
+		rootResource = search.Resource{
+			ID:       "1$2!2",
+			RootID:   "1$2!2",
+			Path:     ".",
+			Document: content.Document{},
+		}
+
+		parentResource = search.Resource{
+			ID:       "1$2!3",
+			ParentID: rootResource.ID,
+			RootID:   rootResource.ID,
+			Path:     "./parent d!r",
+			Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_CONTAINER),
+			Document: content.Document{Name: "parent d!r"},
+		}
+
+		childResource = search.Resource{
+			ID:       "1$2!4",
+			ParentID: parentResource.ID,
+			RootID:   rootResource.ID,
+			Path:     "./parent d!r/child.pdf",
+			Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+			Document: content.Document{Name: "child.pdf"},
+		}
+
+		childResource2 = search.Resource{
+			ID:       "1$2!5",
+			ParentID: parentResource.ID,
+			RootID:   rootResource.ID,
+			Path:     "./parent d!r/child2.pdf",
+			Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+			Document: content.Document{Name: "child2.pdf"},
+		}
+	})
+
+	Describe("New", func() {
+		It("returns a new index instance", func() {
+			b := bleve.NewBackend(idx, bleveQuery.DefaultCreator, log.Logger{})
+			Expect(b).ToNot(BeNil())
+		})
+	})
+
+	Describe("Search", func() {
+		Context("by other fields than filename", func() {
+			It("finds files by tags", func() {
+				parentResource.Document.Tags = []string{"foo", "bar"}
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, "Tags:foo", 1)
+				assertDocCount(rootResource.ID, "Tags:bar", 1)
+				assertDocCount(rootResource.ID, "Tags:foo Tags:bar", 1)
+				assertDocCount(rootResource.ID, "Tags:foo Tags:bar Tags:baz", 1)
+				assertDocCount(rootResource.ID, "Tags:foo Tags:bar Tags:baz", 1)
+				assertDocCount(rootResource.ID, "Tags:baz", 0)
+			})
+
+			It("finds files by size", func() {
+				parentResource.Document.Size = 12345
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, "Size:12345", 1)
+				assertDocCount(rootResource.ID, "Size:>1000", 1)
+				assertDocCount(rootResource.ID, "Size:<100000", 1)
+				assertDocCount(rootResource.ID, "Size:12344", 0)
+				assertDocCount(rootResource.ID, "Size:<1000", 0)
+				assertDocCount(rootResource.ID, "Size:>100000", 0)
+			})
+
+			It("preserves value case for fields not explicitly marked lowercase", func() {
+				parentResource.Document.Audio = &libregraph.Audio{
+					Artist: libregraph.PtrString("Some Artist"),
+				}
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, `audio.artist:"Some Artist"`, 1)
+				assertDocCount(rootResource.ID, `audio.artist:"some artist"`, 0)
+			})
+		})
+
+		Context("by filename", func() {
+			It("finds files with spaces in the filename", func() {
+				parentResource.Document.Name = "Foo oo.pdf"
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, `name:"foo o*"`, 1)
+			})
+
+			It("finds files by digits in the filename", func() {
+				parentResource.Document.Name = "12345.pdf"
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, "Name:1234*", 1)
+			})
+
+			It("filters hidden files", func() {
+				childResource.Hidden = true
+				err := eng.Upsert(childResource.ID, childResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, "Hidden:T", 1)
+				assertDocCount(rootResource.ID, "Hidden:F", 0)
+			})
+
+			Context("with a file in the root of the space", func() {
+				It("scopes the search to the specified space", func() {
+					parentResource.Document.Name = "foo.pdf"
+					err := eng.Upsert(parentResource.ID, parentResource)
+					Expect(err).ToNot(HaveOccurred())
+
+					assertDocCount(rootResource.ID, "Name:foo.pdf", 1)
+					assertDocCount("9$8!7", "Name:foo.pdf", 0)
+				})
+			})
+
+			It("limits the search to the specified fields", func() {
+				parentResource.Document.Name = "bar.pdf"
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, "Name:bar.pdf", 1)
+				assertDocCount(rootResource.ID, "Unknown:field", 0)
+			})
+
+			It("returns the total number of hits", func() {
+				parentResource.Document.Name = "bar.pdf"
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				res, err := doSearch(rootResource.ID, "Name:bar*", "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(res.TotalMatches).To(Equal(int32(1)))
+			})
+
+			It("returns all desired fields", func() {
+				parentResource.Document.Name = "bar.pdf"
+				parentResource.Type = 3
+				parentResource.MimeType = "application/pdf"
+
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				matches := assertDocCount(rootResource.ID, fmt.Sprintf("Name:%s", parentResource.Name), 1)
+				match := matches[0]
+				Expect(match.Entity.Ref.Path).To(Equal(parentResource.Path))
+				Expect(match.Entity.Name).To(Equal(parentResource.Name))
+				Expect(match.Entity.Size).To(Equal(parentResource.Size))
+				Expect(match.Entity.Type).To(Equal(parentResource.Type))
+				Expect(match.Entity.MimeType).To(Equal(parentResource.MimeType))
+				Expect(match.Entity.Deleted).To(BeFalse())
+				Expect(match.Score > 0).To(BeTrue())
+			})
+
+			It("finds files by name, prefix or substring match", func() {
+				parentResource.Document.Name = "foo.pdf"
+
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				queries := []string{"foo.pdf", "foo*", "*oo.p*"}
+				for _, query := range queries {
+					err := eng.Upsert(parentResource.ID, parentResource)
+					Expect(err).ToNot(HaveOccurred())
+
+					assertDocCount(rootResource.ID, query, 1)
+				}
+			})
+
+			It("does a case-insensitive search", func() {
+				parentResource.Document.Name = "foo.pdf"
+
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				assertDocCount(rootResource.ID, "Name:foo*", 1)
+				assertDocCount(rootResource.ID, "Name:Foo*", 1)
+			})
+
+			Context("and an additional file in a subdirectory", func() {
+				BeforeEach(func() {
+					err := eng.Upsert(parentResource.ID, parentResource)
+					Expect(err).ToNot(HaveOccurred())
+
+					err = eng.Upsert(childResource.ID, childResource)
+					Expect(err).ToNot(HaveOccurred())
+				})
+
+				It("finds files living deeper in the tree by filename, prefix or substring match", func() {
+					queries := []string{"child.pdf", "child*", "*ld.*"}
+					for _, query := range queries {
+						assertDocCount(rootResource.ID, query, 1)
+					}
+				})
+			})
+		})
+
+		Context("Highlights", func() {
+
+			It("highlights only for content searches", func() {
+				parentResource.Document.Name = "baz.pdf"
+				parentResource.Document.Content = "foo bar baz"
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				res, err := doSearch(rootResource.ID, "Name:baz*", "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(res.TotalMatches).To(Equal(int32(1)))
+				Expect(res.Matches[0].Entity.Highlights).To(Equal(""))
+			})
+
+			It("highlights search terms", func() {
+				parentResource.Document.Name = "baz.pdf"
+				parentResource.Document.Content = "foo bar baz"
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				res, err := doSearch(rootResource.ID, "Content:bar", "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(res.TotalMatches).To(Equal(int32(1)))
+				Expect(res.Matches[0].Entity.Highlights).To(Equal("foo <mark>bar</mark> baz"))
+			})
+
+		})
+
+		Context("with a file in the root of the space and folder with a file. all of them have the same name", func() {
+			BeforeEach(func() {
+				parentResource := search.Resource{
+					ID:       "1$2!3",
+					ParentID: rootResource.ID,
+					RootID:   rootResource.ID,
+					Path:     "./doc",
+					Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_CONTAINER),
+					Document: content.Document{Name: "doc"},
+				}
+
+				childResource := search.Resource{
+					ID:       "1$2!4",
+					ParentID: parentResource.ID,
+					RootID:   rootResource.ID,
+					Path:     "./doc/doc.pdf",
+					Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+					Document: content.Document{Name: "doc.pdf"},
+				}
+
+				childResource2 := search.Resource{
+					ID:       "1$2!7",
+					ParentID: parentResource.ID,
+					RootID:   rootResource.ID,
+					Path:     "./doc/file.pdf",
+					Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+					Document: content.Document{Name: "file.pdf"},
+				}
+
+				rootChildResource := search.Resource{
+					ID:       "1$2!5",
+					ParentID: rootResource.ID,
+					RootID:   rootResource.ID,
+					Path:     "./doc.pdf",
+					Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+					Document: content.Document{Name: "doc.pdf"},
+				}
+
+				rootChildResource2 := search.Resource{
+					ID:       "1$2!6",
+					ParentID: rootResource.ID,
+					RootID:   rootResource.ID,
+					Path:     "./file.pdf",
+					Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+					Document: content.Document{Name: "file.pdf"},
+				}
+				err := eng.Upsert(parentResource.ID, parentResource)
+				Expect(err).ToNot(HaveOccurred())
+
+				err = eng.Upsert(rootChildResource.ID, rootChildResource)
+				Expect(err).ToNot(HaveOccurred())
+				err = eng.Upsert(rootChildResource2.ID, rootChildResource2)
+				Expect(err).ToNot(HaveOccurred())
+
+				err = eng.Upsert(childResource.ID, childResource)
+				Expect(err).ToNot(HaveOccurred())
+				err = eng.Upsert(childResource2.ID, childResource2)
+				Expect(err).ToNot(HaveOccurred())
+			})
+			It("search *doc* in a root", func() {
+				res, err := doSearch(rootResource.ID, "Name:*doc*", "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(res.TotalMatches).To(Equal(int32(3)))
+			})
+			It("search *doc* in a subfolder", func() {
+				res, err := doSearch(rootResource.ID, "Name:*doc*", "./doc")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(res.TotalMatches).To(Equal(int32(2)))
+			})
+			It("search *file* in a root", func() {
+				res, err := doSearch(rootResource.ID, "Name:*file*", "")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(res.TotalMatches).To(Equal(int32(2)))
+			})
+			It("search *file* in a subfolder", func() {
+				res, err := doSearch(rootResource.ID, "Name:*file*", "./doc")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(res.TotalMatches).To(Equal(int32(1)))
+			})
+		})
+
+	})
+
+	Describe("Upsert", func() {
+		It("adds a resourceInfo to the index", func() {
+			err := eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			count, err := idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(uint64(1)))
+
+			query := bleveSearch.NewMatchQuery("child.pdf")
+			res, err := idx.Search(bleveSearch.NewSearchRequest(query))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Hits.Len()).To(Equal(1))
+		})
+
+		It("updates an existing resource in the index", func() {
+
+			err := eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			countA, err := idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(countA).To(Equal(uint64(1)))
+
+			err = eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			countB, err := idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(countB).To(Equal(uint64(1)))
+		})
+	})
+
+	Describe("Delete", func() {
+		It("marks a resource as deleted", func() {
+			err := eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, "Name:*child*", 1)
+
+			err = eng.Delete(childResource.ID)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, "Name:*child*", 0)
+		})
+
+		It("marks a child resources as deleted", func() {
+			err := eng.Upsert(parentResource.ID, parentResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Document.Name+`"`, 1)
+			assertDocCount(rootResource.ID, `"`+childResource.Document.Name+`"`, 1)
+
+			err = eng.Delete(parentResource.ID)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Document.Name+`"`, 0)
+			assertDocCount(rootResource.ID, `"`+childResource.Document.Name+`"`, 0)
+		})
+	})
+
+	Describe("Restore", func() {
+		It("also marks child resources as restored", func() {
+			err := eng.Upsert(parentResource.ID, parentResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = eng.Delete(parentResource.ID)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Name+`"`, 0)
+			assertDocCount(rootResource.ID, `"`+childResource.Name+`"`, 0)
+
+			err = eng.Restore(parentResource.ID)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Name+`"`, 1)
+			assertDocCount(rootResource.ID, `"`+childResource.Name+`"`, 1)
+		})
+	})
+
+	Describe("Purge", func() {
+		It("removes a resource from the index", func() {
+			err := eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+			assertDocCount(rootResource.ID, "Name:child.pdf", 1)
+
+			err = eng.Purge(childResource.ID, false)
+
+			Expect(err).ToNot(HaveOccurred())
+			assertDocCount(rootResource.ID, "Name:child.pdf", 0)
+		})
+		It("removes a resource and its children from the index", func() {
+			err := eng.Upsert(parentResource.ID, parentResource)
+			Expect(err).ToNot(HaveOccurred())
+			err = eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Document.Name+`"`, 1)
+			assertDocCount(rootResource.ID, `"`+childResource.Document.Name+`"`, 1)
+
+			err = eng.Purge(parentResource.ID, false)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Document.Name+`"`, 0)
+			assertDocCount(rootResource.ID, `"`+childResource.Document.Name+`"`, 0)
+		})
+		It("removes a resource and ignores its children from the index", func() {
+			err := eng.Upsert(parentResource.ID, parentResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Document.Name+`"`, 1)
+
+			err = eng.Delete(parentResource.ID)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+childResource.Document.Name+`"`, 1)
+
+			err = eng.Purge(parentResource.ID, true)
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, `"`+parentResource.Document.Name+`"`, 0)
+			assertDocCount(rootResource.ID, `"`+childResource.Document.Name+`"`, 1)
+		})
+	})
+
+	Describe("Move", func() {
+		It("renames the parent and its child resources", func() {
+			err := eng.Upsert(parentResource.ID, parentResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			parentResource.Path = "newname"
+			err = eng.Move(parentResource.ID, parentResource.ParentID, "./my/newname")
+			Expect(err).ToNot(HaveOccurred())
+
+			assertDocCount(rootResource.ID, parentResource.Name, 0)
+
+			matches := assertDocCount(rootResource.ID, "Name:child.pdf", 1)
+			Expect(matches[0].Entity.ParentId.OpaqueId).To(Equal("3"))
+			Expect(matches[0].Entity.Ref.Path).To(Equal("./my/newname/child.pdf"))
+		})
+
+		It("moves the parent and its child resources", func() {
+			err := eng.Upsert(parentResource.ID, parentResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = eng.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			parentResource.Path = " "
+			parentResource.ParentID = "1$2!somewhereopaqueid"
+
+			err = eng.Move(parentResource.ID, parentResource.ParentID, "./somewhere/else/newname")
+			Expect(err).ToNot(HaveOccurred())
+			assertDocCount(rootResource.ID, `parent d!r`, 0)
+
+			matches := assertDocCount(rootResource.ID, "Name:child.pdf", 1)
+			Expect(matches[0].Entity.ParentId.OpaqueId).To(Equal("3"))
+			Expect(matches[0].Entity.Ref.Path).To(Equal("./somewhere/else/newname/child.pdf"))
+
+			matches = assertDocCount(rootResource.ID, `newname`, 1)
+			Expect(matches[0].Entity.ParentId.OpaqueId).To(Equal("somewhereopaqueid"))
+			Expect(matches[0].Entity.Ref.Path).To(Equal("./somewhere/else/newname"))
+
+		})
+	})
+
+	Describe("StartBatch", func() {
+		It("starts a new batch", func() {
+			b, err := eng.NewBatch(100)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = b.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			count, err := idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(uint64(0)))
+
+			err = b.Push()
+			Expect(err).ToNot(HaveOccurred())
+
+			count, err = idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(uint64(1)))
+
+			query := bleveSearch.NewMatchQuery("child.pdf")
+			res, err := idx.Search(bleveSearch.NewSearchRequest(query))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Hits.Len()).To(Equal(1))
+		})
+
+		It("doesn't intertwine different batches", func() {
+			b, err := eng.NewBatch(100)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = b.Upsert(childResource.ID, childResource)
+			Expect(err).ToNot(HaveOccurred())
+
+			count, err := idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(uint64(0)))
+
+			b2, err := eng.NewBatch(100)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = b2.Upsert(childResource2.ID, childResource2)
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(b.Push()).To(Succeed())
+			count, err = idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(uint64(1)))
+
+			Expect(b2.Push()).To(Succeed())
+			count, err = idx.DocCount()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(uint64(2)))
+		})
+	})
+
+	Describe("File type specific metadata", func() {
+
+		Context("with audio metadata", func() {
+			BeforeEach(func() {
+				resource := search.Resource{
+					ID:       "1$2!7",
+					ParentID: rootResource.ID,
+					RootID:   rootResource.ID,
+					Path:     "./some_song.mp3",
+					Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+					Document: content.Document{
+						Name:     "some_song.mp3",
+						MimeType: "audio/mpeg",
+						Audio: &libregraph.Audio{
+							Album:             libregraph.PtrString("Some Album"),
+							AlbumArtist:       libregraph.PtrString("Some AlbumArtist"),
+							Artist:            libregraph.PtrString("Some Artist"),
+							Bitrate:           libregraph.PtrInt64(192),
+							Composers:         libregraph.PtrString("Some Composers"),
+							Copyright:         libregraph.PtrString(""),
+							Disc:              libregraph.PtrInt32(2),
+							DiscCount:         libregraph.PtrInt32(5),
+							Duration:          libregraph.PtrInt64(225000),
+							Genre:             libregraph.PtrString("Some Genre"),
+							HasDrm:            libregraph.PtrBool(false),
+							IsVariableBitrate: libregraph.PtrBool(true),
+							Title:             libregraph.PtrString("Some Title"),
+							Track:             libregraph.PtrInt32(34),
+							TrackCount:        libregraph.PtrInt32(99),
+							Year:              libregraph.PtrInt32(2004),
+						},
+					},
+				}
+				err := eng.Upsert(resource.ID, resource)
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("returns audio metadata for search", func() {
+				matches := assertDocCount(rootResource.ID, `*song*`, 1)
+				audio := matches[0].Entity.Audio
+
+				Expect(audio).ToNot(BeNil())
+
+				Expect(audio.Album).To(Equal(libregraph.PtrString("Some Album")))
+				Expect(audio.AlbumArtist).To(Equal(libregraph.PtrString("Some AlbumArtist")))
+				Expect(audio.Artist).To(Equal(libregraph.PtrString("Some Artist")))
+				Expect(audio.Bitrate).To(Equal(libregraph.PtrInt64(192)))
+				Expect(audio.Composers).To(Equal(libregraph.PtrString("Some Composers")))
+				Expect(audio.Copyright).To(Equal(libregraph.PtrString("")))
+				Expect(audio.Disc).To(Equal(libregraph.PtrInt32(2)))
+				Expect(audio.DiscCount).To(Equal(libregraph.PtrInt32(5)))
+				Expect(audio.Duration).To(Equal(libregraph.PtrInt64(225000)))
+				Expect(audio.Genre).To(Equal(libregraph.PtrString("Some Genre")))
+				Expect(audio.HasDrm).To(Equal(libregraph.PtrBool(false)))
+				Expect(audio.IsVariableBitrate).To(Equal(libregraph.PtrBool(true)))
+				Expect(audio.Title).To(Equal(libregraph.PtrString("Some Title")))
+				Expect(audio.Track).To(Equal(libregraph.PtrInt32(34)))
+				Expect(audio.TrackCount).To(Equal(libregraph.PtrInt32(99)))
+				Expect(audio.Year).To(Equal(libregraph.PtrInt32(2004)))
+			})
+		})
+
+		Context("with location metadata", func() {
+			BeforeEach(func() {
+				resource := search.Resource{
+					ID:       "1$2!7",
+					ParentID: rootResource.ID,
+					RootID:   rootResource.ID,
+					Path:     "./team.jpg",
+					Type:     uint64(sprovider.ResourceType_RESOURCE_TYPE_FILE),
+					Document: content.Document{
+						Name:     "team.jpg",
+						MimeType: "image/jpeg",
+						Location: &libregraph.GeoCoordinates{
+							Altitude:  libregraph.PtrFloat64(1047.7),
+							Latitude:  libregraph.PtrFloat64(49.48675890884328),
+							Longitude: libregraph.PtrFloat64(11.103870357204285),
+						},
+					},
+				}
+				err := eng.Upsert(resource.ID, resource)
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("returns audio metadata for search", func() {
+				matches := assertDocCount(rootResource.ID, `*team*`, 1)
+				location := matches[0].Entity.Location
+
+				Expect(location).ToNot(BeNil())
+
+				Expect(location.Altitude).To(Equal(libregraph.PtrFloat64(1047.7)))
+				Expect(location.Latitude).To(Equal(libregraph.PtrFloat64(49.48675890884328)))
+				Expect(location.Longitude).To(Equal(libregraph.PtrFloat64(11.103870357204285)))
+			})
+		})
+	})
+})

Server/services/search/pkg/bleve/batch.go

@@ -0,0 +1,195 @@
+package bleve
+
+import (
+	"errors"
+	"path"
+	"strings"
+
+	"github.com/blevesearch/bleve/v2"
+	storageProvider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+	"github.com/opencloud-eu/reva/v2/pkg/utils"
+
+	"github.com/qsfera/server/pkg/log"
+	"github.com/qsfera/server/services/search/pkg/search"
+)
+
+var _ search.BatchOperator = (*Batch)(nil) // ensure Batch implements BatchOperator
+
+type Batch struct {
+	batch *bleve.Batch
+	index bleve.Index
+	size  int
+	log   log.Logger
+}
+
+func NewBatch(index bleve.Index, size int) (*Batch, error) {
+	if size <= 0 {
+		return nil, errors.New("batch size must be greater than 0")
+	}
+
+	return &Batch{
+		batch: index.NewBatch(),
+		index: index,
+		size:  size,
+	}, nil
+}
+
+func (b *Batch) Upsert(id string, r search.Resource) error {
+	return b.withSizeLimit(func() error {
+		return b.batch.Index(id, r)
+	})
+}
+
+func (b *Batch) Move(id, parentID, location string) error {
+	return b.withSizeLimit(func() error {
+		rootResource, err := searchResourceByID(id, b.index)
+		if err != nil {
+			return err
+		}
+		currentPath := rootResource.Path
+		nextPath := utils.MakeRelativePath(location)
+
+		rootResource.Path = nextPath
+		rootResource.Name = path.Base(nextPath)
+		rootResource.ParentID = parentID
+
+		resources := []*search.Resource{rootResource}
+
+		if rootResource.Type == uint64(storageProvider.ResourceType_RESOURCE_TYPE_CONTAINER) {
+			descendantResources, err := searchResourcesByPath(rootResource.RootID, currentPath, b.index)
+			if err != nil {
+				return err
+			}
+
+			for _, descendantResource := range descendantResources {
+				descendantResource.Path = strings.Replace(descendantResource.Path, currentPath, nextPath, 1)
+				resources = append(resources, descendantResource)
+			}
+		}
+
+		for _, resource := range resources {
+			if err := b.batch.Index(resource.ID, resource); err != nil {
+				return err
+			}
+			if b.batch.Size() >= b.size {
+				if err := b.Push(); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	})
+}
+
+func (b *Batch) Delete(id string) error {
+	return b.withSizeLimit(func() error {
+		affectedResources, err := searchAndUpdateResourcesDeletionState(id, true, b.index)
+		if err != nil {
+			return err
+		}
+
+		for _, resource := range affectedResources {
+			if err := b.batch.Index(resource.ID, resource); err != nil {
+				return err
+			}
+			if b.batch.Size() >= b.size {
+				if err := b.Push(); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	})
+}
+
+func (b *Batch) Restore(id string) error {
+	return b.withSizeLimit(func() error {
+		affectedResources, err := searchAndUpdateResourcesDeletionState(id, false, b.index)
+		if err != nil {
+			return err
+		}
+
+		for _, resource := range affectedResources {
+			if err := b.batch.Index(resource.ID, resource); err != nil {
+				return err
+			}
+			if b.batch.Size() >= b.size {
+				if err := b.Push(); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	})
+}
+
+func (b *Batch) Purge(id string, onlyDeleted bool) error {
+	return b.withSizeLimit(func() error {
+		rootResource, err := searchResourceByID(id, b.index)
+		if err != nil {
+			return err
+		}
+
+		var affectResources []*search.Resource
+		add := func(resource *search.Resource) {
+			if onlyDeleted && !resource.Deleted {
+				return
+			}
+
+			affectResources = append(affectResources, resource)
+		}
+
+		add(rootResource)
+
+		if rootResource.Type == uint64(storageProvider.ResourceType_RESOURCE_TYPE_CONTAINER) {
+			descendantResources, err := searchResourcesByPath(rootResource.RootID, rootResource.Path, b.index)
+			if err != nil {
+				return err
+			}
+
+			for _, descendantResource := range descendantResources {
+				add(descendantResource)
+			}
+		}
+
+		for _, resource := range affectResources {
+			b.batch.Delete(resource.ID)
+			if b.batch.Size() >= b.size {
+				if err := b.Push(); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	})
+}
+
+func (b *Batch) Push() error {
+	if b.batch.Size() == 0 {
+		return nil
+	}
+
+	if err := b.index.Batch(b.batch); err != nil {
+		return err
+	}
+
+	b.batch.Reset()
+
+	return nil
+}
+
+func (b *Batch) withSizeLimit(f func() error) error {
+	if err := f(); err != nil {
+		return err
+	}
+
+	if b.batch.Size() >= b.size {
+		return b.Push()
+	}
+
+	return nil
+}

Server/services/search/pkg/bleve/bleve.go

@@ -0,0 +1,207 @@
+package bleve
+
+import (
+	"reflect"
+	"regexp"
+	"strings"
+	"time"
+
+	bleveSearch "github.com/blevesearch/bleve/v2/search"
+	storageProvider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+	libregraph "github.com/opencloud-eu/libre-graph-api-go"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	searchMessage "github.com/qsfera/server/protogen/gen/qsfera/messages/search/v0"
+	"github.com/qsfera/server/services/search/pkg/content"
+	"github.com/qsfera/server/services/search/pkg/search"
+)
+
+var queryEscape = regexp.MustCompile(`([` + regexp.QuoteMeta(`+=&|><!(){}[]^\"~*?:\/`) + `\-\s])`)
+
+func getFieldValue[T any](m map[string]any, key string) (out T) {
+	val, ok := m[key]
+	if !ok {
+		return
+	}
+
+	out, _ = val.(T)
+
+	return
+}
+
+func resourceIDtoSearchID(id storageProvider.ResourceId) *searchMessage.ResourceID {
+	return &searchMessage.ResourceID{
+		StorageId: id.GetStorageId(),
+		SpaceId:   id.GetSpaceId(),
+		OpaqueId:  id.GetOpaqueId()}
+}
+
+func getFieldSliceValue[T any](m map[string]any, key string) (out []T) {
+	iv := getFieldValue[any](m, key)
+	add := func(v any) {
+		cv, ok := v.(T)
+		if !ok {
+			return
+		}
+
+		out = append(out, cv)
+	}
+
+	// bleve tend to convert []string{"foo"} to type string if slice contains only one value
+	// bleve: []string{"foo"} -> "foo"
+	// bleve: []string{"foo", "bar"} -> []string{"foo", "bar"}
+	switch v := iv.(type) {
+	case T:
+		add(v)
+	case []any:
+		for _, rv := range v {
+			add(rv)
+		}
+	}
+
+	return
+}
+
+func getFragmentValue(m bleveSearch.FieldFragmentMap, key string, idx int) string {
+	val, ok := m[key]
+	if !ok {
+		return ""
+	}
+
+	if len(val) <= idx {
+		return ""
+	}
+
+	return val[idx]
+}
+
+func getAudioValue[T any](fields map[string]any) *T {
+	if !strings.HasPrefix(getFieldValue[string](fields, "MimeType"), "audio/") {
+		return nil
+	}
+
+	var audio = newPointerOfType[T]()
+	if ok := unmarshalInterfaceMap(audio, fields, "audio."); ok {
+		return audio
+	}
+
+	return nil
+}
+
+func getImageValue[T any](fields map[string]any) *T {
+	var image = newPointerOfType[T]()
+	if ok := unmarshalInterfaceMap(image, fields, "image."); ok {
+		return image
+	}
+
+	return nil
+}
+
+func getLocationValue[T any](fields map[string]any) *T {
+	var location = newPointerOfType[T]()
+	if ok := unmarshalInterfaceMap(location, fields, "location."); ok {
+		return location
+	}
+
+	return nil
+}
+
+func getPhotoValue[T any](fields map[string]any) *T {
+	var photo = newPointerOfType[T]()
+	if ok := unmarshalInterfaceMap(photo, fields, "photo."); ok {
+		return photo
+	}
+
+	return nil
+}
+
+func newPointerOfType[T any]() *T {
+	t := reflect.TypeOf((*T)(nil)).Elem()
+	ptr := reflect.New(t).Interface()
+	return ptr.(*T)
+}
+
+func unmarshalInterfaceMap(out any, flatMap map[string]any, prefix string) bool {
+	nonEmpty := false
+	obj := reflect.ValueOf(out).Elem()
+	for i := 0; i < obj.NumField(); i++ {
+		field := obj.Field(i)
+		structField := obj.Type().Field(i)
+		mapKey := prefix + getFieldName(structField)
+
+		if value, ok := flatMap[mapKey]; ok {
+			if field.Kind() == reflect.Ptr {
+				alloc := reflect.New(field.Type().Elem())
+				elemType := field.Type().Elem()
+
+				// convert time strings from index for search requests
+				if elemType == reflect.TypeOf(timestamppb.Timestamp{}) {
+					if strValue, ok := value.(string); ok {
+						if parsedTime, err := time.Parse(time.RFC3339, strValue); err == nil {
+							alloc.Elem().Set(reflect.ValueOf(*timestamppb.New(parsedTime)))
+							field.Set(alloc)
+							nonEmpty = true
+						}
+					}
+					continue
+				}
+
+				// convert time strings from index for libregraph structs when updating resources
+				if elemType == reflect.TypeOf(time.Time{}) {
+					if strValue, ok := value.(string); ok {
+						if parsedTime, err := time.Parse(time.RFC3339, strValue); err == nil {
+							alloc.Elem().Set(reflect.ValueOf(parsedTime))
+							field.Set(alloc)
+							nonEmpty = true
+						}
+					}
+					continue
+				}
+
+				alloc.Elem().Set(reflect.ValueOf(value).Convert(elemType))
+				field.Set(alloc)
+				nonEmpty = true
+			}
+		}
+	}
+
+	return nonEmpty
+}
+
+func getFieldName(structField reflect.StructField) string {
+	tag := structField.Tag.Get("json")
+	if tag == "" {
+		return structField.Name
+	}
+
+	return strings.Split(tag, ",")[0]
+}
+
+func matchToResource(match *bleveSearch.DocumentMatch) *search.Resource {
+	return &search.Resource{
+		ID:       getFieldValue[string](match.Fields, "ID"),
+		RootID:   getFieldValue[string](match.Fields, "RootID"),
+		Path:     getFieldValue[string](match.Fields, "Path"),
+		ParentID: getFieldValue[string](match.Fields, "ParentID"),
+		Type:     uint64(getFieldValue[float64](match.Fields, "Type")),
+		Deleted:  getFieldValue[bool](match.Fields, "Deleted"),
+		Document: content.Document{
+			Name:      getFieldValue[string](match.Fields, "Name"),
+			Title:     getFieldValue[string](match.Fields, "Title"),
+			Size:      uint64(getFieldValue[float64](match.Fields, "Size")),
+			Mtime:     getFieldValue[string](match.Fields, "Mtime"),
+			MimeType:  getFieldValue[string](match.Fields, "MimeType"),
+			Content:   getFieldValue[string](match.Fields, "Content"),
+			Tags:      getFieldSliceValue[string](match.Fields, "Tags"),
+			Favorites: getFieldSliceValue[string](match.Fields, "Favorites"),
+			Audio:     getAudioValue[libregraph.Audio](match.Fields),
+			Image:     getImageValue[libregraph.Image](match.Fields),
+			Location:  getLocationValue[libregraph.GeoCoordinates](match.Fields),
+			Photo:     getPhotoValue[libregraph.Photo](match.Fields),
+		},
+	}
+}
+
+func escapeQuery(s string) string {
+	return queryEscape.ReplaceAllString(s, "\\$1")
+}

Server/services/search/pkg/bleve/engine_suite_test.go

@@ -0,0 +1,13 @@
+package bleve_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestEngine(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Bleve Suite")
+}

Server/services/search/pkg/bleve/index.go

@@ -0,0 +1,148 @@
+package bleve
+
+import (
+	"errors"
+	"math"
+	"path/filepath"
+
+	"github.com/blevesearch/bleve/v2"
+	"github.com/blevesearch/bleve/v2/analysis/analyzer/custom"
+	"github.com/blevesearch/bleve/v2/analysis/analyzer/keyword"
+	"github.com/blevesearch/bleve/v2/analysis/token/lowercase"
+	"github.com/blevesearch/bleve/v2/analysis/token/porter"
+	"github.com/blevesearch/bleve/v2/analysis/tokenizer/single"
+	"github.com/blevesearch/bleve/v2/analysis/tokenizer/unicode"
+	"github.com/blevesearch/bleve/v2/mapping"
+	storageProvider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+
+	"github.com/qsfera/server/services/search/pkg/search"
+)
+
+func NewIndex(root string) (bleve.Index, error) {
+	destination := filepath.Join(root, "bleve")
+	index, err := bleve.Open(destination)
+	if errors.Is(bleve.ErrorIndexPathDoesNotExist, err) {
+		indexMapping, err := NewMapping()
+		if err != nil {
+			return nil, err
+		}
+		index, err = bleve.New(destination, indexMapping)
+		if err != nil {
+			return nil, err
+		}
+
+		return index, nil
+	}
+
+	return index, err
+}
+
+func NewMapping() (mapping.IndexMapping, error) {
+	nameMapping := bleve.NewTextFieldMapping()
+	nameMapping.Analyzer = "lowercaseKeyword"
+
+	lowercaseMapping := bleve.NewTextFieldMapping()
+	lowercaseMapping.IncludeInAll = false
+	lowercaseMapping.Analyzer = "lowercaseKeyword"
+
+	fulltextFieldMapping := bleve.NewTextFieldMapping()
+	fulltextFieldMapping.Analyzer = "fulltext"
+	fulltextFieldMapping.IncludeInAll = false
+
+	docMapping := bleve.NewDocumentMapping()
+	docMapping.AddFieldMappingsAt("Name", nameMapping)
+	docMapping.AddFieldMappingsAt("Tags", lowercaseMapping)
+	docMapping.AddFieldMappingsAt("Favorites", lowercaseMapping)
+	docMapping.AddFieldMappingsAt("Content", fulltextFieldMapping)
+
+	indexMapping := bleve.NewIndexMapping()
+	indexMapping.DefaultAnalyzer = keyword.Name
+	indexMapping.DefaultMapping = docMapping
+	err := indexMapping.AddCustomAnalyzer("lowercaseKeyword",
+		map[string]any{
+			"type":      custom.Name,
+			"tokenizer": single.Name,
+			"token_filters": []string{
+				lowercase.Name,
+			},
+		},
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	err = indexMapping.AddCustomAnalyzer("fulltext",
+		map[string]any{
+			"type":      custom.Name,
+			"tokenizer": unicode.Name,
+			"token_filters": []string{
+				lowercase.Name,
+				porter.Name,
+			},
+		},
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return indexMapping, nil
+}
+
+func searchResourceByID(id string, index bleve.Index) (*search.Resource, error) {
+	req := bleve.NewSearchRequest(bleve.NewDocIDQuery([]string{id}))
+	req.Fields = []string{"*"}
+	res, err := index.Search(req)
+	if err != nil {
+		return nil, err
+	}
+	if res.Hits.Len() == 0 {
+		return nil, errors.New("entity not found")
+	}
+
+	return matchToResource(res.Hits[0]), nil
+}
+
+func searchResourcesByPath(rootId, lookupPath string, index bleve.Index) ([]*search.Resource, error) {
+	q := bleve.NewConjunctionQuery(
+		bleve.NewQueryStringQuery("RootID:"+rootId),
+		bleve.NewQueryStringQuery("Path:"+escapeQuery(lookupPath+"/*")),
+	)
+	bleveReq := bleve.NewSearchRequest(q)
+	bleveReq.Size = math.MaxInt
+	bleveReq.Fields = []string{"*"}
+	res, err := index.Search(bleveReq)
+	if err != nil {
+		return nil, err
+	}
+
+	resources := make([]*search.Resource, 0, res.Hits.Len())
+	for _, match := range res.Hits {
+		resources = append(resources, matchToResource(match))
+	}
+
+	return resources, nil
+}
+
+func searchAndUpdateResourcesDeletionState(id string, state bool, index bleve.Index) ([]*search.Resource, error) {
+	rootResource, err := searchResourceByID(id, index)
+	if err != nil {
+		return nil, err
+	}
+	rootResource.Deleted = state
+
+	resources := []*search.Resource{rootResource}
+
+	if rootResource.Type == uint64(storageProvider.ResourceType_RESOURCE_TYPE_CONTAINER) {
+		descendantResources, err := searchResourcesByPath(rootResource.RootID, rootResource.Path, index)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, descendantResource := range descendantResources {
+			descendantResource.Deleted = state
+			resources = append(resources, descendantResource)
+		}
+	}
+
+	return resources, nil
+}