Merge pull request #17065 from overleaf/dp-mongoose-callback-inactive-project-manager

Promisify InactiveProjectManager and InactiveProjectManagerTests

GitOrigin-RevId: 985d0d4c80bfd1e46fa3c85c98203432459bdc84

services/web/app/src/Features/InactiveData/InactiveProjectManager.js

@@ -1,17 +1,4 @@
-/* eslint-disable
-    max-len,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-let InactiveProjectManager
 const OError = require('@overleaf/o-error')
-const async = require('async')
-const _ = require('lodash')
 const logger = require('@overleaf/logger')
 const DocstoreManager = require('../Docstore/DocstoreManager')
 const ProjectGetter = require('../Project/ProjectGetter')
@@ -19,43 +6,45 @@ const ProjectUpdateHandler = require('../Project/ProjectUpdateHandler')
 const { Project } = require('../../models/Project')
 const { ObjectId } = require('mongodb')
 const { READ_PREFERENCE_SECONDARY } = require('../../infrastructure/mongodb')
+const { callbackifyAll } = require('@overleaf/promise-utils')
 
 const MILISECONDS_IN_DAY = 86400000
-module.exports = InactiveProjectManager = {
-  reactivateProjectIfRequired(projectId, callback) {
-    ProjectGetter.getProject(
-      projectId,
-      { active: true },
-      function (err, project) {
-        if (err != null) {
-          OError.tag(err, 'error getting project', {
-            project_id: projectId,
-          })
-          return callback(err)
-        }
-        logger.debug(
-          { projectId, active: project.active },
-          'seeing if need to reactivate project'
-        )
+const InactiveProjectManager = {
+  async reactivateProjectIfRequired(projectId) {
+    let project
+    try {
+      project = await ProjectGetter.promises.getProject(projectId, {
+        active: true,
+      })
+    } catch (err) {
+      OError.tag(err, 'error getting project', {
+        project_id: projectId,
+      })
+      throw err
+    }
 
-        if (project.active) {
-          return callback()
-        }
-
-        DocstoreManager.unarchiveProject(projectId, function (err) {
-          if (err != null) {
-            OError.tag(err, 'error reactivating project in docstore', {
-              project_id: projectId,
-            })
-            return callback(err)
-          }
-          ProjectUpdateHandler.markAsActive(projectId, callback)
-        })
-      }
+    logger.debug(
+      { projectId, active: project.active },
+      'seeing if need to reactivate project'
     )
+
+    if (project.active) {
+      return
+    }
+
+    try {
+      await DocstoreManager.promises.unarchiveProject(projectId)
+    } catch (err) {
+      OError.tag(err, 'error reactivating project in docstore', {
+        project_id: projectId,
+      })
+      throw err
+    }
+
+    await ProjectUpdateHandler.promises.markAsActive(projectId)
   },
 
-  deactivateOldProjects(limit, daysOld, callback) {
+  async deactivateOldProjects(limit, daysOld) {
     if (limit == null) {
       limit = 10
     }
@@ -63,60 +52,59 @@ module.exports = InactiveProjectManager = {
       daysOld = 360
     }
     const oldProjectDate = new Date() - MILISECONDS_IN_DAY * daysOld
-    // use $not $gt to catch non-opened projects where lastOpened is null
-    Project.find({ lastOpened: { $not: { $gt: oldProjectDate } } })
-      .where('_id')
-      .lt(ObjectId.createFromTime(oldProjectDate / 1000))
-      .where('active')
-      .equals(true)
-      .select('_id')
-      .sort({ _id: 1 })
-      .limit(limit)
-      .read(READ_PREFERENCE_SECONDARY)
-      .exec(function (err, projects) {
-        if (err != null) {
-          logger.err({ err }, 'could not get projects for deactivating')
-        }
-        const jobs = _.map(
-          projects,
-          project => cb =>
-            InactiveProjectManager.deactivateProject(
-              project._id,
-              function (err) {
-                if (err) {
-                  logger.err(
-                    { projectId: project._id, err },
-                    'unable to deactivate project'
-                  )
-                }
-                cb()
-              }
-            )
-        )
-        logger.debug(
-          { numberOfProjects: projects && projects.length },
-          'deactivating projects'
-        )
-        async.series(jobs, function (err) {
-          if (err != null) {
-            logger.warn({ err }, 'error deactivating projects')
-          }
-          callback(err, projects)
-        })
+
+    let projects
+    try {
+      // use $not $gt to catch non-opened projects where lastOpened is null
+      projects = await Project.find({
+        lastOpened: { $not: { $gt: oldProjectDate } },
       })
+        .where('_id')
+        .lt(ObjectId.createFromTime(oldProjectDate / 1000))
+        .where('active')
+        .equals(true)
+        .select('_id')
+        .sort({ _id: 1 })
+        .limit(limit)
+        .read(READ_PREFERENCE_SECONDARY)
+        .exec()
+    } catch (err) {
+      logger.err({ err }, 'could not get projects for deactivating')
+    }
+
+    logger.debug(
+      { numberOfProjects: projects && projects.length },
+      'deactivating projects'
+    )
+
+    for (const project of projects) {
+      try {
+        await InactiveProjectManager.deactivateProject(project._id)
+      } catch (err) {
+        logger.err(
+          { projectId: project._id, err },
+          'unable to deactivate project'
+        )
+      }
+    }
+
+    return projects
   },
 
-  deactivateProject(projectId, callback) {
+  async deactivateProject(projectId) {
     logger.debug({ projectId }, 'deactivating inactive project')
-    const jobs = [
-      cb => DocstoreManager.archiveProject(projectId, cb),
-      cb => ProjectUpdateHandler.markAsInactive(projectId, cb),
-    ]
-    async.series(jobs, function (err) {
-      if (err != null) {
-        logger.warn({ err, projectId }, 'error deactivating project')
-      }
-      callback(err)
-    })
+
+    try {
+      await DocstoreManager.promises.archiveProject(projectId)
+      await ProjectUpdateHandler.promises.markAsInactive(projectId)
+    } catch (err) {
+      logger.warn({ err, projectId }, 'error deactivating project')
+      throw err
+    }
   },
 }
+
+module.exports = {
+  ...callbackifyAll(InactiveProjectManager),
+  promises: InactiveProjectManager,
+}