├── .github
    └── workflows
    │   ├── ci.yml
    │   └── release.yml
├── .gitignore
├── .golangci.yml
├── .goreleaser.yml
├── COPYING
├── README.md
├── bin
    ├── .go-1.19.3.pkg
    ├── .golangci-lint-1.50.1.pkg
    ├── .goreleaser-1.15.0.pkg
    ├── .jq-1.6.pkg
    ├── .reflex-0.3.1.pkg
    ├── .shellcheck-0.8.0.pkg
    ├── README.hermit.md
    ├── activate-hermit
    ├── go
    ├── gofmt
    ├── golangci-lint
    ├── goreleaser
    ├── hermit
    ├── hermit.hcl
    ├── jq
    ├── reflex
    └── shellcheck
├── cmd
    └── happy
    │   └── main.go
├── codewriter
    ├── codewriter.go
    └── codewriter_test.go
├── go.mod
├── go.sum
├── reflex.conf
├── scripts
    ├── e2e-test
    └── happy
└── testdata
    ├── main.go
    ├── main_api.go
    └── main_test.go


/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | on:
 2 |   push:
 3 |     branches:
 4 |       - master
 5 |   pull_request:
 6 | name: CI
 7 | jobs:
 8 |   test:
 9 |     name: Test
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - name: Checkout code
13 |         uses: actions/checkout@v3
14 |       - name: Init Hermit
15 |         run: ./bin/hermit env -r >> $GITHUB_ENV
16 |       - name: E2E Test
17 |         run: e2e-test
18 |   lint:
19 |     name: Lint
20 |     runs-on: ubuntu-latest
21 |     steps:
22 |       - name: Checkout code
23 |         uses: actions/checkout@v3
24 |       - name: Init Hermit
25 |         run: ./bin/hermit env -r >> $GITHUB_ENV
26 |       - name: golangci-lint
27 |         run: golangci-lint run
28 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | on:
 3 |   push:
 4 |     tags:
 5 |       - 'v*'
 6 | jobs:
 7 |   release:
 8 |     name: Release
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |     - uses: actions/checkout@v2
12 |       with:
13 |         fetch-depth: 0
14 |     - run: ./bin/hermit env --raw >> $GITHUB_ENV
15 |     - run: goreleaser release
16 |       env:
17 |         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /.hermit
2 | 


--------------------------------------------------------------------------------
/.golangci.yml:
--------------------------------------------------------------------------------
 1 | run:
 2 |   tests: true
 3 |   skip-dirs:
 4 |     - _examples
 5 | 
 6 | output:
 7 |   print-issued-lines: false
 8 | 
 9 | linters:
10 |   enable-all: true
11 |   disable:
12 |     - maligned
13 |     - megacheck
14 |     - lll
15 |     - gocyclo
16 |     - dupl
17 |     - gochecknoglobals
18 |     - funlen
19 |     - godox
20 |     - wsl
21 |     - goimports
22 |     - gomnd
23 |     - gocognit
24 |     - goerr113
25 |     - nolintlint
26 |     - testpackage
27 |     - godot
28 |     - nestif
29 |     - paralleltest
30 |     - nlreturn
31 |     - cyclop
32 |     - exhaustivestruct
33 |     - gci
34 |     - gofumpt
35 |     - errorlint
36 |     - exhaustive
37 |     - ifshort
38 |     - wrapcheck
39 |     - stylecheck
40 |     - nonamedreturns
41 |     - revive
42 |     - dupword
43 |     - exhaustruct
44 |     - varnamelen
45 |     - forcetypeassert
46 |     - ireturn
47 |     - maintidx
48 |     - govet
49 |     - nosnakecase
50 |     - testableexamples
51 |     - gochecknoinits
52 |     - prealloc
53 |     - forbidigo
54 |     - goprintffuncname
55 | 
56 | linters-settings:
57 |   govet:
58 |     check-shadowing: true
59 |   gocyclo:
60 |     min-complexity: 10
61 |   dupl:
62 |     threshold: 100
63 |   goconst:
64 |     min-len: 8
65 |     min-occurrences: 3
66 |   forbidigo:
67 |     #forbid:
68 |     #  - (Must)?NewLexer$
69 |     exclude_godoc_examples: false
70 | 
71 | issues:
72 |   max-per-linter: 0
73 |   max-same: 0
74 |   exclude-use-default: false
75 |   exclude:
76 |     # Captured by errcheck.
77 |     - '^(G104|G204):'
78 |     # Very commonly not checked.
79 |     - 'Error return value of .(.*\.Help|.*\.MarkFlagRequired|(os\.)?std(out|err)\..*|.*Close|.*Flush|os\.Remove(All)?|.*printf?|os\.(Un)?Setenv). is not checked'
80 |     - 'exported method (.*\.MarshalJSON|.*\.UnmarshalJSON|.*\.EntityURN|.*\.GoString|.*\.Pos) should have comment or be unexported'
81 |     - 'comment on exported method'
82 |     - 'composite literal uses unkeyed fields'
83 |     - 'declaration of "err" shadows declaration'
84 |     - 'should not use dot imports'
85 |     - 'Potential file inclusion via variable'
86 |     - 'should have comment or be unexported'
87 |     - 'comment on exported var .* should be of the form'
88 |     - 'at least one file in a package should have a package comment'
89 |     - 'string literal contains the Unicode'
90 |     - 'methods on the same type should have the same receiver name'
91 |     - '_TokenType_name should be _TokenTypeName'
92 |     - '`_TokenType_map` should be `_TokenTypeMap`'
93 |     - 'rewrite if-else to switch statement'
94 |     - 'comment.*should be of the form'
95 |     - 'should have comment'
96 | 


--------------------------------------------------------------------------------
/.goreleaser.yml:
--------------------------------------------------------------------------------
 1 | project_name: happy
 2 | release:
 3 |   github:
 4 |     owner: thnxdev
 5 |     name: happy
 6 | brews:
 7 |   -
 8 |     install: bin.install "happy"
 9 | env:
10 |   - CGO_ENABLED=0
11 | builds:
12 | - goos:
13 |     - linux
14 |     - darwin
15 |     - windows
16 |   goarch:
17 |     - arm64
18 |     - amd64
19 |     - "386"
20 |   goarm:
21 |     - "6"
22 |   dir: ./cmd/happy
23 |   main: .
24 |   ldflags: -s -w -X main.version={{.Version}}
25 |   binary: happy
26 | archives:
27 |   -
28 |     format: tar.gz
29 |     name_template: '{{ .Binary }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{
30 |     .Arm }}{{ end }}'
31 |     files:
32 |       - COPYING
33 |       - README*
34 | snapshot:
35 |   name_template: SNAPSHOT-{{ .Commit }}
36 | checksum:
37 |   name_template: '{{ .ProjectName }}-{{ .Version }}-checksums.txt'
38 | 


--------------------------------------------------------------------------------
/COPYING:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2023 thanks.dev
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # happy is an opinionated tool for generating request-handler boilerplate for Go 😊 [![CI](https://github.com/thnxdev/happy/actions/workflows/ci.yml/badge.svg)](https://github.com/thnxdev/happy/actions/workflows/ci.yml)
  2 | 
  3 | happy automatically generates `http.RequestHandler` boilerplate for routing to Go
  4 | methods annotated with comment directives. The generated code decodes the
  5 | incoming HTTP request into the method's parameters, and encodes method return
  6 | values to HTTP responses.
  7 | 
  8 | happy only supports JSON request/response payloads. That said, see
  9 | [below](#escape-hatch) for workarounds that can leverage just happy's routing.
 10 | 
 11 | happy's generated code relies on only the standard library.
 12 | 
 13 | Here's an example annotated method that happy will generate a request handler for:
 14 | 
 15 | ```go
 16 | //happy:api GET /users/:id
 17 | func (u *UsersService) GetUser(id string) (User, error) {
 18 | 	for _, user := range u.users {
 19 | 		if user.ID == id {
 20 | 			return user, nil
 21 | 		}
 22 | 	}
 23 | 	return User{}, Errorf(http.StatusNotFound, "user %q not found", id)
 24 | }
 25 | ```
 26 | 
 27 | The generated request handler will map the path component `:id` to the parameter
 28 | `id`, and JSON encode the response payload or error.
 29 | 
 30 | See [below](#example) for a full example.
 31 | 
 32 | # Status
 33 | 
 34 | happy is usable but has some limitations and missing features:
 35 | 
 36 | - Does not support pointers to structs for JSON request payloads, only values.
 37 | - Limited (int and string) type support for path and query parameters.
 38 | - Does not support embedded structs for query parameters.
 39 | - A command to dump the API as an OpenAPI schema.
 40 | 
 41 | # Protocol
 42 | 
 43 | happy's protocol is in the form of Go comment directives. Each directive must be
 44 | placed on a method, not a free function.
 45 | 
 46 | Annotations and methods are in the following form:
 47 | 
 48 | ```go
 49 | //happy:api <method> <path> [<option>[=<value>] ...]
 50 | func (s Struct) Method([pathVar0, pathVar1 string][, req Request]) ([<response>, ][error]) { ... }
 51 | ```
 52 | 
 53 | ## Options
 54 | 
 55 | Options are key+value pairs appended to the end of an annotation and are exposed
 56 | via the following generated method on the service struct:
 57 | 
 58 | ```go
 59 | HandlerOptions(r *http.Request) map[string]string
 60 | ```
 61 | 
 62 | This method will return the metadata map associated with the inbound request, or
 63 | `nil`.
 64 | 
 65 | ### Middleware
 66 | 
 67 | A handy pattern is to create a wrapping `http.Handler` that injects options
 68 | into the inbound request context like so:
 69 | 
 70 | ```go
 71 | var Options struct{}
 72 | 
 73 | type OptionHandler interface {
 74 | 	HandlerOptions(*http.Request) map[string]string
 75 | }
 76 | 
 77 | func OptionsMiddleware(options OptionHandler, next http.Handler) http.Handler {
 78 | 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 79 | 		ctx := context.WithValue(r.Context(), Options, options.HandlerOptions(r))
 80 | 		r = r.WithContext(ctx)
 81 | 		next.ServeHTTP(w, r)
 82 | 	})
 83 | }
 84 | ```
 85 | 
 86 | Middleware can then make decisions based on the values of options. For example, a hypothetical `auth` option might be used like so:
 87 | 
 88 | ```go
 89 | func AuthMiddleware(next http.Handler) http.Handler {
 90 | 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 91 | 		_, auth := r.Context.Value(Options)["auth]
 92 | 		if !auth {
 93 | 			next.ServeHttp(w, r)
 94 | 			return
 95 | 		}
 96 | 		// Authenticate endpoint...
 97 | 		cookie, err := r.Cookie("auth")
 98 | 		// ...
 99 | 	})
100 | }
101 | ```
102 | 
103 | ## Request signature
104 | 
105 | The `<path>` value supports variables in the form `:<name>` which are mapped
106 | directly to method parameters of the same name. These parameters must implement
107 | `encoding.TextUnmarshaler` or be of type `string` or `int`.
108 | 
109 | eg.
110 | 
111 | ```go
112 | //happy:api GET /users/:id
113 | func (u *UsersService) GetUser(id string) (User, error) { ... }
114 | ```
115 | 
116 | In addition to path variables and the request payload, happy can pass any of the
117 | following types to your handler method:
118 | 
119 | - `*http.Request`
120 | - `http.ResponseWriter`
121 | - `context.Context` from the incoming `*http.Request`
122 | - `io.Reader` for the request body
123 | 
124 | ### Request payload decoding
125 | 
126 | Finally, a single extra struct parameter can be specified, which will be decoded
127 | from the request payload. For PUT/POST request the "payload" is the request
128 | body, for all other request types the "payload" is the URL query parameters. 
129 | 
130 | eg.
131 | 
132 | ```go
133 | type Paginate struct {
134 | 	Size int
135 | }
136 | 
137 | //happy:api GET /users/
138 | func (u *UsersService) ListUsers(pagination Paginate) ([]User, error) {
139 | 	// ...
140 | }
141 | ```
142 | 
143 | #### Query parameter decoding
144 | 
145 | For query parameters, embedded structs are not supported and fields may
146 | (currently) only be of types `bool`, `int` and `string`.
147 | 
148 | The name of the query parameter will be the name of the Go field with the first
149 | letter lower-cased. This can be overridden with the field tag `query:"<name>"`.
150 | 
151 | ## Response signature
152 | 
153 | The return signature of the method is in the form:
154 | 
155 | ```
156 | [([<response>, ][error])]
157 | ```
158 | 
159 | That is, the method may return a response, an error, both, or nothing.
160 | 
161 |  Depending on the type of the `<response>` value, the response will be encoded
162 |  in the following ways:
163 | 
164 |  | Type | Encoding |
165 |  | ---- | -------- |
166 |  | `nil`/omitted | 204 No Content |
167 |  | `string` | `text/html` |
168 |  | `[]byte` | `application/octet-stream` |
169 |  | `io.Reader` | `application/octet-stream` |
170 |  | `io.ReadCloser` | `application/octet-stream` |
171 |  | `*http.Response` | Response structure is used as-is. |
172 |  | `*` | `application/json` |
173 | 
174 | ## Error handling
175 | 
176 | If the method returns an error, happy will generate code to check the error
177 | and return an error response. If the error value implements `http.Handler` that
178 | will be used to generate the response, otherwise a 500 response will be
179 | generated.
180 | 
181 | A rudimentary HTTP error type might look like this:
182 | 
183 | ```go
184 | type Error struct {
185 | 	Code int
186 | 	Msg string
187 | }
188 | 
189 | func (e Error) Error() string { return fmt.Sprintf("%d: %s", e.Code, e.Msg) }
190 | func (e Error) ServeHTTP(w http.ResponseWriter, r *http.Request) {
191 | 	http.Error(w, w.Msg, e.Code)
192 | }
193 | ```
194 | 
195 | Additionally, if the receiver implements the following interface it will be used
196 | to write errors:
197 | 
198 | ```go
199 | type ErrorHandler interface {
200 | }
201 | ```
202 | 
203 | ## Escape hatch
204 | 
205 | If happy's default request/response handling is not to your liking, you can still
206 | leverage happy's routing by accepting `*http.Request` and `http.ResponseWriter`
207 | as parameters:
208 | 
209 | ```go
210 | //happy:api POST /users
211 | func (s Struct) CreateUser(r *http.Request, w http.ResponseWriter) { ... }
212 | ```
213 | 
214 | # Example
215 | 
216 | Create a `main.go` with the following content and run `go generate`. happy will
217 | create a `main_api.go` file implementing `http.Handler` for `*Service`.
218 | 
219 | ```go
220 | //go:generate happy
221 | package main
222 | 
223 | import (
224 | 	"encoding/json"
225 | 	"fmt"
226 | 	"net/http"
227 | )
228 | 
229 | // An Error that implements http.Handler to write structured JSON errors.
230 | type Error struct {
231 | 	code    int
232 | 	message string
233 | }
234 | 
235 | func Errorf(code int, format string, args ...interface{}) error {
236 | 	return Error{code, fmt.Sprintf(format, args...)}
237 | }
238 | 
239 | func (e Error) Error() string { return e.message }
240 | 
241 | func (e Error) ServeHTTP(w http.ResponseWriter, r *http.Request) {
242 | 	w.Header().Set("Content-Type", "application/json")
243 | 	w.WriteHeader(e.code)
244 | 	json.NewEncoder(w).Encode(map[string]string{"error": e.message})
245 | }
246 | 
247 | type User struct {
248 | 	ID   int    `json:"id"`
249 | 	Name string `json:"name"`
250 | }
251 | 
252 | type Service struct {
253 | 	users []User
254 | }
255 | 
256 | //happy:api GET /users/:id
257 | func (s *Service) GetUser(id int) (User, error) {
258 | 	for _, user := range s.users {
259 | 		if user.ID == id {
260 | 			return user, nil
261 | 		}
262 | 	}
263 | 	return User{}, Errorf(http.StatusNotFound, "user %q not found", id)
264 | }
265 | 
266 | //happy:api GET /users
267 | func (s *Service) ListUsers() ([]User, error) {
268 | 	return s.users, nil
269 | }
270 | 
271 | //happy:api POST /users
272 | func (s *Service) CreateUser(user User) error {
273 | 	for _, u := range s.users {
274 | 		if u.ID == user.ID {
275 | 			return Errorf(http.StatusConflict, "user %d already exists", user.ID)
276 | 		}
277 | 	}
278 | 	s.users = append(s.users, user)
279 | 	return Errorf(http.StatusCreated, "user %d created", user.ID)
280 | }
281 | 
282 | func main() {
283 | 	service := &Service{
284 | 		users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}},
285 | 	}
286 | 	http.ListenAndServe(":8080", service)
287 | }
288 | ```
289 | 
290 | *happy's annotations are vaguely inspired by [Encore](https://encore.dev/).*


--------------------------------------------------------------------------------
/bin/.go-1.19.3.pkg:
--------------------------------------------------------------------------------
1 | hermit


--------------------------------------------------------------------------------
/bin/.golangci-lint-1.50.1.pkg:
--------------------------------------------------------------------------------
1 | hermit


--------------------------------------------------------------------------------
/bin/.goreleaser-1.15.0.pkg:
--------------------------------------------------------------------------------
1 | hermit


--------------------------------------------------------------------------------
/bin/.jq-1.6.pkg:
--------------------------------------------------------------------------------
1 | hermit


--------------------------------------------------------------------------------
/bin/.reflex-0.3.1.pkg:
--------------------------------------------------------------------------------
1 | hermit


--------------------------------------------------------------------------------
/bin/.shellcheck-0.8.0.pkg:
--------------------------------------------------------------------------------
1 | hermit


--------------------------------------------------------------------------------
/bin/README.hermit.md:
--------------------------------------------------------------------------------
1 | # Hermit environment
2 | 
3 | This is a [Hermit](https://github.com/cashapp/hermit) bin directory.
4 | 
5 | The symlinks in this directory are managed by Hermit and will automatically
6 | download and install Hermit itself as well as packages. These packages are
7 | local to this environment.
8 | 


--------------------------------------------------------------------------------
/bin/activate-hermit:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # This file must be used with "source bin/activate-hermit" from bash or zsh.
 3 | # You cannot run it directly
 4 | #
 5 | # THIS FILE IS GENERATED; DO NOT MODIFY
 6 | 
 7 | if [ "${BASH_SOURCE-}" = "$0" ]; then
 8 |   echo "You must source this script: \$ source $0" >&2
 9 |   exit 33
10 | fi
11 | 
12 | BIN_DIR="$(dirname "${BASH_SOURCE[0]:-${(%):-%x}}")"
13 | if "${BIN_DIR}/hermit" noop > /dev/null; then
14 |   eval "$("${BIN_DIR}/hermit" activate "${BIN_DIR}/..")"
15 | 
16 |   if [ -n "${BASH-}" ] || [ -n "${ZSH_VERSION-}" ]; then
17 |       hash -r 2>/dev/null
18 |     fi
19 | 
20 |     echo "Hermit environment $("${HERMIT_ENV}"/bin/hermit env HERMIT_ENV) activated"
21 | fi
22 | 


--------------------------------------------------------------------------------
/bin/go:
--------------------------------------------------------------------------------
1 | .go-1.19.3.pkg


--------------------------------------------------------------------------------
/bin/gofmt:
--------------------------------------------------------------------------------
1 | .go-1.19.3.pkg


--------------------------------------------------------------------------------
/bin/golangci-lint:
--------------------------------------------------------------------------------
1 | .golangci-lint-1.50.1.pkg


--------------------------------------------------------------------------------
/bin/goreleaser:
--------------------------------------------------------------------------------
1 | .goreleaser-1.15.0.pkg


--------------------------------------------------------------------------------
/bin/hermit:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #
 3 | # THIS FILE IS GENERATED; DO NOT MODIFY
 4 | 
 5 | set -eo pipefail
 6 | 
 7 | export HERMIT_USER_HOME=~
 8 | 
 9 | if [ -z "${HERMIT_STATE_DIR}" ]; then
10 |   case "$(uname -s)" in
11 |   Darwin)
12 |     export HERMIT_STATE_DIR="${HERMIT_USER_HOME}/Library/Caches/hermit"
13 |     ;;
14 |   Linux)
15 |     export HERMIT_STATE_DIR="${XDG_CACHE_HOME:-${HERMIT_USER_HOME}/.cache}/hermit"
16 |     ;;
17 |   esac
18 | fi
19 | 
20 | export HERMIT_DIST_URL="${HERMIT_DIST_URL:-https://github.com/cashapp/hermit/releases/download/stable}"
21 | HERMIT_CHANNEL="$(basename "${HERMIT_DIST_URL}")"
22 | export HERMIT_CHANNEL
23 | export HERMIT_EXE=${HERMIT_EXE:-${HERMIT_STATE_DIR}/pkg/hermit@${HERMIT_CHANNEL}/hermit}
24 | 
25 | if [ ! -x "${HERMIT_EXE}" ]; then
26 |   echo "Bootstrapping ${HERMIT_EXE} from ${HERMIT_DIST_URL}" 1>&2
27 |   INSTALL_SCRIPT="$(mktemp)"
28 |   # This value must match that of the install script
29 |   INSTALL_SCRIPT_SHA256="180e997dd837f839a3072a5e2f558619b6d12555cd5452d3ab19d87720704e38"
30 |   if [ "${INSTALL_SCRIPT_SHA256}" = "BYPASS" ]; then
31 |     curl -fsSL "${HERMIT_DIST_URL}/install.sh" -o "${INSTALL_SCRIPT}"
32 |   else
33 |     # Install script is versioned by its sha256sum value
34 |     curl -fsSL "${HERMIT_DIST_URL}/install-${INSTALL_SCRIPT_SHA256}.sh" -o "${INSTALL_SCRIPT}"
35 |     # Verify install script's sha256sum
36 |     openssl dgst -sha256 "${INSTALL_SCRIPT}" | \
37 |       awk -v EXPECTED="$INSTALL_SCRIPT_SHA256" \
38 |       '$2!=EXPECTED {print "Install script sha256 " $2 " does not match " EXPECTED; exit 1}'
39 |   fi
40 |   /bin/bash "${INSTALL_SCRIPT}" 1>&2
41 | fi
42 | 
43 | exec "${HERMIT_EXE}" --level=fatal exec "$0" -- "$@"
44 | 


--------------------------------------------------------------------------------
/bin/hermit.hcl:
--------------------------------------------------------------------------------
1 | env = {
2 |   "PATH": "${HERMIT_ENV}/scripts:${PATH}",
3 | }
4 | 


--------------------------------------------------------------------------------
/bin/jq:
--------------------------------------------------------------------------------
1 | .jq-1.6.pkg


--------------------------------------------------------------------------------
/bin/reflex:
--------------------------------------------------------------------------------
1 | .reflex-0.3.1.pkg


--------------------------------------------------------------------------------
/bin/shellcheck:
--------------------------------------------------------------------------------
1 | .shellcheck-0.8.0.pkg


--------------------------------------------------------------------------------
/cmd/happy/main.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | 	"go/ast"
  7 | 	"go/format"
  8 | 	"go/token"
  9 | 	"go/types"
 10 | 	"net/http"
 11 | 	"os"
 12 | 	"regexp"
 13 | 	"strings"
 14 | 	"sync"
 15 | 	"unicode/utf8"
 16 | 
 17 | 	"github.com/alecthomas/kong"
 18 | 	"github.com/fatih/structtag"
 19 | 	"golang.org/x/tools/go/packages"
 20 | 
 21 | 	"github.com/thnxdev/happy/codewriter"
 22 | )
 23 | 
 24 | var (
 25 | 	version string = "dev"
 26 | 	cli     struct {
 27 | 		Version kong.VersionFlag `help:"Show version."`
 28 | 		List    bool             `help:"List endpoints."`
 29 | 		Pkg     string           `arg:"" help:"Package to scan for API definitions." default:"."`
 30 | 	}
 31 | 	fset = token.NewFileSet()
 32 | 	// httpHandlerInterface     = mustLoadInterface("net/http", "Handler")
 33 | 	textUnmarshalerInterface = mustLoadInterface("encoding", "TextUnmarshaler")
 34 | )
 35 | 
 36 | type directive struct {
 37 | 	doc        string
 38 | 	method     string
 39 | 	pattern    string
 40 | 	options    map[string]string
 41 | 	pathParams []string
 42 | }
 43 | 
 44 | type endpoint struct {
 45 | 	decl      *ast.FuncDecl
 46 | 	fn        *types.Func
 47 | 	signature *types.Signature
 48 | 	directive directive
 49 | }
 50 | 
 51 | func main() {
 52 | 	kctx := kong.Parse(&cli, kong.Vars{"version": version}, kong.Description(`
 53 | happy automatically generates http.RequestHandler boilerplate for routing to Go
 54 | methods annotated with comment directives. The generated code decodes the
 55 | incoming HTTP request into the method's parameters, and encodes method return
 56 | values to HTTP responses.
 57 | 
 58 | eg.
 59 | 
 60 |   //happy:api GET /users/:id
 61 |   func (s *Server) GetUserByID(id int) (User, error) {
 62 | 	// ...
 63 |   }
 64 | 
 65 | See https://github.com/thnxdev/happy for more information.
 66 | `), kong.HelpOptions{WrapUpperBound: 90})
 67 | 	pkgs, err := packages.Load(&packages.Config{
 68 | 		Fset: fset,
 69 | 		Mode: packages.NeedName | packages.NeedFiles | packages.NeedSyntax | packages.NeedTypes | packages.NeedTypesInfo,
 70 | 	}, cli.Pkg)
 71 | 	kctx.FatalIfErrorf(err)
 72 | 
 73 | 	if cli.List {
 74 | 		err = listEndpoints(pkgs)
 75 | 		kctx.FatalIfErrorf(err)
 76 | 		kctx.Exit(0)
 77 | 	}
 78 | 
 79 | 	didWork := false
 80 | 	for _, pkg := range pkgs {
 81 | 		outPath, endpoints, err := extractEndpoints(pkg)
 82 | 		kctx.FatalIfErrorf(err)
 83 | 		if len(endpoints) == 0 {
 84 | 			continue
 85 | 		}
 86 | 		didWork = true
 87 | 
 88 | 		gctx := &genContext{
 89 | 			Writer:      codewriter.New(pkg.Name),
 90 | 			pkg:         pkg,
 91 | 			haveDecoder: map[string]bool{},
 92 | 		}
 93 | 		gctx.Import("net/http", "io", "encoding/json", "strconv")
 94 | 		for _, svcEndpoints := range endpoints {
 95 | 			err := generateHandler(gctx, svcEndpoints, makeTree(svcEndpoints))
 96 | 			kctx.FatalIfErrorf(err)
 97 | 		}
 98 | 
 99 | 		source := gctx.Bytes()
100 | 		formatted, err := format.Source(source)
101 | 		if err != nil {
102 | 			for i, line := range bytes.Split(source, []byte("\n")) {
103 | 				fmt.Printf("%3d: %s\n", i+1, line)
104 | 			}
105 | 			kctx.FatalIfErrorf(err)
106 | 		}
107 | 		err = os.WriteFile(outPath, formatted, 0600)
108 | 		kctx.FatalIfErrorf(err)
109 | 	}
110 | 
111 | 	if !didWork {
112 | 		kctx.Fatalf("no annotated endpoints found, nothing to do")
113 | 	}
114 | }
115 | 
116 | func listEndpoints(pkgs []*packages.Package) error {
117 | 	for _, pkg := range pkgs {
118 | 		_, endpoints, err := extractEndpoints(pkg)
119 | 		if err != nil {
120 | 			return fmt.Errorf("could not list endpoints: %w", err)
121 | 		}
122 | 		if len(endpoints) == 0 {
123 | 			continue
124 | 		}
125 | 
126 | 		for _, handlerEndpoints := range endpoints {
127 | 			for _, endpoint := range handlerEndpoints {
128 | 				dir := endpoint.directive
129 | 				fmt.Printf("%s %s\n", dir.method, dir.pattern)
130 | 				if dir.doc != "" {
131 | 					for _, line := range strings.Split(strings.TrimSpace(dir.doc), "\n") {
132 | 						fmt.Println("  " + line)
133 | 					}
134 | 				}
135 | 			}
136 | 		}
137 | 	}
138 | 	return nil
139 | }
140 | 
141 | func generateHandler(gctx *genContext, eps []endpoint, tree *tree) error {
142 | 	var ptr string
143 | 	var recvType *types.Named
144 | 	recv := eps[0].signature.Recv().Type()
145 | 	if ptrt, ok := recv.(*types.Pointer); ok {
146 | 		ptr = "*"
147 | 		recvType = ptrt.Elem().(*types.Named)
148 | 	}
149 | 	w := gctx.Writer
150 | 	w.L("")
151 | 	w.L("func (h %s%s) HandlerOptions(r *http.Request) map[string]string {", ptr, recvType.Obj().Name())
152 | 	optionsEndpoints := []endpoint{}
153 | 	for _, ep := range eps {
154 | 		if len(ep.directive.options) > 0 {
155 | 			optionsEndpoints = append(optionsEndpoints, ep)
156 | 		}
157 | 	}
158 | 	optionsTree := makeTree(optionsEndpoints)
159 | 	w.In(func(w *codewriter.Writer) {
160 | 		optionsTree.Write(w, "return nil", func(w *codewriter.Writer, ep endpoint) {
161 | 			if len(ep.directive.options) == 0 {
162 | 				w.L("return nil")
163 | 				return
164 | 			}
165 | 			w.L("out := %#v", ep.directive.options)
166 | 			w.L("// Merge url params into options")
167 | 			w.L("for k, v := range params { out[k] = v }")
168 | 			w.L("return out")
169 | 		})
170 | 		w.L("return nil")
171 | 	})
172 | 	w.L("}")
173 | 	w.L("")
174 | 	w.L("func (h %s%s) ServeHTTP(w http.ResponseWriter, r *http.Request) {", ptr, recvType.Obj().Name())
175 | 	w = w.Push()
176 | 	w.L("var err error")
177 | 	w.L("var res any")
178 | 	var treeError error
179 | 	tree.Write(w, "return", func(w *codewriter.Writer, ep endpoint) {
180 | 		if err := genEndpoint(gctx, w, ep); err != nil {
181 | 			pos := gctx.Pos(ep.signature.Recv().Pos())
182 | 			treeError = fmt.Errorf("%s: failed to generate endpoint: %w", pos, err)
183 | 		}
184 | 		w.L("goto matched")
185 | 	})
186 | 	if treeError != nil {
187 | 		return treeError
188 | 	}
189 | 	w.L("  // No match but we don't return a 404 here, to allow the default handler to take control.")
190 | 	w.L("  return")
191 | 	w.L("matched:")
192 | 	w.L("")
193 | 	w.L("// Handle errors")
194 | 	w.L("if err != nil {")
195 | 	w.L("  if herr, ok := err.(http.Handler); ok {")
196 | 	w.L("    herr.ServeHTTP(w, r)")
197 | 	w.L("  } else {")
198 | 	w.L("		 http.Error(w, err.Error(), http.StatusInternalServerError)")
199 | 	w.L("  }")
200 | 	w.L("  return")
201 | 	w.L("}")
202 | 	w.L("")
203 | 	w.L("// Handle response")
204 | 	w.L("switch res := res.(type) {")
205 | 	w.L("case nil:")
206 | 	w.L("  w.WriteHeader(http.StatusNoContent)")
207 | 	w.L("case string:")
208 | 	w.L("  w.Header().Set(\"Content-Type\", \"text/html\")")
209 | 	w.L("  io.WriteString(w, res)")
210 | 	w.L("case []byte:")
211 | 	w.L("  w.Header().Set(\"Content-Type\", \"application/octet-stream\")")
212 | 	w.L("  w.Write(res)")
213 | 	w.L("case *http.Response:")
214 | 	w.L("  headers := w.Header()")
215 | 	w.L("  for k, v := range res.Header {")
216 | 	w.L("    headers[k] = v")
217 | 	w.L("  }")
218 | 	w.L("  w.WriteHeader(res.StatusCode)")
219 | 	w.L("  _, _ = io.Copy(w, res.Body)")
220 | 	w.L("case io.ReadCloser:")
221 | 	w.L("  w.Header().Set(\"Content-Type\", \"application/octet-stream\")")
222 | 	w.L("  _, _ = io.Copy(w, res)")
223 | 	w.L("  res.Close()")
224 | 	w.L("case io.Reader:")
225 | 	w.L("  w.Header().Set(\"Content-Type\", \"application/octet-stream\")")
226 | 	w.L("  _, _ = io.Copy(w, res)")
227 | 	w.L("default:")
228 | 	w.In(func(w *codewriter.Writer) {
229 | 		w.L("data, err := json.Marshal(res)")
230 | 		w.L("if err != nil {")
231 | 		w.L("  http.Error(w, `failed to encode response: ` + err.Error(), http.StatusInternalServerError)")
232 | 		w.L("  return")
233 | 		w.L("}")
234 | 		w.L("w.Header().Set(\"Content-Type\", \"application/json; charset=utf-8\")")
235 | 		w.L("w.Header().Set(\"Content-Length\", strconv.Itoa(len(data)))")
236 | 		w.L("w.WriteHeader(http.StatusOK)")
237 | 		w.L("w.Write(data)")
238 | 	})
239 | 	w.L("}")
240 | 	w = w.Pop()
241 | 	w.L("}")
242 | 	return nil
243 | }
244 | 
245 | //nolint:nakedret
246 | func extractEndpoints(pkg *packages.Package) (outPath string, endpoints map[string][]endpoint, retErr error) {
247 | 	endpoints = map[string][]endpoint{}
248 | 	for _, file := range pkg.Syntax {
249 | 		ast.Inspect(file, func(node ast.Node) bool {
250 | 			fn, ok := node.(*ast.FuncDecl)
251 | 			if !ok || fn.Doc == nil {
252 | 				return true
253 | 			}
254 | 			for _, line := range fn.Doc.List {
255 | 				if strings.HasPrefix(line.Text, "//happy:api") {
256 | 					pos := pkg.Fset.Position(fn.Pos())
257 | 					dir, err := parseDirective(fn.Doc.Text(), line.Text)
258 | 					if err != nil {
259 | 						retErr = fmt.Errorf("%s: %w", pos, err)
260 | 						return false
261 | 					}
262 | 					fnt := pkg.TypesInfo.Defs[fn.Name].(*types.Func)
263 | 					sig := fnt.Type().(*types.Signature)
264 | 					receiverName := sig.Recv().Type().String()
265 | 					endpoints[receiverName] = append(endpoints[receiverName], endpoint{
266 | 						decl:      fn,
267 | 						fn:        fnt,
268 | 						signature: sig,
269 | 						directive: dir,
270 | 					})
271 | 				}
272 | 			}
273 | 			return true
274 | 		})
275 | 		if retErr != nil {
276 | 			return
277 | 		}
278 | 		if outPath == "" && len(endpoints) > 0 {
279 | 			f := pkg.Fset.File(file.Pos())
280 | 			outPath = strings.TrimSuffix(f.Name(), ".go") + "_api.go"
281 | 		}
282 | 	}
283 | 	return
284 | }
285 | 
286 | var nameExtract = regexp.MustCompile(`/:([a-zA-Z0-9]+)`)
287 | 
288 | // <method> <path> [<option>[=<value>] ...]
289 | func parseDirective(doc, comment string) (directive, error) {
290 | 	parts := strings.Fields(comment)
291 | 	if len(parts) < 3 {
292 | 		return directive{}, fmt.Errorf("invalid directive, must be in the form //api:http <method> <url> [<option>=<value> ...]: %s", comment)
293 | 	}
294 | 	pattern := parts[2]
295 | 	matches := nameExtract.FindAllStringSubmatchIndex(pattern, -1)
296 | 	dir := directive{
297 | 		doc:     doc,
298 | 		method:  parts[1],
299 | 		pattern: pattern,
300 | 		options: map[string]string{},
301 | 	}
302 | 	for _, parami := range matches {
303 | 		param := pattern[parami[2]:parami[3]]
304 | 		dir.pathParams = append(dir.pathParams, param)
305 | 	}
306 | 
307 | 	for _, option := range parts[3:] {
308 | 		parts := strings.SplitN(option, "=", 2)
309 | 		var value string
310 | 		if len(parts) == 2 {
311 | 			value = parts[1]
312 | 		}
313 | 		dir.options[parts[0]] = value
314 | 	}
315 | 	return dir, nil
316 | }
317 | 
318 | func once[T any](f func() T) func() T {
319 | 	var once sync.Once
320 | 	var t T
321 | 	return func() T {
322 | 		once.Do(func() {
323 | 			t = f()
324 | 		})
325 | 		return t
326 | 	}
327 | }
328 | 
329 | // Lazy load the compile-time type from a package.
330 | func mustLoadInterface(pkg, name string) func() *types.Interface {
331 | 	return once[*types.Interface](func() *types.Interface {
332 | 		pkgs, err := packages.Load(&packages.Config{Fset: fset, Mode: packages.NeedTypes}, pkg)
333 | 		if err != nil {
334 | 			panic(err)
335 | 		}
336 | 		if len(pkgs) != 1 {
337 | 			panic("expected one package")
338 | 		}
339 | 		iface := pkgs[0].Types.Scope().Lookup(name)
340 | 		if iface == nil {
341 | 			panic("interface not found")
342 | 		}
343 | 		return iface.Type().Underlying().(*types.Interface)
344 | 	})
345 | }
346 | 
347 | // Generate a function for decoding url.Values directly into a struct.
348 | //
349 | // Only a limited set of types are currently supported, and embedded structs are not supported.
350 | func genQueryDecoderFunc(gctx *genContext, paramType types.Type) (name string, err error) {
351 | 	strct, ok := paramType.Underlying().(*types.Struct)
352 | 	if !ok {
353 | 		return "", fmt.Errorf("parameter must be a struct but is %s", paramType)
354 | 	}
355 | 	gctx.Import("net/url")
356 | 	_, typeRef := gctx.TypeRef(paramType)
357 | 	name = "decode" + ucFirst(strings.ReplaceAll(typeRef, ".", ""))
358 | 	if gctx.haveDecoder[typeRef] {
359 | 		return name, nil
360 | 	}
361 | 	gctx.haveDecoder[typeRef] = true
362 | 	w := gctx.Trailer()
363 | 	w.L("func %s(p url.Values, out *%s) (err error) {", name, typeRef)
364 | 	w = w.Push()
365 | 	for i := 0; i < strct.NumFields(); i++ {
366 | 		field := strct.Field(i)
367 | 		tags, err := structtag.Parse(strct.Tag(i))
368 | 		if err != nil {
369 | 			return "", fmt.Errorf("invalid struct tag on %s.%s: %w", typeRef, field.Name(), err)
370 | 		}
371 | 		fieldName := lcFirst(field.Name())
372 | 		if tag, err := tags.Get("query"); err == nil {
373 | 			fieldName = tag.Name
374 | 		}
375 | 		w.L("if q, ok := p[%q]; ok {", fieldName)
376 | 		w = w.Push()
377 | 		fieldType := field.Type()
378 | 		strctRef := "out"
379 | 		if _, ptr := fieldType.(*types.Pointer); ptr {
380 | 			fieldType = fieldType.(*types.Pointer).Elem()
381 | 			w.L("out.%s = new(%s)", field.Name(), fieldType)
382 | 			strctRef = "*" + strctRef
383 | 		}
384 | 		switch fieldType.String() {
385 | 		case "time.Duration":
386 | 			gctx.Import("time")
387 | 			w.Import("fmt")
388 | 			w.L("if %s.%s, err = time.ParseDuration(q[len(q)-1]); err != nil {", strctRef, field.Name())
389 | 			w.L(`  return fmt.Errorf("failed to decode query parameter \"%s\" as %s: %%w", err)`, fieldName, fieldType)
390 | 			w.L("}")
391 | 		case "bool":
392 | 			gctx.Import("strconv")
393 | 			w.Import("fmt")
394 | 			w.L("if %s.%s, err = strconv.ParseBool(q[len(q)-1]); err != nil {", strctRef, field.Name())
395 | 			w.L(`  return fmt.Errorf("failed to decode query parameter \"%s\" as %s: %%w", err)`, fieldName, fieldType)
396 | 			w.L("}")
397 | 		case "int":
398 | 			gctx.Import("strconv")
399 | 			w.Import("fmt")
400 | 			w.L("if %s.%s, err = strconv.Atoi(q[len(q)-1]); err != nil {", strctRef, field.Name())
401 | 			w.L(`  return fmt.Errorf("failed to decode query parameter \"%s\" as %s: %%w", err)`, fieldName, fieldType)
402 | 			w.L("}")
403 | 		case "string":
404 | 			w.L("%s.%s = q[len(q)-1]", strctRef, field.Name())
405 | 		default:
406 | 			if implements(field, textUnmarshalerInterface()) {
407 | 				w.Import("fmt")
408 | 				w.L("if err = %s.%s.UnmarshalText([]byte(q[len(q)-1])); err != nil {", strctRef, field.Name())
409 | 				w.L(`  return fmt.Errorf("failed to decode query parameter \"%s\" as %s: %%w", err)`, fieldName, fieldType)
410 | 				w.L("}")
411 | 			} else {
412 | 				return "", fmt.Errorf("can't decode query parameter into field %s.%s of type %s, only encoding.TextUnmarshaler, time.Duration, int, string and bool are supported", paramType, field.Name(), field.Type())
413 | 			}
414 | 		}
415 | 		w = w.Pop()
416 | 		w.L("}")
417 | 	}
418 | 	w.L("return nil")
419 | 	w = w.Pop()
420 | 	w.L("}")
421 | 	return name, nil
422 | }
423 | 
424 | func ucFirst(s string) string {
425 | 	rn, n := utf8.DecodeRuneInString(s)
426 | 	return strings.ToUpper(string(rn)) + s[n:]
427 | }
428 | 
429 | func lcFirst(s string) string {
430 | 	rn, n := utf8.DecodeRuneInString(s)
431 | 	return strings.ToLower(string(rn)) + s[n:]
432 | }
433 | 
434 | type genContext struct {
435 | 	pkg *packages.Package
436 | 	*codewriter.Writer
437 | 	haveDecoder map[string]bool
438 | }
439 | 
440 | func (g *genContext) Pos(pos token.Pos) token.Position {
441 | 	return g.pkg.Fset.Position(pos)
442 | }
443 | 
444 | func (g *genContext) TypeRef(t types.Type) (pkgRef, ref string) {
445 | 	if named, ok := t.(*types.Named); ok {
446 | 		pkgRef = named.Obj().Pkg().Path()
447 | 		ref = named.Obj().Name()
448 | 		if pkgRef == g.pkg.PkgPath {
449 | 			pkgRef = ""
450 | 		} else {
451 | 			ref = named.Obj().Pkg().Name() + "." + ref
452 | 		}
453 | 		return
454 | 	}
455 | 	return "", t.String()
456 | }
457 | 
458 | func genEndpoint(gctx *genContext, w *codewriter.Writer, ep endpoint) error {
459 | 	params := ep.signature.Params()
460 | 	isParam := map[string]bool{}
461 | 	for i := 0; i < params.Len(); i++ {
462 | 		isParam[params.At(i).Name()] = true
463 | 	}
464 | 
465 | 	isGroup := map[string]int{}
466 | 	for i, param := range ep.directive.pathParams {
467 | 		isGroup[param] = i + 1
468 | 	}
469 | 
470 | 	args := []string{}
471 | 	for i := 0; i < params.Len(); i++ {
472 | 		param := params.At(i)
473 | 		pos := gctx.Pos(param.Pos())
474 | 		tn := param.Type().String()
475 | 		switch {
476 | 		case tn == "context.Context":
477 | 			args = append(args, "r.Context()")
478 | 
479 | 		case tn == "net/http.ResponseWriter":
480 | 			args = append(args, "w")
481 | 			gctx.Import("net/http")
482 | 
483 | 		case tn == "io.Reader":
484 | 			args = append(args, "r.Body")
485 | 
486 | 		case tn == "*net/http.Request":
487 | 			args = append(args, "r")
488 | 			gctx.Import("net/http")
489 | 
490 | 		case isGroup[param.Name()] != 0:
491 | 			index := isGroup[param.Name()] - 1
492 | 			pkgRef, ref := gctx.TypeRef(param.Type())
493 | 			if pkgRef != "" {
494 | 				gctx.Import(pkgRef)
495 | 			}
496 | 			bt := param.Type().Underlying().String()
497 | 			// Type aliases (eg. type Foo int) are supported if they alias
498 | 			// string or int, or implement encoding.TextUnmarshaler.
499 | 			switch {
500 | 			case implements(param, textUnmarshalerInterface()):
501 | 				paramName := fmt.Sprintf("param%d", index)
502 | 				w.L("var %s %s", paramName, ref)
503 | 				w.L(`if err := %s.UnmarshalText([]byte(params[":%s"])); err != nil {`, paramName, param.Name())
504 | 				w.L("  http.Error(w, \"%s: \" + err.Error(), http.StatusBadRequest)", param.Name())
505 | 				w.L("  return")
506 | 				w.L("}")
507 | 				args = append(args, paramName)
508 | 
509 | 			case bt == "string":
510 | 				if bt != ref {
511 | 					args = append(args, fmt.Sprintf(`%s(params[":%s"])`, ref, param.Name()))
512 | 				} else {
513 | 					args = append(args, fmt.Sprintf(`params[":%s"]`, param.Name()))
514 | 				}
515 | 
516 | 			case bt == "int":
517 | 				paramName := fmt.Sprintf("param%d", index)
518 | 				w.L("var %s int", paramName)
519 | 				w.L(`%s, err = strconv.Atoi(params[":%s"])`, paramName, param.Name())
520 | 				if bt != ref {
521 | 					args = append(args, fmt.Sprintf("%s(%s)", ref, paramName))
522 | 				} else {
523 | 					args = append(args, paramName)
524 | 				}
525 | 				w.L("if err != nil {")
526 | 				w.L("  http.Error(w, \"%s: \" + err.Error(), http.StatusBadRequest)", param.Name())
527 | 				w.L("  return")
528 | 				w.L("}")
529 | 
530 | 			default:
531 | 				return fmt.Errorf("%s: %s: unsupported named parameter type %q", pos, param.Name(), param.Type())
532 | 			}
533 | 
534 | 		// Not a parameter, so it must be a request body or query parameters.
535 | 		default: // TODO(aat): Handle pointers.
536 | 			paramType, ok := param.Type().(*types.Named)
537 | 			if !ok {
538 | 				return fmt.Errorf("%s: parameter %q does not map to any URL path variables and is of type %q, but must be a struct to be used as a request payload", pos, param.Name(), param.Type())
539 | 			}
540 | 			pkgRef, ref := gctx.TypeRef(param.Type())
541 | 			gctx.Import(pkgRef)
542 | 
543 | 			w.L("var param%d %s", i, ref)
544 | 			gctx.Import("net/http")
545 | 			if ep.directive.method == http.MethodGet || ep.directive.method == http.MethodDelete {
546 | 				decoderFn, err := genQueryDecoderFunc(gctx, paramType)
547 | 				if err != nil {
548 | 					return fmt.Errorf("%s: %w", pos, err)
549 | 				}
550 | 				w.L("if err := %s(r.URL.Query(), &param%d); err != nil {", decoderFn, i)
551 | 				w.L(`  http.Error(w, err.Error(), http.StatusBadRequest)`)
552 | 				w.L("  return")
553 | 				w.L("}")
554 | 			} else {
555 | 				gctx.Import("encoding/json")
556 | 				gctx.Import("fmt")
557 | 				w.L("if err := json.NewDecoder(r.Body).Decode(&param%d); err != nil {", i)
558 | 				w.L("  http.Error(w, fmt.Sprintf(\"Failed to decode request body: %%s\", err), http.StatusBadRequest)")
559 | 				w.L("  return")
560 | 				w.L("}")
561 | 			}
562 | 			args = append(args, fmt.Sprintf("param%d", i))
563 | 		}
564 | 	}
565 | 	results := ep.signature.Results()
566 | 	switch results.Len() {
567 | 	case 0:
568 | 	case 2:
569 | 		w.W("  res, err = ")
570 | 		pos := gctx.Pos(results.At(0).Pos())
571 | 		resType := results.At(0).Type()
572 | 		switch resType.String() {
573 | 		case "string", "[]byte", "*net/http.Response":
574 | 		default:
575 | 			switch resType.(type) {
576 | 			case *types.Named, *types.Slice, *types.Map:
577 | 			default:
578 | 				return fmt.Errorf("%s: unsupported return type %s", pos, results.At(0).Type())
579 | 			}
580 | 		}
581 | 	case 1:
582 | 		if results.At(0).Type().String() == "error" {
583 | 			w.W("  err = ")
584 | 			break
585 | 		}
586 | 		fallthrough
587 | 	default:
588 | 		return fmt.Errorf("%s: handler return values must be in the form (error) or (T, error)", ep.fn.Name())
589 | 	}
590 | 	w.L("h.%s(%s)", ep.fn.Name(), strings.Join(args, ", "))
591 | 	if results.Len() == 0 {
592 | 		w.L("return")
593 | 	}
594 | 	return nil
595 | }
596 | 
597 | // A tree of path components mapping to endpoints.
598 | type tree struct {
599 | 	part      string
600 | 	children  []tree
601 | 	endpoints []endpoint
602 | }
603 | 
604 | func (t *tree) String() string {
605 | 	if len(t.children) == 0 {
606 | 		return fmt.Sprintf("/%s(%d)", t.part, len(t.endpoints))
607 | 	}
608 | 	childStrings := []string{}
609 | 	for _, child := range t.children {
610 | 		childStrings = append(childStrings, child.String())
611 | 	}
612 | 	return fmt.Sprintf("/%s(%d)[%s]", t.part, len(t.endpoints), strings.Join(childStrings, ", "))
613 | }
614 | 
615 | func (t *tree) Write(w *codewriter.Writer, earlyExit string, visitor func(w *codewriter.Writer, endpoint endpoint)) {
616 | 	w.Import("strings")
617 | 	w.L(`parts := []string{}`)
618 | 	w.L(`for i, p := range strings.Split(r.URL.Path, "/") {`)
619 | 	w.L(`	if i == 0 || p != "" {`)
620 | 	w.L(`		parts = append(parts, p)`)
621 | 	w.L(`	}`)
622 | 	w.L(`}`)
623 | 	w.L(`var params map[string]string = map[string]string{}`)
624 | 	w.L(`_ = params`)
625 | 	w.L(`switch parts[0] {`)
626 | 	t.recursiveWrite(w, 0, visitor, earlyExit)
627 | 	w.L(`}`)
628 | }
629 | 
630 | func (t *tree) recursiveWrite(w *codewriter.Writer, n int, visitor func(w *codewriter.Writer, endpoint endpoint), earlyExit string) {
631 | 	// Check if we want to match more path components but we've run out.
632 | 	// Variable path component always matches.
633 | 	if !strings.HasPrefix(t.part, ":") {
634 | 		w.L(`case "%s":`, t.part)
635 | 	} else {
636 | 		w.L(`default: // Parameter %s`, t.part)
637 | 		w.L(`  params["%s"] = parts[%d]`, t.part, n)
638 | 	}
639 | 	w.In(func(w *codewriter.Writer) {
640 | 		w.In(func(w *codewriter.Writer) {
641 | 			w.L(`if len(parts) == %d {`, n+1)
642 | 			w.In(func(w *codewriter.Writer) {
643 | 				if len(t.endpoints) > 0 {
644 | 					w.L(`switch r.Method { // Leaf`)
645 | 					for _, endpoint := range t.endpoints {
646 | 						w.L(`case "%s":`, endpoint.directive.method)
647 | 						w.In(func(w *codewriter.Writer) {
648 | 							visitor(w, endpoint) //nolint:scopelint
649 | 						})
650 | 					}
651 | 					w.L(`}`)
652 | 				}
653 | 				w.L(`%s`, earlyExit)
654 | 			})
655 | 			w.L(`}`)
656 | 			if len(t.children) != 0 {
657 | 				w.L(`switch parts[%d] {`, n+1)
658 | 				for _, child := range t.children {
659 | 					child.recursiveWrite(w, n+1, visitor, earlyExit)
660 | 				}
661 | 				w.L(`}`)
662 | 			} else {
663 | 				w.L(`%s`, earlyExit)
664 | 			}
665 | 		})
666 | 	})
667 | }
668 | 
669 | func makeTree(endpoints []endpoint) *tree {
670 | 	out := &tree{}
671 | 	for _, endpoint := range endpoints {
672 | 		updateTree(out, endpoint, strings.Split(endpoint.directive.pattern, "/"))
673 | 	}
674 | 	return out
675 | }
676 | 
677 | func updateTree(out *tree, endpoint endpoint, path []string) {
678 | 	if len(path) == 0 || (path[0] == out.part && len(path) == 1) {
679 | 		out.endpoints = append(out.endpoints, endpoint)
680 | 		return
681 | 	}
682 | 	if path[0] == out.part {
683 | 		path = path[1:]
684 | 	}
685 | 	part := path[0]
686 | 	for i, child := range out.children {
687 | 		if child.part == part {
688 | 			updateTree(&out.children[i], endpoint, path[1:])
689 | 			return
690 | 		}
691 | 	}
692 | 	out.children = append(out.children, tree{part: part})
693 | 	updateTree(&out.children[len(out.children)-1], endpoint, path[1:])
694 | }
695 | 
696 | func implements(v *types.Var, iface *types.Interface) bool {
697 | 	return types.Implements(v.Type(), iface) || types.Implements(types.NewPointer(v.Type()), iface)
698 | }
699 | 


--------------------------------------------------------------------------------
/codewriter/codewriter.go:
--------------------------------------------------------------------------------
  1 | // Package codewriter is a simple helper for writing out source code.
  2 | package codewriter
  3 | 
  4 | import (
  5 | 	"bytes"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"sort"
  9 | 	"strings"
 10 | )
 11 | 
 12 | type Writer struct {
 13 | 	imports *[]string
 14 | 	trailer []*Writer
 15 | 	w       *bytes.Buffer
 16 | 	pkg     string
 17 | 	indent  string
 18 | }
 19 | 
 20 | func New(pkg string) *Writer {
 21 | 	return &Writer{w: &bytes.Buffer{}, pkg: pkg, imports: &[]string{}}
 22 | }
 23 | 
 24 | // W writes a formatted string directly to the writer without indentation or newline.
 25 | func (c *Writer) W(format string, args ...interface{}) {
 26 | 	fmt.Fprintf(c.w, format, args...)
 27 | }
 28 | 
 29 | // L writes a newline-terminated string to the writer.
 30 | func (c *Writer) L(format string, args ...interface{}) {
 31 | 	c.W(c.indent+format+"\n", args...)
 32 | }
 33 | 
 34 | // In calls "fn" with a Writer that is indented one level.
 35 | func (c *Writer) In(fn func(w *Writer)) {
 36 | 	fn(c.Push())
 37 | }
 38 | 
 39 | // Push returns a Writer indented one level.
 40 | func (c *Writer) Push() *Writer {
 41 | 	out := *c
 42 | 	out.indent += "  "
 43 | 	return &out
 44 | }
 45 | 
 46 | // Pop returns a Writer unindented one level.
 47 | func (c *Writer) Pop() *Writer {
 48 | 	out := *c
 49 | 	out.indent = out.indent[:len(out.indent)-2]
 50 | 	return &out
 51 | }
 52 | 
 53 | // Body returns the body of the code, without the package declaration and imports.
 54 | func (c *Writer) Body() string {
 55 | 	out := &bytes.Buffer{}
 56 | 	c.writeBody(out)
 57 | 	return out.String()
 58 | }
 59 | 
 60 | // Import adds an import to the generated code.
 61 | func (c *Writer) Import(pkg ...string) {
 62 | 	*c.imports = append(*c.imports, pkg...)
 63 | }
 64 | 
 65 | // Trailer returns a Writer that will be appended to the end of the code.
 66 | //
 67 | // Useful for writing out helper functions and other globals.
 68 | func (c *Writer) Trailer() *Writer {
 69 | 	out := &Writer{imports: c.imports, w: &bytes.Buffer{}}
 70 | 	c.trailer = append(c.trailer, out)
 71 | 	return out
 72 | }
 73 | 
 74 | // String returns the self-contained complete generated code.
 75 | func (c *Writer) String() string {
 76 | 	out := &strings.Builder{}
 77 | 	c.write(out)
 78 | 	return out.String()
 79 | }
 80 | 
 81 | // Bytes returns the self-contained complete generated code.
 82 | func (c *Writer) Bytes() []byte {
 83 | 	out := &bytes.Buffer{}
 84 | 	c.write(out)
 85 | 	return out.Bytes()
 86 | }
 87 | 
 88 | //nolint:errcheck
 89 | func (c *Writer) write(w io.Writer) {
 90 | 	fmt.Fprintf(w, "// Code generated by happy. DO NOT EDIT.\n")
 91 | 	fmt.Fprintf(w, "package %s\n", c.pkg)
 92 | 	fmt.Fprintf(w, "\n")
 93 | 	imports := []string{}
 94 | 	seen := map[string]bool{}
 95 | 	for _, pkg := range *c.imports {
 96 | 		if pkg == "" || seen[pkg] {
 97 | 			continue
 98 | 		}
 99 | 		seen[pkg] = true
100 | 		imports = append(imports, pkg)
101 | 	}
102 | 	sort.Strings(imports)
103 | 	if len(imports) > 0 {
104 | 		fmt.Fprintf(w, "import (\n")
105 | 		for _, pkg := range imports {
106 | 			fmt.Fprintf(w, "  %q\n", pkg)
107 | 		}
108 | 		fmt.Fprintf(w, ")\n")
109 | 		fmt.Fprintf(w, "\n")
110 | 	}
111 | 	io.Copy(w, c.w)
112 | 	for _, trailer := range c.trailer {
113 | 		trailer.writeBody(w)
114 | 	}
115 | }
116 | 
117 | //nolint:errcheck
118 | func (c *Writer) writeBody(w io.Writer) {
119 | 	io.Copy(w, c.w)
120 | 	for _, trailer := range c.trailer {
121 | 		fmt.Fprintln(w, trailer.Body())
122 | 	}
123 | }
124 | 


--------------------------------------------------------------------------------
/codewriter/codewriter_test.go:
--------------------------------------------------------------------------------
 1 | package codewriter_test
 2 | 
 3 | import (
 4 | 	"testing"
 5 | 
 6 | 	"github.com/alecthomas/assert/v2"
 7 | 	"github.com/thnxdev/happy/codewriter"
 8 | )
 9 | 
10 | func TestCodeWriter(t *testing.T) {
11 | 	w := codewriter.New("pkg")
12 | 	w.L("func hello() {")
13 | 	w.In(func(w *codewriter.Writer) {
14 | 		w.L(`println("hello")`)
15 | 	})
16 | 	w.L("}")
17 | 	expected := `func hello() {
18 |   println("hello")
19 | }
20 | `
21 | 	assert.Equal(t, expected, w.Body())
22 | }
23 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/thnxdev/happy
 2 | 
 3 | go 1.19
 4 | 
 5 | require (
 6 | 	github.com/alecthomas/kong v0.7.1
 7 | 	github.com/fatih/structtag v1.2.0
 8 | 	golang.org/x/tools v0.3.0
 9 | )
10 | 
11 | require (
12 | 	github.com/alecthomas/repr v0.1.0 // indirect
13 | 	github.com/hexops/gotextdiff v1.0.3 // indirect
14 | )
15 | 
16 | require (
17 | 	github.com/alecthomas/assert/v2 v2.2.0
18 | 	golang.org/x/mod v0.7.0 // indirect
19 | 	golang.org/x/sys v0.2.0 // indirect
20 | )
21 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
 1 | github.com/alecthomas/assert/v2 v2.2.0 h1:f6L/b7KE2bfA+9O4FL3CM/xJccDEwPVYd5fALBiuwvw=
 2 | github.com/alecthomas/assert/v2 v2.2.0/go.mod h1:b/+1DI2Q6NckYi+3mXyH3wFb8qG37K/DuK80n7WefXA=
 3 | github.com/alecthomas/kong v0.7.1 h1:azoTh0IOfwlAX3qN9sHWTxACE2oV8Bg2gAwBsMwDQY4=
 4 | github.com/alecthomas/kong v0.7.1/go.mod h1:n1iCIO2xS46oE8ZfYCNDqdR0b0wZNrXAIAqro/2132U=
 5 | github.com/alecthomas/repr v0.1.0 h1:ENn2e1+J3k09gyj2shc0dHr/yjaWSHRlrJ4DPMevDqE=
 6 | github.com/alecthomas/repr v0.1.0/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8=
 7 | github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=
 8 | github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
 9 | github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
10 | github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
11 | golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
12 | golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
13 | golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
14 | golang.org/x/sys v0.2.0 h1:ljd4t30dBnAvMZaQCevtY0xLLD0A+bRZXbgLMLU1F/A=
15 | golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
16 | golang.org/x/tools v0.3.0 h1:SrNbZl6ECOS1qFzgTdQfWXZM9XBkiA6tkFrH9YSTPHM=
17 | golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k=
18 | 


--------------------------------------------------------------------------------
/reflex.conf:
--------------------------------------------------------------------------------
1 | -r 'main.go$' \
2 |   happy ./testdata
3 |   
4 | -r '\.go$' -s \
5 |   go run ./testdata
6 | 


--------------------------------------------------------------------------------
/scripts/e2e-test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -euxo pipefail
 3 | 
 4 | happy ./testdata
 5 | go test ./testdata
 6 | go run ./testdata &
 7 | trap 'kill "%%" || true' EXIT INT
 8 | 
 9 | sleep 1
10 | 
11 | # Fail because it's not authenticated
12 | curl --fail-with-body --data-binary '{"id": 3, "name": "Sally"}' http://localhost:8080/users && (echo "did not expect to succeed!"; exit 1)
13 | # Succeed
14 | curl -fsS http://localhost:8080/users | jq | tee /dev/stderr | jq -r '.[].name' | grep Alice
15 | curl --fail-with-body -u alice:secret --data-binary '{"id": 3, "name": "Sally"}' http://localhost:8080/users
16 | curl -fsS http://localhost:8080/users | jq | tee /dev/stderr | jq -r '.[].name' | grep Sally
17 | curl --fail-with-body -u alice:secret http://localhost:8080/users/3 | jq | tee /dev/stderr | jq -r '.name' | grep Sally
18 | curl -X POST http://localhost:8080/shutdown
19 | 
20 | echo "Success!"


--------------------------------------------------------------------------------
/scripts/happy:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | set -euo pipefail
3 | name="$(basename "$0")"
4 | dir="$(dirname "$0")/.."
5 | dest="${TMPDIR:-/tmp}/$name"
6 | (cd "${dir}/cmd/happy" ; go build -trimpath -buildvcs=false -ldflags="-s -w -buildid=" -o "${dest}" .) && exec "${dest}" "$@"
7 | 


--------------------------------------------------------------------------------
/testdata/main.go:
--------------------------------------------------------------------------------
  1 | //go:generate happy
  2 | package main
  3 | 
  4 | import (
  5 | 	"context"
  6 | 	"encoding/json"
  7 | 	"fmt"
  8 | 	"log"
  9 | 	"net/http"
 10 | 	"os"
 11 | 	"strconv"
 12 | 	"time"
 13 | )
 14 | 
 15 | // An Error that implements http.Handler to write structured JSON errors.
 16 | type Error struct {
 17 | 	code    int
 18 | 	message string
 19 | }
 20 | 
 21 | func Errorf(code int, format string, args ...interface{}) error {
 22 | 	return Error{code, fmt.Sprintf(format, args...)}
 23 | }
 24 | 
 25 | func (e Error) Error() string { return e.message }
 26 | 
 27 | func (e Error) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 28 | 	w.Header().Set("Content-Type", "application/json")
 29 | 	w.WriteHeader(e.code)
 30 | 	json.NewEncoder(w).Encode(map[string]string{"error": e.message})
 31 | }
 32 | 
 33 | type ID int
 34 | 
 35 | func (i *ID) UnmarshalJSON(data []byte) error {
 36 | 	id, err := strconv.Atoi(string(data))
 37 | 	if err != nil {
 38 | 		return err
 39 | 	}
 40 | 	*i = ID(id)
 41 | 	return nil
 42 | }
 43 | 
 44 | func (i *ID) UnmarshalText(text []byte) error {
 45 | 	id, err := strconv.Atoi(string(text))
 46 | 	if err != nil {
 47 | 		return err
 48 | 	}
 49 | 	*i = ID(id)
 50 | 	return nil
 51 | }
 52 | 
 53 | type User struct {
 54 | 	ID   ID     `json:"id"`
 55 | 	Name string `json:"name"`
 56 | }
 57 | 
 58 | type Service struct {
 59 | 	users []User
 60 | }
 61 | 
 62 | // GetUser by ID.
 63 | //
 64 | //happy:api GET /users/:id
 65 | func (s *Service) GetUser(id ID) (User, error) {
 66 | 	for _, user := range s.users {
 67 | 		if user.ID == id {
 68 | 			return user, nil
 69 | 		}
 70 | 	}
 71 | 	return User{}, Errorf(http.StatusNotFound, "user %d not found", id)
 72 | }
 73 | 
 74 | //happy:api GET /users/:id/avatar
 75 | func (s *Service) GetAvatar(id ID) ([]byte, error) {
 76 | 	return nil, Errorf(http.StatusNotFound, "avatar %d not found", id)
 77 | }
 78 | 
 79 | //happy:api POST /users authenticated
 80 | func (s *Service) CreateUser(r *http.Request, user User) error {
 81 | 	username := r.Context().Value(AuthenticatedUser)
 82 | 	log.Printf("Authenticated user %s", username)
 83 | 	for _, u := range s.users {
 84 | 		if u.ID == user.ID {
 85 | 			return Errorf(http.StatusConflict, "user %d already exists", user.ID)
 86 | 		}
 87 | 	}
 88 | 	s.users = append(s.users, user)
 89 | 	return nil
 90 | }
 91 | 
 92 | type Paginate struct {
 93 | 	Page   int `query:"p"`
 94 | 	Size   int `query:"s"`
 95 | 	Sparse *bool
 96 | }
 97 | 
 98 | //happy:api GET /users
 99 | func (s *Service) ListUsers(paginate Paginate) ([]User, error) {
100 | 	return s.users, nil
101 | }
102 | 
103 | //happy:api POST /shutdown
104 | func (s *Service) Shutdown(w http.ResponseWriter) {
105 | 	fmt.Fprintln(w, "Shutting down...")
106 | 	go func() { time.Sleep(time.Second); os.Exit(0) }()
107 | }
108 | 
109 | type HAPIOptions interface {
110 | 	HandlerOptions(*http.Request) map[string]string
111 | }
112 | 
113 | type HAPIHandler interface {
114 | 	http.Handler
115 | 	HAPIOptions
116 | }
117 | 
118 | type forwardHAPIHandler struct {
119 | 	HAPIOptions
120 | 	http.HandlerFunc
121 | }
122 | 
123 | var Options struct{}
124 | 
125 | type HAPIService interface {
126 | 	HandlerOptions(*http.Request) map[string]string
127 | }
128 | 
129 | // OptionsMiddleware adds the HAPIOptions to the request context under the key Options.
130 | func OptionsMiddleware(svc HAPIService, next http.Handler) http.Handler {
131 | 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
132 | 		ctx := context.WithValue(r.Context(), Options, svc.HandlerOptions(r))
133 | 		r = r.WithContext(ctx)
134 | 		next.ServeHTTP(w, r)
135 | 	})
136 | }
137 | 
138 | var AuthenticatedUser struct{}
139 | 
140 | func AuthMiddleware(next http.Handler) http.Handler {
141 | 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
142 | 		options := r.Context().Value(Options).(map[string]string)
143 | 		_, authenticated := options["authenticated"]
144 | 		if !authenticated {
145 | 			next.ServeHTTP(w, r)
146 | 			return
147 | 		}
148 | 		username, password, ok := r.BasicAuth()
149 | 		if !ok || username != "alice" || password != "secret" {
150 | 			http.Error(w, "Unauthorized", http.StatusUnauthorized)
151 | 			return
152 | 		}
153 | 		ctx := context.WithValue(r.Context(), AuthenticatedUser, username)
154 | 		r = r.WithContext(ctx)
155 | 		next.ServeHTTP(w, r)
156 | 	})
157 | }
158 | 
159 | func main() {
160 | 	service := &Service{
161 | 		users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}},
162 | 	}
163 | 	const address = "127.0.0.1:8080"
164 | 	log.Printf("Starting server on http://%s\n", address)
165 | 	http.ListenAndServe(address, OptionsMiddleware(service, AuthMiddleware(service)))
166 | }
167 | 


--------------------------------------------------------------------------------
/testdata/main_api.go:
--------------------------------------------------------------------------------
  1 | // Code generated by happy. DO NOT EDIT.
  2 | package main
  3 | 
  4 | import (
  5 | 	"encoding/json"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"net/http"
  9 | 	"net/url"
 10 | 	"strconv"
 11 | 	"strings"
 12 | )
 13 | 
 14 | func (h *Service) HandlerOptions(r *http.Request) map[string]string {
 15 | 	parts := []string{}
 16 | 	for i, p := range strings.Split(r.URL.Path, "/") {
 17 | 		if i == 0 || p != "" {
 18 | 			parts = append(parts, p)
 19 | 		}
 20 | 	}
 21 | 	var params map[string]string = map[string]string{}
 22 | 	_ = params
 23 | 	switch parts[0] {
 24 | 	case "":
 25 | 		if len(parts) == 1 {
 26 | 			return nil
 27 | 		}
 28 | 		switch parts[1] {
 29 | 		case "users":
 30 | 			if len(parts) == 2 {
 31 | 				switch r.Method { // Leaf
 32 | 				case "POST":
 33 | 					out := map[string]string{"authenticated": ""}
 34 | 					// Merge url params into options
 35 | 					for k, v := range params {
 36 | 						out[k] = v
 37 | 					}
 38 | 					return out
 39 | 				}
 40 | 				return nil
 41 | 			}
 42 | 			return nil
 43 | 		}
 44 | 	}
 45 | 	return nil
 46 | }
 47 | 
 48 | func (h *Service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 49 | 	var err error
 50 | 	var res any
 51 | 	parts := []string{}
 52 | 	for i, p := range strings.Split(r.URL.Path, "/") {
 53 | 		if i == 0 || p != "" {
 54 | 			parts = append(parts, p)
 55 | 		}
 56 | 	}
 57 | 	var params map[string]string = map[string]string{}
 58 | 	_ = params
 59 | 	switch parts[0] {
 60 | 	case "":
 61 | 		if len(parts) == 1 {
 62 | 			return
 63 | 		}
 64 | 		switch parts[1] {
 65 | 		case "users":
 66 | 			if len(parts) == 2 {
 67 | 				switch r.Method { // Leaf
 68 | 				case "POST":
 69 | 					var param1 User
 70 | 					if err := json.NewDecoder(r.Body).Decode(&param1); err != nil {
 71 | 						http.Error(w, fmt.Sprintf("Failed to decode request body: %s", err), http.StatusBadRequest)
 72 | 						return
 73 | 					}
 74 | 					err = h.CreateUser(r, param1)
 75 | 					goto matched
 76 | 				case "GET":
 77 | 					var param0 Paginate
 78 | 					if err := decodePaginate(r.URL.Query(), &param0); err != nil {
 79 | 						http.Error(w, err.Error(), http.StatusBadRequest)
 80 | 						return
 81 | 					}
 82 | 					res, err = h.ListUsers(param0)
 83 | 					goto matched
 84 | 				}
 85 | 				return
 86 | 			}
 87 | 			switch parts[2] {
 88 | 			default: // Parameter :id
 89 | 				params[":id"] = parts[2]
 90 | 				if len(parts) == 3 {
 91 | 					switch r.Method { // Leaf
 92 | 					case "GET":
 93 | 						var param0 ID
 94 | 						if err := param0.UnmarshalText([]byte(params[":id"])); err != nil {
 95 | 							http.Error(w, "id: "+err.Error(), http.StatusBadRequest)
 96 | 							return
 97 | 						}
 98 | 						res, err = h.GetUser(param0)
 99 | 						goto matched
100 | 					}
101 | 					return
102 | 				}
103 | 				switch parts[3] {
104 | 				case "avatar":
105 | 					if len(parts) == 4 {
106 | 						switch r.Method { // Leaf
107 | 						case "GET":
108 | 							var param0 ID
109 | 							if err := param0.UnmarshalText([]byte(params[":id"])); err != nil {
110 | 								http.Error(w, "id: "+err.Error(), http.StatusBadRequest)
111 | 								return
112 | 							}
113 | 							res, err = h.GetAvatar(param0)
114 | 							goto matched
115 | 						}
116 | 						return
117 | 					}
118 | 					return
119 | 				}
120 | 			}
121 | 		case "shutdown":
122 | 			if len(parts) == 2 {
123 | 				switch r.Method { // Leaf
124 | 				case "POST":
125 | 					h.Shutdown(w)
126 | 					return
127 | 					goto matched
128 | 				}
129 | 				return
130 | 			}
131 | 			return
132 | 		}
133 | 	}
134 | 	// No match but we don't return a 404 here, to allow the default handler to take control.
135 | 	return
136 | matched:
137 | 
138 | 	// Handle errors
139 | 	if err != nil {
140 | 		if herr, ok := err.(http.Handler); ok {
141 | 			herr.ServeHTTP(w, r)
142 | 		} else {
143 | 			http.Error(w, err.Error(), http.StatusInternalServerError)
144 | 		}
145 | 		return
146 | 	}
147 | 
148 | 	// Handle response
149 | 	switch res := res.(type) {
150 | 	case nil:
151 | 		w.WriteHeader(http.StatusNoContent)
152 | 	case string:
153 | 		w.Header().Set("Content-Type", "text/html")
154 | 		io.WriteString(w, res)
155 | 	case []byte:
156 | 		w.Header().Set("Content-Type", "application/octet-stream")
157 | 		w.Write(res)
158 | 	case *http.Response:
159 | 		headers := w.Header()
160 | 		for k, v := range res.Header {
161 | 			headers[k] = v
162 | 		}
163 | 		w.WriteHeader(res.StatusCode)
164 | 		_, _ = io.Copy(w, res.Body)
165 | 	case io.ReadCloser:
166 | 		w.Header().Set("Content-Type", "application/octet-stream")
167 | 		_, _ = io.Copy(w, res)
168 | 		res.Close()
169 | 	case io.Reader:
170 | 		w.Header().Set("Content-Type", "application/octet-stream")
171 | 		_, _ = io.Copy(w, res)
172 | 	default:
173 | 		data, err := json.Marshal(res)
174 | 		if err != nil {
175 | 			http.Error(w, `failed to encode response: `+err.Error(), http.StatusInternalServerError)
176 | 			return
177 | 		}
178 | 		w.Header().Set("Content-Type", "application/json; charset=utf-8")
179 | 		w.Header().Set("Content-Length", strconv.Itoa(len(data)))
180 | 		w.WriteHeader(http.StatusOK)
181 | 		w.Write(data)
182 | 	}
183 | }
184 | func decodePaginate(p url.Values, out *Paginate) (err error) {
185 | 	if q, ok := p["p"]; ok {
186 | 		if out.Page, err = strconv.Atoi(q[len(q)-1]); err != nil {
187 | 			return fmt.Errorf("failed to decode query parameter \"p\" as int: %w", err)
188 | 		}
189 | 	}
190 | 	if q, ok := p["s"]; ok {
191 | 		if out.Size, err = strconv.Atoi(q[len(q)-1]); err != nil {
192 | 			return fmt.Errorf("failed to decode query parameter \"s\" as int: %w", err)
193 | 		}
194 | 	}
195 | 	if q, ok := p["sparse"]; ok {
196 | 		out.Sparse = new(bool)
197 | 		if *out.Sparse, err = strconv.ParseBool(q[len(q)-1]); err != nil {
198 | 			return fmt.Errorf("failed to decode query parameter \"sparse\" as bool: %w", err)
199 | 		}
200 | 	}
201 | 	return nil
202 | }
203 | 


--------------------------------------------------------------------------------
/testdata/main_test.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"net/http/httptest"
 6 | 	"testing"
 7 | 
 8 | 	"github.com/alecthomas/assert/v2"
 9 | )
10 | 
11 | func BenchmarkOptions(b *testing.B) {
12 | 	b.ReportAllocs()
13 | 	req, err := http.NewRequest("GET", "/users", nil)
14 | 	assert.NoError(b, err)
15 | 	svc := &Service{users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}}}
16 | 	for i := 0; i < b.N; i++ {
17 | 		svc.HandlerOptions(req)
18 | 	}
19 | }
20 | 
21 | func BenchmarkRouting(b *testing.B) {
22 | 	b.ReportAllocs()
23 | 	req, err := http.NewRequest("GET", "/users", nil)
24 | 	assert.NoError(b, err)
25 | 	svc := &Service{users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}}}
26 | 	for i := 0; i < b.N; i++ {
27 | 		w := httptest.NewRecorder()
28 | 		svc.ServeHTTP(w, req)
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------