create-svc 0.1.10 → 0.1.12

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

@@ -1,133 +1,73 @@
-import { connectNodeAdapter } from "@connectrpc/connect-node";
 import { Code, ConnectError } from "@connectrpc/connect";
+import { connectNodeAdapter } from "@connectrpc/connect-node";
 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";
-
-type RpcService = ServiceImpl<typeof ChatRpcService>;
+import { createServer } from "node:http";
+import { WaitlistService as WaitlistRpcService } from "../gen/protos/waitlist/v1/waitlist_pb.js";
+import { withServiceAuth } from "./auth";
+import { AppError, createDefaultWaitlistService, type WaitlistService } from "./waitlist/service";
+import { startTemporalWorker } from "./temporal/worker";
+import type { WaitlistEntry, WaitlistTrigger } from "./waitlist/types";
+
+type RpcService = ServiceImpl<typeof WaitlistRpcService>;
 type FallbackHandler = NonNullable<Parameters<typeof connectNodeAdapter>[0]["fallback"]>;
 
-export function createRpcService(service: ChatService): Partial<RpcService> {
+export function createRpcService(service: WaitlistService): Partial<RpcService> {
   return {
-    async createUser(request) {
-      const user = await service.createUser({
-        username: request.username,
-        displayName: request.displayName || null,
+    async joinWaitlist(request) {
+      const result = await service.joinWaitlist({
+        email: request.email,
+        name: request.name || null,
+        company: request.company || null,
+        source: request.source || null,
       });
-      return { user: toRpcUser(user) };
+      return { entry: toRpcEntry(result.entry), created: result.created };
     },
-    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 getWaitlistEntry(request) {
+      return { entry: toRpcEntry(await service.getWaitlistEntry(request.entryId)) };
     },
-    async getConversation(request) {
-      return { conversation: toRpcConversation(await service.getConversation(request.conversationId)) };
+    async getWaitlistEntryByEmail(request) {
+      return { entry: toRpcEntry(await service.getWaitlistEntryByEmail(request.email)) };
     },
-    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,
+    async listWaitlistEntries(request) {
+      const entries = await service.listWaitlistEntries({
+        status: request.status || null,
         limit: request.limit || null,
       });
-      return {
-        messages: result.messages.map(toRpcMessage),
-        nextCursor: result.nextCursor ?? "",
-      };
+      return { entries: entries.map(toRpcEntry) };
     },
-    async createMessage(request) {
+    async updateWaitlistEntry(request) {
       return {
-        message: toRpcMessage(
-          await service.createMessage(request.conversationId, {
-            userId: request.userId,
-            body: request.body,
+        entry: toRpcEntry(
+          await service.updateWaitlistEntry({
+            entryId: request.entryId,
+            status: request.status,
           })
         ),
       };
     },
-    async updateMessage(request) {
+    async exportWaitlistEntries(request) {
       return {
-        message: toRpcMessage(
-          await service.updateMessage(request.conversationId, request.messageId, { body: request.body })
-        ),
+        csv: await service.exportWaitlistEntries({
+          status: request.status || null,
+          limit: request.limit || null,
+        }),
       };
     },
-    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 {};
+    async recordTrigger(request) {
+      const trigger = (await service.recordTrigger({
+        type: request.type,
+        entryId: request.entryId || null,
+        payloadJson: request.payloadJson || "{}",
+      })) as WaitlistTrigger;
+      return { trigger: toRpcTrigger(trigger) };
     },
   };
 }
 
-export function createHandler(service: ChatService) {
+export function createHandler(service: WaitlistService) {
   return connectNodeAdapter({
     routes: (router) => {
-      router.service(ChatRpcService, createRpcService(service));
+      router.service(WaitlistRpcService, createRpcService(service));
     },
     fallback: (async (request: Parameters<FallbackHandler>[0], response: Parameters<FallbackHandler>[1]) => {
       const url = new URL(request.url ?? "/", "http://localhost");
@@ -141,7 +81,7 @@ export function createHandler(service: ChatService) {
       if (path === "/") {
         respondJson(response, 200, {
           service: "{{SERVICE_NAME}}",
-          domain: "chat",
+          domain: "waitlist",
           apiOrigin: "https://api.{{SERVICE_NAME}}.anmho.com",
         });
         return;
@@ -156,8 +96,11 @@ export function createHandler(service: ChatService) {
         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);
+          const trigger = await service.recordTrigger({
+            type: `webhook.${provider}`,
+            payloadJson: JSON.stringify({ headers: request.headers, rawBody }),
+          });
+          respondJson(response, 202, { trigger });
         } catch (error) {
           respondAppError(response, error);
         }
@@ -177,9 +120,9 @@ export function createHandler(service: ChatService) {
 
 export function createIntrospectionDocument() {
   return {
-    service: ChatRpcService.typeName,
-    file: ChatRpcService.file.proto.name,
-    methods: ChatRpcService.methods.map((method) => ({
+    service: WaitlistRpcService.typeName,
+    file: WaitlistRpcService.file.proto.name,
+    methods: WaitlistRpcService.methods.map((method) => ({
       name: method.name,
       localName: method.localName,
       kind: method.methodKind,
@@ -197,62 +140,28 @@ export function isLocalRpcIntrospectionEnabled() {
   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,
-  };
-}
-
-function toRpcConversation(conversation: Awaited<ReturnType<ChatService["getConversation"]>>) {
+function toRpcEntry(entry: WaitlistEntry) {
   return {
-    id: conversation.id,
-    title: conversation.title ?? "",
-    createdByUserId: conversation.createdByUserId,
-    participants: conversation.participants.map(toRpcUser),
-    createdAt: conversation.createdAt,
-    updatedAt: conversation.updatedAt,
+    id: entry.id,
+    email: entry.email,
+    name: entry.name ?? "",
+    company: entry.company ?? "",
+    source: entry.source ?? "",
+    status: entry.status,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt,
   };
 }
 
-function toRpcMessage(message: Awaited<ReturnType<ChatService["createMessage"]>>) {
+function toRpcTrigger(trigger: WaitlistTrigger) {
   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,
+    id: trigger.id,
+    type: trigger.type,
+    entryId: trigger.entryId ?? "",
+    status: trigger.status,
+    payloadJson: trigger.payloadJson,
+    createdAt: trigger.createdAt,
+    processedAt: trigger.processedAt ?? "",
   };
 }
 
@@ -271,7 +180,7 @@ function respondAppError(response: Parameters<FallbackHandler>[1], error: unknow
     respondJson(response, 500, { error: error.message, code: error.code });
     return;
   }
-  respondJson(response, 500, { error: error instanceof Error ? error.message : String(error) });
+  respondJson(response, 500, { error: error instanceof Error ? error.message : String(error), code: Code[Code.Internal] });
 }
 
 function readRawBody(request: Parameters<FallbackHandler>[0]) {
@@ -283,22 +192,13 @@ function readRawBody(request: Parameters<FallbackHandler>[0]) {
   });
 }
 
-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);
-    }
+if (import.meta.main) {
+  const temporalWorker = await startTemporalWorker();
+  if (temporalWorker) {
+    console.log(`Temporal worker polling ${temporalWorker.taskQueue}`);
   }
-  return headers;
-}
 
-if (import.meta.main) {
   const port = Number(Bun.env.PORT ?? 8080);
-  const server = createServer(createHandler(createDefaultChatService()));
+  const server = createServer(withServiceAuth(createHandler(createDefaultWaitlistService())));
   server.listen(port);
 }

package/templates/variants/bun-connectrpc/src/temporal/activities.ts

@@ -0,0 +1,14 @@
+export type WaitlistFollowUpInput = {
+  triggerId?: string;
+  email?: string;
+  type: string;
+};
+
+export async function recordWaitlistFollowUp(input: WaitlistFollowUpInput) {
+  return {
+    status: "queued",
+    triggerId: input.triggerId ?? null,
+    email: input.email ?? null,
+    type: input.type,
+  };
+}

package/templates/variants/bun-connectrpc/src/temporal/worker.ts

@@ -0,0 +1,38 @@
+import { NativeConnection, Worker } from "@temporalio/worker";
+import * as activities from "./activities";
+
+export function temporalWorkerEnabled() {
+  return (Bun.env.TEMPORAL_ENABLED ?? "").trim().toLowerCase() === "true";
+}
+
+export async function startTemporalWorker() {
+  if (!temporalWorkerEnabled()) {
+    return undefined;
+  }
+
+  const address = Bun.env.TEMPORAL_ADDRESS || "localhost:7233";
+  const namespace = Bun.env.TEMPORAL_NAMESPACE || "default";
+  const taskQueue = Bun.env.TEMPORAL_TASK_QUEUE || "{{SERVICE_NAME}}";
+  const apiKey = Bun.env.TEMPORAL_API_KEY?.trim();
+  const connection = await NativeConnection.connect({
+    address,
+    ...(apiKey ? { apiKey } : {}),
+  });
+  const worker = await Worker.create({
+    connection,
+    namespace,
+    taskQueue,
+    workflowsPath: new URL("./workflows.ts", import.meta.url).pathname,
+    activities,
+  });
+  const running = worker.run();
+
+  return {
+    taskQueue,
+    async shutdown() {
+      worker.shutdown();
+      await running.catch(() => undefined);
+      await connection.close();
+    },
+  };
+}

package/templates/variants/bun-connectrpc/src/temporal/workflows.ts

@@ -0,0 +1,10 @@
+import { proxyActivities } from "@temporalio/workflow";
+import type * as activities from "./activities";
+
+const { recordWaitlistFollowUp } = proxyActivities<typeof activities>({
+  startToCloseTimeout: "1 minute",
+});
+
+export async function waitlistFollowUpWorkflow(input: activities.WaitlistFollowUpInput) {
+  return await recordWaitlistFollowUp(input);
+}

package/templates/variants/bun-connectrpc/src/waitlist/service.ts

@@ -0,0 +1,172 @@
+import { createDb } from "../db/client";
+import { WaitlistRepository } from "../db/repository";
+import type {
+  JoinWaitlistInput,
+  ListWaitlistEntriesInput,
+  RecordTriggerInput,
+  UpdateWaitlistEntryInput,
+  WaitlistEntry,
+  WaitlistEntryStatus,
+} from "./types";
+
+export class AppError extends Error {
+  constructor(
+    readonly status: number,
+    readonly code: string,
+    message: string
+  ) {
+    super(message);
+  }
+}
+
+export type WaitlistService = {
+  joinWaitlist(input: JoinWaitlistInput): Promise<{ entry: WaitlistEntry; created: boolean }>;
+  getWaitlistEntry(entryId: string): Promise<WaitlistEntry>;
+  getWaitlistEntryByEmail(email: string): Promise<WaitlistEntry>;
+  listWaitlistEntries(input?: ListWaitlistEntriesInput): Promise<WaitlistEntry[]>;
+  updateWaitlistEntry(input: UpdateWaitlistEntryInput): Promise<WaitlistEntry>;
+  exportWaitlistEntries(input?: ListWaitlistEntriesInput): Promise<string>;
+  recordTrigger(input: RecordTriggerInput): Promise<unknown>;
+};
+
+export class DefaultWaitlistService implements WaitlistService {
+  constructor(private readonly repository: WaitlistRepository) {}
+
+  async joinWaitlist(input: JoinWaitlistInput) {
+    const email = normalizeEmail(input.email);
+    const existing = await this.repository.getEntryByEmail(email);
+    if (existing) {
+      return { entry: existing, created: false };
+    }
+
+    const entry = await this.repository.createEntry({
+      id: crypto.randomUUID(),
+      email,
+      name: normalizeNullableText(input.name),
+      company: normalizeNullableText(input.company),
+      source: normalizeNullableText(input.source),
+    });
+
+    await this.repository.createTrigger({
+      id: crypto.randomUUID(),
+      type: "waitlist.joined",
+      entryId: entry.id,
+      payloadJson: JSON.stringify({ email: entry.email, source: entry.source }),
+    });
+
+    return { entry, created: true };
+  }
+
+  async getWaitlistEntry(entryId: string) {
+    const entry = await this.repository.getEntryById(entryId.trim());
+    if (!entry) {
+      throw new AppError(404, "entry_not_found", `waitlist entry ${entryId} not found`);
+    }
+    return entry;
+  }
+
+  async getWaitlistEntryByEmail(email: string) {
+    const entry = await this.repository.getEntryByEmail(normalizeEmail(email));
+    if (!entry) {
+      throw new AppError(404, "entry_not_found", `waitlist entry for ${email} not found`);
+    }
+    return entry;
+  }
+
+  async listWaitlistEntries(input: ListWaitlistEntriesInput = {}) {
+    return this.repository.listEntries({
+      status: input.status ? normalizeStatus(input.status) : null,
+      limit: input.limit,
+    });
+  }
+
+  async updateWaitlistEntry(input: UpdateWaitlistEntryInput) {
+    const entryId = input.entryId.trim();
+    if (!entryId) {
+      throw new AppError(400, "invalid_entry_id", "entry id is required");
+    }
+    const entry = await this.repository.updateEntryStatus(entryId, normalizeStatus(input.status));
+    if (!entry) {
+      throw new AppError(404, "entry_not_found", `waitlist entry ${input.entryId} not found`);
+    }
+    return entry;
+  }
+
+  async exportWaitlistEntries(input: ListWaitlistEntriesInput = {}) {
+    return entriesToCsv(await this.listWaitlistEntries(input));
+  }
+
+  async recordTrigger(input: RecordTriggerInput) {
+    const type = input.type.trim();
+    if (!type) {
+      throw new AppError(400, "invalid_trigger_type", "trigger type is required");
+    }
+
+    if (input.entryId) {
+      await this.getWaitlistEntry(input.entryId);
+    }
+
+    return this.repository.createTrigger({
+      id: crypto.randomUUID(),
+      type,
+      entryId: input.entryId?.trim() || null,
+      payloadJson: normalizePayloadJson(input.payloadJson),
+    });
+  }
+}
+
+export function createDefaultWaitlistService() {
+  return new DefaultWaitlistService(new WaitlistRepository(createDb()));
+}
+
+function normalizeEmail(value: string) {
+  const email = value.trim().toLowerCase();
+  if (!email || !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) {
+    throw new AppError(400, "invalid_email", "valid email is required");
+  }
+  return email;
+}
+
+function normalizeNullableText(value: string | null | undefined) {
+  const normalized = value?.trim();
+  return normalized ? normalized : null;
+}
+
+function normalizeStatus(value: string): WaitlistEntryStatus {
+  const status = value.trim().toLowerCase();
+  if (status === "joined" || status === "invited" || status === "converted" || status === "archived") {
+    return status;
+  }
+  throw new AppError(400, "invalid_status", "status must be one of joined, invited, converted, archived");
+}
+
+function entriesToCsv(entries: WaitlistEntry[]) {
+  const headers = ["id", "email", "name", "company", "source", "status", "created_at", "updated_at"];
+  return [
+    headers.join(","),
+    ...entries.map((entry) =>
+      [
+        entry.id,
+        entry.email,
+        entry.name ?? "",
+        entry.company ?? "",
+        entry.source ?? "",
+        entry.status,
+        entry.createdAt,
+        entry.updatedAt,
+      ]
+        .map(csvCell)
+        .join(",")
+    ),
+  ].join("\n");
+}
+
+function csvCell(value: string) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+
+function normalizePayloadJson(value: string | null | undefined) {
+  const payload = value?.trim() || "{}";
+  JSON.parse(payload);
+  return payload;
+}

package/templates/variants/bun-connectrpc/src/waitlist/types.ts

@@ -0,0 +1,45 @@
+export type WaitlistEntry = {
+  id: string;
+  email: string;
+  name: string | null;
+  company: string | null;
+  source: string | null;
+  status: WaitlistEntryStatus;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type WaitlistTrigger = {
+  id: string;
+  type: string;
+  entryId: string | null;
+  status: "queued" | "processed" | "failed";
+  payloadJson: string;
+  createdAt: string;
+  processedAt: string | null;
+};
+
+export type JoinWaitlistInput = {
+  email: string;
+  name?: string | null;
+  company?: string | null;
+  source?: string | null;
+};
+
+export type WaitlistEntryStatus = "joined" | "invited" | "converted" | "archived";
+
+export type ListWaitlistEntriesInput = {
+  status?: string | null;
+  limit?: number | null;
+};
+
+export type UpdateWaitlistEntryInput = {
+  entryId: string;
+  status: string;
+};
+
+export type RecordTriggerInput = {
+  type: string;
+  entryId?: string | null;
+  payloadJson?: string | null;
+};

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

@@ -1,12 +1,12 @@
 import { expect, test } from "bun:test";
 import { createIntrospectionDocument, isLocalRpcIntrospectionEnabled } from "../src/index";
 
-test("local introspection document exposes chat service and methods", () => {
+test("local introspection document exposes waitlist service and methods", () => {
   const document = createIntrospectionDocument();
 
-  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");
+  expect(document.service).toBe("waitlist.v1.WaitlistService");
+  expect(document.methods.map((method) => method.name)).toContain("JoinWaitlist");
+  expect(document.methods.map((method) => method.name)).toContain("RecordTrigger");
 });
 
 test("local introspection defaults to enabled outside Cloud Run", () => {