lexicons: remove sh.tangled.repo::owner

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

api/tangled/cbor_gen.go

···
 		fieldCount--
 	}
 
+	if t.Labels == nil {
+		fieldCount--
+	}
+
 	if t.Source == nil {
 		fieldCount--
 	}
···
 		return err
 	}
 
-	// t.Owner (string) (string)
-	if len("owner") > 1000000 {
-		return xerrors.Errorf("Value in field \"owner\" was too long")
-	}
+	// t.Labels ([]string) (slice)
+	if t.Labels != nil {
+
+		if len("labels") > 1000000 {
+			return xerrors.Errorf("Value in field \"labels\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("labels")); err != nil {
+			return err
+		}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("owner")); err != nil {
-		return err
-	}
+		if len(t.Labels) > 8192 {
+			return xerrors.Errorf("Slice value in field t.Labels was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
+			return err
+		}
+		for _, v := range t.Labels {
+			if len(v) > 1000000 {
+				return xerrors.Errorf("Value in field v was too long")
+			}
 
-	if len(t.Owner) > 1000000 {
-		return xerrors.Errorf("Value in field t.Owner was too long")
-	}
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(v)); err != nil {
+				return err
+			}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Owner)); err != nil {
-		return err
+		}
 	}
 
 	// t.Source (string) (string)
···
 
 				t.LexiconTypeID = string(sval)
 			}
-			// t.Owner (string) (string)
-		case "owner":
+			// t.Labels ([]string) (slice)
+		case "labels":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.Labels: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.Labels = make([]string, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
 
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
+					{
+						sval, err := cbg.ReadStringWithMax(cr, 1000000)
+						if err != nil {
+							return err
+						}
+
+						t.Labels[i] = string(sval)
+					}
+
 				}
-
-				t.Owner = string(sval)
 			}
 			// t.Source (string) (string)
 		case "source":

api/tangled/tangledrepo.go

···
 	Description   *string `json:"description,omitempty" cborgen:"description,omitempty"`
 	// knot: knot where the repo was created
 	Knot string `json:"knot" cborgen:"knot"`
+	// labels: List of labels that this repo subscribes to
+	Labels []string `json:"labels,omitempty" cborgen:"labels,omitempty"`
 	// name: name of the repo
-	Name  string `json:"name" cborgen:"name"`
-	Owner string `json:"owner" cborgen:"owner"`
+	Name string `json:"name" cborgen:"name"`
 	// source: source of the repo
 	Source *string `json:"source,omitempty" cborgen:"source,omitempty"`
 	// spindle: CI runner to send jobs to and receive results from

appview/repo/repo.go

···
 				Val: &tangled.Repo{
 					Knot:        f.Knot,
 					Name:        f.Name,
-					Owner:       user.Did,
 					CreatedAt:   f.Created.Format(time.RFC3339),
 					Description: &newDescription,
 					Spindle:     &f.Spindle,
···
 			Val: &tangled.Repo{
 				Knot:        f.Knot,
 				Name:        f.Name,
-				Owner:       user.Did,
 				CreatedAt:   f.Created.Format(time.RFC3339),
 				Description: &f.Description,
 				Spindle:     spindlePtr,
···
 					Knot:      repo.Knot,
 					Name:      repo.Name,
 					CreatedAt: createdAt,
-					Owner:     user.Did,
 					Source:    &sourceAt,
 				}},
 		})

appview/state/router.go

···
 		Db:         s.db,
 		OAuth:      s.oauth,
 		Pages:      s.pages,
-		Config:     s.config,
-		Enforcer:   s.enforcer,
 		IdResolver: s.idResolver,
-		Knotstream: s.knotstream,
 		Logger:     logger,
 	}
 

appview/state/state.go

···
 					Knot:      repo.Knot,
 					Name:      repoName,
 					CreatedAt: createdAt,
-					Owner:     user.Did,
 				}},
 		})
 		if err != nil {

appview/strings/strings.go

···
 	"time"
 
 	"tangled.sh/tangled.sh/core/api/tangled"
-	"tangled.sh/tangled.sh/core/appview/config"
 	"tangled.sh/tangled.sh/core/appview/db"
 	"tangled.sh/tangled.sh/core/appview/middleware"
 	"tangled.sh/tangled.sh/core/appview/notify"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/pages/markup"
-	"tangled.sh/tangled.sh/core/eventconsumer"
 	"tangled.sh/tangled.sh/core/idresolver"
-	"tangled.sh/tangled.sh/core/rbac"
 	"tangled.sh/tangled.sh/core/tid"
 
 	"github.com/bluesky-social/indigo/api/atproto"
···
 	Db         *db.DB
 	OAuth      *oauth.OAuth
 	Pages      *pages.Pages
-	Config     *config.Config
-	Enforcer   *rbac.Enforcer
 	IdResolver *idresolver.Resolver
 	Logger     *slog.Logger
-	Knotstream *eventconsumer.Consumer
 	Notifier   notify.Notifier
 }
 

knotserver/ingester.go

···
 		return fmt.Errorf("rejected pull record: not this knot, %s != %s", repo.Knot, h.c.Server.Hostname)
 	}
 
-	didSlashRepo, err := securejoin.SecureJoin(repo.Owner, repo.Name)
+	didSlashRepo, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)
 	if err != nil {
 		return fmt.Errorf("failed to construct relative repo path: %w", err)
 	}
···
 			Kind:        string(workflow.TriggerKindPullRequest),
 			PullRequest: &trigger,
 			Repo: &tangled.Pipeline_TriggerRepo{
-				Did:  repo.Owner,
+				Did:  ident.DID.String(),
 				Knot: repo.Knot,
 				Repo: repo.Name,
 			},

knotserver/util.go

···
 package knotserver
 
 import (
-	"net/http"
-	"os"
-	"path/filepath"
-
 	"github.com/bluesky-social/indigo/atproto/syntax"
-	securejoin "github.com/cyphar/filepath-securejoin"
-	"github.com/go-chi/chi/v5"
 )
-
-func didPath(r *http.Request) string {
-	did := chi.URLParam(r, "did")
-	name := chi.URLParam(r, "name")
-	path, _ := securejoin.SecureJoin(did, name)
-	filepath.Clean(path)
-	return path
-}
-
-func getDescription(path string) (desc string) {
-	db, err := os.ReadFile(filepath.Join(path, "description"))
-	if err == nil {
-		desc = string(db)
-	} else {
-		desc = ""
-	}
-	return
-}
-func setContentDisposition(w http.ResponseWriter, name string) {
-	h := "inline; filename=\"" + name + "\""
-	w.Header().Add("Content-Disposition", h)
-}
-
-func setGZipMIME(w http.ResponseWriter) {
-	setMIME(w, "application/gzip")
-}
-
-func setMIME(w http.ResponseWriter, mime string) {
-	w.Header().Add("Content-Type", mime)
-}
 
 var TIDClock = syntax.NewTIDClock(0)
 

lexicons/repo/repo.json

···
         "required": [
           "name",
           "knot",
-          "owner",
           "createdAt"
         ],
         "properties": {
           "name": {
             "type": "string",
             "description": "name of the repo"
-          },
-          "owner": {
-            "type": "string",
-            "format": "did"
           },
           "knot": {
             "type": "string",
···
             "type": "string",
             "format": "uri",
             "description": "source of the repo"
+          },
+          "labels": {
+            "type": "array",
+            "description": "List of labels that this repo subscribes to",
+            "items": {
+              "type": "string",
+              "format": "at-uri"
+            }
           },
           "createdAt": {
             "type": "string",

spindle/ingester.go

···
 
 		// no spindle configured for this repo
 		if record.Spindle == nil {
-			l.Info("no spindle configured", "did", record.Owner, "name", record.Name)
+			l.Info("no spindle configured", "name", record.Name)
 			return nil
 		}
 
 		// this repo did not want this spindle
 		if *record.Spindle != domain {
-			l.Info("different spindle configured", "did", record.Owner, "name", record.Name, "spindle", *record.Spindle, "domain", domain)
+			l.Info("different spindle configured", "name", record.Name, "spindle", *record.Spindle, "domain", domain)
 			return nil
 		}
 
 		// add this repo to the watch list
-		if err := s.db.AddRepo(record.Knot, record.Owner, record.Name); err != nil {
+		if err := s.db.AddRepo(record.Knot, did, record.Name); err != nil {
 			l.Error("failed to add repo", "error", err)
 			return fmt.Errorf("failed to add repo: %w", err)
 		}
 
-		didSlashRepo, err := securejoin.SecureJoin(record.Owner, record.Name)
+		didSlashRepo, err := securejoin.SecureJoin(did, record.Name)
 		if err != nil {
 			return err
 		}
 
 		// add repo to rbac
-		if err := s.e.AddRepo(record.Owner, rbac.ThisServer, didSlashRepo); err != nil {
+		if err := s.e.AddRepo(did, rbac.ThisServer, didSlashRepo); err != nil {
 			l.Error("failed to add repo to enforcer", "error", err)
 			return fmt.Errorf("failed to add repo: %w", err)
 		}

spindle/xrpc/add_secret.go

···
 	}
 
 	repo := resp.Value.Val.(*tangled.Repo)
-	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)
+	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)
 	if err != nil {
 		fail(xrpcerr.GenericError(err))
 		return

spindle/xrpc/list_secrets.go

···
 	}
 
 	repo := resp.Value.Val.(*tangled.Repo)
-	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)
+	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)
 	if err != nil {
 		fail(xrpcerr.GenericError(err))
 		return

spindle/xrpc/remove_secret.go

···
 	}
 
 	repo := resp.Value.Val.(*tangled.Repo)
-	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)
+	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)
 	if err != nil {
 		fail(xrpcerr.GenericError(err))
 		return