[HAT-429] Go SDK v1 (#2089)

* first version of new syntax and semantics

* lint fix

* add very basic example

* fix err handling

* Run method

* more Go SDK v1 examples

* more v1 Go SDK examples

* everything inside sdks/go

* fix lint

* remove code

* fix cancellations example

* fix child workflows example

* fix durablecontext reflection

* events example

* more examples ported to v1

* RunBulk -> RunMany

* address PR comments

* add link to examples in go doc

Author: mnafees

examples/go/v1/bulk-operations/main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	hatchet "github.com/hatchet-dev/hatchet/sdks/go"
+)
+
+type ProcessInput struct {
+	ID      int    `json:"id"`
+	Message string `json:"message"`
+}
+
+type ProcessOutput struct {
+	ID     int    `json:"id"`
+	Result string `json:"result"`
+}
+
+func main() {
+	// Create a new Hatchet client
+	client, err := hatchet.NewClient()
+	if err != nil {
+		log.Fatalf("failed to create hatchet client: %v", err)
+	}
+
+	// Create a workflow for bulk processing
+	workflow := client.NewWorkflow("bulk-processing-workflow")
+
+	// Define the processing task
+	workflow.NewTask("process-item", func(ctx hatchet.Context, input ProcessInput) (ProcessOutput, error) {
+		// Simulate some processing work
+		time.Sleep(time.Duration(100+input.ID*50) * time.Millisecond)
+
+		log.Printf("Processing item %d: %s", input.ID, input.Message)
+
+		return ProcessOutput{
+			ID:     input.ID,
+			Result: fmt.Sprintf("Processed item %d: %s", input.ID, input.Message),
+		}, nil
+	})
+
+	// Create a worker to run the workflow
+	worker, err := client.NewWorker("bulk-operations-worker", hatchet.WithWorkflows(workflow))
+	if err != nil {
+		log.Fatalf("failed to create worker: %v", err)
+	}
+
+	// Start the worker in a goroutine
+	go func() {
+		log.Println("Starting bulk operations worker...")
+		if err := worker.StartBlocking(); err != nil {
+			log.Printf("worker failed: %v", err)
+		}
+	}()
+
+	// Wait a moment for the worker to start
+	time.Sleep(2 * time.Second)
+
+	// Prepare bulk data
+	bulkInputs := make([]ProcessInput, 10)
+	for i := 0; i < 10; i++ {
+		bulkInputs[i] = ProcessInput{
+			ID:      i + 1,
+			Message: fmt.Sprintf("Task number %d", i+1),
+		}
+	}
+
+	log.Printf("Running bulk operations with %d items...", len(bulkInputs))
+
+	// Prepare inputs as []RunManyOpt for bulk run
+	inputs := make([]hatchet.RunManyOpt, len(bulkInputs))
+	for i, input := range bulkInputs {
+		inputs[i] = hatchet.RunManyOpt{
+			Input: input,
+		}
+	}
+
+	// Run workflows in bulk
+	ctx := context.Background()
+	runIDs, err := client.RunMany(ctx, "bulk-processing-workflow", inputs)
+	if err != nil {
+		log.Fatalf("failed to run bulk workflows: %v", err)
+	}
+
+	log.Printf("Started %d bulk workflows with run IDs: %v", len(runIDs), runIDs)
+
+	// Optionally monitor some of the runs
+	for i, runID := range runIDs {
+		if i < 3 { // Monitor first 3 runs as examples
+			log.Printf("Monitoring run %d with ID: %s", i+1, runID)
+		}
+	}
+
+	log.Println("All bulk operations started. Press Ctrl+C to stop the worker.")
+
+	// Keep the main function running
+	select {}
+}

examples/go/v1/cancellations/main.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"context"
+	"log"
+	"time"
+
+	hatchet "github.com/hatchet-dev/hatchet/sdks/go"
+)
+
+type CancellationInput struct {
+	Message string `json:"message"`
+}
+
+type CancellationOutput struct {
+	Status    string `json:"status"`
+	Completed bool   `json:"completed"`
+}
+
+func main() {
+	client, err := hatchet.NewClient()
+	if err != nil {
+		log.Fatalf("failed to create hatchet client: %v", err)
+	}
+
+	// Create a workflow that demonstrates cancellation handling
+	workflow := client.NewWorkflow("cancellation-demo",
+		hatchet.WithWorkflowDescription("Demonstrates workflow cancellation patterns"),
+		hatchet.WithWorkflowVersion("1.0.0"),
+	)
+
+	// Add a long-running task that can be cancelled
+	workflow.NewTask("long-running-task", func(ctx hatchet.Context, input CancellationInput) (CancellationOutput, error) {
+		log.Printf("Starting long-running task with message: %s", input.Message)
+
+		// Simulate long-running work with cancellation checking
+		for i := 0; i < 10; i++ {
+			select {
+			case <-ctx.Done():
+				log.Printf("Task cancelled after %d seconds", i)
+				return CancellationOutput{
+					Status:    "cancelled",
+					Completed: false,
+				}, nil
+			default:
+				log.Printf("Working... step %d/10", i+1)
+				time.Sleep(1 * time.Second)
+			}
+		}
+
+		log.Println("Task completed successfully")
+		return CancellationOutput{
+			Status:    "completed",
+			Completed: true,
+		}, nil
+	}, hatchet.WithTimeout(30*time.Second))
+
+	// Create a worker
+	worker, err := client.NewWorker("cancellation-worker",
+		hatchet.WithWorkflows(workflow),
+		hatchet.WithSlots(3),
+	)
+	if err != nil {
+		log.Fatalf("failed to create worker: %v", err)
+	}
+
+	// Run workflow instances to demonstrate cancellation
+	go func() {
+		time.Sleep(2 * time.Second)
+
+		log.Println("Starting workflow instance...")
+		_, err := client.Run(context.Background(), "cancellation-demo", CancellationInput{
+			Message: "This task will run for 10 seconds and can be cancelled",
+		})
+		if err != nil {
+			log.Printf("failed to run workflow: %v", err)
+		}
+
+		// You can demonstrate cancellation by manually cancelling the workflow
+		// through the Hatchet UI or API after starting it
+	}()
+
+	log.Println("Starting worker for cancellation demo...")
+	log.Println("Features demonstrated:")
+	log.Println("  - Long-running task with cancellation checking")
+	log.Println("  - Context cancellation handling")
+	log.Println("  - Graceful shutdown on cancellation")
+	log.Println("  - Task timeout configuration")
+
+	if err := worker.StartBlocking(); err != nil {
+		log.Fatalf("failed to start worker: %v", err)
+	}
+}

examples/go/v1/child-workflows/main.go

@@ -0,0 +1,127 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	hatchet "github.com/hatchet-dev/hatchet/sdks/go"
+)
+
+type ParentInput struct {
+	Count int `json:"count"`
+}
+
+type ChildInput struct {
+	Value int `json:"value"`
+}
+
+type ChildOutput struct {
+	Result int `json:"result"`
+}
+
+type ParentOutput struct {
+	Sum int `json:"sum"`
+}
+
+func main() {
+	client, err := hatchet.NewClient()
+	if err != nil {
+		log.Fatalf("failed to create hatchet client: %v", err)
+	}
+
+	// Create child workflow
+	childWorkflow := client.NewWorkflow("child-workflow",
+		hatchet.WithWorkflowDescription("Child workflow that processes a single value"),
+		hatchet.WithWorkflowVersion("1.0.0"),
+	)
+
+	childWorkflow.NewTask("process-value", func(ctx hatchet.Context, input ChildInput) (ChildOutput, error) {
+		log.Printf("Child workflow processing value: %d", input.Value)
+
+		// Simulate some processing
+		result := input.Value * 2
+
+		return ChildOutput{
+			Result: result,
+		}, nil
+	})
+
+	// Create parent workflow that spawns multiple child workflows
+	parentWorkflow := client.NewWorkflow("parent-workflow",
+		hatchet.WithWorkflowDescription("Parent workflow that spawns child workflows"),
+		hatchet.WithWorkflowVersion("1.0.0"),
+	)
+
+	parentWorkflow.NewTask("spawn-children", func(ctx hatchet.Context, input ParentInput) (ParentOutput, error) {
+		log.Printf("Parent workflow spawning %d child workflows", input.Count)
+
+		// Spawn multiple child workflows and collect results
+		sum := 0
+		for i := 0; i < input.Count; i++ {
+			log.Printf("Spawning child workflow %d/%d", i+1, input.Count)
+
+			// Spawn child workflow and wait for result
+			childResult, err := childWorkflow.Run(ctx.GetContext(), ChildInput{
+				Value: i + 1,
+			})
+			if err != nil {
+				return ParentOutput{}, fmt.Errorf("failed to spawn child workflow %d: %w", i, err)
+			}
+
+			log.Printf("Child workflow %d completed with result: %d", i+1, childResult)
+		}
+
+		log.Printf("All child workflows completed. Total sum: %d", sum)
+		return ParentOutput{
+			Sum: sum,
+		}, nil
+	})
+
+	// Create a worker with both workflows
+	worker, err := client.NewWorker("child-workflow-worker",
+		hatchet.WithWorkflows(childWorkflow, parentWorkflow),
+		hatchet.WithSlots(10), // Allow parallel execution of child workflows
+	)
+	if err != nil {
+		log.Fatalf("failed to create worker: %v", err)
+	}
+
+	// Run the parent workflow
+	go func() {
+		// Wait a bit for worker to start
+		for i := 0; i < 3; i++ {
+			log.Printf("Starting in %d seconds...", 3-i)
+			select {
+			case <-context.Background().Done():
+				return
+			default:
+				time.Sleep(1 * time.Second)
+			}
+		}
+
+		log.Println("Triggering parent workflow...")
+		_, err := client.Run(context.Background(), "parent-workflow", ParentInput{
+			Count: 5, // Spawn 5 child workflows
+		})
+		if err != nil {
+			log.Printf("failed to run parent workflow: %v", err)
+		}
+	}()
+
+	log.Println("Starting worker for child workflows demo...")
+	log.Println("Features demonstrated:")
+	log.Println("  - Parent workflow spawning multiple child workflows")
+	log.Println("  - Child workflow execution and result collection")
+	log.Println("  - Parallel child workflow processing")
+	log.Println("  - Parent-child workflow communication")
+
+	if err := worker.StartBlocking(); err != nil {
+		log.Fatalf("failed to start worker: %v", err)
+	}
+}
+
+func stringPtr(s string) *string {
+	return &s
+}