fix: clean up dead Temporal operations.go stubs (#31)

- Delete operations.go (TODO stubs, never called by handler.go)
- Refactor handler.go to delegate 8 gRPC operations to
  WorkflowGRPCImpl/SearchAttributesGRPCImpl from operations_grpc.go
- Remove unused imports from handler.go
- Remaining 16 inline operations kept (no matching methods in ops layer)
- No behavior change in API responses

Closes #31

internal/temporal/handler.go

@@ -9,9 +9,6 @@ import (
 	"net/http"
 	"time"
 
-	"go.temporal.io/api/common/v1"
-	"go.temporal.io/api/taskqueue/v1"
-	"go.temporal.io/api/workflowservice/v1"
 )
 
 // RequestPayload represents the unified request format for all operations
@@ -36,6 +33,8 @@ type ResponsePayload struct {
 type Handler struct {
 	hostPort   string      // e.g., "localhost:7233"
 	grpcClient *GRPCClient // gRPC connection to Temporal
+	ops        *WorkflowGRPCImpl
+	searchOps  *SearchAttributesGRPCImpl
 }
 
 // NewHandler creates a new Temporal HTTP handler
@@ -50,10 +49,15 @@ func NewHandler(hostPort string) *Handler {
 		// Don't fail startup; operations will return errors
 	}
 
-	return &Handler{
+	h := &Handler{
 		hostPort:   hostPort,
 		grpcClient: grpcClient,
 	}
+	if grpcClient != nil {
+		h.ops = NewWorkflowGRPCImpl(grpcClient)
+		h.searchOps = NewSearchAttributesGRPCImpl(grpcClient)
+	}
+	return h
 }
 
 // ServeHTTP implements http.Handler
@@ -234,6 +238,10 @@ func (h *Handler) writeSuccess(w http.ResponseWriter, action, namespace string,
 	json.NewEncoder(w).Encode(response)
 }
 
+func (h *Handler) unavailable() (interface{}, string, string) {
+	return nil, "TEMPORAL_UNAVAILABLE", "Temporal server connection not available"
+}
+
 func (h *Handler) writeError(w http.ResponseWriter, action, errorCode, message string) {
 	response := ResponsePayload{
 		Success:   false,
@@ -280,84 +288,43 @@ func getMap(payload map[string]interface{}, key string) map[string]interface{} {
 // Workflow Operations
 
 func (h *Handler) startWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
-	if h.grpcClient == nil {
-		return nil, "TEMPORAL_UNAVAILABLE", "Temporal server connection not available"
+	if h.ops == nil {
+		return h.unavailable()
 	}
-
 	workflowID := getString(payload, "workflow_id")
 	if workflowID == "" {
 		return nil, "INVALID_REQUEST", "workflow_id is required"
 	}
-
 	workflowType := getString(payload, "workflow_type")
 	if workflowType == "" {
 		return nil, "INVALID_REQUEST", "workflow_type is required"
 	}
-
 	taskQueue := getString(payload, "task_queue")
 	if taskQueue == "" {
 		return nil, "INVALID_REQUEST", "task_queue is required"
 	}
-
 	input := getMap(payload, "input")
-
-	req := &workflowservice.StartWorkflowExecutionRequest{
-		Namespace:    namespace,
-		WorkflowId:   workflowID,
-		WorkflowType: &common.WorkflowType{Name: workflowType},
-		TaskQueue:    &taskqueue.TaskQueue{Name: taskQueue},
-	}
-
-	if len(input) > 0 {
-		inputBytes, _ := json.Marshal(input)
-		req.Input = &common.Payloads{
-			Payloads: []*common.Payload{{Data: inputBytes}},
-		}
-	}
-
-	resp, err := h.grpcClient.GetWorkflowServiceStub().StartWorkflowExecution(ctx, req)
+	result, err := h.ops.StartWorkflowExecution(ctx, namespace, workflowID, workflowType, taskQueue, input)
 	if err != nil {
 		return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to start workflow: %v", err)
 	}
-
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"run_id":      resp.RunId,
-		"start_time":  time.Now(),
-	}, "", ""
+	return result, "", ""
 }
 
 func (h *Handler) describeWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
-	if h.grpcClient == nil {
-		return nil, "TEMPORAL_UNAVAILABLE", "Temporal server connection not available"
+	if h.ops == nil {
+		return h.unavailable()
 	}
-
 	workflowID := getString(payload, "workflow_id")
 	if workflowID == "" {
 		return nil, "INVALID_REQUEST", "workflow_id is required"
 	}
-
 	runID := getString(payload, "run_id")
-
-	resp, err := h.grpcClient.GetWorkflowServiceStub().DescribeWorkflowExecution(ctx, &workflowservice.DescribeWorkflowExecutionRequest{
-		Namespace:  namespace,
-		Execution:  &common.WorkflowExecution{WorkflowId: workflowID, RunId: runID},
-	})
+	result, err := h.ops.DescribeWorkflowExecution(ctx, namespace, workflowID, runID)
 	if err != nil {
 		return nil, "WORKFLOW_NOT_FOUND", fmt.Sprintf("failed to describe workflow: %v", err)
 	}
-
-	status := "UNKNOWN"
-	if resp.WorkflowExecutionInfo != nil {
-		status = resp.WorkflowExecutionInfo.Status.String()
-	}
-
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"run_id":      runID,
-		"status":      status,
-		"start_time":  resp.WorkflowExecutionInfo.StartTime,
-	}, "", ""
+	return result, "", ""
 }
 
 func (h *Handler) listWorkflows(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
@@ -369,78 +336,93 @@ func (h *Handler) listWorkflows(ctx context.Context, namespace string, payload m
 }
 
 func (h *Handler) getWorkflowHistory(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
+	if h.ops == nil {
+		return h.unavailable()
+	}
 	workflowID := getString(payload, "workflow_id")
 	if workflowID == "" {
 		return nil, "INVALID_REQUEST", "workflow_id is required"
 	}
-
-	// Would call Temporal WorkflowService.GetWorkflowExecutionHistory
-	return map[string]interface{}{
-		"events":          []interface{}{},
-		"next_page_token": "",
-	}, "", ""
+	runID := getString(payload, "run_id")
+	result, err := h.ops.GetWorkflowExecutionHistory(ctx, namespace, workflowID, runID)
+	if err != nil {
+		return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to get history: %v", err)
+	}
+	return result, "", ""
 }
 
 func (h *Handler) terminateWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
+	if h.ops == nil {
+		return h.unavailable()
+	}
 	workflowID := getString(payload, "workflow_id")
 	if workflowID == "" {
 		return nil, "INVALID_REQUEST", "workflow_id is required"
 	}
-
-	// Would call Temporal WorkflowService.TerminateWorkflowExecution
-	return map[string]interface{}{
-		"workflow_id":   workflowID,
-		"terminated_at": time.Now(),
-	}, "", ""
+	runID := getString(payload, "run_id")
+	reason := getString(payload, "reason")
+	result, err := h.ops.TerminateWorkflowExecution(ctx, namespace, workflowID, runID, reason)
+	if err != nil {
+		return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to terminate workflow: %v", err)
+	}
+	return result, "", ""
 }
 
 func (h *Handler) cancelWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
+	if h.ops == nil {
+		return h.unavailable()
+	}
 	workflowID := getString(payload, "workflow_id")
 	if workflowID == "" {
 		return nil, "INVALID_REQUEST", "workflow_id is required"
 	}
-
-	// Would call Temporal WorkflowService.RequestCancelWorkflowExecution
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"status":      "canceling",
-	}, "", ""
+	runID := getString(payload, "run_id")
+	result, err := h.ops.CancelWorkflowExecution(ctx, namespace, workflowID, runID)
+	if err != nil {
+		return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to cancel workflow: %v", err)
+	}
+	return result, "", ""
 }
 
 func (h *Handler) signalWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
+	if h.ops == nil {
+		return h.unavailable()
+	}
 	workflowID := getString(payload, "workflow_id")
 	if workflowID == "" {
 		return nil, "INVALID_REQUEST", "workflow_id is required"
 	}
-
 	signalName := getString(payload, "signal_name")
 	if signalName == "" {
 		return nil, "INVALID_REQUEST", "signal_name is required"
 	}
-
-	// Would call Temporal WorkflowService.SignalWorkflowExecution
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"signal_name": signalName,
-		"signaled_at": time.Now(),
-	}, "", ""
+	runID := getString(payload, "run_id")
+	signalData := getMap(payload, "signal_data")
+	result, err := h.ops.SignalWorkflowExecution(ctx, namespace, workflowID, runID, signalName, signalData)
+	if err != nil {
+		return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to signal workflow: %v", err)
+	}
+	return result, "", ""
 }
 
 func (h *Handler) queryWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
+	if h.ops == nil {
+		return h.unavailable()
+	}
 	workflowID := getString(payload, "workflow_id")
 	if workflowID == "" {
 		return nil, "INVALID_REQUEST", "workflow_id is required"
 	}
-
 	queryType := getString(payload, "query_type")
 	if queryType == "" {
 		return nil, "INVALID_REQUEST", "query_type is required"
 	}
-
-	// Would call Temporal WorkflowService.QueryWorkflow
-	return map[string]interface{}{
-		"query_result": map[string]interface{}{},
-	}, "", ""
+	runID := getString(payload, "run_id")
+	result, err := h.ops.QueryWorkflowExecution(ctx, namespace, workflowID, runID, queryType)
+	if err != nil {
+		return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to query workflow: %v", err)
+	}
+	return result, "", ""
 }
 
 func (h *Handler) resetWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
@@ -556,10 +538,14 @@ func (h *Handler) deleteNamespace(ctx context.Context, namespace string, payload
 // Search Attributes Operations
 
 func (h *Handler) listSearchAttributes(ctx context.Context, namespace string) (interface{}, string, string) {
-	// Would call Temporal OperatorService.ListSearchAttributes
-	return map[string]interface{}{
-		"attributes": map[string]string{},
-	}, "", ""
+	if h.searchOps == nil {
+		return h.unavailable()
+	}
+	result, err := h.searchOps.ListSearchAttributes(ctx)
+	if err != nil {
+		return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to list search attributes: %v", err)
+	}
+	return result, "", ""
 }
 
 func (h *Handler) addSearchAttributes(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {

internal/temporal/operations.go

@@ -1,95 +0,0 @@
-// Package temporal provides operation wrappers for Temporal operations
-package temporal
-
-import (
-	"context"
-	"fmt"
-	"time"
-)
-
-// OperationHandler handles Temporal operations
-type OperationHandler struct {
-	grpc *GRPCClient
-}
-
-// NewOperationHandler creates a new operation handler
-func NewOperationHandler(grpcClient *GRPCClient) *OperationHandler {
-	return &OperationHandler{
-		grpc: grpcClient,
-	}
-}
-
-// StartWorkflowExecution starts a new workflow execution
-func (oh *OperationHandler) StartWorkflowExecution(ctx context.Context, namespace, workflowID, workflowType, taskQueue string, input map[string]interface{}) (map[string]interface{}, error) {
-	// TODO: Implement gRPC call to Temporal
-	// This is a placeholder for actual implementation
-	if oh.grpc == nil {
-		return nil, fmt.Errorf("gRPC client not initialized")
-	}
-
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"run_id":      fmt.Sprintf("run_%d", time.Now().UnixNano()),
-		"start_time":  time.Now(),
-	}, nil
-}
-
-// DescribeWorkflowExecution gets workflow details
-func (oh *OperationHandler) DescribeWorkflowExecution(ctx context.Context, namespace, workflowID, runID string) (map[string]interface{}, error) {
-	// TODO: Implement gRPC call to Temporal
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"run_id":      runID,
-		"status":      "RUNNING",
-		"start_time":  time.Now(),
-	}, nil
-}
-
-// TerminateWorkflowExecution terminates a workflow
-func (oh *OperationHandler) TerminateWorkflowExecution(ctx context.Context, namespace, workflowID, runID, reason string) (map[string]interface{}, error) {
-	// TODO: Implement gRPC call to Temporal
-	return map[string]interface{}{
-		"workflow_id":   workflowID,
-		"run_id":        runID,
-		"terminated_at": time.Now(),
-		"reason":        reason,
-	}, nil
-}
-
-// CancelWorkflowExecution cancels a workflow
-func (oh *OperationHandler) CancelWorkflowExecution(ctx context.Context, namespace, workflowID, runID string) (map[string]interface{}, error) {
-	// TODO: Implement gRPC call to Temporal
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"status":      "canceling",
-	}, nil
-}
-
-// SignalWorkflowExecution sends a signal to a workflow
-func (oh *OperationHandler) SignalWorkflowExecution(ctx context.Context, namespace, workflowID, runID, signalName string, input map[string]interface{}) (map[string]interface{}, error) {
-	// TODO: Implement gRPC call to Temporal
-	return map[string]interface{}{
-		"workflow_id": workflowID,
-		"signal_name": signalName,
-		"signaled_at": time.Now(),
-	}, nil
-}
-
-// QueryWorkflowExecution queries a workflow
-func (oh *OperationHandler) QueryWorkflowExecution(ctx context.Context, namespace, workflowID, runID, queryType string) (map[string]interface{}, error) {
-	// TODO: Implement gRPC call to Temporal
-	return map[string]interface{}{
-		"workflow_id":  workflowID,
-		"query_type":   queryType,
-		"query_result": map[string]interface{}{},
-	}, nil
-}
-
-// ListWorkflowExecutions lists workflows
-func (oh *OperationHandler) ListWorkflowExecutions(ctx context.Context, namespace string, pageSize int32) (map[string]interface{}, error) {
-	// TODO: Implement gRPC call to Temporal
-	return map[string]interface{}{
-		"executions":      []interface{}{},
-		"next_page_token": "",
-	}, nil
-}