implement queryLabels and add new COCOON_REQUIRE_INVITE env (#47)

* implement queryLabels

* add a COCOON_REQUIRE_INVITE env to make invite codes be able to not be required (still required by default)

* handle handles for http requests and stuff

README.md

···
 
 ### Other
 
-- [ ] `com.atproto.label.queryLabels`
+- [x] `com.atproto.label.queryLabels`
 - [x] `com.atproto.moderation.createReport` (Note: this should be handled by proxying, not actually implemented in the PDS)
 - [x] `app.bsky.actor.getPreferences`
 - [x] `app.bsky.actor.putPreferences`

cmd/cocoon/main.go

···
 				Name:    "admin-password",
 				EnvVars: []string{"COCOON_ADMIN_PASSWORD"},
 			},
+			&cli.BoolFlag{
+				Name:    "require-invite",
+				EnvVars: []string{"COCOON_REQUIRE_INVITE"},
+				Value:   true,
+			},
 			&cli.StringFlag{
 				Name:    "smtp-user",
 				EnvVars: []string{"COCOON_SMTP_USER"},
···
 			Version:         Version,
 			Relays:          cmd.StringSlice("relays"),
 			AdminPassword:   cmd.String("admin-password"),
+			RequireInvite:   cmd.Bool("require-invite"),
 			SmtpUser:        cmd.String("smtp-user"),
 			SmtpPass:        cmd.String("smtp-pass"),
 			SmtpHost:        cmd.String("smtp-host"),

server/handle_label_query_labels.go

···
+package server
+
+import (
+	"github.com/labstack/echo/v4"
+)
+
+type Label struct {
+	Ver *int    `json:"ver,omitempty"`
+	Src string  `json:"src"`
+	Uri string  `json:"uri"`
+	Cid *string `json:"cid,omitempty"`
+	Val string  `json:"val"`
+	Neg *bool   `json:"neg,omitempty"`
+	Cts string  `json:"cts"`
+	Exp *string `json:"exp,omitempty"`
+	Sig []byte  `json:"sig,omitempty"`
+}
+
+type ComAtprotoLabelQueryLabelsResponse struct {
+	Cursor *string `json:"cursor,omitempty"`
+	Labels []Label `json:"labels"`
+}
+
+func (s *Server) handleLabelQueryLabels(e echo.Context) error {
+	svc := e.Request().Header.Get("atproto-proxy")
+	if svc != "" || s.config.FallbackProxy != "" {
+		return s.handleProxy(e)
+	}
+
+	return e.JSON(200, ComAtprotoLabelQueryLabelsResponse{
+		Cursor: nil,
+		Labels: []Label{},
+	})
+}

server/handle_server_create_account.go

···
 	Handle     string  `json:"handle" validate:"required,atproto-handle"`
 	Did        *string `json:"did" validate:"atproto-did"`
 	Password   string  `json:"password" validate:"required"`
-	InviteCode string  `json:"inviteCode" validate:"required"`
+	InviteCode string  `json:"inviteCode" validate:"omitempty"`
 }
 
 type ComAtprotoServerCreateAccountResponse struct {
···
 	}
 
 	var ic models.InviteCode
-	if err := s.db.Raw("SELECT * FROM invite_codes WHERE code = ?", nil, request.InviteCode).Scan(&ic).Error; err != nil {
-		if err == gorm.ErrRecordNotFound {
+	if s.config.RequireInvite {
+		if strings.TrimSpace(request.InviteCode) == "" {
 			return helpers.InputError(e, to.StringPtr("InvalidInviteCode"))
 		}
-		s.logger.Error("error getting invite code from db", "error", err)
-		return helpers.ServerError(e, nil)
-	}
 
-	if ic.RemainingUseCount < 1 {
-		return helpers.InputError(e, to.StringPtr("InvalidInviteCode"))
+		if err := s.db.Raw("SELECT * FROM invite_codes WHERE code = ?", nil, request.InviteCode).Scan(&ic).Error; err != nil {
+			if err == gorm.ErrRecordNotFound {
+				return helpers.InputError(e, to.StringPtr("InvalidInviteCode"))
+			}
+			s.logger.Error("error getting invite code from db", "error", err)
+			return helpers.ServerError(e, nil)
+		}
+
+		if ic.RemainingUseCount < 1 {
+			return helpers.InputError(e, to.StringPtr("InvalidInviteCode"))
+		}
 	}
 
 	// see if the email is already taken
···
 		})
 	}
 
-	if err := s.db.Raw("UPDATE invite_codes SET remaining_use_count = remaining_use_count - 1 WHERE code = ?", nil, request.InviteCode).Scan(&ic).Error; err != nil {
-		s.logger.Error("error decrementing use count", "error", err)
-		return helpers.ServerError(e, nil)
+	if s.config.RequireInvite {
+		if err := s.db.Raw("UPDATE invite_codes SET remaining_use_count = remaining_use_count - 1 WHERE code = ?", nil, request.InviteCode).Scan(&ic).Error; err != nil {
+			s.logger.Error("error decrementing use count", "error", err)
+			return helpers.ServerError(e, nil)
+		}
 	}
 
 	sess, err := s.createSession(&urepo)

server/handle_server_describe_server.go

···
 
 func (s *Server) handleDescribeServer(e echo.Context) error {
 	return e.JSON(200, ComAtprotoServerDescribeServerResponse{
-		InviteCodeRequired:        true,
+		InviteCodeRequired:        s.config.RequireInvite,
 		PhoneVerificationRequired: false,
 		AvailableUserDomains:      []string{"." + s.config.Hostname}, // TODO: more
 		Links: ComAtprotoServerDescribeServerResponseLinks{

server/handle_well_known.go

···
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/Azure/go-autorest/autorest/to"
+	"github.com/haileyok/cocoon/internal/helpers"
 	"github.com/labstack/echo/v4"
+	"gorm.io/gorm"
 )
 
 var (
···
 			},
 		},
 	})
+}
+
+func (s *Server) handleAtprotoDid(e echo.Context) error {
+	host := e.Request().Host
+	if host == "" {
+		return helpers.InputError(e, to.StringPtr("Invalid handle."))
+	}
+
+	host = strings.Split(host, ":")[0]
+	host = strings.ToLower(strings.TrimSpace(host))
+
+	if host == s.config.Hostname {
+		return e.String(200, s.config.Did)
+	}
+
+	suffix := "." + s.config.Hostname
+	if !strings.HasSuffix(host, suffix) {
+		return e.NoContent(404)
+	}
+
+	actor, err := s.getActorByHandle(host)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return e.NoContent(404)
+		}
+		s.logger.Error("error looking up actor by handle", "error", err)
+		return helpers.ServerError(e, nil)
+	}
+
+	return e.String(200, actor.Did)
 }
 
 func (s *Server) handleOauthProtectedResource(e echo.Context) error {

server/server.go

···
 	ContactEmail    string
 	Relays          []string
 	AdminPassword   string
+	RequireInvite   bool
 
 	SmtpUser  string
 	SmtpPass  string
···
 	EnforcePeering    bool
 	Relays            []string
 	AdminPassword     string
+	RequireInvite     bool
 	SmtpEmail         string
 	SmtpName          string
 	BlockstoreVariant BlockstoreVariant
···
 			EnforcePeering:    false,
 			Relays:            args.Relays,
 			AdminPassword:     args.AdminPassword,
+			RequireInvite:     args.RequireInvite,
 			SmtpName:          args.SmtpName,
 			SmtpEmail:         args.SmtpEmail,
 			BlockstoreVariant: args.BlockstoreVariant,
···
 	s.echo.GET("/", s.handleRoot)
 	s.echo.GET("/xrpc/_health", s.handleHealth)
 	s.echo.GET("/.well-known/did.json", s.handleWellKnown)
+	s.echo.GET("/.well-known/atproto-did", s.handleAtprotoDid)
 	s.echo.GET("/.well-known/oauth-protected-resource", s.handleOauthProtectedResource)
 	s.echo.GET("/.well-known/oauth-authorization-server", s.handleOauthAuthorizationServer)
 	s.echo.GET("/robots.txt", s.handleRobots)
···
 	s.echo.GET("/xrpc/com.atproto.sync.subscribeRepos", s.handleSyncSubscribeRepos)
 	s.echo.GET("/xrpc/com.atproto.sync.listBlobs", s.handleSyncListBlobs)
 	s.echo.GET("/xrpc/com.atproto.sync.getBlob", s.handleSyncGetBlob)
+
+	// labels
+	s.echo.GET("/xrpc/com.atproto.label.queryLabels", s.handleLabelQueryLabels)
 
 	// account
 	s.echo.GET("/account", s.handleAccount)