create-svc 0.1.62 → 0.1.64

package/templates/variants/go-connectrpc/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-connectrpc/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-connectrpc/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
+}