From 571811462658b04e8a6ed49dac73b4e0d117b506 Mon Sep 17 00:00:00 2001
From: Seongmin Lee <git@boltless.me>
Date: Mon, 19 Jan 2026 16:05:48 +0000
Subject: [PATCH] appview: handle non-unique publicKey records

- upsert public key to handle record update event
- don't delete by pair of name and key. delete by name or rkey instead.

Signed-off-by: Seongmin Lee <git@boltless.me>
---
 appview/db/pubkeys.go | 24 +++++++++++++++++-------
 appview/ingester.go | 16 +++++++++++++---
 appview/models/pubkey.go | 38 ++++++++++++++++++++++++++++++++++++++
 appview/pages/templates/user/settings/fragments/keyListing.html | 2 +-
 appview/settings/settings.go | 75 +++++++++++++++++++++++++++++++++++++++------------------------------------
 5 file(s) changed, 108 insertion(s)(+), 47 deletion(s)(-)

diff --git a/appview/db/pubkeys.go b/appview/db/pubkeys.go
--- a/appview/db/pubkeys.go
+++ b/appview/db/pubkeys.go
@@ -5,19 +5,29 @@ "tangled.org/core/appview/models"
 	"time"
 )
 
-func AddPublicKey(e Execer, did, name, key, rkey string) error {
+func UpsertPublicKey(e Execer, pubKey models.PublicKey) error {
 	_, err := e.Exec(
-		`insert or ignore into public_keys (did, name, key, rkey)
-		 values (?, ?, ?, ?)`,
-		did, name, key, rkey)
+		`insert into public_keys (did, rkey, name, key, created)
+		values (?, ?, ?, ?, ?)
+		on conflict(did, rkey) do update set
+			name    = excluded.name,
+			key     = excluded.key,
+			created = excluded.created`,
+		pubKey.Did,
+		pubKey.Rkey,
+		pubKey.Name,
+		pubKey.Key,
+		pubKey.Created.Format(time.RFC3339),
+	)
 	return err
 }
 
-func DeletePublicKey(e Execer, did, name, key string) error {
+// for public_keys with empty rkey
+func DeletePublicKeyLegacy(e Execer, did, name string) error {
 	_, err := e.Exec(`
 		delete from public_keys
-		where did = ? and name = ? and key = ?`,
-		did, name, key)
+		where did = ? and name = ? and rkey = ''`,
+		did, name)
 	return err
 }
 
diff --git a/appview/ingester.go b/appview/ingester.go
--- a/appview/ingester.go
+++ b/appview/ingester.go
@@ -131,6 +131,7 @@
 	if err != nil {
 		return fmt.Errorf("failed to %s star record: %w", e.Commit.Operation, err)
 	}
+	l.Info("processed star", "operation", e.Commit.Operation, "rkey", e.Commit.RKey)
 
 	return nil
 }
@@ -164,6 +165,7 @@
 	if err != nil {
 		return fmt.Errorf("failed to %s follow record: %w", e.Commit.Operation, err)
 	}
+	l.Info("processed follow", "operation", e.Commit.Operation, "rkey", e.Commit.RKey)
 
 	return nil
 }
@@ -185,10 +187,17 @@ if err != nil {
 			l.Error("invalid record", "err", err)
 			return err
 		}
+		pubKey, err := models.PublicKeyFromRecord(syntax.DID(did), syntax.RecordKey(e.Commit.RKey), record)
+		if err != nil {
+			l.Error("invalid record", "err", err)
+			return err
+		}
+		if err := pubKey.Validate(); err != nil {
+			l.Error("invalid record", "err", err)
+			return err
+		}
 
-		name := record.Name
-		key := record.Key
-		err = db.AddPublicKey(i.Db, did, name, key, e.Commit.RKey)
+		err = db.UpsertPublicKey(i.Db, pubKey)
 	case jmodels.CommitOperationDelete:
 		l.Debug("processing delete of pubkey")
 		err = db.DeletePublicKeyByRkey(i.Db, did, e.Commit.RKey)
@@ -197,6 +206,7 @@
 	if err != nil {
 		return fmt.Errorf("failed to %s pubkey record: %w", e.Commit.Operation, err)
 	}
+	l.Info("processed pubkey", "operation", e.Commit.Operation, "rkey", e.Commit.RKey)
 
 	return nil
 }
diff --git a/appview/models/pubkey.go b/appview/models/pubkey.go
--- a/appview/models/pubkey.go
+++ b/appview/models/pubkey.go
@@ -2,7 +2,12 @@ package models
 
 import (
 	"encoding/json"
+	"fmt"
 	"time"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/gliderlabs/ssh"
+	"tangled.org/core/api/tangled"
 )
 
 type PublicKey struct {
@@ -23,3 +28,36 @@ Created: p.Created.Format(time.RFC3339),
 		Alias:   (*Alias)(&p),
 	})
 }
+
+func (p *PublicKey) AsRecord() tangled.PublicKey {
+	return tangled.PublicKey{
+		Name:      p.Name,
+		Key:       p.Key,
+		CreatedAt: p.Created.Format(time.RFC3339),
+	}
+}
+
+var _ Validator = new(PublicKey)
+
+func (p *PublicKey) Validate() error {
+	if _, _, _, _, err := ssh.ParseAuthorizedKey([]byte(p.Key)); err != nil {
+		return fmt.Errorf("invalid ssh key format: %w", err)
+	}
+
+	return nil
+}
+
+func PublicKeyFromRecord(did syntax.DID, rkey syntax.RecordKey, record tangled.PublicKey) (PublicKey, error) {
+	created, err := time.Parse(time.RFC3339, record.CreatedAt)
+	if err != nil {
+		return PublicKey{}, fmt.Errorf("invalid time format '%s'", record.CreatedAt)
+	}
+
+	return PublicKey{
+		Did:     did.String(),
+		Rkey:    rkey.String(),
+		Name:    record.Name,
+		Key:     record.Key,
+		Created: &created,
+	}, nil
+}
diff --git a/appview/pages/templates/user/settings/fragments/keyListing.html b/appview/pages/templates/user/settings/fragments/keyListing.html
--- a/appview/pages/templates/user/settings/fragments/keyListing.html
+++ b/appview/pages/templates/user/settings/fragments/keyListing.html
@@ -19,7 +19,7 @@ </div>
     <button
       class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"
       title="Delete key"
-      hx-delete="/settings/keys?name={{urlquery $key.Name}}&rkey={{urlquery $key.Rkey}}&key={{urlquery $key.Key}}"
+      hx-delete="/settings/keys?name={{urlquery $key.Name}}&rkey={{urlquery $key.Rkey}}"
       hx-swap="none"
       hx-confirm="Are you sure you want to delete the key {{ $key.Name }}?"
     >
diff --git a/appview/settings/settings.go b/appview/settings/settings.go
--- a/appview/settings/settings.go
+++ b/appview/settings/settings.go
@@ -24,7 +24,6 @@
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	lexutil "github.com/bluesky-social/indigo/lex/util"
-	"github.com/gliderlabs/ssh"
 	"github.com/google/uuid"
 )
 
@@ -419,25 +418,21 @@ s.Pages.Notice(w, "settings-keys", "Unimplemented.")
 		log.Println("unimplemented")
 		return
 	case http.MethodPut:
-		did := s.OAuth.GetDid(r)
-		key := r.FormValue("key")
-		key = strings.TrimSpace(key)
-		name := r.FormValue("name")
-		client, err := s.OAuth.AuthorizedClient(r)
-		if err != nil {
-			s.Pages.Notice(w, "settings-keys", "Failed to authorize. Try again later.")
-			return
+		created := time.Now()
+		pubKey := models.PublicKey{
+			Did:     s.OAuth.GetDid(r),
+			Rkey:    tid.TID(),
+			Name:    r.FormValue("name"),
+			Key:     strings.TrimSpace(r.FormValue("key")),
+			Created: &created,
 		}
 
-		_, _, _, _, err = ssh.ParseAuthorizedKey([]byte(key))
-		if err != nil {
+		if err := pubKey.Validate(); err != nil {
 			log.Printf("parsing public key: %s", err)
 			s.Pages.Notice(w, "settings-keys", "That doesn't look like a valid public key. Make sure it's a <strong>public</strong> key.")
 			return
 		}
 
-		rkey := tid.TID()
-
 		tx, err := s.Db.Begin()
 		if err != nil {
 			log.Printf("failed to start tx; adding public key: %s", err)
@@ -446,23 +441,27 @@ return
 		}
 		defer tx.Rollback()
 
-		if err := db.AddPublicKey(tx, did, name, key, rkey); err != nil {
+		if err = db.UpsertPublicKey(s.Db, pubKey); err != nil {
 			log.Printf("adding public key: %s", err)
 			s.Pages.Notice(w, "settings-keys", "Failed to add public key.")
+			return
+		}
+
+		client, err := s.OAuth.AuthorizedClient(r)
+		if err != nil {
+			s.Pages.Notice(w, "settings-keys", "Failed to authorize. Try again later.")
 			return
 		}
 
 		// store in pds too
+		record := pubKey.AsRecord()
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.PublicKeyNSID,
-			Repo:       did,
-			Rkey:       rkey,
+			Repo:       pubKey.Did,
+			Rkey:       pubKey.Rkey,
 			Record: &lexutil.LexiconTypeDecoder{
-				Val: &tangled.PublicKey{
-					CreatedAt: time.Now().Format(time.RFC3339),
-					Key:       key,
-					Name:      name,
-				}},
+				Val: &record,
+			},
 		})
 		// invalid record
 		if err != nil {
@@ -489,28 +488,32 @@ q := r.URL.Query()
 
 		name := q.Get("name")
 		rkey := q.Get("rkey")
-		key := q.Get("key")
 
 		log.Println(name)
 		log.Println(rkey)
-		log.Println(key)
 
-		client, err := s.OAuth.AuthorizedClient(r)
-		if err != nil {
-			log.Printf("failed to authorize client: %s", err)
-			s.Pages.Notice(w, "settings-keys", "Failed to authorize client.")
-			return
-		}
+		if rkey == "" {
+			if err := db.DeletePublicKeyLegacy(s.Db, did, name); err != nil {
+				log.Printf("removing public key: %s", err)
+				s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
+				return
+			}
+		} else {
+			if err := db.DeletePublicKeyByRkey(s.Db, did, rkey); err != nil {
+				log.Printf("removing public key: %s", err)
+				s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
+				return
+			}
 
-		if err := db.DeletePublicKey(s.Db, did, name, key); err != nil {
-			log.Printf("removing public key: %s", err)
-			s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
-			return
-		}
+			client, err := s.OAuth.AuthorizedClient(r)
+			if err != nil {
+				log.Printf("failed to authorize client: %s", err)
+				s.Pages.Notice(w, "settings-keys", "Failed to authorize client.")
+				return
+			}
 
-		if rkey != "" {
 			// remove from pds too
-			_, err := comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
+			_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 				Collection: tangled.PublicKeyNSID,
 				Repo:       did,
 				Rkey:       rkey,

--
tangled.sh