aturilist mattress experiment

cmd/aturilist/client/client.go

···
 
 // Constants for the XRPC methods
 const (
-	MethodListRecords     = "app.reddwarf.aturilist.listRecords"
-	MethodCountRecords    = "app.reddwarf.aturilist.countRecords"
-	MethodIndexRecord     = "app.reddwarf.aturilist.indexRecord"
-	MethodValidateRecord  = "app.reddwarf.aturilist.validateRecord"
-	DefaultProductionHost = "https://aturilist.reddwarf.app"
+	MethodListRecords         = "app.reddwarf.aturilist.listRecords"
+	MethodCountRecords        = "app.reddwarf.aturilist.countRecords"
+	MethodIndexRecord         = "app.reddwarf.aturilist.indexRecord"
+	MethodValidateRecord      = "app.reddwarf.aturilist.validateRecord"
+	MethodQueryCollectionRkey = "app.reddwarf.aturilist.queryCollectionRkey"
+	DefaultProductionHost     = "https://aturilist.reddwarf.app"
 )
 
 // Client is the API client for the Red Dwarf AtURI List Service.
···
 	Repo       string `json:"repo"`
 	Collection string `json:"collection"`
 	Count      int    `json:"count"`
+}
+
+type QueryCollectionRkeyResponse struct {
+	Collection string   `json:"collection"`
+	RKey       string   `json:"rkey"`
+	DIDs       []string `json:"dids"`
+	Count      int      `json:"count"`
 }
 
 type ErrorResponse struct {
···
 	}
 
 	return true, nil
+}
+
+// QueryCollectionRkey returns a list of DIDs that have a specific collection and rkey pair.
+func (c *Client) QueryCollectionRkey(ctx context.Context, collection, rkey string) (*QueryCollectionRkeyResponse, error) {
+	params := url.Values{}
+	params.Set("collection", collection)
+	params.Set("rkey", rkey)
+
+	var resp QueryCollectionRkeyResponse
+	if err := c.doRequest(ctx, http.MethodGet, MethodQueryCollectionRkey, params, nil, &resp); err != nil {
+		return nil, err
+	}
+
+	return &resp, nil
 }
 
 // --- Internal Helpers ---

cmd/aturilist/main.go

···
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
···
 
 	router.POST("/xrpc/app.reddwarf.aturilist.validateRecord", srv.handleValidateRecord)
 
+	router.GET("/xrpc/app.reddwarf.aturilist.queryCollectionRkey", srv.handleQueryCollectionRkey)
+
 	// router.GET("/xrpc/app.reddwarf.aturilist.requestBackfill", )
 
 	router.Run(":7155")
···
 	return parts[0], parts[1], parts[2], nil
 }
 
+func makeCollectionRkeyKey(collection, rkey string) []byte {
+	return []byte(fmt.Sprintf("cr|%s|%s|", collection, rkey))
+}
+
+func parseCollectionRkeyKey(key []byte) (collection, rkey string, err error) {
+	parts := strings.Split(string(key), "|")
+	if len(parts) < 3 || parts[0] != "cr" {
+		return "", "", errors.New("invalid collection+rkey key format")
+	}
+	return parts[1], parts[2], nil
+}
+
 func (s *Server) processRecord(repo, collection, rkey string, isDelete bool) {
 	key := makeKey(repo, collection, rkey)
+	crKey := makeCollectionRkeyKey(collection, rkey)
 
 	err := s.db.Update(func(txn *badger.Txn) error {
 		if isDelete {
-			return txn.Delete(key)
+			if err := txn.Delete(key); err != nil {
+				return err
+			}
+			return s.removeDidFromCollectionRkeyIndex(txn, crKey, repo)
 		}
-		return txn.Set(key, []byte(time.Now().Format(time.RFC3339)))
+		if err := txn.Set(key, []byte(time.Now().Format(time.RFC3339))); err != nil {
+			return err
+		}
+		return s.addDidToCollectionRkeyIndex(txn, crKey, repo)
 	})
 
 	if err != nil {
···
 	}
 }
 
+func (s *Server) addDidToCollectionRkeyIndex(txn *badger.Txn, crKey []byte, did string) error {
+	item, err := txn.Get(crKey)
+	if err == badger.ErrKeyNotFound {
+		var dids []string
+		dids = append(dids, did)
+		didsJSON, _ := json.Marshal(dids)
+		return txn.Set(crKey, didsJSON)
+	} else if err != nil {
+		return err
+	}
+
+	var dids []string
+	err = item.Value(func(val []byte) error {
+		return json.Unmarshal(val, &dids)
+	})
+	if err != nil {
+		return err
+	}
+
+	for _, existingDid := range dids {
+		if existingDid == did {
+			return nil
+		}
+	}
+
+	dids = append(dids, did)
+	didsJSON, _ := json.Marshal(dids)
+	return txn.Set(crKey, didsJSON)
+}
+
+func (s *Server) removeDidFromCollectionRkeyIndex(txn *badger.Txn, crKey []byte, did string) error {
+	item, err := txn.Get(crKey)
+	if err == badger.ErrKeyNotFound {
+		return nil
+	} else if err != nil {
+		return err
+	}
+
+	var dids []string
+	err = item.Value(func(val []byte) error {
+		return json.Unmarshal(val, &dids)
+	})
+	if err != nil {
+		return err
+	}
+
+	var newDids []string
+	for _, existingDid := range dids {
+		if existingDid != did {
+			newDids = append(newDids, existingDid)
+		}
+	}
+
+	if len(newDids) == 0 {
+		return txn.Delete(crKey)
+	}
+
+	didsJSON, _ := json.Marshal(newDids)
+	return txn.Set(crKey, didsJSON)
+}
+
 func (s *Server) handleListRecords(c *gin.Context) {
 	repo := c.Query("repo")
 	collection := c.Query("collection")
···
 		c.Status(404)
 	}
 }
+
+func (s *Server) handleQueryCollectionRkey(c *gin.Context) {
+	collection := c.Query("collection")
+	rkey := c.Query("rkey")
+
+	if collection == "" || rkey == "" {
+		c.JSON(400, gin.H{"error": "collection and rkey required"})
+		return
+	}
+
+	crKey := makeCollectionRkeyKey(collection, rkey)
+	var dids []string
+
+	err := s.db.View(func(txn *badger.Txn) error {
+		item, err := txn.Get(crKey)
+		if err == badger.ErrKeyNotFound {
+			return nil
+		} else if err != nil {
+			return err
+		}
+
+		return item.Value(func(val []byte) error {
+			return json.Unmarshal(val, &dids)
+		})
+	})
+
+	if err != nil {
+		c.JSON(500, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(200, gin.H{
+		"collection": collection,
+		"rkey":       rkey,
+		"dids":       dids,
+		"count":      len(dids),
+	})
+}