Basic example cleanup

Rename sales-api to web-api and remove sales-admin

example-project/cmd/web-api/handlers/check.go

@@ -0,0 +1,38 @@
+package handlers
+
+import (
+	"context"
+	"net/http"
+
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/db"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/web"
+	"go.opencensus.io/trace"
+)
+
+// Check provides support for orchestration health checks.
+type Check struct {
+	MasterDB *db.DB
+
+	// ADD OTHER STATE LIKE THE LOGGER IF NEEDED.
+}
+
+// Health validates the service is healthy and ready to accept requests.
+func (c *Check) Health(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.Check.Health")
+	defer span.End()
+
+	dbConn := c.MasterDB.Copy()
+	defer dbConn.Close()
+
+	if err := dbConn.StatusCheck(ctx); err != nil {
+		return err
+	}
+
+	status := struct {
+		Status string `json:"status"`
+	}{
+		Status: "ok",
+	}
+
+	return web.Respond(ctx, w, status, http.StatusOK)
+}

example-project/cmd/web-api/handlers/project.go

@@ -0,0 +1,140 @@
+package handlers
+
+import (
+	"context"
+	"net/http"
+
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/db"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/web"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/project"
+	"github.com/pkg/errors"
+	"go.opencensus.io/trace"
+)
+
+// Project represents the Project API method handler set.
+type Project struct {
+	MasterDB *db.DB
+
+	// ADD OTHER STATE LIKE THE LOGGER IF NEEDED.
+}
+
+// List returns all the existing projects in the system.
+func (p *Project) List(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.Project.List")
+	defer span.End()
+
+	dbConn := p.MasterDB.Copy()
+	defer dbConn.Close()
+
+	projects, err := project.List(ctx, dbConn)
+	if err != nil {
+		return err
+	}
+
+	return web.Respond(ctx, w, projects, http.StatusOK)
+}
+
+// Retrieve returns the specified project from the system.
+func (p *Project) Retrieve(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.Project.Retrieve")
+	defer span.End()
+
+	dbConn := p.MasterDB.Copy()
+	defer dbConn.Close()
+
+	prod, err := project.Retrieve(ctx, dbConn, params["id"])
+	if err != nil {
+		switch err {
+		case project.ErrInvalidID:
+			return web.NewRequestError(err, http.StatusBadRequest)
+		case project.ErrNotFound:
+			return web.NewRequestError(err, http.StatusNotFound)
+		default:
+			return errors.Wrapf(err, "ID: %s", params["id"])
+		}
+	}
+
+	return web.Respond(ctx, w, prod, http.StatusOK)
+}
+
+// Create inserts a new project into the system.
+func (p *Project) Create(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.Project.Create")
+	defer span.End()
+
+	dbConn := p.MasterDB.Copy()
+	defer dbConn.Close()
+
+	v, ok := ctx.Value(web.KeyValues).(*web.Values)
+	if !ok {
+		return web.NewShutdownError("web value missing from context")
+	}
+
+	var np project.NewProject
+	if err := web.Decode(r, &np); err != nil {
+		return errors.Wrap(err, "")
+	}
+
+	nUsr, err := project.Create(ctx, dbConn, &np, v.Now)
+	if err != nil {
+		return errors.Wrapf(err, "Project: %+v", &np)
+	}
+
+	return web.Respond(ctx, w, nUsr, http.StatusCreated)
+}
+
+// Update updates the specified project in the system.
+func (p *Project) Update(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.Project.Update")
+	defer span.End()
+
+	dbConn := p.MasterDB.Copy()
+	defer dbConn.Close()
+
+	v, ok := ctx.Value(web.KeyValues).(*web.Values)
+	if !ok {
+		return web.NewShutdownError("web value missing from context")
+	}
+
+	var up project.UpdateProject
+	if err := web.Decode(r, &up); err != nil {
+		return errors.Wrap(err, "")
+	}
+
+	err := project.Update(ctx, dbConn, params["id"], up, v.Now)
+	if err != nil {
+		switch err {
+		case project.ErrInvalidID:
+			return web.NewRequestError(err, http.StatusBadRequest)
+		case project.ErrNotFound:
+			return web.NewRequestError(err, http.StatusNotFound)
+		default:
+			return errors.Wrapf(err, "ID: %s Update: %+v", params["id"], up)
+		}
+	}
+
+	return web.Respond(ctx, w, nil, http.StatusNoContent)
+}
+
+// Delete removes the specified project from the system.
+func (p *Project) Delete(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.Project.Delete")
+	defer span.End()
+
+	dbConn := p.MasterDB.Copy()
+	defer dbConn.Close()
+
+	err := project.Delete(ctx, dbConn, params["id"])
+	if err != nil {
+		switch err {
+		case project.ErrInvalidID:
+			return web.NewRequestError(err, http.StatusBadRequest)
+		case project.ErrNotFound:
+			return web.NewRequestError(err, http.StatusNotFound)
+		default:
+			return errors.Wrapf(err, "Id: %s", params["id"])
+		}
+	}
+
+	return web.Respond(ctx, w, nil, http.StatusNoContent)
+}

example-project/cmd/web-api/handlers/routes.go

@@ -0,0 +1,51 @@
+package handlers
+
+import (
+	"log"
+	"net/http"
+	"os"
+
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/mid"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/auth"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/db"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/web"
+)
+
+// API returns a handler for a set of routes.
+func API(shutdown chan os.Signal, log *log.Logger, masterDB *db.DB, authenticator *auth.Authenticator) http.Handler {
+
+	// Construct the web.App which holds all routes as well as common Middleware.
+	app := web.NewApp(shutdown, log, mid.Logger(log), mid.Errors(log), mid.Metrics(), mid.Panics())
+
+	// Register health check endpoint. This route is not authenticated.
+	check := Check{
+		MasterDB: masterDB,
+	}
+	app.Handle("GET", "/v1/health", check.Health)
+
+	// Register user management and authentication endpoints.
+	u := User{
+		MasterDB:       masterDB,
+		TokenGenerator: authenticator,
+	}
+	app.Handle("GET", "/v1/users", u.List, mid.Authenticate(authenticator), mid.HasRole(auth.RoleAdmin))
+	app.Handle("POST", "/v1/users", u.Create, mid.Authenticate(authenticator), mid.HasRole(auth.RoleAdmin))
+	app.Handle("GET", "/v1/users/:id", u.Retrieve, mid.Authenticate(authenticator))
+	app.Handle("PUT", "/v1/users/:id", u.Update, mid.Authenticate(authenticator), mid.HasRole(auth.RoleAdmin))
+	app.Handle("DELETE", "/v1/users/:id", u.Delete, mid.Authenticate(authenticator), mid.HasRole(auth.RoleAdmin))
+
+	// This route is not authenticated
+	app.Handle("GET", "/v1/users/token", u.Token)
+
+	// Register project and sale endpoints.
+	p := Project{
+		MasterDB: masterDB,
+	}
+	app.Handle("GET", "/v1/projects", p.List, mid.Authenticate(authenticator))
+	app.Handle("POST", "/v1/projects", p.Create, mid.Authenticate(authenticator))
+	app.Handle("GET", "/v1/projects/:id", p.Retrieve, mid.Authenticate(authenticator))
+	app.Handle("PUT", "/v1/projects/:id", p.Update, mid.Authenticate(authenticator))
+	app.Handle("DELETE", "/v1/projects/:id", p.Delete, mid.Authenticate(authenticator))
+
+	return app
+}

example-project/cmd/web-api/handlers/user.go

@@ -0,0 +1,186 @@
+package handlers
+
+import (
+	"context"
+	"net/http"
+
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/auth"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/db"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/platform/web"
+	"geeks-accelerator/oss/saas-starter-kit/example-project/internal/user"
+	"github.com/pkg/errors"
+	"go.opencensus.io/trace"
+)
+
+// User represents the User API method handler set.
+type User struct {
+	MasterDB       *db.DB
+	TokenGenerator user.TokenGenerator
+
+	// ADD OTHER STATE LIKE THE LOGGER AND CONFIG HERE.
+}
+
+// List returns all the existing users in the system.
+func (u *User) List(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.User.List")
+	defer span.End()
+
+	dbConn := u.MasterDB.Copy()
+	defer dbConn.Close()
+
+	usrs, err := user.List(ctx, dbConn)
+	if err != nil {
+		return err
+	}
+
+	return web.Respond(ctx, w, usrs, http.StatusOK)
+}
+
+// Retrieve returns the specified user from the system.
+func (u *User) Retrieve(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.User.Retrieve")
+	defer span.End()
+
+	dbConn := u.MasterDB.Copy()
+	defer dbConn.Close()
+
+	claims, ok := ctx.Value(auth.Key).(auth.Claims)
+	if !ok {
+		return errors.New("claims missing from context")
+	}
+
+	usr, err := user.Retrieve(ctx, claims, dbConn, params["id"])
+	if err != nil {
+		switch err {
+		case user.ErrInvalidID:
+			return web.NewRequestError(err, http.StatusBadRequest)
+		case user.ErrNotFound:
+			return web.NewRequestError(err, http.StatusNotFound)
+		case user.ErrForbidden:
+			return web.NewRequestError(err, http.StatusForbidden)
+		default:
+			return errors.Wrapf(err, "Id: %s", params["id"])
+		}
+	}
+
+	return web.Respond(ctx, w, usr, http.StatusOK)
+}
+
+// Create inserts a new user into the system.
+func (u *User) Create(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.User.Create")
+	defer span.End()
+
+	dbConn := u.MasterDB.Copy()
+	defer dbConn.Close()
+
+	v, ok := ctx.Value(web.KeyValues).(*web.Values)
+	if !ok {
+		return web.NewShutdownError("web value missing from context")
+	}
+
+	var newU user.NewUser
+	if err := web.Decode(r, &newU); err != nil {
+		return errors.Wrap(err, "")
+	}
+
+	usr, err := user.Create(ctx, dbConn, &newU, v.Now)
+	if err != nil {
+		return errors.Wrapf(err, "User: %+v", &usr)
+	}
+
+	return web.Respond(ctx, w, usr, http.StatusCreated)
+}
+
+// Update updates the specified user in the system.
+func (u *User) Update(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.User.Update")
+	defer span.End()
+
+	dbConn := u.MasterDB.Copy()
+	defer dbConn.Close()
+
+	v, ok := ctx.Value(web.KeyValues).(*web.Values)
+	if !ok {
+		return web.NewShutdownError("web value missing from context")
+	}
+
+	var upd user.UpdateUser
+	if err := web.Decode(r, &upd); err != nil {
+		return errors.Wrap(err, "")
+	}
+
+	err := user.Update(ctx, dbConn, params["id"], &upd, v.Now)
+	if err != nil {
+		switch err {
+		case user.ErrInvalidID:
+			return web.NewRequestError(err, http.StatusBadRequest)
+		case user.ErrNotFound:
+			return web.NewRequestError(err, http.StatusNotFound)
+		case user.ErrForbidden:
+			return web.NewRequestError(err, http.StatusForbidden)
+		default:
+			return errors.Wrapf(err, "Id: %s  User: %+v", params["id"], &upd)
+		}
+	}
+
+	return web.Respond(ctx, w, nil, http.StatusNoContent)
+}
+
+// Delete removes the specified user from the system.
+func (u *User) Delete(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.User.Delete")
+	defer span.End()
+
+	dbConn := u.MasterDB.Copy()
+	defer dbConn.Close()
+
+	err := user.Delete(ctx, dbConn, params["id"])
+	if err != nil {
+		switch err {
+		case user.ErrInvalidID:
+			return web.NewRequestError(err, http.StatusBadRequest)
+		case user.ErrNotFound:
+			return web.NewRequestError(err, http.StatusNotFound)
+		case user.ErrForbidden:
+			return web.NewRequestError(err, http.StatusForbidden)
+		default:
+			return errors.Wrapf(err, "Id: %s", params["id"])
+		}
+	}
+
+	return web.Respond(ctx, w, nil, http.StatusNoContent)
+}
+
+// Token handles a request to authenticate a user. It expects a request using
+// Basic Auth with a user's email and password. It responds with a JWT.
+func (u *User) Token(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
+	ctx, span := trace.StartSpan(ctx, "handlers.User.Token")
+	defer span.End()
+
+	dbConn := u.MasterDB.Copy()
+	defer dbConn.Close()
+
+	v, ok := ctx.Value(web.KeyValues).(*web.Values)
+	if !ok {
+		return web.NewShutdownError("web value missing from context")
+	}
+
+	email, pass, ok := r.BasicAuth()
+	if !ok {
+		err := errors.New("must provide email and password in Basic auth")
+		return web.NewRequestError(err, http.StatusUnauthorized)
+	}
+
+	tkn, err := user.Authenticate(ctx, dbConn, u.TokenGenerator, v.Now, email, pass)
+	if err != nil {
+		switch err {
+		case user.ErrAuthenticationFailure:
+			return web.NewRequestError(err, http.StatusUnauthorized)
+		default:
+			return errors.Wrap(err, "authenticating")
+		}
+	}
+
+	return web.Respond(ctx, w, tkn, http.StatusOK)
+}