Integrate existing business logic without direct import of goa

[ghost]

What I try to do?
I have existing business already built and I am trying to use goadesign to leverage its mapping and openAPI v3 generation to build a rest microservice with proper documentation. My ultimate goal is to call my business logic from goadesign and map it to its defined types without letting goadesign completely take over my business logic.

Why I want to do this?
My business logic is implemented using basic golang features. No libraries used. It is important that goadesign only does the API related stuff and no business logic as try to be framework agnostic so that I can swap out connectors such as REST provider/API's easily while keeping the business logic.

Steps required (probably?)

1. Call own custom function outside from goadesign inside a goadesign definition
2. Map payload to own data struct
3. Map own struct to result
4. Get custom headers such as JWT tokens to pass over to own custom function

Here is the interface of my business logic:

package behaviour

import "account/component/structure"

type AccountService interface {
	Register(email string, password string) (structure.Session, error)
	VerifyEmail(email string, emailVerificationCode string) error
	DoesAccountExist(email string) bool
	Login(email string, password string) (structure.Session, error)
	IssueAccessToken(key string) (string, error)
	GetAllSessions(key string) ([]structure.Session, error)
	LogoutSession(key string, id int) error
}

In goadesign I would like to call my business logic like this:

session, err := service.Register("[email protected]", "super-secure-password")

And then map the credential attributes of goa to strings and session struct to the goadesign types (pseudo code):

var CredentialType = Type("Credential", func() {
	Attribute("email", func() {
		MinLength(3)
	}),
        Attribute("password", func() {
		MinLength(8)
	})

	Required("email", "password")
})

var _ = Service("account", func() {
	Description("Account service manages user accounts")

	Method("register", func() {
		Payload(CredentialType)
		Result(func(credentialType) {
                         session, _ := service.Register(credentialType.Email, credentialType.Password)
                         
                         return session
                 })
	})

	Files("/openapi.json", "./gen/http/openapi.json")
})

Question: Is this possible? How can I achieve the above with preferably minimal amount of code?

Disclaimer: I am new to goadesign so please forgive me for stupid questions or insufficient knowledge.

[raphael]

Hello,

Goa takes care of generating the transport layer and endpoint code and then lets you inject the actual business logic (which Goa cannot generate since it has no knowledge of what it should be). Reusing the diagram from https://goa.design/implement/implementing/:

         TRANSPORT             ENDPOINT            SERVICE

           +-----------+       +--------------+
  Request  | Decoding  |       |  Middleware  |
---------->|    &      +------>|      &       +----------+
           | Validation|       | Type casting |          v
           +-----------+       +--------------+     +----------+
                                                    | Business |
                                                    |  logic   |
           +-----------+       +--------------+     +----+-----+
  Response |           |       |  Middleware  |          |
<----------+ Encoding  |<------+      &       |<---------+
           |           |       | Type casting |
           +-----------+       +--------------+

Goa generates the code for all the boxes except the right-most one. For the business logic It generates an interface and expects the user to provide its implementation - that's how the business logic is injected, see the basic calc example for what that interface looks like.

So to answer the question the idea would be to provide an adapter that maps the existing business logic to the interface expected by the generated code. Just as an example:

type AccountServiceAdapter struct {
    *AccountService
}

// This function implements the interface generated by Goa and calls the underlying business logic.
func (as *AccountServiceAdapter) Register(ctx context.Context, p *accountsvc.RegisterPayload) (*accountsvc.RegisterResult, error) {
    session, err := as.AccountService.Register(p.email, p.password)
    if err != nil {
        return nil, err // may want to map to design errors to produce correct transport code (HTTP status / gRPC code)
    }
    return &accountsvc.RegisterResult{Session: session}, nil
}

// ....

Again above is just one way to do it for illustration.

[ghost]

Thank you for your reply. I successfully generated the code but how do I instantiate the adapter? I have a main.go where I setup all the connectors as such:

func main() {
        service := behaviour.CreateService()
	http.CreateHttpConnector(&service)
}

Inside the connector which acts as Goa service adapter I incorporated the suggestions from your code snippet and the code from the calc example:

package http

import (
	"account/component/behaviour"
	"account/gen/account"
	"context"
)

type HttpConnector struct {
	service *behaviour.AccountService
}

func CreateHttpConnector(service *behaviour.AccountService) account.Service {
	return &HttpConnector{
		service: service,
	}
}

func (c *HttpConnector) Register(ctx context.Context, p *account.RegisterPayload) (*account.SessionPayload, error) {
	session, err := (*c.service).Register(p.Email, p.Password)

	return &account.SessionPayload{
		Key: &session.Key,
	}, err
}

My file structure is like this (everything in the gen directory was generated by Goa):

├── component
│   ├── behaviour
│   │   ├── AccountService.go
│   │   └── AccountServiceImplementation.go
├── connector
│   ├── http
│   │   ├── HttpConnector.go
│   │   └── design.go
├── gen
│   ├── account
│   │   ├── client.go
│   │   ├── endpoints.go
│   │   └── service.go
│   └── http
│       ├── account
│       │   ├── client
│       │   │   ├── client.go
│       │   │   ├── encode_decode.go
│       │   │   ├── paths.go
│       │   │   └── types.go
│       │   └── server
│       │       ├── paths.go
│       │       ├── server.go
│       │       └── types.go
│       ├── cli
│       │   └── account
│       │       └── cli.go
│       ├── openapi.json
│       ├── openapi.yaml
│       ├── openapi3.json
│       └── openapi3.yaml
├── go.mod
├── go.sum
└── main.go

When I try to build and run it immediately stops:

go run .

I have also tried using this code snippet from https://goa.design/learn/guide/ in my main.go:

func main() {
        // Create service
        service := goa.New("cellar")

        // Mount middleware
        service.Use(middleware.RequestID())
        service.Use(middleware.LogRequest(true))
        service.Use(middleware.ErrorHandler(service, true))
        service.Use(middleware.Recover())

        // Mount "bottle" controller
        c := NewBottleController(service)
        app.MountBottleController(service, c)

        // Start service
        if err := service.ListenAndServe(":8080"); err != nil {
                service.LogError("startup", "err", err)
        }
}

But the Goa package does not provide a New func/constructor. Is this outdated?

[ghost]

I got it working. I added a new method to the HttpConnector.go that instantiates the http server:

func (c *HttpConnector) Start() {
	endpoints := account.NewEndpoints(c)
	mux := goahttp.NewMuxer()
	dec := goahttp.RequestDecoder
	enc := goahttp.ResponseEncoder
	svr := server.New(endpoints, mux, dec, enc, nil, nil, nil)
	server.Mount(mux, svr)
	httpsvr := &http.Server{
		Addr:    "localhost:8080",
		Handler: mux,
	}
	if err := httpsvr.ListenAndServe(); err != nil {
		panic(err)
	}
}