Merge pull request #34 from x-team/develop

Deploy to Staging

Author: ccmoralesj

.mocharc.cjs

@@ -1,6 +1,6 @@
 module.exports = {
   require: ['./test/setup-env.js', 'source-map-support/register'],
-  file: ['./src/tests/integrationTestsUtils.ts'],
+  file: ['./test/test-utils.ts'],
   timeout: 600000,
   bail: true,
   exit: true,

package.json

@@ -10,7 +10,7 @@
     "test": "cross-env NODE_ENV=test ENV=test npm run test:all",
     "test:integration": "cross-env NODE_ENV=test ENV=test npm run test:_integration",
     "test:integration:single": "cross-env NODE_ENV=test ENV=test npm run test:prepare:integration && npm run mocha",
-    "test:unit": "cross-env NODE_ENV=test ENV=test npm run mocha \"test/**/*.test.ts\" --exclude \"test/**/*.integration.test.ts\"",
+    "test:unit": "cross-env NODE_ENV=test ENV=test npm run mocha \"test/**/*.test.ts\" --exclude \"test/**/*.integration.test.ts\" ",
     "test:unit:single": "cross-env NODE_ENV=test ENV=test npm run mocha",
     "mocha": "cross-env ENV=test mocha --unhandled-rejections=strict",
     "eslint": "eslint src --fix",
@@ -28,6 +28,7 @@
     "prepare-db": "echo preparing db for $NODE_ENV env && npm run db:seed:up && npm run db:migrate:up",
     "clean": "rm -rf dist",
     "db:test:create": "docker-compose -p gameshq-api-test-project -f 'docker-compose-test.yml' up -d",
+    "db:test:clear": "docker-compose -p gameshq-api-test-project -f 'docker-compose-test.yml' down",
     "test:all": "concurrently --kill-others-on-fail --names *typescript,*****eslint,*tests:unit,integration --prefix-colors blue.inverse,blue,yellow,green 'npm run tsc' 'npm run eslint --quiet' 'npm run test:unit' 'npm run test:integration'",
     "test:prepare:integration": "npm run db:test:create &&  cross-env NODE_ENV=test ENV=test npm run prepare-db",
     "test:_integration": "npm run test:prepare:integration && npm run mocha \"test/**/*.integration.test.ts\"",
@@ -58,8 +59,8 @@
     "node-fetch": "2.6.1",
     "pg": "8.6.0",
     "reflect-metadata": "0.1.13",
-    "sequelize": "6.6.4",
-    "sequelize-typescript": "2.1.0",
+    "sequelize": "6.20.1",
+    "sequelize-typescript": "2.1.3",
     "sql-log-prettifier": "^0.1.2",
     "uuid": "8.3.2",
     "winston": "3.3.3"

src/api-utils/appendUserToRequest.ts

@@ -0,0 +1,23 @@
+import Boom from '@hapi/boom';
+import type { Request, ResponseToolkit } from '@hapi/hapi';
+
+import { findSessionByToken } from '../models/Session';
+import type { User } from '../models/User';
+import { findUserById } from '../models/User';
+
+export async function appendUserToRequest(req: Request, _h: ResponseToolkit): Promise<User> {
+  const sessionToken = req.headers['xtu-session-token'];
+  if (!sessionToken) {
+    throw Boom.forbidden('Only Auth users can access here - send session token');
+  }
+  const userSession = await findSessionByToken(sessionToken);
+  if (!userSession) {
+    throw Boom.forbidden('Only Auth users can access here - user is not logged in');
+  }
+  const user = await findUserById(userSession._userId);
+  if (!user) {
+    throw Boom.notFound('User not found');
+  }
+  return user;
+  // return h.continue;
+}

src/api-utils/getAuthUser.ts

@@ -1,11 +1,18 @@
 import Boom from '@hapi/boom';
 import type { Request, ResponseToolkit } from '@hapi/hapi';
+
 import { ZERO } from '../games/consts/global';
 import { findSessionByToken } from '../models/Session';
+import type { User } from '../models/User';
 import { findUserById } from '../models/User';
-import { CustomRequestThis } from './interfaceAndTypes';
 
-export async function getAuthUser(this: CustomRequestThis, req: Request, _h: ResponseToolkit) {
+import type { CustomRequestThis } from './interfaceAndTypes';
+
+export async function getAuthUser(
+  this: CustomRequestThis,
+  req: Request,
+  _h: ResponseToolkit
+): Promise<User> {
   // console.log({ something: this }); // Get capabilities from this
   const sessionToken = req.headers['xtu-session-token'];
   if (!sessionToken) {
@@ -17,13 +24,13 @@ export async function getAuthUser(this: CustomRequestThis, req: Request, _h: Res
   }
   const user = await findUserById(userSession._userId);
   if (!user) {
-    return Boom.notFound('User not found');
+    throw Boom.notFound('User not found');
   }
   const capabilityHeight = this.requiredCapabilities.shift() ?? ZERO;
 
   // This works for now while we design and code the capabilities system
   if ((user._roleId ?? ZERO) < capabilityHeight) {
-    return Boom.unauthorized('Only authorized users can access here');
+    throw Boom.unauthorized('Only authorized users can access here');
   }
   return user;
   // return h.continue;

src/api-utils/responseSchemas/gamedev.ts src/api-utils/schemas/gameDev/game.ts

@@ -1,11 +1,14 @@
 import Joi from 'joi';
 
+import { leaderboardSchema } from './leaderboardSchemas';
+
 const gameItemSchema = Joi.object({
   id: Joi.number(),
   name: Joi.string(),
   clientSecret: Joi.string(),
   signingSecret: Joi.string(),
   _createdById: Joi.number(),
+  _leaderboards: Joi.array().items(leaderboardSchema),
 }).optional(); //.options({ stripUnknown: true });
 
 export const sigleGameItemSchema = Joi.object({ game: gameItemSchema }).required(); //.options({ stripUnknown: true });

src/api-utils/schemas/gameDev/leaderboardSchemas.ts

@@ -0,0 +1,60 @@
+import Joi from 'joi';
+
+import { ScoreStrategy, ResetStrategy } from '../../../models/LeaderboardEntry';
+
+export const getLeaderboardRankResponseSchema = Joi.array()
+  .items(
+    Joi.object({
+      displayName: Joi.string().allow(null).required(),
+      email: Joi.string().required(),
+      score: Joi.number().required(),
+    })
+  )
+  .required();
+
+export const getUserLeaderboardResultScoreResponseSchema = Joi.object({
+  id: Joi.number().required(),
+  _leaderboardEntryId: Joi.number().required(),
+  _userId: Joi.number().required(),
+  score: Joi.number().required(),
+}).required();
+
+export const postLeaderboardResultScoreResquestSchema = Joi.object({
+  id: Joi.number().optional(),
+  score: Joi.number().required(),
+  _leaderboardResultsMeta: Joi.array()
+    .items(
+      Joi.object({
+        attribute: Joi.string().required(),
+        value: Joi.string().required(),
+      })
+    )
+    .optional(),
+}).required();
+
+export const postLeaderboardResultScoreResponseSchema = Joi.object({
+  newEntry: Joi.boolean().required(),
+}).required();
+
+export const postLeaderboardSchema = Joi.object({
+  id: Joi.number().optional(),
+  name: Joi.string().required(),
+  scoreStrategy: Joi.string()
+    .valid(...Object.values(ScoreStrategy))
+    .optional(),
+  resetStrategy: Joi.string()
+    .valid(...Object.values(ResetStrategy))
+    .optional(),
+}).required();
+
+export const leaderboardSchema = Joi.object({
+  id: Joi.number(),
+  name: Joi.string(),
+  scoreStrategy: Joi.string(),
+  resetStrategy: Joi.string(),
+  _gameTypeId: Joi.number(),
+  createdAt: Joi.date(),
+  updatedAt: Joi.date(),
+}).optional();
+
+export const multipleLeaderboardSchema = Joi.array().items(leaderboardSchema).optional();

src/api-utils/responseSchemas/user.ts src/api-utils/schemas/user.ts

@@ -10,7 +10,7 @@ const sessionTokenSchema = Joi.object({
 }).options({ stripUnknown: true });
 
 const userSessionSchema = Joi.object({
-  displayName: Joi.string().required(),
+  displayName: Joi.string().allow(null).required(),
   email: Joi.string().email().required(),
   slackId: Joi.string().allow(null).optional(),
   firebaseUserUid: Joi.string().allow(null).optional(),

src/api-utils/webhookValidations.ts

@@ -1,6 +1,7 @@
 import Boom from '@hapi/boom';
 import type { Request, ResponseToolkit } from '@hapi/hapi';
 import { isEmpty, isNaN } from 'lodash';
+
 import { TWO } from '../games/consts/global';
 import { findGameTypeByClientSecret } from '../models/GameType';
 import { isRequestFresh } from '../modules/slack/utils';
@@ -10,7 +11,7 @@ export async function webhookValidation(request: Request, _h: ResponseToolkit) {
   if (!isEmpty(request.payload) && !Buffer.isBuffer(request.payload)) {
     throw Boom.internal('Payload is not a Buffer');
   }
-  const bodyString = request.payload ? request.payload.toString('utf-8') : {};
+  const bodyString = request.payload ? request.payload.toString('utf-8') : '{}';
   const timestamp = Number(request.headers['xtu-request-timestamp']);
   if (isNaN(timestamp) || !isRequestFresh(timestamp, TWO)) {
     throw Boom.unauthorized('Invalid timestamp');

src/db.ts

@@ -1,8 +1,9 @@
+import type { Transaction } from 'sequelize';
 import type { Model } from 'sequelize-typescript';
 import { Sequelize } from 'sequelize-typescript';
 import { prettify } from 'sql-log-prettifier';
 
-import { getConfig, prettifyConfig } from './config';
+import { getConfig, prettifyConfig, logger } from './config';
 import * as models from './models';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -44,3 +45,14 @@ export function getAllModels() {
 export function getModelByName(name: string) {
   return getAllModels()[name];
 }
+
+export function withTransaction<T>(fn: (transaction: Transaction) => Promise<T>) {
+  return sequelize
+    .transaction((transaction) => {
+      return fn(transaction);
+    })
+    .catch(async (error) => {
+      logger.error(error);
+      throw error;
+    });
+}

src/migrations/20220509105325-add-key-pair-for-GameType.ts

@@ -89,7 +89,7 @@ module.exports = {
     return queryInterface.sequelize.transaction(async (transaction) => {
       await queryInterface.removeColumn('GameType', 'clientSecret', { transaction });
       await queryInterface.removeColumn('GameType', 'signingSecret', { transaction });
-      await queryInterface.removeColumn('GameType', '_createdBy', { transaction });
+      await queryInterface.removeColumn('GameType', '_createdById', { transaction });
     });
   },
 };

src/migrations/20220512141820-create-Achievements-table.ts

@@ -1,4 +1,5 @@
-import { DataTypes, QueryInterface, Sequelize } from 'sequelize';
+import type { QueryInterface, Sequelize } from 'sequelize';
+import { DataTypes } from 'sequelize';
 
 interface SequelizeContext {
   context: {
@@ -99,8 +100,8 @@ module.exports = {
 
   async down({ context: { queryInterface } }: SequelizeContext) {
     return queryInterface.sequelize.transaction(async (transaction) => {
-      await queryInterface.dropTable('Achievement', { transaction });
       await queryInterface.dropTable('AchievementUnlocked', { transaction });
+      await queryInterface.dropTable('Achievement', { transaction });
     });
   },
 };

src/migrations/20220602174137-create-Leaderboard-tables.ts

@@ -0,0 +1,110 @@
+import type { QueryInterface, Sequelize } from 'sequelize';
+import { DataTypes } from 'sequelize';
+
+interface SequelizeContext {
+  context: {
+    queryInterface: QueryInterface;
+    Sequelize: Sequelize;
+  };
+}
+
+module.exports = {
+  async up({ context: { queryInterface } }: SequelizeContext) {
+    return queryInterface.sequelize.transaction(async (transaction) => {
+      await queryInterface.createTable(
+        'LeaderboardEntry',
+        {
+          id: {
+            allowNull: false,
+            autoIncrement: true,
+            primaryKey: true,
+            type: DataTypes.INTEGER,
+          },
+          _gameTypeId: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+            references: {
+              model: 'GameType',
+              key: 'id',
+            },
+          },
+          name: {
+            allowNull: false,
+            type: DataTypes.TEXT,
+          },
+          scoreStrategy: {
+            allowNull: false,
+            type: DataTypes.ENUM('highest', 'lowest', 'sum', 'latest'),
+            defaultValue: 'highest',
+          },
+          resetStrategy: {
+            allowNull: false,
+            type: DataTypes.ENUM('daily', 'weekly', 'monthly', 'never'),
+            defaultValue: 'never',
+          },
+          createdAt: {
+            allowNull: false,
+            type: DataTypes.DATE,
+          },
+          updatedAt: {
+            allowNull: false,
+            type: DataTypes.DATE,
+          },
+        },
+        { transaction }
+      );
+
+      await queryInterface.createTable(
+        'LeaderboardResults',
+        {
+          id: {
+            allowNull: false,
+            autoIncrement: true,
+            primaryKey: true,
+            type: DataTypes.INTEGER,
+          },
+          _leaderboardEntryId: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+            references: {
+              model: 'LeaderboardEntry',
+              key: 'id',
+            },
+          },
+          _userId: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+            references: {
+              model: 'User',
+              key: 'id',
+            },
+          },
+          score: {
+            allowNull: false,
+            type: DataTypes.INTEGER,
+          },
+          meta: {
+            allowNull: true,
+            type: DataTypes.JSON, //perhaps a LeaderboardResults table?
+          },
+          createdAt: {
+            allowNull: false,
+            type: DataTypes.DATE,
+          },
+          updatedAt: {
+            allowNull: false,
+            type: DataTypes.DATE,
+          },
+        },
+        { transaction }
+      );
+    });
+  },
+
+  async down({ context: { queryInterface } }: SequelizeContext) {
+    return queryInterface.sequelize.transaction(async (transaction) => {
+      await queryInterface.dropTable('LeaderboardResults', { transaction });
+      await queryInterface.dropTable('LeaderboardEntry', { transaction });
+    });
+  },
+};