Upgrade to pgx v5.4.3 (7d63ac22) · Commits · public-projects / Nakama

data/modules/index.js

0 → 100644

+542 −0

Original line number	Diff line number	Diff line
		"use strict";
		// Copyright 2020 The Nakama Authors
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		var rpcIdRewards = 'rewards_js';
		var rpcIdFindMatch = 'find_match_js';
		function InitModule(ctx, logger, nk, initializer) {
		initializer.registerRpc(rpcIdRewards, rpcReward);
		initializer.registerRpc(rpcIdFindMatch, rpcFindMatch);
		initializer.registerMatch(moduleName, {
		matchInit: matchInit,
		matchJoinAttempt: matchJoinAttempt,
		matchJoin: matchJoin,
		matchLeave: matchLeave,
		matchLoop: matchLoop,
		matchTerminate: matchTerminate,
		matchSignal: matchSignal,
		});
		var notifs = [
		{ userId: '767da49c-9792-4fed-b6ca-589b0bc2aaca', code: 10, content: { foo: 'bar' }, senderId: '00000000-0000-0000-0000-000000000000', subject: 'test', persistent: true },
		];
		// nk.notificationsSend(notifs);
		logger.info('JavaScript logic loaded.');
		}
		// Copyright 2020 The Nakama Authors
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		function rpcReward(context, logger, nk, payload) {
		if (!context.userId) {
		throw Error('No user ID in context');
		}
		if (payload) {
		throw Error('no input allowed');
		}
		var objectId = {
		collection: 'reward',
		key: 'daily',
		userId: context.userId,
		};
		var objects;
		try {
		objects = nk.storageRead([objectId]);
		}
		catch (error) {
		logger.error('storageRead error: %s', error);
		throw error;
		}
		var dailyReward = {
		lastClaimUnix: 0,
		};
		objects.forEach(function (object) {
		if (object.key == 'daily') {
		dailyReward = object.value;
		}
		});
		var resp = {
		coinsReceived: 0,
		};
		var d = new Date();
		d.setHours(0, 0, 0, 0);
		// If last claimed is before the new day grant a new reward!
		if (dailyReward.lastClaimUnix < msecToSec(d.getTime())) {
		resp.coinsReceived = 500;
		// Update player wallet.
		var changeset = {
		coins: resp.coinsReceived,
		};
		try {
		nk.walletUpdate(context.userId, changeset, {}, false);
		}
		catch (error) {
		logger.error('walletUpdate error: %q', error);
		throw error;
		}
		var notification = {
		code: 1001,
		content: changeset,
		persistent: true,
		subject: "You've received your daily reward!",
		userId: context.userId,
		};
		try {
		nk.notificationsSend([notification]);
		}
		catch (error) {
		logger.error('notificationsSend error: %q', error);
		throw error;
		}
		dailyReward.lastClaimUnix = msecToSec(Date.now());
		var write = {
		collection: 'reward',
		key: 'daily',
		permissionRead: 1,
		permissionWrite: 0,
		value: dailyReward,
		userId: context.userId,
		};
		if (objects.length > 0) {
		write.version = objects[0].version;
		}
		try {
		nk.storageWrite([write]);
		}
		catch (error) {
		logger.error('storageWrite error: %q', error);
		throw error;
		}
		}
		var result = JSON.stringify(resp);
		logger.debug('rpcReward resp: %q', result);
		return result;
		}
		function msecToSec(n) {
		return Math.floor(n / 1000);
		}
		var Mark;
		(function (Mark) {
		Mark[Mark["X"] = 0] = "X";
		Mark[Mark["O"] = 1] = "O";
		Mark[Mark["UNDEFINED"] = 2] = "UNDEFINED";
		})(Mark \|\| (Mark = {}));
		// The complete set of opcodes used for communication between clients and server.
		var OpCode;
		(function (OpCode) {
		// New game round starting.
		OpCode[OpCode["START"] = 1] = "START";
		// Update to the state of an ongoing round.
		OpCode[OpCode["UPDATE"] = 2] = "UPDATE";
		// A game round has just completed.
		OpCode[OpCode["DONE"] = 3] = "DONE";
		// A move the player wishes to make and sends to the server.
		OpCode[OpCode["MOVE"] = 4] = "MOVE";
		// Move was rejected.
		OpCode[OpCode["REJECTED"] = 5] = "REJECTED";
		})(OpCode \|\| (OpCode = {}));
		// Copyright 2020 The Nakama Authors
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		var moduleName = "tic-tac-toe_js";
		var tickRate = 5;
		var maxEmptySec = 30;
		var delaybetweenGamesSec = 5;
		var turnTimeFastSec = 10;
		var turnTimeNormalSec = 20;
		var winningPositions = [
		[0, 1, 2],
		[3, 4, 5],
		[6, 7, 8],
		[0, 3, 6],
		[1, 4, 7],
		[2, 5, 8],
		[0, 4, 8],
		[2, 4, 6],
		];
		var matchInit = function (ctx, logger, nk, params) {
		var fast = !!params['fast'];
		var label = {
		open: 1,
		fast: 0,
		};
		if (fast) {
		label.fast = 1;
		}
		var state = {
		label: label,
		emptyTicks: 0,
		presences: {},
		joinsInProgress: 0,
		playing: false,
		board: [],
		marks: {},
		mark: Mark.UNDEFINED,
		deadlineRemainingTicks: 0,
		winner: null,
		winnerPositions: null,
		nextGameRemainingTicks: 0,
		};
		return {
		state: state,
		tickRate: tickRate,
		label: JSON.stringify(label),
		};
		};
		var matchJoinAttempt = function (ctx, logger, nk, dispatcher, tick, state, presence, metadata) {
		// Check if it's a user attempting to rejoin after a disconnect.
		if (presence.userId in state.presences) {
		if (state.presences[presence.userId] === null) {
		// User rejoining after a disconnect.
		state.joinsInProgress++;
		return {
		state: state,
		accept: false,
		};
		}
		else {
		// User attempting to join from 2 different devices at the same time.
		return {
		state: state,
		accept: false,
		rejectMessage: 'already joined',
		};
		}
		}
		// Check if match is full.
		if (connectedPlayers(state) + state.joinsInProgress >= 2) {
		return {
		state: state,
		accept: false,
		rejectMessage: 'match full',
		};
		}
		// New player attempting to connect.
		state.joinsInProgress++;
		return {
		state: state,
		accept: true,
		};
		};
		var matchJoin = function (ctx, logger, nk, dispatcher, tick, state, presences) {
		var t = msecToSec(Date.now());
		for (var _i = 0, presences_1 = presences; _i < presences_1.length; _i++) {
		var presence = presences_1[_i];
		state.emptyTicks = 0;
		state.presences[presence.userId] = presence;
		state.joinsInProgress--;
		// Check if we must send a message to this user to update them on the current game state.
		if (state.playing) {
		// There's a game still currently in progress, the player is re-joining after a disconnect. Give them a state update.
		var update = {
		board: state.board,
		mark: state.mark,
		deadline: t + Math.floor(state.deadlineRemainingTicks / tickRate),
		};
		// Send a message to the user that just joined.
		dispatcher.broadcastMessage(OpCode.UPDATE, JSON.stringify(update));
		}
		else if (state.board.length !== 0 && Object.keys(state.marks).length !== 0 && state.marks[presence.userId]) {
		logger.debug('player %s rejoined game', presence.userId);
		// There's no game in progress but we still have a completed game that the user was part of.
		// They likely disconnected before the game ended, and have since forfeited because they took too long to return.
		var done = {
		board: state.board,
		winner: state.winner,
		winnerPositions: state.winnerPositions,
		nextGameStart: t + Math.floor(state.nextGameRemainingTicks / tickRate)
		};
		// Send a message to the user that just joined.
		dispatcher.broadcastMessage(OpCode.DONE, JSON.stringify(done));
		}
		}
		// Check if match was open to new players, but should now be closed.
		if (Object.keys(state.presences).length >= 2 && state.label.open != 0) {
		state.label.open = 0;
		var labelJSON = JSON.stringify(state.label);
		dispatcher.matchLabelUpdate(labelJSON);
		}
		return { state: state };
		};
		var matchLeave = function (ctx, logger, nk, dispatcher, tick, state, presences) {
		for (var _i = 0, presences_2 = presences; _i < presences_2.length; _i++) {
		var presence = presences_2[_i];
		logger.info("Player: %s left match: %s.", presence.userId, ctx.matchId);
		state.presences[presence.userId] = null;
		}
		return { state: state };
		};
		var matchLoop = function (ctx, logger, nk, dispatcher, tick, state, messages) {
		var _a;
		logger.debug('Running match loop. Tick: %d', tick);
		if (connectedPlayers(state) + state.joinsInProgress === 0) {
		state.emptyTicks++;
		if (state.emptyTicks >= maxEmptySec * tickRate) {
		// Match has been empty for too long, close it.
		logger.info('closing idle match');
		return null;
		}
		}
		var t = msecToSec(Date.now());
		// If there's no game in progress check if we can (and should) start one!
		if (!state.playing) {
		// Between games any disconnected users are purged, there's no in-progress game for them to return to anyway.
		for (var userID in state.presences) {
		if (state.presences[userID] === null) {
		delete state.presences[userID];
		}
		}
		// Check if we need to update the label so the match now advertises itself as open to join.
		if (Object.keys(state.presences).length < 2 && state.label.open != 1) {
		state.label.open = 1;
		var labelJSON = JSON.stringify(state.label);
		dispatcher.matchLabelUpdate(labelJSON);
		}
		// Check if we have enough players to start a game.
		if (Object.keys(state.presences).length < 2) {
		return { state: state };
		}
		// Check if enough time has passed since the last game.
		if (state.nextGameRemainingTicks > 0) {
		state.nextGameRemainingTicks--;
		return { state: state };
		}
		// We can start a game! Set up the game state and assign the marks to each player.
		state.playing = true;
		state.board = new Array(9);
		state.marks = {};
		var marks_1 = [Mark.X, Mark.O];
		Object.keys(state.presences).forEach(function (userId) {
		var _a;
		state.marks[userId] = (_a = marks_1.shift(), (_a !== null && _a !== void 0 ? _a : null));
		});
		state.mark = Mark.X;
		state.winner = null;
		state.winnerPositions = null;
		state.deadlineRemainingTicks = calculateDeadlineTicks(state.label);
		state.nextGameRemainingTicks = 0;
		// Notify the players a new game has started.
		var msg = {
		board: state.board,
		marks: state.marks,
		mark: state.mark,
		deadline: t + Math.floor(state.deadlineRemainingTicks / tickRate),
		};
		dispatcher.broadcastMessage(OpCode.START, JSON.stringify(msg));
		return { state: state };
		}
		// There's a game in progresstate. Check for input, update match state, and send messages to clientstate.
		for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
		var message = messages_1[_i];
		switch (message.opCode) {
		case OpCode.MOVE:
		logger.debug('Received move message from user: %v', state.marks);
		var mark = (_a = state.marks[message.sender.userId], (_a !== null && _a !== void 0 ? _a : null));
		if (mark === null \|\| state.mark != mark) {
		// It is not this player's turn.
		dispatcher.broadcastMessage(OpCode.REJECTED, null, [message.sender]);
		continue;
		}
		var msg = {};
		try {
		msg = JSON.parse(nk.binaryToString(message.data));
		}
		catch (error) {
		// Client sent bad data.
		dispatcher.broadcastMessage(OpCode.REJECTED, null, [message.sender]);
		logger.debug('Bad data received: %v', error);
		continue;
		}
		if (state.board[msg.position]) {
		// Client sent a position outside the board, or one that has already been played.
		dispatcher.broadcastMessage(OpCode.REJECTED, null, [message.sender]);
		continue;
		}
		// Update the game state.
		state.board[msg.position] = mark;
		state.mark = mark === Mark.O ? Mark.X : Mark.O;
		state.deadlineRemainingTicks = calculateDeadlineTicks(state.label);
		// Check if game is over through a winning move.
		var _b = winCheck(state.board, mark), winner = _b[0], winningPos = _b[1];
		if (winner) {
		state.winner = mark;
		state.winnerPositions = winningPos;
		state.playing = false;
		state.deadlineRemainingTicks = 0;
		state.nextGameRemainingTicks = delaybetweenGamesSec * tickRate;
		}
		// Check if game is over because no more moves are possible.
		var tie = state.board.every(function (v) { return v !== null; });
		if (tie) {
		// Update state to reflect the tie, and schedule the next game.
		state.playing = false;
		state.deadlineRemainingTicks = 0;
		state.nextGameRemainingTicks = delaybetweenGamesSec * tickRate;
		}
		var opCode = void 0;
		var outgoingMsg = void 0;
		if (state.playing) {
		opCode = OpCode.UPDATE;
		var msg_1 = {
		board: state.board,
		mark: state.mark,
		deadline: t + Math.floor(state.deadlineRemainingTicks / tickRate),
		};
		outgoingMsg = msg_1;
		}
		else {
		opCode = OpCode.DONE;
		var msg_2 = {
		board: state.board,
		winner: state.winner,
		winnerPositions: state.winnerPositions,
		nextGameStart: t + Math.floor(state.nextGameRemainingTicks / tickRate),
		};
		outgoingMsg = msg_2;
		}
		dispatcher.broadcastMessage(opCode, JSON.stringify(outgoingMsg));
		break;
		default:
		// No other opcodes are expected from the client, so automatically treat it as an error.
		dispatcher.broadcastMessage(OpCode.REJECTED, null, [message.sender]);
		logger.error('Unexpected opcode received: %d', message.opCode);
		}
		}
		// Keep track of the time remaining for the player to submit their move. Idle players forfeit.
		if (state.playing) {
		state.deadlineRemainingTicks--;
		if (state.deadlineRemainingTicks <= 0) {
		// The player has run out of time to submit their move.
		state.playing = false;
		state.winner = state.mark === Mark.O ? Mark.X : Mark.O;
		state.deadlineRemainingTicks = 0;
		state.nextGameRemainingTicks = delaybetweenGamesSec * tickRate;
		var msg = {
		board: state.board,
		winner: state.winner,
		nextGameStart: t + Math.floor(state.nextGameRemainingTicks / tickRate),
		winnerPositions: null,
		};
		dispatcher.broadcastMessage(OpCode.DONE, JSON.stringify(msg));
		}
		}
		return { state: state };
		};
		var matchTerminate = function (ctx, logger, nk, dispatcher, tick, state, graceSeconds) {
		return { state: state };
		};
		var matchSignal = function (ctx, logger, nk, dispatcher, tick, state) {
		return { state: state };
		};
		function calculateDeadlineTicks(l) {
		if (l.fast === 1) {
		return turnTimeFastSec * tickRate;
		}
		else {
		return turnTimeNormalSec * tickRate;
		}
		}
		function winCheck(board, mark) {
		for (var _i = 0, winningPositions_1 = winningPositions; _i < winningPositions_1.length; _i++) {
		var wp = winningPositions_1[_i];
		if (board[wp[0]] === mark &&
		board[wp[1]] === mark &&
		board[wp[2]] === mark) {
		return [true, wp];
		}
		}
		return [false, null];
		}
		function connectedPlayers(s) {
		var count = 0;
		for (var _i = 0, _a = Object.keys(s.presences); _i < _a.length; _i++) {
		var p = _a[_i];
		if (s.presences[p] !== null) {
		count++;
		}
		}
		return count;
		}
		// Copyright 2020 The Nakama Authors
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		var rpcFindMatch = function (ctx, logger, nk, payload) {
		if (!ctx.userId) {
		throw Error('No user ID in context');
		}
		if (!payload) {
		throw Error('Expects payload.');
		}
		var request = {};
		try {
		request = JSON.parse(payload);
		}
		catch (error) {
		logger.error('Error parsing json message: %q', error);
		throw error;
		}
		var matches;
		try {
		var query = "+label.open:1 +label.fast:" + (request.fast ? 1 : 0);
		matches = nk.matchList(10, true, null, null, 1, query);
		}
		catch (error) {
		logger.error('Error listing matches: %v', error);
		throw error;
		}
		var matchIds = [];
		if (matches.length > 0) {
		// There are one or more ongoing matches the user could join.
		matchIds = matches.map(function (m) { return m.matchId; });
		}
		else {
		// No available matches found, create a new one.
		try {
		matchIds.push(nk.matchCreate(moduleName, { fast: request.fast }));
		}
		catch (error) {
		logger.error('Error creating match: %v', error);
		throw error;
		}
		}
		var res = { matchIds: matchIds };
		return JSON.stringify(res);
		};

go.mod

+1 −1

Original line number	Diff line number	Diff line
		@@ -21,7 +21,7 @@ require (
		github.com/heroiclabs/sql-migrate v0.0.0-20230615133120-fb3ad977aaaf
		github.com/jackc/pgerrcode v0.0.0-20220416144525-469b46aa5efa
		github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59
		github.com/jackc/pgx/v5 v5.4.2
		github.com/jackc/pgx/v5 v5.4.3
		github.com/prometheus/client_golang v1.16.0
		github.com/stretchr/testify v1.8.4
		github.com/twmb/murmur3 v1.1.8

go.sum

+2 −2

Original line number	Diff line number	Diff line
		@@ -264,8 +264,8 @@ github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08
		github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM=
		github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186 h1:ZQM8qLT/E/CGD6XX0E6q9FAwxJYmWpJufzmLMaFuzgQ=
		github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc=
		github.com/jackc/pgx/v5 v5.4.2 h1:u1gmGDwbdRUZiwisBm/Ky2M14uQyUP65bG8+20nnyrg=
		github.com/jackc/pgx/v5 v5.4.2/go.mod h1:q6iHT8uDNXWiFNOlRqJzBTaSH3+2xCXkokxHZC5qWFY=
		github.com/jackc/pgx/v5 v5.4.3 h1:cxFyXhxlvAifxnkKKdlxv8XqUf59tDlYjnV5YYfsJJY=
		github.com/jackc/pgx/v5 v5.4.3/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=
		github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
		github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
		github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=

main.go

+1 −0

Original line number	Diff line number	Diff line
		@@ -161,6 +161,7 @@ func main() {
		}); err != nil {
		logger.Fatal("Failed to acquire pgx conn for migration check", zap.Error(err))
		}
		conn.Close()

		// Access to social provider integrations.
		socialClient := social.NewClient(logger, 5*time.Second, config.GetGoogleAuth().OAuthConfig)

server/console_channel.go

+1 −2

Original line number	Diff line number	Diff line
		@@ -11,7 +11,6 @@ import (
		"github.com/heroiclabs/nakama-common/api"
		"github.com/heroiclabs/nakama-common/runtime"
		"github.com/heroiclabs/nakama/v3/console"
		"github.com/jackc/pgx/v5/pgtype"
		"go.uber.org/zap"
		"google.golang.org/grpc/codes"
		"google.golang.org/grpc/status"
		@@ -53,7 +52,7 @@ func (s ConsoleServer) DeleteChannelMessages(ctx context.Context, in console.D

		var res sql.Result
		var err error
		if res, err = s.db.ExecContext(ctx, query, &pgtype.Timestamptz{Time: deleteBefore, Valid: true}); err != nil {
		if res, err = s.db.ExecContext(ctx, query, deleteBefore); err != nil {
		s.logger.Error("Could not delete messages.", zap.Error(err))
		return nil, status.Error(codes.Internal, "An error occurred while trying to delete messages.")
		}