create-svc 0.1.10 → 0.1.11

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

@@ -2,214 +2,114 @@ package connectapi
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
 	"net/http"
 
 	"connectrpc.com/connect"
 
-	chatv1 "{{MODULE_PATH}}/gen/chat/v1"
-	chatv1connect "{{MODULE_PATH}}/gen/chat/v1/chatv1connect"
+	waitlistv1 "{{MODULE_PATH}}/gen/waitlist/v1"
+	waitlistv1connect "{{MODULE_PATH}}/gen/waitlist/v1/waitlistv1connect"
 	"{{MODULE_PATH}}/internal/app"
 )
 
 type Handler struct {
-	service *app.ChatService
+	service *app.WaitlistService
 }
 
-func NewHandler(service *app.ChatService) (string, http.Handler) {
-	return chatv1connect.NewChatServiceHandler(&Handler{service: service})
+func NewHandler(service *app.WaitlistService) (string, http.Handler) {
+	return waitlistv1connect.NewWaitlistServiceHandler(&Handler{service: service})
 }
 
-func (h *Handler) CreateUser(ctx context.Context, request *connect.Request[chatv1.CreateUserRequest]) (*connect.Response[chatv1.CreateUserResponse], error) {
-	user, err := h.service.CreateUser(ctx, app.CreateUserInput{
-		Username:    request.Msg.GetUsername(),
-		DisplayName: request.Msg.GetDisplayName(),
+func (h *Handler) JoinWaitlist(ctx context.Context, request *connect.Request[waitlistv1.JoinWaitlistRequest]) (*connect.Response[waitlistv1.JoinWaitlistResponse], error) {
+	result, err := h.service.JoinWaitlist(ctx, app.JoinWaitlistInput{
+		Email:   request.Msg.GetEmail(),
+		Name:    request.Msg.GetName(),
+		Company: request.Msg.GetCompany(),
+		Source:  request.Msg.GetSource(),
 	})
 	if err != nil {
 		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(&chatv1.CreateUserResponse{User: toProtoUser(user)}), nil
-}
-
-func (h *Handler) GetUser(ctx context.Context, request *connect.Request[chatv1.GetUserRequest]) (*connect.Response[chatv1.GetUserResponse], error) {
-	user, err := h.service.GetUser(ctx, request.Msg.GetUserId())
-	if err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.GetUserResponse{User: toProtoUser(user)}), nil
-}
-
-func (h *Handler) GetUserByUsername(ctx context.Context, request *connect.Request[chatv1.GetUserByUsernameRequest]) (*connect.Response[chatv1.GetUserByUsernameResponse], error) {
-	user, err := h.service.GetUserByUsername(ctx, request.Msg.GetUsername())
-	if err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.GetUserByUsernameResponse{User: toProtoUser(user)}), nil
-}
-
-func (h *Handler) CreateConversation(ctx context.Context, request *connect.Request[chatv1.CreateConversationRequest]) (*connect.Response[chatv1.CreateConversationResponse], error) {
-	conversation, err := h.service.CreateConversation(ctx, app.CreateConversationInput{
-		CreatedByUserID:    request.Msg.GetCreatedByUserId(),
-		Title:              request.Msg.GetTitle(),
-		ParticipantUserIDs: request.Msg.GetParticipantUserIds(),
-	})
-	if err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.CreateConversationResponse{Conversation: toProtoConversation(conversation)}), nil
+	return connect.NewResponse(&waitlistv1.JoinWaitlistResponse{
+		Entry:   toProtoEntry(result.Entry),
+		Created: result.Created,
+	}), nil
 }
 
-func (h *Handler) GetConversation(ctx context.Context, request *connect.Request[chatv1.GetConversationRequest]) (*connect.Response[chatv1.GetConversationResponse], error) {
-	conversation, err := h.service.GetConversation(ctx, request.Msg.GetConversationId())
+func (h *Handler) GetWaitlistEntry(ctx context.Context, request *connect.Request[waitlistv1.GetWaitlistEntryRequest]) (*connect.Response[waitlistv1.GetWaitlistEntryResponse], error) {
+	entry, err := h.service.GetEntry(ctx, request.Msg.GetEntryId())
 	if err != nil {
 		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(&chatv1.GetConversationResponse{Conversation: toProtoConversation(conversation)}), nil
+	return connect.NewResponse(&waitlistv1.GetWaitlistEntryResponse{Entry: toProtoEntry(entry)}), nil
 }
 
-func (h *Handler) UpdateConversation(ctx context.Context, request *connect.Request[chatv1.UpdateConversationRequest]) (*connect.Response[chatv1.UpdateConversationResponse], error) {
-	conversation, err := h.service.UpdateConversation(ctx, request.Msg.GetConversationId(), app.UpdateConversationInput{
-		Title: request.Msg.GetTitle(),
-	})
+func (h *Handler) GetWaitlistEntryByEmail(ctx context.Context, request *connect.Request[waitlistv1.GetWaitlistEntryByEmailRequest]) (*connect.Response[waitlistv1.GetWaitlistEntryResponse], error) {
+	entry, err := h.service.GetEntryByEmail(ctx, request.Msg.GetEmail())
 	if err != nil {
 		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(&chatv1.UpdateConversationResponse{Conversation: toProtoConversation(conversation)}), nil
-}
-
-func (h *Handler) DeleteConversation(ctx context.Context, request *connect.Request[chatv1.DeleteConversationRequest]) (*connect.Response[chatv1.DeleteConversationResponse], error) {
-	if err := h.service.DeleteConversation(ctx, request.Msg.GetConversationId()); err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.DeleteConversationResponse{}), nil
+	return connect.NewResponse(&waitlistv1.GetWaitlistEntryResponse{Entry: toProtoEntry(entry)}), nil
 }
 
-func (h *Handler) AddConversationParticipant(ctx context.Context, request *connect.Request[chatv1.AddConversationParticipantRequest]) (*connect.Response[chatv1.AddConversationParticipantResponse], error) {
-	conversation, err := h.service.AddParticipant(ctx, request.Msg.GetConversationId(), request.Msg.GetUserId())
-	if err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.AddConversationParticipantResponse{Conversation: toProtoConversation(conversation)}), nil
-}
-
-func (h *Handler) RemoveConversationParticipant(ctx context.Context, request *connect.Request[chatv1.RemoveConversationParticipantRequest]) (*connect.Response[chatv1.RemoveConversationParticipantResponse], error) {
-	if err := h.service.RemoveParticipant(ctx, request.Msg.GetConversationId(), request.Msg.GetUserId()); err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.RemoveConversationParticipantResponse{}), nil
-}
-
-func (h *Handler) ListMessages(ctx context.Context, request *connect.Request[chatv1.ListMessagesRequest]) (*connect.Response[chatv1.ListMessagesResponse], error) {
-	result, err := h.service.ListMessages(ctx, request.Msg.GetConversationId(), app.ListMessagesInput{
-		Cursor: request.Msg.GetCursor(),
+func (h *Handler) ListWaitlistEntries(ctx context.Context, request *connect.Request[waitlistv1.ListWaitlistEntriesRequest]) (*connect.Response[waitlistv1.ListWaitlistEntriesResponse], error) {
+	entries, err := h.service.ListEntries(ctx, app.ListWaitlistEntriesInput{
+		Status: request.Msg.GetStatus(),
 		Limit:  int(request.Msg.GetLimit()),
 	})
 	if err != nil {
 		return nil, toConnectError(err)
 	}
-	items := make([]*chatv1.Message, 0, len(result.Messages))
-	for _, message := range result.Messages {
-		items = append(items, toProtoMessage(message))
-	}
-	return connect.NewResponse(&chatv1.ListMessagesResponse{
-		Messages:   items,
-		NextCursor: result.NextCursor,
-	}), nil
-}
-
-func (h *Handler) CreateMessage(ctx context.Context, request *connect.Request[chatv1.CreateMessageRequest]) (*connect.Response[chatv1.CreateMessageResponse], error) {
-	message, err := h.service.CreateMessage(ctx, request.Msg.GetConversationId(), app.CreateMessageInput{
-		UserID: request.Msg.GetUserId(),
-		Body:   request.Msg.GetBody(),
-	})
-	if err != nil {
-		return nil, toConnectError(err)
+	response := &waitlistv1.ListWaitlistEntriesResponse{Entries: make([]*waitlistv1.WaitlistEntry, 0, len(entries))}
+	for _, entry := range entries {
+		response.Entries = append(response.Entries, toProtoEntry(entry))
 	}
-	return connect.NewResponse(&chatv1.CreateMessageResponse{Message: toProtoMessage(message)}), nil
+	return connect.NewResponse(response), nil
 }
 
-func (h *Handler) UpdateMessage(ctx context.Context, request *connect.Request[chatv1.UpdateMessageRequest]) (*connect.Response[chatv1.UpdateMessageResponse], error) {
-	message, err := h.service.UpdateMessage(ctx, request.Msg.GetConversationId(), request.Msg.GetMessageId(), app.UpdateMessageInput{
-		Body: request.Msg.GetBody(),
+func (h *Handler) UpdateWaitlistEntry(ctx context.Context, request *connect.Request[waitlistv1.UpdateWaitlistEntryRequest]) (*connect.Response[waitlistv1.GetWaitlistEntryResponse], error) {
+	entry, err := h.service.UpdateEntry(ctx, app.UpdateWaitlistEntryInput{
+		EntryID: request.Msg.GetEntryId(),
+		Status:  request.Msg.GetStatus(),
 	})
 	if err != nil {
 		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(&chatv1.UpdateMessageResponse{Message: toProtoMessage(message)}), nil
+	return connect.NewResponse(&waitlistv1.GetWaitlistEntryResponse{Entry: toProtoEntry(entry)}), nil
 }
 
-func (h *Handler) DeleteMessage(ctx context.Context, request *connect.Request[chatv1.DeleteMessageRequest]) (*connect.Response[chatv1.DeleteMessageResponse], error) {
-	if err := h.service.DeleteMessage(ctx, request.Msg.GetConversationId(), request.Msg.GetMessageId()); err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.DeleteMessageResponse{}), nil
-}
-
-func (h *Handler) CreateAttachmentUpload(ctx context.Context, request *connect.Request[chatv1.CreateAttachmentUploadRequest]) (*connect.Response[chatv1.CreateAttachmentUploadResponse], error) {
-	result, err := h.service.CreateAttachmentUpload(ctx, app.CreateAttachmentUploadInput{
-		ConversationID:   request.Msg.GetConversationId(),
-		UploadedByUserID: request.Msg.GetUserId(),
-		Filename:         request.Msg.GetFilename(),
-		ContentType:      request.Msg.GetContentType(),
-		ByteSize:         request.Msg.GetByteSize(),
+func (h *Handler) ExportWaitlistEntries(ctx context.Context, request *connect.Request[waitlistv1.ExportWaitlistEntriesRequest]) (*connect.Response[waitlistv1.ExportWaitlistEntriesResponse], error) {
+	csv, err := h.service.ExportEntries(ctx, app.ListWaitlistEntriesInput{
+		Status: request.Msg.GetStatus(),
+		Limit:  int(request.Msg.GetLimit()),
 	})
 	if err != nil {
 		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(&chatv1.CreateAttachmentUploadResponse{
-		Attachment: toProtoAttachment(result.Attachment),
-		Upload: &chatv1.UploadTarget{
-			Method:  result.Upload.Method,
-			Url:     result.Upload.URL,
-			Headers: result.Upload.Headers,
-		},
-	}), nil
+	return connect.NewResponse(&waitlistv1.ExportWaitlistEntriesResponse{Csv: csv}), nil
 }
 
-func (h *Handler) FinalizeAttachment(ctx context.Context, request *connect.Request[chatv1.FinalizeAttachmentRequest]) (*connect.Response[chatv1.FinalizeAttachmentResponse], error) {
-	attachment, err := h.service.FinalizeAttachment(ctx, request.Msg.GetAttachmentId(), app.FinalizeAttachmentInput{
-		MessageID: request.Msg.GetMessageId(),
+func (h *Handler) RecordTrigger(ctx context.Context, request *connect.Request[waitlistv1.RecordTriggerRequest]) (*connect.Response[waitlistv1.RecordTriggerResponse], error) {
+	trigger, err := h.service.RecordTrigger(ctx, app.RecordTriggerInput{
+		Type:    request.Msg.GetType(),
+		EntryID: request.Msg.GetEntryId(),
+		Payload: jsonPayload(request.Msg.GetPayloadJson()),
 	})
 	if err != nil {
 		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(&chatv1.FinalizeAttachmentResponse{Attachment: toProtoAttachment(attachment)}), nil
-}
-
-func (h *Handler) GetAttachment(ctx context.Context, request *connect.Request[chatv1.GetAttachmentRequest]) (*connect.Response[chatv1.GetAttachmentResponse], error) {
-	attachment, err := h.service.GetAttachment(ctx, request.Msg.GetAttachmentId())
-	if err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.GetAttachmentResponse{Attachment: toProtoAttachment(attachment)}), nil
-}
-
-func (h *Handler) DeleteAttachment(ctx context.Context, request *connect.Request[chatv1.DeleteAttachmentRequest]) (*connect.Response[chatv1.DeleteAttachmentResponse], error) {
-	if err := h.service.DeleteAttachment(ctx, request.Msg.GetAttachmentId()); err != nil {
-		return nil, toConnectError(err)
-	}
-	return connect.NewResponse(&chatv1.DeleteAttachmentResponse{}), nil
+	return connect.NewResponse(&waitlistv1.RecordTriggerResponse{Trigger: toProtoTrigger(trigger)}), nil
 }
 
 func toConnectError(err error) error {
 	var appErr *app.AppError
-	if ok := asAppError(err, &appErr); ok {
+	if errors.As(err, &appErr) {
 		return connect.NewError(statusCodeToConnectCode(appErr.Status), err)
 	}
 	return connect.NewError(connect.CodeInternal, err)
 }
 
-func asAppError(err error, target **app.AppError) bool {
-	if err == nil {
-		return false
-	}
-	appErr, ok := err.(*app.AppError)
-	if ok {
-		*target = appErr
-		return true
-	}
-	return false
-}
-
 func statusCodeToConnectCode(status int) connect.Code {
 	switch status {
 	case 400:
@@ -223,69 +123,46 @@ func statusCodeToConnectCode(status int) connect.Code {
 	}
 }
 
-func toProtoUser(user app.User) *chatv1.User {
-	return &chatv1.User{
-		Id:          user.ID,
-		Username:    user.Username,
-		DisplayName: user.DisplayName,
-		CreatedAt:   user.CreatedAt,
-		UpdatedAt:   user.UpdatedAt,
+func toProtoEntry(entry app.WaitlistEntry) *waitlistv1.WaitlistEntry {
+	return &waitlistv1.WaitlistEntry{
+		Id:        entry.ID,
+		Email:     entry.Email,
+		Name:      entry.Name,
+		Company:   entry.Company,
+		Source:    entry.Source,
+		Status:    entry.Status,
+		CreatedAt: entry.CreatedAt,
+		UpdatedAt: entry.UpdatedAt,
 	}
 }
 
-func toProtoConversation(conversation app.Conversation) *chatv1.Conversation {
-	participants := make([]*chatv1.User, 0, len(conversation.Participants))
-	for _, participant := range conversation.Participants {
-		participants = append(participants, toProtoUser(participant))
-	}
-	return &chatv1.Conversation{
-		Id:              conversation.ID,
-		Title:           conversation.Title,
-		CreatedByUserId: conversation.CreatedByUserID,
-		Participants:    participants,
-		CreatedAt:       conversation.CreatedAt,
-		UpdatedAt:       conversation.UpdatedAt,
+func toProtoTrigger(trigger app.WaitlistTrigger) *waitlistv1.WaitlistTrigger {
+	return &waitlistv1.WaitlistTrigger{
+		Id:          trigger.ID,
+		Type:        trigger.Type,
+		EntryId:     trigger.EntryID,
+		Status:      trigger.Status,
+		PayloadJson: payloadToJSON(trigger.Payload),
+		CreatedAt:   trigger.CreatedAt,
+		ProcessedAt: trigger.ProcessedAt,
 	}
 }
 
-func toProtoMessage(message app.Message) *chatv1.Message {
-	attachments := make([]*chatv1.MessageAttachment, 0, len(message.Attachments))
-	for _, attachment := range message.Attachments {
-		attachments = append(attachments, &chatv1.MessageAttachment{
-			Id:          attachment.ID,
-			Filename:    attachment.Filename,
-			ContentType: attachment.ContentType,
-			ByteSize:    attachment.ByteSize,
-			Status:      attachment.Status,
-			PublicUrl:   attachment.PublicURL,
-		})
+func jsonPayload(value string) any {
+	if value == "" {
+		return map[string]any{}
 	}
-	return &chatv1.Message{
-		Id:             message.ID,
-		ConversationId: message.ConversationID,
-		UserId:         message.UserID,
-		Body:           message.Body,
-		EditedAt:       message.EditedAt,
-		CreatedAt:      message.CreatedAt,
-		UpdatedAt:      message.UpdatedAt,
-		Attachments:    attachments,
+	var payload any
+	if err := json.Unmarshal([]byte(value), &payload); err != nil {
+		return map[string]any{}
 	}
+	return payload
 }
 
-func toProtoAttachment(attachment app.Attachment) *chatv1.Attachment {
-	return &chatv1.Attachment{
-		Id:               attachment.ID,
-		ConversationId:   attachment.ConversationID,
-		MessageId:        attachment.MessageID,
-		UploadedByUserId: attachment.UploadedByUserID,
-		StorageBucket:    attachment.StorageBucket,
-		StorageKey:       attachment.StorageKey,
-		ContentType:      attachment.ContentType,
-		ByteSize:         attachment.ByteSize,
-		Filename:         attachment.Filename,
-		Status:           attachment.Status,
-		PublicUrl:        attachment.PublicURL,
-		CreatedAt:        attachment.CreatedAt,
-		UpdatedAt:        attachment.UpdatedAt,
+func payloadToJSON(value any) string {
+	encoded, err := json.Marshal(value)
+	if err != nil {
+		return "{}"
 	}
+	return string(encoded)
 }

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

@@ -0,0 +1,122 @@
+package connectapi
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"connectrpc.com/connect"
+	_ "github.com/jackc/pgx/v5/stdlib"
+
+	waitlistv1 "{{MODULE_PATH}}/gen/waitlist/v1"
+	waitlistv1connect "{{MODULE_PATH}}/gen/waitlist/v1/waitlistv1connect"
+	"{{MODULE_PATH}}/internal/app"
+)
+
+func TestWaitlistRPCJoinIsIdempotentAndRecordsTriggers(t *testing.T) {
+	databaseURL := strings.TrimSpace(os.Getenv("DATABASE_URL"))
+	if databaseURL == "" {
+		t.Skip("DATABASE_URL is required for integration 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
+  waitlist_triggers,
+  waitlist_entries
+restart identity cascade`); err != nil {
+		t.Fatalf("truncate tables: %v", err)
+	}
+
+	service := app.NewWaitlistService(db)
+	path, handler := NewHandler(service)
+	mux := http.NewServeMux()
+	mux.Handle(path, handler)
+	server := httptest.NewServer(mux)
+	t.Cleanup(server.Close)
+
+	client := waitlistv1connect.NewWaitlistServiceClient(http.DefaultClient, server.URL)
+
+	first, err := client.JoinWaitlist(context.Background(), connect.NewRequest(&waitlistv1.JoinWaitlistRequest{
+		Email:   "Founder@Example.com",
+		Name:    "Founder",
+		Company: "Example Co",
+		Source:  "homepage",
+	}))
+	if err != nil {
+		t.Fatalf("join waitlist: %v", err)
+	}
+	if !first.Msg.GetCreated() {
+		t.Fatal("expected first join to create entry")
+	}
+	if first.Msg.GetEntry().GetEmail() != "founder@example.com" {
+		t.Fatalf("expected normalized email, got %s", first.Msg.GetEntry().GetEmail())
+	}
+
+	second, err := client.JoinWaitlist(context.Background(), connect.NewRequest(&waitlistv1.JoinWaitlistRequest{
+		Email: "founder@example.com",
+	}))
+	if err != nil {
+		t.Fatalf("join waitlist again: %v", err)
+	}
+	if second.Msg.GetCreated() {
+		t.Fatal("expected second join to be idempotent")
+	}
+	if second.Msg.GetEntry().GetId() != first.Msg.GetEntry().GetId() {
+		t.Fatalf("expected same entry id, got %s and %s", first.Msg.GetEntry().GetId(), second.Msg.GetEntry().GetId())
+	}
+
+	trigger, err := client.RecordTrigger(context.Background(), connect.NewRequest(&waitlistv1.RecordTriggerRequest{
+		Type:        "cron.digest",
+		EntryId:     first.Msg.GetEntry().GetId(),
+		PayloadJson: "{}",
+	}))
+	if err != nil {
+		t.Fatalf("record trigger: %v", err)
+	}
+	if trigger.Msg.GetTrigger().GetType() != "cron.digest" {
+		t.Fatalf("expected cron.digest trigger, got %s", trigger.Msg.GetTrigger().GetType())
+	}
+	if trigger.Msg.GetTrigger().GetEntryId() != first.Msg.GetEntry().GetId() {
+		t.Fatalf("expected entry id %s, got %s", first.Msg.GetEntry().GetId(), trigger.Msg.GetTrigger().GetEntryId())
+	}
+
+	updated, err := client.UpdateWaitlistEntry(context.Background(), connect.NewRequest(&waitlistv1.UpdateWaitlistEntryRequest{
+		EntryId: first.Msg.GetEntry().GetId(),
+		Status:  "invited",
+	}))
+	if err != nil {
+		t.Fatalf("update waitlist entry: %v", err)
+	}
+	if updated.Msg.GetEntry().GetStatus() != "invited" {
+		t.Fatalf("expected invited status, got %s", updated.Msg.GetEntry().GetStatus())
+	}
+
+	list, err := client.ListWaitlistEntries(context.Background(), connect.NewRequest(&waitlistv1.ListWaitlistEntriesRequest{
+		Status: "invited",
+	}))
+	if err != nil {
+		t.Fatalf("list waitlist entries: %v", err)
+	}
+	if len(list.Msg.GetEntries()) != 1 || list.Msg.GetEntries()[0].GetId() != first.Msg.GetEntry().GetId() {
+		t.Fatalf("expected one invited entry %s, got %+v", first.Msg.GetEntry().GetId(), list.Msg.GetEntries())
+	}
+
+	exported, err := client.ExportWaitlistEntries(context.Background(), connect.NewRequest(&waitlistv1.ExportWaitlistEntriesRequest{
+		Status: "invited",
+	}))
+	if err != nil {
+		t.Fatalf("export waitlist entries: %v", err)
+	}
+	if !strings.Contains(exported.Msg.GetCsv(), "founder@example.com") {
+		t.Fatalf("expected exported csv to contain email, got %s", exported.Msg.GetCsv())
+	}
+}