+
+# SimpleAuth.link API
+
+> Passwordless authentication for your users using just an email address.
+
+This repository contains the source code of the SimpleAuth.link API Service.
+
+Read full [documentation here](https://docs.simpleauth.link).
+
+---
+
+## Technical Details π»
+
+### Token Generation Process π
+
+* By leveraging the Ed25519 signature algorithm, the service deterministically generates a private key using your App ID and secret.
+* This ensures that each token is cryptographically secure and uniquely tied to your application, eliminating the need to store sensitive keys.
+
+### Stateless Architecture ποΈ
+
+* SimpleAuth.link works without a traditional database. It does not store any user data, including email addresses, on its servers.
+* Instead, the data generated is self-contained, requiring no further information or state to be used. This stateless design increases security and reduces the risk of data breaches.
+
+## Development π§βπ»
+
+### Prerequisites π
+ - Go (version 1.24 or later recommended)
+ - Docker (optional, for containerized deployment)
+
+### Clone the Repository π₯
+```sh
+git clone --branch v2 https://github.com/SimpleAuthLink/authapi.git
+cd authapi
+```
+
+### Code Structure πͺ
+* Modularity: The repository is structured into packages to simplify testing and future expansion.
+ - `api/`: Contains the core API endpoint definitions and routing logic.
+ - `cmd/`: Entry points and command-line utilities for running the API server.
+ - `docker/`: Dockerfiles and configuration for containerized builds.
+ - `internal/`: Internal packages and libraries used across the application.
+ - `notification/`: Code handling user notifications.
+ - `token/`: Modules for token creation and management.
+ - `.github/`: GitHub-specific workflows and configurations (CI/CD, issue templates, etc.).
+
+ This layout supports modular development and clear separation of concerns across different parts of the API service.
+
+* Testing: Use the standard Go testing framework to run tests. You can run tests with:
+ ```sh
+ go test ./...
+ ```
+
+### Run with go π¦«
+For development purposes, you can run the API server directly with Go.
+```sh
+go run ./cmd/authapi -h
+```
+```sh
+Usage of authapi:
+ -email-addr string
+ email account address
+ -email-host string
+ email server host
+ -email-pass string
+ email account password
+ -email-port int
+ email server port (default 587)
+ -host string
+ service host (default "0.0.0.0")
+ -port int
+ service host (default 8080)
+ -secret string
+ secret used to generate the tokens (default "simpleauthlink-secret")
+```
+
+### Run with docker π³
+
+1. **Prepare the Environment File**
+
+ Copy the `example.env` file to `.env` and edit the file to fill in your parameters:
+ ```bash
+ HOST="localhost"
+ PORT=8080
+ EMAIL_ADDR="test@test.com"
+ EMAIL_PASS="smtp_server_password"
+ EMAIL_HOST="smtp.example.com"
+ EMAIL_PORT=587
+ SECRET="my_backend_secret"
+ ```
+
+2. **Build the Docker Image**
+
+ Run the following command in the root of your project to build the image:
+ ```bash
+ docker build -f docker/Dockerfile.prod -t simpleauthlink .
+ ```
+
+3. **Run the Docker Container**
+
+ Once the image is built, start a container using the environment file:
+ ```bash
+ docker run --name simpleauthlink --env-file .env -p 8080:80 simpleauthlink
+ ```
+ This command maps the containerβs port 80 to port 8080 on your host.
\ No newline at end of file
diff --git a/api/apps.go b/api/apps.go
deleted file mode 100644
index cd78c48..0000000
--- a/api/apps.go
+++ /dev/null
@@ -1,177 +0,0 @@
-package api
-
-import (
- "encoding/hex"
- "fmt"
-
- "github.com/simpleauthlink/authapi/db"
- "github.com/simpleauthlink/authapi/helpers"
-)
-
-// authApp method creates a new app based on the provided name, email, redirectURL
-// and duration. It returns the app id and the app secret. If the name, email or
-// redirectURL are empty, it returns an error. If the duration is less than the
-// minimum duration, it returns an error. If something fails during the process,
-// it returns an error. The app id and the app secret are generated based on the
-// email using the generateApp function. The app is stored in the database using
-// the app id as the key. The secret is stored in the database using the hashed
-// secret as the key. The hashed secret is required to be compared with the
-// secret provided by the user in the requests.
-func (s *Service) authApp(name, email, redirectURL string, duration uint64) (string, string, error) {
- // check if the name, email, and redirectURL are not empty
- if len(name) == 0 || len(email) == 0 || len(redirectURL) == 0 {
- return "", "", fmt.Errorf("name, email, and redirectURL are required")
- }
- // check if the duration is valid
- if duration < helpers.MinTokenDuration {
- return "", "", fmt.Errorf("duration must be at least %d seconds", helpers.MinTokenDuration)
- }
- // compose the app struct for the database
- appData := &db.App{
- Name: name,
- AdminEmail: email,
- SessionDuration: duration,
- RedirectURL: redirectURL,
- UsersQuota: helpers.DefaultUsersQuota,
- }
- // generate app based on email
- appId, secret, hSecret, err := generateApp(appData.AdminEmail)
- if err != nil {
- return "", "", err
- }
- // store app in the database
- if err := s.db.SetApp(appId, appData); err != nil {
- return "", "", err
- }
- // store secret in the database
- if err := s.db.SetSecret(hSecret, appId); err != nil {
- return "", "", err
- }
- return appId, secret, nil
-}
-
-// appMetadata method retrieves the app data based on the app id. If the app id is
-// empty, it returns an error. If something fails during the process, it returns
-// an error. The app data includes the name, the email of the admin, the redirect
-// URL, the duration, the users quota, and the current users. The current users
-// are retrieved from the database using the app id to count the number of tokens
-// for the app.
-func (s *Service) appMetadata(appId string) (AppData, error) {
- dbApp, err := s.db.AppById(appId)
- if err != nil {
- return AppData{}, err
- }
- app := AppData{
- Name: dbApp.Name,
- Email: dbApp.AdminEmail,
- RedirectURL: dbApp.RedirectURL,
- Duration: dbApp.SessionDuration,
- UsersQuota: dbApp.UsersQuota,
- }
- // get the number of current tokens for the app, if it fails, it returns 0
- app.CurrentUsers, _ = s.db.CountTokens(appId)
- return app, nil
-}
-
-// updateAppMetadata method updates the app metadata based on the app id, name,
-// redirectURL, and duration. If the app id is empty, it returns an error. If
-// the duration is non zero an less than the minimum duration, it returns an
-// error. If something fails during the process, it returns an error.
-func (s *Service) updateAppMetadata(appId, name, redirectURL string, duration uint64) error {
- // check if the app id is not empty
- if len(appId) == 0 {
- return fmt.Errorf("app id is required")
- }
- // check if the duration is valid
- if duration != 0 && duration < helpers.MinTokenDuration {
- return fmt.Errorf("duration must be at least %d seconds", helpers.MinTokenDuration)
- }
- // get app from the database
- app, err := s.db.AppById(appId)
- if err != nil {
- return err
- }
- // update app metadata
- if name != "" {
- app.Name = name
- }
- if redirectURL != "" {
- app.RedirectURL = redirectURL
- }
- if duration != 0 {
- app.SessionDuration = duration
- }
- // store app in the database
- return s.db.SetApp(appId, app)
-}
-
-// removeApp method removes an app based on the app id. If the app id is empty,
-// it returns an error. If something fails during the process, it returns an
-// error. It also removes all the tokens for the app from the database using
-// the app id as the prefix to find them.
-func (s *Service) removeApp(appId string) error {
- // check if the app id is not empty
- if len(appId) == 0 {
- return fmt.Errorf("app id is required")
- }
- // remove all the tokens for the app from the database, using the app id as
- // the prefix
- if err := s.db.DeleteTokensByPrefix(appId); err != nil {
- return err
- }
- // remove app from the database
- return s.db.DeleteApp(appId)
-}
-
-func (s *Service) validSecret(appId, rawSecret string) bool {
- secret, err := helpers.Hash(rawSecret, helpers.SecretSize)
- if err != nil {
- return false
- }
- valid, err := s.db.ValidSecret(secret, appId)
- if err != nil {
- return false
- }
- return valid
-}
-
-// generateApp function generates an app based on the email. It returns the app
-// id, the app secret and the hashed secret. If the email is empty or something
-// fails during the process, it returns an error. The app id is generated
-// hashing the email with a length of 4 bytes. The app secret is generated
-// using the appSecret function.
-func generateApp(email string) (string, string, string, error) {
- if len(email) == 0 {
- return "", "", "", fmt.Errorf("email is required")
- }
- // hash email
- hEmail, err := helpers.Hash(email, helpers.EmailHashSize)
- if err != nil {
- return "", "", "", err
- }
- bAppNonce := helpers.RandBytes(helpers.AppNonceSize)
- hAppNonce := hex.EncodeToString(bAppNonce)
- appId := hEmail + hAppNonce
- // generate secret
- secret, hSecret, err := appSecret()
- if err != nil {
- return "", "", "", err
- }
- return appId, secret, hSecret, nil
-}
-
-// appSecret function generates an new app secret. It returns the secret, the
-// hashed secret and an error if something fails during the process. The secret
-// is a random sequence of 16 bytes encoded as a hexadecimal string. The hashed
-// secret is required to store the secret in the database without exposing it.
-func appSecret() (string, string, error) {
- // generate secret
- bSecret := helpers.RandBytes(helpers.SecretSize)
- secret := hex.EncodeToString(bSecret)
- // hash secret
- hSecret, err := helpers.Hash(secret, helpers.SecretSize)
- if err != nil {
- return "", "", err
- }
- return secret, hSecret, nil
-}
diff --git a/api/errors.go b/api/errors.go
new file mode 100644
index 0000000..6613cf8
--- /dev/null
+++ b/api/errors.go
@@ -0,0 +1,27 @@
+package api
+
+import (
+ "net/http"
+
+ "github.com/simpleauthlink/authapi/api/io"
+)
+
+var (
+ // Decode data errors
+ DecodeAppIDRequestErr = io.NewAPIError(1001, http.StatusBadRequest).With("could not decode app id request")
+ DecodeTokenRequestErr = io.NewAPIError(1002, http.StatusBadRequest).With("could not decode token request")
+ DecodeTokenStatusRequestErr = io.NewAPIError(1003, http.StatusBadRequest).With("could not decode token status request")
+ // Encode data errors
+ EncodeAppIDResponseErr = io.NewAPIError(1010, http.StatusInternalServerError).With("could not encode app id response")
+ EncodeTokenStatusResponseErr = io.NewAPIError(1011, http.StatusInternalServerError).With("could not encode token status response")
+ // Bad request errors
+ InvalidAppHeadersErr = io.NewAPIError(1020, http.StatusBadRequest).With("invalid app headers")
+ InvalidAppIDErr = io.NewAPIError(1021, http.StatusBadRequest).With("invalid app id")
+ InvalidAppSecretErr = io.NewAPIError(1022, http.StatusBadRequest).With("invalid app secret")
+ InvalidDemoEmailInboxErr = io.NewAPIError(1023, http.StatusBadRequest).With("invalid demo email inbox")
+ // Internal errors
+ GenerateTokenErr = io.NewAPIError(1030, http.StatusInternalServerError).With("could not generate token")
+ GenerateEmailErr = io.NewAPIError(1031, http.StatusInternalServerError).With("could not generate email")
+ SendEmailErr = io.NewAPIError(1032, http.StatusInternalServerError).With("could not send email")
+ InternalErr = io.NewAPIError(1033, http.StatusInternalServerError).With("internal server error")
+)
diff --git a/api/handlers.go b/api/handlers.go
index dc2c72f..95f0ae4 100644
--- a/api/handlers.go
+++ b/api/handlers.go
@@ -1,321 +1,168 @@
package api
import (
- "encoding/json"
"fmt"
- "io"
- "log"
"net/http"
- "github.com/simpleauthlink/authapi/db"
- "github.com/simpleauthlink/authapi/email"
- "github.com/simpleauthlink/authapi/helpers"
+ "github.com/simpleauthlink/authapi/api/io"
+ "github.com/simpleauthlink/authapi/notification"
+ "github.com/simpleauthlink/authapi/notification/templates/login"
+ "github.com/simpleauthlink/authapi/token"
)
-// userTokenHandler method generates a token for the user and sends it via email
-// to the user's email address. The token is generated based on the app id
-// and the user's email address. The token is stored in the database with an
-// expiration time. It gets the app secret from the helpers.AppSecretHeader
-// header and the user's email address from the request body. If it success it
-// sends an "Ok" response. If something goes wrong, it sends an internal server
-// error response. If the app secret is missing or the request body is invalid,
-// it sends a bad request response.
-func (s *Service) userTokenHandler(w http.ResponseWriter, r *http.Request) {
- // read the app token header
- appSecret := r.Header.Get(helpers.AppSecretHeader)
- if appSecret == "" {
- http.Error(w, "missing app token", http.StatusBadRequest)
- return
- }
- // read body
- defer r.Body.Close()
- body, err := io.ReadAll(r.Body)
- if err != nil {
- log.Println("ERR: error reading request body:", err)
- http.Error(w, "error reading request body", http.StatusInternalServerError)
- return
- }
- // parse request
- req := &TokenRequest{}
- if err := json.Unmarshal(body, req); err != nil {
- log.Println("ERR: error parsing request body:", err)
- http.Error(w, "error parsing request body", http.StatusBadRequest)
- return
- }
- // check if the email is allowed
- if !s.emailQueue.Allowed(req.Email) {
- http.Error(w, "disallowed domain", http.StatusBadRequest)
- return
- }
- // generate token
- magicLink, token, appName, err := s.magicLink(appSecret, req.Email, req.RedirectURL, req.Duration)
- if err != nil {
- log.Println("ERR: error generating token:", err)
- http.Error(w, "error generating token", http.StatusInternalServerError)
- return
- }
- // compose and push the email to the queue to be sent, if it fails, delete
- // the token from the database, log the error and send an error response
- emailData := email.NewUserEmailData(appName, req.Email, magicLink, token)
- emailBody, err := email.ParseTemplate(s.cfg.TokenEmailTemplate, emailData)
- if err != nil {
- log.Println("ERR: error parsing email template:", err)
- http.Error(w, "error parsing email template", http.StatusInternalServerError)
- return
- }
- if err := s.emailQueue.Push(&email.Email{
- To: req.Email,
- Subject: fmt.Sprintf(userTokenSubject, appName),
- Body: emailBody,
- }); err != nil {
- log.Println("ERR: error sending email:", err)
- if err := s.db.DeleteToken(db.Token(token)); err != nil {
- log.Println("ERR: error deleting token:", err)
- }
- http.Error(w, "error sending email", http.StatusInternalServerError)
- return
- }
- // send response
- if _, err := w.Write([]byte("Ok")); err != nil {
- log.Println("ERR: error sending response:", err)
- http.Error(w, "error sending response", http.StatusInternalServerError)
- return
- }
+// generateAppIDHandler handles the request to generate an app id it decodes
+// the app data from the request body and returns the app id in the response
+// body. Every app data information is required to generate the app id. The
+// app id is a self-contained representation of the app that can be used to
+// generate tokens. It is created by encoding the app as a base64-encoded
+// byte slice resulting in concatenating the app name, redirect uri, and
+// session duration.
+func (s *Service) generateAppIDHandler(w http.ResponseWriter, r *http.Request) {
+ // decode the app data from the request body
+ req := new(io.Request[AppIDRequest])
+ if err := req.Read(r); err != nil {
+ DecodeAppIDRequestErr.WithErr(err).Write(w)
+ return
+ }
+ // create the app from the data and check if it is valid
+ app, appSecret := req.Data.parseApp()
+ secret := new(token.Secret).SetParts([]byte(s.cfg.Secret), []byte(appSecret))
+ app.SetSecret(secret)
+ if !app.Valid(secret.Hash()) {
+ InvalidAppIDErr.Write(w)
+ return
+ }
+ // return the app id
+ io.ResponseWith(&AppIDResponse{app.ID(secret).String()}).WriteJSON(w)
}
-// validateUserTokenHandler method validates the user token. It gets the token
-// from the helpers.TokenQueryParam query string and checks if it is valid. If
-// the token is valid, it sends a response with the "Ok" message. If the token
-// is invalid, it sends an unauthorized response. If the token is missing, it
-// sends a bad request response.
-func (s *Service) validateUserTokenHandler(w http.ResponseWriter, r *http.Request) {
- // read the app token header
- appSecret := r.Header.Get(helpers.AppSecretHeader)
- if appSecret == "" {
- http.Error(w, "missing app token", http.StatusBadRequest)
- return
- }
- // get the token from the query
- token := r.URL.Query().Get(helpers.TokenQueryParam)
- if token == "" {
- http.Error(w, "missing token", http.StatusBadRequest)
- return
- }
- // validate the token
- if !s.validUserToken(token, appSecret) {
- http.Error(w, "invalid token", http.StatusUnauthorized)
- return
- }
- if _, err := w.Write([]byte("Ok")); err != nil {
- log.Println("ERR: error sending response:", err)
- http.Error(w, "error sending response", http.StatusInternalServerError)
- return
- }
-}
-
-// appTokenHandler method generates creates an app in the service, it generates
-// an app id and a secret for the app. It sends the app id and the secret via
-// email to the app's email address. It gets the app name, email, callback, and
-// duration from the request body. If it success it sends an "Ok" response. If
-// something goes wrong, it sends an internal server error response. If the
-// request body is invalid, it sends a bad request response.
-func (s *Service) appTokenHandler(w http.ResponseWriter, r *http.Request) {
- // read body
- defer r.Body.Close()
- body, err := io.ReadAll(r.Body)
- if err != nil {
- log.Println("ERR: error reading request body:", err)
- http.Error(w, "error reading request body", http.StatusInternalServerError)
- return
- }
- app := &AppData{}
- if err := json.Unmarshal(body, app); err != nil {
- log.Println("ERR: error parsing request body:", err)
- http.Error(w, "error parsing request body", http.StatusBadRequest)
- return
- }
- // check if the email is allowed
- if !s.emailQueue.Allowed(app.Email) {
- http.Error(w, "disallowed domain", http.StatusBadRequest)
- return
- }
- // generate token
- appId, secret, err := s.authApp(app.Name, app.Email, app.RedirectURL, app.Duration)
+func (s *Service) requestTokenHandler(w http.ResponseWriter, r *http.Request) {
+ // get the app id from the request header
+ strAppID, strAppSecret, err := appConfigFromRequest(r)
if err != nil {
- log.Println("ERR: error generating token:", err)
- http.Error(w, "error generating token", http.StatusInternalServerError)
+ InvalidAppHeadersErr.WithErr(err).Write(w)
return
}
- emailData := email.NewAppEmailData(appId, app.Name, app.RedirectURL, secret, app.Email)
- emailBody, err := email.ParseTemplate(s.cfg.AppEmailTemplate, emailData)
- if err != nil {
- log.Println("ERR: error parsing email template:", err)
- http.Error(w, "error parsing email template", http.StatusInternalServerError)
+ // decode the app id get the app from it
+ appID := new(token.AppID).SetString(strAppID)
+ app := new(token.App).SetID(appID)
+ // compose the app secret with both parts
+ secret := new(token.Secret).SetParts([]byte(s.cfg.Secret), []byte(strAppSecret))
+ if !secret.Valid() {
+ InvalidAppSecretErr.Write(w)
return
}
- // compose and push the email to the queue to be sent if it fails, delete
- // the app from the database, log the error and send an error response
- if err := s.emailQueue.Push(&email.Email{
- To: app.Email,
- Subject: fmt.Sprintf(appTokenSubject, app.Name),
- Body: emailBody,
- }); err != nil {
- log.Println("ERR: error sending email:", err)
- if err := s.removeApp(appId); err != nil {
- log.Println("ERR: error deleting app:", err)
- }
- http.Error(w, "error sending email", http.StatusInternalServerError)
+ // check if the app id is valid (it should be a valid app)
+ if !app.Valid(secret.Hash()) {
+ InvalidAppIDErr.Write(w)
return
}
- // send response
- if _, err := w.Write([]byte("Ok")); err != nil {
- log.Println("ERR: error sending response:", err)
- http.Error(w, "error sending response", http.StatusInternalServerError)
+ // decode the token request from the request body
+ req := new(io.Request[TokenRequest])
+ if err := req.Read(r); err != nil {
+ DecodeTokenRequestErr.WithErr(err).Write(w)
return
}
-}
-
-// appHandler method gets the app metadata from the service. It gets the app id
-// from the token provided in the URL query. If the token is missing, it sends
-// a bad request response. If the token is invalid or is not an admin token, it
-// sends an unauthorized response. If the app is not found, it sends a not found
-// response. If it success it sends the app metadata. If something goes wrong,
-// it sends an internal server error response.
-func (s *Service) appHandler(w http.ResponseWriter, r *http.Request) {
- // read the app token header
- appSecret := r.Header.Get(helpers.AppSecretHeader)
- if appSecret == "" {
- http.Error(w, "missing app token", http.StatusBadRequest)
+ // generate user token
+ token := appID.GenerateToken(*secret, req.Data.Email)
+ if token == nil {
+ GenerateTokenErr.With(req.Data.Email).Write(w)
return
}
- // get the token from the query
- token := r.URL.Query().Get(helpers.TokenQueryParam)
- if token == "" {
- http.Error(w, "missing token", http.StatusBadRequest)
- return
+ // compose the email with the token
+ loginData := login.Data{
+ AppName: app.Name,
+ Email: req.Data.Email,
+ Token: token.String(),
+ Link: app.RedirectURI + token.String(),
}
- // validate the token and get the app id
- appId, valid := s.validAdminToken(token, appSecret)
- if !valid {
- http.Error(w, "invalid token", http.StatusUnauthorized)
- return
- }
- // get the app from the database
- app, err := s.appMetadata(appId)
- if err != nil {
- if err == db.ErrAppNotFound {
- http.Error(w, "app not found", http.StatusNotFound)
- return
- }
- log.Println("ERR: error getting app:", err)
- http.Error(w, "error getting app", http.StatusInternalServerError)
- return
- }
- // encode the app metadata
- res, err := json.Marshal(&app)
+ loginEmail, err := login.Template.Compose(notification.NotificationParams{
+ To: req.Data.Email,
+ Subject: loginData.Subject(),
+ }, loginData)
if err != nil {
- log.Println("ERR: error marshaling app:", err)
- http.Error(w, "error marshaling app", http.StatusInternalServerError)
+ GenerateEmailErr.WithErr(err).Write(w)
return
}
- // send response
- w.Header().Set("Content-Type", "application/json")
- w.WriteHeader(http.StatusOK)
- if _, err := w.Write(res); err != nil {
- log.Println("ERR: error sending response:", err)
- http.Error(w, "error sending response", http.StatusInternalServerError)
+ // push the email to the notification queue
+ if err := s.nq.Push(loginEmail); err != nil {
+ SendEmailErr.WithErr(err).Write(w)
return
}
+ io.OkResponse().WriteJSON(w)
}
-// updateAppHandler method updates an app in the service. It gets the app id
-// from the URL path and the app name, callback, and duration from the request
-// body. If the app id is missing, it sends a bad request response. If the app
-// is not found, it sends a not found response. If it success it sends an Ok
-// response. If something goes wrong, it sends an internal server error
-// response.
-func (s *Service) updateAppHandler(w http.ResponseWriter, r *http.Request) {
- // read the app token header
- appSecret := r.Header.Get(helpers.AppSecretHeader)
- if appSecret == "" {
- http.Error(w, "missing app token", http.StatusBadRequest)
- return
- }
- // get the token from the query
- token := r.URL.Query().Get(helpers.TokenQueryParam)
- if token == "" {
- http.Error(w, "missing token", http.StatusBadRequest)
- return
- }
- // validate the token and get the app id
- appId, valid := s.validAdminToken(token, appSecret)
- if !valid {
- http.Error(w, "invalid token", http.StatusUnauthorized)
- return
- }
- // read body
- defer r.Body.Close()
- body, err := io.ReadAll(r.Body)
+func (s *Service) verifyTokenHandler(w http.ResponseWriter, r *http.Request) {
+ // get the app id from the request header
+ strAppID, strAppSecret, err := appConfigFromRequest(r)
if err != nil {
- log.Println("ERR: error reading request body:", err)
- http.Error(w, "error reading request body", http.StatusInternalServerError)
+ InvalidAppHeadersErr.WithErr(err).Write(w)
return
}
- // decode the app from the request
- app := &AppData{}
- if err := json.Unmarshal(body, app); err != nil {
- log.Println("ERR: error parsing request body:", err)
- http.Error(w, "error parsing request body", http.StatusBadRequest)
+ // decode the app id get the app from it
+ appID := new(token.AppID).SetString(strAppID)
+ app := new(token.App).SetID(appID)
+ // compose the app secret with both parts
+ secret := new(token.Secret).SetParts([]byte(s.cfg.Secret), []byte(strAppSecret))
+ if !secret.Valid() {
+ InvalidAppSecretErr.Write(w)
return
}
- // update the app in the database
- if err := s.updateAppMetadata(appId, app.Name, app.RedirectURL, app.Duration); err != nil {
- log.Println("ERR: error updating app:", err)
- http.Error(w, "error updating app", http.StatusInternalServerError)
+ // check if the app id is valid (it should be a valid app)
+ if !app.Valid(secret.Hash()) {
+ InvalidAppIDErr.Write(w)
return
}
- // send response
- if _, err := w.Write([]byte("Ok")); err != nil {
- log.Println("ERR: error sending response:", err)
- http.Error(w, "error sending response", http.StatusInternalServerError)
+ // decode the token status request from the request body
+ req := new(io.Request[TokenStatusRequest])
+ if err := req.Read(r); err != nil {
+ DecodeTokenStatusRequestErr.WithErr(err).Write(w)
return
}
+ // check if the token is valid
+ tkn := new(token.Token).SetString(req.Data.Token)
+ exp := tkn.Expiration().Time()
+ io.ResponseWith(&TokenStatusResponse{
+ Valid: appID.VerifyToken(*tkn, *secret, req.Data.Email),
+ Expiration: exp,
+ }).WriteJSON(w)
}
-// delAppHandler method deletes an app from the service. It gets the app id from
-// the token provided in the URL query. If the token is missing, it sends a bad
-// request response. If the token is invalid or is not an admin token, it sends
-// an unauthorized response. If it success it sends an Ok response. If something
-// goes wrong, it sends an internal server error response.
-func (s *Service) delAppHandler(w http.ResponseWriter, r *http.Request) {
- // read the app token header
- appSecret := r.Header.Get(helpers.AppSecretHeader)
- if appSecret == "" {
- http.Error(w, "missing app token", http.StatusBadRequest)
- return
- }
- // get the token from the query
- token := r.URL.Query().Get(helpers.TokenQueryParam)
- if token == "" {
- http.Error(w, "missing token", http.StatusBadRequest)
- return
- }
- // validate the token and get the app id
- appId, valid := s.validAdminToken(token, appSecret)
- if !valid {
- http.Error(w, "invalid token", http.StatusUnauthorized)
- return
- }
- // remove the app from the service
- if err := s.removeApp(appId); err != nil {
- log.Println("ERR: error deleting app:", err)
- http.Error(w, "error deleting app", http.StatusInternalServerError)
- return
- }
- // send response
- if _, err := w.Write([]byte("Ok")); err != nil {
- log.Println("ERR: error sending response:", err)
- http.Error(w, "error sending response", http.StatusInternalServerError)
- return
+func (s *Service) healthCheckHandler(w http.ResponseWriter, r *http.Request) {
+ io.OkResponse().Write(w)
+}
+
+func (s *Service) demoInboxHandler(w http.ResponseWriter, r *http.Request) {
+ // get the email from get parameters
+ email := r.URL.Query().Get("email")
+ if email == "" {
+ InvalidDemoEmailInboxErr.Write(w)
+ return
+ }
+ // set http headers required for SSE
+ w.Header().Set("Content-Type", "text/event-stream")
+ w.Header().Set("Cache-Control", "no-cache")
+ w.Header().Set("Connection", "keep-alive")
+ // create a channel for client disconnection
+ clientGone := r.Context().Done()
+ // create a response controller
+ rc := http.NewResponseController(w)
+ for {
+ select {
+ case <-s.ctx.Done():
+ case <-clientGone:
+ return
+ case msg := <-s.demoMailInbox:
+ // find the token in the email
+ if testToken := login.FindToken(email, msg); testToken != nil {
+ // send an event to the client with the token in the "data" field
+ if _, err := fmt.Fprintf(w, "data: %s\n\n", testToken); err != nil {
+ return
+ }
+ if err := rc.Flush(); err != nil {
+ return
+ }
+ }
+ }
}
}
diff --git a/api/handlers_test.go b/api/handlers_test.go
new file mode 100644
index 0000000..bc55131
--- /dev/null
+++ b/api/handlers_test.go
@@ -0,0 +1,309 @@
+package api
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "testing"
+ "time"
+
+ apiio "github.com/simpleauthlink/authapi/api/io"
+ "github.com/simpleauthlink/authapi/notification/email"
+ "github.com/simpleauthlink/authapi/notification/templates/login"
+ "github.com/simpleauthlink/authapi/token"
+)
+
+type testCaseAPIHandler[ReqType, ResType any] struct {
+ name string
+ method string
+ endpoint string
+ header http.Header
+ request *ReqType
+ response *ResType
+ err *apiio.APIError
+}
+
+func (testCase testCaseAPIHandler[Rq, Rs]) url() string {
+ return fmt.Sprintf("%s%s", testServerApiURL, testCase.endpoint)
+}
+
+func (testCase testCaseAPIHandler[Rq, Rs]) Run(t *testing.T) {
+ t.Run(testCase.name, func(t *testing.T) {
+ var reqBuffer io.Reader
+ if testCase.request != nil {
+ rawBody, err := json.Marshal(testCase.request)
+ if err != nil {
+ t.Fatalf("could not marshal request: %v", err)
+ }
+ reqBuffer = bytes.NewReader(rawBody)
+ }
+ req, err := http.NewRequest(testCase.method, testCase.url(), reqBuffer)
+ if err != nil {
+ t.Fatalf("could not create request: %v", err)
+ }
+ req.Header = testCase.header
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ t.Fatalf("could not send request: %v", err)
+ }
+ defer resp.Body.Close()
+ switch {
+ case testCase.err != nil:
+ if resp.StatusCode != testCase.err.StatusCode {
+ t.Fatalf("expected status code: %d, got: %d", testCase.err.StatusCode, resp.StatusCode)
+ }
+ err := new(apiio.APIError)
+ if err := json.NewDecoder(resp.Body).Decode(err); err != nil {
+ t.Fatalf("could not decode error response: %v", err)
+ }
+ if err.Code != testCase.err.Code {
+ t.Fatalf("expected error code: %d, got: %d", testCase.err.Code, err.Code)
+ }
+ return
+ case testCase.response != nil:
+ if resp.StatusCode != http.StatusOK {
+ t.Fatalf("expected status code: %d, got: %d", http.StatusOK, resp.StatusCode)
+ }
+ expected, err := json.Marshal(testCase.response)
+ if err != nil {
+ t.Fatalf("could not marshal response: %v", err)
+ }
+ res, err := io.ReadAll(resp.Body)
+ if err != nil {
+ t.Fatalf("could not read response: %v", err)
+ }
+ if !bytes.Equal(bytes.TrimSpace(expected), bytes.TrimSpace(res)) {
+ t.Fatalf("expected response: %s, got: %s", expected, res)
+ }
+ default:
+ if resp.StatusCode != http.StatusOK {
+ t.Fatalf("expected status code: %d, got: %d", http.StatusOK, resp.StatusCode)
+ }
+ }
+ })
+}
+
+func TestGenerateAppIDHandler(t *testing.T) {
+ testApp := &token.App{
+ Name: testAppName,
+ RedirectURI: testAppRedirectURL,
+ SessionDuration: testAppSessionDuration,
+ }
+ secret := new(token.Secret).SetParts([]byte(testServerSecret), []byte(testAppSecret))
+ testApp.SetSecret(secret)
+ testCaseAPIHandler[AppIDRequest, AppIDResponse]{
+ name: "valid request",
+ method: http.MethodPost,
+ endpoint: AppsPath,
+ request: &AppIDRequest{
+ Name: testApp.Name,
+ RedirectURL: testApp.RedirectURI,
+ Duration: testApp.SessionDuration.String(),
+ Secret: testAppSecret,
+ },
+ response: &AppIDResponse{
+ ID: testApp.ID(secret).String(),
+ },
+ }.Run(t)
+ testCaseAPIHandler[AppIDRequest, AppIDResponse]{
+ name: "no request",
+ method: http.MethodPost,
+ endpoint: AppsPath,
+ request: nil,
+ err: DecodeAppIDRequestErr,
+ }.Run(t)
+ testCaseAPIHandler[AppIDRequest, AppIDResponse]{
+ name: "invalid request",
+ method: http.MethodPost,
+ endpoint: AppsPath,
+ request: &AppIDRequest{
+ Name: testAppName,
+ RedirectURL: testAppRedirectURL,
+ Duration: time.Second.String(),
+ Secret: testAppSecret,
+ },
+ err: InvalidAppIDErr,
+ }.Run(t)
+}
+
+func TestRequestTokenAndStatusHandler(t *testing.T) {
+ testApp := &token.App{
+ Name: testAppName,
+ RedirectURI: testAppRedirectURL,
+ SessionDuration: testAppSessionDuration,
+ }
+ secret := new(token.Secret).SetParts([]byte(testServerSecret), []byte(testAppSecret))
+ testApp.SetSecret(secret)
+ testAppID := testApp.ID(secret)
+ testCaseAPIHandler[TokenRequest, any]{
+ name: "no appID request",
+ method: http.MethodPost,
+ endpoint: TokensPath,
+ header: http.Header{
+ appSecretHeader: []string{testAppSecret},
+ },
+ request: &TokenRequest{
+ Email: testUserEmail,
+ },
+ response: nil,
+ err: InvalidAppHeadersErr,
+ }.Run(t)
+ testCaseAPIHandler[TokenRequest, any]{
+ name: "invalid app id request",
+ method: http.MethodPost,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{"invalid"},
+ appSecretHeader: []string{testAppSecret},
+ },
+ request: &TokenRequest{
+ Email: testUserEmail,
+ },
+ response: nil,
+ err: InvalidAppIDErr,
+ }.Run(t)
+ testCaseAPIHandler[TokenRequest, any]{
+ name: "no app secret request",
+ method: http.MethodPost,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{testAppID.String()},
+ },
+ request: &TokenRequest{
+ Email: testUserEmail,
+ },
+ response: nil,
+ err: InvalidAppHeadersErr,
+ }.Run(t)
+ testCaseAPIHandler[TokenRequest, any]{
+ name: "no email provided",
+ method: http.MethodPost,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{testAppID.String()},
+ appSecretHeader: []string{testAppSecret},
+ },
+ request: &TokenRequest{
+ Email: "",
+ },
+ response: nil,
+ err: GenerateTokenErr,
+ }.Run(t)
+ invalid := []byte("invalid")
+ testCaseAPIHandler[[]byte, any]{
+ name: "no request",
+ method: http.MethodPost,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{testAppID.String()},
+ appSecretHeader: []string{testAppSecret},
+ },
+ request: &invalid,
+ response: nil,
+ err: DecodeTokenRequestErr,
+ }.Run(t)
+
+ login.Template = email.EmailTemplate{
+ HTML: "",
+ Plain: `\[{{.Token}}]`,
+ }
+ testCaseAPIHandler[TokenRequest, any]{
+ name: "valid request",
+ method: http.MethodPost,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{testAppID.String()},
+ appSecretHeader: []string{testAppSecret},
+ },
+ request: &TokenRequest{
+ Email: testUserEmail,
+ },
+ response: nil,
+ }.Run(t)
+
+ var testToken *token.Token
+ select {
+ case receivedMsg := <-inboxChan:
+ testToken = login.FindToken(testUserEmail, receivedMsg)
+ if testToken == nil {
+ t.Fatal("could not find token in email")
+ }
+ break
+ case <-time.After(2 * time.Second):
+ t.Fatal("timed out waiting for the email to be received")
+ }
+
+ testCaseAPIHandler[TokenStatusRequest, TokenStatusResponse]{
+ name: "valid token status request",
+ method: http.MethodPut,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{testAppID.String()},
+ appSecretHeader: []string{testAppSecret},
+ },
+ request: &TokenStatusRequest{
+ Token: testToken.String(),
+ Email: testUserEmail,
+ },
+ response: &TokenStatusResponse{
+ Valid: true,
+ Expiration: testToken.Expiration().Time(),
+ },
+ }.Run(t)
+
+ testCaseAPIHandler[TokenStatusRequest, any]{
+ name: "invalid app id",
+ method: http.MethodPut,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{"invalid"},
+ appSecretHeader: []string{testAppSecret},
+ },
+ request: &TokenStatusRequest{
+ Token: testToken.String(),
+ Email: testUserEmail,
+ },
+ response: nil,
+ err: InvalidAppIDErr,
+ }.Run(t)
+
+ testCaseAPIHandler[TokenStatusRequest, any]{
+ name: "no app secret",
+ method: http.MethodPut,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{testAppID.String()},
+ },
+ request: &TokenStatusRequest{
+ Token: testToken.String(),
+ Email: testUserEmail,
+ },
+ response: nil,
+ err: InvalidAppHeadersErr,
+ }.Run(t)
+
+ testCaseAPIHandler[TokenStatusRequest, any]{
+ name: "no headers",
+ method: http.MethodPut,
+ endpoint: TokensPath,
+ request: &TokenStatusRequest{
+ Token: testToken.String(),
+ Email: testUserEmail,
+ },
+ response: nil,
+ err: InvalidAppHeadersErr,
+ }.Run(t)
+
+ testCaseAPIHandler[any, any]{
+ name: "no request",
+ method: http.MethodPut,
+ endpoint: TokensPath,
+ header: http.Header{
+ appIDHeader: []string{testAppID.String()},
+ appSecretHeader: []string{testAppSecret},
+ },
+ err: DecodeTokenStatusRequestErr,
+ }.Run(t)
+}
diff --git a/api/helpers.go b/api/helpers.go
new file mode 100644
index 0000000..3511b7d
--- /dev/null
+++ b/api/helpers.go
@@ -0,0 +1,25 @@
+package api
+
+import (
+ "fmt"
+ "net/http"
+)
+
+// appConfigFromRequest extracts the app id and app secret from the request
+// headers. It returns an error if the app id or app secret is missing. The
+// app id and app secret are used to authenticate the app making the request.
+// The app id is a unique identifier for the app, and the app secret is a
+// shared secret used to verify the authenticity of the request for this
+// service.
+func appConfigFromRequest(r *http.Request) (string, string, error) {
+ // get the app id from the request header
+ strAppID := r.Header.Get(appIDHeader)
+ if strAppID == "" {
+ return "", "", fmt.Errorf("missing app id")
+ }
+ strAppSecret := r.Header.Get(appSecretHeader)
+ if strAppSecret == "" {
+ return "", "", fmt.Errorf("missing app secret")
+ }
+ return strAppID, strAppSecret, nil
+}
diff --git a/api/helpers_test.go b/api/helpers_test.go
new file mode 100644
index 0000000..8d0c9e8
--- /dev/null
+++ b/api/helpers_test.go
@@ -0,0 +1,60 @@
+package api
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestAppConfigFromRequest(t *testing.T) {
+ tests := []struct {
+ name string
+ headers map[string]string
+ expectedAppID string
+ expectedSecret string
+ expectError bool
+ }{
+ {
+ name: "Valid headers",
+ headers: map[string]string{appIDHeader: "testAppID", appSecretHeader: "testAppSecret"},
+ expectedAppID: "testAppID",
+ expectedSecret: "testAppSecret",
+ expectError: false,
+ },
+ {
+ name: "Missing app id",
+ headers: map[string]string{appSecretHeader: "testAppSecret"},
+ expectError: true,
+ },
+ {
+ name: "Missing app secret",
+ headers: map[string]string{appIDHeader: "testAppID"},
+ expectError: true,
+ },
+ {
+ name: "Missing both headers",
+ headers: map[string]string{},
+ expectError: true,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ req := httptest.NewRequest(http.MethodGet, "/", nil)
+ for key, value := range tt.headers {
+ req.Header.Set(key, value)
+ }
+
+ appID, appSecret, err := appConfigFromRequest(req)
+ if (err != nil) != tt.expectError {
+ t.Errorf("expected error: %v, got: %v", tt.expectError, err)
+ }
+ if appID != tt.expectedAppID {
+ t.Errorf("expected appID: %s, got: %s", tt.expectedAppID, appID)
+ }
+ if appSecret != tt.expectedSecret {
+ t.Errorf("expected appSecret: %s, got: %s", tt.expectedSecret, appSecret)
+ }
+ })
+ }
+}
diff --git a/api/io/error.go b/api/io/error.go
new file mode 100644
index 0000000..d5b77c6
--- /dev/null
+++ b/api/io/error.go
@@ -0,0 +1,88 @@
+package io
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+)
+
+// APIError represents an error response from the API. It includes a code,
+// message, and optional error string. The StatusCode field is used to set the
+// HTTP status code for the response. It has some methods to manipulate the
+// error message and write the error response to an http.ResponseWriter.
+type APIError struct {
+ Code int `json:"code"`
+ Message string `json:"message"`
+ Err string `json:"error,omitempty"`
+ StatusCode int `json:"-"`
+}
+
+// Error implements the error interface for APIError. It returns a string
+// representation of the error, including the code, message, error string,
+// and status code. It can be used for logging or debugging purposes.
+func (e *APIError) Error() string {
+ return fmt.Sprintf("code: %d, message: %s, error: %s, status_code: %d", e.Code, e.Message, e.Err, e.StatusCode)
+}
+
+// WithErr appends an error message to the existing error string in the
+// APIError. If the existing error string is empty, it sets it to the new
+// error message. This method is useful for chaining error messages together
+// for better debugging and logging. It returns the updated APIError instance
+// and also updates the current instance.
+func (e *APIError) WithErr(err error) *APIError {
+ if e.Err == "" {
+ e.Err = err.Error()
+ return e
+ }
+ e.Err = fmt.Sprintf("%s: %s", e.Err, err.Error())
+ return e
+}
+
+// With appends a string message to the existing message in the APIError. If
+// the existing message is empty, it sets it to the new message. This method
+// is useful for chaining messages together for better debugging and logging.
+// It returns the updated APIError instance and also updates the current
+// instance.
+func (e *APIError) With(msg string) *APIError {
+ if e.Message == "" {
+ e.Message = msg
+ return e
+ }
+ e.Message = fmt.Sprintf("%s: %s", e.Message, msg)
+ return e
+}
+
+// WriteJSON writes the APIError as a JSON response to the provided
+// http.ResponseWriter. It sets the Content-Type header to "application/json"
+// and writes the status code and serialized error bytes to the response.
+// If an error occurs during writing, it writes an internal server error
+// response instead.
+func (e *APIError) Write(w http.ResponseWriter) {
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(e.StatusCode)
+ if _, err := w.Write(e.bytes()); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+}
+
+// bytes serializes the APIError to JSON bytes. If an error occurs during
+// serialization, it returns nil.
+func (e *APIError) bytes() []byte {
+ bErr, err := json.Marshal(e)
+ if err != nil {
+ return nil
+ }
+ return bErr
+}
+
+// NewAPIError creates a new APIError instance with the provided code and
+// status code. It initializes the error string and message to empty strings.
+// This function is useful for creating a new APIError instance with
+// specific error codes and status codes. It returns a pointer to the
+// newly created APIError instance.
+func NewAPIError(code, status int) *APIError {
+ return &APIError{
+ Code: code,
+ StatusCode: status,
+ }
+}
diff --git a/api/io/error_test.go b/api/io/error_test.go
new file mode 100644
index 0000000..4da371f
--- /dev/null
+++ b/api/io/error_test.go
@@ -0,0 +1,90 @@
+package io
+
+import (
+ "errors"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestNewAPIError(t *testing.T) {
+ err := NewAPIError(1001, http.StatusBadRequest)
+ if err.Code != 1001 {
+ t.Errorf("expected code 1001, got %d", err.Code)
+ }
+ if err.StatusCode != http.StatusBadRequest {
+ t.Errorf("expected status code %d, got %d", http.StatusBadRequest, err.StatusCode)
+ }
+ if err.Message != "" {
+ t.Errorf("expected empty message, got %s", err.Message)
+ }
+ if err.Err != "" {
+ t.Errorf("expected empty error string, got %s", err.Err)
+ }
+}
+
+func TestAPIError_Error(t *testing.T) {
+ err := NewAPIError(1001, http.StatusBadRequest)
+ err.Message = "Bad Request"
+ err.Err = "Invalid input"
+ expected := "code: 1001, message: Bad Request, error: Invalid input, status_code: 400"
+ if err.Error() != expected {
+ t.Errorf("expected %s, got %s", expected, err.Error())
+ }
+}
+
+func TestAPIError_WithErr(t *testing.T) {
+ err := NewAPIError(1001, http.StatusBadRequest)
+ _ = err.WithErr(errors.New("Invalid input"))
+ if err.Err != "Invalid input" {
+ t.Errorf("expected error string 'Invalid input', got %s", err.Err)
+ }
+
+ _ = err.WithErr(errors.New("Missing field"))
+ if err.Err != "Invalid input: Missing field" {
+ t.Errorf("expected error string 'Invalid input: Missing field', got %s", err.Err)
+ }
+}
+
+func TestAPIError_With(t *testing.T) {
+ err := NewAPIError(1001, http.StatusBadRequest)
+ _ = err.With("Bad Request")
+ if err.Message != "Bad Request" {
+ t.Errorf("expected message 'Bad Request', got %s", err.Message)
+ }
+
+ _ = err.With("Invalid input")
+ if err.Message != "Bad Request: Invalid input" {
+ t.Errorf("expected message 'Bad Request: Invalid input', got %s", err.Message)
+ }
+}
+
+func TestAPIError_Write(t *testing.T) {
+ err := NewAPIError(1001, http.StatusBadRequest)
+ err.Message = "Bad Request"
+ err.Err = "Invalid input"
+
+ rr := httptest.NewRecorder()
+ err.Write(rr)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("expected status code %d, got %d", http.StatusBadRequest, status)
+ }
+
+ expected := `{"code":1001,"message":"Bad Request","error":"Invalid input"}`
+ if rr.Body.String() != expected {
+ t.Errorf("expected body %s, got %s", expected, rr.Body.String())
+ }
+}
+
+func TestAPIError_bytes(t *testing.T) {
+ err := NewAPIError(1001, http.StatusBadRequest)
+ err.Message = "Bad Request"
+ err.Err = "Invalid input"
+
+ data := err.bytes()
+ expected := `{"code":1001,"message":"Bad Request","error":"Invalid input"}`
+ if string(data) != expected {
+ t.Errorf("expected %s, got %s", expected, string(data))
+ }
+}
diff --git a/api/io/req.go b/api/io/req.go
new file mode 100644
index 0000000..0b9691d
--- /dev/null
+++ b/api/io/req.go
@@ -0,0 +1,39 @@
+package io
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+)
+
+// Request represents a request with a generic data type to be unmarshalled
+// from the request body. It implements the Read method to read and
+// unmarshal the request body into the Data field.
+type Request[T any] struct {
+ Data T
+}
+
+// Read reads the request body and unmarshals it into the Data field of the
+// Request struct. It returns an error if the request body is nil or empty,
+// or if there is an error during unmarshalling. If the Request struct is nil,
+// it initializes a new instance of Request[T]. This method is useful for
+// handling incoming requests in a generic way, allowing for different data
+// types to be processed without needing to define separate request structs
+// for each type.
+func (req *Request[T]) Read(r *http.Request) error {
+ if req == nil {
+ req = new(Request[T])
+ }
+ if r.Body == nil {
+ return fmt.Errorf("nil request body")
+ }
+ rawBody, err := io.ReadAll(r.Body)
+ if err != nil {
+ return fmt.Errorf("failed to read request body: %w", err)
+ }
+ if len(rawBody) == 0 {
+ return fmt.Errorf("empty request body")
+ }
+ return json.Unmarshal(rawBody, &req.Data)
+}
diff --git a/api/io/req_test.go b/api/io/req_test.go
new file mode 100644
index 0000000..98b9790
--- /dev/null
+++ b/api/io/req_test.go
@@ -0,0 +1,57 @@
+package io
+
+import (
+ "bytes"
+ "encoding/json"
+ "net/http"
+ "testing"
+)
+
+func TestRead(t *testing.T) {
+ type Data struct {
+ Message string `json:"message"`
+ }
+ data := &Data{Message: "Hello, World!"}
+ body, _ := json.Marshal(data)
+ req, err := http.NewRequest("POST", "/", bytes.NewBuffer(body))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var request Request[Data]
+ if err := request.Read(req); err != nil {
+ t.Errorf("unexpected error: %v", err)
+ }
+ if request.Data.Message != data.Message {
+ t.Errorf("expected %s, got %s", data.Message, request.Data.Message)
+ }
+}
+
+func TestRead_EmptyBody(t *testing.T) {
+ noBody, err := http.NewRequest("POST", "/", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if nilReq := new(Request[any]).Read(noBody); nilReq == nil {
+ t.Errorf("expected error, got nil")
+ }
+
+ req, err := http.NewRequest("POST", "/", bytes.NewBuffer([]byte("")))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var request *Request[any]
+ err = request.Read(req)
+ if err == nil {
+ t.Errorf("expected error, got nil")
+ }
+ err = new(Request[any]).Read(req)
+ if err == nil {
+ t.Errorf("expected error, got nil")
+ }
+ if err.Error() != "empty request body" {
+ t.Errorf("expected empty request body error, got %v", err)
+ }
+}
diff --git a/api/io/res.go b/api/io/res.go
new file mode 100644
index 0000000..a73cc8f
--- /dev/null
+++ b/api/io/res.go
@@ -0,0 +1,113 @@
+package io
+
+import (
+ "encoding/json"
+ "net/http"
+)
+
+// Response represents a response with a generic data type. It can be used to
+// send JSON responses or plain text responses. The Data field holds the
+// response data, and the empty field indicates whether the response is empty
+// or not. It has methods to write the response to an http.ResponseWriter in
+// JSON format or plain text format.
+type Response[T any] struct {
+ Data T
+ empty bool
+}
+
+// ResponseWith creates a new Response instance with the provided data. If
+// the data is nil, it returns an empty response. This method is useful for
+// creating responses with different data types without needing to define
+// separate response structs for each type. It returns a pointer to the
+// Response instance.
+func ResponseWith[T any](data *T) *Response[T] {
+ if data == nil {
+ return &Response[T]{empty: true}
+ }
+ return &Response[T]{
+ Data: *data,
+ empty: false,
+ }
+}
+
+// OkResponse creates a new Response instance with the provided byte slice.
+// If the byte slice is empty, it returns an empty response. This method is
+// useful for creating responses with raw byte data. It returns a pointer to
+// the Response instance. The empty field indicates whether the response is
+// empty or not. If the byte slice is empty, the response is considered empty.
+// If the byte slice is not empty, the response is considered non-empty.
+func OkResponse(body ...byte) *Response[any] {
+ if len(body) > 0 {
+ return &Response[any]{Data: body, empty: false}
+ }
+ return &Response[any]{empty: true}
+}
+
+// WriteJSON writes the response data to the provided http.ResponseWriter in
+// JSON format. It sets the Content-Type header to "application/json" and
+// writes the response data as JSON. If the response is empty, it writes a
+// plain text "OK" response with a 200 OK status code. If there is an error
+// during JSON encoding or response writing, it writes an error response with
+// a 500 Internal Server Error status code. This method is useful for sending
+// JSON responses to the client. It can be used in HTTP handlers or middleware
+// to send structured JSON responses.
+func (r *Response[T]) WriteJSON(w http.ResponseWriter) {
+ if !r.empty {
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ if err := json.NewEncoder(w).Encode(r.Data); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+ if _, err := w.Write([]byte(http.StatusText(http.StatusOK))); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+}
+
+// Write writes the response data to the provided http.ResponseWriter in
+// plain text format. It sets the Content-Type header to "text/plain" and
+// writes the response data as plain text. If the response is empty, it writes
+// a plain text "OK" response with a 200 OK status code. If there is an error
+// during response writing, it writes an error response with a 500 Internal
+// Server Error status code. This method is useful for sending plain text
+// responses to the client. It can be used in HTTP handlers or middleware to
+// send simple text responses. It is a more generic method than WriteJSON, as
+// it does not require the response data to be JSON-serializable.
+func (r *Response[T]) Write(w http.ResponseWriter) {
+ w.WriteHeader(http.StatusOK)
+ if r.empty {
+ if _, err := w.Write([]byte(http.StatusText(http.StatusOK))); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+ return
+ }
+ if data, ok := r.bytes(); ok {
+ if _, err := w.Write(data); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+ }
+}
+
+// bytes returns the response data as a byte slice. If the response is empty,
+// it returns nil and a boolean indicating that the response is empty. If the
+// response data is not a byte slice, it returns nil and a boolean indicating
+// that the response data is not a byte slice. This method is useful for
+// converting the response data to a byte slice for writing to the response
+// writer or for further processing.
+func (r *Response[T]) bytes() ([]byte, bool) {
+ // check if the response is empty
+ if r.empty {
+ return nil, true
+ }
+ // ensure that the response data is an slice of bytes
+ switch v := any(r.Data).(type) {
+ case []byte:
+ return v, true
+ case string:
+ return []byte(v), true
+ default:
+ return nil, false
+ }
+}
diff --git a/api/io/res_test.go b/api/io/res_test.go
new file mode 100644
index 0000000..fc6925d
--- /dev/null
+++ b/api/io/res_test.go
@@ -0,0 +1,179 @@
+package io
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestResponseWith(t *testing.T) {
+ type Data struct {
+ Message string `json:"message"`
+ }
+ nilResp := ResponseWith[Data](nil)
+ if !nilResp.empty {
+ t.Errorf("expected response to be empty")
+ }
+ data := &Data{Message: "Hello, World!"}
+ resp := ResponseWith(data)
+ if resp.empty {
+ t.Errorf("expected response to be non-empty")
+ }
+ if resp.Data.Message != data.Message {
+ t.Errorf("expected %s, got %s", data.Message, resp.Data.Message)
+ }
+}
+
+func TestOkResponse(t *testing.T) {
+ resp := OkResponse()
+ if !resp.empty {
+ t.Errorf("expected response to be empty")
+ }
+}
+
+func TestWriteJSON(t *testing.T) {
+ type Data struct {
+ Message string `json:"message"`
+ }
+ data := &Data{Message: "Hello, World!"}
+ resp := ResponseWith(data)
+
+ rr := httptest.NewRecorder()
+ resp.WriteJSON(rr)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("expected status code %d, got %d", http.StatusOK, status)
+ }
+
+ expected, _ := json.Marshal(data)
+ if rr.Body.String() != string(expected)+"\n" { // Ensure newline is accounted for
+ t.Errorf("expected body %s, got %s", string(expected)+"\n", rr.Body.String())
+ }
+ // write json with nil data
+ nilResp := ResponseWith[string](nil)
+ rr = httptest.NewRecorder()
+ nilResp.WriteJSON(rr)
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("expected status code %d, got %d", http.StatusOK, status)
+ }
+}
+
+func TestWriteJSON_Empty(t *testing.T) {
+ resp := OkResponse()
+
+ rr := httptest.NewRecorder()
+ resp.WriteJSON(rr)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("expected status code %d, got %d", http.StatusOK, status)
+ }
+
+ if rr.Body.String() != "OK" {
+ t.Errorf("expected body OK, got %s", rr.Body.String())
+ }
+}
+
+func TestOkResponse_WithBody(t *testing.T) {
+ body := []byte("Hello, World!")
+ resp := OkResponse(body...)
+
+ if resp.empty {
+ t.Errorf("expected response to be non-empty")
+ }
+
+ if string(resp.Data.([]byte)) != string(body) {
+ t.Errorf("expected body %s, got %s", string(body), string(resp.Data.([]byte)))
+ }
+}
+
+func TestWrite(t *testing.T) {
+ data := []byte("Hello, World!")
+ resp := ResponseWith(&data)
+
+ rr := httptest.NewRecorder()
+ resp.Write(rr)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("expected status code %d, got %d", http.StatusOK, status)
+ }
+
+ // Adjust to match the expected plain text output
+ if rr.Body.String() != string(data) {
+ t.Errorf("expected body %s, got %s", string(data), rr.Body.String())
+ }
+}
+
+func TestWrite_Empty(t *testing.T) {
+ resp := OkResponse()
+
+ rr := httptest.NewRecorder()
+ resp.Write(rr)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("expected status code %d, got %d", http.StatusOK, status)
+ }
+
+ if rr.Body.String() != "OK" {
+ t.Errorf("expected body OK, got %s", rr.Body.String())
+ }
+}
+
+func TestBytes(t *testing.T) {
+ body := []byte("Hello, World!")
+ resp := OkResponse(body...)
+
+ data, ok := resp.bytes()
+ if !ok {
+ t.Errorf("expected bytes to be valid")
+ }
+
+ if string(data) != string(body) {
+ t.Errorf("expected body %s, got %s", string(body), string(data))
+ }
+}
+
+func TestBytes_Empty(t *testing.T) {
+ resp := OkResponse()
+
+ data, ok := resp.bytes()
+ if !ok {
+ t.Errorf("expected bytes to be valid")
+ }
+ if data != nil {
+ t.Errorf("expected nil data for empty response, got %v", data)
+ }
+
+ // custom text response
+ bmsg := []byte("Hello, World!")
+ bresp := ResponseWith(&bmsg)
+ bdata, ok := bresp.bytes()
+ if !ok {
+ t.Errorf("expected bytes to be valid")
+ }
+ if string(bdata) != string(bmsg) {
+ t.Errorf("expected body %s, got %s", string(bmsg), string(bdata))
+ }
+
+ // string type
+ msg := "Hello, World!"
+ sresp := ResponseWith(&msg)
+ sdata, ok := sresp.bytes()
+ if !ok {
+ t.Errorf("expected bytes to be valid")
+ }
+ if string(sdata) != msg {
+ t.Errorf("expected body %s, got %s", msg, string(sdata))
+ }
+
+ // invalid type
+ imsg := 123
+ iresp := ResponseWith(&imsg)
+ idata, ok := iresp.bytes()
+ if ok {
+ t.Errorf("expected bytes to be invalid")
+ }
+ if idata != nil {
+ t.Errorf("expected nil data for invalid response, got %v", idata)
+ }
+}
diff --git a/api/routes.go b/api/routes.go
new file mode 100644
index 0000000..78631ae
--- /dev/null
+++ b/api/routes.go
@@ -0,0 +1,26 @@
+package api
+
+// routes paths constants
+const (
+ // HealthCheckPath constant is the path used to check the health of the API
+ // server. It is a string with a value of "/health".
+ HealthCheckPath = "/ping"
+ // AppsPath constant is the path used to create the apps in the API server.
+ AppsPath = "/apps"
+ // TokensPath constant is the path used to generate and verify the tokens
+ // in the API server.
+ TokensPath = "/tokens"
+ // DemoInboxPath constant is the path used to get the demo email inbox
+ // in the API server when it runs in demo mode.
+ DemoInboxPath = "/demo/inbox"
+)
+
+// other api related constants
+const (
+ // appIDHeader constant is the header of the app ID in the request. It is
+ // used to authenticate the app making the request.
+ appIDHeader = "AppID"
+ // appSecretHeader constant is the header of the app secret in the request
+ // It is used to authenticate the app making the request.
+ appSecretHeader = "AppSecret"
+)
diff --git a/api/service.go b/api/service.go
index ebe696d..acd4b30 100644
--- a/api/service.go
+++ b/api/service.go
@@ -3,7 +3,6 @@ package api
import (
"context"
"fmt"
- "log"
"net/http"
"os"
"os/signal"
@@ -12,77 +11,87 @@ import (
"time"
"github.com/lucasmenendez/apihandler"
- "github.com/simpleauthlink/authapi/db"
- "github.com/simpleauthlink/authapi/email"
- "github.com/simpleauthlink/authapi/helpers"
+ "github.com/simpleauthlink/authapi/internal/fakesmtpserver"
+ "github.com/simpleauthlink/authapi/notification"
)
-// Config struct represents the configuration needed to init the service. It
-// includes the email configuration, the server hostname, the server port, the
-// data path to store the database, and the cleaner cooldown to clean the
-// expired tokens.
+// Config struct represents the configuration for the API service. It contains
+// the server address, server port, and secret key for the service. The server
+// address is the address where the service will listen for incoming requests,
+// and the server port is the port number where the service will listen for
+// incoming requests. The secret key is used to sign and verify tokens. The
+// demo mode is used to enable or disable the demo functionality of the service.
+// The demo SMTP address and port are used to configure the demo mail server.
+// The demo mode is used to enable or disable the demo functionality of the
+// service.
type Config struct {
- email.EmailConfig
- Server string
- ServerPort int
- CleanerCooldown time.Duration
+ Server string
+ ServerPort int
+ Secret string
+ // demo stuff
+ DemoMode bool
+ DemoSMTPAddr string
+ DemoSMTPPort int
}
-// Service struct represents the service that is going to be started. It
-// includes the context and the cancel function to stop the service, the wait
-// group to wait for the background processes to finish, the configuration,
-// the database connection and the api handler.
+// Service struct represents the API service. It contains the context, cancel
+// function, wait group, configuration, notification queue, API handler, HTTP
+// server, and demo mail server. The context is used to manage the lifecycle
+// of the service, while the wait group is used to wait for background processes
+// to finish. The notification queue is used to send notifications, and the API
+// handler is used to handle incoming requests. The HTTP server is used to
+// serve the API endpoints, and the demo mail server is used to simulate
+// sending emails in demo mode.
+// The demo mail server is a fake SMTP server that captures emails sent to it
+// for testing purposes. The demo mail inbox is a channel that receives the
+// captured emails.
type Service struct {
ctx context.Context
cancel context.CancelFunc
wait sync.WaitGroup
cfg *Config
- db db.DB
- emailQueue *email.EmailQueue
+ nq notification.Queue
handler *apihandler.Handler
httpServer *http.Server
+ // demo stuff
+ demoMailServer *fakesmtpserver.FakeSMTPServer
+ demoMailInbox chan string
}
-// New function creates a new service based on the provided context, the db
-// interface and configuration. It initializes the email queue, creates the
-// service and sets the api handlers. If something goes wrong during the
-// process, it returns an error.
-func New(ctx context.Context, db db.DB, cfg *Config) (*Service, error) {
+// New function creates a new service instance. It takes a context, a config
+// struct, and a notification queue as parameters. It returns a pointer to the
+// service instance and an error if something goes wrong during the process.
+// The function is responsible for setting up the service and its dependencies.
+// It handles the configuration, rate limiting, and HTTP server setup. It also
+// manages the demo mode functionality, including the demo mail server and
+// inbox. The function is designed to be used as a constructor for the service
+// and is responsible for initializing all the necessary components for the
+// service to function properly.
+func New(ctx context.Context, cfg *Config, nq notification.Queue) (*Service, error) {
internalCtx, cancel := context.WithCancel(ctx)
- emailQueue, err := email.NewEmailQueue(internalCtx, &cfg.EmailConfig)
- if err != nil {
- if emailQueue == nil {
- cancel()
- return nil, err
- }
- log.Println("WRN: something occurs during email queue creation:", err)
- }
// create the service
srv := &Service{
- ctx: internalCtx,
- cancel: cancel,
- cfg: cfg,
- db: db,
- emailQueue: emailQueue,
- handler: apihandler.NewHandler(&apihandler.Config{
- CORS: true,
- RateLimitConfig: &apihandler.RateLimitConfig{
- Rate: 2,
- Limit: 10,
- },
- }),
+ ctx: internalCtx,
+ cancel: cancel,
+ cfg: cfg,
+ nq: nq,
+ handler: apihandler.NewHandler(true, nil),
}
- srv.handler.Get(helpers.HealthCheckPath, func(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusOK)
- })
- // user handlers
- srv.handler.Post(helpers.UserEndpointPath, srv.userTokenHandler)
- srv.handler.Get(helpers.UserEndpointPath, srv.validateUserTokenHandler)
- // app handlers
- srv.handler.Get(helpers.AppEndpointPath, srv.appHandler)
- srv.handler.Post(helpers.AppEndpointPath, srv.appTokenHandler)
- srv.handler.Put(helpers.AppEndpointPath, srv.updateAppHandler)
- srv.handler.Delete(helpers.AppEndpointPath, srv.delAppHandler)
+ // demo stuff
+ if cfg.DemoMode {
+ srv.demoMailInbox = make(chan string, 1)
+ srv.demoMailServer = fakesmtpserver.NewServer(cfg.DemoSMTPAddr,
+ cfg.DemoSMTPPort, srv.demoMailInbox)
+ if err := srv.demoMailServer.Start(internalCtx); err != nil {
+ return nil, err
+ }
+ _ = srv.handler.Get(DemoInboxPath, srv.demoInboxHandler)
+ }
+ // register the routes and handlers
+ _ = srv.handler.Post(AppsPath, srv.generateAppIDHandler)
+ _ = srv.handler.Post(TokensPath, srv.requestTokenHandler)
+ _ = srv.handler.Put(TokensPath, srv.verifyTokenHandler)
+ _ = srv.handler.Get(HealthCheckPath, srv.healthCheckHandler)
// build the http server
srv.httpServer = &http.Server{
Addr: fmt.Sprintf("%s:%d", cfg.Server, cfg.ServerPort),
@@ -91,13 +100,8 @@ func New(ctx context.Context, db db.DB, cfg *Config) (*Service, error) {
return srv, nil
}
-// Start method starts the service. It starts the token cleaner and the api
-// server. If something goes wrong during the process, it returns an error.
+// Start method starts the service by starting the http server.
func (s *Service) Start() error {
- // start the email queue
- s.emailQueue.Start()
- // start the token cleaner in the background
- s.sanityTokenCleaner()
// start the api server
if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
return err
@@ -106,19 +110,29 @@ func (s *Service) Start() error {
}
// Stop method stops the service. It cancels the context and waits for the
-// background processes to finish. It closes the database. If something goes
-// wrong during the process, it returns an error.
-func (s *Service) Stop() error {
- // close the database
- if err := s.db.Close(); err != nil {
- return fmt.Errorf("error closing db: %w", err)
- }
- // stop the email queue
- s.emailQueue.Stop()
+// background processes to finish. It also closes the http server and the
+// demo mail server if it is running.
+func (s *Service) Stop() {
// cancel the context and wait for the background processes finish
s.cancel()
defer s.wait.Wait()
- return nil
+}
+
+// Ping method checks if the service is up and running. It sends a GET request
+// to the health check endpoint and returns true if the response status code
+// is 200 OK, otherwise it returns false. If something goes wrong during the
+// process, it returns false.
+func (s *Service) Ping() bool {
+ url := fmt.Sprintf("http://%s:%d%s", s.cfg.Server, s.cfg.ServerPort, HealthCheckPath)
+ request, err := http.NewRequest(http.MethodGet, url, nil)
+ if err != nil {
+ return false
+ }
+ response, err := http.DefaultClient.Do(request)
+ if err != nil {
+ return false
+ }
+ return response.StatusCode == http.StatusOK
}
// WaitToShutdown method waits for the service to shutdown. It listens for the
@@ -128,12 +142,8 @@ func (s *Service) WaitToShutdown() error {
done := make(chan os.Signal, 1)
signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
<-done
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
- defer func() {
- if err := s.Stop(); err != nil {
- log.Println(err)
- }
- }()
+ defer s.Stop()
return s.httpServer.Shutdown(ctx)
}
diff --git a/api/service_test.go b/api/service_test.go
index c36056e..4703a1e 100644
--- a/api/service_test.go
+++ b/api/service_test.go
@@ -2,36 +2,84 @@ package api
import (
"context"
+ "fmt"
+ "os"
"testing"
"time"
- "github.com/simpleauthlink/authapi/db"
- "github.com/simpleauthlink/authapi/email"
+ "github.com/simpleauthlink/authapi/internal/fakesmtpserver"
+ "github.com/simpleauthlink/authapi/notification/email"
)
-func TestNew(t *testing.T) {
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
- defer cancel()
+const (
+ testServerAddr = "127.0.0.1"
+ testServerSMTPPort = 2526
+ testServerAPIPort = 5555
+ testServerSecret = "server-secret"
+ testSenderName = "TestAPI"
+ testSender = "api-test@testmail.com"
+ testUserEmail = "user@testmail.com"
+ testAppName = "TestApp"
+ testAppRedirectURL = "http://testapp.com"
+ testAppSessionDuration = time.Second * 35
+ testAppSecret = "test-secret"
+)
+
+var (
+ testServerApiURL = fmt.Sprintf("http://%s:%d", testServerAddr, testServerAPIPort)
+ inboxChan = make(chan string, 1)
+)
- testDB := new(db.TempDriver)
- testDB.Init(nil)
- srv, err := New(ctx, testDB, &Config{
- Server: "localhost",
- ServerPort: 8080,
- CleanerCooldown: 30 * time.Second,
- EmailConfig: email.EmailConfig{
- EmailHost: "smtp.gmail.com",
- EmailPort: 587,
- Address: "",
- Password: "",
- },
+func TestMain(m *testing.M) {
+ defer close(inboxChan)
+ // create context with cancel
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ // start test SMTP server to receive the email
+ testSrv := fakesmtpserver.NewServer(testServerAddr, testServerSMTPPort, inboxChan)
+ if err := testSrv.Start(ctx); err != nil {
+ panic(err)
+ }
+ defer testSrv.Stop()
+ // create email queue with valid config
+ eq, err := email.NewEmailQueue(ctx, &email.EmailConfig{
+ SMTPServer: testServerAddr,
+ SMTPPort: testServerSMTPPort,
+ FromName: testSenderName,
+ FromAddress: testSender,
})
if err != nil {
- t.Errorf("expected nil, got %v", err)
- return
+ panic(err)
+ }
+ eq.Start()
+ defer eq.Stop()
+ // create the API service
+ apiSrv, err := New(ctx, &Config{
+ Server: testServerAddr,
+ ServerPort: testServerAPIPort,
+ Secret: testServerSecret,
+ }, eq)
+ if err != nil {
+ panic(err)
}
- if srv == nil {
- t.Errorf("expected not nil, got nil")
- return
+ go func() {
+ if err := apiSrv.Start(); err != nil {
+ panic(err)
+ }
+ }()
+ defer apiSrv.Stop()
+ // make ping to the server to check if it is running
+ nRetries := 5
+ for {
+ if nRetries == 0 {
+ panic("API server is not running")
+ }
+ if ok := apiSrv.Ping(); ok {
+ break
+ }
+ nRetries--
+ time.Sleep(time.Second)
}
+ // run the tests
+ os.Exit(m.Run())
}
diff --git a/api/tokens.go b/api/tokens.go
deleted file mode 100644
index 2f0f155..0000000
--- a/api/tokens.go
+++ /dev/null
@@ -1,179 +0,0 @@
-package api
-
-import (
- "fmt"
- "log"
- "net/url"
- "strings"
- "time"
-
- "github.com/simpleauthlink/authapi/db"
- "github.com/simpleauthlink/authapi/helpers"
-)
-
-// magicLink function generates and returns a magic link, the generated token
-// and the associated app name, based on the provided app secret and the user
-// email. If the secret or the email are empty, it returns an error. It gets
-// the app id from the database based on the secret. It generates a token and
-// calculates the expiration time based on the app session duration. It stores
-// the token and the expiration time in the database. It returns the magic link
-// composed of the app callback and the generated token.
-func (s *Service) magicLink(rawSecret, email, redirectURL string, duration uint64) (string, string, string, error) {
- // check if the secret and email are not empty
- if len(rawSecret) == 0 || len(email) == 0 {
- return "", "", "", fmt.Errorf("secret and email are required")
- }
- // get app secret from raw secret
- appSecret, err := helpers.Hash(rawSecret, helpers.SecretSize)
- if err != nil {
- return "", "", "", err
- }
- // get app and app id from the database based on the secret
- app, appId, err := s.db.AppBySecret(appSecret)
- if err != nil {
- return "", "", "", err
- }
- // get the number of tokens for the app using the app id as the prefix
- numberOfAppTokens, err := s.db.CountTokens(appId)
- if err != nil {
- return "", "", "", err
- }
- // check if the number of tokens is greater than the users quota
- if numberOfAppTokens >= app.UsersQuota {
- return "", "", "", fmt.Errorf("users quota reached")
- }
- // generate token and calculate expiration
- token, userId, err := helpers.EncodeUserToken(appId, email)
- if err != nil {
- return "", "", "", err
- }
- // by default, the session duration is the app session duration but it can
- // be overwritten by the request
- sessionDuration := app.SessionDuration
- if duration > 0 {
- sessionDuration = duration
- }
- expiration := time.Now().Add(time.Duration(sessionDuration) * time.Second)
- // check if there is a token for the user and app in the database and delete
- // it if it exists
- tokenPrefix := strings.Join([]string{appId, userId}, helpers.TokenSeparator)
- if err := s.db.DeleteTokensByPrefix(tokenPrefix); err != nil {
- if err != db.ErrTokenNotFound {
- log.Println("ERR: error checking token:", err)
- }
- }
- // set token and expiration in the database
- if err := s.db.SetToken(db.Token(token), expiration); err != nil {
- return "", "", "", err
- }
- // return the magic link based on the app callback and the generated token
- // by default, the redirect URL is the app redirect URL but it can be
- // overwritten by the request
- baseRawURL := app.RedirectURL
- if redirectURL != "" {
- baseRawURL = redirectURL
- }
- baseURL, err := url.Parse(baseRawURL)
- if err != nil {
- return "", "", "", fmt.Errorf("invalid redirect URL: %w", err)
- }
- urlQuery := baseURL.Query()
- urlQuery.Set(helpers.TokenQueryParam, token)
- baseURL.RawQuery = urlQuery.Encode()
- return helpers.SafeURL(baseURL), token, app.Name, nil
-}
-
-// validUserToken function checks if the provided token is valid. It checks if
-// the token is not empty, if the app id is in the database, if the token is not
-// expired and if the token is in the database. If the token is invalid, it
-// returns false. If something goes wrong during the process, it logs the error
-// and returns false. If the token is valid, it returns true.
-func (s *Service) validUserToken(token, rawSecret string) bool {
- // check if the token and secret are not empty
- if len(token) == 0 || len(rawSecret) == 0 {
- return false
- }
- // get the app id from the token
- appId, _, err := helpers.DecodeUserToken(token)
- if err != nil {
- return false
- }
- // check if the secret is valid
- if !s.validSecret(appId, rawSecret) {
- return false
- }
- // get the token expiration from the database
- expiration, err := s.db.TokenExpiration(db.Token(token))
- if err != nil {
- return false
- }
- // check if the token is expired
- if time.Now().After(expiration) {
- if err := s.db.DeleteToken(db.Token(token)); err != nil {
- log.Println("ERR: error deleting token:", err)
- }
- return false
- }
- return true
-}
-
-// validAdminToken function checks if the provided token is a valid admin token.
-// It checks if the token is not empty, if the app id is in the database, if the
-// token is not expired and if the token is in the database. If the token is
-// invalid, it returns false. It also returns the app id if the token is valid.
-func (s *Service) validAdminToken(token, rawSecret string) (string, bool) {
- // check if the token and secret are not empty
- if len(token) == 0 || len(rawSecret) == 0 {
- return "", false
- }
- // get the app id from the token
- appId, userId, err := helpers.DecodeUserToken(token)
- if err != nil {
- return "", false
- }
- // the app id is composed by the admin user id hash and a nonce, so
- // the app id starts with the admin user id, check if so
- if !strings.HasPrefix(appId, userId) {
- return "", false
- }
- // check if the secret is valid
- if !s.validSecret(appId, rawSecret) {
- return "", false
- }
- // get the token expiration from the database
- expiration, err := s.db.TokenExpiration(db.Token(token))
- if err != nil {
- return "", false
- }
- // check if the token is expired
- if time.Now().After(expiration) {
- if err := s.db.DeleteToken(db.Token(token)); err != nil {
- log.Println("ERR: error deleting token:", err)
- }
- return "", false
- }
- return appId, true
-}
-
-// sanityTokenCleaner function starts a goroutine that cleans the expired tokens
-// from the database every time the cooldown time is reached. It uses a ticker
-// to check the cooldown time and a context to stop the goroutine when the
-// service is stopped. If something goes wrong during the process, it logs the
-// error.
-func (s *Service) sanityTokenCleaner() {
- s.wait.Add(1)
- go func() {
- defer s.wait.Done()
- ticker := time.NewTicker(s.cfg.CleanerCooldown)
- for {
- select {
- case <-s.ctx.Done():
- return
- case <-ticker.C:
- if err := s.db.DeleteExpiredTokens(); err != nil {
- log.Println("ERR: error deleting expired tokens:", err)
- }
- }
- }
- }()
-}
diff --git a/api/types.go b/api/types.go
index 00d6aa9..4daaebd 100644
--- a/api/types.go
+++ b/api/types.go
@@ -1,27 +1,44 @@
package api
-const (
- userTokenSubject = "Here is your magic link for '%s' π"
- appTokenSubject = "Your app '%s' is ready! π"
+import (
+ "time"
+
+ "github.com/simpleauthlink/authapi/token"
)
-// TokenRequest struct includes the required information by the API service to
-// create a token, which is the email of the user. The app secret is also
-// required but it is provided in the request headers.
-type TokenRequest struct {
- Email string `json:"email"`
+type AppIDRequest struct {
+ Name string `json:"name"`
+ Duration string `json:"session_duration"`
RedirectURL string `json:"redirect_url"`
- Duration uint64 `json:"session_duration"`
+ Secret string `json:"secret"`
+}
+
+func (data *AppIDRequest) parseApp() (*token.App, string) {
+ if duration, err := time.ParseDuration(data.Duration); err == nil {
+ app := &token.App{
+ Name: data.Name,
+ RedirectURI: data.RedirectURL,
+ SessionDuration: duration,
+ }
+ return app, data.Secret
+ }
+ return new(token.App), ""
+}
+
+type AppIDResponse struct {
+ ID string `json:"id"`
+}
+
+type TokenRequest struct {
+ Email string `json:"email"`
+}
+
+type TokenStatusRequest struct {
+ Token string `json:"token"`
+ Email string `json:"email"`
}
-// AppData struct includes the required information by the API service to
-// create an app, which are the name, the email of the admin, the session
-// duration and the callback URL.
-type AppData struct {
- Name string `json:"name"`
- Email string `json:"admin_email"`
- Duration uint64 `json:"session_duration"`
- RedirectURL string `json:"redirect_url"`
- UsersQuota int64 `json:"users_quota"`
- CurrentUsers int64 `json:"current_users"`
+type TokenStatusResponse struct {
+ Valid bool `json:"valid"`
+ Expiration time.Time `json:"expiration"`
}
diff --git a/assets/app_email_template.html b/assets/app_email_template.html
deleted file mode 100644
index 6e77482..0000000
--- a/assets/app_email_template.html
+++ /dev/null
@@ -1,98 +0,0 @@
-
-
-
-
-
-
-
-
|
-
- This is a test email
" +) + +var inboxChan = make(chan string, 1) + +func TestMain(m *testing.M) { + defer close(inboxChan) + // create context with cancel + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + // start test SMTP server to receive the email + testSrv := fakesmtpserver.NewServer(testServerAddr, testServerPort, inboxChan) + if err := testSrv.Start(ctx); err != nil { + panic(err) + } + defer testSrv.Stop() + m.Run() +} + +func TestValidEmail(t *testing.T) { + if !(¬ification.Notification{ + Params: notification.NotificationParams{ + To: testReceiver, + Subject: testSubject, + }, + Body: nil, + PlainBody: []byte(testBody), + }).Valid() { + t.Error("expected email to be valid") + } + if !(¬ification.Notification{ + Params: notification.NotificationParams{ + To: testReceiver, + Subject: testSubject, + }, + Body: []byte(testBody), + PlainBody: nil, + }).Valid() { + t.Error("expected email to be valid") + } + if (¬ification.Notification{ + Params: notification.NotificationParams{ + To: testReceiver, + Subject: "", + }, + Body: nil, + PlainBody: []byte(testBody), + }).Valid() { + t.Error("expected email to be invalid") + } + if (¬ification.Notification{ + Params: notification.NotificationParams{ + To: "", + Subject: testSubject, + }, + Body: nil, + PlainBody: []byte(testBody), + }).Valid() { + t.Error("expected email to be invalid") + } + if (¬ification.Notification{ + Params: notification.NotificationParams{ + To: "invalidEmail", + Subject: testSubject, + }, + Body: nil, + PlainBody: []byte(testBody), + }).Valid() { + t.Error("expected email to be invalid") + } + if (¬ification.Notification{}).Valid() { + t.Error("expected email to be invalid") + } +} + +func TestValidConfig(t *testing.T) { + if !(&EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: testSender, + }).Valid() { + t.Error("expected config to be valid") + } + if (&EmailConfig{ + SMTPServer: "", + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: testSender, + }).Valid() { + t.Error("expected config to be invalid") + } + if (&EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: 0, + FromName: testSenderName, + FromAddress: testSender, + }).Valid() { + t.Error("expected config to be invalid") + } + if (&EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: testServerPort, + FromName: "", + FromAddress: testSender, + }).Valid() { + t.Error("expected config to be invalid") + } + if (&EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: "", + }).Valid() { + t.Error("expected config to be invalid") + } +} + +func TestNewEmailQueue(t *testing.T) { + // create email queue with valid config + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + eq, err := NewEmailQueue(ctx, &EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: testSender, + }) + if err != nil { + t.Fatal(err) + } + if eq == nil { + t.Error("expected email queue to be created") + } + // create email queue with auth + eq, err = NewEmailQueue(ctx, &EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: testSender, + SMTPUsername: "username", + SMTPPassword: "password", + }) + if err != nil { + t.Fatal(err) + } + if eq == nil { + t.Error("expected email queue to be created") + } + // create email queue with invalid config + eq, err = NewEmailQueue(ctx, &EmailConfig{ + SMTPServer: "", + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: testSender, + }) + if err == nil { + t.Error("expected error creating email queue") + } + if eq != nil { + t.Error("expected email queue to be nil") + } +} + +func TestSendEmail(t *testing.T) { + // create email queue but don't start it + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + eq, err := NewEmailQueue(ctx, &EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: testSender, + }) + if err != nil { + t.Fatal(err) + } + // send email + if err := eq.Send(notification.Notification{ + Params: notification.NotificationParams{ + To: testReceiver, + Subject: testSubject, + }, + Body: []byte(testHTMLBody), + PlainBody: []byte(testBody), + }); err != nil { + t.Fatal(err) + } + // check if the email was received + select { + case receivedMsg := <-inboxChan: + if !strings.Contains(receivedMsg, testSubject) { + t.Errorf("expected email content to contain %q, got %q", testSubject, receivedMsg) + } + if !strings.Contains(receivedMsg, testBody) { + t.Errorf("expected email content to contain %q, got %q", testBody, receivedMsg) + } + if !strings.Contains(receivedMsg, testHTMLBody) { + t.Errorf("expected email content to contain %q, got %q", testHTMLBody, receivedMsg) + } + case <-time.After(2 * time.Second): + t.Error("timed out waiting for the email to be received") + } + // try to send invalid email + if err := eq.Send(notification.Notification{}); err == nil { + t.Error("expected error sending invalid email") + } + // try to compose a invalid email + if body, err := eq.composeBody(notification.Notification{}); err == nil { + t.Error("expected error composing invalid email") + } else if body != nil { + t.Error("expected body to be nil") + } + // try to send email to an invalid SMTP server + badEq, err := NewEmailQueue(ctx, &EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: 8080, + FromName: testSenderName, + FromAddress: testSender, + }) + if err != nil { + t.Fatal(err) + } + if err := badEq.Send(notification.Notification{ + Params: notification.NotificationParams{ + To: testReceiver, + Subject: testSubject, + }, + Body: nil, + PlainBody: []byte(testBody), + }); err == nil { + t.Error("expected error sending email") + } +} + +func TestPushSendEmail(t *testing.T) { + // create email queue and start it + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + errCh := make(chan error, 1) + eq, err := NewEmailQueue(ctx, &EmailConfig{ + SMTPServer: testServerAddr, + SMTPPort: testServerPort, + FromName: testSenderName, + FromAddress: testSender, + ErrorCh: errCh, + }) + if err != nil { + t.Fatal(err) + } + eq.Start() + defer eq.Stop() + // push email + if err := eq.Push(notification.Notification{ + Params: notification.NotificationParams{ + To: testReceiver, + Subject: testSubject, + }, + Body: nil, + PlainBody: []byte(testBody), + }); err != nil { + t.Fatal(err) + } + // check if the email was received + select { + case receivedMsg := <-inboxChan: + if !strings.Contains(receivedMsg, testSubject) { + t.Errorf("expected email content to contain %q, got %q", testSubject, receivedMsg) + } + if !strings.Contains(receivedMsg, testBody) { + t.Errorf("expected email content to contain %q, got %q", testBody, receivedMsg) + } + case <-time.After(2 * time.Second): + t.Error("timed out waiting for the email to be received") + } + // sleep to pop nil email + time.Sleep(2 * time.Second) + // push invalid email + if err := eq.Push(notification.Notification{}); err == nil { + t.Error("expected error pushing invalid email") + } +} diff --git a/notification/email/errors.go b/notification/email/errors.go new file mode 100644 index 0000000..1415164 --- /dev/null +++ b/notification/email/errors.go @@ -0,0 +1,33 @@ +package email + +import "github.com/simpleauthlink/authapi/internal" + +var ( + // ErrInvalidConfig is the error returned when the configuration is invalid. + ErrInvalidConfig = internal.NewErr("invalid configuration") + // ErrInitQueue is the error returned when the queue cannot be initialized. + ErrInitQueue = internal.NewErr("error initializing the queue") + // ErrInvalidEmail is the error returned when the email is invalid. + ErrInvalidEmail = internal.NewErr("invalid email") + // ErrInvalidTemplate is the error returned when the template is invalid. + ErrInvalidTemplate = internal.NewErr("invalid template") + // ErrSendEmail is the error returned when the email cannot be sent. + ErrSendEmail = internal.NewErr("error sending email") + // ErrComposeEmail is the error returned when the email cannot be composed. + ErrComposeEmail = internal.NewErr("error composing email") + // ErrParseAddress is the error returned when the email address cannot + // be parsed. + ErrParseAddress = internal.NewErr("error parsing email address") + // ErrSetBoundary is the error returned when the boundary cannot be set + // when a multipart email is composed. + ErrSetBoundary = internal.NewErr("error setting boundary") + // ErrWriteHTMLBody is the error returned when the email plain body cannot + // be written. + ErrWriteBody = internal.NewErr("error writing email plain body") + // ErrWriteHTMLBody is the error returned when the email HTML body cannot + // be written. + ErrWriteHTMLBody = internal.NewErr("error writing email html body") + // ErrCloseEmailWriter is the error returned when the email writer cannot + // be closed after composing the email. + ErrCloseEmailWriter = internal.NewErr("error closing email writer") +) diff --git a/notification/email/template.go b/notification/email/template.go new file mode 100644 index 0000000..4e9bb7a --- /dev/null +++ b/notification/email/template.go @@ -0,0 +1,92 @@ +package email + +import ( + "bytes" + htmltemplate "html/template" + texttemplate "text/template" + + "github.com/simpleauthlink/authapi/notification" +) + +// EmailTemplate is the definition of an email template, which contains the +// HTML and plain text placeholders to be filled with the data. +type EmailTemplate struct { + HTML string + Plain string +} + +// Compose methods fills the email template with the data and returns the email +// ready to be sent. It returns the email or an error if the template could not +// be filled. It tries to fill both the HTML and plain text templates, but if +// any of them is missing, it will return an error. If some of the placeholders +// in the template are not filled, they will be left as they are. +func (temp *EmailTemplate) Compose(params notification.NotificationParams, data any) (notification.Notification, error) { + if !params.Valid() { + return notification.Notification{}, ErrComposeEmail + } + // compose the html body + body, err := temp.composeHTML(data) + if err != nil { + return notification.Notification{}, err + } + // compose the plain body + plainBody, err := temp.composePlain(data) + if err != nil { + return notification.Notification{}, err + } + // if both bodies are empty, return an error + if plainBody == nil && body == nil { + return notification.Notification{}, ErrInvalidTemplate + } + // return the email with the filled bodies + email := notification.Notification{ + Params: params, + Body: body, + PlainBody: plainBody, + } + return email, nil +} + +// composePlain method fills the plain text template with the data and returns the +// filled content as a byte slice. It returns the filled template or an error +// if the template could not be filled. If the plain text template is empty, it +// returns nil and no error. +func (temp *EmailTemplate) composePlain(data any) ([]byte, error) { + if temp.Plain == "" { + return nil, nil + } + // parse the placeholder plain body template + tmpl, err := texttemplate.New("plain").Parse(temp.Plain) + if err != nil { + return nil, err + } + // inflate the template with the data + buf := new(bytes.Buffer) + if err := tmpl.Execute(buf, data); err != nil { + return nil, err + } + // return the notification with the plain body filled with the data + return buf.Bytes(), nil +} + +// composeHTML method fills the HTML template with the data and returns the filled +// content as a byte slice. It returns the filled template or an error if the +// template could not be filled. If the HTML template is empty, it returns nil +// and no error. +func (temp *EmailTemplate) composeHTML(data any) ([]byte, error) { + if temp.HTML == "" { + return nil, nil + } + // parse the email template + tmpl, err := htmltemplate.New("html").Parse(temp.HTML) + if err != nil { + return nil, err + } + // inflate the template with the data + buf := new(bytes.Buffer) + if err := tmpl.Execute(buf, data); err != nil { + return nil, err + } + // set the body of the notification + return buf.Bytes(), nil +} diff --git a/notification/email/template_test.go b/notification/email/template_test.go new file mode 100644 index 0000000..1d5881d --- /dev/null +++ b/notification/email/template_test.go @@ -0,0 +1,152 @@ +package email + +import ( + "testing" + + "github.com/simpleauthlink/authapi/notification" +) + +var testTemplate = &EmailTemplate{ + HTML: "{{.Title}}
{{.Content}}
", + Plain: "Title: {{.Title}}\nContent: {{.Content}}", +} + +type testData struct { + Title string + Content string +} + +func TestCompose(t *testing.T) { + // valid data + data := testData{ + Title: "Test Title", + Content: "Test Content", + } + email, err := testTemplate.Compose(notification.NotificationParams{ + To: testReceiver, + Subject: testSubject, + }, data) + if err != nil { + t.Fatalf("expected nil, got error: %v", err) + } + if email.Params.To != testReceiver { + t.Fatalf("got %v, want %v", email.Params.To, testReceiver) + } + if email.Params.Subject != testSubject { + t.Fatalf("got %v, want %v", email.Params.Subject, testSubject) + } + expectedBody := "Test Title
Test Content
" + expectedPlain := "Title: Test Title\nContent: Test Content" + if string(email.Body) != expectedBody { + t.Fatalf("got %v, want %v", string(email.Body), expectedBody) + } + if string(email.PlainBody) != expectedPlain { + t.Fatalf("got %v, want %v", string(email.PlainBody), expectedPlain) + } + // no subject + if _, err := testTemplate.Compose(notification.NotificationParams{ + To: testReceiver, + Subject: "", + }, data); err == nil { + t.Fatalf("expected error, got nil") + } + // no to address + if _, err := testTemplate.Compose(notification.NotificationParams{ + To: "", + Subject: testSubject, + }, data); err == nil { + t.Fatalf("expected error, got nil") + } + // bad to address + if _, err := testTemplate.Compose(notification.NotificationParams{ + To: "bad email", + Subject: testSubject, + }, data); err == nil { + t.Fatalf("expected error, got nil") + } + // invalid template + emptyTemplate := &EmailTemplate{} + validParams := notification.NotificationParams{ + To: testReceiver, + Subject: testSubject, + } + if _, err := emptyTemplate.Compose(validParams, data); err == nil { + t.Fatalf("expected error, got nil") + } + // no html template + noHTMLTemplate := &EmailTemplate{Plain: testTemplate.Plain} + onlyPlainEmail, err := noHTMLTemplate.Compose(validParams, data) + if err != nil { + t.Fatalf("expected nil, got error: %v", err) + } + if onlyPlainEmail.Body != nil { + t.Fatalf("expected nil, got %v", string(onlyPlainEmail.Body)) + } + if string(onlyPlainEmail.PlainBody) != expectedPlain { + t.Fatalf("got %v, want %v", string(onlyPlainEmail.PlainBody), expectedPlain) + } + // no plain template + noPlainTemplate := &EmailTemplate{HTML: testTemplate.HTML} + onlyHTMLEmail, err := noPlainTemplate.Compose(validParams, data) + if err != nil { + t.Fatalf("expected nil, got error: %v", err) + } + if string(onlyHTMLEmail.Body) != expectedBody { + t.Fatalf("got %v, want %v", string(onlyHTMLEmail.Body), expectedBody) + } + if onlyHTMLEmail.PlainBody != nil { + t.Fatalf("expected nil, got %v", string(onlyHTMLEmail.PlainBody)) + } +} + +func Test_composePlain(t *testing.T) { + // valid data and template + data := testData{ + Title: "Test Title", + Content: "Test Content", + } + body, err := testTemplate.composePlain(data) + if err != nil { + t.Fatalf("expected nil, got error: %v", err) + } + expected := "Title: Test Title\nContent: Test Content" + if string(body) != expected { + t.Fatalf("got %v, want %v", string(body), expected) + } + // no plain template + wrongPlainTemplate := *testTemplate + wrongPlainTemplate.Plain = "" + body, err = wrongPlainTemplate.composePlain(data) + if err != nil { + t.Fatalf("expected nil, got error: %v", err) + } + if body != nil { + t.Fatalf("expected nil, got %v", string(body)) + } +} + +func Test_composeHTML(t *testing.T) { + // valid data and template + data := testData{ + Title: "Test Title", + Content: "Test Content", + } + body, err := testTemplate.composeHTML(data) + if err != nil { + t.Fatalf("expected nil, got error: %v", err) + } + expected := "Test Title
Test Content
" + if string(body) != expected { + t.Fatalf("got %v, want %v", string(body), expected) + } + // no html template + wrongHTMLTemplate := *testTemplate + wrongHTMLTemplate.HTML = "" + body, err = wrongHTMLTemplate.composeHTML(data) + if err != nil { + t.Fatalf("expected nil, got error: %v", err) + } + if body != nil { + t.Fatalf("expected nil, got %v", string(body)) + } +} diff --git a/notification/notification.go b/notification/notification.go new file mode 100644 index 0000000..308c79a --- /dev/null +++ b/notification/notification.go @@ -0,0 +1,33 @@ +package notification + +import "net/mail" + +type NotificationParams struct { + To string + Subject string +} + +func (p NotificationParams) Valid() bool { + _, err := mail.ParseAddress(p.To) + return err == nil && p.Subject != "" +} + +type Notification struct { + Params NotificationParams + Body []byte + PlainBody []byte +} + +// Valid method checks if the email is valid. It returns true if the recipient +// email address, the subject and the body are not empty. +func (n *Notification) Valid() bool { + return n.Params.Valid() && max(len(n.Body), len(n.PlainBody)) > 0 +} + +type Queue interface { + Start() + Stop() + Pop() (Notification, bool) + Push(Notification) error + Send(Notification) error +} diff --git a/notification/notification_test.go b/notification/notification_test.go new file mode 100644 index 0000000..573947c --- /dev/null +++ b/notification/notification_test.go @@ -0,0 +1,90 @@ +package notification + +import ( + "testing" +) + +func TestNotificationParams_Valid(t *testing.T) { + tests := []struct { + name string + params NotificationParams + valid bool + }{ + { + name: "Valid params", + params: NotificationParams{To: "test@example.com", Subject: "Test Subject"}, + valid: true, + }, + { + name: "Invalid email", + params: NotificationParams{To: "invalid-email", Subject: "Test Subject"}, + valid: false, + }, + { + name: "Empty subject", + params: NotificationParams{To: "test@example.com", Subject: ""}, + valid: false, + }, + { + name: "Empty email and subject", + params: NotificationParams{To: "", Subject: ""}, + valid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.params.Valid(); got != tt.valid { + t.Errorf("expected valid: %v, got: %v", tt.valid, got) + } + }) + } +} + +func TestNotification_Valid(t *testing.T) { + tests := []struct { + name string + notification Notification + valid bool + }{ + { + name: "Valid notification with Body", + notification: Notification{ + Params: NotificationParams{To: "test@example.com", Subject: "Test Subject"}, + Body: []byte("Test Body"), + }, + valid: true, + }, + { + name: "Valid notification with PlainBody", + notification: Notification{ + Params: NotificationParams{To: "test@example.com", Subject: "Test Subject"}, + PlainBody: []byte("Test Plain Body"), + }, + valid: true, + }, + { + name: "Invalid notification with empty Body and PlainBody", + notification: Notification{ + Params: NotificationParams{To: "test@example.com", Subject: "Test Subject"}, + }, + valid: false, + }, + { + name: "Invalid notification with invalid Params", + notification: Notification{ + Params: NotificationParams{To: "invalid-email", Subject: "Test Subject"}, + Body: []byte("Test Body"), + }, + valid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.notification.Valid(); got != tt.valid { + t.Errorf("expected valid: %v, got: %v", tt.valid, got) + } + }) + } +} diff --git a/notification/templates/login/definition.go b/notification/templates/login/definition.go new file mode 100644 index 0000000..9a66b67 --- /dev/null +++ b/notification/templates/login/definition.go @@ -0,0 +1,64 @@ +package login + +import ( + _ "embed" + "regexp" + + "github.com/simpleauthlink/authapi/notification" + "github.com/simpleauthlink/authapi/notification/email" + "github.com/simpleauthlink/authapi/token" +) + +//go:embed template.html +var htmlTemplate string + +// Data struct contains the required data to fill the login email template. +type Data struct { + AppName string + Email string + Token string + Link string +} + +// Subject returns the email subject based on the login data. +func (d Data) Subject() string { + return "Your token for '" + d.AppName + "'" +} + +// FindToken function extracts the token from the email content. It uses a +// regular expression to fill the template with regex and find the token in +// the email content. Then it decodes the token and returns it. If the token +// is not found, it returns nil. +func FindToken(email, content string) *token.Token { + loginData := Data{ + AppName: `.+`, + Email: email, + Token: `(.+\..+)`, + Link: `.+`, + } + loginEmail, err := Template.Compose(notification.NotificationParams{ + To: email, + Subject: loginData.Subject(), + }, loginData) + if err != nil { + return nil + } + tokenRgx := regexp.MustCompile(string(loginEmail.PlainBody)) + tokenResult := tokenRgx.FindAllStringSubmatch(content, -1) + if len(tokenResult) < 1 || len(tokenResult[0]) < 2 { + return nil + } + return new(token.Token).SetString(tokenResult[0][1]) +} + +// Template is the login email template definition, which contains the HTML +// and plain text templates. +var Template = email.EmailTemplate{ + HTML: htmlTemplate, + Plain: `Hi, {{.Email}} +You can access to '{{.AppName}}' app using the following link: +{{.Link}} +It contains your login token: '{{.Token}}' +Which is only valid for you and for a short period of time. +If you didn't request this, you can ignore this email.`, +} diff --git a/assets/token_email_template.html b/notification/templates/login/template.html similarity index 60% rename from assets/token_email_template.html rename to notification/templates/login/template.html index 2a51785..ec1476c 100644 --- a/assets/token_email_template.html +++ b/notification/templates/login/template.html @@ -1,5 +1,4 @@ - @@ -7,21 +6,13 @@| @@ -29,35 +20,41 @@ style="border-collapse: collapse; border: 1px solid #cccccc;"> | |||
- 
+
SimpleAuth.link |
|||
| - π Hi, {{.EmailHandler}}! + |
+ π Hi, {{.Email}}!- Your magic link to login to '{{.AppName}}' is ready π. + Your magic link is ready! π + You can access to your {{.AppName}} account using it π. + Click the button below to login to your account. π |
||
SimpleAuth
or copy and paste the following link in your browser:
|
|||
| - {{.AppName}} || Made by SimpleAuth.link + | + {{.AppName}} || Made by SimpleAuth.link |