A Go service that compiles, runs and ships — from one command.

scaffold init writes an HTTP service in DDD layers — a bounded context with its domain, use cases, adapters and an architecture test that enforces the dependency rule — with graceful shutdown, a health check, configuration from the environment, a connection pool, a non-root multi-stage image and docker compose. Before every release CI generates a project and compiles it: a template that emits broken Go does not ship.

go install github.com/Allan-Nava/Go-DDD-Scaffold@latestcopy

The binary is named Go-DDD-Scaffold after the module — rename it to scaffold, or use docker run --rm -v "$PWD:/work" ghcr.io/allan-nava/go-ddd-scaffold init, or the VS Code extension. Templates are embedded: no $GOPATH, no checkout beside it.

$ mkdir -p ~/code/github.com/acme/orders && cd $_
$ scaffold init
Create Dockerfile
Create cmd/main.go
Create cmd/modules.go                       # composition root
Create internal/archtest/arch_test.go       # the dependency rule, as a test
…
Create cmd/module_catalog.go
Create internal/catalog/domain/model.go
Create internal/catalog/application/service.go
Create internal/catalog/infrastructure/gorm.go
Create internal/catalog/transport/http/handler.go
…

28 file(s) created in ~/code/github.com/acme/orders  # module github.com/acme/orders, read from the path

$ go mod tidy && go test ./...
ok  	github.com/acme/orders/cmd	0.007s
ok  	github.com/acme/orders/env	0.003s
ok  	github.com/acme/orders/internal/archtest	0.003s
ok  	github.com/acme/orders/internal/catalog/application	0.004s
ok  	github.com/acme/orders/internal/catalog/domain	0.003s
ok  	github.com/acme/orders/internal/catalog/infrastructure	0.004s
ok  	github.com/acme/orders/internal/catalog/transport/http	0.006s

Real output of v1.0.0, abridged. --no-example skips the catalog module. Inside a git clone the module path comes from the origin remote instead; --module and --name override both. Run it again and every file is reported as Skip: nothing is overwritten without --force.

What it generates

$ make run                                  # no MySQL on this machine: it starts anyway
{"msg":"DB_HOST is empty: starting without a database"}
{"msg":"listening","addr":"0.0.0.0:8080"}

$ curl -s -o /dev/null -w '%{http_code}\n' localhost:8080/health
200
$ curl -s -X POST localhost:8080/api/catalog -H 'Content-Type: application/json' -d '{"name":"Laptop"}'
{"id":"890916a0…","name":"Laptop","status":"active",…}
$ curl -s -X POST localhost:8080/api/catalog/890916a0…/archive   # twice
product is archived                         # 409: the rule lives in the aggregate

make up starts the service with MySQL through docker compose; set DB_HOST=localhost in env/.env.local to run on the host against it. CI starts the generated service exactly like make run, with APP_ENV=local and no database.

DDD, enforced

Dependencies point inwards — transport → application → domain ← infrastructure — and that is a test, not a convention:

$ scaffold add module billing --entity Invoice   # four layers + tests + cmd/module_billing.go
Create cmd/module_billing.go
Create internal/billing/domain/model.go
…
12 file(s) created for module billing            # no existing file edited: the module registers itself

$ echo 'package domain; import _ "gorm.io/gorm"' > internal/billing/domain/leak.go
$ go test ./internal/archtest
--- FAIL: TestDependencyRule
    internal/billing/domain/leak.go imports gorm.io/gorm: the domain stays free of third-party code

Where the rules go, rich versus anemic model, and when each fits: the generated DDD layout. Wiring is plain Go in cmd/: no DI framework.

Guarantees, enforced in CI

Roadmap

Since v1.0 the generated project has real DDD layers and scaffold add module; next comes what a service needs in production. The product audit lists what is missing and orders it:

Each milestone links to its GitHub issues; the plan itself lives in docs/backlog.md.

In VS Code

The extension runs the same CLI: New Scaffold Project on the folder you pick, Add Bounded Context inside a generated project. It carries no templates of its own, so the editor and the terminal always generate the same project.