add owner based link search

add search endpoint with support for owner filtering, the all page
now uses the search template with the expectation that all becomes
a "search" once search is fully implemented

updates #98

Signed-off-by: Tim Walters <tim@tailscale.com>

Author: timtailscale

db.go

@@ -225,3 +225,27 @@ func (s *SQLiteDB) DeleteStats(short string) error {
 	}
 	return nil
 }
+
+// GetLinksByOwner returns all Links owned by the specified owner.
+func (s *SQLiteDB) GetLinksByOwner(owner string) ([]*Link, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	var links []*Link
+	rows, err := s.db.Query("SELECT Short, Long, Created, LastEdit, Owner FROM Links WHERE LOWER(Owner) = LOWER(?)", owner)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		link := new(Link)
+		var created, lastEdit int64
+		err := rows.Scan(&link.Short, &link.Long, &created, &lastEdit, &link.Owner)
+		if err != nil {
+			return nil, err
+		}
+		link.Created = time.Unix(created, 0).UTC()
+		link.LastEdit = time.Unix(lastEdit, 0).UTC()
+		links = append(links, link)
+	}
+	return links, rows.Err()
+}

db_test.go

@@ -125,3 +125,43 @@ func Test_SQLiteDB_SaveLoadDeleteStats(t *testing.T) {
 		t.Errorf("db.LoadStats got %v, want %v", got, want)
 	}
 }
+
+// Test GetLinksByOwner functionality
+func Test_SQLiteDB_GetLinksByOwner(t *testing.T) {
+	db, err := NewSQLiteDB(path.Join(t.TempDir(), "links.db"))
+	if err != nil {
+		t.Error(err)
+	}
+
+	// preload some links with owner
+	links := []*Link{
+		{Short: "a", Owner: "foo@bar.com"},
+		{Short: "B-c", Owner: "bar@foo.com "},
+	}
+	for _, link := range links {
+		if err := db.Save(link); err != nil {
+			t.Error(err)
+		}
+	}
+
+	want := []*Link{
+		{Short: "a", Owner: "foo@bar.com"},
+	}
+	got, err := db.GetLinksByOwner("foo@bar.com")
+	if err != nil {
+		t.Error(err)
+	}
+
+	if !cmp.Equal(got, want) {
+		t.Errorf("db.GetLinksByOwner got %v; want %v", got, want)
+	}
+
+	// confirm empty response for non-existant owner
+	got, err = db.GetLinksByOwner("foo1@bar.com")
+	if err != nil {
+		t.Error(err)
+	}
+	if len(got) != 0 {
+		t.Errorf("db.GetLinksByOwner got %v; want empty slice", got)
+	}
+}

golink.go

@@ -291,6 +291,9 @@ var (
 
 	// opensearchTmpl is the template used by the http://go/.opensearch page
 	opensearchTmpl *template.Template
+
+	// searchTmpl is the template used by the http://go/.search page
+	searchTmpl *template.Template
 )
 
 type visitData struct {
@@ -305,6 +308,7 @@ type homeData struct {
 	Clicks   []visitData
 	XSRF     string
 	ReadOnly bool
+	User     string
 }
 
 // deleteData is the data used by deleteTmpl.
@@ -321,9 +325,9 @@ func init() {
 	detailTmpl = newTemplate("base.html", "detail.html")
 	successTmpl = newTemplate("base.html", "success.html")
 	helpTmpl = newTemplate("base.html", "help.html")
-	allTmpl = newTemplate("base.html", "all.html")
 	deleteTmpl = newTemplate("base.html", "delete.html")
 	opensearchTmpl = newTemplate("opensearch.xml")
+	searchTmpl = newTemplate("base.html", "search.html")
 
 	b := make([]byte, 24)
 	rand.Read(b)
@@ -477,6 +481,7 @@ func serveHandler() http.Handler {
 	mux.HandleFunc("/.opensearch", serveOpenSearch)
 	mux.HandleFunc("/.all", serveAll)
 	mux.HandleFunc("/.delete/", serveDelete)
+	mux.HandleFunc("/.search", serveSearch)
 	mux.Handle("/.metrics", promhttp.Handler())
 	mux.Handle("/.static/", http.StripPrefix("/.", http.FileServer(http.FS(embeddedFS))))
 
@@ -539,6 +544,7 @@ func serveHome(w http.ResponseWriter, r *http.Request, short string) {
 		Clicks:   clicks,
 		XSRF:     xsrftoken.Generate(xsrfKey, cu.login, newShortName),
 		ReadOnly: *readonly,
+		User:     cu.login,
 	})
 }
 
@@ -557,7 +563,7 @@ func serveAll(w http.ResponseWriter, _ *http.Request) {
 		return links[i].Short < links[j].Short
 	})
 
-	allTmpl.Execute(w, links)
+	searchTmpl.Execute(w, links)
 }
 
 func serveHelp(w http.ResponseWriter, _ *http.Request) {
@@ -706,6 +712,27 @@ func serveDetail(w http.ResponseWriter, r *http.Request) {
 	detailTmpl.Execute(w, data)
 }
 
+// serveSearch handles requests to /.search?q={query}, where {query} can currently only be
+// the owner formated like "owner:<email>".
+func serveSearch(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query().Get("q")
+	owner, found := strings.CutPrefix(query, "owner:")
+	if !found {
+		http.Error(w, `search only supports "owner:<email>"`, http.StatusBadRequest)
+		return
+	}
+	links, err := db.GetLinksByOwner(owner)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	sort.Slice(links, func(i, j int) bool {
+		return links[i].Short < links[j].Short
+	})
+	searchTmpl.Execute(w, links)
+}
+
 type expandEnv struct {
 	Now time.Time
 

golink_test.go

@@ -754,3 +754,76 @@ func TestHTTPSRedirectHandlerWithQuery(t *testing.T) {
 		t.Errorf("got %q; want %q", w.Header().Get("Location"), "https://foobar.com/?query=bar")
 	}
 }
+
+func TestServeSearch(t *testing.T) {
+	var err error
+	db, err = NewSQLiteDB(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	links := []*Link{
+		{Short: "alpha", Long: "http://alpha/", Owner: "foo@example.com"},
+		{Short: "beta", Long: "http://beta/", Owner: "foo@example.com"},
+		{Short: "gamma", Long: "http://gamma/", Owner: "bar@example.com"},
+		{Short: "delta", Long: "http://delta/", Owner: "FOO@example.com"},
+	}
+	for _, link := range links {
+		if err := db.Save(link); err != nil {
+			t.Error(err)
+		}
+	}
+
+	tests := []struct {
+		name            string
+		owner           string
+		wantStatus      int
+		wantContains    []string // substrings that should appear in response body
+		wantNotContains []string // substrings that should NOT appear in response body
+	}{
+		{
+			name:            "search by owner with multiple links",
+			owner:           "foo@example.com",
+			wantStatus:      http.StatusOK,
+			wantContains:    []string{"alpha", "beta", "delta", "3 total"},
+			wantNotContains: []string{"gamma"},
+		},
+		{
+			name:         "search by owner case insensitive",
+			owner:        "FOO@EXAMPLE.COM",
+			wantStatus:   http.StatusOK,
+			wantContains: []string{"alpha", "beta", "delta"},
+		},
+		{
+			name:            "search by owner with single link",
+			owner:           "bar@example.com",
+			wantStatus:      http.StatusOK,
+			wantContains:    []string{"gamma", "1 total"},
+			wantNotContains: []string{"alpha", "beta"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testURL := "/.search?q=owner:" + url.QueryEscape(tt.owner)
+			r := httptest.NewRequest("GET", testURL, nil)
+			w := httptest.NewRecorder()
+			serveHandler().ServeHTTP(w, r)
+
+			if w.Code != tt.wantStatus {
+				t.Errorf("serveSearch(owner=%q) = %d; want %d", tt.owner, w.Code, tt.wantStatus)
+			}
+
+			body := w.Body.String()
+			for _, s := range tt.wantContains {
+				if !strings.Contains(body, s) {
+					t.Errorf("serveSearch(owner=%q) body missing %q", tt.owner, s)
+				}
+			}
+			for _, s := range tt.wantNotContains {
+				if strings.Contains(body, s) {
+					t.Errorf("serveSearch(owner=%q) body unexpectedly contains %q", tt.owner, s)
+				}
+			}
+		})
+	}
+}

tmpl/home.html

@@ -43,5 +43,6 @@ <h2 class="text-xl font-bold pt-6 pb-2">Popular Links</h2>
       {{end}}
       </tbody>
     </table>
+    <p class="my-2 text-sm"><a class="text-blue-600 hover:underline" href="/.search?q=owner:{{.User}}">See my links.</a></p>
     <p class="my-2 text-sm"><a class="text-blue-600 hover:underline" href="/.all">See all links.</a></p>
 {{ end }}

tmpl/all.html tmpl/search.htmltmpl/all.html renamed to tmpl/search.html

@@ -1,5 +1,5 @@
 {{ define "main" }}
-    <h2 class="text-xl font-bold pt-6 pb-2">All Links ({{ len . }} total)</h2>
+    <h2 class="text-xl font-bold pt-6 pb-2">Results ({{ len . }} total)</h2>
     <table class="table-auto w-full max-w-screen-lg">
       <thead class="border-b border-gray-200 uppercase text-xs text-gray-500 text-left">
         <tr class="flex">