create-svc 0.1.9 → 0.1.11

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;
+};

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

@@ -1,12 +1,97 @@
 import { expect, test } from "bun:test";
 import { createApp } from "../src/index";
+import type { WaitlistService } from "../src/waitlist/service";
+import type { WaitlistEntry } from "../src/waitlist/types";
 
 test("health endpoint returns ok", async () => {
-  const response = await createApp().request("/healthz");
+  const response = await createApp(createMockService()).request("/healthz");
   expect(response.status).toBe(200);
-  expect(await response.json()).toEqual({
-    status: "ok",
-    runtime: "bun",
-    framework: "hono",
+  expect(await response.json()).toEqual({ status: "ok" });
+});
+
+test("webhook health endpoint returns ok", async () => {
+  const response = await createApp(createMockService()).request("/webhooks/generic/health");
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ status: "ok", provider: "generic" });
+});
+
+test("waitlist join returns created entry", async () => {
+  const response = await createApp(createMockService()).request("/v1/waitlist", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email: "founder@example.com", source: "test" }),
   });
+  expect(response.status).toBe(201);
+  expect(await response.json()).toMatchObject({
+    created: true,
+    entry: {
+      email: "founder@example.com",
+      status: "joined",
+    },
+  });
+});
+
+test("waitlist api requires a bearer token when service auth is enabled", async () => {
+  const previous = Bun.env.AUTH_ENABLED;
+  Bun.env.AUTH_ENABLED = "true";
+  try {
+    const response = await createApp(createMockService()).request("/v1/waitlist", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email: "founder@example.com" }),
+    });
+    expect(response.status).toBe(401);
+    expect(await response.json()).toEqual({ error: "missing bearer token", code: "unauthorized" });
+  } finally {
+    if (previous === undefined) {
+      delete Bun.env.AUTH_ENABLED;
+    } else {
+      Bun.env.AUTH_ENABLED = previous;
+    }
+  }
 });
+
+function createMockService(): WaitlistService {
+  const entry: WaitlistEntry = {
+    id: "entry_1",
+    email: "founder@example.com",
+    name: null,
+    company: null,
+    source: "test",
+    status: "joined",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+  };
+
+  return {
+    async joinWaitlist() {
+      return { entry, created: true };
+    },
+    async getWaitlistEntry() {
+      return entry;
+    },
+    async getWaitlistEntryByEmail() {
+      return entry;
+    },
+    async listWaitlistEntries() {
+      return [entry];
+    },
+    async updateWaitlistEntry() {
+      return { ...entry, status: "invited" };
+    },
+    async exportWaitlistEntries() {
+      return "id,email,name,company,source,status,created_at,updated_at\nentry_1,founder@example.com,,,test,joined,2026-01-01T00:00:00.000Z,2026-01-01T00:00:00.000Z";
+    },
+    async recordTrigger() {
+      return {
+        id: "trigger_1",
+        type: "manual",
+        entryId: null,
+        status: "queued",
+        payload: {},
+        createdAt: "2026-01-01T00:00:00.000Z",
+        processedAt: null,
+      };
+    },
+  };
+}

package/templates/variants/bun-hono/test/waitlist.integration.test.ts

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { SQL } from "bun";
+import { createApp } from "../src/index";
+import { DefaultWaitlistService } from "../src/waitlist/service";
+import { WaitlistRepository } from "../src/db/repository";
+import { createDb } from "../src/db/client";
+
+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
+      waitlist_triggers,
+      waitlist_entries
+    restart identity cascade
+  `);
+});
+
+afterEach(async () => {
+  await sql?.end();
+  sql = null;
+});
+
+integrationTest("waitlist join is idempotent and records triggers", async () => {
+  const app = createApp(new DefaultWaitlistService(new WaitlistRepository(createDb(databaseUrl))));
+
+  const first = await requestJson(app, "/v1/waitlist", {
+    method: "POST",
+    body: {
+      email: "Founder@Example.com",
+      name: "Founder",
+      company: "Example Co",
+      source: "homepage",
+    },
+    expectedStatus: 201,
+  });
+  expect(first.entry.email).toBe("founder@example.com");
+  expect(first.created).toBe(true);
+
+  const second = await requestJson(app, "/v1/waitlist", {
+    method: "POST",
+    body: {
+      email: "founder@example.com",
+    },
+  });
+  expect(second.entry.id).toBe(first.entry.id);
+  expect(second.created).toBe(false);
+
+  const trigger = await requestJson(app, "/v1/triggers/waitlist", {
+    method: "POST",
+    body: {
+      type: "cron.digest",
+      entry_id: first.entry.id,
+    },
+    expectedStatus: 202,
+  });
+  expect(trigger.trigger).toMatchObject({
+    type: "cron.digest",
+    entryId: first.entry.id,
+    status: "queued",
+  });
+
+  const updated = await requestJson(app, `/v1/admin/waitlist/${first.entry.id}`, {
+    method: "PATCH",
+    body: { status: "invited" },
+  });
+  expect(updated.entry).toMatchObject({ id: first.entry.id, status: "invited" });
+
+  const list = await requestJson(app, "/v1/admin/waitlist?status=invited");
+  expect(list.entries).toHaveLength(1);
+  expect(list.entries[0]).toMatchObject({ id: first.entry.id, status: "invited" });
+
+  const exportResponse = await app.request("/v1/admin/waitlist/export?status=invited");
+  expect(exportResponse.status).toBe(200);
+  expect(exportResponse.headers.get("content-type")).toContain("text/csv");
+  expect(await exportResponse.text()).toContain("founder@example.com");
+});
+
+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();
+}

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,25 +1,45 @@
-.PHONY: dev gen lint test bootstrap deploy cleanup
+.PHONY: dev migrate migrate-lint gen lint test create deploy dashboards auth destroy
 
-CLOUDRUN := npx --no-install svc-cloudrun
+SERVICE := npx --no-install service
+WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
+ATLAS ?= atlas
 
 dev:
-	go run ./cmd/server
+	@bun run ./scripts/dev.ts go run ./cmd/server
+
+migrate:
+	@bun run ./scripts/ensure-local-db.ts
+	@bun run ./scripts/wait-for-db.ts
+	@$(WITH_ENV) $(ATLAS) migrate apply --env local
+
+migrate-lint:
+	@bun run ./scripts/ensure-local-db.ts
+	@bun run ./scripts/wait-for-db.ts
+	@$(WITH_ENV) $(ATLAS) migrate lint --env local --latest 1
 
 gen:
-	buf generate
+	@echo "no generated code for go + chi"
 
 lint:
 	go vet ./...
-	buf lint
+	@bun run ./scripts/ensure-local-db.ts
+	@bun run ./scripts/wait-for-db.ts
+	@$(WITH_ENV) $(ATLAS) migrate lint --env local --latest 1
 
 test:
 	bun test ./test
 
-bootstrap:
-	$(CLOUDRUN) bootstrap
+create:
+	$(SERVICE) create
 
 deploy:
-	$(CLOUDRUN) deploy $(ARGS)
+	$(SERVICE) deploy $(ARGS)
+
+dashboards:
+	$(SERVICE) dashboards
+
+auth:
+	$(SERVICE) auth $(ARGS)
 
-cleanup:
-	$(CLOUDRUN) cleanup $(ARGS)
+destroy:
+	$(SERVICE) destroy $(ARGS)

package/templates/variants/go-chi/atlas.hcl

@@ -0,0 +1,8 @@
+env "local" {
+  url = getenv("DATABASE_URL")
+  dev = "docker://postgres/16/dev?search_path=public"
+
+  migration {
+    dir = "file://migrations"
+  }
+}

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

@@ -7,13 +7,15 @@ import (
 	"time"
 
 	"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/auth"
 	"{{MODULE_PATH}}/internal/config"
-	"{{MODULE_PATH}}/internal/connectapi"
 	"{{MODULE_PATH}}/internal/httpapi"
+	temporalapp "{{MODULE_PATH}}/internal/temporal"
 )
 
 func main() {
@@ -22,25 +24,35 @@ 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 {
+	db, err := app.OpenDatabase(context.Background(), cfg.DatabaseURL)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	service := app.NewWaitlistService(db)
+	if cfg.TemporalEnabled {
+		stopTemporal, err := temporalapp.StartWorker(temporalapp.WorkerConfig{
+			Address:   cfg.TemporalAddress,
+			Namespace: cfg.TemporalNamespace,
+			TaskQueue: cfg.TemporalTaskQueue,
+			APIKey:    cfg.TemporalAPIKey,
+		})
+		if err != nil {
 			log.Fatal(err)
 		}
+		defer stopTemporal()
+		log.Printf("Temporal worker polling %s", cfg.TemporalTaskQueue)
 	}
 
 	router := chi.NewRouter()
+	router.Use(auth.Middleware(auth.Config{
+		Enabled:  cfg.AuthEnabled,
+		Issuer:   cfg.AuthIssuer,
+		Audience: cfg.AuthAudience,
+		JWKSURL:  cfg.AuthJWKSURL,
+	}))
 	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,9 @@ module {{MODULE_PATH}}
 go 1.25.4
 
 require (
-	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
+	go.temporal.io/sdk v1.43.0
 	golang.org/x/net v0.42.0
-	google.golang.org/protobuf v1.36.10
 )