Golem
A toolchain, similar to Rails or other application frameworks, that instead
generates idiomatic go.
Supports generation of a simple application, with support for:
- Command-line
- Web
- Database Models
- Background Jobs
This functionality is built on the backs of several technologies:
Cobra
and Viper
for command-line and configuration
Gin Gonic
for web routing
MGM
for Mongodb connections and models
JobRunner
for background jobs and management
Why
I found myself building very similar apps over and over, I was interested
in things like Kallax
and other tools that help solve repitition in go
applications by using code generation tools.
I have existing Ruby on Rails applications that use Mongodb databases and
wanted something to simplify replacing those RoR apps with go-based apps
I wanted to do this in a way that was idiomatic go, rather than using
runtime reflection and things of that nature.
Utlimately, I'd like to see this support additional dialects
for generating
code compatible with other simple frameworks. Like the aforementioned Kallax
for integrating with postgresql
compatible databases, or Gorilla Mux
for
web requests and routing.
Quickstart
This assumes you have a working go installation
go get -u github.com/dashotv/golem
golem new
- <name> is the application name
- <repo> is the full package repo name
Example:
golem new blarg github.com/dashotv/blarg
This will generate an application similar to the following tree:
blarg
├── LICENSE
├── application
│ └── app.go
├── cmd
│ ├── root.go
│ └── server.go
├── config
│ └── config.go
├── main.go
├── models
│ ├── connector.go
│ ├── document.go
│ ├── hello.go
│ └── schema.go
└── server
├── releases
│ └── routes.go
├── routes.go
└── server.go
This structure is a cobra
application, with the addition of a few additional
pacakges. See Anatomy
for more information.
config
package
that manages configuration of the application and a server
subcommand that
runs the application for you. The config
is also configured to automaticall
unmarshal for you, with all the support from viper
for environment and
command line options overriding the settings.
The .golem
directory contins the golem
configuration and additional files
used for generation.
.golem/models
: contains yaml model definition files
.golem/routes.yaml
: contains route definition files
.golem/jobs.yaml
: contains job definition files
Anatomy
A simple overview of the generated files.
Application
The application package manages shared configuration and clients with all other
aspects of the system.
Config
A simple configuration structure setup to use Viper
unmarshalling. Because the
generated application is compatible with Cobra
and Viper
you can use
functionality from those tools to support additional functionality like
environment variable overrides.
There is also a stubbed validation function which is configured to be called
after Viper
loads the configuration. If you look in cmd/root.go
you can
find the wiring that makes this possible, as well as the definitions for where
to search for configurations files at runtime.
Models
The generated model structures are placed here and include a Connector
class
which manges the connections to the database(s). Use the models.NewConnector()
function to get an instance of the Connector
.
The generated models include a model object, a Store
structure which handles interaction with
the database, and a Query
structure that gives you an easy interface to generating
queries to the data.
Server
Golem
assumes that you are building an application to serve web requests and the
server
package is where all of this is wired up.
For each of the Group
of Routes
defined in .golem/routes.yaml
it generates
a package which implements handler functions that automatically convert the
parameters.