Go: Add Function List (valkey-io#3673)

Signed-off-by: TJ Zhang <tj.zhang@improving.com>

Author: tjzhang-BQ

CHANGELOG.md

@@ -64,6 +64,7 @@
 * Go: Add Function Kill ([#3604](https://github.com/valkey-io/valkey-glide/pull/3604))
 * Benchmarks: Fix rust benchmark latencies calculation
 * Python: Moved the tests folder to be under the root folder ([#3661](https://github.com/valkey-io/valkey-glide/pull/3661))
+* Go: Add Function List ([#3673](https://github.com/valkey-io/valkey-glide/pull/3673))
 
 #### Breaking Changes
 

go/api/base_client.go

@@ -7885,3 +7885,28 @@ func (client *baseClient) FunctionKill() (string, error) {
 	}
 	return handleStringResponse(result)
 }
+
+// Returns information about the functions and libraries.
+//
+// Since:
+//
+//	Valkey 7.0 and above.
+//
+// See [valkey.io] for details.
+//
+// Parameters:
+//
+//	query - The query to use to filter the functions and libraries.
+//
+// Return value:
+//
+//	A list of info about queried libraries and their functions.
+//
+// [valkey.io]: https://valkey.io/commands/function-list/
+func (client *baseClient) FunctionList(query FunctionListQuery) ([]LibraryInfo, error) {
+	response, err := client.executeCommand(C.FunctionList, query.ToArgs())
+	if err != nil {
+		return nil, err
+	}
+	return handleFunctionListResponse(response)
+}

go/api/function_command_results.go

@@ -4,6 +4,8 @@ package api
 
 import (
 	"time"
+
+	"github.com/valkey-io/valkey-glide/go/api/options"
 )
 
 type Engine struct {
@@ -32,3 +34,34 @@ type FunctionStatsResult struct {
 	// Information about the currently running script, if any
 	RunningScript RunningScript
 }
+
+type FunctionListQuery struct {
+	// The name of the library to query, use empty string for all libraries
+	LibraryName string
+	// Whether to include the code of the library
+	WithCode bool
+}
+
+func (query FunctionListQuery) ToArgs() []string {
+	args := []string{}
+	if query.LibraryName != "" {
+		args = append(args, options.LibraryNameKeyword, query.LibraryName)
+	}
+	if query.WithCode {
+		args = append(args, options.WithCodeKeyword)
+	}
+	return args
+}
+
+type FunctionInfo struct {
+	Name        string
+	Description string
+	Flags       []string
+}
+
+type LibraryInfo struct {
+	Name      string
+	Engine    string
+	Functions []FunctionInfo
+	Code      string
+}

go/api/glide_cluster_client.go

@@ -1582,6 +1582,49 @@ func (client *GlideClusterClient) FunctionKillWithRoute(route options.RouteOptio
 	return handleOkResponse(result)
 }
 
+// Returns information about the functions and libraries.
+//
+// Since:
+//
+//	Valkey 7.0 and above.
+//
+// See [valkey.io] for details.
+//
+// Parameters:
+//
+//	query - The query to use to filter the functions and libraries.
+//	route - Specifies the routing configuration for the command. The client will route the
+//	        command to the nodes defined by route.
+//
+// Return value:
+//
+//	A [ClusterValue] containing a list of info about queried libraries and their functions.
+//
+// [valkey.io]: https://valkey.io/commands/function-list/
+func (client *GlideClusterClient) FunctionListWithRoute(
+	query FunctionListQuery,
+	route options.RouteOption,
+) (ClusterValue[[]LibraryInfo], error) {
+	response, err := client.executeCommandWithRoute(C.FunctionList, query.ToArgs(), route.Route)
+	if err != nil {
+		return createEmptyClusterValue[[]LibraryInfo](), err
+	}
+
+	if route.Route != nil && route.Route.IsMultiNode() {
+		multiNodeLibs, err := handleFunctionListMultiNodeResponse(response)
+		if err != nil {
+			return createEmptyClusterValue[[]LibraryInfo](), err
+		}
+		return createClusterMultiValue[[]LibraryInfo](multiNodeLibs), nil
+	}
+
+	libs, err := handleFunctionListResponse(response)
+	if err != nil {
+		return createEmptyClusterValue[[]LibraryInfo](), err
+	}
+	return createClusterSingleValue[[]LibraryInfo](libs), nil
+}
+
 // Publish posts a message to the specified channel. Returns the number of clients that received the message.
 //
 // Channel can be any string, but common patterns include using "." to create namespaces like

go/api/options/constants.go

@@ -37,6 +37,8 @@ const (
 	MinIdKeyword        string = "MINID"
 	GroupKeyword        string = "GROUP"
 	StreamsKeyword      string = "STREAMS"
+	WithCodeKeyword     string = "WITHCODE"
+	LibraryNameKeyword  string = "LIBRARYNAME"
 )
 
 type InfBoundary string

go/api/response_handlers.go

@@ -1572,3 +1572,84 @@ func handleFunctionStatsResponse(response *C.struct_CommandResponse) (map[string
 
 	return result, nil
 }
+
+func parseFunctionInfo(items any) []FunctionInfo {
+	result := make([]FunctionInfo, 0, len(items.([]interface{})))
+	for _, item := range items.([]interface{}) {
+		if function, ok := item.(map[string]interface{}); ok {
+			// Handle nullable description
+			var description string
+			if desc, ok := function["description"].(string); ok {
+				description = desc
+			}
+
+			// Handle flags map
+			flags := make([]string, 0)
+			if flagsMap, ok := function["flags"].(map[string]struct{}); ok {
+				for flag := range flagsMap {
+					flags = append(flags, flag)
+				}
+			}
+
+			result = append(result, FunctionInfo{
+				Name:        function["name"].(string),
+				Description: description,
+				Flags:       flags,
+			})
+		}
+	}
+	return result
+}
+
+func parseLibraryInfo(itemMap map[string]interface{}) LibraryInfo {
+	libraryInfo := LibraryInfo{
+		Name:      itemMap["library_name"].(string),
+		Engine:    itemMap["engine"].(string),
+		Functions: parseFunctionInfo(itemMap["functions"]),
+	}
+	// Handle optional library_code field
+	if code, ok := itemMap["library_code"].(string); ok {
+		libraryInfo.Code = code
+	}
+	return libraryInfo
+}
+
+func handleFunctionListResponse(response *C.struct_CommandResponse) ([]LibraryInfo, error) {
+	if err := checkResponseType(response, C.Array, false); err != nil {
+		return nil, err
+	}
+
+	data, err := parseArray(response)
+	if err != nil {
+		return nil, err
+	}
+	result := make([]LibraryInfo, 0, len(data.([]interface{})))
+	for _, item := range data.([]interface{}) {
+		if itemMap, ok := item.(map[string]interface{}); ok {
+			result = append(result, parseLibraryInfo(itemMap))
+		}
+	}
+	return result, nil
+}
+
+func handleFunctionListMultiNodeResponse(response *C.struct_CommandResponse) (map[string][]LibraryInfo, error) {
+	data, err := handleStringToAnyMapResponse(response)
+	if err != nil {
+		return nil, err
+	}
+
+	multiNodeLibs := make(map[string][]LibraryInfo)
+	for node, nodeData := range data {
+		// nodeData is already parsed into a Go array of interfaces
+		if nodeArray, ok := nodeData.([]interface{}); ok {
+			libs := make([]LibraryInfo, 0, len(nodeArray))
+			for _, item := range nodeArray {
+				if itemMap, ok := item.(map[string]interface{}); ok {
+					libs = append(libs, parseLibraryInfo(itemMap))
+				}
+			}
+			multiNodeLibs[node] = libs
+		}
+	}
+	return multiNodeLibs, nil
+}

go/api/scripting_and_function_base_commands.go

@@ -26,4 +26,6 @@ type ScriptingAndFunctionBaseCommands interface {
 	FCallReadOnlyWithKeysAndArgs(function string, keys []string, args []string) (any, error)
 
 	FunctionKill() (string, error)
+
+	FunctionList(query FunctionListQuery) ([]LibraryInfo, error)
 }

go/api/scripting_and_function_cluster_commands.go

@@ -42,4 +42,6 @@ type ScriptingAndFunctionClusterCommands interface {
 	FunctionDeleteWithRoute(libName string, route options.RouteOption) (string, error)
 
 	FunctionKillWithRoute(route options.RouteOption) (string, error)
+
+	FunctionListWithRoute(query FunctionListQuery, route options.RouteOption) (ClusterValue[[]LibraryInfo], error)
 }

go/api/scripting_and_function_commands_test.go

@@ -746,3 +746,111 @@ func ExampleGlideClusterClient_FunctionKillWithRoute() {
 	// Output:
 	// Expected error: An error was signalled by the server: - NotBusy: No scripts in execution right now.
 }
+
+func ExampleGlideClient_FunctionList() {
+	client := getExampleGlideClient()
+
+	// Load a function first
+	_, err := client.FunctionLoad(libraryCode, true)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+		return
+	}
+
+	query := FunctionListQuery{
+		LibraryName: "mylib",
+		WithCode:    true,
+	}
+
+	libs, err := client.FunctionList(query)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+	}
+
+	fmt.Printf("There are %d libraries loaded.\n", len(libs))
+	for i, lib := range libs {
+		fmt.Printf("%d) Library name '%s', on engine %s, with %d functions\n", i+1, lib.Name, lib.Engine, len(lib.Functions))
+		for j, fn := range lib.Functions {
+			fmt.Printf("   %d) function '%s'\n", j+1, fn.Name)
+		}
+	}
+	// Output:
+	// There are 1 libraries loaded.
+	// 1) Library name 'mylib', on engine LUA, with 1 functions
+	//    1) function 'myfunc'
+}
+
+func ExampleGlideClusterClient_FunctionList() {
+	client := getExampleGlideClusterClient()
+
+	// Load a function first
+	_, err := client.FunctionLoad(libraryCode, true)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+		return
+	}
+
+	query := FunctionListQuery{
+		LibraryName: "mylib",
+		WithCode:    true,
+	}
+
+	libs, err := client.FunctionList(query)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+	}
+
+	fmt.Printf("There are %d libraries loaded.\n", len(libs))
+	for i, lib := range libs {
+		fmt.Printf("%d) Library name '%s', on engine %s, with %d functions\n", i+1, lib.Name, lib.Engine, len(lib.Functions))
+		for j, fn := range lib.Functions {
+			fmt.Printf("   %d) function '%s'\n", j+1, fn.Name)
+		}
+	}
+	// Output:
+	// There are 1 libraries loaded.
+	// 1) Library name 'mylib', on engine LUA, with 1 functions
+	//    1) function 'myfunc'
+}
+
+func ExampleGlideClusterClient_FunctionListWithRoute() {
+	client := getExampleGlideClusterClient()
+
+	// Load a function first
+	route := config.Route(config.AllPrimaries)
+	opts := options.RouteOption{
+		Route: route,
+	}
+	_, err := client.FunctionLoadWithRoute(libraryCode, true, opts)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+		return
+	}
+
+	// List functions with route
+	query := FunctionListQuery{
+		WithCode: true,
+	}
+	result, err := client.FunctionListWithRoute(query, opts)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+		return
+	}
+
+	// Print results for each node
+	for _, libs := range result.MultiValue() {
+		fmt.Println("Example Node:")
+		for _, lib := range libs {
+			fmt.Printf("  Library: %s\n", lib.Name)
+			fmt.Printf("  Engine: %s\n", lib.Engine)
+			fmt.Printf("  Functions: %d\n", len(lib.Functions))
+		}
+		break
+	}
+
+	// Output:
+	// Example Node:
+	//   Library: mylib
+	//   Engine: LUA
+	//   Functions: 1
+}