create-svc 0.1.10 → 0.1.11

package/templates/root/gen/dns/v1/dnsv1connect/dns.connect.go

@@ -1,192 +0,0 @@
-// Code generated by protoc-gen-connect-go. DO NOT EDIT.
-//
-// Source: dns/v1/dns.proto
-
-package dnsv1connect
-
-import (
-	connect "connectrpc.com/connect"
-	context "context"
-	errors "errors"
-	v1 "{{MODULE_PATH}}/gen/dns/v1"
-	http "net/http"
-	strings "strings"
-)
-
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
-const (
-	// DNSServiceName is the fully-qualified name of the DNSService service.
-	DNSServiceName = "dns.v1.DNSService"
-)
-
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
-//
-// Note that these are different from the fully-qualified method names used by
-// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
-// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
-// period.
-const (
-	// DNSServiceListRecordsProcedure is the fully-qualified name of the DNSService's ListRecords RPC.
-	DNSServiceListRecordsProcedure = "/dns.v1.DNSService/ListRecords"
-	// DNSServiceCreateRecordProcedure is the fully-qualified name of the DNSService's CreateRecord RPC.
-	DNSServiceCreateRecordProcedure = "/dns.v1.DNSService/CreateRecord"
-	// DNSServiceUpdateRecordProcedure is the fully-qualified name of the DNSService's UpdateRecord RPC.
-	DNSServiceUpdateRecordProcedure = "/dns.v1.DNSService/UpdateRecord"
-	// DNSServiceDeleteRecordProcedure is the fully-qualified name of the DNSService's DeleteRecord RPC.
-	DNSServiceDeleteRecordProcedure = "/dns.v1.DNSService/DeleteRecord"
-)
-
-// DNSServiceClient is a client for the dns.v1.DNSService service.
-type DNSServiceClient interface {
-	ListRecords(context.Context, *connect.Request[v1.ListRecordsRequest]) (*connect.Response[v1.ListRecordsResponse], error)
-	CreateRecord(context.Context, *connect.Request[v1.CreateRecordRequest]) (*connect.Response[v1.CreateRecordResponse], error)
-	UpdateRecord(context.Context, *connect.Request[v1.UpdateRecordRequest]) (*connect.Response[v1.UpdateRecordResponse], error)
-	DeleteRecord(context.Context, *connect.Request[v1.DeleteRecordRequest]) (*connect.Response[v1.DeleteRecordResponse], error)
-}
-
-// NewDNSServiceClient constructs a client for the dns.v1.DNSService service. By default, it uses
-// the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewDNSServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) DNSServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	dNSServiceMethods := v1.File_dns_v1_dns_proto.Services().ByName("DNSService").Methods()
-	return &dNSServiceClient{
-		listRecords: connect.NewClient[v1.ListRecordsRequest, v1.ListRecordsResponse](
-			httpClient,
-			baseURL+DNSServiceListRecordsProcedure,
-			connect.WithSchema(dNSServiceMethods.ByName("ListRecords")),
-			connect.WithClientOptions(opts...),
-		),
-		createRecord: connect.NewClient[v1.CreateRecordRequest, v1.CreateRecordResponse](
-			httpClient,
-			baseURL+DNSServiceCreateRecordProcedure,
-			connect.WithSchema(dNSServiceMethods.ByName("CreateRecord")),
-			connect.WithClientOptions(opts...),
-		),
-		updateRecord: connect.NewClient[v1.UpdateRecordRequest, v1.UpdateRecordResponse](
-			httpClient,
-			baseURL+DNSServiceUpdateRecordProcedure,
-			connect.WithSchema(dNSServiceMethods.ByName("UpdateRecord")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteRecord: connect.NewClient[v1.DeleteRecordRequest, v1.DeleteRecordResponse](
-			httpClient,
-			baseURL+DNSServiceDeleteRecordProcedure,
-			connect.WithSchema(dNSServiceMethods.ByName("DeleteRecord")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// dNSServiceClient implements DNSServiceClient.
-type dNSServiceClient struct {
-	listRecords  *connect.Client[v1.ListRecordsRequest, v1.ListRecordsResponse]
-	createRecord *connect.Client[v1.CreateRecordRequest, v1.CreateRecordResponse]
-	updateRecord *connect.Client[v1.UpdateRecordRequest, v1.UpdateRecordResponse]
-	deleteRecord *connect.Client[v1.DeleteRecordRequest, v1.DeleteRecordResponse]
-}
-
-// ListRecords calls dns.v1.DNSService.ListRecords.
-func (c *dNSServiceClient) ListRecords(ctx context.Context, req *connect.Request[v1.ListRecordsRequest]) (*connect.Response[v1.ListRecordsResponse], error) {
-	return c.listRecords.CallUnary(ctx, req)
-}
-
-// CreateRecord calls dns.v1.DNSService.CreateRecord.
-func (c *dNSServiceClient) CreateRecord(ctx context.Context, req *connect.Request[v1.CreateRecordRequest]) (*connect.Response[v1.CreateRecordResponse], error) {
-	return c.createRecord.CallUnary(ctx, req)
-}
-
-// UpdateRecord calls dns.v1.DNSService.UpdateRecord.
-func (c *dNSServiceClient) UpdateRecord(ctx context.Context, req *connect.Request[v1.UpdateRecordRequest]) (*connect.Response[v1.UpdateRecordResponse], error) {
-	return c.updateRecord.CallUnary(ctx, req)
-}
-
-// DeleteRecord calls dns.v1.DNSService.DeleteRecord.
-func (c *dNSServiceClient) DeleteRecord(ctx context.Context, req *connect.Request[v1.DeleteRecordRequest]) (*connect.Response[v1.DeleteRecordResponse], error) {
-	return c.deleteRecord.CallUnary(ctx, req)
-}
-
-// DNSServiceHandler is an implementation of the dns.v1.DNSService service.
-type DNSServiceHandler interface {
-	ListRecords(context.Context, *connect.Request[v1.ListRecordsRequest]) (*connect.Response[v1.ListRecordsResponse], error)
-	CreateRecord(context.Context, *connect.Request[v1.CreateRecordRequest]) (*connect.Response[v1.CreateRecordResponse], error)
-	UpdateRecord(context.Context, *connect.Request[v1.UpdateRecordRequest]) (*connect.Response[v1.UpdateRecordResponse], error)
-	DeleteRecord(context.Context, *connect.Request[v1.DeleteRecordRequest]) (*connect.Response[v1.DeleteRecordResponse], error)
-}
-
-// NewDNSServiceHandler builds an HTTP handler from the service implementation. It returns the path
-// on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewDNSServiceHandler(svc DNSServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	dNSServiceMethods := v1.File_dns_v1_dns_proto.Services().ByName("DNSService").Methods()
-	dNSServiceListRecordsHandler := connect.NewUnaryHandler(
-		DNSServiceListRecordsProcedure,
-		svc.ListRecords,
-		connect.WithSchema(dNSServiceMethods.ByName("ListRecords")),
-		connect.WithHandlerOptions(opts...),
-	)
-	dNSServiceCreateRecordHandler := connect.NewUnaryHandler(
-		DNSServiceCreateRecordProcedure,
-		svc.CreateRecord,
-		connect.WithSchema(dNSServiceMethods.ByName("CreateRecord")),
-		connect.WithHandlerOptions(opts...),
-	)
-	dNSServiceUpdateRecordHandler := connect.NewUnaryHandler(
-		DNSServiceUpdateRecordProcedure,
-		svc.UpdateRecord,
-		connect.WithSchema(dNSServiceMethods.ByName("UpdateRecord")),
-		connect.WithHandlerOptions(opts...),
-	)
-	dNSServiceDeleteRecordHandler := connect.NewUnaryHandler(
-		DNSServiceDeleteRecordProcedure,
-		svc.DeleteRecord,
-		connect.WithSchema(dNSServiceMethods.ByName("DeleteRecord")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/dns.v1.DNSService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case DNSServiceListRecordsProcedure:
-			dNSServiceListRecordsHandler.ServeHTTP(w, r)
-		case DNSServiceCreateRecordProcedure:
-			dNSServiceCreateRecordHandler.ServeHTTP(w, r)
-		case DNSServiceUpdateRecordProcedure:
-			dNSServiceUpdateRecordHandler.ServeHTTP(w, r)
-		case DNSServiceDeleteRecordProcedure:
-			dNSServiceDeleteRecordHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
-}
-
-// UnimplementedDNSServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedDNSServiceHandler struct{}
-
-func (UnimplementedDNSServiceHandler) ListRecords(context.Context, *connect.Request[v1.ListRecordsRequest]) (*connect.Response[v1.ListRecordsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("dns.v1.DNSService.ListRecords is not implemented"))
-}
-
-func (UnimplementedDNSServiceHandler) CreateRecord(context.Context, *connect.Request[v1.CreateRecordRequest]) (*connect.Response[v1.CreateRecordResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("dns.v1.DNSService.CreateRecord is not implemented"))
-}
-
-func (UnimplementedDNSServiceHandler) UpdateRecord(context.Context, *connect.Request[v1.UpdateRecordRequest]) (*connect.Response[v1.UpdateRecordResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("dns.v1.DNSService.UpdateRecord is not implemented"))
-}
-
-func (UnimplementedDNSServiceHandler) DeleteRecord(context.Context, *connect.Request[v1.DeleteRecordRequest]) (*connect.Response[v1.DeleteRecordResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("dns.v1.DNSService.DeleteRecord is not implemented"))
-}

package/templates/root/go.mod

@@ -1,10 +0,0 @@
-module {{MODULE_PATH}}
-
-go 1.25.4
-
-require (
-	connectrpc.com/connect v1.19.1
-	github.com/go-chi/chi/v5 v5.2.2
-	golang.org/x/net v0.42.0
-	google.golang.org/protobuf v1.36.10
-)

package/templates/root/internal/app/service.go

@@ -1,152 +0,0 @@
-package app
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"{{MODULE_PATH}}/internal/cloudflare"
-)
-
-type Record struct {
-	ID      string `json:"id"`
-	Type    string `json:"type"`
-	Name    string `json:"name"`
-	Content string `json:"content"`
-	TTL     int    `json:"ttl"`
-	Proxied bool   `json:"proxied"`
-}
-
-type CreateRecordInput struct {
-	Type    string `json:"type"`
-	Name    string `json:"name"`
-	Content string `json:"content"`
-	TTL     int    `json:"ttl"`
-	Proxied bool   `json:"proxied"`
-}
-
-type UpdateRecordInput struct {
-	Type    string `json:"type"`
-	Name    string `json:"name"`
-	Content string `json:"content"`
-	TTL     int    `json:"ttl"`
-	Proxied bool   `json:"proxied"`
-}
-
-type TokenSource interface {
-	Token(context.Context) (string, error)
-}
-
-type DNSService struct {
-	zoneID      string
-	apiBaseURL  string
-	tokenSource TokenSource
-	httpClient  *http.Client
-}
-
-func NewDNSService(zoneID string, apiBaseURL string, tokenSource TokenSource) *DNSService {
-	return &DNSService{
-		zoneID:      zoneID,
-		apiBaseURL:  apiBaseURL,
-		tokenSource: tokenSource,
-		httpClient: &http.Client{
-			Timeout: 20 * time.Second,
-		},
-	}
-}
-
-func (s *DNSService) ListRecords(ctx context.Context) ([]Record, error) {
-	client, err := s.cloudflareClient(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	records, err := client.ListRecords(ctx, s.zoneID)
-	if err != nil {
-		return nil, err
-	}
-
-	out := make([]Record, 0, len(records))
-	for _, record := range records {
-		out = append(out, Record{
-			ID:      record.ID,
-			Type:    record.Type,
-			Name:    record.Name,
-			Content: record.Content,
-			TTL:     record.TTL,
-			Proxied: record.Proxied,
-		})
-	}
-	return out, nil
-}
-
-func (s *DNSService) CreateRecord(ctx context.Context, input CreateRecordInput) (Record, error) {
-	client, err := s.cloudflareClient(ctx)
-	if err != nil {
-		return Record{}, err
-	}
-
-	record, err := client.CreateRecord(ctx, s.zoneID, cloudflare.RecordInput{
-		Type:    input.Type,
-		Name:    input.Name,
-		Content: input.Content,
-		TTL:     input.TTL,
-		Proxied: input.Proxied,
-	})
-	if err != nil {
-		return Record{}, err
-	}
-
-	return Record{
-		ID:      record.ID,
-		Type:    record.Type,
-		Name:    record.Name,
-		Content: record.Content,
-		TTL:     record.TTL,
-		Proxied: record.Proxied,
-	}, nil
-}
-
-func (s *DNSService) UpdateRecord(ctx context.Context, id string, input UpdateRecordInput) (Record, error) {
-	client, err := s.cloudflareClient(ctx)
-	if err != nil {
-		return Record{}, err
-	}
-
-	record, err := client.UpdateRecord(ctx, s.zoneID, id, cloudflare.RecordInput{
-		Type:    input.Type,
-		Name:    input.Name,
-		Content: input.Content,
-		TTL:     input.TTL,
-		Proxied: input.Proxied,
-	})
-	if err != nil {
-		return Record{}, err
-	}
-
-	return Record{
-		ID:      record.ID,
-		Type:    record.Type,
-		Name:    record.Name,
-		Content: record.Content,
-		TTL:     record.TTL,
-		Proxied: record.Proxied,
-	}, nil
-}
-
-func (s *DNSService) DeleteRecord(ctx context.Context, id string) error {
-	client, err := s.cloudflareClient(ctx)
-	if err != nil {
-		return err
-	}
-	return client.DeleteRecord(ctx, s.zoneID, id)
-}
-
-func (s *DNSService) cloudflareClient(ctx context.Context) (*cloudflare.Client, error) {
-	token, err := s.tokenSource.Token(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	return cloudflare.NewClient(s.apiBaseURL, token, s.httpClient), nil
-}

package/templates/root/internal/app/token_source.go

@@ -1,50 +0,0 @@
-package app
-
-import (
-	"context"
-	"os"
-	"strings"
-	"sync"
-)
-
-type SecretResolver interface {
-	Get(ctx context.Context, path string, key string) (string, error)
-}
-
-type CloudflareTokenSource struct {
-	resolver SecretResolver
-	secretPath string
-	secretKey  string
-
-	mu     sync.Mutex
-	cached string
-}
-
-func NewCloudflareTokenSource(resolver SecretResolver, secretPath string, secretKey string) *CloudflareTokenSource {
-	return &CloudflareTokenSource{
-		resolver:   resolver,
-		secretPath: secretPath,
-		secretKey:  secretKey,
-	}
-}
-
-func (s *CloudflareTokenSource) Token(ctx context.Context) (string, error) {
-	if token := strings.TrimSpace(os.Getenv("CLOUDFLARE_API_TOKEN")); token != "" {
-		return token, nil
-	}
-
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if s.cached != "" {
-		return s.cached, nil
-	}
-
-	token, err := s.resolver.Get(ctx, s.secretPath, s.secretKey)
-	if err != nil {
-		return "", err
-	}
-
-	s.cached = token
-	return token, nil
-}

package/templates/root/internal/cloudflare/client.go

@@ -1,160 +0,0 @@
-package cloudflare
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-)
-
-type Client struct {
-	baseURL string
-	token   string
-	client  *http.Client
-}
-
-type Record struct {
-	ID      string
-	Type    string
-	Name    string
-	Content string
-	TTL     int
-	Proxied bool
-}
-
-type RecordInput struct {
-	Type    string `json:"type"`
-	Name    string `json:"name"`
-	Content string `json:"content"`
-	TTL     int    `json:"ttl"`
-	Proxied bool   `json:"proxied"`
-}
-
-func NewClient(baseURL string, token string, client *http.Client) *Client {
-	return &Client{
-		baseURL: strings.TrimRight(baseURL, "/"),
-		token:   strings.TrimSpace(token),
-		client:  client,
-	}
-}
-
-func (c *Client) ListRecords(ctx context.Context, zoneID string) ([]Record, error) {
-	endpoint := fmt.Sprintf("%s/zones/%s/dns_records?per_page=200", c.baseURL, url.PathEscape(zoneID))
-	var payload response[[]record]
-	if err := c.doJSON(ctx, http.MethodGet, endpoint, nil, &payload); err != nil {
-		return nil, err
-	}
-
-	out := make([]Record, 0, len(payload.Result))
-	for _, record := range payload.Result {
-		out = append(out, Record{
-			ID:      record.ID,
-			Type:    record.Type,
-			Name:    record.Name,
-			Content: record.Content,
-			TTL:     record.TTL,
-			Proxied: record.Proxied,
-		})
-	}
-	return out, nil
-}
-
-func (c *Client) CreateRecord(ctx context.Context, zoneID string, input RecordInput) (Record, error) {
-	endpoint := fmt.Sprintf("%s/zones/%s/dns_records", c.baseURL, url.PathEscape(zoneID))
-	var payload response[record]
-	if err := c.doJSON(ctx, http.MethodPost, endpoint, input, &payload); err != nil {
-		return Record{}, err
-	}
-	return Record{
-		ID:      payload.Result.ID,
-		Type:    payload.Result.Type,
-		Name:    payload.Result.Name,
-		Content: payload.Result.Content,
-		TTL:     payload.Result.TTL,
-		Proxied: payload.Result.Proxied,
-	}, nil
-}
-
-func (c *Client) UpdateRecord(ctx context.Context, zoneID string, recordID string, input RecordInput) (Record, error) {
-	endpoint := fmt.Sprintf("%s/zones/%s/dns_records/%s", c.baseURL, url.PathEscape(zoneID), url.PathEscape(recordID))
-	var payload response[record]
-	if err := c.doJSON(ctx, http.MethodPut, endpoint, input, &payload); err != nil {
-		return Record{}, err
-	}
-	return Record{
-		ID:      payload.Result.ID,
-		Type:    payload.Result.Type,
-		Name:    payload.Result.Name,
-		Content: payload.Result.Content,
-		TTL:     payload.Result.TTL,
-		Proxied: payload.Result.Proxied,
-	}, nil
-}
-
-func (c *Client) DeleteRecord(ctx context.Context, zoneID string, recordID string) error {
-	endpoint := fmt.Sprintf("%s/zones/%s/dns_records/%s", c.baseURL, url.PathEscape(zoneID), url.PathEscape(recordID))
-	return c.doJSON(ctx, http.MethodDelete, endpoint, nil, nil)
-}
-
-func (c *Client) doJSON(ctx context.Context, method string, endpoint string, body any, out any) error {
-	if c.token == "" {
-		return fmt.Errorf("cloudflare token is empty")
-	}
-
-	var reader io.Reader
-	if body != nil {
-		payload, err := json.Marshal(body)
-		if err != nil {
-			return err
-		}
-		reader = bytes.NewReader(payload)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, method, endpoint, reader)
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Authorization", "Bearer "+c.token)
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	raw, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return err
-	}
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("cloudflare %s %s failed: status=%d body=%s", method, endpoint, resp.StatusCode, strings.TrimSpace(string(raw)))
-	}
-
-	if out == nil {
-		return nil
-	}
-	if err := json.Unmarshal(raw, out); err != nil {
-		return err
-	}
-	return nil
-}
-
-type response[T any] struct {
-	Success bool `json:"success"`
-	Result  T    `json:"result"`
-}
-
-type record struct {
-	ID      string `json:"id"`
-	Type    string `json:"type"`
-	Name    string `json:"name"`
-	Content string `json:"content"`
-	TTL     int    `json:"ttl"`
-	Proxied bool   `json:"proxied"`
-}

package/templates/root/internal/config/config.go

@@ -1,55 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"strings"
-)
-
-type Config struct {
-	Port                string
-	VaultAddr           string
-	VaultRoleIDFile     string
-	VaultSecretIDFile   string
-	VaultSecretPath     string
-	VaultSecretKey      string
-	CloudflareZoneID    string
-	CloudflareAPIBaseURL string
-}
-
-func Load() (Config, error) {
-	cfg := Config{
-		Port:                 envOr("PORT", "8080"),
-		VaultAddr:            strings.TrimSpace(os.Getenv("VAULT_ADDR")),
-		VaultRoleIDFile:      envOr("VAULT_ROLE_ID_FILE", "/var/run/secrets/vault-role-id/value"),
-		VaultSecretIDFile:    envOr("VAULT_SECRET_ID_FILE", "/var/run/secrets/vault-secret-id/value"),
-		VaultSecretPath:      strings.TrimSpace(os.Getenv("VAULT_SECRET_PATH")),
-		VaultSecretKey:       strings.TrimSpace(os.Getenv("VAULT_SECRET_KEY")),
-		CloudflareZoneID:     strings.TrimSpace(os.Getenv("CLOUDFLARE_ZONE_ID")),
-		CloudflareAPIBaseURL: envOr("CLOUDFLARE_API_BASE_URL", "https://api.cloudflare.com/client/v4"),
-	}
-
-	if cfg.CloudflareZoneID == "" {
-		return Config{}, fmt.Errorf("CLOUDFLARE_ZONE_ID is required")
-	}
-	if strings.TrimSpace(os.Getenv("CLOUDFLARE_API_TOKEN")) == "" {
-		if cfg.VaultAddr == "" {
-			return Config{}, fmt.Errorf("VAULT_ADDR is required when CLOUDFLARE_API_TOKEN is not set")
-		}
-		if cfg.VaultSecretPath == "" {
-			return Config{}, fmt.Errorf("VAULT_SECRET_PATH is required when CLOUDFLARE_API_TOKEN is not set")
-		}
-		if cfg.VaultSecretKey == "" {
-			return Config{}, fmt.Errorf("VAULT_SECRET_KEY is required when CLOUDFLARE_API_TOKEN is not set")
-		}
-	}
-
-	return cfg, nil
-}
-
-func envOr(key string, fallback string) string {
-	if value := strings.TrimSpace(os.Getenv(key)); value != "" {
-		return value
-	}
-	return fallback
-}

package/templates/root/internal/connectapi/handler.go

@@ -1,79 +0,0 @@
-package connectapi
-
-import (
-	"context"
-	"net/http"
-
-	"connectrpc.com/connect"
-
-	dnsv1 "{{MODULE_PATH}}/gen/dns/v1"
-	dnsv1connect "{{MODULE_PATH}}/gen/dns/v1/dnsv1connect"
-	"{{MODULE_PATH}}/internal/app"
-)
-
-type Handler struct {
-	service *app.DNSService
-}
-
-func NewHandler(service *app.DNSService) (string, http.Handler) {
-	return dnsv1connect.NewDNSServiceHandler(&Handler{service: service})
-}
-
-func (h *Handler) ListRecords(ctx context.Context, _ *connect.Request[dnsv1.ListRecordsRequest]) (*connect.Response[dnsv1.ListRecordsResponse], error) {
-	records, err := h.service.ListRecords(ctx)
-	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
-	}
-
-	response := &dnsv1.ListRecordsResponse{Records: make([]*dnsv1.Record, 0, len(records))}
-	for _, record := range records {
-		response.Records = append(response.Records, toProtoRecord(record))
-	}
-	return connect.NewResponse(response), nil
-}
-
-func (h *Handler) CreateRecord(ctx context.Context, request *connect.Request[dnsv1.CreateRecordRequest]) (*connect.Response[dnsv1.CreateRecordResponse], error) {
-	record, err := h.service.CreateRecord(ctx, app.CreateRecordInput{
-		Type:    request.Msg.GetType(),
-		Name:    request.Msg.GetName(),
-		Content: request.Msg.GetContent(),
-		TTL:     int(request.Msg.GetTtl()),
-		Proxied: request.Msg.GetProxied(),
-	})
-	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
-	}
-	return connect.NewResponse(&dnsv1.CreateRecordResponse{Record: toProtoRecord(record)}), nil
-}
-
-func (h *Handler) UpdateRecord(ctx context.Context, request *connect.Request[dnsv1.UpdateRecordRequest]) (*connect.Response[dnsv1.UpdateRecordResponse], error) {
-	record, err := h.service.UpdateRecord(ctx, request.Msg.GetId(), app.UpdateRecordInput{
-		Type:    request.Msg.GetType(),
-		Name:    request.Msg.GetName(),
-		Content: request.Msg.GetContent(),
-		TTL:     int(request.Msg.GetTtl()),
-		Proxied: request.Msg.GetProxied(),
-	})
-	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
-	}
-	return connect.NewResponse(&dnsv1.UpdateRecordResponse{Record: toProtoRecord(record)}), nil
-}
-
-func (h *Handler) DeleteRecord(ctx context.Context, request *connect.Request[dnsv1.DeleteRecordRequest]) (*connect.Response[dnsv1.DeleteRecordResponse], error) {
-	if err := h.service.DeleteRecord(ctx, request.Msg.GetId()); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
-	}
-	return connect.NewResponse(&dnsv1.DeleteRecordResponse{}), nil
-}
-
-func toProtoRecord(record app.Record) *dnsv1.Record {
-	return &dnsv1.Record{
-		Id:      record.ID,
-		Type:    record.Type,
-		Name:    record.Name,
-		Content: record.Content,
-		Ttl:     int32(record.TTL),
-		Proxied: record.Proxied,
-	}
-}