add withcontxt to all db calls

internal/db/db.go

···
 package db
 
 import (
+	"context"
 	"sync"
 
 	"gorm.io/gorm"
···
 	}
 }
 
-func (db *DB) Create(value any, clauses []clause.Expression) *gorm.DB {
+func (db *DB) Create(ctx context.Context, value any, clauses []clause.Expression) *gorm.DB {
 	db.mu.Lock()
 	defer db.mu.Unlock()
-	return db.cli.Clauses(clauses...).Create(value)
+	return db.cli.WithContext(ctx).Clauses(clauses...).Create(value)
 }
 
-func (db *DB) Save(value any, clauses []clause.Expression) *gorm.DB {
+func (db *DB) Save(ctx context.Context, value any, clauses []clause.Expression) *gorm.DB {
 	db.mu.Lock()
 	defer db.mu.Unlock()
-	return db.cli.Clauses(clauses...).Save(value)
+	return db.cli.WithContext(ctx).Clauses(clauses...).Save(value)
 }
 
-func (db *DB) Exec(sql string, clauses []clause.Expression, values ...any) *gorm.DB {
+func (db *DB) Exec(ctx context.Context, sql string, clauses []clause.Expression, values ...any) *gorm.DB {
 	db.mu.Lock()
 	defer db.mu.Unlock()
-	return db.cli.Clauses(clauses...).Exec(sql, values...)
+	return db.cli.WithContext(ctx).Clauses(clauses...).Exec(sql, values...)
 }
 
-func (db *DB) Raw(sql string, clauses []clause.Expression, values ...any) *gorm.DB {
-	return db.cli.Clauses(clauses...).Raw(sql, values...)
+func (db *DB) Raw(ctx context.Context, sql string, clauses []clause.Expression, values ...any) *gorm.DB {
+	return db.cli.WithContext(ctx).Clauses(clauses...).Raw(sql, values...)
 }
 
 func (db *DB) AutoMigrate(models ...any) error {
 	return db.cli.AutoMigrate(models...)
 }
 
-func (db *DB) Delete(value any, clauses []clause.Expression) *gorm.DB {
+func (db *DB) Delete(ctx context.Context, value any, clauses []clause.Expression) *gorm.DB {
 	db.mu.Lock()
 	defer db.mu.Unlock()
-	return db.cli.Clauses(clauses...).Delete(value)
+	return db.cli.WithContext(ctx).Clauses(clauses...).Delete(value)
 }
 
-func (db *DB) First(dest any, conds ...any) *gorm.DB {
-	return db.cli.First(dest, conds...)
+func (db *DB) First(ctx context.Context, dest any, conds ...any) *gorm.DB {
+	return db.cli.WithContext(ctx).First(dest, conds...)
 }
 
 // TODO: this isn't actually good. we can commit even if the db is locked here. this is probably okay for the time being, but need to figure
 // out a better solution. right now we only do this whenever we're importing a repo though so i'm mostly not worried, but it's still bad.
 // e.g. when we do apply writes we should also be using a transcation but we don't right now
-func (db *DB) BeginDangerously() *gorm.DB {
-	return db.cli.Begin()
+func (db *DB) BeginDangerously(ctx context.Context) *gorm.DB {
+	return db.cli.WithContext(ctx).Begin()
 }
 
 func (db *DB) Lock() {

server/common.go

···
 package server
 
 import (
+	"context"
+
 	"github.com/haileyok/cocoon/models"
 )
 
-func (s *Server) getActorByHandle(handle string) (*models.Actor, error) {
+func (s *Server) getActorByHandle(ctx context.Context, handle string) (*models.Actor, error) {
 	var actor models.Actor
-	if err := s.db.First(&actor, models.Actor{Handle: handle}).Error; err != nil {
+	if err := s.db.First(ctx, &actor, models.Actor{Handle: handle}).Error; err != nil {
 		return nil, err
 	}
 	return &actor, nil
 }
 
-func (s *Server) getRepoByEmail(email string) (*models.Repo, error) {
+func (s *Server) getRepoByEmail(ctx context.Context, email string) (*models.Repo, error) {
 	var repo models.Repo
-	if err := s.db.First(&repo, models.Repo{Email: email}).Error; err != nil {
+	if err := s.db.First(ctx, &repo, models.Repo{Email: email}).Error; err != nil {
 		return nil, err
 	}
 	return &repo, nil
 }
 
-func (s *Server) getRepoActorByEmail(email string) (*models.RepoActor, error) {
+func (s *Server) getRepoActorByEmail(ctx context.Context, email string) (*models.RepoActor, error) {
 	var repo models.RepoActor
-	if err := s.db.Raw("SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.email= ?", nil, email).Scan(&repo).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.email= ?", nil, email).Scan(&repo).Error; err != nil {
 		return nil, err
 	}
 	return &repo, nil
 }
 
-func (s *Server) getRepoActorByDid(did string) (*models.RepoActor, error) {
+func (s *Server) getRepoActorByDid(ctx context.Context, did string) (*models.RepoActor, error) {
 	var repo models.RepoActor
-	if err := s.db.Raw("SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.did = ?", nil, did).Scan(&repo).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.did = ?", nil, did).Scan(&repo).Error; err != nil {
 		return nil, err
 	}
 	return &repo, nil

server/handle_account.go

···
 
 func (s *Server) handleAccount(e echo.Context) error {
 	ctx := e.Request().Context()
+
 	repo, sess, err := s.getSessionRepoOrErr(e)
 	if err != nil {
 		return e.Redirect(303, "/account/signin")
···
 	oldestPossibleSession := time.Now().Add(constants.ConfidentialClientSessionLifetime)
 
 	var tokens []provider.OauthToken
-	if err := s.db.Raw("SELECT * FROM oauth_tokens WHERE sub = ? AND created_at < ? ORDER BY created_at ASC", nil, repo.Repo.Did, oldestPossibleSession).Scan(&tokens).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM oauth_tokens WHERE sub = ? AND created_at < ? ORDER BY created_at ASC", nil, repo.Repo.Did, oldestPossibleSession).Scan(&tokens).Error; err != nil {
 		s.logger.Error("couldnt fetch oauth sessions for account", "did", repo.Repo.Did, "error", err)
 		sess.AddFlash("Unable to fetch sessions. See server logs for more details.", "error")
 		sess.Save(e.Request(), e.Response())

server/handle_account_revoke.go

···
 	"github.com/labstack/echo/v4"
 )
 
-type AccountRevokeRequest struct {
+type AccountRevokeInput struct {
 	Token string `form:"token"`
 }
 
 func (s *Server) handleAccountRevoke(e echo.Context) error {
-	var req AccountRevokeRequest
+	ctx := e.Request().Context()
+
+	var req AccountRevokeInput
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("could not bind account revoke request", "error", err)
 		return helpers.ServerError(e, nil)
···
 		return e.Redirect(303, "/account/signin")
 	}
 
-	if err := s.db.Exec("DELETE FROM oauth_tokens WHERE sub = ? AND token = ?", nil, repo.Repo.Did, req.Token).Error; err != nil {
+	if err := s.db.Exec(ctx, "DELETE FROM oauth_tokens WHERE sub = ? AND token = ?", nil, repo.Repo.Did, req.Token).Error; err != nil {
 		s.logger.Error("couldnt delete oauth session for account", "did", repo.Repo.Did, "token", req.Token, "error", err)
 		sess.AddFlash("Unable to revoke session. See server logs for more details.", "error")
 		sess.Save(e.Request(), e.Response())

server/handle_account_signin.go

···
 	"gorm.io/gorm"
 )
 
-type OauthSigninRequest struct {
+type OauthSigninInput struct {
 	Username    string `form:"username"`
 	Password    string `form:"password"`
 	QueryParams string `form:"query_params"`
 }
 
 func (s *Server) getSessionRepoOrErr(e echo.Context) (*models.RepoActor, *sessions.Session, error) {
+	ctx := e.Request().Context()
+
 	sess, err := session.Get("session", e)
 	if err != nil {
 		return nil, nil, err
···
 		return nil, sess, errors.New("did was not set in session")
 	}
 
-	repo, err := s.getRepoActorByDid(did)
+	repo, err := s.getRepoActorByDid(ctx, did)
 	if err != nil {
 		return nil, sess, err
 	}
···
 }
 
 func (s *Server) handleAccountSigninPost(e echo.Context) error {
-	var req OauthSigninRequest
+	ctx := e.Request().Context()
+
+	var req OauthSigninInput
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding sign in req", "error", err)
 		return helpers.ServerError(e, nil)
···
 	var err error
 	switch idtype {
 	case "did":
-		err = s.db.Raw("SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.did = ?", nil, req.Username).Scan(&repo).Error
+		err = s.db.Raw(ctx, "SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.did = ?", nil, req.Username).Scan(&repo).Error
 	case "handle":
-		err = s.db.Raw("SELECT r.*, a.* FROM actors a LEFT JOIN repos r ON a.did = r.did WHERE a.handle = ?", nil, req.Username).Scan(&repo).Error
+		err = s.db.Raw(ctx, "SELECT r.*, a.* FROM actors a LEFT JOIN repos r ON a.did = r.did WHERE a.handle = ?", nil, req.Username).Scan(&repo).Error
 	case "email":
-		err = s.db.Raw("SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.email = ?", nil, req.Username).Scan(&repo).Error
+		err = s.db.Raw(ctx, "SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.email = ?", nil, req.Username).Scan(&repo).Error
 	}
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {

server/handle_actor_put_preferences.go

···
 // This is kinda lame. Not great to implement app.bsky in the pds, but alas
 
 func (s *Server) handleActorPutPreferences(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	repo := e.Get("repo").(*models.RepoActor)
 
 	var prefs map[string]any
···
 		return err
 	}
 
-	if err := s.db.Exec("UPDATE repos SET preferences = ? WHERE did = ?", nil, b, repo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET preferences = ? WHERE did = ?", nil, b, repo.Repo.Did).Error; err != nil {
 		return err
 	}
 

server/handle_identity_request_plc_operation.go

···
 )
 
 func (s *Server) handleIdentityRequestPlcOperationSignature(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	code := fmt.Sprintf("%s-%s", helpers.RandomVarchar(5), helpers.RandomVarchar(5))
 	eat := time.Now().Add(10 * time.Minute).UTC()
 
-	if err := s.db.Exec("UPDATE repos SET plc_operation_code = ?, plc_operation_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET plc_operation_code = ?, plc_operation_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating user", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_identity_sign_plc_operation.go

···
 		return helpers.ServerError(e, nil)
 	}
 
-	if err := s.db.Exec("UPDATE repos SET plc_operation_code = NULL, plc_operation_code_expires_at = NULL WHERE did = ?", nil, repo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET plc_operation_code = NULL, plc_operation_code_expires_at = NULL WHERE did = ?", nil, repo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating repo", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_identity_update_handle.go

···
 		},
 	})
 
-	if err := s.db.Exec("UPDATE actors SET handle = ? WHERE did = ?", nil, req.Handle, repo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE actors SET handle = ? WHERE did = ?", nil, req.Handle, repo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating handle in db", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_import_repo.go

···
 )
 
 func (s *Server) handleRepoImportRepo(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	b, err := io.ReadAll(e.Request().Body)
···
 		return helpers.ServerError(e, nil)
 	}
 
-	tx := s.db.BeginDangerously()
+	tx := s.db.BeginDangerously(ctx)
 
 	clock := syntax.NewTIDClock(0)
 

server/handle_oauth_authorize.go

···
 )
 
 func (s *Server) handleOauthAuthorizeGet(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	reqUri := e.QueryParam("request_uri")
 	if reqUri == "" {
 		// render page for logged out dev
···
 	}
 
 	var req provider.OauthAuthorizationRequest
-	if err := s.db.Raw("SELECT * FROM oauth_authorization_requests WHERE request_id = ?", nil, reqId).Scan(&req).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM oauth_authorization_requests WHERE request_id = ?", nil, reqId).Scan(&req).Error; err != nil {
 		return helpers.ServerError(e, to.StringPtr(err.Error()))
 	}
 
···
 }
 
 func (s *Server) handleOauthAuthorizePost(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	repo, _, err := s.getSessionRepoOrErr(e)
 	if err != nil {
 		return e.Redirect(303, "/account/signin")
···
 	}
 
 	var authReq provider.OauthAuthorizationRequest
-	if err := s.db.Raw("SELECT * FROM oauth_authorization_requests WHERE request_id = ?", nil, reqId).Scan(&authReq).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM oauth_authorization_requests WHERE request_id = ?", nil, reqId).Scan(&authReq).Error; err != nil {
 		return helpers.ServerError(e, to.StringPtr(err.Error()))
 	}
 
···
 
 	code := oauth.GenerateCode()
 
-	if err := s.db.Exec("UPDATE oauth_authorization_requests SET sub = ?, code = ?, accepted = ?, ip = ? WHERE request_id = ?", nil, repo.Repo.Did, code, true, e.RealIP(), reqId).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE oauth_authorization_requests SET sub = ?, code = ?, accepted = ?, ip = ? WHERE request_id = ?", nil, repo.Repo.Did, code, true, e.RealIP(), reqId).Error; err != nil {
 		s.logger.Error("error updating authorization request", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_oauth_par.go

···
 }
 
 func (s *Server) handleOauthPar(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var parRequest provider.ParRequest
 	if err := e.Bind(&parRequest); err != nil {
 		s.logger.Error("error binding for par request", "error", err)
···
 		ExpiresAt:  eat,
 	}
 
-	if err := s.db.Create(authRequest, nil).Error; err != nil {
+	if err := s.db.Create(ctx, authRequest, nil).Error; err != nil {
 		s.logger.Error("error creating auth request in db", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_oauth_token.go

···
 }
 
 func (s *Server) handleOauthToken(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req OauthTokenRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding token request", "error", err)
···
 
 		var authReq provider.OauthAuthorizationRequest
 		// get the lil guy and delete him
-		if err := s.db.Raw("DELETE FROM oauth_authorization_requests WHERE code = ? RETURNING *", nil, *req.Code).Scan(&authReq).Error; err != nil {
+		if err := s.db.Raw(ctx, "DELETE FROM oauth_authorization_requests WHERE code = ? RETURNING *", nil, *req.Code).Scan(&authReq).Error; err != nil {
 			s.logger.Error("error finding authorization request", "error", err)
 			return helpers.ServerError(e, nil)
 		}
···
 			return helpers.InputError(e, to.StringPtr("code_challenge parameter wasn't provided"))
 		}
 
-		repo, err := s.getRepoActorByDid(*authReq.Sub)
+		repo, err := s.getRepoActorByDid(ctx, *authReq.Sub)
 		if err != nil {
 			helpers.InputError(e, to.StringPtr("unable to find actor"))
 		}
···
 			return err
 		}
 
-		if err := s.db.Create(&provider.OauthToken{
+		if err := s.db.Create(ctx, &provider.OauthToken{
 			ClientId:     authReq.ClientId,
 			ClientAuth:   *clientAuth,
 			Parameters:   authReq.Parameters,
···
 		}
 
 		var oauthToken provider.OauthToken
-		if err := s.db.Raw("SELECT * FROM oauth_tokens WHERE refresh_token = ?", nil, req.RefreshToken).Scan(&oauthToken).Error; err != nil {
+		if err := s.db.Raw(ctx, "SELECT * FROM oauth_tokens WHERE refresh_token = ?", nil, req.RefreshToken).Scan(&oauthToken).Error; err != nil {
 			s.logger.Error("error finding oauth token by refresh token", "error", err, "refresh_token", req.RefreshToken)
 			return helpers.ServerError(e, nil)
 		}
···
 			return err
 		}
 
-		if err := s.db.Exec("UPDATE oauth_tokens SET token = ?, refresh_token = ?, expires_at = ?, updated_at = ? WHERE refresh_token = ?", nil, accessString, nextRefreshToken, eat, now, *req.RefreshToken).Error; err != nil {
+		if err := s.db.Exec(ctx, "UPDATE oauth_tokens SET token = ?, refresh_token = ?, expires_at = ?, updated_at = ? WHERE refresh_token = ?", nil, accessString, nextRefreshToken, eat, now, *req.RefreshToken).Error; err != nil {
 			s.logger.Error("error updating token", "error", err)
 			return helpers.ServerError(e, nil)
 		}

server/handle_repo_describe_repo.go

···
 }
 
 func (s *Server) handleDescribeRepo(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	did := e.QueryParam("repo")
-	repo, err := s.getRepoActorByDid(did)
+	repo, err := s.getRepoActorByDid(ctx, did)
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {
 			return helpers.InputError(e, to.StringPtr("RepoNotFound"))
···
 	}
 
 	var records []models.Record
-	if err := s.db.Raw("SELECT DISTINCT(nsid) FROM records WHERE did = ?", nil, repo.Repo.Did).Scan(&records).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT DISTINCT(nsid) FROM records WHERE did = ?", nil, repo.Repo.Did).Scan(&records).Error; err != nil {
 		s.logger.Error("error getting collections", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_repo_get_record.go

···
 }
 
 func (s *Server) handleRepoGetRecord(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	repo := e.QueryParam("repo")
 	collection := e.QueryParam("collection")
 	rkey := e.QueryParam("rkey")
···
 	}
 
 	var record models.Record
-	if err := s.db.Raw("SELECT * FROM records WHERE did = ? AND nsid = ? AND rkey = ?"+cidquery, nil, params...).Scan(&record).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM records WHERE did = ? AND nsid = ? AND rkey = ?"+cidquery, nil, params...).Scan(&record).Error; err != nil {
 		// TODO: handle error nicely
 		return err
 	}

server/handle_repo_list_missing_blobs.go

···
 }
 
 func (s *Server) handleListMissingBlobs(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	limitStr := e.QueryParam("limit")
···
 	}
 
 	var records []models.Record
-	if err := s.db.Raw("SELECT * FROM records WHERE did = ?", nil, urepo.Repo.Did).Scan(&records).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM records WHERE did = ?", nil, urepo.Repo.Did).Scan(&records).Error; err != nil {
 		s.logger.Error("failed to get records for listMissingBlobs", "error", err)
 		return helpers.ServerError(e, nil)
 	}
···
 		}
 
 		var count int64
-		if err := s.db.Raw("SELECT COUNT(*) FROM blobs WHERE did = ? AND cid = ?", nil, urepo.Repo.Did, ref.cid.Bytes()).Scan(&count).Error; err != nil {
+		if err := s.db.Raw(ctx, "SELECT COUNT(*) FROM blobs WHERE did = ? AND cid = ?", nil, urepo.Repo.Did, ref.cid.Bytes()).Scan(&count).Error; err != nil {
 			continue
 		}
 

server/handle_repo_list_records.go

···
 }
 
 func (s *Server) handleListRecords(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ComAtprotoRepoListRecordsRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("could not bind list records request", "error", err)
···
 
 	did := req.Repo
 	if _, err := syntax.ParseDID(did); err != nil {
-		actor, err := s.getActorByHandle(req.Repo)
+		actor, err := s.getActorByHandle(ctx, req.Repo)
 		if err != nil {
 			return helpers.InputError(e, to.StringPtr("RepoNotFound"))
 		}
···
 	params = append(params, limit)
 
 	var records []models.Record
-	if err := s.db.Raw("SELECT * FROM records WHERE did = ? AND nsid = ? "+cursorquery+" ORDER BY created_at "+sort+" limit ?", nil, params...).Scan(&records).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM records WHERE did = ? AND nsid = ? "+cursorquery+" ORDER BY created_at "+sort+" limit ?", nil, params...).Scan(&records).Error; err != nil {
 		s.logger.Error("error getting records", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_repo_list_repos.go

···
 
 // TODO: paginate this bitch
 func (s *Server) handleListRepos(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var repos []models.Repo
-	if err := s.db.Raw("SELECT * FROM repos ORDER BY created_at DESC LIMIT 500", nil).Scan(&repos).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM repos ORDER BY created_at DESC LIMIT 500", nil).Scan(&repos).Error; err != nil {
 		return err
 	}
 

server/handle_repo_upload_blob.go

···
 }
 
 func (s *Server) handleRepoUploadBlob(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	mime := e.Request().Header.Get("content-type")
···
 		Storage:   storage,
 	}
 
-	if err := s.db.Create(&blob, nil).Error; err != nil {
+	if err := s.db.Create(ctx, &blob, nil).Error; err != nil {
 		s.logger.Error("error creating new blob in db", "error", err)
 		return helpers.ServerError(e, nil)
 	}
···
 				Data:   data,
 			}
 
-			if err := s.db.Create(&blobPart, nil).Error; err != nil {
+			if err := s.db.Create(ctx, &blobPart, nil).Error; err != nil {
 				s.logger.Error("error adding blob part to db", "error", err)
 				return helpers.ServerError(e, nil)
 			}
···
 		}
 	}
 
-	if err := s.db.Exec("UPDATE blobs SET cid = ? WHERE id = ?", nil, c.Bytes(), blob.ID).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE blobs SET cid = ? WHERE id = ?", nil, c.Bytes(), blob.ID).Error; err != nil {
 		// there should probably be somme handling here if this fails...
 		s.logger.Error("error updating blob", "error", err)
 		return helpers.ServerError(e, nil)

server/handle_server_activate_account.go

···
 }
 
 func (s *Server) handleServerActivateAccount(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ComAtprotoServerDeactivateAccountRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding", "error", err)
···
 
 	urepo := e.Get("repo").(*models.RepoActor)
 
-	if err := s.db.Exec("UPDATE repos SET deactivated = ? WHERE did = ?", nil, false, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET deactivated = ? WHERE did = ?", nil, false, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating account status to deactivated", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_check_account_status.go

···
 }
 
 func (s *Server) handleServerCheckAccountStatus(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	resp := ComAtprotoServerCheckAccountStatusResponse{
···
 	}
 
 	var blockCtResp CountResp
-	if err := s.db.Raw("SELECT COUNT(*) AS ct FROM blocks WHERE did = ?", nil, urepo.Repo.Did).Scan(&blockCtResp).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT COUNT(*) AS ct FROM blocks WHERE did = ?", nil, urepo.Repo.Did).Scan(&blockCtResp).Error; err != nil {
 		s.logger.Error("error getting block count", "error", err)
 		return helpers.ServerError(e, nil)
 	}
 	resp.RepoBlocks = blockCtResp.Ct
 
 	var recCtResp CountResp
-	if err := s.db.Raw("SELECT COUNT(*) AS ct FROM records WHERE did = ?", nil, urepo.Repo.Did).Scan(&recCtResp).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT COUNT(*) AS ct FROM records WHERE did = ?", nil, urepo.Repo.Did).Scan(&recCtResp).Error; err != nil {
 		s.logger.Error("error getting record count", "error", err)
 		return helpers.ServerError(e, nil)
 	}
 	resp.IndexedRecords = recCtResp.Ct
 
 	var blobCtResp CountResp
-	if err := s.db.Raw("SELECT COUNT(*) AS ct FROM blobs WHERE did = ?", nil, urepo.Repo.Did).Scan(&blobCtResp).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT COUNT(*) AS ct FROM blobs WHERE did = ?", nil, urepo.Repo.Did).Scan(&blobCtResp).Error; err != nil {
 		s.logger.Error("error getting record count", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_confirm_email.go

···
 }
 
 func (s *Server) handleServerConfirmEmail(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	var req ComAtprotoServerConfirmEmailRequest
···
 
 	now := time.Now().UTC()
 
-	if err := s.db.Exec("UPDATE repos SET email_verification_code = NULL, email_verification_code_expires_at = NULL, email_confirmed_at = ? WHERE did = ?", nil, now, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET email_verification_code = NULL, email_verification_code_expires_at = NULL, email_confirmed_at = ? WHERE did = ?", nil, now, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating user", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_create_account.go

···
 }
 
 func (s *Server) handleCreateAccount(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var request ComAtprotoServerCreateAccountRequest
 
 	if err := e.Bind(&request); err != nil {
···
 			}
 		}
 	}
-	
+
 	var signupDid string
 	if request.Did != nil {
-		signupDid = *request.Did;
-		
+		signupDid = *request.Did
+
 		token := strings.TrimSpace(strings.Replace(e.Request().Header.Get("authorization"), "Bearer ", "", 1))
 		if token == "" {
 			return helpers.UnauthorizedError(e, to.StringPtr("must authenticate to use an existing did"))
···
 	}
 
 	// see if the handle is already taken
-	actor, err := s.getActorByHandle(request.Handle)
+	actor, err := s.getActorByHandle(ctx, request.Handle)
 	if err != nil && err != gorm.ErrRecordNotFound {
 		s.logger.Error("error looking up handle in db", "endpoint", "com.atproto.server.createAccount", "error", err)
 		return helpers.ServerError(e, nil)
···
 			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 := s.db.Raw(ctx, "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"))
 			}
···
 	}
 
 	// see if the email is already taken
-	existingRepo, err := s.getRepoByEmail(request.Email)
+	existingRepo, err := s.getRepoByEmail(ctx, request.Email)
 	if err != nil && err != gorm.ErrRecordNotFound {
 		s.logger.Error("error looking up email in db", "endpoint", "com.atproto.server.createAccount", "error", err)
 		return helpers.ServerError(e, nil)
···
 	var k *atcrypto.PrivateKeyK256
 
 	if signupDid != "" {
-		reservedKey, err := s.getReservedKey(signupDid)
+		reservedKey, err := s.getReservedKey(ctx, signupDid)
 		if err != nil {
 			s.logger.Error("error looking up reserved key", "error", err)
 		}
···
 				k = nil
 			} else {
 				defer func() {
-					if delErr := s.deleteReservedKey(reservedKey.KeyDid, reservedKey.Did); delErr != nil {
+					if delErr := s.deleteReservedKey(ctx, reservedKey.KeyDid, reservedKey.Did); delErr != nil {
 						s.logger.Error("error deleting reserved key", "error", delErr)
 					}
 				}()
···
 			Handle: request.Handle,
 		}
 
-		if err := s.db.Create(&urepo, nil).Error; err != nil {
+		if err := s.db.Create(ctx, &urepo, nil).Error; err != nil {
 			s.logger.Error("error inserting new repo", "error", err)
 			return helpers.ServerError(e, nil)
 		}
-	
-		if err := s.db.Create(&actor, nil).Error; err != nil {
+
+		if err := s.db.Create(ctx, &actor, nil).Error; err != nil {
 			s.logger.Error("error inserting new actor", "error", err)
 			return helpers.ServerError(e, nil)
 		}
 	} else {
-		if err := s.db.Save(&actor, nil).Error; err != nil {
+		if err := s.db.Save(ctx, &actor, nil).Error; err != nil {
 			s.logger.Error("error inserting new actor", "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 {
+		if err := s.db.Raw(ctx, "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)
+	sess, err := s.createSession(ctx, &urepo)
 	if err != nil {
 		s.logger.Error("error creating new session", "error", err)
 		return helpers.ServerError(e, nil)

server/handle_server_create_invite_code.go

···
 }
 
 func (s *Server) handleCreateInviteCode(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ComAtprotoServerCreateInviteCodeRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding", "error", err)
···
 		acc = *req.ForAccount
 	}
 
-	if err := s.db.Create(&models.InviteCode{
+	if err := s.db.Create(ctx, &models.InviteCode{
 		Code:              ic,
 		Did:               acc,
 		RemainingUseCount: req.UseCount,

server/handle_server_create_invite_codes.go

···
 }
 
 func (s *Server) handleCreateInviteCodes(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ComAtprotoServerCreateInviteCodesRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding", "error", err)
···
 			ic := uuid.NewString()
 			ics = append(ics, ic)
 
-			if err := s.db.Create(&models.InviteCode{
+			if err := s.db.Create(ctx, &models.InviteCode{
 				Code:              ic,
 				Did:               did,
 				RemainingUseCount: req.UseCount,

server/handle_server_create_session.go

···
 }
 
 func (s *Server) handleCreateSession(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ComAtprotoServerCreateSessionRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding request", "endpoint", "com.atproto.server.serverCreateSession", "error", err)
···
 	var err error
 	switch idtype {
 	case "did":
-		err = s.db.Raw("SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.did = ?", nil, req.Identifier).Scan(&repo).Error
+		err = s.db.Raw(ctx, "SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.did = ?", nil, req.Identifier).Scan(&repo).Error
 	case "handle":
-		err = s.db.Raw("SELECT r.*, a.* FROM actors a LEFT JOIN repos r ON a.did = r.did WHERE a.handle = ?", nil, req.Identifier).Scan(&repo).Error
+		err = s.db.Raw(ctx, "SELECT r.*, a.* FROM actors a LEFT JOIN repos r ON a.did = r.did WHERE a.handle = ?", nil, req.Identifier).Scan(&repo).Error
 	case "email":
-		err = s.db.Raw("SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.email = ?", nil, req.Identifier).Scan(&repo).Error
+		err = s.db.Raw(ctx, "SELECT r.*, a.* FROM repos r LEFT JOIN actors a ON r.did = a.did WHERE r.email = ?", nil, req.Identifier).Scan(&repo).Error
 	}
 
 	if err != nil {
···
 		return helpers.InputError(e, to.StringPtr("InvalidRequest"))
 	}
 
-	sess, err := s.createSession(&repo.Repo)
+	sess, err := s.createSession(ctx, &repo.Repo)
 	if err != nil {
 		s.logger.Error("error creating session", "error", err)
 		return helpers.ServerError(e, nil)

server/handle_server_deactivate_account.go

···
 }
 
 func (s *Server) handleServerDeactivateAccount(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ComAtprotoServerDeactivateAccountRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding", "error", err)
···
 
 	urepo := e.Get("repo").(*models.RepoActor)
 
-	if err := s.db.Exec("UPDATE repos SET deactivated = ? WHERE did = ?", nil, true, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET deactivated = ? WHERE did = ?", nil, true, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating account status to deactivated", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_delete_account.go

···
 }
 
 func (s *Server) handleServerDeleteAccount(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ComAtprotoServerDeleteAccountRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("error binding", "error", err)
···
 		return helpers.ServerError(e, nil)
 	}
 
-	urepo, err := s.getRepoActorByDid(req.Did)
+	urepo, err := s.getRepoActorByDid(ctx, req.Did)
 	if err != nil {
 		s.logger.Error("error getting repo", "error", err)
 		return echo.NewHTTPError(400, "account not found")
···
 		})
 	}
 
-	tx := s.db.BeginDangerously()
+	tx := s.db.BeginDangerously(ctx)
 	if tx.Error != nil {
 		s.logger.Error("error starting transaction", "error", tx.Error)
 		return helpers.ServerError(e, nil)

server/handle_server_delete_session.go

···
 )
 
 func (s *Server) handleDeleteSession(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	token := e.Get("token").(string)
 
 	var acctok models.Token
-	if err := s.db.Raw("DELETE FROM tokens WHERE token = ? RETURNING *", nil, token).Scan(&acctok).Error; err != nil {
+	if err := s.db.Raw(ctx, "DELETE FROM tokens WHERE token = ? RETURNING *", nil, token).Scan(&acctok).Error; err != nil {
 		s.logger.Error("error deleting access token from db", "error", err)
 		return helpers.ServerError(e, nil)
 	}
 
-	if err := s.db.Exec("DELETE FROM refresh_tokens WHERE token = ?", nil, acctok.RefreshToken).Error; err != nil {
+	if err := s.db.Exec(ctx, "DELETE FROM refresh_tokens WHERE token = ?", nil, acctok.RefreshToken).Error; err != nil {
 		s.logger.Error("error deleting refresh token from db", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_refresh_session.go

···
 }
 
 func (s *Server) handleRefreshSession(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	token := e.Get("token").(string)
 	repo := e.Get("repo").(*models.RepoActor)
 
-	if err := s.db.Exec("DELETE FROM refresh_tokens WHERE token = ?", nil, token).Error; err != nil {
+	if err := s.db.Exec(ctx, "DELETE FROM refresh_tokens WHERE token = ?", nil, token).Error; err != nil {
 		s.logger.Error("error getting refresh token from db", "error", err)
 		return helpers.ServerError(e, nil)
 	}
 
-	if err := s.db.Exec("DELETE FROM tokens WHERE refresh_token = ?", nil, token).Error; err != nil {
+	if err := s.db.Exec(ctx, "DELETE FROM tokens WHERE refresh_token = ?", nil, token).Error; err != nil {
 		s.logger.Error("error deleting access token from db", "error", err)
 		return helpers.ServerError(e, nil)
 	}
 
-	sess, err := s.createSession(&repo.Repo)
+	sess, err := s.createSession(ctx, &repo.Repo)
 	if err != nil {
 		s.logger.Error("error creating new session for refresh", "error", err)
 		return helpers.ServerError(e, nil)

server/handle_server_request_account_delete.go

···
 )
 
 func (s *Server) handleServerRequestAccountDelete(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	token := fmt.Sprintf("%s-%s", helpers.RandomVarchar(5), helpers.RandomVarchar(5))
 	expiresAt := time.Now().UTC().Add(15 * time.Minute)
 
-	if err := s.db.Exec("UPDATE repos SET account_delete_code = ?, account_delete_code_expires_at = ? WHERE did = ?", nil, token, expiresAt, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET account_delete_code = ?, account_delete_code_expires_at = ? WHERE did = ?", nil, token, expiresAt, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error setting deletion token", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_request_email_confirmation.go

···
 )
 
 func (s *Server) handleServerRequestEmailConfirmation(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	if urepo.EmailConfirmedAt != nil {
···
 	code := fmt.Sprintf("%s-%s", helpers.RandomVarchar(5), helpers.RandomVarchar(5))
 	eat := time.Now().Add(10 * time.Minute).UTC()
 
-	if err := s.db.Exec("UPDATE repos SET email_verification_code = ?, email_verification_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET email_verification_code = ?, email_verification_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating user", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_request_email_update.go

···
 }
 
 func (s *Server) handleServerRequestEmailUpdate(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	if urepo.EmailConfirmedAt != nil {
 		code := fmt.Sprintf("%s-%s", helpers.RandomVarchar(5), helpers.RandomVarchar(5))
 		eat := time.Now().Add(10 * time.Minute).UTC()
 
-		if err := s.db.Exec("UPDATE repos SET email_update_code = ?, email_update_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
+		if err := s.db.Exec(ctx, "UPDATE repos SET email_update_code = ?, email_update_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
 			s.logger.Error("error updating repo", "error", err)
 			return helpers.ServerError(e, nil)
 		}

server/handle_server_request_password_reset.go

···
 }
 
 func (s *Server) handleServerRequestPasswordReset(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo, ok := e.Get("repo").(*models.RepoActor)
 	if !ok {
 		var req ComAtprotoServerRequestPasswordResetRequest
···
 			return err
 		}
 
-		murepo, err := s.getRepoActorByEmail(req.Email)
+		murepo, err := s.getRepoActorByEmail(ctx, req.Email)
 		if err != nil {
 			return err
 		}
···
 	code := fmt.Sprintf("%s-%s", helpers.RandomVarchar(5), helpers.RandomVarchar(5))
 	eat := time.Now().Add(10 * time.Minute).UTC()
 
-	if err := s.db.Exec("UPDATE repos SET password_reset_code = ?, password_reset_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET password_reset_code = ?, password_reset_code_expires_at = ? WHERE did = ?", nil, code, eat, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating repo", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_reserve_signing_key.go

···
 package server
 
 import (
+	"context"
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/atcrypto"
···
 }
 
 func (s *Server) handleServerReserveSigningKey(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	var req ServerReserveSigningKeyRequest
 	if err := e.Bind(&req); err != nil {
 		s.logger.Error("could not bind reserve signing key request", "error", err)
···
 
 	if req.Did != nil && *req.Did != "" {
 		var existing models.ReservedKey
-		if err := s.db.Raw("SELECT * FROM reserved_keys WHERE did = ?", nil, *req.Did).Scan(&existing).Error; err == nil && existing.KeyDid != "" {
+		if err := s.db.Raw(ctx, "SELECT * FROM reserved_keys WHERE did = ?", nil, *req.Did).Scan(&existing).Error; err == nil && existing.KeyDid != "" {
 			return e.JSON(200, ServerReserveSigningKeyResponse{
 				SigningKey: existing.KeyDid,
 			})
···
 		CreatedAt:  time.Now(),
 	}
 
-	if err := s.db.Create(&reservedKey, nil).Error; err != nil {
+	if err := s.db.Create(ctx, &reservedKey, nil).Error; err != nil {
 		s.logger.Error("error storing reserved key", "endpoint", "com.atproto.server.reserveSigningKey", "error", err)
 		return helpers.ServerError(e, nil)
 	}
···
 	})
 }
 
-func (s *Server) getReservedKey(keyDidOrDid string) (*models.ReservedKey, error) {
+func (s *Server) getReservedKey(ctx context.Context, keyDidOrDid string) (*models.ReservedKey, error) {
 	var reservedKey models.ReservedKey
 
-	if err := s.db.Raw("SELECT * FROM reserved_keys WHERE key_did = ?", nil, keyDidOrDid).Scan(&reservedKey).Error; err == nil && reservedKey.KeyDid != "" {
+	if err := s.db.Raw(ctx, "SELECT * FROM reserved_keys WHERE key_did = ?", nil, keyDidOrDid).Scan(&reservedKey).Error; err == nil && reservedKey.KeyDid != "" {
 		return &reservedKey, nil
 	}
 
-	if err := s.db.Raw("SELECT * FROM reserved_keys WHERE did = ?", nil, keyDidOrDid).Scan(&reservedKey).Error; err == nil && reservedKey.KeyDid != "" {
+	if err := s.db.Raw(ctx, "SELECT * FROM reserved_keys WHERE did = ?", nil, keyDidOrDid).Scan(&reservedKey).Error; err == nil && reservedKey.KeyDid != "" {
 		return &reservedKey, nil
 	}
 
 	return nil, nil
 }
 
-func (s *Server) deleteReservedKey(keyDid string, did *string) error {
-	if err := s.db.Exec("DELETE FROM reserved_keys WHERE key_did = ?", nil, keyDid).Error; err != nil {
+func (s *Server) deleteReservedKey(ctx context.Context, keyDid string, did *string) error {
+	if err := s.db.Exec(ctx, "DELETE FROM reserved_keys WHERE key_did = ?", nil, keyDid).Error; err != nil {
 		return err
 	}
 
 	if did != nil && *did != "" {
-		if err := s.db.Exec("DELETE FROM reserved_keys WHERE did = ?", nil, *did).Error; err != nil {
+		if err := s.db.Exec(ctx, "DELETE FROM reserved_keys WHERE did = ?", nil, *did).Error; err != nil {
 			return err
 		}
 	}

server/handle_server_reset_password.go

···
 }
 
 func (s *Server) handleServerResetPassword(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	var req ComAtprotoServerResetPasswordRequest
···
 		return helpers.ServerError(e, nil)
 	}
 
-	if err := s.db.Exec("UPDATE repos SET password_reset_code = NULL, password_reset_code_expires_at = NULL, password = ? WHERE did = ?", nil, hash, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET password_reset_code = NULL, password_reset_code_expires_at = NULL, password = ? WHERE did = ?", nil, hash, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating repo", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_server_update_email.go

···
 }
 
 func (s *Server) handleServerUpdateEmail(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	urepo := e.Get("repo").(*models.RepoActor)
 
 	var req ComAtprotoServerUpdateEmailRequest
···
 		return helpers.ExpiredTokenError(e)
 	}
 
-	if err := s.db.Exec("UPDATE repos SET email_update_code = NULL, email_update_code_expires_at = NULL, email_confirmed_at = NULL,  email = ? WHERE did = ?", nil, req.Email, urepo.Repo.Did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET email_update_code = NULL, email_update_code_expires_at = NULL, email_confirmed_at = NULL,  email = ? WHERE did = ?", nil, req.Email, urepo.Repo.Did).Error; err != nil {
 		s.logger.Error("error updating repo", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_sync_get_blob.go

···
 )
 
 func (s *Server) handleSyncGetBlob(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	did := e.QueryParam("did")
 	if did == "" {
 		return helpers.InputError(e, nil)
···
 		return helpers.InputError(e, nil)
 	}
 
-	urepo, err := s.getRepoActorByDid(did)
+	urepo, err := s.getRepoActorByDid(ctx, did)
 	if err != nil {
 		s.logger.Error("could not find user for requested blob", "error", err)
 		return helpers.InputError(e, nil)
···
 	}
 
 	var blob models.Blob
-	if err := s.db.Raw("SELECT * FROM blobs WHERE did = ? AND cid = ?", nil, did, c.Bytes()).Scan(&blob).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM blobs WHERE did = ? AND cid = ?", nil, did, c.Bytes()).Scan(&blob).Error; err != nil {
 		s.logger.Error("error looking up blob", "error", err)
 		return helpers.ServerError(e, nil)
 	}
···
 
 	if blob.Storage == "sqlite" {
 		var parts []models.BlobPart
-		if err := s.db.Raw("SELECT * FROM blob_parts WHERE blob_id = ? ORDER BY idx", nil, blob.ID).Scan(&parts).Error; err != nil {
+		if err := s.db.Raw(ctx, "SELECT * FROM blob_parts WHERE blob_id = ? ORDER BY idx", nil, blob.ID).Scan(&parts).Error; err != nil {
 			s.logger.Error("error getting blob parts", "error", err)
 			return helpers.ServerError(e, nil)
 		}

server/handle_sync_get_blocks.go

···
 		cids = append(cids, c)
 	}
 
-	urepo, err := s.getRepoActorByDid(req.Did)
+	urepo, err := s.getRepoActorByDid(ctx, req.Did)
 	if err != nil {
 		return helpers.ServerError(e, nil)
 	}

server/handle_sync_get_latest_commit.go

···
 }
 
 func (s *Server) handleSyncGetLatestCommit(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	did := e.QueryParam("did")
 	if did == "" {
 		return helpers.InputError(e, nil)
 	}
 
-	urepo, err := s.getRepoActorByDid(did)
+	urepo, err := s.getRepoActorByDid(ctx, did)
 	if err != nil {
 		return err
 	}

server/handle_sync_get_record.go

···
 	rkey := e.QueryParam("rkey")
 
 	var urepo models.Repo
-	if err := s.db.Raw("SELECT * FROM repos WHERE did = ?", nil, did).Scan(&urepo).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM repos WHERE did = ?", nil, did).Scan(&urepo).Error; err != nil {
 		s.logger.Error("error getting repo", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_sync_get_repo.go

···
 )
 
 func (s *Server) handleSyncGetRepo(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	did := e.QueryParam("did")
 	if did == "" {
 		return helpers.InputError(e, nil)
 	}
 
-	urepo, err := s.getRepoActorByDid(did)
+	urepo, err := s.getRepoActorByDid(ctx, did)
 	if err != nil {
 		return err
 	}
···
 	}
 
 	var blocks []models.Block
-	if err := s.db.Raw("SELECT * FROM blocks WHERE did = ? ORDER BY rev ASC", nil, urepo.Repo.Did).Scan(&blocks).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM blocks WHERE did = ? ORDER BY rev ASC", nil, urepo.Repo.Did).Scan(&blocks).Error; err != nil {
 		return err
 	}
 

server/handle_sync_get_repo_status.go

···
 
 // TODO: make this actually do the right thing
 func (s *Server) handleSyncGetRepoStatus(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	did := e.QueryParam("did")
 	if did == "" {
 		return helpers.InputError(e, nil)
 	}
 
-	urepo, err := s.getRepoActorByDid(did)
+	urepo, err := s.getRepoActorByDid(ctx, did)
 	if err != nil {
 		return err
 	}

server/handle_sync_list_blobs.go

···
 }
 
 func (s *Server) handleSyncListBlobs(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	did := e.QueryParam("did")
 	if did == "" {
 		return helpers.InputError(e, nil)
···
 	}
 	params = append(params, limit)
 
-	urepo, err := s.getRepoActorByDid(did)
+	urepo, err := s.getRepoActorByDid(ctx, did)
 	if err != nil {
 		s.logger.Error("could not find user for requested blobs", "error", err)
 		return helpers.InputError(e, nil)
···
 	}
 
 	var blobs []models.Blob
-	if err := s.db.Raw("SELECT * FROM blobs WHERE did = ? "+cursorquery+" ORDER BY created_at DESC LIMIT ?", nil, params...).Scan(&blobs).Error; err != nil {
+	if err := s.db.Raw(ctx, "SELECT * FROM blobs WHERE did = ? "+cursorquery+" ORDER BY created_at DESC LIMIT ?", nil, params...).Scan(&blobs).Error; err != nil {
 		s.logger.Error("error getting records", "error", err)
 		return helpers.ServerError(e, nil)
 	}

server/handle_well_known.go

···
 }
 
 func (s *Server) handleAtprotoDid(e echo.Context) error {
+	ctx := e.Request().Context()
+
 	host := e.Request().Host
 	if host == "" {
 		return helpers.InputError(e, to.StringPtr("Invalid handle."))
···
 		return e.NoContent(404)
 	}
 
-	actor, err := s.getActorByHandle(host)
+	actor, err := s.getActorByHandle(ctx, host)
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {
 			return e.NoContent(404)

server/middleware.go

···
 
 func (s *Server) handleLegacySessionMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 	return func(e echo.Context) error {
+		ctx := e.Request().Context()
+
 		authheader := e.Request().Header.Get("authorization")
 		if authheader == "" {
 			return e.JSON(401, map[string]string{"error": "Unauthorized"})
···
 			}
 			did = maybeDid
 
-			maybeRepo, err := s.getRepoActorByDid(did)
+			maybeRepo, err := s.getRepoActorByDid(ctx, did)
 			if err != nil {
 				s.logger.Error("error fetching repo", "error", err)
 				return helpers.ServerError(e, nil)
···
 				Found bool
 			}
 			var result Result
-			if err := s.db.Raw("SELECT EXISTS(SELECT 1 FROM "+table+" WHERE token = ?) AS found", nil, tokenstr).Scan(&result).Error; err != nil {
+			if err := s.db.Raw(ctx, "SELECT EXISTS(SELECT 1 FROM "+table+" WHERE token = ?) AS found", nil, tokenstr).Scan(&result).Error; err != nil {
 				if err == gorm.ErrRecordNotFound {
 					return helpers.InvalidTokenError(e)
 				}
···
 		}
 
 		if repo == nil {
-			maybeRepo, err := s.getRepoActorByDid(claims["sub"].(string))
+			maybeRepo, err := s.getRepoActorByDid(ctx, claims["sub"].(string))
 			if err != nil {
 				s.logger.Error("error fetching repo", "error", err)
 				return helpers.ServerError(e, nil)
···
 
 func (s *Server) handleOauthSessionMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 	return func(e echo.Context) error {
+		ctx := e.Request().Context()
+
 		authheader := e.Request().Header.Get("authorization")
 		if authheader == "" {
 			return e.JSON(401, map[string]string{"error": "Unauthorized"})
···
 		}
 
 		var oauthToken provider.OauthToken
-		if err := s.db.Raw("SELECT * FROM oauth_tokens WHERE token = ?", nil, accessToken).Scan(&oauthToken).Error; err != nil {
+		if err := s.db.Raw(ctx, "SELECT * FROM oauth_tokens WHERE token = ?", nil, accessToken).Scan(&oauthToken).Error; err != nil {
 			s.logger.Error("error finding access token in db", "error", err)
 			return helpers.InputError(e, nil)
 		}
···
 			})
 		}
 
-		repo, err := s.getRepoActorByDid(oauthToken.Sub)
+		repo, err := s.getRepoActorByDid(ctx, oauthToken.Sub)
 		if err != nil {
 			s.logger.Error("could not find actor in db", "error", err)
 			return helpers.ServerError(e, nil)

server/repo.go

···
 		case OpTypeDelete:
 			// try to find the old record in the database
 			var old models.Record
-			if err := rm.db.Raw("SELECT value FROM records WHERE did = ? AND nsid = ? AND rkey = ?", nil, urepo.Did, op.Collection, op.Rkey).Scan(&old).Error; err != nil {
+			if err := rm.db.Raw(ctx, "SELECT value FROM records WHERE did = ? AND nsid = ? AND rkey = ?", nil, urepo.Did, op.Collection, op.Rkey).Scan(&old).Error; err != nil {
 				return nil, err
 			}
 
···
 		var cids []cid.Cid
 		// whenever there is cid present, we know it's a create (dumb)
 		if entry.Cid != "" {
-			if err := rm.s.db.Create(&entry, []clause.Expression{clause.OnConflict{
+			if err := rm.s.db.Create(ctx, &entry, []clause.Expression{clause.OnConflict{
 				Columns:   []clause.Column{{Name: "did"}, {Name: "nsid"}, {Name: "rkey"}},
 				UpdateAll: true,
 			}}).Error; err != nil {
···
 			}
 
 			// increment the given blob refs, yay
-			cids, err = rm.incrementBlobRefs(urepo, entry.Value)
+			cids, err = rm.incrementBlobRefs(ctx, urepo, entry.Value)
 			if err != nil {
 				return nil, err
 			}
···
 			// as i noted above this is dumb. but we delete whenever the cid is nil. it works solely becaue the pkey
 			// is did + collection + rkey. i still really want to separate that out, or use a different type to make
 			// this less confusing/easy to read. alas, its 2 am and yea no
-			if err := rm.s.db.Delete(&entry, nil).Error; err != nil {
+			if err := rm.s.db.Delete(ctx, &entry, nil).Error; err != nil {
 				return nil, err
 			}
 
 			// TODO:
-			cids, err = rm.decrementBlobRefs(urepo, entry.Value)
+			cids, err = rm.decrementBlobRefs(ctx, urepo, entry.Value)
 			if err != nil {
 				return nil, err
 			}
···
 	return c, bs.GetReadLog(), nil
 }
 
-func (rm *RepoMan) incrementBlobRefs(urepo models.Repo, cbor []byte) ([]cid.Cid, error) {
+func (rm *RepoMan) incrementBlobRefs(ctx context.Context, urepo models.Repo, cbor []byte) ([]cid.Cid, error) {
 	cids, err := getBlobCidsFromCbor(cbor)
 	if err != nil {
 		return nil, err
 	}
 
 	for _, c := range cids {
-		if err := rm.db.Exec("UPDATE blobs SET ref_count = ref_count + 1 WHERE did = ? AND cid = ?", nil, urepo.Did, c.Bytes()).Error; err != nil {
+		if err := rm.db.Exec(ctx, "UPDATE blobs SET ref_count = ref_count + 1 WHERE did = ? AND cid = ?", nil, urepo.Did, c.Bytes()).Error; err != nil {
 			return nil, err
 		}
 	}
···
 	return cids, nil
 }
 
-func (rm *RepoMan) decrementBlobRefs(urepo models.Repo, cbor []byte) ([]cid.Cid, error) {
+func (rm *RepoMan) decrementBlobRefs(ctx context.Context, urepo models.Repo, cbor []byte) ([]cid.Cid, error) {
 	cids, err := getBlobCidsFromCbor(cbor)
 	if err != nil {
 		return nil, err
···
 			ID    uint
 			Count int
 		}
-		if err := rm.db.Raw("UPDATE blobs SET ref_count = ref_count - 1 WHERE did = ? AND cid = ? RETURNING id, ref_count", nil, urepo.Did, c.Bytes()).Scan(&res).Error; err != nil {
+		if err := rm.db.Raw(ctx, "UPDATE blobs SET ref_count = ref_count - 1 WHERE did = ? AND cid = ? RETURNING id, ref_count", nil, urepo.Did, c.Bytes()).Scan(&res).Error; err != nil {
 			return nil, err
 		}
 
 		// TODO: this does _not_ handle deletions of blobs that are on s3 storage!!!! we need to get the blob, see what
 		// storage it is in, and clean up s3!!!!
 		if res.Count == 0 {
-			if err := rm.db.Exec("DELETE FROM blobs WHERE id = ?", nil, res.ID).Error; err != nil {
+			if err := rm.db.Exec(ctx, "DELETE FROM blobs WHERE id = ?", nil, res.ID).Error; err != nil {
 				return nil, err
 			}
-			if err := rm.db.Exec("DELETE FROM blob_parts WHERE blob_id = ?", nil, res.ID).Error; err != nil {
+			if err := rm.db.Exec(ctx, "DELETE FROM blob_parts WHERE blob_id = ?", nil, res.ID).Error; err != nil {
 				return nil, err
 			}
 		}

server/server.go

···
 }
 
 func (s *Server) UpdateRepo(ctx context.Context, did string, root cid.Cid, rev string) error {
-	if err := s.db.Exec("UPDATE repos SET root = ?, rev = ? WHERE did = ?", nil, root.Bytes(), rev, did).Error; err != nil {
+	if err := s.db.Exec(ctx, "UPDATE repos SET root = ?, rev = ? WHERE did = ?", nil, root.Bytes(), rev, did).Error; err != nil {
 		return err
 	}
 

server/session.go

···
 package server
 
 import (
+	"context"
 	"time"
 
 	"github.com/golang-jwt/jwt/v4"
···
 	RefreshToken string
 }
 
-func (s *Server) createSession(repo *models.Repo) (*Session, error) {
+func (s *Server) createSession(ctx context.Context, repo *models.Repo) (*Session, error) {
 	now := time.Now()
 	accexp := now.Add(3 * time.Hour)
 	refexp := now.Add(7 * 24 * time.Hour)
···
 		return nil, err
 	}
 
-	if err := s.db.Create(&models.Token{
+	if err := s.db.Create(ctx, &models.Token{
 		Token:        accessString,
 		Did:          repo.Did,
 		RefreshToken: refreshString,
···
 		return nil, err
 	}
 
-	if err := s.db.Create(&models.RefreshToken{
+	if err := s.db.Create(ctx, &models.RefreshToken{
 		Token:     refreshString,
 		Did:       repo.Did,
 		CreatedAt: now,

sqlite_blockstore/sqlite_blockstore.go

···
 		return maybeBlock, nil
 	}
 
-	if err := bs.db.Raw("SELECT * FROM blocks WHERE did = ? AND cid = ?", nil, bs.did, cid.Bytes()).Scan(&block).Error; err != nil {
+	if err := bs.db.Raw(ctx, "SELECT * FROM blocks WHERE did = ? AND cid = ?", nil, bs.did, cid.Bytes()).Scan(&block).Error; err != nil {
 		return nil, err
 	}
 
···
 		Value: block.RawData(),
 	}
 
-	if err := bs.db.Create(&b, []clause.Expression{clause.OnConflict{
+	if err := bs.db.Create(ctx, &b, []clause.Expression{clause.OnConflict{
 		Columns:   []clause.Column{{Name: "did"}, {Name: "cid"}},
 		UpdateAll: true,
 	}}).Error; err != nil {
···
 }
 
 func (bs *SqliteBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {
-	tx := bs.db.BeginDangerously()
+	tx := bs.db.BeginDangerously(ctx)
 
 	for _, block := range blocks {
 		bs.inserts[block.Cid()] = block