Pg to bun (#148)

* start moving to bun

* changing more stuff

* more

* and yet more

* tests passing

* seems stable now

* more big changes

* small fix

* little fixes

7 files changed, 44 insertions, 36 deletions

diff --git a/internal/processing/admin/admin.go b/internal/processing/admin/admin.go
index fd63d8a10..de288811b 100644
--- a/internal/processing/admin/admin.go
+++ b/internal/processing/admin/admin.go
@@ -19,6 +19,7 @@
 package admin
 
 import (
+	"context"
 	"mime/multipart"
 
 	"github.com/sirupsen/logrus"
@@ -33,12 +34,12 @@ import (
 
 // Processor wraps a bunch of functions for processing admin actions.
 type Processor interface {
-	DomainBlockCreate(account *gtsmodel.Account, domain string, obfuscate bool, publicComment string, privateComment string, subscriptionID string) (*apimodel.DomainBlock, gtserror.WithCode)
-	DomainBlocksImport(account *gtsmodel.Account, domains *multipart.FileHeader) ([]*apimodel.DomainBlock, gtserror.WithCode)
-	DomainBlocksGet(account *gtsmodel.Account, export bool) ([]*apimodel.DomainBlock, gtserror.WithCode)
-	DomainBlockGet(account *gtsmodel.Account, id string, export bool) (*apimodel.DomainBlock, gtserror.WithCode)
-	DomainBlockDelete(account *gtsmodel.Account, id string) (*apimodel.DomainBlock, gtserror.WithCode)
-	EmojiCreate(account *gtsmodel.Account, user *gtsmodel.User, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error)
+	DomainBlockCreate(ctx context.Context, account *gtsmodel.Account, domain string, obfuscate bool, publicComment string, privateComment string, subscriptionID string) (*apimodel.DomainBlock, gtserror.WithCode)
+	DomainBlocksImport(ctx context.Context, account *gtsmodel.Account, domains *multipart.FileHeader) ([]*apimodel.DomainBlock, gtserror.WithCode)
+	DomainBlocksGet(ctx context.Context, account *gtsmodel.Account, export bool) ([]*apimodel.DomainBlock, gtserror.WithCode)
+	DomainBlockGet(ctx context.Context, account *gtsmodel.Account, id string, export bool) (*apimodel.DomainBlock, gtserror.WithCode)
+	DomainBlockDelete(ctx context.Context, account *gtsmodel.Account, id string) (*apimodel.DomainBlock, gtserror.WithCode)
+	EmojiCreate(ctx context.Context, account *gtsmodel.Account, user *gtsmodel.User, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error)
 }
 
 type processor struct {
diff --git a/internal/processing/admin/createdomainblock.go b/internal/processing/admin/createdomainblock.go
index 624f632dc..a34c03a44 100644
--- a/internal/processing/admin/createdomainblock.go
+++ b/internal/processing/admin/createdomainblock.go
@@ -19,6 +19,7 @@
 package admin
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -31,10 +32,10 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/text"
 )
 
-func (p *processor) DomainBlockCreate(account *gtsmodel.Account, domain string, obfuscate bool, publicComment string, privateComment string, subscriptionID string) (*apimodel.DomainBlock, gtserror.WithCode) {
+func (p *processor) DomainBlockCreate(ctx context.Context, account *gtsmodel.Account, domain string, obfuscate bool, publicComment string, privateComment string, subscriptionID string) (*apimodel.DomainBlock, gtserror.WithCode) {
 	// first check if we already have a block -- if err == nil we already had a block so we can skip a whole lot of work
 	domainBlock := &gtsmodel.DomainBlock{}
-	err := p.db.GetWhere([]db.Where{{Key: "domain", Value: domain, CaseInsensitive: true}}, domainBlock)
+	err := p.db.GetWhere(ctx, []db.Where{{Key: "domain", Value: domain, CaseInsensitive: true}}, domainBlock)
 	if err != nil {
 		if err != db.ErrNoEntries {
 			// something went wrong in the DB
@@ -59,7 +60,7 @@ func (p *processor) DomainBlockCreate(account *gtsmodel.Account, domain string,
 		}
 
 		// put the new block in the database
-		if err := p.db.Put(domainBlock); err != nil {
+		if err := p.db.Put(ctx, domainBlock); err != nil {
 			if err != db.ErrNoEntries {
 				// there's a real error creating the block
 				return nil, gtserror.NewErrorInternalError(fmt.Errorf("DomainBlockCreate: db error putting new domain block %s: %s", domain, err))
@@ -67,10 +68,10 @@ func (p *processor) DomainBlockCreate(account *gtsmodel.Account, domain string,
 		}
 
 		// process the side effects of the domain block asynchronously since it might take a while
-		go p.initiateDomainBlockSideEffects(account, domainBlock) // TODO: add this to a queuing system so it can retry/resume
+		go p.initiateDomainBlockSideEffects(ctx, account, domainBlock) // TODO: add this to a queuing system so it can retry/resume
 	}
 
-	mastoDomainBlock, err := p.tc.DomainBlockToMasto(domainBlock, false)
+	mastoDomainBlock, err := p.tc.DomainBlockToMasto(ctx, domainBlock, false)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("DomainBlockCreate: error converting domain block to frontend/masto representation %s: %s", domain, err))
 	}
@@ -83,7 +84,7 @@ func (p *processor) DomainBlockCreate(account *gtsmodel.Account, domain string,
 // 1. Strip most info away from the instance entry for the domain.
 // 2. Delete the instance account for that instance if it exists.
 // 3. Select all accounts from this instance and pass them through the delete functionality of the processor.
-func (p *processor) initiateDomainBlockSideEffects(account *gtsmodel.Account, block *gtsmodel.DomainBlock) {
+func (p *processor) initiateDomainBlockSideEffects(ctx context.Context, account *gtsmodel.Account, block *gtsmodel.DomainBlock) {
 	l := p.log.WithFields(logrus.Fields{
 		"func":   "domainBlockProcessSideEffects",
 		"domain": block.Domain,
@@ -93,7 +94,7 @@ func (p *processor) initiateDomainBlockSideEffects(account *gtsmodel.Account, bl
 
 	// if we have an instance entry for this domain, update it with the new block ID and clear all fields
 	instance := &gtsmodel.Instance{}
-	if err := p.db.GetWhere([]db.Where{{Key: "domain", Value: block.Domain, CaseInsensitive: true}}, instance); err == nil {
+	if err := p.db.GetWhere(ctx, []db.Where{{Key: "domain", Value: block.Domain, CaseInsensitive: true}}, instance); err == nil {
 		instance.Title = ""
 		instance.UpdatedAt = time.Now()
 		instance.SuspendedAt = time.Now()
@@ -105,14 +106,14 @@ func (p *processor) initiateDomainBlockSideEffects(account *gtsmodel.Account, bl
 		instance.ContactAccountUsername = ""
 		instance.ContactAccountID = ""
 		instance.Version = ""
-		if err := p.db.UpdateByID(instance.ID, instance); err != nil {
+		if err := p.db.UpdateByID(ctx, instance.ID, instance); err != nil {
 			l.Errorf("domainBlockProcessSideEffects: db error updating instance: %s", err)
 		}
 		l.Debug("domainBlockProcessSideEffects: instance entry updated")
 	}
 
 	// if we have an instance account for this instance, delete it
-	if err := p.db.DeleteWhere([]db.Where{{Key: "username", Value: block.Domain, CaseInsensitive: true}}, &gtsmodel.Account{}); err != nil {
+	if err := p.db.DeleteWhere(ctx, []db.Where{{Key: "username", Value: block.Domain, CaseInsensitive: true}}, &gtsmodel.Account{}); err != nil {
 		l.Errorf("domainBlockProcessSideEffects: db error removing instance account: %s", err)
 	}
 
@@ -123,7 +124,7 @@ func (p *processor) initiateDomainBlockSideEffects(account *gtsmodel.Account, bl
 
 selectAccountsLoop:
 	for {
-		accounts, err := p.db.GetInstanceAccounts(block.Domain, maxID, limit)
+		accounts, err := p.db.GetInstanceAccounts(ctx, block.Domain, maxID, limit)
 		if err != nil {
 			if err == db.ErrNoEntries {
 				// no accounts left for this instance so we're done
diff --git a/internal/processing/admin/deletedomainblock.go b/internal/processing/admin/deletedomainblock.go
index edb0a58f9..2563b557d 100644
--- a/internal/processing/admin/deletedomainblock.go
+++ b/internal/processing/admin/deletedomainblock.go
@@ -19,6 +19,7 @@
 package admin
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -28,10 +29,10 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 )
 
-func (p *processor) DomainBlockDelete(account *gtsmodel.Account, id string) (*apimodel.DomainBlock, gtserror.WithCode) {
+func (p *processor) DomainBlockDelete(ctx context.Context, account *gtsmodel.Account, id string) (*apimodel.DomainBlock, gtserror.WithCode) {
 	domainBlock := &gtsmodel.DomainBlock{}
 
-	if err := p.db.GetByID(id, domainBlock); err != nil {
+	if err := p.db.GetByID(ctx, id, domainBlock); err != nil {
 		if err != db.ErrNoEntries {
 			// something has gone really wrong
 			return nil, gtserror.NewErrorInternalError(err)
@@ -41,39 +42,39 @@ func (p *processor) DomainBlockDelete(account *gtsmodel.Account, id string) (*ap
 	}
 
 	// prepare the domain block to return
-	mastoDomainBlock, err := p.tc.DomainBlockToMasto(domainBlock, false)
+	mastoDomainBlock, err := p.tc.DomainBlockToMasto(ctx, domainBlock, false)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(err)
 	}
 
 	// delete the domain block
-	if err := p.db.DeleteByID(id, domainBlock); err != nil {
+	if err := p.db.DeleteByID(ctx, id, domainBlock); err != nil {
 		return nil, gtserror.NewErrorInternalError(err)
 	}
 
 	// remove the domain block reference from the instance, if we have an entry for it
 	i := &gtsmodel.Instance{}
-	if err := p.db.GetWhere([]db.Where{
+	if err := p.db.GetWhere(ctx, []db.Where{
 		{Key: "domain", Value: domainBlock.Domain, CaseInsensitive: true},
 		{Key: "domain_block_id", Value: id},
 	}, i); err == nil {
 		i.SuspendedAt = time.Time{}
 		i.DomainBlockID = ""
-		if err := p.db.UpdateByID(i.ID, i); err != nil {
+		if err := p.db.UpdateByID(ctx, i.ID, i); err != nil {
 			return nil, gtserror.NewErrorInternalError(fmt.Errorf("couldn't update database entry for instance %s: %s", domainBlock.Domain, err))
 		}
 	}
 
 	// unsuspend all accounts whose suspension origin was this domain block
 	// 1. remove the 'suspended_at' entry from their accounts
-	if err := p.db.UpdateWhere([]db.Where{
+	if err := p.db.UpdateWhere(ctx, []db.Where{
 		{Key: "suspension_origin", Value: domainBlock.ID},
 	}, "suspended_at", nil, &[]*gtsmodel.Account{}); err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("database error removing suspended_at from accounts: %s", err))
 	}
 
 	// 2. remove the 'suspension_origin' entry from their accounts
-	if err := p.db.UpdateWhere([]db.Where{
+	if err := p.db.UpdateWhere(ctx, []db.Where{
 		{Key: "suspension_origin", Value: domainBlock.ID},
 	}, "suspension_origin", nil, &[]*gtsmodel.Account{}); err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("database error removing suspension_origin from accounts: %s", err))
diff --git a/internal/processing/admin/emoji.go b/internal/processing/admin/emoji.go
index f19e173b5..f56bde8e0 100644
--- a/internal/processing/admin/emoji.go
+++ b/internal/processing/admin/emoji.go
@@ -20,6 +20,7 @@ package admin
 
 import (
 	"bytes"
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -29,7 +30,7 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/id"
 )
 
-func (p *processor) EmojiCreate(account *gtsmodel.Account, user *gtsmodel.User, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error) {
+func (p *processor) EmojiCreate(ctx context.Context, account *gtsmodel.Account, user *gtsmodel.User, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error) {
 	if user.Admin {
 		return nil, fmt.Errorf("user %s not an admin", user.ID)
 	}
@@ -49,7 +50,7 @@ func (p *processor) EmojiCreate(account *gtsmodel.Account, user *gtsmodel.User,
 	}
 
 	// allow the mediaHandler to work its magic of processing the emoji bytes, and putting them in whatever storage backend we're using
-	emoji, err := p.mediaHandler.ProcessLocalEmoji(buf.Bytes(), form.Shortcode)
+	emoji, err := p.mediaHandler.ProcessLocalEmoji(ctx, buf.Bytes(), form.Shortcode)
 	if err != nil {
 		return nil, fmt.Errorf("error reading emoji: %s", err)
 	}
@@ -60,12 +61,12 @@ func (p *processor) EmojiCreate(account *gtsmodel.Account, user *gtsmodel.User,
 	}
 	emoji.ID = emojiID
 
-	mastoEmoji, err := p.tc.EmojiToMasto(emoji)
+	mastoEmoji, err := p.tc.EmojiToMasto(ctx, emoji)
 	if err != nil {
 		return nil, fmt.Errorf("error converting emoji to mastotype: %s", err)
 	}
 
-	if err := p.db.Put(emoji); err != nil {
+	if err := p.db.Put(ctx, emoji); err != nil {
 		return nil, fmt.Errorf("database error while processing emoji: %s", err)
 	}
 
diff --git a/internal/processing/admin/getdomainblock.go b/internal/processing/admin/getdomainblock.go
index f74010627..19bc9fe09 100644
--- a/internal/processing/admin/getdomainblock.go
+++ b/internal/processing/admin/getdomainblock.go
@@ -19,6 +19,7 @@
 package admin
 
 import (
+	"context"
 	"fmt"
 
 	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
@@ -27,10 +28,10 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 )
 
-func (p *processor) DomainBlockGet(account *gtsmodel.Account, id string, export bool) (*apimodel.DomainBlock, gtserror.WithCode) {
+func (p *processor) DomainBlockGet(ctx context.Context, account *gtsmodel.Account, id string, export bool) (*apimodel.DomainBlock, gtserror.WithCode) {
 	domainBlock := &gtsmodel.DomainBlock{}
 
-	if err := p.db.GetByID(id, domainBlock); err != nil {
+	if err := p.db.GetByID(ctx, id, domainBlock); err != nil {
 		if err != db.ErrNoEntries {
 			// something has gone really wrong
 			return nil, gtserror.NewErrorInternalError(err)
@@ -39,7 +40,7 @@ func (p *processor) DomainBlockGet(account *gtsmodel.Account, id string, export
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("no entry for ID %s", id))
 	}
 
-	mastoDomainBlock, err := p.tc.DomainBlockToMasto(domainBlock, export)
+	mastoDomainBlock, err := p.tc.DomainBlockToMasto(ctx, domainBlock, export)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(err)
 	}
diff --git a/internal/processing/admin/getdomainblocks.go b/internal/processing/admin/getdomainblocks.go
index f827d03fc..0ec33cfff 100644
--- a/internal/processing/admin/getdomainblocks.go
+++ b/internal/processing/admin/getdomainblocks.go
@@ -19,16 +19,18 @@
 package admin
 
 import (
+	"context"
+
 	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
 	"github.com/superseriousbusiness/gotosocial/internal/db"
 	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 )
 
-func (p *processor) DomainBlocksGet(account *gtsmodel.Account, export bool) ([]*apimodel.DomainBlock, gtserror.WithCode) {
+func (p *processor) DomainBlocksGet(ctx context.Context, account *gtsmodel.Account, export bool) ([]*apimodel.DomainBlock, gtserror.WithCode) {
 	domainBlocks := []*gtsmodel.DomainBlock{}
 
-	if err := p.db.GetAll(&domainBlocks); err != nil {
+	if err := p.db.GetAll(ctx, &domainBlocks); err != nil {
 		if err != db.ErrNoEntries {
 			// something has gone really wrong
 			return nil, gtserror.NewErrorInternalError(err)
@@ -37,7 +39,7 @@ func (p *processor) DomainBlocksGet(account *gtsmodel.Account, export bool) ([]*
 
 	mastoDomainBlocks := []*apimodel.DomainBlock{}
 	for _, b := range domainBlocks {
-		mastoDomainBlock, err := p.tc.DomainBlockToMasto(b, export)
+		mastoDomainBlock, err := p.tc.DomainBlockToMasto(ctx, b, export)
 		if err != nil {
 			return nil, gtserror.NewErrorInternalError(err)
 		}
diff --git a/internal/processing/admin/importdomainblocks.go b/internal/processing/admin/importdomainblocks.go
index ab171b712..66326bd62 100644
--- a/internal/processing/admin/importdomainblocks.go
+++ b/internal/processing/admin/importdomainblocks.go
@@ -20,6 +20,7 @@ package admin
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -32,7 +33,7 @@ import (
 )
 
 // DomainBlocksImport handles the import of a bunch of domain blocks at once, by calling the DomainBlockCreate function for each domain in the provided file.
-func (p *processor) DomainBlocksImport(account *gtsmodel.Account, domains *multipart.FileHeader) ([]*apimodel.DomainBlock, gtserror.WithCode) {
+func (p *processor) DomainBlocksImport(ctx context.Context, account *gtsmodel.Account, domains *multipart.FileHeader) ([]*apimodel.DomainBlock, gtserror.WithCode) {
 
 	f, err := domains.Open()
 	if err != nil {
@@ -54,7 +55,7 @@ func (p *processor) DomainBlocksImport(account *gtsmodel.Account, domains *multi
 
 	blocks := []*apimodel.DomainBlock{}
 	for _, d := range d {
-		block, err := p.DomainBlockCreate(account, d.Domain, false, d.PublicComment, "", "")
+		block, err := p.DomainBlockCreate(ctx, account, d.Domain, false, d.PublicComment, "", "")
 
 		if err != nil {
 			return nil, err