create-svc 0.1.8 → 0.1.10

package/templates/variants/bun-connectrpc/src/index.ts

@@ -1,32 +1,304 @@
-type ConnectResponse = {
-  message: string;
-};
+import { connectNodeAdapter } from "@connectrpc/connect-node";
+import { Code, ConnectError } from "@connectrpc/connect";
+import type { ServiceImpl } from "@connectrpc/connect";
+import { createServer } from "node:http2";
+import { ChatService as ChatRpcService } from "../gen/protos/chat/v1/chat_pb.js";
+import { AppError, createDefaultChatService, type ChatService } from "./chat/service";
 
-export async function handleRequest(request: Request) {
-  const url = new URL(request.url);
+type RpcService = ServiceImpl<typeof ChatRpcService>;
+type FallbackHandler = NonNullable<Parameters<typeof connectNodeAdapter>[0]["fallback"]>;
 
-  if (url.pathname === "/healthz") {
-    return Response.json({ status: "ok", runtime: "bun", framework: "connectrpc" });
+export function createRpcService(service: ChatService): Partial<RpcService> {
+  return {
+    async createUser(request) {
+      const user = await service.createUser({
+        username: request.username,
+        displayName: request.displayName || null,
+      });
+      return { user: toRpcUser(user) };
+    },
+    async getUser(request) {
+      return { user: toRpcUser(await service.getUser(request.userId)) };
+    },
+    async getUserByUsername(request) {
+      return { user: toRpcUser(await service.getUserByUsername(request.username)) };
+    },
+    async createConversation(request) {
+      return {
+        conversation: toRpcConversation(
+          await service.createConversation({
+            createdByUserId: request.createdByUserId,
+            title: request.title || null,
+            participantUserIds: request.participantUserIds,
+          })
+        ),
+      };
+    },
+    async getConversation(request) {
+      return { conversation: toRpcConversation(await service.getConversation(request.conversationId)) };
+    },
+    async updateConversation(request) {
+      return {
+        conversation: toRpcConversation(
+          await service.updateConversation(request.conversationId, { title: request.title || null })
+        ),
+      };
+    },
+    async deleteConversation(request) {
+      await service.deleteConversation(request.conversationId);
+      return {};
+    },
+    async addConversationParticipant(request) {
+      return {
+        conversation: toRpcConversation(
+          await service.addParticipant(request.conversationId, request.userId)
+        ),
+      };
+    },
+    async removeConversationParticipant(request) {
+      await service.removeParticipant(request.conversationId, request.userId);
+      return {};
+    },
+    async listMessages(request) {
+      const result = await service.listMessages(request.conversationId, {
+        cursor: request.cursor || null,
+        limit: request.limit || null,
+      });
+      return {
+        messages: result.messages.map(toRpcMessage),
+        nextCursor: result.nextCursor ?? "",
+      };
+    },
+    async createMessage(request) {
+      return {
+        message: toRpcMessage(
+          await service.createMessage(request.conversationId, {
+            userId: request.userId,
+            body: request.body,
+          })
+        ),
+      };
+    },
+    async updateMessage(request) {
+      return {
+        message: toRpcMessage(
+          await service.updateMessage(request.conversationId, request.messageId, { body: request.body })
+        ),
+      };
+    },
+    async deleteMessage(request) {
+      await service.deleteMessage(request.conversationId, request.messageId);
+      return {};
+    },
+    async createAttachmentUpload(request) {
+      const result = await service.createAttachmentUpload({
+        conversationId: request.conversationId,
+        uploadedByUserId: request.userId,
+        filename: request.filename,
+        contentType: request.contentType,
+        byteSize: Number(request.byteSize),
+      });
+      return {
+        attachment: toRpcAttachment(result.attachment),
+        upload: {
+          method: result.upload.method,
+          url: result.upload.url,
+          headers: result.upload.headers,
+        },
+      };
+    },
+    async finalizeAttachment(request) {
+      return {
+        attachment: toRpcAttachment(
+          await service.finalizeAttachment(request.attachmentId, { messageId: request.messageId || null })
+        ),
+      };
+    },
+    async getAttachment(request) {
+      return { attachment: toRpcAttachment(await service.getAttachment(request.attachmentId)) };
+    },
+    async deleteAttachment(request) {
+      await service.deleteAttachment(request.attachmentId);
+      return {};
+    },
+  };
+}
+
+export function createHandler(service: ChatService) {
+  return connectNodeAdapter({
+    routes: (router) => {
+      router.service(ChatRpcService, createRpcService(service));
+    },
+    fallback: (async (request: Parameters<FallbackHandler>[0], response: Parameters<FallbackHandler>[1]) => {
+      const url = new URL(request.url ?? "/", "http://localhost");
+      const path = url.pathname;
+
+      if (path === "/healthz" || path === "/readyz") {
+        respondJson(response, 200, { status: "ok" });
+        return;
+      }
+
+      if (path === "/") {
+        respondJson(response, 200, {
+          service: "{{SERVICE_NAME}}",
+          domain: "chat",
+          apiOrigin: "https://api.{{SERVICE_NAME}}.anmho.com",
+        });
+        return;
+      }
+
+      if (path === "/debug/connectrpc" && isLocalRpcIntrospectionEnabled()) {
+        respondJson(response, 200, createIntrospectionDocument());
+        return;
+      }
+
+      if (request.method === "POST" && path.startsWith("/webhooks/")) {
+        try {
+          const provider = path.split("/").filter(Boolean)[1] ?? "generic";
+          const rawBody = await readRawBody(request);
+          const result = await service.processWebhook(provider, toHeaders(request), rawBody);
+          respondJson(response, result.duplicate ? 200 : 202, result);
+        } catch (error) {
+          respondAppError(response, error);
+        }
+        return;
+      }
+
+      if (request.method === "GET" && path.startsWith("/webhooks/") && path.endsWith("/health")) {
+        const provider = path.split("/").filter(Boolean)[1] ?? "generic";
+        respondJson(response, 200, { status: "ok", provider });
+        return;
+      }
+
+      respondJson(response, 404, { error: "not found" });
+    }) as FallbackHandler,
+  });
+}
+
+export function createIntrospectionDocument() {
+  return {
+    service: ChatRpcService.typeName,
+    file: ChatRpcService.file.proto.name,
+    methods: ChatRpcService.methods.map((method) => ({
+      name: method.name,
+      localName: method.localName,
+      kind: method.methodKind,
+      input: method.input.typeName,
+      output: method.output.typeName,
+    })),
+  };
+}
+
+export function isLocalRpcIntrospectionEnabled() {
+  const override = Bun.env.ENABLE_RPC_INTROSPECTION?.trim().toLowerCase();
+  if (override) {
+    return !["0", "false", "no", "off"].includes(override);
   }
+  return !Bun.env.K_SERVICE && Bun.env.NODE_ENV !== "production";
+}
+
+function toRpcUser(user: Awaited<ReturnType<ChatService["getUser"]>>) {
+  return {
+    id: user.id,
+    username: user.username,
+    displayName: user.displayName ?? "",
+    createdAt: user.createdAt,
+    updatedAt: user.updatedAt,
+  };
+}
 
-  if (url.pathname === "/rpc.example.v1.Service/Ping" && request.method === "POST") {
-    const payload = (await request.json().catch(() => ({}))) as { name?: string };
-    const body: ConnectResponse = {
-      message: `hello ${payload.name?.trim() || "{{SERVICE_NAME}}"}`,
-    };
-    return Response.json(body, {
-      headers: {
-        "Content-Type": "application/json",
-      },
-    });
+function toRpcConversation(conversation: Awaited<ReturnType<ChatService["getConversation"]>>) {
+  return {
+    id: conversation.id,
+    title: conversation.title ?? "",
+    createdByUserId: conversation.createdByUserId,
+    participants: conversation.participants.map(toRpcUser),
+    createdAt: conversation.createdAt,
+    updatedAt: conversation.updatedAt,
+  };
+}
+
+function toRpcMessage(message: Awaited<ReturnType<ChatService["createMessage"]>>) {
+  return {
+    id: message.id,
+    conversationId: message.conversationId,
+    userId: message.userId,
+    body: message.body,
+    editedAt: message.editedAt ?? "",
+    createdAt: message.createdAt,
+    updatedAt: message.updatedAt,
+    attachments: message.attachments.map((attachment) => ({
+      id: attachment.id,
+      filename: attachment.filename,
+      contentType: attachment.contentType,
+      byteSize: BigInt(attachment.byteSize),
+      status: attachment.status,
+      publicUrl: attachment.publicUrl,
+    })),
+  };
+}
+
+function toRpcAttachment(attachment: Awaited<ReturnType<ChatService["getAttachment"]>>) {
+  return {
+    id: attachment.id,
+    conversationId: attachment.conversationId,
+    messageId: attachment.messageId ?? "",
+    uploadedByUserId: attachment.uploadedByUserId,
+    storageBucket: attachment.storageBucket,
+    storageKey: attachment.storageKey,
+    contentType: attachment.contentType,
+    byteSize: BigInt(attachment.byteSize),
+    filename: attachment.filename,
+    status: attachment.status,
+    publicUrl: attachment.publicUrl,
+    createdAt: attachment.createdAt,
+    updatedAt: attachment.updatedAt,
+  };
+}
+
+function respondJson(response: Parameters<FallbackHandler>[1], status: number, body: unknown) {
+  response.statusCode = status;
+  response.setHeader("Content-Type", "application/json");
+  response.end(JSON.stringify(body));
+}
+
+function respondAppError(response: Parameters<FallbackHandler>[1], error: unknown) {
+  if (error instanceof AppError) {
+    respondJson(response, error.status, { error: error.message, code: error.code });
+    return;
   }
+  if (error instanceof ConnectError) {
+    respondJson(response, 500, { error: error.message, code: error.code });
+    return;
+  }
+  respondJson(response, 500, { error: error instanceof Error ? error.message : String(error) });
+}
 
-  return Response.json({ error: "not found" }, { status: 404 });
+function readRawBody(request: Parameters<FallbackHandler>[0]) {
+  return new Promise<string>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    request.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    request.on("error", reject);
+  });
+}
+
+function toHeaders(request: Parameters<FallbackHandler>[0]) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(request.headers)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+    } else if (value) {
+      headers.set(key, value);
+    }
+  }
+  return headers;
 }
 
 if (import.meta.main) {
-  Bun.serve({
-    port: Number(Bun.env.PORT ?? 8080),
-    fetch: handleRequest,
-  });
+  const port = Number(Bun.env.PORT ?? 8080);
+  const server = createServer(createHandler(createDefaultChatService()));
+  server.listen(port);
 }

package/templates/variants/bun-connectrpc/src/storage.ts

@@ -0,0 +1,72 @@
+import { Storage } from "@google-cloud/storage";
+import type { AttachmentObjectMetadata, AttachmentUploadTarget } from "./chat/types";
+
+export type AttachmentStorage = {
+  createSignedUpload(input: {
+    attachmentId: string;
+    conversationId: string;
+    filename: string;
+    contentType: string;
+  }): Promise<{ bucket: string; key: string; upload: AttachmentUploadTarget; publicUrl: string }>;
+  getObjectMetadata(input: { bucket: string; key: string }): Promise<AttachmentObjectMetadata>;
+};
+
+export class GcsAttachmentStorage implements AttachmentStorage {
+  constructor(
+    private readonly bucketName = requireAttachmentBucket(),
+    private readonly publicBaseUrl = Bun.env.ATTACHMENT_PUBLIC_BASE_URL?.trim() || `https://storage.googleapis.com/${requireAttachmentBucket()}`
+  ) {}
+
+  async createSignedUpload(input: { attachmentId: string; conversationId: string; filename: string; contentType: string }) {
+    const storage = new Storage();
+    const bucket = storage.bucket(this.bucketName);
+    const key = `attachments/${input.conversationId}/${input.attachmentId}/${sanitizeFilename(input.filename)}`;
+    const file = bucket.file(key);
+    const [url] = await file.getSignedUrl({
+      action: "write",
+      version: "v4",
+      expires: Date.now() + 15 * 60 * 1000,
+      contentType: input.contentType,
+    });
+    return {
+      bucket: this.bucketName,
+      key,
+      upload: {
+        method: "PUT" as const,
+        url,
+        headers: {
+          "Content-Type": input.contentType,
+        },
+      },
+      publicUrl: `${this.publicBaseUrl.replace(/\/+$/g, "")}/${key}`,
+    };
+  }
+
+  async getObjectMetadata(input: { bucket: string; key: string }): Promise<AttachmentObjectMetadata> {
+    const storage = new Storage();
+    const [metadata] = await storage.bucket(input.bucket).file(input.key).getMetadata();
+    return {
+      bucket: input.bucket,
+      key: input.key,
+      contentType: String(metadata.contentType ?? ""),
+      byteSize: Number(metadata.size ?? 0),
+      publicUrl: `${this.publicBaseUrl.replace(/\/+$/g, "")}/${input.key}`,
+    };
+  }
+}
+
+export function createAttachmentStorage() {
+  return new GcsAttachmentStorage();
+}
+
+export function requireAttachmentBucket() {
+  const bucket = Bun.env.ATTACHMENT_BUCKET?.trim();
+  if (!bucket) {
+    throw new Error("ATTACHMENT_BUCKET is required");
+  }
+  return bucket;
+}
+
+function sanitizeFilename(filename: string) {
+  return filename.trim().replace(/[^a-zA-Z0-9._-]+/g, "-") || "upload.bin";
+}

package/templates/variants/bun-connectrpc/src/webhooks.ts

@@ -0,0 +1,35 @@
+import type { NormalizedWebhookEvent } from "./chat/types";
+
+export type WebhookAdapter = {
+  normalize(provider: string, headers: Headers, rawBody: string): Promise<NormalizedWebhookEvent>;
+};
+
+export class GenericJsonWebhookAdapter implements WebhookAdapter {
+  async normalize(provider: string, headers: Headers, rawBody: string): Promise<NormalizedWebhookEvent> {
+    const payload = parseJson(rawBody);
+    const secret = Bun.env[`WEBHOOK_${provider.toUpperCase()}_SECRET`]?.trim();
+    const incomingSecret = headers.get("x-webhook-secret")?.trim() ?? "";
+    const externalEventId = String(payload.id ?? headers.get("x-event-id") ?? crypto.randomUUID());
+    const eventType = String(payload.type ?? headers.get("x-event-type") ?? "generic.event");
+
+    return {
+      provider,
+      externalEventId,
+      eventType,
+      signatureValid: secret ? incomingSecret === secret : true,
+      payloadJson: rawBody,
+    };
+  }
+}
+
+export function createWebhookAdapter() {
+  return new GenericJsonWebhookAdapter();
+}
+
+function parseJson(rawBody: string) {
+  try {
+    return JSON.parse(rawBody) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}

package/templates/variants/bun-connectrpc/test/app.test.ts

@@ -1,17 +1,18 @@
 import { expect, test } from "bun:test";
-import { handleRequest } from "../src/index";
+import { createIntrospectionDocument, isLocalRpcIntrospectionEnabled } from "../src/index";
 
-test("connect-style ping route responds", async () => {
-  const response = await handleRequest(
-    new Request("http://localhost/rpc.example.v1.Service/Ping", {
-      method: "POST",
-      body: JSON.stringify({ name: "preview" }),
-      headers: {
-        "Content-Type": "application/json",
-      },
-    })
-  );
+test("local introspection document exposes chat service and methods", () => {
+  const document = createIntrospectionDocument();
 
-  expect(response.status).toBe(200);
-  expect(await response.json()).toEqual({ message: "hello preview" });
+  expect(document.service).toBe("chat.v1.ChatService");
+  expect(document.methods.map((method) => method.name)).toContain("CreateUser");
+  expect(document.methods.map((method) => method.name)).toContain("CreateAttachmentUpload");
+});
+
+test("local introspection defaults to enabled outside Cloud Run", () => {
+  delete Bun.env.K_SERVICE;
+  delete Bun.env.ENABLE_RPC_INTROSPECTION;
+  Bun.env.NODE_ENV = "development";
+
+  expect(isLocalRpcIntrospectionEnabled()).toBeTrue();
 });

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

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { SQL } from "bun";
+import { createDb } from "../src/db/client";
+import { ChatRepository } from "../src/db/repository";
+import { DefaultChatService } from "../src/chat/service";
+import { createRpcService } from "../src/index";
+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 rpc = createRpcService(new DefaultChatService(new ChatRepository(createDb(databaseUrl)), storage, new NoopWebhookAdapter()));
+
+  const user = (await rpc.createUser!({ username: "alice", displayName: "Alice" } as any, undefined as never)).user!;
+  const conversation = (
+    await rpc.createConversation!({
+      createdByUserId: user.id!,
+      title: "General",
+      participantUserIds: [user.id!],
+    } as any, undefined as never)
+  ).conversation!;
+
+  const messageIds: string[] = [];
+  for (let index = 1; index <= 55; index += 1) {
+    const response = await rpc.createMessage!({
+      conversationId: conversation.id!,
+      userId: user.id!,
+      body: `message-${index}`,
+    } as any, undefined as never);
+    messageIds.push(response.message!.id!);
+  }
+  await rewriteMessageTimestamps(messageIds);
+
+  const uploadResult = await rpc.createAttachmentUpload!({
+    conversationId: conversation.id!,
+    userId: user.id!,
+    filename: "photo.png",
+    contentType: "image/png",
+    byteSize: BigInt(1234),
+  } as any, undefined as never);
+  storage.setObjectMetadata(uploadResult.attachment!.publicUrl!, {
+    contentType: "image/png",
+    byteSize: 1234,
+    publicUrl: uploadResult.attachment!.publicUrl!,
+  });
+  await rpc.finalizeAttachment!({
+    attachmentId: uploadResult.attachment!.id!,
+    messageId: messageIds[54]!,
+  } as any, undefined as never);
+
+  const firstPage = await rpc.listMessages!({
+    conversationId: conversation.id!,
+  } as any, undefined as never);
+  expect(firstPage.messages!).toHaveLength(50);
+  expect(firstPage.messages![0]?.body).toBe("message-55");
+  expect(firstPage.messages![49]?.body).toBe("message-6");
+  expect(firstPage.nextCursor).toBeString();
+  expect(firstPage.messages![0]?.attachments).toEqual([
+    {
+      id: uploadResult.attachment!.id!,
+      filename: "photo.png",
+      contentType: "image/png",
+      byteSize: BigInt(1234),
+      status: "ready",
+      publicUrl: uploadResult.attachment!.publicUrl!,
+    },
+  ]);
+
+  const secondPage = await rpc.listMessages!({
+    conversationId: conversation.id!,
+    cursor: firstPage.nextCursor,
+  } as any, undefined as never);
+  expect(secondPage.messages!.map((message) => message.body)).toEqual([
+    "message-5",
+    "message-4",
+    "message-3",
+    "message-2",
+    "message-1",
+  ]);
+  expect(secondPage.nextCursor).toBe("");
+});
+
+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;
+  }
+
+  setObjectMetadata(publicUrl: string, input: Omit<AttachmentObjectMetadata, "bucket" | "key">) {
+    const [, key = ""] = publicUrl.split("https://storage.test/");
+    this.metadata.set(`test-bucket/${key}`, {
+      bucket: "test-bucket",
+      key,
+      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-connectrpc/tsconfig.json

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

package/templates/variants/bun-hono/Makefile

@@ -1,10 +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
 
 dev:
 	bun run ./src/index.ts
 
+migrate:
+	bun run ./scripts/migrate.ts
+
 gen:
 	bun run ./scripts/codegen.ts