create-svc 0.1.2 → 0.1.3

package/templates/variants/go-connectrpc/gen/dns/v1/dnsv1connect/dns.connect.go

@@ -0,0 +1,192 @@
+// 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/variants/go-connectrpc/go.mod

@@ -0,0 +1,10 @@
+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/variants/go-connectrpc/internal/app/service.go

@@ -0,0 +1,109 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+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 DNSService struct {
+	mu      sync.RWMutex
+	nextID  int
+	records map[string]Record
+}
+
+func NewDNSService() *DNSService {
+	return &DNSService{
+		nextID:  1,
+		records: map[string]Record{},
+	}
+}
+
+func (s *DNSService) ListRecords(ctx context.Context) ([]Record, error) {
+	_ = ctx
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	out := make([]Record, 0, len(s.records))
+	for _, record := range s.records {
+		out = append(out, record)
+	}
+	return out, nil
+}
+
+func (s *DNSService) CreateRecord(ctx context.Context, input CreateRecordInput) (Record, error) {
+	_ = ctx
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	record := Record{
+		ID:      fmt.Sprintf("%d", s.nextID),
+		Type:    input.Type,
+		Name:    input.Name,
+		Content: input.Content,
+		TTL:     input.TTL,
+		Proxied: input.Proxied,
+	}
+
+	s.nextID += 1
+	s.records[record.ID] = record
+	return record, nil
+}
+
+func (s *DNSService) UpdateRecord(ctx context.Context, id string, input UpdateRecordInput) (Record, error) {
+	_ = ctx
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	record, ok := s.records[id]
+	if !ok {
+		return Record{}, fmt.Errorf("record %s not found", id)
+	}
+
+	record.Type = input.Type
+	record.Name = input.Name
+	record.Content = input.Content
+	record.TTL = input.TTL
+	record.Proxied = input.Proxied
+	s.records[id] = record
+
+	return record, nil
+}
+
+func (s *DNSService) DeleteRecord(ctx context.Context, id string) error {
+	_ = ctx
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if _, ok := s.records[id]; !ok {
+		return fmt.Errorf("record %s not found", id)
+	}
+
+	delete(s.records, id)
+	return nil
+}

package/templates/variants/go-connectrpc/internal/app/token_source.go

@@ -0,0 +1,50 @@
+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/variants/go-connectrpc/internal/cloudflare/client.go

@@ -0,0 +1,160 @@
+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/variants/go-connectrpc/internal/config/config.go

@@ -0,0 +1,23 @@
+package config
+
+import "os"
+
+type Config struct {
+	Port        string
+	DatabaseURL string
+}
+
+func Load() (Config, error) {
+	return Config{
+		Port:        envOr("PORT", "8080"),
+		DatabaseURL: envOr("DATABASE_URL", ""),
+	}, nil
+}
+
+func envOr(key string, fallback string) string {
+	value := os.Getenv(key)
+	if value != "" {
+		return value
+	}
+	return fallback
+}

package/templates/variants/go-connectrpc/internal/connectapi/handler.go

@@ -0,0 +1,79 @@
+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,
+	}
+}