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

internal/gotosocial/actions.go

@@ -25,10 +25,20 @@ import (
 	"os/signal"
 	"syscall"
 
-	"github.com/gotosocial/gotosocial/internal/action"
-	"github.com/gotosocial/gotosocial/internal/config"
-	"github.com/gotosocial/gotosocial/internal/db"
 	"github.com/sirupsen/logrus"
+	"github.com/superseriousbusiness/gotosocial/internal/action"
+	"github.com/superseriousbusiness/gotosocial/internal/apimodule"
+	"github.com/superseriousbusiness/gotosocial/internal/apimodule/account"
+	"github.com/superseriousbusiness/gotosocial/internal/apimodule/app"
+	"github.com/superseriousbusiness/gotosocial/internal/apimodule/auth"
+	"github.com/superseriousbusiness/gotosocial/internal/cache"
+	"github.com/superseriousbusiness/gotosocial/internal/config"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
+	"github.com/superseriousbusiness/gotosocial/internal/federation"
+	"github.com/superseriousbusiness/gotosocial/internal/media"
+	"github.com/superseriousbusiness/gotosocial/internal/oauth"
+	"github.com/superseriousbusiness/gotosocial/internal/router"
+	"github.com/superseriousbusiness/gotosocial/internal/storage"
 )
 
 // Run creates and starts a gotosocial server
@@ -38,9 +48,48 @@ var Run action.GTSAction = func(ctx context.Context, c *config.Config, log *logr
 		return fmt.Errorf("error creating dbservice: %s", err)
 	}
 
-	// if err := dbService.CreateSchema(ctx); err != nil {
-	// 	return fmt.Errorf("error creating dbschema: %s", err)
-	// }
+	router, err := router.New(c, log)
+	if err != nil {
+		return fmt.Errorf("error creating router: %s", err)
+	}
+
+	storageBackend, err := storage.NewInMem(c, log)
+	if err != nil {
+		return fmt.Errorf("error creating storage backend: %s", err)
+	}
+
+	// build backend handlers
+	mediaHandler := media.New(c, dbService, storageBackend, log)
+	oauthServer := oauth.New(dbService, log)
+
+	// build client api modules
+	authModule := auth.New(oauthServer, dbService, log)
+	accountModule := account.New(c, dbService, oauthServer, mediaHandler, log)
+	appsModule := app.New(oauthServer, dbService, log)
+
+	apiModules := []apimodule.ClientAPIModule{
+		authModule, // this one has to go first so the other modules use its middleware
+		accountModule,
+		appsModule,
+	}
+
+	for _, m := range apiModules {
+		if err := m.Route(router); err != nil {
+			return fmt.Errorf("routing error: %s", err)
+		}
+		if err := m.CreateTables(dbService); err != nil {
+			return fmt.Errorf("table creation error: %s", err)
+		}
+	}
+
+	gts, err := New(dbService, &cache.MockCache{}, router, federation.New(dbService, log), c)
+	if err != nil {
+		return fmt.Errorf("error creating gotosocial service: %s", err)
+	}
+
+	if err := gts.Start(ctx); err != nil {
+		return fmt.Errorf("error starting gotosocial service: %s", err)
+	}
 
 	// catch shutdown signals from the operating system
 	sigs := make(chan os.Signal, 1)
@@ -49,8 +98,8 @@ var Run action.GTSAction = func(ctx context.Context, c *config.Config, log *logr
 	log.Infof("received signal %s, shutting down", sig)
 
 	// close down all running services in order
-	if err := dbService.Stop(ctx); err != nil {
-		return fmt.Errorf("error closing dbservice: %s", err)
+	if err := gts.Stop(ctx); err != nil {
+		return fmt.Errorf("error closing gotosocial service: %s", err)
 	}
 
 	log.Info("done! exiting...")

internal/gotosocial/gotosocial.go

@@ -22,17 +22,22 @@ import (
 	"context"
 
 	"github.com/go-fed/activity/pub"
-	"github.com/gotosocial/gotosocial/internal/cache"
-	"github.com/gotosocial/gotosocial/internal/config"
-	"github.com/gotosocial/gotosocial/internal/db"
-	"github.com/gotosocial/gotosocial/internal/router"
+	"github.com/superseriousbusiness/gotosocial/internal/cache"
+	"github.com/superseriousbusiness/gotosocial/internal/config"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
+	"github.com/superseriousbusiness/gotosocial/internal/router"
 )
 
+// Gotosocial is the 'main' function of the gotosocial server, and the place where everything hangs together.
+// The logic of stopping and starting the entire server is contained here.
 type Gotosocial interface {
 	Start(context.Context) error
 	Stop(context.Context) error
 }
 
+// New returns a new gotosocial server, initialized with the given configuration.
+// An error will be returned the caller if something goes wrong during initialization
+// eg., no db or storage connection, port for router already in use, etc.
 func New(db db.DB, cache cache.Cache, apiRouter router.Router, federationAPI pub.FederatingActor, config *config.Config) (Gotosocial, error) {
 	return &gotosocial{
 		db:            db,
@@ -43,6 +48,7 @@ func New(db db.DB, cache cache.Cache, apiRouter router.Router, federationAPI pub
 	}, nil
 }
 
+// gotosocial fulfils the gotosocial interface.
 type gotosocial struct {
 	db            db.DB
 	cache         cache.Cache
@@ -51,10 +57,19 @@ type gotosocial struct {
 	config        *config.Config
 }
 
+// Start starts up the gotosocial server. If something goes wrong
+// while starting the server, then an error will be returned.
 func (gts *gotosocial) Start(ctx context.Context) error {
+	gts.apiRouter.Start()
 	return nil
 }
 
 func (gts *gotosocial) Stop(ctx context.Context) error {
+	if err := gts.apiRouter.Stop(ctx); err != nil {
+		return err
+	}
+	if err := gts.db.Stop(ctx); err != nil {
+		return err
+	}
 	return nil
 }

internal/gotosocial/mock_Gotosocial.go

@@ -0,0 +1,28 @@
+// Code generated by mockery v2.7.4. DO NOT EDIT.
+
+package gotosocial
+
+import (
+	context "context"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockGotosocial is an autogenerated mock type for the Gotosocial type
+type MockGotosocial struct {
+	mock.Mock
+}
+
+// Start provides a mock function with given fields: _a0
+func (_m *MockGotosocial) Start(_a0 context.Context) error {
+	ret := _m.Called(_a0)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}