create-svc 0.1.62 → 0.1.64

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

@@ -0,0 +1,56 @@
+export type TemporalRuntimeConfig = {
+  enabled: boolean;
+  address: string;
+  namespace: string;
+  taskQueue: string;
+};
+
+type Env = Record<string, string | undefined>;
+
+export function resolveTemporalRuntimeConfig(env: Env = Bun.env): TemporalRuntimeConfig {
+  const enabled = readBoolean(env.TEMPORAL_ENABLED, true);
+  const cloudRun = isCloudRun(env);
+
+  return {
+    enabled,
+    address: readString(env.TEMPORAL_ADDRESS, cloudRun ? "" : "localhost:7233"),
+    namespace: readString(env.TEMPORAL_NAMESPACE, cloudRun ? "" : "default"),
+    taskQueue: readString(env.TEMPORAL_TASK_QUEUE, "{{SERVICE_NAME}}"),
+  };
+}
+
+export function assertTemporalRuntimeConfig(config = resolveTemporalRuntimeConfig()) {
+  if (!config.enabled) {
+    return config;
+  }
+
+  const missing = [
+    config.address ? "" : "TEMPORAL_ADDRESS",
+    config.namespace ? "" : "TEMPORAL_NAMESPACE",
+  ].filter(Boolean);
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Temporal is enabled, but ${missing.join(" and ")} ${missing.length === 1 ? "is" : "are"} required. Set Temporal Cloud connection settings or TEMPORAL_ENABLED=false.`
+    );
+  }
+
+  return config;
+}
+
+function readBoolean(value: string | undefined, fallback: boolean) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  return !["0", "false", "no", "off"].includes(normalized);
+}
+
+function readString(value: string | undefined, fallback: string) {
+  const normalized = value?.trim();
+  return normalized || fallback;
+}
+
+function isCloudRun(env: Env) {
+  return Boolean(env.K_SERVICE?.trim());
+}

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

@@ -1,5 +1,6 @@
 import { createDb } from "../db/client";
 import { WaitlistRepository } from "../db/repository";
+import { startWaitlistFollowUpWorkflow } from "../temporal/client";
 import type {
   JoinWaitlistInput,
   ListWaitlistEntriesInput,
@@ -109,12 +110,20 @@ export class DefaultWaitlistService implements WaitlistService {
       await this.getWaitlistEntry(input.entryId);
     }
 
-    return this.repository.createTrigger({
+    const trigger = await this.repository.createTrigger({
       id: crypto.randomUUID(),
       type,
       entryId: input.entryId?.trim() || null,
       payload: input.payload ?? {},
     });
+
+    startWaitlistFollowUpWorkflow({
+      triggerId: trigger.id,
+      email: trigger.payload && typeof trigger.payload === "object" && "email" in trigger.payload ? String(trigger.payload.email) : undefined,
+      type: trigger.type,
+    }).catch((error) => console.error("failed to start waitlist follow-up workflow", error));
+
+    return trigger;
   }
 
   async recordWebhookEvent(input: RecordWebhookEventInput) {

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

@@ -0,0 +1,21 @@
+import { assertTemporalRuntimeConfig } from "./temporal";
+import { startTemporalWorker } from "./temporal/worker";
+
+assertTemporalRuntimeConfig();
+const temporalWorker = await startTemporalWorker();
+if (!temporalWorker) {
+  throw new Error("Temporal worker is disabled. Set TEMPORAL_ENABLED=true or do not run the worker process.");
+}
+
+console.log(`Temporal worker polling ${temporalWorker.taskQueue}`);
+
+Bun.serve({
+  port: Number(Bun.env.PORT ?? 8080),
+  fetch: (request) => {
+    const path = new URL(request.url).pathname;
+    if (path === "/healthz" || path === "/readyz") {
+      return Response.json({ status: "ok", worker: "temporal" });
+    }
+    return Response.json({ status: "ok", worker: "temporal" });
+  },
+});

package/templates/variants/go-chi/Dockerfile

@@ -8,12 +8,14 @@ COPY cmd ./cmd
 
 RUN go mod download
 RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/server ./cmd/server
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/worker ./cmd/worker
 
 FROM gcr.io/distroless/base-debian12
 
 WORKDIR /app
 
 COPY --from=builder /out/server /app/server
+COPY --from=builder /out/worker /app/worker
 
 ENV PORT=8080
 

package/templates/variants/go-chi/Makefile

@@ -5,7 +5,7 @@ WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
 ATLAS ?= atlas
 
 dev:
-	@bun run ./scripts/dev.ts go run ./cmd/server
+	@bun run ./scripts/dev.ts go run ./cmd/server --worker go run ./cmd/worker
 
 migrate:
 	@bun run ./scripts/ensure-local-db.ts

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

@@ -31,17 +31,18 @@ func main() {
 
 	service := app.NewWaitlistService(db)
 	if cfg.TemporalEnabled {
-		stopTemporal, err := temporalapp.StartWorker(temporalapp.WorkerConfig{
+		temporalConfig := temporalapp.WorkerConfig{
 			Address:   cfg.TemporalAddress,
 			Namespace: cfg.TemporalNamespace,
 			TaskQueue: cfg.TemporalTaskQueue,
 			APIKey:    cfg.TemporalAPIKey,
-		})
+		}
+		dispatcher, err := temporalapp.NewTriggerDispatcher(temporalConfig)
 		if err != nil {
 			log.Fatal(err)
 		}
-		defer stopTemporal()
-		log.Printf("Temporal worker polling %s", cfg.TemporalTaskQueue)
+		defer dispatcher.Close()
+		service.SetTriggerDispatcher(dispatcher)
 	}
 
 	router := chi.NewRouter()

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

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"{{MODULE_PATH}}/internal/config"
+	temporalapp "{{MODULE_PATH}}/internal/temporal"
+)
+
+func main() {
+	cfg, err := config.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !cfg.TemporalEnabled {
+		log.Fatal("Temporal worker is disabled. Set TEMPORAL_ENABLED=true or do not run the worker process.")
+	}
+
+	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)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", func(w http.ResponseWriter, request *http.Request) {
+		writeWorkerHealth(w)
+	})
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, request *http.Request) {
+		writeWorkerHealth(w)
+	})
+	mux.HandleFunc("/readyz", func(w http.ResponseWriter, request *http.Request) {
+		writeWorkerHealth(w)
+	})
+
+	server := &http.Server{
+		Addr:              ":" + cfg.Port,
+		ReadHeaderTimeout: 10 * time.Second,
+		Handler:           mux,
+	}
+	log.Printf("worker health listening on %s", server.Addr)
+	log.Fatal(server.ListenAndServe())
+}
+
+func writeWorkerHealth(w http.ResponseWriter) {
+	w.Header().Set("Content-Type", "application/json")
+	_, _ = w.Write([]byte(`{"status":"ok","worker":"temporal"}`))
+}

package/templates/variants/go-chi/internal/app/service.go

@@ -12,6 +12,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/stdlib"
 	"github.com/jmoiron/sqlx"
 )
 
@@ -94,20 +96,39 @@ type AppError struct {
 func (e *AppError) Error() string { return e.Err.Error() }
 
 type WaitlistService struct {
-	db *sqlx.DB
+	db                *sqlx.DB
+	triggerDispatcher TriggerDispatcher
+}
+
+type TriggerDispatcher interface {
+	DispatchWaitlistFollowUp(context.Context, WaitlistTrigger) error
 }
 
 func OpenDatabase(ctx context.Context, databaseURL string) (*sqlx.DB, error) {
 	if strings.TrimSpace(databaseURL) == "" {
 		return nil, errors.New("DATABASE_URL is required")
 	}
-	return sqlx.ConnectContext(ctx, "pgx", databaseURL)
+	cfg, err := pgx.ParseConfig(databaseURL)
+	if err != nil {
+		return nil, err
+	}
+	cfg.DefaultQueryExecMode = pgx.QueryExecModeSimpleProtocol
+	db := sqlx.NewDb(stdlib.OpenDB(*cfg), "pgx")
+	if err := db.PingContext(ctx); err != nil {
+		_ = db.Close()
+		return nil, err
+	}
+	return db, nil
 }
 
 func NewWaitlistService(db *sqlx.DB) *WaitlistService {
 	return &WaitlistService{db: db}
 }
 
+func (s *WaitlistService) SetTriggerDispatcher(dispatcher TriggerDispatcher) {
+	s.triggerDispatcher = dispatcher
+}
+
 func (s *WaitlistService) JoinWaitlist(ctx context.Context, input JoinWaitlistInput) (JoinWaitlistResult, error) {
 	email, err := normalizeEmail(input.Email)
 	if err != nil {
@@ -270,7 +291,18 @@ returning id, type, coalesce(entry_id, '') as entry_id, status, payload_json, cr
 	if err != nil {
 		return WaitlistTrigger{}, err
 	}
-	return row.toTrigger()
+	trigger, err := row.toTrigger()
+	if err != nil {
+		return WaitlistTrigger{}, err
+	}
+	if s.triggerDispatcher != nil {
+		go func() {
+			if err := s.triggerDispatcher.DispatchWaitlistFollowUp(context.Background(), trigger); err != nil {
+				fmt.Printf("failed to start waitlist follow-up workflow: %v\n", err)
+			}
+		}()
+	}
+	return trigger, nil
 }
 
 func (s *WaitlistService) RecordWebhookEvent(ctx context.Context, input RecordWebhookEventInput) (RecordWebhookEventResult, error) {

package/templates/variants/go-chi/internal/config/config.go

@@ -24,9 +24,9 @@ func Load() (Config, error) {
 	cfg := Config{
 		Port:              envOr("PORT", "8080"),
 		DatabaseURL:       strings.TrimSpace(os.Getenv("DATABASE_URL")),
-		TemporalEnabled:   envBool("TEMPORAL_ENABLED"),
-		TemporalAddress:   envOr("TEMPORAL_ADDRESS", "localhost:7233"),
-		TemporalNamespace: envOr("TEMPORAL_NAMESPACE", "default"),
+		TemporalEnabled:   envBoolDefault("TEMPORAL_ENABLED", true),
+		TemporalAddress:   envOrRuntime("TEMPORAL_ADDRESS", "localhost:7233"),
+		TemporalNamespace: envOrRuntime("TEMPORAL_NAMESPACE", "default"),
 		TemporalTaskQueue: envOr("TEMPORAL_TASK_QUEUE", "{{SERVICE_NAME}}"),
 		TemporalAPIKey:    strings.TrimSpace(os.Getenv("TEMPORAL_API_KEY")),
 		AuthEnabled:       envBool("AUTH_ENABLED"),
@@ -37,6 +37,18 @@ func Load() (Config, error) {
 	if cfg.DatabaseURL == "" {
 		return Config{}, errors.New("DATABASE_URL is required")
 	}
+	if cfg.TemporalEnabled {
+		missing := make([]string, 0, 2)
+		if cfg.TemporalAddress == "" {
+			missing = append(missing, "TEMPORAL_ADDRESS")
+		}
+		if cfg.TemporalNamespace == "" {
+			missing = append(missing, "TEMPORAL_NAMESPACE")
+		}
+		if len(missing) > 0 {
+			return Config{}, errors.New(strings.Join(missing, " and ") + " required when Temporal is enabled")
+		}
+	}
 	return cfg, nil
 }
 
@@ -45,6 +57,14 @@ func envBool(key string) bool {
 	return value == "1" || value == "true" || value == "yes" || value == "on"
 }
 
+func envBoolDefault(key string, fallback bool) bool {
+	value := strings.TrimSpace(strings.ToLower(os.Getenv(key)))
+	if value == "" {
+		return fallback
+	}
+	return value == "1" || value == "true" || value == "yes" || value == "on"
+}
+
 func envOr(key string, fallback string) string {
 	value := os.Getenv(key)
 	if value != "" {
@@ -52,3 +72,14 @@ func envOr(key string, fallback string) string {
 	}
 	return fallback
 }
+
+func envOrRuntime(key string, localFallback string) string {
+	value := os.Getenv(key)
+	if value != "" {
+		return value
+	}
+	if strings.TrimSpace(os.Getenv("K_SERVICE")) != "" {
+		return ""
+	}
+	return localFallback
+}

package/templates/variants/go-chi/internal/config/config_test.go

@@ -0,0 +1,63 @@
+package config
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestLoadTemporalDefaultsToLocalDevelopment(t *testing.T) {
+	setRequiredEnv(t)
+
+	cfg, err := Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !cfg.TemporalEnabled {
+		t.Fatal("Temporal should default to enabled")
+	}
+	if cfg.TemporalAddress != "localhost:7233" {
+		t.Fatalf("unexpected Temporal address: %s", cfg.TemporalAddress)
+	}
+	if cfg.TemporalNamespace != "default" {
+		t.Fatalf("unexpected Temporal namespace: %s", cfg.TemporalNamespace)
+	}
+	if cfg.TemporalTaskQueue != "{{SERVICE_NAME}}" {
+		t.Fatalf("unexpected Temporal task queue: %s", cfg.TemporalTaskQueue)
+	}
+}
+
+func TestLoadTemporalOptOut(t *testing.T) {
+	setRequiredEnv(t)
+	t.Setenv("K_SERVICE", "svc")
+	t.Setenv("TEMPORAL_ENABLED", "false")
+
+	cfg, err := Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if cfg.TemporalEnabled {
+		t.Fatal("Temporal should be disabled")
+	}
+}
+
+func TestLoadTemporalCloudRunFailsWithoutConnectionSettings(t *testing.T) {
+	setRequiredEnv(t)
+	t.Setenv("K_SERVICE", "svc")
+
+	_, err := Load()
+	if err == nil {
+		t.Fatal("expected Temporal configuration error")
+	}
+	if !strings.Contains(err.Error(), "TEMPORAL_ADDRESS and TEMPORAL_NAMESPACE") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func setRequiredEnv(t *testing.T) {
+	t.Helper()
+	t.Setenv("DATABASE_URL", "postgres://postgres:postgres@127.0.0.1:5432/app")
+	t.Setenv("ATTACHMENT_BUCKET", "bucket")
+	t.Setenv("ATTACHMENT_PUBLIC_BASE_URL", "https://storage.test")
+}

package/templates/variants/go-chi/internal/temporal/client.go

@@ -0,0 +1,55 @@
+package temporalapp
+
+import (
+	"context"
+
+	"{{MODULE_PATH}}/internal/app"
+
+	"go.temporal.io/sdk/client"
+)
+
+type TriggerDispatcher struct {
+	client    client.Client
+	taskQueue string
+}
+
+func NewTriggerDispatcher(cfg WorkerConfig) (*TriggerDispatcher, 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
+	}
+	return &TriggerDispatcher{client: temporalClient, taskQueue: cfg.TaskQueue}, nil
+}
+
+func (d *TriggerDispatcher) Close() {
+	d.client.Close()
+}
+
+func (d *TriggerDispatcher) DispatchWaitlistFollowUp(ctx context.Context, trigger app.WaitlistTrigger) error {
+	_, err := d.client.ExecuteWorkflow(ctx, client.StartWorkflowOptions{
+		ID:        "waitlist-follow-up-" + trigger.ID,
+		TaskQueue: d.taskQueue,
+	}, WaitlistFollowUpWorkflow, WaitlistFollowUpInput{
+		TriggerID: trigger.ID,
+		Email:     triggerEmail(trigger.Payload),
+		Type:      trigger.Type,
+	})
+	return err
+}
+
+func triggerEmail(payload any) string {
+	values, ok := payload.(map[string]any)
+	if !ok {
+		return ""
+	}
+	email, _ := values["email"].(string)
+	return email
+}

package/templates/variants/go-connectrpc/Dockerfile

@@ -9,12 +9,14 @@ COPY cmd ./cmd
 
 RUN go mod download
 RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/server ./cmd/server
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/worker ./cmd/worker
 
 FROM gcr.io/distroless/base-debian12
 
 WORKDIR /app
 
 COPY --from=builder /out/server /app/server
+COPY --from=builder /out/worker /app/worker
 
 ENV PORT=8080
 

package/templates/variants/go-connectrpc/Makefile

@@ -5,7 +5,7 @@ WITH_ENV := set -a; [ ! -f .env.local ] || . ./.env.local; set +a;
 ATLAS ?= atlas
 
 dev:
-	@bun run ./scripts/dev.ts go run ./cmd/server
+	@bun run ./scripts/dev.ts go run ./cmd/server --worker go run ./cmd/worker
 
 migrate:
 	@bun run ./scripts/ensure-local-db.ts

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

@@ -35,17 +35,18 @@ func main() {
 	}
 	service := app.NewWaitlistService(db)
 	if cfg.TemporalEnabled {
-		stopTemporal, err := temporalapp.StartWorker(temporalapp.WorkerConfig{
+		temporalConfig := temporalapp.WorkerConfig{
 			Address:   cfg.TemporalAddress,
 			Namespace: cfg.TemporalNamespace,
 			TaskQueue: cfg.TemporalTaskQueue,
 			APIKey:    cfg.TemporalAPIKey,
-		})
+		}
+		dispatcher, err := temporalapp.NewTriggerDispatcher(temporalConfig)
 		if err != nil {
 			log.Fatal(err)
 		}
-		defer stopTemporal()
-		log.Printf("Temporal worker polling %s", cfg.TemporalTaskQueue)
+		defer dispatcher.Close()
+		service.SetTriggerDispatcher(dispatcher)
 	}
 
 	router := chi.NewRouter()

package/templates/variants/go-connectrpc/cmd/worker/main.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"{{MODULE_PATH}}/internal/config"
+	temporalapp "{{MODULE_PATH}}/internal/temporal"
+)
+
+func main() {
+	cfg, err := config.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !cfg.TemporalEnabled {
+		log.Fatal("Temporal worker is disabled. Set TEMPORAL_ENABLED=true or do not run the worker process.")
+	}
+
+	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)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", func(w http.ResponseWriter, request *http.Request) {
+		writeWorkerHealth(w)
+	})
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, request *http.Request) {
+		writeWorkerHealth(w)
+	})
+	mux.HandleFunc("/readyz", func(w http.ResponseWriter, request *http.Request) {
+		writeWorkerHealth(w)
+	})
+
+	server := &http.Server{
+		Addr:              ":" + cfg.Port,
+		ReadHeaderTimeout: 10 * time.Second,
+		Handler:           mux,
+	}
+	log.Printf("worker health listening on %s", server.Addr)
+	log.Fatal(server.ListenAndServe())
+}
+
+func writeWorkerHealth(w http.ResponseWriter) {
+	w.Header().Set("Content-Type", "application/json")
+	_, _ = w.Write([]byte(`{"status":"ok","worker":"temporal"}`))
+}

package/templates/variants/go-connectrpc/internal/app/service.go

@@ -12,6 +12,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/stdlib"
 	"github.com/jmoiron/sqlx"
 )
 
@@ -94,20 +96,39 @@ type AppError struct {
 func (e *AppError) Error() string { return e.Err.Error() }
 
 type WaitlistService struct {
-	db *sqlx.DB
+	db                *sqlx.DB
+	triggerDispatcher TriggerDispatcher
+}
+
+type TriggerDispatcher interface {
+	DispatchWaitlistFollowUp(context.Context, WaitlistTrigger) error
 }
 
 func OpenDatabase(ctx context.Context, databaseURL string) (*sqlx.DB, error) {
 	if strings.TrimSpace(databaseURL) == "" {
 		return nil, errors.New("DATABASE_URL is required")
 	}
-	return sqlx.ConnectContext(ctx, "pgx", databaseURL)
+	cfg, err := pgx.ParseConfig(databaseURL)
+	if err != nil {
+		return nil, err
+	}
+	cfg.DefaultQueryExecMode = pgx.QueryExecModeSimpleProtocol
+	db := sqlx.NewDb(stdlib.OpenDB(*cfg), "pgx")
+	if err := db.PingContext(ctx); err != nil {
+		_ = db.Close()
+		return nil, err
+	}
+	return db, nil
 }
 
 func NewWaitlistService(db *sqlx.DB) *WaitlistService {
 	return &WaitlistService{db: db}
 }
 
+func (s *WaitlistService) SetTriggerDispatcher(dispatcher TriggerDispatcher) {
+	s.triggerDispatcher = dispatcher
+}
+
 func (s *WaitlistService) JoinWaitlist(ctx context.Context, input JoinWaitlistInput) (JoinWaitlistResult, error) {
 	email, err := normalizeEmail(input.Email)
 	if err != nil {
@@ -270,7 +291,18 @@ returning id, type, coalesce(entry_id, '') as entry_id, status, payload_json, cr
 	if err != nil {
 		return WaitlistTrigger{}, err
 	}
-	return row.toTrigger()
+	trigger, err := row.toTrigger()
+	if err != nil {
+		return WaitlistTrigger{}, err
+	}
+	if s.triggerDispatcher != nil {
+		go func() {
+			if err := s.triggerDispatcher.DispatchWaitlistFollowUp(context.Background(), trigger); err != nil {
+				fmt.Printf("failed to start waitlist follow-up workflow: %v\n", err)
+			}
+		}()
+	}
+	return trigger, nil
 }
 
 func (s *WaitlistService) RecordWebhookEvent(ctx context.Context, input RecordWebhookEventInput) (RecordWebhookEventResult, error) {