appview/labels: add "subscribe all" button for default labels

quickly subscribe to all default labels.

Signed-off-by: oppiliappan <[e-mail]>

appview/db/db.go

···
 			-- label to subscribe to
 			label_at text not null,
 
-			unique (repo_at, label_at),
-			foreign key (label_at) references label_definitions (at_uri)
+			unique (repo_at, label_at)
 		);
 
 		create table if not exists migrations (

appview/db/repos.go

···
 	return &repo, nil
 }
 
-func AddRepo(e Execer, repo *models.Repo) error {
-	_, err := e.Exec(
+func AddRepo(tx *sql.Tx, repo *models.Repo) error {
+	_, err := tx.Exec(
 		`insert into repos
 		(did, name, knot, rkey, at_uri, description, source)
 		values (?, ?, ?, ?, ?, ?, ?)`,
 		repo.Did, repo.Name, repo.Knot, repo.Rkey, repo.RepoAt().String(), repo.Description, repo.Source,
 	)
-	return err
+	if err != nil {
+		return fmt.Errorf("failed to insert repo: %w", err)
+	}
+
+	for _, dl := range repo.Labels {
+		if err := SubscribeLabel(tx, &models.RepoLabel{
+			RepoAt:  repo.RepoAt(),
+			LabelAt: syntax.ATURI(dl),
+		}); err != nil {
+			return fmt.Errorf("failed to subscribe to label: %w", err)
+		}
+	}
+
+	return nil
 }
 
 func RemoveRepo(e Execer, did, name string) error {

appview/ingester.go

···
 	"encoding/json"
 	"fmt"
 	"log/slog"
+	"maps"
+	"slices"
 
 	"time"
 
···
 				err = i.ingestIssueComment(e)
 			case tangled.LabelDefinitionNSID:
 				err = i.ingestLabelDefinition(e)
+			case tangled.LabelOpNSID:
+				err = i.ingestLabelOp(e)
 			}
 			l = i.Logger.With("nsid", e.Commit.Collection)
 		}
···
 
 	return nil
 }
+
+func (i *Ingester) ingestLabelOp(e *jmodels.Event) error {
+	did := e.Did
+	rkey := e.Commit.RKey
+
+	var err error
+
+	l := i.Logger.With("handler", "ingestLabelOp", "nsid", e.Commit.Collection, "did", did, "rkey", rkey)
+	l.Info("ingesting record")
+
+	ddb, ok := i.Db.Execer.(*db.DB)
+	if !ok {
+		return fmt.Errorf("failed to index label op, invalid db cast")
+	}
+
+	switch e.Commit.Operation {
+	case jmodels.CommitOperationCreate:
+		raw := json.RawMessage(e.Commit.Record)
+		record := tangled.LabelOp{}
+		err = json.Unmarshal(raw, &record)
+		if err != nil {
+			return fmt.Errorf("invalid record: %w", err)
+		}
+
+		subject := syntax.ATURI(record.Subject)
+		collection := subject.Collection()
+
+		var repo *models.Repo
+		switch collection {
+		case tangled.RepoIssueNSID:
+			i, err := db.GetIssues(ddb, db.FilterEq("at_uri", subject))
+			if err != nil || len(i) != 1 {
+				return fmt.Errorf("failed to find subject: %w || subject count %d", err, len(i))
+			}
+			repo = i[0].Repo
+		default:
+			return fmt.Errorf("unsupport label subject: %s", collection)
+		}
+
+		actx, err := db.NewLabelApplicationCtx(ddb, db.FilterIn("at_uri", repo.Labels))
+		if err != nil {
+			return fmt.Errorf("failed to build label application ctx: %w", err)
+		}
+
+		ops := models.LabelOpsFromRecord(did, rkey, record)
+
+		for _, o := range ops {
+			def, ok := actx.Defs[o.OperandKey]
+			if !ok {
+				return fmt.Errorf("failed to find label def for key: %s, expected: %q", o.OperandKey, slices.Collect(maps.Keys(actx.Defs)))
+			}
+			if err := i.Validator.ValidateLabelOp(def, &o); err != nil {
+				return fmt.Errorf("failed to validate labelop: %w", err)
+			}
+		}
+
+		tx, err := ddb.Begin()
+		if err != nil {
+			return err
+		}
+		defer tx.Rollback()
+
+		for _, o := range ops {
+			_, err = db.AddLabelOp(tx, &o)
+			if err != nil {
+				return fmt.Errorf("failed to add labelop: %w", err)
+			}
+		}
+
+		if err = tx.Commit(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

appview/labels/labels.go

···
 		return
 	}
 
-	l.logger.Info("actx", "labels", labelAts)
-	l.logger.Info("actx", "defs", actx.Defs)
-
 	// calculate the start state by applying already known labels
 	existingOps, err := db.GetLabelOps(l.db, db.FilterEq("subject", subjectUri))
 	if err != nil {

appview/models/label.go

···
 package models
 
 import (
+	"context"
 	"crypto/sha1"
 	"encoding/hex"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"slices"
 	"time"
 
+	"github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/bluesky-social/indigo/xrpc"
 	"tangled.org/core/api/tangled"
 	"tangled.org/core/consts"
+	"tangled.org/core/idresolver"
 )
 
 type ConcreteType string
···
 
 	return defs
 }
+
+func FetchDefaultDefs(r *idresolver.Resolver) ([]LabelDefinition, error) {
+	resolved, err := r.ResolveIdent(context.Background(), consts.TangledDid)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve tangled.sh DID %s: %v", consts.TangledDid, err)
+	}
+	pdsEndpoint := resolved.PDSEndpoint()
+	if pdsEndpoint == "" {
+		return nil, fmt.Errorf("no PDS endpoint found for tangled.sh DID %s", consts.TangledDid)
+	}
+	client := &xrpc.Client{
+		Host: pdsEndpoint,
+	}
+
+	var labelDefs []LabelDefinition
+
+	for _, dl := range DefaultLabelDefs() {
+		atUri := syntax.ATURI(dl)
+		parsedUri, err := syntax.ParseATURI(string(atUri))
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse AT-URI %s: %v", atUri, err)
+		}
+		record, err := atproto.RepoGetRecord(
+			context.Background(),
+			client,
+			"",
+			parsedUri.Collection().String(),
+			parsedUri.Authority().String(),
+			parsedUri.RecordKey().String(),
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get record for %s: %v", atUri, err)
+		}
+
+		if record != nil {
+			bytes, err := record.Value.MarshalJSON()
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal record value for %s: %v", atUri, err)
+			}
+
+			raw := json.RawMessage(bytes)
+			labelRecord := tangled.LabelDefinition{}
+			err = json.Unmarshal(raw, &labelRecord)
+			if err != nil {
+				return nil, fmt.Errorf("invalid record for %s: %w", atUri, err)
+			}
+
+			labelDef, err := LabelDefinitionFromRecord(
+				parsedUri.Authority().String(),
+				parsedUri.RecordKey().String(),
+				labelRecord,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("failed to create label definition from record %s: %v", atUri, err)
+			}
+
+			labelDefs = append(labelDefs, *labelDef)
+		}
+	}
+
+	return labelDefs, nil
+}

appview/pages/pages.go

···
 }
 
 type RepoGeneralSettingsParams struct {
-	LoggedInUser     *oauth.User
-	RepoInfo         repoinfo.RepoInfo
-	Labels           []models.LabelDefinition
-	DefaultLabels    []models.LabelDefinition
-	SubscribedLabels map[string]struct{}
-	Active           string
-	Tabs             []map[string]any
-	Tab              string
-	Branches         []types.Branch
+	LoggedInUser       *oauth.User
+	RepoInfo           repoinfo.RepoInfo
+	Labels             []models.LabelDefinition
+	DefaultLabels      []models.LabelDefinition
+	SubscribedLabels   map[string]struct{}
+	ShouldSubscribeAll bool
+	Active             string
+	Tabs               []map[string]any
+	Tab                string
+	Branches           []types.Branch
 }
 
 func (p *Pages) RepoGeneralSettings(w io.Writer, params RepoGeneralSettingsParams) error {

appview/pages/templates/repo/settings/general.html

···
 
 {{ define "defaultLabelSettings" }}
   <div class="flex flex-col gap-2">
-    <h2 class="text-sm pb-2 uppercase font-bold">Default Labels</h2>
-    <p class="text-gray-500 dark:text-gray-400">
-      Manage your issues and pulls by creating labels to categorize them. Only
-      repository owners may configure labels. You may choose to subscribe to
-      default labels, or create entirely custom labels.
-    </p>
+    <div class="grid grid-cols-1 md:grid-cols-3 gap-4 items-center">
+      <div class="col-span-1 md:col-span-2">
+        <h2 class="text-sm pb-2 uppercase font-bold">Default Labels</h2>
+        <p class="text-gray-500 dark:text-gray-400">
+          Manage your issues and pulls by creating labels to categorize them. Only
+          repository owners may configure labels. You may choose to subscribe to
+          default labels, or create entirely custom labels.
+        <p>
+      </div>
+      <form class="col-span-1 md:col-span-1 md:justify-self-end">
+        {{ $title := "Unubscribe from all labels" }}
+        {{ $icon := "x" }}
+        {{ $text := "unsubscribe all" }}
+        {{ $action := "unsubscribe" }}
+        {{ if $.ShouldSubscribeAll }}
+          {{ $title = "Subscribe to all labels" }}
+          {{ $icon = "check-check" }}
+          {{ $text = "subscribe all" }}
+          {{ $action = "subscribe" }}
+        {{ end }}
+        {{ range .DefaultLabels }}
+          <input type="hidden" name="label" value="{{ .AtUri.String }}">
+        {{ end }}
+        <button
+          type="submit"
+          title="{{$title}}" 
+          class="btn flex items-center gap-2 group"
+          hx-swap="none"
+          hx-post="/{{ $.RepoInfo.FullName }}/settings/label/{{$action}}"
+          {{ if not .RepoInfo.Roles.IsOwner }}disabled{{ end }}>
+          {{ i $icon "size-4" }}
+          {{ $text }}
+          {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}
+        </button>
+      </form>
+    </div>
     <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700 w-full">
       {{ range .DefaultLabels }}
         <div id="label-{{.Id}}" class="flex items-center justify-between p-2 pl-4">

appview/repo/repo.go

···
 		return
 	}
 
+	if err := r.ParseForm(); err != nil {
+		l.Error("invalid form", "err", err)
+		return
+	}
+
 	errorId := "default-label-operation"
 	fail := func(msg string, err error) {
 		l.Error(msg, "err", err)
 		rp.pages.Notice(w, errorId, msg)
 	}
 
-	labelAt := r.FormValue("label")
-	_, err = db.GetLabelDefinition(rp.db, db.FilterEq("at_uri", labelAt))
+	labelAts := r.Form["label"]
+	_, err = db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", labelAts))
 	if err != nil {
 		fail("Failed to subscribe to label.", err)
 		return
 	}
 
 	newRepo := f.Repo
-	newRepo.Labels = append(newRepo.Labels, labelAt)
+	newRepo.Labels = append(newRepo.Labels, labelAts...)
+
+	// dedup
+	slices.Sort(newRepo.Labels)
+	newRepo.Labels = slices.Compact(newRepo.Labels)
+
 	repoRecord := newRepo.AsRecord()
 
 	client, err := rp.oauth.AuthorizedClient(r)
···
 		},
 	})
 
-	err = db.SubscribeLabel(rp.db, &models.RepoLabel{
-		RepoAt:  f.RepoAt(),
-		LabelAt: syntax.ATURI(labelAt),
-	})
+	tx, err := rp.db.Begin()
 	if err != nil {
 		fail("Failed to subscribe to label.", err)
 		return
 	}
+	defer tx.Rollback()
+
+	for _, l := range labelAts {
+		err = db.SubscribeLabel(tx, &models.RepoLabel{
+			RepoAt:  f.RepoAt(),
+			LabelAt: syntax.ATURI(l),
+		})
+		if err != nil {
+			fail("Failed to subscribe to label.", err)
+			return
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		fail("Failed to subscribe to label.", err)
+		return
+	}
 
 	// everything succeeded
 	rp.pages.HxRefresh(w)
···
 		return
 	}
 
+	if err := r.ParseForm(); err != nil {
+		l.Error("invalid form", "err", err)
+		return
+	}
+
 	errorId := "default-label-operation"
 	fail := func(msg string, err error) {
 		l.Error(msg, "err", err)
 		rp.pages.Notice(w, errorId, msg)
 	}
 
-	labelAt := r.FormValue("label")
-	_, err = db.GetLabelDefinition(rp.db, db.FilterEq("at_uri", labelAt))
+	labelAts := r.Form["label"]
+	_, err = db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", labelAts))
 	if err != nil {
 		fail("Failed to unsubscribe to label.", err)
 		return
···
 	newRepo := f.Repo
 	var updated []string
 	for _, l := range newRepo.Labels {
-		if l != labelAt {
+		if !slices.Contains(labelAts, l) {
 			updated = append(updated, l)
 		}
 	}
···
 	err = db.UnsubscribeLabel(
 		rp.db,
 		db.FilterEq("repo_at", f.RepoAt()),
-		db.FilterEq("label_at", labelAt),
+		db.FilterIn("label_at", labelAts),
 	)
 	if err != nil {
 		fail("Failed to unsubscribe label.", err)
···
 		subscribedLabels[l] = struct{}{}
 	}
 
+	// if there is atleast 1 unsubbed default label, show the "subscribe all" button,
+	// if all default labels are subbed, show the "unsubscribe all" button
+	shouldSubscribeAll := false
+	for _, dl := range defaultLabels {
+		if _, ok := subscribedLabels[dl.AtUri().String()]; !ok {
+			// one of the default labels is not subscribed to
+			shouldSubscribeAll = true
+			break
+		}
+	}
+
 	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{
-		LoggedInUser:     user,
-		RepoInfo:         f.RepoInfo(user),
-		Branches:         result.Branches,
-		Labels:           labels,
-		DefaultLabels:    defaultLabels,
-		SubscribedLabels: subscribedLabels,
-		Tabs:             settingsTabs,
-		Tab:              "general",
+		LoggedInUser:       user,
+		RepoInfo:           f.RepoInfo(user),
+		Branches:           result.Branches,
+		Labels:             labels,
+		DefaultLabels:      defaultLabels,
+		SubscribedLabels:   subscribedLabels,
+		ShouldSubscribeAll: shouldSubscribeAll,
+		Tabs:               settingsTabs,
+		Tab:                "general",
 	})
 }
 
···
 			Source:      sourceAt,
 			Description: existingRepo.Description,
 			Created:     time.Now(),
+			Labels:      models.DefaultLabelDefs(),
 		}
 		record := repo.AsRecord()
 

appview/state/state.go

···
 			tangled.RepoIssueNSID,
 			tangled.RepoIssueCommentNSID,
 			tangled.LabelDefinitionNSID,
+			tangled.LabelOpNSID,
 		},
 		nil,
 		slog.Default(),
···
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create jetstream client: %w", err)
+	}
+
+	if err := db.BackfillDefaultDefs(d, res); err != nil {
+		return nil, fmt.Errorf("failed to backfill default label defs: %w", err)
 	}
 
 	ingester := appview.Ingester{
···
 			Rkey:        rkey,
 			Description: description,
 			Created:     time.Now(),
+			Labels:      models.DefaultLabelDefs(),
 		}
 		record := repo.AsRecord()
 
···
 	})
 	return err
 }
+
+func BackfillDefaultDefs(e db.Execer, r *idresolver.Resolver) error {
+	defaults := models.DefaultLabelDefs()
+	defaultLabels, err := db.GetLabelDefinitions(e, db.FilterIn("at_uri", defaults))
+	if err != nil {
+		return err
+	}
+	// already present
+	if len(defaultLabels) == len(defaults) {
+		return nil
+	}
+
+	labelDefs, err := models.FetchDefaultDefs(r)
+	if err != nil {
+		return err
+	}
+
+	// Insert each label definition to the database
+	for _, labelDef := range labelDefs {
+		_, err = db.AddLabelDefinition(e, &labelDef)
+		if err != nil {
+			return fmt.Errorf("failed to add label definition %s: %v", labelDef.Name, err)
+		}
+	}
+
+	return nil
+}