Merge pull request #25 from vast-data/async_result_processing

refactor AsyncResult logic

Author: vlboiko

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.107.0
+
+BREAKING CHANGES:
+
+* **EmptyRecord Removed**: The `EmptyRecord` type has been completely removed from the library. All methods that previously returned `EmptyRecord` now return `Record` instead.
+ 
+ENHANCEMENTS:
+
+* **Async Task Processing Utilities**: Added new helper functions in the `untyped` package for simplified async task handling
+  * `MaybeWaitAsyncResult(record, rest, timeout)`: Automatically detects and waits for async tasks with a timeout
+  * `MaybeWaitAsyncResultWithContext(ctx, record, rest, timeout)`: Context-aware version with timeout support
+
 ## 0.106.0
 
 ENHANCEMENTS:

client.go

@@ -25,7 +25,7 @@ type (
 	// RecordSet is a collection of Record objects.
 	RecordSet = core.RecordSet
 
-	// Renderable is the interface for Record, RecordSet, and EmptyRecord.
+	// Renderable is the interface for Record and RecordSet.
 	Renderable = core.Renderable
 
 	// DisplayableRecord is an interface for records that can be displayed.

codegen/README.md

@@ -134,7 +134,7 @@ delete:
 
 **Generated (Simplified):**
 ```go
-func (u *UserKey) UserKeyDeleteAccessKeys(id any, accessKey string) (core.EmptyRecord, error) {
+func (u *UserKey) UserKeyDeleteAccessKeys(id any, accessKey string) error {
     // Body automatically constructed: {"access_key": accessKey}
 }
 ```

codegen/cmd/generate-untyped-resources/main.go

@@ -33,7 +33,7 @@ type MethodInfo struct {
 	HasParams        bool
 	HasBody          bool
 	ReceiverName     string
-	ReturnsNoContent bool // True if returns 204 No Content (use core.EmptyRecord)
+	ReturnsNoContent bool // True if returns 204 No Content (use core.Record)
 	ReturnsArray     bool // True if returns an array (use core.RecordSet)
 	// For simplified bodies (up to 3 fields become inline parameters)
 	SimplifiedBody   bool              // True if body has 1-3 fields
@@ -214,7 +214,7 @@ func generateMethodInfo(resourceName string, extraMethod apibuilder.ExtraMethod,
 	returns204, err := api.Returns204NoContent(extraMethod.Method, extraMethod.Path)
 	if err == nil && returns204 {
 		methodInfo.ReturnsNoContent = true
-		fmt.Printf("  ℹ️  Method returns 204 No Content, using core.EmptyRecord\n")
+		fmt.Printf("  ℹ️  Method returns 204 No Content, using core.Record\n")
 	}
 
 	// Check if this is a bare array response BEFORE schema unwrapping
@@ -480,18 +480,10 @@ func ({{$.ReceiverName}} *{{$.Name}}) {{.Name}}WithContext_{{.HTTPMethod}}(ctx c
 	if err != nil {
 		return nil, err
 	}
-	// Create async task from result
-	task := asyncResultFromRecord(ctx, result, {{$.ReceiverName}}.Rest)
-	// If waitTimeout is 0, return task immediately without waiting (async background operation)
-	if waitTimeout == 0 {
-		return task, nil
-	}
-	// Wait for task completion with the specified timeout
-	if _, err := task.Wait(waitTimeout); err != nil {
-		return task, err
-	}
-	return task, nil
-	{{else}}{{if .ReturnsNoContent}}_, err := core.Request[core.EmptyRecord](ctx, {{$.ReceiverName}}, http.{{.GoHTTPMethod}}, resourcePath, {{if .HasParams}}params{{else}}nil{{end}}, {{if or .HasBody .SimplifiedBody}}body{{else}}nil{{end}})
+
+	asyncResult, _, err := MaybeWaitAsyncResultWithContext(ctx, result, {{$.ReceiverName}}.Rest, waitTimeout)
+	return asyncResult, err
+	{{else}}{{if .ReturnsNoContent}}_, err := core.Request[core.Record](ctx, {{$.ReceiverName}}, http.{{.GoHTTPMethod}}, resourcePath, {{if .HasParams}}params{{else}}nil{{end}}, {{if or .HasBody .SimplifiedBody}}body{{else}}nil{{end}})
 	return err
 	{{else}}{{if .ReturnsArray}}result, err := core.Request[core.RecordSet](ctx, {{$.ReceiverName}}, http.{{.GoHTTPMethod}}, resourcePath, {{if .HasParams}}params{{else}}nil{{end}}, {{if or .HasBody .SimplifiedBody}}body{{else}}nil{{end}})
 	if err != nil {

codegen/misc/verify_autogen.sh

@@ -6,7 +6,7 @@
 #   2. core.Params in function signatures (untyped parameters)
 #   3. core.Record in function return types (untyped records)
 #   4. core.RecordSet in function return types (untyped record sets)
-#   5. core.EmptyRecord in function return types (untyped empty records)
+#   5. EmptyRecord references (removed type that should not appear)
 #
 # Usage: ./verify_autogen.sh [path_to_typed_resources]
 #
@@ -90,14 +90,15 @@ else
 fi
 echo ""
 
-# Check 5: core.EmptyRecord in function return types
-echo "Checking for core.EmptyRecord in function return types..."
-core_emptyrecord=$(grep -n "func.*core\.EmptyRecord" "$TYPED_DIR"/*_autogen.go 2>/dev/null | grep -v "// " | grep -v "//" || true)
+# Check 5: Verify no references to removed EmptyRecord type remain
+echo "Checking for any references to removed EmptyRecord type..."
+core_emptyrecord=$(grep -n "EmptyRecord" "$TYPED_DIR"/*_autogen.go 2>/dev/null | grep -v "// " | grep -v "//" || true)
 if [ -n "$core_emptyrecord" ]; then
+    echo "Found references to removed EmptyRecord type:"
     echo "$core_emptyrecord" | while read line; do echo "  $line"; done
     errors=$((errors + 1))
 else
-    echo "No core.EmptyRecord found in function return types"
+    echo "No references to removed EmptyRecord type found"
 fi
 echo ""
 

codegen/templates/extramethods-only.tpl

@@ -98,19 +98,11 @@ func (r *{{$.Name}}) {{.Name}}WithContext_{{.HTTPMethod}}(ctx context.Context{{i
 	if err != nil {
 		return nil, err
 	}
-	// Create async task from result
-	task := untyped.NewAsyncResult(ctx, result.RecordID(), r.Untyped)
-	// If waitTimeout is 0, return task immediately without waiting (async background operation)
-	if waitTimeout == 0 {
-		return task, nil
-	}
-	// Wait for task completion with the specified timeout
-	if _, err := task.Wait(waitTimeout); err != nil {
-		return task, err
-	}
-	return task, nil
-	{{else}}{{if .ReturnsNoContent}}{{if and (or (and .HasParams .BodyFields) (and .HasBody .BodyFields)) (not .SimplifiedBody)}}_, err = core.Request[core.EmptyRecord](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
-	return err{{else}}_, err := core.Request[core.EmptyRecord](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
+
+	asyncResult, _, err := untyped.MaybeWaitAsyncResultWithContext(ctx, result, r.Untyped, waitTimeout)
+	return asyncResult, err
+	{{else}}{{if .ReturnsNoContent}}{{if and (or (and .HasParams .BodyFields) (and .HasBody .BodyFields)) (not .SimplifiedBody)}}_, err = core.Request[core.Record](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
+	return err{{else}}_, err := core.Request[core.Record](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
 	return err{{end}}
 	{{else}}{{if .ReturnsTextPlain}}record, err := core.Request[core.Record](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
 	if err != nil {

codegen/templates/resource.tpl

@@ -276,17 +276,8 @@ func (r *{{.Name}}) UpdateWithContext(ctx context.Context, id any{{range .Update
 		return nil, err
 	}
 
-	// Create async task from result
-	task := untyped.NewAsyncResult(ctx, record.RecordID(), r.Untyped)
-	
-	// Wait for task completion if timeout > 0
-	if waitTimeout > 0 {
-		if _, err := task.Wait(waitTimeout); err != nil {
-			return task, err
-		}
-	}
-	
-	return task, nil
+	asyncResult, _, err := untyped.MaybeWaitAsyncResultWithContext(ctx, record, r.Untyped, waitTimeout)
+	return asyncResult, err
 }
 {{else}}
 // Update updates an existing {{.LowerName}} and returns an async task{{if .UpdateSummary}}
@@ -314,17 +305,8 @@ func (r *{{.Name}}) UpdateWithContext(ctx context.Context, id any, req *{{.Name}
 		return nil, err
 	}
 
-	// Create async task from result
-	task := untyped.NewAsyncResult(ctx, record.RecordID(), r.Untyped)
-	
-	// Wait for task completion if timeout > 0
-	if waitTimeout > 0 {
-		if _, err := task.Wait(waitTimeout); err != nil {
-			return task, err
-		}
-	}
-	
-	return task, nil
+	asyncResult, _, err := untyped.MaybeWaitAsyncResultWithContext(ctx, record, r.Untyped, waitTimeout)
+	return asyncResult, err
 }
 {{end}}
 {{else}}
@@ -440,17 +422,8 @@ func (r *{{.Name}}) DeleteWithContext(ctx context.Context, req *{{.Name}}SearchP
 		return nil, err
 	}
 
-	// Create async task from result
-	task := untyped.NewAsyncResult(ctx, record.RecordID(), r.Untyped)
-	
-	// Wait for task completion if timeout > 0
-	if waitTimeout > 0 {
-		if _, err := task.Wait(waitTimeout); err != nil {
-			return task, err
-		}
-	}
-	
-	return task, nil
+	asyncResult, _, err := untyped.MaybeWaitAsyncResultWithContext(ctx, record, r.Untyped, waitTimeout)
+	return asyncResult, err
 }
 {{else}}
 // Delete deletes a {{.LowerName}} with search parameters{{if or .DeleteQueryParams .DeleteBodyParams}}
@@ -520,17 +493,8 @@ func (r *{{.Name}}) DeleteByIdWithContext(ctx context.Context, id any{{range .De
 		return nil, err
 	}
 
-	// Create async task from result
-	task := untyped.NewAsyncResult(ctx, record.RecordID(), r.Untyped)
-	
-	// Wait for task completion if timeout > 0
-	if waitTimeout > 0 {
-		if _, err := task.Wait(waitTimeout); err != nil {
-			return task, err
-		}
-	}
-	
-	return task, nil
+	asyncResult, _, err := untyped.MaybeWaitAsyncResultWithContext(ctx, record, r.Untyped, waitTimeout)
+	return asyncResult, err
 }
 {{else}}
 // DeleteById deletes a {{.LowerName}} by ID{{if .DeleteSummary}}
@@ -710,19 +674,11 @@ func (r *{{$.Name}}) {{.Name}}WithContext_{{.HTTPMethod}}(ctx context.Context{{i
 	if err != nil {
 		return nil, err
 	}
-	// Create async task from result
-	task := untyped.NewAsyncResult(ctx, result.RecordID(), r.Untyped)
-	// If waitTimeout is 0, return task immediately without waiting (async background operation)
-	if waitTimeout == 0 {
-		return task, nil
-	}
-	// Wait for task completion with the specified timeout
-	if _, err := task.Wait(waitTimeout); err != nil {
-		return task, err
-	}
-	return task, nil
-	{{else}}{{if .ReturnsNoContent}}{{if and (or (and .HasParams .BodyFields) (and .HasBody .BodyFields)) (not .SimplifiedBody)}}_, err = core.Request[core.EmptyRecord](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
-	return err{{else}}_, err := core.Request[core.EmptyRecord](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
+
+	asyncResult, _, err := untyped.MaybeWaitAsyncResultWithContext(ctx, result, r.Untyped, waitTimeout)
+	return asyncResult, err
+	{{else}}{{if .ReturnsNoContent}}{{if and (or (and .HasParams .BodyFields) (and .HasBody .BodyFields)) (not .SimplifiedBody)}}_, err = core.Request[core.Record](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
+	return err{{else}}_, err := core.Request[core.Record](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
 	return err{{end}}
 	{{else}}{{if .ReturnsTextPlain}}record, err := core.Request[core.Record](ctx, r.Untyped.GetResourceMap()[r.GetResourceType()], http.{{.GoHTTPMethod}}, resourcePath, reqParams, reqBody)
 	if err != nil {