refactor(server): improve database typing

Author: ethanwu10

package.json

@@ -63,6 +63,7 @@
     "@types/mailgun-js": "0.22.10",
     "@types/mustache": "4.0.1",
     "@types/nodemailer": "6.4.0",
+    "@types/pg": "7.14.4",
     "@typescript-eslint/eslint-plugin": "3.7.0",
     "@typescript-eslint/parser": "3.8.0",
     "ava": "3.11.1",

server/.eslintrc.js

@@ -21,7 +21,10 @@ module.exports = {
     ],
     plugins: [
       '@typescript-eslint'
-    ]
+    ],
+    rules: {
+      '@typescript-eslint/no-unnecessary-condition': 'error'
+    }
   }, {
     files: ['.eslintrc.js'],
     parser: 'espree'

server/database/challenges.ts

@@ -7,24 +7,24 @@ export interface DatabaseChallenge {
 }
 
 export const getAllChallenges = (): Promise<DatabaseChallenge[]> => {
-  return db.query('SELECT * FROM challenges')
+  return db.query<DatabaseChallenge>('SELECT * FROM challenges')
     .then(res => res.rows)
 }
 
 export const getChallengeById = ({ id }: Pick<DatabaseChallenge, 'id'>): Promise<DatabaseChallenge | undefined> => {
-  return db.query('SELECT * FROM challenges WHERE id = $1', [id])
+  return db.query<DatabaseChallenge>('SELECT * FROM challenges WHERE id = $1', [id])
     .then(res => res.rows[0])
 }
 
 export const createChallenge = ({ id, data }: DatabaseChallenge): Promise<DatabaseChallenge> => {
-  return db.query('INSERT INTO challenges ($1, $2) RETURNING *',
+  return db.query<DatabaseChallenge>('INSERT INTO challenges ($1, $2) RETURNING *',
     [id, data]
   )
     .then(res => res.rows[0])
 }
 
 export const removeChallengeById = ({ id }: Pick<DatabaseChallenge, 'id'>): Promise<DatabaseChallenge | undefined> => {
-  return db.query('DELETE FROM challenges WHERE id = $1 RETURNING *', [id])
+  return db.query<DatabaseChallenge>('DELETE FROM challenges WHERE id = $1 RETURNING *', [id])
     .then(res => res.rows[0])
 }
 

server/database/members.ts

@@ -1,24 +1,25 @@
 import db from './db'
+import { User } from './users'
 
 export interface UserMember {
   id: string;
-  userid: string; // FIXME: type via User type
+  userid: User['id'];
   email: string;
 }
 
 export const getMembers = ({ userid }: Pick<UserMember, 'userid'>): Promise<UserMember[]> => {
-  return db.query('SELECT * FROM user_members WHERE userid = $1', [userid])
+  return db.query<UserMember>('SELECT * FROM user_members WHERE userid = $1', [userid])
     .then(res => res.rows)
 }
 
 export const makeMember = ({ id, userid, email }: UserMember): Promise<UserMember> => {
-  return db.query('INSERT INTO user_members (id, userid, email) VALUES ($1, $2, $3) RETURNING *',
+  return db.query<UserMember>('INSERT INTO user_members (id, userid, email) VALUES ($1, $2, $3) RETURNING *',
     [id, userid, email]
   )
     .then(res => res.rows[0])
 }
 
 export const removeMember = ({ id, userid }: Pick<UserMember, 'id' | 'userid'>): Promise<UserMember | undefined> => {
-  return db.query('DELETE FROM user_members WHERE id = $1 and userid = $2 RETURNING *', [id, userid])
+  return db.query<UserMember>('DELETE FROM user_members WHERE id = $1 and userid = $2 RETURNING *', [id, userid])
     .then(res => res.rows[0])
 }

server/database/solves.ts

@@ -1,6 +1,7 @@
 import db from './db'
 import { Challenge } from '../challenges/types'
 import { User } from './users'
+import { ExtractQueryType } from './util'
 
 export interface Solve {
   id: string;
@@ -10,27 +11,27 @@ export interface Solve {
 }
 
 export const getAllSolves = (): Promise<Solve[]> => {
-  return db.query('SELECT * FROM solves ORDER BY createdat ASC')
+  return db.query<Solve>('SELECT * FROM solves ORDER BY createdat ASC')
     .then(res => res.rows)
 }
 
 export const getSolvesByUserId = ({ userid }: Pick<Solve, 'userid'>): Promise<Solve[]> => {
-  return db.query('SELECT * FROM solves WHERE userid = $1 ORDER BY createdat DESC', [userid])
+  return db.query<Solve>('SELECT * FROM solves WHERE userid = $1 ORDER BY createdat DESC', [userid])
     .then(res => res.rows)
 }
 
 export const getSolvesByChallId = ({ challengeid, limit, offset }: Pick<Solve, 'challengeid'> & { limit: number; offset: number; }): Promise<(Solve & Pick<User, 'name'>)[]> => {
-  return db.query('SELECT solves.id, solves.userid, solves.createdat, users.name FROM solves INNER JOIN users ON solves.userid = users.id WHERE solves.challengeid=$1 ORDER BY solves.createdat ASC LIMIT $2 OFFSET $3', [challengeid, limit, offset])
+  return db.query<ExtractQueryType<typeof getSolvesByChallId>>('SELECT solves.id, solves.userid, solves.createdat, users.name FROM solves INNER JOIN users ON solves.userid = users.id WHERE solves.challengeid=$1 ORDER BY solves.createdat ASC LIMIT $2 OFFSET $3', [challengeid, limit, offset])
     .then(res => res.rows)
 }
 
 export const getSolveByUserIdAndChallId = ({ userid, challengeid }: Pick<Solve, 'userid' | 'challengeid'>): Promise<Solve | undefined> => {
-  return db.query('SELECT * FROM solves WHERE userid = $1 AND challengeid = $2 ORDER BY createdat DESC', [userid, challengeid])
+  return db.query<Solve>('SELECT * FROM solves WHERE userid = $1 AND challengeid = $2 ORDER BY createdat DESC', [userid, challengeid])
     .then(res => res.rows[0])
 }
 
 export const newSolve = ({ id, userid, challengeid, createdat }: Solve): Promise<Solve> => {
-  return db.query('INSERT INTO solves (id, challengeid, userid, createdat) VALUES ($1, $2, $3, $4) RETURNING *', [id, challengeid, userid, createdat])
+  return db.query<Solve>('INSERT INTO solves (id, challengeid, userid, createdat) VALUES ($1, $2, $3, $4) RETURNING *', [id, challengeid, userid, createdat])
     .then(res => res.rows[0])
 }
 

server/database/users.ts

@@ -2,6 +2,7 @@ import db from './db'
 import * as util from '../util'
 import config, { ServerConfig } from '../config/server'
 import { DivisionACLError } from '../errors'
+import { ExtractQueryType } from './util'
 
 export interface User {
   id: string;
@@ -13,67 +14,67 @@ export interface User {
 }
 
 export const getAllUsers = (): Promise<Pick<User, 'id' | 'name' | 'division'>[]> => {
-  return db.query('SELECT id, name, division FROM users')
+  return db.query<ExtractQueryType<typeof getAllUsers>>('SELECT id, name, division FROM users')
     .then(res => res.rows)
 }
 
 export const getUserById = ({ id }: Pick<User, 'id'>): Promise<User | undefined> => {
-  return db.query('SELECT * FROM users WHERE id = $1', [id])
+  return db.query<User>('SELECT * FROM users WHERE id = $1', [id])
     .then(res => res.rows[0])
 }
 
 export const getUserByEmail = ({ email }: Pick<User, 'email'>): Promise<User | undefined> => {
-  return db.query('SELECT * FROM users WHERE email = $1', [email])
+  return db.query<User>('SELECT * FROM users WHERE email = $1', [email])
     .then(res => res.rows[0])
 }
 
 export const getUserByCtftimeId = ({ ctftimeId }: Pick<User, 'ctftimeId'>): Promise<User | undefined> => {
-  return db.query('SELECT * FROM users WHERE ctftime_id = $1', [ctftimeId])
+  return db.query<User>('SELECT * FROM users WHERE ctftime_id = $1', [ctftimeId])
     .then(res => res.rows[0])
 }
 
 export const getUserByIdAndEmail = ({ id, email }: Pick<User, 'id' | 'email'>): Promise<User | undefined> => {
-  return db.query('SELECT * FROM users WHERE id = $1 AND email = $2', [id, email])
+  return db.query<User>('SELECT * FROM users WHERE id = $1 AND email = $2', [id, email])
     .then(res => res.rows[0])
 }
 
 export const getUserByNameOrEmail = ({ name, email }: Pick<User, 'name' | 'email'>): Promise<User | undefined> => {
-  return db.query('SELECT * FROM users WHERE name = $1 OR email = $2', [name, email])
+  return db.query<User>('SELECT * FROM users WHERE name = $1 OR email = $2', [name, email])
     .then(res => res.rows[0])
 }
 
 export const getUserByNameOrCtftimeId = ({ name, ctftimeId }: Pick<User, 'name' | 'ctftimeId'>): Promise<User | undefined> => {
-  return db.query('SELECT * FROM users WHERE name = $1 OR ctftime_id = $2', [name, ctftimeId])
+  return db.query<User>('SELECT * FROM users WHERE name = $1 OR ctftime_id = $2', [name, ctftimeId])
     .then(res => res.rows[0])
 }
 
 export const removeUserByEmail = ({ email }: Pick<User, 'email'>): Promise<User | undefined> => {
-  return db.query('DELETE FROM users WHERE email = $1 RETURNING *', [email])
+  return db.query<User>('DELETE FROM users WHERE email = $1 RETURNING *', [email])
     .then(res => res.rows[0])
 }
 
 export const removeUserById = ({ id }: Pick<User, 'id'>): Promise<User | undefined> => {
-  return db.query('DELETE FROM users WHERE id = $1 RETURNING *', [id])
+  return db.query<User>('DELETE FROM users WHERE id = $1 RETURNING *', [id])
     .then(res => res.rows[0])
 }
 
 export const makeUser = ({ id, name, email, division, ctftimeId, perms }: User): Promise<User> => {
   if (config.email && config.divisionACLs && !util.restrict.divisionAllowed(email, division)) {
     throw new DivisionACLError()
   }
-  return db.query('INSERT INTO users (id, name, email, division, ctftime_id, perms) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *',
+  return db.query<User>('INSERT INTO users (id, name, email, division, ctftime_id, perms) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *',
     [id, name, email, division, ctftimeId, perms]
   )
     .then(res => res.rows[0])
 }
 
 export const removeCtftimeId = ({ id }: Pick<User, 'id'>): Promise<User | undefined> => {
-  return db.query('UPDATE users SET ctftime_id = NULL WHERE id = $1 AND ctftime_id IS NOT NULL RETURNING *', [id])
+  return db.query<User>('UPDATE users SET ctftime_id = NULL WHERE id = $1 AND ctftime_id IS NOT NULL RETURNING *', [id])
     .then(res => res.rows[0])
 }
 
 export const removeEmail = ({ id }: Pick<User, 'id'>): Promise<User | undefined> => {
-  return db.query('UPDATE users SET email = NULL WHERE id = $1 AND email IS NOT NULL RETURNING *', [id])
+  return db.query<User>('UPDATE users SET email = NULL WHERE id = $1 AND email IS NOT NULL RETURNING *', [id])
     .then(res => res.rows[0])
 }
 
@@ -92,7 +93,7 @@ export const updateUser = async ({ id, name, email, division, ctftimeId, perms }
       throw new DivisionACLError()
     }
   }
-  return db.query(`
+  return db.query<User>(`
       UPDATE users SET
         name = COALESCE($1, name),
         email = COALESCE($2, email),

server/database/util.ts

@@ -0,0 +1,7 @@
+import { PromiseValue } from 'type-fest'
+
+type ArrayValue<Arr> = Arr extends (infer Val)[] ? Val : Arr
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ExtractQueryType<FuncType extends (...args: any) => any> =
+  NonNullable<ArrayValue<PromiseValue<ReturnType<FuncType>>>>

yarn.lock

@@ -1279,6 +1279,14 @@
   resolved "https://registry.yarnpkg.com/@types/pg-types/-/pg-types-1.11.5.tgz#1eebbe62b6772fcc75c18957a90f933d155e005b"
   integrity sha512-L8ogeT6vDzT1vxlW3KITTCt+BVXXVkLXfZ/XNm6UqbcJgxf+KPO7yjWx7dQQE8RW07KopL10x2gNMs41+IkMGQ==
 
+"@types/[email protected]":
+  version "7.14.4"
+  resolved "https://registry.yarnpkg.com/@types/pg/-/pg-7.14.4.tgz#15cfcfd9300f94fd44e6191a1b0ba18d2de209f6"
+  integrity sha512-yCKVMCcFPZSFHGg+8qjY368uf3ruyDBPjxvOU2ZcGa/vRFo5Ti5Y6z6vl+2hxtwm9VMWUGb6TWkIk3cIV8C0Cw==
+  dependencies:
+    "@types/node" "*"
+    "@types/pg-types" "*"
+
 "@types/pg@^7.4.0":
   version "7.14.3"
   resolved "https://registry.yarnpkg.com/@types/pg/-/pg-7.14.3.tgz#eb166e4f4287923890b10ed20371f937938cb995"