reblogs and attachments now sort of work

Author: davecheney

activitypub/activitypub.go

@@ -33,7 +33,7 @@ func (e *Env) Log() *slog.Logger {
 func Followers(env *Env, w http.ResponseWriter, r *http.Request) error {
 	var followers []*models.Relationship
 	query := env.DB.Joins("JOIN actors ON actors.object_id = relationships.target_id and actors.name = ? and actors.domain = ?", chi.URLParam(r, "name"), r.Host)
-	if err := query.Model(&models.Relationship{}).Preload("Actor").Find(&followers, "following = true").Error; err != nil {
+	if err := query.Model(&models.Relationship{}).Scopes(models.PreloadActor).Find(&followers, "following = true").Error; err != nil {
 		return err
 	}
 	return to.JSON(w, map[string]any{
@@ -53,7 +53,7 @@ func Followers(env *Env, w http.ResponseWriter, r *http.Request) error {
 func Following(env *Env, w http.ResponseWriter, r *http.Request) error {
 	var following []*models.Relationship
 	query := env.DB.Joins("JOIN actors ON actors.object_id = relationships.actor_id and actors.name = ? and actors.domain = ?", chi.URLParam(r, "name"), r.Host)
-	if err := query.Model(&models.Relationship{}).Preload("Target").Find(&following, "following = true").Error; err != nil {
+	if err := query.Model(&models.Relationship{}).Scopes(models.PreloadRelationshipTarget).Find(&following, "following = true").Error; err != nil {
 		return err
 	}
 	return to.JSON(w, map[string]any{

activitypub/fetchers.go

@@ -3,7 +3,6 @@ package activitypub
 import (
 	"context"
 	"fmt"
-	"net/url"
 	"time"
 
 	"github.com/davecheney/pub/internal/algorithms"
@@ -12,79 +11,6 @@ import (
 	"gorm.io/gorm"
 )
 
-type RemoteActorFetcher struct {
-	// signAs is the account that will be used to sign the request
-	signAs *models.Account
-}
-
-func NewRemoteActorFetcher(signAs *models.Account) *RemoteActorFetcher {
-	return &RemoteActorFetcher{
-		signAs: signAs,
-	}
-}
-
-func (f *RemoteActorFetcher) Fetch(ctx context.Context, uri string) (*models.Actor, error) {
-	c, err := NewClient(f.signAs)
-	if err != nil {
-		return nil, err
-	}
-	var actor struct {
-		Type string `json:"type"`
-		// The Actor's unique global identifier.
-		ID                string `json:"id"`
-		Inbox             string `json:"inbox"`
-		Outbox            string `json:"outbox"`
-		PreferredUsername string `json:"preferredUsername"`
-		Name              string `json:"name"`
-		Summary           string `json:"summary"`
-		Icon              struct {
-			Type      string `json:"type"`
-			MediaType string `json:"mediaType"`
-			URL       string `json:"url"`
-		} `json:"icon"`
-		Image struct {
-			Type      string `json:"type"`
-			MediaType string `json:"mediaType"`
-			URL       string `json:"url"`
-		} `json:"image"`
-		Endpoints struct {
-			SharedInbox string `json:"sharedInbox"`
-		} `json:"endpoints"`
-		ManuallyApprovesFollowers bool      `json:"manuallyApprovesFollowers"`
-		Published                 time.Time `json:"published"`
-		PublicKey                 struct {
-			ID           string `json:"id"`
-			Owner        string `json:"owner"`
-			PublicKeyPem string `json:"publicKeyPem"`
-		} `json:"publicKey"`
-		Attachments []Attachment `json:"attachment"`
-	}
-	if err := c.Fetch(ctx, uri, &actor); err != nil {
-		return nil, err
-	}
-
-	published := actor.Published
-	if published.IsZero() {
-		published = time.Now()
-	}
-
-	u, err := url.Parse(actor.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return &models.Actor{
-		ObjectID: snowflake.TimeToID(published),
-		Type:     models.ActorType(actor.Type),
-		Name:     actor.PreferredUsername,
-		Domain:   u.Host,
-		// URI:    actor.ID,
-		// Avatar: actor.Icon.URL,
-		// Header:     actor.Image.URL,
-		// Attributes: attachmentsToActorAttributes(actor.Attachments),
-	}, nil
-}
-
 func attachmentsToActorAttributes(attachments []Attachment) []*models.ActorAttribute {
 	return algorithms.Map(
 		algorithms.Filter(
@@ -236,12 +162,12 @@ func (f *RemoteStatusFetcher) Fetch(uri string) (*models.Status, error) {
 	return st, nil
 }
 
-func attachmentsToStatusAttachments(attachments []any) []*models.StatusAttachment {
-	return algorithms.Map(
-		algorithms.Map(
-			attachments,
-			mapFromAny,
-		),
-		objToStatusAttachment,
-	)
-}
+// func attachmentsToStatusAttachments(attachments []any) []*models.StatusAttachment {
+// 	return algorithms.Map(
+// 		algorithms.Map(
+// 			attachments,
+// 			mapFromAny,
+// 		),
+// 		objToStatusAttachment,
+// 	)
+// }

activitypub/inbox.go

@@ -144,50 +144,18 @@ func (i *inboxProcessor) processUndoFollow(body map[string]any) error {
 }
 
 func (i *inboxProcessor) processAnnounce(act *Activity) error {
-	target := stringFromAny(act.Object)
-	original, err := models.NewStatuses(i.db).FindOrCreateByURI(target)
-	if err != nil {
-		return err
-	}
-	actor, err := models.NewActors(i.db).FindOrCreateByURI(stringFromAny(act.Actor))
-	if err != nil {
-		return err
-	}
-
 	var buf bytes.Buffer
 	if err := json.MarshalFull(&buf, act); err != nil {
 		return err
 	}
-
 	var props map[string]any
 	if err := json.UnmarshalFull(&buf, &props); err != nil {
 		return err
 	}
 	obj := &models.Object{
 		Properties: props,
 	}
-	if err := i.db.Create(&obj).Error; err != nil {
-		return err
-	}
-
-	updatedAt := act.Updated
-	if updatedAt.IsZero() {
-		updatedAt = obj.ID.ToTime()
-	}
-
-	status := &models.Status{
-		ObjectID:  obj.ID,
-		UpdatedAt: updatedAt,
-		ActorID:   actor.ObjectID,
-		Actor:     actor,
-		Conversation: &models.Conversation{
-			Visibility: "public",
-		},
-		Visibility: "public",
-		ReblogID:   &original.ObjectID,
-	}
-
-	return i.db.Save(status).Error
+	return i.db.Create(&obj).Error
 }
 
 func (i *inboxProcessor) processAdd(act *Activity) error {
@@ -261,14 +229,6 @@ func (i *inboxProcessor) processCreate(create map[string]any) error {
 		return err
 	}
 	return nil
-
-	// typ := stringFromAny(create["type"])
-	// switch typ {
-	// case "Note", "Question":
-	// 	return i.processCreateNote(create)
-	// default:
-	// 	return fmt.Errorf("unknown create object type: %q", typ)
-	// }
 }
 
 func (i *inboxProcessor) processCreateNote(create map[string]any) error {
@@ -378,20 +338,20 @@ func inReplyToActorID(inReplyTo *models.Status) *snowflake.ID {
 	return nil
 }
 
-func objToStatusAttachment(obj map[string]any) *models.StatusAttachment {
-	return &models.StatusAttachment{
-		Attachment: models.Attachment{
-			ID:         snowflake.Now(),
-			MediaType:  stringFromAny(obj["mediaType"]),
-			URL:        stringFromAny(obj["url"]),
-			Name:       stringFromAny(obj["name"]),
-			Width:      intFromAny(obj["width"]),
-			Height:     intFromAny(obj["height"]),
-			Blurhash:   stringFromAny(obj["blurhash"]),
-			FocalPoint: focalPoint(obj),
-		},
-	}
-}
+// func objToStatusAttachment(obj map[string]any) *models.StatusAttachment {
+// 	return &models.StatusAttachment{
+// 		Attachment: models.Attachment{
+// 			ID:         snowflake.Now(),
+// 			MediaType:  stringFromAny(obj["mediaType"]),
+// 			URL:        stringFromAny(obj["url"]),
+// 			Name:       stringFromAny(obj["name"]),
+// 			Width:      intFromAny(obj["width"]),
+// 			Height:     intFromAny(obj["height"]),
+// 			Blurhash:   stringFromAny(obj["blurhash"]),
+// 			FocalPoint: focalPoint(obj),
+// 		},
+// 	}
+// }
 
 func focalPoint(obj map[string]any) models.FocalPoint {
 	focalPoint := anyToSlice(obj["focalPoint"])

activitypub/users.go

@@ -108,7 +108,7 @@ func UsersShow(env *Env, w http.ResponseWriter, r *http.Request) error {
 		"icon": map[string]any{
 			"type":      "Image",
 			"mediaType": "image/jpeg",
-			"url":       actor.Avatar(),
+			"url":       "https://media.hachyderm.io/accounts/headers/109/364/117/028/564/263/original/c6b5edf498087717.jpeg",
 		},
 	})
 }

fetchactor.go

@@ -3,13 +3,9 @@ package main
 import (
 	"context"
 	"fmt"
-	"net/http"
-	"os"
 
 	"github.com/davecheney/pub/activitypub"
-	"github.com/davecheney/pub/mastodon"
 	"github.com/davecheney/pub/models"
-	"github.com/go-json-experiment/json"
 	"gorm.io/gorm"
 )
 
@@ -33,38 +29,14 @@ func (f *FetchActorCmd) Run(ctx *Context) error {
 		return fmt.Errorf("failed to find account: %w", err)
 	}
 
-	orig, err := models.NewActors(db).FindByURI(f.Actor)
+	var props map[string]any
+	client, err := activitypub.NewClient(account)
 	if err != nil {
-		return fmt.Errorf("failed to find actor: %w", err)
+		return fmt.Errorf("failed to create client: %w", err)
 	}
-
-	updated, err := activitypub.NewRemoteActorFetcher(account).Fetch(context.Background(), f.Actor)
-	if err != nil {
+	if err := client.Fetch(context.Background(), f.Actor, &props); err != nil {
 		return fmt.Errorf("failed to fetch actor: %w", err)
 	}
 
-	if !orig.ObjectID.ToTime().Equal(updated.ObjectID.ToTime()) {
-		return fmt.Errorf("actor ID changed from %v to %v", orig.ObjectID, updated.ObjectID)
-	}
-
-	// RemoteActorFetcher.Fetch will have created a new snowflake ID for the updated record
-	// even if the created-at date has not changed because of the random component of the ID.
-	// We need to update the ID to match the original record.
-	updated.ObjectID = orig.ObjectID
-
-	req, _ := http.NewRequest("GET", updated.URI(), nil)
-	ser := mastodon.NewSerialiser(req)
-	json.MarshalFull(os.Stdout, map[string]any{
-		"original": ser.Account(orig),
-		"updated":  ser.Account(updated),
-	})
-
-	return db.Transaction(func(tx *gorm.DB) error {
-		// delete actor attributes
-		if err := tx.Where("actor_id = ?", orig.ObjectID).Delete(&models.ActorAttribute{}).Error; err != nil {
-			return err
-		}
-		// save updated actor
-		return tx.Session(&gorm.Session{FullSaveAssociations: true}).Updates(updated).Error
-	})
+	return db.Create(&models.Object{Properties: props}).Error
 }

main.go

@@ -33,6 +33,7 @@ var cli struct {
 	Serve                ServeCmd                `cmd:"" help:"Serve a local web server."`
 	ShowActor            ShowActorCmd            `cmd:"" help:"Display an actor."`
 	SynchroniseFollowers SynchroniseFollowersCmd `cmd:"" help:"Synchronise followers."`
+	RerunObjectHooks     RerunObjectHooksCmd     `cmd:"" help:"Rerun object hooks."`
 	Follow               FollowCmd               `cmd:"" help:"Follow an object."`
 }
 

mastodon/accounts.go

@@ -17,7 +17,7 @@ func AccountsShow(env *Env, w http.ResponseWriter, r *http.Request) error {
 		return err
 	}
 	var actor models.Actor
-	if err := env.DB.Scopes(models.PreloadActor).Take(&actor, "id = ? ", chi.URLParam(r, "id")).Error; err != nil {
+	if err := env.DB.Scopes(models.PreloadActor).Take(&actor, "object_id = ? ", chi.URLParam(r, "id")).Error; err != nil {
 		return httpx.Error(http.StatusNotFound, err)
 	}
 	serialise := Serialiser{req: r}
@@ -47,8 +47,8 @@ func AccountsStatusesShow(env *Env, w http.ResponseWriter, r *http.Request) erro
 		models.MaybeExcludeReblogs(r),
 		models.MaybePinned(r),
 	)
-	query = query.Preload("Reaction", &models.Reaction{ActorID: user.Actor.ObjectID}) // reactions
-	query = query.Preload("Reblog.Reaction", &models.Reaction{ActorID: user.Actor.ObjectID})
+	query = query.Preload("Reaction", &models.Reaction{ActorID: user.Actor.ObjectID}).Preload("Reaction.Actor").Preload("Reaction.Actor.Object") // reactions
+	query = query.Preload("Reblog.Reaction", &models.Reaction{ActorID: user.Actor.ObjectID}).Preload("Reblog.Reaction.Actor").Preload("Reblog.Reaction.Actor.Object")
 	if err := query.Where("statuses.actor_id = ?", chi.URLParam(r, "id")).Find(&statuses).Error; err != nil {
 		return err
 	}
@@ -69,7 +69,7 @@ func AccountsFollowersShow(env *Env, w http.ResponseWriter, r *http.Request) err
 	}
 
 	var followers []*models.Relationship
-	if err := env.DB.Scopes(models.PaginateRelationship(r)).Preload("Target").Where("actor_id = ? and followed_by = true", chi.URLParam(r, "id")).Find(&followers).Error; err != nil {
+	if err := env.DB.Scopes(models.PaginateRelationship(r), models.PreloadRelationshipTarget).Where("actor_id = ? and followed_by = true", chi.URLParam(r, "id")).Find(&followers).Error; err != nil {
 		return err
 	}
 
@@ -90,7 +90,7 @@ func AccountsFollowingShow(env *Env, w http.ResponseWriter, r *http.Request) err
 		return err
 	}
 	var following []*models.Relationship
-	if err := env.DB.Scopes(models.PaginateRelationship(r)).Preload("Target").Preload("Target.Attributes").Where("actor_id = ? and following = true", chi.URLParam(r, "id")).Find(&following).Error; err != nil {
+	if err := env.DB.Scopes(models.PaginateRelationship(r), models.PreloadRelationshipTarget).Where("actor_id = ? and following = true", chi.URLParam(r, "id")).Find(&following).Error; err != nil {
 		return err
 	}
 
@@ -166,7 +166,7 @@ func AccountsFamiliarFollowersShow(env *Env, w http.ResponseWriter, req *http.Re
 		}
 		followers := env.DB.Select("target_id").Where("actor_id = ? and following = true", id).Table("relationships")
 		var commonFollowers []*models.Relationship
-		if err := env.DB.Preload("Target").Preload("Target.Attributes").Where("actor_id = ? and following = true and target_id in (?)", user.Actor.ObjectID, followers).Find(&commonFollowers).Error; err != nil {
+		if err := env.DB.Scopes(models.PreloadRelationshipTarget).Where("actor_id = ? and following = true and target_id in (?)", user.Actor.ObjectID, followers).Find(&commonFollowers).Error; err != nil {
 			return httpx.Error(http.StatusInternalServerError, err)
 		}
 		resp = append(resp, FamiliarFollowers{

mastodon/conversations.go

@@ -1,7 +1,6 @@
 package mastodon
 
 import (
-	"fmt"
 	"net/http"
 
 	"github.com/davecheney/pub/internal/algorithms"
@@ -16,21 +15,20 @@ func ConversationsIndex(env *Env, w http.ResponseWriter, r *http.Request) error
 	}
 
 	var statuses []*models.Status
-	scope := env.DB.Scopes(models.PaginateConversation(r)).Where("visibility = ?", "direct")
+	query := env.DB.Scopes(models.PaginateConversation(r), models.PreloadStatus).Where("visibility = ?", "direct")
 	switch r.URL.Query().Get("local") {
 	case "":
-		scope = scope.Joins("Actor")
+		// nothing
 	default:
-		scope = scope.Joins("Actor").Where("Actor.domain = ?", r.Host)
+		query = query.Where("Actor.domain = ?", r.Host)
 	}
-
-	if err := scope.Order("statuses.id desc").Find(&statuses).Error; err != nil {
+	if err := query.Order("statuses.object_id desc").Find(&statuses).Error; err != nil {
 		return err
 	}
-
 	if len(statuses) > 0 {
-		w.Header().Set("Link", fmt.Sprintf("<https://%s/api/v1/timelines/public?max_id=%d>; rel=\"next\", <https://%s/api/v1/timelines/public?min_id=%d>; rel=\"prev\"", r.Host, statuses[len(statuses)-1].ObjectID, r.Host, statuses[0].ObjectID))
+		linkHeader(w, r, statuses[0].ObjectID, statuses[len(statuses)-1].ObjectID)
 	}
+
 	serialise := Serialiser{req: r}
 	return to.JSON(w, algorithms.Map(statuses, serialise.Status))
 }