fix(server): enable original key filter (#57)

* enable original key filter

* add PaginateProject method

* fix lint

---------

Co-authored-by: tomokazu tantaka <[email protected]>

Author: hexaforce

mongox/pagination.go

@@ -27,64 +27,7 @@ func (c *Collection) Paginate(ctx context.Context, rawFilter any, s *usecasex.So
 		filter = And(rawFilter, "", pFilter)
 	}
 
-	sortKey := idKey
-	sortOrder := 1
-	if s != nil && s.Key != "" {
-		sortKey = s.Key
-		if s.Reverted {
-			sortOrder = -1
-		}
-	}
-
-	if p.Cursor != nil && p.Cursor.Last != nil {
-		sortOrder *= -1
-	}
-
-	sort := bson.D{{Key: sortKey, Value: sortOrder}}
-	if sortKey != idKey {
-		sort = append(sort, bson.E{Key: idKey, Value: sortOrder})
-	}
-
-	findOpts := options.Find().
-		SetSort(sort).
-		SetLimit(limit(*p))
-
-	if p.Offset != nil {
-		findOpts.SetSkip(p.Offset.Offset)
-	}
-
-	cursor, err := c.collection.Find(ctx, filter, append([]*options.FindOptions{findOpts}, opts...)...)
-	if err != nil {
-		return nil, rerror.ErrInternalByWithContext(ctx, fmt.Errorf("failed to find: %w", err))
-	}
-	defer func() {
-		_ = cursor.Close(ctx)
-	}()
-
-	count, err := c.collection.CountDocuments(ctx, rawFilter)
-	if err != nil {
-		return nil, rerror.ErrInternalByWithContext(ctx, fmt.Errorf("failed to count: %w", err))
-	}
-
-	items, startCursor, endCursor, hasMore, err := consume(ctx, cursor, limit(*p))
-	if err != nil {
-		return nil, err
-	}
-
-	if p.Cursor != nil && p.Cursor.Last != nil {
-		reverse(items)
-		startCursor, endCursor = endCursor, startCursor
-	}
-
-	for _, item := range items {
-		if err := consumer.Consume(item); err != nil {
-			return nil, err
-		}
-	}
-
-	hasNextPage, hasPreviousPage := pageInfo(p, hasMore)
-
-	return usecasex.NewPageInfo(count, startCursor, endCursor, hasNextPage, hasPreviousPage), nil
+	return c.paginate(ctx, rawFilter, s, p, filter, consumer, opts)
 }
 
 func (c *Collection) PaginateAggregation(ctx context.Context, pipeline []any, s *usecasex.Sort, p *usecasex.Pagination, consumer Consumer, opts ...*options.AggregateOptions) (*usecasex.PageInfo, error) {
@@ -327,3 +270,84 @@ func sortDirection(p usecasex.Pagination, s *usecasex.Sort) int {
 	}
 	return 1
 }
+
+func (c *Collection) PaginateProject(ctx context.Context, rawFilter any, s *usecasex.Sort, p *usecasex.Pagination, consumer Consumer, opts ...*options.FindOptions) (*usecasex.PageInfo, error) {
+	if p == nil || (p.Cursor == nil && p.Offset == nil) {
+		return nil, nil
+	}
+
+	pFilter, err := c.pageFilter(ctx, *p, s)
+	if err != nil {
+		return nil, rerror.ErrInternalByWithContext(ctx, err)
+	}
+
+	filter := rawFilter
+	if pFilter != nil {
+		filter = AddCondition(rawFilter, "", pFilter)
+	}
+
+	return c.paginate(ctx, rawFilter, s, p, filter, consumer, opts)
+
+}
+
+func (c *Collection) paginate(ctx context.Context, rawFilter any, s *usecasex.Sort, p *usecasex.Pagination, filter any, consumer Consumer, opts []*options.FindOptions) (*usecasex.PageInfo, error) {
+
+	sortKey := idKey
+	sortOrder := 1
+	if s != nil && s.Key != "" {
+		sortKey = s.Key
+		if s.Reverted {
+			sortOrder = -1
+		}
+	}
+
+	if p.Cursor != nil && p.Cursor.Last != nil {
+		sortOrder *= -1
+	}
+
+	sort := bson.D{{Key: sortKey, Value: sortOrder}}
+	if sortKey != idKey {
+		sort = append(sort, bson.E{Key: idKey, Value: sortOrder})
+	}
+
+	findOpts := options.Find().
+		SetSort(sort).
+		SetLimit(limit(*p))
+
+	if p.Offset != nil {
+		findOpts.SetSkip(p.Offset.Offset)
+	}
+
+	cursor, err := c.collection.Find(ctx, filter, append([]*options.FindOptions{findOpts}, opts...)...)
+	if err != nil {
+		return nil, rerror.ErrInternalByWithContext(ctx, fmt.Errorf("failed to find: %w", err))
+	}
+	defer func() {
+		_ = cursor.Close(ctx)
+	}()
+
+	count, err := c.collection.CountDocuments(ctx, rawFilter)
+	if err != nil {
+		return nil, rerror.ErrInternalByWithContext(ctx, fmt.Errorf("failed to count: %w", err))
+	}
+
+	items, startCursor, endCursor, hasMore, err := consume(ctx, cursor, limit(*p))
+	if err != nil {
+		return nil, err
+	}
+
+	if p.Cursor != nil && p.Cursor.Last != nil {
+		reverse(items)
+		startCursor, endCursor = endCursor, startCursor
+	}
+
+	for _, item := range items {
+		if err := consumer.Consume(item); err != nil {
+			return nil, err
+		}
+	}
+
+	hasNextPage, hasPreviousPage := pageInfo(p, hasMore)
+
+	return usecasex.NewPageInfo(count, startCursor, endCursor, hasNextPage, hasPreviousPage), nil
+}

mongox/util.go

@@ -157,3 +157,58 @@ func And(filter interface{}, key string, f interface{}) interface{} {
 	}
 	return AppendE(filter, bson.E{Key: key, Value: f})
 }
+
+func isEmptyCondition(condition interface{}) bool {
+	switch c := condition.(type) {
+	case bson.M:
+		return len(c) == 0
+	case bson.D:
+		return len(c) == 0
+	case bson.A:
+		return len(c) == 0
+	case []bson.M:
+		return len(c) == 0
+	case []bson.D:
+		return len(c) == 0
+	case []bson.A:
+		return len(c) == 0
+	case []interface{}:
+		return len(c) == 0
+	default:
+		return false
+	}
+}
+
+func AddCondition(filter interface{}, key string, condition interface{}) interface{} {
+	if condition == nil || isEmptyCondition(condition) {
+		return filter
+	}
+
+	filterMap, ok := filter.(bson.M)
+	if !ok || len(filterMap) == 0 {
+		filterMap = bson.M{}
+	}
+
+	var newCondition interface{}
+	if key != "" {
+		if _, exists := filterMap[key]; exists {
+			return filter
+		}
+		newCondition = bson.M{key: condition}
+	} else {
+		newCondition = condition
+	}
+
+	if existingAnd, ok := filterMap["$and"].(bson.A); ok {
+		filterMap["$and"] = append(existingAnd, newCondition)
+	} else {
+		existingConditions := make(bson.A, 0)
+		for k, v := range filterMap {
+			if k != "$and" {
+				existingConditions = append(existingConditions, bson.M{k: v})
+			}
+		}
+		filterMap["$and"] = append(existingConditions, newCondition)
+	}
+	return filterMap
+}