create-svc 0.1.2 → 0.1.4

package/templates/variants/go-connectrpc/internal/httpapi/routes.go

@@ -0,0 +1,93 @@
+package httpapi
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+
+	"{{MODULE_PATH}}/internal/app"
+)
+
+func RegisterRoutes(router chi.Router, service *app.DNSService) {
+	router.Get("/healthz", func(w http.ResponseWriter, _ *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+	})
+
+	router.Route("/v1/dns/records", func(r chi.Router) {
+		r.Get("/", func(w http.ResponseWriter, request *http.Request) {
+			records, err := service.ListRecords(request.Context())
+			if err != nil {
+				writeError(w, err)
+				return
+			}
+			writeJSON(w, http.StatusOK, map[string]any{"records": records})
+		})
+
+		r.Post("/", func(w http.ResponseWriter, request *http.Request) {
+			var input app.CreateRecordInput
+			if err := decodeJSON(request, &input); err != nil {
+				writeError(w, err)
+				return
+			}
+
+			record, err := service.CreateRecord(request.Context(), input)
+			if err != nil {
+				writeError(w, err)
+				return
+			}
+			writeJSON(w, http.StatusCreated, map[string]any{"record": record})
+		})
+
+		r.Route("/{recordID}", func(r chi.Router) {
+			r.Put("/", func(w http.ResponseWriter, request *http.Request) {
+				var input app.UpdateRecordInput
+				if err := decodeJSON(request, &input); err != nil {
+					writeError(w, err)
+					return
+				}
+
+				record, err := service.UpdateRecord(request.Context(), chi.URLParam(request, "recordID"), input)
+				if err != nil {
+					writeError(w, err)
+					return
+				}
+				writeJSON(w, http.StatusOK, map[string]any{"record": record})
+			})
+
+			r.Delete("/", func(w http.ResponseWriter, request *http.Request) {
+				if err := service.DeleteRecord(request.Context(), chi.URLParam(request, "recordID")); err != nil {
+					writeError(w, err)
+					return
+				}
+				w.WriteHeader(http.StatusNoContent)
+			})
+		})
+	})
+}
+
+func decodeJSON(request *http.Request, out any) error {
+	defer request.Body.Close()
+
+	if err := json.NewDecoder(request.Body).Decode(out); err != nil {
+		return err
+	}
+	return nil
+}
+
+func writeJSON(w http.ResponseWriter, status int, payload any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(payload)
+}
+
+func writeError(w http.ResponseWriter, err error) {
+	status := http.StatusInternalServerError
+	if errors.Is(err, strconv.ErrSyntax) || strings.Contains(strings.ToLower(err.Error()), "json") {
+		status = http.StatusBadRequest
+	}
+	writeJSON(w, status, map[string]string{"error": err.Error()})
+}

package/templates/variants/go-connectrpc/internal/vault/client.go

@@ -0,0 +1,148 @@
+package vault
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+)
+
+type AppRoleClient struct {
+	addr         string
+	roleIDFile   string
+	secretIDFile string
+	client       *http.Client
+
+	mu    sync.Mutex
+	token string
+}
+
+func NewAppRoleClient(addr string, roleIDFile string, secretIDFile string, client *http.Client) *AppRoleClient {
+	return &AppRoleClient{
+		addr:         strings.TrimRight(addr, "/"),
+		roleIDFile:   roleIDFile,
+		secretIDFile: secretIDFile,
+		client:       client,
+	}
+}
+
+func (c *AppRoleClient) Get(ctx context.Context, path string, key string) (string, error) {
+	token, err := c.login(ctx)
+	if err != nil {
+		return "", err
+	}
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s/v1/secret/data/%s", c.addr, strings.TrimLeft(path, "/")), nil)
+	if err != nil {
+		return "", err
+	}
+	request.Header.Set("X-Vault-Token", token)
+
+	response, err := c.client.Do(request)
+	if err != nil {
+		return "", err
+	}
+	defer response.Body.Close()
+
+	raw, err := io.ReadAll(response.Body)
+	if err != nil {
+		return "", err
+	}
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return "", fmt.Errorf("vault read failed: status=%d body=%s", response.StatusCode, strings.TrimSpace(string(raw)))
+	}
+
+	var payload struct {
+		Data struct {
+			Data map[string]string `json:"data"`
+		} `json:"data"`
+	}
+	if err := json.Unmarshal(raw, &payload); err != nil {
+		return "", err
+	}
+
+	value := strings.TrimSpace(payload.Data.Data[key])
+	if value == "" {
+		return "", fmt.Errorf("vault secret key %q is empty", key)
+	}
+	return value, nil
+}
+
+func (c *AppRoleClient) login(ctx context.Context) (string, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.token != "" {
+		return c.token, nil
+	}
+
+	roleID, err := readSecretFile(c.roleIDFile)
+	if err != nil {
+		return "", err
+	}
+	secretID, err := readSecretFile(c.secretIDFile)
+	if err != nil {
+		return "", err
+	}
+
+	body, err := json.Marshal(map[string]string{
+		"role_id":   roleID,
+		"secret_id": secretID,
+	})
+	if err != nil {
+		return "", err
+	}
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodPost, c.addr+"/v1/auth/approle/login", bytes.NewReader(body))
+	if err != nil {
+		return "", err
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err := c.client.Do(request)
+	if err != nil {
+		return "", err
+	}
+	defer response.Body.Close()
+
+	raw, err := io.ReadAll(response.Body)
+	if err != nil {
+		return "", err
+	}
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return "", fmt.Errorf("vault login failed: status=%d body=%s", response.StatusCode, strings.TrimSpace(string(raw)))
+	}
+
+	var payload struct {
+		Auth struct {
+			ClientToken string `json:"client_token"`
+		} `json:"auth"`
+	}
+	if err := json.Unmarshal(raw, &payload); err != nil {
+		return "", err
+	}
+
+	c.token = strings.TrimSpace(payload.Auth.ClientToken)
+	if c.token == "" {
+		return "", fmt.Errorf("vault returned an empty client token")
+	}
+	return c.token, nil
+}
+
+func readSecretFile(path string) (string, error) {
+	bytes, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+
+	value := strings.TrimSpace(string(bytes))
+	if value == "" {
+		return "", fmt.Errorf("secret file %q is empty", path)
+	}
+	return value, nil
+}

package/templates/variants/go-connectrpc/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "{{SERVICE_NAME}}",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@neondatabase/api-client": "^2.7.1"
+  },
+  "scripts": {
+    "dev": "go run ./cmd/server",
+    "gen": "buf generate",
+    "lint": "go vet ./... && buf lint",
+    "test": "bun test ./test",
+    "bootstrap": "bun run ./scripts/cloudrun/bootstrap.ts",
+    "deploy": "bun run ./scripts/cloudrun/deploy.ts"
+  }
+}

package/templates/variants/go-connectrpc/protos/dns/v1/dns.proto

@@ -0,0 +1,58 @@
+syntax = "proto3";
+
+package dns.v1;
+
+option go_package = "{{MODULE_PATH}}/gen/dns/v1;dnsv1";
+
+service DNSService {
+  rpc ListRecords(ListRecordsRequest) returns (ListRecordsResponse) {}
+  rpc CreateRecord(CreateRecordRequest) returns (CreateRecordResponse) {}
+  rpc UpdateRecord(UpdateRecordRequest) returns (UpdateRecordResponse) {}
+  rpc DeleteRecord(DeleteRecordRequest) returns (DeleteRecordResponse) {}
+}
+
+message Record {
+  string id = 1;
+  string type = 2;
+  string name = 3;
+  string content = 4;
+  int32 ttl = 5;
+  bool proxied = 6;
+}
+
+message ListRecordsRequest {}
+
+message ListRecordsResponse {
+  repeated Record records = 1;
+}
+
+message CreateRecordRequest {
+  string type = 1;
+  string name = 2;
+  string content = 3;
+  int32 ttl = 4;
+  bool proxied = 5;
+}
+
+message CreateRecordResponse {
+  Record record = 1;
+}
+
+message UpdateRecordRequest {
+  string id = 1;
+  string type = 2;
+  string name = 3;
+  string content = 4;
+  int32 ttl = 5;
+  bool proxied = 6;
+}
+
+message UpdateRecordResponse {
+  Record record = 1;
+}
+
+message DeleteRecordRequest {
+  string id = 1;
+}
+
+message DeleteRecordResponse {}

package/templates/variants/go-connectrpc/test/go.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+
+const decoder = new TextDecoder();
+
+test(
+  "go test ./...",
+  { timeout: 60_000 },
+  () => {
+  const result = Bun.spawnSync(["go", "test", "./..."], {
+    cwd: process.cwd(),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  });
+
+  const output = [decoder.decode(result.stdout), decoder.decode(result.stderr)].join("").trim();
+  expect(result.exitCode, output || "go test ./... failed").toBe(0);
+  }
+);