Add runtime leaderboardListCursorFromRank function (#1111)

### Added

- Allow HTTP key to be read from an HTTP request's Basic auth header if present.

- Add prefix search for storage keys in console (key%).

- Runtime functions to build a leaderboardList cursor to start listing from a given rank.

### Changed

- Use Steam partner API instead of public API for Steam profiles and friends requests.

	github.com/gorilla/mux v1.8.0

	github.com/gorilla/websocket v1.5.0

	github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0

	github.com/heroiclabs/nakama-common v1.28.2-0.20231010150216-b178843845fa

	github.com/heroiclabs/nakama-common v1.28.2-0.20231020105308-855feebe94cb

	github.com/jackc/pgconn v1.14.0

	github.com/jackc/pgerrcode v0.0.0-20220416144525-469b46aa5efa

	github.com/jackc/pgtype v1.14.0

github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=

github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=

github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=

github.com/heroiclabs/nakama-common v1.28.2-0.20231010150216-b178843845fa h1:2yXME7CoepD1WIV/iGpMOVmyhFxlTrM4dGTKBxqaLpw=

github.com/heroiclabs/nakama-common v1.28.2-0.20231010150216-b178843845fa/go.mod h1:Os8XeXGvHAap/p6M/8fQ3gle4eEXDGRQmoRNcPQTjXs=

github.com/heroiclabs/nakama-common v1.28.2-0.20231020105308-855feebe94cb h1:8/oTLaFxc+SpwZdcP0QuSXKPI/OgIvON+ATFc8vzzuk=

github.com/heroiclabs/nakama-common v1.28.2-0.20231020105308-855feebe94cb/go.mod h1:Os8XeXGvHAap/p6M/8fQ3gle4eEXDGRQmoRNcPQTjXs=

github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=

github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=

github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=

import (

	"context"

	"database/sql"

	"errors"

	"fmt"

	"runtime"

	"sync"

type LeaderboardRankCache interface {

	Get(leaderboardId string, sortOrder int, score, subscore, expiryUnix int64, ownerID uuid.UUID) int64

	GetDataByRank(leaderboardId string, expiryUnix int64, sortOrder int, rank int64) (ownerID uuid.UUID, score, subscore int64, err error)

	Fill(leaderboardId string, sortOrder int, expiryUnix int64, records []*api.LeaderboardRecord) int64

	Insert(leaderboardId string, sortOrder int, score, subscore int64, oldScore, oldSubscore *int64, expiryUnix int64, ownerID uuid.UUID) int64

	Delete(leaderboardId string, sortOrder int, score, subscore, expiryUnix int64, ownerID uuid.UUID) bool

	return int64(rank)

}

func (l *LocalLeaderboardRankCache) GetDataByRank(leaderboardId string, expiryUnix int64, sortOrder int, rank int64) (ownerID uuid.UUID, score, subscore int64, err error) {

	if l.blacklistAll {

		return uuid.Nil, 0, 0, errors.New("rank cache is disabled")

	}

	if _, ok := l.blacklistIds[leaderboardId]; ok {

		return uuid.Nil, 0, 0, fmt.Errorf("rank cache is disabled for leaderboard: %s", leaderboardId)

	}

	key := LeaderboardWithExpiry{LeaderboardId: leaderboardId, Expiry: expiryUnix}

	l.RLock()

	rankCache, ok := l.cache[key]

	l.RUnlock()

	if !ok {

		return uuid.Nil, 0, 0, fmt.Errorf("rank cache for leaderboard %q with expiry %d not found", leaderboardId, expiryUnix)

	}

	recordData := rankCache.cache.GetElementByRank(int(rank))

	if recordData == nil {

		return uuid.Nil, 0, 0, fmt.Errorf("rank entry %d not found for leaderboard %q with expiry %d", rank, leaderboardId, expiryUnix)

	}

	if sortOrder == LeaderboardSortOrderDescending {

		data, ok := recordData.Value.(RankDesc)

		if !ok {

			return uuid.Nil, 0, 0, fmt.Errorf("failed to type assert rank cache data")

		}

		return data.OwnerId, data.Score, data.Subscore, nil

	} else {

		data, ok := recordData.Value.(RankAsc)

		if !ok {

			return uuid.Nil, 0, 0, fmt.Errorf("failed to type assert rank cache data")

		}

		return data.OwnerId, data.Score, data.Subscore, nil

	}

}

func (l *LocalLeaderboardRankCache) Fill(leaderboardId string, sortOrder int, expiryUnix int64, records []*api.LeaderboardRecord) int64 {

	if l.blacklistAll {

		// If all rank caching is disabled.

}

func newRank(sortOrder int, score, subscore int64, ownerID uuid.UUID) skiplist.Interface {

	if sortOrder == LeaderboardSortOrderDescending {

		return RankDesc{

			OwnerId:  ownerID,

	return list.Records, list.OwnerRecords, list.NextCursor, list.PrevCursor, nil

}

// @group leaderboards

// @summary Build a cursor to be used with leaderboardRecordsList to fetch records starting at a given rank. Only available if rank cache is not disabled for the leaderboard.

// @param leaderboardID(type=string) The unique identifier of the leaderboard.

// @param rank(type=int64) The rank to start listing leaderboard records from.

// @param overrideExpiry(type=int64) Records with expiry in the past are not returned unless within this defined limit. Must be equal or greater than 0.

// @return leaderboardListCursor(string) A string cursor to be used with leaderboardRecordsList.

// @return error(error) An optional error value if an error occurred.

func (n *RuntimeGoNakamaModule) LeaderboardRecordsListCursorFromRank(id string, rank, expiry int64) (string, error) {

	if id == "" {

		return "", errors.New("invalid leaderboard id")

	}

	if rank < 1 {

		return "", errors.New("invalid rank - must be > 1")

	}

	if expiry < 0 {

		return "", errors.New("expects expiry to equal or greater than 0")

	}

	l := n.leaderboardCache.Get(id)

	if l == nil {

		return "", ErrLeaderboardNotFound

	}

	expiryTime, ok := calculateExpiryOverride(expiry, l)

	if !ok {

		return "", errors.New("invalid expiry")

	}

	rank-- // Fetch previous entry to include requested rank in the results

	if rank == 0 {

		return "", nil

	}

	ownerId, score, subscore, err := n.leaderboardRankCache.GetDataByRank(id, expiryTime, l.SortOrder, rank)

	if err != nil {

		return "", fmt.Errorf("failed to get cursor from rank: %s", err.Error())

	}

	cursor := &leaderboardRecordListCursor{

		IsNext:        true,

		LeaderboardId: id,

		ExpiryTime:    expiryTime,

		Score:         score,

		Subscore:      subscore,

		OwnerId:       ownerId.String(),

		Rank:          rank,

	}

	cursorStr, err := marshalLeaderboardRecordsListCursor(cursor)

	if err != nil {

		return "", fmt.Errorf("failed to marshal leaderboard cursor: %s", err.Error())

	}

	return cursorStr, nil

}

// @group leaderboards

// @summary Use the preconfigured operator for the given leaderboard to submit a score for a particular user.

// @param ctx(type=context.Context) The context object represents information about the server and requester.