Fixed the device sign

internal/index/index.go

@@ -1,88 +1,63 @@
 package index
 
 import (
-	"sort"
+	"errors"
 	"sync"
-	"time"
 )
 
+// Entry is the minimal metadata we expose to clients.
 type Entry struct {
 	Hash      string `json:"hash"`
 	Bytes     int64  `json:"bytes"`
-	StoredAt  string `json:"stored_at"`
-	Private   bool   `json:"private"`
-	CreatorTZ string `json:"creator_tz,omitempty"`
-}
-
-type rec struct {
-	Hash      string
-	Bytes     int64
-	StoredAt  time.Time
-	Private   bool
-	CreatorTZ string
+	StoredAt  string `json:"stored_at"`            // RFC3339Nano
+	Private   bool   `json:"private"`              // true if client marked encrypted
+	CreatorTZ string `json:"creator_tz,omitempty"` // optional IANA TZ from client
 }
 
+// Index is an in-memory map from hash -> Entry, safe for concurrent use.
 type Index struct {
-	mu   sync.RWMutex
-	hash map[string]rec
+	mu sync.RWMutex
+	m  map[string]Entry
 }
 
-func New() *Index { return &Index{hash: make(map[string]rec)} }
+func New() *Index {
+	return &Index{m: make(map[string]Entry)}
+}
 
 func (ix *Index) Put(e Entry) error {
+	if e.Hash == "" {
+		return errors.New("empty hash")
+	}
 	ix.mu.Lock()
-	defer ix.mu.Unlock()
-	t := parseWhen(e.StoredAt)
-	if t.IsZero() {
-		t = time.Now().UTC()
-	}
-	ix.hash[e.Hash] = rec{
-		Hash:      e.Hash,
-		Bytes:     e.Bytes,
-		StoredAt:  t,
-		Private:   e.Private,
-		CreatorTZ: e.CreatorTZ,
-	}
+	ix.m[e.Hash] = e
+	ix.mu.Unlock()
 	return nil
 }
 
 func (ix *Index) Delete(hash string) error {
+	if hash == "" {
+		return errors.New("empty hash")
+	}
 	ix.mu.Lock()
-	defer ix.mu.Unlock()
-	delete(ix.hash, hash)
+	delete(ix.m, hash)
+	ix.mu.Unlock()
 	return nil
 }
 
-func (ix *Index) List() ([]Entry, error) {
+func (ix *Index) Get(hash string) (Entry, bool) {
 	ix.mu.RLock()
-	defer ix.mu.RUnlock()
-	tmp := make([]rec, 0, len(ix.hash))
-	for _, r := range ix.hash {
-		tmp = append(tmp, r)
-	}
-	sort.Slice(tmp, func(i, j int) bool { return tmp[i].StoredAt.After(tmp[j].StoredAt) })
-	out := make([]Entry, len(tmp))
-	for i, r := range tmp {
-		out[i] = Entry{
-			Hash:      r.Hash,
-			Bytes:     r.Bytes,
-			StoredAt:  r.StoredAt.UTC().Format(time.RFC3339Nano),
-			Private:   r.Private,
-			CreatorTZ: r.CreatorTZ,
-		}
-	}
-	return out, nil
+	e, ok := ix.m[hash]
+	ix.mu.RUnlock()
+	return e, ok
 }
 
-func parseWhen(s string) time.Time {
-	if s == "" {
-		return time.Time{}
+// All returns an unsorted copy of all entries.
+func (ix *Index) All() []Entry {
+	ix.mu.RLock()
+	out := make([]Entry, 0, len(ix.m))
+	for _, v := range ix.m {
+		out = append(out, v)
 	}
-	if t, err := time.Parse(time.RFC3339Nano, s); err == nil {
-		return t
-	}
-	if t, err := time.Parse(time.RFC3339, s); err == nil {
-		return t
-	}
-	return time.Time{}
+	ix.mu.RUnlock()
+	return out
 }