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