create-svc 0.1.10 → 0.1.12

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

@@ -1,7 +1,9 @@
 import { Hono } from "hono";
-import { AppError, createDefaultChatService, type ChatService } from "./chat/service";
+import { authMiddleware } from "./auth";
+import { AppError, createDefaultWaitlistService, type WaitlistService } from "./waitlist/service";
+import { startTemporalWorker } from "./temporal/worker";
 
-export function createApp(service: ChatService) {
+export function createApp(service: WaitlistService) {
   const app = new Hono();
 
   app.get("/healthz", (context) => context.json({ status: "ok" }));
@@ -9,71 +11,50 @@ export function createApp(service: ChatService) {
   app.get("/", (context) =>
     context.json({
       service: "{{SERVICE_NAME}}",
-      domain: "chat",
+      domain: "waitlist",
       apiOrigin: "https://api.{{SERVICE_NAME}}.anmho.com",
     })
   );
 
-  app.post("/v1/users", async (context) => {
+  app.use("/v1/*", authMiddleware());
+
+  app.post("/v1/waitlist", async (context) => {
     try {
       const body = await context.req.json();
-      const user = await service.createUser({
-        username: String(body.username ?? ""),
-        displayName: body.display_name ?? body.displayName ?? null,
+      const result = await service.joinWaitlist({
+        email: String(body.email ?? ""),
+        name: body.name ?? null,
+        company: body.company ?? null,
+        source: body.source ?? null,
       });
-      return context.json({ user }, 201);
+      return context.json(result, result.created ? 201 : 200);
     } catch (error) {
       return writeError(context, error);
     }
   });
 
-  app.get("/v1/users/:userId", async (context) => {
+  app.get("/v1/waitlist", async (context) => {
     try {
-      return context.json({ user: await service.getUser(context.req.param("userId")) });
+      return context.json({ entry: await service.getWaitlistEntryByEmail(context.req.query("email") ?? "") });
     } catch (error) {
       return writeError(context, error);
     }
   });
 
-  app.get("/v1/users", async (context) => {
+  app.get("/v1/waitlist/:entryId", async (context) => {
     try {
-      const username = context.req.query("username") ?? "";
-      return context.json({ user: await service.getUserByUsername(username) });
+      return context.json({ entry: await service.getWaitlistEntry(context.req.param("entryId")) });
     } catch (error) {
       return writeError(context, error);
     }
   });
 
-  app.post("/v1/conversations", async (context) => {
+  app.get("/v1/admin/waitlist", async (context) => {
     try {
-      const body = await context.req.json();
-      const conversation = await service.createConversation({
-        createdByUserId: String(body.created_by_user_id ?? body.createdByUserId ?? ""),
-        title: body.title ?? null,
-        participantUserIds: Array.isArray(body.participant_user_ids ?? body.participantUserIds)
-          ? (body.participant_user_ids ?? body.participantUserIds).map(String)
-          : [],
-      });
-      return context.json({ conversation }, 201);
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.get("/v1/conversations/:conversationId", async (context) => {
-    try {
-      return context.json({ conversation: await service.getConversation(context.req.param("conversationId")) });
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.patch("/v1/conversations/:conversationId", async (context) => {
-    try {
-      const body = await context.req.json();
       return context.json({
-        conversation: await service.updateConversation(context.req.param("conversationId"), {
-          title: body.title ?? null,
+        entries: await service.listWaitlistEntries({
+          status: context.req.query("status"),
+          limit: parseOptionalNumber(context.req.query("limit")),
         }),
       });
     } catch (error) {
@@ -81,159 +62,46 @@ export function createApp(service: ChatService) {
     }
   });
 
-  app.delete("/v1/conversations/:conversationId", async (context) => {
-    try {
-      await service.deleteConversation(context.req.param("conversationId"));
-      return context.body(null, 204);
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.post("/v1/conversations/:conversationId/participants", async (context) => {
+  app.patch("/v1/admin/waitlist/:entryId", async (context) => {
     try {
       const body = await context.req.json();
-      return context.json(
-        {
-          conversation: await service.addParticipant(
-            context.req.param("conversationId"),
-            String(body.user_id ?? body.userId ?? "")
-          ),
-        },
-        201
-      );
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.delete("/v1/conversations/:conversationId/participants/:userId", async (context) => {
-    try {
-      await service.removeParticipant(context.req.param("conversationId"), context.req.param("userId"));
-      return context.body(null, 204);
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.get("/v1/conversations/:conversationId/messages", async (context) => {
-    try {
-      const limit = context.req.query("limit");
-      const result = await service.listMessages(context.req.param("conversationId"), {
-        cursor: context.req.query("cursor") ?? undefined,
-        limit: limit == null ? undefined : Number(limit),
-      });
       return context.json({
-        messages: result.messages.map((message) => ({
-          id: message.id,
-          conversation_id: message.conversationId,
-          user_id: message.userId,
-          body: message.body,
-          edited_at: message.editedAt,
-          created_at: message.createdAt,
-          updated_at: message.updatedAt,
-          attachments: message.attachments.map((attachment) => ({
-            id: attachment.id,
-            filename: attachment.filename,
-            content_type: attachment.contentType,
-            byte_size: attachment.byteSize,
-            status: attachment.status,
-            public_url: attachment.publicUrl,
-          })),
-        })),
-        ...(result.nextCursor ? { next_cursor: result.nextCursor } : {}),
+        entry: await service.updateWaitlistEntry({
+          entryId: context.req.param("entryId"),
+          status: String(body.status ?? ""),
+        }),
       });
     } catch (error) {
       return writeError(context, error);
     }
   });
 
-  app.post("/v1/conversations/:conversationId/messages", async (context) => {
-    try {
-      const body = await context.req.json();
-      return context.json(
-        {
-          message: await service.createMessage(context.req.param("conversationId"), {
-            userId: String(body.user_id ?? body.userId ?? ""),
-            body: String(body.body ?? ""),
-          }),
-        },
-        201
-      );
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.patch("/v1/conversations/:conversationId/messages/:messageId", async (context) => {
+  app.get("/v1/admin/waitlist/export", async (context) => {
     try {
-      const body = await context.req.json();
-      return context.json({
-        message: await service.updateMessage(
-          context.req.param("conversationId"),
-          context.req.param("messageId"),
-          { body: String(body.body ?? "") }
-        ),
+      const csv = await service.exportWaitlistEntries({
+        status: context.req.query("status"),
+        limit: parseOptionalNumber(context.req.query("limit")),
       });
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.delete("/v1/conversations/:conversationId/messages/:messageId", async (context) => {
-    try {
-      await service.deleteMessage(context.req.param("conversationId"), context.req.param("messageId"));
-      return context.body(null, 204);
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.post("/v1/attachments/uploads", async (context) => {
-    try {
-      const body = await context.req.json();
-      return context.json(
-        {
-          result: await service.createAttachmentUpload({
-            conversationId: String(body.conversation_id ?? body.conversationId ?? ""),
-            uploadedByUserId: String(body.user_id ?? body.userId ?? ""),
-            filename: String(body.filename ?? ""),
-            contentType: String(body.content_type ?? body.contentType ?? ""),
-            byteSize: Number(body.byte_size ?? body.byteSize ?? 0),
-          }),
+      return new Response(csv, {
+        headers: {
+          "Content-Type": "text/csv; charset=utf-8",
+          "Content-Disposition": 'attachment; filename="waitlist.csv"',
         },
-        201
-      );
+      });
     } catch (error) {
       return writeError(context, error);
     }
   });
 
-  app.post("/v1/attachments/:attachmentId/finalize", async (context) => {
+  app.post("/v1/triggers/waitlist", async (context) => {
     try {
       const body = await context.req.json().catch(() => ({}));
-      return context.json({
-        attachment: await service.finalizeAttachment(context.req.param("attachmentId"), {
-          messageId: body.message_id ?? body.messageId ?? null,
-        }),
+      const trigger = await service.recordTrigger({
+        type: String(body.type ?? "manual"),
+        entryId: body.entry_id ?? body.entryId ?? null,
+        payload: body,
       });
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.get("/v1/attachments/:attachmentId", async (context) => {
-    try {
-      return context.json({ attachment: await service.getAttachment(context.req.param("attachmentId")) });
-    } catch (error) {
-      return writeError(context, error);
-    }
-  });
-
-  app.delete("/v1/attachments/:attachmentId", async (context) => {
-    try {
-      await service.deleteAttachment(context.req.param("attachmentId"));
-      return context.body(null, 204);
+      return context.json({ trigger }, 202);
     } catch (error) {
       return writeError(context, error);
     }
@@ -242,8 +110,15 @@ export function createApp(service: ChatService) {
   app.post("/webhooks/:provider", async (context) => {
     try {
       const rawBody = await context.req.text();
-      const result = await service.processWebhook(context.req.param("provider"), context.req.raw.headers, rawBody);
-      return context.json(result, result.duplicate ? 200 : 202);
+      const trigger = await service.recordTrigger({
+        type: `webhook.${context.req.param("provider")}`,
+        entryId: null,
+        payload: {
+          headers: Object.fromEntries(context.req.raw.headers),
+          rawBody,
+        },
+      });
+      return context.json({ trigger }, 202);
     } catch (error) {
       return writeError(context, error);
     }
@@ -258,13 +133,23 @@ function writeError(context: any, error: unknown) {
   if (error instanceof AppError) {
     return context.json({ error: error.message, code: error.code }, error.status);
   }
-  return context.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+
+  console.error(error);
+  return context.json({ error: "internal server error", code: "internal" }, 500);
+}
+
+function parseOptionalNumber(value: string | undefined) {
+  return value ? Number(value) : null;
 }
 
 if (import.meta.main) {
-  const app = createApp(createDefaultChatService());
+  const temporalWorker = await startTemporalWorker();
+  if (temporalWorker) {
+    console.log(`Temporal worker polling ${temporalWorker.taskQueue}`);
+  }
+
   Bun.serve({
-    port: Number(Bun.env.PORT ?? 8080),
-    fetch: app.fetch,
+    port: Number(Bun.env.PORT ?? 3000),
+    fetch: createApp(createDefaultWaitlistService()).fetch,
   });
 }

package/templates/variants/bun-hono/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-hono/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-hono/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-hono/src/waitlist/service.ts

@@ -0,0 +1,166 @@
+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,
+      payload: { 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,
+      payload: input.payload ?? {},
+    });
+  }
+}
+
+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('"', '""')}"`;
+}

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

@@ -0,0 +1,50 @@
+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";
+  payload: unknown;
+  createdAt: string;
+  processedAt: string | null;
+};
+
+export type JoinWaitlistInput = {
+  email: string;
+  name?: string | null;
+  company?: string | null;
+  source?: string | null;
+};
+
+export type JoinWaitlistResult = {
+  entry: WaitlistEntry;
+  created: boolean;
+};
+
+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;
+  payload?: unknown;
+};