Merge pull request #303 from redpwn/refactor/stricter-typechecking

ethanwu10 · web-flow · commit 0c6910ae27f1 · 2020-08-07T00:15:16.000-04:00
refactor(server): add and enforce stricter ts config
diff --git a/package.json b/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",
     "@types/uuid": "8.0.1",
     "@typescript-eslint/eslint-plugin": "3.7.0",
     "@typescript-eslint/parser": "3.8.0",
diff --git a/server/.eslintrc.js b/server/.eslintrc.js
@@ -16,11 +16,16 @@ module.exports = {
   overrides: [{
     files: ['*.ts'],
     extends: [
-      'plugin:@typescript-eslint/recommended'
+      'plugin:@typescript-eslint/recommended',
+      'plugin:@typescript-eslint/recommended-requiring-type-checking'
     ],
     plugins: [
       '@typescript-eslint'
-    ]
+    ],
+    rules: {
+      '@typescript-eslint/no-unnecessary-condition': 'error',
+      '@typescript-eslint/require-await': 'off'
+    }
   }, {
     files: ['.eslintrc.js'],
     parser: 'espree'
diff --git a/server/challenges/Provider.ts b/server/challenges/Provider.ts
@@ -9,8 +9,8 @@ export interface Provider extends EventEmitter {
 
     Challenge equality is determined by chall.id.
   */
-  updateChallenge(chall: Challenge): void;
-  deleteChallenge(id: string): void;
+  updateChallenge(chall: Challenge): Promise<void>;
+  deleteChallenge(id: string): Promise<void>;
   cleanup (): void;
 }
 
diff --git a/server/challenges/index.ts b/server/challenges/index.ts
@@ -3,6 +3,7 @@ import path from 'path'
 import { Challenge, CleanedChallenge } from './types'
 import { Provider, ProviderConstructor } from './Provider'
 import { challUpdateEmitter, publishChallUpdate } from '../cache/challs'
+import { EventEmitter } from 'events'
 
 let provider: Provider
 
@@ -41,7 +42,8 @@ void import(path.join('../providers', config.challengeProvider.name))
     provider.on('update', onUpdate)
   })
 
-challUpdateEmitter.on('update', () => {
+// FIXME: remove cast once cache is typed
+;(challUpdateEmitter as EventEmitter).on('update', () => {
   provider.forceUpdate()
 })
 
diff --git a/server/config/server.ts b/server/config/server.ts
@@ -80,24 +80,27 @@ export type ServerConfig = {
   loginTimeout: number;
 }
 
-const fileConfigLoaders: Map<string, (file: string) => unknown> = new Map([
-  ['json', file => JSON.parse(file)],
-  ['yaml', file => yaml.parse(file)],
-  ['yml', file => yaml.parse(file)]
+const jsonLoader = (file: string) => JSON.parse(file) as PartialDeep<ServerConfig>
+const yamlLoader = (file: string) => yaml.parse(file) as PartialDeep<ServerConfig>
+
+const fileConfigLoaders: Map<string, (file: string) => PartialDeep<ServerConfig>> = new Map([
+  ['json', jsonLoader],
+  ['yaml', yamlLoader],
+  ['yml', yamlLoader]
 ])
 
 const configPath = process.env.RCTF_CONF_PATH ?? path.join(__dirname, '../../../conf.d')
 const fileConfigs: PartialDeep<ServerConfig>[] = []
 fs.readdirSync(configPath).sort().forEach((name) => {
-  const matched = name.match(/\.(.+)$/)
+  const matched = /\.(.+)$/.exec(name)
   if (matched === null) {
     return
   }
   const loader = fileConfigLoaders.get(matched[1])
   if (loader === undefined) {
     return
   }
-  const config = loader(fs.readFileSync(path.join(configPath, name)).toString()) as PartialDeep<ServerConfig>
+  const config = loader(fs.readFileSync(path.join(configPath, name)).toString())
   fileConfigs.push(config)
 })
 
diff --git a/server/database/challenges.ts b/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])
 }
 
diff --git a/server/database/members.ts b/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])
 }
diff --git a/server/database/solves.ts b/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])
 }
 
diff --git a/server/database/users.ts b/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),
diff --git a/server/database/util.ts b/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>>>>
diff --git a/server/providers/emails/smtp/index.ts b/server/providers/emails/smtp/index.ts
@@ -17,7 +17,7 @@ export default class SmtpProvider implements Provider {
     this.mailer = nodemailer.createTransport(options.smtpUrl)
   }
 
-  send (mail: Mail): Promise<void> {
-    return this.mailer.sendMail(mail)
+  async send (mail: Mail): Promise<void> {
+    await this.mailer.sendMail(mail)
   }
 }
diff --git a/server/providers/uploads/gcs/index.ts b/server/providers/uploads/gcs/index.ts
@@ -13,7 +13,7 @@ export default class GcsProvider implements Provider {
 
   constructor (_options: Partial<GcsProviderOptions>) {
     const options: Required<GcsProviderOptions> = {
-      credentials: _options.credentials || JSON.parse(process.env.RCTF_GCS_CREDENTIALS as string),
+      credentials: _options.credentials || JSON.parse(process.env.RCTF_GCS_CREDENTIALS as string) as GcsProviderOptions['credentials'],
       bucketName: _options.bucketName || process.env.RCTF_GCS_BUCKET as string
     }
     // TODO: validate that all options are indeed provided
diff --git a/server/providers/uploads/local/index.ts b/server/providers/uploads/local/index.ts
@@ -38,16 +38,18 @@ export default class LocalProvider implements Provider {
     this.uploadDirectory = path.resolve(options.uploadDirectory)
     this.endpoint = options.endpoint || '/uploads'
 
-    this.uploadMap = new Map()
+    this.uploadMap = new Map<string, Upload>()
 
-    app.register(async (fastify) => {
-      fastify.register(fastifyStatic, {
+    void app.register(async (fastify) => {
+      void fastify.register(fastifyStatic, {
         root: this.uploadDirectory,
         serve: false
       })
 
+      // Fastify bug #2466
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
       fastify.setNotFoundHandler(async (req, res) => {
-        res.status(404)
+        void res.status(404)
         return 'Not found'
       })
 
@@ -70,9 +72,9 @@ export default class LocalProvider implements Provider {
 
         const upload = this.uploadMap.get(key)
         if (upload != null) {
-          reply.header('Cache-Control', 'public, max-age=31557600, immutable')
-          reply.header('Content-Disposition', contentDisposition(upload.name))
-          reply.sendFile(path.relative(this.uploadDirectory, upload.filePath))
+          void reply.header('Cache-Control', 'public, max-age=31557600, immutable')
+          void reply.header('Content-Disposition', contentDisposition(upload.name))
+          void reply.sendFile(path.relative(this.uploadDirectory, upload.filePath))
         } else {
           reply.callNotFound()
         }
diff --git a/server/uploads/index.ts b/server/uploads/index.ts
@@ -1,6 +1,6 @@
 import config from '../config/server'
 import path from 'path'
-import { Provider } from './types'
+import { Provider, ProviderConstructor } from './types'
 import { FastifyInstance } from 'fastify'
 
 let provider: Provider | null = null
@@ -10,7 +10,7 @@ export const init = (app: FastifyInstance | null): void => {
 
   // FIXME: use async loading
   // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const ProviderClass = require(path.join('../providers', name)).default
+  const { default: ProviderClass } = require(path.join('../providers', name)) as { default: ProviderConstructor }
 
   provider = new ProviderClass(config.uploadProvider.options ?? {}, app)
 }
diff --git a/server/uploads/types.ts b/server/uploads/types.ts
@@ -1,7 +1,13 @@
+import { FastifyInstance } from 'fastify'
+
 export interface Provider {
   // Returns a string, the url of the uploaded file
   upload (data: Buffer, name: string): Promise<string>;
 
   // Returns a string, the url of the previously uploaded file. Returns null if the file was not previously uploaded.
   getUrl (sha256: string, name: string): Promise<string|null>;
 }
+
+export interface ProviderConstructor {
+  new (options: unknown, app: FastifyInstance | null): Provider
+}
diff --git a/server/util/index.ts b/server/util/index.ts
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ export interface Provider extends EventEmitter {`
`9`	`9`
`10`	`10`	`Challenge equality is determined by chall.id.`
`11`	`11`	`*/`
`12`		`- updateChallenge(chall: Challenge): void;`
`13`		`- deleteChallenge(id: string): void;`
	`12`	`+ updateChallenge(chall: Challenge): Promise<void>;`
	`13`	`+ deleteChallenge(id: string): Promise<void>;`
`14`	`14`	`cleanup (): void;`
`15`	`15`	`}`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -7,24 +7,24 @@ export interface DatabaseChallenge {`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`export const getAllChallenges = (): Promise<DatabaseChallenge[]> => {`
`10`		`- return db.query('SELECT * FROM challenges')`
	`10`	`+ return db.query<DatabaseChallenge>('SELECT * FROM challenges')`
`11`	`11`	`.then(res => res.rows)`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`export const getChallengeById = ({ id }: Pick<DatabaseChallenge, 'id'>): Promise<DatabaseChallenge \| undefined> => {`
`15`		`- return db.query('SELECT * FROM challenges WHERE id = $1', [id])`
	`15`	`+ return db.query<DatabaseChallenge>('SELECT * FROM challenges WHERE id = $1', [id])`
`16`	`16`	`.then(res => res.rows[0])`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`export const createChallenge = ({ id, data }: DatabaseChallenge): Promise<DatabaseChallenge> => {`
`20`		`- return db.query('INSERT INTO challenges ($1, $2) RETURNING *',`
	`20`	`+ return db.query<DatabaseChallenge>('INSERT INTO challenges ($1, $2) RETURNING *',`
`21`	`21`	`[id, data]`
`22`	`22`	`)`
`23`	`23`	`.then(res => res.rows[0])`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`export const removeChallengeById = ({ id }: Pick<DatabaseChallenge, 'id'>): Promise<DatabaseChallenge \| undefined> => {`
`27`		`- return db.query('DELETE FROM challenges WHERE id = $1 RETURNING *', [id])`
	`27`	`+ return db.query<DatabaseChallenge>('DELETE FROM challenges WHERE id = $1 RETURNING *', [id])`
`28`	`28`	`.then(res => res.rows[0])`
`29`	`29`	`}`
`30`	`30`
Original file line number	Diff line number	Diff line change
`@@ -1,24 +1,25 @@`
`1`	`1`	`import db from './db'`
	`2`	`+import { User } from './users'`
`2`	`3`
`3`	`4`	`export interface UserMember {`
`4`	`5`	`id: string;`
`5`		`- userid: string; // FIXME: type via User type`
	`6`	`+ userid: User['id'];`
`6`	`7`	`email: string;`
`7`	`8`	`}`
`8`	`9`
`9`	`10`	`export const getMembers = ({ userid }: Pick<UserMember, 'userid'>): Promise<UserMember[]> => {`
`10`		`- return db.query('SELECT * FROM user_members WHERE userid = $1', [userid])`
	`11`	`+ return db.query<UserMember>('SELECT * FROM user_members WHERE userid = $1', [userid])`
`11`	`12`	`.then(res => res.rows)`
`12`	`13`	`}`
`13`	`14`
`14`	`15`	`export const makeMember = ({ id, userid, email }: UserMember): Promise<UserMember> => {`
`15`		`- return db.query('INSERT INTO user_members (id, userid, email) VALUES ($1, $2, $3) RETURNING *',`
	`16`	`+ return db.query<UserMember>('INSERT INTO user_members (id, userid, email) VALUES ($1, $2, $3) RETURNING *',`
`16`	`17`	`[id, userid, email]`
`17`	`18`	`)`
`18`	`19`	`.then(res => res.rows[0])`
`19`	`20`	`}`
`20`	`21`
`21`	`22`	`export const removeMember = ({ id, userid }: Pick<UserMember, 'id' \| 'userid'>): Promise<UserMember \| undefined> => {`
`22`		`- return db.query('DELETE FROM user_members WHERE id = $1 and userid = $2 RETURNING *', [id, userid])`
	`23`	`+ return db.query<UserMember>('DELETE FROM user_members WHERE id = $1 and userid = $2 RETURNING *', [id, userid])`
`23`	`24`	`.then(res => res.rows[0])`
`24`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`import db from './db'`
`2`	`2`	`import { Challenge } from '../challenges/types'`
`3`	`3`	`import { User } from './users'`
	`4`	`+import { ExtractQueryType } from './util'`
`4`	`5`
`5`	`6`	`export interface Solve {`
`6`	`7`	`id: string;`
`@@ -10,27 +11,27 @@ export interface Solve {`
`10`	`11`	`}`
`11`	`12`
`12`	`13`	`export const getAllSolves = (): Promise<Solve[]> => {`
`13`		`- return db.query('SELECT * FROM solves ORDER BY createdat ASC')`
	`14`	`+ return db.query<Solve>('SELECT * FROM solves ORDER BY createdat ASC')`
`14`	`15`	`.then(res => res.rows)`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`export const getSolvesByUserId = ({ userid }: Pick<Solve, 'userid'>): Promise<Solve[]> => {`
`18`		`- return db.query('SELECT * FROM solves WHERE userid = $1 ORDER BY createdat DESC', [userid])`
	`19`	`+ return db.query<Solve>('SELECT * FROM solves WHERE userid = $1 ORDER BY createdat DESC', [userid])`
`19`	`20`	`.then(res => res.rows)`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`export const getSolvesByChallId = ({ challengeid, limit, offset }: Pick<Solve, 'challengeid'> & { limit: number; offset: number; }): Promise<(Solve & Pick<User, 'name'>)[]> => {`
`23`		`- 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])`
	`24`	`+ 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])`
`24`	`25`	`.then(res => res.rows)`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`export const getSolveByUserIdAndChallId = ({ userid, challengeid }: Pick<Solve, 'userid' \| 'challengeid'>): Promise<Solve \| undefined> => {`
`28`		`- return db.query('SELECT * FROM solves WHERE userid = $1 AND challengeid = $2 ORDER BY createdat DESC', [userid, challengeid])`
	`29`	`+ return db.query<Solve>('SELECT * FROM solves WHERE userid = $1 AND challengeid = $2 ORDER BY createdat DESC', [userid, challengeid])`
`29`	`30`	`.then(res => res.rows[0])`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`export const newSolve = ({ id, userid, challengeid, createdat }: Solve): Promise<Solve> => {`
`33`		`- return db.query('INSERT INTO solves (id, challengeid, userid, createdat) VALUES ($1, $2, $3, $4) RETURNING *', [id, challengeid, userid, createdat])`
	`34`	`+ return db.query<Solve>('INSERT INTO solves (id, challengeid, userid, createdat) VALUES ($1, $2, $3, $4) RETURNING *', [id, challengeid, userid, createdat])`
`34`	`35`	`.then(res => res.rows[0])`
`35`	`36`	`}`
`36`	`37`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ import db from './db'`
`2`	`2`	`import * as util from '../util'`
`3`	`3`	`import config, { ServerConfig } from '../config/server'`
`4`	`4`	`import { DivisionACLError } from '../errors'`
	`5`	`+import { ExtractQueryType } from './util'`
`5`	`6`
`6`	`7`	`export interface User {`
`7`	`8`	`id: string;`
`@@ -13,67 +14,67 @@ export interface User {`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`export const getAllUsers = (): Promise<Pick<User, 'id' \| 'name' \| 'division'>[]> => {`
`16`		`- return db.query('SELECT id, name, division FROM users')`
	`17`	`+ return db.query<ExtractQueryType<typeof getAllUsers>>('SELECT id, name, division FROM users')`
`17`	`18`	`.then(res => res.rows)`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`export const getUserById = ({ id }: Pick<User, 'id'>): Promise<User \| undefined> => {`
`21`		`- return db.query('SELECT * FROM users WHERE id = $1', [id])`
	`22`	`+ return db.query<User>('SELECT * FROM users WHERE id = $1', [id])`
`22`	`23`	`.then(res => res.rows[0])`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`export const getUserByEmail = ({ email }: Pick<User, 'email'>): Promise<User \| undefined> => {`
`26`		`- return db.query('SELECT * FROM users WHERE email = $1', [email])`
	`27`	`+ return db.query<User>('SELECT * FROM users WHERE email = $1', [email])`
`27`	`28`	`.then(res => res.rows[0])`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`export const getUserByCtftimeId = ({ ctftimeId }: Pick<User, 'ctftimeId'>): Promise<User \| undefined> => {`
`31`		`- return db.query('SELECT * FROM users WHERE ctftime_id = $1', [ctftimeId])`
	`32`	`+ return db.query<User>('SELECT * FROM users WHERE ctftime_id = $1', [ctftimeId])`
`32`	`33`	`.then(res => res.rows[0])`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`export const getUserByIdAndEmail = ({ id, email }: Pick<User, 'id' \| 'email'>): Promise<User \| undefined> => {`
`36`		`- return db.query('SELECT * FROM users WHERE id = $1 AND email = $2', [id, email])`
	`37`	`+ return db.query<User>('SELECT * FROM users WHERE id = $1 AND email = $2', [id, email])`
`37`	`38`	`.then(res => res.rows[0])`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`export const getUserByNameOrEmail = ({ name, email }: Pick<User, 'name' \| 'email'>): Promise<User \| undefined> => {`
`41`		`- return db.query('SELECT * FROM users WHERE name = $1 OR email = $2', [name, email])`
	`42`	`+ return db.query<User>('SELECT * FROM users WHERE name = $1 OR email = $2', [name, email])`
`42`	`43`	`.then(res => res.rows[0])`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`export const getUserByNameOrCtftimeId = ({ name, ctftimeId }: Pick<User, 'name' \| 'ctftimeId'>): Promise<User \| undefined> => {`
`46`		`- return db.query('SELECT * FROM users WHERE name = $1 OR ctftime_id = $2', [name, ctftimeId])`
	`47`	`+ return db.query<User>('SELECT * FROM users WHERE name = $1 OR ctftime_id = $2', [name, ctftimeId])`
`47`	`48`	`.then(res => res.rows[0])`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`export const removeUserByEmail = ({ email }: Pick<User, 'email'>): Promise<User \| undefined> => {`
`51`		`- return db.query('DELETE FROM users WHERE email = $1 RETURNING *', [email])`
	`52`	`+ return db.query<User>('DELETE FROM users WHERE email = $1 RETURNING *', [email])`
`52`	`53`	`.then(res => res.rows[0])`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`export const removeUserById = ({ id }: Pick<User, 'id'>): Promise<User \| undefined> => {`
`56`		`- return db.query('DELETE FROM users WHERE id = $1 RETURNING *', [id])`
	`57`	`+ return db.query<User>('DELETE FROM users WHERE id = $1 RETURNING *', [id])`
`57`	`58`	`.then(res => res.rows[0])`
`58`	`59`	`}`
`59`	`60`
`60`	`61`	`export const makeUser = ({ id, name, email, division, ctftimeId, perms }: User): Promise<User> => {`
`61`	`62`	`if (config.email && config.divisionACLs && !util.restrict.divisionAllowed(email, division)) {`
`62`	`63`	`throw new DivisionACLError()`
`63`	`64`	`}`
`64`		`- return db.query('INSERT INTO users (id, name, email, division, ctftime_id, perms) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *',`
	`65`	`+ return db.query<User>('INSERT INTO users (id, name, email, division, ctftime_id, perms) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *',`
`65`	`66`	`[id, name, email, division, ctftimeId, perms]`
`66`	`67`	`)`
`67`	`68`	`.then(res => res.rows[0])`
`68`	`69`	`}`
`69`	`70`
`70`	`71`	`export const removeCtftimeId = ({ id }: Pick<User, 'id'>): Promise<User \| undefined> => {`
`71`		`- return db.query('UPDATE users SET ctftime_id = NULL WHERE id = $1 AND ctftime_id IS NOT NULL RETURNING *', [id])`
	`72`	`+ return db.query<User>('UPDATE users SET ctftime_id = NULL WHERE id = $1 AND ctftime_id IS NOT NULL RETURNING *', [id])`
`72`	`73`	`.then(res => res.rows[0])`
`73`	`74`	`}`
`74`	`75`
`75`	`76`	`export const removeEmail = ({ id }: Pick<User, 'id'>): Promise<User \| undefined> => {`
`76`		`- return db.query('UPDATE users SET email = NULL WHERE id = $1 AND email IS NOT NULL RETURNING *', [id])`
	`77`	`+ return db.query<User>('UPDATE users SET email = NULL WHERE id = $1 AND email IS NOT NULL RETURNING *', [id])`
`77`	`78`	`.then(res => res.rows[0])`
`78`	`79`	`}`
`79`	`80`
`@@ -92,7 +93,7 @@ export const updateUser = async ({ id, name, email, division, ctftimeId, perms }`
`92`	`93`	`throw new DivisionACLError()`
`93`	`94`	`}`
`94`	`95`	`}`
`95`		- return db.query(`
	`96`	+ return db.query<User>(`
`96`	`97`	`UPDATE users SET`
`97`	`98`	`name = COALESCE($1, name),`
`98`	`99`	`email = COALESCE($2, email),`