Add base CLI and API

Author: code-asher

Diff for: .gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+bin
+coverage
+extensions

Diff for: Makefile

@@ -0,0 +1,31 @@
+#TODO: build
+
+lint: lint/go
+.PHONY: lint
+
+lint/go:
+	golangci-lint run
+.PHONY: lint/go
+
+test-clean:
+	go clean -testcache
+.PHONY: test-clean
+
+test: test-clean
+	gotestsum -- -v -short -coverprofile coverage ./...
+.PHONY: test
+
+coverage:
+	go tool cover -func=coverage
+.PHONY: coverage
+
+TAG=$(shell git describe --always)
+
+build:
+	GOOS=darwin GOARCH=amd64 go build -ldflags "-X github.com/coder/code-marketplace/buildinfo.tag=$(TAG)" -o bin/code-marketplace-mac-amd64 ./cmd/marketplace/main.go
+	GOOS=darwin GOARCH=arm64 go build -ldflags "-X github.com/coder/code-marketplace/buildinfo.tag=$(TAG)" -o bin/code-marketplace-mac-arm64 ./cmd/marketplace/main.go
+	GOOS=linux GOARCH=amd64 go build -ldflags "-X github.com/coder/code-marketplace/buildinfo.tag=$(TAG)" -o bin/code-marketplace-linux-amd64 ./cmd/marketplace/main.go
+	GOOS=linux GOARCH=arm64 go build -ldflags "-X github.com/coder/code-marketplace/buildinfo.tag=$(TAG)" -o bin/code-marketplace-linux-arm64 ./cmd/marketplace/main.go
+	GOOS=windows GOARCH=amd64 go build -ldflags "-X github.com/coder/code-marketplace/buildinfo.tag=$(TAG)" -o bin/code-marketplace-windows-amd64 ./cmd/marketplace/main.go
+	GOOS=windows GOARCH=arm64 go build -ldflags "-X github.com/coder/code-marketplace/buildinfo.tag=$(TAG)" -o bin/code-marketplace-windows-arm64 ./cmd/marketplace/main.go
+.PHONY: build

Diff for: api/api.go

@@ -0,0 +1,58 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/cors"
+
+	"cdr.dev/slog"
+	"github.com/coder/code-marketplace/api/httpmw"
+)
+
+type Options struct {
+	ExtDir string
+	Logger slog.Logger
+	// Set to <0 to disable.
+	RateLimit int
+}
+
+type API struct {
+	Handler http.Handler
+}
+
+// New creates a new API server.
+func New(options *Options) *API {
+	if options.RateLimit == 0 {
+		options.RateLimit = 512
+	}
+
+	r := chi.NewRouter()
+
+	cors := cors.New(cors.Options{
+		AllowedOrigins:   []string{"*"},
+		AllowedMethods:   []string{"POST", "GET", "OPTIONS"},
+		AllowedHeaders:   []string{"*"},
+		AllowCredentials: true,
+		MaxAge:           300,
+	})
+
+	r.Use(
+		cors.Handler,
+		httpmw.RateLimitPerMinute(options.RateLimit),
+		middleware.GetHead,
+		httpmw.AttachRequestID,
+		httpmw.Recover(options.Logger),
+		httpmw.AttachBuildInfo,
+		httpmw.Logger(options.Logger),
+	)
+
+	r.Get("/", func(rw http.ResponseWriter, r *http.Request) {
+		httpapi.WriteBytes(rw, http.StatusOK, []byte("Marketplace is running"))
+	})
+
+	return &API{
+		Handler: r,
+	}
+}

Diff for: api/api_test.go

@@ -0,0 +1,34 @@
+package api_test
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"cdr.dev/slog"
+	"cdr.dev/slog/sloggers/slogtest"
+	"github.com/coder/code-marketplace/api"
+)
+
+func TestServer(t *testing.T) {
+	t.Parallel()
+
+	api := api.New(&api.Options{
+		Logger: slogtest.Make(t, nil).Leveled(slog.LevelDebug),
+		ExtDir: filepath.Join(t.TempDir(), "extensions"),
+	})
+
+	server := httptest.NewServer(api.Handler)
+	defer server.Close()
+
+	resp, err := http.Get(server.URL + "/non-existent")
+	require.NoError(t, err)
+	require.Equal(t, http.StatusNotFound, resp.StatusCode)
+
+	resp, err = http.Get(server.URL)
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+}

Diff for: api/httpapi/httpapi.go

@@ -0,0 +1,39 @@
+package httpapi
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+
+	"github.com/google/uuid"
+)
+
+type ErrorResponse struct {
+	Message   string    `json:"message"`
+	Detail    string    `json:"detail"`
+	RequestID uuid.UUID `json:"requestId,omitempty"`
+}
+
+// WriteBytes tries to write the provided bytes and errors if unable.
+func WriteBytes(rw http.ResponseWriter, status int, bytes []byte) {
+	rw.WriteHeader(status)
+	_, err := rw.Write(bytes)
+	if err != nil {
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+// Write outputs a standardized format to an HTTP response body.
+func Write(rw http.ResponseWriter, status int, response interface{}) {
+	buf := &bytes.Buffer{}
+	enc := json.NewEncoder(buf)
+	enc.SetEscapeHTML(true)
+	err := enc.Encode(response)
+	if err != nil {
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	rw.Header().Set("Content-Type", "application/json; charset=utf-8")
+	WriteBytes(rw, status, buf.Bytes())
+}

Diff for: api/httpapi/httpapi_test.go

@@ -0,0 +1,62 @@
+package httpapi_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/code-marketplace/api/httpapi"
+)
+
+type TestResponse struct {
+	Message string
+}
+
+func TestWrite(t *testing.T) {
+	t.Parallel()
+
+	t.Run("OK", func(t *testing.T) {
+		t.Parallel()
+
+		message := TestResponse{Message: "foo"}
+		rw := httptest.NewRecorder()
+		httpapi.Write(rw, http.StatusOK, message)
+		require.Equal(t, http.StatusOK, rw.Code)
+
+		var m TestResponse
+		err := json.NewDecoder(rw.Body).Decode(&m)
+		require.NoError(t, err)
+		require.Equal(t, message, m)
+	})
+
+	t.Run("Error", func(t *testing.T) {
+		t.Parallel()
+
+		message := httpapi.ErrorResponse{Message: "foo", Detail: "bar", RequestID: uuid.New()}
+		rw := httptest.NewRecorder()
+		httpapi.Write(rw, http.StatusMethodNotAllowed, message)
+		require.Equal(t, http.StatusMethodNotAllowed, rw.Code)
+
+		var m httpapi.ErrorResponse
+		err := json.NewDecoder(rw.Body).Decode(&m)
+		require.NoError(t, err)
+		require.Equal(t, message, m)
+	})
+
+	t.Run("Malformed", func(t *testing.T) {
+		t.Parallel()
+
+		rw := httptest.NewRecorder()
+		httpapi.Write(rw, http.StatusMethodNotAllowed, "no")
+		// This will still be the original code since it was already set.
+		require.Equal(t, http.StatusMethodNotAllowed, rw.Code)
+
+		var m httpapi.ErrorResponse
+		err := json.NewDecoder(rw.Body).Decode(&m)
+		require.Error(t, err)
+	})
+}

Diff for: api/httpapi/status_writer.go

@@ -0,0 +1,72 @@
+package httpapi
+
+import (
+	"bufio"
+	"net"
+	"net/http"
+
+	"golang.org/x/xerrors"
+)
+
+var _ http.ResponseWriter = (*StatusWriter)(nil)
+var _ http.Hijacker = (*StatusWriter)(nil)
+
+// StatusWriter intercepts the status of the request and the response body up to
+// maxBodySize if Status >= 400. It is guaranteed to be the ResponseWriter
+// directly downstream from Middleware.
+type StatusWriter struct {
+	http.ResponseWriter
+	Status       int
+	Hijacked     bool
+	responseBody []byte
+
+	wroteHeader bool
+}
+
+func (w *StatusWriter) WriteHeader(status int) {
+	if !w.wroteHeader {
+		w.Status = status
+		w.wroteHeader = true
+	}
+	w.ResponseWriter.WriteHeader(status)
+}
+
+func (w *StatusWriter) Write(b []byte) (int, error) {
+	const maxBodySize = 4096
+
+	if !w.wroteHeader {
+		w.Status = http.StatusOK
+		w.wroteHeader = true
+	}
+
+	if w.Status >= http.StatusBadRequest {
+		// This is technically wrong as multiple calls to write will simply
+		// overwrite w.ResponseBody but we typically only write to the response body
+		// once and this field is only used for logging.
+		w.responseBody = make([]byte, minInt(len(b), maxBodySize))
+		copy(w.responseBody, b)
+	}
+
+	return w.ResponseWriter.Write(b)
+}
+
+func minInt(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func (w *StatusWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hijacker, ok := w.ResponseWriter.(http.Hijacker)
+	if !ok {
+		return nil, nil, xerrors.Errorf("%T is not a http.Hijacker", w.ResponseWriter)
+	}
+	w.Hijacked = true
+
+	return hijacker.Hijack()
+}
+
+func (w *StatusWriter) ResponseBody() []byte {
+	return w.responseBody
+}