Put activity pub sends inside transactions

21 files changed, 144 insertions, 113 deletions

diff --git a/server/controllers/api/videos/rate.ts b/server/controllers/api/videos/rate.ts
index 0c6a988cf..c27c61116 100644
--- a/server/controllers/api/videos/rate.ts
+++ b/server/controllers/api/videos/rate.ts
@@ -58,11 +58,11 @@ async function rateVideo (req: express.Request, res: express.Response) {
       else if (previousRate.type === VIDEO_RATE_TYPES.DISLIKE) dislikesToIncrement--
 
       if (rateType === 'none') { // Destroy previous rate
-        await previousRate.destroy()
+        await previousRate.destroy({ transaction: t })
       } else { // Update previous rate
         previousRate.type = rateType
 
-        await previousRate.save()
+        await previousRate.save({ transaction: t })
       }
     } else if (rateType !== 'none') { // There was not a previous rate, insert a new one if there is a rate
       const query = {
diff --git a/server/lib/activitypub/process/process-update.ts b/server/lib/activitypub/process/process-update.ts
index 84a62de9f..11c6de8f5 100644
--- a/server/lib/activitypub/process/process-update.ts
+++ b/server/lib/activitypub/process/process-update.ts
@@ -1,3 +1,4 @@
+import * as Bluebird from 'bluebird'
 import { VideoChannelObject, VideoTorrentObject } from '../../../../shared'
 import { ActivityUpdate } from '../../../../shared/models/activitypub/activity'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
@@ -6,9 +7,8 @@ import { resetSequelizeInstance } from '../../../helpers/utils'
 import { database as db } from '../../../initializers'
 import { AccountInstance } from '../../../models/account/account-interface'
 import { VideoInstance } from '../../../models/video/video-interface'
-import { videoActivityObjectToDBAttributes, videoFileActivityUrlToDBAttributes } from './misc'
-import Bluebird = require('bluebird')
 import { getOrCreateAccountAndServer } from '../account'
+import { videoActivityObjectToDBAttributes, videoFileActivityUrlToDBAttributes } from './misc'
 
 async function processUpdateActivity (activity: ActivityUpdate) {
   const account = await getOrCreateAccountAndServer(activity.actor)
diff --git a/server/lib/activitypub/send/misc.ts b/server/lib/activitypub/send/misc.ts
index fd1add68e..999def701 100644
--- a/server/lib/activitypub/send/misc.ts
+++ b/server/lib/activitypub/send/misc.ts
@@ -25,8 +25,8 @@ async function forwardActivity (
     }
   }
 
-  const toAccountFollowers = await db.Account.listByFollowersUrls(followersUrls)
-  const uris = await computeFollowerUris(toAccountFollowers, followersException)
+  const toAccountFollowers = await db.Account.listByFollowersUrls(followersUrls, t)
+  const uris = await computeFollowerUris(toAccountFollowers, followersException, t)
 
   if (uris.length === 0) {
     logger.info('0 followers for %s, no forwarding.', toAccountFollowers.map(a => a.id).join(', '))
@@ -50,7 +50,7 @@ async function broadcastToFollowers (
   t: Transaction,
   followersException: AccountInstance[] = []
 ) {
-  const uris = await computeFollowerUris(toAccountFollowers, followersException)
+  const uris = await computeFollowerUris(toAccountFollowers, followersException, t)
   if (uris.length === 0) {
     logger.info('0 followers for %s, no broadcasting.', toAccountFollowers.map(a => a.id).join(', '))
     return undefined
@@ -100,22 +100,22 @@ function getObjectFollowersAudience (accountsInvolvedInObject: AccountInstance[]
   }
 }
 
-async function getAccountsInvolvedInVideo (video: VideoInstance) {
-  const accountsToForwardView = await db.VideoShare.loadAccountsByShare(video.id)
+async function getAccountsInvolvedInVideo (video: VideoInstance, t: Transaction) {
+  const accountsToForwardView = await db.VideoShare.loadAccountsByShare(video.id, t)
   accountsToForwardView.push(video.VideoChannel.Account)
 
   return accountsToForwardView
 }
 
-async function getAccountsInvolvedInVideoChannel (videoChannel: VideoChannelInstance) {
-  const accountsToForwardView = await db.VideoChannelShare.loadAccountsByShare(videoChannel.id)
+async function getAccountsInvolvedInVideoChannel (videoChannel: VideoChannelInstance, t: Transaction) {
+  const accountsToForwardView = await db.VideoChannelShare.loadAccountsByShare(videoChannel.id, t)
   accountsToForwardView.push(videoChannel.Account)
 
   return accountsToForwardView
 }
 
-async function getAudience (accountSender: AccountInstance, isPublic = true) {
-  const followerInboxUrls = await accountSender.getFollowerSharedInboxUrls()
+async function getAudience (accountSender: AccountInstance, t: Transaction, isPublic = true) {
+  const followerInboxUrls = await accountSender.getFollowerSharedInboxUrls(t)
 
   // Thanks Mastodon: https://github.com/tootsuite/mastodon/blob/master/app/lib/activitypub/tag_manager.rb#L47
   let to = []
@@ -132,10 +132,10 @@ async function getAudience (accountSender: AccountInstance, isPublic = true) {
   return { to, cc }
 }
 
-async function computeFollowerUris (toAccountFollower: AccountInstance[], followersException: AccountInstance[]) {
+async function computeFollowerUris (toAccountFollower: AccountInstance[], followersException: AccountInstance[], t: Transaction) {
   const toAccountFollowerIds = toAccountFollower.map(a => a.id)
 
-  const result = await db.AccountFollow.listAcceptedFollowerSharedInboxUrls(toAccountFollowerIds)
+  const result = await db.AccountFollow.listAcceptedFollowerSharedInboxUrls(toAccountFollowerIds, t)
   const followersSharedInboxException = followersException.map(f => f.sharedInboxUrl)
   const uris = result.data.filter(sharedInbox => followersSharedInboxException.indexOf(sharedInbox) === -1)
 
diff --git a/server/lib/activitypub/send/send-accept.ts b/server/lib/activitypub/send/send-accept.ts
index eeab19ed0..d3f8fbe38 100644
--- a/server/lib/activitypub/send/send-accept.ts
+++ b/server/lib/activitypub/send/send-accept.ts
@@ -10,7 +10,7 @@ async function sendAccept (accountFollow: AccountFollowInstance, t: Transaction)
   const me = accountFollow.AccountFollowing
 
   const url = getAccountFollowAcceptActivityPubUrl(accountFollow)
-  const data = await acceptActivityData(url, me)
+  const data = acceptActivityData(url, me)
 
   return unicastTo(data, me, follower.inboxUrl, t)
 }
@@ -23,7 +23,7 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function acceptActivityData (url: string, byAccount: AccountInstance) {
+function acceptActivityData (url: string, byAccount: AccountInstance) {
   const activity: ActivityAccept = {
     type: 'Accept',
     id: url,
diff --git a/server/lib/activitypub/send/send-add.ts b/server/lib/activitypub/send/send-add.ts
index 3012b7533..d8ac2853e 100644
--- a/server/lib/activitypub/send/send-add.ts
+++ b/server/lib/activitypub/send/send-add.ts
@@ -8,15 +8,22 @@ async function sendAddVideo (video: VideoInstance, t: Transaction) {
   const byAccount = video.VideoChannel.Account
 
   const videoObject = video.toActivityPubObject()
-  const data = await addActivityData(video.url, byAccount, video, video.VideoChannel.url, videoObject)
+  const data = await addActivityData(video.url, byAccount, video, video.VideoChannel.url, videoObject, t)
 
   return broadcastToFollowers(data, byAccount, [ byAccount ], t)
 }
 
-async function addActivityData (url: string, byAccount: AccountInstance, video: VideoInstance, target: string, object: any) {
+async function addActivityData (
+  url: string,
+  byAccount: AccountInstance,
+  video: VideoInstance,
+  target: string,
+  object: any,
+  t: Transaction
+) {
   const videoPublic = video.privacy === VideoPrivacy.PUBLIC
 
-  const { to, cc } = await getAudience(byAccount, videoPublic)
+  const { to, cc } = await getAudience(byAccount, t, videoPublic)
   const activity: ActivityAdd = {
     type: 'Add',
     id: url,
diff --git a/server/lib/activitypub/send/send-announce.ts b/server/lib/activitypub/send/send-announce.ts
index efc23af46..3acf604cd 100644
--- a/server/lib/activitypub/send/send-announce.ts
+++ b/server/lib/activitypub/send/send-announce.ts
@@ -21,11 +21,11 @@ async function buildVideoAnnounceToFollowers (byAccount: AccountInstance, video:
   const url = getAnnounceActivityPubUrl(video.url, byAccount)
 
   const videoChannel = video.VideoChannel
-  const announcedActivity = await addActivityData(url, videoChannel.Account, video, videoChannel.url, video.toActivityPubObject())
+  const announcedActivity = await addActivityData(url, videoChannel.Account, video, videoChannel.url, video.toActivityPubObject(), t)
 
-  const accountsToForwardView = await getAccountsInvolvedInVideo(video)
+  const accountsToForwardView = await getAccountsInvolvedInVideo(video, t)
   const audience = getObjectFollowersAudience(accountsToForwardView)
-  const data = await announceActivityData(url, byAccount, announcedActivity, audience)
+  const data = await announceActivityData(url, byAccount, announcedActivity, t, audience)
 
   return data
 }
@@ -40,22 +40,22 @@ async function sendVideoAnnounceToOrigin (byAccount: AccountInstance, video: Vid
   const url = getAnnounceActivityPubUrl(video.url, byAccount)
 
   const videoChannel = video.VideoChannel
-  const announcedActivity = await addActivityData(url, videoChannel.Account, video, videoChannel.url, video.toActivityPubObject())
+  const announcedActivity = await addActivityData(url, videoChannel.Account, video, videoChannel.url, video.toActivityPubObject(), t)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video, t)
   const audience = getOriginVideoAudience(video, accountsInvolvedInVideo)
-  const data = await createActivityData(url, byAccount, announcedActivity, audience)
+  const data = await createActivityData(url, byAccount, announcedActivity, t, audience)
 
   return unicastTo(data, byAccount, videoChannel.Account.sharedInboxUrl, t)
 }
 
 async function buildVideoChannelAnnounceToFollowers (byAccount: AccountInstance, videoChannel: VideoChannelInstance, t: Transaction) {
   const url = getAnnounceActivityPubUrl(videoChannel.url, byAccount)
-  const announcedActivity = await createActivityData(url, videoChannel.Account, videoChannel.toActivityPubObject())
+  const announcedActivity = await createActivityData(url, videoChannel.Account, videoChannel.toActivityPubObject(), t)
 
-  const accountsToForwardView = await getAccountsInvolvedInVideoChannel(videoChannel)
+  const accountsToForwardView = await getAccountsInvolvedInVideoChannel(videoChannel, t)
   const audience = getObjectFollowersAudience(accountsToForwardView)
-  const data = await announceActivityData(url, byAccount, announcedActivity, audience)
+  const data = await announceActivityData(url, byAccount, announcedActivity, t, audience)
 
   return data
 }
@@ -68,11 +68,11 @@ async function sendVideoChannelAnnounceToFollowers (byAccount: AccountInstance,
 
 async function sendVideoChannelAnnounceToOrigin (byAccount: AccountInstance, videoChannel: VideoChannelInstance, t: Transaction) {
   const url = getAnnounceActivityPubUrl(videoChannel.url, byAccount)
-  const announcedActivity = await createActivityData(url, videoChannel.Account, videoChannel.toActivityPubObject())
+  const announcedActivity = await createActivityData(url, videoChannel.Account, videoChannel.toActivityPubObject(), t)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideoChannel(videoChannel)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideoChannel(videoChannel, t)
   const audience = getOriginVideoChannelAudience(videoChannel, accountsInvolvedInVideo)
-  const data = await createActivityData(url, byAccount, announcedActivity, audience)
+  const data = await createActivityData(url, byAccount, announcedActivity, t, audience)
 
   return unicastTo(data, byAccount, videoChannel.Account.sharedInboxUrl, t)
 }
@@ -81,10 +81,11 @@ async function announceActivityData (
   url: string,
   byAccount: AccountInstance,
   object: ActivityCreate | ActivityAdd,
+  t: Transaction,
   audience?: ActivityAudience
 ) {
   if (!audience) {
-    audience = await getAudience(byAccount)
+    audience = await getAudience(byAccount, t)
   }
 
   const activity: ActivityAnnounce = {
diff --git a/server/lib/activitypub/send/send-create.ts b/server/lib/activitypub/send/send-create.ts
index bf66606c1..a34d3776c 100644
--- a/server/lib/activitypub/send/send-create.ts
+++ b/server/lib/activitypub/send/send-create.ts
@@ -8,8 +8,8 @@ import {
   broadcastToFollowers,
   getAccountsInvolvedInVideo,
   getAudience,
-  getOriginVideoAudience,
   getObjectFollowersAudience,
+  getOriginVideoAudience,
   unicastTo
 } from './misc'
 
@@ -17,7 +17,7 @@ async function sendCreateVideoChannel (videoChannel: VideoChannelInstance, t: Tr
   const byAccount = videoChannel.Account
 
   const videoChannelObject = videoChannel.toActivityPubObject()
-  const data = await createActivityData(videoChannel.url, byAccount, videoChannelObject)
+  const data = await createActivityData(videoChannel.url, byAccount, videoChannelObject, t)
 
   return broadcastToFollowers(data, byAccount, [ byAccount ], t)
 }
@@ -26,7 +26,7 @@ async function sendVideoAbuse (byAccount: AccountInstance, videoAbuse: VideoAbus
   const url = getVideoAbuseActivityPubUrl(videoAbuse)
 
   const audience = { to: [ video.VideoChannel.Account.url ], cc: [] }
-  const data = await createActivityData(url, byAccount, videoAbuse.toActivityPubObject(), audience)
+  const data = await createActivityData(url, byAccount, videoAbuse.toActivityPubObject(), t, audience)
 
   return unicastTo(data, byAccount, video.VideoChannel.Account.sharedInboxUrl, t)
 }
@@ -35,9 +35,9 @@ async function sendCreateViewToOrigin (byAccount: AccountInstance, video: VideoI
   const url = getVideoViewActivityPubUrl(byAccount, video)
   const viewActivity = createViewActivityData(byAccount, video)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video, t)
   const audience = getOriginVideoAudience(video, accountsInvolvedInVideo)
-  const data = await createActivityData(url, byAccount, viewActivity, audience)
+  const data = await createActivityData(url, byAccount, viewActivity, t, audience)
 
   return unicastTo(data, byAccount, video.VideoChannel.Account.sharedInboxUrl, t)
 }
@@ -46,9 +46,9 @@ async function sendCreateViewToVideoFollowers (byAccount: AccountInstance, video
   const url = getVideoViewActivityPubUrl(byAccount, video)
   const viewActivity = createViewActivityData(byAccount, video)
 
-  const accountsToForwardView = await getAccountsInvolvedInVideo(video)
+  const accountsToForwardView = await getAccountsInvolvedInVideo(video, t)
   const audience = getObjectFollowersAudience(accountsToForwardView)
-  const data = await createActivityData(url, byAccount, viewActivity, audience)
+  const data = await createActivityData(url, byAccount, viewActivity, t, audience)
 
   // Use the server account to send the view, because it could be an unregistered account
   const serverAccount = await getServerAccount()
@@ -60,9 +60,9 @@ async function sendCreateDislikeToOrigin (byAccount: AccountInstance, video: Vid
   const url = getVideoDislikeActivityPubUrl(byAccount, video)
   const dislikeActivity = createDislikeActivityData(byAccount, video)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video, t)
   const audience = getOriginVideoAudience(video, accountsInvolvedInVideo)
-  const data = await createActivityData(url, byAccount, dislikeActivity, audience)
+  const data = await createActivityData(url, byAccount, dislikeActivity, t, audience)
 
   return unicastTo(data, byAccount, video.VideoChannel.Account.sharedInboxUrl, t)
 }
@@ -71,17 +71,17 @@ async function sendCreateDislikeToVideoFollowers (byAccount: AccountInstance, vi
   const url = getVideoDislikeActivityPubUrl(byAccount, video)
   const dislikeActivity = createDislikeActivityData(byAccount, video)
 
-  const accountsToForwardView = await getAccountsInvolvedInVideo(video)
+  const accountsToForwardView = await getAccountsInvolvedInVideo(video, t)
   const audience = getObjectFollowersAudience(accountsToForwardView)
-  const data = await createActivityData(url, byAccount, dislikeActivity, audience)
+  const data = await createActivityData(url, byAccount, dislikeActivity, t, audience)
 
   const followersException = [ byAccount ]
   return broadcastToFollowers(data, byAccount, accountsToForwardView, t, followersException)
 }
 
-async function createActivityData (url: string, byAccount: AccountInstance, object: any, audience?: ActivityAudience) {
+async function createActivityData (url: string, byAccount: AccountInstance, object: any, t: Transaction, audience?: ActivityAudience) {
   if (!audience) {
-    audience = await getAudience(byAccount)
+    audience = await getAudience(byAccount, t)
   }
 
   const activity: ActivityCreate = {
diff --git a/server/lib/activitypub/send/send-delete.ts b/server/lib/activitypub/send/send-delete.ts
index 5be0e2d24..c49cda04f 100644
--- a/server/lib/activitypub/send/send-delete.ts
+++ b/server/lib/activitypub/send/send-delete.ts
@@ -7,9 +7,9 @@ import { broadcastToFollowers } from './misc'
 async function sendDeleteVideoChannel (videoChannel: VideoChannelInstance, t: Transaction) {
   const byAccount = videoChannel.Account
 
-  const data = await deleteActivityData(videoChannel.url, byAccount)
+  const data = deleteActivityData(videoChannel.url, byAccount)
 
-  const accountsInvolved = await db.VideoChannelShare.loadAccountsByShare(videoChannel.id)
+  const accountsInvolved = await db.VideoChannelShare.loadAccountsByShare(videoChannel.id, t)
   accountsInvolved.push(byAccount)
 
   return broadcastToFollowers(data, byAccount, accountsInvolved, t)
@@ -18,9 +18,9 @@ async function sendDeleteVideoChannel (videoChannel: VideoChannelInstance, t: Tr
 async function sendDeleteVideo (video: VideoInstance, t: Transaction) {
   const byAccount = video.VideoChannel.Account
 
-  const data = await deleteActivityData(video.url, byAccount)
+  const data = deleteActivityData(video.url, byAccount)
 
-  const accountsInvolved = await db.VideoShare.loadAccountsByShare(video.id)
+  const accountsInvolved = await db.VideoShare.loadAccountsByShare(video.id, t)
   accountsInvolved.push(byAccount)
 
   return broadcastToFollowers(data, byAccount, accountsInvolved, t)
@@ -42,7 +42,7 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function deleteActivityData (url: string, byAccount: AccountInstance) {
+function deleteActivityData (url: string, byAccount: AccountInstance) {
   const activity: ActivityDelete = {
     type: 'Delete',
     id: url,
diff --git a/server/lib/activitypub/send/send-follow.ts b/server/lib/activitypub/send/send-follow.ts
index 3c01fb77c..8fba1b6b5 100644
--- a/server/lib/activitypub/send/send-follow.ts
+++ b/server/lib/activitypub/send/send-follow.ts
@@ -5,17 +5,17 @@ import { AccountFollowInstance } from '../../../models/account/account-follow-in
 import { getAccountFollowActivityPubUrl } from '../url'
 import { unicastTo } from './misc'
 
-async function sendFollow (accountFollow: AccountFollowInstance, t: Transaction) {
+function sendFollow (accountFollow: AccountFollowInstance, t: Transaction) {
   const me = accountFollow.AccountFollower
   const following = accountFollow.AccountFollowing
 
   const url = getAccountFollowActivityPubUrl(accountFollow)
-  const data = await followActivityData(url, me, following)
+  const data = followActivityData(url, me, following)
 
   return unicastTo(data, me, following.inboxUrl, t)
 }
 
-async function followActivityData (url: string, byAccount: AccountInstance, targetAccount: AccountInstance) {
+function followActivityData (url: string, byAccount: AccountInstance, targetAccount: AccountInstance) {
   const activity: ActivityFollow = {
     type: 'Follow',
     id: url,
diff --git a/server/lib/activitypub/send/send-like.ts b/server/lib/activitypub/send/send-like.ts
index 41b879b8a..0c464b2d3 100644
--- a/server/lib/activitypub/send/send-like.ts
+++ b/server/lib/activitypub/send/send-like.ts
@@ -1,5 +1,5 @@
 import { Transaction } from 'sequelize'
-import { ActivityLike } from '../../../../shared/models/activitypub/activity'
+import { ActivityAudience, ActivityLike } from '../../../../shared/models/activitypub/activity'
 import { AccountInstance, VideoInstance } from '../../../models'
 import { getVideoLikeActivityPubUrl } from '../url'
 import {
@@ -14,9 +14,9 @@ import {
 async function sendLikeToOrigin (byAccount: AccountInstance, video: VideoInstance, t: Transaction) {
   const url = getVideoLikeActivityPubUrl(byAccount, video)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video, t)
   const audience = getOriginVideoAudience(video, accountsInvolvedInVideo)
-  const data = await likeActivityData(url, byAccount, video, audience)
+  const data = await likeActivityData(url, byAccount, video, t, audience)
 
   return unicastTo(data, byAccount, video.VideoChannel.Account.sharedInboxUrl, t)
 }
@@ -24,19 +24,23 @@ async function sendLikeToOrigin (byAccount: AccountInstance, video: VideoInstanc
 async function sendLikeToVideoFollowers (byAccount: AccountInstance, video: VideoInstance, t: Transaction) {
   const url = getVideoLikeActivityPubUrl(byAccount, video)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video, t)
   const audience = getObjectFollowersAudience(accountsInvolvedInVideo)
-  const data = await likeActivityData(url, byAccount, video, audience)
-
-  const toAccountsFollowers = await getAccountsInvolvedInVideo(video)
+  const data = await likeActivityData(url, byAccount, video, t, audience)
 
   const followersException = [ byAccount ]
-  return broadcastToFollowers(data, byAccount, toAccountsFollowers, t, followersException)
+  return broadcastToFollowers(data, byAccount, accountsInvolvedInVideo, t, followersException)
 }
 
-async function likeActivityData (url: string, byAccount: AccountInstance, video: VideoInstance, audience?: { to: string[], cc: string[] }) {
+async function likeActivityData (
+  url: string,
+  byAccount: AccountInstance,
+  video: VideoInstance,
+  t: Transaction,
+  audience?: ActivityAudience
+) {
   if (!audience) {
-    audience = await getAudience(byAccount)
+    audience = await getAudience(byAccount, t)
   }
 
   const activity: ActivityLike = {
diff --git a/server/lib/activitypub/send/send-undo.ts b/server/lib/activitypub/send/send-undo.ts
index 878acd21e..2f5e6998e 100644
--- a/server/lib/activitypub/send/send-undo.ts
+++ b/server/lib/activitypub/send/send-undo.ts
@@ -29,8 +29,8 @@ async function sendUndoFollow (accountFollow: AccountFollowInstance, t: Transact
   const followUrl = getAccountFollowActivityPubUrl(accountFollow)
   const undoUrl = getUndoActivityPubUrl(followUrl)
 
-  const object = await followActivityData(followUrl, me, following)
-  const data = await undoActivityData(undoUrl, me, object)
+  const object = followActivityData(followUrl, me, following)
+  const data = await undoActivityData(undoUrl, me, object, t)
 
   return unicastTo(data, me, following.inboxUrl, t)
 }
@@ -39,10 +39,10 @@ async function sendUndoLikeToOrigin (byAccount: AccountInstance, video: VideoIns
   const likeUrl = getVideoLikeActivityPubUrl(byAccount, video)
   const undoUrl = getUndoActivityPubUrl(likeUrl)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video, t)
   const audience = getOriginVideoAudience(video, accountsInvolvedInVideo)
-  const object = await likeActivityData(likeUrl, byAccount, video)
-  const data = await undoActivityData(undoUrl, byAccount, object, audience)
+  const object = await likeActivityData(likeUrl, byAccount, video, t)
+  const data = await undoActivityData(undoUrl, byAccount, object, t, audience)
 
   return unicastTo(data, byAccount, video.VideoChannel.Account.sharedInboxUrl, t)
 }
@@ -51,10 +51,10 @@ async function sendUndoLikeToVideoFollowers (byAccount: AccountInstance, video:
   const likeUrl = getVideoLikeActivityPubUrl(byAccount, video)
   const undoUrl = getUndoActivityPubUrl(likeUrl)
 
-  const toAccountsFollowers = await getAccountsInvolvedInVideo(video)
+  const toAccountsFollowers = await getAccountsInvolvedInVideo(video, t)
   const audience = getObjectFollowersAudience(toAccountsFollowers)
-  const object = await likeActivityData(likeUrl, byAccount, video)
-  const data = await undoActivityData(undoUrl, byAccount, object, audience)
+  const object = await likeActivityData(likeUrl, byAccount, video, t)
+  const data = await undoActivityData(undoUrl, byAccount, object, t, audience)
 
   const followersException = [ byAccount ]
   return broadcastToFollowers(data, byAccount, toAccountsFollowers, t, followersException)
@@ -64,12 +64,12 @@ async function sendUndoDislikeToOrigin (byAccount: AccountInstance, video: Video
   const dislikeUrl = getVideoDislikeActivityPubUrl(byAccount, video)
   const undoUrl = getUndoActivityPubUrl(dislikeUrl)
 
-  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video)
+  const accountsInvolvedInVideo = await getAccountsInvolvedInVideo(video, t)
   const audience = getOriginVideoAudience(video, accountsInvolvedInVideo)
   const dislikeActivity = createDislikeActivityData(byAccount, video)
-  const object = await createActivityData(undoUrl, byAccount, dislikeActivity, audience)
+  const object = await createActivityData(undoUrl, byAccount, dislikeActivity, t, audience)
 
-  const data = await undoActivityData(undoUrl, byAccount, object)
+  const data = await undoActivityData(undoUrl, byAccount, object, t)
 
   return unicastTo(data, byAccount, video.VideoChannel.Account.sharedInboxUrl, t)
 }
@@ -79,11 +79,11 @@ async function sendUndoDislikeToVideoFollowers (byAccount: AccountInstance, vide
   const undoUrl = getUndoActivityPubUrl(dislikeUrl)
 
   const dislikeActivity = createDislikeActivityData(byAccount, video)
-  const object = await createActivityData(undoUrl, byAccount, dislikeActivity)
+  const object = await createActivityData(undoUrl, byAccount, dislikeActivity, t)
 
-  const data = await undoActivityData(undoUrl, byAccount, object)
+  const data = await undoActivityData(undoUrl, byAccount, object, t)
 
-  const toAccountsFollowers = await getAccountsInvolvedInVideo(video)
+  const toAccountsFollowers = await getAccountsInvolvedInVideo(video, t)
 
   const followersException = [ byAccount ]
   return broadcastToFollowers(data, byAccount, toAccountsFollowers, t, followersException)
@@ -105,10 +105,11 @@ async function undoActivityData (
   url: string,
   byAccount: AccountInstance,
   object: ActivityFollow | ActivityLike | ActivityCreate,
+  t: Transaction,
   audience?: ActivityAudience
 ) {
   if (!audience) {
-    audience = await getAudience(byAccount)
+    audience = await getAudience(byAccount, t)
   }
 
   const activity: ActivityUndo = {
diff --git a/server/lib/activitypub/send/send-update.ts b/server/lib/activitypub/send/send-update.ts
index 32cada06e..59524e523 100644
--- a/server/lib/activitypub/send/send-update.ts
+++ b/server/lib/activitypub/send/send-update.ts
@@ -10,9 +10,9 @@ async function sendUpdateVideoChannel (videoChannel: VideoChannelInstance, t: Tr
 
   const url = getUpdateActivityPubUrl(videoChannel.url, videoChannel.updatedAt.toISOString())
   const videoChannelObject = videoChannel.toActivityPubObject()
-  const data = await updateActivityData(url, byAccount, videoChannelObject)
+  const data = await updateActivityData(url, byAccount, videoChannelObject, t)
 
-  const accountsInvolved = await db.VideoChannelShare.loadAccountsByShare(videoChannel.id)
+  const accountsInvolved = await db.VideoChannelShare.loadAccountsByShare(videoChannel.id, t)
   accountsInvolved.push(byAccount)
 
   return broadcastToFollowers(data, byAccount, accountsInvolved, t)
@@ -23,9 +23,9 @@ async function sendUpdateVideo (video: VideoInstance, t: Transaction) {
 
   const url = getUpdateActivityPubUrl(video.url, video.updatedAt.toISOString())
   const videoObject = video.toActivityPubObject()
-  const data = await updateActivityData(url, byAccount, videoObject)
+  const data = await updateActivityData(url, byAccount, videoObject, t)
 
-  const accountsInvolved = await db.VideoShare.loadAccountsByShare(video.id)
+  const accountsInvolved = await db.VideoShare.loadAccountsByShare(video.id, t)
   accountsInvolved.push(byAccount)
 
   return broadcastToFollowers(data, byAccount, accountsInvolved, t)
@@ -40,8 +40,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function updateActivityData (url: string, byAccount: AccountInstance, object: any) {
-  const { to, cc } = await getAudience(byAccount)
+async function updateActivityData (url: string, byAccount: AccountInstance, object: any, t: Transaction) {
+  const { to, cc } = await getAudience(byAccount, t)
   const activity: ActivityUpdate = {
     type: 'Update',
     id: url,
diff --git a/server/models/account/account-follow-interface.ts b/server/models/account/account-follow-interface.ts
index a0d620dd0..7975a46f3 100644
--- a/server/models/account/account-follow-interface.ts
+++ b/server/models/account/account-follow-interface.ts
@@ -14,9 +14,19 @@ export namespace AccountFollowMethods {
   export type ListFollowingForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountFollowInstance>>
   export type ListFollowersForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountFollowInstance>>
 
-  export type ListAcceptedFollowerUrlsForApi = (accountId: number[], start?: number, count?: number) => Promise< ResultList<string> >
-  export type ListAcceptedFollowingUrlsForApi = (accountId: number[], start?: number, count?: number) => Promise< ResultList<string> >
-  export type ListAcceptedFollowerSharedInboxUrls = (accountId: number[]) => Promise< ResultList<string> >
+  export type ListAcceptedFollowerUrlsForApi = (
+    accountId: number[],
+    t: Sequelize.Transaction,
+    start?: number,
+    count?: number
+  ) => Promise< ResultList<string> >
+  export type ListAcceptedFollowingUrlsForApi = (
+    accountId: number[],
+    t: Sequelize.Transaction,
+    start?: number,
+    count?: number
+  ) => Promise< ResultList<string> >
+  export type ListAcceptedFollowerSharedInboxUrls = (accountId: number[], t: Sequelize.Transaction) => Promise< ResultList<string> >
   export type ToFormattedJSON = (this: AccountFollowInstance) => AccountFollow
 }
 
diff --git a/server/models/account/account-follow.ts b/server/models/account/account-follow.ts
index 8e35c7d20..724f37baa 100644
--- a/server/models/account/account-follow.ts
+++ b/server/models/account/account-follow.ts
@@ -181,16 +181,16 @@ listFollowersForApi = function (id: number, start: number, count: number, sort:
   })
 }
 
-listAcceptedFollowerUrlsForApi = function (accountIds: number[], start?: number, count?: number) {
-  return createListAcceptedFollowForApiQuery('followers', accountIds, start, count)
+listAcceptedFollowerUrlsForApi = function (accountIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
+  return createListAcceptedFollowForApiQuery('followers', accountIds, t, start, count)
 }
 
-listAcceptedFollowerSharedInboxUrls = function (accountIds: number[]) {
-  return createListAcceptedFollowForApiQuery('followers', accountIds, undefined, undefined, 'sharedInboxUrl')
+listAcceptedFollowerSharedInboxUrls = function (accountIds: number[], t: Sequelize.Transaction) {
+  return createListAcceptedFollowForApiQuery('followers', accountIds, t, undefined, undefined, 'sharedInboxUrl')
 }
 
-listAcceptedFollowingUrlsForApi = function (accountIds: number[], start?: number, count?: number) {
-  return createListAcceptedFollowForApiQuery('following', accountIds, start, count)
+listAcceptedFollowingUrlsForApi = function (accountIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
+  return createListAcceptedFollowForApiQuery('following', accountIds, t, start, count)
 }
 
 // ------------------------------ UTILS ------------------------------
@@ -198,6 +198,7 @@ listAcceptedFollowingUrlsForApi = function (accountIds: number[], start?: number
 async function createListAcceptedFollowForApiQuery (
   type: 'followers' | 'following',
   accountIds: number[],
+  t: Sequelize.Transaction,
   start?: number,
   count?: number,
   columnUrl = 'url'
@@ -227,7 +228,8 @@ async function createListAcceptedFollowForApiQuery (
 
     const options = {
       bind: { accountIds },
-      type: Sequelize.QueryTypes.SELECT
+      type: Sequelize.QueryTypes.SELECT,
+      transaction: t
     }
     tasks.push(AccountFollow['sequelize'].query(query, options))
   }
diff --git a/server/models/account/account-interface.ts b/server/models/account/account-interface.ts
index 6fc98ba45..b369766dc 100644
--- a/server/models/account/account-interface.ts
+++ b/server/models/account/account-interface.ts
@@ -12,12 +12,12 @@ export namespace AccountMethods {
   export type LoadByUrl = (url: string, transaction?: Sequelize.Transaction) => Bluebird<AccountInstance>
   export type LoadLocalByName = (name: string) => Bluebird<AccountInstance>
   export type LoadByNameAndHost = (name: string, host: string) => Bluebird<AccountInstance>
-  export type ListByFollowersUrls = (followerUrls: string[], transaction?: Sequelize.Transaction) => Bluebird<AccountInstance[]>
+  export type ListByFollowersUrls = (followerUrls: string[], transaction: Sequelize.Transaction) => Bluebird<AccountInstance[]>
 
   export type ToActivityPubObject = (this: AccountInstance) => ActivityPubActor
   export type ToFormattedJSON = (this: AccountInstance) => FormattedAccount
   export type IsOwned = (this: AccountInstance) => boolean
-  export type GetFollowerSharedInboxUrls = (this: AccountInstance) => Bluebird<string[]>
+  export type GetFollowerSharedInboxUrls = (this: AccountInstance, t: Sequelize.Transaction) => Bluebird<string[]>
   export type GetFollowingUrl = (this: AccountInstance) => string
   export type GetFollowersUrl = (this: AccountInstance) => string
   export type GetPublicKeyUrl = (this: AccountInstance) => string
diff --git a/server/models/account/account-video-rate.ts b/server/models/account/account-video-rate.ts
index 7f7c97606..d92834bbb 100644
--- a/server/models/account/account-video-rate.ts
+++ b/server/models/account/account-video-rate.ts
@@ -28,7 +28,7 @@ export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.Da
     {
       indexes: [
         {
-          fields: [ 'videoId', 'accountId', 'type' ],
+          fields: [ 'videoId', 'accountId' ],
           unique: true
         }
       ]
diff --git a/server/models/account/account.ts b/server/models/account/account.ts
index c721656cb..61a88524c 100644
--- a/server/models/account/account.ts
+++ b/server/models/account/account.ts
@@ -10,7 +10,6 @@ import {
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
 import { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { sendDeleteAccount } from '../../lib/activitypub/send/send-delete'
-
 import { addMethodsToModel } from '../utils'
 import { AccountAttributes, AccountInstance, AccountMethods } from './account-interface'
 
@@ -315,7 +314,7 @@ isOwned = function (this: AccountInstance) {
   return this.serverId === null
 }
 
-getFollowerSharedInboxUrls = function (this: AccountInstance) {
+getFollowerSharedInboxUrls = function (this: AccountInstance, t: Sequelize.Transaction) {
   const query: Sequelize.FindOptions<AccountAttributes> = {
     attributes: [ 'sharedInboxUrl' ],
     include: [
@@ -327,7 +326,8 @@ getFollowerSharedInboxUrls = function (this: AccountInstance) {
           targetAccountId: this.id
         }
       }
-    ]
+    ],
+    transaction: t
   }
 
   return Account.findAll(query)
diff --git a/server/models/video/video-channel-share-interface.ts b/server/models/video/video-channel-share-interface.ts
index bcb3a0e24..0482e8297 100644
--- a/server/models/video/video-channel-share-interface.ts
+++ b/server/models/video/video-channel-share-interface.ts
@@ -1,11 +1,12 @@
 import * as Bluebird from 'bluebird'
 import * as Sequelize from 'sequelize'
+import { Transaction } from 'sequelize'
 import { AccountInstance } from '../account/account-interface'
 import { VideoChannelInstance } from './video-channel-interface'
 
 export namespace VideoChannelShareMethods {
-  export type LoadAccountsByShare = (videoChannelId: number) => Bluebird<AccountInstance[]>
-  export type Load = (accountId: number, videoId: number) => Bluebird<VideoChannelShareInstance>
+  export type LoadAccountsByShare = (videoChannelId: number, t: Transaction) => Bluebird<AccountInstance[]>
+  export type Load = (accountId: number, videoId: number, t: Transaction) => Bluebird<VideoChannelShareInstance>
 }
 
 export interface VideoChannelShareClass {
diff --git a/server/models/video/video-channel-share.ts b/server/models/video/video-channel-share.ts
index e47c0dae7..2e9b658a3 100644
--- a/server/models/video/video-channel-share.ts
+++ b/server/models/video/video-channel-share.ts
@@ -52,7 +52,7 @@ function associate (models) {
   })
 }
 
-load = function (accountId: number, videoChannelId: number) {
+load = function (accountId: number, videoChannelId: number, t: Sequelize.Transaction) {
   return VideoChannelShare.findOne({
     where: {
       accountId,
@@ -61,11 +61,12 @@ load = function (accountId: number, videoChannelId: number) {
     include: [
       VideoChannelShare['sequelize'].models.Account,
       VideoChannelShare['sequelize'].models.VideoChannel
-    ]
+    ],
+    transaction: t
   })
 }
 
-loadAccountsByShare = function (videoChannelId: number) {
+loadAccountsByShare = function (videoChannelId: number, t: Sequelize.Transaction) {
   const query = {
     where: {
       videoChannelId
@@ -75,7 +76,8 @@ loadAccountsByShare = function (videoChannelId: number) {
         model: VideoChannelShare['sequelize'].models.Account,
         required: true
       }
-    ]
+    ],
+    transaction: t
   }
 
   return VideoChannelShare.findAll(query)
diff --git a/server/models/video/video-share-interface.ts b/server/models/video/video-share-interface.ts
index ad23444b6..8ad10e095 100644
--- a/server/models/video/video-share-interface.ts
+++ b/server/models/video/video-share-interface.ts
@@ -1,11 +1,12 @@
 import * as Bluebird from 'bluebird'
 import * as Sequelize from 'sequelize'
+import { Transaction } from 'sequelize'
 import { AccountInstance } from '../account/account-interface'
 import { VideoInstance } from './video-interface'
 
 export namespace VideoShareMethods {
-  export type LoadAccountsByShare = (videoId: number) => Bluebird<AccountInstance[]>
-  export type Load = (accountId: number, videoId: number) => Bluebird<VideoShareInstance>
+  export type LoadAccountsByShare = (videoId: number, t: Transaction) => Bluebird<AccountInstance[]>
+  export type Load = (accountId: number, videoId: number, t: Transaction) => Bluebird<VideoShareInstance>
 }
 
 export interface VideoShareClass {
diff --git a/server/models/video/video-share.ts b/server/models/video/video-share.ts
index fe5d56d42..37e405fa9 100644
--- a/server/models/video/video-share.ts
+++ b/server/models/video/video-share.ts
@@ -52,7 +52,7 @@ function associate (models) {
   })
 }
 
-load = function (accountId: number, videoId: number) {
+load = function (accountId: number, videoId: number, t: Sequelize.Transaction) {
   return VideoShare.findOne({
     where: {
       accountId,
@@ -60,11 +60,12 @@ load = function (accountId: number, videoId: number) {
     },
     include: [
       VideoShare['sequelize'].models.Account
-    ]
+    ],
+    transaction: t
   })
 }
 
-loadAccountsByShare = function (videoId: number) {
+loadAccountsByShare = function (videoId: number, t: Sequelize.Transaction) {
   const query = {
     where: {
       videoId
@@ -74,7 +75,8 @@ loadAccountsByShare = function (videoId: number) {
         model: VideoShare['sequelize'].models.Account,
         required: true
       }
-    ]
+    ],
+    transaction: t
   }
 
   return VideoShare.findAll(query)