create-svc 0.1.10 → 0.1.11

package/templates/variants/bun-hono/test/list-messages.integration.test.ts

@@ -1,256 +0,0 @@
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import { SQL } from "bun";
-import { createApp } from "../src/index";
-import { DefaultChatService } from "../src/chat/service";
-import { ChatRepository } from "../src/db/repository";
-import { createDb } from "../src/db/client";
-import type { AttachmentObjectMetadata, AttachmentUploadTarget } from "../src/chat/types";
-import type { AttachmentStorage } from "../src/storage";
-
-const databaseUrl = Bun.env.DATABASE_URL?.trim();
-const integrationTest = databaseUrl ? test : test.skip;
-
-let sql: SQL | null = null;
-
-beforeEach(async () => {
-  if (!databaseUrl) {
-    return;
-  }
-  sql = new SQL(databaseUrl);
-  await sql.unsafe(`
-    truncate table
-      webhook_events,
-      attachments,
-      messages,
-      conversation_participants,
-      conversations,
-      users
-    restart identity cascade
-  `);
-});
-
-afterEach(async () => {
-  await sql?.end();
-  sql = null;
-});
-
-integrationTest("list messages returns newest-first pages with attachment metadata", async () => {
-  Bun.env.ATTACHMENT_PUBLIC_BASE_URL = "https://storage.test";
-  const storage = new FakeAttachmentStorage();
-  const app = createApp(new DefaultChatService(new ChatRepository(createDb(databaseUrl)), storage, new NoopWebhookAdapter()));
-
-  const user = await createUser(app);
-  const conversation = await createConversation(app, user.id);
-  const messageIds: string[] = [];
-
-  for (let index = 1; index <= 55; index += 1) {
-    const message = await createMessage(app, conversation.id, user.id, `message-${index}`);
-    messageIds.push(message.id);
-  }
-
-  await rewriteMessageTimestamps(messageIds);
-
-  const uploadResult = await requestJson(app, "/v1/attachments/uploads", {
-    method: "POST",
-    body: {
-      conversation_id: conversation.id,
-      user_id: user.id,
-      filename: "photo.png",
-      content_type: "image/png",
-      byte_size: 1234,
-    },
-    expectedStatus: 201,
-  });
-  const attachment = uploadResult.result.attachment as {
-    id: string;
-    publicUrl: string;
-    filename: string;
-    contentType: string;
-    byteSize: number;
-    status: string;
-  };
-
-  storage.setObjectMetadataFromUrl(uploadResult.result.attachment.publicUrl, {
-    contentType: "image/png",
-    byteSize: 1234,
-    publicUrl: uploadResult.result.attachment.publicUrl,
-  });
-
-  await requestJson(app, `/v1/attachments/${attachment.id}/finalize`, {
-    method: "POST",
-    body: {
-      message_id: messageIds[54],
-    },
-  });
-
-  const firstPage = await requestJson(app, `/v1/conversations/${conversation.id}/messages`);
-  expect(firstPage.messages).toHaveLength(50);
-  expect(firstPage.messages[0].body).toBe("message-55");
-  expect(firstPage.messages[49].body).toBe("message-6");
-  expect(firstPage.next_cursor).toBeString();
-  expect(firstPage.messages[0].attachments).toEqual([
-    {
-      id: attachment.id,
-      filename: "photo.png",
-      content_type: "image/png",
-      byte_size: 1234,
-      status: "ready",
-      public_url: attachment.publicUrl,
-    },
-  ]);
-
-  const secondPage = await requestJson(
-    app,
-    `/v1/conversations/${conversation.id}/messages?cursor=${encodeURIComponent(firstPage.next_cursor)}`
-  );
-  expect(secondPage.messages.map((message: { body: string }) => message.body)).toEqual([
-    "message-5",
-    "message-4",
-    "message-3",
-    "message-2",
-    "message-1",
-  ]);
-  expect(secondPage.next_cursor).toBeUndefined();
-
-  const invalidLimit = await app.request(`/v1/conversations/${conversation.id}/messages?limit=0`);
-  expect(invalidLimit.status).toBe(400);
-  expect(await invalidLimit.json()).toEqual({
-    error: "limit must be a positive integer",
-    code: "invalid_limit",
-  });
-
-  const tooLargeLimit = await app.request(`/v1/conversations/${conversation.id}/messages?limit=101`);
-  expect(tooLargeLimit.status).toBe(400);
-  expect(await tooLargeLimit.json()).toEqual({
-    error: "limit must be at most 100",
-    code: "invalid_limit",
-  });
-});
-
-async function createUser(app: ReturnType<typeof createApp>) {
-  const response = await requestJson(app, "/v1/users", {
-    method: "POST",
-    body: {
-      username: "alice",
-      display_name: "Alice",
-    },
-    expectedStatus: 201,
-  });
-  return response.user as { id: string };
-}
-
-async function createConversation(app: ReturnType<typeof createApp>, createdByUserId: string) {
-  const response = await requestJson(app, "/v1/conversations", {
-    method: "POST",
-    body: {
-      created_by_user_id: createdByUserId,
-      title: "General",
-      participant_user_ids: [createdByUserId],
-    },
-    expectedStatus: 201,
-  });
-  return response.conversation as { id: string };
-}
-
-async function createMessage(app: ReturnType<typeof createApp>, conversationId: string, userId: string, body: string) {
-  const response = await requestJson(app, `/v1/conversations/${conversationId}/messages`, {
-    method: "POST",
-    body: {
-      user_id: userId,
-      body,
-    },
-    expectedStatus: 201,
-  });
-  return response.message as { id: string };
-}
-
-async function requestJson(
-  app: ReturnType<typeof createApp>,
-  path: string,
-  input: {
-    method?: string;
-    body?: unknown;
-    expectedStatus?: number;
-  } = {}
-) {
-  const response = await app.request(path, {
-    method: input.method ?? "GET",
-    headers: input.body ? { "Content-Type": "application/json" } : undefined,
-    body: input.body ? JSON.stringify(input.body) : undefined,
-  });
-  expect(response.status).toBe(input.expectedStatus ?? 200);
-  return response.json();
-}
-
-async function rewriteMessageTimestamps(messageIds: string[]) {
-  if (!sql) {
-    throw new Error("sql client not initialized");
-  }
-
-  const baseTime = Date.parse("2026-01-01T00:00:00.000Z");
-  for (const [index, messageId] of messageIds.entries()) {
-    const createdAt = new Date(baseTime + (index + 1) * 1000).toISOString();
-    await sql`
-      update messages
-      set created_at = ${createdAt}::timestamptz,
-          updated_at = ${createdAt}::timestamptz
-      where id = ${messageId}
-    `;
-  }
-}
-
-class FakeAttachmentStorage implements AttachmentStorage {
-  private readonly metadata = new Map<string, AttachmentObjectMetadata>();
-
-  async createSignedUpload(input: {
-    attachmentId: string;
-    conversationId: string;
-    filename: string;
-    contentType: string;
-  }): Promise<{ bucket: string; key: string; upload: AttachmentUploadTarget; publicUrl: string }> {
-    const bucket = "test-bucket";
-    const key = `attachments/${input.conversationId}/${input.attachmentId}/${input.filename}`;
-    const publicUrl = `https://storage.test/${key}`;
-    return {
-      bucket,
-      key,
-      upload: {
-        method: "PUT",
-        url: `https://uploads.test/${key}`,
-        headers: { "Content-Type": input.contentType },
-      },
-      publicUrl,
-    };
-  }
-
-  async getObjectMetadata(input: { bucket: string; key: string }) {
-    const metadata = this.metadata.get(`${input.bucket}/${input.key}`);
-    if (!metadata) {
-      throw new Error(`missing metadata for ${input.bucket}/${input.key}`);
-    }
-    return metadata;
-  }
-
-  setObjectMetadataFromUrl(publicUrl: string, input: Omit<AttachmentObjectMetadata, "bucket" | "key">) {
-    const [, bucketAndKey = ""] = publicUrl.split("https://storage.test/");
-    this.metadata.set(`test-bucket/${bucketAndKey}`, {
-      bucket: "test-bucket",
-      key: bucketAndKey,
-      contentType: input.contentType,
-      byteSize: input.byteSize,
-      publicUrl: input.publicUrl,
-    });
-  }
-}
-
-class NoopWebhookAdapter {
-  async normalize() {
-    return {
-      provider: "generic",
-      externalEventId: "evt_test",
-      eventType: "generic.event",
-      signatureValid: true,
-      payloadJson: "{}",
-    };
-  }
-}

package/templates/variants/go-chi/buf.gen.yaml

@@ -1,12 +0,0 @@
-version: v2
-plugins:
-  - local: protoc-gen-go
-    out: gen
-    opt:
-      - paths=source_relative
-      - Mchat/v1/chat.proto={{MODULE_PATH}}/gen/chat/v1
-  - local: protoc-gen-connect-go
-    out: gen
-    opt:
-      - paths=source_relative
-      - Mchat/v1/chat.proto={{MODULE_PATH}}/gen/chat/v1

package/templates/variants/go-chi/buf.yaml

@@ -1,9 +0,0 @@
-version: v2
-modules:
-  - path: protos
-lint:
-  use:
-    - STANDARD
-breaking:
-  use:
-    - FILE

package/templates/variants/go-chi/cmd/migrate/main.go

@@ -1,101 +0,0 @@
-package main
-
-import (
-	"context"
-	"log"
-	"os"
-	"sort"
-	"strings"
-	"time"
-
-	_ "github.com/jackc/pgx/v5/stdlib"
-	"github.com/jmoiron/sqlx"
-
-	"{{MODULE_PATH}}/internal/app"
-	"{{MODULE_PATH}}/internal/config"
-)
-
-func main() {
-	cfg, err := config.Load()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	db, err := app.OpenDatabase(context.Background(), cfg.DatabaseURL)
-	if err != nil {
-		db, err = waitForDatabase(cfg.DatabaseURL, 30*time.Second)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	if _, err := db.ExecContext(context.Background(), `
-create table if not exists schema_migrations (
-  version text primary key,
-  applied_at timestamptz not null default now()
-)`); err != nil {
-		log.Fatal(err)
-	}
-
-	entries, err := os.ReadDir("migrations")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	versions := make([]string, 0, len(entries))
-	for _, entry := range entries {
-		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".sql") {
-			continue
-		}
-		versions = append(versions, entry.Name())
-	}
-	sort.Strings(versions)
-
-	for _, version := range versions {
-		var count int
-		if err := db.GetContext(context.Background(), &count, `select count(*) from schema_migrations where version = $1`, version); err != nil {
-			log.Fatal(err)
-		}
-		if count > 0 {
-			continue
-		}
-
-		sqlBytes, err := os.ReadFile("migrations/" + version)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		tx, err := db.BeginTxx(context.Background(), nil)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if _, err := tx.ExecContext(context.Background(), string(sqlBytes)); err != nil {
-			_ = tx.Rollback()
-			log.Fatal(err)
-		}
-		if _, err := tx.ExecContext(context.Background(), `insert into schema_migrations (version) values ($1)`, version); err != nil {
-			_ = tx.Rollback()
-			log.Fatal(err)
-		}
-		if err := tx.Commit(); err != nil {
-			log.Fatal(err)
-		}
-		log.Printf("applied migration %s", version)
-	}
-}
-
-func waitForDatabase(databaseURL string, timeout time.Duration) (*sqlx.DB, error) {
-	deadline := time.Now().Add(timeout)
-	var lastErr error
-
-	for time.Now().Before(deadline) {
-		db, err := app.OpenDatabase(context.Background(), databaseURL)
-		if err == nil {
-			return db, nil
-		}
-		lastErr = err
-		time.Sleep(time.Second)
-	}
-
-	return nil, lastErr
-}

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

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