create-svc 0.1.10 → 0.1.12

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

@@ -13,7 +13,7 @@ import (
 	"{{MODULE_PATH}}/internal/app"
 )
 
-func RegisterRoutes(router chi.Router, service *app.ChatService) {
+func RegisterRoutes(router chi.Router, service *app.WaitlistService) {
 	router.Get("/healthz", func(w http.ResponseWriter, _ *http.Request) {
 		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
 	})
@@ -23,212 +23,105 @@ func RegisterRoutes(router chi.Router, service *app.ChatService) {
 	router.Get("/", func(w http.ResponseWriter, _ *http.Request) {
 		writeJSON(w, http.StatusOK, map[string]string{
 			"service":   "{{SERVICE_NAME}}",
-			"domain":    "chat",
+			"domain":    "waitlist",
 			"apiOrigin": "https://api.{{SERVICE_NAME}}.anmho.com",
 		})
 	})
 
-	router.Post("/v1/users", func(w http.ResponseWriter, request *http.Request) {
-		var input app.CreateUserInput
+	router.Post("/v1/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		var input app.JoinWaitlistInput
 		if err := decodeJSON(request, &input); err != nil {
 			writeError(w, err)
 			return
 		}
-		user, err := service.CreateUser(request.Context(), input)
+		result, err := service.JoinWaitlist(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
+		status := http.StatusOK
+		if result.Created {
+			status = http.StatusCreated
 		}
-		writeJSON(w, http.StatusOK, map[string]any{"user": user})
+		writeJSON(w, status, result)
 	})
 
-	router.Get("/v1/users", func(w http.ResponseWriter, request *http.Request) {
-		user, err := service.GetUserByUsername(request.Context(), request.URL.Query().Get("username"))
+	router.Get("/v1/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		entry, err := service.GetEntryByEmail(request.Context(), request.URL.Query().Get("email"))
 		if err != nil {
 			writeError(w, err)
 			return
 		}
-		writeJSON(w, http.StatusOK, map[string]any{"user": user})
+		writeJSON(w, http.StatusOK, map[string]any{"entry": entry})
 	})
 
-	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)
+	router.Get("/v1/waitlist/{entryID}", func(w http.ResponseWriter, request *http.Request) {
+		entry, err := service.GetEntry(request.Context(), chi.URLParam(request, "entryID"))
 		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})
-	})
-
-	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)
+		writeJSON(w, http.StatusOK, map[string]any{"entry": entry})
 	})
 
-	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, &app.AppError{Status: http.StatusBadRequest, Code: "invalid_limit", Err: errors.New("limit must be a positive integer")})
-				return
-			}
-			limit = parsedLimit
-		}
-		result, err := service.ListMessages(request.Context(), chi.URLParam(request, "conversationID"), app.ListMessagesInput{
-			Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
-			Limit:  limit,
+	router.Get("/v1/admin/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		entries, err := service.ListEntries(request.Context(), app.ListWaitlistEntriesInput{
+			Status: request.URL.Query().Get("status"),
+			Limit:  optionalInt(request.URL.Query().Get("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})
+		writeJSON(w, http.StatusOK, map[string]any{"entries": entries})
 	})
 
-	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)
+	router.Get("/v1/admin/waitlist/export", func(w http.ResponseWriter, request *http.Request) {
+		csv, err := service.ExportEntries(request.Context(), app.ListWaitlistEntriesInput{
+			Status: request.URL.Query().Get("status"),
+			Limit:  optionalInt(request.URL.Query().Get("limit")),
+		})
 		if err != nil {
 			writeError(w, err)
 			return
 		}
-		writeJSON(w, http.StatusOK, map[string]any{"message": message})
+		w.Header().Set("Content-Type", "text/csv; charset=utf-8")
+		w.Header().Set("Content-Disposition", `attachment; filename="waitlist.csv"`)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(csv))
 	})
 
-	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
+	router.Patch("/v1/admin/waitlist/{entryID}", func(w http.ResponseWriter, request *http.Request) {
+		var input app.UpdateWaitlistEntryInput
 		if err := decodeJSON(request, &input); err != nil {
 			writeError(w, err)
 			return
 		}
-		result, err := service.CreateAttachmentUpload(request.Context(), input)
+		input.EntryID = chi.URLParam(request, "entryID")
+		entry, err := service.UpdateEntry(request.Context(), input)
 		if err != nil {
 			writeError(w, err)
 			return
 		}
-		writeJSON(w, http.StatusCreated, map[string]any{"result": result})
+		writeJSON(w, http.StatusOK, map[string]any{"entry": entry})
 	})
 
-	router.Post("/v1/attachments/{attachmentID}/finalize", func(w http.ResponseWriter, request *http.Request) {
-		var input app.FinalizeAttachmentInput
-		if err := decodeOptionalJSON(request, &input); err != nil {
+	router.Post("/v1/triggers/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		var payload map[string]any
+		if err := decodeOptionalJSON(request, &payload); 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"))
+		trigger, err := service.RecordTrigger(request.Context(), app.RecordTriggerInput{
+			Type:    stringValue(payload, "type", "manual"),
+			EntryID: stringValue(payload, "entry_id", ""),
+			Payload: payload,
+		})
 		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)
+		writeJSON(w, http.StatusAccepted, map[string]any{"trigger": trigger})
 	})
 
 	router.Post("/webhooks/{provider}", func(w http.ResponseWriter, request *http.Request) {
@@ -237,16 +130,18 @@ func RegisterRoutes(router chi.Router, service *app.ChatService) {
 			writeError(w, err)
 			return
 		}
-		event, duplicate, err := service.ProcessWebhook(request.Context(), chi.URLParam(request, "provider"), request.Header, rawBody)
+		trigger, err := service.RecordTrigger(request.Context(), app.RecordTriggerInput{
+			Type: "webhook." + chi.URLParam(request, "provider"),
+			Payload: map[string]any{
+				"headers": request.Header,
+				"rawBody": string(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})
+		writeJSON(w, http.StatusAccepted, map[string]any{"trigger": trigger})
 	})
 
 	router.Get("/webhooks/{provider}/health", func(w http.ResponseWriter, request *http.Request) {
@@ -288,8 +183,34 @@ func writeError(w http.ResponseWriter, err error) {
 	}
 
 	status := http.StatusInternalServerError
-	if errors.Is(err, strconv.ErrSyntax) || strings.Contains(strings.ToLower(err.Error()), "json") {
+	if strings.Contains(strings.ToLower(err.Error()), "json") {
 		status = http.StatusBadRequest
 	}
 	writeJSON(w, status, map[string]string{"error": err.Error()})
 }
+
+func stringValue(values map[string]any, key string, fallback string) string {
+	if values == nil {
+		return fallback
+	}
+	value, ok := values[key]
+	if !ok && key == "entry_id" {
+		value, ok = values["entryId"]
+	}
+	if !ok {
+		return fallback
+	}
+	text, ok := value.(string)
+	if !ok {
+		return fallback
+	}
+	return strings.TrimSpace(text)
+}
+
+func optionalInt(value string) int {
+	parsed, err := strconv.Atoi(strings.TrimSpace(value))
+	if err != nil {
+		return 0
+	}
+	return parsed
+}

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

@@ -0,0 +1,199 @@
+package httpapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/go-chi/chi/v5"
+	_ "github.com/jackc/pgx/v5/stdlib"
+
+	"{{MODULE_PATH}}/internal/app"
+)
+
+func TestWaitlistJoinIsIdempotentAndRecordsTriggers(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)
+	router := chi.NewRouter()
+	RegisterRoutes(router, service)
+	server := httptest.NewServer(router)
+	t.Cleanup(server.Close)
+
+	first := joinWaitlist(t, server.URL, "Founder@Example.com")
+	if first.Created != true {
+		t.Fatal("expected first join to create entry")
+	}
+	if first.Entry.Email != "founder@example.com" {
+		t.Fatalf("expected normalized email, got %s", first.Entry.Email)
+	}
+
+	second := joinWaitlist(t, server.URL, "founder@example.com")
+	if second.Created {
+		t.Fatal("expected second join to be idempotent")
+	}
+	if second.Entry.ID != first.Entry.ID {
+		t.Fatalf("expected same entry id, got %s and %s", first.Entry.ID, second.Entry.ID)
+	}
+
+	trigger := recordTrigger(t, server.URL, first.Entry.ID)
+	if trigger.Trigger.Type != "cron.digest" {
+		t.Fatalf("expected cron.digest trigger, got %s", trigger.Trigger.Type)
+	}
+	if trigger.Trigger.EntryID != first.Entry.ID {
+		t.Fatalf("expected trigger entry id %s, got %s", first.Entry.ID, trigger.Trigger.EntryID)
+	}
+
+	updated := updateEntry(t, server.URL, first.Entry.ID, "invited")
+	if updated.Entry.Status != "invited" {
+		t.Fatalf("expected invited status, got %s", updated.Entry.Status)
+	}
+
+	list := listEntries(t, server.URL, "invited")
+	if len(list.Entries) != 1 || list.Entries[0].ID != first.Entry.ID {
+		t.Fatalf("expected one invited entry %s, got %+v", first.Entry.ID, list.Entries)
+	}
+
+	exported := exportEntries(t, server.URL, "invited")
+	if !strings.Contains(exported, "founder@example.com") {
+		t.Fatalf("expected exported csv to contain email, got %s", exported)
+	}
+}
+
+type joinResponse struct {
+	Entry   app.WaitlistEntry `json:"entry"`
+	Created bool              `json:"created"`
+}
+
+type triggerResponse struct {
+	Trigger app.WaitlistTrigger `json:"trigger"`
+}
+
+type entryResponse struct {
+	Entry app.WaitlistEntry `json:"entry"`
+}
+
+type listResponse struct {
+	Entries []app.WaitlistEntry `json:"entries"`
+}
+
+func joinWaitlist(t *testing.T, baseURL string, email string) joinResponse {
+	t.Helper()
+	body := bytes.NewBufferString(`{"email":` + quoteJSON(email) + `,"name":"Founder","company":"Example Co","source":"homepage"}`)
+	response, err := http.Post(baseURL+"/v1/waitlist", "application/json", body)
+	if err != nil {
+		t.Fatalf("join waitlist: %v", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusCreated && response.StatusCode != http.StatusOK {
+		t.Fatalf("expected success, got %d", response.StatusCode)
+	}
+	var payload joinResponse
+	if err := json.NewDecoder(response.Body).Decode(&payload); err != nil {
+		t.Fatalf("decode join response: %v", err)
+	}
+	return payload
+}
+
+func recordTrigger(t *testing.T, baseURL string, entryID string) triggerResponse {
+	t.Helper()
+	body := bytes.NewBufferString(`{"type":"cron.digest","entry_id":` + quoteJSON(entryID) + `}`)
+	response, err := http.Post(baseURL+"/v1/triggers/waitlist", "application/json", body)
+	if err != nil {
+		t.Fatalf("record trigger: %v", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusAccepted {
+		t.Fatalf("expected 202, got %d", response.StatusCode)
+	}
+	var payload triggerResponse
+	if err := json.NewDecoder(response.Body).Decode(&payload); err != nil {
+		t.Fatalf("decode trigger response: %v", err)
+	}
+	return payload
+}
+
+func updateEntry(t *testing.T, baseURL string, entryID string, status string) entryResponse {
+	t.Helper()
+	body := bytes.NewBufferString(`{"status":` + quoteJSON(status) + `}`)
+	request, err := http.NewRequest(http.MethodPatch, baseURL+"/v1/admin/waitlist/"+entryID, body)
+	if err != nil {
+		t.Fatalf("build update entry request: %v", err)
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := http.DefaultClient.Do(request)
+	if err != nil {
+		t.Fatalf("update entry: %v", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		t.Fatalf("expected 200, got %d", response.StatusCode)
+	}
+	var payload entryResponse
+	if err := json.NewDecoder(response.Body).Decode(&payload); err != nil {
+		t.Fatalf("decode update response: %v", err)
+	}
+	return payload
+}
+
+func listEntries(t *testing.T, baseURL string, status string) listResponse {
+	t.Helper()
+	response, err := http.Get(baseURL + "/v1/admin/waitlist?status=" + status)
+	if err != nil {
+		t.Fatalf("list entries: %v", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		t.Fatalf("expected 200, got %d", response.StatusCode)
+	}
+	var payload listResponse
+	if err := json.NewDecoder(response.Body).Decode(&payload); err != nil {
+		t.Fatalf("decode list response: %v", err)
+	}
+	return payload
+}
+
+func exportEntries(t *testing.T, baseURL string, status string) string {
+	t.Helper()
+	response, err := http.Get(baseURL + "/v1/admin/waitlist/export?status=" + status)
+	if err != nil {
+		t.Fatalf("export entries: %v", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		t.Fatalf("expected 200, got %d", response.StatusCode)
+	}
+	raw, err := io.ReadAll(response.Body)
+	if err != nil {
+		t.Fatalf("read export response: %v", err)
+	}
+	return string(raw)
+}
+
+func quoteJSON(value string) string {
+	encoded, _ := json.Marshal(value)
+	return string(encoded)
+}

package/templates/variants/go-chi/internal/temporal/activities.go

@@ -0,0 +1,27 @@
+package temporalapp
+
+import "context"
+
+type WaitlistFollowUpInput struct {
+	TriggerID string
+	Email     string
+	Type      string
+}
+
+type WaitlistFollowUpResult struct {
+	Status    string
+	TriggerID string
+	Email     string
+	Type      string
+}
+
+type Activities struct{}
+
+func (a *Activities) RecordWaitlistFollowUp(ctx context.Context, input WaitlistFollowUpInput) (WaitlistFollowUpResult, error) {
+	return WaitlistFollowUpResult{
+		Status:    "queued",
+		TriggerID: input.TriggerID,
+		Email:     input.Email,
+		Type:      input.Type,
+	}, nil
+}

package/templates/variants/go-chi/internal/temporal/worker.go

@@ -0,0 +1,42 @@
+package temporalapp
+
+import (
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/worker"
+)
+
+type WorkerConfig struct {
+	Address   string
+	Namespace string
+	TaskQueue string
+	APIKey    string
+}
+
+func StartWorker(cfg WorkerConfig) (func(), error) {
+	options := client.Options{
+		HostPort:  cfg.Address,
+		Namespace: cfg.Namespace,
+	}
+	if cfg.APIKey != "" {
+		options.Credentials = client.NewAPIKeyStaticCredentials(cfg.APIKey)
+	}
+
+	temporalClient, err := client.Dial(options)
+	if err != nil {
+		return nil, err
+	}
+
+	temporalWorker := worker.New(temporalClient, cfg.TaskQueue, worker.Options{})
+	temporalWorker.RegisterWorkflow(WaitlistFollowUpWorkflow)
+	temporalWorker.RegisterActivity(&Activities{})
+
+	if err := temporalWorker.Start(); err != nil {
+		temporalClient.Close()
+		return nil, err
+	}
+
+	return func() {
+		temporalWorker.Stop()
+		temporalClient.Close()
+	}, nil
+}

package/templates/variants/go-chi/internal/temporal/workflows.go

@@ -0,0 +1,18 @@
+package temporalapp
+
+import (
+	"time"
+
+	"go.temporal.io/sdk/workflow"
+)
+
+func WaitlistFollowUpWorkflow(ctx workflow.Context, input WaitlistFollowUpInput) (WaitlistFollowUpResult, error) {
+	options := workflow.ActivityOptions{
+		StartToCloseTimeout: time.Minute,
+	}
+	ctx = workflow.WithActivityOptions(ctx, options)
+
+	var result WaitlistFollowUpResult
+	err := workflow.ExecuteActivity(ctx, "RecordWaitlistFollowUp", input).Get(ctx, &result)
+	return result, err
+}

package/templates/variants/go-chi/migrations/0000_init.sql

@@ -1,63 +1,20 @@
-create table if not exists users (
+create table if not exists waitlist_entries (
   id text primary key,
-  username text not null unique,
-  display_name text,
+  email text not null unique,
+  name text,
+  company text,
+  source text,
+  status text not null default 'joined',
   created_at timestamptz not null default now(),
   updated_at timestamptz not null default now()
 );
 
-create table if not exists conversations (
+create table if not exists waitlist_triggers (
   id text primary key,
-  title text,
-  created_by_user_id text not null references users(id),
-  deleted_at timestamptz,
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists conversation_participants (
-  conversation_id text not null references conversations(id),
-  user_id text not null references users(id),
-  joined_at timestamptz not null default now(),
-  primary key (conversation_id, user_id)
-);
-
-create table if not exists messages (
-  id text primary key,
-  conversation_id text not null references conversations(id),
-  user_id text not null references users(id),
-  body text not null,
-  edited_at timestamptz,
-  deleted_at timestamptz,
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists attachments (
-  id text primary key,
-  conversation_id text not null references conversations(id),
-  message_id text references messages(id),
-  uploaded_by_user_id text not null references users(id),
-  storage_bucket text not null,
-  storage_key text not null,
-  content_type text not null,
-  byte_size bigint not null,
-  filename text not null,
-  status text not null,
-  deleted_at timestamptz,
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists webhook_events (
-  id text primary key,
-  provider text not null,
-  external_event_id text not null,
-  event_type text not null,
-  signature_valid text not null,
-  status text not null,
+  type text not null,
+  entry_id text references waitlist_entries(id),
+  status text not null default 'queued',
   payload_json text not null,
-  received_at timestamptz not null default now(),
-  processed_at timestamptz,
-  unique (provider, external_event_id)
+  created_at timestamptz not null default now(),
+  processed_at timestamptz
 );