Improve WASM runtime error messages by adding a function to retrieve errors from resourceList

functions/go/apply-replacements/run_js.go

@@ -17,16 +17,20 @@
 package main
 
 import (
-	"fmt"
 	"syscall/js"
 
 	"github.com/GoogleContainerTools/kpt-functions-catalog/functions/go/apply-replacements/replacements"
 	"github.com/GoogleContainerTools/kpt-functions-sdk/go/fn"
 )
 
 func run() error {
+	resourceList := []byte("")
+
 	// Register js function processResourceList to the globals.
-	js.Global().Set("processResourceList", resourceListProcessorWrapper())
+	js.Global().Set("processResourceList", resourceListProcessorWrapper(&resourceList))
+	// Provide a second function that serves purely to also return the resourceList,
+	// in case of the above function failing.
+	js.Global().Set("processResourceListErrors", resourceListProcessorErrors(&resourceList))
 	// We need to ensure that the Go program is running when JavaScript calls it.
 	// Otherwise, it will complain the Go program has already exited.
 	<-make(chan bool)
@@ -37,19 +41,42 @@ func applyReplacements(input []byte) ([]byte, error) {
 	return fn.Run(fn.ResourceListProcessorFunc(replacements.ApplyReplacements), []byte(input))
 }
 
-func resourceListProcessorWrapper() js.Func {
-	// TODO: figure out a better way to surface a golang error to JS environment.
-	// Currently error is surfaced as a string.
-	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+func resourceListProcessorWrapper(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
 		if len(args) != 1 {
 			return "Invalid number of arguments passed"
 		}
 		input := args[0].String()
 		applied, err := applyReplacements([]byte(input))
 		if err != nil {
-			return fmt.Errorf("unable to process resource list:", err.Error())
+			*resourceList = applied
+			return "unable to process resource list: " + err.Error()
 		}
+		*resourceList = applied
 		return string(applied)
 	})
+
 	return jsonFunc
 }
+
+// This funcion will return ALL Results with Severity error,
+// meaning unrelated errors may also be included.
+func resourceListProcessorErrors(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
+		rl, err := fn.ParseResourceList(*resourceList)
+		if err != nil {
+			return ""
+		}
+		if len(rl.Results) == 0 {
+			return ""
+		}
+		errorMessages := ""
+		for _, r := range(rl.Results) {
+			if (r.Severity == "error") {
+				errorMessages += r.Message
+			}
+		}
+		return errorMessages
+	})
+	return jsonFunc
+}

functions/go/apply-setters/applysetters/apply_setters.go

@@ -82,7 +82,6 @@ For input ApplySetters [name: env, value: "[stage, prod]"], qthe yaml node is tr
 environments: # kpt-set: ${env}
 - stage
 - prod
-
 */
 func (as *ApplySetters) visitMapping(object *yaml.RNode, path string) error {
 	return object.VisitFields(func(node *yaml.MapNode) error {
@@ -180,15 +179,16 @@ e.g.for input of scalar node 'nginx:1.7.1 # kpt-set: ${image}:${tag}' in the yam
 
 apiVersion: v1
 ...
-  image: nginx:1.7.1 # kpt-set: ${image}:${tag}
+
+	image: nginx:1.7.1 # kpt-set: ${image}:${tag}
 
 and for input ApplySetters [[name: image, value: ubuntu], [name: tag, value: 1.8.0]]
 The yaml node is transformed to
 
 apiVersion: v1
 ...
-  image: ubuntu:1.8.0 # kpt-set: ${image}:${tag}
 
+	image: ubuntu:1.8.0 # kpt-set: ${image}:${tag}
 */
 func (as *ApplySetters) visitScalar(object *yaml.RNode, path string) error {
 	if object.IsNil() {

functions/go/apply-setters/main.go

@@ -11,7 +11,7 @@ import (
 	kyaml "sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
-//nolint
+// nolint
 func main() {
 	asp := ApplySettersProcessor{}
 	cmd := command.Build(&asp, command.StandaloneEnabled, false)

functions/go/set-labels/run_js.go

@@ -17,16 +17,19 @@
 package main
 
 import (
-	"fmt"
 	"syscall/js"
 
 	"github.com/GoogleContainerTools/kpt-functions-catalog/functions/go/set-labels/setlabels"
 	"github.com/GoogleContainerTools/kpt-functions-sdk/go/fn"
 )
 
 func run() error {
-	// Register js function processResourceList to the globals.
-	js.Global().Set("processResourceList", resourceListProcessorWrapper())
+	resourceList := []byte("")
+
+	js.Global().Set("processResourceList", resourceListProcessorWrapper(&resourceList))
+	// Provide a second function that serves purely to also return the resourceList,
+	// in case of the above function failing.
+	js.Global().Set("processResourceListErrors", resourceListProcessorErrors(&resourceList))
 	// We need to ensure that the Go program is running when JavaScript calls it.
 	// Otherwise, it will complain the Go program has already exited.
 	<-make(chan bool)
@@ -38,19 +41,42 @@ func transformLabels(input []byte) ([]byte, error) {
 	return fn.Run(runner, []byte(input))
 }
 
-func resourceListProcessorWrapper() js.Func {
-	// TODO: figure out a better way to surface a golang error to JS environment.
-	// Currently error is surfaced as a string.
-	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+// This funcion will return ALL Results with Severity error,
+// meaning unrelated errors may also be included.
+func resourceListProcessorWrapper(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
 		if len(args) != 1 {
 			return "Invalid number of arguments passed"
 		}
 		input := args[0].String()
-		transformed, err := transformLabels([]byte(input))
+		applied, err := transformLabels([]byte(input))
+		if err != nil {
+			*resourceList = applied
+			return "unable to process resource list: " + err.Error()
+		}
+		*resourceList = applied
+		return string(applied)
+	})
+
+	return jsonFunc
+}
+
+func resourceListProcessorErrors(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
+		rl, err := fn.ParseResourceList(*resourceList)
 		if err != nil {
-			return fmt.Errorf("unable to process resource list:", err.Error())
+			return ""
+		}
+		if len(rl.Results) == 0 {
+			return ""
+		}
+		errorMessages := ""
+		for _, r := range(rl.Results) {
+			if (r.Severity == "error") {
+				errorMessages += r.Message
+			}
 		}
-		return string(transformed)
+		return errorMessages
 	})
 	return jsonFunc
 }

functions/go/set-namespace/run_js.go

@@ -17,16 +17,20 @@
 package main
 
 import (
-	"fmt"
 	"syscall/js"
 
 	"github.com/GoogleContainerTools/kpt-functions-catalog/functions/go/set-namespace/transformer"
 	"github.com/GoogleContainerTools/kpt-functions-sdk/go/fn"
 )
 
 func run() error {
+	resourceList := []byte("")
+
 	// Register js function processResourceList to the globals.
-	js.Global().Set("processResourceList", resourceListProcessorWrapper())
+	js.Global().Set("processResourceList", resourceListProcessorWrapper(&resourceList))
+	// Provide a second function that serves purely to also return the resourceList,
+	// in case of the above function failing.
+	js.Global().Set("processResourceListErrors", resourceListProcessorErrors(&resourceList))
 	// We need to ensure that the Go program is running when JavaScript calls it.
 	// Otherwise, it will complain the Go program has already exited.
 	<-make(chan bool)
@@ -37,19 +41,42 @@ func transformNamespace(input []byte) ([]byte, error) {
 	return fn.Run(fn.ResourceListProcessorFunc(transformer.Run), []byte(input))
 }
 
-func resourceListProcessorWrapper() js.Func {
-	// TODO: figure out a better way to surface a golang error to JS environment.
-	// Currently error is surfaced as a string.
-	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+// This funcion will return ALL Results with Severity error,
+// meaning unrelated errors may also be included.
+func resourceListProcessorWrapper(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
 		if len(args) != 1 {
 			return "Invalid number of arguments passed"
 		}
 		input := args[0].String()
-		transformed, err := transformNamespace([]byte(input))
+		applied, err := transformNamespace([]byte(input))
+		if err != nil {
+			*resourceList = applied
+			return "unable to process resource list: " + err.Error()
+		}
+		*resourceList = applied
+		return string(applied)
+	})
+
+	return jsonFunc
+}
+
+func resourceListProcessorErrors(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
+		rl, err := fn.ParseResourceList(*resourceList)
 		if err != nil {
-			return fmt.Errorf("unable to process resource list:", err.Error())
+			return ""
+		}
+		if len(rl.Results) == 0 {
+			return ""
+		}
+		errorMessages := ""
+		for _, r := range(rl.Results) {
+			if (r.Severity == "error") {
+				errorMessages += r.Message
+			}
 		}
-		return string(transformed)
+		return errorMessages
 	})
 	return jsonFunc
 }

functions/go/starlark/run_js.go

@@ -17,16 +17,22 @@
 package main
 
 import (
-	"fmt"
 	"syscall/js"
 
 	"github.com/GoogleContainerTools/kpt-functions-catalog/functions/go/starlark/starlark"
 	"github.com/GoogleContainerTools/kpt-functions-sdk/go/fn"
 )
 
 func run() error {
+	resourceList := []byte("")
+
 	// Register js function processResourceList to the globals.
-	js.Global().Set("processResourceList", resourceListProcessorWrapper())
+	js.Global().Set("processResourceList", resourceListProcessorWrapper(&resourceList))
+	// Provide a second function that serves purely to also return the resourceList,
+	// in case of the above function failing.
+	js.Global().Set("processResourceListErrors", resourceListProcessorErrors(&resourceList))
+
+
 	// We need to ensure that the Go program is running when JavaScript calls it.
 	// Otherwise, it will complain the Go program has already exited.
 	<-make(chan bool)
@@ -37,19 +43,42 @@ func executeStarlark(input []byte) ([]byte, error) {
 	return fn.Run(fn.ResourceListProcessorFunc(starlark.Process), []byte(input))
 }
 
-func resourceListProcessorWrapper() js.Func {
-	// TODO: figure out a better way to surface a golang error to JS environment.
-	// Currently error is surfaced as a string.
-	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+func resourceListProcessorWrapper(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
 		if len(args) != 1 {
 			return "Invalid number of arguments passed"
 		}
 		input := args[0].String()
 		applied, err := executeStarlark([]byte(input))
 		if err != nil {
-			return fmt.Errorf("unable to process resource list:", err.Error())
+			*resourceList = applied
+			return "unable to process resource list: " + err.Error()
 		}
+		*resourceList = applied
 		return string(applied)
 	})
+
 	return jsonFunc
 }
+
+// This funcion will return ALL Results with Severity error,
+// meaning unrelated errors may also be included.
+func resourceListProcessorErrors(resourceList *[]byte) js.Func {
+	jsonFunc := js.FuncOf(func(this js.Value, args []js.Value) any {
+		rl, err := fn.ParseResourceList(*resourceList)
+		if err != nil {
+			return ""
+		}
+		if len(rl.Results) == 0 {
+			return ""
+		}
+		errorMessages := ""
+		for _, r := range(rl.Results) {
+			if (r.Severity == "error") {
+				errorMessages += r.Message
+			}
+		}
+		return errorMessages
+	})
+	return jsonFunc
+}