https://github.com/clavoie/ae
Injectable Google AppEngine wrappers for Go.
https://github.com/clavoie/ae
appengine-go dependency-injection go golang
Last synced: about 1 year ago
JSON representation
Injectable Google AppEngine wrappers for Go.
- Host: GitHub
- URL: https://github.com/clavoie/ae
- Owner: clavoie
- License: mit
- Created: 2018-09-04T12:25:00.000Z (almost 8 years ago)
- Default Branch: master
- Last Pushed: 2018-09-07T11:36:03.000Z (almost 8 years ago)
- Last Synced: 2025-04-12T00:49:43.409Z (about 1 year ago)
- Topics: appengine-go, dependency-injection, go, golang
- Language: Go
- Size: 17.6 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# ae [](http://godoc.org/github.com/clavoie/ae) [](https://travis-ci.org/clavoie/ae) [](https://goreportcard.com/report/github.com/clavoie/ae)
Wrappers around Google's AppEngine Go packages, meant for use with a dependency injection system and unit tests. Currently only the `appengine`, `datastore`, and `taskqueue` pakcages are wrapped.
## Usage
The wrapper interfaces aim to keep the names, parameter types, and parameter orders the same as the functions of the packages they wrap. Using the wrappers should consist of setting up your dependency injection system and then using the wrappers as you would the package functions directly.
One major advantage of using this package with a dependency injection system is you no longer have to keep track of the `r *http.Request` or `c context.Context` as those are injected into the dependency wrappers.
```go
fnuc MyHandler(app ae.AppEngine, db ae.Db, log logu.Logger) {
// wraps the appengine package
if app.ModuleName() != "address" {
return;
}
// wraps the datastore package
q := db.NewQuery("Address")
q = q.Filter("Street =", someValue).KeysOnly()
addresses := make([]Address, 0)
keys, err := q.GetAll(addresses)
if err != nil {
log.Errorf("Could not get addresses: %v", err)
return
}
// etc
}
```
## Setup
Below is a more complete example of how the main.go file would be set up for an App Engine service:
```go
package main
import (
"myPackage"
"net/http"
"github.com/clavoie/di"
"github.com/clavoie/erru"
"github.com/clavoie/logu"
)
var httpResolver di.IHttpResolver
func onResolveErr(err *di.ErrResolve, w http.ResponseWriter, r *http.Request) {
logger := logu.NewAppEngineLogger(r)
logger.Errorf("err encountered while resolving dependencies: %v", err.String())
httpErr, isHttpErr := err.Err.(erru.HttpErr)
if isHttpErr {
w.WriteHeader(httpErr.StatusCode())
} else {
w.WriteHeader(http.StatusInternalServerError)
}
}
var httpDefs = []*di.HttpDef{
{myPackage.HomeHandler, "/"},
{myPackage.AddressHandler, "/address"},
// etc...
}
func init() {
var err error
httpResolver, err = di.NewResolver(onResolveErr,
ae.NewDiDefs(),
logu.NewAppEngineDiDefs(),
myPackage.NewDiDefs(),
// etc, your service deps here
)
if err != nil {
panic(err)
}
err = httpResolver.SetDefaultServeMux(httpDefs)
if err != nil {
panic(err)
}
}
```