overleaf/services/web/scripts/history/HistoryUpgradeHelper.js

const { ReadPreference, ObjectId } = require('mongodb')
const { db } = require('../../app/src/infrastructure/mongodb')
const Settings = require('@overleaf/settings')

const ProjectHistoryHandler = require('../../app/src/Features/Project/ProjectHistoryHandler')
const HistoryManager = require('../../app/src/Features/History/HistoryManager')
const ProjectHistoryController = require('../../modules/admin-panel/app/src/ProjectHistoryController')
const ProjectEntityHandler = require('../../app/src/Features/Project/ProjectEntityHandler')
const ProjectEntityUpdateHandler = require('../../app/src/Features/Project/ProjectEntityUpdateHandler')

// Timestamp of when 'Enable history for SL in background' release
const ID_WHEN_FULL_PROJECT_HISTORY_ENABLED = '5a8d8a370000000000000000'
const OBJECT_ID_WHEN_FULL_PROJECT_HISTORY_ENABLED = new ObjectId(
  ID_WHEN_FULL_PROJECT_HISTORY_ENABLED
)
const DATETIME_WHEN_FULL_PROJECT_HISTORY_ENABLED =
  OBJECT_ID_WHEN_FULL_PROJECT_HISTORY_ENABLED.getTimestamp()

async function determineProjectHistoryType(project) {
  if (project.overleaf && project.overleaf.history) {
    if (project.overleaf.history.upgradeFailed) {
      return 'UpgradeFailed'
    }
    if (project.overleaf.history.conversionFailed) {
      return 'ConversionFailed'
    }
  }
  if (
    project.overleaf &&
    project.overleaf.history &&
    project.overleaf.history.id
  ) {
    if (project.overleaf.history.display) {
      // v2: full project history, do nothing
      return 'V2'
    } else {
      if (projectCreatedAfterFullProjectHistoryEnabled(project)) {
        // IF project initialised after full project history enabled for all projects
        //    THEN project history should contain all information we need, without intervention
        return 'V1WithoutConversion'
      } else {
        // ELSE SL history may predate full project history
        //    THEN delete full project history and convert their SL history to full project history
        // --
        // TODO: how to verify this, can get rough start date of SL history, but not full project history
        const preserveHistory = await shouldPreserveHistory(project)
        const anyDocHistory = await anyDocHistoryExists(project)
        const anyDocHistoryIndex = await anyDocHistoryIndexExists(project)
        if (preserveHistory) {
          if (anyDocHistory || anyDocHistoryIndex) {
            // if SL history exists that we need to preserve, then we must convert
            return 'V1WithConversion'
          } else {
            // otherwise just upgrade without conversion
            return 'V1WithoutConversion'
          }
        } else {
          // if preserveHistory false, then max 7 days of SL history
          // but v1 already record to both histories, so safe to upgrade
          return 'V1WithoutConversion'
        }
      }
    }
  } else {
    const preserveHistory = await shouldPreserveHistory(project)
    const anyDocHistory = await anyDocHistoryExists(project)
    const anyDocHistoryIndex = await anyDocHistoryIndexExists(project)
    if (anyDocHistory || anyDocHistoryIndex) {
      // IF there is SL history ->
      if (preserveHistory) {
        // that needs to be preserved:
        //    THEN initialise full project history and convert SL history to full project history
        return 'NoneWithConversion'
      } else {
        return 'NoneWithTemporaryHistory'
      }
    } else {
      // ELSE there is not any SL history ->
      //    THEN initialise full project history and sync with current content
      return 'NoneWithoutConversion'
    }
  }
}

async function upgradeProject(project) {
  const historyType = await determineProjectHistoryType(project)
  if (historyType === 'V2') {
    return { historyType, upgraded: true }
  }
  const upgradeFn = getUpgradeFunctionForType(historyType)
  if (!upgradeFn) {
    return { error: 'unsupported history type' }
  }
  const result = await upgradeFn(project)
  result.historyType = historyType
  return result
}

// Do upgrades/conversion:

function getUpgradeFunctionForType(historyType) {
  return UpgradeFunctionMapping[historyType]
}

const UpgradeFunctionMapping = {
  NoneWithoutConversion: doUpgradeForNoneWithoutConversion,
  UpgradeFailed: doUpgradeForNoneWithoutConversion,
  ConversionFailed: doUpgradeForNoneWithConversion,
  V1WithoutConversion: doUpgradeForV1WithoutConversion,
  V1WithConversion: doUpgradeForV1WithConversion,
  NoneWithConversion: doUpgradeForNoneWithConversion,
  NoneWithTemporaryHistory: doUpgradeForNoneWithConversion,
}

async function doUpgradeForV1WithoutConversion(project) {
  await db.projects.updateOne(
    { _id: project._id },
    {
      $set: {
        'overleaf.history.display': true,
        'overleaf.history.upgradedAt': new Date(),
        'overleaf.history.upgradeReason': `v1-without-sl-history`,
      },
    }
  )
  return { upgraded: true }
}

async function doUpgradeForV1WithConversion(project) {
  const result = {}
  const projectId = project._id
  // migrateProjectHistory expects project id as a string
  const projectIdString = project._id.toString()
  try {
    // We treat these essentially as None projects, the V1 history is irrelevant,
    // so we will delete it, and do a conversion as if we're a None project
    await ProjectHistoryController.deleteProjectHistory(projectIdString)
    await ProjectHistoryController.migrateProjectHistory(projectIdString)
  } catch (err) {
    // if migrateProjectHistory fails, it cleans up by deleting
    // the history and unsetting the history id
    // therefore a failed project will still look like a 'None with conversion' project
    result.error = err
    await db.projects.updateOne(
      { _id: projectId },
      {
        $set: {
          'overleaf.history.conversionFailed': true,
        },
      }
    )
    return result
  }
  await db.projects.updateOne(
    { _id: projectId },
    {
      $set: {
        'overleaf.history.upgradeReason': `v1-with-conversion`,
      },
      $unset: {
        'overleaf.history.upgradeFailed': true,
        'overleaf.history.conversionFailed': true,
      },
    }
  )
  result.upgraded = true
  return result
}

async function doUpgradeForNoneWithoutConversion(project) {
  const result = {}
  const projectId = project._id
  try {
    // Logic originally from ProjectHistoryHandler.ensureHistoryExistsForProject
    // However sends a force resync project to project history instead
    // of a resync request to doc-updater
    const historyId = await ProjectHistoryHandler.promises.getHistoryId(
      projectId
    )
    if (!historyId) {
      const history = await HistoryManager.promises.initializeProject()
      if (history && history.overleaf_id) {
        await ProjectHistoryHandler.promises.setHistoryId(
          projectId,
          history.overleaf_id
        )
      }
    }
    await HistoryManager.promises.resyncProject(projectId, {
      force: true,
      origin: { kind: 'history-migration' },
    })
    await HistoryManager.promises.flushProject(projectId)
  } catch (err) {
    result.error = err
    await db.projects.updateOne(
      { _id: project._id },
      {
        $set: {
          'overleaf.history.upgradeFailed': true,
        },
      }
    )
    return result
  }
  await db.projects.updateOne(
    { _id: project._id },
    {
      $set: {
        'overleaf.history.display': true,
        'overleaf.history.upgradedAt': new Date(),
        'overleaf.history.upgradeReason': `none-without-conversion`,
      },
    }
  )
  result.upgraded = true
  return result
}

async function doUpgradeForNoneWithConversion(project) {
  const result = {}
  const projectId = project._id
  // migrateProjectHistory expects project id as a string
  const projectIdString = project._id.toString()
  try {
    await ProjectHistoryController.migrateProjectHistory(projectIdString)
  } catch (err) {
    // if migrateProjectHistory fails, it cleans up by deleting
    // the history and unsetting the history id
    // therefore a failed project will still look like a 'None with conversion' project
    result.error = err
    await db.projects.updateOne(
      { _id: projectId },
      {
        $set: {
          'overleaf.history.conversionFailed': true,
        },
      }
    )
    return result
  }
  await db.projects.updateOne(
    { _id: projectId },
    {
      $set: {
        'overleaf.history.upgradeReason': `none-with-conversion`,
      },
      $unset: {
        'overleaf.history.upgradeFailed': true,
        'overleaf.history.conversionFailed': true,
      },
    }
  )
  result.upgraded = true
  return result
}

// Util

function projectCreatedAfterFullProjectHistoryEnabled(project) {
  return (
    project._id.getTimestamp() >= DATETIME_WHEN_FULL_PROJECT_HISTORY_ENABLED
  )
}

async function shouldPreserveHistory(project) {
  return await db.projectHistoryMetaData.findOne(
    {
      $and: [
        { project_id: { $eq: project._id } },
        { preserveHistory: { $eq: true } },
      ],
    },
    { readPreference: ReadPreference.SECONDARY }
  )
}

async function anyDocHistoryExists(project) {
  return await db.docHistory.findOne(
    { project_id: { $eq: project._id } },
    {
      projection: { _id: 1 },
      readPreference: ReadPreference.SECONDARY,
    }
  )
}

async function anyDocHistoryIndexExists(project) {
  return await db.docHistoryIndex.findOne(
    { project_id: { $eq: project._id } },
    {
      projection: { _id: 1 },
      readPreference: ReadPreference.SECONDARY,
    }
  )
}

async function convertLargeDocsToFile(projectId, userId) {
  const docs = await ProjectEntityHandler.promises.getAllDocs(projectId)
  let convertedDocCount = 0
  for (const doc of Object.values(docs)) {
    const sizeBound = JSON.stringify(doc.lines)
    if (docIsTooLarge(sizeBound, doc.lines, Settings.max_doc_length)) {
      await ProjectEntityUpdateHandler.promises.convertDocToFile(
        projectId,
        doc._id,
        userId
      )
      convertedDocCount++
    }
  }
  return convertedDocCount
}

// check whether the total size of the document in characters exceeds the
// maxDocLength.
//
// Copied from document-updater:
// https://github.com/overleaf/internal/blob/74adfbebda5f3c2c37d9937f0db5c4106ecde492/services/document-updater/app/js/Limits.js#L18
function docIsTooLarge(estimatedSize, lines, maxDocLength) {
  if (estimatedSize <= maxDocLength) {
    return false // definitely under the limit, no need to calculate the total size
  }
  // calculate the total size, bailing out early if the size limit is reached
  let size = 0
  for (const line of lines) {
    size += line.length + 1 // include the newline
    if (size > maxDocLength) return true
  }
  // since we didn't hit the limit in the loop, the document is within the allowed length
  return false
}

module.exports = {
  determineProjectHistoryType,
  getUpgradeFunctionForType,
  upgradeProject,
  convertLargeDocsToFile,
}