server/helpers/database-utils.ts

   1 import * as retry from 'async/retry'
   2 import * as Bluebird from 'bluebird'
   3 import { Model } from 'sequelize-typescript'
   4 import { logger } from './logger'
   5 import { Transaction } from 'sequelize'
   6
   7 function retryTransactionWrapper <T, A, B, C, D> (
   8   functionToRetry: (arg1: A, arg2: B, arg3: C, arg4: D) => Promise<T> | Bluebird<T>,
   9   arg1: A,
  10   arg2: B,
  11   arg3: C,
  12   arg4: D,
  13 ): Promise<T>
  14
  15 function retryTransactionWrapper <T, A, B, C> (
  16   functionToRetry: (arg1: A, arg2: B, arg3: C) => Promise<T> | Bluebird<T>,
  17   arg1: A,
  18   arg2: B,
  19   arg3: C
  20 ): Promise<T>
  21
  22 function retryTransactionWrapper <T, A, B> (
  23   functionToRetry: (arg1: A, arg2: B) => Promise<T> | Bluebird<T>,
  24   arg1: A,
  25   arg2: B
  26 ): Promise<T>
  27
  28 function retryTransactionWrapper <T, A> (
  29   functionToRetry: (arg1: A) => Promise<T> | Bluebird<T>,
  30   arg1: A
  31 ): Promise<T>
  32
  33 function retryTransactionWrapper <T> (
  34   functionToRetry: () => Promise<T> | Bluebird<T>
  35 ): Promise<T>
  36
  37 function retryTransactionWrapper <T> (
  38   functionToRetry: (...args: any[]) => Promise<T> | Bluebird<T>,
  39   ...args: any[]
  40 ): Promise<T> {
  41   return transactionRetryer<T>(callback => {
  42     functionToRetry.apply(null, args)
  43         .then((result: T) => callback(null, result))
  44         .catch(err => callback(err))
  45   })
  46   .catch(err => {
  47     logger.error(`Cannot execute ${functionToRetry.name} with many retries.`, { err })
  48     throw err
  49   })
  50 }
  51
  52 function transactionRetryer <T> (func: (err: any, data: T) => any) {
  53   return new Promise<T>((res, rej) => {
  54     retry(
  55       {
  56         times: 5,
  57
  58         errorFilter: err => {
  59           const willRetry = (err.name === 'SequelizeDatabaseError')
  60           logger.debug('Maybe retrying the transaction function.', { willRetry, err })
  61           return willRetry
  62         }
  63       },
  64       func,
  65       (err, data) => err ? rej(err) : res(data)
  66     )
  67   })
  68 }
  69
  70 function updateInstanceWithAnother <T extends Model<T>> (instanceToUpdate: Model<T>, baseInstance: Model<T>) {
  71   const obj = baseInstance.toJSON()
  72
  73   for (const key of Object.keys(obj)) {
  74     instanceToUpdate[key] = obj[key]
  75   }
  76 }
  77
  78 function resetSequelizeInstance (instance: Model<any>, savedFields: object) {
  79   Object.keys(savedFields).forEach(key => {
  80     instance[key] = savedFields[key]
  81   })
  82 }
  83
  84 function afterCommitIfTransaction (t: Transaction, fn: Function) {
  85   if (t) return t.afterCommit(() => fn())
  86
  87   return fn()
  88 }
  89
  90 function deleteNonExistingModels <T extends { hasSameUniqueKeysThan (other: T): boolean } & Model<T>> (
  91   fromDatabase: T[],
  92   newModels: T[],
  93   t: Transaction
  94 ) {
  95   return fromDatabase.filter(f => !newModels.find(newModel => newModel.hasSameUniqueKeysThan(f)))
  96               .map(f => f.destroy({ transaction: t }))
  97 }
  98
  99 // ---------------------------------------------------------------------------
 100
 101 export {
 102   resetSequelizeInstance,
 103   retryTransactionWrapper,
 104   transactionRetryer,
 105   updateInstanceWithAnother,
 106   afterCommitIfTransaction,
 107   deleteNonExistingModels
 108 }