create-svc 0.1.9 → 0.1.10

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

@@ -0,0 +1,256 @@
+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/bun-hono/tsconfig.json

@@ -4,6 +4,7 @@
     "module": "ESNext",
     "moduleResolution": "Bundler",
     "strict": true,
+    "skipLibCheck": true,
     "types": ["bun"]
   },
   "include": ["src/**/*.ts", "test/**/*.ts", "scripts/**/*.ts"]

package/templates/variants/go-chi/Makefile

@@ -1,9 +1,13 @@
-.PHONY: dev gen lint test bootstrap deploy cleanup
+.PHONY: dev migrate gen lint test bootstrap deploy cleanup
 
 CLOUDRUN := npx --no-install svc-cloudrun
+WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
 
 dev:
-	go run ./cmd/server
+	@$(WITH_ENV) go run ./cmd/server
+
+migrate:
+	@$(WITH_ENV) go run ./cmd/migrate
 
 gen:
 	buf generate

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

@@ -4,7 +4,9 @@ plugins:
     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/cmd/migrate/main.go

@@ -0,0 +1,101 @@
+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/cmd/server/main.go

@@ -6,13 +6,14 @@ import (
 	"net/http"
 	"time"
 
+	"cloud.google.com/go/storage"
 	"github.com/go-chi/chi/v5"
+	_ "github.com/jackc/pgx/v5/stdlib"
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/h2c"
 
 	"{{MODULE_PATH}}/internal/app"
 	"{{MODULE_PATH}}/internal/config"
-	"{{MODULE_PATH}}/internal/connectapi"
 	"{{MODULE_PATH}}/internal/httpapi"
 )
 
@@ -22,25 +23,25 @@ func main() {
 		log.Fatal(err)
 	}
 
-	service := app.NewDNSService()
-	if cfg.DatabaseURL != "" {
-		if _, err := service.CreateRecord(context.Background(), app.CreateRecordInput{
-			Type:    "TXT",
-			Name:    "bootstrap",
-			Content: "database-configured",
-			TTL:     60,
-			Proxied: false,
-		}); err != nil {
-			log.Fatal(err)
-		}
+	db, err := app.OpenDatabase(context.Background(), cfg.DatabaseURL)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	storageClient, err := storage.NewClient(context.Background())
+	if err != nil {
+		log.Fatal(err)
 	}
 
+	service := app.NewChatService(
+		db,
+		app.NewGCSStorage(cfg.AttachmentBucket, cfg.AttachmentPublicBaseURL, storageClient),
+		app.GenericWebhookAdapter{},
+	)
+
 	router := chi.NewRouter()
 	httpapi.RegisterRoutes(router, service)
 
-	connectPath, connectHandler := connectapi.NewHandler(service)
-	router.Mount(connectPath, connectHandler)
-
 	server := &http.Server{
 		Addr:              ":" + cfg.Port,
 		ReadHeaderTimeout: 10 * time.Second,

package/templates/variants/go-chi/go.mod

@@ -3,8 +3,11 @@ module {{MODULE_PATH}}
 go 1.25.4
 
 require (
+	cloud.google.com/go/storage v1.53.0
 	connectrpc.com/connect v1.19.1
 	github.com/go-chi/chi/v5 v5.2.2
+	github.com/jackc/pgx/v5 v5.7.5
+	github.com/jmoiron/sqlx v1.4.0
 	golang.org/x/net v0.42.0
 	google.golang.org/protobuf v1.36.10
 )