Api/v1/accounts (#8)

* start work on accounts module

* plodding away on the accounts endpoint

* groundwork for other account routes

* add password validator

* validation utils

* require account approval flags

* comments

* comments

* go fmt

* comments

* add distributor stub

* rename api to federator

* tidy a bit

* validate new account requests

* rename r router

* comments

* add domain blocks

* add some more shortcuts

* add some more shortcuts

* check email + username availability

* email block checking for signups

* chunking away at it

* tick off a few more things

* some fiddling with tests

* add mock package

* relocate repo

* move mocks around

* set app id on new signups

* initialize oauth server properly

* rename oauth server

* proper mocking tests

* go fmt ./...

* add required fields

* change name of func

* move validation to account.go

* more tests!

* add some file utility tools

* add mediaconfig

* new shortcut

* add some more fields

* add followrequest model

* add notify

* update mastotypes

* mock out storage interface

* start building media interface

* start on update credentials

* mess about with media a bit more

* test image manipulation

* media more or less working

* account update nearly working

* rearranging my package ;) ;) ;)

* phew big stuff!!!!

* fix type checking

* *fiddles*

* Add CreateTables func

* account registration flow working

* tidy

* script to step through auth flow

* add a lil helper for generating user uris

* fiddling with federation a bit

* update progress

* Tidying and linting

8 files changed, 0 insertions, 1240 deletions

diff --git a/internal/module/account/account.go b/internal/module/account/account.go
deleted file mode 100644
index d82d96e78..000000000
--- a/internal/module/account/account.go
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
-   GoToSocial
-   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package account
-
-import (
-	"github.com/gotosocial/gotosocial/internal/module"
-	"github.com/gotosocial/gotosocial/internal/router"
-)
-
-type accountModule struct {
-}
-
-// New returns a new account module
-func New() module.ClientAPIModule {
-	return &accountModule{}
-}
-
-// Route attaches all routes from this module to the given router
-func (m *accountModule) Route(r router.Router) error {
-	return nil
-}
diff --git a/internal/module/module.go b/internal/module/module.go
deleted file mode 100644
index 8618d2857..000000000
--- a/internal/module/module.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-   GoToSocial
-   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-// Package module is basically a wrapper for a lot of modules (in subdirectories) that satisfy the ClientAPIModule interface.
-package module
-
-import "github.com/gotosocial/gotosocial/internal/router"
-
-// ClientAPIModule represents a chunk of code (usually contained in a single package) that adds a set
-// of functionalities and side effects to a router, by mapping routes and handlers onto it--in other words, a REST API ;)
-// A ClientAPIMpdule corresponds roughly to one main path of the gotosocial REST api, for example /api/v1/accounts/ or /oauth/
-type ClientAPIModule interface {
-	Route(s router.Router) error
-}
diff --git a/internal/module/oauth/README.md b/internal/module/oauth/README.md
deleted file mode 100644
index 3d8427302..000000000
--- a/internal/module/oauth/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# oauth
-
-This package provides uses the [GoToSocial oauth2](https://github.com/gotosocial/oauth2) module (forked from [go-oauth2](https://github.com/go-oauth2/oauth2)) to provide [oauth2](https://www.oauth.com/) functionality to the GoToSocial client API.
-
-It also provides a handler/middleware for attaching to the Gin engine for validating authenticated users.
diff --git a/internal/module/oauth/clientstore.go b/internal/module/oauth/clientstore.go
deleted file mode 100644
index f99c160c2..000000000
--- a/internal/module/oauth/clientstore.go
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-   GoToSocial
-   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package oauth
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/gotosocial/gotosocial/internal/db"
-	"github.com/gotosocial/oauth2/v4"
-	"github.com/gotosocial/oauth2/v4/models"
-)
-
-type clientStore struct {
-	db db.DB
-}
-
-func newClientStore(db db.DB) oauth2.ClientStore {
-	pts := &clientStore{
-		db: db,
-	}
-	return pts
-}
-
-func (cs *clientStore) GetByID(ctx context.Context, clientID string) (oauth2.ClientInfo, error) {
-	poc := &oauthClient{
-		ID: clientID,
-	}
-	if err := cs.db.GetByID(clientID, poc); err != nil {
-		return nil, fmt.Errorf("database error: %s", err)
-	}
-	return models.New(poc.ID, poc.Secret, poc.Domain, poc.UserID), nil
-}
-
-func (cs *clientStore) Set(ctx context.Context, id string, cli oauth2.ClientInfo) error {
-	poc := &oauthClient{
-		ID:     cli.GetID(),
-		Secret: cli.GetSecret(),
-		Domain: cli.GetDomain(),
-		UserID: cli.GetUserID(),
-	}
-	return cs.db.UpdateByID(id, poc)
-}
-
-func (cs *clientStore) Delete(ctx context.Context, id string) error {
-	poc := &oauthClient{
-		ID: id,
-	}
-	return cs.db.DeleteByID(id, poc)
-}
-
-type oauthClient struct {
-	ID     string
-	Secret string
-	Domain string
-	UserID string
-}
diff --git a/internal/module/oauth/clientstore_test.go b/internal/module/oauth/clientstore_test.go
deleted file mode 100644
index bca002411..000000000
--- a/internal/module/oauth/clientstore_test.go
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-   GoToSocial
-   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-package oauth
-
-import (
-	"context"
-	"testing"
-
-	"github.com/gotosocial/gotosocial/internal/config"
-	"github.com/gotosocial/gotosocial/internal/db"
-	"github.com/gotosocial/oauth2/v4/models"
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/suite"
-)
-
-type PgClientStoreTestSuite struct {
-	suite.Suite
-	db               db.DB
-	testClientID     string
-	testClientSecret string
-	testClientDomain string
-	testClientUserID string
-}
-
-const ()
-
-// SetupSuite sets some variables on the suite that we can use as consts (more or less) throughout
-func (suite *PgClientStoreTestSuite) SetupSuite() {
-	suite.testClientID = "test-client-id"
-	suite.testClientSecret = "test-client-secret"
-	suite.testClientDomain = "https://example.org"
-	suite.testClientUserID = "test-client-user-id"
-}
-
-// SetupTest creates a postgres connection and creates the oauth_clients table before each test
-func (suite *PgClientStoreTestSuite) SetupTest() {
-	log := logrus.New()
-	log.SetLevel(logrus.TraceLevel)
-	c := config.Empty()
-	c.DBConfig = &config.DBConfig{
-		Type:            "postgres",
-		Address:         "localhost",
-		Port:            5432,
-		User:            "postgres",
-		Password:        "postgres",
-		Database:        "postgres",
-		ApplicationName: "gotosocial",
-	}
-	db, err := db.New(context.Background(), c, log)
-	if err != nil {
-		logrus.Panicf("error creating database connection: %s", err)
-	}
-
-	suite.db = db
-
-	models := []interface{}{
-		&oauthClient{},
-	}
-
-	for _, m := range models {
-		if err := suite.db.CreateTable(m); err != nil {
-			logrus.Panicf("db connection error: %s", err)
-		}
-	}
-}
-
-// TearDownTest drops the oauth_clients table and closes the pg connection after each test
-func (suite *PgClientStoreTestSuite) TearDownTest() {
-	models := []interface{}{
-		&oauthClient{},
-	}
-	for _, m := range models {
-		if err := suite.db.DropTable(m); err != nil {
-			logrus.Panicf("error dropping table: %s", err)
-		}
-	}
-	if err := suite.db.Stop(context.Background()); err != nil {
-		logrus.Panicf("error closing db connection: %s", err)
-	}
-	suite.db = nil
-}
-
-func (suite *PgClientStoreTestSuite) TestClientStoreSetAndGet() {
-	// set a new client in the store
-	cs := newClientStore(suite.db)
-	if err := cs.Set(context.Background(), suite.testClientID, models.New(suite.testClientID, suite.testClientSecret, suite.testClientDomain, suite.testClientUserID)); err != nil {
-		suite.FailNow(err.Error())
-	}
-
-	// fetch that client from the store
-	client, err := cs.GetByID(context.Background(), suite.testClientID)
-	if err != nil {
-		suite.FailNow(err.Error())
-	}
-
-	// check that the values are the same
-	suite.NotNil(client)
-	suite.EqualValues(models.New(suite.testClientID, suite.testClientSecret, suite.testClientDomain, suite.testClientUserID), client)
-}
-
-func (suite *PgClientStoreTestSuite) TestClientSetAndDelete() {
-	// set a new client in the store
-	cs := newClientStore(suite.db)
-	if err := cs.Set(context.Background(), suite.testClientID, models.New(suite.testClientID, suite.testClientSecret, suite.testClientDomain, suite.testClientUserID)); err != nil {
-		suite.FailNow(err.Error())
-	}
-
-	// fetch the client from the store
-	client, err := cs.GetByID(context.Background(), suite.testClientID)
-	if err != nil {
-		suite.FailNow(err.Error())
-	}
-
-	// check that the values are the same
-	suite.NotNil(client)
-	suite.EqualValues(models.New(suite.testClientID, suite.testClientSecret, suite.testClientDomain, suite.testClientUserID), client)
-	if err := cs.Delete(context.Background(), suite.testClientID); err != nil {
-		suite.FailNow(err.Error())
-	}
-
-	// try to get the deleted client; we should get an error
-	deletedClient, err := cs.GetByID(context.Background(), suite.testClientID)
-	suite.Assert().Nil(deletedClient)
-	suite.Assert().NotNil(err)
-}
-
-func TestPgClientStoreTestSuite(t *testing.T) {
-	suite.Run(t, new(PgClientStoreTestSuite))
-}
diff --git a/internal/module/oauth/oauth.go b/internal/module/oauth/oauth.go
deleted file mode 100644
index 4436f7a8d..000000000
--- a/internal/module/oauth/oauth.go
+++ /dev/null
@@ -1,510 +0,0 @@
-/*
-   GoToSocial
-   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-// Package oauth is a module that provides oauth functionality to a router.
-// It adds the following paths:
-//    /api/v1/apps
-//    /auth/sign_in
-//    /oauth/token
-//    /oauth/authorize
-// It also includes the oauthTokenMiddleware, which can be attached to a router to authenticate every request by Bearer token.
-package oauth
-
-import (
-	"fmt"
-	"net/http"
-	"net/url"
-
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-	"github.com/gotosocial/gotosocial/internal/db"
-	"github.com/gotosocial/gotosocial/internal/gtsmodel"
-	"github.com/gotosocial/gotosocial/internal/module"
-	"github.com/gotosocial/gotosocial/internal/router"
-	"github.com/gotosocial/gotosocial/pkg/mastotypes"
-	"github.com/gotosocial/oauth2/v4"
-	"github.com/gotosocial/oauth2/v4/errors"
-	"github.com/gotosocial/oauth2/v4/manage"
-	"github.com/gotosocial/oauth2/v4/server"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/crypto/bcrypt"
-)
-
-const (
-	appsPath           = "/api/v1/apps"
-	authSignInPath     = "/auth/sign_in"
-	oauthTokenPath     = "/oauth/token"
-	oauthAuthorizePath = "/oauth/authorize"
-)
-
-// oauthModule is an oauth2 oauthModule that satisfies the ClientAPIModule interface
-type oauthModule struct {
-	oauthManager *manage.Manager
-	oauthServer  *server.Server
-	db           db.DB
-	log          *logrus.Logger
-}
-
-type login struct {
-	Email    string `form:"username"`
-	Password string `form:"password"`
-}
-
-// New returns a new oauth module
-func New(ts oauth2.TokenStore, cs oauth2.ClientStore, db db.DB, log *logrus.Logger) module.ClientAPIModule {
-	manager := manage.NewDefaultManager()
-	manager.MapTokenStorage(ts)
-	manager.MapClientStorage(cs)
-	manager.SetAuthorizeCodeTokenCfg(manage.DefaultAuthorizeCodeTokenCfg)
-	sc := &server.Config{
-		TokenType: "Bearer",
-		// Must follow the spec.
-		AllowGetAccessRequest: false,
-		// Support only the non-implicit flow.
-		AllowedResponseTypes: []oauth2.ResponseType{oauth2.Code},
-		// Allow:
-		// - Authorization Code (for first & third parties)
-		AllowedGrantTypes: []oauth2.GrantType{
-			oauth2.AuthorizationCode,
-		},
-		AllowedCodeChallengeMethods: []oauth2.CodeChallengeMethod{oauth2.CodeChallengePlain},
-	}
-
-	srv := server.NewServer(sc, manager)
-	srv.SetInternalErrorHandler(func(err error) *errors.Response {
-		log.Errorf("internal oauth error: %s", err)
-		return nil
-	})
-
-	srv.SetResponseErrorHandler(func(re *errors.Response) {
-		log.Errorf("internal response error: %s", re.Error)
-	})
-
-	m := &oauthModule{
-		oauthManager: manager,
-		oauthServer:  srv,
-		db:           db,
-		log:          log,
-	}
-
-	m.oauthServer.SetUserAuthorizationHandler(m.userAuthorizationHandler)
-	m.oauthServer.SetClientInfoHandler(server.ClientFormHandler)
-	return m
-}
-
-// Route satisfies the RESTAPIModule interface
-func (m *oauthModule) Route(s router.Router) error {
-	s.AttachHandler(http.MethodPost, appsPath, m.appsPOSTHandler)
-
-	s.AttachHandler(http.MethodGet, authSignInPath, m.signInGETHandler)
-	s.AttachHandler(http.MethodPost, authSignInPath, m.signInPOSTHandler)
-
-	s.AttachHandler(http.MethodPost, oauthTokenPath, m.tokenPOSTHandler)
-
-	s.AttachHandler(http.MethodGet, oauthAuthorizePath, m.authorizeGETHandler)
-	s.AttachHandler(http.MethodPost, oauthAuthorizePath, m.authorizePOSTHandler)
-
-	s.AttachMiddleware(m.oauthTokenMiddleware)
-
-	return nil
-}
-
-/*
-	MAIN HANDLERS -- serve these through a server/router
-*/
-
-// appsPOSTHandler should be served at https://example.org/api/v1/apps
-// It is equivalent to: https://docs.joinmastodon.org/methods/apps/
-func (m *oauthModule) appsPOSTHandler(c *gin.Context) {
-	l := m.log.WithField("func", "AppsPOSTHandler")
-	l.Trace("entering AppsPOSTHandler")
-
-	form := &mastotypes.ApplicationPOSTRequest{}
-	if err := c.ShouldBind(form); err != nil {
-		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": err.Error()})
-		return
-	}
-
-	// permitted length for most fields
-	permittedLength := 64
-	// redirect can be a bit bigger because we probably need to encode data in the redirect uri
-	permittedRedirect := 256
-
-	// check lengths of fields before proceeding so the user can't spam huge entries into the database
-	if len(form.ClientName) > permittedLength {
-		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("client_name must be less than %d bytes", permittedLength)})
-		return
-	}
-	if len(form.Website) > permittedLength {
-		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("website must be less than %d bytes", permittedLength)})
-		return
-	}
-	if len(form.RedirectURIs) > permittedRedirect {
-		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("redirect_uris must be less than %d bytes", permittedRedirect)})
-		return
-	}
-	if len(form.Scopes) > permittedLength {
-		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("scopes must be less than %d bytes", permittedLength)})
-		return
-	}
-
-	// set default 'read' for scopes if it's not set, this follows the default of the mastodon api https://docs.joinmastodon.org/methods/apps/
-	var scopes string
-	if form.Scopes == "" {
-		scopes = "read"
-	} else {
-		scopes = form.Scopes
-	}
-
-	// generate new IDs for this application and its associated client
-	clientID := uuid.NewString()
-	clientSecret := uuid.NewString()
-	vapidKey := uuid.NewString()
-
-	// generate the application to put in the database
-	app := &gtsmodel.Application{
-		Name:         form.ClientName,
-		Website:      form.Website,
-		RedirectURI:  form.RedirectURIs,
-		ClientID:     clientID,
-		ClientSecret: clientSecret,
-		Scopes:       scopes,
-		VapidKey:     vapidKey,
-	}
-
-	// chuck it in the db
-	if err := m.db.Put(app); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	// now we need to model an oauth client from the application that the oauth library can use
-	oc := &oauthClient{
-		ID:     clientID,
-		Secret: clientSecret,
-		Domain: form.RedirectURIs,
-		UserID: "", // This client isn't yet associated with a specific user,  it's just an app client right now
-	}
-
-	// chuck it in the db
-	if err := m.db.Put(oc); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	// done, return the new app information per the spec here: https://docs.joinmastodon.org/methods/apps/
-	c.JSON(http.StatusOK, app.ToMastotype())
-}
-
-// signInGETHandler should be served at https://example.org/auth/sign_in.
-// The idea is to present a sign in page to the user, where they can enter their username and password.
-// The form will then POST to the sign in page, which will be handled by SignInPOSTHandler
-func (m *oauthModule) signInGETHandler(c *gin.Context) {
-	m.log.WithField("func", "SignInGETHandler").Trace("serving sign in html")
-	c.HTML(http.StatusOK, "sign-in.tmpl", gin.H{})
-}
-
-// signInPOSTHandler should be served at https://example.org/auth/sign_in.
-// The idea is to present a sign in page to the user, where they can enter their username and password.
-// The handler will then redirect to the auth handler served at /auth
-func (m *oauthModule) signInPOSTHandler(c *gin.Context) {
-	l := m.log.WithField("func", "SignInPOSTHandler")
-	s := sessions.Default(c)
-	form := &login{}
-	if err := c.ShouldBind(form); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-	l.Tracef("parsed form: %+v", form)
-
-	userid, err := m.validatePassword(form.Email, form.Password)
-	if err != nil {
-		c.String(http.StatusForbidden, err.Error())
-		return
-	}
-
-	s.Set("userid", userid)
-	if err := s.Save(); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	l.Trace("redirecting to auth page")
-	c.Redirect(http.StatusFound, oauthAuthorizePath)
-}
-
-// tokenPOSTHandler should be served as a POST at https://example.org/oauth/token
-// The idea here is to serve an oauth access token to a user, which can be used for authorizing against non-public APIs.
-// See https://docs.joinmastodon.org/methods/apps/oauth/#obtain-a-token
-func (m *oauthModule) tokenPOSTHandler(c *gin.Context) {
-	l := m.log.WithField("func", "TokenPOSTHandler")
-	l.Trace("entered TokenPOSTHandler")
-	if err := m.oauthServer.HandleTokenRequest(c.Writer, c.Request); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-	}
-}
-
-// authorizeGETHandler should be served as GET at https://example.org/oauth/authorize
-// The idea here is to present an oauth authorize page to the user, with a button
-// that they have to click to accept. See here: https://docs.joinmastodon.org/methods/apps/oauth/#authorize-a-user
-func (m *oauthModule) authorizeGETHandler(c *gin.Context) {
-	l := m.log.WithField("func", "AuthorizeGETHandler")
-	s := sessions.Default(c)
-
-	// UserID will be set in the session by AuthorizePOSTHandler if the caller has already gone through the authentication flow
-	// If it's not set, then we don't know yet who the user is, so we need to redirect them to the sign in page.
-	userID, ok := s.Get("userid").(string)
-	if !ok || userID == "" {
-		l.Trace("userid was empty, parsing form then redirecting to sign in page")
-		if err := parseAuthForm(c, l); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		} else {
-			c.Redirect(http.StatusFound, authSignInPath)
-		}
-		return
-	}
-
-	// We can use the client_id on the session to retrieve info about the app associated with the client_id
-	clientID, ok := s.Get("client_id").(string)
-	if !ok || clientID == "" {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "no client_id found in session"})
-		return
-	}
-	app := &gtsmodel.Application{
-		ClientID: clientID,
-	}
-	if err := m.db.GetWhere("client_id", app.ClientID, app); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("no application found for client id %s", clientID)})
-		return
-	}
-
-	// we can also use the userid of the user to fetch their username from the db to greet them nicely <3
-	user := &gtsmodel.User{
-		ID: userID,
-	}
-	if err := m.db.GetByID(user.ID, user); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	acct := &gtsmodel.Account{
-		ID: user.AccountID,
-	}
-
-	if err := m.db.GetByID(acct.ID, acct); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	// Finally we should also get the redirect and scope of this particular request, as stored in the session.
-	redirect, ok := s.Get("redirect_uri").(string)
-	if !ok || redirect == "" {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "no redirect_uri found in session"})
-		return
-	}
-	scope, ok := s.Get("scope").(string)
-	if !ok || scope == "" {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "no scope found in session"})
-		return
-	}
-
-	// the authorize template will display a form to the user where they can get some information
-	// about the app that's trying to authorize, and the scope of the request.
-	// They can then approve it if it looks OK to them, which will POST to the AuthorizePOSTHandler
-	l.Trace("serving authorize html")
-	c.HTML(http.StatusOK, "authorize.tmpl", gin.H{
-		"appname":    app.Name,
-		"appwebsite": app.Website,
-		"redirect":   redirect,
-		"scope":      scope,
-		"user":       acct.Username,
-	})
-}
-
-// authorizePOSTHandler should be served as POST at https://example.org/oauth/authorize
-// At this point we assume that the user has A) logged in and B) accepted that the app should act for them,
-// so we should proceed with the authentication flow and generate an oauth token for them if we can.
-// See here: https://docs.joinmastodon.org/methods/apps/oauth/#authorize-a-user
-func (m *oauthModule) authorizePOSTHandler(c *gin.Context) {
-	l := m.log.WithField("func", "AuthorizePOSTHandler")
-	s := sessions.Default(c)
-
-	// At this point we know the user has said 'yes' to allowing the application and oauth client
-	// work for them, so we can set the
-
-	// We need to retrieve the original form submitted to the authorizeGEThandler, and
-	// recreate it on the request so that it can be used further by the oauth2 library.
-	// So first fetch all the values from the session.
-	forceLogin, ok := s.Get("force_login").(string)
-	if !ok {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "session missing force_login"})
-		return
-	}
-	responseType, ok := s.Get("response_type").(string)
-	if !ok || responseType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "session missing response_type"})
-		return
-	}
-	clientID, ok := s.Get("client_id").(string)
-	if !ok || clientID == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "session missing client_id"})
-		return
-	}
-	redirectURI, ok := s.Get("redirect_uri").(string)
-	if !ok || redirectURI == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "session missing redirect_uri"})
-		return
-	}
-	scope, ok := s.Get("scope").(string)
-	if !ok {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "session missing scope"})
-		return
-	}
-	userID, ok := s.Get("userid").(string)
-	if !ok {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "session missing userid"})
-		return
-	}
-	// we're done with the session so we can clear it now
-	s.Clear()
-
-	// now set the values on the request
-	values := url.Values{}
-	values.Set("force_login", forceLogin)
-	values.Set("response_type", responseType)
-	values.Set("client_id", clientID)
-	values.Set("redirect_uri", redirectURI)
-	values.Set("scope", scope)
-	values.Set("userid", userID)
-	c.Request.Form = values
-	l.Tracef("values on request set to %+v", c.Request.Form)
-
-	// and proceed with authorization using the oauth2 library
-	if err := m.oauthServer.HandleAuthorizeRequest(c.Writer, c.Request); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-	}
-}
-
-/*
-	MIDDLEWARE
-*/
-
-// oauthTokenMiddleware
-func (m *oauthModule) oauthTokenMiddleware(c *gin.Context) {
-	l := m.log.WithField("func", "ValidatePassword")
-	l.Trace("entering OauthTokenMiddleware")
-	if ti, err := m.oauthServer.ValidationBearerToken(c.Request); err == nil {
-		l.Tracef("authenticated user %s with bearer token, scope is %s", ti.GetUserID(), ti.GetScope())
-		c.Set("authenticated_user", ti.GetUserID())
-
-	} else {
-		l.Trace("continuing with unauthenticated request")
-	}
-}
-
-/*
-	SUB-HANDLERS -- don't serve these directly, they should be attached to the oauth2 server or used inside handler funcs
-*/
-
-// validatePassword takes an email address and a password.
-// The goal is to authenticate the password against the one for that email
-// address stored in the database. If OK, we return the userid (a uuid) for that user,
-// so that it can be used in further Oauth flows to generate a token/retreieve an oauth client from the db.
-func (m *oauthModule) validatePassword(email string, password string) (userid string, err error) {
-	l := m.log.WithField("func", "ValidatePassword")
-
-	// make sure an email/password was provided and bail if not
-	if email == "" || password == "" {
-		l.Debug("email or password was not provided")
-		return incorrectPassword()
-	}
-
-	// first we select the user from the database based on email address, bail if no user found for that email
-	gtsUser := &gtsmodel.User{}
-
-	if err := m.db.GetWhere("email", email, gtsUser); err != nil {
-		l.Debugf("user %s was not retrievable from db during oauth authorization attempt: %s", email, err)
-		return incorrectPassword()
-	}
-
-	// make sure a password is actually set and bail if not
-	if gtsUser.EncryptedPassword == "" {
-		l.Warnf("encrypted password for user %s was empty for some reason", gtsUser.Email)
-		return incorrectPassword()
-	}
-
-	// compare the provided password with the encrypted one from the db, bail if they don't match
-	if err := bcrypt.CompareHashAndPassword([]byte(gtsUser.EncryptedPassword), []byte(password)); err != nil {
-		l.Debugf("password hash didn't match for user %s during login attempt: %s", gtsUser.Email, err)
-		return incorrectPassword()
-	}
-
-	// If we've made it this far the email/password is correct, so we can just return the id of the user.
-	userid = gtsUser.ID
-	l.Tracef("returning (%s, %s)", userid, err)
-	return
-}
-
-// incorrectPassword is just a little helper function to use in the ValidatePassword function
-func incorrectPassword() (string, error) {
-	return "", errors.New("password/email combination was incorrect")
-}
-
-// userAuthorizationHandler gets the user's ID from the 'userid' field of the request form,
-// or redirects to the /auth/sign_in page, if this key is not present.
-func (m *oauthModule) userAuthorizationHandler(w http.ResponseWriter, r *http.Request) (userID string, err error) {
-	l := m.log.WithField("func", "UserAuthorizationHandler")
-	userID = r.FormValue("userid")
-	if userID == "" {
-		return "", errors.New("userid was empty, redirecting to sign in page")
-	}
-	l.Tracef("returning userID %s", userID)
-	return userID, err
-}
-
-// parseAuthForm parses the OAuthAuthorize form in the gin context, and stores
-// the values in the form into the session.
-func parseAuthForm(c *gin.Context, l *logrus.Entry) error {
-	s := sessions.Default(c)
-
-	// first make sure they've filled out the authorize form with the required values
-	form := &mastotypes.OAuthAuthorize{}
-	if err := c.ShouldBind(form); err != nil {
-		return err
-	}
-	l.Tracef("parsed form: %+v", form)
-
-	// these fields are *required* so check 'em
-	if form.ResponseType == "" || form.ClientID == "" || form.RedirectURI == "" {
-		return errors.New("missing one of: response_type, client_id or redirect_uri")
-	}
-
-	// set default scope to read
-	if form.Scope == "" {
-		form.Scope = "read"
-	}
-
-	// save these values from the form so we can use them elsewhere in the session
-	s.Set("force_login", form.ForceLogin)
-	s.Set("response_type", form.ResponseType)
-	s.Set("client_id", form.ClientID)
-	s.Set("redirect_uri", form.RedirectURI)
-	s.Set("scope", form.Scope)
-	return s.Save()
-}
diff --git a/internal/module/oauth/oauth_test.go b/internal/module/oauth/oauth_test.go
deleted file mode 100644
index adfb40ac5..000000000
--- a/internal/module/oauth/oauth_test.go
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
-   GoToSocial
-   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package oauth
-
-import (
-	"context"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/gotosocial/gotosocial/internal/config"
-	"github.com/gotosocial/gotosocial/internal/db"
-	"github.com/gotosocial/gotosocial/internal/gtsmodel"
-	"github.com/gotosocial/gotosocial/internal/router"
-	"github.com/gotosocial/oauth2/v4"
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/suite"
-	"golang.org/x/crypto/bcrypt"
-)
-
-type OauthTestSuite struct {
-	suite.Suite
-	tokenStore      oauth2.TokenStore
-	clientStore     oauth2.ClientStore
-	db              db.DB
-	testAccount     *gtsmodel.Account
-	testApplication *gtsmodel.Application
-	testUser        *gtsmodel.User
-	testClient      *oauthClient
-	config          *config.Config
-}
-
-// SetupSuite sets some variables on the suite that we can use as consts (more or less) throughout
-func (suite *OauthTestSuite) SetupSuite() {
-	c := config.Empty()
-	// we're running on localhost without https so set the protocol to http
-	c.Protocol = "http"
-	// just for testing
-	c.Host = "localhost:8080"
-	// because go tests are run within the test package directory, we need to fiddle with the templateconfig
-	// basedir in a way that we wouldn't normally have to do when running the binary, in order to make
-	// the templates actually load
-	c.TemplateConfig.BaseDir = "../../../web/template/"
-	c.DBConfig = &config.DBConfig{
-		Type:            "postgres",
-		Address:         "localhost",
-		Port:            5432,
-		User:            "postgres",
-		Password:        "postgres",
-		Database:        "postgres",
-		ApplicationName: "gotosocial",
-	}
-	suite.config = c
-
-	encryptedPassword, err := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
-	if err != nil {
-		logrus.Panicf("error encrypting user pass: %s", err)
-	}
-
-	acctID := uuid.NewString()
-
-	suite.testAccount = &gtsmodel.Account{
-		ID:       acctID,
-		Username: "test_user",
-	}
-	suite.testUser = &gtsmodel.User{
-		EncryptedPassword: string(encryptedPassword),
-		Email:             "user@example.org",
-		AccountID:         acctID,
-	}
-	suite.testClient = &oauthClient{
-		ID:     "a-known-client-id",
-		Secret: "some-secret",
-		Domain: fmt.Sprintf("%s://%s", c.Protocol, c.Host),
-	}
-	suite.testApplication = &gtsmodel.Application{
-		Name:         "a test application",
-		Website:      "https://some-application-website.com",
-		RedirectURI:  "http://localhost:8080",
-		ClientID:     "a-known-client-id",
-		ClientSecret: "some-secret",
-		Scopes:       "read",
-		VapidKey:     uuid.NewString(),
-	}
-}
-
-// SetupTest creates a postgres connection and creates the oauth_clients table before each test
-func (suite *OauthTestSuite) SetupTest() {
-
-	log := logrus.New()
-	log.SetLevel(logrus.TraceLevel)
-	db, err := db.New(context.Background(), suite.config, log)
-	if err != nil {
-		logrus.Panicf("error creating database connection: %s", err)
-	}
-
-	suite.db = db
-
-	models := []interface{}{
-		&oauthClient{},
-		&oauthToken{},
-		&gtsmodel.User{},
-		&gtsmodel.Account{},
-		&gtsmodel.Application{},
-	}
-
-	for _, m := range models {
-		if err := suite.db.CreateTable(m); err != nil {
-			logrus.Panicf("db connection error: %s", err)
-		}
-	}
-
-	suite.tokenStore = newTokenStore(context.Background(), suite.db, logrus.New())
-	suite.clientStore = newClientStore(suite.db)
-
-	if err := suite.db.Put(suite.testAccount); err != nil {
-		logrus.Panicf("could not insert test account into db: %s", err)
-	}
-	if err := suite.db.Put(suite.testUser); err != nil {
-		logrus.Panicf("could not insert test user into db: %s", err)
-	}
-	if err := suite.db.Put(suite.testClient); err != nil {
-		logrus.Panicf("could not insert test client into db: %s", err)
-	}
-	if err := suite.db.Put(suite.testApplication); err != nil {
-		logrus.Panicf("could not insert test application into db: %s", err)
-	}
-
-}
-
-// TearDownTest drops the oauth_clients table and closes the pg connection after each test
-func (suite *OauthTestSuite) TearDownTest() {
-	models := []interface{}{
-		&oauthClient{},
-		&oauthToken{},
-		&gtsmodel.User{},
-		&gtsmodel.Account{},
-		&gtsmodel.Application{},
-	}
-	for _, m := range models {
-		if err := suite.db.DropTable(m); err != nil {
-			logrus.Panicf("error dropping table: %s", err)
-		}
-	}
-	if err := suite.db.Stop(context.Background()); err != nil {
-		logrus.Panicf("error closing db connection: %s", err)
-	}
-	suite.db = nil
-}
-
-func (suite *OauthTestSuite) TestAPIInitialize() {
-	log := logrus.New()
-	log.SetLevel(logrus.TraceLevel)
-
-	r, err := router.New(suite.config, log)
-	if err != nil {
-		suite.FailNow(fmt.Sprintf("error mapping routes onto router: %s", err))
-	}
-
-	api := New(suite.tokenStore, suite.clientStore, suite.db, log)
-	if err := api.Route(r); err != nil {
-		suite.FailNow(fmt.Sprintf("error mapping routes onto router: %s", err))
-	}
-
-	go r.Start()
-	time.Sleep(60 * time.Second)
-	// http://localhost:8080/oauth/authorize?client_id=a-known-client-id&response_type=code&redirect_uri=http://localhost:8080&scope=read
-	// curl -v -F client_id=a-known-client-id -F client_secret=some-secret -F redirect_uri=http://localhost:8080 -F code=[ INSERT CODE HERE ] -F grant_type=authorization_code localhost:8080/oauth/token
-	// curl -v -H "Authorization: Bearer [INSERT TOKEN HERE]" http://localhost:8080
-}
-
-func TestOauthTestSuite(t *testing.T) {
-	suite.Run(t, new(OauthTestSuite))
-}
diff --git a/internal/module/oauth/tokenstore.go b/internal/module/oauth/tokenstore.go
deleted file mode 100644
index d8a6d5814..000000000
--- a/internal/module/oauth/tokenstore.go
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
-   GoToSocial
-   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package oauth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/gotosocial/gotosocial/internal/db"
-	"github.com/gotosocial/oauth2/v4"
-	"github.com/gotosocial/oauth2/v4/models"
-	"github.com/sirupsen/logrus"
-)
-
-// tokenStore is an implementation of oauth2.TokenStore, which uses our db interface as a storage backend.
-type tokenStore struct {
-	oauth2.TokenStore
-	db  db.DB
-	log *logrus.Logger
-}
-
-// newTokenStore returns a token store that satisfies the oauth2.TokenStore interface.
-//
-// In order to allow tokens to 'expire', it will also set off a goroutine that iterates through
-// the tokens in the DB once per minute and deletes any that have expired.
-func newTokenStore(ctx context.Context, db db.DB, log *logrus.Logger) oauth2.TokenStore {
-	pts := &tokenStore{
-		db:  db,
-		log: log,
-	}
-
-	// set the token store to clean out expired tokens once per minute, or return if we're done
-	go func(ctx context.Context, pts *tokenStore, log *logrus.Logger) {
-	cleanloop:
-		for {
-			select {
-			case <-ctx.Done():
-				log.Info("breaking cleanloop")
-				break cleanloop
-			case <-time.After(1 * time.Minute):
-				log.Debug("sweeping out old oauth entries broom broom")
-				if err := pts.sweep(); err != nil {
-					log.Errorf("error while sweeping oauth entries: %s", err)
-				}
-			}
-		}
-	}(ctx, pts, log)
-	return pts
-}
-
-// sweep clears out old tokens that have expired; it should be run on a loop about once per minute or so.
-func (pts *tokenStore) sweep() error {
-	// select *all* tokens from the db
-	// todo: if this becomes expensive (ie., there are fucking LOADS of tokens) then figure out a better way.
-	tokens := new([]*oauthToken)
-	if err := pts.db.GetAll(tokens); err != nil {
-		return err
-	}
-
-	// iterate through and remove expired tokens
-	now := time.Now()
-	for _, pgt := range *tokens {
-		// The zero value of a time.Time is 00:00 january 1 1970, which will always be before now. So:
-		// we only want to check if a token expired before now if the expiry time is *not zero*;
-		// ie., if it's been explicity set.
-		if !pgt.CodeExpiresAt.IsZero() && pgt.CodeExpiresAt.Before(now) || !pgt.RefreshExpiresAt.IsZero() && pgt.RefreshExpiresAt.Before(now) || !pgt.AccessExpiresAt.IsZero() && pgt.AccessExpiresAt.Before(now) {
-			if err := pts.db.DeleteByID(pgt.ID, &pgt); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-// Create creates and store the new token information.
-// For the original implementation, see https://github.com/gotosocial/oauth2/blob/master/store/token.go#L34
-func (pts *tokenStore) Create(ctx context.Context, info oauth2.TokenInfo) error {
-	t, ok := info.(*models.Token)
-	if !ok {
-		return errors.New("info param was not a models.Token")
-	}
-	if err := pts.db.Put(oauthTokenToPGToken(t)); err != nil {
-		return fmt.Errorf("error in tokenstore create: %s", err)
-	}
-	return nil
-}
-
-// RemoveByCode deletes a token from the DB based on the Code field
-func (pts *tokenStore) RemoveByCode(ctx context.Context, code string) error {
-	return pts.db.DeleteWhere("code", code, &oauthToken{})
-}
-
-// RemoveByAccess deletes a token from the DB based on the Access field
-func (pts *tokenStore) RemoveByAccess(ctx context.Context, access string) error {
-	return pts.db.DeleteWhere("access", access, &oauthToken{})
-}
-
-// RemoveByRefresh deletes a token from the DB based on the Refresh field
-func (pts *tokenStore) RemoveByRefresh(ctx context.Context, refresh string) error {
-	return pts.db.DeleteWhere("refresh", refresh, &oauthToken{})
-}
-
-// GetByCode selects a token from the DB based on the Code field
-func (pts *tokenStore) GetByCode(ctx context.Context, code string) (oauth2.TokenInfo, error) {
-	pgt := &oauthToken{
-		Code: code,
-	}
-	if err := pts.db.GetWhere("code", code, pgt); err != nil {
-		return nil, err
-	}
-	return pgTokenToOauthToken(pgt), nil
-}
-
-// GetByAccess selects a token from the DB based on the Access field
-func (pts *tokenStore) GetByAccess(ctx context.Context, access string) (oauth2.TokenInfo, error) {
-	pgt := &oauthToken{
-		Access: access,
-	}
-	if err := pts.db.GetWhere("access", access, pgt); err != nil {
-		return nil, err
-	}
-	return pgTokenToOauthToken(pgt), nil
-}
-
-// GetByRefresh selects a token from the DB based on the Refresh field
-func (pts *tokenStore) GetByRefresh(ctx context.Context, refresh string) (oauth2.TokenInfo, error) {
-	pgt := &oauthToken{
-		Refresh: refresh,
-	}
-	if err := pts.db.GetWhere("refresh", refresh, pgt); err != nil {
-		return nil, err
-	}
-	return pgTokenToOauthToken(pgt), nil
-}
-
-/*
-	The following models are basically helpers for the postgres token store implementation, they should only be used internally.
-*/
-
-// oauthToken is a translation of the gotosocial token with the ExpiresIn fields replaced with ExpiresAt.
-//
-// Explanation for this: gotosocial assumes an in-memory or file database of some kind, where a time-to-live parameter (TTL) can be defined,
-// and tokens with expired TTLs are automatically removed. Since Postgres doesn't have that feature, it's easier to set an expiry time and
-// then periodically sweep out tokens when that time has passed.
-//
-// Note that this struct does *not* satisfy the token interface shown here: https://github.com/gotosocial/oauth2/blob/master/model.go#L22
-// and implemented here: https://github.com/gotosocial/oauth2/blob/master/models/token.go.
-// As such, manual translation is always required between oauthToken and the gotosocial *model.Token. The helper functions oauthTokenToPGToken
-// and pgTokenToOauthToken can be used for that.
-type oauthToken struct {
-	ID                  string `pg:"type:uuid,default:gen_random_uuid(),pk,notnull"`
-	ClientID            string
-	UserID              string
-	RedirectURI         string
-	Scope               string
-	Code                string `pg:"default:'',pk"`
-	CodeChallenge       string
-	CodeChallengeMethod string
-	CodeCreateAt        time.Time `pg:"type:timestamp"`
-	CodeExpiresAt       time.Time `pg:"type:timestamp"`
-	Access              string    `pg:"default:'',pk"`
-	AccessCreateAt      time.Time `pg:"type:timestamp"`
-	AccessExpiresAt     time.Time `pg:"type:timestamp"`
-	Refresh             string    `pg:"default:'',pk"`
-	RefreshCreateAt     time.Time `pg:"type:timestamp"`
-	RefreshExpiresAt    time.Time `pg:"type:timestamp"`
-}
-
-// oauthTokenToPGToken is a lil util function that takes a gotosocial token and gives back a token for inserting into postgres
-func oauthTokenToPGToken(tkn *models.Token) *oauthToken {
-	now := time.Now()
-
-	// For the following, we want to make sure we're not adding a time.Now() to an *empty* ExpiresIn, otherwise that's
-	// going to cause all sorts of interesting problems. So check first to make sure that the ExpiresIn is not equal
-	// to the zero value of a time.Duration, which is 0s. If it *is* empty/nil, just leave the ExpiresAt at nil as well.
-
-	var cea time.Time
-	if tkn.CodeExpiresIn != 0*time.Second {
-		cea = now.Add(tkn.CodeExpiresIn)
-	}
-
-	var aea time.Time
-	if tkn.AccessExpiresIn != 0*time.Second {
-		aea = now.Add(tkn.AccessExpiresIn)
-	}
-
-	var rea time.Time
-	if tkn.RefreshExpiresIn != 0*time.Second {
-		rea = now.Add(tkn.RefreshExpiresIn)
-	}
-
-	return &oauthToken{
-		ClientID:            tkn.ClientID,
-		UserID:              tkn.UserID,
-		RedirectURI:         tkn.RedirectURI,
-		Scope:               tkn.Scope,
-		Code:                tkn.Code,
-		CodeChallenge:       tkn.CodeChallenge,
-		CodeChallengeMethod: tkn.CodeChallengeMethod,
-		CodeCreateAt:        tkn.CodeCreateAt,
-		CodeExpiresAt:       cea,
-		Access:              tkn.Access,
-		AccessCreateAt:      tkn.AccessCreateAt,
-		AccessExpiresAt:     aea,
-		Refresh:             tkn.Refresh,
-		RefreshCreateAt:     tkn.RefreshCreateAt,
-		RefreshExpiresAt:    rea,
-	}
-}
-
-// pgTokenToOauthToken is a lil util function that takes a postgres token and gives back a gotosocial token
-func pgTokenToOauthToken(pgt *oauthToken) *models.Token {
-	now := time.Now()
-
-	return &models.Token{
-		ClientID:            pgt.ClientID,
-		UserID:              pgt.UserID,
-		RedirectURI:         pgt.RedirectURI,
-		Scope:               pgt.Scope,
-		Code:                pgt.Code,
-		CodeChallenge:       pgt.CodeChallenge,
-		CodeChallengeMethod: pgt.CodeChallengeMethod,
-		CodeCreateAt:        pgt.CodeCreateAt,
-		CodeExpiresIn:       pgt.CodeExpiresAt.Sub(now),
-		Access:              pgt.Access,
-		AccessCreateAt:      pgt.AccessCreateAt,
-		AccessExpiresIn:     pgt.AccessExpiresAt.Sub(now),
-		Refresh:             pgt.Refresh,
-		RefreshCreateAt:     pgt.RefreshCreateAt,
-		RefreshExpiresIn:    pgt.RefreshExpiresAt.Sub(now),
-	}
-}