create-svc 0.1.8 → 0.1.10

package/templates/variants/go-chi/internal/config/config.go

@@ -1,17 +1,32 @@
 package config
 
-import "os"
+import (
+	"errors"
+	"os"
+	"strings"
+)
 
 type Config struct {
-	Port        string
-	DatabaseURL string
+	Port                    string
+	DatabaseURL             string
+	AttachmentBucket        string
+	AttachmentPublicBaseURL string
 }
 
 func Load() (Config, error) {
-	return Config{
-		Port:        envOr("PORT", "8080"),
-		DatabaseURL: envOr("DATABASE_URL", ""),
-	}, nil
+	cfg := Config{
+		Port:                    envOr("PORT", "8080"),
+		DatabaseURL:             strings.TrimSpace(os.Getenv("DATABASE_URL")),
+		AttachmentBucket:        strings.TrimSpace(os.Getenv("ATTACHMENT_BUCKET")),
+		AttachmentPublicBaseURL: strings.TrimSpace(os.Getenv("ATTACHMENT_PUBLIC_BASE_URL")),
+	}
+	if cfg.DatabaseURL == "" {
+		return Config{}, errors.New("DATABASE_URL is required")
+	}
+	if cfg.AttachmentBucket == "" {
+		return Config{}, errors.New("ATTACHMENT_BUCKET is required")
+	}
+	return cfg, nil
 }
 
 func envOr(key string, fallback string) string {

package/templates/variants/go-chi/internal/httpapi/list_messages_integration_test.go

@@ -0,0 +1,298 @@
+package httpapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	_ "github.com/jackc/pgx/v5/stdlib"
+	"github.com/jmoiron/sqlx"
+
+	"{{MODULE_PATH}}/internal/app"
+)
+
+func TestListMessagesPaginationIncludesAttachmentMetadata(t *testing.T) {
+	databaseURL := strings.TrimSpace(os.Getenv("DATABASE_URL"))
+	if databaseURL == "" {
+		t.Skip("DATABASE_URL is required for integration test")
+	}
+
+	t.Setenv("ATTACHMENT_PUBLIC_BASE_URL", "https://storage.test")
+
+	db, err := app.OpenDatabase(context.Background(), databaseURL)
+	if err != nil {
+		t.Fatalf("open database: %v", err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+
+	if _, err := db.ExecContext(context.Background(), `
+truncate table
+  webhook_events,
+  attachments,
+  messages,
+  conversation_participants,
+  conversations,
+  users
+restart identity cascade`); err != nil {
+		t.Fatalf("truncate tables: %v", err)
+	}
+
+	storage := newFakeStorage()
+	service := app.NewChatService(db, storage, app.GenericWebhookAdapter{})
+	router := chi.NewRouter()
+	RegisterRoutes(router, service)
+	server := httptest.NewServer(router)
+	t.Cleanup(server.Close)
+
+	userID := createUser(t, server.URL)
+	conversationID := createConversation(t, server.URL, userID)
+
+	messageIDs := make([]string, 0, 55)
+	for index := 1; index <= 55; index++ {
+		messageIDs = append(messageIDs, createMessage(t, server.URL, conversationID, userID, fmt.Sprintf("message-%d", index)))
+	}
+	rewriteMessageTimestamps(t, db, messageIDs)
+
+	upload := createAttachmentUpload(t, server.URL, conversationID, userID)
+	storage.set(upload.Result.Attachment.PublicURL, "image/png", 1234)
+	finalizeAttachment(t, server.URL, upload.Result.Attachment.ID, messageIDs[54])
+
+	firstPage := listMessagesPage(t, server.URL, conversationID, "")
+	if len(firstPage.Messages) != 50 {
+		t.Fatalf("expected 50 messages, got %d", len(firstPage.Messages))
+	}
+	if firstPage.Messages[0].Body != "message-55" {
+		t.Fatalf("expected newest message first, got %s", firstPage.Messages[0].Body)
+	}
+	if firstPage.Messages[49].Body != "message-6" {
+		t.Fatalf("expected oldest message on first page to be message-6, got %s", firstPage.Messages[49].Body)
+	}
+	if firstPage.NextCursor == "" {
+		t.Fatal("expected next_cursor on first page")
+	}
+	if len(firstPage.Messages[0].Attachments) != 1 {
+		t.Fatalf("expected attachment metadata on newest message, got %#v", firstPage.Messages[0].Attachments)
+	}
+	if firstPage.Messages[0].Attachments[0].PublicURL != upload.Result.Attachment.PublicURL {
+		t.Fatalf("expected public_url %s, got %s", upload.Result.Attachment.PublicURL, firstPage.Messages[0].Attachments[0].PublicURL)
+	}
+
+	secondPage := listMessagesPage(t, server.URL, conversationID, firstPage.NextCursor)
+	expectedBodies := []string{"message-5", "message-4", "message-3", "message-2", "message-1"}
+	if len(secondPage.Messages) != len(expectedBodies) {
+		t.Fatalf("expected %d messages on second page, got %d", len(expectedBodies), len(secondPage.Messages))
+	}
+	for index, body := range expectedBodies {
+		if secondPage.Messages[index].Body != body {
+			t.Fatalf("expected %s at index %d, got %s", body, index, secondPage.Messages[index].Body)
+		}
+	}
+	if secondPage.NextCursor != "" {
+		t.Fatalf("expected no next cursor on final page, got %s", secondPage.NextCursor)
+	}
+}
+
+type pageResponse struct {
+	Messages []struct {
+		ID          string `json:"id"`
+		Body        string `json:"body"`
+		Attachments []struct {
+			ID          string `json:"id"`
+			Filename    string `json:"filename"`
+			ContentType string `json:"content_type"`
+			ByteSize    int64  `json:"byte_size"`
+			Status      string `json:"status"`
+			PublicURL   string `json:"public_url"`
+		} `json:"attachments"`
+	} `json:"messages"`
+	NextCursor string `json:"next_cursor"`
+}
+
+type attachmentUploadResponse struct {
+	Result struct {
+		Attachment struct {
+			ID        string `json:"id"`
+			PublicURL string `json:"public_url"`
+		} `json:"attachment"`
+	} `json:"result"`
+}
+
+type fakeStorage struct {
+	metadata map[string]struct {
+		contentType string
+		byteSize    int64
+		publicURL   string
+	}
+}
+
+func newFakeStorage() *fakeStorage {
+	return &fakeStorage{metadata: map[string]struct {
+		contentType string
+		byteSize    int64
+		publicURL   string
+	}{}}
+}
+
+func (f *fakeStorage) CreateSignedUpload(_ context.Context, attachmentID string, conversationID string, filename string, contentType string) (string, string, app.UploadTarget, string, error) {
+	key := fmt.Sprintf("attachments/%s/%s/%s", conversationID, attachmentID, filename)
+	return "test-bucket", key, app.UploadTarget{
+		Method: http.MethodPut,
+		URL:    "https://uploads.test/" + key,
+		Headers: map[string]string{
+			"Content-Type": contentType,
+		},
+	}, "https://storage.test/" + key, nil
+}
+
+func (f *fakeStorage) GetObjectMetadata(_ context.Context, bucket string, key string) (string, int64, string, error) {
+	entry, ok := f.metadata[bucket+"/"+key]
+	if !ok {
+		return "", 0, "", fmt.Errorf("missing metadata for %s/%s", bucket, key)
+	}
+	return entry.contentType, entry.byteSize, entry.publicURL, nil
+}
+
+func (f *fakeStorage) set(publicURL string, contentType string, byteSize int64) {
+	key := strings.TrimPrefix(publicURL, "https://storage.test/")
+	f.metadata["test-bucket/"+key] = struct {
+		contentType string
+		byteSize    int64
+		publicURL   string
+	}{
+		contentType: contentType,
+		byteSize:    byteSize,
+		publicURL:   publicURL,
+	}
+}
+
+func createUser(t *testing.T, baseURL string) string {
+	var response struct {
+		User struct {
+			ID string `json:"id"`
+		} `json:"user"`
+	}
+	requestJSON(t, http.MethodPost, baseURL+"/v1/users", map[string]any{
+		"username":     "alice",
+		"display_name": "Alice",
+	}, &response)
+	return response.User.ID
+}
+
+func createConversation(t *testing.T, baseURL string, userID string) string {
+	var response struct {
+		Conversation struct {
+			ID string `json:"id"`
+		} `json:"conversation"`
+	}
+	requestJSON(t, http.MethodPost, baseURL+"/v1/conversations", map[string]any{
+		"created_by_user_id":  userID,
+		"title":               "General",
+		"participant_user_ids": []string{userID},
+	}, &response)
+	return response.Conversation.ID
+}
+
+func createMessage(t *testing.T, baseURL string, conversationID string, userID string, body string) string {
+	var response struct {
+		Message struct {
+			ID string `json:"id"`
+		} `json:"message"`
+	}
+	requestJSON(t, http.MethodPost, baseURL+"/v1/conversations/"+conversationID+"/messages", map[string]any{
+		"user_id": userID,
+		"body":    body,
+	}, &response)
+	return response.Message.ID
+}
+
+func createAttachmentUpload(t *testing.T, baseURL string, conversationID string, userID string) attachmentUploadResponse {
+	var response attachmentUploadResponse
+	requestJSON(t, http.MethodPost, baseURL+"/v1/attachments/uploads", map[string]any{
+		"conversation_id": conversationID,
+		"user_id":         userID,
+		"filename":        "photo.png",
+		"content_type":    "image/png",
+		"byte_size":       1234,
+	}, &response)
+	return response
+}
+
+func finalizeAttachment(t *testing.T, baseURL string, attachmentID string, messageID string) {
+	requestJSON(t, http.MethodPost, baseURL+"/v1/attachments/"+attachmentID+"/finalize", map[string]any{
+		"message_id": messageID,
+	}, &struct{}{})
+}
+
+func listMessagesPage(t *testing.T, baseURL string, conversationID string, cursor string) pageResponse {
+	requestURL := baseURL + "/v1/conversations/" + conversationID + "/messages"
+	if cursor != "" {
+		requestURL += "?cursor=" + url.QueryEscape(cursor)
+	}
+	var response pageResponse
+	requestJSON(t, http.MethodGet, requestURL, nil, &response)
+	return response
+}
+
+func requestJSON(t *testing.T, method string, url string, payload any, out any) {
+	t.Helper()
+
+	var bodyReader *bytes.Reader
+	if payload == nil {
+		bodyReader = bytes.NewReader(nil)
+	} else {
+		body, err := json.Marshal(payload)
+		if err != nil {
+			t.Fatalf("marshal request: %v", err)
+		}
+		bodyReader = bytes.NewReader(body)
+	}
+
+	request, err := http.NewRequest(method, url, bodyReader)
+	if err != nil {
+		t.Fatalf("new request: %v", err)
+	}
+	if payload != nil {
+		request.Header.Set("Content-Type", "application/json")
+	}
+
+	response, err := http.DefaultClient.Do(request)
+	if err != nil {
+		t.Fatalf("do request: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		var problem map[string]any
+		_ = json.NewDecoder(response.Body).Decode(&problem)
+		t.Fatalf("unexpected status %d: %#v", response.StatusCode, problem)
+	}
+
+	if out != nil {
+		if err := json.NewDecoder(response.Body).Decode(out); err != nil {
+			t.Fatalf("decode response: %v", err)
+		}
+	}
+}
+
+func rewriteMessageTimestamps(t *testing.T, db *sqlx.DB, messageIDs []string) {
+	t.Helper()
+	baseTime := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC)
+	for index, messageID := range messageIDs {
+		createdAt := baseTime.Add(time.Duration(index+1) * time.Second)
+		if _, err := db.ExecContext(context.Background(), `
+update messages
+set created_at = $2, updated_at = $2
+where id = $1`, messageID, createdAt); err != nil {
+			t.Fatalf("rewrite message timestamp: %v", err)
+		}
+	}
+}

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

@@ -3,6 +3,7 @@ package httpapi
 import (
 	"encoding/json"
 	"errors"
+	"io"
 	"net/http"
 	"strconv"
 	"strings"
@@ -12,67 +13,259 @@ import (
 	"{{MODULE_PATH}}/internal/app"
 )
 
-func RegisterRoutes(router chi.Router, service *app.DNSService) {
+func RegisterRoutes(router chi.Router, service *app.ChatService) {
 	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})
+	router.Get("/readyz", func(w http.ResponseWriter, _ *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+	})
+	router.Get("/", func(w http.ResponseWriter, _ *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]string{
+			"service":   "{{SERVICE_NAME}}",
+			"domain":    "chat",
+			"apiOrigin": "https://api.{{SERVICE_NAME}}.anmho.com",
 		})
+	})
 
-		r.Post("/", func(w http.ResponseWriter, request *http.Request) {
-			var input app.CreateRecordInput
-			if err := decodeJSON(request, &input); err != nil {
-				writeError(w, err)
-				return
-			}
+	router.Post("/v1/users", func(w http.ResponseWriter, request *http.Request) {
+		var input app.CreateUserInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		user, err := service.CreateUser(request.Context(), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusCreated, map[string]any{"user": user})
+	})
+
+	router.Get("/v1/users/{userID}", func(w http.ResponseWriter, request *http.Request) {
+		user, err := service.GetUser(request.Context(), chi.URLParam(request, "userID"))
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"user": user})
+	})
+
+	router.Get("/v1/users", func(w http.ResponseWriter, request *http.Request) {
+		user, err := service.GetUserByUsername(request.Context(), request.URL.Query().Get("username"))
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"user": user})
+	})
+
+	router.Post("/v1/conversations", func(w http.ResponseWriter, request *http.Request) {
+		var input app.CreateConversationInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		conversation, err := service.CreateConversation(request.Context(), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusCreated, map[string]any{"conversation": conversation})
+	})
+
+	router.Get("/v1/conversations/{conversationID}", func(w http.ResponseWriter, request *http.Request) {
+		conversation, err := service.GetConversation(request.Context(), chi.URLParam(request, "conversationID"))
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"conversation": conversation})
+	})
+
+	router.Patch("/v1/conversations/{conversationID}", func(w http.ResponseWriter, request *http.Request) {
+		var input app.UpdateConversationInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		conversation, err := service.UpdateConversation(request.Context(), chi.URLParam(request, "conversationID"), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"conversation": conversation})
+	})
+
+	router.Delete("/v1/conversations/{conversationID}", func(w http.ResponseWriter, request *http.Request) {
+		if err := service.DeleteConversation(request.Context(), chi.URLParam(request, "conversationID")); err != nil {
+			writeError(w, err)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	router.Post("/v1/conversations/{conversationID}/participants", func(w http.ResponseWriter, request *http.Request) {
+		var input struct {
+			UserID string `json:"user_id"`
+		}
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		conversation, err := service.AddParticipant(request.Context(), chi.URLParam(request, "conversationID"), input.UserID)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusCreated, map[string]any{"conversation": conversation})
+	})
 
-			record, err := service.CreateRecord(request.Context(), input)
+	router.Delete("/v1/conversations/{conversationID}/participants/{userID}", func(w http.ResponseWriter, request *http.Request) {
+		if err := service.RemoveParticipant(request.Context(), chi.URLParam(request, "conversationID"), chi.URLParam(request, "userID")); err != nil {
+			writeError(w, err)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	router.Get("/v1/conversations/{conversationID}/messages", func(w http.ResponseWriter, request *http.Request) {
+		limit := 0
+		if rawLimit := strings.TrimSpace(request.URL.Query().Get("limit")); rawLimit != "" {
+			parsedLimit, err := strconv.Atoi(rawLimit)
 			if err != nil {
-				writeError(w, err)
+				writeError(w, &app.AppError{Status: http.StatusBadRequest, Code: "invalid_limit", Err: errors.New("limit must be a positive integer")})
 				return
 			}
-			writeJSON(w, http.StatusCreated, map[string]any{"record": record})
+			limit = parsedLimit
+		}
+		result, err := service.ListMessages(request.Context(), chi.URLParam(request, "conversationID"), app.ListMessagesInput{
+			Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
+			Limit:  limit,
 		})
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, result)
+	})
+
+	router.Post("/v1/conversations/{conversationID}/messages", func(w http.ResponseWriter, request *http.Request) {
+		var input app.CreateMessageInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		message, err := service.CreateMessage(request.Context(), chi.URLParam(request, "conversationID"), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusCreated, map[string]any{"message": message})
+	})
+
+	router.Patch("/v1/conversations/{conversationID}/messages/{messageID}", func(w http.ResponseWriter, request *http.Request) {
+		var input app.UpdateMessageInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		message, err := service.UpdateMessage(request.Context(), chi.URLParam(request, "conversationID"), chi.URLParam(request, "messageID"), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"message": message})
+	})
+
+	router.Delete("/v1/conversations/{conversationID}/messages/{messageID}", func(w http.ResponseWriter, request *http.Request) {
+		if err := service.DeleteMessage(request.Context(), chi.URLParam(request, "conversationID"), chi.URLParam(request, "messageID")); err != nil {
+			writeError(w, err)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	router.Post("/v1/attachments/uploads", func(w http.ResponseWriter, request *http.Request) {
+		var input app.CreateAttachmentUploadInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		result, err := service.CreateAttachmentUpload(request.Context(), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusCreated, map[string]any{"result": result})
+	})
+
+	router.Post("/v1/attachments/{attachmentID}/finalize", func(w http.ResponseWriter, request *http.Request) {
+		var input app.FinalizeAttachmentInput
+		if err := decodeOptionalJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		attachment, err := service.FinalizeAttachment(request.Context(), chi.URLParam(request, "attachmentID"), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"attachment": attachment})
+	})
+
+	router.Get("/v1/attachments/{attachmentID}", func(w http.ResponseWriter, request *http.Request) {
+		attachment, err := service.GetAttachment(request.Context(), chi.URLParam(request, "attachmentID"))
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"attachment": attachment})
+	})
+
+	router.Delete("/v1/attachments/{attachmentID}", func(w http.ResponseWriter, request *http.Request) {
+		if err := service.DeleteAttachment(request.Context(), chi.URLParam(request, "attachmentID")); err != nil {
+			writeError(w, err)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	router.Post("/webhooks/{provider}", func(w http.ResponseWriter, request *http.Request) {
+		rawBody, err := io.ReadAll(request.Body)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		event, duplicate, err := service.ProcessWebhook(request.Context(), chi.URLParam(request, "provider"), request.Header, rawBody)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		status := http.StatusAccepted
+		if duplicate {
+			status = http.StatusOK
+		}
+		writeJSON(w, status, map[string]any{"event": event, "duplicate": duplicate})
+	})
 
-		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)
-			})
+	router.Get("/webhooks/{provider}/health", func(w http.ResponseWriter, request *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]string{
+			"status":   "ok",
+			"provider": chi.URLParam(request, "provider"),
 		})
 	})
 }
 
 func decodeJSON(request *http.Request, out any) error {
 	defer request.Body.Close()
+	return json.NewDecoder(request.Body).Decode(out)
+}
 
-	if err := json.NewDecoder(request.Body).Decode(out); err != nil {
+func decodeOptionalJSON(request *http.Request, out any) error {
+	defer request.Body.Close()
+	decoder := json.NewDecoder(request.Body)
+	if err := decoder.Decode(out); err != nil && !errors.Is(err, io.EOF) {
 		return err
 	}
 	return nil
@@ -85,6 +278,15 @@ func writeJSON(w http.ResponseWriter, status int, payload any) {
 }
 
 func writeError(w http.ResponseWriter, err error) {
+	var appErr *app.AppError
+	if errors.As(err, &appErr) {
+		writeJSON(w, appErr.Status, map[string]string{
+			"error": appErr.Error(),
+			"code":  appErr.Code,
+		})
+		return
+	}
+
 	status := http.StatusInternalServerError
 	if errors.Is(err, strconv.ErrSyntax) || strings.Contains(strings.ToLower(err.Error()), "json") {
 		status = http.StatusBadRequest