create-svc 0.1.10 → 0.1.12

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

@@ -1,6 +1,7 @@
 import { expect, test } from "bun:test";
 import { createApp } from "../src/index";
-import type { ChatService } from "../src/chat/service";
+import type { WaitlistService } from "../src/waitlist/service";
+import type { WaitlistEntry } from "../src/waitlist/types";
 
 test("health endpoint returns ok", async () => {
   const response = await createApp(createMockService()).request("/healthz");
@@ -14,53 +15,83 @@ test("webhook health endpoint returns ok", async () => {
   expect(await response.json()).toEqual({ status: "ok", provider: "generic" });
 });
 
-function createMockService(): ChatService {
-  return {
-    async createUser() {
-      throw new Error("not implemented");
-    },
-    async getUser() {
-      throw new Error("not implemented");
-    },
-    async getUserByUsername() {
-      throw new Error("not implemented");
-    },
-    async createConversation() {
-      throw new Error("not implemented");
-    },
-    async getConversation() {
-      throw new Error("not implemented");
-    },
-    async updateConversation() {
-      throw new Error("not implemented");
-    },
-    async deleteConversation() {},
-    async addParticipant() {
-      throw new Error("not implemented");
+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",
     },
-    async removeParticipant() {},
-    async listMessages() {
-      return { messages: [] };
+  });
+});
+
+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 createMessage() {
-      throw new Error("not implemented");
+    async getWaitlistEntry() {
+      return entry;
     },
-    async updateMessage() {
-      throw new Error("not implemented");
+    async getWaitlistEntryByEmail() {
+      return entry;
     },
-    async deleteMessage() {},
-    async createAttachmentUpload() {
-      throw new Error("not implemented");
+    async listWaitlistEntries() {
+      return [entry];
     },
-    async finalizeAttachment() {
-      throw new Error("not implemented");
+    async updateWaitlistEntry() {
+      return { ...entry, status: "invited" };
     },
-    async getAttachment() {
-      throw new Error("not implemented");
+    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 deleteAttachment() {},
-    async processWebhook() {
-      throw new Error("not implemented");
+    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/go-chi/Makefile

@@ -1,29 +1,45 @@
-.PHONY: dev migrate 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:
-	@$(WITH_ENV) go run ./cmd/server
+	@bun run ./scripts/dev.ts go run ./cmd/server
 
 migrate:
-	@$(WITH_ENV) go run ./cmd/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

@@ -6,15 +6,16 @@ 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/auth"
 	"{{MODULE_PATH}}/internal/config"
 	"{{MODULE_PATH}}/internal/httpapi"
+	temporalapp "{{MODULE_PATH}}/internal/temporal"
 )
 
 func main() {
@@ -28,18 +29,28 @@ func main() {
 		log.Fatal(err)
 	}
 
-	storageClient, err := storage.NewClient(context.Background())
-	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)
 	}
 
-	service := app.NewChatService(
-		db,
-		app.NewGCSStorage(cfg.AttachmentBucket, cfg.AttachmentPublicBaseURL, storageClient),
-		app.GenericWebhookAdapter{},
-	)
-
 	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)
 
 	server := &http.Server{

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

@@ -3,11 +3,9 @@ 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
+	go.temporal.io/sdk v1.43.0
 	golang.org/x/net v0.42.0
-	google.golang.org/protobuf v1.36.10
 )