create-svc 0.1.10 → 0.1.11

package/templates/variants/go-connectrpc/internal/httpapi/routes.go

@@ -13,7 +13,7 @@ import (
 	"{{MODULE_PATH}}/internal/app"
 )
 
-func RegisterRoutes(router chi.Router, service *app.ChatService) {
+func RegisterRoutes(router chi.Router, service *app.WaitlistService) {
 	router.Get("/healthz", func(w http.ResponseWriter, _ *http.Request) {
 		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
 	})
@@ -23,27 +23,125 @@ func RegisterRoutes(router chi.Router, service *app.ChatService) {
 	router.Get("/", func(w http.ResponseWriter, _ *http.Request) {
 		writeJSON(w, http.StatusOK, map[string]string{
 			"service":   "{{SERVICE_NAME}}",
-			"domain":    "chat",
+			"domain":    "waitlist",
 			"apiOrigin": "https://api.{{SERVICE_NAME}}.anmho.com",
 		})
 	})
 
+	router.Post("/v1/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		var input app.JoinWaitlistInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		result, err := service.JoinWaitlist(request.Context(), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		status := http.StatusOK
+		if result.Created {
+			status = http.StatusCreated
+		}
+		writeJSON(w, status, result)
+	})
+
+	router.Get("/v1/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		entry, err := service.GetEntryByEmail(request.Context(), request.URL.Query().Get("email"))
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"entry": entry})
+	})
+
+	router.Get("/v1/waitlist/{entryID}", func(w http.ResponseWriter, request *http.Request) {
+		entry, err := service.GetEntry(request.Context(), chi.URLParam(request, "entryID"))
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"entry": entry})
+	})
+
+	router.Get("/v1/admin/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		entries, err := service.ListEntries(request.Context(), app.ListWaitlistEntriesInput{
+			Status: request.URL.Query().Get("status"),
+			Limit:  optionalInt(request.URL.Query().Get("limit")),
+		})
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"entries": entries})
+	})
+
+	router.Get("/v1/admin/waitlist/export", func(w http.ResponseWriter, request *http.Request) {
+		csv, err := service.ExportEntries(request.Context(), app.ListWaitlistEntriesInput{
+			Status: request.URL.Query().Get("status"),
+			Limit:  optionalInt(request.URL.Query().Get("limit")),
+		})
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		w.Header().Set("Content-Type", "text/csv; charset=utf-8")
+		w.Header().Set("Content-Disposition", `attachment; filename="waitlist.csv"`)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(csv))
+	})
+
+	router.Patch("/v1/admin/waitlist/{entryID}", func(w http.ResponseWriter, request *http.Request) {
+		var input app.UpdateWaitlistEntryInput
+		if err := decodeJSON(request, &input); err != nil {
+			writeError(w, err)
+			return
+		}
+		input.EntryID = chi.URLParam(request, "entryID")
+		entry, err := service.UpdateEntry(request.Context(), input)
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"entry": entry})
+	})
+
+	router.Post("/v1/triggers/waitlist", func(w http.ResponseWriter, request *http.Request) {
+		var payload map[string]any
+		if err := decodeOptionalJSON(request, &payload); err != nil {
+			writeError(w, err)
+			return
+		}
+		trigger, err := service.RecordTrigger(request.Context(), app.RecordTriggerInput{
+			Type:    stringValue(payload, "type", "manual"),
+			EntryID: stringValue(payload, "entry_id", ""),
+			Payload: payload,
+		})
+		if err != nil {
+			writeError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusAccepted, map[string]any{"trigger": trigger})
+	})
+
 	router.Post("/webhooks/{provider}", func(w http.ResponseWriter, request *http.Request) {
 		rawBody, err := io.ReadAll(request.Body)
 		if err != nil {
 			writeError(w, err)
 			return
 		}
-		event, duplicate, err := service.ProcessWebhook(request.Context(), chi.URLParam(request, "provider"), request.Header, rawBody)
+		trigger, err := service.RecordTrigger(request.Context(), app.RecordTriggerInput{
+			Type: "webhook." + chi.URLParam(request, "provider"),
+			Payload: map[string]any{
+				"headers": request.Header,
+				"rawBody": string(rawBody),
+			},
+		})
 		if err != nil {
 			writeError(w, err)
 			return
 		}
-		status := http.StatusAccepted
-		if duplicate {
-			status = http.StatusOK
-		}
-		writeJSON(w, status, map[string]any{"event": event, "duplicate": duplicate})
+		writeJSON(w, http.StatusAccepted, map[string]any{"trigger": trigger})
 	})
 
 	router.Get("/webhooks/{provider}/health", func(w http.ResponseWriter, request *http.Request) {
@@ -54,6 +152,20 @@ func RegisterRoutes(router chi.Router, service *app.ChatService) {
 	})
 }
 
+func decodeJSON(request *http.Request, out any) error {
+	defer request.Body.Close()
+	return json.NewDecoder(request.Body).Decode(out)
+}
+
+func decodeOptionalJSON(request *http.Request, out any) error {
+	defer request.Body.Close()
+	decoder := json.NewDecoder(request.Body)
+	if err := decoder.Decode(out); err != nil && !errors.Is(err, io.EOF) {
+		return err
+	}
+	return nil
+}
+
 func writeJSON(w http.ResponseWriter, status int, payload any) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)
@@ -71,8 +183,34 @@ func writeError(w http.ResponseWriter, err error) {
 	}
 
 	status := http.StatusInternalServerError
-	if errors.Is(err, strconv.ErrSyntax) || strings.Contains(strings.ToLower(err.Error()), "json") {
+	if strings.Contains(strings.ToLower(err.Error()), "json") {
 		status = http.StatusBadRequest
 	}
 	writeJSON(w, status, map[string]string{"error": err.Error()})
 }
+
+func stringValue(values map[string]any, key string, fallback string) string {
+	if values == nil {
+		return fallback
+	}
+	value, ok := values[key]
+	if !ok && key == "entry_id" {
+		value, ok = values["entryId"]
+	}
+	if !ok {
+		return fallback
+	}
+	text, ok := value.(string)
+	if !ok {
+		return fallback
+	}
+	return strings.TrimSpace(text)
+}
+
+func optionalInt(value string) int {
+	parsed, err := strconv.Atoi(strings.TrimSpace(value))
+	if err != nil {
+		return 0
+	}
+	return parsed
+}

package/templates/variants/go-connectrpc/internal/temporal/activities.go

@@ -0,0 +1,27 @@
+package temporalapp
+
+import "context"
+
+type WaitlistFollowUpInput struct {
+	TriggerID string
+	Email     string
+	Type      string
+}
+
+type WaitlistFollowUpResult struct {
+	Status    string
+	TriggerID string
+	Email     string
+	Type      string
+}
+
+type Activities struct{}
+
+func (a *Activities) RecordWaitlistFollowUp(ctx context.Context, input WaitlistFollowUpInput) (WaitlistFollowUpResult, error) {
+	return WaitlistFollowUpResult{
+		Status:    "queued",
+		TriggerID: input.TriggerID,
+		Email:     input.Email,
+		Type:      input.Type,
+	}, nil
+}

package/templates/variants/go-connectrpc/internal/temporal/worker.go

@@ -0,0 +1,42 @@
+package temporalapp
+
+import (
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/worker"
+)
+
+type WorkerConfig struct {
+	Address   string
+	Namespace string
+	TaskQueue string
+	APIKey    string
+}
+
+func StartWorker(cfg WorkerConfig) (func(), error) {
+	options := client.Options{
+		HostPort:  cfg.Address,
+		Namespace: cfg.Namespace,
+	}
+	if cfg.APIKey != "" {
+		options.Credentials = client.NewAPIKeyStaticCredentials(cfg.APIKey)
+	}
+
+	temporalClient, err := client.Dial(options)
+	if err != nil {
+		return nil, err
+	}
+
+	temporalWorker := worker.New(temporalClient, cfg.TaskQueue, worker.Options{})
+	temporalWorker.RegisterWorkflow(WaitlistFollowUpWorkflow)
+	temporalWorker.RegisterActivity(&Activities{})
+
+	if err := temporalWorker.Start(); err != nil {
+		temporalClient.Close()
+		return nil, err
+	}
+
+	return func() {
+		temporalWorker.Stop()
+		temporalClient.Close()
+	}, nil
+}

package/templates/variants/go-connectrpc/internal/temporal/workflows.go

@@ -0,0 +1,18 @@
+package temporalapp
+
+import (
+	"time"
+
+	"go.temporal.io/sdk/workflow"
+)
+
+func WaitlistFollowUpWorkflow(ctx workflow.Context, input WaitlistFollowUpInput) (WaitlistFollowUpResult, error) {
+	options := workflow.ActivityOptions{
+		StartToCloseTimeout: time.Minute,
+	}
+	ctx = workflow.WithActivityOptions(ctx, options)
+
+	var result WaitlistFollowUpResult
+	err := workflow.ExecuteActivity(ctx, "RecordWaitlistFollowUp", input).Get(ctx, &result)
+	return result, err
+}

package/templates/variants/go-connectrpc/migrations/0000_init.sql

@@ -1,63 +1,20 @@
-create table if not exists users (
+create table if not exists waitlist_entries (
   id text primary key,
-  username text not null unique,
-  display_name text,
+  email text not null unique,
+  name text,
+  company text,
+  source text,
+  status text not null default 'joined',
   created_at timestamptz not null default now(),
   updated_at timestamptz not null default now()
 );
 
-create table if not exists conversations (
+create table if not exists waitlist_triggers (
   id text primary key,
-  title text,
-  created_by_user_id text not null references users(id),
-  deleted_at timestamptz,
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists conversation_participants (
-  conversation_id text not null references conversations(id),
-  user_id text not null references users(id),
-  joined_at timestamptz not null default now(),
-  primary key (conversation_id, user_id)
-);
-
-create table if not exists messages (
-  id text primary key,
-  conversation_id text not null references conversations(id),
-  user_id text not null references users(id),
-  body text not null,
-  edited_at timestamptz,
-  deleted_at timestamptz,
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists attachments (
-  id text primary key,
-  conversation_id text not null references conversations(id),
-  message_id text references messages(id),
-  uploaded_by_user_id text not null references users(id),
-  storage_bucket text not null,
-  storage_key text not null,
-  content_type text not null,
-  byte_size bigint not null,
-  filename text not null,
-  status text not null,
-  deleted_at timestamptz,
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now()
-);
-
-create table if not exists webhook_events (
-  id text primary key,
-  provider text not null,
-  external_event_id text not null,
-  event_type text not null,
-  signature_valid text not null,
-  status text not null,
+  type text not null,
+  entry_id text references waitlist_entries(id),
+  status text not null default 'queued',
   payload_json text not null,
-  received_at timestamptz not null default now(),
-  processed_at timestamptz,
-  unique (provider, external_event_id)
+  created_at timestamptz not null default now(),
+  processed_at timestamptz
 );

package/templates/variants/go-connectrpc/migrations/atlas.sum

@@ -0,0 +1,2 @@
+h1:D9GgvtEf0xxnRDaTb/C3cPtRbncVXsK6Ef0KYQuLMRw=
+0000_init.sql h1:dBpLGyoeZNRpjT6RvQXiqx3p2ICAChKy2jVqCIYuWQg=

package/templates/variants/go-connectrpc/package.json

@@ -3,9 +3,15 @@
   "private": true,
   "type": "module",
   "bin": {
-    "svc-cloudrun": "./scripts/cloudrun/cli.ts"
+    "service": "./scripts/cloudrun/cli.ts"
+  },
+  "scripts": {
+    "service": "bun run ./scripts/cloudrun/cli.ts",
+    "auth": "bun run ./scripts/cloudrun/cli.ts auth",
+    "dashboards": "bun run ./scripts/cloudrun/cli.ts dashboards"
   },
   "dependencies": {
+    "@anmho/authctl": "0.1.1",
     "@clack/prompts": "^1.2.0",
     "@neondatabase/api-client": "^2.7.1"
   }

package/templates/variants/go-connectrpc/protos/waitlist/v1/waitlist.proto

@@ -0,0 +1,93 @@
+syntax = "proto3";
+
+package waitlist.v1;
+
+option go_package = "{{MODULE_PATH}}/gen/waitlist/v1;waitlistv1";
+
+service WaitlistService {
+  rpc JoinWaitlist(JoinWaitlistRequest) returns (JoinWaitlistResponse);
+  rpc GetWaitlistEntry(GetWaitlistEntryRequest) returns (GetWaitlistEntryResponse);
+  rpc GetWaitlistEntryByEmail(GetWaitlistEntryByEmailRequest) returns (GetWaitlistEntryResponse);
+  rpc ListWaitlistEntries(ListWaitlistEntriesRequest) returns (ListWaitlistEntriesResponse);
+  rpc UpdateWaitlistEntry(UpdateWaitlistEntryRequest) returns (GetWaitlistEntryResponse);
+  rpc ExportWaitlistEntries(ExportWaitlistEntriesRequest) returns (ExportWaitlistEntriesResponse);
+  rpc RecordTrigger(RecordTriggerRequest) returns (RecordTriggerResponse);
+}
+
+message WaitlistEntry {
+  string id = 1;
+  string email = 2;
+  string name = 3;
+  string company = 4;
+  string source = 5;
+  string status = 6;
+  string created_at = 7;
+  string updated_at = 8;
+}
+
+message WaitlistTrigger {
+  string id = 1;
+  string type = 2;
+  string entry_id = 3;
+  string status = 4;
+  string payload_json = 5;
+  string created_at = 6;
+  string processed_at = 7;
+}
+
+message JoinWaitlistRequest {
+  string email = 1;
+  string name = 2;
+  string company = 3;
+  string source = 4;
+}
+
+message JoinWaitlistResponse {
+  WaitlistEntry entry = 1;
+  bool created = 2;
+}
+
+message GetWaitlistEntryRequest {
+  string entry_id = 1;
+}
+
+message GetWaitlistEntryByEmailRequest {
+  string email = 1;
+}
+
+message GetWaitlistEntryResponse {
+  WaitlistEntry entry = 1;
+}
+
+message ListWaitlistEntriesRequest {
+  string status = 1;
+  uint32 limit = 2;
+}
+
+message ListWaitlistEntriesResponse {
+  repeated WaitlistEntry entries = 1;
+}
+
+message UpdateWaitlistEntryRequest {
+  string entry_id = 1;
+  string status = 2;
+}
+
+message ExportWaitlistEntriesRequest {
+  string status = 1;
+  uint32 limit = 2;
+}
+
+message ExportWaitlistEntriesResponse {
+  string csv = 1;
+}
+
+message RecordTriggerRequest {
+  string type = 1;
+  string entry_id = 2;
+  string payload_json = 3;
+}
+
+message RecordTriggerResponse {
+  WaitlistTrigger trigger = 1;
+}

package/templates/root/.github/workflows/buf-publish.yml

@@ -1,19 +0,0 @@
-name: buf-publish
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "protos/**"
-
-jobs:
-  publish:
-    if: ${{ vars.BUF_MODULE != '' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: bufbuild/buf-setup-action@v1
-      - run: buf push
-        env:
-          BUF_TOKEN: ${{ secrets.BUF_TOKEN }}

package/templates/root/.github/workflows/ci.yml

@@ -1,26 +0,0 @@
-name: ci
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version: '1.25.4'
-      - uses: oven-sh/setup-bun@v2
-      - uses: bufbuild/buf-setup-action@v1
-      - name: Install proto plugins
-        run: |
-          go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.36.10
-          go install connectrpc.com/connect/cmd/protoc-gen-connect-go@v1.19.1
-          echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH"
-      - run: bun gen
-      - run: bun lint
-      - run: bun test

package/templates/root/.github/workflows/deploy.yml

@@ -1,22 +0,0 @@
-name: deploy
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-      - uses: google-github-actions/auth@v3
-        with:
-          workload_identity_provider: ${{ vars.GCP_WIF_PROVIDER }}
-          service_account: ${{ vars.GCP_DEPLOYER_SERVICE_ACCOUNT }}
-      - uses: google-github-actions/setup-gcloud@v2
-      - run: bun run deploy -- --ci

package/templates/root/Dockerfile

@@ -1,23 +0,0 @@
-FROM golang:1.25.4 AS builder
-
-WORKDIR /app
-
-COPY go.mod ./
-COPY gen ./gen
-COPY internal ./internal
-COPY cmd ./cmd
-
-RUN go mod download
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/server ./cmd/server
-
-FROM gcr.io/distroless/base-debian12
-
-WORKDIR /app
-
-COPY --from=builder /out/server /app/server
-
-ENV PORT=8080
-
-EXPOSE 8080
-
-ENTRYPOINT ["/app/server"]

package/templates/root/README.md

@@ -1,69 +0,0 @@
-# {{SERVICE_NAME}}
-
-Cloud Run API scaffold generated by `create-service`.
-
-## What it includes
-
-- Chi HTTP routes
-- ConnectRPC handlers
-- real Cloud Run service manifest in [service.yaml](service.yaml)
-- Bun-based Cloud Run deploy config in [scripts/cloudrun/config.ts](scripts/cloudrun/config.ts)
-- Vault-backed Cloudflare DNS CRUD example
-- script-first deployment via Bun
-
-## Prerequisites
-
-- Bun
-- Go 1.25+
-- `gcloud`
-- `gh`
-- `buf`
-- `protoc`
-- `protoc-gen-go`
-- `protoc-gen-connect-go`
-
-Install the Go protobuf plugins:
-
-```bash
-go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.36.10
-go install connectrpc.com/connect/cmd/protoc-gen-connect-go@v1.19.1
-```
-
-## Commands
-
-```bash
-bun dev
-bun gen
-bun lint
-bun test
-bun run deploy
-```
-
-`bun test` uses Bun's test runner to invoke `go test ./...` so the command surface stays Bun-first.
-
-## First deploy
-
-The runtime reads Vault AppRole credentials from Secret Manager. On the first deploy, seed those two secret values locally:
-
-```bash
-export BOOTSTRAP_VAULT_ROLE_ID=...
-export BOOTSTRAP_VAULT_SECRET_ID=...
-bun run deploy
-```
-
-`bun run deploy` will:
-
-1. enable required GCP services
-2. create runtime and deployer service accounts
-3. create the Secret Manager secrets if missing
-4. wire GitHub OIDC for `main` deploys
-5. build the image and apply the Cloud Run manifest through the Bun deploy helper
-
-## Local fallback
-
-For local development, you can skip Vault and provide the Cloudflare token directly:
-
-```bash
-export CLOUDFLARE_API_TOKEN=...
-bun dev
-```

package/templates/root/buf.gen.yaml

@@ -1,10 +0,0 @@
-version: v2
-plugins:
-  - local: protoc-gen-go
-    out: gen
-    opt:
-      - paths=source_relative
-  - local: protoc-gen-connect-go
-    out: gen
-    opt:
-      - paths=source_relative

package/templates/root/buf.yaml

@@ -1,9 +0,0 @@
-version: v2
-modules:
-  - path: protos
-lint:
-  use:
-    - STANDARD
-breaking:
-  use:
-    - FILE